diff --git a/go.mod b/go.mod index b1c79370..1dc43498 100644 --- a/go.mod +++ b/go.mod @@ -1,11 +1,11 @@ module github.com/qdm12/private-internet-access-docker -go 1.13 +go 1.14 require ( github.com/golang/mock v1.4.3 - github.com/kyokomi/emoji v2.1.0+incompatible - github.com/qdm12/golibs v0.0.0-20200329231626-f55b47cd4e96 + github.com/kyokomi/emoji v2.2.1+incompatible + github.com/qdm12/golibs v0.0.0-20200412175259-da41d65db446 github.com/stretchr/testify v1.5.1 - golang.org/x/sys v0.0.0-20200327173247-9dae0f8f5775 + golang.org/x/sys v0.0.0-20200409092240-59c9f1ba88fa ) diff --git a/go.sum b/go.sum index 5f5855cf..41ac3476 100644 --- a/go.sum +++ b/go.sum @@ -48,8 +48,8 @@ github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORN github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE= github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= -github.com/kyokomi/emoji v2.1.0+incompatible h1:+DYU2RgpI6OHG4oQkM5KlqD3Wd3UPEsX8jamTo1Mp6o= -github.com/kyokomi/emoji v2.1.0+incompatible/go.mod h1:mZ6aGCD7yk8j6QY6KICwnZ2pxoszVseX1DNoGtU2tBA= +github.com/kyokomi/emoji v2.2.1+incompatible h1:uP/6J5y5U0XxPh6fv8YximpVD1uMrshXG78I1+uF5SA= +github.com/kyokomi/emoji v2.2.1+incompatible/go.mod h1:mZ6aGCD7yk8j6QY6KICwnZ2pxoszVseX1DNoGtU2tBA= github.com/mailru/easyjson v0.0.0-20180823135443-60711f1a8329 h1:2gxZ0XQIU/5z3Z3bUBu+FXuk2pFbkN6tcwi/pjyaDic= github.com/mailru/easyjson v0.0.0-20180823135443-60711f1a8329/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc= github.com/mitchellh/mapstructure v1.1.2 h1:fmNYVwqnSfB9mZU6OS2O6GsXM+wcskZDuKQzvN1EDeE= @@ -63,8 +63,8 @@ github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I= github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/qdm12/golibs v0.0.0-20200329231626-f55b47cd4e96 h1:vGvPItljtw8Z0xVJSyE80Z+6zzRZqrHoXr5vx5iB+rI= -github.com/qdm12/golibs v0.0.0-20200329231626-f55b47cd4e96/go.mod h1:YULaFjj6VGmhjak6f35sUWwEleHUmngN5IQ3kdvd6XE= +github.com/qdm12/golibs v0.0.0-20200412175259-da41d65db446 h1:sBPYLwDSqRsOqHi7f34c7QMcoR1xLD1wLnOl0L7br6c= +github.com/qdm12/golibs v0.0.0-20200412175259-da41d65db446/go.mod h1:y4hRtiU2Al0+y2UP1I9e0yYu9VqemnMwyJVCkyhy9r8= github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4= github.com/stretchr/objx v0.1.0 h1:4G4v2dO3VZwixGIRoQ5Lfboy6nUhCyYzaqnIAPPhYs4= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= @@ -97,8 +97,8 @@ golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJ golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190412213103-97732733099d h1:+R4KGOnez64A81RvjARKc4UT5/tI9ujCIVX+P5KiHuI= golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200327173247-9dae0f8f5775 h1:TC0v2RSO1u2kn1ZugjrFXkRZAEaqMN/RW+OTZkBzmLE= -golang.org/x/sys v0.0.0-20200327173247-9dae0f8f5775/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200409092240-59c9f1ba88fa h1:mQTN3ECqfsViCNBgq+A40vdwhkGykrrQlYe3mPj6BoU= +golang.org/x/sys v0.0.0-20200409092240-59c9f1ba88fa/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= diff --git a/internal/dns/command_test.go b/internal/dns/command_test.go index 495ee5ae..4f09968f 100644 --- a/internal/dns/command_test.go +++ b/internal/dns/command_test.go @@ -4,8 +4,9 @@ import ( "fmt" "testing" - commandMocks "github.com/qdm12/golibs/command/mocks" - loggingMocks "github.com/qdm12/golibs/logging/mocks" + "github.com/golang/mock/gomock" + "github.com/qdm12/golibs/command/mock_command" + "github.com/qdm12/golibs/logging/mock_logging" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" @@ -14,18 +15,18 @@ import ( func Test_Start(t *testing.T) { t.Parallel() - logger := &loggingMocks.Logger{} - logger.On("Info", "%s: starting unbound", logPrefix).Once() - commander := &commandMocks.Commander{} - commander.On("Start", "unbound", "-d", "-c", string(constants.UnboundConf), "-vv"). - Return(nil, nil, nil, nil).Once() + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + logger := mock_logging.NewMockLogger(mockCtrl) + logger.EXPECT().Info("%s: starting unbound", logPrefix).Times(1) + commander := mock_command.NewMockCommander(mockCtrl) + commander.EXPECT().Start("unbound", "-d", "-c", string(constants.UnboundConf), "-vv"). + Return(nil, nil, nil, nil).Times(1) c := &configurator{commander: commander, logger: logger} stdout, waitFn, err := c.Start(2) assert.Nil(t, stdout) assert.Nil(t, waitFn) assert.NoError(t, err) - logger.AssertExpectations(t) - commander.AssertExpectations(t) } func Test_Version(t *testing.T) { @@ -52,9 +53,11 @@ func Test_Version(t *testing.T) { tc := tc t.Run(name, func(t *testing.T) { t.Parallel() - commander := &commandMocks.Commander{} - commander.On("Run", "unbound", "-V"). - Return(tc.runOutput, tc.runErr).Once() + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + commander := mock_command.NewMockCommander(mockCtrl) + commander.EXPECT().Run("unbound", "-V"). + Return(tc.runOutput, tc.runErr).Times(1) c := &configurator{commander: commander} version, err := c.Version() if tc.err != nil { @@ -64,7 +67,6 @@ func Test_Version(t *testing.T) { assert.NoError(t, err) } assert.Equal(t, tc.version, version) - commander.AssertExpectations(t) }) } } diff --git a/internal/dns/conf_test.go b/internal/dns/conf_test.go index b7bba8eb..a4fff08d 100644 --- a/internal/dns/conf_test.go +++ b/internal/dns/conf_test.go @@ -5,8 +5,9 @@ import ( "strings" "testing" - "github.com/qdm12/golibs/logging" - "github.com/qdm12/golibs/network/mocks" + "github.com/golang/mock/gomock" + "github.com/qdm12/golibs/logging/mock_logging" + "github.com/qdm12/golibs/network/mock_network" "github.com/qdm12/private-internet-access-docker/internal/constants" "github.com/qdm12/private-internet-access-docker/internal/models" "github.com/qdm12/private-internet-access-docker/internal/settings" @@ -28,17 +29,19 @@ func Test_generateUnboundConf(t *testing.T) { Caching: true, IPv6: true, } - client := &mocks.Client{} - client.On("GetContent", string(constants.MaliciousBlockListHostnamesURL)). - Return([]byte("b\na\nc"), 200, nil).Once() - client.On("GetContent", string(constants.MaliciousBlockListIPsURL)). - Return([]byte("c\nd\n"), 200, nil).Once() - emptyLogger, err := logging.NewEmptyLogger() - require.NoError(t, err) - lines, warnings, err := generateUnboundConf(settings, client, emptyLogger) + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + client := mock_network.NewMockClient(mockCtrl) + client.EXPECT().GetContent(string(constants.MaliciousBlockListHostnamesURL)). + Return([]byte("b\na\nc"), 200, nil).Times(1) + client.EXPECT().GetContent(string(constants.MaliciousBlockListIPsURL)). + Return([]byte("c\nd\n"), 200, nil).Times(1) + logger := mock_logging.NewMockLogger(mockCtrl) + logger.EXPECT().Info("%s: %d hostnames blocked overall", logPrefix, 2).Times(1) + logger.EXPECT().Info("%s: %d IP addresses blocked overall", logPrefix, 3).Times(1) + lines, warnings, err := generateUnboundConf(settings, client, logger) require.Len(t, warnings, 0) require.NoError(t, err) - client.AssertExpectations(t) expected := ` server: cache-max-ttl: 9000 @@ -228,24 +231,26 @@ func Test_buildBlocked(t *testing.T) { tc := tc t.Run(name, func(t *testing.T) { t.Parallel() - client := &mocks.Client{} + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + client := mock_network.NewMockClient(mockCtrl) if tc.malicious.blocked { - client.On("GetContent", string(constants.MaliciousBlockListHostnamesURL)). - Return(tc.malicious.content, 200, tc.malicious.clientErr).Once() - client.On("GetContent", string(constants.MaliciousBlockListIPsURL)). - Return(tc.malicious.content, 200, tc.malicious.clientErr).Once() + client.EXPECT().GetContent(string(constants.MaliciousBlockListHostnamesURL)). + Return(tc.malicious.content, 200, tc.malicious.clientErr).Times(1) + client.EXPECT().GetContent(string(constants.MaliciousBlockListIPsURL)). + Return(tc.malicious.content, 200, tc.malicious.clientErr).Times(1) } if tc.ads.blocked { - client.On("GetContent", string(constants.AdsBlockListHostnamesURL)). - Return(tc.ads.content, 200, tc.ads.clientErr).Once() - client.On("GetContent", string(constants.AdsBlockListIPsURL)). - Return(tc.ads.content, 200, tc.ads.clientErr).Once() + client.EXPECT().GetContent(string(constants.AdsBlockListHostnamesURL)). + Return(tc.ads.content, 200, tc.ads.clientErr).Times(1) + client.EXPECT().GetContent(string(constants.AdsBlockListIPsURL)). + Return(tc.ads.content, 200, tc.ads.clientErr).Times(1) } if tc.surveillance.blocked { - client.On("GetContent", string(constants.SurveillanceBlockListHostnamesURL)). - Return(tc.surveillance.content, 200, tc.surveillance.clientErr).Once() - client.On("GetContent", string(constants.SurveillanceBlockListIPsURL)). - Return(tc.surveillance.content, 200, tc.surveillance.clientErr).Once() + client.EXPECT().GetContent(string(constants.SurveillanceBlockListHostnamesURL)). + Return(tc.surveillance.content, 200, tc.surveillance.clientErr).Times(1) + client.EXPECT().GetContent(string(constants.SurveillanceBlockListIPsURL)). + Return(tc.surveillance.content, 200, tc.surveillance.clientErr).Times(1) } hostnamesLines, ipsLines, errs := buildBlocked(client, tc.malicious.blocked, tc.ads.blocked, tc.surveillance.blocked, tc.allowedHostnames, tc.privateAddresses) @@ -256,7 +261,6 @@ func Test_buildBlocked(t *testing.T) { assert.ElementsMatch(t, tc.errsString, errsString) assert.ElementsMatch(t, tc.hostnamesLines, hostnamesLines) assert.ElementsMatch(t, tc.ipsLines, ipsLines) - client.AssertExpectations(t) }) } } @@ -279,10 +283,11 @@ func Test_getList(t *testing.T) { tc := tc t.Run(name, func(t *testing.T) { t.Parallel() - client := &mocks.Client{} - client.On("GetContent", "irrelevant_url").Return( - tc.content, tc.status, tc.clientErr, - ).Once() + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + client := mock_network.NewMockClient(mockCtrl) + client.EXPECT().GetContent("irrelevant_url"). + Return(tc.content, tc.status, tc.clientErr).Times(1) results, err := getList(client, "irrelevant_url") if tc.err != nil { require.Error(t, err) @@ -291,7 +296,6 @@ func Test_getList(t *testing.T) { assert.NoError(t, err) } assert.Equal(t, tc.results, results) - client.AssertExpectations(t) }) } } @@ -383,18 +387,20 @@ func Test_buildBlockedHostnames(t *testing.T) { tc := tc t.Run(name, func(t *testing.T) { t.Parallel() - client := &mocks.Client{} + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + client := mock_network.NewMockClient(mockCtrl) if tc.malicious.blocked { - client.On("GetContent", string(constants.MaliciousBlockListHostnamesURL)). - Return(tc.malicious.content, 200, tc.malicious.clientErr).Once() + client.EXPECT().GetContent(string(constants.MaliciousBlockListHostnamesURL)). + Return(tc.malicious.content, 200, tc.malicious.clientErr).Times(1) } if tc.ads.blocked { - client.On("GetContent", string(constants.AdsBlockListHostnamesURL)). - Return(tc.ads.content, 200, tc.ads.clientErr).Once() + client.EXPECT().GetContent(string(constants.AdsBlockListHostnamesURL)). + Return(tc.ads.content, 200, tc.ads.clientErr).Times(1) } if tc.surveillance.blocked { - client.On("GetContent", string(constants.SurveillanceBlockListHostnamesURL)). - Return(tc.surveillance.content, 200, tc.surveillance.clientErr).Once() + client.EXPECT().GetContent(string(constants.SurveillanceBlockListHostnamesURL)). + Return(tc.surveillance.content, 200, tc.surveillance.clientErr).Times(1) } lines, errs := buildBlockedHostnames(client, tc.malicious.blocked, tc.ads.blocked, tc.surveillance.blocked, tc.allowedHostnames) @@ -404,7 +410,6 @@ func Test_buildBlockedHostnames(t *testing.T) { } assert.ElementsMatch(t, tc.errsString, errsString) assert.ElementsMatch(t, tc.lines, lines) - client.AssertExpectations(t) }) } } @@ -498,18 +503,20 @@ func Test_buildBlockedIPs(t *testing.T) { tc := tc t.Run(name, func(t *testing.T) { t.Parallel() - client := &mocks.Client{} + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + client := mock_network.NewMockClient(mockCtrl) if tc.malicious.blocked { - client.On("GetContent", string(constants.MaliciousBlockListIPsURL)). - Return(tc.malicious.content, 200, tc.malicious.clientErr).Once() + client.EXPECT().GetContent(string(constants.MaliciousBlockListIPsURL)). + Return(tc.malicious.content, 200, tc.malicious.clientErr).Times(1) } if tc.ads.blocked { - client.On("GetContent", string(constants.AdsBlockListIPsURL)). - Return(tc.ads.content, 200, tc.ads.clientErr).Once() + client.EXPECT().GetContent(string(constants.AdsBlockListIPsURL)). + Return(tc.ads.content, 200, tc.ads.clientErr).Times(1) } if tc.surveillance.blocked { - client.On("GetContent", string(constants.SurveillanceBlockListIPsURL)). - Return(tc.surveillance.content, 200, tc.surveillance.clientErr).Once() + client.EXPECT().GetContent(string(constants.SurveillanceBlockListIPsURL)). + Return(tc.surveillance.content, 200, tc.surveillance.clientErr).Times(1) } lines, errs := buildBlockedIPs(client, tc.malicious.blocked, tc.ads.blocked, tc.surveillance.blocked, tc.privateAddresses) @@ -519,7 +526,6 @@ func Test_buildBlockedIPs(t *testing.T) { } assert.ElementsMatch(t, tc.errsString, errsString) assert.ElementsMatch(t, tc.lines, lines) - client.AssertExpectations(t) }) } } diff --git a/internal/dns/nameserver_test.go b/internal/dns/nameserver_test.go index 0dcd9768..8dfd586b 100644 --- a/internal/dns/nameserver_test.go +++ b/internal/dns/nameserver_test.go @@ -5,8 +5,9 @@ import ( "net" "testing" - filesmocks "github.com/qdm12/golibs/files/mocks" - loggingmocks "github.com/qdm12/golibs/logging/mocks" + "github.com/golang/mock/gomock" + "github.com/qdm12/golibs/files/mock_files" + "github.com/qdm12/golibs/logging/mock_logging" "github.com/qdm12/private-internet-access-docker/internal/constants" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" @@ -46,15 +47,17 @@ func Test_UseDNSSystemWide(t *testing.T) { tc := tc t.Run(name, func(t *testing.T) { t.Parallel() - fileManager := &filesmocks.FileManager{} - fileManager.On("ReadFile", string(constants.ResolvConf)). - Return(tc.data, tc.readErr).Once() + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + fileManager := mock_files.NewMockFileManager(mockCtrl) + fileManager.EXPECT().ReadFile(string(constants.ResolvConf)). + Return(tc.data, tc.readErr).Times(1) if tc.readErr == nil { - fileManager.On("WriteToFile", string(constants.ResolvConf), tc.writtenData). - Return(tc.writeErr).Once() + fileManager.EXPECT().WriteToFile(string(constants.ResolvConf), tc.writtenData). + Return(tc.writeErr).Times(1) } - logger := &loggingmocks.Logger{} - logger.On("Info", "%s: using DNS address %s system wide", logPrefix, "127.0.0.1").Once() + logger := mock_logging.NewMockLogger(mockCtrl) + logger.EXPECT().Info("%s: using DNS address %s system wide", logPrefix, "127.0.0.1").Times(1) c := &configurator{ fileManager: fileManager, logger: logger, @@ -66,8 +69,6 @@ func Test_UseDNSSystemWide(t *testing.T) { } else { assert.NoError(t, err) } - fileManager.AssertExpectations(t) - logger.AssertExpectations(t) }) } } diff --git a/internal/dns/roots_test.go b/internal/dns/roots_test.go index 5a84a7d3..f18a5ecf 100644 --- a/internal/dns/roots_test.go +++ b/internal/dns/roots_test.go @@ -5,11 +5,12 @@ import ( "net/http" "testing" - filesMocks "github.com/qdm12/golibs/files/mocks" - loggingMocks "github.com/qdm12/golibs/logging/mocks" - networkMocks "github.com/qdm12/golibs/network/mocks" + "github.com/golang/mock/gomock" + "github.com/qdm12/golibs/files" + "github.com/qdm12/golibs/files/mock_files" + "github.com/qdm12/golibs/logging/mock_logging" + "github.com/qdm12/golibs/network/mock_network" "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/mock" "github.com/stretchr/testify/require" "github.com/qdm12/private-internet-access-docker/internal/constants" @@ -49,20 +50,21 @@ func Test_DownloadRootHints(t *testing.T) { tc := tc t.Run(name, func(t *testing.T) { t.Parallel() - logger := &loggingMocks.Logger{} - logger.On("Info", "%s: downloading root hints from %s", logPrefix, constants.NamedRootURL).Once() - client := &networkMocks.Client{} - client.On("GetContent", string(constants.NamedRootURL)). - Return(tc.content, tc.status, tc.clientErr).Once() - fileManager := &filesMocks.FileManager{} + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + logger := mock_logging.NewMockLogger(mockCtrl) + logger.EXPECT().Info("%s: downloading root hints from %s", logPrefix, constants.NamedRootURL).Times(1) + client := mock_network.NewMockClient(mockCtrl) + client.EXPECT().GetContent(string(constants.NamedRootURL)). + Return(tc.content, tc.status, tc.clientErr).Times(1) + fileManager := mock_files.NewMockFileManager(mockCtrl) if tc.clientErr == nil && tc.status == http.StatusOK { - fileManager.On( - "WriteToFile", + fileManager.EXPECT().WriteToFile( string(constants.RootHints), tc.content, - mock.AnythingOfType("files.WriteOptionSetter"), - mock.AnythingOfType("files.WriteOptionSetter")). - Return(tc.writeErr).Once() + gomock.AssignableToTypeOf(files.Ownership(0, 0)), + gomock.AssignableToTypeOf(files.Ownership(0, 0))). + Return(tc.writeErr).Times(1) } c := &configurator{logger: logger, client: client, fileManager: fileManager} err := c.DownloadRootHints(1000, 1000) @@ -72,9 +74,6 @@ func Test_DownloadRootHints(t *testing.T) { } else { assert.NoError(t, err) } - logger.AssertExpectations(t) - client.AssertExpectations(t) - fileManager.AssertExpectations(t) }) } } @@ -113,20 +112,21 @@ func Test_DownloadRootKey(t *testing.T) { tc := tc t.Run(name, func(t *testing.T) { t.Parallel() - logger := &loggingMocks.Logger{} - logger.On("Info", "%s: downloading root key from %s", logPrefix, constants.RootKeyURL).Once() - client := &networkMocks.Client{} - client.On("GetContent", string(constants.RootKeyURL)). - Return(tc.content, tc.status, tc.clientErr).Once() - fileManager := &filesMocks.FileManager{} + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + logger := mock_logging.NewMockLogger(mockCtrl) + logger.EXPECT().Info("%s: downloading root key from %s", logPrefix, constants.RootKeyURL).Times(1) + client := mock_network.NewMockClient(mockCtrl) + client.EXPECT().GetContent(string(constants.RootKeyURL)). + Return(tc.content, tc.status, tc.clientErr).Times(1) + fileManager := mock_files.NewMockFileManager(mockCtrl) if tc.clientErr == nil && tc.status == http.StatusOK { - fileManager.On( - "WriteToFile", + fileManager.EXPECT().WriteToFile( string(constants.RootKey), tc.content, - mock.AnythingOfType("files.WriteOptionSetter"), - mock.AnythingOfType("files.WriteOptionSetter"), - ).Return(tc.writeErr).Once() + gomock.AssignableToTypeOf(files.Ownership(0, 0)), + gomock.AssignableToTypeOf(files.Ownership(0, 0)), + ).Return(tc.writeErr).Times(1) } c := &configurator{logger: logger, client: client, fileManager: fileManager} err := c.DownloadRootKey(1000, 1001) @@ -136,9 +136,6 @@ func Test_DownloadRootKey(t *testing.T) { } else { assert.NoError(t, err) } - logger.AssertExpectations(t) - client.AssertExpectations(t) - fileManager.AssertExpectations(t) }) } } diff --git a/internal/env/env_test.go b/internal/env/env_test.go index 5a585f02..4e3898be 100644 --- a/internal/env/env_test.go +++ b/internal/env/env_test.go @@ -4,9 +4,9 @@ import ( "fmt" "testing" - "github.com/qdm12/golibs/logging/mocks" + "github.com/golang/mock/gomock" + "github.com/qdm12/golibs/logging/mock_logging" "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/mock" ) func Test_FatalOnError(t *testing.T) { @@ -23,13 +23,13 @@ func Test_FatalOnError(t *testing.T) { t.Parallel() var logged string var exitCode int - logger := &mocks.Logger{} + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + logger := mock_logging.NewMockLogger(mockCtrl) if tc.err != nil { - logger.On("Error", tc.err). - Run(func(args mock.Arguments) { - err := args.Get(0).(error) - logged = err.Error() - }).Once() + logger.EXPECT().Error(tc.err).Do(func(err error) { + logged = err.Error() + }).Times(1) } osExit := func(n int) { exitCode = n } e := &env{logger, osExit} @@ -61,21 +61,19 @@ func Test_PrintVersion(t *testing.T) { t.Run(name, func(t *testing.T) { t.Parallel() var logged string - logger := &mocks.Logger{} + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + logger := mock_logging.NewMockLogger(mockCtrl) if tc.commandErr != nil { - logger.On("Error", tc.commandErr). - Run(func(args mock.Arguments) { - err := args.Get(0).(error) - logged = err.Error() - }).Once() + logger.EXPECT().Error(tc.commandErr).Do(func(err error) { + logged = err.Error() + }).Times(1) + } else { - logger.On("Info", "%s version: %s", tc.program, tc.commandVersion). - Run(func(args mock.Arguments) { - format := args.Get(0).(string) - program := args.Get(1).(string) - version := args.Get(2).(string) + logger.EXPECT().Info("%s version: %s", tc.program, tc.commandVersion). + Do(func(format, program, version string) { logged = fmt.Sprintf(format, program, version) - }).Once() + }).Times(1) } e := &env{logger: logger} commandFn := func() (string, error) { return tc.commandVersion, tc.commandErr } diff --git a/internal/healthcheck/healthcheck.go b/internal/healthcheck/healthcheck.go index b9d39988..1f0b6029 100644 --- a/internal/healthcheck/healthcheck.go +++ b/internal/healthcheck/healthcheck.go @@ -5,12 +5,12 @@ import ( "strings" "time" - "github.com/qdm12/golibs/network" + "github.com/qdm12/golibs/network/connectivity" ) func HealthCheck() error { // DNS, HTTP and HTTPs check on github.com - connectivty := network.NewConnectivity(3 * time.Second) + connectivty := connectivity.NewConnectivity(3 * time.Second) errs := connectivty.Checks("github.com") if len(errs) > 0 { var errsStr []string diff --git a/internal/routing/mockCommander_test.go b/internal/routing/mockCommander_test.go deleted file mode 100644 index 41082105..00000000 --- a/internal/routing/mockCommander_test.go +++ /dev/null @@ -1,76 +0,0 @@ -// Code generated by MockGen. DO NOT EDIT. -// Source: github.com/qdm12/golibs/command (interfaces: Commander) - -// Package routing is a generated GoMock package. -package routing - -import ( - gomock "github.com/golang/mock/gomock" - io "io" - reflect "reflect" -) - -// MockCommander is a mock of Commander interface -type MockCommander struct { - ctrl *gomock.Controller - recorder *MockCommanderMockRecorder -} - -// MockCommanderMockRecorder is the mock recorder for MockCommander -type MockCommanderMockRecorder struct { - mock *MockCommander -} - -// NewMockCommander creates a new mock instance -func NewMockCommander(ctrl *gomock.Controller) *MockCommander { - mock := &MockCommander{ctrl: ctrl} - mock.recorder = &MockCommanderMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockCommander) EXPECT() *MockCommanderMockRecorder { - return m.recorder -} - -// Run mocks base method -func (m *MockCommander) Run(arg0 string, arg1 ...string) (string, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0} - for _, a := range arg1 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "Run", varargs...) - ret0, _ := ret[0].(string) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Run indicates an expected call of Run -func (mr *MockCommanderMockRecorder) Run(arg0 interface{}, arg1 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0}, arg1...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockCommander)(nil).Run), varargs...) -} - -// Start mocks base method -func (m *MockCommander) Start(arg0 string, arg1 ...string) (io.ReadCloser, io.ReadCloser, func() error, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0} - for _, a := range arg1 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "Start", varargs...) - ret0, _ := ret[0].(io.ReadCloser) - ret1, _ := ret[1].(io.ReadCloser) - ret2, _ := ret[2].(func() error) - ret3, _ := ret[3].(error) - return ret0, ret1, ret2, ret3 -} - -// Start indicates an expected call of Start -func (mr *MockCommanderMockRecorder) Start(arg0 interface{}, arg1 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0}, arg1...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockCommander)(nil).Start), varargs...) -} diff --git a/internal/routing/mockFilemanager_test.go b/internal/routing/mockFilemanager_test.go deleted file mode 100644 index e269db13..00000000 --- a/internal/routing/mockFilemanager_test.go +++ /dev/null @@ -1,232 +0,0 @@ -// Code generated by MockGen. DO NOT EDIT. -// Source: github.com/qdm12/golibs/files (interfaces: FileManager) - -// Package routing is a generated GoMock package. -package routing - -import ( - gomock "github.com/golang/mock/gomock" - files "github.com/qdm12/golibs/files" - os "os" - reflect "reflect" -) - -// MockFileManager is a mock of FileManager interface -type MockFileManager struct { - ctrl *gomock.Controller - recorder *MockFileManagerMockRecorder -} - -// MockFileManagerMockRecorder is the mock recorder for MockFileManager -type MockFileManagerMockRecorder struct { - mock *MockFileManager -} - -// NewMockFileManager creates a new mock instance -func NewMockFileManager(ctrl *gomock.Controller) *MockFileManager { - mock := &MockFileManager{ctrl: ctrl} - mock.recorder = &MockFileManagerMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockFileManager) EXPECT() *MockFileManagerMockRecorder { - return m.recorder -} - -// CreateDir mocks base method -func (m *MockFileManager) CreateDir(arg0 string, arg1 ...files.WriteOptionSetter) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0} - for _, a := range arg1 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateDir", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// CreateDir indicates an expected call of CreateDir -func (mr *MockFileManagerMockRecorder) CreateDir(arg0 interface{}, arg1 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0}, arg1...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDir", reflect.TypeOf((*MockFileManager)(nil).CreateDir), varargs...) -} - -// DirectoryExists mocks base method -func (m *MockFileManager) DirectoryExists(arg0 string) (bool, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DirectoryExists", arg0) - ret0, _ := ret[0].(bool) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DirectoryExists indicates an expected call of DirectoryExists -func (mr *MockFileManagerMockRecorder) DirectoryExists(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DirectoryExists", reflect.TypeOf((*MockFileManager)(nil).DirectoryExists), arg0) -} - -// FileExists mocks base method -func (m *MockFileManager) FileExists(arg0 string) (bool, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "FileExists", arg0) - ret0, _ := ret[0].(bool) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// FileExists indicates an expected call of FileExists -func (mr *MockFileManagerMockRecorder) FileExists(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FileExists", reflect.TypeOf((*MockFileManager)(nil).FileExists), arg0) -} - -// FilepathExists mocks base method -func (m *MockFileManager) FilepathExists(arg0 string) (bool, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "FilepathExists", arg0) - ret0, _ := ret[0].(bool) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// FilepathExists indicates an expected call of FilepathExists -func (mr *MockFileManagerMockRecorder) FilepathExists(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FilepathExists", reflect.TypeOf((*MockFileManager)(nil).FilepathExists), arg0) -} - -// GetOwnership mocks base method -func (m *MockFileManager) GetOwnership(arg0 string) (int, int, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetOwnership", arg0) - ret0, _ := ret[0].(int) - ret1, _ := ret[1].(int) - ret2, _ := ret[2].(error) - return ret0, ret1, ret2 -} - -// GetOwnership indicates an expected call of GetOwnership -func (mr *MockFileManagerMockRecorder) GetOwnership(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOwnership", reflect.TypeOf((*MockFileManager)(nil).GetOwnership), arg0) -} - -// GetUserPermissions mocks base method -func (m *MockFileManager) GetUserPermissions(arg0 string) (bool, bool, bool, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetUserPermissions", arg0) - ret0, _ := ret[0].(bool) - ret1, _ := ret[1].(bool) - ret2, _ := ret[2].(bool) - ret3, _ := ret[3].(error) - return ret0, ret1, ret2, ret3 -} - -// GetUserPermissions indicates an expected call of GetUserPermissions -func (mr *MockFileManagerMockRecorder) GetUserPermissions(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserPermissions", reflect.TypeOf((*MockFileManager)(nil).GetUserPermissions), arg0) -} - -// ReadFile mocks base method -func (m *MockFileManager) ReadFile(arg0 string) ([]byte, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ReadFile", arg0) - ret0, _ := ret[0].([]byte) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ReadFile indicates an expected call of ReadFile -func (mr *MockFileManagerMockRecorder) ReadFile(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadFile", reflect.TypeOf((*MockFileManager)(nil).ReadFile), arg0) -} - -// SetOwnership mocks base method -func (m *MockFileManager) SetOwnership(arg0 string, arg1, arg2 int) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetOwnership", arg0, arg1, arg2) - ret0, _ := ret[0].(error) - return ret0 -} - -// SetOwnership indicates an expected call of SetOwnership -func (mr *MockFileManagerMockRecorder) SetOwnership(arg0, arg1, arg2 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetOwnership", reflect.TypeOf((*MockFileManager)(nil).SetOwnership), arg0, arg1, arg2) -} - -// SetUserPermissions mocks base method -func (m *MockFileManager) SetUserPermissions(arg0 string, arg1 os.FileMode) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetUserPermissions", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// SetUserPermissions indicates an expected call of SetUserPermissions -func (mr *MockFileManagerMockRecorder) SetUserPermissions(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserPermissions", reflect.TypeOf((*MockFileManager)(nil).SetUserPermissions), arg0, arg1) -} - -// Touch mocks base method -func (m *MockFileManager) Touch(arg0 string, arg1 ...files.WriteOptionSetter) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0} - for _, a := range arg1 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "Touch", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// Touch indicates an expected call of Touch -func (mr *MockFileManagerMockRecorder) Touch(arg0 interface{}, arg1 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0}, arg1...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Touch", reflect.TypeOf((*MockFileManager)(nil).Touch), varargs...) -} - -// WriteLinesToFile mocks base method -func (m *MockFileManager) WriteLinesToFile(arg0 string, arg1 []string, arg2 ...files.WriteOptionSetter) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "WriteLinesToFile", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// WriteLinesToFile indicates an expected call of WriteLinesToFile -func (mr *MockFileManagerMockRecorder) WriteLinesToFile(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteLinesToFile", reflect.TypeOf((*MockFileManager)(nil).WriteLinesToFile), varargs...) -} - -// WriteToFile mocks base method -func (m *MockFileManager) WriteToFile(arg0 string, arg1 []byte, arg2 ...files.WriteOptionSetter) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "WriteToFile", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// WriteToFile indicates an expected call of WriteToFile -func (mr *MockFileManagerMockRecorder) WriteToFile(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteToFile", reflect.TypeOf((*MockFileManager)(nil).WriteToFile), varargs...) -} diff --git a/internal/routing/mockLogger_test.go b/internal/routing/mockLogger_test.go deleted file mode 100644 index d5221360..00000000 --- a/internal/routing/mockLogger_test.go +++ /dev/null @@ -1,126 +0,0 @@ -// Code generated by MockGen. DO NOT EDIT. -// Source: github.com/qdm12/golibs/logging (interfaces: Logger) - -// Package routing is a generated GoMock package. -package routing - -import ( - gomock "github.com/golang/mock/gomock" - logging "github.com/qdm12/golibs/logging" - reflect "reflect" -) - -// MockLogger is a mock of Logger interface -type MockLogger struct { - ctrl *gomock.Controller - recorder *MockLoggerMockRecorder -} - -// MockLoggerMockRecorder is the mock recorder for MockLogger -type MockLoggerMockRecorder struct { - mock *MockLogger -} - -// NewMockLogger creates a new mock instance -func NewMockLogger(ctrl *gomock.Controller) *MockLogger { - mock := &MockLogger{ctrl: ctrl} - mock.recorder = &MockLoggerMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use -func (m *MockLogger) EXPECT() *MockLoggerMockRecorder { - return m.recorder -} - -// Debug mocks base method -func (m *MockLogger) Debug(arg0 ...interface{}) { - m.ctrl.T.Helper() - varargs := []interface{}{} - for _, a := range arg0 { - varargs = append(varargs, a) - } - m.ctrl.Call(m, "Debug", varargs...) -} - -// Debug indicates an expected call of Debug -func (mr *MockLoggerMockRecorder) Debug(arg0 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Debug", reflect.TypeOf((*MockLogger)(nil).Debug), arg0...) -} - -// Error mocks base method -func (m *MockLogger) Error(arg0 ...interface{}) { - m.ctrl.T.Helper() - varargs := []interface{}{} - for _, a := range arg0 { - varargs = append(varargs, a) - } - m.ctrl.Call(m, "Error", varargs...) -} - -// Error indicates an expected call of Error -func (mr *MockLoggerMockRecorder) Error(arg0 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Error", reflect.TypeOf((*MockLogger)(nil).Error), arg0...) -} - -// Info mocks base method -func (m *MockLogger) Info(arg0 ...interface{}) { - m.ctrl.T.Helper() - varargs := []interface{}{} - for _, a := range arg0 { - varargs = append(varargs, a) - } - m.ctrl.Call(m, "Info", varargs...) -} - -// Info indicates an expected call of Info -func (mr *MockLoggerMockRecorder) Info(arg0 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Info", reflect.TypeOf((*MockLogger)(nil).Info), arg0...) -} - -// Sync mocks base method -func (m *MockLogger) Sync() error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Sync") - ret0, _ := ret[0].(error) - return ret0 -} - -// Sync indicates an expected call of Sync -func (mr *MockLoggerMockRecorder) Sync() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sync", reflect.TypeOf((*MockLogger)(nil).Sync)) -} - -// Warn mocks base method -func (m *MockLogger) Warn(arg0 ...interface{}) { - m.ctrl.T.Helper() - varargs := []interface{}{} - for _, a := range arg0 { - varargs = append(varargs, a) - } - m.ctrl.Call(m, "Warn", varargs...) -} - -// Warn indicates an expected call of Warn -func (mr *MockLoggerMockRecorder) Warn(arg0 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Warn", reflect.TypeOf((*MockLogger)(nil).Warn), arg0...) -} - -// WithPrefix mocks base method -func (m *MockLogger) WithPrefix(arg0 string) logging.Logger { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WithPrefix", arg0) - ret0, _ := ret[0].(logging.Logger) - return ret0 -} - -// WithPrefix indicates an expected call of WithPrefix -func (mr *MockLoggerMockRecorder) WithPrefix(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithPrefix", reflect.TypeOf((*MockLogger)(nil).WithPrefix), arg0) -} diff --git a/internal/routing/mutate_test.go b/internal/routing/mutate_test.go index a39567e8..b434f75e 100644 --- a/internal/routing/mutate_test.go +++ b/internal/routing/mutate_test.go @@ -5,13 +5,12 @@ import ( "net" "testing" - gomock "github.com/golang/mock/gomock" + "github.com/golang/mock/gomock" + "github.com/qdm12/golibs/command/mock_command" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) -//go:generate mockgen -destination=mockCommander_test.go -package=routing github.com/qdm12/golibs/command Commander - func Test_removeRoute(t *testing.T) { t.Parallel() tests := map[string]struct { @@ -50,11 +49,11 @@ func Test_removeRoute(t *testing.T) { t.Parallel() mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() - mockCommander := NewMockCommander(mockCtrl) + commander := mock_command.NewMockCommander(mockCtrl) - mockCommander.EXPECT().Run("ip", "route", "del", tc.subnet.String()). + commander.EXPECT().Run("ip", "route", "del", tc.subnet.String()). Return(tc.runOutput, tc.runErr).Times(1) - r := &routing{commander: mockCommander} + r := &routing{commander: commander} err := r.removeRoute(tc.subnet) if tc.err != nil { require.Error(t, err) diff --git a/internal/routing/reader_test.go b/internal/routing/reader_test.go index aefbfd09..5ca038ca 100644 --- a/internal/routing/reader_test.go +++ b/internal/routing/reader_test.go @@ -5,16 +5,15 @@ import ( "net" "testing" - gomock "github.com/golang/mock/gomock" + "github.com/golang/mock/gomock" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" + "github.com/qdm12/golibs/files/mock_files" + "github.com/qdm12/golibs/logging/mock_logging" "github.com/qdm12/private-internet-access-docker/internal/constants" ) -//go:generate mockgen -destination=mockLogger_test.go -package=routing github.com/qdm12/golibs/logging Logger -//go:generate mockgen -destination=mockFilemanager_test.go -package=routing github.com/qdm12/golibs/files FileManager - func Test_parseRoutingTable(t *testing.T) { t.Parallel() tests := map[string]struct { @@ -130,19 +129,19 @@ eth0 000011AC 00000000 0001 0 0 0 0000FFFF t.Parallel() mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() - mockLogger := NewMockLogger(mockCtrl) - mockFilemanager := NewMockFileManager(mockCtrl) + logger := mock_logging.NewMockLogger(mockCtrl) + filemanager := mock_files.NewMockFileManager(mockCtrl) - mockFilemanager.EXPECT().ReadFile(string(constants.NetRoute)). + filemanager.EXPECT().ReadFile(string(constants.NetRoute)). Return(tc.data, tc.readErr).Times(1) - mockLogger.EXPECT().Info("detecting default network route").Times(1) + logger.EXPECT().Info("detecting default network route").Times(1) if tc.err == nil { - mockLogger.EXPECT().Info( + logger.EXPECT().Info( "default route found: interface %s, gateway %s, subnet %s", tc.defaultInterface, tc.defaultGateway.String(), tc.defaultSubnet.String(), ).Times(1) } - r := &routing{logger: mockLogger, fileManager: mockFilemanager} + r := &routing{logger: logger, fileManager: filemanager} defaultInterface, defaultGateway, defaultSubnet, err := r.DefaultRoute() if tc.err != nil { require.Error(t, err) @@ -203,10 +202,10 @@ eth0 0002A8C0 0100000A 0003 0 0 0 00FFFFFF t.Parallel() mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() - mockFilemanager := NewMockFileManager(mockCtrl) - mockFilemanager.EXPECT().ReadFile(string(constants.NetRoute)). + filemanager := mock_files.NewMockFileManager(mockCtrl) + filemanager.EXPECT().ReadFile(string(constants.NetRoute)). Return(tc.data, tc.readErr).Times(1) - r := &routing{fileManager: mockFilemanager} + r := &routing{fileManager: filemanager} exists, err := r.routeExists(tc.subnet) if tc.err != nil { require.Error(t, err) @@ -268,10 +267,10 @@ eth0 x t.Parallel() mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() - mockFilemanager := NewMockFileManager(mockCtrl) - mockFilemanager.EXPECT().ReadFile(string(constants.NetRoute)). + filemanager := mock_files.NewMockFileManager(mockCtrl) + filemanager.EXPECT().ReadFile(string(constants.NetRoute)). Return(tc.data, tc.readErr).Times(1) - r := &routing{fileManager: mockFilemanager} + r := &routing{fileManager: filemanager} ip, err := r.CurrentPublicIP(tc.defaultInterface) if tc.err != nil { require.Error(t, err) diff --git a/internal/shadowsocks/conf_test.go b/internal/shadowsocks/conf_test.go index 631476f4..aa8abfe2 100644 --- a/internal/shadowsocks/conf_test.go +++ b/internal/shadowsocks/conf_test.go @@ -4,11 +4,12 @@ import ( "fmt" "testing" - filesMocks "github.com/qdm12/golibs/files/mocks" - loggingMocks "github.com/qdm12/golibs/logging/mocks" + "github.com/golang/mock/gomock" + "github.com/qdm12/golibs/files" + "github.com/qdm12/golibs/files/mock_files" + "github.com/qdm12/golibs/logging/mock_logging" "github.com/qdm12/private-internet-access-docker/internal/constants" "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/mock" "github.com/stretchr/testify/require" ) @@ -54,16 +55,17 @@ func Test_MakeConf(t *testing.T) { tc := tc t.Run(name, func(t *testing.T) { t.Parallel() - logger := &loggingMocks.Logger{} - logger.On("Info", "%s: generating configuration file", logPrefix).Once() - fileManager := &filesMocks.FileManager{} - fileManager.On("WriteToFile", + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + logger := mock_logging.NewMockLogger(mockCtrl) + logger.EXPECT().Info("%s: generating configuration file", logPrefix).Times(1) + fileManager := mock_files.NewMockFileManager(mockCtrl) + fileManager.EXPECT().WriteToFile( string(constants.ShadowsocksConf), []byte(`{"server":"0.0.0.0","user":"nonrootuser","method":"chacha20-ietf-poly1305","timeout":30,"fast_open":false,"mode":"tcp_and_udp","port_password":{"2000":"abcde"},"workers":2,"interface":"tun","nameserver":"127.0.0.1"}`), - mock.AnythingOfType("files.WriteOptionSetter"), - mock.AnythingOfType("files.WriteOptionSetter"), - ). - Return(tc.writeErr).Once() + gomock.AssignableToTypeOf(files.Ownership(0, 0)), + gomock.AssignableToTypeOf(files.Ownership(0, 0)), + ).Return(tc.writeErr).Times(1) c := &configurator{logger: logger, fileManager: fileManager} err := c.MakeConf(2000, "abcde", "chacha20-ietf-poly1305", 1000, 1001) if tc.err != nil { @@ -72,8 +74,6 @@ func Test_MakeConf(t *testing.T) { } else { assert.NoError(t, err) } - logger.AssertExpectations(t) - fileManager.AssertExpectations(t) }) } }