go.temporal.io/server@v1.23.0/common/persistence/mock/store_mock.go (about) 1 // The MIT License 2 // 3 // Copyright (c) 2020 Temporal Technologies Inc. All rights reserved. 4 // 5 // Copyright (c) 2020 Uber Technologies, Inc. 6 // 7 // Permission is hereby granted, free of charge, to any person obtaining a copy 8 // of this software and associated documentation files (the "Software"), to deal 9 // in the Software without restriction, including without limitation the rights 10 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 11 // copies of the Software, and to permit persons to whom the Software is 12 // furnished to do so, subject to the following conditions: 13 // 14 // The above copyright notice and this permission notice shall be included in 15 // all copies or substantial portions of the Software. 16 // 17 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 18 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 19 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 20 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 21 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 22 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 23 // THE SOFTWARE. 24 25 // Code generated by MockGen. DO NOT EDIT. 26 // Source: persistence_interface.go 27 28 // Package mock is a generated GoMock package. 29 package mock 30 31 import ( 32 context "context" 33 reflect "reflect" 34 35 gomock "github.com/golang/mock/gomock" 36 common "go.temporal.io/api/common/v1" 37 persistence "go.temporal.io/server/common/persistence" 38 ) 39 40 // MockShardStore is a mock of ShardStore interface. 41 type MockShardStore struct { 42 ctrl *gomock.Controller 43 recorder *MockShardStoreMockRecorder 44 } 45 46 // MockShardStoreMockRecorder is the mock recorder for MockShardStore. 47 type MockShardStoreMockRecorder struct { 48 mock *MockShardStore 49 } 50 51 // NewMockShardStore creates a new mock instance. 52 func NewMockShardStore(ctrl *gomock.Controller) *MockShardStore { 53 mock := &MockShardStore{ctrl: ctrl} 54 mock.recorder = &MockShardStoreMockRecorder{mock} 55 return mock 56 } 57 58 // EXPECT returns an object that allows the caller to indicate expected use. 59 func (m *MockShardStore) EXPECT() *MockShardStoreMockRecorder { 60 return m.recorder 61 } 62 63 // AssertShardOwnership mocks base method. 64 func (m *MockShardStore) AssertShardOwnership(ctx context.Context, request *persistence.AssertShardOwnershipRequest) error { 65 m.ctrl.T.Helper() 66 ret := m.ctrl.Call(m, "AssertShardOwnership", ctx, request) 67 ret0, _ := ret[0].(error) 68 return ret0 69 } 70 71 // AssertShardOwnership indicates an expected call of AssertShardOwnership. 72 func (mr *MockShardStoreMockRecorder) AssertShardOwnership(ctx, request interface{}) *gomock.Call { 73 mr.mock.ctrl.T.Helper() 74 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssertShardOwnership", reflect.TypeOf((*MockShardStore)(nil).AssertShardOwnership), ctx, request) 75 } 76 77 // Close mocks base method. 78 func (m *MockShardStore) Close() { 79 m.ctrl.T.Helper() 80 m.ctrl.Call(m, "Close") 81 } 82 83 // Close indicates an expected call of Close. 84 func (mr *MockShardStoreMockRecorder) Close() *gomock.Call { 85 mr.mock.ctrl.T.Helper() 86 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockShardStore)(nil).Close)) 87 } 88 89 // GetClusterName mocks base method. 90 func (m *MockShardStore) GetClusterName() string { 91 m.ctrl.T.Helper() 92 ret := m.ctrl.Call(m, "GetClusterName") 93 ret0, _ := ret[0].(string) 94 return ret0 95 } 96 97 // GetClusterName indicates an expected call of GetClusterName. 98 func (mr *MockShardStoreMockRecorder) GetClusterName() *gomock.Call { 99 mr.mock.ctrl.T.Helper() 100 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterName", reflect.TypeOf((*MockShardStore)(nil).GetClusterName)) 101 } 102 103 // GetName mocks base method. 104 func (m *MockShardStore) GetName() string { 105 m.ctrl.T.Helper() 106 ret := m.ctrl.Call(m, "GetName") 107 ret0, _ := ret[0].(string) 108 return ret0 109 } 110 111 // GetName indicates an expected call of GetName. 112 func (mr *MockShardStoreMockRecorder) GetName() *gomock.Call { 113 mr.mock.ctrl.T.Helper() 114 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetName", reflect.TypeOf((*MockShardStore)(nil).GetName)) 115 } 116 117 // GetOrCreateShard mocks base method. 118 func (m *MockShardStore) GetOrCreateShard(ctx context.Context, request *persistence.InternalGetOrCreateShardRequest) (*persistence.InternalGetOrCreateShardResponse, error) { 119 m.ctrl.T.Helper() 120 ret := m.ctrl.Call(m, "GetOrCreateShard", ctx, request) 121 ret0, _ := ret[0].(*persistence.InternalGetOrCreateShardResponse) 122 ret1, _ := ret[1].(error) 123 return ret0, ret1 124 } 125 126 // GetOrCreateShard indicates an expected call of GetOrCreateShard. 127 func (mr *MockShardStoreMockRecorder) GetOrCreateShard(ctx, request interface{}) *gomock.Call { 128 mr.mock.ctrl.T.Helper() 129 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrCreateShard", reflect.TypeOf((*MockShardStore)(nil).GetOrCreateShard), ctx, request) 130 } 131 132 // UpdateShard mocks base method. 133 func (m *MockShardStore) UpdateShard(ctx context.Context, request *persistence.InternalUpdateShardRequest) error { 134 m.ctrl.T.Helper() 135 ret := m.ctrl.Call(m, "UpdateShard", ctx, request) 136 ret0, _ := ret[0].(error) 137 return ret0 138 } 139 140 // UpdateShard indicates an expected call of UpdateShard. 141 func (mr *MockShardStoreMockRecorder) UpdateShard(ctx, request interface{}) *gomock.Call { 142 mr.mock.ctrl.T.Helper() 143 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateShard", reflect.TypeOf((*MockShardStore)(nil).UpdateShard), ctx, request) 144 } 145 146 // MockTaskStore is a mock of TaskStore interface. 147 type MockTaskStore struct { 148 ctrl *gomock.Controller 149 recorder *MockTaskStoreMockRecorder 150 } 151 152 // MockTaskStoreMockRecorder is the mock recorder for MockTaskStore. 153 type MockTaskStoreMockRecorder struct { 154 mock *MockTaskStore 155 } 156 157 // NewMockTaskStore creates a new mock instance. 158 func NewMockTaskStore(ctrl *gomock.Controller) *MockTaskStore { 159 mock := &MockTaskStore{ctrl: ctrl} 160 mock.recorder = &MockTaskStoreMockRecorder{mock} 161 return mock 162 } 163 164 // EXPECT returns an object that allows the caller to indicate expected use. 165 func (m *MockTaskStore) EXPECT() *MockTaskStoreMockRecorder { 166 return m.recorder 167 } 168 169 // Close mocks base method. 170 func (m *MockTaskStore) Close() { 171 m.ctrl.T.Helper() 172 m.ctrl.Call(m, "Close") 173 } 174 175 // Close indicates an expected call of Close. 176 func (mr *MockTaskStoreMockRecorder) Close() *gomock.Call { 177 mr.mock.ctrl.T.Helper() 178 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockTaskStore)(nil).Close)) 179 } 180 181 // CompleteTask mocks base method. 182 func (m *MockTaskStore) CompleteTask(ctx context.Context, request *persistence.CompleteTaskRequest) error { 183 m.ctrl.T.Helper() 184 ret := m.ctrl.Call(m, "CompleteTask", ctx, request) 185 ret0, _ := ret[0].(error) 186 return ret0 187 } 188 189 // CompleteTask indicates an expected call of CompleteTask. 190 func (mr *MockTaskStoreMockRecorder) CompleteTask(ctx, request interface{}) *gomock.Call { 191 mr.mock.ctrl.T.Helper() 192 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteTask", reflect.TypeOf((*MockTaskStore)(nil).CompleteTask), ctx, request) 193 } 194 195 // CompleteTasksLessThan mocks base method. 196 func (m *MockTaskStore) CompleteTasksLessThan(ctx context.Context, request *persistence.CompleteTasksLessThanRequest) (int, error) { 197 m.ctrl.T.Helper() 198 ret := m.ctrl.Call(m, "CompleteTasksLessThan", ctx, request) 199 ret0, _ := ret[0].(int) 200 ret1, _ := ret[1].(error) 201 return ret0, ret1 202 } 203 204 // CompleteTasksLessThan indicates an expected call of CompleteTasksLessThan. 205 func (mr *MockTaskStoreMockRecorder) CompleteTasksLessThan(ctx, request interface{}) *gomock.Call { 206 mr.mock.ctrl.T.Helper() 207 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteTasksLessThan", reflect.TypeOf((*MockTaskStore)(nil).CompleteTasksLessThan), ctx, request) 208 } 209 210 // CountTaskQueuesByBuildId mocks base method. 211 func (m *MockTaskStore) CountTaskQueuesByBuildId(ctx context.Context, request *persistence.CountTaskQueuesByBuildIdRequest) (int, error) { 212 m.ctrl.T.Helper() 213 ret := m.ctrl.Call(m, "CountTaskQueuesByBuildId", ctx, request) 214 ret0, _ := ret[0].(int) 215 ret1, _ := ret[1].(error) 216 return ret0, ret1 217 } 218 219 // CountTaskQueuesByBuildId indicates an expected call of CountTaskQueuesByBuildId. 220 func (mr *MockTaskStoreMockRecorder) CountTaskQueuesByBuildId(ctx, request interface{}) *gomock.Call { 221 mr.mock.ctrl.T.Helper() 222 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CountTaskQueuesByBuildId", reflect.TypeOf((*MockTaskStore)(nil).CountTaskQueuesByBuildId), ctx, request) 223 } 224 225 // CreateTaskQueue mocks base method. 226 func (m *MockTaskStore) CreateTaskQueue(ctx context.Context, request *persistence.InternalCreateTaskQueueRequest) error { 227 m.ctrl.T.Helper() 228 ret := m.ctrl.Call(m, "CreateTaskQueue", ctx, request) 229 ret0, _ := ret[0].(error) 230 return ret0 231 } 232 233 // CreateTaskQueue indicates an expected call of CreateTaskQueue. 234 func (mr *MockTaskStoreMockRecorder) CreateTaskQueue(ctx, request interface{}) *gomock.Call { 235 mr.mock.ctrl.T.Helper() 236 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTaskQueue", reflect.TypeOf((*MockTaskStore)(nil).CreateTaskQueue), ctx, request) 237 } 238 239 // CreateTasks mocks base method. 240 func (m *MockTaskStore) CreateTasks(ctx context.Context, request *persistence.InternalCreateTasksRequest) (*persistence.CreateTasksResponse, error) { 241 m.ctrl.T.Helper() 242 ret := m.ctrl.Call(m, "CreateTasks", ctx, request) 243 ret0, _ := ret[0].(*persistence.CreateTasksResponse) 244 ret1, _ := ret[1].(error) 245 return ret0, ret1 246 } 247 248 // CreateTasks indicates an expected call of CreateTasks. 249 func (mr *MockTaskStoreMockRecorder) CreateTasks(ctx, request interface{}) *gomock.Call { 250 mr.mock.ctrl.T.Helper() 251 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTasks", reflect.TypeOf((*MockTaskStore)(nil).CreateTasks), ctx, request) 252 } 253 254 // DeleteTaskQueue mocks base method. 255 func (m *MockTaskStore) DeleteTaskQueue(ctx context.Context, request *persistence.DeleteTaskQueueRequest) error { 256 m.ctrl.T.Helper() 257 ret := m.ctrl.Call(m, "DeleteTaskQueue", ctx, request) 258 ret0, _ := ret[0].(error) 259 return ret0 260 } 261 262 // DeleteTaskQueue indicates an expected call of DeleteTaskQueue. 263 func (mr *MockTaskStoreMockRecorder) DeleteTaskQueue(ctx, request interface{}) *gomock.Call { 264 mr.mock.ctrl.T.Helper() 265 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTaskQueue", reflect.TypeOf((*MockTaskStore)(nil).DeleteTaskQueue), ctx, request) 266 } 267 268 // GetName mocks base method. 269 func (m *MockTaskStore) GetName() string { 270 m.ctrl.T.Helper() 271 ret := m.ctrl.Call(m, "GetName") 272 ret0, _ := ret[0].(string) 273 return ret0 274 } 275 276 // GetName indicates an expected call of GetName. 277 func (mr *MockTaskStoreMockRecorder) GetName() *gomock.Call { 278 mr.mock.ctrl.T.Helper() 279 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetName", reflect.TypeOf((*MockTaskStore)(nil).GetName)) 280 } 281 282 // GetTaskQueue mocks base method. 283 func (m *MockTaskStore) GetTaskQueue(ctx context.Context, request *persistence.InternalGetTaskQueueRequest) (*persistence.InternalGetTaskQueueResponse, error) { 284 m.ctrl.T.Helper() 285 ret := m.ctrl.Call(m, "GetTaskQueue", ctx, request) 286 ret0, _ := ret[0].(*persistence.InternalGetTaskQueueResponse) 287 ret1, _ := ret[1].(error) 288 return ret0, ret1 289 } 290 291 // GetTaskQueue indicates an expected call of GetTaskQueue. 292 func (mr *MockTaskStoreMockRecorder) GetTaskQueue(ctx, request interface{}) *gomock.Call { 293 mr.mock.ctrl.T.Helper() 294 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTaskQueue", reflect.TypeOf((*MockTaskStore)(nil).GetTaskQueue), ctx, request) 295 } 296 297 // GetTaskQueueUserData mocks base method. 298 func (m *MockTaskStore) GetTaskQueueUserData(ctx context.Context, request *persistence.GetTaskQueueUserDataRequest) (*persistence.InternalGetTaskQueueUserDataResponse, error) { 299 m.ctrl.T.Helper() 300 ret := m.ctrl.Call(m, "GetTaskQueueUserData", ctx, request) 301 ret0, _ := ret[0].(*persistence.InternalGetTaskQueueUserDataResponse) 302 ret1, _ := ret[1].(error) 303 return ret0, ret1 304 } 305 306 // GetTaskQueueUserData indicates an expected call of GetTaskQueueUserData. 307 func (mr *MockTaskStoreMockRecorder) GetTaskQueueUserData(ctx, request interface{}) *gomock.Call { 308 mr.mock.ctrl.T.Helper() 309 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTaskQueueUserData", reflect.TypeOf((*MockTaskStore)(nil).GetTaskQueueUserData), ctx, request) 310 } 311 312 // GetTaskQueuesByBuildId mocks base method. 313 func (m *MockTaskStore) GetTaskQueuesByBuildId(ctx context.Context, request *persistence.GetTaskQueuesByBuildIdRequest) ([]string, error) { 314 m.ctrl.T.Helper() 315 ret := m.ctrl.Call(m, "GetTaskQueuesByBuildId", ctx, request) 316 ret0, _ := ret[0].([]string) 317 ret1, _ := ret[1].(error) 318 return ret0, ret1 319 } 320 321 // GetTaskQueuesByBuildId indicates an expected call of GetTaskQueuesByBuildId. 322 func (mr *MockTaskStoreMockRecorder) GetTaskQueuesByBuildId(ctx, request interface{}) *gomock.Call { 323 mr.mock.ctrl.T.Helper() 324 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTaskQueuesByBuildId", reflect.TypeOf((*MockTaskStore)(nil).GetTaskQueuesByBuildId), ctx, request) 325 } 326 327 // GetTasks mocks base method. 328 func (m *MockTaskStore) GetTasks(ctx context.Context, request *persistence.GetTasksRequest) (*persistence.InternalGetTasksResponse, error) { 329 m.ctrl.T.Helper() 330 ret := m.ctrl.Call(m, "GetTasks", ctx, request) 331 ret0, _ := ret[0].(*persistence.InternalGetTasksResponse) 332 ret1, _ := ret[1].(error) 333 return ret0, ret1 334 } 335 336 // GetTasks indicates an expected call of GetTasks. 337 func (mr *MockTaskStoreMockRecorder) GetTasks(ctx, request interface{}) *gomock.Call { 338 mr.mock.ctrl.T.Helper() 339 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTasks", reflect.TypeOf((*MockTaskStore)(nil).GetTasks), ctx, request) 340 } 341 342 // ListTaskQueue mocks base method. 343 func (m *MockTaskStore) ListTaskQueue(ctx context.Context, request *persistence.ListTaskQueueRequest) (*persistence.InternalListTaskQueueResponse, error) { 344 m.ctrl.T.Helper() 345 ret := m.ctrl.Call(m, "ListTaskQueue", ctx, request) 346 ret0, _ := ret[0].(*persistence.InternalListTaskQueueResponse) 347 ret1, _ := ret[1].(error) 348 return ret0, ret1 349 } 350 351 // ListTaskQueue indicates an expected call of ListTaskQueue. 352 func (mr *MockTaskStoreMockRecorder) ListTaskQueue(ctx, request interface{}) *gomock.Call { 353 mr.mock.ctrl.T.Helper() 354 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTaskQueue", reflect.TypeOf((*MockTaskStore)(nil).ListTaskQueue), ctx, request) 355 } 356 357 // ListTaskQueueUserDataEntries mocks base method. 358 func (m *MockTaskStore) ListTaskQueueUserDataEntries(ctx context.Context, request *persistence.ListTaskQueueUserDataEntriesRequest) (*persistence.InternalListTaskQueueUserDataEntriesResponse, error) { 359 m.ctrl.T.Helper() 360 ret := m.ctrl.Call(m, "ListTaskQueueUserDataEntries", ctx, request) 361 ret0, _ := ret[0].(*persistence.InternalListTaskQueueUserDataEntriesResponse) 362 ret1, _ := ret[1].(error) 363 return ret0, ret1 364 } 365 366 // ListTaskQueueUserDataEntries indicates an expected call of ListTaskQueueUserDataEntries. 367 func (mr *MockTaskStoreMockRecorder) ListTaskQueueUserDataEntries(ctx, request interface{}) *gomock.Call { 368 mr.mock.ctrl.T.Helper() 369 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTaskQueueUserDataEntries", reflect.TypeOf((*MockTaskStore)(nil).ListTaskQueueUserDataEntries), ctx, request) 370 } 371 372 // UpdateTaskQueue mocks base method. 373 func (m *MockTaskStore) UpdateTaskQueue(ctx context.Context, request *persistence.InternalUpdateTaskQueueRequest) (*persistence.UpdateTaskQueueResponse, error) { 374 m.ctrl.T.Helper() 375 ret := m.ctrl.Call(m, "UpdateTaskQueue", ctx, request) 376 ret0, _ := ret[0].(*persistence.UpdateTaskQueueResponse) 377 ret1, _ := ret[1].(error) 378 return ret0, ret1 379 } 380 381 // UpdateTaskQueue indicates an expected call of UpdateTaskQueue. 382 func (mr *MockTaskStoreMockRecorder) UpdateTaskQueue(ctx, request interface{}) *gomock.Call { 383 mr.mock.ctrl.T.Helper() 384 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTaskQueue", reflect.TypeOf((*MockTaskStore)(nil).UpdateTaskQueue), ctx, request) 385 } 386 387 // UpdateTaskQueueUserData mocks base method. 388 func (m *MockTaskStore) UpdateTaskQueueUserData(ctx context.Context, request *persistence.InternalUpdateTaskQueueUserDataRequest) error { 389 m.ctrl.T.Helper() 390 ret := m.ctrl.Call(m, "UpdateTaskQueueUserData", ctx, request) 391 ret0, _ := ret[0].(error) 392 return ret0 393 } 394 395 // UpdateTaskQueueUserData indicates an expected call of UpdateTaskQueueUserData. 396 func (mr *MockTaskStoreMockRecorder) UpdateTaskQueueUserData(ctx, request interface{}) *gomock.Call { 397 mr.mock.ctrl.T.Helper() 398 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTaskQueueUserData", reflect.TypeOf((*MockTaskStore)(nil).UpdateTaskQueueUserData), ctx, request) 399 } 400 401 // MockMetadataStore is a mock of MetadataStore interface. 402 type MockMetadataStore struct { 403 ctrl *gomock.Controller 404 recorder *MockMetadataStoreMockRecorder 405 } 406 407 // MockMetadataStoreMockRecorder is the mock recorder for MockMetadataStore. 408 type MockMetadataStoreMockRecorder struct { 409 mock *MockMetadataStore 410 } 411 412 // NewMockMetadataStore creates a new mock instance. 413 func NewMockMetadataStore(ctrl *gomock.Controller) *MockMetadataStore { 414 mock := &MockMetadataStore{ctrl: ctrl} 415 mock.recorder = &MockMetadataStoreMockRecorder{mock} 416 return mock 417 } 418 419 // EXPECT returns an object that allows the caller to indicate expected use. 420 func (m *MockMetadataStore) EXPECT() *MockMetadataStoreMockRecorder { 421 return m.recorder 422 } 423 424 // Close mocks base method. 425 func (m *MockMetadataStore) Close() { 426 m.ctrl.T.Helper() 427 m.ctrl.Call(m, "Close") 428 } 429 430 // Close indicates an expected call of Close. 431 func (mr *MockMetadataStoreMockRecorder) Close() *gomock.Call { 432 mr.mock.ctrl.T.Helper() 433 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockMetadataStore)(nil).Close)) 434 } 435 436 // CreateNamespace mocks base method. 437 func (m *MockMetadataStore) CreateNamespace(ctx context.Context, request *persistence.InternalCreateNamespaceRequest) (*persistence.CreateNamespaceResponse, error) { 438 m.ctrl.T.Helper() 439 ret := m.ctrl.Call(m, "CreateNamespace", ctx, request) 440 ret0, _ := ret[0].(*persistence.CreateNamespaceResponse) 441 ret1, _ := ret[1].(error) 442 return ret0, ret1 443 } 444 445 // CreateNamespace indicates an expected call of CreateNamespace. 446 func (mr *MockMetadataStoreMockRecorder) CreateNamespace(ctx, request interface{}) *gomock.Call { 447 mr.mock.ctrl.T.Helper() 448 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNamespace", reflect.TypeOf((*MockMetadataStore)(nil).CreateNamespace), ctx, request) 449 } 450 451 // DeleteNamespace mocks base method. 452 func (m *MockMetadataStore) DeleteNamespace(ctx context.Context, request *persistence.DeleteNamespaceRequest) error { 453 m.ctrl.T.Helper() 454 ret := m.ctrl.Call(m, "DeleteNamespace", ctx, request) 455 ret0, _ := ret[0].(error) 456 return ret0 457 } 458 459 // DeleteNamespace indicates an expected call of DeleteNamespace. 460 func (mr *MockMetadataStoreMockRecorder) DeleteNamespace(ctx, request interface{}) *gomock.Call { 461 mr.mock.ctrl.T.Helper() 462 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNamespace", reflect.TypeOf((*MockMetadataStore)(nil).DeleteNamespace), ctx, request) 463 } 464 465 // DeleteNamespaceByName mocks base method. 466 func (m *MockMetadataStore) DeleteNamespaceByName(ctx context.Context, request *persistence.DeleteNamespaceByNameRequest) error { 467 m.ctrl.T.Helper() 468 ret := m.ctrl.Call(m, "DeleteNamespaceByName", ctx, request) 469 ret0, _ := ret[0].(error) 470 return ret0 471 } 472 473 // DeleteNamespaceByName indicates an expected call of DeleteNamespaceByName. 474 func (mr *MockMetadataStoreMockRecorder) DeleteNamespaceByName(ctx, request interface{}) *gomock.Call { 475 mr.mock.ctrl.T.Helper() 476 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNamespaceByName", reflect.TypeOf((*MockMetadataStore)(nil).DeleteNamespaceByName), ctx, request) 477 } 478 479 // GetMetadata mocks base method. 480 func (m *MockMetadataStore) GetMetadata(ctx context.Context) (*persistence.GetMetadataResponse, error) { 481 m.ctrl.T.Helper() 482 ret := m.ctrl.Call(m, "GetMetadata", ctx) 483 ret0, _ := ret[0].(*persistence.GetMetadataResponse) 484 ret1, _ := ret[1].(error) 485 return ret0, ret1 486 } 487 488 // GetMetadata indicates an expected call of GetMetadata. 489 func (mr *MockMetadataStoreMockRecorder) GetMetadata(ctx interface{}) *gomock.Call { 490 mr.mock.ctrl.T.Helper() 491 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMetadata", reflect.TypeOf((*MockMetadataStore)(nil).GetMetadata), ctx) 492 } 493 494 // GetName mocks base method. 495 func (m *MockMetadataStore) GetName() string { 496 m.ctrl.T.Helper() 497 ret := m.ctrl.Call(m, "GetName") 498 ret0, _ := ret[0].(string) 499 return ret0 500 } 501 502 // GetName indicates an expected call of GetName. 503 func (mr *MockMetadataStoreMockRecorder) GetName() *gomock.Call { 504 mr.mock.ctrl.T.Helper() 505 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetName", reflect.TypeOf((*MockMetadataStore)(nil).GetName)) 506 } 507 508 // GetNamespace mocks base method. 509 func (m *MockMetadataStore) GetNamespace(ctx context.Context, request *persistence.GetNamespaceRequest) (*persistence.InternalGetNamespaceResponse, error) { 510 m.ctrl.T.Helper() 511 ret := m.ctrl.Call(m, "GetNamespace", ctx, request) 512 ret0, _ := ret[0].(*persistence.InternalGetNamespaceResponse) 513 ret1, _ := ret[1].(error) 514 return ret0, ret1 515 } 516 517 // GetNamespace indicates an expected call of GetNamespace. 518 func (mr *MockMetadataStoreMockRecorder) GetNamespace(ctx, request interface{}) *gomock.Call { 519 mr.mock.ctrl.T.Helper() 520 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNamespace", reflect.TypeOf((*MockMetadataStore)(nil).GetNamespace), ctx, request) 521 } 522 523 // ListNamespaces mocks base method. 524 func (m *MockMetadataStore) ListNamespaces(ctx context.Context, request *persistence.InternalListNamespacesRequest) (*persistence.InternalListNamespacesResponse, error) { 525 m.ctrl.T.Helper() 526 ret := m.ctrl.Call(m, "ListNamespaces", ctx, request) 527 ret0, _ := ret[0].(*persistence.InternalListNamespacesResponse) 528 ret1, _ := ret[1].(error) 529 return ret0, ret1 530 } 531 532 // ListNamespaces indicates an expected call of ListNamespaces. 533 func (mr *MockMetadataStoreMockRecorder) ListNamespaces(ctx, request interface{}) *gomock.Call { 534 mr.mock.ctrl.T.Helper() 535 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListNamespaces", reflect.TypeOf((*MockMetadataStore)(nil).ListNamespaces), ctx, request) 536 } 537 538 // RenameNamespace mocks base method. 539 func (m *MockMetadataStore) RenameNamespace(ctx context.Context, request *persistence.InternalRenameNamespaceRequest) error { 540 m.ctrl.T.Helper() 541 ret := m.ctrl.Call(m, "RenameNamespace", ctx, request) 542 ret0, _ := ret[0].(error) 543 return ret0 544 } 545 546 // RenameNamespace indicates an expected call of RenameNamespace. 547 func (mr *MockMetadataStoreMockRecorder) RenameNamespace(ctx, request interface{}) *gomock.Call { 548 mr.mock.ctrl.T.Helper() 549 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenameNamespace", reflect.TypeOf((*MockMetadataStore)(nil).RenameNamespace), ctx, request) 550 } 551 552 // UpdateNamespace mocks base method. 553 func (m *MockMetadataStore) UpdateNamespace(ctx context.Context, request *persistence.InternalUpdateNamespaceRequest) error { 554 m.ctrl.T.Helper() 555 ret := m.ctrl.Call(m, "UpdateNamespace", ctx, request) 556 ret0, _ := ret[0].(error) 557 return ret0 558 } 559 560 // UpdateNamespace indicates an expected call of UpdateNamespace. 561 func (mr *MockMetadataStoreMockRecorder) UpdateNamespace(ctx, request interface{}) *gomock.Call { 562 mr.mock.ctrl.T.Helper() 563 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateNamespace", reflect.TypeOf((*MockMetadataStore)(nil).UpdateNamespace), ctx, request) 564 } 565 566 // MockClusterMetadataStore is a mock of ClusterMetadataStore interface. 567 type MockClusterMetadataStore struct { 568 ctrl *gomock.Controller 569 recorder *MockClusterMetadataStoreMockRecorder 570 } 571 572 // MockClusterMetadataStoreMockRecorder is the mock recorder for MockClusterMetadataStore. 573 type MockClusterMetadataStoreMockRecorder struct { 574 mock *MockClusterMetadataStore 575 } 576 577 // NewMockClusterMetadataStore creates a new mock instance. 578 func NewMockClusterMetadataStore(ctrl *gomock.Controller) *MockClusterMetadataStore { 579 mock := &MockClusterMetadataStore{ctrl: ctrl} 580 mock.recorder = &MockClusterMetadataStoreMockRecorder{mock} 581 return mock 582 } 583 584 // EXPECT returns an object that allows the caller to indicate expected use. 585 func (m *MockClusterMetadataStore) EXPECT() *MockClusterMetadataStoreMockRecorder { 586 return m.recorder 587 } 588 589 // Close mocks base method. 590 func (m *MockClusterMetadataStore) Close() { 591 m.ctrl.T.Helper() 592 m.ctrl.Call(m, "Close") 593 } 594 595 // Close indicates an expected call of Close. 596 func (mr *MockClusterMetadataStoreMockRecorder) Close() *gomock.Call { 597 mr.mock.ctrl.T.Helper() 598 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockClusterMetadataStore)(nil).Close)) 599 } 600 601 // DeleteClusterMetadata mocks base method. 602 func (m *MockClusterMetadataStore) DeleteClusterMetadata(ctx context.Context, request *persistence.InternalDeleteClusterMetadataRequest) error { 603 m.ctrl.T.Helper() 604 ret := m.ctrl.Call(m, "DeleteClusterMetadata", ctx, request) 605 ret0, _ := ret[0].(error) 606 return ret0 607 } 608 609 // DeleteClusterMetadata indicates an expected call of DeleteClusterMetadata. 610 func (mr *MockClusterMetadataStoreMockRecorder) DeleteClusterMetadata(ctx, request interface{}) *gomock.Call { 611 mr.mock.ctrl.T.Helper() 612 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteClusterMetadata", reflect.TypeOf((*MockClusterMetadataStore)(nil).DeleteClusterMetadata), ctx, request) 613 } 614 615 // GetClusterMembers mocks base method. 616 func (m *MockClusterMetadataStore) GetClusterMembers(ctx context.Context, request *persistence.GetClusterMembersRequest) (*persistence.GetClusterMembersResponse, error) { 617 m.ctrl.T.Helper() 618 ret := m.ctrl.Call(m, "GetClusterMembers", ctx, request) 619 ret0, _ := ret[0].(*persistence.GetClusterMembersResponse) 620 ret1, _ := ret[1].(error) 621 return ret0, ret1 622 } 623 624 // GetClusterMembers indicates an expected call of GetClusterMembers. 625 func (mr *MockClusterMetadataStoreMockRecorder) GetClusterMembers(ctx, request interface{}) *gomock.Call { 626 mr.mock.ctrl.T.Helper() 627 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterMembers", reflect.TypeOf((*MockClusterMetadataStore)(nil).GetClusterMembers), ctx, request) 628 } 629 630 // GetClusterMetadata mocks base method. 631 func (m *MockClusterMetadataStore) GetClusterMetadata(ctx context.Context, request *persistence.InternalGetClusterMetadataRequest) (*persistence.InternalGetClusterMetadataResponse, error) { 632 m.ctrl.T.Helper() 633 ret := m.ctrl.Call(m, "GetClusterMetadata", ctx, request) 634 ret0, _ := ret[0].(*persistence.InternalGetClusterMetadataResponse) 635 ret1, _ := ret[1].(error) 636 return ret0, ret1 637 } 638 639 // GetClusterMetadata indicates an expected call of GetClusterMetadata. 640 func (mr *MockClusterMetadataStoreMockRecorder) GetClusterMetadata(ctx, request interface{}) *gomock.Call { 641 mr.mock.ctrl.T.Helper() 642 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterMetadata", reflect.TypeOf((*MockClusterMetadataStore)(nil).GetClusterMetadata), ctx, request) 643 } 644 645 // GetName mocks base method. 646 func (m *MockClusterMetadataStore) GetName() string { 647 m.ctrl.T.Helper() 648 ret := m.ctrl.Call(m, "GetName") 649 ret0, _ := ret[0].(string) 650 return ret0 651 } 652 653 // GetName indicates an expected call of GetName. 654 func (mr *MockClusterMetadataStoreMockRecorder) GetName() *gomock.Call { 655 mr.mock.ctrl.T.Helper() 656 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetName", reflect.TypeOf((*MockClusterMetadataStore)(nil).GetName)) 657 } 658 659 // ListClusterMetadata mocks base method. 660 func (m *MockClusterMetadataStore) ListClusterMetadata(ctx context.Context, request *persistence.InternalListClusterMetadataRequest) (*persistence.InternalListClusterMetadataResponse, error) { 661 m.ctrl.T.Helper() 662 ret := m.ctrl.Call(m, "ListClusterMetadata", ctx, request) 663 ret0, _ := ret[0].(*persistence.InternalListClusterMetadataResponse) 664 ret1, _ := ret[1].(error) 665 return ret0, ret1 666 } 667 668 // ListClusterMetadata indicates an expected call of ListClusterMetadata. 669 func (mr *MockClusterMetadataStoreMockRecorder) ListClusterMetadata(ctx, request interface{}) *gomock.Call { 670 mr.mock.ctrl.T.Helper() 671 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClusterMetadata", reflect.TypeOf((*MockClusterMetadataStore)(nil).ListClusterMetadata), ctx, request) 672 } 673 674 // PruneClusterMembership mocks base method. 675 func (m *MockClusterMetadataStore) PruneClusterMembership(ctx context.Context, request *persistence.PruneClusterMembershipRequest) error { 676 m.ctrl.T.Helper() 677 ret := m.ctrl.Call(m, "PruneClusterMembership", ctx, request) 678 ret0, _ := ret[0].(error) 679 return ret0 680 } 681 682 // PruneClusterMembership indicates an expected call of PruneClusterMembership. 683 func (mr *MockClusterMetadataStoreMockRecorder) PruneClusterMembership(ctx, request interface{}) *gomock.Call { 684 mr.mock.ctrl.T.Helper() 685 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PruneClusterMembership", reflect.TypeOf((*MockClusterMetadataStore)(nil).PruneClusterMembership), ctx, request) 686 } 687 688 // SaveClusterMetadata mocks base method. 689 func (m *MockClusterMetadataStore) SaveClusterMetadata(ctx context.Context, request *persistence.InternalSaveClusterMetadataRequest) (bool, error) { 690 m.ctrl.T.Helper() 691 ret := m.ctrl.Call(m, "SaveClusterMetadata", ctx, request) 692 ret0, _ := ret[0].(bool) 693 ret1, _ := ret[1].(error) 694 return ret0, ret1 695 } 696 697 // SaveClusterMetadata indicates an expected call of SaveClusterMetadata. 698 func (mr *MockClusterMetadataStoreMockRecorder) SaveClusterMetadata(ctx, request interface{}) *gomock.Call { 699 mr.mock.ctrl.T.Helper() 700 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveClusterMetadata", reflect.TypeOf((*MockClusterMetadataStore)(nil).SaveClusterMetadata), ctx, request) 701 } 702 703 // UpsertClusterMembership mocks base method. 704 func (m *MockClusterMetadataStore) UpsertClusterMembership(ctx context.Context, request *persistence.UpsertClusterMembershipRequest) error { 705 m.ctrl.T.Helper() 706 ret := m.ctrl.Call(m, "UpsertClusterMembership", ctx, request) 707 ret0, _ := ret[0].(error) 708 return ret0 709 } 710 711 // UpsertClusterMembership indicates an expected call of UpsertClusterMembership. 712 func (mr *MockClusterMetadataStoreMockRecorder) UpsertClusterMembership(ctx, request interface{}) *gomock.Call { 713 mr.mock.ctrl.T.Helper() 714 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertClusterMembership", reflect.TypeOf((*MockClusterMetadataStore)(nil).UpsertClusterMembership), ctx, request) 715 } 716 717 // MockExecutionStore is a mock of ExecutionStore interface. 718 type MockExecutionStore struct { 719 ctrl *gomock.Controller 720 recorder *MockExecutionStoreMockRecorder 721 } 722 723 // MockExecutionStoreMockRecorder is the mock recorder for MockExecutionStore. 724 type MockExecutionStoreMockRecorder struct { 725 mock *MockExecutionStore 726 } 727 728 // NewMockExecutionStore creates a new mock instance. 729 func NewMockExecutionStore(ctrl *gomock.Controller) *MockExecutionStore { 730 mock := &MockExecutionStore{ctrl: ctrl} 731 mock.recorder = &MockExecutionStoreMockRecorder{mock} 732 return mock 733 } 734 735 // EXPECT returns an object that allows the caller to indicate expected use. 736 func (m *MockExecutionStore) EXPECT() *MockExecutionStoreMockRecorder { 737 return m.recorder 738 } 739 740 // AddHistoryTasks mocks base method. 741 func (m *MockExecutionStore) AddHistoryTasks(ctx context.Context, request *persistence.InternalAddHistoryTasksRequest) error { 742 m.ctrl.T.Helper() 743 ret := m.ctrl.Call(m, "AddHistoryTasks", ctx, request) 744 ret0, _ := ret[0].(error) 745 return ret0 746 } 747 748 // AddHistoryTasks indicates an expected call of AddHistoryTasks. 749 func (mr *MockExecutionStoreMockRecorder) AddHistoryTasks(ctx, request interface{}) *gomock.Call { 750 mr.mock.ctrl.T.Helper() 751 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddHistoryTasks", reflect.TypeOf((*MockExecutionStore)(nil).AddHistoryTasks), ctx, request) 752 } 753 754 // AppendHistoryNodes mocks base method. 755 func (m *MockExecutionStore) AppendHistoryNodes(ctx context.Context, request *persistence.InternalAppendHistoryNodesRequest) error { 756 m.ctrl.T.Helper() 757 ret := m.ctrl.Call(m, "AppendHistoryNodes", ctx, request) 758 ret0, _ := ret[0].(error) 759 return ret0 760 } 761 762 // AppendHistoryNodes indicates an expected call of AppendHistoryNodes. 763 func (mr *MockExecutionStoreMockRecorder) AppendHistoryNodes(ctx, request interface{}) *gomock.Call { 764 mr.mock.ctrl.T.Helper() 765 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendHistoryNodes", reflect.TypeOf((*MockExecutionStore)(nil).AppendHistoryNodes), ctx, request) 766 } 767 768 // Close mocks base method. 769 func (m *MockExecutionStore) Close() { 770 m.ctrl.T.Helper() 771 m.ctrl.Call(m, "Close") 772 } 773 774 // Close indicates an expected call of Close. 775 func (mr *MockExecutionStoreMockRecorder) Close() *gomock.Call { 776 mr.mock.ctrl.T.Helper() 777 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockExecutionStore)(nil).Close)) 778 } 779 780 // CompleteHistoryTask mocks base method. 781 func (m *MockExecutionStore) CompleteHistoryTask(ctx context.Context, request *persistence.CompleteHistoryTaskRequest) error { 782 m.ctrl.T.Helper() 783 ret := m.ctrl.Call(m, "CompleteHistoryTask", ctx, request) 784 ret0, _ := ret[0].(error) 785 return ret0 786 } 787 788 // CompleteHistoryTask indicates an expected call of CompleteHistoryTask. 789 func (mr *MockExecutionStoreMockRecorder) CompleteHistoryTask(ctx, request interface{}) *gomock.Call { 790 mr.mock.ctrl.T.Helper() 791 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteHistoryTask", reflect.TypeOf((*MockExecutionStore)(nil).CompleteHistoryTask), ctx, request) 792 } 793 794 // ConflictResolveWorkflowExecution mocks base method. 795 func (m *MockExecutionStore) ConflictResolveWorkflowExecution(ctx context.Context, request *persistence.InternalConflictResolveWorkflowExecutionRequest) error { 796 m.ctrl.T.Helper() 797 ret := m.ctrl.Call(m, "ConflictResolveWorkflowExecution", ctx, request) 798 ret0, _ := ret[0].(error) 799 return ret0 800 } 801 802 // ConflictResolveWorkflowExecution indicates an expected call of ConflictResolveWorkflowExecution. 803 func (mr *MockExecutionStoreMockRecorder) ConflictResolveWorkflowExecution(ctx, request interface{}) *gomock.Call { 804 mr.mock.ctrl.T.Helper() 805 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConflictResolveWorkflowExecution", reflect.TypeOf((*MockExecutionStore)(nil).ConflictResolveWorkflowExecution), ctx, request) 806 } 807 808 // CreateWorkflowExecution mocks base method. 809 func (m *MockExecutionStore) CreateWorkflowExecution(ctx context.Context, request *persistence.InternalCreateWorkflowExecutionRequest) (*persistence.InternalCreateWorkflowExecutionResponse, error) { 810 m.ctrl.T.Helper() 811 ret := m.ctrl.Call(m, "CreateWorkflowExecution", ctx, request) 812 ret0, _ := ret[0].(*persistence.InternalCreateWorkflowExecutionResponse) 813 ret1, _ := ret[1].(error) 814 return ret0, ret1 815 } 816 817 // CreateWorkflowExecution indicates an expected call of CreateWorkflowExecution. 818 func (mr *MockExecutionStoreMockRecorder) CreateWorkflowExecution(ctx, request interface{}) *gomock.Call { 819 mr.mock.ctrl.T.Helper() 820 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateWorkflowExecution", reflect.TypeOf((*MockExecutionStore)(nil).CreateWorkflowExecution), ctx, request) 821 } 822 823 // DeleteCurrentWorkflowExecution mocks base method. 824 func (m *MockExecutionStore) DeleteCurrentWorkflowExecution(ctx context.Context, request *persistence.DeleteCurrentWorkflowExecutionRequest) error { 825 m.ctrl.T.Helper() 826 ret := m.ctrl.Call(m, "DeleteCurrentWorkflowExecution", ctx, request) 827 ret0, _ := ret[0].(error) 828 return ret0 829 } 830 831 // DeleteCurrentWorkflowExecution indicates an expected call of DeleteCurrentWorkflowExecution. 832 func (mr *MockExecutionStoreMockRecorder) DeleteCurrentWorkflowExecution(ctx, request interface{}) *gomock.Call { 833 mr.mock.ctrl.T.Helper() 834 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCurrentWorkflowExecution", reflect.TypeOf((*MockExecutionStore)(nil).DeleteCurrentWorkflowExecution), ctx, request) 835 } 836 837 // DeleteHistoryBranch mocks base method. 838 func (m *MockExecutionStore) DeleteHistoryBranch(ctx context.Context, request *persistence.InternalDeleteHistoryBranchRequest) error { 839 m.ctrl.T.Helper() 840 ret := m.ctrl.Call(m, "DeleteHistoryBranch", ctx, request) 841 ret0, _ := ret[0].(error) 842 return ret0 843 } 844 845 // DeleteHistoryBranch indicates an expected call of DeleteHistoryBranch. 846 func (mr *MockExecutionStoreMockRecorder) DeleteHistoryBranch(ctx, request interface{}) *gomock.Call { 847 mr.mock.ctrl.T.Helper() 848 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteHistoryBranch", reflect.TypeOf((*MockExecutionStore)(nil).DeleteHistoryBranch), ctx, request) 849 } 850 851 // DeleteHistoryNodes mocks base method. 852 func (m *MockExecutionStore) DeleteHistoryNodes(ctx context.Context, request *persistence.InternalDeleteHistoryNodesRequest) error { 853 m.ctrl.T.Helper() 854 ret := m.ctrl.Call(m, "DeleteHistoryNodes", ctx, request) 855 ret0, _ := ret[0].(error) 856 return ret0 857 } 858 859 // DeleteHistoryNodes indicates an expected call of DeleteHistoryNodes. 860 func (mr *MockExecutionStoreMockRecorder) DeleteHistoryNodes(ctx, request interface{}) *gomock.Call { 861 mr.mock.ctrl.T.Helper() 862 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteHistoryNodes", reflect.TypeOf((*MockExecutionStore)(nil).DeleteHistoryNodes), ctx, request) 863 } 864 865 // DeleteReplicationTaskFromDLQ mocks base method. 866 func (m *MockExecutionStore) DeleteReplicationTaskFromDLQ(ctx context.Context, request *persistence.DeleteReplicationTaskFromDLQRequest) error { 867 m.ctrl.T.Helper() 868 ret := m.ctrl.Call(m, "DeleteReplicationTaskFromDLQ", ctx, request) 869 ret0, _ := ret[0].(error) 870 return ret0 871 } 872 873 // DeleteReplicationTaskFromDLQ indicates an expected call of DeleteReplicationTaskFromDLQ. 874 func (mr *MockExecutionStoreMockRecorder) DeleteReplicationTaskFromDLQ(ctx, request interface{}) *gomock.Call { 875 mr.mock.ctrl.T.Helper() 876 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteReplicationTaskFromDLQ", reflect.TypeOf((*MockExecutionStore)(nil).DeleteReplicationTaskFromDLQ), ctx, request) 877 } 878 879 // DeleteWorkflowExecution mocks base method. 880 func (m *MockExecutionStore) DeleteWorkflowExecution(ctx context.Context, request *persistence.DeleteWorkflowExecutionRequest) error { 881 m.ctrl.T.Helper() 882 ret := m.ctrl.Call(m, "DeleteWorkflowExecution", ctx, request) 883 ret0, _ := ret[0].(error) 884 return ret0 885 } 886 887 // DeleteWorkflowExecution indicates an expected call of DeleteWorkflowExecution. 888 func (mr *MockExecutionStoreMockRecorder) DeleteWorkflowExecution(ctx, request interface{}) *gomock.Call { 889 mr.mock.ctrl.T.Helper() 890 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteWorkflowExecution", reflect.TypeOf((*MockExecutionStore)(nil).DeleteWorkflowExecution), ctx, request) 891 } 892 893 // ForkHistoryBranch mocks base method. 894 func (m *MockExecutionStore) ForkHistoryBranch(ctx context.Context, request *persistence.InternalForkHistoryBranchRequest) error { 895 m.ctrl.T.Helper() 896 ret := m.ctrl.Call(m, "ForkHistoryBranch", ctx, request) 897 ret0, _ := ret[0].(error) 898 return ret0 899 } 900 901 // ForkHistoryBranch indicates an expected call of ForkHistoryBranch. 902 func (mr *MockExecutionStoreMockRecorder) ForkHistoryBranch(ctx, request interface{}) *gomock.Call { 903 mr.mock.ctrl.T.Helper() 904 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForkHistoryBranch", reflect.TypeOf((*MockExecutionStore)(nil).ForkHistoryBranch), ctx, request) 905 } 906 907 // GetAllHistoryTreeBranches mocks base method. 908 func (m *MockExecutionStore) GetAllHistoryTreeBranches(ctx context.Context, request *persistence.GetAllHistoryTreeBranchesRequest) (*persistence.InternalGetAllHistoryTreeBranchesResponse, error) { 909 m.ctrl.T.Helper() 910 ret := m.ctrl.Call(m, "GetAllHistoryTreeBranches", ctx, request) 911 ret0, _ := ret[0].(*persistence.InternalGetAllHistoryTreeBranchesResponse) 912 ret1, _ := ret[1].(error) 913 return ret0, ret1 914 } 915 916 // GetAllHistoryTreeBranches indicates an expected call of GetAllHistoryTreeBranches. 917 func (mr *MockExecutionStoreMockRecorder) GetAllHistoryTreeBranches(ctx, request interface{}) *gomock.Call { 918 mr.mock.ctrl.T.Helper() 919 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllHistoryTreeBranches", reflect.TypeOf((*MockExecutionStore)(nil).GetAllHistoryTreeBranches), ctx, request) 920 } 921 922 // GetCurrentExecution mocks base method. 923 func (m *MockExecutionStore) GetCurrentExecution(ctx context.Context, request *persistence.GetCurrentExecutionRequest) (*persistence.InternalGetCurrentExecutionResponse, error) { 924 m.ctrl.T.Helper() 925 ret := m.ctrl.Call(m, "GetCurrentExecution", ctx, request) 926 ret0, _ := ret[0].(*persistence.InternalGetCurrentExecutionResponse) 927 ret1, _ := ret[1].(error) 928 return ret0, ret1 929 } 930 931 // GetCurrentExecution indicates an expected call of GetCurrentExecution. 932 func (mr *MockExecutionStoreMockRecorder) GetCurrentExecution(ctx, request interface{}) *gomock.Call { 933 mr.mock.ctrl.T.Helper() 934 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentExecution", reflect.TypeOf((*MockExecutionStore)(nil).GetCurrentExecution), ctx, request) 935 } 936 937 // GetHistoryBranchUtil mocks base method. 938 func (m *MockExecutionStore) GetHistoryBranchUtil() persistence.HistoryBranchUtil { 939 m.ctrl.T.Helper() 940 ret := m.ctrl.Call(m, "GetHistoryBranchUtil") 941 ret0, _ := ret[0].(persistence.HistoryBranchUtil) 942 return ret0 943 } 944 945 // GetHistoryBranchUtil indicates an expected call of GetHistoryBranchUtil. 946 func (mr *MockExecutionStoreMockRecorder) GetHistoryBranchUtil() *gomock.Call { 947 mr.mock.ctrl.T.Helper() 948 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHistoryBranchUtil", reflect.TypeOf((*MockExecutionStore)(nil).GetHistoryBranchUtil)) 949 } 950 951 // GetHistoryTasks mocks base method. 952 func (m *MockExecutionStore) GetHistoryTasks(ctx context.Context, request *persistence.GetHistoryTasksRequest) (*persistence.InternalGetHistoryTasksResponse, error) { 953 m.ctrl.T.Helper() 954 ret := m.ctrl.Call(m, "GetHistoryTasks", ctx, request) 955 ret0, _ := ret[0].(*persistence.InternalGetHistoryTasksResponse) 956 ret1, _ := ret[1].(error) 957 return ret0, ret1 958 } 959 960 // GetHistoryTasks indicates an expected call of GetHistoryTasks. 961 func (mr *MockExecutionStoreMockRecorder) GetHistoryTasks(ctx, request interface{}) *gomock.Call { 962 mr.mock.ctrl.T.Helper() 963 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHistoryTasks", reflect.TypeOf((*MockExecutionStore)(nil).GetHistoryTasks), ctx, request) 964 } 965 966 // GetHistoryTree mocks base method. 967 func (m *MockExecutionStore) GetHistoryTree(ctx context.Context, request *persistence.GetHistoryTreeRequest) (*persistence.InternalGetHistoryTreeResponse, error) { 968 m.ctrl.T.Helper() 969 ret := m.ctrl.Call(m, "GetHistoryTree", ctx, request) 970 ret0, _ := ret[0].(*persistence.InternalGetHistoryTreeResponse) 971 ret1, _ := ret[1].(error) 972 return ret0, ret1 973 } 974 975 // GetHistoryTree indicates an expected call of GetHistoryTree. 976 func (mr *MockExecutionStoreMockRecorder) GetHistoryTree(ctx, request interface{}) *gomock.Call { 977 mr.mock.ctrl.T.Helper() 978 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHistoryTree", reflect.TypeOf((*MockExecutionStore)(nil).GetHistoryTree), ctx, request) 979 } 980 981 // GetName mocks base method. 982 func (m *MockExecutionStore) GetName() string { 983 m.ctrl.T.Helper() 984 ret := m.ctrl.Call(m, "GetName") 985 ret0, _ := ret[0].(string) 986 return ret0 987 } 988 989 // GetName indicates an expected call of GetName. 990 func (mr *MockExecutionStoreMockRecorder) GetName() *gomock.Call { 991 mr.mock.ctrl.T.Helper() 992 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetName", reflect.TypeOf((*MockExecutionStore)(nil).GetName)) 993 } 994 995 // GetReplicationTasksFromDLQ mocks base method. 996 func (m *MockExecutionStore) GetReplicationTasksFromDLQ(ctx context.Context, request *persistence.GetReplicationTasksFromDLQRequest) (*persistence.InternalGetReplicationTasksFromDLQResponse, error) { 997 m.ctrl.T.Helper() 998 ret := m.ctrl.Call(m, "GetReplicationTasksFromDLQ", ctx, request) 999 ret0, _ := ret[0].(*persistence.InternalGetReplicationTasksFromDLQResponse) 1000 ret1, _ := ret[1].(error) 1001 return ret0, ret1 1002 } 1003 1004 // GetReplicationTasksFromDLQ indicates an expected call of GetReplicationTasksFromDLQ. 1005 func (mr *MockExecutionStoreMockRecorder) GetReplicationTasksFromDLQ(ctx, request interface{}) *gomock.Call { 1006 mr.mock.ctrl.T.Helper() 1007 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReplicationTasksFromDLQ", reflect.TypeOf((*MockExecutionStore)(nil).GetReplicationTasksFromDLQ), ctx, request) 1008 } 1009 1010 // GetWorkflowExecution mocks base method. 1011 func (m *MockExecutionStore) GetWorkflowExecution(ctx context.Context, request *persistence.GetWorkflowExecutionRequest) (*persistence.InternalGetWorkflowExecutionResponse, error) { 1012 m.ctrl.T.Helper() 1013 ret := m.ctrl.Call(m, "GetWorkflowExecution", ctx, request) 1014 ret0, _ := ret[0].(*persistence.InternalGetWorkflowExecutionResponse) 1015 ret1, _ := ret[1].(error) 1016 return ret0, ret1 1017 } 1018 1019 // GetWorkflowExecution indicates an expected call of GetWorkflowExecution. 1020 func (mr *MockExecutionStoreMockRecorder) GetWorkflowExecution(ctx, request interface{}) *gomock.Call { 1021 mr.mock.ctrl.T.Helper() 1022 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkflowExecution", reflect.TypeOf((*MockExecutionStore)(nil).GetWorkflowExecution), ctx, request) 1023 } 1024 1025 // IsReplicationDLQEmpty mocks base method. 1026 func (m *MockExecutionStore) IsReplicationDLQEmpty(ctx context.Context, request *persistence.GetReplicationTasksFromDLQRequest) (bool, error) { 1027 m.ctrl.T.Helper() 1028 ret := m.ctrl.Call(m, "IsReplicationDLQEmpty", ctx, request) 1029 ret0, _ := ret[0].(bool) 1030 ret1, _ := ret[1].(error) 1031 return ret0, ret1 1032 } 1033 1034 // IsReplicationDLQEmpty indicates an expected call of IsReplicationDLQEmpty. 1035 func (mr *MockExecutionStoreMockRecorder) IsReplicationDLQEmpty(ctx, request interface{}) *gomock.Call { 1036 mr.mock.ctrl.T.Helper() 1037 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsReplicationDLQEmpty", reflect.TypeOf((*MockExecutionStore)(nil).IsReplicationDLQEmpty), ctx, request) 1038 } 1039 1040 // ListConcreteExecutions mocks base method. 1041 func (m *MockExecutionStore) ListConcreteExecutions(ctx context.Context, request *persistence.ListConcreteExecutionsRequest) (*persistence.InternalListConcreteExecutionsResponse, error) { 1042 m.ctrl.T.Helper() 1043 ret := m.ctrl.Call(m, "ListConcreteExecutions", ctx, request) 1044 ret0, _ := ret[0].(*persistence.InternalListConcreteExecutionsResponse) 1045 ret1, _ := ret[1].(error) 1046 return ret0, ret1 1047 } 1048 1049 // ListConcreteExecutions indicates an expected call of ListConcreteExecutions. 1050 func (mr *MockExecutionStoreMockRecorder) ListConcreteExecutions(ctx, request interface{}) *gomock.Call { 1051 mr.mock.ctrl.T.Helper() 1052 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListConcreteExecutions", reflect.TypeOf((*MockExecutionStore)(nil).ListConcreteExecutions), ctx, request) 1053 } 1054 1055 // PutReplicationTaskToDLQ mocks base method. 1056 func (m *MockExecutionStore) PutReplicationTaskToDLQ(ctx context.Context, request *persistence.PutReplicationTaskToDLQRequest) error { 1057 m.ctrl.T.Helper() 1058 ret := m.ctrl.Call(m, "PutReplicationTaskToDLQ", ctx, request) 1059 ret0, _ := ret[0].(error) 1060 return ret0 1061 } 1062 1063 // PutReplicationTaskToDLQ indicates an expected call of PutReplicationTaskToDLQ. 1064 func (mr *MockExecutionStoreMockRecorder) PutReplicationTaskToDLQ(ctx, request interface{}) *gomock.Call { 1065 mr.mock.ctrl.T.Helper() 1066 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutReplicationTaskToDLQ", reflect.TypeOf((*MockExecutionStore)(nil).PutReplicationTaskToDLQ), ctx, request) 1067 } 1068 1069 // RangeCompleteHistoryTasks mocks base method. 1070 func (m *MockExecutionStore) RangeCompleteHistoryTasks(ctx context.Context, request *persistence.RangeCompleteHistoryTasksRequest) error { 1071 m.ctrl.T.Helper() 1072 ret := m.ctrl.Call(m, "RangeCompleteHistoryTasks", ctx, request) 1073 ret0, _ := ret[0].(error) 1074 return ret0 1075 } 1076 1077 // RangeCompleteHistoryTasks indicates an expected call of RangeCompleteHistoryTasks. 1078 func (mr *MockExecutionStoreMockRecorder) RangeCompleteHistoryTasks(ctx, request interface{}) *gomock.Call { 1079 mr.mock.ctrl.T.Helper() 1080 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RangeCompleteHistoryTasks", reflect.TypeOf((*MockExecutionStore)(nil).RangeCompleteHistoryTasks), ctx, request) 1081 } 1082 1083 // RangeDeleteReplicationTaskFromDLQ mocks base method. 1084 func (m *MockExecutionStore) RangeDeleteReplicationTaskFromDLQ(ctx context.Context, request *persistence.RangeDeleteReplicationTaskFromDLQRequest) error { 1085 m.ctrl.T.Helper() 1086 ret := m.ctrl.Call(m, "RangeDeleteReplicationTaskFromDLQ", ctx, request) 1087 ret0, _ := ret[0].(error) 1088 return ret0 1089 } 1090 1091 // RangeDeleteReplicationTaskFromDLQ indicates an expected call of RangeDeleteReplicationTaskFromDLQ. 1092 func (mr *MockExecutionStoreMockRecorder) RangeDeleteReplicationTaskFromDLQ(ctx, request interface{}) *gomock.Call { 1093 mr.mock.ctrl.T.Helper() 1094 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RangeDeleteReplicationTaskFromDLQ", reflect.TypeOf((*MockExecutionStore)(nil).RangeDeleteReplicationTaskFromDLQ), ctx, request) 1095 } 1096 1097 // ReadHistoryBranch mocks base method. 1098 func (m *MockExecutionStore) ReadHistoryBranch(ctx context.Context, request *persistence.InternalReadHistoryBranchRequest) (*persistence.InternalReadHistoryBranchResponse, error) { 1099 m.ctrl.T.Helper() 1100 ret := m.ctrl.Call(m, "ReadHistoryBranch", ctx, request) 1101 ret0, _ := ret[0].(*persistence.InternalReadHistoryBranchResponse) 1102 ret1, _ := ret[1].(error) 1103 return ret0, ret1 1104 } 1105 1106 // ReadHistoryBranch indicates an expected call of ReadHistoryBranch. 1107 func (mr *MockExecutionStoreMockRecorder) ReadHistoryBranch(ctx, request interface{}) *gomock.Call { 1108 mr.mock.ctrl.T.Helper() 1109 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadHistoryBranch", reflect.TypeOf((*MockExecutionStore)(nil).ReadHistoryBranch), ctx, request) 1110 } 1111 1112 // RegisterHistoryTaskReader mocks base method. 1113 func (m *MockExecutionStore) RegisterHistoryTaskReader(ctx context.Context, request *persistence.RegisterHistoryTaskReaderRequest) error { 1114 m.ctrl.T.Helper() 1115 ret := m.ctrl.Call(m, "RegisterHistoryTaskReader", ctx, request) 1116 ret0, _ := ret[0].(error) 1117 return ret0 1118 } 1119 1120 // RegisterHistoryTaskReader indicates an expected call of RegisterHistoryTaskReader. 1121 func (mr *MockExecutionStoreMockRecorder) RegisterHistoryTaskReader(ctx, request interface{}) *gomock.Call { 1122 mr.mock.ctrl.T.Helper() 1123 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterHistoryTaskReader", reflect.TypeOf((*MockExecutionStore)(nil).RegisterHistoryTaskReader), ctx, request) 1124 } 1125 1126 // SetWorkflowExecution mocks base method. 1127 func (m *MockExecutionStore) SetWorkflowExecution(ctx context.Context, request *persistence.InternalSetWorkflowExecutionRequest) error { 1128 m.ctrl.T.Helper() 1129 ret := m.ctrl.Call(m, "SetWorkflowExecution", ctx, request) 1130 ret0, _ := ret[0].(error) 1131 return ret0 1132 } 1133 1134 // SetWorkflowExecution indicates an expected call of SetWorkflowExecution. 1135 func (mr *MockExecutionStoreMockRecorder) SetWorkflowExecution(ctx, request interface{}) *gomock.Call { 1136 mr.mock.ctrl.T.Helper() 1137 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWorkflowExecution", reflect.TypeOf((*MockExecutionStore)(nil).SetWorkflowExecution), ctx, request) 1138 } 1139 1140 // UnregisterHistoryTaskReader mocks base method. 1141 func (m *MockExecutionStore) UnregisterHistoryTaskReader(ctx context.Context, request *persistence.UnregisterHistoryTaskReaderRequest) { 1142 m.ctrl.T.Helper() 1143 m.ctrl.Call(m, "UnregisterHistoryTaskReader", ctx, request) 1144 } 1145 1146 // UnregisterHistoryTaskReader indicates an expected call of UnregisterHistoryTaskReader. 1147 func (mr *MockExecutionStoreMockRecorder) UnregisterHistoryTaskReader(ctx, request interface{}) *gomock.Call { 1148 mr.mock.ctrl.T.Helper() 1149 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnregisterHistoryTaskReader", reflect.TypeOf((*MockExecutionStore)(nil).UnregisterHistoryTaskReader), ctx, request) 1150 } 1151 1152 // UpdateHistoryTaskReaderProgress mocks base method. 1153 func (m *MockExecutionStore) UpdateHistoryTaskReaderProgress(ctx context.Context, request *persistence.UpdateHistoryTaskReaderProgressRequest) { 1154 m.ctrl.T.Helper() 1155 m.ctrl.Call(m, "UpdateHistoryTaskReaderProgress", ctx, request) 1156 } 1157 1158 // UpdateHistoryTaskReaderProgress indicates an expected call of UpdateHistoryTaskReaderProgress. 1159 func (mr *MockExecutionStoreMockRecorder) UpdateHistoryTaskReaderProgress(ctx, request interface{}) *gomock.Call { 1160 mr.mock.ctrl.T.Helper() 1161 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateHistoryTaskReaderProgress", reflect.TypeOf((*MockExecutionStore)(nil).UpdateHistoryTaskReaderProgress), ctx, request) 1162 } 1163 1164 // UpdateWorkflowExecution mocks base method. 1165 func (m *MockExecutionStore) UpdateWorkflowExecution(ctx context.Context, request *persistence.InternalUpdateWorkflowExecutionRequest) error { 1166 m.ctrl.T.Helper() 1167 ret := m.ctrl.Call(m, "UpdateWorkflowExecution", ctx, request) 1168 ret0, _ := ret[0].(error) 1169 return ret0 1170 } 1171 1172 // UpdateWorkflowExecution indicates an expected call of UpdateWorkflowExecution. 1173 func (mr *MockExecutionStoreMockRecorder) UpdateWorkflowExecution(ctx, request interface{}) *gomock.Call { 1174 mr.mock.ctrl.T.Helper() 1175 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkflowExecution", reflect.TypeOf((*MockExecutionStore)(nil).UpdateWorkflowExecution), ctx, request) 1176 } 1177 1178 // MockQueue is a mock of Queue interface. 1179 type MockQueue struct { 1180 ctrl *gomock.Controller 1181 recorder *MockQueueMockRecorder 1182 } 1183 1184 // MockQueueMockRecorder is the mock recorder for MockQueue. 1185 type MockQueueMockRecorder struct { 1186 mock *MockQueue 1187 } 1188 1189 // NewMockQueue creates a new mock instance. 1190 func NewMockQueue(ctrl *gomock.Controller) *MockQueue { 1191 mock := &MockQueue{ctrl: ctrl} 1192 mock.recorder = &MockQueueMockRecorder{mock} 1193 return mock 1194 } 1195 1196 // EXPECT returns an object that allows the caller to indicate expected use. 1197 func (m *MockQueue) EXPECT() *MockQueueMockRecorder { 1198 return m.recorder 1199 } 1200 1201 // Close mocks base method. 1202 func (m *MockQueue) Close() { 1203 m.ctrl.T.Helper() 1204 m.ctrl.Call(m, "Close") 1205 } 1206 1207 // Close indicates an expected call of Close. 1208 func (mr *MockQueueMockRecorder) Close() *gomock.Call { 1209 mr.mock.ctrl.T.Helper() 1210 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockQueue)(nil).Close)) 1211 } 1212 1213 // DeleteMessageFromDLQ mocks base method. 1214 func (m *MockQueue) DeleteMessageFromDLQ(ctx context.Context, messageID int64) error { 1215 m.ctrl.T.Helper() 1216 ret := m.ctrl.Call(m, "DeleteMessageFromDLQ", ctx, messageID) 1217 ret0, _ := ret[0].(error) 1218 return ret0 1219 } 1220 1221 // DeleteMessageFromDLQ indicates an expected call of DeleteMessageFromDLQ. 1222 func (mr *MockQueueMockRecorder) DeleteMessageFromDLQ(ctx, messageID interface{}) *gomock.Call { 1223 mr.mock.ctrl.T.Helper() 1224 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMessageFromDLQ", reflect.TypeOf((*MockQueue)(nil).DeleteMessageFromDLQ), ctx, messageID) 1225 } 1226 1227 // DeleteMessagesBefore mocks base method. 1228 func (m *MockQueue) DeleteMessagesBefore(ctx context.Context, messageID int64) error { 1229 m.ctrl.T.Helper() 1230 ret := m.ctrl.Call(m, "DeleteMessagesBefore", ctx, messageID) 1231 ret0, _ := ret[0].(error) 1232 return ret0 1233 } 1234 1235 // DeleteMessagesBefore indicates an expected call of DeleteMessagesBefore. 1236 func (mr *MockQueueMockRecorder) DeleteMessagesBefore(ctx, messageID interface{}) *gomock.Call { 1237 mr.mock.ctrl.T.Helper() 1238 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMessagesBefore", reflect.TypeOf((*MockQueue)(nil).DeleteMessagesBefore), ctx, messageID) 1239 } 1240 1241 // EnqueueMessage mocks base method. 1242 func (m *MockQueue) EnqueueMessage(ctx context.Context, blob *common.DataBlob) error { 1243 m.ctrl.T.Helper() 1244 ret := m.ctrl.Call(m, "EnqueueMessage", ctx, blob) 1245 ret0, _ := ret[0].(error) 1246 return ret0 1247 } 1248 1249 // EnqueueMessage indicates an expected call of EnqueueMessage. 1250 func (mr *MockQueueMockRecorder) EnqueueMessage(ctx, blob interface{}) *gomock.Call { 1251 mr.mock.ctrl.T.Helper() 1252 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnqueueMessage", reflect.TypeOf((*MockQueue)(nil).EnqueueMessage), ctx, blob) 1253 } 1254 1255 // EnqueueMessageToDLQ mocks base method. 1256 func (m *MockQueue) EnqueueMessageToDLQ(ctx context.Context, blob *common.DataBlob) (int64, error) { 1257 m.ctrl.T.Helper() 1258 ret := m.ctrl.Call(m, "EnqueueMessageToDLQ", ctx, blob) 1259 ret0, _ := ret[0].(int64) 1260 ret1, _ := ret[1].(error) 1261 return ret0, ret1 1262 } 1263 1264 // EnqueueMessageToDLQ indicates an expected call of EnqueueMessageToDLQ. 1265 func (mr *MockQueueMockRecorder) EnqueueMessageToDLQ(ctx, blob interface{}) *gomock.Call { 1266 mr.mock.ctrl.T.Helper() 1267 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnqueueMessageToDLQ", reflect.TypeOf((*MockQueue)(nil).EnqueueMessageToDLQ), ctx, blob) 1268 } 1269 1270 // GetAckLevels mocks base method. 1271 func (m *MockQueue) GetAckLevels(ctx context.Context) (*persistence.InternalQueueMetadata, error) { 1272 m.ctrl.T.Helper() 1273 ret := m.ctrl.Call(m, "GetAckLevels", ctx) 1274 ret0, _ := ret[0].(*persistence.InternalQueueMetadata) 1275 ret1, _ := ret[1].(error) 1276 return ret0, ret1 1277 } 1278 1279 // GetAckLevels indicates an expected call of GetAckLevels. 1280 func (mr *MockQueueMockRecorder) GetAckLevels(ctx interface{}) *gomock.Call { 1281 mr.mock.ctrl.T.Helper() 1282 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAckLevels", reflect.TypeOf((*MockQueue)(nil).GetAckLevels), ctx) 1283 } 1284 1285 // GetDLQAckLevels mocks base method. 1286 func (m *MockQueue) GetDLQAckLevels(ctx context.Context) (*persistence.InternalQueueMetadata, error) { 1287 m.ctrl.T.Helper() 1288 ret := m.ctrl.Call(m, "GetDLQAckLevels", ctx) 1289 ret0, _ := ret[0].(*persistence.InternalQueueMetadata) 1290 ret1, _ := ret[1].(error) 1291 return ret0, ret1 1292 } 1293 1294 // GetDLQAckLevels indicates an expected call of GetDLQAckLevels. 1295 func (mr *MockQueueMockRecorder) GetDLQAckLevels(ctx interface{}) *gomock.Call { 1296 mr.mock.ctrl.T.Helper() 1297 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDLQAckLevels", reflect.TypeOf((*MockQueue)(nil).GetDLQAckLevels), ctx) 1298 } 1299 1300 // Init mocks base method. 1301 func (m *MockQueue) Init(ctx context.Context, blob *common.DataBlob) error { 1302 m.ctrl.T.Helper() 1303 ret := m.ctrl.Call(m, "Init", ctx, blob) 1304 ret0, _ := ret[0].(error) 1305 return ret0 1306 } 1307 1308 // Init indicates an expected call of Init. 1309 func (mr *MockQueueMockRecorder) Init(ctx, blob interface{}) *gomock.Call { 1310 mr.mock.ctrl.T.Helper() 1311 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockQueue)(nil).Init), ctx, blob) 1312 } 1313 1314 // RangeDeleteMessagesFromDLQ mocks base method. 1315 func (m *MockQueue) RangeDeleteMessagesFromDLQ(ctx context.Context, firstMessageID, lastMessageID int64) error { 1316 m.ctrl.T.Helper() 1317 ret := m.ctrl.Call(m, "RangeDeleteMessagesFromDLQ", ctx, firstMessageID, lastMessageID) 1318 ret0, _ := ret[0].(error) 1319 return ret0 1320 } 1321 1322 // RangeDeleteMessagesFromDLQ indicates an expected call of RangeDeleteMessagesFromDLQ. 1323 func (mr *MockQueueMockRecorder) RangeDeleteMessagesFromDLQ(ctx, firstMessageID, lastMessageID interface{}) *gomock.Call { 1324 mr.mock.ctrl.T.Helper() 1325 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RangeDeleteMessagesFromDLQ", reflect.TypeOf((*MockQueue)(nil).RangeDeleteMessagesFromDLQ), ctx, firstMessageID, lastMessageID) 1326 } 1327 1328 // ReadMessages mocks base method. 1329 func (m *MockQueue) ReadMessages(ctx context.Context, lastMessageID int64, maxCount int) ([]*persistence.QueueMessage, error) { 1330 m.ctrl.T.Helper() 1331 ret := m.ctrl.Call(m, "ReadMessages", ctx, lastMessageID, maxCount) 1332 ret0, _ := ret[0].([]*persistence.QueueMessage) 1333 ret1, _ := ret[1].(error) 1334 return ret0, ret1 1335 } 1336 1337 // ReadMessages indicates an expected call of ReadMessages. 1338 func (mr *MockQueueMockRecorder) ReadMessages(ctx, lastMessageID, maxCount interface{}) *gomock.Call { 1339 mr.mock.ctrl.T.Helper() 1340 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadMessages", reflect.TypeOf((*MockQueue)(nil).ReadMessages), ctx, lastMessageID, maxCount) 1341 } 1342 1343 // ReadMessagesFromDLQ mocks base method. 1344 func (m *MockQueue) ReadMessagesFromDLQ(ctx context.Context, firstMessageID, lastMessageID int64, pageSize int, pageToken []byte) ([]*persistence.QueueMessage, []byte, error) { 1345 m.ctrl.T.Helper() 1346 ret := m.ctrl.Call(m, "ReadMessagesFromDLQ", ctx, firstMessageID, lastMessageID, pageSize, pageToken) 1347 ret0, _ := ret[0].([]*persistence.QueueMessage) 1348 ret1, _ := ret[1].([]byte) 1349 ret2, _ := ret[2].(error) 1350 return ret0, ret1, ret2 1351 } 1352 1353 // ReadMessagesFromDLQ indicates an expected call of ReadMessagesFromDLQ. 1354 func (mr *MockQueueMockRecorder) ReadMessagesFromDLQ(ctx, firstMessageID, lastMessageID, pageSize, pageToken interface{}) *gomock.Call { 1355 mr.mock.ctrl.T.Helper() 1356 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadMessagesFromDLQ", reflect.TypeOf((*MockQueue)(nil).ReadMessagesFromDLQ), ctx, firstMessageID, lastMessageID, pageSize, pageToken) 1357 } 1358 1359 // UpdateAckLevel mocks base method. 1360 func (m *MockQueue) UpdateAckLevel(ctx context.Context, metadata *persistence.InternalQueueMetadata) error { 1361 m.ctrl.T.Helper() 1362 ret := m.ctrl.Call(m, "UpdateAckLevel", ctx, metadata) 1363 ret0, _ := ret[0].(error) 1364 return ret0 1365 } 1366 1367 // UpdateAckLevel indicates an expected call of UpdateAckLevel. 1368 func (mr *MockQueueMockRecorder) UpdateAckLevel(ctx, metadata interface{}) *gomock.Call { 1369 mr.mock.ctrl.T.Helper() 1370 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAckLevel", reflect.TypeOf((*MockQueue)(nil).UpdateAckLevel), ctx, metadata) 1371 } 1372 1373 // UpdateDLQAckLevel mocks base method. 1374 func (m *MockQueue) UpdateDLQAckLevel(ctx context.Context, metadata *persistence.InternalQueueMetadata) error { 1375 m.ctrl.T.Helper() 1376 ret := m.ctrl.Call(m, "UpdateDLQAckLevel", ctx, metadata) 1377 ret0, _ := ret[0].(error) 1378 return ret0 1379 } 1380 1381 // UpdateDLQAckLevel indicates an expected call of UpdateDLQAckLevel. 1382 func (mr *MockQueueMockRecorder) UpdateDLQAckLevel(ctx, metadata interface{}) *gomock.Call { 1383 mr.mock.ctrl.T.Helper() 1384 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDLQAckLevel", reflect.TypeOf((*MockQueue)(nil).UpdateDLQAckLevel), ctx, metadata) 1385 } 1386 1387 // MockQueueV2 is a mock of QueueV2 interface. 1388 type MockQueueV2 struct { 1389 ctrl *gomock.Controller 1390 recorder *MockQueueV2MockRecorder 1391 } 1392 1393 // MockQueueV2MockRecorder is the mock recorder for MockQueueV2. 1394 type MockQueueV2MockRecorder struct { 1395 mock *MockQueueV2 1396 } 1397 1398 // NewMockQueueV2 creates a new mock instance. 1399 func NewMockQueueV2(ctrl *gomock.Controller) *MockQueueV2 { 1400 mock := &MockQueueV2{ctrl: ctrl} 1401 mock.recorder = &MockQueueV2MockRecorder{mock} 1402 return mock 1403 } 1404 1405 // EXPECT returns an object that allows the caller to indicate expected use. 1406 func (m *MockQueueV2) EXPECT() *MockQueueV2MockRecorder { 1407 return m.recorder 1408 } 1409 1410 // CreateQueue mocks base method. 1411 func (m *MockQueueV2) CreateQueue(ctx context.Context, request *persistence.InternalCreateQueueRequest) (*persistence.InternalCreateQueueResponse, error) { 1412 m.ctrl.T.Helper() 1413 ret := m.ctrl.Call(m, "CreateQueue", ctx, request) 1414 ret0, _ := ret[0].(*persistence.InternalCreateQueueResponse) 1415 ret1, _ := ret[1].(error) 1416 return ret0, ret1 1417 } 1418 1419 // CreateQueue indicates an expected call of CreateQueue. 1420 func (mr *MockQueueV2MockRecorder) CreateQueue(ctx, request interface{}) *gomock.Call { 1421 mr.mock.ctrl.T.Helper() 1422 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateQueue", reflect.TypeOf((*MockQueueV2)(nil).CreateQueue), ctx, request) 1423 } 1424 1425 // EnqueueMessage mocks base method. 1426 func (m *MockQueueV2) EnqueueMessage(ctx context.Context, request *persistence.InternalEnqueueMessageRequest) (*persistence.InternalEnqueueMessageResponse, error) { 1427 m.ctrl.T.Helper() 1428 ret := m.ctrl.Call(m, "EnqueueMessage", ctx, request) 1429 ret0, _ := ret[0].(*persistence.InternalEnqueueMessageResponse) 1430 ret1, _ := ret[1].(error) 1431 return ret0, ret1 1432 } 1433 1434 // EnqueueMessage indicates an expected call of EnqueueMessage. 1435 func (mr *MockQueueV2MockRecorder) EnqueueMessage(ctx, request interface{}) *gomock.Call { 1436 mr.mock.ctrl.T.Helper() 1437 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnqueueMessage", reflect.TypeOf((*MockQueueV2)(nil).EnqueueMessage), ctx, request) 1438 } 1439 1440 // ListQueues mocks base method. 1441 func (m *MockQueueV2) ListQueues(ctx context.Context, request *persistence.InternalListQueuesRequest) (*persistence.InternalListQueuesResponse, error) { 1442 m.ctrl.T.Helper() 1443 ret := m.ctrl.Call(m, "ListQueues", ctx, request) 1444 ret0, _ := ret[0].(*persistence.InternalListQueuesResponse) 1445 ret1, _ := ret[1].(error) 1446 return ret0, ret1 1447 } 1448 1449 // ListQueues indicates an expected call of ListQueues. 1450 func (mr *MockQueueV2MockRecorder) ListQueues(ctx, request interface{}) *gomock.Call { 1451 mr.mock.ctrl.T.Helper() 1452 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListQueues", reflect.TypeOf((*MockQueueV2)(nil).ListQueues), ctx, request) 1453 } 1454 1455 // RangeDeleteMessages mocks base method. 1456 func (m *MockQueueV2) RangeDeleteMessages(ctx context.Context, request *persistence.InternalRangeDeleteMessagesRequest) (*persistence.InternalRangeDeleteMessagesResponse, error) { 1457 m.ctrl.T.Helper() 1458 ret := m.ctrl.Call(m, "RangeDeleteMessages", ctx, request) 1459 ret0, _ := ret[0].(*persistence.InternalRangeDeleteMessagesResponse) 1460 ret1, _ := ret[1].(error) 1461 return ret0, ret1 1462 } 1463 1464 // RangeDeleteMessages indicates an expected call of RangeDeleteMessages. 1465 func (mr *MockQueueV2MockRecorder) RangeDeleteMessages(ctx, request interface{}) *gomock.Call { 1466 mr.mock.ctrl.T.Helper() 1467 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RangeDeleteMessages", reflect.TypeOf((*MockQueueV2)(nil).RangeDeleteMessages), ctx, request) 1468 } 1469 1470 // ReadMessages mocks base method. 1471 func (m *MockQueueV2) ReadMessages(ctx context.Context, request *persistence.InternalReadMessagesRequest) (*persistence.InternalReadMessagesResponse, error) { 1472 m.ctrl.T.Helper() 1473 ret := m.ctrl.Call(m, "ReadMessages", ctx, request) 1474 ret0, _ := ret[0].(*persistence.InternalReadMessagesResponse) 1475 ret1, _ := ret[1].(error) 1476 return ret0, ret1 1477 } 1478 1479 // ReadMessages indicates an expected call of ReadMessages. 1480 func (mr *MockQueueV2MockRecorder) ReadMessages(ctx, request interface{}) *gomock.Call { 1481 mr.mock.ctrl.T.Helper() 1482 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadMessages", reflect.TypeOf((*MockQueueV2)(nil).ReadMessages), ctx, request) 1483 }