admin/gluetun
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove unneeded .Times(1) for unit tests mocks

Browse Source
This commit is contained in:
Quentin McGaw
2020-12-28 01:52:30 +00:00
parent db886163c2
commit f5366c33bc
4 changed files with 29 additions and 29 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
internal/dns/command_test.go
View File

@@ -18,10 +18,10 @@ func Test_Start(t *testing.T) {
mockCtrl := gomock.NewController(t) mockCtrl := gomock.NewController(t)
defer mockCtrl.Finish() defer mockCtrl.Finish()
logger := mock_logging.NewMockLogger(mockCtrl) logger := mock_logging.NewMockLogger(mockCtrl)
logger.EXPECT().Info("starting unbound").Times(1) logger.EXPECT().Info("starting unbound")
commander := mock_command.NewMockCommander(mockCtrl) commander := mock_command.NewMockCommander(mockCtrl)
commander.EXPECT().Start(context.Background(), "unbound", "-d", "-c", string(constants.UnboundConf), "-vv"). 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} c := &configurator{commander: commander, logger: logger}
stdout, waitFn, err := c.Start(context.Background(), 2) stdout, waitFn, err := c.Start(context.Background(), 2)
assert.Nil(t, stdout) assert.Nil(t, stdout)
@@ -57,7 +57,7 @@ func Test_Version(t *testing.T) {
defer mockCtrl.Finish() defer mockCtrl.Finish()
commander := mock_command.NewMockCommander(mockCtrl) commander := mock_command.NewMockCommander(mockCtrl)
commander.EXPECT().Run(context.Background(), "unbound", "-V"). commander.EXPECT().Run(context.Background(), "unbound", "-V").
Return(tc.runOutput, tc.runErr).Times(1) Return(tc.runOutput, tc.runErr)
c := &configurator{commander: commander} c := &configurator{commander: commander}
version, err := c.Version(context.Background()) version, err := c.Version(context.Background())
if tc.err != nil { if tc.err != nil {

34
internal/dns/conf_test.go
View File

@@ -35,12 +35,12 @@ func Test_generateUnboundConf(t *testing.T) {
ctx := context.Background() ctx := context.Background()
client := mock_network.NewMockClient(mockCtrl) client := mock_network.NewMockClient(mockCtrl)
client.EXPECT().Get(ctx, string(constants.MaliciousBlockListHostnamesURL)). 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)). 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 := mock_logging.NewMockLogger(mockCtrl)
logger.EXPECT().Info("%d hostnames blocked overall", 2).Times(1) logger.EXPECT().Info("%d hostnames blocked overall", 2)
logger.EXPECT().Info("%d IP addresses blocked overall", 3).Times(1) logger.EXPECT().Info("%d IP addresses blocked overall", 3)
lines, warnings := generateUnboundConf(ctx, settings, "nonrootuser", client, logger) lines, warnings := generateUnboundConf(ctx, settings, "nonrootuser", client, logger)
require.Len(t, warnings, 0) require.Len(t, warnings, 0)
expected := ` expected := `
@@ -238,21 +238,21 @@ func Test_buildBlocked(t *testing.T) {
client := mock_network.NewMockClient(mockCtrl) client := mock_network.NewMockClient(mockCtrl)
if tc.malicious.blocked { if tc.malicious.blocked {
client.EXPECT().Get(ctx, string(constants.MaliciousBlockListHostnamesURL)). 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)). 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 { if tc.ads.blocked {
client.EXPECT().Get(ctx, string(constants.AdsBlockListHostnamesURL)). 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)). 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 { if tc.surveillance.blocked {
client.EXPECT().Get(ctx, string(constants.SurveillanceBlockListHostnamesURL)). 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)). 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, hostnamesLines, ipsLines, errs := buildBlocked(ctx, client,
tc.malicious.blocked, tc.ads.blocked, tc.surveillance.blocked, tc.malicious.blocked, tc.ads.blocked, tc.surveillance.blocked,
@@ -291,7 +291,7 @@ func Test_getList(t *testing.T) {
ctx := context.Background() ctx := context.Background()
client := mock_network.NewMockClient(mockCtrl) client := mock_network.NewMockClient(mockCtrl)
client.EXPECT().Get(ctx, "irrelevant_url"). 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") results, err := getList(ctx, client, "irrelevant_url")
if tc.err != nil { if tc.err != nil {
require.Error(t, err) require.Error(t, err)
@@ -397,15 +397,15 @@ func Test_buildBlockedHostnames(t *testing.T) {
client := mock_network.NewMockClient(mockCtrl) client := mock_network.NewMockClient(mockCtrl)
if tc.malicious.blocked { if tc.malicious.blocked {
client.EXPECT().Get(ctx, string(constants.MaliciousBlockListHostnamesURL)). 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 { if tc.ads.blocked {
client.EXPECT().Get(ctx, string(constants.AdsBlockListHostnamesURL)). 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 { if tc.surveillance.blocked {
client.EXPECT().Get(ctx, string(constants.SurveillanceBlockListHostnamesURL)). 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, lines, errs := buildBlockedHostnames(ctx, client,
tc.malicious.blocked, tc.ads.blocked, tc.malicious.blocked, tc.ads.blocked,
@@ -515,15 +515,15 @@ func Test_buildBlockedIPs(t *testing.T) {
client := mock_network.NewMockClient(mockCtrl) client := mock_network.NewMockClient(mockCtrl)
if tc.malicious.blocked { if tc.malicious.blocked {
client.EXPECT().Get(ctx, string(constants.MaliciousBlockListIPsURL)). 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 { if tc.ads.blocked {
client.EXPECT().Get(ctx, string(constants.AdsBlockListIPsURL)). 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 { if tc.surveillance.blocked {
client.EXPECT().Get(ctx, string(constants.SurveillanceBlockListIPsURL)). 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, lines, errs := buildBlockedIPs(ctx, client,
tc.malicious.blocked, tc.ads.blocked, tc.malicious.blocked, tc.ads.blocked,

6
internal/dns/nameserver_test.go
View File

@@ -51,13 +51,13 @@ func Test_UseDNSSystemWide(t *testing.T) {
defer mockCtrl.Finish() defer mockCtrl.Finish()
fileManager := mock_files.NewMockFileManager(mockCtrl) fileManager := mock_files.NewMockFileManager(mockCtrl)
fileManager.EXPECT().ReadFile(string(constants.ResolvConf)). fileManager.EXPECT().ReadFile(string(constants.ResolvConf)).
Return(tc.data, tc.readErr).Times(1) Return(tc.data, tc.readErr)
if tc.readErr == nil { if tc.readErr == nil {
fileManager.EXPECT().WriteToFile(string(constants.ResolvConf), tc.writtenData). fileManager.EXPECT().WriteToFile(string(constants.ResolvConf), tc.writtenData).
Return(tc.writeErr).Times(1) Return(tc.writeErr)
} }
logger := mock_logging.NewMockLogger(mockCtrl) 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{ c := &configurator{
fileManager: fileManager, fileManager: fileManager,
logger: logger, logger: logger,

12
internal/dns/roots_test.go
View File

@@ -54,10 +54,10 @@ func Test_DownloadRootHints(t *testing.T) { //nolint:dupl
defer mockCtrl.Finish() defer mockCtrl.Finish()
ctx := context.Background() ctx := context.Background()
logger := mock_logging.NewMockLogger(mockCtrl) 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 := mock_network.NewMockClient(mockCtrl)
client.EXPECT().Get(ctx, string(constants.NamedRootURL)). 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) fileManager := mock_files.NewMockFileManager(mockCtrl)
if tc.clientErr == nil && tc.status == http.StatusOK { if tc.clientErr == nil && tc.status == http.StatusOK {
fileManager.EXPECT().WriteToFile( fileManager.EXPECT().WriteToFile(
@@ -65,7 +65,7 @@ func Test_DownloadRootHints(t *testing.T) { //nolint:dupl
tc.content, tc.content,
gomock.AssignableToTypeOf(files.Ownership(0, 0)), gomock.AssignableToTypeOf(files.Ownership(0, 0)),
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} c := &configurator{logger: logger, client: client, fileManager: fileManager}
err := c.DownloadRootHints(ctx, 1000, 1000) err := c.DownloadRootHints(ctx, 1000, 1000)
@@ -117,10 +117,10 @@ func Test_DownloadRootKey(t *testing.T) { //nolint:dupl
defer mockCtrl.Finish() defer mockCtrl.Finish()
ctx := context.Background() ctx := context.Background()
logger := mock_logging.NewMockLogger(mockCtrl) 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 := mock_network.NewMockClient(mockCtrl)
client.EXPECT().Get(ctx, string(constants.RootKeyURL)). 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) fileManager := mock_files.NewMockFileManager(mockCtrl)
if tc.clientErr == nil && tc.status == http.StatusOK { if tc.clientErr == nil && tc.status == http.StatusOK {
fileManager.EXPECT().WriteToFile( fileManager.EXPECT().WriteToFile(
@@ -128,7 +128,7 @@ func Test_DownloadRootKey(t *testing.T) { //nolint:dupl
tc.content, tc.content,
gomock.AssignableToTypeOf(files.Ownership(0, 0)), gomock.AssignableToTypeOf(files.Ownership(0, 0)),
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} c := &configurator{logger: logger, client: client, fileManager: fileManager}
err := c.DownloadRootKey(ctx, 1000, 1001) err := c.DownloadRootKey(ctx, 1000, 1001)