go.temporal.io/server@v1.23.0/common/namespace/transmission_task_handler_test.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 package namespace 26 27 import ( 28 "context" 29 "testing" 30 "time" 31 32 "github.com/golang/mock/gomock" 33 "github.com/stretchr/testify/suite" 34 enumspb "go.temporal.io/api/enums/v1" 35 namespacepb "go.temporal.io/api/namespace/v1" 36 replicationpb "go.temporal.io/api/replication/v1" 37 "google.golang.org/protobuf/types/known/durationpb" 38 39 enumsspb "go.temporal.io/server/api/enums/v1" 40 persistencespb "go.temporal.io/server/api/persistence/v1" 41 replicationspb "go.temporal.io/server/api/replication/v1" 42 "go.temporal.io/server/common/log" 43 "go.temporal.io/server/common/persistence" 44 "go.temporal.io/server/common/primitives" 45 ) 46 47 type ( 48 transmissionTaskSuite struct { 49 suite.Suite 50 51 controller *gomock.Controller 52 53 namespaceReplicator *namespaceReplicatorImpl 54 namespaceReplicationQueue *persistence.MockNamespaceReplicationQueue 55 } 56 ) 57 58 func TestTransmissionTaskSuite(t *testing.T) { 59 s := new(transmissionTaskSuite) 60 suite.Run(t, s) 61 } 62 63 func (s *transmissionTaskSuite) SetupSuite() { 64 } 65 66 func (s *transmissionTaskSuite) TearDownSuite() { 67 68 } 69 70 func (s *transmissionTaskSuite) SetupTest() { 71 s.controller = gomock.NewController(s.T()) 72 s.namespaceReplicationQueue = persistence.NewMockNamespaceReplicationQueue(s.controller) 73 s.namespaceReplicator = NewNamespaceReplicator( 74 s.namespaceReplicationQueue, 75 log.NewTestLogger(), 76 ).(*namespaceReplicatorImpl) 77 } 78 79 func (s *transmissionTaskSuite) TearDownTest() { 80 s.controller.Finish() 81 } 82 83 func (s *transmissionTaskSuite) TestHandleTransmissionTask_RegisterNamespaceTask_IsGlobalNamespace() { 84 taskType := enumsspb.REPLICATION_TASK_TYPE_NAMESPACE_TASK 85 id := primitives.NewUUID().String() 86 name := "some random namespace test name" 87 state := enumspb.NAMESPACE_STATE_REGISTERED 88 description := "some random test description" 89 ownerEmail := "some random test owner" 90 data := map[string]string{"k": "v"} 91 retention := 10 * time.Hour * 24 92 historyArchivalState := enumspb.ARCHIVAL_STATE_ENABLED 93 historyArchivalURI := "some random history archival uri" 94 visibilityArchivalState := enumspb.ARCHIVAL_STATE_ENABLED 95 visibilityArchivalURI := "some random visibility archival uri" 96 clusterActive := "some random active cluster name" 97 clusterStandby := "some random standby cluster name" 98 configVersion := int64(0) 99 failoverVersion := int64(59) 100 clusters := []string{clusterActive, clusterStandby} 101 102 namespaceOperation := enumsspb.NAMESPACE_OPERATION_CREATE 103 info := &persistencespb.NamespaceInfo{ 104 Id: id, 105 Name: name, 106 State: enumspb.NAMESPACE_STATE_REGISTERED, 107 Description: description, 108 Owner: ownerEmail, 109 Data: data, 110 } 111 config := &persistencespb.NamespaceConfig{ 112 Retention: durationpb.New(retention), 113 HistoryArchivalState: historyArchivalState, 114 HistoryArchivalUri: historyArchivalURI, 115 VisibilityArchivalState: visibilityArchivalState, 116 VisibilityArchivalUri: visibilityArchivalURI, 117 BadBinaries: &namespacepb.BadBinaries{Binaries: map[string]*namespacepb.BadBinaryInfo{}}, 118 } 119 replicationConfig := &persistencespb.NamespaceReplicationConfig{ 120 ActiveClusterName: clusterActive, 121 Clusters: clusters, 122 } 123 isGlobalNamespace := true 124 125 s.namespaceReplicationQueue.EXPECT().Publish(gomock.Any(), &replicationspb.ReplicationTask{ 126 TaskType: taskType, 127 Attributes: &replicationspb.ReplicationTask_NamespaceTaskAttributes{ 128 NamespaceTaskAttributes: &replicationspb.NamespaceTaskAttributes{ 129 NamespaceOperation: namespaceOperation, 130 Id: id, 131 Info: &namespacepb.NamespaceInfo{ 132 Name: name, 133 State: state, 134 Description: description, 135 OwnerEmail: ownerEmail, 136 Data: data, 137 }, 138 Config: &namespacepb.NamespaceConfig{ 139 WorkflowExecutionRetentionTtl: durationpb.New(retention), 140 HistoryArchivalState: historyArchivalState, 141 HistoryArchivalUri: historyArchivalURI, 142 VisibilityArchivalState: visibilityArchivalState, 143 VisibilityArchivalUri: visibilityArchivalURI, 144 BadBinaries: &namespacepb.BadBinaries{Binaries: map[string]*namespacepb.BadBinaryInfo{}}, 145 }, 146 ReplicationConfig: &replicationpb.NamespaceReplicationConfig{ 147 ActiveClusterName: clusterActive, 148 Clusters: convertClusterReplicationConfigToProto(clusters), 149 }, 150 ConfigVersion: configVersion, 151 FailoverVersion: failoverVersion, 152 }, 153 }, 154 }).Return(nil) 155 156 err := s.namespaceReplicator.HandleTransmissionTask( 157 context.Background(), 158 namespaceOperation, 159 info, 160 config, 161 replicationConfig, 162 true, 163 configVersion, 164 failoverVersion, 165 isGlobalNamespace, 166 nil, 167 ) 168 s.Nil(err) 169 } 170 171 func (s *transmissionTaskSuite) TestHandleTransmissionTask_RegisterNamespaceTask_NotGlobalNamespace() { 172 id := primitives.NewUUID().String() 173 name := "some random namespace test name" 174 description := "some random test description" 175 ownerEmail := "some random test owner" 176 data := map[string]string{"k": "v"} 177 retention := 10 * time.Hour * 24 178 historyArchivalState := enumspb.ARCHIVAL_STATE_ENABLED 179 historyArchivalURI := "some random history archival uri" 180 visibilityArchivalState := enumspb.ARCHIVAL_STATE_ENABLED 181 visibilityArchivalURI := "some random visibility archival uri" 182 clusterActive := "some random active cluster name" 183 clusterStandby := "some random standby cluster name" 184 configVersion := int64(0) 185 failoverVersion := int64(59) 186 clusters := []string{clusterActive, clusterStandby} 187 188 namespaceOperation := enumsspb.NAMESPACE_OPERATION_CREATE 189 info := &persistencespb.NamespaceInfo{ 190 Id: id, 191 Name: name, 192 State: enumspb.NAMESPACE_STATE_REGISTERED, 193 Description: description, 194 Owner: ownerEmail, 195 Data: data, 196 } 197 config := &persistencespb.NamespaceConfig{ 198 Retention: durationpb.New(retention), 199 HistoryArchivalState: historyArchivalState, 200 HistoryArchivalUri: historyArchivalURI, 201 VisibilityArchivalState: visibilityArchivalState, 202 VisibilityArchivalUri: visibilityArchivalURI, 203 BadBinaries: &namespacepb.BadBinaries{}, 204 } 205 replicationConfig := &persistencespb.NamespaceReplicationConfig{ 206 ActiveClusterName: clusterActive, 207 Clusters: clusters, 208 } 209 isGlobalNamespace := false 210 211 err := s.namespaceReplicator.HandleTransmissionTask( 212 context.Background(), 213 namespaceOperation, 214 info, 215 config, 216 replicationConfig, 217 true, 218 configVersion, 219 failoverVersion, 220 isGlobalNamespace, 221 nil, 222 ) 223 s.Nil(err) 224 } 225 226 func (s *transmissionTaskSuite) TestHandleTransmissionTask_UpdateNamespaceTask_IsGlobalNamespace() { 227 taskType := enumsspb.REPLICATION_TASK_TYPE_NAMESPACE_TASK 228 id := primitives.NewUUID().String() 229 name := "some random namespace test name" 230 state := enumspb.NAMESPACE_STATE_DEPRECATED 231 description := "some random test description" 232 ownerEmail := "some random test owner" 233 data := map[string]string{"k": "v"} 234 retention := 10 * time.Hour * 24 235 historyArchivalState := enumspb.ARCHIVAL_STATE_ENABLED 236 historyArchivalURI := "some random history archival uri" 237 visibilityArchivalState := enumspb.ARCHIVAL_STATE_ENABLED 238 visibilityArchivalURI := "some random visibility archival uri" 239 clusterActive := "some random active cluster name" 240 clusterStandby := "some random standby cluster name" 241 configVersion := int64(0) 242 failoverVersion := int64(59) 243 clusters := []string{clusterActive, clusterStandby} 244 245 namespaceOperation := enumsspb.NAMESPACE_OPERATION_UPDATE 246 info := &persistencespb.NamespaceInfo{ 247 Id: id, 248 Name: name, 249 State: enumspb.NAMESPACE_STATE_DEPRECATED, 250 Description: description, 251 Owner: ownerEmail, 252 Data: data, 253 } 254 config := &persistencespb.NamespaceConfig{ 255 Retention: durationpb.New(retention), 256 HistoryArchivalState: historyArchivalState, 257 HistoryArchivalUri: historyArchivalURI, 258 VisibilityArchivalState: visibilityArchivalState, 259 VisibilityArchivalUri: visibilityArchivalURI, 260 BadBinaries: &namespacepb.BadBinaries{Binaries: map[string]*namespacepb.BadBinaryInfo{}}, 261 } 262 replicationConfig := &persistencespb.NamespaceReplicationConfig{ 263 ActiveClusterName: clusterActive, 264 Clusters: clusters, 265 } 266 isGlobalNamespace := true 267 268 s.namespaceReplicationQueue.EXPECT().Publish(gomock.Any(), &replicationspb.ReplicationTask{ 269 TaskType: taskType, 270 Attributes: &replicationspb.ReplicationTask_NamespaceTaskAttributes{ 271 NamespaceTaskAttributes: &replicationspb.NamespaceTaskAttributes{ 272 NamespaceOperation: namespaceOperation, 273 Id: id, 274 Info: &namespacepb.NamespaceInfo{ 275 Name: name, 276 State: state, 277 Description: description, 278 OwnerEmail: ownerEmail, 279 Data: data, 280 }, 281 Config: &namespacepb.NamespaceConfig{ 282 WorkflowExecutionRetentionTtl: durationpb.New(retention), 283 HistoryArchivalState: historyArchivalState, 284 HistoryArchivalUri: historyArchivalURI, 285 VisibilityArchivalState: visibilityArchivalState, 286 VisibilityArchivalUri: visibilityArchivalURI, 287 BadBinaries: &namespacepb.BadBinaries{Binaries: map[string]*namespacepb.BadBinaryInfo{}}, 288 }, 289 ReplicationConfig: &replicationpb.NamespaceReplicationConfig{ 290 ActiveClusterName: clusterActive, 291 Clusters: convertClusterReplicationConfigToProto(clusters), 292 }, 293 ConfigVersion: configVersion, 294 FailoverVersion: failoverVersion}, 295 }, 296 }).Return(nil) 297 298 err := s.namespaceReplicator.HandleTransmissionTask( 299 context.Background(), 300 namespaceOperation, 301 info, 302 config, 303 replicationConfig, 304 true, 305 configVersion, 306 failoverVersion, 307 isGlobalNamespace, 308 nil, 309 ) 310 s.Nil(err) 311 } 312 313 func (s *transmissionTaskSuite) TestHandleTransmissionTask_UpdateNamespaceTask_NotGlobalNamespace() { 314 id := primitives.NewUUID().String() 315 name := "some random namespace test name" 316 description := "some random test description" 317 ownerEmail := "some random test owner" 318 data := map[string]string{"k": "v"} 319 retention := 10 * time.Hour * 24 320 historyArchivalState := enumspb.ARCHIVAL_STATE_ENABLED 321 historyArchivalURI := "some random history archival uri" 322 visibilityArchivalState := enumspb.ARCHIVAL_STATE_ENABLED 323 visibilityArchivalURI := "some random visibility archival uri" 324 clusterActive := "some random active cluster name" 325 clusterStandby := "some random standby cluster name" 326 configVersion := int64(0) 327 failoverVersion := int64(59) 328 clusters := []string{clusterActive, clusterStandby} 329 330 namespaceOperation := enumsspb.NAMESPACE_OPERATION_UPDATE 331 info := &persistencespb.NamespaceInfo{ 332 Id: id, 333 Name: name, 334 State: enumspb.NAMESPACE_STATE_DEPRECATED, 335 Description: description, 336 Owner: ownerEmail, 337 Data: data, 338 } 339 config := &persistencespb.NamespaceConfig{ 340 Retention: durationpb.New(retention), 341 HistoryArchivalState: historyArchivalState, 342 HistoryArchivalUri: historyArchivalURI, 343 VisibilityArchivalState: visibilityArchivalState, 344 VisibilityArchivalUri: visibilityArchivalURI, 345 } 346 replicationConfig := &persistencespb.NamespaceReplicationConfig{ 347 ActiveClusterName: clusterActive, 348 Clusters: clusters, 349 } 350 isGlobalNamespace := false 351 352 err := s.namespaceReplicator.HandleTransmissionTask( 353 context.Background(), 354 namespaceOperation, 355 info, 356 config, 357 replicationConfig, 358 true, 359 configVersion, 360 failoverVersion, 361 isGlobalNamespace, 362 nil, 363 ) 364 s.Nil(err) 365 } 366 367 func (s *transmissionTaskSuite) TestHandleTransmissionTask_UpdateNamespaceTask_ReplicationClusterListUpdated() { 368 taskType := enumsspb.REPLICATION_TASK_TYPE_NAMESPACE_TASK 369 id := primitives.NewUUID().String() 370 name := "some random namespace test name" 371 state := enumspb.NAMESPACE_STATE_DEPRECATED 372 description := "some random test description" 373 ownerEmail := "some random test owner" 374 data := map[string]string{"k": "v"} 375 retention := 10 * time.Hour * 24 376 historyArchivalState := enumspb.ARCHIVAL_STATE_ENABLED 377 historyArchivalURI := "some random history archival uri" 378 visibilityArchivalState := enumspb.ARCHIVAL_STATE_ENABLED 379 visibilityArchivalURI := "some random visibility archival uri" 380 clusterActive := "some random active cluster name" 381 configVersion := int64(0) 382 failoverVersion := int64(59) 383 singleClusterList := []string{clusterActive} 384 385 namespaceOperation := enumsspb.NAMESPACE_OPERATION_UPDATE 386 info := &persistencespb.NamespaceInfo{ 387 Id: id, 388 Name: name, 389 State: enumspb.NAMESPACE_STATE_DEPRECATED, 390 Description: description, 391 Owner: ownerEmail, 392 Data: data, 393 } 394 config := &persistencespb.NamespaceConfig{ 395 Retention: durationpb.New(retention), 396 HistoryArchivalState: historyArchivalState, 397 HistoryArchivalUri: historyArchivalURI, 398 VisibilityArchivalState: visibilityArchivalState, 399 VisibilityArchivalUri: visibilityArchivalURI, 400 BadBinaries: &namespacepb.BadBinaries{Binaries: map[string]*namespacepb.BadBinaryInfo{}}, 401 } 402 replicationConfig := &persistencespb.NamespaceReplicationConfig{ 403 ActiveClusterName: clusterActive, 404 Clusters: singleClusterList, 405 } 406 407 isGlobalNamespace := true 408 409 s.namespaceReplicationQueue.EXPECT().Publish(gomock.Any(), &replicationspb.ReplicationTask{ 410 TaskType: taskType, 411 Attributes: &replicationspb.ReplicationTask_NamespaceTaskAttributes{ 412 NamespaceTaskAttributes: &replicationspb.NamespaceTaskAttributes{ 413 NamespaceOperation: namespaceOperation, 414 Id: id, 415 Info: &namespacepb.NamespaceInfo{ 416 Name: name, 417 State: state, 418 Description: description, 419 OwnerEmail: ownerEmail, 420 Data: data, 421 }, 422 Config: &namespacepb.NamespaceConfig{ 423 WorkflowExecutionRetentionTtl: durationpb.New(retention), 424 HistoryArchivalState: historyArchivalState, 425 HistoryArchivalUri: historyArchivalURI, 426 VisibilityArchivalState: visibilityArchivalState, 427 VisibilityArchivalUri: visibilityArchivalURI, 428 BadBinaries: &namespacepb.BadBinaries{Binaries: map[string]*namespacepb.BadBinaryInfo{}}, 429 }, 430 ReplicationConfig: &replicationpb.NamespaceReplicationConfig{ 431 ActiveClusterName: clusterActive, 432 Clusters: convertClusterReplicationConfigToProto(singleClusterList), 433 }, 434 ConfigVersion: configVersion, 435 FailoverVersion: failoverVersion}, 436 }, 437 }).Return(nil).Times(1) 438 439 err := s.namespaceReplicator.HandleTransmissionTask( 440 context.Background(), 441 namespaceOperation, 442 info, 443 config, 444 replicationConfig, 445 true, 446 configVersion, 447 failoverVersion, 448 isGlobalNamespace, 449 nil, 450 ) 451 s.Nil(err) 452 453 err = s.namespaceReplicator.HandleTransmissionTask( 454 context.Background(), 455 namespaceOperation, 456 info, 457 config, 458 replicationConfig, 459 false, 460 configVersion, 461 failoverVersion, 462 isGlobalNamespace, 463 nil, 464 ) 465 s.Nil(err) 466 }