1// Code generated by mockery; DO NOT EDIT.
2// github.com/vektra/mockery
3// template: testify
4
5package mocks
6
7import (
8 mock "github.com/stretchr/testify/mock"
9)
10
11// NewSecretSealer creates a new instance of SecretSealer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
12// The first argument is typically a *testing.T value.
13func NewSecretSealer(t interface {
14 mock.TestingT
15 Cleanup(func())
16}) *SecretSealer {
17 if helper, ok := t.(interface{ Helper() }); ok {
18 helper.Helper()
19 }
20
21 mock := &SecretSealer{}
22 mock.Mock.Test(t)
23
24 t.Cleanup(func() {
25 if helper, ok := t.(interface{ Helper() }); ok {
26 helper.Helper()
27 }
28 mock.AssertExpectations(t)
29 })
30
31 return mock
32}
33
34// SecretSealer is an autogenerated mock type for the SecretSealer type
35type SecretSealer struct {
36 mock.Mock
37}
38
39type SecretSealer_Expecter struct {
40 mock *mock.Mock
41}
42
43func (_m *SecretSealer) EXPECT() *SecretSealer_Expecter {
44 return &SecretSealer_Expecter{mock: &_m.Mock}
45}
46
47// KeyCheck provides a mock function for the type SecretSealer
48func (_mock *SecretSealer) KeyCheck() []byte {
49 ret := _mock.Called()
50
51 if len(ret) == 0 {
52 panic("no return value specified for KeyCheck")
53 }
54
55 var r0 []byte
56 if returnFunc, ok := ret.Get(0).(func() []byte); ok {
57 r0 = returnFunc()
58 } else {
59 if ret.Get(0) != nil {
60 r0 = ret.Get(0).([]byte)
61 }
62 }
63 return r0
64}
65
66// SecretSealer_KeyCheck_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'KeyCheck'
67type SecretSealer_KeyCheck_Call struct {
68 *mock.Call
69}
70
71// KeyCheck is a helper method to define mock.On call
72func (_e *SecretSealer_Expecter) KeyCheck() *SecretSealer_KeyCheck_Call {
73 return &SecretSealer_KeyCheck_Call{Call: _e.mock.On("KeyCheck")}
74}
75
76func (_c *SecretSealer_KeyCheck_Call) Run(run func()) *SecretSealer_KeyCheck_Call {
77 _c.Call.Run(func(args mock.Arguments) {
78 run()
79 })
80 return _c
81}
82
83func (_c *SecretSealer_KeyCheck_Call) Return(bytes []byte) *SecretSealer_KeyCheck_Call {
84 _c.Call.Return(bytes)
85 return _c
86}
87
88func (_c *SecretSealer_KeyCheck_Call) RunAndReturn(run func() []byte) *SecretSealer_KeyCheck_Call {
89 _c.Call.Return(run)
90 return _c
91}
92
93// Open provides a mock function for the type SecretSealer
94func (_mock *SecretSealer) Open(sealed []byte, aad []byte) ([]byte, error) {
95 ret := _mock.Called(sealed, aad)
96
97 if len(ret) == 0 {
98 panic("no return value specified for Open")
99 }
100
101 var r0 []byte
102 var r1 error
103 if returnFunc, ok := ret.Get(0).(func([]byte, []byte) ([]byte, error)); ok {
104 return returnFunc(sealed, aad)
105 }
106 if returnFunc, ok := ret.Get(0).(func([]byte, []byte) []byte); ok {
107 r0 = returnFunc(sealed, aad)
108 } else {
109 if ret.Get(0) != nil {
110 r0 = ret.Get(0).([]byte)
111 }
112 }
113 if returnFunc, ok := ret.Get(1).(func([]byte, []byte) error); ok {
114 r1 = returnFunc(sealed, aad)
115 } else {
116 r1 = ret.Error(1)
117 }
118 return r0, r1
119}
120
121// SecretSealer_Open_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Open'
122type SecretSealer_Open_Call struct {
123 *mock.Call
124}
125
126// Open is a helper method to define mock.On call
127// - sealed []byte
128// - aad []byte
129func (_e *SecretSealer_Expecter) Open(sealed any, aad any) *SecretSealer_Open_Call {
130 return &SecretSealer_Open_Call{Call: _e.mock.On("Open", sealed, aad)}
131}
132
133func (_c *SecretSealer_Open_Call) Run(run func(sealed []byte, aad []byte)) *SecretSealer_Open_Call {
134 _c.Call.Run(func(args mock.Arguments) {
135 var arg0 []byte
136 if args[0] != nil {
137 arg0 = args[0].([]byte)
138 }
139 var arg1 []byte
140 if args[1] != nil {
141 arg1 = args[1].([]byte)
142 }
143 run(
144 arg0,
145 arg1,
146 )
147 })
148 return _c
149}
150
151func (_c *SecretSealer_Open_Call) Return(bytes []byte, err error) *SecretSealer_Open_Call {
152 _c.Call.Return(bytes, err)
153 return _c
154}
155
156func (_c *SecretSealer_Open_Call) RunAndReturn(run func(sealed []byte, aad []byte) ([]byte, error)) *SecretSealer_Open_Call {
157 _c.Call.Return(run)
158 return _c
159}
160
161// Seal provides a mock function for the type SecretSealer
162func (_mock *SecretSealer) Seal(plaintext []byte, aad []byte) []byte {
163 ret := _mock.Called(plaintext, aad)
164
165 if len(ret) == 0 {
166 panic("no return value specified for Seal")
167 }
168
169 var r0 []byte
170 if returnFunc, ok := ret.Get(0).(func([]byte, []byte) []byte); ok {
171 r0 = returnFunc(plaintext, aad)
172 } else {
173 if ret.Get(0) != nil {
174 r0 = ret.Get(0).([]byte)
175 }
176 }
177 return r0
178}
179
180// SecretSealer_Seal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Seal'
181type SecretSealer_Seal_Call struct {
182 *mock.Call
183}
184
185// Seal is a helper method to define mock.On call
186// - plaintext []byte
187// - aad []byte
188func (_e *SecretSealer_Expecter) Seal(plaintext any, aad any) *SecretSealer_Seal_Call {
189 return &SecretSealer_Seal_Call{Call: _e.mock.On("Seal", plaintext, aad)}
190}
191
192func (_c *SecretSealer_Seal_Call) Run(run func(plaintext []byte, aad []byte)) *SecretSealer_Seal_Call {
193 _c.Call.Run(func(args mock.Arguments) {
194 var arg0 []byte
195 if args[0] != nil {
196 arg0 = args[0].([]byte)
197 }
198 var arg1 []byte
199 if args[1] != nil {
200 arg1 = args[1].([]byte)
201 }
202 run(
203 arg0,
204 arg1,
205 )
206 })
207 return _c
208}
209
210func (_c *SecretSealer_Seal_Call) Return(bytes []byte) *SecretSealer_Seal_Call {
211 _c.Call.Return(bytes)
212 return _c
213}
214
215func (_c *SecretSealer_Seal_Call) RunAndReturn(run func(plaintext []byte, aad []byte) []byte) *SecretSealer_Seal_Call {
216 _c.Call.Return(run)
217 return _c
218}