From b42299a5aa0f663a57b074a9b2d719e8d2c04509 Mon Sep 17 00:00:00 2001 From: Pete Davison Date: Sat, 15 Apr 2023 21:27:14 +0100 Subject: [PATCH] feat: use mockery/testify for mocking instead of mockgen/gomock (#1118) --- .mockery.yaml | 4 + Taskfile.yml | 26 ++-- go.mod | 2 +- go.sum | 26 +--- internal/fingerprint/checker_mock.go | 132 ---------------- internal/fingerprint/task_test.go | 61 ++++---- internal/mocks/sources_checkable.go | 225 +++++++++++++++++++++++++++ internal/mocks/status_checkable.go | 92 +++++++++++ 8 files changed, 370 insertions(+), 198 deletions(-) create mode 100644 .mockery.yaml delete mode 100644 internal/fingerprint/checker_mock.go create mode 100644 internal/mocks/sources_checkable.go create mode 100644 internal/mocks/status_checkable.go diff --git a/.mockery.yaml b/.mockery.yaml new file mode 100644 index 00000000..2d095f31 --- /dev/null +++ b/.mockery.yaml @@ -0,0 +1,4 @@ +with-expecter: true +keeptree: true +case: underscore +output: ./internal/mocks diff --git a/Taskfile.yml b/Taskfile.yml index eada85f6..cc60cb63 100644 --- a/Taskfile.yml +++ b/Taskfile.yml @@ -6,6 +6,9 @@ includes: taskfile: ./docs dir: ./docs +vars: + BIN: "{{.ROOT_DIR}}/bin" + env: CGO_ENABLED: '0' @@ -26,20 +29,25 @@ tasks: generate: desc: Runs Go generate to create mocks aliases: [gen, g] - deps: [install:mockgen] + deps: [install:mockery] sources: - "internal/fingerprint/checker.go" generates: - - "internal/fingerprint/checker_mock.go" + - "internal/mocks/*.go" cmds: - - mockgen -source=internal/fingerprint/checker.go -destination=internal/fingerprint/checker_mock.go -package=fingerprint + - "{{.BIN}}/mockery --dir ./internal/fingerprint --name SourcesCheckable" + - "{{.BIN}}/mockery --dir ./internal/fingerprint --name StatusCheckable" - install:mockgen: + install:mockery: desc: Installs mockgen; a tool to generate mock files + vars: + MOCKERY_VERSION: v2.24.0 + env: + GOBIN: "{{.BIN}}" status: - - command -v mockgen &>/dev/null + - go version -m {{.BIN}}/mockery | grep github.com/vektra/mockery | grep {{.MOCKERY_VERSION}} cmds: - - go install github.com/golang/mock/mockgen@latest + - go install github.com/vektra/mockery/v2@{{.MOCKERY_VERSION}} mod: desc: Downloads and tidy Go modules @@ -75,15 +83,15 @@ tasks: sources: - ./cmd/sleepit/**/*.go generates: - - ./bin/sleepit + - "{{.BIN}}/sleepit" cmds: - - go build -o ./bin/sleepit{{exeExt}} ./cmd/sleepit + - go build -o {{.BIN}}/sleepit{{exeExt}} ./cmd/sleepit sleepit:run: desc: Builds the sleepit test helper deps: [sleepit:build] cmds: - - ./bin/sleepit {{.CLI_ARGS}} + - "{{.BIN}}/sleepit {{.CLI_ARGS}}" silent: true test: diff --git a/go.mod b/go.mod index e6265fbb..8e58fa42 100644 --- a/go.mod +++ b/go.mod @@ -6,7 +6,6 @@ require ( github.com/Masterminds/semver/v3 v3.2.1 github.com/fatih/color v1.15.0 github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0 - github.com/golang/mock v1.6.0 github.com/joho/godotenv v1.5.1 github.com/mattn/go-zglob v0.0.4 github.com/mitchellh/hashstructure/v2 v2.0.2 @@ -25,6 +24,7 @@ require ( github.com/mattn/go-colorable v0.1.13 // indirect github.com/mattn/go-isatty v0.0.17 // indirect github.com/pmezard/go-difflib v1.0.0 // indirect + github.com/stretchr/objx v0.5.0 // indirect golang.org/x/sys v0.6.0 // indirect golang.org/x/term v0.3.0 // indirect gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 // indirect diff --git a/go.sum b/go.sum index 6b97fc4f..35b18fa8 100644 --- a/go.sum +++ b/go.sum @@ -9,8 +9,6 @@ github.com/fatih/color v1.15.0/go.mod h1:0h5ZqXfHYED7Bhv2ZJamyIOUej9KtShiJESRwBD github.com/frankban/quicktest v1.14.4 h1:g2rn0vABPOOXmZUj+vbmUp0lPoXEMuhTpIluN0XL9UY= github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0 h1:p104kn46Q8WdvHunIJ9dAyjPVtrBPhSr3KT2yUst43I= github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0/go.mod h1:fyg7847qk6SyHyPtNmDHnmrv/HOrqktSC+C9fM+CJOE= -github.com/golang/mock v1.6.0 h1:ErTB+efbowRARo13NNdxyJji2egdxLGQhRaY+DUumQc= -github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs= github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38= github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0= github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4= @@ -36,44 +34,22 @@ github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA= github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= +github.com/stretchr/objx v0.5.0 h1:1zr/of2m5FGMsad5YfcqgdqdWrIhu+EBEJRhR1U7z/c= github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA= github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= github.com/stretchr/testify v1.8.2 h1:+h33VjcLVPDHtOdpUCuF+7gSuG3yGIftsP1YvFihtJ8= github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= -github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= -golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= -golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/exp v0.0.0-20230212135524-a684f29349b6 h1:Ic9KukPQ7PegFzHckNiMTQXGgEszA7mY2Fn4ZMtnMbw= golang.org/x/exp v0.0.0-20230212135524-a684f29349b6/go.mod h1:CxIveKay+FTh1D0yPZemJVgC/95VzuuOLq5Qi4xnoYc= -golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= -golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= -golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= -golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o= golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= -golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.6.0 h1:MVltZSvRTcU2ljQOhs94SXPftV6DCNnZViHeQps87pQ= golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/term v0.3.0 h1:qoo4akIqOcDME5bhc/NgxUdovd6BSS2uMsVjB56q1xI= golang.org/x/term v0.3.0/go.mod h1:q750SLmJuPmVoN1blW3UFBPREJfb1KmY3vwxfr+nFDA= -golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= -golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= -golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= -golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= -golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY= gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= diff --git a/internal/fingerprint/checker_mock.go b/internal/fingerprint/checker_mock.go deleted file mode 100644 index fbafd4a7..00000000 --- a/internal/fingerprint/checker_mock.go +++ /dev/null @@ -1,132 +0,0 @@ -// Code generated by MockGen. DO NOT EDIT. -// Source: internal/fingerprint/checker.go - -// Package fingerprint is a generated GoMock package. -package fingerprint - -import ( - context "context" - reflect "reflect" - - taskfile "github.com/go-task/task/v3/taskfile" - gomock "github.com/golang/mock/gomock" -) - -// MockStatusCheckable is a mock of StatusCheckable interface. -type MockStatusCheckable struct { - ctrl *gomock.Controller - recorder *MockStatusCheckableMockRecorder -} - -// MockStatusCheckableMockRecorder is the mock recorder for MockStatusCheckable. -type MockStatusCheckableMockRecorder struct { - mock *MockStatusCheckable -} - -// NewMockStatusCheckable creates a new mock instance. -func NewMockStatusCheckable(ctrl *gomock.Controller) *MockStatusCheckable { - mock := &MockStatusCheckable{ctrl: ctrl} - mock.recorder = &MockStatusCheckableMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockStatusCheckable) EXPECT() *MockStatusCheckableMockRecorder { - return m.recorder -} - -// IsUpToDate mocks base method. -func (m *MockStatusCheckable) IsUpToDate(ctx context.Context, t *taskfile.Task) (bool, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "IsUpToDate", ctx, t) - ret0, _ := ret[0].(bool) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// IsUpToDate indicates an expected call of IsUpToDate. -func (mr *MockStatusCheckableMockRecorder) IsUpToDate(ctx, t interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsUpToDate", reflect.TypeOf((*MockStatusCheckable)(nil).IsUpToDate), ctx, t) -} - -// MockSourcesCheckable is a mock of SourcesCheckable interface. -type MockSourcesCheckable struct { - ctrl *gomock.Controller - recorder *MockSourcesCheckableMockRecorder -} - -// MockSourcesCheckableMockRecorder is the mock recorder for MockSourcesCheckable. -type MockSourcesCheckableMockRecorder struct { - mock *MockSourcesCheckable -} - -// NewMockSourcesCheckable creates a new mock instance. -func NewMockSourcesCheckable(ctrl *gomock.Controller) *MockSourcesCheckable { - mock := &MockSourcesCheckable{ctrl: ctrl} - mock.recorder = &MockSourcesCheckableMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockSourcesCheckable) EXPECT() *MockSourcesCheckableMockRecorder { - return m.recorder -} - -// IsUpToDate mocks base method. -func (m *MockSourcesCheckable) IsUpToDate(t *taskfile.Task) (bool, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "IsUpToDate", t) - ret0, _ := ret[0].(bool) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// IsUpToDate indicates an expected call of IsUpToDate. -func (mr *MockSourcesCheckableMockRecorder) IsUpToDate(t interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsUpToDate", reflect.TypeOf((*MockSourcesCheckable)(nil).IsUpToDate), t) -} - -// Kind mocks base method. -func (m *MockSourcesCheckable) Kind() string { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Kind") - ret0, _ := ret[0].(string) - return ret0 -} - -// Kind indicates an expected call of Kind. -func (mr *MockSourcesCheckableMockRecorder) Kind() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Kind", reflect.TypeOf((*MockSourcesCheckable)(nil).Kind)) -} - -// OnError mocks base method. -func (m *MockSourcesCheckable) OnError(t *taskfile.Task) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "OnError", t) - ret0, _ := ret[0].(error) - return ret0 -} - -// OnError indicates an expected call of OnError. -func (mr *MockSourcesCheckableMockRecorder) OnError(t interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnError", reflect.TypeOf((*MockSourcesCheckable)(nil).OnError), t) -} - -// Value mocks base method. -func (m *MockSourcesCheckable) Value(t *taskfile.Task) (any, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Value", t) - ret0, _ := ret[0].(any) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Value indicates an expected call of Value. -func (mr *MockSourcesCheckableMockRecorder) Value(t interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Value", reflect.TypeOf((*MockSourcesCheckable)(nil).Value), t) -} diff --git a/internal/fingerprint/task_test.go b/internal/fingerprint/task_test.go index a6a38167..8bbff836 100644 --- a/internal/fingerprint/task_test.go +++ b/internal/fingerprint/task_test.go @@ -4,10 +4,11 @@ import ( "context" "testing" - "github.com/golang/mock/gomock" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" "github.com/stretchr/testify/require" + "github.com/go-task/task/v3/internal/mocks" "github.com/go-task/task/v3/taskfile" ) @@ -28,8 +29,8 @@ func TestIsTaskUpToDate(t *testing.T) { tests := []struct { name string task *taskfile.Task - setupMockStatusChecker func(m *MockStatusCheckable) - setupMockSourcesChecker func(m *MockSourcesCheckable) + setupMockStatusChecker func(m *mocks.StatusCheckable) + setupMockSourcesChecker func(m *mocks.SourcesCheckable) expected bool }{ { @@ -49,8 +50,8 @@ func TestIsTaskUpToDate(t *testing.T) { Sources: []string{"sources"}, }, setupMockStatusChecker: nil, - setupMockSourcesChecker: func(m *MockSourcesCheckable) { - m.EXPECT().IsUpToDate(gomock.Any()).Return(true, nil) + setupMockSourcesChecker: func(m *mocks.SourcesCheckable) { + m.EXPECT().IsUpToDate(mock.Anything).Return(true, nil) }, expected: true, }, @@ -61,8 +62,8 @@ func TestIsTaskUpToDate(t *testing.T) { Sources: []string{"sources"}, }, setupMockStatusChecker: nil, - setupMockSourcesChecker: func(m *MockSourcesCheckable) { - m.EXPECT().IsUpToDate(gomock.Any()).Return(false, nil) + setupMockSourcesChecker: func(m *mocks.SourcesCheckable) { + m.EXPECT().IsUpToDate(mock.Anything).Return(false, nil) }, expected: false, }, @@ -72,8 +73,8 @@ func TestIsTaskUpToDate(t *testing.T) { Status: []string{"status"}, Sources: nil, }, - setupMockStatusChecker: func(m *MockStatusCheckable) { - m.EXPECT().IsUpToDate(gomock.Any(), gomock.Any()).Return(true, nil) + setupMockStatusChecker: func(m *mocks.StatusCheckable) { + m.EXPECT().IsUpToDate(mock.Anything, mock.Anything).Return(true, nil) }, setupMockSourcesChecker: nil, expected: true, @@ -84,11 +85,11 @@ func TestIsTaskUpToDate(t *testing.T) { Status: []string{"status"}, Sources: []string{"sources"}, }, - setupMockStatusChecker: func(m *MockStatusCheckable) { - m.EXPECT().IsUpToDate(gomock.Any(), gomock.Any()).Return(true, nil) + setupMockStatusChecker: func(m *mocks.StatusCheckable) { + m.EXPECT().IsUpToDate(mock.Anything, mock.Anything).Return(true, nil) }, - setupMockSourcesChecker: func(m *MockSourcesCheckable) { - m.EXPECT().IsUpToDate(gomock.Any()).Return(true, nil) + setupMockSourcesChecker: func(m *mocks.SourcesCheckable) { + m.EXPECT().IsUpToDate(mock.Anything).Return(true, nil) }, expected: true, }, @@ -98,11 +99,11 @@ func TestIsTaskUpToDate(t *testing.T) { Status: []string{"status"}, Sources: []string{"sources"}, }, - setupMockStatusChecker: func(m *MockStatusCheckable) { - m.EXPECT().IsUpToDate(gomock.Any(), gomock.Any()).Return(true, nil) + setupMockStatusChecker: func(m *mocks.StatusCheckable) { + m.EXPECT().IsUpToDate(mock.Anything, mock.Anything).Return(true, nil) }, - setupMockSourcesChecker: func(m *MockSourcesCheckable) { - m.EXPECT().IsUpToDate(gomock.Any()).Return(false, nil) + setupMockSourcesChecker: func(m *mocks.SourcesCheckable) { + m.EXPECT().IsUpToDate(mock.Anything).Return(false, nil) }, expected: false, }, @@ -112,8 +113,8 @@ func TestIsTaskUpToDate(t *testing.T) { Status: []string{"status"}, Sources: nil, }, - setupMockStatusChecker: func(m *MockStatusCheckable) { - m.EXPECT().IsUpToDate(gomock.Any(), gomock.Any()).Return(false, nil) + setupMockStatusChecker: func(m *mocks.StatusCheckable) { + m.EXPECT().IsUpToDate(mock.Anything, mock.Anything).Return(false, nil) }, setupMockSourcesChecker: nil, expected: false, @@ -124,11 +125,11 @@ func TestIsTaskUpToDate(t *testing.T) { Status: []string{"status"}, Sources: []string{"sources"}, }, - setupMockStatusChecker: func(m *MockStatusCheckable) { - m.EXPECT().IsUpToDate(gomock.Any(), gomock.Any()).Return(false, nil) + setupMockStatusChecker: func(m *mocks.StatusCheckable) { + m.EXPECT().IsUpToDate(mock.Anything, mock.Anything).Return(false, nil) }, - setupMockSourcesChecker: func(m *MockSourcesCheckable) { - m.EXPECT().IsUpToDate(gomock.Any()).Return(true, nil) + setupMockSourcesChecker: func(m *mocks.SourcesCheckable) { + m.EXPECT().IsUpToDate(mock.Anything).Return(true, nil) }, expected: false, }, @@ -138,25 +139,23 @@ func TestIsTaskUpToDate(t *testing.T) { Status: []string{"status"}, Sources: []string{"sources"}, }, - setupMockStatusChecker: func(m *MockStatusCheckable) { - m.EXPECT().IsUpToDate(gomock.Any(), gomock.Any()).Return(false, nil) + setupMockStatusChecker: func(m *mocks.StatusCheckable) { + m.EXPECT().IsUpToDate(mock.Anything, mock.Anything).Return(false, nil) }, - setupMockSourcesChecker: func(m *MockSourcesCheckable) { - m.EXPECT().IsUpToDate(gomock.Any()).Return(false, nil) + setupMockSourcesChecker: func(m *mocks.SourcesCheckable) { + m.EXPECT().IsUpToDate(mock.Anything).Return(false, nil) }, expected: false, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - ctrl := gomock.NewController(t) - - mockStatusChecker := NewMockStatusCheckable(ctrl) + mockStatusChecker := mocks.NewStatusCheckable(t) if tt.setupMockStatusChecker != nil { tt.setupMockStatusChecker(mockStatusChecker) } - mockSourcesChecker := NewMockSourcesCheckable(ctrl) + mockSourcesChecker := mocks.NewSourcesCheckable(t) if tt.setupMockSourcesChecker != nil { tt.setupMockSourcesChecker(mockSourcesChecker) } diff --git a/internal/mocks/sources_checkable.go b/internal/mocks/sources_checkable.go new file mode 100644 index 00000000..1c99f0a4 --- /dev/null +++ b/internal/mocks/sources_checkable.go @@ -0,0 +1,225 @@ +// Code generated by mockery v2.24.0. DO NOT EDIT. + +package mocks + +import ( + taskfile "github.com/go-task/task/v3/taskfile" + mock "github.com/stretchr/testify/mock" +) + +// SourcesCheckable is an autogenerated mock type for the SourcesCheckable type +type SourcesCheckable struct { + mock.Mock +} + +type SourcesCheckable_Expecter struct { + mock *mock.Mock +} + +func (_m *SourcesCheckable) EXPECT() *SourcesCheckable_Expecter { + return &SourcesCheckable_Expecter{mock: &_m.Mock} +} + +// IsUpToDate provides a mock function with given fields: t +func (_m *SourcesCheckable) IsUpToDate(t *taskfile.Task) (bool, error) { + ret := _m.Called(t) + + var r0 bool + var r1 error + if rf, ok := ret.Get(0).(func(*taskfile.Task) (bool, error)); ok { + return rf(t) + } + if rf, ok := ret.Get(0).(func(*taskfile.Task) bool); ok { + r0 = rf(t) + } else { + r0 = ret.Get(0).(bool) + } + + if rf, ok := ret.Get(1).(func(*taskfile.Task) error); ok { + r1 = rf(t) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SourcesCheckable_IsUpToDate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsUpToDate' +type SourcesCheckable_IsUpToDate_Call struct { + *mock.Call +} + +// IsUpToDate is a helper method to define mock.On call +// - t *taskfile.Task +func (_e *SourcesCheckable_Expecter) IsUpToDate(t interface{}) *SourcesCheckable_IsUpToDate_Call { + return &SourcesCheckable_IsUpToDate_Call{Call: _e.mock.On("IsUpToDate", t)} +} + +func (_c *SourcesCheckable_IsUpToDate_Call) Run(run func(t *taskfile.Task)) *SourcesCheckable_IsUpToDate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*taskfile.Task)) + }) + return _c +} + +func (_c *SourcesCheckable_IsUpToDate_Call) Return(_a0 bool, _a1 error) *SourcesCheckable_IsUpToDate_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SourcesCheckable_IsUpToDate_Call) RunAndReturn(run func(*taskfile.Task) (bool, error)) *SourcesCheckable_IsUpToDate_Call { + _c.Call.Return(run) + return _c +} + +// Kind provides a mock function with given fields: +func (_m *SourcesCheckable) Kind() string { + ret := _m.Called() + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// SourcesCheckable_Kind_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Kind' +type SourcesCheckable_Kind_Call struct { + *mock.Call +} + +// Kind is a helper method to define mock.On call +func (_e *SourcesCheckable_Expecter) Kind() *SourcesCheckable_Kind_Call { + return &SourcesCheckable_Kind_Call{Call: _e.mock.On("Kind")} +} + +func (_c *SourcesCheckable_Kind_Call) Run(run func()) *SourcesCheckable_Kind_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *SourcesCheckable_Kind_Call) Return(_a0 string) *SourcesCheckable_Kind_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SourcesCheckable_Kind_Call) RunAndReturn(run func() string) *SourcesCheckable_Kind_Call { + _c.Call.Return(run) + return _c +} + +// OnError provides a mock function with given fields: t +func (_m *SourcesCheckable) OnError(t *taskfile.Task) error { + ret := _m.Called(t) + + var r0 error + if rf, ok := ret.Get(0).(func(*taskfile.Task) error); ok { + r0 = rf(t) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// SourcesCheckable_OnError_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OnError' +type SourcesCheckable_OnError_Call struct { + *mock.Call +} + +// OnError is a helper method to define mock.On call +// - t *taskfile.Task +func (_e *SourcesCheckable_Expecter) OnError(t interface{}) *SourcesCheckable_OnError_Call { + return &SourcesCheckable_OnError_Call{Call: _e.mock.On("OnError", t)} +} + +func (_c *SourcesCheckable_OnError_Call) Run(run func(t *taskfile.Task)) *SourcesCheckable_OnError_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*taskfile.Task)) + }) + return _c +} + +func (_c *SourcesCheckable_OnError_Call) Return(_a0 error) *SourcesCheckable_OnError_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SourcesCheckable_OnError_Call) RunAndReturn(run func(*taskfile.Task) error) *SourcesCheckable_OnError_Call { + _c.Call.Return(run) + return _c +} + +// Value provides a mock function with given fields: t +func (_m *SourcesCheckable) Value(t *taskfile.Task) (interface{}, error) { + ret := _m.Called(t) + + var r0 interface{} + var r1 error + if rf, ok := ret.Get(0).(func(*taskfile.Task) (interface{}, error)); ok { + return rf(t) + } + if rf, ok := ret.Get(0).(func(*taskfile.Task) interface{}); ok { + r0 = rf(t) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(interface{}) + } + } + + if rf, ok := ret.Get(1).(func(*taskfile.Task) error); ok { + r1 = rf(t) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SourcesCheckable_Value_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Value' +type SourcesCheckable_Value_Call struct { + *mock.Call +} + +// Value is a helper method to define mock.On call +// - t *taskfile.Task +func (_e *SourcesCheckable_Expecter) Value(t interface{}) *SourcesCheckable_Value_Call { + return &SourcesCheckable_Value_Call{Call: _e.mock.On("Value", t)} +} + +func (_c *SourcesCheckable_Value_Call) Run(run func(t *taskfile.Task)) *SourcesCheckable_Value_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*taskfile.Task)) + }) + return _c +} + +func (_c *SourcesCheckable_Value_Call) Return(_a0 interface{}, _a1 error) *SourcesCheckable_Value_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SourcesCheckable_Value_Call) RunAndReturn(run func(*taskfile.Task) (interface{}, error)) *SourcesCheckable_Value_Call { + _c.Call.Return(run) + return _c +} + +type mockConstructorTestingTNewSourcesCheckable interface { + mock.TestingT + Cleanup(func()) +} + +// NewSourcesCheckable creates a new instance of SourcesCheckable. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +func NewSourcesCheckable(t mockConstructorTestingTNewSourcesCheckable) *SourcesCheckable { + mock := &SourcesCheckable{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/internal/mocks/status_checkable.go b/internal/mocks/status_checkable.go new file mode 100644 index 00000000..f057718e --- /dev/null +++ b/internal/mocks/status_checkable.go @@ -0,0 +1,92 @@ +// Code generated by mockery v2.24.0. DO NOT EDIT. + +package mocks + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" + + taskfile "github.com/go-task/task/v3/taskfile" +) + +// StatusCheckable is an autogenerated mock type for the StatusCheckable type +type StatusCheckable struct { + mock.Mock +} + +type StatusCheckable_Expecter struct { + mock *mock.Mock +} + +func (_m *StatusCheckable) EXPECT() *StatusCheckable_Expecter { + return &StatusCheckable_Expecter{mock: &_m.Mock} +} + +// IsUpToDate provides a mock function with given fields: ctx, t +func (_m *StatusCheckable) IsUpToDate(ctx context.Context, t *taskfile.Task) (bool, error) { + ret := _m.Called(ctx, t) + + var r0 bool + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *taskfile.Task) (bool, error)); ok { + return rf(ctx, t) + } + if rf, ok := ret.Get(0).(func(context.Context, *taskfile.Task) bool); ok { + r0 = rf(ctx, t) + } else { + r0 = ret.Get(0).(bool) + } + + if rf, ok := ret.Get(1).(func(context.Context, *taskfile.Task) error); ok { + r1 = rf(ctx, t) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// StatusCheckable_IsUpToDate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsUpToDate' +type StatusCheckable_IsUpToDate_Call struct { + *mock.Call +} + +// IsUpToDate is a helper method to define mock.On call +// - ctx context.Context +// - t *taskfile.Task +func (_e *StatusCheckable_Expecter) IsUpToDate(ctx interface{}, t interface{}) *StatusCheckable_IsUpToDate_Call { + return &StatusCheckable_IsUpToDate_Call{Call: _e.mock.On("IsUpToDate", ctx, t)} +} + +func (_c *StatusCheckable_IsUpToDate_Call) Run(run func(ctx context.Context, t *taskfile.Task)) *StatusCheckable_IsUpToDate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*taskfile.Task)) + }) + return _c +} + +func (_c *StatusCheckable_IsUpToDate_Call) Return(_a0 bool, _a1 error) *StatusCheckable_IsUpToDate_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *StatusCheckable_IsUpToDate_Call) RunAndReturn(run func(context.Context, *taskfile.Task) (bool, error)) *StatusCheckable_IsUpToDate_Call { + _c.Call.Return(run) + return _c +} + +type mockConstructorTestingTNewStatusCheckable interface { + mock.TestingT + Cleanup(func()) +} + +// NewStatusCheckable creates a new instance of StatusCheckable. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +func NewStatusCheckable(t mockConstructorTestingTNewStatusCheckable) *StatusCheckable { + mock := &StatusCheckable{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +}