Updated golibs and using gomock+mockgen for tests

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/kyokomi/emoji v2.2.1+incompatible
-	github.com/qdm12/golibs v0.0.0-20200329231626-f55b47cd4e96
+	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
 )

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.2.1+incompatible h1:uP/6J5y5U0XxPh6fv8YximpVD1uMrshXG78I1+uF5SA=
-github.com/kyokomi/emoji v2.1.0+incompatible/go.mod h1:mZ6aGCD7yk8j6QY6KICwnZ2pxoszVseX1DNoGtU2tBA=
+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-20200412175259-da41d65db446 h1:sBPYLwDSqRsOqHi7f34c7QMcoR1xLD1wLnOl0L7br6c=
-github.com/qdm12/golibs v0.0.0-20200329231626-f55b47cd4e96/go.mod h1:YULaFjj6VGmhjak6f35sUWwEleHUmngN5IQ3kdvd6XE=
+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-20200409092240-59c9f1ba88fa h1:mQTN3ECqfsViCNBgq+A40vdwhkGykrrQlYe3mPj6BoU=
-golang.org/x/sys v0.0.0-20200327173247-9dae0f8f5775/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+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=

internal/dns/command_test.go

@@ -4,8 +4,9 @@ import (
 	"fmt"
 	"testing"
 
-	commandMocks "github.com/qdm12/golibs/command/mocks"
+	"github.com/golang/mock/gomock"
-	loggingMocks "github.com/qdm12/golibs/logging/mocks"
+	"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{}
+	mockCtrl := gomock.NewController(t)
-	logger.On("Info", "%s: starting unbound", logPrefix).Once()
+	defer mockCtrl.Finish()
-	commander := &commandMocks.Commander{}
+	logger := mock_logging.NewMockLogger(mockCtrl)
-	commander.On("Start", "unbound", "-d", "-c", string(constants.UnboundConf), "-vv").
+	logger.EXPECT().Info("%s: starting unbound", logPrefix).Times(1)
-		Return(nil, nil, nil, nil).Once()
+	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{}
+			mockCtrl := gomock.NewController(t)
-			commander.On("Run", "unbound", "-V").
+			defer mockCtrl.Finish()
-				Return(tc.runOutput, tc.runErr).Once()
+			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)
 		})
 	}
 }

internal/dns/conf_test.go

@@ -5,8 +5,9 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/qdm12/golibs/logging"
+	"github.com/golang/mock/gomock"
-	"github.com/qdm12/golibs/network/mocks"
+	"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{}
+	mockCtrl := gomock.NewController(t)
-	client.On("GetContent", string(constants.MaliciousBlockListHostnamesURL)).
+	defer mockCtrl.Finish()
-		Return([]byte("b\na\nc"), 200, nil).Once()
+	client := mock_network.NewMockClient(mockCtrl)
-	client.On("GetContent", string(constants.MaliciousBlockListIPsURL)).
+	client.EXPECT().GetContent(string(constants.MaliciousBlockListHostnamesURL)).
-		Return([]byte("c\nd\n"), 200, nil).Once()
+		Return([]byte("b\na\nc"), 200, nil).Times(1)
-	emptyLogger, err := logging.NewEmptyLogger()
+	client.EXPECT().GetContent(string(constants.MaliciousBlockListIPsURL)).
-	require.NoError(t, err)
+		Return([]byte("c\nd\n"), 200, nil).Times(1)
-	lines, warnings, err := generateUnboundConf(settings, client, emptyLogger)
+	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)).
+				client.EXPECT().GetContent(string(constants.MaliciousBlockListHostnamesURL)).
-					Return(tc.malicious.content, 200, tc.malicious.clientErr).Once()
+					Return(tc.malicious.content, 200, tc.malicious.clientErr).Times(1)
-				client.On("GetContent", string(constants.MaliciousBlockListIPsURL)).
+				client.EXPECT().GetContent(string(constants.MaliciousBlockListIPsURL)).
-					Return(tc.malicious.content, 200, tc.malicious.clientErr).Once()
+					Return(tc.malicious.content, 200, tc.malicious.clientErr).Times(1)
 			}
 			if tc.ads.blocked {
-				client.On("GetContent", string(constants.AdsBlockListHostnamesURL)).
+				client.EXPECT().GetContent(string(constants.AdsBlockListHostnamesURL)).
-					Return(tc.ads.content, 200, tc.ads.clientErr).Once()
+					Return(tc.ads.content, 200, tc.ads.clientErr).Times(1)
-				client.On("GetContent", string(constants.AdsBlockListIPsURL)).
+				client.EXPECT().GetContent(string(constants.AdsBlockListIPsURL)).
-					Return(tc.ads.content, 200, tc.ads.clientErr).Once()
+					Return(tc.ads.content, 200, tc.ads.clientErr).Times(1)
 			}
 			if tc.surveillance.blocked {
-				client.On("GetContent", string(constants.SurveillanceBlockListHostnamesURL)).
+				client.EXPECT().GetContent(string(constants.SurveillanceBlockListHostnamesURL)).
-					Return(tc.surveillance.content, 200, tc.surveillance.clientErr).Once()
+					Return(tc.surveillance.content, 200, tc.surveillance.clientErr).Times(1)
-				client.On("GetContent", string(constants.SurveillanceBlockListIPsURL)).
+				client.EXPECT().GetContent(string(constants.SurveillanceBlockListIPsURL)).
-					Return(tc.surveillance.content, 200, tc.surveillance.clientErr).Once()
+					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{}
+			mockCtrl := gomock.NewController(t)
-			client.On("GetContent", "irrelevant_url").Return(
+			defer mockCtrl.Finish()
-				tc.content, tc.status, tc.clientErr,
+			client := mock_network.NewMockClient(mockCtrl)
-			).Once()
+			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)).
+				client.EXPECT().GetContent(string(constants.MaliciousBlockListHostnamesURL)).
-					Return(tc.malicious.content, 200, tc.malicious.clientErr).Once()
+					Return(tc.malicious.content, 200, tc.malicious.clientErr).Times(1)
 			}
 			if tc.ads.blocked {
-				client.On("GetContent", string(constants.AdsBlockListHostnamesURL)).
+				client.EXPECT().GetContent(string(constants.AdsBlockListHostnamesURL)).
-					Return(tc.ads.content, 200, tc.ads.clientErr).Once()
+					Return(tc.ads.content, 200, tc.ads.clientErr).Times(1)
 			}
 			if tc.surveillance.blocked {
-				client.On("GetContent", string(constants.SurveillanceBlockListHostnamesURL)).
+				client.EXPECT().GetContent(string(constants.SurveillanceBlockListHostnamesURL)).
-					Return(tc.surveillance.content, 200, tc.surveillance.clientErr).Once()
+					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)).
+				client.EXPECT().GetContent(string(constants.MaliciousBlockListIPsURL)).
-					Return(tc.malicious.content, 200, tc.malicious.clientErr).Once()
+					Return(tc.malicious.content, 200, tc.malicious.clientErr).Times(1)
 			}
 			if tc.ads.blocked {
-				client.On("GetContent", string(constants.AdsBlockListIPsURL)).
+				client.EXPECT().GetContent(string(constants.AdsBlockListIPsURL)).
-					Return(tc.ads.content, 200, tc.ads.clientErr).Once()
+					Return(tc.ads.content, 200, tc.ads.clientErr).Times(1)
 			}
 			if tc.surveillance.blocked {
-				client.On("GetContent", string(constants.SurveillanceBlockListIPsURL)).
+				client.EXPECT().GetContent(string(constants.SurveillanceBlockListIPsURL)).
-					Return(tc.surveillance.content, 200, tc.surveillance.clientErr).Once()
+					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)
 		})
 	}
 }

internal/dns/nameserver_test.go

@@ -5,8 +5,9 @@ import (
 	"net"
 	"testing"
 
-	filesmocks "github.com/qdm12/golibs/files/mocks"
+	"github.com/golang/mock/gomock"
-	loggingmocks "github.com/qdm12/golibs/logging/mocks"
+	"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{}
+			mockCtrl := gomock.NewController(t)
-			fileManager.On("ReadFile", string(constants.ResolvConf)).
+			defer mockCtrl.Finish()
-				Return(tc.data, tc.readErr).Once()
+			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).
+				fileManager.EXPECT().WriteToFile(string(constants.ResolvConf), tc.writtenData).
-					Return(tc.writeErr).Once()
+					Return(tc.writeErr).Times(1)
 			}
-			logger := &loggingmocks.Logger{}
+			logger := mock_logging.NewMockLogger(mockCtrl)
-			logger.On("Info", "%s: using DNS address %s system wide", logPrefix, "127.0.0.1").Once()
+			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)
 		})
 	}
 }

internal/dns/roots_test.go

@@ -5,11 +5,12 @@ import (
 	"net/http"
 	"testing"
 
-	filesMocks "github.com/qdm12/golibs/files/mocks"
+	"github.com/golang/mock/gomock"
-	loggingMocks "github.com/qdm12/golibs/logging/mocks"
+	"github.com/qdm12/golibs/files"
-	networkMocks "github.com/qdm12/golibs/network/mocks"
+	"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{}
+			mockCtrl := gomock.NewController(t)
-			logger.On("Info", "%s: downloading root hints from %s", logPrefix, constants.NamedRootURL).Once()
+			defer mockCtrl.Finish()
-			client := &networkMocks.Client{}
+			logger := mock_logging.NewMockLogger(mockCtrl)
-			client.On("GetContent", string(constants.NamedRootURL)).
+			logger.EXPECT().Info("%s: downloading root hints from %s", logPrefix, constants.NamedRootURL).Times(1)
-				Return(tc.content, tc.status, tc.clientErr).Once()
+			client := mock_network.NewMockClient(mockCtrl)
-			fileManager := &filesMocks.FileManager{}
+			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(
+				fileManager.EXPECT().WriteToFile(
-					"WriteToFile",
 					string(constants.RootHints),
 					tc.content,
-					mock.AnythingOfType("files.WriteOptionSetter"),
+					gomock.AssignableToTypeOf(files.Ownership(0, 0)),
-					mock.AnythingOfType("files.WriteOptionSetter")).
+					gomock.AssignableToTypeOf(files.Ownership(0, 0))).
-					Return(tc.writeErr).Once()
+					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{}
+			mockCtrl := gomock.NewController(t)
-			logger.On("Info", "%s: downloading root key from %s", logPrefix, constants.RootKeyURL).Once()
+			defer mockCtrl.Finish()
-			client := &networkMocks.Client{}
+			logger := mock_logging.NewMockLogger(mockCtrl)
-			client.On("GetContent", string(constants.RootKeyURL)).
+			logger.EXPECT().Info("%s: downloading root key from %s", logPrefix, constants.RootKeyURL).Times(1)
-				Return(tc.content, tc.status, tc.clientErr).Once()
+			client := mock_network.NewMockClient(mockCtrl)
-			fileManager := &filesMocks.FileManager{}
+			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(
+				fileManager.EXPECT().WriteToFile(
-					"WriteToFile",
 					string(constants.RootKey),
 					tc.content,
-					mock.AnythingOfType("files.WriteOptionSetter"),
+					gomock.AssignableToTypeOf(files.Ownership(0, 0)),
-					mock.AnythingOfType("files.WriteOptionSetter"),
+					gomock.AssignableToTypeOf(files.Ownership(0, 0)),
-				).Return(tc.writeErr).Once()
+				).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)
 		})
 	}
 }

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).
+				logger.EXPECT().Error(tc.err).Do(func(err error) {
-					Run(func(args mock.Arguments) {
+					logged = err.Error()
-						err := args.Get(0).(error)
+				}).Times(1)
-						logged = err.Error()
-					}).Once()
 			}
 			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).
+				logger.EXPECT().Error(tc.commandErr).Do(func(err error) {
-					Run(func(args mock.Arguments) {
+					logged = err.Error()
-						err := args.Get(0).(error)
+				}).Times(1)
-						logged = err.Error()
+
-					}).Once()
 			} else {
-				logger.On("Info", "%s version: %s", tc.program, tc.commandVersion).
+				logger.EXPECT().Info("%s version: %s", tc.program, tc.commandVersion).
-					Run(func(args mock.Arguments) {
+					Do(func(format, program, version string) {
-						format := args.Get(0).(string)
-						program := args.Get(1).(string)
-						version := args.Get(2).(string)
 						logged = fmt.Sprintf(format, program, version)
-					}).Once()
+					}).Times(1)
 			}
 			e := &env{logger: logger}
 			commandFn := func() (string, error) { return tc.commandVersion, tc.commandErr }

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

internal/routing/mockCommander_test.go

@@ -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...)
-}

internal/routing/mockFilemanager_test.go

@@ -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...)
-}

internal/routing/mockLogger_test.go

@@ -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)
-}

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)

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)
+			logger := mock_logging.NewMockLogger(mockCtrl)
-			mockFilemanager := NewMockFileManager(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)
+			filemanager := mock_files.NewMockFileManager(mockCtrl)
-			mockFilemanager.EXPECT().ReadFile(string(constants.NetRoute)).
+			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)
+			filemanager := mock_files.NewMockFileManager(mockCtrl)
-			mockFilemanager.EXPECT().ReadFile(string(constants.NetRoute)).
+			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)

internal/shadowsocks/conf_test.go

@@ -4,11 +4,12 @@ import (
 	"fmt"
 	"testing"
 
-	filesMocks "github.com/qdm12/golibs/files/mocks"
+	"github.com/golang/mock/gomock"
-	loggingMocks "github.com/qdm12/golibs/logging/mocks"
+	"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{}
+			mockCtrl := gomock.NewController(t)
-			logger.On("Info", "%s: generating configuration file", logPrefix).Once()
+			defer mockCtrl.Finish()
-			fileManager := &filesMocks.FileManager{}
+			logger := mock_logging.NewMockLogger(mockCtrl)
-			fileManager.On("WriteToFile",
+			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"),
+				gomock.AssignableToTypeOf(files.Ownership(0, 0)),
-				mock.AnythingOfType("files.WriteOptionSetter"),
+				gomock.AssignableToTypeOf(files.Ownership(0, 0)),
-			).
+			).Return(tc.writeErr).Times(1)
-				Return(tc.writeErr).Once()
 			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)
 		})
 	}
 }