Vihren Atlas

store_mock.go ×33

Code frontier

unlabeled · c_6262aab4fa1b

36 tests · 2651 LOC · 111 files · introduces 0 tests · 149 LOC · 1 file

Introduces — evidence that enters the hierarchy at this concept

Code
33 ranges149 lines · 1 files
Tests
0 tests

Contains — complete concept membership

All code (extent)
436 ranges2651 lines · 111 files · Browse complete extent
All tests (intent)
36 testsBrowse complete intent

Neighbourhood graph

The orange circle is the focus. Violet and green circles are every ancestor and descendant, broader and narrower, at any distance; blue squares and pink diamonds are the introduced files and exact introduced tests of every visible concept, not only the focus's. Arrows point from broader to narrower concepts and bridge only concepts omitted from this view. Undirected links show source or test introduction. Concept and file size follows LOC; exact test nodes use test-count units.

Introduced files, introduced tests, and structurally relevant concept specialization

In the embedded map, ordinary wheel input scrolls the page; use the visible controls to zoom and drag to pan. Open the full-screen map for canvas navigation: wheel pans, Ctrl/Command plus wheel zooms, and arrow keys pan when this region is focused. On touch screens, open the full-screen map to pan or pinch. If JavaScript or WebGL is unavailable, use the native relationship evidence on this page.

Graph controls are ready.

Interactive rendering requires JavaScript and WebGL. Use the native relationship evidence on this page while the interactive map is unavailable.

Native relationship evidence

Every exact file and test below is linked only from the concept that introduces it.

Introduced tests

Every collected test enters the hierarchy at exactly one concept.

No tests are introduced at this concept. Its intent tests are introduced by other concepts.

Introduced code

Every collected source range enters the hierarchy at exactly one concept.

1 file ranked by introduced lines: 149 introduced LOC across 33 ranges. Expand a file to inspect source; the > gutter marks introduced lines.

go.temporal.io/server/common/persistence/mock/store_mock.go 149 introduced LOC · 33 ranges

Open complete file

56
57 // NewClusterMetadataStore mocks base method.
58 > func (m *MockDataStoreFactory) NewClusterMetadataStore() (persistence.ClusterMetadataStore, error) { store_mock.go
59 > m.ctrl.T.Helper()
60 > ret := m.ctrl.Call(m, "NewClusterMetadataStore")
61 > ret0, _ := ret[0].(persistence.ClusterMetadataStore)
62 > ret1, _ := ret[1].(error)
63 > return ret0, ret1
64 > }
65
66 // NewClusterMetadataStore indicates an expected call of NewClusterMetadataStore.
67 > func (mr *MockDataStoreFactoryMockRecorder) NewClusterMetadataStore() *gomock.Call { store_mock.go
68 > mr.mock.ctrl.T.Helper()
69 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewClusterMetadataStore", reflect.TypeOf((*MockDataStoreFactory)(nil).NewClusterMetadataStore))
70 > }
71
72 // NewExecutionStore mocks base method.
101
102 // NewMetadataStore mocks base method.
103 > func (m *MockDataStoreFactory) NewMetadataStore() (persistence.MetadataStore, error) { store_mock.go
104 > m.ctrl.T.Helper()
105 > ret := m.ctrl.Call(m, "NewMetadataStore")
106 > ret0, _ := ret[0].(persistence.MetadataStore)
107 > ret1, _ := ret[1].(error)
108 > return ret0, ret1
109 > }
110
111 // NewMetadataStore indicates an expected call of NewMetadataStore.
112 > func (mr *MockDataStoreFactoryMockRecorder) NewMetadataStore() *gomock.Call { store_mock.go
113 > mr.mock.ctrl.T.Helper()
114 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewMetadataStore", reflect.TypeOf((*MockDataStoreFactory)(nil).NewMetadataStore))
115 > }
116
117 // NewNexusEndpointStore mocks base method.
118 > func (m *MockDataStoreFactory) NewNexusEndpointStore() (persistence.NexusEndpointStore, error) { store_mock.go
119 > m.ctrl.T.Helper()
120 > ret := m.ctrl.Call(m, "NewNexusEndpointStore")
121 > ret0, _ := ret[0].(persistence.NexusEndpointStore)
122 > ret1, _ := ret[1].(error)
123 > return ret0, ret1
124 > }
125
126 // NewNexusEndpointStore indicates an expected call of NewNexusEndpointStore.
127 > func (mr *MockDataStoreFactoryMockRecorder) NewNexusEndpointStore() *gomock.Call { store_mock.go
128 > mr.mock.ctrl.T.Helper()
129 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewNexusEndpointStore", reflect.TypeOf((*MockDataStoreFactory)(nil).NewNexusEndpointStore))
130 > }
131
132 // NewQueue mocks base method.
133 > func (m *MockDataStoreFactory) NewQueue(queueType persistence.QueueType) (persistence.Queue, error) { store_mock.go
134 > m.ctrl.T.Helper()
135 > ret := m.ctrl.Call(m, "NewQueue", queueType)
136 > ret0, _ := ret[0].(persistence.Queue)
137 > ret1, _ := ret[1].(error)
138 > return ret0, ret1
139 > }
140
141 // NewQueue indicates an expected call of NewQueue.
142 > func (mr *MockDataStoreFactoryMockRecorder) NewQueue(queueType any) *gomock.Call { store_mock.go
143 > mr.mock.ctrl.T.Helper()
144 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewQueue", reflect.TypeOf((*MockDataStoreFactory)(nil).NewQueue), queueType)
145 > }
146
147 // NewQueueV2 mocks base method.
161
162 // NewShardStore mocks base method.
163 > func (m *MockDataStoreFactory) NewShardStore() (persistence.ShardStore, error) { store_mock.go
164 > m.ctrl.T.Helper()
165 > ret := m.ctrl.Call(m, "NewShardStore")
166 > ret0, _ := ret[0].(persistence.ShardStore)
167 > ret1, _ := ret[1].(error)
168 > return ret0, ret1
169 > }
170
171 // NewShardStore indicates an expected call of NewShardStore.
172 > func (mr *MockDataStoreFactoryMockRecorder) NewShardStore() *gomock.Call { store_mock.go
173 > mr.mock.ctrl.T.Helper()
174 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewShardStore", reflect.TypeOf((*MockDataStoreFactory)(nil).NewShardStore))
175 > }
176
177 // NewTaskStore mocks base method.
185
186 // NewTaskStore indicates an expected call of NewTaskStore.
187 > func (mr *MockDataStoreFactoryMockRecorder) NewTaskStore() *gomock.Call { store_mock.go
188 > mr.mock.ctrl.T.Helper()
189 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewTaskStore", reflect.TypeOf((*MockDataStoreFactory)(nil).NewTaskStore))
190 > }
191
192 // MockShardStore is a mock of ShardStore interface.
203
204 // NewMockShardStore creates a new mock instance.
205 > func NewMockShardStore(ctrl *gomock.Controller) *MockShardStore { store_mock.go
206 > mock := &MockShardStore{ctrl: ctrl}
207 > mock.recorder = &MockShardStoreMockRecorder{mock}
208 > return mock
209 > }
210
211 // EXPECT returns an object that allows the caller to indicate expected use.
212 > func (m *MockShardStore) EXPECT() *MockShardStoreMockRecorder { store_mock.go
213 > return m.recorder
214 > }
215
216 // AssertShardOwnership mocks base method.
223
224 // AssertShardOwnership indicates an expected call of AssertShardOwnership.
225 > func (mr *MockShardStoreMockRecorder) AssertShardOwnership(ctx, request any) *gomock.Call { store_mock.go
226 > mr.mock.ctrl.T.Helper()
227 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssertShardOwnership", reflect.TypeOf((*MockShardStore)(nil).AssertShardOwnership), ctx, request)
228 > }
229
230 // Close mocks base method.
310
311 // NewMockTaskStore creates a new mock instance.
312 > func NewMockTaskStore(ctrl *gomock.Controller) *MockTaskStore { store_mock.go
313 > mock := &MockTaskStore{ctrl: ctrl}
314 > mock.recorder = &MockTaskStoreMockRecorder{mock}
315 > return mock
316 > }
317
318 // EXPECT returns an object that allows the caller to indicate expected use.
319 > func (m *MockTaskStore) EXPECT() *MockTaskStoreMockRecorder { store_mock.go
320 > return m.recorder
321 > }
322
323 // Close mocks base method.
475
476 // GetTasks indicates an expected call of GetTasks.
477 > func (mr *MockTaskStoreMockRecorder) GetTasks(ctx, request any) *gomock.Call { store_mock.go
478 > mr.mock.ctrl.T.Helper()
479 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTasks", reflect.TypeOf((*MockTaskStore)(nil).GetTasks), ctx, request)
480 > }
481
482 // ListTaskQueue mocks base method.
552
553 // NewMockMetadataStore creates a new mock instance.
554 > func NewMockMetadataStore(ctrl *gomock.Controller) *MockMetadataStore { store_mock.go
555 > mock := &MockMetadataStore{ctrl: ctrl}
556 > mock.recorder = &MockMetadataStoreMockRecorder{mock}
557 > return mock
558 > }
559
560 // EXPECT returns an object that allows the caller to indicate expected use.
561 > func (m *MockMetadataStore) EXPECT() *MockMetadataStoreMockRecorder { store_mock.go
562 > return m.recorder
563 > }
564
565 // Close mocks base method.
599
600 // DeleteNamespace indicates an expected call of DeleteNamespace.
601 > func (mr *MockMetadataStoreMockRecorder) DeleteNamespace(ctx, request any) *gomock.Call { store_mock.go
602 > mr.mock.ctrl.T.Helper()
603 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNamespace", reflect.TypeOf((*MockMetadataStore)(nil).DeleteNamespace), ctx, request)
604 > }
605
606 // DeleteNamespaceByName mocks base method.
657
658 // GetNamespace indicates an expected call of GetNamespace.
659 > func (mr *MockMetadataStoreMockRecorder) GetNamespace(ctx, request any) *gomock.Call { store_mock.go
660 > mr.mock.ctrl.T.Helper()
661 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNamespace", reflect.TypeOf((*MockMetadataStore)(nil).GetNamespace), ctx, request)
662 > }
663
664 // ListNamespaces mocks base method.
718
719 // NewMockClusterMetadataStore creates a new mock instance.
720 > func NewMockClusterMetadataStore(ctrl *gomock.Controller) *MockClusterMetadataStore { store_mock.go
721 > mock := &MockClusterMetadataStore{ctrl: ctrl}
722 > mock.recorder = &MockClusterMetadataStoreMockRecorder{mock}
723 > return mock
724 > }
725
726 // EXPECT returns an object that allows the caller to indicate expected use.
727 > func (m *MockClusterMetadataStore) EXPECT() *MockClusterMetadataStoreMockRecorder { store_mock.go
728 > return m.recorder
729 > }
730
731 // Close mocks base method.
750
751 // DeleteClusterMetadata indicates an expected call of DeleteClusterMetadata.
752 > func (mr *MockClusterMetadataStoreMockRecorder) DeleteClusterMetadata(ctx, request any) *gomock.Call { store_mock.go
753 > mr.mock.ctrl.T.Helper()
754 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteClusterMetadata", reflect.TypeOf((*MockClusterMetadataStore)(nil).DeleteClusterMetadata), ctx, request)
755 > }
756
757 // GetClusterMembers mocks base method.
780
781 // GetClusterMetadata indicates an expected call of GetClusterMetadata.
782 > func (mr *MockClusterMetadataStoreMockRecorder) GetClusterMetadata(ctx, request any) *gomock.Call { store_mock.go
783 > mr.mock.ctrl.T.Helper()
784 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterMetadata", reflect.TypeOf((*MockClusterMetadataStore)(nil).GetClusterMetadata), ctx, request)
785 > }
786
787 // GetName mocks base method.
1029
1030 // DeleteWorkflowExecution indicates an expected call of DeleteWorkflowExecution.
1031 > func (mr *MockExecutionStoreMockRecorder) DeleteWorkflowExecution(ctx, request any) *gomock.Call { store_mock.go
1032 > mr.mock.ctrl.T.Helper()
1033 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteWorkflowExecution", reflect.TypeOf((*MockExecutionStore)(nil).DeleteWorkflowExecution), ctx, request)
1034 > }
1035
1036 // ForkHistoryBranch mocks base method.
1326
1327 // DeleteMessageFromDLQ indicates an expected call of DeleteMessageFromDLQ.
1328 > func (mr *MockQueueMockRecorder) DeleteMessageFromDLQ(ctx, messageID any) *gomock.Call { store_mock.go
1329 > mr.mock.ctrl.T.Helper()
1330 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMessageFromDLQ", reflect.TypeOf((*MockQueue)(nil).DeleteMessageFromDLQ), ctx, messageID)
1331 > }
1332
1333 // DeleteMessagesBefore mocks base method.
1405
1406 // Init mocks base method.
1407 > func (m *MockQueue) Init(ctx context.Context, blob *common.DataBlob) error { store_mock.go
1408 > m.ctrl.T.Helper()
1409 > ret := m.ctrl.Call(m, "Init", ctx, blob)
1410 > ret0, _ := ret[0].(error)
1411 > return ret0
1412 > }
1413
1414 // Init indicates an expected call of Init.
1415 > func (mr *MockQueueMockRecorder) Init(ctx, blob any) *gomock.Call { store_mock.go
1416 > mr.mock.ctrl.T.Helper()
1417 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockQueue)(nil).Init), ctx, blob)
1418 > }
1419
1420 // RangeDeleteMessagesFromDLQ mocks base method.
1504
1505 // NewMockNexusEndpointStore creates a new mock instance.
1506 > func NewMockNexusEndpointStore(ctrl *gomock.Controller) *MockNexusEndpointStore { store_mock.go
1507 > mock := &MockNexusEndpointStore{ctrl: ctrl}
1508 > mock.recorder = &MockNexusEndpointStoreMockRecorder{mock}
1509 > return mock
1510 > }
1511
1512 // EXPECT returns an object that allows the caller to indicate expected use.
1513 > func (m *MockNexusEndpointStore) EXPECT() *MockNexusEndpointStoreMockRecorder { store_mock.go
1514 > return m.recorder
1515 > }
1516
1517 // Close mocks base method.
1550
1551 // DeleteNexusEndpoint indicates an expected call of DeleteNexusEndpoint.
1552 > func (mr *MockNexusEndpointStoreMockRecorder) DeleteNexusEndpoint(ctx, request any) *gomock.Call { store_mock.go
1553 > mr.mock.ctrl.T.Helper()
1554 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNexusEndpoint", reflect.TypeOf((*MockNexusEndpointStore)(nil).DeleteNexusEndpoint), ctx, request)
1555 > }
1556
1557 // GetName mocks base method.
1594
1595 // ListNexusEndpoints indicates an expected call of ListNexusEndpoints.
1596 > func (mr *MockNexusEndpointStoreMockRecorder) ListNexusEndpoints(ctx, request any) *gomock.Call { store_mock.go
1597 > mr.mock.ctrl.T.Helper()
1598 > return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListNexusEndpoints", reflect.TypeOf((*MockNexusEndpointStore)(nil).ListNexusEndpoints), ctx, request)
1599 > }
1600
1601 // MockQueueV2 is a mock of QueueV2 interface.

Direct hierarchy

Parents

Children