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  }