From b9caf3ddd43ac2986f5991f47a1d83e17779088d Mon Sep 17 00:00:00 2001 From: Dimitrij Drus Date: Tue, 20 Oct 2026 20:25:38 +0200 Subject: [PATCH] chore: Mockery updated to the most recent version --- .mockery.yaml | 15 ++++++- mock_key_resolver_test.go | 84 +++++++++++++++++++++++--------------- mock_nonce_checker_test.go | 75 ++++++++++++++++++++++------------ mock_nonce_getter_test.go | 79 ++++++++++++++++++++--------------- nonce.go | 4 -- verifier.go | 2 - 6 files changed, 160 insertions(+), 99 deletions(-) diff --git a/.mockery.yaml b/.mockery.yaml index 1b933da..6bc26c1 100644 --- a/.mockery.yaml +++ b/.mockery.yaml @@ -1,2 +1,13 @@ -case: underscore -with-expecter: true \ No newline at end of file +template: testify +filename: "mock_{{ snakecase .InterfaceName | lower }}_test.go" +structname: "{{ firstUpper .InterfaceName }}Mock" +dir: "{{ .InterfaceDir }}" +pkgname: "{{ .SrcPackageName }}" +template-data: + unroll-variadic: true +packages: + github.com/dadrus/httpsig: + interfaces: + NonceGetter: {} + NonceChecker: {} + KeyResolver: {} diff --git a/mock_key_resolver_test.go b/mock_key_resolver_test.go index 86517eb..70503d3 100644 --- a/mock_key_resolver_test.go +++ b/mock_key_resolver_test.go @@ -1,13 +1,38 @@ -// Code generated by mockery v2.42.1. DO NOT EDIT. +// Code generated by mockery; DO NOT EDIT. +// github.com/vektra/mockery +// template: testify package httpsig import ( - context "context" + "context" mock "github.com/stretchr/testify/mock" ) +// NewKeyResolverMock creates a new instance of KeyResolverMock. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewKeyResolverMock(t interface { + mock.TestingT + Cleanup(func()) +}) *KeyResolverMock { + if helper, ok := t.(interface{ Helper() }); ok { + helper.Helper() + } + + mock := &KeyResolverMock{} + mock.Mock.Test(t) + + t.Cleanup(func() { + if helper, ok := t.(interface{ Helper() }); ok { + helper.Helper() + } + mock.AssertExpectations(t) + }) + + return mock +} + // KeyResolverMock is an autogenerated mock type for the KeyResolver type type KeyResolverMock struct { mock.Mock @@ -21,9 +46,9 @@ func (_m *KeyResolverMock) EXPECT() *KeyResolverMock_Expecter { return &KeyResolverMock_Expecter{mock: &_m.Mock} } -// ResolveKey provides a mock function with given fields: ctx, keyID -func (_m *KeyResolverMock) ResolveKey(ctx context.Context, keyID string) (Key, error) { - ret := _m.Called(ctx, keyID) +// ResolveKey provides a mock function for the type KeyResolverMock +func (_mock *KeyResolverMock) ResolveKey(ctx context.Context, keyID string) (Key, error) { + ret := _mock.Called(ctx, keyID) if len(ret) == 0 { panic("no return value specified for ResolveKey") @@ -31,21 +56,19 @@ func (_m *KeyResolverMock) ResolveKey(ctx context.Context, keyID string) (Key, e var r0 Key var r1 error - if rf, ok := ret.Get(0).(func(context.Context, string) (Key, error)); ok { - return rf(ctx, keyID) + if returnFunc, ok := ret.Get(0).(func(context.Context, string) (Key, error)); ok { + return returnFunc(ctx, keyID) } - if rf, ok := ret.Get(0).(func(context.Context, string) Key); ok { - r0 = rf(ctx, keyID) + if returnFunc, ok := ret.Get(0).(func(context.Context, string) Key); ok { + r0 = returnFunc(ctx, keyID) } else { r0 = ret.Get(0).(Key) } - - if rf, ok := ret.Get(1).(func(context.Context, string) error); ok { - r1 = rf(ctx, keyID) + if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok { + r1 = returnFunc(ctx, keyID) } else { r1 = ret.Error(1) } - return r0, r1 } @@ -57,37 +80,34 @@ type KeyResolverMock_ResolveKey_Call struct { // ResolveKey is a helper method to define mock.On call // - ctx context.Context // - keyID string -func (_e *KeyResolverMock_Expecter) ResolveKey(ctx interface{}, keyID interface{}) *KeyResolverMock_ResolveKey_Call { +func (_e *KeyResolverMock_Expecter) ResolveKey(ctx any, keyID any) *KeyResolverMock_ResolveKey_Call { return &KeyResolverMock_ResolveKey_Call{Call: _e.mock.On("ResolveKey", ctx, keyID)} } func (_c *KeyResolverMock_ResolveKey_Call) Run(run func(ctx context.Context, keyID string)) *KeyResolverMock_ResolveKey_Call { _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string)) + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 string + if args[1] != nil { + arg1 = args[1].(string) + } + run( + arg0, + arg1, + ) }) return _c } -func (_c *KeyResolverMock_ResolveKey_Call) Return(_a0 Key, _a1 error) *KeyResolverMock_ResolveKey_Call { - _c.Call.Return(_a0, _a1) +func (_c *KeyResolverMock_ResolveKey_Call) Return(key Key, err error) *KeyResolverMock_ResolveKey_Call { + _c.Call.Return(key, err) return _c } -func (_c *KeyResolverMock_ResolveKey_Call) RunAndReturn(run func(context.Context, string) (Key, error)) *KeyResolverMock_ResolveKey_Call { +func (_c *KeyResolverMock_ResolveKey_Call) RunAndReturn(run func(ctx context.Context, keyID string) (Key, error)) *KeyResolverMock_ResolveKey_Call { _c.Call.Return(run) return _c } - -// NewKeyResolverMock creates a new instance of KeyResolverMock. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewKeyResolverMock(t interface { - mock.TestingT - Cleanup(func()) -}) *KeyResolverMock { - mock := &KeyResolverMock{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} diff --git a/mock_nonce_checker_test.go b/mock_nonce_checker_test.go index 8ef301e..73e1a44 100644 --- a/mock_nonce_checker_test.go +++ b/mock_nonce_checker_test.go @@ -1,13 +1,38 @@ -// Code generated by mockery v2.53.6. DO NOT EDIT. +// Code generated by mockery; DO NOT EDIT. +// github.com/vektra/mockery +// template: testify package httpsig import ( - context "context" + "context" mock "github.com/stretchr/testify/mock" ) +// NewNonceCheckerMock creates a new instance of NonceCheckerMock. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewNonceCheckerMock(t interface { + mock.TestingT + Cleanup(func()) +}) *NonceCheckerMock { + if helper, ok := t.(interface{ Helper() }); ok { + helper.Helper() + } + + mock := &NonceCheckerMock{} + mock.Mock.Test(t) + + t.Cleanup(func() { + if helper, ok := t.(interface{ Helper() }); ok { + helper.Helper() + } + mock.AssertExpectations(t) + }) + + return mock +} + // NonceCheckerMock is an autogenerated mock type for the NonceChecker type type NonceCheckerMock struct { mock.Mock @@ -21,21 +46,20 @@ func (_m *NonceCheckerMock) EXPECT() *NonceCheckerMock_Expecter { return &NonceCheckerMock_Expecter{mock: &_m.Mock} } -// CheckNonce provides a mock function with given fields: ctx, nonce -func (_m *NonceCheckerMock) CheckNonce(ctx context.Context, nonce NonceValue) error { - ret := _m.Called(ctx, nonce) +// CheckNonce provides a mock function for the type NonceCheckerMock +func (_mock *NonceCheckerMock) CheckNonce(ctx context.Context, nonce NonceValue) error { + ret := _mock.Called(ctx, nonce) if len(ret) == 0 { panic("no return value specified for CheckNonce") } var r0 error - if rf, ok := ret.Get(0).(func(context.Context, NonceValue) error); ok { - r0 = rf(ctx, nonce) + if returnFunc, ok := ret.Get(0).(func(context.Context, NonceValue) error); ok { + r0 = returnFunc(ctx, nonce) } else { r0 = ret.Error(0) } - return r0 } @@ -47,37 +71,34 @@ type NonceCheckerMock_CheckNonce_Call struct { // CheckNonce is a helper method to define mock.On call // - ctx context.Context // - nonce NonceValue -func (_e *NonceCheckerMock_Expecter) CheckNonce(ctx interface{}, nonce interface{}) *NonceCheckerMock_CheckNonce_Call { +func (_e *NonceCheckerMock_Expecter) CheckNonce(ctx any, nonce any) *NonceCheckerMock_CheckNonce_Call { return &NonceCheckerMock_CheckNonce_Call{Call: _e.mock.On("CheckNonce", ctx, nonce)} } func (_c *NonceCheckerMock_CheckNonce_Call) Run(run func(ctx context.Context, nonce NonceValue)) *NonceCheckerMock_CheckNonce_Call { _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(NonceValue)) + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 NonceValue + if args[1] != nil { + arg1 = args[1].(NonceValue) + } + run( + arg0, + arg1, + ) }) return _c } -func (_c *NonceCheckerMock_CheckNonce_Call) Return(_a0 error) *NonceCheckerMock_CheckNonce_Call { - _c.Call.Return(_a0) +func (_c *NonceCheckerMock_CheckNonce_Call) Return(err error) *NonceCheckerMock_CheckNonce_Call { + _c.Call.Return(err) return _c } -func (_c *NonceCheckerMock_CheckNonce_Call) RunAndReturn(run func(context.Context, NonceValue) error) *NonceCheckerMock_CheckNonce_Call { +func (_c *NonceCheckerMock_CheckNonce_Call) RunAndReturn(run func(ctx context.Context, nonce NonceValue) error) *NonceCheckerMock_CheckNonce_Call { _c.Call.Return(run) return _c } - -// NewNonceCheckerMock creates a new instance of NonceCheckerMock. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewNonceCheckerMock(t interface { - mock.TestingT - Cleanup(func()) -}) *NonceCheckerMock { - mock := &NonceCheckerMock{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} diff --git a/mock_nonce_getter_test.go b/mock_nonce_getter_test.go index fdf8577..5285e7e 100644 --- a/mock_nonce_getter_test.go +++ b/mock_nonce_getter_test.go @@ -1,13 +1,38 @@ -// Code generated by mockery v2.42.1. DO NOT EDIT. +// Code generated by mockery; DO NOT EDIT. +// github.com/vektra/mockery +// template: testify package httpsig import ( - context "context" + "context" mock "github.com/stretchr/testify/mock" ) +// NewNonceGetterMock creates a new instance of NonceGetterMock. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewNonceGetterMock(t interface { + mock.TestingT + Cleanup(func()) +}) *NonceGetterMock { + if helper, ok := t.(interface{ Helper() }); ok { + helper.Helper() + } + + mock := &NonceGetterMock{} + mock.Mock.Test(t) + + t.Cleanup(func() { + if helper, ok := t.(interface{ Helper() }); ok { + helper.Helper() + } + mock.AssertExpectations(t) + }) + + return mock +} + // NonceGetterMock is an autogenerated mock type for the NonceGetter type type NonceGetterMock struct { mock.Mock @@ -21,9 +46,9 @@ func (_m *NonceGetterMock) EXPECT() *NonceGetterMock_Expecter { return &NonceGetterMock_Expecter{mock: &_m.Mock} } -// GetNonce provides a mock function with given fields: ctx -func (_m *NonceGetterMock) GetNonce(ctx context.Context) (string, error) { - ret := _m.Called(ctx) +// GetNonce provides a mock function for the type NonceGetterMock +func (_mock *NonceGetterMock) GetNonce(ctx context.Context) (string, error) { + ret := _mock.Called(ctx) if len(ret) == 0 { panic("no return value specified for GetNonce") @@ -31,21 +56,19 @@ func (_m *NonceGetterMock) GetNonce(ctx context.Context) (string, error) { var r0 string var r1 error - if rf, ok := ret.Get(0).(func(context.Context) (string, error)); ok { - return rf(ctx) + if returnFunc, ok := ret.Get(0).(func(context.Context) (string, error)); ok { + return returnFunc(ctx) } - if rf, ok := ret.Get(0).(func(context.Context) string); ok { - r0 = rf(ctx) + if returnFunc, ok := ret.Get(0).(func(context.Context) string); ok { + r0 = returnFunc(ctx) } else { r0 = ret.Get(0).(string) } - - if rf, ok := ret.Get(1).(func(context.Context) error); ok { - r1 = rf(ctx) + if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = returnFunc(ctx) } else { r1 = ret.Error(1) } - return r0, r1 } @@ -56,37 +79,29 @@ type NonceGetterMock_GetNonce_Call struct { // GetNonce is a helper method to define mock.On call // - ctx context.Context -func (_e *NonceGetterMock_Expecter) GetNonce(ctx interface{}) *NonceGetterMock_GetNonce_Call { +func (_e *NonceGetterMock_Expecter) GetNonce(ctx any) *NonceGetterMock_GetNonce_Call { return &NonceGetterMock_GetNonce_Call{Call: _e.mock.On("GetNonce", ctx)} } func (_c *NonceGetterMock_GetNonce_Call) Run(run func(ctx context.Context)) *NonceGetterMock_GetNonce_Call { _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context)) + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + run( + arg0, + ) }) return _c } -func (_c *NonceGetterMock_GetNonce_Call) Return(_a0 string, _a1 error) *NonceGetterMock_GetNonce_Call { - _c.Call.Return(_a0, _a1) +func (_c *NonceGetterMock_GetNonce_Call) Return(s string, err error) *NonceGetterMock_GetNonce_Call { + _c.Call.Return(s, err) return _c } -func (_c *NonceGetterMock_GetNonce_Call) RunAndReturn(run func(context.Context) (string, error)) *NonceGetterMock_GetNonce_Call { +func (_c *NonceGetterMock_GetNonce_Call) RunAndReturn(run func(ctx context.Context) (string, error)) *NonceGetterMock_GetNonce_Call { _c.Call.Return(run) return _c } - -// NewNonceGetterMock creates a new instance of NonceGetterMock. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewNonceGetterMock(t interface { - mock.TestingT - Cleanup(func()) -}) *NonceGetterMock { - mock := &NonceGetterMock{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} diff --git a/nonce.go b/nonce.go index fb49f6f..060c008 100644 --- a/nonce.go +++ b/nonce.go @@ -6,8 +6,6 @@ import ( "encoding/base64" ) -//go:generate mockery --name NonceGetter --structname NonceGetterMock --inpackage --testonly - // NonceGetter represents a source of random nonces to go into resulting objects. type NonceGetter interface { GetNonce(ctx context.Context) (string, error) @@ -17,8 +15,6 @@ type NonceGetterFunc func(ctx context.Context) (string, error) func (ng NonceGetterFunc) GetNonce(ctx context.Context) (string, error) { return ng(ctx) } -//go:generate mockery --name NonceChecker --structname NonceCheckerMock --inpackage --testonly - // NonceChecker is responsible for the verification of the nonce received in a signature, // e.g. to prevent replay attacks, or to verify that the nonce is the expected one, like // if requested using the Accept-Signature header. diff --git a/verifier.go b/verifier.go index d7d6f70..b61dfcd 100644 --- a/verifier.go +++ b/verifier.go @@ -18,8 +18,6 @@ type Verifier interface { Verify(msg *Message) error } -//go:generate mockery --name KeyResolver --structname KeyResolverMock --inpackage --testonly - // KeyResolver is used to resolve a key id to a verifying key. type KeyResolver interface { ResolveKey(ctx context.Context, keyID string) (Key, error)