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

Updated golibs and using gomock+mockgen for tests

Browse Source
This commit is contained in:
Quentin McGaw
2020-04-12 18:09:46 +00:00
parent 68203c221d
commit d42de99879
14 changed files with 171 additions and 603 deletions
Download Patch File Download Diff File Expand all files Collapse all files

76
internal/routing/mockCommander_test.go
View File

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

232
internal/routing/mockFilemanager_test.go
View File

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

126
internal/routing/mockLogger_test.go
View File

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

11
internal/routing/mutate_test.go
View File

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

31
internal/routing/reader_test.go
View File

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