From f5366c33bc098e625ae99494fb6240fdc1a1ca65 Mon Sep 17 00:00:00 2001 From: Quentin McGaw Date: Mon, 28 Dec 2020 01:52:30 +0000 Subject: [PATCH] Remove unneeded .Times(1) for unit tests mocks --- internal/dns/command_test.go | 6 +++--- internal/dns/conf_test.go | 34 ++++++++++++++++----------------- internal/dns/nameserver_test.go | 6 +++--- internal/dns/roots_test.go | 12 ++++++------ 4 files changed, 29 insertions(+), 29 deletions(-) diff --git a/internal/dns/command_test.go b/internal/dns/command_test.go index 214d1de3..7300780b 100644 --- a/internal/dns/command_test.go +++ b/internal/dns/command_test.go @@ -18,10 +18,10 @@ func Test_Start(t *testing.T) { mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() logger := mock_logging.NewMockLogger(mockCtrl) - logger.EXPECT().Info("starting unbound").Times(1) + logger.EXPECT().Info("starting unbound") commander := mock_command.NewMockCommander(mockCtrl) commander.EXPECT().Start(context.Background(), "unbound", "-d", "-c", string(constants.UnboundConf), "-vv"). - Return(nil, nil, nil, nil).Times(1) + Return(nil, nil, nil, nil) c := &configurator{commander: commander, logger: logger} stdout, waitFn, err := c.Start(context.Background(), 2) assert.Nil(t, stdout) @@ -57,7 +57,7 @@ func Test_Version(t *testing.T) { defer mockCtrl.Finish() commander := mock_command.NewMockCommander(mockCtrl) commander.EXPECT().Run(context.Background(), "unbound", "-V"). - Return(tc.runOutput, tc.runErr).Times(1) + Return(tc.runOutput, tc.runErr) c := &configurator{commander: commander} version, err := c.Version(context.Background()) if tc.err != nil { diff --git a/internal/dns/conf_test.go b/internal/dns/conf_test.go index 3b3e0380..5bccd18d 100644 --- a/internal/dns/conf_test.go +++ b/internal/dns/conf_test.go @@ -35,12 +35,12 @@ func Test_generateUnboundConf(t *testing.T) { ctx := context.Background() client := mock_network.NewMockClient(mockCtrl) client.EXPECT().Get(ctx, string(constants.MaliciousBlockListHostnamesURL)). - Return([]byte("b\na\nc"), 200, nil).Times(1) + Return([]byte("b\na\nc"), 200, nil) client.EXPECT().Get(ctx, string(constants.MaliciousBlockListIPsURL)). - Return([]byte("c\nd\n"), 200, nil).Times(1) + Return([]byte("c\nd\n"), 200, nil) logger := mock_logging.NewMockLogger(mockCtrl) - logger.EXPECT().Info("%d hostnames blocked overall", 2).Times(1) - logger.EXPECT().Info("%d IP addresses blocked overall", 3).Times(1) + logger.EXPECT().Info("%d hostnames blocked overall", 2) + logger.EXPECT().Info("%d IP addresses blocked overall", 3) lines, warnings := generateUnboundConf(ctx, settings, "nonrootuser", client, logger) require.Len(t, warnings, 0) expected := ` @@ -238,21 +238,21 @@ func Test_buildBlocked(t *testing.T) { client := mock_network.NewMockClient(mockCtrl) if tc.malicious.blocked { client.EXPECT().Get(ctx, string(constants.MaliciousBlockListHostnamesURL)). - Return(tc.malicious.content, 200, tc.malicious.clientErr).Times(1) + Return(tc.malicious.content, 200, tc.malicious.clientErr) client.EXPECT().Get(ctx, string(constants.MaliciousBlockListIPsURL)). - Return(tc.malicious.content, 200, tc.malicious.clientErr).Times(1) + Return(tc.malicious.content, 200, tc.malicious.clientErr) } if tc.ads.blocked { client.EXPECT().Get(ctx, string(constants.AdsBlockListHostnamesURL)). - Return(tc.ads.content, 200, tc.ads.clientErr).Times(1) + Return(tc.ads.content, 200, tc.ads.clientErr) client.EXPECT().Get(ctx, string(constants.AdsBlockListIPsURL)). - Return(tc.ads.content, 200, tc.ads.clientErr).Times(1) + Return(tc.ads.content, 200, tc.ads.clientErr) } if tc.surveillance.blocked { client.EXPECT().Get(ctx, string(constants.SurveillanceBlockListHostnamesURL)). - Return(tc.surveillance.content, 200, tc.surveillance.clientErr).Times(1) + Return(tc.surveillance.content, 200, tc.surveillance.clientErr) client.EXPECT().Get(ctx, string(constants.SurveillanceBlockListIPsURL)). - Return(tc.surveillance.content, 200, tc.surveillance.clientErr).Times(1) + Return(tc.surveillance.content, 200, tc.surveillance.clientErr) } hostnamesLines, ipsLines, errs := buildBlocked(ctx, client, tc.malicious.blocked, tc.ads.blocked, tc.surveillance.blocked, @@ -291,7 +291,7 @@ func Test_getList(t *testing.T) { ctx := context.Background() client := mock_network.NewMockClient(mockCtrl) client.EXPECT().Get(ctx, "irrelevant_url"). - Return(tc.content, tc.status, tc.clientErr).Times(1) + Return(tc.content, tc.status, tc.clientErr) results, err := getList(ctx, client, "irrelevant_url") if tc.err != nil { require.Error(t, err) @@ -397,15 +397,15 @@ func Test_buildBlockedHostnames(t *testing.T) { client := mock_network.NewMockClient(mockCtrl) if tc.malicious.blocked { client.EXPECT().Get(ctx, string(constants.MaliciousBlockListHostnamesURL)). - Return(tc.malicious.content, 200, tc.malicious.clientErr).Times(1) + Return(tc.malicious.content, 200, tc.malicious.clientErr) } if tc.ads.blocked { client.EXPECT().Get(ctx, string(constants.AdsBlockListHostnamesURL)). - Return(tc.ads.content, 200, tc.ads.clientErr).Times(1) + Return(tc.ads.content, 200, tc.ads.clientErr) } if tc.surveillance.blocked { client.EXPECT().Get(ctx, string(constants.SurveillanceBlockListHostnamesURL)). - Return(tc.surveillance.content, 200, tc.surveillance.clientErr).Times(1) + Return(tc.surveillance.content, 200, tc.surveillance.clientErr) } lines, errs := buildBlockedHostnames(ctx, client, tc.malicious.blocked, tc.ads.blocked, @@ -515,15 +515,15 @@ func Test_buildBlockedIPs(t *testing.T) { client := mock_network.NewMockClient(mockCtrl) if tc.malicious.blocked { client.EXPECT().Get(ctx, string(constants.MaliciousBlockListIPsURL)). - Return(tc.malicious.content, 200, tc.malicious.clientErr).Times(1) + Return(tc.malicious.content, 200, tc.malicious.clientErr) } if tc.ads.blocked { client.EXPECT().Get(ctx, string(constants.AdsBlockListIPsURL)). - Return(tc.ads.content, 200, tc.ads.clientErr).Times(1) + Return(tc.ads.content, 200, tc.ads.clientErr) } if tc.surveillance.blocked { client.EXPECT().Get(ctx, string(constants.SurveillanceBlockListIPsURL)). - Return(tc.surveillance.content, 200, tc.surveillance.clientErr).Times(1) + Return(tc.surveillance.content, 200, tc.surveillance.clientErr) } lines, errs := buildBlockedIPs(ctx, client, tc.malicious.blocked, tc.ads.blocked, diff --git a/internal/dns/nameserver_test.go b/internal/dns/nameserver_test.go index 915fc922..ace1b333 100644 --- a/internal/dns/nameserver_test.go +++ b/internal/dns/nameserver_test.go @@ -51,13 +51,13 @@ func Test_UseDNSSystemWide(t *testing.T) { defer mockCtrl.Finish() fileManager := mock_files.NewMockFileManager(mockCtrl) fileManager.EXPECT().ReadFile(string(constants.ResolvConf)). - Return(tc.data, tc.readErr).Times(1) + Return(tc.data, tc.readErr) if tc.readErr == nil { fileManager.EXPECT().WriteToFile(string(constants.ResolvConf), tc.writtenData). - Return(tc.writeErr).Times(1) + Return(tc.writeErr) } logger := mock_logging.NewMockLogger(mockCtrl) - logger.EXPECT().Info("using DNS address %s system wide", "127.0.0.1").Times(1) + logger.EXPECT().Info("using DNS address %s system wide", "127.0.0.1") c := &configurator{ fileManager: fileManager, logger: logger, diff --git a/internal/dns/roots_test.go b/internal/dns/roots_test.go index a774244c..e8a4237b 100644 --- a/internal/dns/roots_test.go +++ b/internal/dns/roots_test.go @@ -54,10 +54,10 @@ func Test_DownloadRootHints(t *testing.T) { //nolint:dupl defer mockCtrl.Finish() ctx := context.Background() logger := mock_logging.NewMockLogger(mockCtrl) - logger.EXPECT().Info("downloading root hints from %s", constants.NamedRootURL).Times(1) + logger.EXPECT().Info("downloading root hints from %s", constants.NamedRootURL) client := mock_network.NewMockClient(mockCtrl) client.EXPECT().Get(ctx, string(constants.NamedRootURL)). - Return(tc.content, tc.status, tc.clientErr).Times(1) + Return(tc.content, tc.status, tc.clientErr) fileManager := mock_files.NewMockFileManager(mockCtrl) if tc.clientErr == nil && tc.status == http.StatusOK { fileManager.EXPECT().WriteToFile( @@ -65,7 +65,7 @@ func Test_DownloadRootHints(t *testing.T) { //nolint:dupl tc.content, gomock.AssignableToTypeOf(files.Ownership(0, 0)), gomock.AssignableToTypeOf(files.Ownership(0, 0))). - Return(tc.writeErr).Times(1) + Return(tc.writeErr) } c := &configurator{logger: logger, client: client, fileManager: fileManager} err := c.DownloadRootHints(ctx, 1000, 1000) @@ -117,10 +117,10 @@ func Test_DownloadRootKey(t *testing.T) { //nolint:dupl defer mockCtrl.Finish() ctx := context.Background() logger := mock_logging.NewMockLogger(mockCtrl) - logger.EXPECT().Info("downloading root key from %s", constants.RootKeyURL).Times(1) + logger.EXPECT().Info("downloading root key from %s", constants.RootKeyURL) client := mock_network.NewMockClient(mockCtrl) client.EXPECT().Get(ctx, string(constants.RootKeyURL)). - Return(tc.content, tc.status, tc.clientErr).Times(1) + Return(tc.content, tc.status, tc.clientErr) fileManager := mock_files.NewMockFileManager(mockCtrl) if tc.clientErr == nil && tc.status == http.StatusOK { fileManager.EXPECT().WriteToFile( @@ -128,7 +128,7 @@ func Test_DownloadRootKey(t *testing.T) { //nolint:dupl tc.content, gomock.AssignableToTypeOf(files.Ownership(0, 0)), gomock.AssignableToTypeOf(files.Ownership(0, 0)), - ).Return(tc.writeErr).Times(1) + ).Return(tc.writeErr) } c := &configurator{logger: logger, client: client, fileManager: fileManager} err := c.DownloadRootKey(ctx, 1000, 1001)