go-transaction-manager

1
// Code generated by MockGen. DO NOT EDIT.
2
// Source: transaction.go
3

4
// Package mock is a generated GoMock package.
5
package mock
6

7
import (
8
	"context"
9
	"reflect"
10

11
	"github.com/golang/mock/gomock"
12

13
	"github.com/avito-tech/go-transaction-manager/trm/v2"
14
)
15

16
// MockNestedTrFactory is a mock of NestedTrFactory interface.
17
type MockNestedTrFactory struct {
18
	ctrl     *gomock.Controller
19
	recorder *MockNestedTrFactoryMockRecorder
20
}
21

22
// MockNestedTrFactoryMockRecorder is the mock recorder for MockNestedTrFactory.
23
type MockNestedTrFactoryMockRecorder struct {
24
	mock *MockNestedTrFactory
25
}
26

27
// NewMockNestedTrFactory creates a new mock instance.
28
func NewMockNestedTrFactory(ctrl *gomock.Controller) *MockNestedTrFactory {
29
	mock := &MockNestedTrFactory{ctrl: ctrl}
30
	mock.recorder = &MockNestedTrFactoryMockRecorder{mock}
31
	return mock
32
}
33

34
// EXPECT returns an object that allows the caller to indicate expected use.
35
func (m *MockNestedTrFactory) EXPECT() *MockNestedTrFactoryMockRecorder {
36
	return m.recorder
37
}
38

39
// Begin mocks base method.
40
func (m *MockNestedTrFactory) Begin(ctx context.Context, s trm.Settings) (context.Context, trm.Transaction, error) {
41
	m.ctrl.T.Helper()
42
	ret := m.ctrl.Call(m, "Begin", ctx, s)
43
	ret0, _ := ret[0].(context.Context)
44
	ret1, _ := ret[1].(trm.Transaction)
45
	ret2, _ := ret[2].(error)
46
	return ret0, ret1, ret2
47
}
48

49
// Begin indicates an expected call of Begin.
50
func (mr *MockNestedTrFactoryMockRecorder) Begin(ctx, s interface{}) *gomock.Call {
51
	mr.mock.ctrl.T.Helper()
52
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Begin", reflect.TypeOf((*MockNestedTrFactory)(nil).Begin), ctx, s)
53
}
54

55
// MockTransaction is a mock of Transaction interface.
56
type MockTransaction struct {
57
	ctrl     *gomock.Controller
58
	recorder *MockTransactionMockRecorder
59
}
60

61
// MockTransactionMockRecorder is the mock recorder for MockTransaction.
62
type MockTransactionMockRecorder struct {
63
	mock *MockTransaction
64
}
65

66
// NewMockTransaction creates a new mock instance.
67
func NewMockTransaction(ctrl *gomock.Controller) *MockTransaction {
68
	mock := &MockTransaction{ctrl: ctrl}
69
	mock.recorder = &MockTransactionMockRecorder{mock}
70
	return mock
71
}
72

73
// EXPECT returns an object that allows the caller to indicate expected use.
74
func (m *MockTransaction) EXPECT() *MockTransactionMockRecorder {
75
	return m.recorder
76
}
77

78
// Closed mocks base method.
79
func (m *MockTransaction) Closed() <-chan struct{} {
80
	m.ctrl.T.Helper()
81
	ret := m.ctrl.Call(m, "Closed")
82
	ret0, _ := ret[0].(<-chan struct{})
83
	return ret0
84
}
85

86
// Closed indicates an expected call of Closed.
87
func (mr *MockTransactionMockRecorder) Closed() *gomock.Call {
88
	mr.mock.ctrl.T.Helper()
89
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Closed", reflect.TypeOf((*MockTransaction)(nil).Closed))
90
}
91

92
// Commit mocks base method.
93
func (m *MockTransaction) Commit(arg0 context.Context) error {
94
	m.ctrl.T.Helper()
95
	ret := m.ctrl.Call(m, "Commit", arg0)
96
	ret0, _ := ret[0].(error)
97
	return ret0
98
}
99

100
// Commit indicates an expected call of Commit.
101
func (mr *MockTransactionMockRecorder) Commit(arg0 interface{}) *gomock.Call {
102
	mr.mock.ctrl.T.Helper()
103
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Commit", reflect.TypeOf((*MockTransaction)(nil).Commit), arg0)
104
}
105

106
// IsActive mocks base method.
107
func (m *MockTransaction) IsActive() bool {
108
	m.ctrl.T.Helper()
109
	ret := m.ctrl.Call(m, "IsActive")
110
	ret0, _ := ret[0].(bool)
111
	return ret0
112
}
113

114
// IsActive indicates an expected call of IsActive.
115
func (mr *MockTransactionMockRecorder) IsActive() *gomock.Call {
116
	mr.mock.ctrl.T.Helper()
117
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsActive", reflect.TypeOf((*MockTransaction)(nil).IsActive))
118
}
119

120
// Rollback mocks base method.
121
func (m *MockTransaction) Rollback(arg0 context.Context) error {
122
	m.ctrl.T.Helper()
123
	ret := m.ctrl.Call(m, "Rollback", arg0)
124
	ret0, _ := ret[0].(error)
125
	return ret0
126
}
127

128
// Rollback indicates an expected call of Rollback.
129
func (mr *MockTransactionMockRecorder) Rollback(arg0 interface{}) *gomock.Call {
130
	mr.mock.ctrl.T.Helper()
131
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rollback", reflect.TypeOf((*MockTransaction)(nil).Rollback), arg0)
132
}
133

134
// Transaction mocks base method.
135
func (m *MockTransaction) Transaction() interface{} {
136
	m.ctrl.T.Helper()
137
	ret := m.ctrl.Call(m, "Transaction")
138
	ret0, _ := ret[0].(interface{})
139
	return ret0
140
}
141

142
// Transaction indicates an expected call of Transaction.
143
func (mr *MockTransactionMockRecorder) Transaction() *gomock.Call {
144
	mr.mock.ctrl.T.Helper()
145
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Transaction", reflect.TypeOf((*MockTransaction)(nil).Transaction))
146
}
147

148
// MocktransactionWithSP is a mock of transactionWithSP interface.
149
type MocktransactionWithSP struct {
150
	ctrl     *gomock.Controller
151
	recorder *MocktransactionWithSPMockRecorder
152
}
153

154
// MocktransactionWithSPMockRecorder is the mock recorder for MocktransactionWithSP.
155
type MocktransactionWithSPMockRecorder struct {
156
	mock *MocktransactionWithSP
157
}
158

159
// NewMocktransactionWithSP creates a new mock instance.
160
func NewMocktransactionWithSP(ctrl *gomock.Controller) *MocktransactionWithSP {
161
	mock := &MocktransactionWithSP{ctrl: ctrl}
162
	mock.recorder = &MocktransactionWithSPMockRecorder{mock}
163
	return mock
164
}
165

166
// EXPECT returns an object that allows the caller to indicate expected use.
167
func (m *MocktransactionWithSP) EXPECT() *MocktransactionWithSPMockRecorder {
168
	return m.recorder
169
}
170

171
// Begin mocks base method.
172
func (m *MocktransactionWithSP) Begin(ctx context.Context, s trm.Settings) (context.Context, trm.Transaction, error) {
173
	m.ctrl.T.Helper()
174
	ret := m.ctrl.Call(m, "Begin", ctx, s)
175
	ret0, _ := ret[0].(context.Context)
176
	ret1, _ := ret[1].(trm.Transaction)
177
	ret2, _ := ret[2].(error)
178
	return ret0, ret1, ret2
179
}
180

181
// Begin indicates an expected call of Begin.
182
func (mr *MocktransactionWithSPMockRecorder) Begin(ctx, s interface{}) *gomock.Call {
183
	mr.mock.ctrl.T.Helper()
184
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Begin", reflect.TypeOf((*MocktransactionWithSP)(nil).Begin), ctx, s)
185
}
186

187
// Closed mocks base method.
188
func (m *MocktransactionWithSP) Closed() <-chan struct{} {
189
	m.ctrl.T.Helper()
190
	ret := m.ctrl.Call(m, "Closed")
191
	ret0, _ := ret[0].(<-chan struct{})
192
	return ret0
193
}
194

195
// Closed indicates an expected call of Closed.
196
func (mr *MocktransactionWithSPMockRecorder) Closed() *gomock.Call {
197
	mr.mock.ctrl.T.Helper()
198
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Closed", reflect.TypeOf((*MocktransactionWithSP)(nil).Closed))
199
}
200

201
// Commit mocks base method.
202
func (m *MocktransactionWithSP) Commit(arg0 context.Context) error {
203
	m.ctrl.T.Helper()
204
	ret := m.ctrl.Call(m, "Commit", arg0)
205
	ret0, _ := ret[0].(error)
206
	return ret0
207
}
208

209
// Commit indicates an expected call of Commit.
210
func (mr *MocktransactionWithSPMockRecorder) Commit(arg0 interface{}) *gomock.Call {
211
	mr.mock.ctrl.T.Helper()
212
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Commit", reflect.TypeOf((*MocktransactionWithSP)(nil).Commit), arg0)
213
}
214

215
// IsActive mocks base method.
216
func (m *MocktransactionWithSP) IsActive() bool {
217
	m.ctrl.T.Helper()
218
	ret := m.ctrl.Call(m, "IsActive")
219
	ret0, _ := ret[0].(bool)
220
	return ret0
221
}
222

223
// IsActive indicates an expected call of IsActive.
224
func (mr *MocktransactionWithSPMockRecorder) IsActive() *gomock.Call {
225
	mr.mock.ctrl.T.Helper()
226
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsActive", reflect.TypeOf((*MocktransactionWithSP)(nil).IsActive))
227
}
228

229
// Rollback mocks base method.
230
func (m *MocktransactionWithSP) Rollback(arg0 context.Context) error {
231
	m.ctrl.T.Helper()
232
	ret := m.ctrl.Call(m, "Rollback", arg0)
233
	ret0, _ := ret[0].(error)
234
	return ret0
235
}
236

237
// Rollback indicates an expected call of Rollback.
238
func (mr *MocktransactionWithSPMockRecorder) Rollback(arg0 interface{}) *gomock.Call {
239
	mr.mock.ctrl.T.Helper()
240
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rollback", reflect.TypeOf((*MocktransactionWithSP)(nil).Rollback), arg0)
241
}
242

243
// Transaction mocks base method.
244
func (m *MocktransactionWithSP) Transaction() interface{} {
245
	m.ctrl.T.Helper()
246
	ret := m.ctrl.Call(m, "Transaction")
247
	ret0, _ := ret[0].(interface{})
248
	return ret0
249
}
250

251
// Transaction indicates an expected call of Transaction.
252
func (mr *MocktransactionWithSPMockRecorder) Transaction() *gomock.Call {
253
	mr.mock.ctrl.T.Helper()
254
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Transaction", reflect.TypeOf((*MocktransactionWithSP)(nil).Transaction))
255
}
256