diff --git a/common/authorization/default_authorizer_test.go b/common/authorization/default_authorizer_test.go index 344accf3b9e..0316688c677 100644 --- a/common/authorization/default_authorizer_test.go +++ b/common/authorization/default_authorizer_test.go @@ -173,7 +173,7 @@ func (s *defaultAuthorizerSuite) testGetAuthorizerFromConfig(name string, valid s.NoError(err) s.NotNil(auth) t := reflect.TypeOf(auth) - s.True(t == authorizerType) + s.Equal(t, authorizerType) } else { s.Error(err) s.Nil(auth) diff --git a/common/authorization/default_jwt_claim_mapper_test.go b/common/authorization/default_jwt_claim_mapper_test.go index 2c683c65fa1..34dcfdd944f 100644 --- a/common/authorization/default_jwt_claim_mapper_test.go +++ b/common/authorization/default_jwt_claim_mapper_test.go @@ -134,7 +134,7 @@ func (s *defaultClaimMapperSuite) testTokenWithAdminPermissions(alg keyAlgorithm s.NoError(err) s.Equal(testSubject, claims.Subject) s.Equal(RoleAdmin, claims.System) - s.Equal(1, len(claims.Namespaces)) + s.Len(claims.Namespaces, 1) defaultRole := claims.Namespaces[defaultNamespace] s.Equal(RoleReader, defaultRole) } @@ -154,7 +154,7 @@ func (s *defaultClaimMapperSuite) TestNamespacePermissionCaseSensitive() { s.NoError(err) s.Equal(testSubject, claims.Subject) s.Equal(RoleUndefined, claims.System) // no system role - s.Equal(2, len(claims.Namespaces)) + s.Len(claims.Namespaces, 2) // claims contain namespace role for 'Foo', not for 'foo'. s.Equal(RoleReader, claims.Namespaces["Foo"]) s.Equal(RoleAdmin, claims.Namespaces["Temporal-system"]) @@ -181,7 +181,7 @@ func (s *defaultClaimMapperSuite) testTokenWithReaderWriterWorkerPermissions(alg s.NoError(err) s.Equal(testSubject, claims.Subject) s.Equal(RoleUndefined, claims.System) - s.Equal(1, len(claims.Namespaces)) + s.Len(claims.Namespaces, 1) defaultRole := claims.Namespaces[defaultNamespace] s.Equal(RoleReader|RoleWriter|RoleWorker, defaultRole) } @@ -198,7 +198,7 @@ func (s *defaultClaimMapperSuite) TestTokenWithReaderWriterWorkerPermissionsRege s.NoError(err) s.Equal(testSubject, claims.Subject) s.Equal(RoleUndefined, claims.System) - s.Equal(1, len(claims.Namespaces)) + s.Len(claims.Namespaces, 1) defaultRole := claims.Namespaces[defaultNamespace] s.Equal(RoleReader|RoleWriter|RoleWorker, defaultRole) } @@ -258,7 +258,7 @@ func (s *defaultClaimMapperSuite) TestTokenWithAdminPermissionsRegex() { s.NoError(err) s.Equal(testSubject, claims.Subject) s.Equal(RoleAdmin, claims.System) - s.Equal(1, len(claims.Namespaces)) + s.Len(claims.Namespaces, 1) defaultRole := claims.Namespaces[defaultNamespace] s.Equal(RoleReader, defaultRole) } @@ -314,7 +314,7 @@ func (s *defaultClaimMapperSuite) testGetClaimMapperFromConfig(name string, vali s.NoError(err) s.NotNil(cm) t := reflect.TypeOf(cm) - s.True(t == cmType) + s.Equal(t, cmType) } else { s.Error(err) s.Nil(cm) diff --git a/common/backoff/jitter_test.go b/common/backoff/jitter_test.go index 9b3f5bf62fd..0ea669de03d 100644 --- a/common/backoff/jitter_test.go +++ b/common/backoff/jitter_test.go @@ -30,12 +30,12 @@ func (s *jitterSuite) TestJitter_Int64() { for range 1048576 { result := Jitter(input, coefficient) - s.True(result >= lowerBound) - s.True(result < upperBound) + s.GreaterOrEqual(result, lowerBound) + s.Less(result, upperBound) result = FullJitter(input) - s.True(result >= 0) - s.True(result < input) + s.GreaterOrEqual(result, int64(0)) + s.Less(result, input) } } @@ -47,12 +47,12 @@ func (s *jitterSuite) TestJitter_Float64() { for range 1048576 { result := Jitter(input, coefficient) - s.True(result >= lowerBound) - s.True(result < upperBound) + s.GreaterOrEqual(result, lowerBound) + s.Less(result, upperBound) result = FullJitter(input) - s.True(result >= 0) - s.True(result < input) + s.GreaterOrEqual(result, float64(0)) + s.Less(result, input) } } @@ -64,12 +64,12 @@ func (s *jitterSuite) TestJitter_Duration() { for range 1048576 { result := Jitter(input, coefficient) - s.True(result >= lowerBound) - s.True(result < upperBound) + s.GreaterOrEqual(result, lowerBound) + s.Less(result, upperBound) result = FullJitter(input) - s.True(result >= 0) - s.True(result < input) + s.GreaterOrEqual(result, time.Duration(0)) + s.Less(result, input) } } diff --git a/common/backoff/retrypolicy_test.go b/common/backoff/retrypolicy_test.go index 78ee024a282..79f622454f7 100644 --- a/common/backoff/retrypolicy_test.go +++ b/common/backoff/retrypolicy_test.go @@ -82,8 +82,8 @@ func (s *RetryPolicySuite) TestExponentialBackoff() { for _, expected := range expectedResult { min, max := getNextBackoffRange(expected) next := r.NextBackOff(nil) - s.True(next >= min, "NextBackoff too low") - s.True(next < max, "NextBackoff too high") + s.GreaterOrEqual(next, min, "NextBackoff too low") + s.Less(next, max, "NextBackoff too high") } } @@ -116,8 +116,8 @@ func (s *RetryPolicySuite) TestMaximumInterval() { for _, expected := range expectedResult { min, max := getNextBackoffRange(expected) next := r.NextBackOff(nil) - s.True(next >= min, "NextBackoff too low") - s.True(next < max, "NextBackoff too high") + s.GreaterOrEqual(next, min, "NextBackoff too low") + s.Less(next, max, "NextBackoff too high") } } @@ -129,8 +129,8 @@ func (s *RetryPolicySuite) TestBackoffCoefficient() { min, max := getNextBackoffRange(2 * time.Second) for range 10 { next := r.NextBackOff(nil) - s.True(next >= min, "NextBackoff too low") - s.True(next < max, "NextBackoff too high") + s.GreaterOrEqual(next, min, "NextBackoff too low") + s.Less(next, max, "NextBackoff too high") } } @@ -152,15 +152,15 @@ func (s *RetryPolicySuite) TestExpirationOverflow() { r, ts := createRetrier(policy) next := r.NextBackOff(nil) min, max := getNextBackoffRange(2 * time.Second) - s.True(next >= min, "NextBackoff too low") - s.True(next < max, "NextBackoff too high") + s.GreaterOrEqual(next, min, "NextBackoff too low") + s.Less(next, max, "NextBackoff too high") ts.Advance(2 * time.Second) next = r.NextBackOff(nil) min, max = getNextBackoffRange(3 * time.Second) - s.True(next >= min, "NextBackoff too low") - s.True(next < max, "NextBackoff too high") + s.GreaterOrEqual(next, min, "NextBackoff too low") + s.Less(next, max, "NextBackoff too high") } func (s *RetryPolicySuite) TestDefaultPublishRetryPolicy() { @@ -192,8 +192,8 @@ func (s *RetryPolicySuite) TestDefaultPublishRetryPolicy() { s.Equal(done, next, "backoff not done yet!!!") } else { min, max := getNextBackoffRange(expected) - s.True(next >= min, "NextBackoff too low: actual: %v, min: %v", next, min) - s.True(next < max, "NextBackoff too high: actual: %v, max: %v", next, max) + s.GreaterOrEqual(next, min, "NextBackoff too low: actual: %v, min: %v", next, min) + s.Less(next, max, "NextBackoff too high: actual: %v, max: %v", next, max) ts.Advance(expected) } } @@ -262,8 +262,8 @@ func (s *RetryPolicySuite) TestErrorDependentPolicy() { retrier, _ = createRetrier(policy) delay = retrier.NextBackOff(fmt.Errorf("other error")) - s.True(delay >= 1*time.Second) - s.True(delay < 1500*time.Millisecond) + s.GreaterOrEqual(delay, 1*time.Second) + s.Less(delay, 1500*time.Millisecond) } func (s *RetryPolicySuite) TestConstantDelayPolicy() { @@ -290,8 +290,8 @@ func (s *RetryPolicySuite) TestConstantDelayPolicy() { retrier, _ = createRetrier(policy) delay = retrier.NextBackOff(nil) - s.True(delay >= 2*time.Second) - s.True(delay < 2200*time.Millisecond) + s.GreaterOrEqual(delay, 2*time.Second) + s.Less(delay, 2200*time.Millisecond) } // Validate jitter computation @@ -300,8 +300,8 @@ func (s *RetryPolicySuite) TestAddJitter() { delay := 1 * time.Second jitter := 0.5 jitteredDelay := addJitter(delay, jitter) - s.True(jitteredDelay >= 1*time.Second) - s.True(jitteredDelay < 1500*time.Millisecond) + s.GreaterOrEqual(jitteredDelay, 1*time.Second) + s.Less(jitteredDelay, 1500*time.Millisecond) } } diff --git a/common/cluster/metadata_test.go b/common/cluster/metadata_test.go index d4abbc476ed..fbe8ecca44c 100644 --- a/common/cluster/metadata_test.go +++ b/common/cluster/metadata_test.go @@ -127,11 +127,11 @@ func (s *metadataSuite) Test_RegisterMetadataChangeCallback() { s.metadata.RegisterMetadataChangeCallback( s, func(oldClusterMetadata map[string]*ClusterInformation, newClusterMetadata map[string]*ClusterInformation) { - s.Equal(3, len(newClusterMetadata)) + s.Len(newClusterMetadata, 3) }) s.metadata.UnRegisterMetadataChangeCallback(s) - s.Equal(0, len(s.metadata.clusterChangeCallback)) + s.Empty(s.metadata.clusterChangeCallback) } func (s *metadataSuite) Test_RefreshClusterMetadata_Success() { @@ -389,5 +389,5 @@ func (s *metadataSuite) Test_ListAllClusterMetadataFromDB_Success() { resp, err := s.metadata.listAllClusterMetadataFromDB(context.Background()) s.NoError(err) - s.Equal(2, len(resp)) + s.Len(resp, 2) } diff --git a/common/collection/concurrent_tx_map_test.go b/common/collection/concurrent_tx_map_test.go index c69d4947467..10b520e9632 100644 --- a/common/collection/concurrent_tx_map_test.go +++ b/common/collection/concurrent_tx_map_test.go @@ -64,7 +64,7 @@ func (s *ConcurrentTxMapSuite) TestGetAndDo() { return nil }) s.Nil(interf, "GetAndDo should return nil when key not found") - s.Nil(err, "GetAndDo should return nil when function not applied") + s.NoError(err, "GetAndDo should return nil when function not applied") s.False(ok, "GetAndDo should return false when key not found") s.False(fnApplied, "GetAndDo should not apply function when key not exixts") @@ -79,7 +79,7 @@ func (s *ConcurrentTxMapSuite) TestGetAndDo() { value1 := interf.(*intType) s.Equal(*(value1), intType(2)) - s.NotNil(err, "GetAndDo should return non nil when function applied") + s.Error(err, "GetAndDo should return non nil when function applied") s.True(ok, "GetAndDo should return true when key found") s.True(fnApplied, "GetAndDo should apply function when key exixts") } @@ -97,7 +97,7 @@ func (s *ConcurrentTxMapSuite) TestPutOrDo() { }) valueRetuern := interf.(*intType) s.Equal(value, *valueRetuern) - s.Nil(err, "PutOrDo should return nil when function not applied") + s.NoError(err, "PutOrDo should return nil when function not applied") s.False(ok, "PutOrDo should return false when function not applied") s.False(fnApplied, "PutOrDo should not apply function when key not exixts") @@ -110,7 +110,7 @@ func (s *ConcurrentTxMapSuite) TestPutOrDo() { }) valueRetuern = interf.(*intType) s.Equal(value, *valueRetuern) - s.NotNil(err, "PutOrDo should return non nil when function applied") + s.Error(err, "PutOrDo should return non nil when function applied") s.True(ok, "PutOrDo should return true when function applied") s.True(fnApplied, "PutOrDo should apply function when key exixts") } diff --git a/common/dynamicconfig/collection_test.go b/common/dynamicconfig/collection_test.go index 7ae80fdbd63..9964293e6f0 100644 --- a/common/dynamicconfig/collection_test.go +++ b/common/dynamicconfig/collection_test.go @@ -129,20 +129,20 @@ func (s *collectionSuite) TestGetFloat64Property() { func (s *collectionSuite) TestGetBoolProperty() { setting := dynamicconfig.NewGlobalBoolSetting(testGetBoolPropertyKey, true, "") value := setting.Get(s.cln) - s.Equal(true, value()) + s.True(value()) s.client.SetValue(testGetBoolPropertyKey, false) - s.Equal(false, value()) + s.False(value()) s.client.SetValue(testGetBoolPropertyKey, "false") - s.Equal(false, value()) + s.False(value()) } func (s *collectionSuite) TestGetBoolPropertyFilteredByNamespaceID() { setting := dynamicconfig.NewNamespaceIDBoolSetting(testGetBoolPropertyFilteredByNamespaceIDKey, true, "") namespaceID := namespace.ID("testNamespaceID") value := setting.Get(s.cln) - s.Equal(true, value(namespaceID)) + s.True(value(namespaceID)) s.client.SetValue(testGetBoolPropertyFilteredByNamespaceIDKey, false) - s.Equal(false, value(namespaceID)) + s.False(value(namespaceID)) } func (s *collectionSuite) TestGetBoolPropertyFilteredByTaskQueueInfo() { @@ -150,9 +150,9 @@ func (s *collectionSuite) TestGetBoolPropertyFilteredByTaskQueueInfo() { namespace := "testNamespace" taskQueue := "testTaskQueue" value := setting.Get(s.cln) - s.Equal(false, value(namespace, taskQueue, 0)) + s.False(value(namespace, taskQueue, 0)) s.client.SetValue(testGetBoolPropertyFilteredByTaskQueueInfoKey, true) - s.Equal(true, value(namespace, taskQueue, 0)) + s.True(value(namespace, taskQueue, 0)) } func (s *collectionSuite) TestGetDurationProperty() { diff --git a/common/dynamicconfig/file_based_client_test.go b/common/dynamicconfig/file_based_client_test.go index 5ae15d8c50d..612ef11e2a8 100644 --- a/common/dynamicconfig/file_based_client_test.go +++ b/common/dynamicconfig/file_based_client_test.go @@ -58,7 +58,7 @@ func (s *fileBasedClientSuite) SetupTest() { func (s *fileBasedClientSuite) TestGetValue() { cvs := s.client.GetValue(dynamicconfig.MakeKey(testGetBoolPropertyKey)) - s.Equal(3, len(cvs)) + s.Len(cvs, 3) s.ElementsMatch([]dynamicconfig.ConstrainedValue{ {Constraints: dynamicconfig.Constraints{}, Value: false}, {Constraints: dynamicconfig.Constraints{Namespace: "global-samples-namespace"}, Value: true}, @@ -91,10 +91,10 @@ func (s *fileBasedClientSuite) TestNewFileBasedClientWithoutMetrics() { func (s *fileBasedClientSuite) TestGetValue_CaseInsensitie() { cvs := s.client.GetValue(dynamicconfig.MakeKey(testCaseInsensitivePropertyKey)) - s.Equal(1, len(cvs)) + s.Len(cvs, 1) v := dynamicconfig.NewGlobalBoolSetting(testCaseInsensitivePropertyKey, false, "").Get(s.collection)() - s.Equal(true, v) + s.True(v) } func (s *fileBasedClientSuite) TestGetIntValue() { @@ -185,7 +185,7 @@ func (s *fileBasedClientSuite) TestGetFloatValue_WrongType() { func (s *fileBasedClientSuite) TestGetBoolValue() { v := dynamicconfig.NewGlobalBoolSetting(testGetBoolPropertyKey, true, "").Get(s.collection)() - s.Equal(false, v) + s.False(v) } func (s *fileBasedClientSuite) TestGetStringValue() { @@ -902,7 +902,7 @@ testGetFloat64PropertyKey: - value: 22.222 `)) s.Empty(lr.Errors) - s.Equal(1, len(lr.Warnings)) + s.Len(lr.Warnings, 1) s.ErrorContains(lr.Warnings[0], `unregistered key "testgetfloat64propertykey"`) } @@ -914,7 +914,7 @@ testGetIntPropertyKey: - value: not a number `)) s.Empty(lr.Errors) - s.Equal(1, len(lr.Warnings)) + s.Len(lr.Warnings, 1) s.ErrorContains(lr.Warnings[0], `validation failed: key "testgetintpropertykey" value not a number: value type is not int`) } @@ -928,7 +928,7 @@ testGetIntPropertyKey: namespace: samples-namespace `)) s.Empty(lr.Errors) - s.Equal(1, len(lr.Warnings)) + s.Len(lr.Warnings, 1) s.ErrorContains(lr.Warnings[0], `constraint "namespace" isn't valid for dynamic config key "testgetintpropertykey"`) } @@ -944,12 +944,12 @@ testGetIntPropertyKey: namespace: samples-namespace `)) s.Empty(lr.Errors) - s.Equal(3, len(lr.Warnings)) + s.Len(lr.Warnings, 3) } func (s *fileBasedClientSuite) TestErrorYamlDecode() { lr := dynamicconfig.LoadYamlFile([]byte(`}}}}}}}}}`)) - s.Equal(1, len(lr.Errors)) + s.Len(lr.Errors, 1) s.ErrorContains(lr.Errors[0], "decode error") } @@ -962,7 +962,7 @@ testGetBoolPropertyKey: constraints: namespace: 35 `)) - s.Equal(1, len(lr.Errors)) + s.Len(lr.Errors, 1) s.ErrorContains(lr.Errors[0], "namespace constraint must be string") } diff --git a/common/effect/buffer_test.go b/common/effect/buffer_test.go index c26d23a40bf..6a7db23a219 100644 --- a/common/effect/buffer_test.go +++ b/common/effect/buffer_test.go @@ -47,8 +47,8 @@ func TestBufferCancelAfterApply(t *testing.T) { buf.Apply(context.TODO()) buf.Cancel(context.TODO()) - require.Equal(t, commit, 1) - require.Equal(t, rollback, 0) + require.Equal(t, 1, commit) + require.Equal(t, 0, rollback) } func TestBufferApplyAfterCancel(t *testing.T) { @@ -64,6 +64,6 @@ func TestBufferApplyAfterCancel(t *testing.T) { buf.Apply(context.TODO()) buf.Cancel(context.TODO()) - require.Equal(t, commit, 0) - require.Equal(t, rollback, 1) + require.Equal(t, 0, commit) + require.Equal(t, 1, rollback) } diff --git a/common/effect/immediate_test.go b/common/effect/immediate_test.go index bf25924bc1a..85c60e86416 100644 --- a/common/effect/immediate_test.go +++ b/common/effect/immediate_test.go @@ -12,8 +12,8 @@ func TestImmediate(t *testing.T) { var i int immediate := effect.Immediate(context.TODO()) immediate.OnAfterCommit(func(context.Context) { i = 1 }) - require.Equal(t, i, 1, "commit func should have run") + require.Equal(t, 1, i, "commit func should have run") immediate.OnAfterRollback(func(context.Context) { i = 2 }) - require.Equal(t, i, 1, "rollback func should not run") + require.Equal(t, 1, i, "rollback func should not run") } diff --git a/common/finalizer/finalizer_test.go b/common/finalizer/finalizer_test.go index 0e80f591fae..52d134403c9 100644 --- a/common/finalizer/finalizer_test.go +++ b/common/finalizer/finalizer_test.go @@ -76,7 +76,7 @@ func TestFinalizer(t *testing.T) { })) } - require.EqualValues(t, 5, f.Run(1*time.Second)) + require.Equal(t, 5, f.Run(1*time.Second)) require.EqualValues(t, 5, completed.Load()) snap := capture.Snapshot() @@ -105,7 +105,7 @@ func TestFinalizer(t *testing.T) { capture := mh.StartCapture() completed := f.Run(timeout) - require.EqualValues(t, 1, completed, "expected only one callback to complete") + require.Equal(t, 1, completed, "expected only one callback to complete") snap := capture.Snapshot() require.Equal(t, int64(1), snap[metrics.FinalizerItemsCompleted.Name()][0].Value) @@ -142,7 +142,7 @@ func TestFinalizer(t *testing.T) { func(ctx context.Context) error { return nil })) - require.EqualValues(t, 1, f.Run(1*time.Second)) + require.Equal(t, 1, f.Run(1*time.Second)) // 2nd call require.Zero(t, f.Run(1*time.Second), "expected no callbacks to complete") diff --git a/common/goro/goro_test.go b/common/goro/goro_test.go index 3b5d56c4d6c..7aef59865ac 100644 --- a/common/goro/goro_test.go +++ b/common/goro/goro_test.go @@ -43,7 +43,7 @@ func TestGoroCancel(t *testing.T) { g.Cancel() <-g.Done() require.ErrorIs(t, context.Canceled, g.Err()) - require.Nil(t, pctx.Err()) + require.NoError(t, pctx.Err()) } func TestGoroMultiCancel(t *testing.T) { diff --git a/common/locks/id_mutex_test.go b/common/locks/id_mutex_test.go index ec1c70ae721..f0fc6c65e95 100644 --- a/common/locks/id_mutex_test.go +++ b/common/locks/id_mutex_test.go @@ -202,6 +202,6 @@ func (s *idMutexSuite) TestConcurrentAccess() { s.Equal(iteration, counter) impl := s.idMutex.(*idMutexImpl) for i := uint32(0); i < s.numShard; i++ { - s.Equal(0, len(impl.shards[i].mutexInfos)) + s.Empty(impl.shards[i].mutexInfos) } } diff --git a/common/locks/priority_mutex_test.go b/common/locks/priority_mutex_test.go index d31d75b9c8a..4c72492a626 100644 --- a/common/locks/priority_mutex_test.go +++ b/common/locks/priority_mutex_test.go @@ -179,7 +179,7 @@ func (s *priorityMutexSuite) TestLock_Mixed() { for result := range resultChan { results = append(results, result) } - s.Equal(2*concurrency, len(results)) + s.Len(results, 2*concurrency) zeros := float64(0) totalZeros := float64(concurrency) @@ -197,5 +197,5 @@ func (s *priorityMutexSuite) TestLock_Mixed() { overallPossibility := possibility / float64(concurrency) fmt.Printf("overall possibility: %.2f\n", overallPossibility) - s.True(overallPossibility >= 0.5) + s.GreaterOrEqual(overallPossibility, 0.5) } diff --git a/common/membership/ringpop/factory_test.go b/common/membership/ringpop/factory_test.go index f0d7e654146..6f7a9d61662 100644 --- a/common/membership/ringpop/factory_test.go +++ b/common/membership/ringpop/factory_test.go @@ -110,7 +110,7 @@ func (s *RingpopSuite) TearDownSuite() { func (s *RingpopSuite) TestHostsMode() { var cfg config.Membership err := yaml.Unmarshal([]byte(getHostsConfig()), &cfg) - s.Nil(err) + s.NoError(err) s.Equal("1.2.3.4", cfg.BroadcastAddress) s.Equal(time.Second*30, cfg.MaxJoinDuration) @@ -120,7 +120,7 @@ func (s *RingpopSuite) TestHostsMode() { Logger: log.Logger(log.NewNoopLogger()), } f, err := newFactory(params) - s.Nil(err) + s.NoError(err) s.NotNil(f) } diff --git a/common/membership/ringpop/monitor_test.go b/common/membership/ringpop/monitor_test.go index 292fb5a607f..2a605a82ef3 100644 --- a/common/membership/ringpop/monitor_test.go +++ b/common/membership/ringpop/monitor_test.go @@ -41,10 +41,10 @@ func (s *RpoSuite) TestMonitor() { r, err := rpm.GetResolver(serviceName) s.NoError(err) err = r.AddListener("test-listener", listenCh) - s.Nil(err, "AddListener failed") + s.NoError(err, "AddListener failed") host, err := r.Lookup("key") - s.Nil(err, "Ringpop monitor failed to find host for key") + s.NoError(err, "Ringpop monitor failed to find host for key") s.NotNil(host, "Ringpop monitor returned a nil host") s.Eventually(func() bool { @@ -65,7 +65,7 @@ func (s *RpoSuite) TestMonitor() { select { case e := <-listenCh: s.T().Log("Got update") - s.Equal(1, len(e.HostsRemoved), "ringpop monitor event does not report the removed host") + s.Len(e.HostsRemoved, 1, "ringpop monitor event does not report the removed host") s.Equal(testService.hostAddrs[1], e.HostsRemoved[0].GetAddress(), "ringpop monitor reported that a wrong host was removed") s.Nil(e.HostsAdded, "Unexpected host reported to be added by ringpop monitor") s.Nil(e.HostsChanged, "Unexpected host reported to be changed by ringpop monitor") @@ -75,7 +75,7 @@ func (s *RpoSuite) TestMonitor() { for k := range 10 { host, err = r.Lookup(fmt.Sprintf("key%d", k)) - s.Nil(err, "Ringpop monitor failed to find host for key") + s.NoError(err, "Ringpop monitor failed to find host for key") s.NotEqual(testService.hostAddrs[1], host.GetAddress(), "Ringpop monitor assigned key to dead host") // check that LookupN[0] is the same as Lookup @@ -83,8 +83,8 @@ func (s *RpoSuite) TestMonitor() { s.Len(hosts, 1) s.Equal(host.GetAddress(), hosts[0].GetAddress()) } - s.Equal(2, len(r.Members())) - s.Equal(2, len(r.AvailableMembers())) + s.Len(r.Members(), 2) + s.Len(r.AvailableMembers(), 2) s.T().Log("Draining host 2") testService.DrainHost(testService.hostUUIDs[2]) @@ -94,17 +94,17 @@ func (s *RpoSuite) TestMonitor() { s.T().Log("Got update") s.Nil(e.HostsRemoved) s.Nil(e.HostsAdded) - s.Equal(1, len(e.HostsChanged)) + s.Len(e.HostsChanged, 1) s.Equal(testService.hostAddrs[2], e.HostsChanged[0].GetAddress()) case <-timer.C: s.Fail("Timed out waiting for failure to be detected by ringpop") } - s.Equal(2, len(r.Members())) - s.Equal(1, len(r.AvailableMembers())) + s.Len(r.Members(), 2) + s.Len(r.AvailableMembers(), 1) err = r.RemoveListener("test-listener") - s.Nil(err, "RemoveListener() failed") + s.NoError(err, "RemoveListener() failed") testService.Stop() } @@ -218,8 +218,8 @@ func (s *RpoSuite) TestCompareMembersWithDraining() { resolver.ringAndHosts.Store(ringAndHosts{ hosts: newMembers, }) - s.Equal(3, len(resolver.Members())) - s.Equal(2, len(resolver.AvailableMembers())) + s.Len(resolver.Members(), 3) + s.Len(resolver.AvailableMembers(), 2) } func eventToString(event *membership.ChangedEvent) []string { diff --git a/common/metrics/grpc_test.go b/common/metrics/grpc_test.go index 34724682094..3e67a2c004a 100644 --- a/common/metrics/grpc_test.go +++ b/common/metrics/grpc_test.go @@ -73,21 +73,21 @@ func (s *grpcSuite) TestMetadataMetricInjection() { }, ) - s.Nil(err) + s.NoError(err) trailers := ssts.CapturedTrailers() - s.Equal(1, len(trailers)) + s.Len(trailers, 1) propagationContextBlobs := trailers[0].Get(metricsTrailerKey) s.NotNil(propagationContextBlobs) - s.Equal(1, len(propagationContextBlobs)) + s.Len(propagationContextBlobs, 1) baggage := &metricsspb.Baggage{} err = baggage.Unmarshal(([]byte)(propagationContextBlobs[0])) - s.Nil(err) + s.NoError(err) s.Equal(int64(1234), baggage.CountersInt[anyMetricName]) return res, err }, ) - s.Nil(err) + s.NoError(err) s.Equal(10, res) s.Assert() } @@ -129,21 +129,21 @@ func (s *grpcSuite) TestMetadataMetricInjection_NoMetricPresent() { }, ) - s.Nil(err) + s.NoError(err) trailers := ssts.CapturedTrailers() - s.Equal(1, len(trailers)) + s.Len(trailers, 1) propagationContextBlobs := trailers[0].Get(metricsTrailerKey) s.NotNil(propagationContextBlobs) - s.Equal(1, len(propagationContextBlobs)) + s.Len(propagationContextBlobs, 1) baggage := &metricsspb.Baggage{} err = baggage.Unmarshal(([]byte)(propagationContextBlobs[0])) - s.Nil(err) + s.NoError(err) s.Nil(baggage.CountersInt) return res, err }, ) - s.Nil(err) + s.NoError(err) s.Equal(10, res) s.Assert() } diff --git a/common/metrics/metricstest/task_queues_test.go b/common/metrics/metricstest/task_queues_test.go index 22485551181..bc81d3bdeda 100644 --- a/common/metrics/metricstest/task_queues_test.go +++ b/common/metrics/metricstest/task_queues_test.go @@ -81,7 +81,7 @@ func verifyTags(t *testing.T, handler metrics.Handler, expectedTags map[string]s h.Counter("MyMetric").Record(1) snap := capture.Snapshot() h.StopCapture(capture) - a.Equal(1, len(snap)) - a.Equal(1, len(snap["MyMetric"])) + a.Len(snap, 1) + a.Len(snap["MyMetric"], 1) a.Equal(expectedTags, snap["MyMetric"][0].Tags) } diff --git a/common/metrics/registry_test.go b/common/metrics/registry_test.go index 586e5a210bd..30709d839e4 100644 --- a/common/metrics/registry_test.go +++ b/common/metrics/registry_test.go @@ -14,8 +14,8 @@ func TestRegistryBuildCatalog_Ok(t *testing.T) { r.register(newMetricDefinition("foo", WithDescription("foo description"))) r.register(newMetricDefinition("bar", WithDescription("bar description"))) c, err := r.buildCatalog() - require.Nil(t, err) - require.Equal(t, 2, len(c)) + require.NoError(t, err) + require.Len(t, c, 2) require.Equal(t, "foo description", c["foo"].description) require.Equal(t, "bar description", c["bar"].description) } diff --git a/common/namespace/nsregistry/registry_test.go b/common/namespace/nsregistry/registry_test.go index da2760f576b..ad42f508ad4 100644 --- a/common/namespace/nsregistry/registry_test.go +++ b/common/namespace/nsregistry/registry_test.go @@ -186,17 +186,17 @@ func (s *registrySuite) TestListNamespace() { defer s.registry.Stop() entryByName1, err := s.registry.GetNamespace(namespace.Name(namespaceRecord1.Namespace.Info.Name)) - s.Nil(err) + s.NoError(err) s.Equal(entry1, entryByName1) entryByID1, err := s.registry.GetNamespaceByID(namespace.ID(namespaceRecord1.Namespace.Info.Id)) - s.Nil(err) + s.NoError(err) s.Equal(entry1, entryByID1) entryByName2, err := s.registry.GetNamespace(namespace.Name(namespaceRecord2.Namespace.Info.Name)) - s.Nil(err) + s.NoError(err) s.Equal(entry2, entryByName2) entryByID2, err := s.registry.GetNamespaceByID(namespace.ID(namespaceRecord2.Namespace.Info.Id)) - s.Nil(err) + s.NoError(err) s.Equal(entry2, entryByID2) } diff --git a/common/payload/payload_test.go b/common/payload/payload_test.go index 00659d23d94..3aafcd59924 100644 --- a/common/payload/payload_test.go +++ b/common/payload/payload_test.go @@ -39,7 +39,7 @@ func TestToString(t *testing.T) { }) s.NoError(err) result = ToString(p) - s.Equal(`{"Int":10,"String":"str","Bytes":"MzQ1"}`, result) + s.JSONEq(`{"Int":10,"String":"str","Bytes":"MzQ1"}`, result) p, err = Encode(nil) s.NoError(err) @@ -47,7 +47,7 @@ func TestToString(t *testing.T) { s.Equal("nil", result) result = ToString(nil) - s.Equal("", result) + s.Empty(result) } func TestEncodeDecode(t *testing.T) { diff --git a/common/rpc/context_test.go b/common/rpc/context_test.go index 1fd38ec8154..d17e0b73d80 100644 --- a/common/rpc/context_test.go +++ b/common/rpc/context_test.go @@ -59,8 +59,8 @@ func (s *contextSuite) TestCopyContextValue_DeadlineSeparated() { newContext = CopyContextValues(newContext, ctx) cancel() - s.NotNil(ctx.Err()) - s.Nil(newContext.Err()) + s.Error(ctx.Err()) + s.NoError(newContext.Err()) } func (s *contextSuite) TestCopyContextValue_ValueNotOverWritten() { diff --git a/common/rpc/encryption/tls_config_test.go b/common/rpc/encryption/tls_config_test.go index feb2f6b5bd5..74fde7d19a1 100644 --- a/common/rpc/encryption/tls_config_test.go +++ b/common/rpc/encryption/tls_config_test.go @@ -108,11 +108,11 @@ func (s *tlsConfigTest) testGroupTLS(f func(*config.RootTLS, *config.GroupTLS)) func (s *tlsConfigTest) testCertFileAndData(cfg *config.RootTLS, group *config.GroupTLS) { group.Server = config.ServerTLS{} - s.Nil(validateRootTLS(cfg)) + s.NoError(validateRootTLS(cfg)) group.Server = config.ServerTLS{CertFile: "foo"} - s.Nil(validateRootTLS(cfg)) + s.NoError(validateRootTLS(cfg)) group.Server = config.ServerTLS{CertData: "bar"} - s.Nil(validateRootTLS(cfg)) + s.NoError(validateRootTLS(cfg)) group.Server = config.ServerTLS{CertFile: "foo", CertData: "bar"} s.Error(validateRootTLS(cfg)) } @@ -120,11 +120,11 @@ func (s *tlsConfigTest) testCertFileAndData(cfg *config.RootTLS, group *config.G func (s *tlsConfigTest) testKeyFileAndData(cfg *config.RootTLS, group *config.GroupTLS) { group.Server = config.ServerTLS{} - s.Nil(validateRootTLS(cfg)) + s.NoError(validateRootTLS(cfg)) group.Server = config.ServerTLS{KeyFile: "foo"} - s.Nil(validateRootTLS(cfg)) + s.NoError(validateRootTLS(cfg)) group.Server = config.ServerTLS{KeyData: "bar"} - s.Nil(validateRootTLS(cfg)) + s.NoError(validateRootTLS(cfg)) group.Server = config.ServerTLS{KeyFile: "foo", KeyData: "bar"} s.Error(validateRootTLS(cfg)) } @@ -132,13 +132,13 @@ func (s *tlsConfigTest) testKeyFileAndData(cfg *config.RootTLS, group *config.Gr func (s *tlsConfigTest) testClientCAData(cfg *config.RootTLS, group *config.GroupTLS) { group.Server = config.ServerTLS{} - s.Nil(validateRootTLS(cfg)) + s.NoError(validateRootTLS(cfg)) group.Server = config.ServerTLS{ClientCAData: []string{}} - s.Nil(validateRootTLS(cfg)) + s.NoError(validateRootTLS(cfg)) group.Server = config.ServerTLS{ClientCAData: []string{"foo"}} - s.Nil(validateRootTLS(cfg)) + s.NoError(validateRootTLS(cfg)) group.Server = config.ServerTLS{ClientCAData: []string{"foo", "bar"}} - s.Nil(validateRootTLS(cfg)) + s.NoError(validateRootTLS(cfg)) group.Server = config.ServerTLS{ClientCAData: []string{"foo", " "}} s.Error(validateRootTLS(cfg)) group.Server = config.ServerTLS{ClientCAData: []string{""}} @@ -148,13 +148,13 @@ func (s *tlsConfigTest) testClientCAData(cfg *config.RootTLS, group *config.Grou func (s *tlsConfigTest) testClientCAFiles(cfg *config.RootTLS, group *config.GroupTLS) { group.Server = config.ServerTLS{} - s.Nil(validateRootTLS(cfg)) + s.NoError(validateRootTLS(cfg)) group.Server = config.ServerTLS{ClientCAFiles: []string{}} - s.Nil(validateRootTLS(cfg)) + s.NoError(validateRootTLS(cfg)) group.Server = config.ServerTLS{ClientCAFiles: []string{"foo"}} - s.Nil(validateRootTLS(cfg)) + s.NoError(validateRootTLS(cfg)) group.Server = config.ServerTLS{ClientCAFiles: []string{"foo", "bar"}} - s.Nil(validateRootTLS(cfg)) + s.NoError(validateRootTLS(cfg)) group.Server = config.ServerTLS{ClientCAFiles: []string{"foo", " "}} s.Error(validateRootTLS(cfg)) group.Server = config.ServerTLS{ClientCAFiles: []string{""}} @@ -164,13 +164,13 @@ func (s *tlsConfigTest) testClientCAFiles(cfg *config.RootTLS, group *config.Gro func (s *tlsConfigTest) testRootCAData(cfg *config.RootTLS, group *config.GroupTLS) { group.Client = config.ClientTLS{} - s.Nil(validateRootTLS(cfg)) + s.NoError(validateRootTLS(cfg)) group.Client = config.ClientTLS{RootCAData: []string{}} - s.Nil(validateRootTLS(cfg)) + s.NoError(validateRootTLS(cfg)) group.Client = config.ClientTLS{RootCAData: []string{"foo"}} - s.Nil(validateRootTLS(cfg)) + s.NoError(validateRootTLS(cfg)) group.Client = config.ClientTLS{RootCAData: []string{"foo", "bar"}} - s.Nil(validateRootTLS(cfg)) + s.NoError(validateRootTLS(cfg)) group.Client = config.ClientTLS{RootCAData: []string{"foo", " "}} s.Error(validateRootTLS(cfg)) group.Client = config.ClientTLS{RootCAData: []string{""}} @@ -180,13 +180,13 @@ func (s *tlsConfigTest) testRootCAData(cfg *config.RootTLS, group *config.GroupT func (s *tlsConfigTest) testRootCAFiles(cfg *config.RootTLS, group *config.GroupTLS) { group.Client = config.ClientTLS{} - s.Nil(validateRootTLS(cfg)) + s.NoError(validateRootTLS(cfg)) group.Client = config.ClientTLS{RootCAFiles: []string{}} - s.Nil(validateRootTLS(cfg)) + s.NoError(validateRootTLS(cfg)) group.Client = config.ClientTLS{RootCAFiles: []string{"foo"}} - s.Nil(validateRootTLS(cfg)) + s.NoError(validateRootTLS(cfg)) group.Client = config.ClientTLS{RootCAFiles: []string{"foo", "bar"}} - s.Nil(validateRootTLS(cfg)) + s.NoError(validateRootTLS(cfg)) group.Client = config.ClientTLS{RootCAFiles: []string{"foo", " "}} s.Error(validateRootTLS(cfg)) group.Client = config.ClientTLS{RootCAFiles: []string{""}} @@ -196,28 +196,28 @@ func (s *tlsConfigTest) testRootCAFiles(cfg *config.RootTLS, group *config.Group func (s *tlsConfigTest) TestSystemWorkerTLSConfig() { cfg := &config.RootTLS{} cfg.SystemWorker = config.WorkerTLS{} - s.Nil(validateRootTLS(cfg)) + s.NoError(validateRootTLS(cfg)) cfg.SystemWorker = config.WorkerTLS{CertFile: "foo"} - s.Nil(validateRootTLS(cfg)) + s.NoError(validateRootTLS(cfg)) cfg.SystemWorker = config.WorkerTLS{CertData: "bar"} - s.Nil(validateRootTLS(cfg)) + s.NoError(validateRootTLS(cfg)) cfg.SystemWorker = config.WorkerTLS{CertFile: "foo", CertData: "bar"} s.Error(validateRootTLS(cfg)) cfg.SystemWorker = config.WorkerTLS{KeyFile: "foo"} - s.Nil(validateRootTLS(cfg)) + s.NoError(validateRootTLS(cfg)) cfg.SystemWorker = config.WorkerTLS{KeyData: "bar"} - s.Nil(validateRootTLS(cfg)) + s.NoError(validateRootTLS(cfg)) cfg.SystemWorker = config.WorkerTLS{KeyFile: "foo", KeyData: "bar"} s.Error(validateRootTLS(cfg)) cfg.SystemWorker = config.WorkerTLS{Client: config.ClientTLS{}} client := &cfg.SystemWorker.Client client.RootCAData = []string{} - s.Nil(validateRootTLS(cfg)) + s.NoError(validateRootTLS(cfg)) client.RootCAData = []string{"foo"} - s.Nil(validateRootTLS(cfg)) + s.NoError(validateRootTLS(cfg)) client.RootCAData = []string{"foo", "bar"} - s.Nil(validateRootTLS(cfg)) + s.NoError(validateRootTLS(cfg)) client.RootCAData = []string{"foo", " "} s.Error(validateRootTLS(cfg)) client.RootCAData = []string{""} diff --git a/common/rpc/interceptor/dc_redirection_policy_test.go b/common/rpc/interceptor/dc_redirection_policy_test.go index 9491d9f1685..41a43e9a43e 100644 --- a/common/rpc/interceptor/dc_redirection_policy_test.go +++ b/common/rpc/interceptor/dc_redirection_policy_test.go @@ -78,10 +78,10 @@ func (s *noopDCRedirectionPolicySuite) TestWithNamespaceRedirect() { } err := s.policy.WithNamespaceIDRedirect(context.Background(), namespaceID, apiName, nil, callFn) - s.Nil(err) + s.NoError(err) err = s.policy.WithNamespaceRedirect(context.Background(), namespaceName, apiName, nil, callFn) - s.Nil(err) + s.NoError(err) s.Equal(2, callCount) } @@ -135,10 +135,10 @@ func (s *selectedAPIsForwardingRedirectionPolicySuite) TestWithNamespaceRedirect } err := s.policy.WithNamespaceIDRedirect(context.Background(), s.namespaceID, apiName, nil, callFn) - s.Nil(err) + s.NoError(err) err = s.policy.WithNamespaceRedirect(context.Background(), s.namespace, apiName, nil, callFn) - s.Nil(err) + s.NoError(err) s.Equal(2, callCount) } @@ -155,10 +155,10 @@ func (s *selectedAPIsForwardingRedirectionPolicySuite) TestWithNamespaceRedirect } err := s.policy.WithNamespaceIDRedirect(context.Background(), s.namespaceID, apiName, nil, callFn) - s.Nil(err) + s.NoError(err) err = s.policy.WithNamespaceRedirect(context.Background(), s.namespace, apiName, nil, callFn) - s.Nil(err) + s.NoError(err) s.Equal(2, callCount) } @@ -175,10 +175,10 @@ func (s *selectedAPIsForwardingRedirectionPolicySuite) TestWithNamespaceRedirect } err := s.policy.WithNamespaceIDRedirect(context.Background(), s.namespaceID, apiName, nil, callFn) - s.Nil(err) + s.NoError(err) err = s.policy.WithNamespaceRedirect(context.Background(), s.namespace, apiName, nil, callFn) - s.Nil(err) + s.NoError(err) s.Equal(2, callCount) } @@ -195,10 +195,10 @@ func (s *selectedAPIsForwardingRedirectionPolicySuite) TestWithNamespaceRedirect for apiName := range selectedAPIsForwardingRedirectionPolicyWhitelistedAPIs { err := s.policy.WithNamespaceIDRedirect(context.Background(), s.namespaceID, apiName, nil, callFn) - s.Nil(err) + s.NoError(err) err = s.policy.WithNamespaceRedirect(context.Background(), s.namespace, apiName, nil, callFn) - s.Nil(err) + s.NoError(err) } s.Equal(2*len(selectedAPIsForwardingRedirectionPolicyWhitelistedAPIs), callCount) @@ -216,10 +216,10 @@ func (s *selectedAPIsForwardingRedirectionPolicySuite) TestGetTargetDataCenter_G for apiName := range selectedAPIsForwardingRedirectionPolicyWhitelistedAPIs { err := s.policy.WithNamespaceIDRedirect(context.Background(), s.namespaceID, apiName, nil, callFn) - s.Nil(err) + s.NoError(err) err = s.policy.WithNamespaceRedirect(context.Background(), s.namespace, apiName, nil, callFn) - s.Nil(err) + s.NoError(err) } s.Equal(2*len(selectedAPIsForwardingRedirectionPolicyWhitelistedAPIs), callCount) @@ -237,10 +237,10 @@ func (s *selectedAPIsForwardingRedirectionPolicySuite) TestGetTargetDataCenter_G for apiName := range selectedAPIsForwardingRedirectionPolicyWhitelistedAPIs { err := s.policy.WithNamespaceIDRedirect(context.Background(), s.namespaceID, apiName, nil, callFn) - s.Nil(err) + s.NoError(err) err = s.policy.WithNamespaceRedirect(context.Background(), s.namespace, apiName, nil, callFn) - s.Nil(err) + s.NoError(err) } s.Equal(2*len(selectedAPIsForwardingRedirectionPolicyWhitelistedAPIs), callCount) @@ -299,10 +299,10 @@ func (s *selectedAPIsForwardingRedirectionPolicySuite) TestGetTargetDataCenter_G api = api + "_notwhitelisted" } err := s.policy.WithNamespaceIDRedirect(context.Background(), s.namespaceID, api, nil, callFn) - s.Nil(err) + s.NoError(err) err = s.policy.WithNamespaceRedirect(context.Background(), s.namespace, api, nil, callFn) - s.Nil(err) + s.NoError(err) } s.Equal(tc.expectedCallCount, callCountByCluster) @@ -330,10 +330,10 @@ func (s *selectedAPIsForwardingRedirectionPolicySuite) TestGetTargetDataCenter_G for apiName := range selectedAPIsForwardingRedirectionPolicyWhitelistedAPIs { err := s.policy.WithNamespaceIDRedirect(context.Background(), s.namespaceID, apiName, nil, callFn) - s.Nil(err) + s.NoError(err) err = s.policy.WithNamespaceRedirect(context.Background(), s.namespace, apiName, nil, callFn) - s.Nil(err) + s.NoError(err) } s.Equal(2*len(selectedAPIsForwardingRedirectionPolicyWhitelistedAPIs), currentClustercallCount) @@ -360,10 +360,10 @@ func (s *selectedAPIsForwardingRedirectionPolicySuite) TestGetTargetDataCenter_G for apiName := range selectedAPIsForwardingRedirectionPolicyWhitelistedAPIs { err := s.policy.WithNamespaceIDRedirect(context.Background(), s.namespaceID, apiName, nil, callFn) - s.Nil(err) + s.NoError(err) err = s.policy.WithNamespaceRedirect(context.Background(), s.namespace, apiName, nil, callFn) - s.Nil(err) + s.NoError(err) } s.Equal(2*len(selectedAPIsForwardingRedirectionPolicyWhitelistedAPIs), currentClustercallCount) @@ -391,10 +391,10 @@ func (s *selectedAPIsForwardingRedirectionPolicySuite) TestGetTargetDataCenter_G apiName := "NotExistRandomAPI" err := s.policy.WithNamespaceIDRedirect(context.Background(), s.namespaceID, apiName, nil, callFn) - s.Nil(err) + s.NoError(err) err = s.policy.WithNamespaceRedirect(context.Background(), s.namespace, apiName, nil, callFn) - s.Nil(err) + s.NoError(err) s.Equal(2, currentClustercallCount) s.Equal(2, alternativeClustercallCount) diff --git a/common/rpc/interceptor/stream_error_test.go b/common/rpc/interceptor/stream_error_test.go index 718265a4d30..8ad5bbe61a4 100644 --- a/common/rpc/interceptor/stream_error_test.go +++ b/common/rpc/interceptor/stream_error_test.go @@ -37,10 +37,10 @@ func (s *streamErrorSuite) TearDownTest() { } func (s *streamErrorSuite) TestErrorConversion() { - s.Equal(nil, errorConvert(nil)) + s.NoError(errorConvert(nil)) s.Equal(io.EOF, errorConvert(io.EOF)) - s.IsType(nil, errorConvert(status.Error(codes.OK, ""))) + s.NoError(errorConvert(status.Error(codes.OK, ""))) s.IsType(&serviceerror.DeadlineExceeded{}, errorConvert(status.Error(codes.DeadlineExceeded, ""))) s.IsType(&serviceerror.Canceled{}, errorConvert(status.Error(codes.Canceled, ""))) s.IsType(&serviceerror.InvalidArgument{}, errorConvert(status.Error(codes.InvalidArgument, ""))) diff --git a/common/rpc/test/rpc_common_test.go b/common/rpc/test/rpc_common_test.go index 6ae5f479629..b8af377cfa1 100644 --- a/common/rpc/test/rpc_common_test.go +++ b/common/rpc/test/rpc_common_test.go @@ -170,7 +170,7 @@ func dialTestServiceAndGetTLSInfo( if err == nil { s.NotNil(reply) - s.True(strings.Contains(reply.Message, request.Name)) + s.Contains(reply.Message, request.Name) } _ = clientConn.Close() diff --git a/common/rpc/test/rpc_localstore_tls_test.go b/common/rpc/test/rpc_localstore_tls_test.go index ca1245a7db7..360da89d602 100644 --- a/common/rpc/test/rpc_localstore_tls_test.go +++ b/common/rpc/test/rpc_localstore_tls_test.go @@ -563,7 +563,7 @@ func (s *localStoreRPCSuite) testCertExpiration(factory *TestFactory, timeWindow s.NotNil(expiring) s.Empty(expired) s.NoError(err) - s.Equal(nExpiring, len(expiring)) + s.Len(expiring, nExpiring) } func (s *localStoreRPCSuite) testDynamicRootCA(host string, frontend bool) { diff --git a/common/serviceerror/service_error_with_dpanic_test.go b/common/serviceerror/service_error_with_dpanic_test.go index 473aa8c398b..8d4a7bb29d3 100644 --- a/common/serviceerror/service_error_with_dpanic_test.go +++ b/common/serviceerror/service_error_with_dpanic_test.go @@ -31,7 +31,7 @@ func (s *serviceErrorWithDPanicSuite) TestNewDPanicInProd() { s.NotNil(logger) err := NewInternalErrorWithDPanic(logger, "Must not panic!") - s.NotNil(err) + s.Error(err) _, ok := err.(*serviceerror.Internal) s.True(ok) } @@ -47,6 +47,6 @@ func (s *serviceErrorWithDPanicSuite) TestNewDPanicInDev() { s.Panics(nil, func() { err := NewInternalErrorWithDPanic(logger, "Must panic!") - s.Nil(err) + s.NoError(err) }) } diff --git a/common/stream_batcher/batcher_test.go b/common/stream_batcher/batcher_test.go index 021673c3823..9051c070037 100644 --- a/common/stream_batcher/batcher_test.go +++ b/common/stream_batcher/batcher_test.go @@ -267,7 +267,7 @@ func TestStreamBatcher_AddTimeout(t *testing.T) { defer cancel() r, err := sb.Add(ctx, 123) assert.NoError(t, err) - assert.Equal(t, r, 123) + assert.Equal(t, 123, r) }) time.Sleep(time.Millisecond) // wait for it to block in Add clk.AdvanceNext() diff --git a/common/telemetry/config_test.go b/common/telemetry/config_test.go index 8254f49ed4e..13ec80f688d 100644 --- a/common/telemetry/config_test.go +++ b/common/telemetry/config_test.go @@ -58,7 +58,7 @@ func TestEmptyConfig(t *testing.T) { cfg := telemetry.ExportConfig{} exporters, err := cfg.SpanExporters() require.NoError(t, err) - require.Len(t, exporters, 0) + require.Empty(t, exporters) } func TestExportersWithSharedConn(t *testing.T) { @@ -85,18 +85,18 @@ func TestSharedConn(t *testing.T) { require.Len(t, cfg.Exporters, 2) exp := cfg.Exporters[0] - require.Equal(t, exp.Kind.Signal, "traces") - require.Equal(t, exp.Kind.Model, "otlp") - require.Equal(t, exp.Kind.Protocol, "grpc") + require.Equal(t, "traces", exp.Kind.Signal) + require.Equal(t, "otlp", exp.Kind.Model) + require.Equal(t, "grpc", exp.Kind.Protocol) require.NotNil(t, exp.Spec) sspec, ok := exp.Spec.(*telemetry.OTLPGRPCSpanExporter) require.True(t, ok) require.Equal(t, "conn1", sspec.ConnectionName) exp = cfg.Exporters[1] - require.Equal(t, exp.Kind.Signal, "metrics") - require.Equal(t, exp.Kind.Model, "otlp") - require.Equal(t, exp.Kind.Protocol, "grpc") + require.Equal(t, "metrics", exp.Kind.Signal) + require.Equal(t, "otlp", exp.Kind.Model) + require.Equal(t, "grpc", exp.Kind.Protocol) require.NotNil(t, exp.Spec) mspec, ok := exp.Spec.(*telemetry.OTLPGRPCMetricExporter) require.True(t, ok) @@ -107,13 +107,13 @@ func TestOTLPTraceGRPC(t *testing.T) { cfg := telemetry.PrivateExportConfig{} err := yaml.Unmarshal([]byte(basicOTLPTraceOnlyConfig), &cfg) require.NoError(t, err) - require.Len(t, cfg.Connections, 0) + require.Empty(t, cfg.Connections) require.Len(t, cfg.Exporters, 1) exp := cfg.Exporters[0] - require.Equal(t, exp.Kind.Signal, "traces") - require.Equal(t, exp.Kind.Model, "otlp") - require.Equal(t, exp.Kind.Protocol, "grpc") + require.Equal(t, "traces", exp.Kind.Signal) + require.Equal(t, "otlp", exp.Kind.Model) + require.Equal(t, "grpc", exp.Kind.Protocol) require.NotNil(t, exp.Spec) spec, ok := exp.Spec.(*telemetry.OTLPGRPCSpanExporter) diff --git a/common/telemetry/grpc_test.go b/common/telemetry/grpc_test.go index 1163fdd2aa9..b85f68a093e 100644 --- a/common/telemetry/grpc_test.go +++ b/common/telemetry/grpc_test.go @@ -76,7 +76,7 @@ func Test_ServerStatsHandler(t *testing.T) { spanAttrsByKey := makeRequest(nil) - require.Equal(t, + require.JSONEq(t, `{"workflowExecution":{"workflowId":"WF-ID","runId":"RUN-ID"}}`, toStr(t, spanAttrsByKey["rpc.request.payload"].Value)) require.Equal(t, "{}", spanAttrsByKey["rpc.response.payload"].Value.AsString()) @@ -88,7 +88,7 @@ func Test_ServerStatsHandler(t *testing.T) { spanAttrsByKey := makeRequest(status.Errorf(codes.Internal, "Something went wrong")) - require.Equal(t, + require.JSONEq(t, `{"code":13,"message":"Something went wrong"}`, toStr(t, spanAttrsByKey["rpc.response.error"].Value)) }) diff --git a/common/testing/historyrequire/history_require.go b/common/testing/historyrequire/history_require.go index 35365a66dbf..82a44852821 100644 --- a/common/testing/historyrequire/history_require.go +++ b/common/testing/historyrequire/history_require.go @@ -90,7 +90,7 @@ func (h HistoryRequire) EqualHistoryEvents(expectedHistory string, actualHistory expectedHistoryEvents, expectedEventsAttributes := h.parseHistory(expectedHistory) - require.Equalf(h.t, len(expectedHistoryEvents), len(actualHistoryEvents), + require.Lenf(h.t, actualHistoryEvents, len(expectedHistoryEvents), "Length of expected(%d) and actual(%d) histories is not equal - actual history: \n%v", len(expectedHistoryEvents), len(actualHistoryEvents), h.formatHistoryEvents(actualHistoryEvents, true)) @@ -151,7 +151,7 @@ func (h HistoryRequire) WaitForHistoryEvents(expectedHistory string, actualHisto var actualHistoryEvents []*historypb.HistoryEvent require.EventuallyWithT(h.t, func(t *assert.CollectT) { actualHistoryEvents = actualHistoryEventsReader() - require.Equalf(t, len(expectedHistoryEvents), len(actualHistoryEvents), + require.Lenf(t, actualHistoryEvents, len(expectedHistoryEvents), "Length of expected(%d) and actual(%d) histories is not equal - actual history: \n%v", len(expectedHistoryEvents), len(actualHistoryEvents), h.formatHistoryEvents(actualHistoryEvents, true)) }, waitFor, tick) @@ -293,7 +293,7 @@ func (h HistoryRequire) containsHistoryEvents( actualCompactHistory := h.formatHistoryEvents(actualHistoryEvents, true) startPos := strings.Index(actualCompactHistory, expectedCompactHistory) - require.True(h.t, startPos >= 0, "Expected history is not found in actual history. Expected:\n%s\nActual:\n%s", expectedCompactHistory, actualCompactHistory) + require.GreaterOrEqual(h.t, startPos, 0, "Expected history is not found in actual history. Expected:\n%s\nActual:\n%s", expectedCompactHistory, actualCompactHistory) actualHistoryEventsFirstIndex := strings.Count(actualCompactHistory[:startPos], "\n") h.equalHistoryEventsAttributes(expectedEventsAttributes, actualHistoryEvents[actualHistoryEventsFirstIndex:]) diff --git a/common/util/util_test.go b/common/util/util_test.go index 8e2ff68f63b..0df2b134727 100644 --- a/common/util/util_test.go +++ b/common/util/util_test.go @@ -14,17 +14,17 @@ func TestRepeatSlice(t *testing.T) { t.Run("when input slice is empty should return empty", func(t *testing.T) { empty := []int{} got := RepeatSlice(empty, 5) - require.Len(t, got, 0, "RepeatSlice filled empty slice") + require.Empty(t, got, "RepeatSlice filled empty slice") }) t.Run("when requested repeat number equal 0 should return empty slice", func(t *testing.T) { xs := []int{1, 2, 3, 4, 5} got := RepeatSlice(xs, 0) - require.Len(t, got, 0, "RepeatSlice with repeat count 0 returned non-empty slice") + require.Empty(t, got, "RepeatSlice with repeat count 0 returned non-empty slice") }) t.Run("when requested repeat number is less than 0 should return empty slice", func(t *testing.T) { xs := []int{1, 2, 3, 4, 5} got := RepeatSlice(xs, -1) - require.Len(t, got, 0, "RepeatSlice with repeat count -1 returned non-empty slice") + require.Empty(t, got, "RepeatSlice with repeat count -1 returned non-empty slice") }) t.Run("when requested repeat number is 3 should return slice three times the input", func(t *testing.T) { xs := []int{1, 2, 3, 4, 5} @@ -147,7 +147,7 @@ func TestMapSlice(t *testing.T) { xs := []int{} var ys []uint32 ys = MapSlice(xs, func(x int) uint32 { return uint32(x) }) - require.Len(t, ys, 0, "mapping over empty slice produced non empty slice got %v", ys) + require.Empty(t, ys, "mapping over empty slice produced non empty slice got %v", ys) }) t.Run("when given a slice and a function should apply function to every element of the original slice", func(t *testing.T) { xs := []int{1, 2, 3, 4, 5} diff --git a/service/frontend/configs/quotas_test.go b/service/frontend/configs/quotas_test.go index 60d697b1271..5ce6dfb232d 100644 --- a/service/frontend/configs/quotas_test.go +++ b/service/frontend/configs/quotas_test.go @@ -69,19 +69,19 @@ func (s *quotasSuite) TestNamespaceReplicationInducingAPIToPriorityMapping() { func (s *quotasSuite) TestExecutionAPIPrioritiesOrdered() { for idx := range ExecutionAPIPrioritiesOrdered[1:] { - s.True(ExecutionAPIPrioritiesOrdered[idx] < ExecutionAPIPrioritiesOrdered[idx+1]) + s.Less(ExecutionAPIPrioritiesOrdered[idx], ExecutionAPIPrioritiesOrdered[idx+1]) } } func (s *quotasSuite) TestVisibilityAPIPrioritiesOrdered() { for idx := range VisibilityAPIPrioritiesOrdered[1:] { - s.True(VisibilityAPIPrioritiesOrdered[idx] < VisibilityAPIPrioritiesOrdered[idx+1]) + s.Less(VisibilityAPIPrioritiesOrdered[idx], VisibilityAPIPrioritiesOrdered[idx+1]) } } func (s *quotasSuite) TestNamespaceReplicationInducingAPIPrioritiesOrdered() { for idx := range NamespaceReplicationInducingAPIPrioritiesOrdered[1:] { - s.True(NamespaceReplicationInducingAPIPrioritiesOrdered[idx] < NamespaceReplicationInducingAPIPrioritiesOrdered[idx+1]) + s.Less(NamespaceReplicationInducingAPIPrioritiesOrdered[idx], NamespaceReplicationInducingAPIPrioritiesOrdered[idx+1]) } } diff --git a/service/frontend/namespace_handler_test.go b/service/frontend/namespace_handler_test.go index c245c858fd6..eee83dca972 100644 --- a/service/frontend/namespace_handler_test.go +++ b/service/frontend/namespace_handler_test.go @@ -7,7 +7,6 @@ import ( "time" "github.com/google/uuid" - "github.com/stretchr/testify/assert" "github.com/stretchr/testify/suite" enumspb "go.temporal.io/api/enums/v1" namespacepb "go.temporal.io/api/namespace/v1" @@ -112,7 +111,7 @@ func (s *namespaceHandlerCommonSuite) TestMergeNamespaceData_Overriding() { }, ) - assert.Equal(s.T(), map[string]string{ + s.Equal(map[string]string{ "k0": "v2", }, out) } @@ -127,7 +126,7 @@ func (s *namespaceHandlerCommonSuite) TestMergeNamespaceData_Adding() { }, ) - assert.Equal(s.T(), map[string]string{ + s.Equal(map[string]string{ "k0": "v0", "k1": "v2", }, out) @@ -144,7 +143,7 @@ func (s *namespaceHandlerCommonSuite) TestMergeNamespaceData_Merging() { }, ) - assert.Equal(s.T(), map[string]string{ + s.Equal(map[string]string{ "k0": "v1", "k1": "v2", }, out) @@ -159,7 +158,7 @@ func (s *namespaceHandlerCommonSuite) TestMergeNamespaceData_Nil() { }, ) - assert.Equal(s.T(), map[string]string{ + s.Equal(map[string]string{ "k0": "v1", "k1": "v2", }, out) @@ -199,7 +198,7 @@ func (s *namespaceHandlerCommonSuite) TestMergeBadBinaries_Adding() { "k1": {Reason: "reason2", CreateTime: timestamppb.New(now)}, }, } - assert.Equal(s.T(), out.String(), expected.String()) + s.Equal(out.String(), expected.String()) } func (s *namespaceHandlerCommonSuite) TestMergeBadBinaries_Merging() { @@ -331,7 +330,7 @@ func (s *namespaceHandlerCommonSuite) TestListNamespace() { }) s.NoError(err) token = resp.NextPageToken - s.True(len(resp.Namespaces) <= int(pagesize)) + s.LessOrEqual(len(resp.Namespaces), int(pagesize)) if len(resp.Namespaces) > 0 { namespaces[resp.Namespaces[0].NamespaceInfo.GetName()] = resp.Namespaces[0] } @@ -1004,7 +1003,7 @@ func (s *namespaceHandlerCommonSuite) TestRegisterLocalNamespace_AllDefault() { s.NotEmpty(request.Namespace.GetInfo().GetId()) s.Equal(enumspb.NAMESPACE_STATE_REGISTERED, request.Namespace.Info.GetState()) s.Equal(namespace, request.Namespace.GetInfo().GetName()) - s.Equal(false, request.IsGlobalNamespace) + s.False(request.IsGlobalNamespace) s.Equal(retention, request.Namespace.GetConfig().GetRetention()) s.Equal(cluster.TestCurrentClusterName, request.Namespace.GetReplicationConfig().ActiveClusterName) s.Equal([]string{cluster.TestCurrentClusterName}, request.Namespace.GetReplicationConfig().GetClusters()) @@ -1054,7 +1053,7 @@ func (s *namespaceHandlerCommonSuite) TestRegisterLocalNamespace_NoDefault() { s.Equal(description, request.Namespace.GetInfo().GetDescription()) s.Equal(email, request.Namespace.GetInfo().GetOwner()) s.Equal(data, request.Namespace.GetInfo().GetData()) - s.Equal(false, request.IsGlobalNamespace) + s.False(request.IsGlobalNamespace) s.Equal(retention, request.Namespace.GetConfig().GetRetention()) s.Equal(activeClusterName, request.Namespace.GetReplicationConfig().ActiveClusterName) s.Equal([]string{activeClusterName}, request.Namespace.GetReplicationConfig().GetClusters()) @@ -1231,7 +1230,7 @@ func (s *namespaceHandlerCommonSuite) TestRegisterGlobalNamespace_AllDefault() { s.NotEmpty(request.Namespace.GetInfo().GetId()) s.Equal(enumspb.NAMESPACE_STATE_REGISTERED, request.Namespace.Info.GetState()) s.Equal(namespace, request.Namespace.GetInfo().GetName()) - s.Equal(true, request.IsGlobalNamespace) + s.True(request.IsGlobalNamespace) s.Equal(retention, request.Namespace.GetConfig().GetRetention()) s.Equal(cluster.TestCurrentClusterName, request.Namespace.GetReplicationConfig().ActiveClusterName) s.Equal([]string{cluster.TestCurrentClusterName}, request.Namespace.GetReplicationConfig().GetClusters()) @@ -1285,7 +1284,7 @@ func (s *namespaceHandlerCommonSuite) TestRegisterGlobalNamespace_NoDefault() { s.NotEmpty(request.Namespace.GetInfo().GetId()) s.Equal(enumspb.NAMESPACE_STATE_REGISTERED, request.Namespace.Info.GetState()) s.Equal(namespace, request.Namespace.GetInfo().GetName()) - s.Equal(true, request.IsGlobalNamespace) + s.True(request.IsGlobalNamespace) s.Equal(retention, request.Namespace.GetConfig().GetRetention()) s.Equal(cluster.TestCurrentClusterName, request.Namespace.GetReplicationConfig().ActiveClusterName) s.Equal([]string{cluster.TestCurrentClusterName, cluster.TestAlternativeClusterName}, request.Namespace.GetReplicationConfig().GetClusters()) @@ -1457,7 +1456,7 @@ func (s *namespaceHandlerCommonSuite) TestRegisterLocalNamespace_NotMaster() { s.NotEmpty(request.Namespace.GetInfo().GetId()) s.Equal(enumspb.NAMESPACE_STATE_REGISTERED, request.Namespace.Info.GetState()) s.Equal(namespace, request.Namespace.GetInfo().GetName()) - s.Equal(false, request.IsGlobalNamespace) + s.False(request.IsGlobalNamespace) s.Equal(retention, request.Namespace.GetConfig().GetRetention()) s.Equal(cluster.TestCurrentClusterName, request.Namespace.GetReplicationConfig().ActiveClusterName) s.Equal([]string{cluster.TestCurrentClusterName}, request.Namespace.GetReplicationConfig().GetClusters()) @@ -1910,14 +1909,14 @@ func (s *namespaceHandlerCommonSuite) TestListWorkflowRules() { rules, err := s.handler.ListWorkflowRules(context.Background(), namespaceName) s.NoError(err) s.NotNil(rules) - s.Equal(2, len(rules)) + s.Len(rules, 2) // config is nil nsConfig.WorkflowRules = nil rules, err = s.handler.ListWorkflowRules(context.Background(), namespaceName) s.NoError(err) s.NotNil(rules) - s.Equal(0, len(rules)) + s.Empty(rules) } func (s *namespaceHandlerCommonSuite) TestWorkflowRuleEviction() { @@ -1955,7 +1954,7 @@ func (s *namespaceHandlerCommonSuite) TestWorkflowRuleEviction() { oldLens := len(tt.rules) s.handler.removeOldestExpiredWorkflowRule("", tt.rules) if len(tt.deletedRule) == 0 { - s.Equal(oldLens, len(tt.rules)) + s.Len(tt.rules, oldLens) } else { if _, exists := tt.rules[tt.deletedRule]; exists { s.True(false, "Rule was not deleted") diff --git a/service/frontend/nexus_handler_test.go b/service/frontend/nexus_handler_test.go index d27c363fab5..0f4d13565c0 100644 --- a/service/frontend/nexus_handler_test.go +++ b/service/frontend/nexus_handler_test.go @@ -201,7 +201,7 @@ func TestNexusInterceptRequest_InvalidNamespaceState_ResultsInBadRequest(t *test oc.metricsHandler.Counter("test").Record(1) mh.StopCapture(capture) snap := capture.Snapshot() - require.Equal(t, 1, len(snap["test"])) + require.Len(t, snap["test"], 1) require.Equal(t, map[string]string{"outcome": "invalid_namespace_state"}, snap["test"][0].Tags) } @@ -225,7 +225,7 @@ func TestNexusInterceptRequest_NamespaceConcurrencyLimited_ResultsInResourceExha oc.metricsHandler.Counter("test").Record(1) mh.StopCapture(capture) snap := capture.Snapshot() - require.Equal(t, 1, len(snap["test"])) + require.Len(t, snap["test"], 1) require.Equal(t, map[string]string{"outcome": "namespace_concurrency_limited"}, snap["test"][0].Tags) } @@ -249,7 +249,7 @@ func TestNexusInterceptRequest_NamespaceRateLimited_ResultsInResourceExhausted(t oc.metricsHandler.Counter("test").Record(1) mh.StopCapture(capture) snap := capture.Snapshot() - require.Equal(t, 1, len(snap["test"])) + require.Len(t, snap["test"], 1) require.Equal(t, map[string]string{"outcome": "namespace_rate_limited"}, snap["test"][0].Tags) } @@ -273,7 +273,7 @@ func TestNexusInterceptRequest_GlobalRateLimited_ResultsInResourceExhausted(t *t oc.metricsHandler.Counter("test").Record(1) mh.StopCapture(capture) snap := capture.Snapshot() - require.Equal(t, 1, len(snap["test"])) + require.Len(t, snap["test"], 1) require.Equal(t, map[string]string{"outcome": "global_rate_limited"}, snap["test"][0].Tags) } @@ -298,7 +298,7 @@ func TestNexusInterceptRequest_ForwardingDisabled_ResultsInUnavailable(t *testin oc.metricsHandler.Counter("test").Record(1) mh.StopCapture(capture) snap := capture.Snapshot() - require.Equal(t, 1, len(snap["test"])) + require.Len(t, snap["test"], 1) require.Equal(t, map[string]string{"outcome": "namespace_inactive_forwarding_disabled"}, snap["test"][0].Tags) } @@ -322,7 +322,7 @@ func TestNexusInterceptRequest_ForwardingEnabled_ResultsInNotActiveError(t *test oc.metricsHandler.Counter("test").Record(1) mh.StopCapture(capture) snap := capture.Snapshot() - require.Equal(t, 1, len(snap["test"])) + require.Len(t, snap["test"], 1) require.Equal(t, map[string]string{"outcome": "request_forwarded"}, snap["test"][0].Tags) } @@ -349,7 +349,7 @@ func TestNexusInterceptRequest_InvalidSDKVersion_ResultsInBadRequest(t *testing. oc.metricsHandler.Counter("test").Record(1) mh.StopCapture(capture) snap := capture.Snapshot() - require.Equal(t, 1, len(snap["test"])) + require.Len(t, snap["test"], 1) require.Equal(t, map[string]string{"outcome": "unsupported_client"}, snap["test"][0].Tags) } diff --git a/service/history/api/getdlqtasks/getdlqtaskstest/apitest.go b/service/history/api/getdlqtasks/getdlqtaskstest/apitest.go index 0d8fb542d3b..5230edd1f1e 100644 --- a/service/history/api/getdlqtasks/getdlqtaskstest/apitest.go +++ b/service/history/api/getdlqtasks/getdlqtaskstest/apitest.go @@ -55,7 +55,7 @@ func TestInvoke(t *testing.T, manager persistence.HistoryTaskQueueManager) { }, ) require.NoError(t, err) - require.Equal(t, 1, len(res.DlqTasks)) + require.Len(t, res.DlqTasks, 1) assert.Equal(t, int64(persistence.FirstQueueMessageID), res.DlqTasks[0].Metadata.MessageId) assert.Equal(t, 1, int(res.DlqTasks[0].Payload.ShardId)) serializer := serialization.NewSerializer() diff --git a/service/history/api/respondactivitytaskfailed/api_test.go b/service/history/api/respondactivitytaskfailed/api_test.go index 6f5dea10047..8b889c15b45 100644 --- a/service/history/api/respondactivitytaskfailed/api_test.go +++ b/service/history/api/respondactivitytaskfailed/api_test.go @@ -166,7 +166,7 @@ func (s *workflowSuite) Test_WorkflowExecutionIsNotRunning_ReturnWorkflowNotRunn s.workflowConsistencyChecker, ) s.Error(err) - s.EqualValues(consts.ErrWorkflowCompleted, err) + s.Equal(consts.ErrWorkflowCompleted, err) } func (s *workflowSuite) Test_CacheRefreshRequired_ReturnCacheStaleError() { @@ -210,7 +210,7 @@ func (s *workflowSuite) Test_ActivityTaskDoesNotExist_ActivityNotRunning() { s.workflowConsistencyChecker, ) s.Error(err) - s.EqualValues(consts.ErrActivityTaskNotFound, err) + s.Equal(consts.ErrActivityTaskNotFound, err) } func (s *workflowSuite) Test_ActivityTaskDoesNotExist_TokenVersionDoesNotMatchActivityVersion() { @@ -232,7 +232,7 @@ func (s *workflowSuite) Test_ActivityTaskDoesNotExist_TokenVersionDoesNotMatchAc s.workflowConsistencyChecker, ) s.Error(err) - s.EqualValues(consts.ErrActivityTaskNotFound, err) + s.Equal(consts.ErrActivityTaskNotFound, err) } func (s *workflowSuite) Test_ActivityTaskDoesNotExist_TokenVersionNonZeroAndAttemptDoesNotMatchActivityAttempt() { @@ -255,7 +255,7 @@ func (s *workflowSuite) Test_ActivityTaskDoesNotExist_TokenVersionNonZeroAndAtte s.workflowConsistencyChecker, ) s.Error(err) - s.EqualValues(consts.ErrActivityTaskNotFound, err) + s.Equal(consts.ErrActivityTaskNotFound, err) } func (s *workflowSuite) Test_LastHeartBeatDetailsExist_UpdatesMutableState() { diff --git a/service/history/api/signalwithstartworkflow/signal_with_start_workflow_test.go b/service/history/api/signalwithstartworkflow/signal_with_start_workflow_test.go index 91b89a497f6..36a6309f24d 100644 --- a/service/history/api/signalwithstartworkflow/signal_with_start_workflow_test.go +++ b/service/history/api/signalwithstartworkflow/signal_with_start_workflow_test.go @@ -99,7 +99,7 @@ func (s *signalWithStartWorkflowSuite) TestSignalWorkflow_WorkflowCloseAttempted currentWorkflowLease, request, ) - s.Error(consts.ErrWorkflowClosing, err) + s.ErrorIs(consts.ErrWorkflowClosing, err) } func (s *signalWithStartWorkflowSuite) TestSignalWorkflow_Dedup() { diff --git a/service/history/api/signalworkflow/api_test.go b/service/history/api/signalworkflow/api_test.go index 9ec94a110fd..174d834e99b 100644 --- a/service/history/api/signalworkflow/api_test.go +++ b/service/history/api/signalworkflow/api_test.go @@ -119,5 +119,5 @@ func (s *signalWorkflowSuite) TestSignalWorkflow_WorkflowCloseAttempted() { s.workflowConsistencyChecker, ) s.Nil(resp) - s.Error(consts.ErrWorkflowClosing, err) + s.ErrorIs(consts.ErrWorkflowClosing, err) } diff --git a/service/history/configs/quotas_test.go b/service/history/configs/quotas_test.go index fec8d229af4..f6ad7f78c74 100644 --- a/service/history/configs/quotas_test.go +++ b/service/history/configs/quotas_test.go @@ -45,7 +45,7 @@ func (s *quotasSuite) TestCallerTypeToPriorityMapping() { func (s *quotasSuite) TestAPIPrioritiesOrdered() { for idx := range APIPrioritiesOrdered[1:] { - s.True(APIPrioritiesOrdered[idx] < APIPrioritiesOrdered[idx+1]) + s.Less(APIPrioritiesOrdered[idx], APIPrioritiesOrdered[idx+1]) } } diff --git a/service/history/events/cache_test.go b/service/history/events/cache_test.go index 95b0dbc58d7..9cc5638c45c 100644 --- a/service/history/events/cache_test.go +++ b/service/history/events/cache_test.go @@ -89,7 +89,7 @@ func (s *eventsCacheSuite) TestEventsCacheHitSuccess() { shardID, EventKey{namespaceID, workflowID, runID, eventID, common.EmptyVersion}, eventID, nil) - s.Nil(err) + s.NoError(err) s.Equal(event, actualEvent) } @@ -149,7 +149,7 @@ func (s *eventsCacheSuite) TestEventsCacheMissMultiEventsBatchV2Success() { shardID, EventKey{namespaceID, workflowID, runID, event6.GetEventId(), common.EmptyVersion}, event1.GetEventId(), []byte("store_token")) - s.Nil(err) + s.NoError(err) s.Equal(event6, actualEvent) } @@ -218,7 +218,7 @@ func (s *eventsCacheSuite) TestEventsCacheDisableSuccess() { shardID, EventKey{namespaceID, workflowID, runID, event2.GetEventId(), common.EmptyVersion}, event2.GetEventId(), []byte("store_token")) - s.Nil(err) + s.NoError(err) s.Equal(event2, actualEvent) } diff --git a/service/history/events/notifier_test.go b/service/history/events/notifier_test.go index 61ae3d2471d..f4418d94929 100644 --- a/service/history/events/notifier_test.go +++ b/service/history/events/notifier_test.go @@ -83,7 +83,7 @@ func (s *notifierSuite) TestSingleSubscriberWatchingEvents() { timerChan := time.NewTimer(time.Second * 2).C subscriberID, channel, err := s.notifier.WatchHistoryEvent(definition.NewWorkflowKey(namespaceID, execution.GetWorkflowId(), execution.GetRunId())) - s.Nil(err) + s.NoError(err) go func() { <-timerChan @@ -94,7 +94,7 @@ func (s *notifierSuite) TestSingleSubscriberWatchingEvents() { s.Equal(historyEvent, msg) err = s.notifier.UnwatchHistoryEvent(definition.NewWorkflowKey(namespaceID, execution.GetWorkflowId(), execution.GetRunId()), subscriberID) - s.Nil(err) + s.NoError(err) } func (s *notifierSuite) TestMultipleSubscriberWatchingEvents() { @@ -127,7 +127,7 @@ func (s *notifierSuite) TestMultipleSubscriberWatchingEvents() { watchFunc := func() { subscriberID, channel, err := s.notifier.WatchHistoryEvent(definition.NewWorkflowKey(namespaceID, execution.GetWorkflowId(), execution.GetRunId())) - s.Nil(err) + s.NoError(err) timeourChan := time.NewTimer(time.Second * 10).C @@ -138,7 +138,7 @@ func (s *notifierSuite) TestMultipleSubscriberWatchingEvents() { s.Fail("subscribe to new events timeout") } err = s.notifier.UnwatchHistoryEvent(definition.NewWorkflowKey(namespaceID, execution.GetWorkflowId(), execution.GetRunId()), subscriberID) - s.Nil(err) + s.NoError(err) waitGroup.Done() } diff --git a/service/history/history_engine3_eventsv2_test.go b/service/history/history_engine3_eventsv2_test.go index d0a3391cdad..191fdceb2b7 100644 --- a/service/history/history_engine3_eventsv2_test.go +++ b/service/history/history_engine3_eventsv2_test.go @@ -263,7 +263,7 @@ func (s *engine3Suite) TestRecordWorkflowTaskStartedSuccessStickyEnabled() { expectedResponse.NextPageToken = nil response, err := s.historyEngine.RecordWorkflowTaskStarted(context.Background(), &request) - s.Nil(err) + s.NoError(err) s.NotNil(response) s.True(response.StartedTime.AsTime().After(expectedResponse.ScheduledTime.AsTime())) expectedResponse.StartedTime = response.StartedTime @@ -377,7 +377,7 @@ func (s *engine3Suite) TestRecordWorkflowTaskStartedSuccessStickyEnabled_WithInt expectedResponse.NextPageToken = nil response, err := s.historyEngine.RecordWorkflowTaskStarted(context.Background(), &request) - s.Nil(err) + s.NoError(err) s.NotNil(response) s.True(response.StartedTime.AsTime().After(expectedResponse.ScheduledTime.AsTime())) expectedResponse.StartedTime = response.StartedTime @@ -414,7 +414,7 @@ func (s *engine3Suite) TestStartWorkflowExecution_BrandNew() { RequestId: requestID, }, }) - s.Nil(err) + s.NoError(err) s.NotNil(resp.RunId) } @@ -472,7 +472,7 @@ func (s *engine3Suite) TestSignalWithStartWorkflowExecution_JustSignal() { s.mockExecutionMgr.EXPECT().UpdateWorkflowExecution(gomock.Any(), gomock.Any()).Return(tests.UpdateWorkflowExecutionResponse, nil) resp, err := s.historyEngine.SignalWithStartWorkflowExecution(context.Background(), sRequest) - s.Nil(err) + s.NoError(err) s.Equal(runID, resp.GetRunId()) } @@ -521,6 +521,6 @@ func (s *engine3Suite) TestSignalWithStartWorkflowExecution_WorkflowNotExist() { s.mockExecutionMgr.EXPECT().CreateWorkflowExecution(gomock.Any(), gomock.Any()).Return(tests.CreateWorkflowExecutionResponse, nil) resp, err := s.historyEngine.SignalWithStartWorkflowExecution(context.Background(), sRequest) - s.Nil(err) + s.NoError(err) s.NotNil(resp.GetRunId()) } diff --git a/service/history/hsm/tree_test.go b/service/history/hsm/tree_test.go index 766e1fe8f48..8bdc9162c4b 100644 --- a/service/history/hsm/tree_test.go +++ b/service/history/hsm/tree_test.go @@ -61,7 +61,7 @@ func TestNode_MaintainsCachedData(t *testing.T) { require.False(t, root.Dirty()) opLog, err := root.OpLog() require.NoError(t, err) - require.Equal(t, 0, len(opLog)) + require.Empty(t, opLog) err = hsm.MachineTransition(root, func(d *hsmtest.Data) (hsm.TransitionOutput, error) { d.SetState(hsmtest.State2) @@ -75,7 +75,7 @@ func TestNode_MaintainsCachedData(t *testing.T) { require.True(t, root.Dirty()) opLog, err = root.OpLog() require.NoError(t, err) - require.Equal(t, 1, len(opLog)) + require.Len(t, opLog, 1) transOp, ok := opLog[0].(hsm.TransitionOperation) require.True(t, ok) @@ -131,7 +131,7 @@ func TestNode_MaintainsChildCache(t *testing.T) { opLog, err := root.OpLog() require.NoError(t, err) - require.Equal(t, 1, len(opLog)) + require.Len(t, opLog, 1) transOp, ok := opLog[0].(hsm.TransitionOperation) require.True(t, ok) require.Equal(t, int64(1), transOp.Output.TransitionCount) @@ -675,7 +675,7 @@ func TestNode_DeleteDeepHierarchy(t *testing.T) { case hsm.TransitionOperation: transitionCount++ pathLen := len(o.Path()) - require.True(t, pathLen <= 3, "should not see transitions for deleted nodes") + require.LessOrEqual(t, pathLen, 3, "should not see transitions for deleted nodes") case hsm.DeleteOperation: deletionCount++ } diff --git a/service/history/tasks/key_test.go b/service/history/tasks/key_test.go index 993a521a276..a29241741d4 100644 --- a/service/history/tasks/key_test.go +++ b/service/history/tasks/key_test.go @@ -70,12 +70,12 @@ func (s *taskKeySuite) TestMinMaxKey() { thatKey := NewKey(time.Unix(0, rand.Int63()), rand.Int63()) minKey := MinKey(thisKey, thatKey) - s.True(minKey.CompareTo(thisKey) <= 0) - s.True(minKey.CompareTo(thatKey) <= 0) + s.LessOrEqual(minKey.CompareTo(thisKey), 0) + s.LessOrEqual(minKey.CompareTo(thatKey), 0) maxKey := MaxKey(thisKey, thatKey) - s.True(maxKey.CompareTo(thisKey) >= 0) - s.True(maxKey.CompareTo(thisKey) >= 0) + s.GreaterOrEqual(maxKey.CompareTo(thisKey), 0) + s.GreaterOrEqual(maxKey.CompareTo(thisKey), 0) } func (s *taskKeySuite) TestSort() { @@ -98,7 +98,7 @@ func (s *taskKeySuite) TestSort() { if prev.FireTime.Before(next.FireTime) { // noop } else if prev.FireTime.Equal(next.FireTime) { - s.True(prev.TaskID <= next.TaskID) + s.LessOrEqual(prev.TaskID, next.TaskID) } else { s.Fail("task keys are not sorted prev: %v, next: %v", prev, next) } diff --git a/service/history/timer_queue_standby_task_executor_test.go b/service/history/timer_queue_standby_task_executor_test.go index 408cb438d12..e1325e39008 100644 --- a/service/history/timer_queue_standby_task_executor_test.go +++ b/service/history/timer_queue_standby_task_executor_test.go @@ -353,7 +353,7 @@ func (s *timerQueueStandbyTaskExecutorSuite) TestProcessUserTimerTimeout_Success s.mockShard.SetCurrentTime(s.clusterName, s.now) resp := s.timerQueueStandbyTaskExecutor.Execute(context.Background(), s.newTaskExecutable(timerTask)) - s.Nil(resp.ExecutionErr) + s.NoError(resp.ExecutionErr) } func (s *timerQueueStandbyTaskExecutorSuite) TestProcessUserTimerTimeout_Multiple() { @@ -420,7 +420,7 @@ func (s *timerQueueStandbyTaskExecutorSuite) TestProcessUserTimerTimeout_Multipl s.mockShard.SetCurrentTime(s.clusterName, s.now) resp := s.timerQueueStandbyTaskExecutor.Execute(context.Background(), s.newTaskExecutable(timerTask)) - s.Nil(resp.ExecutionErr) + s.NoError(resp.ExecutionErr) } func (s *timerQueueStandbyTaskExecutorSuite) TestProcessActivityTimeout_Pending() { @@ -570,7 +570,7 @@ func (s *timerQueueStandbyTaskExecutorSuite) TestProcessActivityTimeout_Success( s.mockShard.SetCurrentTime(s.clusterName, s.now) resp := s.timerQueueStandbyTaskExecutor.Execute(context.Background(), s.newTaskExecutable(timerTask)) - s.Nil(resp.ExecutionErr) + s.NoError(resp.ExecutionErr) } func (s *timerQueueStandbyTaskExecutorSuite) TestProcessActivityTimeout_Heartbeat_Noop() { @@ -640,7 +640,7 @@ func (s *timerQueueStandbyTaskExecutorSuite) TestProcessActivityTimeout_Heartbea s.mockShard.SetCurrentTime(s.clusterName, s.now) resp := s.timerQueueStandbyTaskExecutor.Execute(context.Background(), s.newTaskExecutable(timerTask)) - s.Nil(resp.ExecutionErr) + s.NoError(resp.ExecutionErr) } func (s *timerQueueStandbyTaskExecutorSuite) TestProcessActivityTimeout_Multiple_CanUpdate() { @@ -718,8 +718,8 @@ func (s *timerQueueStandbyTaskExecutorSuite) TestProcessActivityTimeout_Multiple s.mockExecutionMgr.EXPECT().GetWorkflowExecution(gomock.Any(), gomock.Any()).Return(&persistence.GetWorkflowExecutionResponse{State: persistenceMutableState}, nil) s.mockExecutionMgr.EXPECT().UpdateWorkflowExecution(gomock.Any(), gomock.Any()).DoAndReturn( func(_ context.Context, input *persistence.UpdateWorkflowExecutionRequest) (*persistence.UpdateWorkflowExecutionResponse, error) { - s.Equal(1, len(input.UpdateWorkflowMutation.Tasks[tasks.CategoryTimer])) - s.Equal(1, len(input.UpdateWorkflowMutation.UpsertActivityInfos)) + s.Len(input.UpdateWorkflowMutation.Tasks[tasks.CategoryTimer], 1) + s.Len(input.UpdateWorkflowMutation.UpsertActivityInfos, 1) mutableState.GetExecutionInfo().LastUpdateTime = input.UpdateWorkflowMutation.ExecutionInfo.LastUpdateTime input.RangeID = 0 input.UpdateWorkflowMutation.ExecutionInfo.LastRunningClock = 0 @@ -761,7 +761,7 @@ func (s *timerQueueStandbyTaskExecutorSuite) TestProcessActivityTimeout_Multiple s.mockShard.SetCurrentTime(s.clusterName, s.now) resp := s.timerQueueStandbyTaskExecutor.Execute(context.Background(), s.newTaskExecutable(timerTask)) - s.Nil(resp.ExecutionErr) + s.NoError(resp.ExecutionErr) } // TestProcessUserTimerTimeout_StandbyFiresUnderSkip: without virtual time, the @@ -1067,7 +1067,7 @@ func (s *timerQueueStandbyTaskExecutorSuite) TestProcessWorkflowTaskTimeout_Sche s.mockShard.SetCurrentTime(s.clusterName, s.now) resp := s.timerQueueStandbyTaskExecutor.Execute(context.Background(), s.newTaskExecutable(timerTask)) - s.Equal(nil, resp.ExecutionErr) + s.NoError(resp.ExecutionErr) } func (s *timerQueueStandbyTaskExecutorSuite) TestProcessWorkflowTaskTimeout_Success() { @@ -1120,7 +1120,7 @@ func (s *timerQueueStandbyTaskExecutorSuite) TestProcessWorkflowTaskTimeout_Succ s.mockShard.SetCurrentTime(s.clusterName, s.now) resp := s.timerQueueStandbyTaskExecutor.Execute(context.Background(), s.newTaskExecutable(timerTask)) - s.Nil(resp.ExecutionErr) + s.NoError(resp.ExecutionErr) } func (s *timerQueueStandbyTaskExecutorSuite) TestProcessWorkflowTaskTimeout_AttemptMismatch() { @@ -1355,7 +1355,7 @@ func (s *timerQueueStandbyTaskExecutorSuite) TestProcessWorkflowBackoffTimer_Suc s.mockShard.SetCurrentTime(s.clusterName, s.now) resp := s.timerQueueStandbyTaskExecutor.Execute(context.Background(), s.newTaskExecutable(timerTask)) - s.Nil(resp.ExecutionErr) + s.NoError(resp.ExecutionErr) } func (s *timerQueueStandbyTaskExecutorSuite) TestProcessWorkflowRunTimeout_Pending() { @@ -1475,7 +1475,7 @@ func (s *timerQueueStandbyTaskExecutorSuite) TestProcessWorkflowRunTimeout_Succe s.mockShard.SetCurrentTime(s.clusterName, s.now) resp := s.timerQueueStandbyTaskExecutor.Execute(context.Background(), s.newTaskExecutable(timerTask)) - s.Nil(resp.ExecutionErr) + s.NoError(resp.ExecutionErr) } func (s *timerQueueStandbyTaskExecutorSuite) TestProcessWorkflowExecutionTimeout_Pending() { @@ -1607,7 +1607,7 @@ func (s *timerQueueStandbyTaskExecutorSuite) TestProcessWorkflowExecutionTimeout s.mockShard.SetCurrentTime(s.clusterName, s.now) resp := s.timerQueueStandbyTaskExecutor.Execute(context.Background(), s.newTaskExecutable(timerTask)) - s.Nil(resp.ExecutionErr) + s.NoError(resp.ExecutionErr) } func (s *timerQueueStandbyTaskExecutorSuite) TestProcessRetryTimeout() { @@ -1650,7 +1650,7 @@ func (s *timerQueueStandbyTaskExecutorSuite) TestProcessRetryTimeout() { s.mockShard.SetCurrentTime(s.clusterName, s.now) resp := s.timerQueueStandbyTaskExecutor.Execute(context.Background(), s.newTaskExecutable(timerTask)) - s.Nil(resp.ExecutionErr) + s.NoError(resp.ExecutionErr) } func (s *timerQueueStandbyTaskExecutorSuite) TestProcessActivityRetryTimer_Noop() { @@ -1718,7 +1718,7 @@ func (s *timerQueueStandbyTaskExecutorSuite) TestProcessActivityRetryTimer_Noop( EventID: scheduledEvent.GetEventId(), } resp := s.timerQueueStandbyTaskExecutor.Execute(context.Background(), s.newTaskExecutable(timerTask)) - s.Nil(resp.ExecutionErr) + s.NoError(resp.ExecutionErr) timerTask = &tasks.ActivityRetryTimerTask{ WorkflowKey: definition.NewWorkflowKey( @@ -1748,7 +1748,7 @@ func (s *timerQueueStandbyTaskExecutorSuite) TestProcessActivityRetryTimer_Noop( EventID: scheduledEvent.GetEventId(), } resp = s.timerQueueStandbyTaskExecutor.Execute(context.Background(), s.newTaskExecutable(timerTask)) - s.Nil(resp.ExecutionErr) + s.NoError(resp.ExecutionErr) } func (s *timerQueueStandbyTaskExecutorSuite) TestProcessActivityRetryTimer_ActivityCompleted() { @@ -1817,7 +1817,7 @@ func (s *timerQueueStandbyTaskExecutorSuite) TestProcessActivityRetryTimer_Activ EventID: scheduledEvent.GetEventId(), } resp := s.timerQueueStandbyTaskExecutor.Execute(context.Background(), s.newTaskExecutable(timerTask)) - s.Nil(resp.ExecutionErr) + s.NoError(resp.ExecutionErr) } func (s *timerQueueStandbyTaskExecutorSuite) TestProcessActivityRetryTimer_Pending() { @@ -1912,7 +1912,7 @@ func (s *timerQueueStandbyTaskExecutorSuite) TestProcessActivityRetryTimer_Pendi ).Return(&matchingservice.AddActivityTaskResponse{}, nil) resp = s.timerQueueStandbyTaskExecutor.Execute(context.Background(), s.newTaskExecutable(timerTask)) - s.Nil(resp.ExecutionErr) + s.NoError(resp.ExecutionErr) } func (s *timerQueueStandbyTaskExecutorSuite) TestExecuteStateMachineTimerTask_ExecutesAllAvailableTimers() { @@ -2036,7 +2036,7 @@ func (s *timerQueueStandbyTaskExecutorSuite) TestExecuteStateMachineTimerTask_Ex err = timerQueueStandbyTaskExecutor.executeStateMachineTimerTask(context.Background(), task) s.NoError(err) - s.Equal(1, len(info.StateMachineTimers)) + s.Len(info.StateMachineTimers, 1) s.Equal(futureDeadline, info.StateMachineTimers[0].Deadline.AsTime()) } @@ -2146,7 +2146,7 @@ func (s *timerQueueStandbyTaskExecutorSuite) TestExecuteStateMachineTimerTask_Va err = timerQueueStandbyTaskExecutor.executeStateMachineTimerTask(context.Background(), task) s.ErrorIs(err, consts.ErrTaskRetry) - s.Equal(1, len(info.StateMachineTimers)) + s.Len(info.StateMachineTimers, 1) } func (s *timerQueueStandbyTaskExecutorSuite) TestExecuteStateMachineTimerTask_StaleStateMachine() { @@ -2251,7 +2251,7 @@ func (s *timerQueueStandbyTaskExecutorSuite) TestExecuteStateMachineTimerTask_St err = timerQueueStandbyTaskExecutor.executeStateMachineTimerTask(context.Background(), task) s.ErrorIs(err, consts.ErrTaskRetry) - s.Equal(2, len(info.StateMachineTimers)) + s.Len(info.StateMachineTimers, 2) } func (s *timerQueueStandbyTaskExecutorSuite) TestExecuteStateMachineTimerTask_ZombieWorkflow() { diff --git a/service/history/transfer_queue_active_task_executor_test.go b/service/history/transfer_queue_active_task_executor_test.go index 0a7f0eb824c..7016b2308b9 100644 --- a/service/history/transfer_queue_active_task_executor_test.go +++ b/service/history/transfer_queue_active_task_executor_test.go @@ -2159,7 +2159,7 @@ func (s *transferQueueActiveTaskExecutorSuite) TestProcessStartChildExecution_Su return nil, err } s.NoError(err) - s.True(cmpResult <= 0) + s.LessOrEqual(cmpResult, 0) return &historyservice.ScheduleWorkflowTaskResponse{}, nil }, ) @@ -2398,7 +2398,7 @@ func (s *transferQueueActiveTaskExecutorSuite) TestProcessStartChildExecution_Re return nil, err } s.NoError(err) - s.True(cmpResult <= 0) + s.LessOrEqual(cmpResult, 0) return &historyservice.ScheduleWorkflowTaskResponse{}, nil }, ) @@ -2657,7 +2657,7 @@ func (s *transferQueueActiveTaskExecutorSuite) TestProcessStartChildExecution_Su return nil, err } s.NoError(err) - s.True(cmpResult <= 0) + s.LessOrEqual(cmpResult, 0) return &historyservice.ScheduleWorkflowTaskResponse{}, nil }, ) @@ -2844,7 +2844,7 @@ func (s *transferQueueActiveTaskExecutorSuite) TestProcessorStartChildExecution_ return nil, err } s.NoError(err) - s.True(cmpResult <= 0) + s.LessOrEqual(cmpResult, 0) return &historyservice.ScheduleWorkflowTaskResponse{}, nil }, ) @@ -3004,7 +3004,7 @@ func (s *transferQueueActiveTaskExecutorSuite) TestPendingCloseExecutionTasks() s.NoError(resp.ExecutionErr) } else { s.Error(resp.ExecutionErr) - s.Assert().ErrorIs(resp.ExecutionErr, consts.ErrDependencyTaskNotCompleted) + s.ErrorIs(resp.ExecutionErr, consts.ErrDependencyTaskNotCompleted) } }) } diff --git a/service/history/transfer_queue_standby_task_executor_test.go b/service/history/transfer_queue_standby_task_executor_test.go index 1f0e20a852e..69936f90832 100644 --- a/service/history/transfer_queue_standby_task_executor_test.go +++ b/service/history/transfer_queue_standby_task_executor_test.go @@ -282,7 +282,7 @@ func (s *transferQueueStandbyTaskExecutorSuite) TestProcessActivityTask_Pending( s.mockShard.SetCurrentTime(s.clusterName, now.Add(s.discardDuration)) s.mockMatchingClient.EXPECT().AddActivityTask(gomock.Any(), gomock.Any(), gomock.Any()).Return(&matchingservice.AddActivityTaskResponse{}, nil) resp = s.transferQueueStandbyTaskExecutor.Execute(context.Background(), s.newTaskExecutable(transferTask)) - s.Nil(resp.ExecutionErr) + s.NoError(resp.ExecutionErr) } func (s *transferQueueStandbyTaskExecutorSuite) TestExecuteChasmSideEffectTransferTask_ExecutesTask() { @@ -435,7 +435,7 @@ func (s *transferQueueStandbyTaskExecutorSuite) TestProcessActivityTask_Success( s.mockShard.SetCurrentTime(s.clusterName, now) resp := s.transferQueueStandbyTaskExecutor.Execute(context.Background(), s.newTaskExecutable(transferTask)) - s.Nil(resp.ExecutionErr) + s.NoError(resp.ExecutionErr) } func (s *transferQueueStandbyTaskExecutorSuite) TestProcessActivityTask_Paused() { @@ -558,7 +558,7 @@ func (s *transferQueueStandbyTaskExecutorSuite) TestProcessWorkflowTask_Pending( s.mockShard.SetCurrentTime(s.clusterName, now.Add(s.discardDuration)) s.mockMatchingClient.EXPECT().AddWorkflowTask(gomock.Any(), gomock.Any(), gomock.Any()).Return(&matchingservice.AddWorkflowTaskResponse{}, nil) resp = s.transferQueueStandbyTaskExecutor.Execute(context.Background(), s.newTaskExecutable(transferTask)) - s.Nil(resp.ExecutionErr) + s.NoError(resp.ExecutionErr) } func (s *transferQueueStandbyTaskExecutorSuite) TestProcessWorkflowTask_Success_FirstWorkflowTask() { @@ -610,7 +610,7 @@ func (s *transferQueueStandbyTaskExecutorSuite) TestProcessWorkflowTask_Success_ s.mockShard.SetCurrentTime(s.clusterName, now) resp := s.transferQueueStandbyTaskExecutor.Execute(context.Background(), s.newTaskExecutable(transferTask)) - s.Nil(resp.ExecutionErr) + s.NoError(resp.ExecutionErr) } func (s *transferQueueStandbyTaskExecutorSuite) TestProcessWorkflowTask_Success_NonFirstWorkflowTask() { @@ -667,7 +667,7 @@ func (s *transferQueueStandbyTaskExecutorSuite) TestProcessWorkflowTask_Success_ s.mockShard.SetCurrentTime(s.clusterName, now) resp := s.transferQueueStandbyTaskExecutor.Execute(context.Background(), s.newTaskExecutable(transferTask)) - s.Nil(resp.ExecutionErr) + s.NoError(resp.ExecutionErr) } func (s *transferQueueStandbyTaskExecutorSuite) TestProcessWorkflowTask_StampMismatch() { @@ -819,7 +819,7 @@ func (s *transferQueueStandbyTaskExecutorSuite) TestProcessCloseExecution() { s.mockShard.SetCurrentTime(s.clusterName, now) s.mockHistoryClient.EXPECT().VerifyChildExecutionCompletionRecorded(gomock.Any(), expectedVerificationRequest).Return(nil, nil) resp := s.transferQueueStandbyTaskExecutor.Execute(context.Background(), s.newTaskExecutable(transferTask)) - s.Nil(resp.ExecutionErr) + s.NoError(resp.ExecutionErr) s.mockHistoryClient.EXPECT().VerifyChildExecutionCompletionRecorded(gomock.Any(), expectedVerificationRequest).Return(nil, consts.ErrWorkflowExecutionNotFound) resp = s.transferQueueStandbyTaskExecutor.Execute(context.Background(), s.newTaskExecutable(transferTask)) @@ -831,14 +831,14 @@ func (s *transferQueueStandbyTaskExecutorSuite) TestProcessCloseExecution() { s.mockHistoryClient.EXPECT().VerifyChildExecutionCompletionRecorded(gomock.Any(), expectedVerificationRequest).Return(nil, serviceerror.NewUnimplemented("not implemented")) resp = s.transferQueueStandbyTaskExecutor.Execute(context.Background(), s.newTaskExecutable(transferTask)) - s.Nil(resp.ExecutionErr) + s.NoError(resp.ExecutionErr) s.mockHistoryClient.EXPECT().VerifyChildExecutionCompletionRecorded(gomock.Any(), expectedVerificationRequest).Return(nil, consts.ErrResourceExhaustedBusyWorkflow) resp = s.transferQueueStandbyTaskExecutor.Execute(context.Background(), s.newTaskExecutable(transferTask)) var verificationErr *verificationErr - s.True(errors.As(resp.ExecutionErr, &verificationErr)) + s.ErrorAs(resp.ExecutionErr, &verificationErr) var resourceExhaustedErr *serviceerror.ResourceExhausted - s.True(errors.As(resp.ExecutionErr, &resourceExhaustedErr)) + s.ErrorAs(resp.ExecutionErr, &resourceExhaustedErr) s.mockShard.SetCurrentTime(s.clusterName, now.Add(s.localVerificationDuration)) s.mockHistoryClient.EXPECT().VerifyChildExecutionCompletionRecorded(gomock.Any(), expectedVerificationWithResendParentRequest).Return(nil, consts.ErrWorkflowNotReady) @@ -987,7 +987,7 @@ func (s *transferQueueStandbyTaskExecutorSuite) TestProcessCancelExecution_Succe s.mockShard.SetCurrentTime(s.clusterName, now) resp := s.transferQueueStandbyTaskExecutor.Execute(context.Background(), s.newTaskExecutable(transferTask)) - s.Nil(resp.ExecutionErr) + s.NoError(resp.ExecutionErr) } func (s *transferQueueStandbyTaskExecutorSuite) TestProcessSignalExecution_Pending() { @@ -1119,7 +1119,7 @@ func (s *transferQueueStandbyTaskExecutorSuite) TestProcessSignalExecution_Succe s.mockShard.SetCurrentTime(s.clusterName, now) resp := s.transferQueueStandbyTaskExecutor.Execute(context.Background(), s.newTaskExecutable(transferTask)) - s.Nil(resp.ExecutionErr) + s.NoError(resp.ExecutionErr) } func (s *transferQueueStandbyTaskExecutorSuite) TestProcessStartChildExecution_Pending() { @@ -1193,7 +1193,7 @@ func (s *transferQueueStandbyTaskExecutorSuite) TestProcessStartChildExecution_P s.mockHistoryClient.EXPECT().VerifyFirstWorkflowTaskScheduled(gomock.Any(), gomock.Any()).Return(nil, nil) resp = s.transferQueueStandbyTaskExecutor.Execute(context.Background(), s.newTaskExecutable(transferTask)) - s.Nil(resp.ExecutionErr) + s.NoError(resp.ExecutionErr) s.mockHistoryClient.EXPECT().VerifyFirstWorkflowTaskScheduled(gomock.Any(), gomock.Any()).Return(nil, consts.ErrWorkflowNotReady) resp = s.transferQueueStandbyTaskExecutor.Execute(context.Background(), s.newTaskExecutable(transferTask)) @@ -1205,14 +1205,14 @@ func (s *transferQueueStandbyTaskExecutorSuite) TestProcessStartChildExecution_P s.mockHistoryClient.EXPECT().VerifyFirstWorkflowTaskScheduled(gomock.Any(), gomock.Any()).Return(nil, &serviceerror.Unimplemented{}) resp = s.transferQueueStandbyTaskExecutor.Execute(context.Background(), s.newTaskExecutable(transferTask)) - s.Nil(resp.ExecutionErr) + s.NoError(resp.ExecutionErr) s.mockHistoryClient.EXPECT().VerifyFirstWorkflowTaskScheduled(gomock.Any(), gomock.Any()).Return(nil, consts.ErrResourceExhaustedBusyWorkflow) resp = s.transferQueueStandbyTaskExecutor.Execute(context.Background(), s.newTaskExecutable(transferTask)) var verificationErr *verificationErr - s.True(errors.As(resp.ExecutionErr, &verificationErr)) + s.ErrorAs(resp.ExecutionErr, &verificationErr) var resourceExhaustedErr *serviceerror.ResourceExhausted - s.True(errors.As(resp.ExecutionErr, &resourceExhaustedErr)) + s.ErrorAs(resp.ExecutionErr, &resourceExhaustedErr) s.mockShard.SetCurrentTime(s.clusterName, now.Add(s.discardDuration)) s.mockHistoryClient.EXPECT().VerifyFirstWorkflowTaskScheduled(gomock.Any(), gomock.Any()).Return(nil, &serviceerror.WorkflowNotReady{}) @@ -1227,7 +1227,7 @@ func (s *transferQueueStandbyTaskExecutorSuite) TestProcessStartChildExecution_P s.mockHistoryClient.EXPECT().VerifyFirstWorkflowTaskScheduled(gomock.Any(), gomock.Any()).Return(nil, nil) resp = s.transferQueueStandbyTaskExecutor.Execute(context.Background(), s.newTaskExecutable(transferTask)) - s.Nil(resp.ExecutionErr) + s.NoError(resp.ExecutionErr) } func (s *transferQueueStandbyTaskExecutorSuite) TestProcessStartChildExecution_Success() { @@ -1291,7 +1291,7 @@ func (s *transferQueueStandbyTaskExecutorSuite) TestProcessStartChildExecution_S s.mockShard.SetCurrentTime(s.clusterName, now) resp := s.transferQueueStandbyTaskExecutor.Execute(context.Background(), s.newTaskExecutable(transferTask)) - s.Nil(resp.ExecutionErr) + s.NoError(resp.ExecutionErr) // workflow closed && child started && parent close policy is abandon event, err = mutableState.AddTimeoutWorkflowEvent( @@ -1307,7 +1307,7 @@ func (s *transferQueueStandbyTaskExecutorSuite) TestProcessStartChildExecution_S s.mockShard.SetCurrentTime(s.clusterName, now) resp = s.transferQueueStandbyTaskExecutor.Execute(context.Background(), s.newTaskExecutable(transferTask)) - s.Nil(resp.ExecutionErr) + s.NoError(resp.ExecutionErr) } func (s *transferQueueStandbyTaskExecutorSuite) createPersistenceMutableState( diff --git a/service/history/workflow/activity_test.go b/service/history/workflow/activity_test.go index bd32194a10a..d5d538b82ce 100644 --- a/service/history/workflow/activity_test.go +++ b/service/history/workflow/activity_test.go @@ -2,7 +2,6 @@ package workflow import ( "context" - "fmt" "testing" "time" @@ -215,7 +214,7 @@ func (s *activitySuite) TestGetPendingActivityInfo_ActivityState() { s.NoError(err) s.NotNil(pi) - s.Equal(tc.expectedState, pi.State, fmt.Sprintf("failed for paused: %v, cancelRequested: %v, startedEventId: %v", tc.paused, tc.cancelRequested, tc.startedEventId)) + s.Equal(tc.expectedState, pi.State, "failed for paused: %v, cancelRequested: %v, startedEventId: %v", tc.paused, tc.cancelRequested, tc.startedEventId) } } @@ -339,8 +338,8 @@ func (s *activitySuite) TestResetPausedActivityAcceptance() { s.NoError(err) s.NotEqual(prevStamp, ai.Stamp, "ActivityInfo.Stamp should change") s.NotNil(ai.PauseInfo) - s.Equal(ai.PauseInfo.GetManual().Identity, "test_identity") - s.Equal(ai.PauseInfo.GetManual().Reason, "test_reason") + s.Equal("test_identity", ai.PauseInfo.GetManual().Identity) + s.Equal("test_reason", ai.PauseInfo.GetManual().Reason) prevStamp = ai.Stamp err = ResetActivity(context.Background(), s.mockShard, s.mutableState, ai.ActivityId, @@ -369,8 +368,8 @@ func (s *activitySuite) TestResetAndUnPauseActivityAcceptance() { s.NoError(err) s.NotEqual(prevStamp, ai.Stamp, "ActivityInfo.Stamp should change") s.NotNil(ai.PauseInfo) - s.Equal(ai.PauseInfo.GetManual().Identity, "test_identity") - s.Equal(ai.PauseInfo.GetManual().Reason, "test_reason") + s.Equal("test_identity", ai.PauseInfo.GetManual().Identity) + s.Equal("test_reason", ai.PauseInfo.GetManual().Reason) prevStamp = ai.Stamp err = ResetActivity(context.Background(), s.mockShard, s.mutableState, ai.ActivityId, @@ -391,14 +390,14 @@ func (s *activitySuite) TestUnpauseActivityWithResumeAcceptance() { s.Equal(int32(1), ai.Attempt, "ActivityInfo.Attempt is shouldn't change") s.NotEqual(prevStamp, ai.Stamp, "ActivityInfo.Stamp should change") - s.Equal(true, ai.Paused, "ActivityInfo.Paused was not unpaused") + s.True(ai.Paused, "ActivityInfo.Paused was not unpaused") prevStamp = ai.Stamp _, err = UnpauseActivityWithResume(s.mockShard, s.mutableState, ai, false, 0) s.NoError(err) s.Equal(int32(1), ai.Attempt, "ActivityInfo.Attempt is shouldn't change") s.NotEqual(prevStamp, ai.Stamp, "ActivityInfo.Stamp should change") - s.Equal(false, ai.Paused, "ActivityInfo.Paused was not unpaused") + s.False(ai.Paused, "ActivityInfo.Paused was not unpaused") } func (s *activitySuite) TestUnpauseActivityWithNewRun() { @@ -410,7 +409,7 @@ func (s *activitySuite) TestUnpauseActivityWithNewRun() { s.Equal(int32(1), ai.Attempt, "ActivityInfo.Attempt is shouldn't change") s.NotEqual(prevStamp, ai.Stamp, "ActivityInfo.Stamp should change") - s.Equal(true, ai.Paused, "ActivityInfo.Paused was not unpaused") + s.True(ai.Paused, "ActivityInfo.Paused was not unpaused") prevStamp = ai.Stamp fakeScheduledTime := time.Now().UTC().Add(5 * time.Minute) ai.ScheduledTime = timestamppb.New(fakeScheduledTime) @@ -421,7 +420,7 @@ func (s *activitySuite) TestUnpauseActivityWithNewRun() { s.NotEqual(fakeScheduledTime, ai.ScheduledTime.AsTime()) s.Equal(int32(1), ai.Attempt, "ActivityInfo.Attempt is shouldn't change") s.NotEqual(prevStamp, ai.Stamp, "ActivityInfo.Stamp should change") - s.Equal(false, ai.Paused, "ActivityInfo.Paused was not unpaused") + s.False(ai.Paused, "ActivityInfo.Paused was not unpaused") } func (s *activitySuite) TestUnpauseActivityWithResetAcceptance() { @@ -438,17 +437,17 @@ func (s *activitySuite) TestUnpauseActivityWithResetAcceptance() { err := PauseActivity(s.mutableState, ai.ActivityId, pauseInfo) s.NoError(err) s.NotNil(ai.PauseInfo) - s.Equal(ai.PauseInfo.GetRuleId(), "rule_id") + s.Equal("rule_id", ai.PauseInfo.GetRuleId()) s.Equal(int32(1), ai.Attempt, "ActivityInfo.Attempt is shouldn't change") s.NotEqual(prevStamp, ai.Stamp, "ActivityInfo.Stamp should change") - s.Equal(true, ai.Paused, "ActivityInfo.Paused was not unpaused") + s.True(ai.Paused, "ActivityInfo.Paused was not unpaused") prevStamp = ai.Stamp _, err = UnpauseActivityWithReset(s.mockShard, s.mutableState, ai, false, true, 0) s.NoError(err) s.Equal(int32(1), ai.Attempt, "ActivityInfo.Attempt is shouldn't change") - s.Equal(false, ai.Paused, "ActivityInfo.Paused was not unpaused") + s.False(ai.Paused, "ActivityInfo.Paused was not unpaused") s.NotEqual(prevStamp, ai.Stamp, "ActivityInfo.Stamp should change") s.Nil(ai.LastHeartbeatUpdateTime) s.Nil(ai.LastHeartbeatDetails) diff --git a/service/history/workflow/cache/cache_test.go b/service/history/workflow/cache/cache_test.go index c940b2715a4..dbd9937888d 100644 --- a/service/history/workflow/cache/cache_test.go +++ b/service/history/workflow/cache/cache_test.go @@ -221,7 +221,7 @@ func (s *workflowCacheSuite) TestHistoryCachePinning() { locks.PriorityHigh, ) s.NoError(err4) - s.False(ctx == newContext) + s.NotEqual(ctx, newContext) release(err4) } diff --git a/service/history/workflow/mutable_state_rebuilder_test.go b/service/history/workflow/mutable_state_rebuilder_test.go index e134c908ef4..02fd09ffc44 100644 --- a/service/history/workflow/mutable_state_rebuilder_test.go +++ b/service/history/workflow/mutable_state_rebuilder_test.go @@ -201,7 +201,7 @@ func (s *stateBuilderSuite) TestApplyEvents_EventTypeWorkflowExecutionStarted_No s.mockMutableState.EXPECT().SetHistoryTree(nil, timestamp.DurationFromSeconds(100), tests.RunID).Return(nil) _, err := s.stateRebuilder.ApplyEvents(context.Background(), tests.NamespaceID, requestID, execution, s.toHistory(event), nil, "") - s.Nil(err) + s.NoError(err) s.Equal(event.TaskId, s.executionInfo.LastRunningClock) } @@ -250,7 +250,7 @@ func (s *stateBuilderSuite) TestApplyEvents_EventTypeWorkflowExecutionStarted_Wi s.mockMutableState.EXPECT().SetHistoryTree(nil, timestamp.DurationFromSeconds(100), tests.RunID).Return(nil) _, err := s.stateRebuilder.ApplyEvents(context.Background(), tests.NamespaceID, requestID, execution, s.toHistory(event), nil, "") - s.Nil(err) + s.NoError(err) s.Equal(event.TaskId, s.executionInfo.LastRunningClock) } @@ -283,7 +283,7 @@ func (s *stateBuilderSuite) TestApplyEvents_EventTypeWorkflowExecutionTimedOut() s.mockMutableState.EXPECT().ClearStickyTaskQueue() _, err := s.stateRebuilder.ApplyEvents(context.Background(), tests.NamespaceID, requestID, execution, s.toHistory(event), nil, "") - s.Nil(err) + s.NoError(err) s.Equal(event.TaskId, s.executionInfo.LastRunningClock) } @@ -347,7 +347,7 @@ func (s *stateBuilderSuite) TestApplyEvents_EventTypeWorkflowExecutionTimedOut_W s.mockMutableState.EXPECT().ClearStickyTaskQueue() newRunStateBuilder, err := s.stateRebuilder.ApplyEvents(context.Background(), tests.NamespaceID, requestID, execution, s.toHistory(event), newRunEvents, newRunID) - s.Nil(err) + s.NoError(err) s.NotNil(newRunStateBuilder) s.Equal(event.TaskId, s.executionInfo.LastRunningClock) @@ -384,7 +384,7 @@ func (s *stateBuilderSuite) TestApplyEvents_EventTypeWorkflowExecutionTerminated ).Return(nil) s.mockMutableState.EXPECT().ClearStickyTaskQueue() _, err := s.stateRebuilder.ApplyEvents(context.Background(), tests.NamespaceID, requestID, execution, s.toHistory(event), nil, "") - s.Nil(err) + s.NoError(err) s.Equal(event.TaskId, s.executionInfo.LastRunningClock) } @@ -442,7 +442,7 @@ func (s *stateBuilderSuite) TestApplyEvents_EventTypeWorkflowExecutionTerminated s.mockMutableState.EXPECT().ClearStickyTaskQueue() newRunStateBuilder, err := s.stateRebuilder.ApplyEvents(context.Background(), tests.NamespaceID, requestID, execution, s.toHistory(event), newRunEvents, uuid.NewString()) - s.Nil(err) + s.NoError(err) s.NotNil(newRunStateBuilder) s.Equal(event.TaskId, s.executionInfo.LastRunningClock) @@ -480,7 +480,7 @@ func (s *stateBuilderSuite) TestApplyEvents_EventTypeWorkflowExecutionFailed() { s.mockMutableState.EXPECT().ClearStickyTaskQueue() _, err := s.stateRebuilder.ApplyEvents(context.Background(), tests.NamespaceID, requestID, execution, s.toHistory(event), nil, "") - s.Nil(err) + s.NoError(err) s.Equal(event.TaskId, s.executionInfo.LastRunningClock) } @@ -544,7 +544,7 @@ func (s *stateBuilderSuite) TestApplyEvents_EventTypeWorkflowExecutionFailed_Wit s.mockMutableState.EXPECT().ClearStickyTaskQueue() newRunStateBuilder, err := s.stateRebuilder.ApplyEvents(context.Background(), tests.NamespaceID, requestID, execution, s.toHistory(event), newRunEvents, newRunID) - s.Nil(err) + s.NoError(err) s.NotNil(newRunStateBuilder) s.Equal(event.TaskId, s.executionInfo.LastRunningClock) @@ -582,7 +582,7 @@ func (s *stateBuilderSuite) TestApplyEvents_EventTypeWorkflowExecutionCompleted( s.mockMutableState.EXPECT().ClearStickyTaskQueue() _, err := s.stateRebuilder.ApplyEvents(context.Background(), tests.NamespaceID, requestID, execution, s.toHistory(event), nil, "") - s.Nil(err) + s.NoError(err) s.Equal(event.TaskId, s.executionInfo.LastRunningClock) } @@ -645,12 +645,12 @@ func (s *stateBuilderSuite) TestApplyEvents_EventTypeWorkflowExecutionCompleted_ s.mockMutableState.EXPECT().ClearStickyTaskQueue() newRunStateBuilder, err := s.stateRebuilder.ApplyEvents(context.Background(), tests.NamespaceID, requestID, execution, s.toHistory(event), newRunEvents, newRunID) - s.Nil(err) + s.NoError(err) s.NotNil(newRunStateBuilder) s.Equal(event.TaskId, s.executionInfo.LastRunningClock) newRunTasks := newRunStateBuilder.PopTasks() - s.Len(newRunTasks[tasks.CategoryTimer], 0) + s.Empty(newRunTasks[tasks.CategoryTimer]) s.Len(newRunTasks[tasks.CategoryVisibility], 1) // recordWorkflowStarted } @@ -683,7 +683,7 @@ func (s *stateBuilderSuite) TestApplyEvents_EventTypeWorkflowExecutionCanceled() s.mockMutableState.EXPECT().ClearStickyTaskQueue() _, err := s.stateRebuilder.ApplyEvents(context.Background(), tests.NamespaceID, requestID, execution, s.toHistory(event), nil, "") - s.Nil(err) + s.NoError(err) s.Equal(event.TaskId, s.executionInfo.LastRunningClock) } @@ -796,7 +796,7 @@ func (s *stateBuilderSuite) TestApplyEvents_EventTypeWorkflowExecutionContinuedA newRunStateBuilder, err := s.stateRebuilder.ApplyEvents( context.Background(), tests.NamespaceID, requestID, execution, s.toHistory(continueAsNewEvent), newRunEvents, "", ) - s.Nil(err) + s.NoError(err) s.NotNil(newRunStateBuilder) s.Equal(continueAsNewEvent.TaskId, s.executionInfo.LastRunningClock) @@ -846,7 +846,7 @@ func (s *stateBuilderSuite) TestApplyEvents_EventTypeWorkflowExecutionContinuedA newRunStateBuilder, err := s.stateRebuilder.ApplyEvents( context.Background(), tests.NamespaceID, requestID, execution, s.toHistory(continueAsNewEvent), nil, "", ) - s.Nil(err) + s.NoError(err) s.Nil(newRunStateBuilder) s.Equal(continueAsNewEvent.TaskId, s.executionInfo.LastRunningClock) } @@ -875,7 +875,7 @@ func (s *stateBuilderSuite) TestApplyEvents_EventTypeWorkflowExecutionSignaled() s.mockMutableState.EXPECT().ClearStickyTaskQueue() _, err := s.stateRebuilder.ApplyEvents(context.Background(), tests.NamespaceID, requestID, execution, s.toHistory(event), nil, "") - s.Nil(err) + s.NoError(err) s.Equal(event.TaskId, s.executionInfo.LastRunningClock) } @@ -903,7 +903,7 @@ func (s *stateBuilderSuite) TestApplyEvents_EventTypeWorkflowExecutionCancelRequ s.mockMutableState.EXPECT().ClearStickyTaskQueue() _, err := s.stateRebuilder.ApplyEvents(context.Background(), tests.NamespaceID, requestID, execution, s.toHistory(event), nil, "") - s.Nil(err) + s.NoError(err) s.Equal(event.TaskId, s.executionInfo.LastRunningClock) } @@ -934,7 +934,7 @@ func (s *stateBuilderSuite) TestApplyEvents_EventTypeUpsertWorkflowSearchAttribu s.mockMutableState.EXPECT().ClearStickyTaskQueue() _, err := s.stateRebuilder.ApplyEvents(context.Background(), tests.NamespaceID, requestID, execution, s.toHistory(event), nil, "") - s.Nil(err) + s.NoError(err) s.Equal(event.TaskId, s.executionInfo.LastRunningClock) } @@ -965,7 +965,7 @@ func (s *stateBuilderSuite) TestApplyEvents_EventTypeWorkflowPropertiesModified( s.mockMutableState.EXPECT().ClearStickyTaskQueue() _, err := s.stateRebuilder.ApplyEvents(context.Background(), tests.NamespaceID, requestID, execution, s.toHistory(event), nil, "") - s.Nil(err) + s.NoError(err) s.Equal(event.TaskId, s.executionInfo.LastRunningClock) } @@ -992,7 +992,7 @@ func (s *stateBuilderSuite) TestApplyEvents_EventTypeMarkerRecorded() { s.mockMutableState.EXPECT().ClearStickyTaskQueue() _, err := s.stateRebuilder.ApplyEvents(context.Background(), tests.NamespaceID, requestID, execution, s.toHistory(event), nil, "") - s.Nil(err) + s.NoError(err) s.Equal(event.TaskId, s.executionInfo.LastRunningClock) } @@ -1044,7 +1044,7 @@ func (s *stateBuilderSuite) TestApplyEvents_EventTypeWorkflowTaskScheduled() { s.mockMutableState.EXPECT().ClearStickyTaskQueue() _, err := s.stateRebuilder.ApplyEvents(context.Background(), tests.NamespaceID, requestID, execution, s.toHistory(event), nil, "") - s.Nil(err) + s.NoError(err) s.Equal(event.TaskId, s.executionInfo.LastRunningClock) } func (s *stateBuilderSuite) TestApplyEvents_EventTypeWorkflowTaskStarted() { @@ -1093,7 +1093,7 @@ func (s *stateBuilderSuite) TestApplyEvents_EventTypeWorkflowTaskStarted() { s.mockMutableState.EXPECT().ClearStickyTaskQueue() _, err := s.stateRebuilder.ApplyEvents(context.Background(), tests.NamespaceID, requestID, execution, s.toHistory(event), nil, "") - s.Nil(err) + s.NoError(err) s.Equal(event.TaskId, s.executionInfo.LastRunningClock) } @@ -1138,7 +1138,7 @@ func (s *stateBuilderSuite) TestApplyEvents_EventTypeWorkflowTaskTimedOut() { s.mockMutableState.EXPECT().ClearStickyTaskQueue() _, err := s.stateRebuilder.ApplyEvents(context.Background(), tests.NamespaceID, requestID, execution, s.toHistory(event), nil, "") - s.Nil(err) + s.NoError(err) s.Equal(event.TaskId, s.executionInfo.LastRunningClock) } @@ -1182,7 +1182,7 @@ func (s *stateBuilderSuite) TestApplyEvents_EventTypeWorkflowTaskFailed() { s.mockMutableState.EXPECT().ClearStickyTaskQueue() _, err := s.stateRebuilder.ApplyEvents(context.Background(), tests.NamespaceID, requestID, execution, s.toHistory(event), nil, "") - s.Nil(err) + s.NoError(err) s.Equal(event.TaskId, s.executionInfo.LastRunningClock) } @@ -1215,7 +1215,7 @@ func (s *stateBuilderSuite) TestApplyEvents_EventTypeWorkflowTaskCompleted() { s.mockMutableState.EXPECT().ClearStickyTaskQueue() _, err := s.stateRebuilder.ApplyEvents(context.Background(), tests.NamespaceID, requestID, execution, s.toHistory(event), nil, "") - s.Nil(err) + s.NoError(err) s.Equal(event.TaskId, s.executionInfo.LastRunningClock) } @@ -1260,7 +1260,7 @@ func (s *stateBuilderSuite) TestApplyEvents_EventTypeTimerStarted() { s.mockMutableState.EXPECT().ClearStickyTaskQueue() _, err := s.stateRebuilder.ApplyEvents(context.Background(), tests.NamespaceID, requestID, execution, s.toHistory(event), nil, "") - s.Nil(err) + s.NoError(err) s.Equal(event.TaskId, s.executionInfo.LastRunningClock) } @@ -1291,7 +1291,7 @@ func (s *stateBuilderSuite) TestApplyEvents_EventTypeTimerFired() { s.mockMutableState.EXPECT().ClearStickyTaskQueue() _, err := s.stateRebuilder.ApplyEvents(context.Background(), tests.NamespaceID, requestID, execution, s.toHistory(event), nil, "") - s.Nil(err) + s.NoError(err) s.Equal(event.TaskId, s.executionInfo.LastRunningClock) } @@ -1322,7 +1322,7 @@ func (s *stateBuilderSuite) TestApplyEvents_EventTypeTimerCanceled() { s.mockMutableState.EXPECT().ClearStickyTaskQueue() _, err := s.stateRebuilder.ApplyEvents(context.Background(), tests.NamespaceID, requestID, execution, s.toHistory(event), nil, "") - s.Nil(err) + s.NoError(err) s.Equal(event.TaskId, s.executionInfo.LastRunningClock) } @@ -1380,7 +1380,7 @@ func (s *stateBuilderSuite) TestApplyEvents_EventTypeActivityTaskScheduled() { s.mockMutableState.EXPECT().ClearStickyTaskQueue() _, err := s.stateRebuilder.ApplyEvents(context.Background(), tests.NamespaceID, requestID, execution, s.toHistory(event), nil, "") - s.Nil(err) + s.NoError(err) s.Equal(event.TaskId, s.executionInfo.LastRunningClock) } @@ -1423,7 +1423,7 @@ func (s *stateBuilderSuite) TestApplyEvents_EventTypeActivityTaskStarted() { s.mockMutableState.EXPECT().ClearStickyTaskQueue() _, err := s.stateRebuilder.ApplyEvents(context.Background(), tests.NamespaceID, requestID, execution, s.toHistory(startedEvent), nil, "") - s.Nil(err) + s.NoError(err) s.Equal(startedEvent.TaskId, s.executionInfo.LastRunningClock) } @@ -1455,7 +1455,7 @@ func (s *stateBuilderSuite) TestApplyEvents_EventTypeActivityTaskTimedOut() { s.mockMutableState.EXPECT().ClearStickyTaskQueue() _, err := s.stateRebuilder.ApplyEvents(context.Background(), tests.NamespaceID, requestID, execution, s.toHistory(event), nil, "") - s.Nil(err) + s.NoError(err) s.Equal(event.TaskId, s.executionInfo.LastRunningClock) } @@ -1486,7 +1486,7 @@ func (s *stateBuilderSuite) TestApplyEvents_EventTypeActivityTaskFailed() { s.mockMutableState.EXPECT().ClearStickyTaskQueue() _, err := s.stateRebuilder.ApplyEvents(context.Background(), tests.NamespaceID, requestID, execution, s.toHistory(event), nil, "") - s.Nil(err) + s.NoError(err) s.Equal(event.TaskId, s.executionInfo.LastRunningClock) } @@ -1517,7 +1517,7 @@ func (s *stateBuilderSuite) TestApplyEvents_EventTypeActivityTaskCompleted() { s.mockMutableState.EXPECT().ClearStickyTaskQueue() _, err := s.stateRebuilder.ApplyEvents(context.Background(), tests.NamespaceID, requestID, execution, s.toHistory(event), nil, "") - s.Nil(err) + s.NoError(err) s.Equal(event.TaskId, s.executionInfo.LastRunningClock) } @@ -1545,7 +1545,7 @@ func (s *stateBuilderSuite) TestApplyEvents_EventTypeActivityTaskCancelRequested s.mockMutableState.EXPECT().ClearStickyTaskQueue() _, err := s.stateRebuilder.ApplyEvents(context.Background(), tests.NamespaceID, requestID, execution, s.toHistory(event), nil, "") - s.Nil(err) + s.NoError(err) s.Equal(event.TaskId, s.executionInfo.LastRunningClock) } @@ -1576,7 +1576,7 @@ func (s *stateBuilderSuite) TestApplyEvents_EventTypeActivityTaskCanceled() { s.mockMutableState.EXPECT().ClearStickyTaskQueue() _, err := s.stateRebuilder.ApplyEvents(context.Background(), tests.NamespaceID, requestID, execution, s.toHistory(event), nil, "") - s.Nil(err) + s.NoError(err) s.Equal(event.TaskId, s.executionInfo.LastRunningClock) } @@ -1629,7 +1629,7 @@ func (s *stateBuilderSuite) TestApplyEvents_EventTypeStartChildWorkflowExecution s.mockMutableState.EXPECT().ClearStickyTaskQueue() _, err := s.stateRebuilder.ApplyEvents(context.Background(), tests.NamespaceID, requestID, execution, s.toHistory(event), nil, "") - s.Nil(err) + s.NoError(err) s.Equal(event.TaskId, s.executionInfo.LastRunningClock) } @@ -1657,7 +1657,7 @@ func (s *stateBuilderSuite) TestApplyEvents_EventTypeStartChildWorkflowExecution s.mockMutableState.EXPECT().ClearStickyTaskQueue() _, err := s.stateRebuilder.ApplyEvents(context.Background(), tests.NamespaceID, requestID, execution, s.toHistory(event), nil, "") - s.Nil(err) + s.NoError(err) s.Equal(event.TaskId, s.executionInfo.LastRunningClock) } @@ -1685,7 +1685,7 @@ func (s *stateBuilderSuite) TestApplyEvents_EventTypeChildWorkflowExecutionStart s.mockMutableState.EXPECT().ClearStickyTaskQueue() _, err := s.stateRebuilder.ApplyEvents(context.Background(), tests.NamespaceID, requestID, execution, s.toHistory(event), nil, "") - s.Nil(err) + s.NoError(err) s.Equal(event.TaskId, s.executionInfo.LastRunningClock) } @@ -1713,7 +1713,7 @@ func (s *stateBuilderSuite) TestApplyEvents_EventTypeChildWorkflowExecutionTimed s.mockMutableState.EXPECT().ClearStickyTaskQueue() _, err := s.stateRebuilder.ApplyEvents(context.Background(), tests.NamespaceID, requestID, execution, s.toHistory(event), nil, "") - s.Nil(err) + s.NoError(err) s.Equal(event.TaskId, s.executionInfo.LastRunningClock) } @@ -1741,7 +1741,7 @@ func (s *stateBuilderSuite) TestApplyEvents_EventTypeChildWorkflowExecutionTermi s.mockMutableState.EXPECT().ClearStickyTaskQueue() _, err := s.stateRebuilder.ApplyEvents(context.Background(), tests.NamespaceID, requestID, execution, s.toHistory(event), nil, "") - s.Nil(err) + s.NoError(err) s.Equal(event.TaskId, s.executionInfo.LastRunningClock) } @@ -1769,7 +1769,7 @@ func (s *stateBuilderSuite) TestApplyEvents_EventTypeChildWorkflowExecutionFaile s.mockMutableState.EXPECT().ClearStickyTaskQueue() _, err := s.stateRebuilder.ApplyEvents(context.Background(), tests.NamespaceID, requestID, execution, s.toHistory(event), nil, "") - s.Nil(err) + s.NoError(err) s.Equal(event.TaskId, s.executionInfo.LastRunningClock) } @@ -1797,7 +1797,7 @@ func (s *stateBuilderSuite) TestApplyEvents_EventTypeChildWorkflowExecutionCompl s.mockMutableState.EXPECT().ClearStickyTaskQueue() _, err := s.stateRebuilder.ApplyEvents(context.Background(), tests.NamespaceID, requestID, execution, s.toHistory(event), nil, "") - s.Nil(err) + s.NoError(err) s.Equal(event.TaskId, s.executionInfo.LastRunningClock) } @@ -1854,7 +1854,7 @@ func (s *stateBuilderSuite) TestApplyEvents_EventTypeRequestCancelExternalWorkfl s.mockMutableState.EXPECT().ClearStickyTaskQueue() _, err := s.stateRebuilder.ApplyEvents(context.Background(), tests.NamespaceID, requestID, execution, s.toHistory(event), nil, "") - s.Nil(err) + s.NoError(err) s.Equal(event.TaskId, s.executionInfo.LastRunningClock) } @@ -1882,7 +1882,7 @@ func (s *stateBuilderSuite) TestApplyEvents_EventTypeRequestCancelExternalWorkfl s.mockMutableState.EXPECT().ClearStickyTaskQueue() _, err := s.stateRebuilder.ApplyEvents(context.Background(), tests.NamespaceID, requestID, execution, s.toHistory(event), nil, "") - s.Nil(err) + s.NoError(err) s.Equal(event.TaskId, s.executionInfo.LastRunningClock) } @@ -1910,7 +1910,7 @@ func (s *stateBuilderSuite) TestApplyEvents_EventTypeExternalWorkflowExecutionCa s.mockMutableState.EXPECT().ClearStickyTaskQueue() _, err := s.stateRebuilder.ApplyEvents(context.Background(), tests.NamespaceID, requestID, execution, s.toHistory(event), nil, "") - s.Nil(err) + s.NoError(err) s.Equal(event.TaskId, s.executionInfo.LastRunningClock) } @@ -1938,7 +1938,7 @@ func (s *stateBuilderSuite) TestApplyEvents_EventTypeChildWorkflowExecutionCance s.mockMutableState.EXPECT().ClearStickyTaskQueue() _, err := s.stateRebuilder.ApplyEvents(context.Background(), tests.NamespaceID, requestID, execution, s.toHistory(event), nil, "") - s.Nil(err) + s.NoError(err) s.Equal(event.TaskId, s.executionInfo.LastRunningClock) } @@ -2001,7 +2001,7 @@ func (s *stateBuilderSuite) TestApplyEvents_EventTypeSignalExternalWorkflowExecu s.mockMutableState.EXPECT().ClearStickyTaskQueue() _, err := s.stateRebuilder.ApplyEvents(context.Background(), tests.NamespaceID, requestID, execution, s.toHistory(event), nil, "") - s.Nil(err) + s.NoError(err) s.Equal(event.TaskId, s.executionInfo.LastRunningClock) } @@ -2029,7 +2029,7 @@ func (s *stateBuilderSuite) TestApplyEvents_EventTypeSignalExternalWorkflowExecu s.mockMutableState.EXPECT().ClearStickyTaskQueue() _, err := s.stateRebuilder.ApplyEvents(context.Background(), tests.NamespaceID, requestID, execution, s.toHistory(event), nil, "") - s.Nil(err) + s.NoError(err) s.Equal(event.TaskId, s.executionInfo.LastRunningClock) } @@ -2057,7 +2057,7 @@ func (s *stateBuilderSuite) TestApplyEvents_EventTypeExternalWorkflowExecutionSi s.mockMutableState.EXPECT().ClearStickyTaskQueue() _, err := s.stateRebuilder.ApplyEvents(context.Background(), tests.NamespaceID, requestID, execution, s.toHistory(event), nil, "") - s.Nil(err) + s.NoError(err) s.Equal(event.TaskId, s.executionInfo.LastRunningClock) } diff --git a/service/history/workflow/query_registry_test.go b/service/history/workflow/query_registry_test.go index e626be86cd2..9a8d288e33e 100644 --- a/service/history/workflow/query_registry_test.go +++ b/service/history/workflow/query_registry_test.go @@ -162,7 +162,7 @@ func (s *QueryRegistrySuite) assertCompletedState(qr historyi.QueryRegistry, ids s.NotNil(completionState) s.Equal(QueryCompletionTypeSucceeded, completionState.Type) s.NotNil(completionState.Result) - s.Nil(completionState.Err) + s.NoError(completionState.Err) } } @@ -179,7 +179,7 @@ func (s *QueryRegistrySuite) assertUnblockedState(qr historyi.QueryRegistry, ids s.NotNil(completionState) s.Equal(QueryCompletionTypeUnblocked, completionState.Type) s.Nil(completionState.Result) - s.Nil(completionState.Err) + s.NoError(completionState.Err) } } @@ -196,7 +196,7 @@ func (s *QueryRegistrySuite) assertFailedState(qr historyi.QueryRegistry, ids .. s.NotNil(completionState) s.Equal(QueryCompletionTypeFailed, completionState.Type) s.Nil(completionState.Result) - s.NotNil(completionState.Err) + s.Error(completionState.Err) } } diff --git a/service/history/workflow/state_machine_timers_test.go b/service/history/workflow/state_machine_timers_test.go index 2c535efc1d3..e4e9ad04ee7 100644 --- a/service/history/workflow/state_machine_timers_test.go +++ b/service/history/workflow/state_machine_timers_test.go @@ -39,18 +39,18 @@ func TestTrackStateMachineTimer_MaintainsSortedSlice(t *testing.T) { workflow.TrackStateMachineTimer(ms, now.Add(time.Hour), &persistencespb.StateMachineTaskInfo{Type: "2"}) workflow.TrackStateMachineTimer(ms, now.Add(-time.Hour), &persistencespb.StateMachineTaskInfo{Type: "3"}) - require.Equal(t, 3, len(execInfo.StateMachineTimers)) + require.Len(t, execInfo.StateMachineTimers, 3) - require.Equal(t, 1, len(execInfo.StateMachineTimers[0].Infos)) + require.Len(t, execInfo.StateMachineTimers[0].Infos, 1) require.Equal(t, "3", execInfo.StateMachineTimers[0].Infos[0].Type) - require.Equal(t, 2, len(execInfo.StateMachineTimers[1].Infos)) + require.Len(t, execInfo.StateMachineTimers[1].Infos, 2) require.Equal(t, "0", execInfo.StateMachineTimers[1].Infos[0].Type) protorequire.ProtoSliceEqual(t, []*persistencespb.StateMachineKey{{Type: "t", Id: "a"}}, execInfo.StateMachineTimers[1].Infos[0].Ref.Path) require.Equal(t, "0", execInfo.StateMachineTimers[1].Infos[1].Type) protorequire.ProtoSliceEqual(t, []*persistencespb.StateMachineKey{{Type: "t", Id: "b"}}, execInfo.StateMachineTimers[1].Infos[1].Ref.Path) - require.Equal(t, 2, len(execInfo.StateMachineTimers[2].Infos)) + require.Len(t, execInfo.StateMachineTimers[2].Infos, 2) require.Equal(t, "1", execInfo.StateMachineTimers[2].Infos[0].Type) require.Equal(t, "2", execInfo.StateMachineTimers[2].Infos[1].Type) } @@ -77,7 +77,7 @@ func TestAddNextStateMachineTimerTask(t *testing.T) { workflow.AddNextStateMachineTimerTask(ms) - require.Equal(t, 1, len(scheduledTasks)) + require.Len(t, scheduledTasks, 1) task, ok := scheduledTasks[0].(*tasks.StateMachineTimerTask) require.True(t, ok) require.Equal(t, "ns-id", task.GetNamespaceID()) @@ -88,5 +88,5 @@ func TestAddNextStateMachineTimerTask(t *testing.T) { // First timer already scheduled should not generate any tasks. workflow.AddNextStateMachineTimerTask(ms) - require.Equal(t, 1, len(scheduledTasks)) + require.Len(t, scheduledTasks, 1) } diff --git a/service/history/workflow/task_generator_test.go b/service/history/workflow/task_generator_test.go index fc12c1a7030..4a8706fa7cf 100644 --- a/service/history/workflow/task_generator_test.go +++ b/service/history/workflow/task_generator_test.go @@ -400,7 +400,7 @@ func TestTaskGenerator_GenerateDirtySubStateMachineTasks(t *testing.T) { err = taskGenerator.GenerateDirtySubStateMachineTasks(reg) require.NoError(t, err) - require.Equal(t, 2, len(genTasks)) + require.Len(t, genTasks, 2) invocationTask, ok := genTasks[0].(*tasks.StateMachineOutboundTask) var backoffTask *tasks.StateMachineTimerTask if ok { @@ -441,7 +441,7 @@ func TestTaskGenerator_GenerateDirtySubStateMachineTasks(t *testing.T) { require.Equal(t, int64(3), backoffTask.Version) timers := mutableState.GetExecutionInfo().StateMachineTimers - require.Equal(t, 1, len(timers)) + require.Len(t, timers, 1) protorequire.ProtoEqual(t, &persistencespb.StateMachineTimerGroup{ Deadline: callbackToBackoff.NextAttemptScheduleTime, Scheduled: true, @@ -495,12 +495,12 @@ func TestTaskGenerator_GenerateDirtySubStateMachineTasks(t *testing.T) { // No new timer tasks are generated they are collapsed. // Only an outbound task is expected here. - require.Equal(t, 1, len(genTasks)) + require.Len(t, genTasks, 1) _, ok = genTasks[0].(*tasks.StateMachineOutboundTask) require.True(t, ok) timers = mutableState.GetExecutionInfo().StateMachineTimers - require.Equal(t, 2, len(timers)) + require.Len(t, timers, 2) protorequire.ProtoEqual(t, &persistencespb.StateMachineTaskInfo{ Ref: &persistencespb.StateMachineRef{ @@ -828,15 +828,15 @@ func TestTaskGeneratorImpl_GenerateMigrationTasks(t *testing.T) { ) resultTasks, _, err := taskGenerator.GenerateMigrationTasks(nil) require.NoError(t, err) - require.Equal(t, len(tc.expectedTaskTypes), len(resultTasks)) + require.Len(t, resultTasks, len(tc.expectedTaskTypes)) if tc.transitionHistoryEnabled { - require.Equal(t, 1, len(resultTasks)) + require.Len(t, resultTasks, 1) require.Equal(t, tc.expectedTaskTypes[0].String(), resultTasks[0].GetType().String()) syncVersionTask, ok := resultTasks[0].(*tasks.SyncVersionedTransitionTask) require.True(t, ok) require.Equal(t, chasm.WorkflowArchetypeID, syncVersionTask.GetArchetypeID()) taskEquivalent := syncVersionTask.TaskEquivalents - require.Equal(t, len(tc.expectedTaskEquivalentTypes), len(taskEquivalent)) + require.Len(t, taskEquivalent, len(tc.expectedTaskEquivalentTypes)) for i, equivalent := range taskEquivalent { require.Equal(t, tc.expectedTaskEquivalentTypes[i], equivalent.GetType()) } diff --git a/service/history/workflow/timer_sequence_test.go b/service/history/workflow/timer_sequence_test.go index 2d7aabad779..9a90b1ea3a0 100644 --- a/service/history/workflow/timer_sequence_test.go +++ b/service/history/workflow/timer_sequence_test.go @@ -825,7 +825,7 @@ func (s *timerSequenceSuite) TestLoadAndSortActivityTimers_One_Scheduled_Started s.mockMutableState.EXPECT().GetPendingActivityInfos().Return(activityInfos) timerSequenceIDs := s.timerSequence.LoadAndSortActivityTimers() - s.EqualValues([]TimerSequenceID{ + s.Equal([]TimerSequenceID{ { EventID: activityInfo.ScheduledEventId, Timestamp: activityInfo.StartedTime.AsTime().Add(activityInfo.StartToCloseTimeout.AsDuration()), diff --git a/service/history/workflow/update/abort_reason_test.go b/service/history/workflow/update/abort_reason_test.go index e35941abcba..1b7a5018f26 100644 --- a/service/history/workflow/update/abort_reason_test.go +++ b/service/history/workflow/update/abort_reason_test.go @@ -14,7 +14,7 @@ func TestAbortReasonUpdateStateMatrix(t *testing.T) { // Do not modify the test but make sure to update the reasonStateMatrix. require.True(t, ok, "Missing combination: %v, %v. If new abort reason or state is added make sure to update the reasonStateMatrix", r, st) if fe.f != nil { - require.Nil(t, fe.err) + require.NoError(t, fe.err) } if fe.err != nil { require.Nil(t, fe.f) diff --git a/service/history/workflow/update/registry_test.go b/service/history/workflow/update/registry_test.go index d07c9b72b7c..e648aa7f5fb 100644 --- a/service/history/workflow/update/registry_test.go +++ b/service/history/workflow/update/registry_test.go @@ -712,7 +712,7 @@ func TestClear(t *testing.T) { reg.Clear() wg.Wait() - require.Equal(t, reg.Len(), 0, "registry should be cleared") + require.Equal(t, 0, reg.Len(), "registry should be cleared") } func TestFailoverVersion(t *testing.T) { @@ -788,11 +788,11 @@ func TestTryResurrect(t *testing.T) { reg := update.NewRegistry(emptyUpdateStore) upd, err := reg.TryResurrect(context.Background(), nil) - require.Nil(t, err) + require.NoError(t, err) require.Nil(t, upd) upd, err = reg.TryResurrect(context.Background(), &protocolpb.Message{Body: nil}) - require.Nil(t, err) + require.NoError(t, err) require.Nil(t, upd) }) @@ -803,7 +803,7 @@ func TestTryResurrect(t *testing.T) { })} upd, err := reg.TryResurrect(context.Background(), completedMsg) - require.Nil(t, err) + require.NoError(t, err) require.Nil(t, upd) }) diff --git a/temporal/environment/env_test.go b/temporal/environment/env_test.go index e6addee752d..67b7a3b45ca 100644 --- a/temporal/environment/env_test.go +++ b/temporal/environment/env_test.go @@ -25,7 +25,7 @@ func TestLookupLocalhostIPMissingHostname(t *testing.T) { ip := net.ParseIP(ipString) a.True(ip.IsLoopback()) // if host can't be found, use ipv4 loopback - a.Equal(ip.String(), localhostIPDefault) + a.Equal(localhostIPDefault, ip.String()) } func TestLookupLocalhostIPWithIPv6(t *testing.T) { diff --git a/temporal/fx_test.go b/temporal/fx_test.go index fc4fe72d57f..b6fef3f2cac 100644 --- a/temporal/fx_test.go +++ b/temporal/fx_test.go @@ -63,7 +63,7 @@ func TestUpdateCurrentClusterMetadataRecord(t *testing.T) { mockClusterMetadataManager.EXPECT().SaveClusterMetadata(gomock.Any(), gomock.Any()).DoAndReturn( func(_ context.Context, request *persistence.SaveClusterMetadataRequest) (bool, error) { require.Equal(t, cfg.ClusterMetadata.EnableGlobalNamespace, request.IsGlobalNamespaceEnabled) - require.Equal(t, "", request.ClusterName) + require.Empty(t, request.ClusterName) require.Equal(t, cfg.ClusterMetadata.ClusterInformation[cfg.ClusterMetadata.CurrentClusterName].RPCAddress, request.ClusterAddress) require.Equal(t, cfg.ClusterMetadata.ClusterInformation[cfg.ClusterMetadata.CurrentClusterName].HTTPAddress, request.HttpAddress) require.Equal(t, cfg.ClusterMetadata.ClusterInformation[cfg.ClusterMetadata.CurrentClusterName].InitialFailoverVersion, request.InitialFailoverVersion) diff --git a/tools/cassandra/cqlclient_tests.go b/tools/cassandra/cqlclient_tests.go index b987f7db1d0..474ab29650f 100644 --- a/tools/cassandra/cqlclient_tests.go +++ b/tools/cassandra/cqlclient_tests.go @@ -38,7 +38,7 @@ func (s *CQLClientTestSuite) TestParseCQLFile() { func (s *CQLClientTestSuite) TestCQLClient() { client, err := newTestCQLClient(s.DBName) - s.Nil(err) + s.NoError(err) s.RunCreateTest(client) s.RunUpdateTest(client) s.RunDropTest(client) diff --git a/tools/cassandra/setup_task_tests.go b/tools/cassandra/setup_task_tests.go index a78ed543d00..936be67f971 100644 --- a/tools/cassandra/setup_task_tests.go +++ b/tools/cassandra/setup_task_tests.go @@ -27,13 +27,13 @@ func (s *SetupSchemaTestSuite) TearDownSuite() { } func (s *SetupSchemaTestSuite) TestCreateKeyspace() { - s.Nil(RunTool([]string{"./tool", "create", "-k", "foobar123", "--rf", "1"})) + s.NoError(RunTool([]string{"./tool", "create", "-k", "foobar123", "--rf", "1"})) err := s.client.dropKeyspace("foobar123") - s.Nil(err) + s.NoError(err) } func (s *SetupSchemaTestSuite) TestSetupSchema() { client, err := newTestCQLClient(s.DBName) - s.Nil(err) + s.NoError(err) s.RunSetupTest(buildCLIOptions(), client, "-k", createTestCQLFileContent(), []string{"tasks", "events"}) } diff --git a/tools/cassandra/update_task_tests.go b/tools/cassandra/update_task_tests.go index 38e13ee864b..339ed32ed1e 100644 --- a/tools/cassandra/update_task_tests.go +++ b/tools/cassandra/update_task_tests.go @@ -25,14 +25,14 @@ func (s *UpdateSchemaTestSuite) TearDownSuite() { func (s *UpdateSchemaTestSuite) TestUpdateSchema() { client, err := newTestCQLClient(s.DBName) - s.Nil(err) + s.NoError(err) defer client.Close() s.RunUpdateSchemaTest(buildCLIOptions(), client, "-k", createTestCQLFileContent(), []string{"events", "tasks"}) } func (s *UpdateSchemaTestSuite) TestDryrun() { client, err := newTestCQLClient(s.DBName) - s.Nil(err) + s.NoError(err) defer client.Close() dir := "../../schema/cassandra/temporal/versioned" s.RunDryrunTest(buildCLIOptions(), client, "-k", dir, cassandra.Version) diff --git a/tools/cassandra/version_tests.go b/tools/cassandra/version_tests.go index 666d9854b5c..4ea3f56c7f3 100644 --- a/tools/cassandra/version_tests.go +++ b/tools/cassandra/version_tests.go @@ -34,7 +34,7 @@ func (s *VersionTestSuite) TestVerifyCompatibleVersion() { cqlFile := path.Join(root, "schema/cassandra/temporal/schema.cql") defer s.createKeyspace(keyspace)() - s.Nil(RunTool([]string{ + s.NoError(RunTool([]string{ "./tool", "-k", keyspace, "-q", "setup-schema", "-f", cqlFile, "-version", "10.0", "-o", })) diff --git a/tools/common/schema/handler_test.go b/tools/common/schema/handler_test.go index 7362573e093..0de188e30b0 100644 --- a/tools/common/schema/handler_test.go +++ b/tools/common/schema/handler_test.go @@ -102,24 +102,24 @@ func (s *HandlerTestSuite) TestValidateUpdateConfig() { func (s *HandlerTestSuite) assertValidateSetupSucceeds(input *SetupConfig, db DB) { err := validateSetupConfig(input, db) - s.Nil(err) + s.NoError(err) } func (s *HandlerTestSuite) assertValidateSetupFails(input *SetupConfig, db DB) { err := validateSetupConfig(input, db) - s.NotNil(err) + s.Error(err) _, ok := err.(*ConfigError) s.True(ok) } func (s *HandlerTestSuite) assertValidateUpdateSucceeds(input *UpdateConfig, db DB) { err := validateUpdateConfig(input, db) - s.Nil(err) + s.NoError(err) } func (s *HandlerTestSuite) assertValidateUpdateFails(input *UpdateConfig, db DB) { err := validateUpdateConfig(input, db) - s.NotNil(err) + s.Error(err) _, ok := err.(*ConfigError) s.True(ok) } diff --git a/tools/common/schema/test/setuptest.go b/tools/common/schema/test/setuptest.go index c2344bab68b..2366391d175 100644 --- a/tools/common/schema/test/setuptest.go +++ b/tools/common/schema/test/setuptest.go @@ -59,8 +59,8 @@ func (tb *SetupSchemaTestBase) RunSetupTest( }...) tb.NoError(app.Run(command)) tables, err := db.ListTables() - tb.Nil(err) - tb.Equal(0, len(tables)) + tb.NoError(err) + tb.Empty(tables) tmpDir := testutils.MkdirTemp(tb.T(), "", "setupSchemaTestDir") sqlFile := testutils.CreateTemp(tb.T(), tmpDir, "setupSchema.cliOptionsTest") @@ -77,8 +77,8 @@ func (tb *SetupSchemaTestBase) RunSetupTest( }...) tb.NoError(app.Run(command)) tables, err = db.ListTables() - tb.Nil(err) - tb.Equal(0, len(tables)) + tb.NoError(err) + tb.Empty(tables) for i := range 4 { @@ -110,22 +110,22 @@ func (tb *SetupSchemaTestBase) RunSetupTest( expectedTables := getExpectedTables(versioningEnabled, expectedTables) tables, err = db.ListTables() - tb.Nil(err) - tb.Equal(len(expectedTables), len(tables)) + tb.NoError(err) + tb.Len(tables, len(expectedTables)) for _, t := range tables { _, ok := expectedTables[t] tb.True(ok) delete(expectedTables, t) } - tb.Equal(0, len(expectedTables)) + tb.Empty(expectedTables) gotVer, err := db.ReadSchemaVersion() if versioningEnabled { - tb.Nil(err) + tb.NoError(err) tb.Equal(ver, gotVer) } else { - tb.NotNil(err) + tb.Error(err) } } } diff --git a/tools/common/schema/test/updatetest.go b/tools/common/schema/test/updatetest.go index ad2b3598a1d..f65baeaaa65 100644 --- a/tools/common/schema/test/updatetest.go +++ b/tools/common/schema/test/updatetest.go @@ -66,7 +66,7 @@ func (tb *UpdateSchemaTestBase) RunDryrunTest(app *cli.App, db DB, dbNameFlag st }...) tb.NoError(app.Run(command)) ver, err := db.ReadSchemaVersion() - tb.Nil(err) + tb.NoError(err) // update the version to the latest tb.Logger.Info(ver) tb.Equal(endVersion, ver) @@ -100,12 +100,12 @@ func (tb *UpdateSchemaTestBase) RunUpdateSchemaTest(app *cli.App, db DB, dbNameF expected["namespaces"] = struct{}{} ver, err := db.ReadSchemaVersion() - tb.Nil(err) + tb.NoError(err) tb.Equal("2.0", ver) tables, err := db.ListTables() - tb.Nil(err) - tb.Equal(len(expected), len(tables)) + tb.NoError(err) + tb.Len(tables, len(expected)) for _, t := range tables { _, ok := expected[t] @@ -113,7 +113,7 @@ func (tb *UpdateSchemaTestBase) RunUpdateSchemaTest(app *cli.App, db DB, dbNameF delete(expected, t) } - tb.Equal(0, len(expected)) + tb.Empty(expected) tb.NoError(db.DropAllTables()) } @@ -128,9 +128,9 @@ func (tb *UpdateSchemaTestBase) makeSchemaVersionDirs(rootDir string, sqlFileCon dir := rootDir + "/v1.0" tb.NoError(os.Mkdir(rootDir+"/v1.0", os.FileMode(0700))) err := os.WriteFile(dir+"/manifest.json", []byte(mData), os.FileMode(0600)) - tb.Nil(err) + tb.NoError(err) err = os.WriteFile(dir+"/base.sql", []byte(sqlFileContent), os.FileMode(0600)) - tb.Nil(err) + tb.NoError(err) mData = `{ "CurrVersion": "2.0", @@ -147,9 +147,9 @@ func (tb *UpdateSchemaTestBase) makeSchemaVersionDirs(rootDir string, sqlFileCon dir = rootDir + "/v2.0" tb.NoError(os.Mkdir(rootDir+"/v2.0", os.FileMode(0700))) err = os.WriteFile(dir+"/manifest.json", []byte(mData), os.FileMode(0600)) - tb.Nil(err) + tb.NoError(err) err = os.WriteFile(dir+"/namespace.cql", []byte(namespace), os.FileMode(0600)) - tb.Nil(err) + tb.NoError(err) } func (tb *UpdateSchemaTestBase) getCommandBase() []string { diff --git a/tools/elasticsearch/main_test.go b/tools/elasticsearch/main_test.go index 251af9c665a..31e7464e8e7 100644 --- a/tools/elasticsearch/main_test.go +++ b/tools/elasticsearch/main_test.go @@ -33,7 +33,7 @@ func (s *MainTestSuite) TestSetupSchemaError() { args := []string{"./tool", "setup-schema"} app := BuildCLIOptions() err := app.Run(args) - s.Nil(err) + s.NoError(err) } func (s *MainTestSuite) TestPingError() { @@ -46,5 +46,5 @@ func (s *MainTestSuite) TestPingError() { args := []string{"./tool", "--endpoint", "http://nonexistent:9200", "ping"} app := BuildCLIOptions() err := app.Run(args) - s.Nil(err) + s.NoError(err) } diff --git a/tools/sql/clitest/conn_tests.go b/tools/sql/clitest/conn_tests.go index 137d8fd879f..f08681ad30b 100644 --- a/tools/sql/clitest/conn_tests.go +++ b/tools/sql/clitest/conn_tests.go @@ -72,7 +72,7 @@ func (s *SQLConnTestSuite) TestParseCQLFile() { // TestSQLConn test func (s *SQLConnTestSuite) TestSQLConn() { conn, err := newTestConn(s.DBName, s.host, s.port, s.pluginName) - s.Nil(err) + s.NoError(err) s.RunCreateTest(conn) s.RunUpdateTest(conn) s.RunDropTest(conn) diff --git a/tools/sql/clitest/handler_tests.go b/tools/sql/clitest/handler_tests.go index adca13224f7..3c348e5b687 100644 --- a/tools/sql/clitest/handler_tests.go +++ b/tools/sql/clitest/handler_tests.go @@ -44,14 +44,14 @@ func (s *HandlerTestSuite) SetupTest() { func (s *HandlerTestSuite) TestValidateConnectConfig() { cfg := new(config.SQL) - s.NotNil(sql.ValidateConnectConfig(cfg)) + s.Error(sql.ValidateConnectConfig(cfg)) cfg.ConnectAddr = net.JoinHostPort( environment.GetMySQLAddress(), strconv.Itoa(environment.GetMySQLPort()), ) - s.NotNil(sql.ValidateConnectConfig(cfg)) + s.Error(sql.ValidateConnectConfig(cfg)) cfg.DatabaseName = "foobar" - s.Nil(sql.ValidateConnectConfig(cfg)) + s.NoError(sql.ValidateConnectConfig(cfg)) } diff --git a/tools/sql/clitest/update_task_tests.go b/tools/sql/clitest/update_task_tests.go index 48df6260ff9..e85ee917d80 100644 --- a/tools/sql/clitest/update_task_tests.go +++ b/tools/sql/clitest/update_task_tests.go @@ -66,7 +66,7 @@ func (s *UpdateSchemaTestSuite) TearDownSuite() { // TestUpdateSchema test func (s *UpdateSchemaTestSuite) TestUpdateSchema() { conn, err := newTestConn(s.DBName, s.host, s.port, s.pluginName) - s.Nil(err) + s.NoError(err) defer conn.Close() s.RunUpdateSchemaTest(sql.BuildCLIOptions(), conn, "--db", s.sqlQuery, []string{"executions", "current_executions"}) } diff --git a/tools/tdbg/app_test.go b/tools/tdbg/app_test.go index 10627a6b456..16253f953d0 100644 --- a/tools/tdbg/app_test.go +++ b/tools/tdbg/app_test.go @@ -31,7 +31,7 @@ func (s *utilSuite) TestAcceptStringSliceArgsWithCommas() { Name: "dostuff", Action: func(c *cli.Context) error { input := c.StringSlice("input") - s.Equal(3, len(input)) + s.Len(input, 3) expectedInput := []string{"s1", "s2", "s3"} s.Equal(expectedInput, input) return nil diff --git a/tools/tdbg/util_test.go b/tools/tdbg/util_test.go index 861829ddbbd..44ff7beb88b 100644 --- a/tools/tdbg/util_test.go +++ b/tools/tdbg/util_test.go @@ -12,7 +12,7 @@ func (s *utilSuite) TestStringToEnum_MapCaseInsensitive() { result, err := tdbg.StringToEnum("timeR", enumValues) s.NoError(err) - s.Equal(result, int32(2)) // Timer + s.Equal(int32(2), result) // Timer } func (s *utilSuite) TestStringToEnum_MapNonExisting() { @@ -25,7 +25,7 @@ func (s *utilSuite) TestStringToEnum_MapNonExisting() { result, err := tdbg.StringToEnum("Timer2", enumValues) s.Error(err) - s.Equal(result, int32(0)) + s.Equal(int32(0), result) } func (s *utilSuite) TestStringToEnum_MapEmptyValue() { @@ -38,7 +38,7 @@ func (s *utilSuite) TestStringToEnum_MapEmptyValue() { result, err := tdbg.StringToEnum("", enumValues) s.NoError(err) - s.Equal(result, int32(0)) + s.Equal(int32(0), result) } func (s *utilSuite) TestStringToEnum_MapEmptyEnum() { @@ -46,5 +46,5 @@ func (s *utilSuite) TestStringToEnum_MapEmptyEnum() { result, err := tdbg.StringToEnum("Timer", enumValues) s.Error(err) - s.Equal(result, int32(0)) + s.Equal(int32(0), result) } diff --git a/tools/testrunner/junit_test.go b/tools/testrunner/junit_test.go index df806928d84..124937aa311 100644 --- a/tools/testrunner/junit_test.go +++ b/tools/testrunner/junit_test.go @@ -319,7 +319,7 @@ func TestJUnitXMLWellFormed(t *testing.T) { require.NoError(t, j2.read(), "Should be able to re-read the written XML") // Validate that the structure is reasonable - require.Greater(t, len(parsed.Suites), 0, "Should have at least one test suite") + require.NotEmpty(t, parsed.Suites, "Should have at least one test suite") }) } } diff --git a/tools/testrunner/log_test.go b/tools/testrunner/log_test.go index a3ca35f4def..779809bca36 100644 --- a/tools/testrunner/log_test.go +++ b/tools/testrunner/log_test.go @@ -72,7 +72,7 @@ func TestParseAlerts_DataRaceAndPanic(t *testing.T) { alerts := parseAlerts(string(input)) require.NotEmpty(t, alerts) - require.Equal(t, 2, len(alerts)) + require.Len(t, alerts, 2) require.Contains(t, alerts[0].Details, "WARNING: DATA RACE") require.Contains(t, alerts[0].Tests[0], "test.TestDataRaceExample") @@ -83,7 +83,7 @@ func TestParseAlerts_DataRaceAndPanic(t *testing.T) { // Ensure dedupe works deduped := dedupeAlerts(append(alerts, alerts...)) - require.Equal(t, len(deduped), len(alerts)) + require.Len(t, alerts, len(deduped)) } func TestParseFailureDetails(t *testing.T) {