From 88d58bb90d16cd8e94fece26bcb9cab9d48d1158 Mon Sep 17 00:00:00 2001 From: Stephan Behnke Date: Fri, 5 Jun 2026 14:58:56 -0700 Subject: [PATCH 01/27] Migrate worker_deployment_test.go Co-Authored-By: Claude Opus 4.8 (1M context) --- tests/worker_deployment_test.go | 1433 ++++++++++++++++--------------- 1 file changed, 735 insertions(+), 698 deletions(-) diff --git a/tests/worker_deployment_test.go b/tests/worker_deployment_test.go index 2f2ad94bc01..cc24c5fb91a 100644 --- a/tests/worker_deployment_test.go +++ b/tests/worker_deployment_test.go @@ -10,7 +10,6 @@ import ( "github.com/dgryski/go-farm" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" - "github.com/stretchr/testify/suite" commonpb "go.temporal.io/api/common/v1" deploymentpb "go.temporal.io/api/deployment/v1" enumspb "go.temporal.io/api/enums/v1" @@ -22,6 +21,7 @@ import ( "go.temporal.io/server/api/matchingservice/v1" "go.temporal.io/server/common" "go.temporal.io/server/common/dynamicconfig" + "go.temporal.io/server/common/testing/parallelsuite" "go.temporal.io/server/common/testing/testhooks" "go.temporal.io/server/common/testing/testvars" "go.temporal.io/server/common/worker_versioning" @@ -33,67 +33,67 @@ import ( type ( WorkerDeploymentSuite struct { - testcore.FunctionalTestBase - workflowVersion workerdeployment.DeploymentWorkflowVersion + parallelsuite.Suite[*WorkerDeploymentSuite] } ) func TestWorkerDeploymentSuite(t *testing.T) { - t.Parallel() - suite.Run(t, &WorkerDeploymentSuite{workflowVersion: workerdeployment.VersionDataRevisionNumber}) + parallelsuite.Run(t, &WorkerDeploymentSuite{}) } -func (s *WorkerDeploymentSuite) SetupSuite() { - s.FunctionalTestBase.SetupSuiteWithCluster(testcore.WithDynamicConfigOverrides(map[dynamicconfig.Key]any{ - dynamicconfig.MatchingDeploymentWorkflowVersion.Key(): int(s.workflowVersion), +// newTestEnv creates a TestEnv with the dynamic config this suite needs. +// Each test gets a dedicated, worker-enabled cluster since this suite mutates +// cluster-global deployment state and drives deployment system workflows. +// Additional per-test options may be passed in opts. +func (s *WorkerDeploymentSuite) newTestEnv(opts ...testcore.TestOption) *testcore.TestEnv { + baseOpts := []testcore.TestOption{ + testcore.WithWorkerService("worker deployment system workflows"), + testcore.WithDynamicConfig(dynamicconfig.MatchingDeploymentWorkflowVersion, int(workerdeployment.VersionDataRevisionNumber)), // Make sure we don't hit the rate limiter in tests - dynamicconfig.FrontendGlobalNamespaceNamespaceReplicationInducingAPIsRPS.Key(): 1000, - dynamicconfig.FrontendMaxNamespaceNamespaceReplicationInducingAPIsBurstRatioPerInstance.Key(): 1, - dynamicconfig.FrontendNamespaceReplicationInducingAPIsRPS.Key(): 1000, + testcore.WithDynamicConfig(dynamicconfig.FrontendGlobalNamespaceNamespaceReplicationInducingAPIsRPS, 1000), + testcore.WithDynamicConfig(dynamicconfig.FrontendMaxNamespaceNamespaceReplicationInducingAPIsBurstRatioPerInstance, 1), + testcore.WithDynamicConfig(dynamicconfig.FrontendNamespaceReplicationInducingAPIsRPS, 1000), // Make drainage happen sooner - dynamicconfig.VersionDrainageStatusRefreshInterval.Key(): testVersionDrainageRefreshInterval, - dynamicconfig.VersionDrainageStatusVisibilityGracePeriod.Key(): testVersionDrainageVisibilityGracePeriod, + testcore.WithDynamicConfig(dynamicconfig.VersionDrainageStatusRefreshInterval, testVersionDrainageRefreshInterval), + testcore.WithDynamicConfig(dynamicconfig.VersionDrainageStatusVisibilityGracePeriod, testVersionDrainageVisibilityGracePeriod), // To increase the rate at which the per-ns worker can consume tasks from a task queue. Required since // tests in this suite create a lot of tasks and expect them to be consumed quickly. - dynamicconfig.WorkerPerNamespaceWorkerOptions.Key(): sdkworker.Options{ + testcore.WithDynamicConfig(dynamicconfig.WorkerPerNamespaceWorkerOptions, sdkworker.Options{ MaxConcurrentWorkflowTaskPollers: 100, MaxConcurrentActivityTaskPollers: 100, - }, - - dynamicconfig.MatchingMaxTaskQueuesInDeploymentVersion.Key(): 1000, - dynamicconfig.VisibilityPersistenceSlowQueryThreshold.Key(): 60 * time.Second, - })) -} + }), -func (s *WorkerDeploymentSuite) SetupTest() { - s.FunctionalTestBase.SetupTest() + testcore.WithDynamicConfig(dynamicconfig.MatchingMaxTaskQueuesInDeploymentVersion, 1000), + testcore.WithDynamicConfig(dynamicconfig.VisibilityPersistenceSlowQueryThreshold, 60*time.Second), + } + return testcore.NewEnv(s.T(), append(baseOpts, opts...)...) } // pollFromDeployment calls PollWorkflowTaskQueue to start deployment related workflows -func (s *WorkerDeploymentSuite) pollFromDeployment(ctx context.Context, tv *testvars.TestVars) { - _, _ = s.FrontendClient().PollWorkflowTaskQueue(ctx, &workflowservice.PollWorkflowTaskQueueRequest{ - Namespace: s.Namespace().String(), +func (s *WorkerDeploymentSuite) pollFromDeployment(ctx context.Context, env *testcore.TestEnv, tv *testvars.TestVars) { + _, _ = env.FrontendClient().PollWorkflowTaskQueue(ctx, &workflowservice.PollWorkflowTaskQueueRequest{ + Namespace: env.Namespace().String(), TaskQueue: tv.TaskQueue(), Identity: "random", DeploymentOptions: tv.WorkerDeploymentOptions(true), }) } -func (s *WorkerDeploymentSuite) pollFromDeploymentWithTaskQueueNumber(ctx context.Context, tv *testvars.TestVars, taskQueueNumber int) { - _, _ = s.FrontendClient().PollWorkflowTaskQueue(ctx, &workflowservice.PollWorkflowTaskQueueRequest{ - Namespace: s.Namespace().String(), +func (s *WorkerDeploymentSuite) pollFromDeploymentWithTaskQueueNumber(ctx context.Context, env *testcore.TestEnv, tv *testvars.TestVars, taskQueueNumber int) { + _, _ = env.FrontendClient().PollWorkflowTaskQueue(ctx, &workflowservice.PollWorkflowTaskQueueRequest{ + Namespace: env.Namespace().String(), TaskQueue: tv.WithTaskQueueNumber(taskQueueNumber).TaskQueue(), Identity: "random", DeploymentOptions: tv.WorkerDeploymentOptions(true), }) } -func (s *WorkerDeploymentSuite) pollFromDeploymentExpectFail(ctx context.Context, tv *testvars.TestVars, expectedError string) { - _, err := s.FrontendClient().PollWorkflowTaskQueue(ctx, &workflowservice.PollWorkflowTaskQueueRequest{ - Namespace: s.Namespace().String(), +func (s *WorkerDeploymentSuite) pollFromDeploymentExpectFail(env *testcore.TestEnv, tv *testvars.TestVars, expectedError string) { + _, err := env.FrontendClient().PollWorkflowTaskQueue(s.Context(), &workflowservice.PollWorkflowTaskQueueRequest{ + Namespace: env.Namespace().String(), TaskQueue: tv.TaskQueue(), Identity: "random", DeploymentOptions: tv.WorkerDeploymentOptions(true), @@ -102,11 +102,11 @@ func (s *WorkerDeploymentSuite) pollFromDeploymentExpectFail(ctx context.Context s.Equal(expectedError, err.Error()) } -func (s *WorkerDeploymentSuite) ensureCreateVersionWithExpectedTaskQueues(ctx context.Context, tv *testvars.TestVars, expectedTaskQueues int) { +func (s *WorkerDeploymentSuite) ensureCreateVersionWithExpectedTaskQueues(env *testcore.TestEnv, tv *testvars.TestVars, expectedTaskQueues int) { s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - respV, _ := s.FrontendClient().DescribeWorkerDeploymentVersion(ctx, &workflowservice.DescribeWorkerDeploymentVersionRequest{ - Namespace: s.Namespace().String(), + respV, _ := env.FrontendClient().DescribeWorkerDeploymentVersion(s.Context(), &workflowservice.DescribeWorkerDeploymentVersionRequest{ + Namespace: env.Namespace().String(), Version: tv.DeploymentVersionString(), }) @@ -115,16 +115,17 @@ func (s *WorkerDeploymentSuite) ensureCreateVersionWithExpectedTaskQueues(ctx co } func (s *WorkerDeploymentSuite) ensureCreateVersionInDeployment( + env *testcore.TestEnv, tv *testvars.TestVars, ) { v := tv.DeploymentVersionString() - ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + ctx, cancel := context.WithTimeout(s.Context(), 5*time.Second) defer cancel() s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - res, _ := s.FrontendClient().DescribeWorkerDeployment(ctx, + res, _ := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentSeries(), }) @@ -141,27 +142,28 @@ func (s *WorkerDeploymentSuite) ensureCreateVersionInDeployment( } func (s *WorkerDeploymentSuite) ensureCreateDeployment( + env *testcore.TestEnv, tv *testvars.TestVars, ) { - ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + ctx, cancel := context.WithTimeout(s.Context(), 5*time.Second) defer cancel() s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - res, _ := s.FrontendClient().DescribeWorkerDeployment(ctx, + res, _ := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentSeries(), }) a.NotNil(res) }, 5*time.Second, 100*time.Millisecond) } -func (s *WorkerDeploymentSuite) startVersionWorkflow(ctx context.Context, tv *testvars.TestVars) { - go s.pollFromDeployment(ctx, tv) +func (s *WorkerDeploymentSuite) startVersionWorkflow(ctx context.Context, env *testcore.TestEnv, tv *testvars.TestVars) { + go s.pollFromDeployment(ctx, env, tv) s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err := s.FrontendClient().DescribeWorkerDeploymentVersion(ctx, &workflowservice.DescribeWorkerDeploymentVersionRequest{ - Namespace: s.Namespace().String(), + resp, err := env.FrontendClient().DescribeWorkerDeploymentVersion(ctx, &workflowservice.DescribeWorkerDeploymentVersionRequest{ + Namespace: env.Namespace().String(), Version: tv.DeploymentVersionString(), }) a.NoError(err) @@ -171,17 +173,18 @@ func (s *WorkerDeploymentSuite) startVersionWorkflow(ctx context.Context, tv *te } func (s *WorkerDeploymentSuite) TestForceCAN_NoOpenWFS() { - ctx, cancel := context.WithTimeout(context.Background(), time.Minute) - defer cancel() - tv := testvars.New(s) + env := s.newTestEnv() + + ctx := s.Context() + tv := s.tv() // Start a version workflow - s.startVersionWorkflow(ctx, tv) - s.ensureCreateVersionInDeployment(tv) + s.startVersionWorkflow(ctx, env, tv) + s.ensureCreateVersionInDeployment(env, tv) // Set the version as current - _, err := s.FrontendClient().SetWorkerDeploymentCurrentVersion(ctx, &workflowservice.SetWorkerDeploymentCurrentVersionRequest{ - Namespace: s.Namespace().String(), + _, err := env.FrontendClient().SetWorkerDeploymentCurrentVersion(ctx, &workflowservice.SetWorkerDeploymentCurrentVersionRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentSeries(), Version: tv.DeploymentVersionString(), }) @@ -193,14 +196,14 @@ func (s *WorkerDeploymentSuite) TestForceCAN_NoOpenWFS() { WorkflowId: workflowID, } - err = s.SendSignal(s.Namespace().String(), workflowExecution, workerdeployment.ForceCANSignalName, nil, tv.ClientIdentity()) + err = env.SendSignal(env.Namespace().String(), workflowExecution, workerdeployment.ForceCANSignalName, nil, tv.ClientIdentity()) s.NoError(err) // Verify if the state is intact even after a CAN s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err := s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentSeries(), }) a.NoError(err) @@ -209,17 +212,18 @@ func (s *WorkerDeploymentSuite) TestForceCAN_NoOpenWFS() { } func (s *WorkerDeploymentSuite) TestForceCAN_WithOverrideState() { - ctx, cancel := context.WithTimeout(context.Background(), time.Minute) - defer cancel() - tv := testvars.New(s) + env := s.newTestEnv() + + ctx := s.Context() + tv := s.tv() // Start a version workflow - s.startVersionWorkflow(ctx, tv) - s.ensureCreateVersionInDeployment(tv) + s.startVersionWorkflow(ctx, env, tv) + s.ensureCreateVersionInDeployment(env, tv) // Set the version as current - _, err := s.FrontendClient().SetWorkerDeploymentCurrentVersion(ctx, &workflowservice.SetWorkerDeploymentCurrentVersionRequest{ - Namespace: s.Namespace().String(), + _, err := env.FrontendClient().SetWorkerDeploymentCurrentVersion(ctx, &workflowservice.SetWorkerDeploymentCurrentVersionRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentSeries(), Version: tv.DeploymentVersionString(), }) @@ -257,14 +261,14 @@ func (s *WorkerDeploymentSuite) TestForceCAN_WithOverrideState() { WorkflowId: workflowID, } - err = s.SendSignal(s.Namespace().String(), workflowExecution, workerdeployment.ForceCANSignalName, signalPayload, tv.ClientIdentity()) + err = env.SendSignal(env.Namespace().String(), workflowExecution, workerdeployment.ForceCANSignalName, signalPayload, tv.ClientIdentity()) s.NoError(err) // Verify that the override state is used after CAN s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err := s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentSeries(), }) a.NoError(err) @@ -273,14 +277,15 @@ func (s *WorkerDeploymentSuite) TestForceCAN_WithOverrideState() { } func (s *WorkerDeploymentSuite) TestDeploymentVersionLimits() { - s.OverrideDynamicConfig(dynamicconfig.MatchingMaxVersionsInDeployment, 1) - s.OverrideDynamicConfig(dynamicconfig.MatchingMaxTaskQueuesInDeploymentVersion, 1) + env := s.newTestEnv( + testcore.WithDynamicConfig(dynamicconfig.MatchingMaxVersionsInDeployment, 1), + testcore.WithDynamicConfig(dynamicconfig.MatchingMaxTaskQueuesInDeploymentVersion, 1), + ) - ctx, cancel := context.WithTimeout(context.Background(), time.Second*120) - defer cancel() + ctx := s.Context() - firstDeployment := testvars.New(s).WithDeploymentSeriesNumber(1) - secondDeployment := testvars.New(s).WithDeploymentSeriesNumber(2) + firstDeployment := s.tv().WithDeploymentSeriesNumber(1) + secondDeployment := s.tv().WithDeploymentSeriesNumber(2) firstDeploymentVersionOne := firstDeployment.WithBuildIDNumber(1) firstDeploymentVersionTwo := firstDeployment.WithBuildIDNumber(2) @@ -291,18 +296,18 @@ func (s *WorkerDeploymentSuite) TestDeploymentVersionLimits() { expectedErrorMaxTaskQueues := fmt.Sprintf("cannot add task queue %v since maximum number of task queues (1) have been registered in deployment", secondDeploymentVersionOne.WithTaskQueueNumber(2).TaskQueue().GetName()) // First deployment version should be fine - go s.pollFromDeployment(ctx, firstDeploymentVersionOne) - s.ensureCreateVersionInDeployment(firstDeploymentVersionOne) + go s.pollFromDeployment(ctx, env, firstDeploymentVersionOne) + s.ensureCreateVersionInDeployment(env, firstDeploymentVersionOne) // pollers of second version in the same deployment should be rejected - s.pollFromDeploymentExpectFail(ctx, firstDeploymentVersionTwo, expectedErrorMaxVersions) + s.pollFromDeploymentExpectFail(env, firstDeploymentVersionTwo, expectedErrorMaxVersions) // But first version of another deployment fine - go s.pollFromDeployment(ctx, secondDeploymentVersionOne) - s.ensureCreateVersionInDeployment(secondDeploymentVersionOne) + go s.pollFromDeployment(ctx, env, secondDeploymentVersionOne) + s.ensureCreateVersionInDeployment(env, secondDeploymentVersionOne) // pollers of the second TQ in the same deployment version should be rejected - s.pollFromDeploymentExpectFail(ctx, secondDeploymentVersionOne.WithTaskQueueNumber(2), expectedErrorMaxTaskQueues) + s.pollFromDeploymentExpectFail(env, secondDeploymentVersionOne.WithTaskQueueNumber(2), expectedErrorMaxTaskQueues) } func (s *WorkerDeploymentSuite) TestNamespaceDeploymentsLimit() { @@ -310,49 +315,49 @@ func (s *WorkerDeploymentSuite) TestNamespaceDeploymentsLimit() { // Also in TestCreateWorkerDeployment_MaxDeploymentsLimit s.T().Skip() // Need to separate this test so other tests do not create deployment in the same NS - s.OverrideDynamicConfig(dynamicconfig.MatchingMaxDeployments, 1) + env := s.newTestEnv(testcore.WithDynamicConfig(dynamicconfig.MatchingMaxDeployments, 1)) - ctx, cancel := context.WithTimeout(context.Background(), time.Second*30) - defer cancel() + ctx := s.Context() - tv := testvars.New(s) + tv := s.tv() // First deployment version should be fine - go s.pollFromDeployment(ctx, tv) - s.ensureCreateVersionInDeployment(tv) + go s.pollFromDeployment(ctx, env, tv) + s.ensureCreateVersionInDeployment(env, tv) // wait for all existing deployments to show up in visibility - s.validateWorkerDeploymentCount(ctx, &workflowservice.ListWorkerDeploymentsRequest{Namespace: s.Namespace().String()}, 1) + s.validateWorkerDeploymentCount(env, &workflowservice.ListWorkerDeploymentsRequest{Namespace: env.Namespace().String()}, 1) // pollers of the second deployment version should be rejected - s.pollFromDeploymentExpectFail(ctx, tv.WithDeploymentSeriesNumber(2), "reached maximum deployments in namespace (1)") + s.pollFromDeploymentExpectFail(env, tv.WithDeploymentSeriesNumber(2), "reached maximum deployments in namespace (1)") } func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_TwoVersions_Sorted() { - ctx, cancel := context.WithTimeout(context.Background(), time.Second*30) - defer cancel() - tv := testvars.New(s) + env := s.newTestEnv() + + ctx := s.Context() + tv := s.tv() // Starting two versions of the deployment firstVersion := tv.WithBuildIDNumber(1) secondVersion := tv.WithBuildIDNumber(2) - go s.pollFromDeployment(ctx, firstVersion) + go s.pollFromDeployment(ctx, env, firstVersion) // Wait until the first version is registered in the deployment before starting the second. // This ensures that both versions get distinct CreateTime values in the deployment workflow // (each processed in a separate workflow task), so that the descending-by-CreateTime sort // produces a deterministic order. A wall-clock wait is not sufficient because in V2 mode // both registrations can queue up and be processed within the same workflow task millisecond. - s.ensureCreateVersionInDeployment(firstVersion) + s.ensureCreateVersionInDeployment(env, firstVersion) - go s.pollFromDeployment(ctx, secondVersion) + go s.pollFromDeployment(ctx, env, secondVersion) s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err := s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentSeries(), }) a.NoError(err) @@ -381,14 +386,15 @@ func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_TwoVersions_Sorted( } func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_MultipleVersions_Sorted() { - ctx, cancel := context.WithTimeout(context.Background(), time.Second*30) - defer cancel() - tv := testvars.New(s) + env := s.newTestEnv() + + ctx := s.Context() + tv := s.tv() numVersions := 10 for i := range numVersions { - go s.pollFromDeployment(ctx, tv.WithBuildIDNumber(i)) + go s.pollFromDeployment(ctx, env, tv.WithBuildIDNumber(i)) // waiting for 1ms to start the next version later. startTime := time.Now() @@ -401,8 +407,8 @@ func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_MultipleVersions_So s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err := s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentSeries(), }) a.NoError(err) @@ -420,24 +426,25 @@ func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_MultipleVersions_So // Testing ConflictToken func (s *WorkerDeploymentSuite) TestConflictToken_Describe_SetCurrent_SetRamping() { - ctx, cancel := context.WithTimeout(context.Background(), time.Second*30) - defer cancel() - tv := testvars.New(s) + env := s.newTestEnv() + + ctx := s.Context() + tv := s.tv() firstVersion := tv.WithBuildIDNumber(1) secondVersion := tv.WithBuildIDNumber(2) // Start deployment version workflow + worker-deployment workflow. - go s.pollFromDeployment(ctx, firstVersion) - go s.pollFromDeployment(ctx, secondVersion) + go s.pollFromDeployment(ctx, env, firstVersion) + go s.pollFromDeployment(ctx, env, secondVersion) var cT []byte // No current deployment version set. s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err := s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentSeries(), }) a.NoError(err) @@ -445,10 +452,10 @@ func (s *WorkerDeploymentSuite) TestConflictToken_Describe_SetCurrent_SetRamping cT = resp.GetConflictToken() }, time.Second*10, time.Millisecond*1000) - s.ensureCreateVersionInDeployment(firstVersion) + s.ensureCreateVersionInDeployment(env, firstVersion) // Set first version as current version - _, err := s.FrontendClient().SetWorkerDeploymentCurrentVersion(ctx, &workflowservice.SetWorkerDeploymentCurrentVersionRequest{ - Namespace: s.Namespace().String(), + _, err := env.FrontendClient().SetWorkerDeploymentCurrentVersion(ctx, &workflowservice.SetWorkerDeploymentCurrentVersionRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentSeries(), Version: firstVersion.DeploymentVersionString(), ConflictToken: cT, @@ -458,8 +465,8 @@ func (s *WorkerDeploymentSuite) TestConflictToken_Describe_SetCurrent_SetRamping s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err := s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentSeries(), }) a.NoError(err) @@ -468,9 +475,9 @@ func (s *WorkerDeploymentSuite) TestConflictToken_Describe_SetCurrent_SetRamping }, time.Second*10, time.Millisecond*1000) // Set a new second version and set it as the current version - go s.pollFromDeployment(ctx, secondVersion) - _, _ = s.FrontendClient().SetWorkerDeploymentRampingVersion(ctx, &workflowservice.SetWorkerDeploymentRampingVersionRequest{ - Namespace: s.Namespace().String(), + go s.pollFromDeployment(ctx, env, secondVersion) + _, _ = env.FrontendClient().SetWorkerDeploymentRampingVersion(ctx, &workflowservice.SetWorkerDeploymentRampingVersionRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentSeries(), Version: secondVersion.DeploymentVersionString(), Percentage: 5, @@ -481,8 +488,8 @@ func (s *WorkerDeploymentSuite) TestConflictToken_Describe_SetCurrent_SetRamping s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err := s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentSeries(), }) a.NoError(err) @@ -491,24 +498,23 @@ func (s *WorkerDeploymentSuite) TestConflictToken_Describe_SetCurrent_SetRamping } func (s *WorkerDeploymentSuite) TestConflictToken_SetCurrent_SetRamping_Wrong() { - s.OverrideDynamicConfig(dynamicconfig.FrontendMaskInternalErrorDetails, true) + env := s.newTestEnv(testcore.WithDynamicConfig(dynamicconfig.FrontendMaskInternalErrorDetails, true)) - ctx, cancel := context.WithTimeout(context.Background(), time.Second*30) - defer cancel() - tv := testvars.New(s) + ctx := s.Context() + tv := s.tv() expectedError := "conflict token mismatch" firstVersion := tv.WithBuildIDNumber(1) // Start deployment version workflow + worker-deployment workflow. - go s.pollFromDeployment(ctx, firstVersion) + go s.pollFromDeployment(ctx, env, firstVersion) cTWrong, _ := time.Now().MarshalBinary() // wrong token // Wait until deployment exists s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err := s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentSeries(), }) a.NoError(err) @@ -516,8 +522,8 @@ func (s *WorkerDeploymentSuite) TestConflictToken_SetCurrent_SetRamping_Wrong() }, time.Second*10, time.Millisecond*1000) // Set first version as current version with wrong token - _, err := s.FrontendClient().SetWorkerDeploymentCurrentVersion(ctx, &workflowservice.SetWorkerDeploymentCurrentVersionRequest{ - Namespace: s.Namespace().String(), + _, err := env.FrontendClient().SetWorkerDeploymentCurrentVersion(ctx, &workflowservice.SetWorkerDeploymentCurrentVersionRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentSeries(), Version: firstVersion.DeploymentVersionString(), ConflictToken: cTWrong, @@ -525,8 +531,8 @@ func (s *WorkerDeploymentSuite) TestConflictToken_SetCurrent_SetRamping_Wrong() s.Equal(expectedError, err.Error()) // Set first version as ramping version with wrong token - _, err = s.FrontendClient().SetWorkerDeploymentRampingVersion(ctx, &workflowservice.SetWorkerDeploymentRampingVersionRequest{ - Namespace: s.Namespace().String(), + _, err = env.FrontendClient().SetWorkerDeploymentRampingVersion(ctx, &workflowservice.SetWorkerDeploymentRampingVersionRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentSeries(), Version: firstVersion.DeploymentVersionString(), Percentage: 5, @@ -538,13 +544,14 @@ func (s *WorkerDeploymentSuite) TestConflictToken_SetCurrent_SetRamping_Wrong() // Testing ListWorkerDeployments func (s *WorkerDeploymentSuite) TestListWorkerDeployments_OneVersion_OneDeployment() { - ctx, cancel := context.WithTimeout(context.Background(), time.Minute) - defer cancel() - tv := testvars.New(s) + env := s.newTestEnv() + + ctx := s.Context() + tv := s.tv() startTime := timestamppb.Now() - s.startVersionWorkflow(ctx, tv) - s.ensureCreateVersionInDeployment(tv) + s.startVersionWorkflow(ctx, env, tv) + s.ensureCreateVersionInDeployment(env, tv) latestVersionSummary := &deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ Version: tv.DeploymentVersionString(), @@ -569,29 +576,30 @@ func (s *WorkerDeploymentSuite) TestListWorkerDeployments_OneVersion_OneDeployme nil, ) - s.startAndValidateWorkerDeployments(ctx, &workflowservice.ListWorkerDeploymentsRequest{ - Namespace: s.Namespace().String(), + s.startAndValidateWorkerDeployments(env, &workflowservice.ListWorkerDeploymentsRequest{ + Namespace: env.Namespace().String(), }, []*workflowservice.ListWorkerDeploymentsResponse_WorkerDeploymentSummary{expectedDeploymentSummaries}) } func (s *WorkerDeploymentSuite) TestListWorkerDeployments_TwoVersions_SameDeployment_OneCurrent_NoRamping() { - ctx, cancel := context.WithTimeout(context.Background(), time.Minute) - defer cancel() - tv := testvars.New(s) + env := s.newTestEnv() + + ctx := s.Context() + tv := s.tv() firstVersion := tv.WithBuildIDNumber(1) secondVersion := tv.WithBuildIDNumber(2) createVersion1Time := timestamppb.Now() - s.startVersionWorkflow(ctx, firstVersion) - s.ensureCreateVersionInDeployment(firstVersion) + s.startVersionWorkflow(ctx, env, firstVersion) + s.ensureCreateVersionInDeployment(env, firstVersion) createVersion2Time := timestamppb.Now() - s.startVersionWorkflow(ctx, secondVersion) - s.ensureCreateVersionInDeployment(secondVersion) + s.startVersionWorkflow(ctx, env, secondVersion) + s.ensureCreateVersionInDeployment(env, secondVersion) setCurrentTime := timestamppb.Now() - s.setCurrentVersion(ctx, firstVersion, true, "") + s.setCurrentVersion(env, firstVersion, true, "") routingInfo := &deploymentpb.RoutingConfig{ CurrentVersion: firstVersion.DeploymentVersionString(), @@ -631,33 +639,34 @@ func (s *WorkerDeploymentSuite) TestListWorkerDeployments_TwoVersions_SameDeploy nil, ) - s.startAndValidateWorkerDeployments(ctx, &workflowservice.ListWorkerDeploymentsRequest{ - Namespace: s.Namespace().String(), + s.startAndValidateWorkerDeployments(env, &workflowservice.ListWorkerDeploymentsRequest{ + Namespace: env.Namespace().String(), }, []*workflowservice.ListWorkerDeploymentsResponse_WorkerDeploymentSummary{ expectedDeploymentSummary, }) } func (s *WorkerDeploymentSuite) TestListWorkerDeployments_TwoVersions_SameDeployment_OneCurrent_OneRamping() { - ctx, cancel := context.WithTimeout(context.Background(), time.Minute) - defer cancel() - tv := testvars.New(s) + env := s.newTestEnv() + + ctx := s.Context() + tv := s.tv() currentVersionVars := tv.WithBuildIDNumber(1) rampingVersionVars := tv.WithBuildIDNumber(2) createVersion1Time := timestamppb.Now() - s.startVersionWorkflow(ctx, currentVersionVars) - s.ensureCreateVersionInDeployment(currentVersionVars) + s.startVersionWorkflow(ctx, env, currentVersionVars) + s.ensureCreateVersionInDeployment(env, currentVersionVars) createVersion2Time := timestamppb.Now() - s.startVersionWorkflow(ctx, rampingVersionVars) - s.ensureCreateVersionInDeployment(rampingVersionVars) + s.startVersionWorkflow(ctx, env, rampingVersionVars) + s.ensureCreateVersionInDeployment(env, rampingVersionVars) setCurrentTime := timestamppb.Now() - s.setCurrentVersion(ctx, currentVersionVars, true, "") // starts first version's version workflow + set it to current + s.setCurrentVersion(env, currentVersionVars, true, "") // starts first version's version workflow + set it to current setRampingTime := timestamppb.Now() - s.setAndVerifyRampingVersion(ctx, rampingVersionVars, false, 50, true, "") + s.setAndVerifyRampingVersion(env, rampingVersionVars, false, 50, true, "") routingInfo := &deploymentpb.RoutingConfig{ CurrentVersion: currentVersionVars.DeploymentVersionString(), CurrentVersionChangedTime: setCurrentTime, @@ -699,22 +708,23 @@ func (s *WorkerDeploymentSuite) TestListWorkerDeployments_TwoVersions_SameDeploy latestVersionSummary, // latest version added is the ramping version ) - s.startAndValidateWorkerDeployments(ctx, &workflowservice.ListWorkerDeploymentsRequest{ - Namespace: s.Namespace().String(), + s.startAndValidateWorkerDeployments(env, &workflowservice.ListWorkerDeploymentsRequest{ + Namespace: env.Namespace().String(), }, []*workflowservice.ListWorkerDeploymentsResponse_WorkerDeploymentSummary{ expectedDeploymentSummary, }) } func (s *WorkerDeploymentSuite) TestListWorkerDeployments_RampingVersionPercentageChange_RampingChangedTime() { - ctx, cancel := context.WithTimeout(context.Background(), time.Minute) - defer cancel() - tv := testvars.New(s) + env := s.newTestEnv() + + ctx := s.Context() + tv := s.tv() startTime := timestamppb.Now() - s.startVersionWorkflow(ctx, tv) + s.startVersionWorkflow(ctx, env, tv) setRampTime := timestamppb.Now() - s.setAndVerifyRampingVersion(ctx, tv, false, 50, true, "") // set version as ramping + s.setAndVerifyRampingVersion(env, tv, false, 50, true, "") // set version as ramping routingInfo := &deploymentpb.RoutingConfig{ CurrentVersion: worker_versioning.UnversionedVersionId, @@ -731,7 +741,7 @@ func (s *WorkerDeploymentSuite) TestListWorkerDeployments_RampingVersionPercenta changeRampTime := timestamppb.Now() // modify ramping version percentage - s.setAndVerifyRampingVersion(ctx, tv, false, 75, true, "") + s.setAndVerifyRampingVersion(env, tv, false, 75, true, "") // only the ramping version percentage should be updated, not the ramping version update time // since we are not changing the ramping version @@ -759,8 +769,8 @@ func (s *WorkerDeploymentSuite) TestListWorkerDeployments_RampingVersionPercenta rampingVersionSummary, ) - s.startAndValidateWorkerDeployments(ctx, &workflowservice.ListWorkerDeploymentsRequest{ - Namespace: s.Namespace().String(), + s.startAndValidateWorkerDeployments(env, &workflowservice.ListWorkerDeploymentsRequest{ + Namespace: env.Namespace().String(), }, []*workflowservice.ListWorkerDeploymentsResponse_WorkerDeploymentSummary{ expectedDeploymentSummary, }) @@ -768,27 +778,27 @@ func (s *WorkerDeploymentSuite) TestListWorkerDeployments_RampingVersionPercenta } func (s *WorkerDeploymentSuite) TestListWorkerDeployments_MultipleVersions_MultipleDeployments_OnePage() { - ctx, cancel := context.WithTimeout(context.Background(), time.Minute) - defer cancel() - tv := testvars.New(s) + env := s.newTestEnv() + + tv := s.tv() - expectedDeploymentSummaries := s.createVersionsInDeployments(ctx, tv, 2) + expectedDeploymentSummaries := s.createVersionsInDeployments(env, tv, 2) - s.startAndValidateWorkerDeployments(ctx, &workflowservice.ListWorkerDeploymentsRequest{ - Namespace: s.Namespace().String(), + s.startAndValidateWorkerDeployments(env, &workflowservice.ListWorkerDeploymentsRequest{ + Namespace: env.Namespace().String(), }, expectedDeploymentSummaries) } func (s *WorkerDeploymentSuite) TestListWorkerDeployments_MultipleVersions_MultipleDeployments_MultiplePages() { - ctx, cancel := context.WithTimeout(context.Background(), time.Minute) - defer cancel() - tv := testvars.New(s) + env := s.newTestEnv() - expectedDeploymentSummaries := s.createVersionsInDeployments(ctx, tv, 5) + tv := s.tv() - s.startAndValidateWorkerDeployments(ctx, &workflowservice.ListWorkerDeploymentsRequest{ - Namespace: s.Namespace().String(), + expectedDeploymentSummaries := s.createVersionsInDeployments(env, tv, 5) + + s.startAndValidateWorkerDeployments(env, &workflowservice.ListWorkerDeploymentsRequest{ + Namespace: env.Namespace().String(), PageSize: 1, }, expectedDeploymentSummaries) } @@ -796,26 +806,27 @@ func (s *WorkerDeploymentSuite) TestListWorkerDeployments_MultipleVersions_Multi // Testing SetWorkerDeploymentRampingVersion // Also tests whether LastCurrentTime is successfully updated when a previously-current version is demoted and then promoted back to current. func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Ramping_With_Current() { - ctx, cancel := context.WithTimeout(context.Background(), time.Minute) - defer cancel() - tv := testvars.New(s) + env := s.newTestEnv() + + ctx := s.Context() + tv := s.tv() rampingVersionVars := tv.WithBuildIDNumber(1) currentVersionVars := tv.WithBuildIDNumber(2) versionCreateTime := timestamppb.Now() - s.startVersionWorkflow(ctx, rampingVersionVars) - s.startVersionWorkflow(ctx, currentVersionVars) + s.startVersionWorkflow(ctx, env, rampingVersionVars) + s.startVersionWorkflow(ctx, env, currentVersionVars) // set version as ramping setRampingUpdateTime := timestamppb.Now() - s.setAndVerifyRampingVersion(ctx, rampingVersionVars, false, 50, true, "") - resp, err := s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + s.setAndVerifyRampingVersion(env, rampingVersionVars, false, 50, true, "") + resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentSeries(), }) s.NoError(err) - s.verifyDescribeWorkerDeployment(s.Require(), resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: tv.DeploymentSeries(), CreateTime: versionCreateTime, @@ -846,15 +857,15 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Ramping_Wi // set current version setCurrentUpdateTime := timestamppb.Now() - s.setCurrentVersion(ctx, currentVersionVars, true, "") + s.setCurrentVersion(env, currentVersionVars, true, "") // fresh DescribeWorkerDeployment call - resp, err = s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + resp, err = env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentSeries(), }) s.NoError(err) - s.verifyDescribeWorkerDeployment(s.Require(), resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: tv.DeploymentSeries(), CreateTime: versionCreateTime, @@ -897,14 +908,14 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Ramping_Wi // Now, demote the current version (by promoting the ramping version) and verify that LastCurrentTime is unchanged. setRampingAsCurrentUpdateTime := timestamppb.Now() - s.setCurrentVersion(ctx, rampingVersionVars, true, "") + s.setCurrentVersion(env, rampingVersionVars, true, "") // fresh DescribeWorkerDeployment call - resp, err = s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + resp, err = env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentSeries(), }) s.NoError(err) - s.verifyDescribeWorkerDeployment(s.Require(), resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: tv.DeploymentSeries(), CreateTime: versionCreateTime, @@ -950,14 +961,14 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Ramping_Wi // Now, re-promote the current version to Current and verify that LastCurrentTime is updated for that version (and unchanged for the originally-ramping version). rePromoteCurrentUpdateTime := timestamppb.Now() - s.setCurrentVersion(ctx, currentVersionVars, true, "") + s.setCurrentVersion(env, currentVersionVars, true, "") // fresh DescribeWorkerDeployment call - resp, err = s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + resp, err = env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentSeries(), }) s.NoError(err) - s.verifyDescribeWorkerDeployment(s.Require(), resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: tv.DeploymentSeries(), CreateTime: versionCreateTime, @@ -1004,22 +1015,23 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Ramping_Wi } func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_DuplicateRamp() { - ctx, cancel := context.WithTimeout(context.Background(), time.Minute) - defer cancel() - rampingVersionVars := testvars.New(s).WithBuildIDNumber(1) + env := s.newTestEnv() + + ctx := s.Context() + rampingVersionVars := s.tv().WithBuildIDNumber(1) versionCreateTime := timestamppb.Now() - s.startVersionWorkflow(ctx, rampingVersionVars) + s.startVersionWorkflow(ctx, env, rampingVersionVars) // set version as ramping setRampingUpdateTime := timestamppb.Now() - s.setAndVerifyRampingVersion(ctx, rampingVersionVars, false, 50, true, "") - resp, err := s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + s.setAndVerifyRampingVersion(env, rampingVersionVars, false, 50, true, "") + resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: rampingVersionVars.DeploymentSeries(), }) s.NoError(err) - s.verifyDescribeWorkerDeployment(s.Require(), resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: rampingVersionVars.DeploymentSeries(), CreateTime: versionCreateTime, @@ -1049,26 +1061,27 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_DuplicateR }) // setting version as ramping again - s.setAndVerifyRampingVersion(ctx, rampingVersionVars, false, 50, true, "") + s.setAndVerifyRampingVersion(env, rampingVersionVars, false, 50, true, "") } func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Invalid_SetCurrent_To_Ramping() { - ctx, cancel := context.WithTimeout(context.Background(), time.Minute) - defer cancel() + env := s.newTestEnv() + + ctx := s.Context() versionCreateTime := timestamppb.Now() - currentVersionVars := testvars.New(s).WithBuildIDNumber(1) - s.startVersionWorkflow(ctx, currentVersionVars) + currentVersionVars := s.tv().WithBuildIDNumber(1) + s.startVersionWorkflow(ctx, env, currentVersionVars) setCurrentUpdateTime := timestamppb.Now() - s.setCurrentVersion(ctx, currentVersionVars, true, "") + s.setCurrentVersion(env, currentVersionVars, true, "") - resp, err := s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: currentVersionVars.DeploymentSeries(), }) s.NoError(err) - s.verifyDescribeWorkerDeployment(s.Require(), resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: currentVersionVars.DeploymentSeries(), CreateTime: versionCreateTime, @@ -1099,14 +1112,14 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Invalid_Se }) expectedError := fmt.Errorf("ramping version %s is already current", currentVersionVars.DeploymentVersionString()) - s.setAndVerifyRampingVersion(ctx, currentVersionVars, false, 50, true, expectedError.Error()) // setting current version to ramping should fail + s.setAndVerifyRampingVersion(env, currentVersionVars, false, 50, true, expectedError.Error()) // setting current version to ramping should fail - resp, err = s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + resp, err = env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: currentVersionVars.DeploymentSeries(), }) s.NoError(err) - s.verifyDescribeWorkerDeployment(s.Require(), resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: currentVersionVars.DeploymentSeries(), CreateTime: versionCreateTime, @@ -1138,40 +1151,42 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Invalid_Se } func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Valid_SetNilCurrent_To_Ramping() { - ctx, cancel := context.WithTimeout(context.Background(), time.Minute) - defer cancel() + env := s.newTestEnv() - tv := testvars.New(s).WithBuildIDNumber(1) - s.startVersionWorkflow(ctx, tv) + ctx := s.Context() + + tv := s.tv().WithBuildIDNumber(1) + s.startVersionWorkflow(ctx, env, tv) // set ramping version to unversioned will change the modifier identity, so it's not a no-op - s.setAndVerifyRampingVersion(ctx, tv, true, 0, false, "") + s.setAndVerifyRampingVersion(env, tv, true, 0, false, "") // set a non-nil ramping version so that we can unset it in the next step - s.setAndVerifyRampingVersion(ctx, tv, false, 5, false, "") + s.setAndVerifyRampingVersion(env, tv, false, 5, false, "") // should be able to unset ramping version while current version is nil with no error - s.setAndVerifyRampingVersion(ctx, tv, true, 0, true, "") + s.setAndVerifyRampingVersion(env, tv, true, 0, true, "") } func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_ModifyExistingRampVersionPercentage() { - ctx, cancel := context.WithTimeout(context.Background(), time.Minute) - defer cancel() - tv := testvars.New(s) + env := s.newTestEnv() + + ctx := s.Context() + tv := s.tv() versionCreateTime := timestamppb.Now() rampingVersionVars := tv.WithBuildIDNumber(1) - s.startVersionWorkflow(ctx, rampingVersionVars) + s.startVersionWorkflow(ctx, env, rampingVersionVars) // set version as ramping setRampingUpdateTime := timestamppb.Now() - s.setAndVerifyRampingVersion(ctx, rampingVersionVars, false, 50, true, "") - resp, err := s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + s.setAndVerifyRampingVersion(env, rampingVersionVars, false, 50, true, "") + resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentSeries(), }) s.NoError(err) - s.verifyDescribeWorkerDeployment(s.Require(), resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: tv.DeploymentSeries(), CreateTime: versionCreateTime, @@ -1202,15 +1217,15 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_ModifyExis // modify ramping version percentage modifyRampingPercentageTime := timestamppb.Now() - s.setAndVerifyRampingVersion(ctx, rampingVersionVars, false, 75, true, "") + s.setAndVerifyRampingVersion(env, rampingVersionVars, false, 75, true, "") // RampingVersionPercentage and RampingVersionPercentageChangedTime should be updated - resp, err = s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + resp, err = env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentSeries(), }) s.NoError(err) - s.verifyDescribeWorkerDeployment(s.Require(), resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: tv.DeploymentSeries(), CreateTime: versionCreateTime, @@ -1242,30 +1257,31 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_ModifyExis } func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_WithCurrent_Unset_Ramp() { - ctx, cancel := context.WithTimeout(context.Background(), time.Minute) - defer cancel() - tv := testvars.New(s) + env := s.newTestEnv() + + ctx := s.Context() + tv := s.tv() rampingVersionVars := tv.WithBuildIDNumber(1) currentVersionVars := tv.WithBuildIDNumber(2) version1CreateTime := timestamppb.Now() - s.startVersionWorkflow(ctx, rampingVersionVars) + s.startVersionWorkflow(ctx, env, rampingVersionVars) version2CreateTime := timestamppb.Now() - s.startVersionWorkflow(ctx, currentVersionVars) + s.startVersionWorkflow(ctx, env, currentVersionVars) setRampingUpdateTime := timestamppb.Now() - s.setAndVerifyRampingVersion(ctx, rampingVersionVars, false, 50, true, "") // set version as ramping + s.setAndVerifyRampingVersion(env, rampingVersionVars, false, 50, true, "") // set version as ramping setCurrentUpdateTime := timestamppb.Now() - s.setCurrentVersion(ctx, currentVersionVars, true, "") // set version as curent + s.setCurrentVersion(env, currentVersionVars, true, "") // set version as curent - resp, err := s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentSeries(), }) s.NoError(err) - s.verifyDescribeWorkerDeployment(s.Require(), resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: tv.DeploymentSeries(), CreateTime: version1CreateTime, @@ -1308,14 +1324,14 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_WithCurren // unset ramping version unsetRampingUpdateTime := timestamppb.Now() - s.setAndVerifyRampingVersion(ctx, rampingVersionVars, true, 0, true, "") + s.setAndVerifyRampingVersion(env, rampingVersionVars, true, 0, true, "") - resp, err = s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + resp, err = env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentSeries(), }) s.NoError(err) - s.verifyDescribeWorkerDeployment(s.Require(), resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: tv.DeploymentSeries(), CreateTime: version1CreateTime, @@ -1358,27 +1374,28 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_WithCurren } func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_SetRampingAsCurrent() { - ctx, cancel := context.WithTimeout(context.Background(), time.Minute) - defer cancel() - tv := testvars.New(s) + env := s.newTestEnv() + + ctx := s.Context() + tv := s.tv() versionCreateTime := timestamppb.Now() rampingVersionVars := tv.WithBuildIDNumber(1) - s.startVersionWorkflow(ctx, rampingVersionVars) + s.startVersionWorkflow(ctx, env, rampingVersionVars) setRampingUpdateTime := timestamppb.Now() - s.setAndVerifyRampingVersion(ctx, rampingVersionVars, false, 50, true, "") + s.setAndVerifyRampingVersion(env, rampingVersionVars, false, 50, true, "") // set ramping version as current setCurrentUpdateTime := timestamppb.Now() - s.setCurrentVersion(ctx, rampingVersionVars, true, "") + s.setCurrentVersion(env, rampingVersionVars, true, "") - resp, err := s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentSeries(), }) s.NoError(err) - s.verifyDescribeWorkerDeployment(s.Require(), resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: tv.DeploymentSeries(), CreateTime: versionCreateTime, @@ -1410,58 +1427,60 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_SetRamping } func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_NoCurrent_Unset_Ramp() { - ctx, cancel := context.WithTimeout(context.Background(), time.Minute) - defer cancel() - tv := testvars.New(s) + env := s.newTestEnv() + + ctx := s.Context() + tv := s.tv() rampingVersionVars := tv.WithBuildIDNumber(1) - s.startVersionWorkflow(ctx, rampingVersionVars) + s.startVersionWorkflow(ctx, env, rampingVersionVars) - s.setAndVerifyRampingVersion(ctx, rampingVersionVars, false, 50, true, "") - s.setAndVerifyRampingVersion(ctx, rampingVersionVars, true, 0, true, "") + s.setAndVerifyRampingVersion(env, rampingVersionVars, false, 50, true, "") + s.setAndVerifyRampingVersion(env, rampingVersionVars, true, 0, true, "") } func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Batching() { - ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute) - defer cancel() - tv := testvars.New(s) + env := s.newTestEnv() + + ctx := s.Context() + tv := s.tv() - s.InjectHook(testhooks.NewHook(testhooks.TaskQueuesInDeploymentSyncBatchSize, 1)) + env.InjectHook(testhooks.NewHook(testhooks.TaskQueuesInDeploymentSyncBatchSize, 1)) // registering 5 task-queues in the version which would result in the creation of 5 batches, each with 1 task-queue, during the SyncState call. versionCreateTime := timestamppb.Now() taskQueues := 5 for i := range taskQueues { - go s.pollFromDeploymentWithTaskQueueNumber(ctx, tv, i) + go s.pollFromDeploymentWithTaskQueueNumber(ctx, env, tv, i) } // ensure the version has been created in the deployment with the right number of task-queues - s.ensureCreateVersionInDeployment(tv) - s.ensureCreateVersionWithExpectedTaskQueues(ctx, tv, taskQueues) + s.ensureCreateVersionInDeployment(env, tv) + s.ensureCreateVersionWithExpectedTaskQueues(env, tv, taskQueues) // verify that all the registered task-queues have "" set as their ramping version for i := range taskQueues { - s.verifyTaskQueueVersioningInfo(ctx, tv.WithTaskQueueNumber(i).TaskQueue(), worker_versioning.UnversionedVersionId, "", 0) + s.verifyTaskQueueVersioningInfo(env, tv.WithTaskQueueNumber(i).TaskQueue(), worker_versioning.UnversionedVersionId, "", 0) } // set ramping version to 50% setRampingUpdateTime := timestamppb.Now() - s.setAndVerifyRampingVersion(ctx, tv, false, 50, true, "") + s.setAndVerifyRampingVersion(env, tv, false, 50, true, "") // verify the task queues have new ramping version for i := range taskQueues { - s.verifyTaskQueueVersioningInfo(ctx, tv.WithTaskQueueNumber(i).TaskQueue(), worker_versioning.UnversionedVersionId, tv.DeploymentVersionString(), 50) + s.verifyTaskQueueVersioningInfo(env, tv.WithTaskQueueNumber(i).TaskQueue(), worker_versioning.UnversionedVersionId, tv.DeploymentVersionString(), 50) } // verify if the worker-deployment has the right ramping version set - resp, err := s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentSeries(), }) s.NoError(err) s.Equal(tv.DeploymentVersionString(), resp.GetWorkerDeploymentInfo().GetRoutingConfig().GetRampingVersion()) - s.verifyDescribeWorkerDeployment(s.Require(), resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: tv.DeploymentSeries(), CreateTime: versionCreateTime, @@ -1495,39 +1514,40 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Batching() // TestSetWorkerDeploymentRampingVersion_UnversionedRamp_Batching verifies that the batching functionality works // when ramping unversioned. func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_UnversionedRamp_Batching() { - ctx, cancel := context.WithTimeout(context.Background(), time.Second*60) - defer cancel() - tv := testvars.New(s) + env := s.newTestEnv() + + ctx := s.Context() + tv := s.tv() - s.InjectHook(testhooks.NewHook(testhooks.TaskQueuesInDeploymentSyncBatchSize, 1)) + env.InjectHook(testhooks.NewHook(testhooks.TaskQueuesInDeploymentSyncBatchSize, 1)) // registering 5 task-queues in the version which would result in the creation of 5 batches, each with 1 task-queue, during the SyncState call. versionCreateTime := timestamppb.Now() taskQueues := 5 for i := range taskQueues { - go s.pollFromDeploymentWithTaskQueueNumber(ctx, tv, i) + go s.pollFromDeploymentWithTaskQueueNumber(ctx, env, tv, i) } // ensure the version has been created in the deployment with the right number of task-queues - s.ensureCreateVersionInDeployment(tv) - s.ensureCreateVersionWithExpectedTaskQueues(ctx, tv, taskQueues) + s.ensureCreateVersionInDeployment(env, tv) + s.ensureCreateVersionWithExpectedTaskQueues(env, tv, taskQueues) // make the current version versioned, so that we can set ramp to unversioned later setCurrentUpdateTime := timestamppb.Now() - s.setCurrentVersion(ctx, tv, true, "") + s.setCurrentVersion(env, tv, true, "") // set ramp to unversioned which should trigger a batch of SyncDeploymentVersionUserData requests. setRampingUpdateTime := timestamppb.Now() - s.setAndVerifyRampingVersionUnversionedOption(ctx, tv, true, false, 75, true, false, true, "") + s.setAndVerifyRampingVersionUnversionedOption(env, tv, true, false, 75, true, false, true, "") // check that the current version's task queues have ramping version == __unversioned__ for i := range taskQueues { - s.verifyTaskQueueVersioningInfo(ctx, tv.WithTaskQueueNumber(i).TaskQueue(), tv.DeploymentVersionString(), worker_versioning.UnversionedVersionId, 75) + s.verifyTaskQueueVersioningInfo(env, tv.WithTaskQueueNumber(i).TaskQueue(), tv.DeploymentVersionString(), worker_versioning.UnversionedVersionId, 75) } // verify if the worker-deployment has the right ramping version set - resp, err := s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentSeries(), }) s.NoError(err) @@ -1535,7 +1555,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Unversione s.Equal(worker_versioning.UnversionedVersionId, resp.GetWorkerDeploymentInfo().GetRoutingConfig().GetRampingVersion()) s.Nil(resp.GetWorkerDeploymentInfo().GetRoutingConfig().GetRampingDeploymentVersion()) - s.verifyDescribeWorkerDeployment(s.Require(), resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: tv.DeploymentSeries(), CreateTime: versionCreateTime, @@ -1570,9 +1590,10 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Unversione // SetCurrent tests func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_SetCurrentVersion() { - ctx, cancel := context.WithTimeout(context.Background(), time.Second*30) - defer cancel() - tv := testvars.New(s) + env := s.newTestEnv() + + ctx := s.Context() + tv := s.tv() firstVersion := tv.WithBuildIDNumber(1) secondVersion := tv.WithBuildIDNumber(2) @@ -1581,14 +1602,14 @@ func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_SetCurrentVersion() // Start poller with cancellable context for deterministic control pollerCtx, pollerCancel := context.WithCancel(ctx) defer pollerCancel() - go s.pollFromDeployment(pollerCtx, firstVersion) + go s.pollFromDeployment(pollerCtx, env, firstVersion) // Wait for version to be created deterministically - s.ensureCreateVersionInDeployment(firstVersion) + s.ensureCreateVersionInDeployment(env, firstVersion) // Verify no current deployment version is set initially - resp, err := s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentSeries(), }) s.NoError(err) @@ -1597,14 +1618,14 @@ func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_SetCurrentVersion() // Set first version as current version firstVersionCurrentUpdateTime := timestamppb.Now() - s.setCurrentVersion(ctx, firstVersion, true, "") + s.setCurrentVersion(env, firstVersion, true, "") - resp, err = s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + resp, err = env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentSeries(), }) s.NoError(err) - s.verifyDescribeWorkerDeployment(s.Require(), resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: tv.DeploymentSeries(), CreateTime: version1CreateTime, @@ -1635,17 +1656,17 @@ func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_SetCurrentVersion() // Start second poller with cancellable context poller2Ctx, poller2Cancel := context.WithCancel(ctx) defer poller2Cancel() - go s.pollFromDeployment(poller2Ctx, secondVersion) + go s.pollFromDeployment(poller2Ctx, env, secondVersion) secondVersionCurrentUpdateTime := timestamppb.Now() - s.setCurrentVersion(ctx, secondVersion, true, "") + s.setCurrentVersion(env, secondVersion, true, "") // Verify that the first version is draining, has an updated last deactivation time + second version is current, has an updated first activation time. - resp, err = s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + resp, err = env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentSeries(), }) s.NoError(err) - s.verifyDescribeWorkerDeployment(s.Require(), resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: tv.DeploymentSeries(), CreateTime: version1CreateTime, @@ -1686,45 +1707,46 @@ func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_SetCurrentVersion() } func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Batching() { - ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute) - defer cancel() - tv := testvars.New(s) + env := s.newTestEnv() - s.InjectHook(testhooks.NewHook(testhooks.TaskQueuesInDeploymentSyncBatchSize, 1)) + ctx := s.Context() + tv := s.tv() + + env.InjectHook(testhooks.NewHook(testhooks.TaskQueuesInDeploymentSyncBatchSize, 1)) // registering 5 task-queues in the version which would result in the creation of 5 batches, each with 1 task-queue, during the SyncState call. versionCreateTime := timestamppb.Now() taskQueues := 5 for i := range taskQueues { - go s.pollFromDeploymentWithTaskQueueNumber(ctx, tv, i) + go s.pollFromDeploymentWithTaskQueueNumber(ctx, env, tv, i) } // ensure the version has been created in the deployment with the right number of task-queues - s.ensureCreateVersionInDeployment(tv) - s.ensureCreateVersionWithExpectedTaskQueues(ctx, tv, taskQueues) + s.ensureCreateVersionInDeployment(env, tv) + s.ensureCreateVersionWithExpectedTaskQueues(env, tv, taskQueues) // verify that all the registered task-queues have "__unversioned__" as their current version for i := range taskQueues { - s.verifyTaskQueueVersioningInfo(ctx, tv.WithTaskQueueNumber(i).TaskQueue(), worker_versioning.UnversionedVersionId, "", 0) + s.verifyTaskQueueVersioningInfo(env, tv.WithTaskQueueNumber(i).TaskQueue(), worker_versioning.UnversionedVersionId, "", 0) } // set current and check that the current version's task queues have new current version setCurrentUpdateTime := timestamppb.Now() - s.setCurrentVersion(ctx, tv, true, "") + s.setCurrentVersion(env, tv, true, "") // verify the current version has propogated to all the registered task-queues userData for i := range taskQueues { - s.verifyTaskQueueVersioningInfo(ctx, tv.WithTaskQueueNumber(i).TaskQueue(), tv.DeploymentVersionString(), "", 0) + s.verifyTaskQueueVersioningInfo(env, tv.WithTaskQueueNumber(i).TaskQueue(), tv.DeploymentVersionString(), "", 0) } // verify if the worker-deployment has the right current version set - resp, err := s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentSeries(), }) s.NoError(err) - s.verifyDescribeWorkerDeployment(s.Require(), resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: tv.DeploymentSeries(), CreateTime: versionCreateTime, @@ -1757,117 +1779,119 @@ func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Batching() { } func (s *WorkerDeploymentSuite) TestSetManagerIdentity_RW() { - ctx, cancel := context.WithTimeout(context.Background(), time.Second*30) - defer cancel() - tv := testvars.New(s).WithBuildIDNumber(1) + env := s.newTestEnv() - go s.pollFromDeployment(ctx, tv) - s.ensureCreateVersionInDeployment(tv) + ctx := s.Context() + tv := s.tv().WithBuildIDNumber(1) + + go s.pollFromDeployment(ctx, env, tv) + s.ensureCreateVersionInDeployment(env, tv) // set identity to self - s.setAndValidateManagerIdentity(ctx, tv, true, false, "", "") + s.setAndValidateManagerIdentity(env, tv, true, false, "", "") // set identity to other - s.setAndValidateManagerIdentity(ctx, tv, false, false, "other", "") + s.setAndValidateManagerIdentity(env, tv, false, false, "other", "") // set identity to other again (should be idempotent) - s.setAndValidateManagerIdentity(ctx, tv, false, false, "other", "") + s.setAndValidateManagerIdentity(env, tv, false, false, "other", "") // unset identity - s.setAndValidateManagerIdentity(ctx, tv, false, false, "", "") + s.setAndValidateManagerIdentity(env, tv, false, false, "", "") // set identity with bad conflict token - s.setAndValidateManagerIdentity(ctx, tv, true, true, "", "conflict token mismatch") + s.setAndValidateManagerIdentity(env, tv, true, true, "", "conflict token mismatch") } func (s *WorkerDeploymentSuite) TestSetManagerIdentity_WithSetRampSetCurrent() { - ctx, cancel := context.WithTimeout(context.Background(), time.Second*30) - defer cancel() - tv := testvars.New(s).WithBuildIDNumber(1) + env := s.newTestEnv() + + ctx := s.Context() + tv := s.tv().WithBuildIDNumber(1) - go s.pollFromDeployment(ctx, tv) - s.ensureCreateVersionInDeployment(tv) + go s.pollFromDeployment(ctx, env, tv) + s.ensureCreateVersionInDeployment(env, tv) // set identity to self - s.setAndValidateManagerIdentity(ctx, tv, true, false, "", "") + s.setAndValidateManagerIdentity(env, tv, true, false, "", "") // -> self can successfully set ramp - s.setAndVerifyRampingVersion(ctx, tv, false, 1, true, "") + s.setAndVerifyRampingVersion(env, tv, false, 1, true, "") // set identity to other - s.setAndValidateManagerIdentity(ctx, tv, false, false, "other", "") + s.setAndValidateManagerIdentity(env, tv, false, false, "other", "") // -> self cannot set ramp - s.setAndVerifyRampingVersion(ctx, tv, false, 2, true, fmt.Sprintf(workerdeployment.ErrManagerIdentityMismatch, "other", tv.ClientIdentity())) + s.setAndVerifyRampingVersion(env, tv, false, 2, true, fmt.Sprintf(workerdeployment.ErrManagerIdentityMismatch, "other", tv.ClientIdentity())) // -> self cannot set current - s.setCurrentVersion(ctx, tv, true, fmt.Sprintf(workerdeployment.ErrManagerIdentityMismatch, "other", tv.ClientIdentity())) + s.setCurrentVersion(env, tv, true, fmt.Sprintf(workerdeployment.ErrManagerIdentityMismatch, "other", tv.ClientIdentity())) // unset identity - s.setAndValidateManagerIdentity(ctx, tv, false, false, "", "") + s.setAndValidateManagerIdentity(env, tv, false, false, "", "") // -> self can now set ramp - s.setAndVerifyRampingVersion(ctx, tv, false, 2, true, "") + s.setAndVerifyRampingVersion(env, tv, false, 2, true, "") // set identity to self - s.setAndValidateManagerIdentity(ctx, tv, true, false, "", "") + s.setAndValidateManagerIdentity(env, tv, true, false, "", "") // -> self can now set current - s.setCurrentVersion(ctx, tv, true, "") + s.setCurrentVersion(env, tv, true, "") } func (s *WorkerDeploymentSuite) TestSetManagerIdentity_WithDeleteVersion() { - s.OverrideDynamicConfig(dynamicconfig.PollerHistoryTTL, 500*time.Millisecond) + env := s.newTestEnv(testcore.WithDynamicConfig(dynamicconfig.PollerHistoryTTL, 500*time.Millisecond)) - ctx, cancel := context.WithTimeout(context.Background(), time.Second*30) - defer cancel() - tv := testvars.New(s).WithBuildIDNumber(1) + ctx := s.Context() + tv := s.tv().WithBuildIDNumber(1) // start and stop polling so that version is eligible for deletion pollerCtx, pollerCancel := context.WithCancel(ctx) - go s.pollFromDeployment(pollerCtx, tv) - s.ensureCreateVersionInDeployment(tv) + go s.pollFromDeployment(pollerCtx, env, tv) + s.ensureCreateVersionInDeployment(env, tv) pollerCancel() // set identity to other - s.setAndValidateManagerIdentity(ctx, tv, false, false, "other", "") + s.setAndValidateManagerIdentity(env, tv, false, false, "other", "") // -> self cannot delete version - s.tryDeleteVersion(ctx, tv, fmt.Sprintf(workerdeployment.ErrManagerIdentityMismatch, "other", tv.ClientIdentity())) + s.tryDeleteVersion(env, tv, fmt.Sprintf(workerdeployment.ErrManagerIdentityMismatch, "other", tv.ClientIdentity())) // set identity to self - s.setAndValidateManagerIdentity(ctx, tv, true, false, "", "") + s.setAndValidateManagerIdentity(env, tv, true, false, "", "") // -> self can now delete version - s.tryDeleteVersion(ctx, tv, "") + s.tryDeleteVersion(env, tv, "") } // TestDeleteVersion_ServerDeleteMaxVersionsReached tests that when the internal limit for the number of versions // in a worker-deployment (defaultMaxVersions) is reached, the server deletes the oldest version to register the new version. // Additionally, the test verifies that the last modifier identity is not set to the identity of the worker-deployment workflow. func (s *WorkerDeploymentSuite) TestDeleteVersion_ServerDeleteMaxVersionsReached() { - s.OverrideDynamicConfig(dynamicconfig.PollerHistoryTTL, 1*time.Millisecond) - s.OverrideDynamicConfig(dynamicconfig.MatchingMaxVersionsInDeployment, 1) + env := s.newTestEnv( + testcore.WithDynamicConfig(dynamicconfig.PollerHistoryTTL, 1*time.Millisecond), + testcore.WithDynamicConfig(dynamicconfig.MatchingMaxVersionsInDeployment, 1), + ) - ctx, cancel := context.WithTimeout(context.Background(), time.Second*30) - defer cancel() - tv := testvars.New(s).WithBuildIDNumber(1) - tv2 := testvars.New(s).WithBuildIDNumber(2) + ctx := s.Context() + tv := s.tv().WithBuildIDNumber(1) + tv2 := s.tv().WithBuildIDNumber(2) // start and stop polling so that version is eligible for deletion pollerCtx, pollerCancel := context.WithCancel(ctx) - go s.pollFromDeployment(pollerCtx, tv) - s.ensureCreateVersionInDeployment(tv) + go s.pollFromDeployment(pollerCtx, env, tv) + s.ensureCreateVersionInDeployment(env, tv) pollerCancel() // Set a different manager identity so that we can verify that the internal delete operation does not conduct the manager identity check // while deleting the version - s.setAndValidateManagerIdentity(ctx, tv, false, false, "other", "") + s.setAndValidateManagerIdentity(env, tv, false, false, "other", "") // Start another poller which shall aim to create a new version. This should, in turn, delete the first version. pollerCtx2, pollerCancel2 := context.WithCancel(ctx) - go s.pollFromDeployment(pollerCtx2, tv2) - s.ensureCreateVersionInDeployment(tv2) + go s.pollFromDeployment(pollerCtx2, env, tv2) + s.ensureCreateVersionInDeployment(env, tv2) pollerCancel2() // Verify that the worker deployment only has one version in it's version summaries. s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err := s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentSeries(), }) a.NoError(err) @@ -1881,34 +1905,35 @@ func (s *WorkerDeploymentSuite) TestDeleteVersion_ServerDeleteMaxVersionsReached // Should see that the current version of the task queues becomes unversioned func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Unversioned_NoRamp() { - ctx, cancel := context.WithTimeout(context.Background(), time.Second*30) - defer cancel() - currentVars := testvars.New(s).WithBuildIDNumber(1) + env := s.newTestEnv() + + ctx := s.Context() + currentVars := s.tv().WithBuildIDNumber(1) versionCreateTime := timestamppb.Now() - go s.pollFromDeployment(ctx, currentVars) - s.ensureCreateVersionInDeployment(currentVars) + go s.pollFromDeployment(ctx, env, currentVars) + s.ensureCreateVersionInDeployment(env, currentVars) // check that the current version's task queues have current version unversioned to start - s.verifyTaskQueueVersioningInfo(ctx, currentVars.TaskQueue(), worker_versioning.UnversionedVersionId, "", 0) + s.verifyTaskQueueVersioningInfo(env, currentVars.TaskQueue(), worker_versioning.UnversionedVersionId, "", 0) // set current and check that the current version's task queues have new current version firstCurrentUpdateTime := timestamppb.Now() - s.setCurrentVersion(ctx, currentVars, true, "") - s.verifyTaskQueueVersioningInfo(ctx, currentVars.TaskQueue(), currentVars.DeploymentVersionString(), "", 0) + s.setCurrentVersion(env, currentVars, true, "") + s.verifyTaskQueueVersioningInfo(env, currentVars.TaskQueue(), currentVars.DeploymentVersionString(), "", 0) // set current unversioned and check that the current version's task queues have current version unversioned again secondCurrentUpdateTime := timestamppb.Now() - s.setCurrentVersionUnversionedOption(ctx, currentVars, true, true, false, true, "") - s.verifyTaskQueueVersioningInfo(ctx, currentVars.TaskQueue(), worker_versioning.UnversionedVersionId, "", 0) + s.setCurrentVersionUnversionedOption(env, currentVars, true, true, false, true, "") + s.verifyTaskQueueVersioningInfo(env, currentVars.TaskQueue(), worker_versioning.UnversionedVersionId, "", 0) // check that deployment has current version == __unversioned__ - resp, err := s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: currentVars.DeploymentSeries(), }) s.NoError(err) - s.verifyDescribeWorkerDeployment(s.Require(), resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: currentVars.DeploymentSeries(), CreateTime: versionCreateTime, @@ -1937,47 +1962,47 @@ func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Unversioned_NoRamp() { // Should see that the current version of the task queue becomes unversioned, and the unversioned ramping version of the task queue is removed func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Unversioned_PromoteUnversionedRamp() { - ctx, cancel := context.WithTimeout(context.Background(), time.Second*60) - defer cancel() - tv := testvars.New(s) + env := s.newTestEnv() + + ctx := s.Context() + tv := s.tv() currentVars := tv.WithBuildIDNumber(1) - go s.pollFromDeployment(ctx, currentVars) - s.ensureCreateVersionInDeployment(currentVars) + go s.pollFromDeployment(ctx, env, currentVars) + s.ensureCreateVersionInDeployment(env, currentVars) // make the current version versioned, so that we can set ramp to unversioned - s.setCurrentVersion(ctx, currentVars, true, "") + s.setCurrentVersion(env, currentVars, true, "") // set ramp to unversioned - s.setAndVerifyRampingVersionUnversionedOption(ctx, tv, true, false, 75, true, false, true, "") + s.setAndVerifyRampingVersionUnversionedOption(env, tv, true, false, 75, true, false, true, "") // check that the current version's task queues have ramping version == __unversioned__ - s.verifyTaskQueueVersioningInfo(ctx, currentVars.TaskQueue(), currentVars.DeploymentVersionString(), worker_versioning.UnversionedVersionId, 75) + s.verifyTaskQueueVersioningInfo(env, currentVars.TaskQueue(), currentVars.DeploymentVersionString(), worker_versioning.UnversionedVersionId, 75) // set current to unversioned - s.setCurrentVersionUnversionedOption(ctx, tv, true, true, false, true, "") + s.setCurrentVersionUnversionedOption(env, tv, true, true, false, true, "") // check that the current version's task queues have ramping version == "" and current version == "__unversioned__" - s.verifyTaskQueueVersioningInfo(ctx, currentVars.TaskQueue(), worker_versioning.UnversionedVersionId, "", 0) + s.verifyTaskQueueVersioningInfo(env, currentVars.TaskQueue(), worker_versioning.UnversionedVersionId, "", 0) } func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Concurrent_DifferentVersions_NoUnexpectedErrors() { - s.OverrideDynamicConfig(dynamicconfig.WorkflowExecutionMaxInFlightUpdates, 10) // this is the default + env := s.newTestEnv(testcore.WithDynamicConfig(dynamicconfig.WorkflowExecutionMaxInFlightUpdates, 10)) // this is the default - ctx, cancel := context.WithTimeout(context.Background(), time.Minute) - defer cancel() + ctx := s.Context() - tv := testvars.New(s) + tv := s.tv() errChan := make(chan error) versions := 10 for i := range versions { - s.startVersionWorkflow(ctx, tv.WithBuildIDNumber(i)) + s.startVersionWorkflow(ctx, env, tv.WithBuildIDNumber(i)) } // Concurrently set 10 different versions as current version for i := range versions { go func() { - _, err := s.FrontendClient().SetWorkerDeploymentCurrentVersion(ctx, &workflowservice.SetWorkerDeploymentCurrentVersionRequest{ - Namespace: s.Namespace().String(), + _, err := env.FrontendClient().SetWorkerDeploymentCurrentVersion(ctx, &workflowservice.SetWorkerDeploymentCurrentVersionRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentVersion().GetDeploymentName(), Version: tv.WithBuildIDNumber(i).DeploymentVersionString(), IgnoreMissingTaskQueues: true, @@ -2002,8 +2027,8 @@ func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Concurrent_DifferentVersio } // Verify that the current version is set. - resp, err := s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentVersion().GetDeploymentName(), }) s.NoError(err) @@ -2011,21 +2036,20 @@ func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Concurrent_DifferentVersio } func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Concurrent_SameVersion_NoUnexpectedErrors() { - s.OverrideDynamicConfig(dynamicconfig.WorkflowExecutionMaxInFlightUpdates, 10) // this is the default + env := s.newTestEnv(testcore.WithDynamicConfig(dynamicconfig.WorkflowExecutionMaxInFlightUpdates, 10)) // this is the default - ctx, cancel := context.WithTimeout(context.Background(), time.Minute) - defer cancel() + ctx := s.Context() - tv := testvars.New(s) + tv := s.tv() errChan := make(chan error) - s.startVersionWorkflow(ctx, tv) // create version + s.startVersionWorkflow(ctx, env, tv) // create version // Concurrently set the same version as current version 10 times. for range 10 { go func() { - _, err := s.FrontendClient().SetWorkerDeploymentCurrentVersion(ctx, &workflowservice.SetWorkerDeploymentCurrentVersionRequest{ - Namespace: s.Namespace().String(), + _, err := env.FrontendClient().SetWorkerDeploymentCurrentVersion(ctx, &workflowservice.SetWorkerDeploymentCurrentVersionRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentVersion().GetDeploymentName(), Version: tv.DeploymentVersionString(), IgnoreMissingTaskQueues: true, @@ -2050,8 +2074,8 @@ func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Concurrent_SameVersion_NoU } // Verify that the current version is set. - resp, err := s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentVersion().GetDeploymentName(), }) s.NoError(err) @@ -2061,24 +2085,25 @@ func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Concurrent_SameVersion_NoU // TestConcurrentPollers_DifferentTaskQueues_SameVersion_SetCurrentVersion aims to test that when there are multiple pollers polling on different task queues, // all belonging to the same version, a setCurrentVersion call succeeds with all the task queues eventually having this version as the current version in their versioning info. func (s *WorkerDeploymentSuite) TestConcurrentPollers_DifferentTaskQueues_SameVersion_SetCurrentVersion() { - ctx, cancel := context.WithTimeout(context.Background(), 1*time.Minute) - defer cancel() + env := s.newTestEnv() + + ctx := s.Context() // start 10 different pollers each polling on a different task queue but belonging to the same version - tv := testvars.New(s) + tv := s.tv() tqs := 10 // Start all pollers concurrently (pollFromDeployment has no assertions, so it's safe to call from goroutines) for i := range tqs { - go s.pollFromDeployment(ctx, tv.WithTaskQueueNumber(i)) + go s.pollFromDeployment(ctx, env, tv.WithTaskQueueNumber(i)) } // Wait for all version workflows to appear (must run in the test goroutine due to assertions) for i := range tqs { tvI := tv.WithTaskQueueNumber(i) s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err := s.FrontendClient().DescribeWorkerDeploymentVersion(ctx, &workflowservice.DescribeWorkerDeploymentVersionRequest{ - Namespace: s.Namespace().String(), + resp, err := env.FrontendClient().DescribeWorkerDeploymentVersion(ctx, &workflowservice.DescribeWorkerDeploymentVersionRequest{ + Namespace: env.Namespace().String(), Version: tvI.DeploymentVersionString(), }) a.NoError(err) @@ -2087,33 +2112,32 @@ func (s *WorkerDeploymentSuite) TestConcurrentPollers_DifferentTaskQueues_SameVe } // set this version as current version - s.setCurrentVersion(ctx, tv, false, "") + s.setCurrentVersion(env, tv, false, "") // verify that the task queues, eventually, have this version as the current version in their versioning info for i := range tqs { - s.verifyTaskQueueVersioningInfo(ctx, tv.WithTaskQueueNumber(i).TaskQueue(), tv.DeploymentVersionString(), "", 0) + s.verifyTaskQueueVersioningInfo(env, tv.WithTaskQueueNumber(i).TaskQueue(), tv.DeploymentVersionString(), "", 0) } } func (s *WorkerDeploymentSuite) TestSetRampingVersion_Concurrent_DifferentVersions_NoUnexpectedErrors() { - s.OverrideDynamicConfig(dynamicconfig.WorkflowExecutionMaxInFlightUpdates, 10) // this is the default + env := s.newTestEnv(testcore.WithDynamicConfig(dynamicconfig.WorkflowExecutionMaxInFlightUpdates, 10)) // this is the default - ctx, cancel := context.WithTimeout(context.Background(), time.Minute) - defer cancel() + ctx := s.Context() - tv := testvars.New(s) + tv := s.tv() errChan := make(chan error) versions := 10 for i := range versions { - s.startVersionWorkflow(ctx, tv.WithBuildIDNumber(i)) + s.startVersionWorkflow(ctx, env, tv.WithBuildIDNumber(i)) } // Concurrently set 10 different versions as ramping version for i := range versions { go func() { - _, err := s.FrontendClient().SetWorkerDeploymentRampingVersion(ctx, &workflowservice.SetWorkerDeploymentRampingVersionRequest{ - Namespace: s.Namespace().String(), + _, err := env.FrontendClient().SetWorkerDeploymentRampingVersion(ctx, &workflowservice.SetWorkerDeploymentRampingVersionRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentVersion().GetDeploymentName(), Version: tv.WithBuildIDNumber(i).DeploymentVersionString(), IgnoreMissingTaskQueues: true, @@ -2139,8 +2163,8 @@ func (s *WorkerDeploymentSuite) TestSetRampingVersion_Concurrent_DifferentVersio } // Verify that the ramping version is set. - resp, err := s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentVersion().GetDeploymentName(), }) s.NoError(err) @@ -2148,21 +2172,20 @@ func (s *WorkerDeploymentSuite) TestSetRampingVersion_Concurrent_DifferentVersio } func (s *WorkerDeploymentSuite) TestSetRampingVersion_Concurrent_SameVersion_NoUnexpectedErrors() { - s.OverrideDynamicConfig(dynamicconfig.WorkflowExecutionMaxInFlightUpdates, 10) // this is the default + env := s.newTestEnv(testcore.WithDynamicConfig(dynamicconfig.WorkflowExecutionMaxInFlightUpdates, 10)) // this is the default - ctx, cancel := context.WithTimeout(context.Background(), time.Minute) - defer cancel() + ctx := s.Context() - tv := testvars.New(s) + tv := s.tv() errChan := make(chan error) - s.startVersionWorkflow(ctx, tv) // create version + s.startVersionWorkflow(ctx, env, tv) // create version // Concurrently set the same version as ramping version 10 times. for range 10 { go func() { - _, err := s.FrontendClient().SetWorkerDeploymentRampingVersion(ctx, &workflowservice.SetWorkerDeploymentRampingVersionRequest{ - Namespace: s.Namespace().String(), + _, err := env.FrontendClient().SetWorkerDeploymentRampingVersion(ctx, &workflowservice.SetWorkerDeploymentRampingVersionRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentVersion().GetDeploymentName(), Version: tv.DeploymentVersionString(), IgnoreMissingTaskQueues: true, @@ -2188,8 +2211,8 @@ func (s *WorkerDeploymentSuite) TestSetRampingVersion_Concurrent_SameVersion_NoU } // Verify that the ramping version is set. - resp, err := s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentVersion().GetDeploymentName(), }) s.NoError(err) @@ -2206,20 +2229,22 @@ func (s *WorkerDeploymentSuite) TestConcurrentPollers_ManyTaskQueues_RapidRoutin // Also skipping for AsyncSetCurrentAndRampingVersion, to reduce flake chance. s.skipBeforeVersion(workerdeployment.VersionDataRevisionNumber) + env := s.newTestEnv() + // Start pollers on many task queues across 3 versions numTaskQueues := 50 numVersions := 3 syncBatchSize := 2 // reducing batch size to cause more delay numOperations := 20 - s.OverrideDynamicConfig(dynamicconfig.MatchingMaxTaskQueuesInDeploymentVersion, numTaskQueues) - s.InjectHook(testhooks.NewHook(testhooks.TaskQueuesInDeploymentSyncBatchSize, syncBatchSize)) - s.InjectHook(testhooks.NewHook(testhooks.MatchingDeploymentRegisterErrorBackoff, time.Millisecond*500)) + env.OverrideDynamicConfig(dynamicconfig.MatchingMaxTaskQueuesInDeploymentVersion, numTaskQueues) + env.InjectHook(testhooks.NewHook(testhooks.TaskQueuesInDeploymentSyncBatchSize, syncBatchSize)) + env.InjectHook(testhooks.NewHook(testhooks.MatchingDeploymentRegisterErrorBackoff, time.Millisecond*500)) // Need to increase max pending activities because it is set only to 10 for functional tests. it's 2000 by default. - s.OverrideDynamicConfig(dynamicconfig.NumPendingActivitiesLimitError, numOperations) + env.OverrideDynamicConfig(dynamicconfig.NumPendingActivitiesLimitError, numOperations) - tv := testvars.New(s) + tv := s.tv() dn := tv.DeploymentVersion().GetDeploymentName() start := time.Now() @@ -2229,7 +2254,7 @@ func (s *WorkerDeploymentSuite) TestConcurrentPollers_ManyTaskQueues_RapidRoutin sendPollers := func() { for j := range numTaskQueues { - go s.pollFromDeployment(pollCtx, tv.WithBuildIDNumber(i).WithTaskQueueNumber(j)) + go s.pollFromDeployment(pollCtx, env, tv.WithBuildIDNumber(i).WithTaskQueueNumber(j)) } } @@ -2253,8 +2278,8 @@ func (s *WorkerDeploymentSuite) TestConcurrentPollers_ManyTaskQueues_RapidRoutin // Wait for the versions to be created s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err := s.FrontendClient().DescribeWorkerDeployment(pollCtx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + resp, err := env.FrontendClient().DescribeWorkerDeployment(pollCtx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: dn, }) a.NoError(err) @@ -2266,8 +2291,8 @@ func (s *WorkerDeploymentSuite) TestConcurrentPollers_ManyTaskQueues_RapidRoutin s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err := s.FrontendClient().DescribeWorkerDeploymentVersion(pollCtx, &workflowservice.DescribeWorkerDeploymentVersionRequest{ - Namespace: s.Namespace().String(), + resp, err := env.FrontendClient().DescribeWorkerDeploymentVersion(pollCtx, &workflowservice.DescribeWorkerDeploymentVersionRequest{ + Namespace: env.Namespace().String(), DeploymentVersion: tv.WithBuildIDNumber(i).ExternalDeploymentVersion(), }) a.NoError(err) @@ -2280,8 +2305,7 @@ func (s *WorkerDeploymentSuite) TestConcurrentPollers_ManyTaskQueues_RapidRoutin fmt.Printf(">>> Time taken registration for version %d: %v\n", i, time.Since(start)) } - ctx, cancel := context.WithTimeout(context.Background(), 10*time.Minute) - defer cancel() + ctx := s.Context() // Rapidly perform 20 setCurrent and setRamping operations, each targeting one of the 3 versions for i := range numOperations { @@ -2292,8 +2316,8 @@ func (s *WorkerDeploymentSuite) TestConcurrentPollers_ManyTaskQueues_RapidRoutin var err error if i%2 == 0 { // setCurrent operation - _, err = s.FrontendClient().SetWorkerDeploymentCurrentVersion(ctx, &workflowservice.SetWorkerDeploymentCurrentVersionRequest{ - Namespace: s.Namespace().String(), + _, err = env.FrontendClient().SetWorkerDeploymentCurrentVersion(ctx, &workflowservice.SetWorkerDeploymentCurrentVersionRequest{ + Namespace: env.Namespace().String(), DeploymentName: dn, BuildId: versionTV.DeploymentVersion().GetBuildId(), IgnoreMissingTaskQueues: true, @@ -2301,8 +2325,8 @@ func (s *WorkerDeploymentSuite) TestConcurrentPollers_ManyTaskQueues_RapidRoutin }) } else { // setRamping operation - _, err = s.FrontendClient().SetWorkerDeploymentRampingVersion(ctx, &workflowservice.SetWorkerDeploymentRampingVersionRequest{ - Namespace: s.Namespace().String(), + _, err = env.FrontendClient().SetWorkerDeploymentRampingVersion(ctx, &workflowservice.SetWorkerDeploymentRampingVersionRequest{ + Namespace: env.Namespace().String(), DeploymentName: dn, BuildId: versionTV.DeploymentVersion().GetBuildId(), IgnoreMissingTaskQueues: true, @@ -2327,8 +2351,8 @@ func (s *WorkerDeploymentSuite) TestConcurrentPollers_ManyTaskQueues_RapidRoutin var latestRoutingConfig *deploymentpb.RoutingConfig s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err := s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: dn, }) a.NoError(err) @@ -2344,8 +2368,8 @@ func (s *WorkerDeploymentSuite) TestConcurrentPollers_ManyTaskQueues_RapidRoutin // versioning info has been propagated correctly by checking the current/ramping versions for j := range numTaskQueues { tqTV := tv.WithTaskQueueNumber(j) - tqUD, err := s.GetTestCluster().MatchingClient().GetTaskQueueUserData(ctx, &matchingservice.GetTaskQueueUserDataRequest{ - NamespaceId: s.NamespaceID().String(), + tqUD, err := env.GetTestCluster().MatchingClient().GetTaskQueueUserData(ctx, &matchingservice.GetTaskQueueUserDataRequest{ + NamespaceId: env.NamespaceID().String(), TaskQueueType: tqTypeWf, TaskQueue: tqTV.TaskQueue().GetName(), }) @@ -2357,24 +2381,23 @@ func (s *WorkerDeploymentSuite) TestConcurrentPollers_ManyTaskQueues_RapidRoutin } func (s *WorkerDeploymentSuite) TestResourceExhaustedErrors_Converted_To_ReadableMessage() { - s.OverrideDynamicConfig(dynamicconfig.WorkflowExecutionMaxInFlightUpdates, 2) // Lowering the limit to encounter ResourceExhausted errors + env := s.newTestEnv(testcore.WithDynamicConfig(dynamicconfig.WorkflowExecutionMaxInFlightUpdates, 2)) // Lowering the limit to encounter ResourceExhausted errors - ctx, cancel := context.WithTimeout(context.Background(), time.Minute) - defer cancel() + ctx := s.Context() - tv := testvars.New(s) + tv := s.tv() versions := 5 errChan := make(chan error, versions) // Start all version workflows first for i := range versions { - s.startVersionWorkflow(ctx, tv.WithBuildIDNumber(i)) + s.startVersionWorkflow(ctx, env, tv.WithBuildIDNumber(i)) } // Test SetRampingVersion s.testConcurrentRequestsResourceExhausted(ctx, tv, versions, errChan, "SetWorkerDeploymentRampingVersion", func(i int) error { - _, err := s.FrontendClient().SetWorkerDeploymentRampingVersion(ctx, &workflowservice.SetWorkerDeploymentRampingVersionRequest{ - Namespace: s.Namespace().String(), + _, err := env.FrontendClient().SetWorkerDeploymentRampingVersion(ctx, &workflowservice.SetWorkerDeploymentRampingVersionRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentVersion().GetDeploymentName(), Version: tv.WithBuildIDNumber(i).DeploymentVersionString(), IgnoreMissingTaskQueues: true, @@ -2386,8 +2409,8 @@ func (s *WorkerDeploymentSuite) TestResourceExhaustedErrors_Converted_To_Readabl // Test SetCurrentVersion s.testConcurrentRequestsResourceExhausted(ctx, tv, versions, errChan, "SetWorkerDeploymentCurrentVersion", func(i int) error { - _, err := s.FrontendClient().SetWorkerDeploymentCurrentVersion(ctx, &workflowservice.SetWorkerDeploymentCurrentVersionRequest{ - Namespace: s.Namespace().String(), + _, err := env.FrontendClient().SetWorkerDeploymentCurrentVersion(ctx, &workflowservice.SetWorkerDeploymentCurrentVersionRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentVersion().GetDeploymentName(), Version: tv.WithBuildIDNumber(i).DeploymentVersionString(), IgnoreMissingTaskQueues: true, @@ -2402,8 +2425,8 @@ func (s *WorkerDeploymentSuite) TestResourceExhaustedErrors_Converted_To_Readabl "key2": {Data: testRandomMetadataValue}, } s.testConcurrentRequestsResourceExhausted(ctx, tv, versions, errChan, "UpdateWorkerDeploymentVersionMetadata", func(i int) error { - _, err := s.FrontendClient().UpdateWorkerDeploymentVersionMetadata(ctx, &workflowservice.UpdateWorkerDeploymentVersionMetadataRequest{ - Namespace: s.Namespace().String(), + _, err := env.FrontendClient().UpdateWorkerDeploymentVersionMetadata(ctx, &workflowservice.UpdateWorkerDeploymentVersionMetadataRequest{ + Namespace: env.Namespace().String(), Version: tv.WithBuildIDNumber(i).DeploymentVersionString(), UpsertEntries: metadata, }) @@ -2443,66 +2466,69 @@ func (s *WorkerDeploymentSuite) testConcurrentRequestsResourceExhausted( // Should see it fail because unversioned is already current func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Unversioned_UnversionedCurrent() { - ctx, cancel := context.WithTimeout(context.Background(), time.Minute) - defer cancel() - tv := testvars.New(s) + env := s.newTestEnv() + + ctx := s.Context() + tv := s.tv() rampingVars := tv.WithBuildIDNumber(1) - s.startVersionWorkflow(ctx, rampingVars) - s.setAndVerifyRampingVersionUnversionedOption(ctx, rampingVars, true, false, 50, true, false, true, "ramping version __unversioned__ is already current") + s.startVersionWorkflow(ctx, env, rampingVars) + s.setAndVerifyRampingVersionUnversionedOption(env, rampingVars, true, false, 50, true, false, true, "ramping version __unversioned__ is already current") } // Should see that the ramping version of the task queues in the current version is unversioned func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Unversioned_VersionedCurrent() { - ctx, cancel := context.WithTimeout(context.Background(), time.Second*30) - defer cancel() - tv := testvars.New(s) + env := s.newTestEnv() + + ctx := s.Context() + tv := s.tv() currentVars := tv.WithBuildIDNumber(1) - go s.pollFromDeployment(ctx, currentVars) - s.ensureCreateVersionInDeployment(currentVars) + go s.pollFromDeployment(ctx, env, currentVars) + s.ensureCreateVersionInDeployment(env, currentVars) // check that the current version's task queues have ramping version == "" - s.setCurrentVersion(ctx, currentVars, true, "") - s.verifyTaskQueueVersioningInfo(ctx, currentVars.TaskQueue(), currentVars.DeploymentVersionString(), "", 0) + s.setCurrentVersion(env, currentVars, true, "") + s.verifyTaskQueueVersioningInfo(env, currentVars.TaskQueue(), currentVars.DeploymentVersionString(), "", 0) // set ramp to unversioned - s.setAndVerifyRampingVersionUnversionedOption(ctx, tv, true, false, 75, true, false, true, "") + s.setAndVerifyRampingVersionUnversionedOption(env, tv, true, false, 75, true, false, true, "") // check that deployment has ramping version == __unversioned__ - resp, err := s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentSeries(), }) s.NoError(err) s.Equal(worker_versioning.UnversionedVersionId, resp.GetWorkerDeploymentInfo().GetRoutingConfig().GetRampingVersion()) // check that the current version's task queues have ramping version == __unversioned__ - s.verifyTaskQueueVersioningInfo(ctx, currentVars.TaskQueue(), currentVars.DeploymentVersionString(), worker_versioning.UnversionedVersionId, 75) + s.verifyTaskQueueVersioningInfo(env, currentVars.TaskQueue(), currentVars.DeploymentVersionString(), worker_versioning.UnversionedVersionId, 75) } func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentCurrentVersion_NoPollers() { - ctx, cancel := context.WithTimeout(context.Background(), time.Second*30) - defer cancel() - tv := testvars.New(s).WithBuildIDNumber(1) + env := s.newTestEnv() + + ctx := s.Context() + tv := s.tv().WithBuildIDNumber(1) // try to set current with allowNoPollers=false --> error allowNoPollers := false expectedErr := fmt.Sprintf(workerdeployment.ErrWorkerDeploymentNotFound, tv.DeploymentVersion().GetDeploymentName()) - s.setCurrentVersionAllowNoPollersOption(ctx, tv, true, allowNoPollers, false, expectedErr) + s.setCurrentVersionAllowNoPollersOption(env, tv, true, allowNoPollers, false, expectedErr) // try to set current with allowNoPollers=true --> success allowNoPollers = true expectedErr = "" versionCreateTime := timestamppb.Now() - s.setCurrentVersionAllowNoPollersOption(ctx, tv, true, allowNoPollers, false, expectedErr) + s.setCurrentVersionAllowNoPollersOption(env, tv, true, allowNoPollers, false, expectedErr) // let a poller arrive with that version --> triggers user data propagation - go s.pollFromDeployment(ctx, tv) + go s.pollFromDeployment(ctx, env, tv) s.EventuallyWithT(func(t *assert.CollectT) { // check describe worker deployment - resp, err := s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentSeries(), }) a := require.New(t) @@ -2533,32 +2559,33 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentCurrentVersion_NoPollers( }, 10*time.Second, 100*time.Millisecond) // that poller's task queue should have the current versioning info - s.verifyTaskQueueVersioningInfo(ctx, tv.TaskQueue(), tv.DeploymentVersionString(), "", 0) + s.verifyTaskQueueVersioningInfo(env, tv.TaskQueue(), tv.DeploymentVersionString(), "", 0) } func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_NoPollers() { - ctx, cancel := context.WithTimeout(context.Background(), time.Second*30) - defer cancel() - tv := testvars.New(s).WithBuildIDNumber(1) + env := s.newTestEnv() + + ctx := s.Context() + tv := s.tv().WithBuildIDNumber(1) // try to set ramping with allowNoPollers=false --> error allowNoPollers := false expectedErr := fmt.Sprintf(workerdeployment.ErrWorkerDeploymentNotFound, tv.DeploymentVersion().GetDeploymentName()) - s.setAndVerifyRampingVersionUnversionedOption(ctx, tv, false, false, 5, true, allowNoPollers, false, expectedErr) + s.setAndVerifyRampingVersionUnversionedOption(env, tv, false, false, 5, true, allowNoPollers, false, expectedErr) // try to set ramping with allowNoPollers=true --> success allowNoPollers = true expectedErr = "" versionCreateTime := timestamppb.Now() - s.setAndVerifyRampingVersionUnversionedOption(ctx, tv, false, false, 5, true, allowNoPollers, false, expectedErr) + s.setAndVerifyRampingVersionUnversionedOption(env, tv, false, false, 5, true, allowNoPollers, false, expectedErr) // let a poller arrive with that version --> triggers user data propagation - go s.pollFromDeployment(ctx, tv) + go s.pollFromDeployment(ctx, env, tv) s.EventuallyWithT(func(t *assert.CollectT) { // check describe worker deployment - resp, err := s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentSeries(), }) a := require.New(t) @@ -2592,28 +2619,27 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_NoPollers( }, 10*time.Second, 100*time.Millisecond) // that poller's task queue should have the ramping version info - s.verifyTaskQueueVersioningInfo(ctx, tv.TaskQueue(), worker_versioning.UnversionedVersionId, tv.DeploymentVersionString(), 5) + s.verifyTaskQueueVersioningInfo(env, tv.TaskQueue(), worker_versioning.UnversionedVersionId, tv.DeploymentVersionString(), 5) } func (s *WorkerDeploymentSuite) TestTwoPollers_EnsureCreateVersion() { - ctx, cancel := context.WithTimeout(context.Background(), time.Second*30) - defer func() { - cancel() - }() - tv := testvars.New(s) + env := s.newTestEnv() + + ctx := s.Context() + tv := s.tv() tv1 := tv.WithBuildIDNumber(1) tv2 := tv.WithBuildIDNumber(2) - go s.pollFromDeployment(ctx, tv1) - go s.pollFromDeployment(ctx, tv2) - s.ensureCreateVersionWithExpectedTaskQueues(ctx, tv1, 1) - s.ensureCreateVersionWithExpectedTaskQueues(ctx, tv2, 1) + go s.pollFromDeployment(ctx, env, tv1) + go s.pollFromDeployment(ctx, env, tv2) + s.ensureCreateVersionWithExpectedTaskQueues(env, tv1, 1) + s.ensureCreateVersionWithExpectedTaskQueues(env, tv2, 1) } -func (s *WorkerDeploymentSuite) verifyTaskQueueVersioningInfo(ctx context.Context, tq *taskqueuepb.TaskQueue, expectedCurrentVersion, expectedRampingVersion string, expectedPercentage float32) { +func (s *WorkerDeploymentSuite) verifyTaskQueueVersioningInfo(env *testcore.TestEnv, tq *taskqueuepb.TaskQueue, expectedCurrentVersion, expectedRampingVersion string, expectedPercentage float32) { s.EventuallyWithT(func(t *assert.CollectT) { - tqDesc, err := s.FrontendClient().DescribeTaskQueue(ctx, &workflowservice.DescribeTaskQueueRequest{ - Namespace: s.Namespace().String(), + tqDesc, err := env.FrontendClient().DescribeTaskQueue(s.Context(), &workflowservice.DescribeTaskQueueRequest{ + Namespace: env.Namespace().String(), TaskQueue: tq, }) a := require.New(t) @@ -2632,27 +2658,26 @@ func (s *WorkerDeploymentSuite) verifyTaskQueueVersioningInfo(ctx context.Contex // Note: This test reproduces a bug we saw in production where the drainage status was not being properly cleared when a draining version // is reactivated and then re-deactivated func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { - s.OverrideDynamicConfig(dynamicconfig.PollerHistoryTTL, 500*time.Millisecond) + env := s.newTestEnv(testcore.WithDynamicConfig(dynamicconfig.PollerHistoryTTL, 500*time.Millisecond)) - ctx, cancel := context.WithTimeout(context.Background(), time.Minute) - defer cancel() - tv1 := testvars.New(s).WithBuildIDNumber(1) - tv2 := testvars.New(s).WithBuildIDNumber(2) - tv3 := testvars.New(s).WithBuildIDNumber(3) + ctx := s.Context() + tv1 := s.tv().WithBuildIDNumber(1) + tv2 := s.tv().WithBuildIDNumber(2) + tv3 := s.tv().WithBuildIDNumber(3) // Start deployment workflow 1 and wait for the deployment version to exist v1CreateTime := timestamppb.New(time.Now()) - s.startVersionWorkflow(ctx, tv1) + s.startVersionWorkflow(ctx, env, tv1) // Set v1 as current version setCurrentV1UpdateTime := timestamppb.Now() - s.setCurrentVersion(ctx, tv1, true, "") - resp, err := s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + s.setCurrentVersion(env, tv1, true, "") + resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv1.DeploymentSeries(), }) s.NoError(err) - s.verifyDescribeWorkerDeployment(s.Require(), resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: tv1.DeploymentSeries(), CreateTime: v1CreateTime, @@ -2680,17 +2705,17 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { // Start deployment workflow 2 and set v2 to current so that v1 can start draining v2CreateTime := timestamppb.New(time.Now()) - s.startVersionWorkflow(ctx, tv2) + s.startVersionWorkflow(ctx, env, tv2) setCurrentV2UpdateTime := timestamppb.New(time.Now()) - s.setCurrentVersion(ctx, tv2, true, "") - resp, err = s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + s.setCurrentVersion(env, tv2, true, "") + resp, err = env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv2.DeploymentSeries(), }) s.NoError(err) - s.verifyDescribeWorkerDeployment(s.Require(), resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: tv2.DeploymentSeries(), CreateTime: v1CreateTime, @@ -2735,8 +2760,8 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { // wait for v1 to be drained s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err := s.FrontendClient().DescribeWorkerDeploymentVersion(ctx, &workflowservice.DescribeWorkerDeploymentVersionRequest{ - Namespace: s.Namespace().String(), + resp, err := env.FrontendClient().DescribeWorkerDeploymentVersion(ctx, &workflowservice.DescribeWorkerDeploymentVersionRequest{ + Namespace: env.Namespace().String(), Version: tv1.DeploymentVersionString(), }) a.NoError(err) @@ -2746,8 +2771,8 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { // Verify that the drainageStatus of v1 has been updated in the VersionSummaries s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err = s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + resp, err = env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv2.DeploymentSeries(), }) a.NoError(err) @@ -2796,13 +2821,13 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { // start ramping traffic back to v1 setRampingUpdateTime := timestamppb.Now() - s.setAndVerifyRampingVersion(ctx, tv1, false, 10, false, "") + s.setAndVerifyRampingVersion(env, tv1, false, 10, false, "") // verify if the right information is set in the DescribeWorkerDeployment response s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err = s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + resp, err = env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv2.DeploymentSeries(), }) a.NoError(err) @@ -2851,13 +2876,13 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { // Set version v1 as the current version; this shall drain out v2 newCurrentV1UpdateTime := timestamppb.Now() - s.setCurrentVersion(ctx, tv1, true, "") + s.setCurrentVersion(env, tv1, true, "") // Verify that v2 is drained s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err := s.FrontendClient().DescribeWorkerDeploymentVersion(ctx, &workflowservice.DescribeWorkerDeploymentVersionRequest{ - Namespace: s.Namespace().String(), + resp, err := env.FrontendClient().DescribeWorkerDeploymentVersion(ctx, &workflowservice.DescribeWorkerDeploymentVersionRequest{ + Namespace: env.Namespace().String(), Version: tv2.DeploymentVersionString(), }) a.NoError(err) @@ -2867,8 +2892,8 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { // verify if the right information is set in the DescribeWorkerDeployment response s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err = s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + resp, err = env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv1.DeploymentSeries(), }) a.NoError(err) @@ -2917,16 +2942,16 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { // Roll out a new version v3 and set it to current v3CreateTime := timestamppb.Now() - s.startVersionWorkflow(ctx, tv3) + s.startVersionWorkflow(ctx, env, tv3) newCurrentV3UpdateTime := timestamppb.Now() - s.setCurrentVersion(ctx, tv3, true, "") + s.setCurrentVersion(env, tv3, true, "") // Verify that v1 is drained eventually s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err := s.FrontendClient().DescribeWorkerDeploymentVersion(ctx, &workflowservice.DescribeWorkerDeploymentVersionRequest{ - Namespace: s.Namespace().String(), + resp, err := env.FrontendClient().DescribeWorkerDeploymentVersion(ctx, &workflowservice.DescribeWorkerDeploymentVersionRequest{ + Namespace: env.Namespace().String(), Version: tv1.DeploymentVersionString(), }) a.NoError(err) @@ -2937,8 +2962,8 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { // in the deployment workflow. s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err = s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + resp, err = env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv1.DeploymentSeries(), }) a.NoError(err) @@ -3000,26 +3025,25 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { // Test that rolling back to a drained version works func (s *WorkerDeploymentSuite) TestSetRampingVersion_AfterDrained() { - s.OverrideDynamicConfig(dynamicconfig.PollerHistoryTTL, 500*time.Millisecond) + env := s.newTestEnv(testcore.WithDynamicConfig(dynamicconfig.PollerHistoryTTL, 500*time.Millisecond)) - ctx, cancel := context.WithTimeout(context.Background(), time.Minute) - defer cancel() - tv1 := testvars.New(s).WithBuildIDNumber(1) - tv2 := testvars.New(s).WithBuildIDNumber(2) + ctx := s.Context() + tv1 := s.tv().WithBuildIDNumber(1) + tv2 := s.tv().WithBuildIDNumber(2) // Start deployment workflow 1 and wait for the deployment version to exist v1CreateTime := timestamppb.New(time.Now()) - s.startVersionWorkflow(ctx, tv1) + s.startVersionWorkflow(ctx, env, tv1) // Set v1 as current version setCurrentV1UpdateTime := timestamppb.Now() - s.setCurrentVersion(ctx, tv1, true, "") - resp, err := s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + s.setCurrentVersion(env, tv1, true, "") + resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv1.DeploymentSeries(), }) s.NoError(err) - s.verifyDescribeWorkerDeployment(s.Require(), resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: tv1.DeploymentSeries(), CreateTime: v1CreateTime, @@ -3047,17 +3071,17 @@ func (s *WorkerDeploymentSuite) TestSetRampingVersion_AfterDrained() { // Start deployment workflow 2 and set v2 to current so that v1 can start draining v2CreateTime := timestamppb.New(time.Now()) - s.startVersionWorkflow(ctx, tv2) + s.startVersionWorkflow(ctx, env, tv2) setCurrentV2UpdateTime := timestamppb.New(time.Now()) - s.setCurrentVersion(ctx, tv2, true, "") - resp, err = s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + s.setCurrentVersion(env, tv2, true, "") + resp, err = env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv2.DeploymentSeries(), }) s.NoError(err) - s.verifyDescribeWorkerDeployment(s.Require(), resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: tv2.DeploymentSeries(), CreateTime: v1CreateTime, @@ -3102,8 +3126,8 @@ func (s *WorkerDeploymentSuite) TestSetRampingVersion_AfterDrained() { // wait for v1 to be drained s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err := s.FrontendClient().DescribeWorkerDeploymentVersion(ctx, &workflowservice.DescribeWorkerDeploymentVersionRequest{ - Namespace: s.Namespace().String(), + resp, err := env.FrontendClient().DescribeWorkerDeploymentVersion(ctx, &workflowservice.DescribeWorkerDeploymentVersionRequest{ + Namespace: env.Namespace().String(), Version: tv1.DeploymentVersionString(), }) a.NoError(err) @@ -3113,8 +3137,8 @@ func (s *WorkerDeploymentSuite) TestSetRampingVersion_AfterDrained() { // Verify that the drainageStatus of v1 has been updated in the VersionSummaries s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err = s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + resp, err = env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv2.DeploymentSeries(), }) a.NoError(err) @@ -3163,13 +3187,13 @@ func (s *WorkerDeploymentSuite) TestSetRampingVersion_AfterDrained() { // start ramping traffic back to v1 setRampingUpdateTime := timestamppb.Now() - s.setAndVerifyRampingVersion(ctx, tv1, false, 10, false, "") + s.setAndVerifyRampingVersion(env, tv1, false, 10, false, "") // verify if the right information is set in the DescribeWorkerDeployment response s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err = s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + resp, err = env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv2.DeploymentSeries(), }) a.NoError(err) @@ -3218,17 +3242,16 @@ func (s *WorkerDeploymentSuite) TestSetRampingVersion_AfterDrained() { } func (s *WorkerDeploymentSuite) TestDeleteWorkerDeployment_ValidDelete() { - s.OverrideDynamicConfig(dynamicconfig.PollerHistoryTTL, 500*time.Millisecond) + env := s.newTestEnv(testcore.WithDynamicConfig(dynamicconfig.PollerHistoryTTL, 500*time.Millisecond)) - ctx, cancel := context.WithTimeout(context.Background(), time.Minute) - defer cancel() - tv1 := testvars.New(s).WithBuildIDNumber(1) + ctx := s.Context() + tv1 := s.tv().WithBuildIDNumber(1) // Start deployment workflow 1 and wait for the deployment version to exist // Use a cancellable context so we can stop the poller before checking pollers disappeared pollerCtx, pollerCancel := context.WithCancel(ctx) defer pollerCancel() - s.startVersionWorkflow(pollerCtx, tv1) + s.startVersionWorkflow(pollerCtx, env, tv1) // Signal the first version to be drained. Only do this in tests. versionWorkflowID := workerdeployment.GenerateVersionWorkflowID(tv1.DeploymentSeries(), tv1.BuildID()) @@ -3253,7 +3276,7 @@ func (s *WorkerDeploymentSuite) TestDeleteWorkerDeployment_ValidDelete() { }, } - err = s.SendSignal(s.Namespace().String(), workflowExecution, workerdeployment.SyncDrainageSignalName, signalPayload, tv1.ClientIdentity()) + err = env.SendSignal(env.Namespace().String(), workflowExecution, workerdeployment.SyncDrainageSignalName, signalPayload, tv1.ClientIdentity()) s.NoError(err) // Stop the poller so it doesn't keep polling @@ -3261,8 +3284,8 @@ func (s *WorkerDeploymentSuite) TestDeleteWorkerDeployment_ValidDelete() { // Wait for pollers going away s.EventuallyWithT(func(t *assert.CollectT) { - resp, err := s.FrontendClient().DescribeTaskQueue(ctx, &workflowservice.DescribeTaskQueueRequest{ - Namespace: s.Namespace().String(), + resp, err := env.FrontendClient().DescribeTaskQueue(ctx, &workflowservice.DescribeTaskQueueRequest{ + Namespace: env.Namespace().String(), TaskQueue: tv1.TaskQueue(), TaskQueueType: enumspb.TASK_QUEUE_TYPE_WORKFLOW, }) @@ -3271,13 +3294,13 @@ func (s *WorkerDeploymentSuite) TestDeleteWorkerDeployment_ValidDelete() { }, 5*time.Second, time.Second) // delete succeeds - s.tryDeleteVersion(ctx, tv1, "") + s.tryDeleteVersion(env, tv1, "") // deployment version does not exist in the deployment list s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err := s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv1.DeploymentSeries(), }) a.NoError(err) @@ -3289,8 +3312,8 @@ func (s *WorkerDeploymentSuite) TestDeleteWorkerDeployment_ValidDelete() { }, time.Second*5, time.Millisecond*200) // Deleting the worker deployment should succeed since there are no associated versions left - _, err = s.FrontendClient().DeleteWorkerDeployment(ctx, &workflowservice.DeleteWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + _, err = env.FrontendClient().DeleteWorkerDeployment(ctx, &workflowservice.DeleteWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv1.DeploymentSeries(), Identity: tv1.ClientIdentity(), }) @@ -3299,8 +3322,8 @@ func (s *WorkerDeploymentSuite) TestDeleteWorkerDeployment_ValidDelete() { // Describe Worker Deployment should give not found s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - _, err := s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + _, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv1.DeploymentSeries(), }) a.Error(err) @@ -3311,8 +3334,8 @@ func (s *WorkerDeploymentSuite) TestDeleteWorkerDeployment_ValidDelete() { // ListDeployments should not show the closed/deleted Worker Deployment s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - listResp, err := s.FrontendClient().ListWorkerDeployments(ctx, &workflowservice.ListWorkerDeploymentsRequest{ - Namespace: s.Namespace().String(), + listResp, err := env.FrontendClient().ListWorkerDeployments(ctx, &workflowservice.ListWorkerDeploymentsRequest{ + Namespace: env.Namespace().String(), }) a.NoError(err) for _, dInfo := range listResp.GetWorkerDeployments() { @@ -3322,14 +3345,15 @@ func (s *WorkerDeploymentSuite) TestDeleteWorkerDeployment_ValidDelete() { } func (s *WorkerDeploymentSuite) TestDeleteWorkerDeployment_Idempotent() { - ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second) - defer cancel() - tv1 := testvars.New(s).WithBuildIDNumber(1) + env := s.newTestEnv() + + ctx := s.Context() + tv1 := s.tv().WithBuildIDNumber(1) s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - _, err := s.FrontendClient().DeleteWorkerDeployment(ctx, &workflowservice.DeleteWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + _, err := env.FrontendClient().DeleteWorkerDeployment(ctx, &workflowservice.DeleteWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv1.DeploymentSeries(), Identity: tv1.ClientIdentity(), }) @@ -3338,16 +3362,17 @@ func (s *WorkerDeploymentSuite) TestDeleteWorkerDeployment_Idempotent() { } func (s *WorkerDeploymentSuite) TestDeleteWorkerDeployment_InvalidDelete() { - ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second) - defer cancel() - tv1 := testvars.New(s).WithBuildIDNumber(1) + env := s.newTestEnv() + + ctx := s.Context() + tv1 := s.tv().WithBuildIDNumber(1) // Start deployment workflow 1 and wait for the deployment version and deployment workflow to exist - go s.pollFromDeployment(ctx, tv1) + go s.pollFromDeployment(ctx, env, tv1) s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err := s.FrontendClient().DescribeWorkerDeploymentVersion(ctx, &workflowservice.DescribeWorkerDeploymentVersionRequest{ - Namespace: s.Namespace().String(), + resp, err := env.FrontendClient().DescribeWorkerDeploymentVersion(ctx, &workflowservice.DescribeWorkerDeploymentVersionRequest{ + Namespace: env.Namespace().String(), Version: tv1.DeploymentVersionString(), }) a.NoError(err) @@ -3356,8 +3381,8 @@ func (s *WorkerDeploymentSuite) TestDeleteWorkerDeployment_InvalidDelete() { s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err := s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv1.DeploymentSeries(), }) a.NoError(err) @@ -3368,8 +3393,8 @@ func (s *WorkerDeploymentSuite) TestDeleteWorkerDeployment_InvalidDelete() { }, time.Second*5, time.Millisecond*200) // Delete the worker deployment should fail since there are versions associated with it - _, err := s.FrontendClient().DeleteWorkerDeployment(ctx, &workflowservice.DeleteWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + _, err := env.FrontendClient().DeleteWorkerDeployment(ctx, &workflowservice.DeleteWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv1.DeploymentSeries(), Identity: tv1.ClientIdentity(), }) @@ -3377,12 +3402,12 @@ func (s *WorkerDeploymentSuite) TestDeleteWorkerDeployment_InvalidDelete() { } func (s *WorkerDeploymentSuite) tryDeleteVersion( - ctx context.Context, + env *testcore.TestEnv, tv *testvars.TestVars, expectedError string, ) { - _, err := s.FrontendClient().DeleteWorkerDeploymentVersion(ctx, &workflowservice.DeleteWorkerDeploymentVersionRequest{ - Namespace: s.Namespace().String(), + _, err := env.FrontendClient().DeleteWorkerDeploymentVersion(s.Context(), &workflowservice.DeleteWorkerDeploymentVersionRequest{ + Namespace: env.Namespace().String(), Version: tv.DeploymentVersionString(), Identity: tv.ClientIdentity(), }) @@ -3485,19 +3510,19 @@ func (s *WorkerDeploymentSuite) verifyDescribeWorkerDeployment( } func (s *WorkerDeploymentSuite) setAndVerifyRampingVersion( - ctx context.Context, + env *testcore.TestEnv, tv *testvars.TestVars, unset bool, percentage int, ignoreMissingTaskQueues bool, expectedError string, ) { - s.setAndVerifyRampingVersionUnversionedOption(ctx, tv, false, unset, percentage, ignoreMissingTaskQueues, false, true, expectedError) + s.setAndVerifyRampingVersionUnversionedOption(env, tv, false, unset, percentage, ignoreMissingTaskQueues, false, true, expectedError) } //nolint:staticcheck // SA1019 func (s *WorkerDeploymentSuite) setAndVerifyRampingVersionUnversionedOption( - ctx context.Context, + env *testcore.TestEnv, tv *testvars.TestVars, unversioned, unset bool, percentage int, @@ -3513,13 +3538,13 @@ func (s *WorkerDeploymentSuite) setAndVerifyRampingVersionUnversionedOption( } if !allowNoPollers && ensureSystemWorkflowsExist { if !unversioned && !unset { - s.ensureCreateVersionInDeployment(tv) + s.ensureCreateVersionInDeployment(env, tv) } else { - s.ensureCreateDeployment(tv) + s.ensureCreateDeployment(env, tv) } } - _, err := s.FrontendClient().SetWorkerDeploymentRampingVersion(ctx, &workflowservice.SetWorkerDeploymentRampingVersionRequest{ - Namespace: s.Namespace().String(), + _, err := env.FrontendClient().SetWorkerDeploymentRampingVersion(s.Context(), &workflowservice.SetWorkerDeploymentRampingVersionRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentVersion().GetDeploymentName(), BuildId: bld, Percentage: float32(percentage), @@ -3535,21 +3560,21 @@ func (s *WorkerDeploymentSuite) setAndVerifyRampingVersionUnversionedOption( s.NoError(err) } -func (s *WorkerDeploymentSuite) setCurrentVersion(ctx context.Context, tv *testvars.TestVars, ignoreMissingTaskQueues bool, expectedError string) { - s.setCurrentVersionUnversionedOption(ctx, tv, false, ignoreMissingTaskQueues, false, true, expectedError) +func (s *WorkerDeploymentSuite) setCurrentVersion(env *testcore.TestEnv, tv *testvars.TestVars, ignoreMissingTaskQueues bool, expectedError string) { + s.setCurrentVersionUnversionedOption(env, tv, false, ignoreMissingTaskQueues, false, true, expectedError) } func (s *WorkerDeploymentSuite) setCurrentVersionAllowNoPollersOption( - ctx context.Context, + env *testcore.TestEnv, tv *testvars.TestVars, ignoreMissingTaskQueues, allowNoPollers, ensureSystemWorkflowsExist bool, expectedError string, ) { - s.setCurrentVersionUnversionedOption(ctx, tv, false, ignoreMissingTaskQueues, allowNoPollers, ensureSystemWorkflowsExist, expectedError) + s.setCurrentVersionUnversionedOption(env, tv, false, ignoreMissingTaskQueues, allowNoPollers, ensureSystemWorkflowsExist, expectedError) } func (s *WorkerDeploymentSuite) setCurrentVersionUnversionedOption( - ctx context.Context, + env *testcore.TestEnv, tv *testvars.TestVars, unversioned, ignoreMissingTaskQueues, allowNoPollers, ensureSystemWorkflowsExist bool, expectedError string, @@ -3560,14 +3585,14 @@ func (s *WorkerDeploymentSuite) setCurrentVersionUnversionedOption( } if !allowNoPollers && ensureSystemWorkflowsExist { if unversioned { - s.ensureCreateDeployment(tv) + s.ensureCreateDeployment(env, tv) } else { - s.ensureCreateVersionInDeployment(tv) + s.ensureCreateVersionInDeployment(env, tv) } } - _, err := s.FrontendClient().SetWorkerDeploymentCurrentVersion(ctx, &workflowservice.SetWorkerDeploymentCurrentVersionRequest{ - Namespace: s.Namespace().String(), + _, err := env.FrontendClient().SetWorkerDeploymentCurrentVersion(s.Context(), &workflowservice.SetWorkerDeploymentCurrentVersionRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentVersion().GetDeploymentName(), BuildId: bld, IgnoreMissingTaskQueues: ignoreMissingTaskQueues, @@ -3582,16 +3607,16 @@ func (s *WorkerDeploymentSuite) setCurrentVersionUnversionedOption( s.NoError(err) } -func (s *WorkerDeploymentSuite) setAndValidateManagerIdentity(ctx context.Context, tv *testvars.TestVars, self, useWrongConflictToken bool, newManager, expectedError string) { - s.ensureCreateDeployment(tv) - s.ensureCreateVersionInDeployment(tv) +func (s *WorkerDeploymentSuite) setAndValidateManagerIdentity(env *testcore.TestEnv, tv *testvars.TestVars, self, useWrongConflictToken bool, newManager, expectedError string) { + s.ensureCreateDeployment(env, tv) + s.ensureCreateVersionInDeployment(env, tv) var cT []byte if useWrongConflictToken { cT, _ = time.Now().MarshalBinary() } else { - desc, err := s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + desc, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentVersion().GetDeploymentName(), }) s.NoError(err) @@ -3599,7 +3624,7 @@ func (s *WorkerDeploymentSuite) setAndValidateManagerIdentity(ctx context.Contex } req := &workflowservice.SetWorkerDeploymentManagerRequest{ - Namespace: s.Namespace().String(), + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentVersion().GetDeploymentName(), NewManagerIdentity: &workflowservice.SetWorkerDeploymentManagerRequest_ManagerIdentity{}, Identity: tv.ClientIdentity(), @@ -3622,7 +3647,7 @@ func (s *WorkerDeploymentSuite) setAndValidateManagerIdentity(ctx context.Contex req.Identity = newManager } } - _, err := s.FrontendClient().SetWorkerDeploymentManager(ctx, req) + _, err := env.FrontendClient().SetWorkerDeploymentManager(s.Context(), req) if expectedError != "" { s.Error(err) s.Contains(err.Error(), expectedError) @@ -3630,15 +3655,15 @@ func (s *WorkerDeploymentSuite) setAndValidateManagerIdentity(ctx context.Contex } s.NoError(err) - desc, err := s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + desc, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentVersion().GetDeploymentName(), }) s.NoError(err) s.Equal(expectedManagerIdentity, desc.GetWorkerDeploymentInfo().GetManagerIdentity()) } -func (s *WorkerDeploymentSuite) createVersionsInDeployments(ctx context.Context, tv *testvars.TestVars, n int) []*workflowservice.ListWorkerDeploymentsResponse_WorkerDeploymentSummary { +func (s *WorkerDeploymentSuite) createVersionsInDeployments(env *testcore.TestEnv, tv *testvars.TestVars, n int) []*workflowservice.ListWorkerDeploymentsResponse_WorkerDeploymentSummary { var expectedDeploymentSummaries []*workflowservice.ListWorkerDeploymentsResponse_WorkerDeploymentSummary for i := range n { @@ -3646,9 +3671,9 @@ func (s *WorkerDeploymentSuite) createVersionsInDeployments(ctx context.Context, version := deployment.WithBuildIDNumber(i) startTime := timestamppb.Now() - s.startVersionWorkflow(ctx, version) + s.startVersionWorkflow(s.Context(), env, version) setCurrentTime := timestamppb.Now() - s.setCurrentVersion(ctx, version, true, "") + s.setCurrentVersion(env, version, true, "") currentVersionSummary := &deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ Version: version.DeploymentVersionString(), @@ -3715,12 +3740,12 @@ func (s *WorkerDeploymentSuite) verifyWorkerDeploymentSummary( return true } -func (s *WorkerDeploymentSuite) listWorkerDeployments(ctx context.Context, request *workflowservice.ListWorkerDeploymentsRequest) ([]*workflowservice.ListWorkerDeploymentsResponse_WorkerDeploymentSummary, error) { +func (s *WorkerDeploymentSuite) listWorkerDeployments(env *testcore.TestEnv, request *workflowservice.ListWorkerDeploymentsRequest) ([]*workflowservice.ListWorkerDeploymentsResponse_WorkerDeploymentSummary, error) { var resp *workflowservice.ListWorkerDeploymentsResponse var err error var deploymentSummaries []*workflowservice.ListWorkerDeploymentsResponse_WorkerDeploymentSummary for resp == nil || len(resp.NextPageToken) > 0 { - resp, err = s.FrontendClient().ListWorkerDeployments(ctx, request) + resp, err = env.FrontendClient().ListWorkerDeployments(s.Context(), request) if err != nil { return nil, err } @@ -3731,7 +3756,7 @@ func (s *WorkerDeploymentSuite) listWorkerDeployments(ctx context.Context, reque } func (s *WorkerDeploymentSuite) startAndValidateWorkerDeployments( - ctx context.Context, + env *testcore.TestEnv, request *workflowservice.ListWorkerDeploymentsRequest, expectedDeploymentSummaries []*workflowservice.ListWorkerDeploymentsResponse_WorkerDeploymentSummary, ) { @@ -3739,7 +3764,7 @@ func (s *WorkerDeploymentSuite) startAndValidateWorkerDeployments( s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - actualDeploymentSummaries, err := s.listWorkerDeployments(ctx, request) + actualDeploymentSummaries, err := s.listWorkerDeployments(env, request) a.NoError(err) if len(actualDeploymentSummaries) < len(expectedDeploymentSummaries) { a.Failf("not enough deployment summaries", "got %d, want at least %d", len(actualDeploymentSummaries), len(expectedDeploymentSummaries)) @@ -3764,13 +3789,13 @@ func (s *WorkerDeploymentSuite) startAndValidateWorkerDeployments( } func (s *WorkerDeploymentSuite) validateWorkerDeploymentCount( - ctx context.Context, + env *testcore.TestEnv, request *workflowservice.ListWorkerDeploymentsRequest, expectedCount int, ) { s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - actualDeploymentSummaries, err := s.listWorkerDeployments(ctx, request) + actualDeploymentSummaries, err := s.listWorkerDeployments(env, request) a.NoError(err) a.Len(actualDeploymentSummaries, expectedCount) }, time.Second*5, time.Millisecond*200) @@ -3794,18 +3819,19 @@ func (s *WorkerDeploymentSuite) buildWorkerDeploymentSummary( } func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_Success() { - ctx, cancel := context.WithTimeout(context.Background(), time.Minute) - defer cancel() + env := s.newTestEnv() + + ctx := s.Context() - tv := testvars.New(s) + tv := s.tv() deploymentName := tv.DeploymentSeries() requestID := tv.Any().String() identity := tv.Any().String() // Create a new worker deployment - resp, err := s.FrontendClient().CreateWorkerDeployment(ctx, &workflowservice.CreateWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + resp, err := env.FrontendClient().CreateWorkerDeployment(ctx, &workflowservice.CreateWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: deploymentName, Identity: identity, RequestId: requestID, @@ -3816,8 +3842,8 @@ func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_Success() { s.NotEmpty(resp.ConflictToken) // Verify the deployment was created - descResp, err := s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + descResp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: deploymentName, }) s.NoError(err) @@ -3830,17 +3856,18 @@ func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_Success() { } func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_Idempotent() { - ctx, cancel := context.WithTimeout(context.Background(), time.Minute) - defer cancel() + env := s.newTestEnv() + + ctx := s.Context() - tv := testvars.New(s) + tv := s.tv() deploymentName := tv.DeploymentSeries() requestID := tv.Any().String() // Create a worker deployment - resp1, err := s.FrontendClient().CreateWorkerDeployment(ctx, &workflowservice.CreateWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + resp1, err := env.FrontendClient().CreateWorkerDeployment(ctx, &workflowservice.CreateWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: deploymentName, RequestId: requestID, }) @@ -3849,8 +3876,8 @@ func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_Idempotent() { token1 := resp1.ConflictToken // Create the same deployment again with same request ID - should be idempotent - resp2, err := s.FrontendClient().CreateWorkerDeployment(ctx, &workflowservice.CreateWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + resp2, err := env.FrontendClient().CreateWorkerDeployment(ctx, &workflowservice.CreateWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: deploymentName, RequestId: requestID, }) @@ -3860,26 +3887,27 @@ func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_Idempotent() { } func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_AlreadyExists_DifferentRequestID() { - ctx, cancel := context.WithTimeout(context.Background(), time.Minute) - defer cancel() + env := s.newTestEnv() - tv := testvars.New(s) + ctx := s.Context() + + tv := s.tv() deploymentName := tv.DeploymentSeries() requestID1 := tv.Any().String() requestID2 := tv.Any().String() // Create a worker deployment - _, err := s.FrontendClient().CreateWorkerDeployment(ctx, &workflowservice.CreateWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + _, err := env.FrontendClient().CreateWorkerDeployment(ctx, &workflowservice.CreateWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: deploymentName, RequestId: requestID1, }) s.NoError(err) // Try to create the same deployment with different request ID - should fail - _, err = s.FrontendClient().CreateWorkerDeployment(ctx, &workflowservice.CreateWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + _, err = env.FrontendClient().CreateWorkerDeployment(ctx, &workflowservice.CreateWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: deploymentName, RequestId: requestID2, }) @@ -3890,18 +3918,19 @@ func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_AlreadyExists_Differe } func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_AutoCreatedByPoller_ConflictWithExplicitCreate() { - ctx, cancel := context.WithTimeout(context.Background(), time.Minute) - defer cancel() + env := s.newTestEnv() - tv := testvars.New(s) + ctx := s.Context() + + tv := s.tv() // First, create deployment via polling - go s.pollFromDeployment(ctx, tv) - s.ensureCreateDeployment(tv) + go s.pollFromDeployment(ctx, env, tv) + s.ensureCreateDeployment(env, tv) // Try to explicitly create the same deployment - _, err := s.FrontendClient().CreateWorkerDeployment(ctx, &workflowservice.CreateWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + _, err := env.FrontendClient().CreateWorkerDeployment(ctx, &workflowservice.CreateWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentSeries(), RequestId: tv.Any().String(), }) @@ -3912,9 +3941,6 @@ func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_AutoCreatedByPoller_C } func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_InvalidDeploymentName() { - ctx, cancel := context.WithTimeout(context.Background(), time.Minute) - defer cancel() - testCases := []struct { name string deploymentName string @@ -3943,11 +3969,12 @@ func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_InvalidDeploymentName } for _, tc := range testCases { - s.Run(tc.name, func() { - _, err := s.FrontendClient().CreateWorkerDeployment(ctx, &workflowservice.CreateWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + s.Run(tc.name, func(s *WorkerDeploymentSuite) { + env := s.newTestEnv() + _, err := env.FrontendClient().CreateWorkerDeployment(s.Context(), &workflowservice.CreateWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tc.deploymentName, - RequestId: testvars.New(s).Any().String(), + RequestId: s.tv().Any().String(), }) s.Error(err) var invalidArg *serviceerror.InvalidArgument @@ -3962,36 +3989,35 @@ func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_MaxDeploymentsLimit() // Also in TestNamespaceDeploymentsLimit s.T().Skip() // Need to separate this test so other tests do not create deployment in the same NS - ctx, cancel := context.WithTimeout(context.Background(), time.Minute) - defer cancel() - // Override the max deployments limit for this test - s.OverrideDynamicConfig(dynamicconfig.MatchingMaxDeployments, 2) + env := s.newTestEnv(testcore.WithDynamicConfig(dynamicconfig.MatchingMaxDeployments, 2)) - tv := testvars.New(s) + ctx := s.Context() + + tv := s.tv() // Create first deployment - _, err := s.FrontendClient().CreateWorkerDeployment(ctx, &workflowservice.CreateWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + _, err := env.FrontendClient().CreateWorkerDeployment(ctx, &workflowservice.CreateWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentSeries() + "_1", RequestId: tv.Any().String(), }) s.NoError(err) // Create second deployment - _, err = s.FrontendClient().CreateWorkerDeployment(ctx, &workflowservice.CreateWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + _, err = env.FrontendClient().CreateWorkerDeployment(ctx, &workflowservice.CreateWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentSeries() + "_2", RequestId: tv.Any().String(), }) s.NoError(err) // wait for all existing deployments to show up in visibility - s.validateWorkerDeploymentCount(ctx, &workflowservice.ListWorkerDeploymentsRequest{Namespace: s.Namespace().String()}, 2) + s.validateWorkerDeploymentCount(env, &workflowservice.ListWorkerDeploymentsRequest{Namespace: env.Namespace().String()}, 2) // Try to create third deployment - should fail - _, err = s.FrontendClient().CreateWorkerDeployment(ctx, &workflowservice.CreateWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + _, err = env.FrontendClient().CreateWorkerDeployment(ctx, &workflowservice.CreateWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: tv.DeploymentSeries() + "_3", RequestId: tv.Any().String(), }) @@ -4004,18 +4030,19 @@ func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_MaxDeploymentsLimit() } func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_AfterDelete_CanRecreate() { - ctx, cancel := context.WithTimeout(context.Background(), time.Minute) - defer cancel() + env := s.newTestEnv() - tv := testvars.New(s) + ctx := s.Context() + + tv := s.tv() deploymentName := tv.DeploymentSeries() requestID1 := tv.Any().String() requestID2 := tv.Any().String() // Create a worker deployment - resp1, err := s.FrontendClient().CreateWorkerDeployment(ctx, &workflowservice.CreateWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + resp1, err := env.FrontendClient().CreateWorkerDeployment(ctx, &workflowservice.CreateWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: deploymentName, RequestId: requestID1, }) @@ -4023,16 +4050,16 @@ func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_AfterDelete_CanRecrea s.NotNil(resp1) // Delete the deployment - _, err = s.FrontendClient().DeleteWorkerDeployment(ctx, &workflowservice.DeleteWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + _, err = env.FrontendClient().DeleteWorkerDeployment(ctx, &workflowservice.DeleteWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: deploymentName, Identity: "test", }) s.NoError(err) // Should be able to create a deployment with the same name again - resp2, err := s.FrontendClient().CreateWorkerDeployment(ctx, &workflowservice.CreateWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + resp2, err := env.FrontendClient().CreateWorkerDeployment(ctx, &workflowservice.CreateWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: deploymentName, RequestId: requestID2, }) @@ -4041,8 +4068,8 @@ func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_AfterDelete_CanRecrea s.NotEqual(resp1.ConflictToken, resp2.ConflictToken) // Should be a new deployment with different token // Verify the deployment was created - descResp, err := s.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ - Namespace: s.Namespace().String(), + descResp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + Namespace: env.Namespace().String(), DeploymentName: deploymentName, }) s.NoError(err) @@ -4053,10 +4080,20 @@ func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_AfterDelete_CanRecrea s.Empty(descResp.WorkerDeploymentInfo.VersionSummaries) // No versions initially } -// Name is used by testvars. We use a shortened test name in variables so that physical task queue IDs +// tv returns test variables seeded from a shortened test name so that physical task queue IDs // do not grow larger than DB column limit (currently as low as 272 chars). -func (s *WorkerDeploymentSuite) Name() string { - fullName := s.T().Name() +func (s *WorkerDeploymentSuite) tv() *testvars.TestVars { + return testvars.New(shortNamer{s.T()}) +} + +// shortNamer is used by testvars. We use a shortened test name in variables so that physical task +// queue IDs do not grow larger than DB column limit (currently as low as 272 chars). +type shortNamer struct { + t *testing.T +} + +func (n shortNamer) Name() string { + fullName := n.t.Name() if len(fullName) <= 30 { return fullName } @@ -4068,13 +4105,13 @@ func (s *WorkerDeploymentSuite) Name() string { } func (s *WorkerDeploymentSuite) skipBeforeVersion(version workerdeployment.DeploymentWorkflowVersion) { - if s.workflowVersion < version { + if workerdeployment.VersionDataRevisionNumber < version { s.T().Skipf("test supports version %v and newer", version) } } func (s *WorkerDeploymentSuite) skipFromVersion(version workerdeployment.DeploymentWorkflowVersion) { - if s.workflowVersion >= version { + if workerdeployment.VersionDataRevisionNumber >= version { s.T().Skipf("test supports version older than %v", version) } } From 83cde408f0867d4b8f64a1e9bbaa21903fe9713a Mon Sep 17 00:00:00 2001 From: Stephan Behnke Date: Sat, 6 Jun 2026 13:02:49 -0700 Subject: [PATCH 02/27] Inline ctx and tv locals in test methods Co-Authored-By: Claude Opus 4.8 (1M context) --- tests/worker_deployment_test.go | 925 ++++++++++++++------------------ 1 file changed, 389 insertions(+), 536 deletions(-) diff --git a/tests/worker_deployment_test.go b/tests/worker_deployment_test.go index cc24c5fb91a..d69aa73a2c3 100644 --- a/tests/worker_deployment_test.go +++ b/tests/worker_deployment_test.go @@ -175,65 +175,59 @@ func (s *WorkerDeploymentSuite) startVersionWorkflow(ctx context.Context, env *t func (s *WorkerDeploymentSuite) TestForceCAN_NoOpenWFS() { env := s.newTestEnv() - ctx := s.Context() - tv := s.tv() - // Start a version workflow - s.startVersionWorkflow(ctx, env, tv) - s.ensureCreateVersionInDeployment(env, tv) + s.startVersionWorkflow(s.Context(), env, s.tv()) + s.ensureCreateVersionInDeployment(env, s.tv()) // Set the version as current - _, err := env.FrontendClient().SetWorkerDeploymentCurrentVersion(ctx, &workflowservice.SetWorkerDeploymentCurrentVersionRequest{ + _, err := env.FrontendClient().SetWorkerDeploymentCurrentVersion(s.Context(), &workflowservice.SetWorkerDeploymentCurrentVersionRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv.DeploymentSeries(), - Version: tv.DeploymentVersionString(), + DeploymentName: s.tv().DeploymentSeries(), + Version: s.tv().DeploymentVersionString(), }) s.NoError(err) // ForceCAN - workflowID := workerdeployment.GenerateDeploymentWorkflowID(tv.DeploymentSeries()) + workflowID := workerdeployment.GenerateDeploymentWorkflowID(s.tv().DeploymentSeries()) workflowExecution := &commonpb.WorkflowExecution{ WorkflowId: workflowID, } - err = env.SendSignal(env.Namespace().String(), workflowExecution, workerdeployment.ForceCANSignalName, nil, tv.ClientIdentity()) + err = env.SendSignal(env.Namespace().String(), workflowExecution, workerdeployment.ForceCANSignalName, nil, s.tv().ClientIdentity()) s.NoError(err) // Verify if the state is intact even after a CAN s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv.DeploymentSeries(), + DeploymentName: s.tv().DeploymentSeries(), }) a.NoError(err) - a.Equal(tv.DeploymentVersionString(), resp.GetWorkerDeploymentInfo().GetRoutingConfig().GetCurrentVersion()) + a.Equal(s.tv().DeploymentVersionString(), resp.GetWorkerDeploymentInfo().GetRoutingConfig().GetCurrentVersion()) //nolint:staticcheck // SA1019: old worker versioning }, time.Second*10, time.Millisecond*1000) } func (s *WorkerDeploymentSuite) TestForceCAN_WithOverrideState() { env := s.newTestEnv() - ctx := s.Context() - tv := s.tv() - // Start a version workflow - s.startVersionWorkflow(ctx, env, tv) - s.ensureCreateVersionInDeployment(env, tv) + s.startVersionWorkflow(s.Context(), env, s.tv()) + s.ensureCreateVersionInDeployment(env, s.tv()) // Set the version as current - _, err := env.FrontendClient().SetWorkerDeploymentCurrentVersion(ctx, &workflowservice.SetWorkerDeploymentCurrentVersionRequest{ + _, err := env.FrontendClient().SetWorkerDeploymentCurrentVersion(s.Context(), &workflowservice.SetWorkerDeploymentCurrentVersionRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv.DeploymentSeries(), - Version: tv.DeploymentVersionString(), + DeploymentName: s.tv().DeploymentSeries(), + Version: s.tv().DeploymentVersionString(), }) s.NoError(err) // Create a modified state with a different manager identity overrideState := &deploymentspb.WorkerDeploymentLocalState{ CreateTime: timestamppb.New(time.Now()), - RoutingConfig: &deploymentpb.RoutingConfig{CurrentVersion: tv.DeploymentVersionString()}, - Versions: map[string]*deploymentspb.WorkerDeploymentVersionSummary{tv.DeploymentVersionString(): {Version: tv.DeploymentVersionString(), CreateTime: timestamppb.New(time.Now())}}, + RoutingConfig: &deploymentpb.RoutingConfig{CurrentVersion: s.tv().DeploymentVersionString()}, + Versions: map[string]*deploymentspb.WorkerDeploymentVersionSummary{s.tv().DeploymentVersionString(): {Version: s.tv().DeploymentVersionString(), CreateTime: timestamppb.New(time.Now())}}, LastModifierIdentity: "override-test-identity", ManagerIdentity: "override-manager-identity", } @@ -256,20 +250,20 @@ func (s *WorkerDeploymentSuite) TestForceCAN_WithOverrideState() { } // Send ForceCAN signal with override state - workflowID := workerdeployment.GenerateDeploymentWorkflowID(tv.DeploymentSeries()) + workflowID := workerdeployment.GenerateDeploymentWorkflowID(s.tv().DeploymentSeries()) workflowExecution := &commonpb.WorkflowExecution{ WorkflowId: workflowID, } - err = env.SendSignal(env.Namespace().String(), workflowExecution, workerdeployment.ForceCANSignalName, signalPayload, tv.ClientIdentity()) + err = env.SendSignal(env.Namespace().String(), workflowExecution, workerdeployment.ForceCANSignalName, signalPayload, s.tv().ClientIdentity()) s.NoError(err) // Verify that the override state is used after CAN s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv.DeploymentSeries(), + DeploymentName: s.tv().DeploymentSeries(), }) a.NoError(err) a.Equal("override-manager-identity", resp.GetWorkerDeploymentInfo().GetManagerIdentity()) @@ -282,8 +276,6 @@ func (s *WorkerDeploymentSuite) TestDeploymentVersionLimits() { testcore.WithDynamicConfig(dynamicconfig.MatchingMaxTaskQueuesInDeploymentVersion, 1), ) - ctx := s.Context() - firstDeployment := s.tv().WithDeploymentSeriesNumber(1) secondDeployment := s.tv().WithDeploymentSeriesNumber(2) @@ -296,14 +288,14 @@ func (s *WorkerDeploymentSuite) TestDeploymentVersionLimits() { expectedErrorMaxTaskQueues := fmt.Sprintf("cannot add task queue %v since maximum number of task queues (1) have been registered in deployment", secondDeploymentVersionOne.WithTaskQueueNumber(2).TaskQueue().GetName()) // First deployment version should be fine - go s.pollFromDeployment(ctx, env, firstDeploymentVersionOne) + go s.pollFromDeployment(s.Context(), env, firstDeploymentVersionOne) s.ensureCreateVersionInDeployment(env, firstDeploymentVersionOne) // pollers of second version in the same deployment should be rejected s.pollFromDeploymentExpectFail(env, firstDeploymentVersionTwo, expectedErrorMaxVersions) // But first version of another deployment fine - go s.pollFromDeployment(ctx, env, secondDeploymentVersionOne) + go s.pollFromDeployment(s.Context(), env, secondDeploymentVersionOne) s.ensureCreateVersionInDeployment(env, secondDeploymentVersionOne) // pollers of the second TQ in the same deployment version should be rejected @@ -317,32 +309,25 @@ func (s *WorkerDeploymentSuite) TestNamespaceDeploymentsLimit() { env := s.newTestEnv(testcore.WithDynamicConfig(dynamicconfig.MatchingMaxDeployments, 1)) - ctx := s.Context() - - tv := s.tv() - // First deployment version should be fine - go s.pollFromDeployment(ctx, env, tv) - s.ensureCreateVersionInDeployment(env, tv) + go s.pollFromDeployment(s.Context(), env, s.tv()) + s.ensureCreateVersionInDeployment(env, s.tv()) // wait for all existing deployments to show up in visibility s.validateWorkerDeploymentCount(env, &workflowservice.ListWorkerDeploymentsRequest{Namespace: env.Namespace().String()}, 1) // pollers of the second deployment version should be rejected - s.pollFromDeploymentExpectFail(env, tv.WithDeploymentSeriesNumber(2), "reached maximum deployments in namespace (1)") + s.pollFromDeploymentExpectFail(env, s.tv().WithDeploymentSeriesNumber(2), "reached maximum deployments in namespace (1)") } func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_TwoVersions_Sorted() { env := s.newTestEnv() - ctx := s.Context() - tv := s.tv() - // Starting two versions of the deployment - firstVersion := tv.WithBuildIDNumber(1) - secondVersion := tv.WithBuildIDNumber(2) + firstVersion := s.tv().WithBuildIDNumber(1) + secondVersion := s.tv().WithBuildIDNumber(2) - go s.pollFromDeployment(ctx, env, firstVersion) + go s.pollFromDeployment(s.Context(), env, firstVersion) // Wait until the first version is registered in the deployment before starting the second. // This ensures that both versions get distinct CreateTime values in the deployment workflow @@ -351,18 +336,18 @@ func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_TwoVersions_Sorted( // both registrations can queue up and be processed within the same workflow task millisecond. s.ensureCreateVersionInDeployment(env, firstVersion) - go s.pollFromDeployment(ctx, env, secondVersion) + go s.pollFromDeployment(s.Context(), env, secondVersion) s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv.DeploymentSeries(), + DeploymentName: s.tv().DeploymentSeries(), }) a.NoError(err) a.NotNil(resp.GetWorkerDeploymentInfo()) - a.Equal(tv.DeploymentSeries(), resp.GetWorkerDeploymentInfo().GetName()) + a.Equal(s.tv().DeploymentSeries(), resp.GetWorkerDeploymentInfo().GetName()) a.NotNil(resp.GetWorkerDeploymentInfo().GetVersionSummaries()) a.Len(resp.GetWorkerDeploymentInfo().GetVersionSummaries(), 2) @@ -388,13 +373,10 @@ func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_TwoVersions_Sorted( func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_MultipleVersions_Sorted() { env := s.newTestEnv() - ctx := s.Context() - tv := s.tv() - numVersions := 10 for i := range numVersions { - go s.pollFromDeployment(ctx, env, tv.WithBuildIDNumber(i)) + go s.pollFromDeployment(s.Context(), env, s.tv().WithBuildIDNumber(i)) // waiting for 1ms to start the next version later. startTime := time.Now() @@ -407,9 +389,9 @@ func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_MultipleVersions_So s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv.DeploymentSeries(), + DeploymentName: s.tv().DeploymentSeries(), }) a.NoError(err) @@ -428,24 +410,21 @@ func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_MultipleVersions_So func (s *WorkerDeploymentSuite) TestConflictToken_Describe_SetCurrent_SetRamping() { env := s.newTestEnv() - ctx := s.Context() - tv := s.tv() - - firstVersion := tv.WithBuildIDNumber(1) - secondVersion := tv.WithBuildIDNumber(2) + firstVersion := s.tv().WithBuildIDNumber(1) + secondVersion := s.tv().WithBuildIDNumber(2) // Start deployment version workflow + worker-deployment workflow. - go s.pollFromDeployment(ctx, env, firstVersion) - go s.pollFromDeployment(ctx, env, secondVersion) + go s.pollFromDeployment(s.Context(), env, firstVersion) + go s.pollFromDeployment(s.Context(), env, secondVersion) var cT []byte // No current deployment version set. s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv.DeploymentSeries(), + DeploymentName: s.tv().DeploymentSeries(), }) a.NoError(err) a.Equal(worker_versioning.UnversionedVersionId, resp.GetWorkerDeploymentInfo().GetRoutingConfig().GetCurrentVersion()) @@ -454,9 +433,9 @@ func (s *WorkerDeploymentSuite) TestConflictToken_Describe_SetCurrent_SetRamping s.ensureCreateVersionInDeployment(env, firstVersion) // Set first version as current version - _, err := env.FrontendClient().SetWorkerDeploymentCurrentVersion(ctx, &workflowservice.SetWorkerDeploymentCurrentVersionRequest{ + _, err := env.FrontendClient().SetWorkerDeploymentCurrentVersion(s.Context(), &workflowservice.SetWorkerDeploymentCurrentVersionRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv.DeploymentSeries(), + DeploymentName: s.tv().DeploymentSeries(), Version: firstVersion.DeploymentVersionString(), ConflictToken: cT, }) @@ -465,9 +444,9 @@ func (s *WorkerDeploymentSuite) TestConflictToken_Describe_SetCurrent_SetRamping s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv.DeploymentSeries(), + DeploymentName: s.tv().DeploymentSeries(), }) a.NoError(err) a.Equal(firstVersion.DeploymentVersionString(), resp.GetWorkerDeploymentInfo().GetRoutingConfig().GetCurrentVersion()) @@ -475,10 +454,10 @@ func (s *WorkerDeploymentSuite) TestConflictToken_Describe_SetCurrent_SetRamping }, time.Second*10, time.Millisecond*1000) // Set a new second version and set it as the current version - go s.pollFromDeployment(ctx, env, secondVersion) - _, _ = env.FrontendClient().SetWorkerDeploymentRampingVersion(ctx, &workflowservice.SetWorkerDeploymentRampingVersionRequest{ + go s.pollFromDeployment(s.Context(), env, secondVersion) + _, _ = env.FrontendClient().SetWorkerDeploymentRampingVersion(s.Context(), &workflowservice.SetWorkerDeploymentRampingVersionRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv.DeploymentSeries(), + DeploymentName: s.tv().DeploymentSeries(), Version: secondVersion.DeploymentVersionString(), Percentage: 5, ConflictToken: cT, @@ -488,9 +467,9 @@ func (s *WorkerDeploymentSuite) TestConflictToken_Describe_SetCurrent_SetRamping s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv.DeploymentSeries(), + DeploymentName: s.tv().DeploymentSeries(), }) a.NoError(err) a.Equal(secondVersion.DeploymentVersionString(), resp.GetWorkerDeploymentInfo().GetRoutingConfig().GetRampingVersion()) @@ -500,40 +479,38 @@ func (s *WorkerDeploymentSuite) TestConflictToken_Describe_SetCurrent_SetRamping func (s *WorkerDeploymentSuite) TestConflictToken_SetCurrent_SetRamping_Wrong() { env := s.newTestEnv(testcore.WithDynamicConfig(dynamicconfig.FrontendMaskInternalErrorDetails, true)) - ctx := s.Context() - tv := s.tv() expectedError := "conflict token mismatch" - firstVersion := tv.WithBuildIDNumber(1) + firstVersion := s.tv().WithBuildIDNumber(1) // Start deployment version workflow + worker-deployment workflow. - go s.pollFromDeployment(ctx, env, firstVersion) + go s.pollFromDeployment(s.Context(), env, firstVersion) cTWrong, _ := time.Now().MarshalBinary() // wrong token // Wait until deployment exists s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv.DeploymentSeries(), + DeploymentName: s.tv().DeploymentSeries(), }) a.NoError(err) a.Equal(worker_versioning.UnversionedVersionId, resp.GetWorkerDeploymentInfo().GetRoutingConfig().GetCurrentVersion()) }, time.Second*10, time.Millisecond*1000) // Set first version as current version with wrong token - _, err := env.FrontendClient().SetWorkerDeploymentCurrentVersion(ctx, &workflowservice.SetWorkerDeploymentCurrentVersionRequest{ + _, err := env.FrontendClient().SetWorkerDeploymentCurrentVersion(s.Context(), &workflowservice.SetWorkerDeploymentCurrentVersionRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv.DeploymentSeries(), + DeploymentName: s.tv().DeploymentSeries(), Version: firstVersion.DeploymentVersionString(), ConflictToken: cTWrong, }) s.Equal(expectedError, err.Error()) // Set first version as ramping version with wrong token - _, err = env.FrontendClient().SetWorkerDeploymentRampingVersion(ctx, &workflowservice.SetWorkerDeploymentRampingVersionRequest{ + _, err = env.FrontendClient().SetWorkerDeploymentRampingVersion(s.Context(), &workflowservice.SetWorkerDeploymentRampingVersionRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv.DeploymentSeries(), + DeploymentName: s.tv().DeploymentSeries(), Version: firstVersion.DeploymentVersionString(), Percentage: 5, ConflictToken: cTWrong, @@ -546,15 +523,13 @@ func (s *WorkerDeploymentSuite) TestConflictToken_SetCurrent_SetRamping_Wrong() func (s *WorkerDeploymentSuite) TestListWorkerDeployments_OneVersion_OneDeployment() { env := s.newTestEnv() - ctx := s.Context() - tv := s.tv() startTime := timestamppb.Now() - s.startVersionWorkflow(ctx, env, tv) - s.ensureCreateVersionInDeployment(env, tv) + s.startVersionWorkflow(s.Context(), env, s.tv()) + s.ensureCreateVersionInDeployment(env, s.tv()) latestVersionSummary := &deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ - Version: tv.DeploymentVersionString(), + Version: s.tv().DeploymentVersionString(), CreateTime: startTime, DrainageInfo: nil, RampingSinceTime: nil, @@ -566,7 +541,7 @@ func (s *WorkerDeploymentSuite) TestListWorkerDeployments_OneVersion_OneDeployme } expectedDeploymentSummaries := s.buildWorkerDeploymentSummary( - tv.DeploymentSeries(), + s.tv().DeploymentSeries(), startTime, &deploymentpb.RoutingConfig{ CurrentVersion: worker_versioning.UnversionedVersionId, // default current version is __unversioned__ @@ -584,18 +559,15 @@ func (s *WorkerDeploymentSuite) TestListWorkerDeployments_OneVersion_OneDeployme func (s *WorkerDeploymentSuite) TestListWorkerDeployments_TwoVersions_SameDeployment_OneCurrent_NoRamping() { env := s.newTestEnv() - ctx := s.Context() - tv := s.tv() - - firstVersion := tv.WithBuildIDNumber(1) - secondVersion := tv.WithBuildIDNumber(2) + firstVersion := s.tv().WithBuildIDNumber(1) + secondVersion := s.tv().WithBuildIDNumber(2) createVersion1Time := timestamppb.Now() - s.startVersionWorkflow(ctx, env, firstVersion) + s.startVersionWorkflow(s.Context(), env, firstVersion) s.ensureCreateVersionInDeployment(env, firstVersion) createVersion2Time := timestamppb.Now() - s.startVersionWorkflow(ctx, env, secondVersion) + s.startVersionWorkflow(s.Context(), env, secondVersion) s.ensureCreateVersionInDeployment(env, secondVersion) setCurrentTime := timestamppb.Now() @@ -631,7 +603,7 @@ func (s *WorkerDeploymentSuite) TestListWorkerDeployments_TwoVersions_SameDeploy } expectedDeploymentSummary := s.buildWorkerDeploymentSummary( - tv.DeploymentSeries(), + s.tv().DeploymentSeries(), createVersion1Time, routingInfo, latestVersionSummary, @@ -649,18 +621,15 @@ func (s *WorkerDeploymentSuite) TestListWorkerDeployments_TwoVersions_SameDeploy func (s *WorkerDeploymentSuite) TestListWorkerDeployments_TwoVersions_SameDeployment_OneCurrent_OneRamping() { env := s.newTestEnv() - ctx := s.Context() - tv := s.tv() - - currentVersionVars := tv.WithBuildIDNumber(1) - rampingVersionVars := tv.WithBuildIDNumber(2) + currentVersionVars := s.tv().WithBuildIDNumber(1) + rampingVersionVars := s.tv().WithBuildIDNumber(2) createVersion1Time := timestamppb.Now() - s.startVersionWorkflow(ctx, env, currentVersionVars) + s.startVersionWorkflow(s.Context(), env, currentVersionVars) s.ensureCreateVersionInDeployment(env, currentVersionVars) createVersion2Time := timestamppb.Now() - s.startVersionWorkflow(ctx, env, rampingVersionVars) + s.startVersionWorkflow(s.Context(), env, rampingVersionVars) s.ensureCreateVersionInDeployment(env, rampingVersionVars) setCurrentTime := timestamppb.Now() @@ -700,7 +669,7 @@ func (s *WorkerDeploymentSuite) TestListWorkerDeployments_TwoVersions_SameDeploy } expectedDeploymentSummary := s.buildWorkerDeploymentSummary( - tv.DeploymentSeries(), + s.tv().DeploymentSeries(), createVersion1Time, routingInfo, latestVersionSummary, @@ -718,18 +687,15 @@ func (s *WorkerDeploymentSuite) TestListWorkerDeployments_TwoVersions_SameDeploy func (s *WorkerDeploymentSuite) TestListWorkerDeployments_RampingVersionPercentageChange_RampingChangedTime() { env := s.newTestEnv() - ctx := s.Context() - tv := s.tv() - startTime := timestamppb.Now() - s.startVersionWorkflow(ctx, env, tv) + s.startVersionWorkflow(s.Context(), env, s.tv()) setRampTime := timestamppb.Now() - s.setAndVerifyRampingVersion(env, tv, false, 50, true, "") // set version as ramping + s.setAndVerifyRampingVersion(env, s.tv(), false, 50, true, "") // set version as ramping routingInfo := &deploymentpb.RoutingConfig{ CurrentVersion: worker_versioning.UnversionedVersionId, CurrentVersionChangedTime: nil, - RampingVersion: tv.DeploymentVersionString(), + RampingVersion: s.tv().DeploymentVersionString(), RampingVersionPercentage: 50, RampingVersionChangedTime: setRampTime, RampingVersionPercentageChangedTime: setRampTime, @@ -741,7 +707,7 @@ func (s *WorkerDeploymentSuite) TestListWorkerDeployments_RampingVersionPercenta changeRampTime := timestamppb.Now() // modify ramping version percentage - s.setAndVerifyRampingVersion(env, tv, false, 75, true, "") + s.setAndVerifyRampingVersion(env, s.tv(), false, 75, true, "") // only the ramping version percentage should be updated, not the ramping version update time // since we are not changing the ramping version @@ -749,7 +715,7 @@ func (s *WorkerDeploymentSuite) TestListWorkerDeployments_RampingVersionPercenta routingInfo.RampingVersionPercentageChangedTime = changeRampTime rampingVersionSummary := &deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ - Version: tv.DeploymentVersionString(), + Version: s.tv().DeploymentVersionString(), CreateTime: startTime, DrainageInfo: nil, RampingSinceTime: setRampTime, @@ -761,7 +727,7 @@ func (s *WorkerDeploymentSuite) TestListWorkerDeployments_RampingVersionPercenta } expectedDeploymentSummary := s.buildWorkerDeploymentSummary( - tv.DeploymentSeries(), + s.tv().DeploymentSeries(), startTime, routingInfo, rampingVersionSummary, // latest version added is the ramping version @@ -780,9 +746,7 @@ func (s *WorkerDeploymentSuite) TestListWorkerDeployments_RampingVersionPercenta func (s *WorkerDeploymentSuite) TestListWorkerDeployments_MultipleVersions_MultipleDeployments_OnePage() { env := s.newTestEnv() - tv := s.tv() - - expectedDeploymentSummaries := s.createVersionsInDeployments(env, tv, 2) + expectedDeploymentSummaries := s.createVersionsInDeployments(env, s.tv(), 2) s.startAndValidateWorkerDeployments(env, &workflowservice.ListWorkerDeploymentsRequest{ Namespace: env.Namespace().String(), @@ -793,9 +757,7 @@ func (s *WorkerDeploymentSuite) TestListWorkerDeployments_MultipleVersions_Multi env := s.newTestEnv() - tv := s.tv() - - expectedDeploymentSummaries := s.createVersionsInDeployments(env, tv, 5) + expectedDeploymentSummaries := s.createVersionsInDeployments(env, s.tv(), 5) s.startAndValidateWorkerDeployments(env, &workflowservice.ListWorkerDeploymentsRequest{ Namespace: env.Namespace().String(), @@ -808,27 +770,24 @@ func (s *WorkerDeploymentSuite) TestListWorkerDeployments_MultipleVersions_Multi func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Ramping_With_Current() { env := s.newTestEnv() - ctx := s.Context() - tv := s.tv() - - rampingVersionVars := tv.WithBuildIDNumber(1) - currentVersionVars := tv.WithBuildIDNumber(2) + rampingVersionVars := s.tv().WithBuildIDNumber(1) + currentVersionVars := s.tv().WithBuildIDNumber(2) versionCreateTime := timestamppb.Now() - s.startVersionWorkflow(ctx, env, rampingVersionVars) - s.startVersionWorkflow(ctx, env, currentVersionVars) + s.startVersionWorkflow(s.Context(), env, rampingVersionVars) + s.startVersionWorkflow(s.Context(), env, currentVersionVars) // set version as ramping setRampingUpdateTime := timestamppb.Now() s.setAndVerifyRampingVersion(env, rampingVersionVars, false, 50, true, "") - resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv.DeploymentSeries(), + DeploymentName: s.tv().DeploymentSeries(), }) s.NoError(err) s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ - Name: tv.DeploymentSeries(), + Name: s.tv().DeploymentSeries(), CreateTime: versionCreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ RampingVersion: rampingVersionVars.DeploymentVersionString(), @@ -851,7 +810,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Ramping_Wi Status: enumspb.WORKER_DEPLOYMENT_VERSION_STATUS_RAMPING, }, }, - LastModifierIdentity: tv.ClientIdentity(), + LastModifierIdentity: s.tv().ClientIdentity(), }, }) @@ -860,14 +819,14 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Ramping_Wi s.setCurrentVersion(env, currentVersionVars, true, "") // fresh DescribeWorkerDeployment call - resp, err = env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + resp, err = env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv.DeploymentSeries(), + DeploymentName: s.tv().DeploymentSeries(), }) s.NoError(err) s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ - Name: tv.DeploymentSeries(), + Name: s.tv().DeploymentSeries(), CreateTime: versionCreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ RampingVersion: rampingVersionVars.DeploymentVersionString(), @@ -902,7 +861,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Ramping_Wi Status: enumspb.WORKER_DEPLOYMENT_VERSION_STATUS_RAMPING, }, }, - LastModifierIdentity: tv.ClientIdentity(), + LastModifierIdentity: s.tv().ClientIdentity(), }, }) @@ -910,14 +869,14 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Ramping_Wi setRampingAsCurrentUpdateTime := timestamppb.Now() s.setCurrentVersion(env, rampingVersionVars, true, "") // fresh DescribeWorkerDeployment call - resp, err = env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + resp, err = env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv.DeploymentSeries(), + DeploymentName: s.tv().DeploymentSeries(), }) s.NoError(err) s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ - Name: tv.DeploymentSeries(), + Name: s.tv().DeploymentSeries(), CreateTime: versionCreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ RampingVersion: "", @@ -955,7 +914,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Ramping_Wi Status: enumspb.WORKER_DEPLOYMENT_VERSION_STATUS_CURRENT, }, }, - LastModifierIdentity: tv.ClientIdentity(), + LastModifierIdentity: s.tv().ClientIdentity(), }, }) @@ -963,14 +922,14 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Ramping_Wi rePromoteCurrentUpdateTime := timestamppb.Now() s.setCurrentVersion(env, currentVersionVars, true, "") // fresh DescribeWorkerDeployment call - resp, err = env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + resp, err = env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv.DeploymentSeries(), + DeploymentName: s.tv().DeploymentSeries(), }) s.NoError(err) s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ - Name: tv.DeploymentSeries(), + Name: s.tv().DeploymentSeries(), CreateTime: versionCreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ RampingVersion: "", @@ -1008,7 +967,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Ramping_Wi Status: enumspb.WORKER_DEPLOYMENT_VERSION_STATUS_DRAINING, }, }, - LastModifierIdentity: tv.ClientIdentity(), + LastModifierIdentity: s.tv().ClientIdentity(), }, }) @@ -1017,16 +976,15 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Ramping_Wi func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_DuplicateRamp() { env := s.newTestEnv() - ctx := s.Context() rampingVersionVars := s.tv().WithBuildIDNumber(1) versionCreateTime := timestamppb.Now() - s.startVersionWorkflow(ctx, env, rampingVersionVars) + s.startVersionWorkflow(s.Context(), env, rampingVersionVars) // set version as ramping setRampingUpdateTime := timestamppb.Now() s.setAndVerifyRampingVersion(env, rampingVersionVars, false, 50, true, "") - resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), DeploymentName: rampingVersionVars.DeploymentSeries(), }) @@ -1067,16 +1025,14 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_DuplicateR func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Invalid_SetCurrent_To_Ramping() { env := s.newTestEnv() - ctx := s.Context() - versionCreateTime := timestamppb.Now() currentVersionVars := s.tv().WithBuildIDNumber(1) - s.startVersionWorkflow(ctx, env, currentVersionVars) + s.startVersionWorkflow(s.Context(), env, currentVersionVars) setCurrentUpdateTime := timestamppb.Now() s.setCurrentVersion(env, currentVersionVars, true, "") - resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), DeploymentName: currentVersionVars.DeploymentSeries(), }) @@ -1114,7 +1070,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Invalid_Se expectedError := fmt.Errorf("ramping version %s is already current", currentVersionVars.DeploymentVersionString()) s.setAndVerifyRampingVersion(env, currentVersionVars, false, 50, true, expectedError.Error()) // setting current version to ramping should fail - resp, err = env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + resp, err = env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), DeploymentName: currentVersionVars.DeploymentSeries(), }) @@ -1153,42 +1109,36 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Invalid_Se func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Valid_SetNilCurrent_To_Ramping() { env := s.newTestEnv() - ctx := s.Context() - - tv := s.tv().WithBuildIDNumber(1) - s.startVersionWorkflow(ctx, env, tv) + s.startVersionWorkflow(s.Context(), env, s.tv().WithBuildIDNumber(1)) // set ramping version to unversioned will change the modifier identity, so it's not a no-op - s.setAndVerifyRampingVersion(env, tv, true, 0, false, "") + s.setAndVerifyRampingVersion(env, s.tv().WithBuildIDNumber(1), true, 0, false, "") // set a non-nil ramping version so that we can unset it in the next step - s.setAndVerifyRampingVersion(env, tv, false, 5, false, "") + s.setAndVerifyRampingVersion(env, s.tv().WithBuildIDNumber(1), false, 5, false, "") // should be able to unset ramping version while current version is nil with no error - s.setAndVerifyRampingVersion(env, tv, true, 0, true, "") + s.setAndVerifyRampingVersion(env, s.tv().WithBuildIDNumber(1), true, 0, true, "") } func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_ModifyExistingRampVersionPercentage() { env := s.newTestEnv() - ctx := s.Context() - tv := s.tv() - versionCreateTime := timestamppb.Now() - rampingVersionVars := tv.WithBuildIDNumber(1) - s.startVersionWorkflow(ctx, env, rampingVersionVars) + rampingVersionVars := s.tv().WithBuildIDNumber(1) + s.startVersionWorkflow(s.Context(), env, rampingVersionVars) // set version as ramping setRampingUpdateTime := timestamppb.Now() s.setAndVerifyRampingVersion(env, rampingVersionVars, false, 50, true, "") - resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv.DeploymentSeries(), + DeploymentName: s.tv().DeploymentSeries(), }) s.NoError(err) s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ - Name: tv.DeploymentSeries(), + Name: s.tv().DeploymentSeries(), CreateTime: versionCreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ RampingVersion: rampingVersionVars.DeploymentVersionString(), @@ -1211,7 +1161,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_ModifyExis Status: enumspb.WORKER_DEPLOYMENT_VERSION_STATUS_RAMPING, }, }, - LastModifierIdentity: tv.ClientIdentity(), + LastModifierIdentity: s.tv().ClientIdentity(), }, }) @@ -1220,14 +1170,14 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_ModifyExis s.setAndVerifyRampingVersion(env, rampingVersionVars, false, 75, true, "") // RampingVersionPercentage and RampingVersionPercentageChangedTime should be updated - resp, err = env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + resp, err = env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv.DeploymentSeries(), + DeploymentName: s.tv().DeploymentSeries(), }) s.NoError(err) s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ - Name: tv.DeploymentSeries(), + Name: s.tv().DeploymentSeries(), CreateTime: versionCreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ RampingVersion: rampingVersionVars.DeploymentVersionString(), @@ -1250,7 +1200,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_ModifyExis Status: enumspb.WORKER_DEPLOYMENT_VERSION_STATUS_RAMPING, }, }, - LastModifierIdentity: tv.ClientIdentity(), + LastModifierIdentity: s.tv().ClientIdentity(), }, }) @@ -1259,16 +1209,13 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_ModifyExis func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_WithCurrent_Unset_Ramp() { env := s.newTestEnv() - ctx := s.Context() - tv := s.tv() - - rampingVersionVars := tv.WithBuildIDNumber(1) - currentVersionVars := tv.WithBuildIDNumber(2) + rampingVersionVars := s.tv().WithBuildIDNumber(1) + currentVersionVars := s.tv().WithBuildIDNumber(2) version1CreateTime := timestamppb.Now() - s.startVersionWorkflow(ctx, env, rampingVersionVars) + s.startVersionWorkflow(s.Context(), env, rampingVersionVars) version2CreateTime := timestamppb.Now() - s.startVersionWorkflow(ctx, env, currentVersionVars) + s.startVersionWorkflow(s.Context(), env, currentVersionVars) setRampingUpdateTime := timestamppb.Now() s.setAndVerifyRampingVersion(env, rampingVersionVars, false, 50, true, "") // set version as ramping @@ -1276,14 +1223,14 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_WithCurren setCurrentUpdateTime := timestamppb.Now() s.setCurrentVersion(env, currentVersionVars, true, "") // set version as curent - resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv.DeploymentSeries(), + DeploymentName: s.tv().DeploymentSeries(), }) s.NoError(err) s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ - Name: tv.DeploymentSeries(), + Name: s.tv().DeploymentSeries(), CreateTime: version1CreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ RampingVersion: rampingVersionVars.DeploymentVersionString(), @@ -1318,7 +1265,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_WithCurren Status: enumspb.WORKER_DEPLOYMENT_VERSION_STATUS_CURRENT, }, }, - LastModifierIdentity: tv.ClientIdentity(), + LastModifierIdentity: s.tv().ClientIdentity(), }, }) @@ -1326,14 +1273,14 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_WithCurren unsetRampingUpdateTime := timestamppb.Now() s.setAndVerifyRampingVersion(env, rampingVersionVars, true, 0, true, "") - resp, err = env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + resp, err = env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv.DeploymentSeries(), + DeploymentName: s.tv().DeploymentSeries(), }) s.NoError(err) s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ - Name: tv.DeploymentSeries(), + Name: s.tv().DeploymentSeries(), CreateTime: version1CreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ RampingVersion: "", @@ -1368,7 +1315,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_WithCurren Status: enumspb.WORKER_DEPLOYMENT_VERSION_STATUS_CURRENT, }, }, - LastModifierIdentity: tv.ClientIdentity(), + LastModifierIdentity: s.tv().ClientIdentity(), }, }) } @@ -1376,12 +1323,9 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_WithCurren func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_SetRampingAsCurrent() { env := s.newTestEnv() - ctx := s.Context() - tv := s.tv() - versionCreateTime := timestamppb.Now() - rampingVersionVars := tv.WithBuildIDNumber(1) - s.startVersionWorkflow(ctx, env, rampingVersionVars) + rampingVersionVars := s.tv().WithBuildIDNumber(1) + s.startVersionWorkflow(s.Context(), env, rampingVersionVars) setRampingUpdateTime := timestamppb.Now() s.setAndVerifyRampingVersion(env, rampingVersionVars, false, 50, true, "") @@ -1390,14 +1334,14 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_SetRamping setCurrentUpdateTime := timestamppb.Now() s.setCurrentVersion(env, rampingVersionVars, true, "") - resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv.DeploymentSeries(), + DeploymentName: s.tv().DeploymentSeries(), }) s.NoError(err) s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ - Name: tv.DeploymentSeries(), + Name: s.tv().DeploymentSeries(), CreateTime: versionCreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ RampingVersion: "", // no ramping info should be set @@ -1421,7 +1365,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_SetRamping Status: enumspb.WORKER_DEPLOYMENT_VERSION_STATUS_CURRENT, }, }, - LastModifierIdentity: tv.ClientIdentity(), + LastModifierIdentity: s.tv().ClientIdentity(), }, }) } @@ -1429,11 +1373,8 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_SetRamping func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_NoCurrent_Unset_Ramp() { env := s.newTestEnv() - ctx := s.Context() - tv := s.tv() - - rampingVersionVars := tv.WithBuildIDNumber(1) - s.startVersionWorkflow(ctx, env, rampingVersionVars) + rampingVersionVars := s.tv().WithBuildIDNumber(1) + s.startVersionWorkflow(s.Context(), env, rampingVersionVars) s.setAndVerifyRampingVersion(env, rampingVersionVars, false, 50, true, "") s.setAndVerifyRampingVersion(env, rampingVersionVars, true, 0, true, "") @@ -1442,50 +1383,47 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_NoCurrent_ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Batching() { env := s.newTestEnv() - ctx := s.Context() - tv := s.tv() - env.InjectHook(testhooks.NewHook(testhooks.TaskQueuesInDeploymentSyncBatchSize, 1)) // registering 5 task-queues in the version which would result in the creation of 5 batches, each with 1 task-queue, during the SyncState call. versionCreateTime := timestamppb.Now() taskQueues := 5 for i := range taskQueues { - go s.pollFromDeploymentWithTaskQueueNumber(ctx, env, tv, i) + go s.pollFromDeploymentWithTaskQueueNumber(s.Context(), env, s.tv(), i) } // ensure the version has been created in the deployment with the right number of task-queues - s.ensureCreateVersionInDeployment(env, tv) - s.ensureCreateVersionWithExpectedTaskQueues(env, tv, taskQueues) + s.ensureCreateVersionInDeployment(env, s.tv()) + s.ensureCreateVersionWithExpectedTaskQueues(env, s.tv(), taskQueues) // verify that all the registered task-queues have "" set as their ramping version for i := range taskQueues { - s.verifyTaskQueueVersioningInfo(env, tv.WithTaskQueueNumber(i).TaskQueue(), worker_versioning.UnversionedVersionId, "", 0) + s.verifyTaskQueueVersioningInfo(env, s.tv().WithTaskQueueNumber(i).TaskQueue(), worker_versioning.UnversionedVersionId, "", 0) } // set ramping version to 50% setRampingUpdateTime := timestamppb.Now() - s.setAndVerifyRampingVersion(env, tv, false, 50, true, "") + s.setAndVerifyRampingVersion(env, s.tv(), false, 50, true, "") // verify the task queues have new ramping version for i := range taskQueues { - s.verifyTaskQueueVersioningInfo(env, tv.WithTaskQueueNumber(i).TaskQueue(), worker_versioning.UnversionedVersionId, tv.DeploymentVersionString(), 50) + s.verifyTaskQueueVersioningInfo(env, s.tv().WithTaskQueueNumber(i).TaskQueue(), worker_versioning.UnversionedVersionId, s.tv().DeploymentVersionString(), 50) } // verify if the worker-deployment has the right ramping version set - resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv.DeploymentSeries(), + DeploymentName: s.tv().DeploymentSeries(), }) s.NoError(err) - s.Equal(tv.DeploymentVersionString(), resp.GetWorkerDeploymentInfo().GetRoutingConfig().GetRampingVersion()) + s.Equal(s.tv().DeploymentVersionString(), resp.GetWorkerDeploymentInfo().GetRoutingConfig().GetRampingVersion()) //nolint:staticcheck // SA1019: old worker versioning s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ - Name: tv.DeploymentSeries(), + Name: s.tv().DeploymentSeries(), CreateTime: versionCreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ - RampingVersion: tv.DeploymentVersionString(), + RampingVersion: s.tv().DeploymentVersionString(), RampingVersionPercentage: 50, RampingVersionChangedTime: setRampingUpdateTime, RampingVersionPercentageChangedTime: setRampingUpdateTime, @@ -1494,7 +1432,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Batching() }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ { - Version: tv.DeploymentVersionString(), + Version: s.tv().DeploymentVersionString(), CreateTime: versionCreateTime, DrainageInfo: nil, RoutingUpdateTime: setRampingUpdateTime, @@ -1505,7 +1443,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Batching() Status: enumspb.WORKER_DEPLOYMENT_VERSION_STATUS_RAMPING, }, }, - LastModifierIdentity: tv.ClientIdentity(), + LastModifierIdentity: s.tv().ClientIdentity(), }, }) @@ -1516,39 +1454,36 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Batching() func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_UnversionedRamp_Batching() { env := s.newTestEnv() - ctx := s.Context() - tv := s.tv() - env.InjectHook(testhooks.NewHook(testhooks.TaskQueuesInDeploymentSyncBatchSize, 1)) // registering 5 task-queues in the version which would result in the creation of 5 batches, each with 1 task-queue, during the SyncState call. versionCreateTime := timestamppb.Now() taskQueues := 5 for i := range taskQueues { - go s.pollFromDeploymentWithTaskQueueNumber(ctx, env, tv, i) + go s.pollFromDeploymentWithTaskQueueNumber(s.Context(), env, s.tv(), i) } // ensure the version has been created in the deployment with the right number of task-queues - s.ensureCreateVersionInDeployment(env, tv) - s.ensureCreateVersionWithExpectedTaskQueues(env, tv, taskQueues) + s.ensureCreateVersionInDeployment(env, s.tv()) + s.ensureCreateVersionWithExpectedTaskQueues(env, s.tv(), taskQueues) // make the current version versioned, so that we can set ramp to unversioned later setCurrentUpdateTime := timestamppb.Now() - s.setCurrentVersion(env, tv, true, "") + s.setCurrentVersion(env, s.tv(), true, "") // set ramp to unversioned which should trigger a batch of SyncDeploymentVersionUserData requests. setRampingUpdateTime := timestamppb.Now() - s.setAndVerifyRampingVersionUnversionedOption(env, tv, true, false, 75, true, false, true, "") + s.setAndVerifyRampingVersionUnversionedOption(env, s.tv(), true, false, 75, true, false, true, "") // check that the current version's task queues have ramping version == __unversioned__ for i := range taskQueues { - s.verifyTaskQueueVersioningInfo(env, tv.WithTaskQueueNumber(i).TaskQueue(), tv.DeploymentVersionString(), worker_versioning.UnversionedVersionId, 75) + s.verifyTaskQueueVersioningInfo(env, s.tv().WithTaskQueueNumber(i).TaskQueue(), s.tv().DeploymentVersionString(), worker_versioning.UnversionedVersionId, 75) } // verify if the worker-deployment has the right ramping version set - resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv.DeploymentSeries(), + DeploymentName: s.tv().DeploymentSeries(), }) s.NoError(err) // nolint:staticcheck // SA1019: old worker versioning @@ -1557,19 +1492,19 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Unversione s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ - Name: tv.DeploymentSeries(), + Name: s.tv().DeploymentSeries(), CreateTime: versionCreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ RampingVersion: worker_versioning.UnversionedVersionId, RampingVersionPercentage: 75, RampingVersionChangedTime: setRampingUpdateTime, RampingVersionPercentageChangedTime: setRampingUpdateTime, - CurrentVersion: tv.DeploymentVersionString(), + CurrentVersion: s.tv().DeploymentVersionString(), CurrentVersionChangedTime: setCurrentUpdateTime, }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ { - Version: tv.DeploymentVersionString(), + Version: s.tv().DeploymentVersionString(), CreateTime: versionCreateTime, DrainageInfo: nil, RoutingUpdateTime: setCurrentUpdateTime, @@ -1581,7 +1516,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Unversione Status: enumspb.WORKER_DEPLOYMENT_VERSION_STATUS_CURRENT, }, }, - LastModifierIdentity: tv.ClientIdentity(), + LastModifierIdentity: s.tv().ClientIdentity(), }, }) @@ -1592,15 +1527,12 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Unversione func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_SetCurrentVersion() { env := s.newTestEnv() - ctx := s.Context() - tv := s.tv() - - firstVersion := tv.WithBuildIDNumber(1) - secondVersion := tv.WithBuildIDNumber(2) + firstVersion := s.tv().WithBuildIDNumber(1) + secondVersion := s.tv().WithBuildIDNumber(2) version1CreateTime := timestamppb.Now() // Start poller with cancellable context for deterministic control - pollerCtx, pollerCancel := context.WithCancel(ctx) + pollerCtx, pollerCancel := context.WithCancel(s.Context()) defer pollerCancel() go s.pollFromDeployment(pollerCtx, env, firstVersion) @@ -1608,9 +1540,9 @@ func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_SetCurrentVersion() s.ensureCreateVersionInDeployment(env, firstVersion) // Verify no current deployment version is set initially - resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv.DeploymentSeries(), + DeploymentName: s.tv().DeploymentSeries(), }) s.NoError(err) s.Equal(worker_versioning.UnversionedVersionId, resp.GetWorkerDeploymentInfo().GetRoutingConfig().GetCurrentVersion()) //nolint:staticcheck // SA1019: old worker versioning @@ -1620,14 +1552,14 @@ func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_SetCurrentVersion() firstVersionCurrentUpdateTime := timestamppb.Now() s.setCurrentVersion(env, firstVersion, true, "") - resp, err = env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + resp, err = env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv.DeploymentSeries(), + DeploymentName: s.tv().DeploymentSeries(), }) s.NoError(err) s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ - Name: tv.DeploymentSeries(), + Name: s.tv().DeploymentSeries(), CreateTime: version1CreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ CurrentVersion: firstVersion.DeploymentVersionString(), @@ -1647,28 +1579,28 @@ func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_SetCurrentVersion() Status: enumspb.WORKER_DEPLOYMENT_VERSION_STATUS_CURRENT, }, }, - LastModifierIdentity: tv.ClientIdentity(), + LastModifierIdentity: s.tv().ClientIdentity(), }, }) // Set a new second version and set it as the current version version2CreateTime := timestamppb.Now() // Start second poller with cancellable context - poller2Ctx, poller2Cancel := context.WithCancel(ctx) + poller2Ctx, poller2Cancel := context.WithCancel(s.Context()) defer poller2Cancel() go s.pollFromDeployment(poller2Ctx, env, secondVersion) secondVersionCurrentUpdateTime := timestamppb.Now() s.setCurrentVersion(env, secondVersion, true, "") // Verify that the first version is draining, has an updated last deactivation time + second version is current, has an updated first activation time. - resp, err = env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + resp, err = env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv.DeploymentSeries(), + DeploymentName: s.tv().DeploymentSeries(), }) s.NoError(err) s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ - Name: tv.DeploymentSeries(), + Name: s.tv().DeploymentSeries(), CreateTime: version1CreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ CurrentVersion: secondVersion.DeploymentVersionString(), @@ -1700,7 +1632,7 @@ func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_SetCurrentVersion() Status: enumspb.WORKER_DEPLOYMENT_VERSION_STATUS_CURRENT, }, }, - LastModifierIdentity: tv.ClientIdentity(), + LastModifierIdentity: s.tv().ClientIdentity(), }, }) @@ -1709,58 +1641,55 @@ func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_SetCurrentVersion() func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Batching() { env := s.newTestEnv() - ctx := s.Context() - tv := s.tv() - env.InjectHook(testhooks.NewHook(testhooks.TaskQueuesInDeploymentSyncBatchSize, 1)) // registering 5 task-queues in the version which would result in the creation of 5 batches, each with 1 task-queue, during the SyncState call. versionCreateTime := timestamppb.Now() taskQueues := 5 for i := range taskQueues { - go s.pollFromDeploymentWithTaskQueueNumber(ctx, env, tv, i) + go s.pollFromDeploymentWithTaskQueueNumber(s.Context(), env, s.tv(), i) } // ensure the version has been created in the deployment with the right number of task-queues - s.ensureCreateVersionInDeployment(env, tv) - s.ensureCreateVersionWithExpectedTaskQueues(env, tv, taskQueues) + s.ensureCreateVersionInDeployment(env, s.tv()) + s.ensureCreateVersionWithExpectedTaskQueues(env, s.tv(), taskQueues) // verify that all the registered task-queues have "__unversioned__" as their current version for i := range taskQueues { - s.verifyTaskQueueVersioningInfo(env, tv.WithTaskQueueNumber(i).TaskQueue(), worker_versioning.UnversionedVersionId, "", 0) + s.verifyTaskQueueVersioningInfo(env, s.tv().WithTaskQueueNumber(i).TaskQueue(), worker_versioning.UnversionedVersionId, "", 0) } // set current and check that the current version's task queues have new current version setCurrentUpdateTime := timestamppb.Now() - s.setCurrentVersion(env, tv, true, "") + s.setCurrentVersion(env, s.tv(), true, "") // verify the current version has propogated to all the registered task-queues userData for i := range taskQueues { - s.verifyTaskQueueVersioningInfo(env, tv.WithTaskQueueNumber(i).TaskQueue(), tv.DeploymentVersionString(), "", 0) + s.verifyTaskQueueVersioningInfo(env, s.tv().WithTaskQueueNumber(i).TaskQueue(), s.tv().DeploymentVersionString(), "", 0) } // verify if the worker-deployment has the right current version set - resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv.DeploymentSeries(), + DeploymentName: s.tv().DeploymentSeries(), }) s.NoError(err) s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ - Name: tv.DeploymentSeries(), + Name: s.tv().DeploymentSeries(), CreateTime: versionCreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ RampingVersion: "", RampingVersionPercentage: 0, RampingVersionChangedTime: nil, RampingVersionPercentageChangedTime: nil, - CurrentVersion: tv.DeploymentVersionString(), + CurrentVersion: s.tv().DeploymentVersionString(), CurrentVersionChangedTime: setCurrentUpdateTime, }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ { - Version: tv.DeploymentVersionString(), + Version: s.tv().DeploymentVersionString(), CreateTime: versionCreateTime, DrainageInfo: nil, RoutingUpdateTime: setCurrentUpdateTime, @@ -1772,7 +1701,7 @@ func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Batching() { Status: enumspb.WORKER_DEPLOYMENT_VERSION_STATUS_CURRENT, }, }, - LastModifierIdentity: tv.ClientIdentity(), + LastModifierIdentity: s.tv().ClientIdentity(), }, }) @@ -1781,81 +1710,72 @@ func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Batching() { func (s *WorkerDeploymentSuite) TestSetManagerIdentity_RW() { env := s.newTestEnv() - ctx := s.Context() - tv := s.tv().WithBuildIDNumber(1) - - go s.pollFromDeployment(ctx, env, tv) - s.ensureCreateVersionInDeployment(env, tv) + go s.pollFromDeployment(s.Context(), env, s.tv().WithBuildIDNumber(1)) + s.ensureCreateVersionInDeployment(env, s.tv().WithBuildIDNumber(1)) // set identity to self - s.setAndValidateManagerIdentity(env, tv, true, false, "", "") + s.setAndValidateManagerIdentity(env, s.tv().WithBuildIDNumber(1), true, false, "", "") // set identity to other - s.setAndValidateManagerIdentity(env, tv, false, false, "other", "") + s.setAndValidateManagerIdentity(env, s.tv().WithBuildIDNumber(1), false, false, "other", "") // set identity to other again (should be idempotent) - s.setAndValidateManagerIdentity(env, tv, false, false, "other", "") + s.setAndValidateManagerIdentity(env, s.tv().WithBuildIDNumber(1), false, false, "other", "") // unset identity - s.setAndValidateManagerIdentity(env, tv, false, false, "", "") + s.setAndValidateManagerIdentity(env, s.tv().WithBuildIDNumber(1), false, false, "", "") // set identity with bad conflict token - s.setAndValidateManagerIdentity(env, tv, true, true, "", "conflict token mismatch") + s.setAndValidateManagerIdentity(env, s.tv().WithBuildIDNumber(1), true, true, "", "conflict token mismatch") } func (s *WorkerDeploymentSuite) TestSetManagerIdentity_WithSetRampSetCurrent() { env := s.newTestEnv() - ctx := s.Context() - tv := s.tv().WithBuildIDNumber(1) - - go s.pollFromDeployment(ctx, env, tv) - s.ensureCreateVersionInDeployment(env, tv) + go s.pollFromDeployment(s.Context(), env, s.tv().WithBuildIDNumber(1)) + s.ensureCreateVersionInDeployment(env, s.tv().WithBuildIDNumber(1)) // set identity to self - s.setAndValidateManagerIdentity(env, tv, true, false, "", "") + s.setAndValidateManagerIdentity(env, s.tv().WithBuildIDNumber(1), true, false, "", "") // -> self can successfully set ramp - s.setAndVerifyRampingVersion(env, tv, false, 1, true, "") + s.setAndVerifyRampingVersion(env, s.tv().WithBuildIDNumber(1), false, 1, true, "") // set identity to other - s.setAndValidateManagerIdentity(env, tv, false, false, "other", "") + s.setAndValidateManagerIdentity(env, s.tv().WithBuildIDNumber(1), false, false, "other", "") // -> self cannot set ramp - s.setAndVerifyRampingVersion(env, tv, false, 2, true, fmt.Sprintf(workerdeployment.ErrManagerIdentityMismatch, "other", tv.ClientIdentity())) + s.setAndVerifyRampingVersion(env, s.tv().WithBuildIDNumber(1), false, 2, true, fmt.Sprintf(workerdeployment.ErrManagerIdentityMismatch, "other", s.tv().WithBuildIDNumber(1).ClientIdentity())) // -> self cannot set current - s.setCurrentVersion(env, tv, true, fmt.Sprintf(workerdeployment.ErrManagerIdentityMismatch, "other", tv.ClientIdentity())) + s.setCurrentVersion(env, s.tv().WithBuildIDNumber(1), true, fmt.Sprintf(workerdeployment.ErrManagerIdentityMismatch, "other", s.tv().WithBuildIDNumber(1).ClientIdentity())) // unset identity - s.setAndValidateManagerIdentity(env, tv, false, false, "", "") + s.setAndValidateManagerIdentity(env, s.tv().WithBuildIDNumber(1), false, false, "", "") // -> self can now set ramp - s.setAndVerifyRampingVersion(env, tv, false, 2, true, "") + s.setAndVerifyRampingVersion(env, s.tv().WithBuildIDNumber(1), false, 2, true, "") // set identity to self - s.setAndValidateManagerIdentity(env, tv, true, false, "", "") + s.setAndValidateManagerIdentity(env, s.tv().WithBuildIDNumber(1), true, false, "", "") // -> self can now set current - s.setCurrentVersion(env, tv, true, "") + s.setCurrentVersion(env, s.tv().WithBuildIDNumber(1), true, "") } func (s *WorkerDeploymentSuite) TestSetManagerIdentity_WithDeleteVersion() { env := s.newTestEnv(testcore.WithDynamicConfig(dynamicconfig.PollerHistoryTTL, 500*time.Millisecond)) - ctx := s.Context() - tv := s.tv().WithBuildIDNumber(1) - // start and stop polling so that version is eligible for deletion - pollerCtx, pollerCancel := context.WithCancel(ctx) - go s.pollFromDeployment(pollerCtx, env, tv) - s.ensureCreateVersionInDeployment(env, tv) + pollerCtx, pollerCancel := context.WithCancel(s.Context()) + go s.pollFromDeployment(pollerCtx, env, s.tv().WithBuildIDNumber(1)) + s.ensureCreateVersionInDeployment(env, s.tv().WithBuildIDNumber(1)) pollerCancel() // set identity to other - s.setAndValidateManagerIdentity(env, tv, false, false, "other", "") + s.setAndValidateManagerIdentity(env, s.tv().WithBuildIDNumber(1), false, false, "other", "") // -> self cannot delete version - s.tryDeleteVersion(env, tv, fmt.Sprintf(workerdeployment.ErrManagerIdentityMismatch, "other", tv.ClientIdentity())) + s.tryDeleteVersion(env, s.tv().WithBuildIDNumber(1), fmt.Sprintf(workerdeployment.ErrManagerIdentityMismatch, "other", s.tv().WithBuildIDNumber(1).ClientIdentity())) // set identity to self - s.setAndValidateManagerIdentity(env, tv, true, false, "", "") + s.setAndValidateManagerIdentity(env, s.tv().WithBuildIDNumber(1), true, false, "", "") // -> self can now delete version - s.tryDeleteVersion(env, tv, "") + s.tryDeleteVersion(env, s.tv().WithBuildIDNumber(1), "") } // TestDeleteVersion_ServerDeleteMaxVersionsReached tests that when the internal limit for the number of versions @@ -1867,22 +1787,20 @@ func (s *WorkerDeploymentSuite) TestDeleteVersion_ServerDeleteMaxVersionsReached testcore.WithDynamicConfig(dynamicconfig.MatchingMaxVersionsInDeployment, 1), ) - ctx := s.Context() - tv := s.tv().WithBuildIDNumber(1) tv2 := s.tv().WithBuildIDNumber(2) // start and stop polling so that version is eligible for deletion - pollerCtx, pollerCancel := context.WithCancel(ctx) - go s.pollFromDeployment(pollerCtx, env, tv) - s.ensureCreateVersionInDeployment(env, tv) + pollerCtx, pollerCancel := context.WithCancel(s.Context()) + go s.pollFromDeployment(pollerCtx, env, s.tv().WithBuildIDNumber(1)) + s.ensureCreateVersionInDeployment(env, s.tv().WithBuildIDNumber(1)) pollerCancel() // Set a different manager identity so that we can verify that the internal delete operation does not conduct the manager identity check // while deleting the version - s.setAndValidateManagerIdentity(env, tv, false, false, "other", "") + s.setAndValidateManagerIdentity(env, s.tv().WithBuildIDNumber(1), false, false, "other", "") // Start another poller which shall aim to create a new version. This should, in turn, delete the first version. - pollerCtx2, pollerCancel2 := context.WithCancel(ctx) + pollerCtx2, pollerCancel2 := context.WithCancel(s.Context()) go s.pollFromDeployment(pollerCtx2, env, tv2) s.ensureCreateVersionInDeployment(env, tv2) pollerCancel2() @@ -1890,16 +1808,16 @@ func (s *WorkerDeploymentSuite) TestDeleteVersion_ServerDeleteMaxVersionsReached // Verify that the worker deployment only has one version in it's version summaries. s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv.DeploymentSeries(), + DeploymentName: s.tv().WithBuildIDNumber(1).DeploymentSeries(), }) a.NoError(err) a.Len(resp.GetWorkerDeploymentInfo().GetVersionSummaries(), 1) a.Equal(tv2.ExternalDeploymentVersion().GetBuildId(), resp.GetWorkerDeploymentInfo().GetVersionSummaries()[0].GetDeploymentVersion().GetBuildId()) // Also verify that the last modifier identity is not set to the identity of the worker-deployment workflow. - a.NotEqual(tv.ClientIdentity(), resp.GetWorkerDeploymentInfo().GetLastModifierIdentity()) + a.NotEqual(s.tv().WithBuildIDNumber(1).ClientIdentity(), resp.GetWorkerDeploymentInfo().GetLastModifierIdentity()) }, time.Second*5, time.Millisecond*200) } @@ -1907,11 +1825,10 @@ func (s *WorkerDeploymentSuite) TestDeleteVersion_ServerDeleteMaxVersionsReached func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Unversioned_NoRamp() { env := s.newTestEnv() - ctx := s.Context() currentVars := s.tv().WithBuildIDNumber(1) versionCreateTime := timestamppb.Now() - go s.pollFromDeployment(ctx, env, currentVars) + go s.pollFromDeployment(s.Context(), env, currentVars) s.ensureCreateVersionInDeployment(env, currentVars) // check that the current version's task queues have current version unversioned to start @@ -1928,7 +1845,7 @@ func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Unversioned_NoRamp() { s.verifyTaskQueueVersioningInfo(env, currentVars.TaskQueue(), worker_versioning.UnversionedVersionId, "", 0) // check that deployment has current version == __unversioned__ - resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), DeploymentName: currentVars.DeploymentSeries(), }) @@ -1964,22 +1881,20 @@ func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Unversioned_NoRamp() { func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Unversioned_PromoteUnversionedRamp() { env := s.newTestEnv() - ctx := s.Context() - tv := s.tv() - currentVars := tv.WithBuildIDNumber(1) + currentVars := s.tv().WithBuildIDNumber(1) - go s.pollFromDeployment(ctx, env, currentVars) + go s.pollFromDeployment(s.Context(), env, currentVars) s.ensureCreateVersionInDeployment(env, currentVars) // make the current version versioned, so that we can set ramp to unversioned s.setCurrentVersion(env, currentVars, true, "") // set ramp to unversioned - s.setAndVerifyRampingVersionUnversionedOption(env, tv, true, false, 75, true, false, true, "") + s.setAndVerifyRampingVersionUnversionedOption(env, s.tv(), true, false, 75, true, false, true, "") // check that the current version's task queues have ramping version == __unversioned__ s.verifyTaskQueueVersioningInfo(env, currentVars.TaskQueue(), currentVars.DeploymentVersionString(), worker_versioning.UnversionedVersionId, 75) // set current to unversioned - s.setCurrentVersionUnversionedOption(env, tv, true, true, false, true, "") + s.setCurrentVersionUnversionedOption(env, s.tv(), true, true, false, true, "") // check that the current version's task queues have ramping version == "" and current version == "__unversioned__" s.verifyTaskQueueVersioningInfo(env, currentVars.TaskQueue(), worker_versioning.UnversionedVersionId, "", 0) @@ -1988,25 +1903,22 @@ func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Unversioned_PromoteUnversi func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Concurrent_DifferentVersions_NoUnexpectedErrors() { env := s.newTestEnv(testcore.WithDynamicConfig(dynamicconfig.WorkflowExecutionMaxInFlightUpdates, 10)) // this is the default - ctx := s.Context() - - tv := s.tv() errChan := make(chan error) versions := 10 for i := range versions { - s.startVersionWorkflow(ctx, env, tv.WithBuildIDNumber(i)) + s.startVersionWorkflow(s.Context(), env, s.tv().WithBuildIDNumber(i)) } // Concurrently set 10 different versions as current version for i := range versions { go func() { - _, err := env.FrontendClient().SetWorkerDeploymentCurrentVersion(ctx, &workflowservice.SetWorkerDeploymentCurrentVersionRequest{ + _, err := env.FrontendClient().SetWorkerDeploymentCurrentVersion(s.Context(), &workflowservice.SetWorkerDeploymentCurrentVersionRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv.DeploymentVersion().GetDeploymentName(), - Version: tv.WithBuildIDNumber(i).DeploymentVersionString(), + DeploymentName: s.tv().DeploymentVersion().GetDeploymentName(), + Version: s.tv().WithBuildIDNumber(i).DeploymentVersionString(), IgnoreMissingTaskQueues: true, - Identity: tv.ClientIdentity(), + Identity: s.tv().ClientIdentity(), }) errChan <- err }() @@ -2027,9 +1939,9 @@ func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Concurrent_DifferentVersio } // Verify that the current version is set. - resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv.DeploymentVersion().GetDeploymentName(), + DeploymentName: s.tv().DeploymentVersion().GetDeploymentName(), }) s.NoError(err) s.NotEqual(worker_versioning.UnversionedVersionId, resp.GetWorkerDeploymentInfo().GetRoutingConfig().GetCurrentVersion()) @@ -2038,22 +1950,19 @@ func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Concurrent_DifferentVersio func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Concurrent_SameVersion_NoUnexpectedErrors() { env := s.newTestEnv(testcore.WithDynamicConfig(dynamicconfig.WorkflowExecutionMaxInFlightUpdates, 10)) // this is the default - ctx := s.Context() - - tv := s.tv() errChan := make(chan error) - s.startVersionWorkflow(ctx, env, tv) // create version + s.startVersionWorkflow(s.Context(), env, s.tv()) // create version // Concurrently set the same version as current version 10 times. for range 10 { go func() { - _, err := env.FrontendClient().SetWorkerDeploymentCurrentVersion(ctx, &workflowservice.SetWorkerDeploymentCurrentVersionRequest{ + _, err := env.FrontendClient().SetWorkerDeploymentCurrentVersion(s.Context(), &workflowservice.SetWorkerDeploymentCurrentVersionRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv.DeploymentVersion().GetDeploymentName(), - Version: tv.DeploymentVersionString(), + DeploymentName: s.tv().DeploymentVersion().GetDeploymentName(), + Version: s.tv().DeploymentVersionString(), IgnoreMissingTaskQueues: true, - Identity: tv.ClientIdentity(), + Identity: s.tv().ClientIdentity(), }) errChan <- err }() @@ -2074,12 +1983,12 @@ func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Concurrent_SameVersion_NoU } // Verify that the current version is set. - resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv.DeploymentVersion().GetDeploymentName(), + DeploymentName: s.tv().DeploymentVersion().GetDeploymentName(), }) s.NoError(err) - s.Equal(tv.DeploymentVersionString(), resp.GetWorkerDeploymentInfo().GetRoutingConfig().GetCurrentVersion()) + s.Equal(s.tv().DeploymentVersionString(), resp.GetWorkerDeploymentInfo().GetRoutingConfig().GetCurrentVersion()) //nolint:staticcheck // SA1019: old worker versioning } // TestConcurrentPollers_DifferentTaskQueues_SameVersion_SetCurrentVersion aims to test that when there are multiple pollers polling on different task queues, @@ -2087,22 +1996,19 @@ func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Concurrent_SameVersion_NoU func (s *WorkerDeploymentSuite) TestConcurrentPollers_DifferentTaskQueues_SameVersion_SetCurrentVersion() { env := s.newTestEnv() - ctx := s.Context() - // start 10 different pollers each polling on a different task queue but belonging to the same version - tv := s.tv() tqs := 10 // Start all pollers concurrently (pollFromDeployment has no assertions, so it's safe to call from goroutines) for i := range tqs { - go s.pollFromDeployment(ctx, env, tv.WithTaskQueueNumber(i)) + go s.pollFromDeployment(s.Context(), env, s.tv().WithTaskQueueNumber(i)) } // Wait for all version workflows to appear (must run in the test goroutine due to assertions) for i := range tqs { - tvI := tv.WithTaskQueueNumber(i) + tvI := s.tv().WithTaskQueueNumber(i) s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err := env.FrontendClient().DescribeWorkerDeploymentVersion(ctx, &workflowservice.DescribeWorkerDeploymentVersionRequest{ + resp, err := env.FrontendClient().DescribeWorkerDeploymentVersion(s.Context(), &workflowservice.DescribeWorkerDeploymentVersionRequest{ Namespace: env.Namespace().String(), Version: tvI.DeploymentVersionString(), }) @@ -2112,36 +2018,33 @@ func (s *WorkerDeploymentSuite) TestConcurrentPollers_DifferentTaskQueues_SameVe } // set this version as current version - s.setCurrentVersion(env, tv, false, "") + s.setCurrentVersion(env, s.tv(), false, "") // verify that the task queues, eventually, have this version as the current version in their versioning info for i := range tqs { - s.verifyTaskQueueVersioningInfo(env, tv.WithTaskQueueNumber(i).TaskQueue(), tv.DeploymentVersionString(), "", 0) + s.verifyTaskQueueVersioningInfo(env, s.tv().WithTaskQueueNumber(i).TaskQueue(), s.tv().DeploymentVersionString(), "", 0) } } func (s *WorkerDeploymentSuite) TestSetRampingVersion_Concurrent_DifferentVersions_NoUnexpectedErrors() { env := s.newTestEnv(testcore.WithDynamicConfig(dynamicconfig.WorkflowExecutionMaxInFlightUpdates, 10)) // this is the default - ctx := s.Context() - - tv := s.tv() errChan := make(chan error) versions := 10 for i := range versions { - s.startVersionWorkflow(ctx, env, tv.WithBuildIDNumber(i)) + s.startVersionWorkflow(s.Context(), env, s.tv().WithBuildIDNumber(i)) } // Concurrently set 10 different versions as ramping version for i := range versions { go func() { - _, err := env.FrontendClient().SetWorkerDeploymentRampingVersion(ctx, &workflowservice.SetWorkerDeploymentRampingVersionRequest{ + _, err := env.FrontendClient().SetWorkerDeploymentRampingVersion(s.Context(), &workflowservice.SetWorkerDeploymentRampingVersionRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv.DeploymentVersion().GetDeploymentName(), - Version: tv.WithBuildIDNumber(i).DeploymentVersionString(), + DeploymentName: s.tv().DeploymentVersion().GetDeploymentName(), + Version: s.tv().WithBuildIDNumber(i).DeploymentVersionString(), IgnoreMissingTaskQueues: true, - Identity: tv.ClientIdentity(), + Identity: s.tv().ClientIdentity(), Percentage: 50, }) errChan <- err @@ -2163,9 +2066,9 @@ func (s *WorkerDeploymentSuite) TestSetRampingVersion_Concurrent_DifferentVersio } // Verify that the ramping version is set. - resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv.DeploymentVersion().GetDeploymentName(), + DeploymentName: s.tv().DeploymentVersion().GetDeploymentName(), }) s.NoError(err) s.NotNil(resp.GetWorkerDeploymentInfo().GetRoutingConfig().GetRampingVersion()) @@ -2174,22 +2077,19 @@ func (s *WorkerDeploymentSuite) TestSetRampingVersion_Concurrent_DifferentVersio func (s *WorkerDeploymentSuite) TestSetRampingVersion_Concurrent_SameVersion_NoUnexpectedErrors() { env := s.newTestEnv(testcore.WithDynamicConfig(dynamicconfig.WorkflowExecutionMaxInFlightUpdates, 10)) // this is the default - ctx := s.Context() - - tv := s.tv() errChan := make(chan error) - s.startVersionWorkflow(ctx, env, tv) // create version + s.startVersionWorkflow(s.Context(), env, s.tv()) // create version // Concurrently set the same version as ramping version 10 times. for range 10 { go func() { - _, err := env.FrontendClient().SetWorkerDeploymentRampingVersion(ctx, &workflowservice.SetWorkerDeploymentRampingVersionRequest{ + _, err := env.FrontendClient().SetWorkerDeploymentRampingVersion(s.Context(), &workflowservice.SetWorkerDeploymentRampingVersionRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv.DeploymentVersion().GetDeploymentName(), - Version: tv.DeploymentVersionString(), + DeploymentName: s.tv().DeploymentVersion().GetDeploymentName(), + Version: s.tv().DeploymentVersionString(), IgnoreMissingTaskQueues: true, - Identity: tv.ClientIdentity(), + Identity: s.tv().ClientIdentity(), Percentage: 50, }) errChan <- err @@ -2211,12 +2111,12 @@ func (s *WorkerDeploymentSuite) TestSetRampingVersion_Concurrent_SameVersion_NoU } // Verify that the ramping version is set. - resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv.DeploymentVersion().GetDeploymentName(), + DeploymentName: s.tv().DeploymentVersion().GetDeploymentName(), }) s.NoError(err) - s.Equal(tv.DeploymentVersionString(), resp.GetWorkerDeploymentInfo().GetRoutingConfig().GetRampingVersion()) + s.Equal(s.tv().DeploymentVersionString(), resp.GetWorkerDeploymentInfo().GetRoutingConfig().GetRampingVersion()) //nolint:staticcheck // SA1019: old worker versioning } // TODO: this test reliably produces a rare error seemingly about speculative tasks. use it for debugging the error @@ -2244,8 +2144,7 @@ func (s *WorkerDeploymentSuite) TestConcurrentPollers_ManyTaskQueues_RapidRoutin // Need to increase max pending activities because it is set only to 10 for functional tests. it's 2000 by default. env.OverrideDynamicConfig(dynamicconfig.NumPendingActivitiesLimitError, numOperations) - tv := s.tv() - dn := tv.DeploymentVersion().GetDeploymentName() + dn := s.tv().DeploymentVersion().GetDeploymentName() start := time.Now() // For each version send pollers regularly until all TQs are registered from DescribeVersion POV @@ -2254,7 +2153,7 @@ func (s *WorkerDeploymentSuite) TestConcurrentPollers_ManyTaskQueues_RapidRoutin sendPollers := func() { for j := range numTaskQueues { - go s.pollFromDeployment(pollCtx, env, tv.WithBuildIDNumber(i).WithTaskQueueNumber(j)) + go s.pollFromDeployment(pollCtx, env, s.tv().WithBuildIDNumber(i).WithTaskQueueNumber(j)) } } @@ -2293,7 +2192,7 @@ func (s *WorkerDeploymentSuite) TestConcurrentPollers_ManyTaskQueues_RapidRoutin a := require.New(t) resp, err := env.FrontendClient().DescribeWorkerDeploymentVersion(pollCtx, &workflowservice.DescribeWorkerDeploymentVersionRequest{ Namespace: env.Namespace().String(), - DeploymentVersion: tv.WithBuildIDNumber(i).ExternalDeploymentVersion(), + DeploymentVersion: s.tv().WithBuildIDNumber(i).ExternalDeploymentVersion(), }) a.NoError(err) a.Len(resp.GetVersionTaskQueues(), numTaskQueues) @@ -2305,32 +2204,30 @@ func (s *WorkerDeploymentSuite) TestConcurrentPollers_ManyTaskQueues_RapidRoutin fmt.Printf(">>> Time taken registration for version %d: %v\n", i, time.Since(start)) } - ctx := s.Context() - // Rapidly perform 20 setCurrent and setRamping operations, each targeting one of the 3 versions for i := range numOperations { // Alternate between setCurrent and setRamping targetVersion := i % numVersions - versionTV := tv.WithBuildIDNumber(targetVersion) + versionTV := s.tv().WithBuildIDNumber(targetVersion) for { var err error if i%2 == 0 { // setCurrent operation - _, err = env.FrontendClient().SetWorkerDeploymentCurrentVersion(ctx, &workflowservice.SetWorkerDeploymentCurrentVersionRequest{ + _, err = env.FrontendClient().SetWorkerDeploymentCurrentVersion(s.Context(), &workflowservice.SetWorkerDeploymentCurrentVersionRequest{ Namespace: env.Namespace().String(), DeploymentName: dn, BuildId: versionTV.DeploymentVersion().GetBuildId(), IgnoreMissingTaskQueues: true, - Identity: tv.ClientIdentity(), + Identity: s.tv().ClientIdentity(), }) } else { // setRamping operation - _, err = env.FrontendClient().SetWorkerDeploymentRampingVersion(ctx, &workflowservice.SetWorkerDeploymentRampingVersionRequest{ + _, err = env.FrontendClient().SetWorkerDeploymentRampingVersion(s.Context(), &workflowservice.SetWorkerDeploymentRampingVersionRequest{ Namespace: env.Namespace().String(), DeploymentName: dn, BuildId: versionTV.DeploymentVersion().GetBuildId(), IgnoreMissingTaskQueues: true, - Identity: tv.ClientIdentity(), + Identity: s.tv().ClientIdentity(), Percentage: float32(50 + (i % 50)), }) } @@ -2351,7 +2248,7 @@ func (s *WorkerDeploymentSuite) TestConcurrentPollers_ManyTaskQueues_RapidRoutin var latestRoutingConfig *deploymentpb.RoutingConfig s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), DeploymentName: dn, }) @@ -2367,8 +2264,8 @@ func (s *WorkerDeploymentSuite) TestConcurrentPollers_ManyTaskQueues_RapidRoutin // Note: The public API doesn't expose revision numbers at the task queue level, so we verify that the // versioning info has been propagated correctly by checking the current/ramping versions for j := range numTaskQueues { - tqTV := tv.WithTaskQueueNumber(j) - tqUD, err := env.GetTestCluster().MatchingClient().GetTaskQueueUserData(ctx, &matchingservice.GetTaskQueueUserDataRequest{ + tqTV := s.tv().WithTaskQueueNumber(j) + tqUD, err := env.GetTestCluster().MatchingClient().GetTaskQueueUserData(s.Context(), &matchingservice.GetTaskQueueUserDataRequest{ NamespaceId: env.NamespaceID().String(), TaskQueueType: tqTypeWf, TaskQueue: tqTV.TaskQueue().GetName(), @@ -2383,38 +2280,35 @@ func (s *WorkerDeploymentSuite) TestConcurrentPollers_ManyTaskQueues_RapidRoutin func (s *WorkerDeploymentSuite) TestResourceExhaustedErrors_Converted_To_ReadableMessage() { env := s.newTestEnv(testcore.WithDynamicConfig(dynamicconfig.WorkflowExecutionMaxInFlightUpdates, 2)) // Lowering the limit to encounter ResourceExhausted errors - ctx := s.Context() - - tv := s.tv() versions := 5 errChan := make(chan error, versions) // Start all version workflows first for i := range versions { - s.startVersionWorkflow(ctx, env, tv.WithBuildIDNumber(i)) + s.startVersionWorkflow(s.Context(), env, s.tv().WithBuildIDNumber(i)) } // Test SetRampingVersion - s.testConcurrentRequestsResourceExhausted(ctx, tv, versions, errChan, "SetWorkerDeploymentRampingVersion", func(i int) error { - _, err := env.FrontendClient().SetWorkerDeploymentRampingVersion(ctx, &workflowservice.SetWorkerDeploymentRampingVersionRequest{ + s.testConcurrentRequestsResourceExhausted(s.Context(), s.tv(), versions, errChan, "SetWorkerDeploymentRampingVersion", func(i int) error { + _, err := env.FrontendClient().SetWorkerDeploymentRampingVersion(s.Context(), &workflowservice.SetWorkerDeploymentRampingVersionRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv.DeploymentVersion().GetDeploymentName(), - Version: tv.WithBuildIDNumber(i).DeploymentVersionString(), + DeploymentName: s.tv().DeploymentVersion().GetDeploymentName(), + Version: s.tv().WithBuildIDNumber(i).DeploymentVersionString(), IgnoreMissingTaskQueues: true, - Identity: tv.ClientIdentity(), + Identity: s.tv().ClientIdentity(), Percentage: 50, }) return err }) // Test SetCurrentVersion - s.testConcurrentRequestsResourceExhausted(ctx, tv, versions, errChan, "SetWorkerDeploymentCurrentVersion", func(i int) error { - _, err := env.FrontendClient().SetWorkerDeploymentCurrentVersion(ctx, &workflowservice.SetWorkerDeploymentCurrentVersionRequest{ + s.testConcurrentRequestsResourceExhausted(s.Context(), s.tv(), versions, errChan, "SetWorkerDeploymentCurrentVersion", func(i int) error { + _, err := env.FrontendClient().SetWorkerDeploymentCurrentVersion(s.Context(), &workflowservice.SetWorkerDeploymentCurrentVersionRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv.DeploymentVersion().GetDeploymentName(), - Version: tv.WithBuildIDNumber(i).DeploymentVersionString(), + DeploymentName: s.tv().DeploymentVersion().GetDeploymentName(), + Version: s.tv().WithBuildIDNumber(i).DeploymentVersionString(), IgnoreMissingTaskQueues: true, - Identity: tv.ClientIdentity(), + Identity: s.tv().ClientIdentity(), }) return err }) @@ -2424,10 +2318,10 @@ func (s *WorkerDeploymentSuite) TestResourceExhaustedErrors_Converted_To_Readabl "key1": {Data: testRandomMetadataValue}, "key2": {Data: testRandomMetadataValue}, } - s.testConcurrentRequestsResourceExhausted(ctx, tv, versions, errChan, "UpdateWorkerDeploymentVersionMetadata", func(i int) error { - _, err := env.FrontendClient().UpdateWorkerDeploymentVersionMetadata(ctx, &workflowservice.UpdateWorkerDeploymentVersionMetadataRequest{ + s.testConcurrentRequestsResourceExhausted(s.Context(), s.tv(), versions, errChan, "UpdateWorkerDeploymentVersionMetadata", func(i int) error { + _, err := env.FrontendClient().UpdateWorkerDeploymentVersionMetadata(s.Context(), &workflowservice.UpdateWorkerDeploymentVersionMetadataRequest{ Namespace: env.Namespace().String(), - Version: tv.WithBuildIDNumber(i).DeploymentVersionString(), + Version: s.tv().WithBuildIDNumber(i).DeploymentVersionString(), UpsertEntries: metadata, }) return err @@ -2468,10 +2362,8 @@ func (s *WorkerDeploymentSuite) testConcurrentRequestsResourceExhausted( func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Unversioned_UnversionedCurrent() { env := s.newTestEnv() - ctx := s.Context() - tv := s.tv() - rampingVars := tv.WithBuildIDNumber(1) - s.startVersionWorkflow(ctx, env, rampingVars) + rampingVars := s.tv().WithBuildIDNumber(1) + s.startVersionWorkflow(s.Context(), env, rampingVars) s.setAndVerifyRampingVersionUnversionedOption(env, rampingVars, true, false, 50, true, false, true, "ramping version __unversioned__ is already current") } @@ -2479,11 +2371,9 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Unversione func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Unversioned_VersionedCurrent() { env := s.newTestEnv() - ctx := s.Context() - tv := s.tv() - currentVars := tv.WithBuildIDNumber(1) + currentVars := s.tv().WithBuildIDNumber(1) - go s.pollFromDeployment(ctx, env, currentVars) + go s.pollFromDeployment(s.Context(), env, currentVars) s.ensureCreateVersionInDeployment(env, currentVars) // check that the current version's task queues have ramping version == "" @@ -2491,12 +2381,12 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Unversione s.verifyTaskQueueVersioningInfo(env, currentVars.TaskQueue(), currentVars.DeploymentVersionString(), "", 0) // set ramp to unversioned - s.setAndVerifyRampingVersionUnversionedOption(env, tv, true, false, 75, true, false, true, "") + s.setAndVerifyRampingVersionUnversionedOption(env, s.tv(), true, false, 75, true, false, true, "") // check that deployment has ramping version == __unversioned__ - resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv.DeploymentSeries(), + DeploymentName: s.tv().DeploymentSeries(), }) s.NoError(err) s.Equal(worker_versioning.UnversionedVersionId, resp.GetWorkerDeploymentInfo().GetRoutingConfig().GetRampingVersion()) @@ -2508,41 +2398,38 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Unversione func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentCurrentVersion_NoPollers() { env := s.newTestEnv() - ctx := s.Context() - tv := s.tv().WithBuildIDNumber(1) - // try to set current with allowNoPollers=false --> error allowNoPollers := false - expectedErr := fmt.Sprintf(workerdeployment.ErrWorkerDeploymentNotFound, tv.DeploymentVersion().GetDeploymentName()) - s.setCurrentVersionAllowNoPollersOption(env, tv, true, allowNoPollers, false, expectedErr) + expectedErr := fmt.Sprintf(workerdeployment.ErrWorkerDeploymentNotFound, s.tv().WithBuildIDNumber(1).DeploymentVersion().GetDeploymentName()) + s.setCurrentVersionAllowNoPollersOption(env, s.tv().WithBuildIDNumber(1), true, allowNoPollers, false, expectedErr) // try to set current with allowNoPollers=true --> success allowNoPollers = true expectedErr = "" versionCreateTime := timestamppb.Now() - s.setCurrentVersionAllowNoPollersOption(env, tv, true, allowNoPollers, false, expectedErr) + s.setCurrentVersionAllowNoPollersOption(env, s.tv().WithBuildIDNumber(1), true, allowNoPollers, false, expectedErr) // let a poller arrive with that version --> triggers user data propagation - go s.pollFromDeployment(ctx, env, tv) + go s.pollFromDeployment(s.Context(), env, s.tv().WithBuildIDNumber(1)) s.EventuallyWithT(func(t *assert.CollectT) { // check describe worker deployment - resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv.DeploymentSeries(), + DeploymentName: s.tv().WithBuildIDNumber(1).DeploymentSeries(), }) a := require.New(t) a.NoError(err) s.verifyWorkerDeploymentInfo(a, &deploymentpb.WorkerDeploymentInfo{ - Name: tv.DeploymentSeries(), + Name: s.tv().WithBuildIDNumber(1).DeploymentSeries(), CreateTime: versionCreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ - CurrentVersion: tv.DeploymentVersionString(), + CurrentVersion: s.tv().WithBuildIDNumber(1).DeploymentVersionString(), CurrentVersionChangedTime: versionCreateTime, }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ { - Version: tv.DeploymentVersionString(), + Version: s.tv().WithBuildIDNumber(1).DeploymentVersionString(), CreateTime: versionCreateTime, DrainageInfo: nil, RoutingUpdateTime: versionCreateTime, @@ -2554,47 +2441,44 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentCurrentVersion_NoPollers( Status: enumspb.WORKER_DEPLOYMENT_VERSION_STATUS_CURRENT, }, }, - LastModifierIdentity: tv.ClientIdentity(), + LastModifierIdentity: s.tv().WithBuildIDNumber(1).ClientIdentity(), }, resp.GetWorkerDeploymentInfo()) }, 10*time.Second, 100*time.Millisecond) // that poller's task queue should have the current versioning info - s.verifyTaskQueueVersioningInfo(env, tv.TaskQueue(), tv.DeploymentVersionString(), "", 0) + s.verifyTaskQueueVersioningInfo(env, s.tv().WithBuildIDNumber(1).TaskQueue(), s.tv().WithBuildIDNumber(1).DeploymentVersionString(), "", 0) } func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_NoPollers() { env := s.newTestEnv() - ctx := s.Context() - tv := s.tv().WithBuildIDNumber(1) - // try to set ramping with allowNoPollers=false --> error allowNoPollers := false - expectedErr := fmt.Sprintf(workerdeployment.ErrWorkerDeploymentNotFound, tv.DeploymentVersion().GetDeploymentName()) - s.setAndVerifyRampingVersionUnversionedOption(env, tv, false, false, 5, true, allowNoPollers, false, expectedErr) + expectedErr := fmt.Sprintf(workerdeployment.ErrWorkerDeploymentNotFound, s.tv().WithBuildIDNumber(1).DeploymentVersion().GetDeploymentName()) + s.setAndVerifyRampingVersionUnversionedOption(env, s.tv().WithBuildIDNumber(1), false, false, 5, true, allowNoPollers, false, expectedErr) // try to set ramping with allowNoPollers=true --> success allowNoPollers = true expectedErr = "" versionCreateTime := timestamppb.Now() - s.setAndVerifyRampingVersionUnversionedOption(env, tv, false, false, 5, true, allowNoPollers, false, expectedErr) + s.setAndVerifyRampingVersionUnversionedOption(env, s.tv().WithBuildIDNumber(1), false, false, 5, true, allowNoPollers, false, expectedErr) // let a poller arrive with that version --> triggers user data propagation - go s.pollFromDeployment(ctx, env, tv) + go s.pollFromDeployment(s.Context(), env, s.tv().WithBuildIDNumber(1)) s.EventuallyWithT(func(t *assert.CollectT) { // check describe worker deployment - resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv.DeploymentSeries(), + DeploymentName: s.tv().WithBuildIDNumber(1).DeploymentSeries(), }) a := require.New(t) a.NoError(err) s.verifyWorkerDeploymentInfo(a, &deploymentpb.WorkerDeploymentInfo{ - Name: tv.DeploymentSeries(), + Name: s.tv().WithBuildIDNumber(1).DeploymentSeries(), CreateTime: versionCreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ - RampingVersion: tv.DeploymentVersionString(), + RampingVersion: s.tv().WithBuildIDNumber(1).DeploymentVersionString(), RampingVersionPercentage: 5, RampingVersionChangedTime: versionCreateTime, RampingVersionPercentageChangedTime: versionCreateTime, @@ -2603,7 +2487,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_NoPollers( }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ { - Version: tv.DeploymentVersionString(), + Version: s.tv().WithBuildIDNumber(1).DeploymentVersionString(), CreateTime: versionCreateTime, DrainageInfo: nil, RoutingUpdateTime: versionCreateTime, @@ -2614,24 +2498,22 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_NoPollers( Status: enumspb.WORKER_DEPLOYMENT_VERSION_STATUS_RAMPING, }, }, - LastModifierIdentity: tv.ClientIdentity(), + LastModifierIdentity: s.tv().WithBuildIDNumber(1).ClientIdentity(), }, resp.GetWorkerDeploymentInfo()) }, 10*time.Second, 100*time.Millisecond) // that poller's task queue should have the ramping version info - s.verifyTaskQueueVersioningInfo(env, tv.TaskQueue(), worker_versioning.UnversionedVersionId, tv.DeploymentVersionString(), 5) + s.verifyTaskQueueVersioningInfo(env, s.tv().WithBuildIDNumber(1).TaskQueue(), worker_versioning.UnversionedVersionId, s.tv().WithBuildIDNumber(1).DeploymentVersionString(), 5) } func (s *WorkerDeploymentSuite) TestTwoPollers_EnsureCreateVersion() { env := s.newTestEnv() - ctx := s.Context() - tv := s.tv() - tv1 := tv.WithBuildIDNumber(1) - tv2 := tv.WithBuildIDNumber(2) + tv1 := s.tv().WithBuildIDNumber(1) + tv2 := s.tv().WithBuildIDNumber(2) - go s.pollFromDeployment(ctx, env, tv1) - go s.pollFromDeployment(ctx, env, tv2) + go s.pollFromDeployment(s.Context(), env, tv1) + go s.pollFromDeployment(s.Context(), env, tv2) s.ensureCreateVersionWithExpectedTaskQueues(env, tv1, 1) s.ensureCreateVersionWithExpectedTaskQueues(env, tv2, 1) } @@ -2660,19 +2542,18 @@ func (s *WorkerDeploymentSuite) verifyTaskQueueVersioningInfo(env *testcore.Test func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { env := s.newTestEnv(testcore.WithDynamicConfig(dynamicconfig.PollerHistoryTTL, 500*time.Millisecond)) - ctx := s.Context() tv1 := s.tv().WithBuildIDNumber(1) tv2 := s.tv().WithBuildIDNumber(2) tv3 := s.tv().WithBuildIDNumber(3) // Start deployment workflow 1 and wait for the deployment version to exist v1CreateTime := timestamppb.New(time.Now()) - s.startVersionWorkflow(ctx, env, tv1) + s.startVersionWorkflow(s.Context(), env, tv1) // Set v1 as current version setCurrentV1UpdateTime := timestamppb.Now() s.setCurrentVersion(env, tv1, true, "") - resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), DeploymentName: tv1.DeploymentSeries(), }) @@ -2705,11 +2586,11 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { // Start deployment workflow 2 and set v2 to current so that v1 can start draining v2CreateTime := timestamppb.New(time.Now()) - s.startVersionWorkflow(ctx, env, tv2) + s.startVersionWorkflow(s.Context(), env, tv2) setCurrentV2UpdateTime := timestamppb.New(time.Now()) s.setCurrentVersion(env, tv2, true, "") - resp, err = env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + resp, err = env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), DeploymentName: tv2.DeploymentSeries(), }) @@ -2760,7 +2641,7 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { // wait for v1 to be drained s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err := env.FrontendClient().DescribeWorkerDeploymentVersion(ctx, &workflowservice.DescribeWorkerDeploymentVersionRequest{ + resp, err := env.FrontendClient().DescribeWorkerDeploymentVersion(s.Context(), &workflowservice.DescribeWorkerDeploymentVersionRequest{ Namespace: env.Namespace().String(), Version: tv1.DeploymentVersionString(), }) @@ -2771,7 +2652,7 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { // Verify that the drainageStatus of v1 has been updated in the VersionSummaries s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err = env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + resp, err = env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), DeploymentName: tv2.DeploymentSeries(), }) @@ -2826,7 +2707,7 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { // verify if the right information is set in the DescribeWorkerDeployment response s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err = env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + resp, err = env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), DeploymentName: tv2.DeploymentSeries(), }) @@ -2881,7 +2762,7 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { // Verify that v2 is drained s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err := env.FrontendClient().DescribeWorkerDeploymentVersion(ctx, &workflowservice.DescribeWorkerDeploymentVersionRequest{ + resp, err := env.FrontendClient().DescribeWorkerDeploymentVersion(s.Context(), &workflowservice.DescribeWorkerDeploymentVersionRequest{ Namespace: env.Namespace().String(), Version: tv2.DeploymentVersionString(), }) @@ -2892,7 +2773,7 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { // verify if the right information is set in the DescribeWorkerDeployment response s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err = env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + resp, err = env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), DeploymentName: tv1.DeploymentSeries(), }) @@ -2942,7 +2823,7 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { // Roll out a new version v3 and set it to current v3CreateTime := timestamppb.Now() - s.startVersionWorkflow(ctx, env, tv3) + s.startVersionWorkflow(s.Context(), env, tv3) newCurrentV3UpdateTime := timestamppb.Now() s.setCurrentVersion(env, tv3, true, "") @@ -2950,7 +2831,7 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { // Verify that v1 is drained eventually s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err := env.FrontendClient().DescribeWorkerDeploymentVersion(ctx, &workflowservice.DescribeWorkerDeploymentVersionRequest{ + resp, err := env.FrontendClient().DescribeWorkerDeploymentVersion(s.Context(), &workflowservice.DescribeWorkerDeploymentVersionRequest{ Namespace: env.Namespace().String(), Version: tv1.DeploymentVersionString(), }) @@ -2962,7 +2843,7 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { // in the deployment workflow. s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err = env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + resp, err = env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), DeploymentName: tv1.DeploymentSeries(), }) @@ -3027,18 +2908,17 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { func (s *WorkerDeploymentSuite) TestSetRampingVersion_AfterDrained() { env := s.newTestEnv(testcore.WithDynamicConfig(dynamicconfig.PollerHistoryTTL, 500*time.Millisecond)) - ctx := s.Context() tv1 := s.tv().WithBuildIDNumber(1) tv2 := s.tv().WithBuildIDNumber(2) // Start deployment workflow 1 and wait for the deployment version to exist v1CreateTime := timestamppb.New(time.Now()) - s.startVersionWorkflow(ctx, env, tv1) + s.startVersionWorkflow(s.Context(), env, tv1) // Set v1 as current version setCurrentV1UpdateTime := timestamppb.Now() s.setCurrentVersion(env, tv1, true, "") - resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), DeploymentName: tv1.DeploymentSeries(), }) @@ -3071,11 +2951,11 @@ func (s *WorkerDeploymentSuite) TestSetRampingVersion_AfterDrained() { // Start deployment workflow 2 and set v2 to current so that v1 can start draining v2CreateTime := timestamppb.New(time.Now()) - s.startVersionWorkflow(ctx, env, tv2) + s.startVersionWorkflow(s.Context(), env, tv2) setCurrentV2UpdateTime := timestamppb.New(time.Now()) s.setCurrentVersion(env, tv2, true, "") - resp, err = env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + resp, err = env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), DeploymentName: tv2.DeploymentSeries(), }) @@ -3126,7 +3006,7 @@ func (s *WorkerDeploymentSuite) TestSetRampingVersion_AfterDrained() { // wait for v1 to be drained s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err := env.FrontendClient().DescribeWorkerDeploymentVersion(ctx, &workflowservice.DescribeWorkerDeploymentVersionRequest{ + resp, err := env.FrontendClient().DescribeWorkerDeploymentVersion(s.Context(), &workflowservice.DescribeWorkerDeploymentVersionRequest{ Namespace: env.Namespace().String(), Version: tv1.DeploymentVersionString(), }) @@ -3137,7 +3017,7 @@ func (s *WorkerDeploymentSuite) TestSetRampingVersion_AfterDrained() { // Verify that the drainageStatus of v1 has been updated in the VersionSummaries s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err = env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + resp, err = env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), DeploymentName: tv2.DeploymentSeries(), }) @@ -3192,7 +3072,7 @@ func (s *WorkerDeploymentSuite) TestSetRampingVersion_AfterDrained() { // verify if the right information is set in the DescribeWorkerDeployment response s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err = env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + resp, err = env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), DeploymentName: tv2.DeploymentSeries(), }) @@ -3244,12 +3124,11 @@ func (s *WorkerDeploymentSuite) TestSetRampingVersion_AfterDrained() { func (s *WorkerDeploymentSuite) TestDeleteWorkerDeployment_ValidDelete() { env := s.newTestEnv(testcore.WithDynamicConfig(dynamicconfig.PollerHistoryTTL, 500*time.Millisecond)) - ctx := s.Context() tv1 := s.tv().WithBuildIDNumber(1) // Start deployment workflow 1 and wait for the deployment version to exist // Use a cancellable context so we can stop the poller before checking pollers disappeared - pollerCtx, pollerCancel := context.WithCancel(ctx) + pollerCtx, pollerCancel := context.WithCancel(s.Context()) defer pollerCancel() s.startVersionWorkflow(pollerCtx, env, tv1) @@ -3284,7 +3163,7 @@ func (s *WorkerDeploymentSuite) TestDeleteWorkerDeployment_ValidDelete() { // Wait for pollers going away s.EventuallyWithT(func(t *assert.CollectT) { - resp, err := env.FrontendClient().DescribeTaskQueue(ctx, &workflowservice.DescribeTaskQueueRequest{ + resp, err := env.FrontendClient().DescribeTaskQueue(s.Context(), &workflowservice.DescribeTaskQueueRequest{ Namespace: env.Namespace().String(), TaskQueue: tv1.TaskQueue(), TaskQueueType: enumspb.TASK_QUEUE_TYPE_WORKFLOW, @@ -3299,7 +3178,7 @@ func (s *WorkerDeploymentSuite) TestDeleteWorkerDeployment_ValidDelete() { // deployment version does not exist in the deployment list s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), DeploymentName: tv1.DeploymentSeries(), }) @@ -3312,7 +3191,7 @@ func (s *WorkerDeploymentSuite) TestDeleteWorkerDeployment_ValidDelete() { }, time.Second*5, time.Millisecond*200) // Deleting the worker deployment should succeed since there are no associated versions left - _, err = env.FrontendClient().DeleteWorkerDeployment(ctx, &workflowservice.DeleteWorkerDeploymentRequest{ + _, err = env.FrontendClient().DeleteWorkerDeployment(s.Context(), &workflowservice.DeleteWorkerDeploymentRequest{ Namespace: env.Namespace().String(), DeploymentName: tv1.DeploymentSeries(), Identity: tv1.ClientIdentity(), @@ -3322,7 +3201,7 @@ func (s *WorkerDeploymentSuite) TestDeleteWorkerDeployment_ValidDelete() { // Describe Worker Deployment should give not found s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - _, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + _, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), DeploymentName: tv1.DeploymentSeries(), }) @@ -3334,7 +3213,7 @@ func (s *WorkerDeploymentSuite) TestDeleteWorkerDeployment_ValidDelete() { // ListDeployments should not show the closed/deleted Worker Deployment s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - listResp, err := env.FrontendClient().ListWorkerDeployments(ctx, &workflowservice.ListWorkerDeploymentsRequest{ + listResp, err := env.FrontendClient().ListWorkerDeployments(s.Context(), &workflowservice.ListWorkerDeploymentsRequest{ Namespace: env.Namespace().String(), }) a.NoError(err) @@ -3347,12 +3226,11 @@ func (s *WorkerDeploymentSuite) TestDeleteWorkerDeployment_ValidDelete() { func (s *WorkerDeploymentSuite) TestDeleteWorkerDeployment_Idempotent() { env := s.newTestEnv() - ctx := s.Context() tv1 := s.tv().WithBuildIDNumber(1) s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - _, err := env.FrontendClient().DeleteWorkerDeployment(ctx, &workflowservice.DeleteWorkerDeploymentRequest{ + _, err := env.FrontendClient().DeleteWorkerDeployment(s.Context(), &workflowservice.DeleteWorkerDeploymentRequest{ Namespace: env.Namespace().String(), DeploymentName: tv1.DeploymentSeries(), Identity: tv1.ClientIdentity(), @@ -3364,14 +3242,13 @@ func (s *WorkerDeploymentSuite) TestDeleteWorkerDeployment_Idempotent() { func (s *WorkerDeploymentSuite) TestDeleteWorkerDeployment_InvalidDelete() { env := s.newTestEnv() - ctx := s.Context() tv1 := s.tv().WithBuildIDNumber(1) // Start deployment workflow 1 and wait for the deployment version and deployment workflow to exist - go s.pollFromDeployment(ctx, env, tv1) + go s.pollFromDeployment(s.Context(), env, tv1) s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err := env.FrontendClient().DescribeWorkerDeploymentVersion(ctx, &workflowservice.DescribeWorkerDeploymentVersionRequest{ + resp, err := env.FrontendClient().DescribeWorkerDeploymentVersion(s.Context(), &workflowservice.DescribeWorkerDeploymentVersionRequest{ Namespace: env.Namespace().String(), Version: tv1.DeploymentVersionString(), }) @@ -3381,7 +3258,7 @@ func (s *WorkerDeploymentSuite) TestDeleteWorkerDeployment_InvalidDelete() { s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), DeploymentName: tv1.DeploymentSeries(), }) @@ -3393,7 +3270,7 @@ func (s *WorkerDeploymentSuite) TestDeleteWorkerDeployment_InvalidDelete() { }, time.Second*5, time.Millisecond*200) // Delete the worker deployment should fail since there are versions associated with it - _, err := env.FrontendClient().DeleteWorkerDeployment(ctx, &workflowservice.DeleteWorkerDeploymentRequest{ + _, err := env.FrontendClient().DeleteWorkerDeployment(s.Context(), &workflowservice.DeleteWorkerDeploymentRequest{ Namespace: env.Namespace().String(), DeploymentName: tv1.DeploymentSeries(), Identity: tv1.ClientIdentity(), @@ -3821,16 +3698,12 @@ func (s *WorkerDeploymentSuite) buildWorkerDeploymentSummary( func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_Success() { env := s.newTestEnv() - ctx := s.Context() - - tv := s.tv() - - deploymentName := tv.DeploymentSeries() - requestID := tv.Any().String() - identity := tv.Any().String() + deploymentName := s.tv().DeploymentSeries() + requestID := s.tv().Any().String() + identity := s.tv().Any().String() // Create a new worker deployment - resp, err := env.FrontendClient().CreateWorkerDeployment(ctx, &workflowservice.CreateWorkerDeploymentRequest{ + resp, err := env.FrontendClient().CreateWorkerDeployment(s.Context(), &workflowservice.CreateWorkerDeploymentRequest{ Namespace: env.Namespace().String(), DeploymentName: deploymentName, Identity: identity, @@ -3842,7 +3715,7 @@ func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_Success() { s.NotEmpty(resp.ConflictToken) // Verify the deployment was created - descResp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + descResp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), DeploymentName: deploymentName, }) @@ -3858,15 +3731,11 @@ func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_Success() { func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_Idempotent() { env := s.newTestEnv() - ctx := s.Context() - - tv := s.tv() - - deploymentName := tv.DeploymentSeries() - requestID := tv.Any().String() + deploymentName := s.tv().DeploymentSeries() + requestID := s.tv().Any().String() // Create a worker deployment - resp1, err := env.FrontendClient().CreateWorkerDeployment(ctx, &workflowservice.CreateWorkerDeploymentRequest{ + resp1, err := env.FrontendClient().CreateWorkerDeployment(s.Context(), &workflowservice.CreateWorkerDeploymentRequest{ Namespace: env.Namespace().String(), DeploymentName: deploymentName, RequestId: requestID, @@ -3876,7 +3745,7 @@ func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_Idempotent() { token1 := resp1.ConflictToken // Create the same deployment again with same request ID - should be idempotent - resp2, err := env.FrontendClient().CreateWorkerDeployment(ctx, &workflowservice.CreateWorkerDeploymentRequest{ + resp2, err := env.FrontendClient().CreateWorkerDeployment(s.Context(), &workflowservice.CreateWorkerDeploymentRequest{ Namespace: env.Namespace().String(), DeploymentName: deploymentName, RequestId: requestID, @@ -3889,16 +3758,12 @@ func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_Idempotent() { func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_AlreadyExists_DifferentRequestID() { env := s.newTestEnv() - ctx := s.Context() - - tv := s.tv() - - deploymentName := tv.DeploymentSeries() - requestID1 := tv.Any().String() - requestID2 := tv.Any().String() + deploymentName := s.tv().DeploymentSeries() + requestID1 := s.tv().Any().String() + requestID2 := s.tv().Any().String() // Create a worker deployment - _, err := env.FrontendClient().CreateWorkerDeployment(ctx, &workflowservice.CreateWorkerDeploymentRequest{ + _, err := env.FrontendClient().CreateWorkerDeployment(s.Context(), &workflowservice.CreateWorkerDeploymentRequest{ Namespace: env.Namespace().String(), DeploymentName: deploymentName, RequestId: requestID1, @@ -3906,7 +3771,7 @@ func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_AlreadyExists_Differe s.NoError(err) // Try to create the same deployment with different request ID - should fail - _, err = env.FrontendClient().CreateWorkerDeployment(ctx, &workflowservice.CreateWorkerDeploymentRequest{ + _, err = env.FrontendClient().CreateWorkerDeployment(s.Context(), &workflowservice.CreateWorkerDeploymentRequest{ Namespace: env.Namespace().String(), DeploymentName: deploymentName, RequestId: requestID2, @@ -3920,19 +3785,15 @@ func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_AlreadyExists_Differe func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_AutoCreatedByPoller_ConflictWithExplicitCreate() { env := s.newTestEnv() - ctx := s.Context() - - tv := s.tv() - // First, create deployment via polling - go s.pollFromDeployment(ctx, env, tv) - s.ensureCreateDeployment(env, tv) + go s.pollFromDeployment(s.Context(), env, s.tv()) + s.ensureCreateDeployment(env, s.tv()) // Try to explicitly create the same deployment - _, err := env.FrontendClient().CreateWorkerDeployment(ctx, &workflowservice.CreateWorkerDeploymentRequest{ + _, err := env.FrontendClient().CreateWorkerDeployment(s.Context(), &workflowservice.CreateWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv.DeploymentSeries(), - RequestId: tv.Any().String(), + DeploymentName: s.tv().DeploymentSeries(), + RequestId: s.tv().Any().String(), }) s.Error(err) var alreadyExists *serviceerror.AlreadyExists @@ -3992,23 +3853,19 @@ func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_MaxDeploymentsLimit() // Override the max deployments limit for this test env := s.newTestEnv(testcore.WithDynamicConfig(dynamicconfig.MatchingMaxDeployments, 2)) - ctx := s.Context() - - tv := s.tv() - // Create first deployment - _, err := env.FrontendClient().CreateWorkerDeployment(ctx, &workflowservice.CreateWorkerDeploymentRequest{ + _, err := env.FrontendClient().CreateWorkerDeployment(s.Context(), &workflowservice.CreateWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv.DeploymentSeries() + "_1", - RequestId: tv.Any().String(), + DeploymentName: s.tv().DeploymentSeries() + "_1", + RequestId: s.tv().Any().String(), }) s.NoError(err) // Create second deployment - _, err = env.FrontendClient().CreateWorkerDeployment(ctx, &workflowservice.CreateWorkerDeploymentRequest{ + _, err = env.FrontendClient().CreateWorkerDeployment(s.Context(), &workflowservice.CreateWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv.DeploymentSeries() + "_2", - RequestId: tv.Any().String(), + DeploymentName: s.tv().DeploymentSeries() + "_2", + RequestId: s.tv().Any().String(), }) s.NoError(err) @@ -4016,10 +3873,10 @@ func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_MaxDeploymentsLimit() s.validateWorkerDeploymentCount(env, &workflowservice.ListWorkerDeploymentsRequest{Namespace: env.Namespace().String()}, 2) // Try to create third deployment - should fail - _, err = env.FrontendClient().CreateWorkerDeployment(ctx, &workflowservice.CreateWorkerDeploymentRequest{ + _, err = env.FrontendClient().CreateWorkerDeployment(s.Context(), &workflowservice.CreateWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv.DeploymentSeries() + "_3", - RequestId: tv.Any().String(), + DeploymentName: s.tv().DeploymentSeries() + "_3", + RequestId: s.tv().Any().String(), }) s.Error(err) var resourceExhausted *serviceerror.ResourceExhausted @@ -4032,16 +3889,12 @@ func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_MaxDeploymentsLimit() func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_AfterDelete_CanRecreate() { env := s.newTestEnv() - ctx := s.Context() - - tv := s.tv() - - deploymentName := tv.DeploymentSeries() - requestID1 := tv.Any().String() - requestID2 := tv.Any().String() + deploymentName := s.tv().DeploymentSeries() + requestID1 := s.tv().Any().String() + requestID2 := s.tv().Any().String() // Create a worker deployment - resp1, err := env.FrontendClient().CreateWorkerDeployment(ctx, &workflowservice.CreateWorkerDeploymentRequest{ + resp1, err := env.FrontendClient().CreateWorkerDeployment(s.Context(), &workflowservice.CreateWorkerDeploymentRequest{ Namespace: env.Namespace().String(), DeploymentName: deploymentName, RequestId: requestID1, @@ -4050,7 +3903,7 @@ func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_AfterDelete_CanRecrea s.NotNil(resp1) // Delete the deployment - _, err = env.FrontendClient().DeleteWorkerDeployment(ctx, &workflowservice.DeleteWorkerDeploymentRequest{ + _, err = env.FrontendClient().DeleteWorkerDeployment(s.Context(), &workflowservice.DeleteWorkerDeploymentRequest{ Namespace: env.Namespace().String(), DeploymentName: deploymentName, Identity: "test", @@ -4058,7 +3911,7 @@ func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_AfterDelete_CanRecrea s.NoError(err) // Should be able to create a deployment with the same name again - resp2, err := env.FrontendClient().CreateWorkerDeployment(ctx, &workflowservice.CreateWorkerDeploymentRequest{ + resp2, err := env.FrontendClient().CreateWorkerDeployment(s.Context(), &workflowservice.CreateWorkerDeploymentRequest{ Namespace: env.Namespace().String(), DeploymentName: deploymentName, RequestId: requestID2, @@ -4068,7 +3921,7 @@ func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_AfterDelete_CanRecrea s.NotEqual(resp1.ConflictToken, resp2.ConflictToken) // Should be a new deployment with different token // Verify the deployment was created - descResp, err := env.FrontendClient().DescribeWorkerDeployment(ctx, &workflowservice.DescribeWorkerDeploymentRequest{ + descResp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), DeploymentName: deploymentName, }) @@ -4080,7 +3933,7 @@ func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_AfterDelete_CanRecrea s.Empty(descResp.WorkerDeploymentInfo.VersionSummaries) // No versions initially } -// tv returns test variables seeded from a shortened test name so that physical task queue IDs +// s.tv() returns test variables seeded from a shortened test name so that physical task queue IDs // do not grow larger than DB column limit (currently as low as 272 chars). func (s *WorkerDeploymentSuite) tv() *testvars.TestVars { return testvars.New(shortNamer{s.T()}) From 866727c9335be233048b8c41d6e02a6bdb1d7c54 Mon Sep 17 00:00:00 2001 From: Stephan Behnke Date: Sat, 6 Jun 2026 13:06:51 -0700 Subject: [PATCH 03/27] Remove shortNamer; use full test name in tv() Let CI verify physical task queue IDs stay within DB column limits. Co-Authored-By: Claude Opus 4.8 (1M context) --- tests/testcore/test_env.go | 14 ++ tests/worker_deployment_test.go | 252 ++++++++++++++------------------ 2 files changed, 123 insertions(+), 143 deletions(-) diff --git a/tests/testcore/test_env.go b/tests/testcore/test_env.go index 0aaa7255fee..44ba4fbfe0d 100644 --- a/tests/testcore/test_env.go +++ b/tests/testcore/test_env.go @@ -95,6 +95,7 @@ type testOptions struct { dedicatedReason string disableTestloggerFailure bool dynamicConfigSettings []dynamicConfigOverride + testHooks []testhooks.Hook clusterOptions []TestClusterOption testVars func(*testvars.TestVars) *testvars.TestVars } @@ -215,6 +216,16 @@ func WithDynamicConfig(setting dynamicconfig.GenericSetting, value any) TestOpti } } +// WithTestHook injects a test hook for the duration of the test. +func WithTestHook(hook testhooks.Hook) TestOption { + return func(o *testOptions) { + if hook.Scope() == testhooks.ScopeGlobal { + o.dedicatedCluster = true + } + o.testHooks = append(o.testHooks, hook) + } +} + // NewEnv creates a new test environment with access to a Temporal cluster. func NewEnv(t *testing.T, opts ...TestOption) *TestEnv { t.Helper() @@ -301,6 +312,9 @@ func NewEnv(t *testing.T, opts ...TestOption) *TestEnv { env.OverrideDynamicConfig(override.setting, override.value) } } + for _, hook := range options.testHooks { + env.InjectHook(hook) + } return env } diff --git a/tests/worker_deployment_test.go b/tests/worker_deployment_test.go index d69aa73a2c3..41911696d6e 100644 --- a/tests/worker_deployment_test.go +++ b/tests/worker_deployment_test.go @@ -7,7 +7,6 @@ import ( "testing" "time" - "github.com/dgryski/go-farm" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" commonpb "go.temporal.io/api/common/v1" @@ -785,7 +784,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Ramping_Wi DeploymentName: s.tv().DeploymentSeries(), }) s.NoError(err) - s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: s.tv().DeploymentSeries(), CreateTime: versionCreateTime, @@ -824,7 +823,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Ramping_Wi DeploymentName: s.tv().DeploymentSeries(), }) s.NoError(err) - s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: s.tv().DeploymentSeries(), CreateTime: versionCreateTime, @@ -874,7 +873,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Ramping_Wi DeploymentName: s.tv().DeploymentSeries(), }) s.NoError(err) - s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: s.tv().DeploymentSeries(), CreateTime: versionCreateTime, @@ -927,7 +926,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Ramping_Wi DeploymentName: s.tv().DeploymentSeries(), }) s.NoError(err) - s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: s.tv().DeploymentSeries(), CreateTime: versionCreateTime, @@ -989,7 +988,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_DuplicateR DeploymentName: rampingVersionVars.DeploymentSeries(), }) s.NoError(err) - s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: rampingVersionVars.DeploymentSeries(), CreateTime: versionCreateTime, @@ -1037,7 +1036,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Invalid_Se DeploymentName: currentVersionVars.DeploymentSeries(), }) s.NoError(err) - s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: currentVersionVars.DeploymentSeries(), CreateTime: versionCreateTime, @@ -1075,7 +1074,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Invalid_Se DeploymentName: currentVersionVars.DeploymentSeries(), }) s.NoError(err) - s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: currentVersionVars.DeploymentSeries(), CreateTime: versionCreateTime, @@ -1136,7 +1135,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_ModifyExis DeploymentName: s.tv().DeploymentSeries(), }) s.NoError(err) - s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: s.tv().DeploymentSeries(), CreateTime: versionCreateTime, @@ -1175,7 +1174,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_ModifyExis DeploymentName: s.tv().DeploymentSeries(), }) s.NoError(err) - s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: s.tv().DeploymentSeries(), CreateTime: versionCreateTime, @@ -1228,7 +1227,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_WithCurren DeploymentName: s.tv().DeploymentSeries(), }) s.NoError(err) - s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: s.tv().DeploymentSeries(), CreateTime: version1CreateTime, @@ -1278,7 +1277,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_WithCurren DeploymentName: s.tv().DeploymentSeries(), }) s.NoError(err) - s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: s.tv().DeploymentSeries(), CreateTime: version1CreateTime, @@ -1339,7 +1338,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_SetRamping DeploymentName: s.tv().DeploymentSeries(), }) s.NoError(err) - s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: s.tv().DeploymentSeries(), CreateTime: versionCreateTime, @@ -1418,7 +1417,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Batching() s.NoError(err) s.Equal(s.tv().DeploymentVersionString(), resp.GetWorkerDeploymentInfo().GetRoutingConfig().GetRampingVersion()) //nolint:staticcheck // SA1019: old worker versioning - s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: s.tv().DeploymentSeries(), CreateTime: versionCreateTime, @@ -1490,7 +1489,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Unversione s.Equal(worker_versioning.UnversionedVersionId, resp.GetWorkerDeploymentInfo().GetRoutingConfig().GetRampingVersion()) s.Nil(resp.GetWorkerDeploymentInfo().GetRoutingConfig().GetRampingDeploymentVersion()) - s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: s.tv().DeploymentSeries(), CreateTime: versionCreateTime, @@ -1557,7 +1556,7 @@ func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_SetCurrentVersion() DeploymentName: s.tv().DeploymentSeries(), }) s.NoError(err) - s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: s.tv().DeploymentSeries(), CreateTime: version1CreateTime, @@ -1598,7 +1597,7 @@ func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_SetCurrentVersion() DeploymentName: s.tv().DeploymentSeries(), }) s.NoError(err) - s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: s.tv().DeploymentSeries(), CreateTime: version1CreateTime, @@ -1675,7 +1674,7 @@ func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Batching() { }) s.NoError(err) - s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: s.tv().DeploymentSeries(), CreateTime: versionCreateTime, @@ -1787,17 +1786,18 @@ func (s *WorkerDeploymentSuite) TestDeleteVersion_ServerDeleteMaxVersionsReached testcore.WithDynamicConfig(dynamicconfig.MatchingMaxVersionsInDeployment, 1), ) + tv1 := s.tv().WithBuildIDNumber(1) tv2 := s.tv().WithBuildIDNumber(2) // start and stop polling so that version is eligible for deletion pollerCtx, pollerCancel := context.WithCancel(s.Context()) - go s.pollFromDeployment(pollerCtx, env, s.tv().WithBuildIDNumber(1)) - s.ensureCreateVersionInDeployment(env, s.tv().WithBuildIDNumber(1)) + go s.pollFromDeployment(pollerCtx, env, tv1) + s.ensureCreateVersionInDeployment(env, tv1) pollerCancel() // Set a different manager identity so that we can verify that the internal delete operation does not conduct the manager identity check // while deleting the version - s.setAndValidateManagerIdentity(env, s.tv().WithBuildIDNumber(1), false, false, "other", "") + s.setAndValidateManagerIdentity(env, tv1, false, false, "other", "") // Start another poller which shall aim to create a new version. This should, in turn, delete the first version. pollerCtx2, pollerCancel2 := context.WithCancel(s.Context()) @@ -1810,14 +1810,14 @@ func (s *WorkerDeploymentSuite) TestDeleteVersion_ServerDeleteMaxVersionsReached a := require.New(t) resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: s.tv().WithBuildIDNumber(1).DeploymentSeries(), + DeploymentName: tv1.DeploymentSeries(), }) a.NoError(err) a.Len(resp.GetWorkerDeploymentInfo().GetVersionSummaries(), 1) a.Equal(tv2.ExternalDeploymentVersion().GetBuildId(), resp.GetWorkerDeploymentInfo().GetVersionSummaries()[0].GetDeploymentVersion().GetBuildId()) // Also verify that the last modifier identity is not set to the identity of the worker-deployment workflow. - a.NotEqual(s.tv().WithBuildIDNumber(1).ClientIdentity(), resp.GetWorkerDeploymentInfo().GetLastModifierIdentity()) + a.NotEqual(tv1.ClientIdentity(), resp.GetWorkerDeploymentInfo().GetLastModifierIdentity()) }, time.Second*5, time.Millisecond*200) } @@ -1850,7 +1850,7 @@ func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Unversioned_NoRamp() { DeploymentName: currentVars.DeploymentSeries(), }) s.NoError(err) - s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: currentVars.DeploymentSeries(), CreateTime: versionCreateTime, @@ -2129,17 +2129,17 @@ func (s *WorkerDeploymentSuite) TestConcurrentPollers_ManyTaskQueues_RapidRoutin // Also skipping for AsyncSetCurrentAndRampingVersion, to reduce flake chance. s.skipBeforeVersion(workerdeployment.VersionDataRevisionNumber) - env := s.newTestEnv() - // Start pollers on many task queues across 3 versions numTaskQueues := 50 numVersions := 3 syncBatchSize := 2 // reducing batch size to cause more delay numOperations := 20 - env.OverrideDynamicConfig(dynamicconfig.MatchingMaxTaskQueuesInDeploymentVersion, numTaskQueues) - env.InjectHook(testhooks.NewHook(testhooks.TaskQueuesInDeploymentSyncBatchSize, syncBatchSize)) - env.InjectHook(testhooks.NewHook(testhooks.MatchingDeploymentRegisterErrorBackoff, time.Millisecond*500)) + env := s.newTestEnv( + testcore.WithDynamicConfig(dynamicconfig.MatchingMaxTaskQueuesInDeploymentVersion, numTaskQueues), + testcore.WithTestHook(testhooks.NewHook(testhooks.TaskQueuesInDeploymentSyncBatchSize, syncBatchSize)), + testcore.WithTestHook(testhooks.NewHook(testhooks.MatchingDeploymentRegisterErrorBackoff, time.Millisecond*500)), + ) // Need to increase max pending activities because it is set only to 10 for functional tests. it's 2000 by default. env.OverrideDynamicConfig(dynamicconfig.NumPendingActivitiesLimitError, numOperations) @@ -2289,7 +2289,7 @@ func (s *WorkerDeploymentSuite) TestResourceExhaustedErrors_Converted_To_Readabl } // Test SetRampingVersion - s.testConcurrentRequestsResourceExhausted(s.Context(), s.tv(), versions, errChan, "SetWorkerDeploymentRampingVersion", func(i int) error { + s.testConcurrentRequestsResourceExhausted(versions, errChan, "SetWorkerDeploymentRampingVersion", func(i int) error { _, err := env.FrontendClient().SetWorkerDeploymentRampingVersion(s.Context(), &workflowservice.SetWorkerDeploymentRampingVersionRequest{ Namespace: env.Namespace().String(), DeploymentName: s.tv().DeploymentVersion().GetDeploymentName(), @@ -2302,7 +2302,7 @@ func (s *WorkerDeploymentSuite) TestResourceExhaustedErrors_Converted_To_Readabl }) // Test SetCurrentVersion - s.testConcurrentRequestsResourceExhausted(s.Context(), s.tv(), versions, errChan, "SetWorkerDeploymentCurrentVersion", func(i int) error { + s.testConcurrentRequestsResourceExhausted(versions, errChan, "SetWorkerDeploymentCurrentVersion", func(i int) error { _, err := env.FrontendClient().SetWorkerDeploymentCurrentVersion(s.Context(), &workflowservice.SetWorkerDeploymentCurrentVersionRequest{ Namespace: env.Namespace().String(), DeploymentName: s.tv().DeploymentVersion().GetDeploymentName(), @@ -2318,7 +2318,7 @@ func (s *WorkerDeploymentSuite) TestResourceExhaustedErrors_Converted_To_Readabl "key1": {Data: testRandomMetadataValue}, "key2": {Data: testRandomMetadataValue}, } - s.testConcurrentRequestsResourceExhausted(s.Context(), s.tv(), versions, errChan, "UpdateWorkerDeploymentVersionMetadata", func(i int) error { + s.testConcurrentRequestsResourceExhausted(versions, errChan, "UpdateWorkerDeploymentVersionMetadata", func(i int) error { _, err := env.FrontendClient().UpdateWorkerDeploymentVersionMetadata(s.Context(), &workflowservice.UpdateWorkerDeploymentVersionMetadataRequest{ Namespace: env.Namespace().String(), Version: s.tv().WithBuildIDNumber(i).DeploymentVersionString(), @@ -2329,8 +2329,6 @@ func (s *WorkerDeploymentSuite) TestResourceExhaustedErrors_Converted_To_Readabl } func (s *WorkerDeploymentSuite) testConcurrentRequestsResourceExhausted( - ctx context.Context, - tv *testvars.TestVars, versions int, errChan chan error, apiName string, @@ -2412,15 +2410,14 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentCurrentVersion_NoPollers( // let a poller arrive with that version --> triggers user data propagation go s.pollFromDeployment(s.Context(), env, s.tv().WithBuildIDNumber(1)) - s.EventuallyWithT(func(t *assert.CollectT) { + s.Await(func(s *WorkerDeploymentSuite) { // check describe worker deployment resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), DeploymentName: s.tv().WithBuildIDNumber(1).DeploymentSeries(), }) - a := require.New(t) - a.NoError(err) - s.verifyWorkerDeploymentInfo(a, &deploymentpb.WorkerDeploymentInfo{ + s.NoError(err) + s.verifyWorkerDeploymentInfo(&deploymentpb.WorkerDeploymentInfo{ Name: s.tv().WithBuildIDNumber(1).DeploymentSeries(), CreateTime: versionCreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ @@ -2466,15 +2463,14 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_NoPollers( // let a poller arrive with that version --> triggers user data propagation go s.pollFromDeployment(s.Context(), env, s.tv().WithBuildIDNumber(1)) - s.EventuallyWithT(func(t *assert.CollectT) { + s.Await(func(s *WorkerDeploymentSuite) { // check describe worker deployment resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), DeploymentName: s.tv().WithBuildIDNumber(1).DeploymentSeries(), }) - a := require.New(t) - a.NoError(err) - s.verifyWorkerDeploymentInfo(a, &deploymentpb.WorkerDeploymentInfo{ + s.NoError(err) + s.verifyWorkerDeploymentInfo(&deploymentpb.WorkerDeploymentInfo{ Name: s.tv().WithBuildIDNumber(1).DeploymentSeries(), CreateTime: versionCreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ @@ -2558,7 +2554,7 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { DeploymentName: tv1.DeploymentSeries(), }) s.NoError(err) - s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: tv1.DeploymentSeries(), CreateTime: v1CreateTime, @@ -2596,7 +2592,7 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { }) s.NoError(err) - s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: tv2.DeploymentSeries(), CreateTime: v1CreateTime, @@ -2650,14 +2646,13 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { }, time.Second*10, time.Millisecond*1000) // Verify that the drainageStatus of v1 has been updated in the VersionSummaries - s.EventuallyWithT(func(t *assert.CollectT) { - a := require.New(t) + s.Await(func(s *WorkerDeploymentSuite) { resp, err = env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), DeploymentName: tv2.DeploymentSeries(), }) - a.NoError(err) - s.verifyDescribeWorkerDeployment(a, resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.NoError(err) + s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: tv2.DeploymentSeries(), CreateTime: v1CreateTime, @@ -2705,14 +2700,13 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { s.setAndVerifyRampingVersion(env, tv1, false, 10, false, "") // verify if the right information is set in the DescribeWorkerDeployment response - s.EventuallyWithT(func(t *assert.CollectT) { - a := require.New(t) + s.Await(func(s *WorkerDeploymentSuite) { resp, err = env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), DeploymentName: tv2.DeploymentSeries(), }) - a.NoError(err) - s.verifyDescribeWorkerDeployment(a, resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.NoError(err) + s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: tv2.DeploymentSeries(), CreateTime: v1CreateTime, @@ -2771,14 +2765,13 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { }, time.Second*10, time.Millisecond*1000) // verify if the right information is set in the DescribeWorkerDeployment response - s.EventuallyWithT(func(t *assert.CollectT) { - a := require.New(t) + s.Await(func(s *WorkerDeploymentSuite) { resp, err = env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), DeploymentName: tv1.DeploymentSeries(), }) - a.NoError(err) - s.verifyDescribeWorkerDeployment(a, resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.NoError(err) + s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: tv1.DeploymentSeries(), CreateTime: v1CreateTime, @@ -2841,14 +2834,13 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { // Verify that v1, which was rolled back to being current previously, is drained with it's information present // in the deployment workflow. - s.EventuallyWithT(func(t *assert.CollectT) { - a := require.New(t) + s.Await(func(s *WorkerDeploymentSuite) { resp, err = env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), DeploymentName: tv1.DeploymentSeries(), }) - a.NoError(err) - s.verifyDescribeWorkerDeployment(a, resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.NoError(err) + s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: tv1.DeploymentSeries(), CreateTime: v1CreateTime, @@ -2923,7 +2915,7 @@ func (s *WorkerDeploymentSuite) TestSetRampingVersion_AfterDrained() { DeploymentName: tv1.DeploymentSeries(), }) s.NoError(err) - s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: tv1.DeploymentSeries(), CreateTime: v1CreateTime, @@ -2961,7 +2953,7 @@ func (s *WorkerDeploymentSuite) TestSetRampingVersion_AfterDrained() { }) s.NoError(err) - s.verifyDescribeWorkerDeployment(s.Assertions, resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: tv2.DeploymentSeries(), CreateTime: v1CreateTime, @@ -3015,14 +3007,13 @@ func (s *WorkerDeploymentSuite) TestSetRampingVersion_AfterDrained() { }, time.Second*10, time.Millisecond*1000) // Verify that the drainageStatus of v1 has been updated in the VersionSummaries - s.EventuallyWithT(func(t *assert.CollectT) { - a := require.New(t) + s.Await(func(s *WorkerDeploymentSuite) { resp, err = env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), DeploymentName: tv2.DeploymentSeries(), }) - a.NoError(err) - s.verifyDescribeWorkerDeployment(a, resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.NoError(err) + s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: tv2.DeploymentSeries(), CreateTime: v1CreateTime, @@ -3070,14 +3061,13 @@ func (s *WorkerDeploymentSuite) TestSetRampingVersion_AfterDrained() { s.setAndVerifyRampingVersion(env, tv1, false, 10, false, "") // verify if the right information is set in the DescribeWorkerDeployment response - s.EventuallyWithT(func(t *assert.CollectT) { - a := require.New(t) + s.Await(func(s *WorkerDeploymentSuite) { resp, err = env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), DeploymentName: tv2.DeploymentSeries(), }) - a.NoError(err) - s.verifyDescribeWorkerDeployment(a, resp, &workflowservice.DescribeWorkerDeploymentResponse{ + s.NoError(err) + s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ Name: tv2.DeploymentSeries(), CreateTime: v1CreateTime, @@ -3299,91 +3289,90 @@ func (s *WorkerDeploymentSuite) tryDeleteVersion( // verifyTimestampWithinRange asserts if the actual timestamp is set to an appropriate value. It // does this check by checking if the timestamp set is within respectable bounds or is equal to the // expected timestamp. -func (s *WorkerDeploymentSuite) verifyTimestampWithinRange(a *require.Assertions, expected, actual *timestamppb.Timestamp, msg string) { - a.Equalf(expected == nil, actual == nil, +func (s *WorkerDeploymentSuite) verifyTimestampWithinRange(expected, actual *timestamppb.Timestamp, msg string) { + s.Equalf(expected == nil, actual == nil, "expected %s to be: '%s', actual: %s", msg, expected.AsTime().String(), actual.AsTime().String()) if expected == nil { return } acceptableDelayBetweenExpectedAndActual := 5 * time.Second // works locally with 2s, but setting to 5 to avoid flakes in CI - a.Truef(expected.AsTime().Equal(actual.AsTime()) || (actual.AsTime().After(expected.AsTime()) && actual.AsTime().Before(expected.AsTime().Add(acceptableDelayBetweenExpectedAndActual))), + s.Truef(expected.AsTime().Equal(actual.AsTime()) || (actual.AsTime().After(expected.AsTime()) && actual.AsTime().Before(expected.AsTime().Add(acceptableDelayBetweenExpectedAndActual))), "expected %s to be: '%s', actual: %s", msg, expected.AsTime().String(), actual.AsTime().String()) } -func (s *WorkerDeploymentSuite) verifyVersionSummary(a *require.Assertions, expected, actual *deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary) { - a.Equal(expected.GetVersion(), actual.GetVersion()) //nolint:staticcheck // SA1019: old worker versioning - a.Equal(worker_versioning.ExternalWorkerDeploymentVersionFromStringV31(expected.GetVersion()), actual.GetDeploymentVersion()) //nolint:staticcheck // SA1019: old worker versioning - a.Equalf(expected.GetDrainageInfo().GetStatus().String(), actual.GetDrainageInfo().GetStatus().String(), +func (s *WorkerDeploymentSuite) verifyVersionSummary(expected, actual *deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary) { + s.Equal(expected.GetVersion(), actual.GetVersion()) //nolint:staticcheck // SA1019: old worker versioning + s.Equal(worker_versioning.ExternalWorkerDeploymentVersionFromStringV31(expected.GetVersion()), actual.GetDeploymentVersion()) //nolint:staticcheck // SA1019: old worker versioning + s.Equalf(expected.GetDrainageInfo().GetStatus().String(), actual.GetDrainageInfo().GetStatus().String(), "Version %s:%s drainage status mismatch", actual.GetDeploymentVersion().GetDeploymentName(), actual.GetDeploymentVersion().GetBuildId()) - a.Equalf(expected.GetStatus(), actual.GetStatus(), + s.Equalf(expected.GetStatus(), actual.GetStatus(), "Version %s:%s status mismatch", actual.GetDeploymentVersion().GetDeploymentName(), actual.GetDeploymentVersion().GetBuildId()) - s.verifyTimestampWithinRange(a, expected.GetCreateTime(), actual.GetCreateTime(), + s.verifyTimestampWithinRange(expected.GetCreateTime(), actual.GetCreateTime(), fmt.Sprintf("Version %s:%s create time", actual.GetDeploymentVersion().GetDeploymentName(), actual.GetDeploymentVersion().GetBuildId())) - s.verifyTimestampWithinRange(a, expected.GetRoutingUpdateTime(), actual.GetRoutingUpdateTime(), + s.verifyTimestampWithinRange(expected.GetRoutingUpdateTime(), actual.GetRoutingUpdateTime(), fmt.Sprintf("Version %s:%s routing update time", actual.GetDeploymentVersion().GetDeploymentName(), actual.GetDeploymentVersion().GetBuildId())) - s.verifyTimestampWithinRange(a, expected.GetCurrentSinceTime(), actual.GetCurrentSinceTime(), + s.verifyTimestampWithinRange(expected.GetCurrentSinceTime(), actual.GetCurrentSinceTime(), fmt.Sprintf("Version %s:%s current since time", actual.GetDeploymentVersion().GetDeploymentName(), actual.GetDeploymentVersion().GetBuildId())) - s.verifyTimestampWithinRange(a, expected.GetRampingSinceTime(), actual.GetRampingSinceTime(), + s.verifyTimestampWithinRange(expected.GetRampingSinceTime(), actual.GetRampingSinceTime(), fmt.Sprintf("Version %s:%s ramping since time", actual.GetDeploymentVersion().GetDeploymentName(), actual.GetDeploymentVersion().GetBuildId())) - s.verifyTimestampWithinRange(a, expected.GetFirstActivationTime(), actual.GetFirstActivationTime(), + s.verifyTimestampWithinRange(expected.GetFirstActivationTime(), actual.GetFirstActivationTime(), fmt.Sprintf("Version %s:%s first activation time", actual.GetDeploymentVersion().GetDeploymentName(), actual.GetDeploymentVersion().GetBuildId())) - s.verifyTimestampWithinRange(a, expected.GetLastCurrentTime(), actual.GetLastCurrentTime(), + s.verifyTimestampWithinRange(expected.GetLastCurrentTime(), actual.GetLastCurrentTime(), fmt.Sprintf("Version %s:%s last current time", actual.GetDeploymentVersion().GetDeploymentName(), actual.GetDeploymentVersion().GetBuildId())) - s.verifyTimestampWithinRange(a, expected.GetLastDeactivationTime(), actual.GetLastDeactivationTime(), + s.verifyTimestampWithinRange(expected.GetLastDeactivationTime(), actual.GetLastDeactivationTime(), fmt.Sprintf("Version %s:%s last deactivation time", actual.GetDeploymentVersion().GetDeploymentName(), actual.GetDeploymentVersion().GetBuildId())) } -func (s *WorkerDeploymentSuite) verifyRoutingConfig(a *require.Assertions, expected, actual *deploymentpb.RoutingConfig, deploymentName string) { - a.Equal(expected.GetRampingVersion(), actual.GetRampingVersion()) //nolint:staticcheck // SA1019: old worker versioning +func (s *WorkerDeploymentSuite) verifyRoutingConfig(expected, actual *deploymentpb.RoutingConfig, deploymentName string) { + s.Equal(expected.GetRampingVersion(), actual.GetRampingVersion()) //nolint:staticcheck // SA1019: old worker versioning s.ProtoEqual(worker_versioning.ExternalWorkerDeploymentVersionFromStringV31(expected.GetRampingVersion()), actual.GetRampingDeploymentVersion()) //nolint:staticcheck // SA1019: worker versioning v0.31 - a.Equal(expected.GetRampingVersionPercentage(), actual.GetRampingVersionPercentage()) - a.Equal(expected.GetCurrentVersion(), actual.GetCurrentVersion()) //nolint:staticcheck // SA1019: old worker versioning + s.Equal(expected.GetRampingVersionPercentage(), actual.GetRampingVersionPercentage()) + s.Equal(expected.GetCurrentVersion(), actual.GetCurrentVersion()) //nolint:staticcheck // SA1019: old worker versioning s.ProtoEqual(worker_versioning.ExternalWorkerDeploymentVersionFromStringV31(expected.GetCurrentVersion()), actual.GetCurrentDeploymentVersion()) //nolint:staticcheck // SA1019: worker versioning v0.31 - s.verifyTimestampWithinRange(a, expected.GetRampingVersionChangedTime(), actual.GetRampingVersionChangedTime(), + s.verifyTimestampWithinRange(expected.GetRampingVersionChangedTime(), actual.GetRampingVersionChangedTime(), fmt.Sprintf("Deployment %s ramping version changed time", deploymentName)) - s.verifyTimestampWithinRange(a, expected.GetCurrentVersionChangedTime(), actual.GetCurrentVersionChangedTime(), + s.verifyTimestampWithinRange(expected.GetCurrentVersionChangedTime(), actual.GetCurrentVersionChangedTime(), fmt.Sprintf("Deployment %s current version changed time", deploymentName)) - s.verifyTimestampWithinRange(a, expected.GetRampingVersionPercentageChangedTime(), actual.GetRampingVersionPercentageChangedTime(), + s.verifyTimestampWithinRange(expected.GetRampingVersionPercentageChangedTime(), actual.GetRampingVersionPercentageChangedTime(), fmt.Sprintf("Deployment %s ramping percentage changed time", deploymentName)) } -func (s *WorkerDeploymentSuite) verifyWorkerDeploymentInfo(a *require.Assertions, expected, actual *deploymentpb.WorkerDeploymentInfo) { - a.Equal((actual == nil), (expected == nil)) - a.Equal(expected.GetName(), actual.GetName()) - a.Equal((actual.GetRoutingConfig() == nil), (expected.GetRoutingConfig() == nil)) - a.Equal(expected.GetLastModifierIdentity(), actual.GetLastModifierIdentity()) +func (s *WorkerDeploymentSuite) verifyWorkerDeploymentInfo(expected, actual *deploymentpb.WorkerDeploymentInfo) { + s.Equal((actual == nil), (expected == nil)) + s.Equal(expected.GetName(), actual.GetName()) + s.Equal((actual.GetRoutingConfig() == nil), (expected.GetRoutingConfig() == nil)) + s.Equal(expected.GetLastModifierIdentity(), actual.GetLastModifierIdentity()) - s.verifyTimestampWithinRange(a, expected.GetCreateTime(), actual.GetCreateTime(), + s.verifyTimestampWithinRange(expected.GetCreateTime(), actual.GetCreateTime(), fmt.Sprintf("Deployment %s create time", expected.GetName())) - s.verifyRoutingConfig(a, expected.GetRoutingConfig(), actual.GetRoutingConfig(), expected.GetName()) + s.verifyRoutingConfig(expected.GetRoutingConfig(), actual.GetRoutingConfig(), expected.GetName()) // Verify version summaries for _, expectedSummary := range expected.GetVersionSummaries() { found := false for _, actualSummary := range actual.GetVersionSummaries() { if actualSummary.Version == expectedSummary.Version { //nolint:staticcheck // SA1019: old worker versioning - s.verifyVersionSummary(a, expectedSummary, actualSummary) + s.verifyVersionSummary(expectedSummary, actualSummary) found = true break } } - a.True(found) + s.True(found) } } func (s *WorkerDeploymentSuite) verifyDescribeWorkerDeployment( - a *require.Assertions, actualResp *workflowservice.DescribeWorkerDeploymentResponse, expectedResp *workflowservice.DescribeWorkerDeploymentResponse, ) { if expectedResp == nil { - a.Nil(actualResp) + s.Nil(actualResp) } else { - a.NotNil(actualResp) + s.NotNil(actualResp) } - s.verifyWorkerDeploymentInfo(a, expectedResp.GetWorkerDeploymentInfo(), actualResp.GetWorkerDeploymentInfo()) + s.verifyWorkerDeploymentInfo(expectedResp.GetWorkerDeploymentInfo(), actualResp.GetWorkerDeploymentInfo()) } func (s *WorkerDeploymentSuite) setAndVerifyRampingVersion( @@ -3583,36 +3572,35 @@ func (s *WorkerDeploymentSuite) createVersionsInDeployments(env *testcore.TestEn } func (s *WorkerDeploymentSuite) verifyWorkerDeploymentSummary( - a *require.Assertions, expectedSummary *workflowservice.ListWorkerDeploymentsResponse_WorkerDeploymentSummary, actualSummary *workflowservice.ListWorkerDeploymentsResponse_WorkerDeploymentSummary, ) bool { - s.verifyTimestampWithinRange(a, expectedSummary.CreateTime, actualSummary.CreateTime, + s.verifyTimestampWithinRange(expectedSummary.CreateTime, actualSummary.CreateTime, fmt.Sprintf("Deployment %s create time", expectedSummary.GetName())) // Current version checks - a.Equal(expectedSummary.RoutingConfig.GetCurrentVersion(), actualSummary.RoutingConfig.GetCurrentVersion(), "Current version mismatch") //nolint:staticcheck // SA1019: old worker versioning + s.Equal(expectedSummary.RoutingConfig.GetCurrentVersion(), actualSummary.RoutingConfig.GetCurrentVersion(), "Current version mismatch") //nolint:staticcheck // SA1019: old worker versioning s.ProtoEqual(worker_versioning.ExternalWorkerDeploymentVersionFromStringV31(expectedSummary.RoutingConfig.GetCurrentVersion()), actualSummary.RoutingConfig.GetCurrentDeploymentVersion()) //nolint:staticcheck // SA1019: worker versioning v0.31 - s.verifyTimestampWithinRange(a, expectedSummary.RoutingConfig.GetCurrentVersionChangedTime(), actualSummary.RoutingConfig.GetCurrentVersionChangedTime(), + s.verifyTimestampWithinRange(expectedSummary.RoutingConfig.GetCurrentVersionChangedTime(), actualSummary.RoutingConfig.GetCurrentVersionChangedTime(), fmt.Sprintf("Deployment %s current version changed time", expectedSummary.GetName())) // Ramping version checks - a.Equal(expectedSummary.RoutingConfig.GetRampingVersion(), actualSummary.RoutingConfig.GetRampingVersion(), "Ramping version mismatch") //nolint:staticcheck // SA1019: old worker versioning + s.Equal(expectedSummary.RoutingConfig.GetRampingVersion(), actualSummary.RoutingConfig.GetRampingVersion(), "Ramping version mismatch") //nolint:staticcheck // SA1019: old worker versioning s.ProtoEqual(worker_versioning.ExternalWorkerDeploymentVersionFromStringV31(expectedSummary.RoutingConfig.GetRampingVersion()), actualSummary.RoutingConfig.GetRampingDeploymentVersion()) //nolint:staticcheck // SA1019: worker versioning v0.31 - a.Equal(expectedSummary.RoutingConfig.GetRampingVersionPercentage(), actualSummary.RoutingConfig.GetRampingVersionPercentage(), "Ramping version percentage mismatch") + s.Equal(expectedSummary.RoutingConfig.GetRampingVersionPercentage(), actualSummary.RoutingConfig.GetRampingVersionPercentage(), "Ramping version percentage mismatch") - s.verifyTimestampWithinRange(a, expectedSummary.RoutingConfig.GetRampingVersionChangedTime(), actualSummary.RoutingConfig.GetRampingVersionChangedTime(), + s.verifyTimestampWithinRange(expectedSummary.RoutingConfig.GetRampingVersionChangedTime(), actualSummary.RoutingConfig.GetRampingVersionChangedTime(), fmt.Sprintf("Deployment %s ramping version changed time", expectedSummary.GetName())) // Latest version summary checks - s.verifyVersionSummary(a, expectedSummary.LatestVersionSummary, actualSummary.LatestVersionSummary) + s.verifyVersionSummary(expectedSummary.LatestVersionSummary, actualSummary.LatestVersionSummary) // Current version summary checks - s.verifyVersionSummary(a, expectedSummary.CurrentVersionSummary, actualSummary.CurrentVersionSummary) + s.verifyVersionSummary(expectedSummary.CurrentVersionSummary, actualSummary.CurrentVersionSummary) // Ramping version summary checks - s.verifyVersionSummary(a, expectedSummary.RampingVersionSummary, actualSummary.RampingVersionSummary) + s.verifyVersionSummary(expectedSummary.RampingVersionSummary, actualSummary.RampingVersionSummary) return true } @@ -3638,13 +3626,11 @@ func (s *WorkerDeploymentSuite) startAndValidateWorkerDeployments( expectedDeploymentSummaries []*workflowservice.ListWorkerDeploymentsResponse_WorkerDeploymentSummary, ) { - s.EventuallyWithT(func(t *assert.CollectT) { - a := require.New(t) - + s.Await(func(s *WorkerDeploymentSuite) { actualDeploymentSummaries, err := s.listWorkerDeployments(env, request) - a.NoError(err) + s.NoError(err) if len(actualDeploymentSummaries) < len(expectedDeploymentSummaries) { - a.Failf("not enough deployment summaries", "got %d, want at least %d", len(actualDeploymentSummaries), len(expectedDeploymentSummaries)) + s.Failf("not enough deployment summaries", "got %d, want at least %d", len(actualDeploymentSummaries), len(expectedDeploymentSummaries)) return } @@ -3656,11 +3642,11 @@ func (s *WorkerDeploymentSuite) startAndValidateWorkerDeployments( if actualDeploymentSummary.Name != expectedDeploymentSummary.Name { continue } - s.verifyWorkerDeploymentSummary(a, expectedDeploymentSummary, actualDeploymentSummary) + s.verifyWorkerDeploymentSummary(expectedDeploymentSummary, actualDeploymentSummary) deploymentSummaryFound = true break } - a.True(deploymentSummaryFound) + s.True(deploymentSummaryFound) } }, time.Second*10, time.Millisecond*1000) } @@ -3933,28 +3919,8 @@ func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_AfterDelete_CanRecrea s.Empty(descResp.WorkerDeploymentInfo.VersionSummaries) // No versions initially } -// s.tv() returns test variables seeded from a shortened test name so that physical task queue IDs -// do not grow larger than DB column limit (currently as low as 272 chars). func (s *WorkerDeploymentSuite) tv() *testvars.TestVars { - return testvars.New(shortNamer{s.T()}) -} - -// shortNamer is used by testvars. We use a shortened test name in variables so that physical task -// queue IDs do not grow larger than DB column limit (currently as low as 272 chars). -type shortNamer struct { - t *testing.T -} - -func (n shortNamer) Name() string { - fullName := n.t.Name() - if len(fullName) <= 30 { - return fullName - } - short := fmt.Sprintf("%s-%08x", - fullName[len(fullName)-21:], - farm.Fingerprint32([]byte(fullName)), - ) - return strings.Replace(short, ".", "|", -1) + return testvars.New(s.T()) } func (s *WorkerDeploymentSuite) skipBeforeVersion(version workerdeployment.DeploymentWorkflowVersion) { From a4d0047c193ab252b76bb693fa69134b5c097591 Mon Sep 17 00:00:00 2001 From: Stephan Behnke Date: Thu, 18 Jun 2026 15:37:27 -0700 Subject: [PATCH 04/27] Reuse worker service cluster in worker deployment suite --- tests/worker_deployment_test.go | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/tests/worker_deployment_test.go b/tests/worker_deployment_test.go index 41911696d6e..0816bc9da00 100644 --- a/tests/worker_deployment_test.go +++ b/tests/worker_deployment_test.go @@ -37,16 +37,16 @@ type ( ) func TestWorkerDeploymentSuite(t *testing.T) { - parallelsuite.Run(t, &WorkerDeploymentSuite{}) + testcore.UseSuiteScopedCluster(t) //nolint:staticcheck // SA1019: suite reuses one worker-service cluster to avoid per-test cluster churn. + parallelsuite.RunLegacySequential(t, &WorkerDeploymentSuite{}) //nolint:staticcheck // SA1019: suite reuses one worker-service cluster to avoid per-test cluster churn. } // newTestEnv creates a TestEnv with the dynamic config this suite needs. -// Each test gets a dedicated, worker-enabled cluster since this suite mutates +// Tests share a dedicated, worker-enabled cluster since this suite mutates // cluster-global deployment state and drives deployment system workflows. // Additional per-test options may be passed in opts. func (s *WorkerDeploymentSuite) newTestEnv(opts ...testcore.TestOption) *testcore.TestEnv { baseOpts := []testcore.TestOption{ - testcore.WithWorkerService("worker deployment system workflows"), testcore.WithDynamicConfig(dynamicconfig.MatchingDeploymentWorkflowVersion, int(workerdeployment.VersionDataRevisionNumber)), // Make sure we don't hit the rate limiter in tests @@ -66,7 +66,6 @@ func (s *WorkerDeploymentSuite) newTestEnv(opts ...testcore.TestOption) *testcor }), testcore.WithDynamicConfig(dynamicconfig.MatchingMaxTaskQueuesInDeploymentVersion, 1000), - testcore.WithDynamicConfig(dynamicconfig.VisibilityPersistenceSlowQueryThreshold, 60*time.Second), } return testcore.NewEnv(s.T(), append(baseOpts, opts...)...) } From a53b6ebc3eb736fddca9b5eb8b5dc50583e8126b Mon Sep 17 00:00:00 2001 From: Stephan Behnke Date: Thu, 18 Jun 2026 16:02:43 -0700 Subject: [PATCH 05/27] Fix worker deployment lint --- tests/worker_deployment_test.go | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) diff --git a/tests/worker_deployment_test.go b/tests/worker_deployment_test.go index 0816bc9da00..5e4e4f14212 100644 --- a/tests/worker_deployment_test.go +++ b/tests/worker_deployment_test.go @@ -42,8 +42,6 @@ func TestWorkerDeploymentSuite(t *testing.T) { } // newTestEnv creates a TestEnv with the dynamic config this suite needs. -// Tests share a dedicated, worker-enabled cluster since this suite mutates -// cluster-global deployment state and drives deployment system workflows. // Additional per-test options may be passed in opts. func (s *WorkerDeploymentSuite) newTestEnv(opts ...testcore.TestOption) *testcore.TestEnv { baseOpts := []testcore.TestOption{ @@ -2136,13 +2134,12 @@ func (s *WorkerDeploymentSuite) TestConcurrentPollers_ManyTaskQueues_RapidRoutin env := s.newTestEnv( testcore.WithDynamicConfig(dynamicconfig.MatchingMaxTaskQueuesInDeploymentVersion, numTaskQueues), + // Need to increase max pending activities because it is set only to 10 for functional tests. it's 2000 by default. + testcore.WithDynamicConfig(dynamicconfig.NumPendingActivitiesLimitError, numOperations), testcore.WithTestHook(testhooks.NewHook(testhooks.TaskQueuesInDeploymentSyncBatchSize, syncBatchSize)), testcore.WithTestHook(testhooks.NewHook(testhooks.MatchingDeploymentRegisterErrorBackoff, time.Millisecond*500)), ) - // Need to increase max pending activities because it is set only to 10 for functional tests. it's 2000 by default. - env.OverrideDynamicConfig(dynamicconfig.NumPendingActivitiesLimitError, numOperations) - dn := s.tv().DeploymentVersion().GetDeploymentName() start := time.Now() @@ -3326,7 +3323,7 @@ func (s *WorkerDeploymentSuite) verifyVersionSummary(expected, actual *deploymen func (s *WorkerDeploymentSuite) verifyRoutingConfig(expected, actual *deploymentpb.RoutingConfig, deploymentName string) { s.Equal(expected.GetRampingVersion(), actual.GetRampingVersion()) //nolint:staticcheck // SA1019: old worker versioning s.ProtoEqual(worker_versioning.ExternalWorkerDeploymentVersionFromStringV31(expected.GetRampingVersion()), actual.GetRampingDeploymentVersion()) //nolint:staticcheck // SA1019: worker versioning v0.31 - s.Equal(expected.GetRampingVersionPercentage(), actual.GetRampingVersionPercentage()) + s.InDelta(expected.GetRampingVersionPercentage(), actual.GetRampingVersionPercentage(), 0.001) s.Equal(expected.GetCurrentVersion(), actual.GetCurrentVersion()) //nolint:staticcheck // SA1019: old worker versioning s.ProtoEqual(worker_versioning.ExternalWorkerDeploymentVersionFromStringV31(expected.GetCurrentVersion()), actual.GetCurrentDeploymentVersion()) //nolint:staticcheck // SA1019: worker versioning v0.31 @@ -3587,7 +3584,7 @@ func (s *WorkerDeploymentSuite) verifyWorkerDeploymentSummary( // Ramping version checks s.Equal(expectedSummary.RoutingConfig.GetRampingVersion(), actualSummary.RoutingConfig.GetRampingVersion(), "Ramping version mismatch") //nolint:staticcheck // SA1019: old worker versioning s.ProtoEqual(worker_versioning.ExternalWorkerDeploymentVersionFromStringV31(expectedSummary.RoutingConfig.GetRampingVersion()), actualSummary.RoutingConfig.GetRampingDeploymentVersion()) //nolint:staticcheck // SA1019: worker versioning v0.31 - s.Equal(expectedSummary.RoutingConfig.GetRampingVersionPercentage(), actualSummary.RoutingConfig.GetRampingVersionPercentage(), "Ramping version percentage mismatch") + s.InDelta(expectedSummary.RoutingConfig.GetRampingVersionPercentage(), actualSummary.RoutingConfig.GetRampingVersionPercentage(), 0.001, "Ramping version percentage mismatch") s.verifyTimestampWithinRange(expectedSummary.RoutingConfig.GetRampingVersionChangedTime(), actualSummary.RoutingConfig.GetRampingVersionChangedTime(), fmt.Sprintf("Deployment %s ramping version changed time", expectedSummary.GetName())) From 7110e57c3a75bea54ae61615e1cf230bdd1e60a1 Mon Sep 17 00:00:00 2001 From: Stephan Behnke Date: Thu, 18 Jun 2026 16:25:43 -0700 Subject: [PATCH 06/27] Simplify worker deployment poller helpers --- tests/testcore/dynamic_config_overrides.go | 1 + tests/worker_deployment_test.go | 157 +++++++++++---------- 2 files changed, 84 insertions(+), 74 deletions(-) diff --git a/tests/testcore/dynamic_config_overrides.go b/tests/testcore/dynamic_config_overrides.go index 6fccde14de9..cd3bb360d20 100644 --- a/tests/testcore/dynamic_config_overrides.go +++ b/tests/testcore/dynamic_config_overrides.go @@ -38,6 +38,7 @@ var ( dynamicconfig.ReplicationTaskProcessorErrorRetryWait.Key(): time.Millisecond, dynamicconfig.ClusterMetadataRefreshInterval.Key(): 100 * time.Millisecond, dynamicconfig.NamespaceCacheRefreshInterval.Key(): NamespaceCacheRefreshInterval, + dynamicconfig.VisibilityPersistenceSlowQueryThreshold.Key(): 60 * time.Second, dynamicconfig.ReplicationEnableUpdateWithNewTaskMerge.Key(): true, dynamicconfig.FrontendMaskInternalErrorDetails.Key(): false, dynamicconfig.HistoryScannerEnabled.Key(): false, diff --git a/tests/worker_deployment_test.go b/tests/worker_deployment_test.go index 5e4e4f14212..fed4c7cc9db 100644 --- a/tests/worker_deployment_test.go +++ b/tests/worker_deployment_test.go @@ -69,7 +69,11 @@ func (s *WorkerDeploymentSuite) newTestEnv(opts ...testcore.TestOption) *testcor } // pollFromDeployment calls PollWorkflowTaskQueue to start deployment related workflows -func (s *WorkerDeploymentSuite) pollFromDeployment(ctx context.Context, env *testcore.TestEnv, tv *testvars.TestVars) { +func (s *WorkerDeploymentSuite) pollFromDeployment(env *testcore.TestEnv, tv *testvars.TestVars) { + s.pollFromDeploymentWithContext(s.Context(), env, tv) +} + +func (s *WorkerDeploymentSuite) pollFromDeploymentWithContext(ctx context.Context, env *testcore.TestEnv, tv *testvars.TestVars) { _, _ = env.FrontendClient().PollWorkflowTaskQueue(ctx, &workflowservice.PollWorkflowTaskQueueRequest{ Namespace: env.Namespace().String(), TaskQueue: tv.TaskQueue(), @@ -78,8 +82,14 @@ func (s *WorkerDeploymentSuite) pollFromDeployment(ctx context.Context, env *tes }) } -func (s *WorkerDeploymentSuite) pollFromDeploymentWithTaskQueueNumber(ctx context.Context, env *testcore.TestEnv, tv *testvars.TestVars, taskQueueNumber int) { - _, _ = env.FrontendClient().PollWorkflowTaskQueue(ctx, &workflowservice.PollWorkflowTaskQueueRequest{ +func (s *WorkerDeploymentSuite) startDeploymentPoller(env *testcore.TestEnv, tv *testvars.TestVars) context.CancelFunc { + ctx, cancel := context.WithCancel(s.Context()) + go s.pollFromDeploymentWithContext(ctx, env, tv) + return cancel +} + +func (s *WorkerDeploymentSuite) pollFromDeploymentWithTaskQueueNumber(env *testcore.TestEnv, tv *testvars.TestVars, taskQueueNumber int) { + _, _ = env.FrontendClient().PollWorkflowTaskQueue(s.Context(), &workflowservice.PollWorkflowTaskQueueRequest{ Namespace: env.Namespace().String(), TaskQueue: tv.WithTaskQueueNumber(taskQueueNumber).TaskQueue(), Identity: "random", @@ -154,11 +164,15 @@ func (s *WorkerDeploymentSuite) ensureCreateDeployment( }, 5*time.Second, 100*time.Millisecond) } -func (s *WorkerDeploymentSuite) startVersionWorkflow(ctx context.Context, env *testcore.TestEnv, tv *testvars.TestVars) { - go s.pollFromDeployment(ctx, env, tv) +func (s *WorkerDeploymentSuite) startVersionWorkflow(env *testcore.TestEnv, tv *testvars.TestVars) { + go s.pollFromDeployment(env, tv) + s.waitForDeploymentVersion(env, tv) +} + +func (s *WorkerDeploymentSuite) waitForDeploymentVersion(env *testcore.TestEnv, tv *testvars.TestVars) { s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) - resp, err := env.FrontendClient().DescribeWorkerDeploymentVersion(ctx, &workflowservice.DescribeWorkerDeploymentVersionRequest{ + resp, err := env.FrontendClient().DescribeWorkerDeploymentVersion(s.Context(), &workflowservice.DescribeWorkerDeploymentVersionRequest{ Namespace: env.Namespace().String(), Version: tv.DeploymentVersionString(), }) @@ -172,7 +186,7 @@ func (s *WorkerDeploymentSuite) TestForceCAN_NoOpenWFS() { env := s.newTestEnv() // Start a version workflow - s.startVersionWorkflow(s.Context(), env, s.tv()) + s.startVersionWorkflow(env, s.tv()) s.ensureCreateVersionInDeployment(env, s.tv()) // Set the version as current @@ -208,7 +222,7 @@ func (s *WorkerDeploymentSuite) TestForceCAN_WithOverrideState() { env := s.newTestEnv() // Start a version workflow - s.startVersionWorkflow(s.Context(), env, s.tv()) + s.startVersionWorkflow(env, s.tv()) s.ensureCreateVersionInDeployment(env, s.tv()) // Set the version as current @@ -284,14 +298,14 @@ func (s *WorkerDeploymentSuite) TestDeploymentVersionLimits() { expectedErrorMaxTaskQueues := fmt.Sprintf("cannot add task queue %v since maximum number of task queues (1) have been registered in deployment", secondDeploymentVersionOne.WithTaskQueueNumber(2).TaskQueue().GetName()) // First deployment version should be fine - go s.pollFromDeployment(s.Context(), env, firstDeploymentVersionOne) + go s.pollFromDeployment(env, firstDeploymentVersionOne) s.ensureCreateVersionInDeployment(env, firstDeploymentVersionOne) // pollers of second version in the same deployment should be rejected s.pollFromDeploymentExpectFail(env, firstDeploymentVersionTwo, expectedErrorMaxVersions) // But first version of another deployment fine - go s.pollFromDeployment(s.Context(), env, secondDeploymentVersionOne) + go s.pollFromDeployment(env, secondDeploymentVersionOne) s.ensureCreateVersionInDeployment(env, secondDeploymentVersionOne) // pollers of the second TQ in the same deployment version should be rejected @@ -306,7 +320,7 @@ func (s *WorkerDeploymentSuite) TestNamespaceDeploymentsLimit() { env := s.newTestEnv(testcore.WithDynamicConfig(dynamicconfig.MatchingMaxDeployments, 1)) // First deployment version should be fine - go s.pollFromDeployment(s.Context(), env, s.tv()) + go s.pollFromDeployment(env, s.tv()) s.ensureCreateVersionInDeployment(env, s.tv()) // wait for all existing deployments to show up in visibility @@ -323,7 +337,7 @@ func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_TwoVersions_Sorted( firstVersion := s.tv().WithBuildIDNumber(1) secondVersion := s.tv().WithBuildIDNumber(2) - go s.pollFromDeployment(s.Context(), env, firstVersion) + go s.pollFromDeployment(env, firstVersion) // Wait until the first version is registered in the deployment before starting the second. // This ensures that both versions get distinct CreateTime values in the deployment workflow @@ -332,7 +346,7 @@ func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_TwoVersions_Sorted( // both registrations can queue up and be processed within the same workflow task millisecond. s.ensureCreateVersionInDeployment(env, firstVersion) - go s.pollFromDeployment(s.Context(), env, secondVersion) + go s.pollFromDeployment(env, secondVersion) s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) @@ -372,7 +386,7 @@ func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_MultipleVersions_So numVersions := 10 for i := range numVersions { - go s.pollFromDeployment(s.Context(), env, s.tv().WithBuildIDNumber(i)) + go s.pollFromDeployment(env, s.tv().WithBuildIDNumber(i)) // waiting for 1ms to start the next version later. startTime := time.Now() @@ -410,8 +424,8 @@ func (s *WorkerDeploymentSuite) TestConflictToken_Describe_SetCurrent_SetRamping secondVersion := s.tv().WithBuildIDNumber(2) // Start deployment version workflow + worker-deployment workflow. - go s.pollFromDeployment(s.Context(), env, firstVersion) - go s.pollFromDeployment(s.Context(), env, secondVersion) + go s.pollFromDeployment(env, firstVersion) + go s.pollFromDeployment(env, secondVersion) var cT []byte // No current deployment version set. @@ -450,7 +464,7 @@ func (s *WorkerDeploymentSuite) TestConflictToken_Describe_SetCurrent_SetRamping }, time.Second*10, time.Millisecond*1000) // Set a new second version and set it as the current version - go s.pollFromDeployment(s.Context(), env, secondVersion) + go s.pollFromDeployment(env, secondVersion) _, _ = env.FrontendClient().SetWorkerDeploymentRampingVersion(s.Context(), &workflowservice.SetWorkerDeploymentRampingVersionRequest{ Namespace: env.Namespace().String(), DeploymentName: s.tv().DeploymentSeries(), @@ -480,7 +494,7 @@ func (s *WorkerDeploymentSuite) TestConflictToken_SetCurrent_SetRamping_Wrong() firstVersion := s.tv().WithBuildIDNumber(1) // Start deployment version workflow + worker-deployment workflow. - go s.pollFromDeployment(s.Context(), env, firstVersion) + go s.pollFromDeployment(env, firstVersion) cTWrong, _ := time.Now().MarshalBinary() // wrong token // Wait until deployment exists @@ -521,7 +535,7 @@ func (s *WorkerDeploymentSuite) TestListWorkerDeployments_OneVersion_OneDeployme startTime := timestamppb.Now() - s.startVersionWorkflow(s.Context(), env, s.tv()) + s.startVersionWorkflow(env, s.tv()) s.ensureCreateVersionInDeployment(env, s.tv()) latestVersionSummary := &deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ @@ -559,11 +573,11 @@ func (s *WorkerDeploymentSuite) TestListWorkerDeployments_TwoVersions_SameDeploy secondVersion := s.tv().WithBuildIDNumber(2) createVersion1Time := timestamppb.Now() - s.startVersionWorkflow(s.Context(), env, firstVersion) + s.startVersionWorkflow(env, firstVersion) s.ensureCreateVersionInDeployment(env, firstVersion) createVersion2Time := timestamppb.Now() - s.startVersionWorkflow(s.Context(), env, secondVersion) + s.startVersionWorkflow(env, secondVersion) s.ensureCreateVersionInDeployment(env, secondVersion) setCurrentTime := timestamppb.Now() @@ -621,11 +635,11 @@ func (s *WorkerDeploymentSuite) TestListWorkerDeployments_TwoVersions_SameDeploy rampingVersionVars := s.tv().WithBuildIDNumber(2) createVersion1Time := timestamppb.Now() - s.startVersionWorkflow(s.Context(), env, currentVersionVars) + s.startVersionWorkflow(env, currentVersionVars) s.ensureCreateVersionInDeployment(env, currentVersionVars) createVersion2Time := timestamppb.Now() - s.startVersionWorkflow(s.Context(), env, rampingVersionVars) + s.startVersionWorkflow(env, rampingVersionVars) s.ensureCreateVersionInDeployment(env, rampingVersionVars) setCurrentTime := timestamppb.Now() @@ -684,7 +698,7 @@ func (s *WorkerDeploymentSuite) TestListWorkerDeployments_RampingVersionPercenta env := s.newTestEnv() startTime := timestamppb.Now() - s.startVersionWorkflow(s.Context(), env, s.tv()) + s.startVersionWorkflow(env, s.tv()) setRampTime := timestamppb.Now() s.setAndVerifyRampingVersion(env, s.tv(), false, 50, true, "") // set version as ramping @@ -770,8 +784,8 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Ramping_Wi currentVersionVars := s.tv().WithBuildIDNumber(2) versionCreateTime := timestamppb.Now() - s.startVersionWorkflow(s.Context(), env, rampingVersionVars) - s.startVersionWorkflow(s.Context(), env, currentVersionVars) + s.startVersionWorkflow(env, rampingVersionVars) + s.startVersionWorkflow(env, currentVersionVars) // set version as ramping setRampingUpdateTime := timestamppb.Now() @@ -975,7 +989,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_DuplicateR rampingVersionVars := s.tv().WithBuildIDNumber(1) versionCreateTime := timestamppb.Now() - s.startVersionWorkflow(s.Context(), env, rampingVersionVars) + s.startVersionWorkflow(env, rampingVersionVars) // set version as ramping setRampingUpdateTime := timestamppb.Now() @@ -1023,7 +1037,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Invalid_Se versionCreateTime := timestamppb.Now() currentVersionVars := s.tv().WithBuildIDNumber(1) - s.startVersionWorkflow(s.Context(), env, currentVersionVars) + s.startVersionWorkflow(env, currentVersionVars) setCurrentUpdateTime := timestamppb.Now() s.setCurrentVersion(env, currentVersionVars, true, "") @@ -1105,7 +1119,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Invalid_Se func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Valid_SetNilCurrent_To_Ramping() { env := s.newTestEnv() - s.startVersionWorkflow(s.Context(), env, s.tv().WithBuildIDNumber(1)) + s.startVersionWorkflow(env, s.tv().WithBuildIDNumber(1)) // set ramping version to unversioned will change the modifier identity, so it's not a no-op s.setAndVerifyRampingVersion(env, s.tv().WithBuildIDNumber(1), true, 0, false, "") @@ -1122,7 +1136,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_ModifyExis versionCreateTime := timestamppb.Now() rampingVersionVars := s.tv().WithBuildIDNumber(1) - s.startVersionWorkflow(s.Context(), env, rampingVersionVars) + s.startVersionWorkflow(env, rampingVersionVars) // set version as ramping setRampingUpdateTime := timestamppb.Now() @@ -1209,9 +1223,9 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_WithCurren currentVersionVars := s.tv().WithBuildIDNumber(2) version1CreateTime := timestamppb.Now() - s.startVersionWorkflow(s.Context(), env, rampingVersionVars) + s.startVersionWorkflow(env, rampingVersionVars) version2CreateTime := timestamppb.Now() - s.startVersionWorkflow(s.Context(), env, currentVersionVars) + s.startVersionWorkflow(env, currentVersionVars) setRampingUpdateTime := timestamppb.Now() s.setAndVerifyRampingVersion(env, rampingVersionVars, false, 50, true, "") // set version as ramping @@ -1321,7 +1335,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_SetRamping versionCreateTime := timestamppb.Now() rampingVersionVars := s.tv().WithBuildIDNumber(1) - s.startVersionWorkflow(s.Context(), env, rampingVersionVars) + s.startVersionWorkflow(env, rampingVersionVars) setRampingUpdateTime := timestamppb.Now() s.setAndVerifyRampingVersion(env, rampingVersionVars, false, 50, true, "") @@ -1370,7 +1384,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_NoCurrent_ env := s.newTestEnv() rampingVersionVars := s.tv().WithBuildIDNumber(1) - s.startVersionWorkflow(s.Context(), env, rampingVersionVars) + s.startVersionWorkflow(env, rampingVersionVars) s.setAndVerifyRampingVersion(env, rampingVersionVars, false, 50, true, "") s.setAndVerifyRampingVersion(env, rampingVersionVars, true, 0, true, "") @@ -1385,7 +1399,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Batching() versionCreateTime := timestamppb.Now() taskQueues := 5 for i := range taskQueues { - go s.pollFromDeploymentWithTaskQueueNumber(s.Context(), env, s.tv(), i) + go s.pollFromDeploymentWithTaskQueueNumber(env, s.tv(), i) } // ensure the version has been created in the deployment with the right number of task-queues @@ -1456,7 +1470,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Unversione versionCreateTime := timestamppb.Now() taskQueues := 5 for i := range taskQueues { - go s.pollFromDeploymentWithTaskQueueNumber(s.Context(), env, s.tv(), i) + go s.pollFromDeploymentWithTaskQueueNumber(env, s.tv(), i) } // ensure the version has been created in the deployment with the right number of task-queues @@ -1528,9 +1542,8 @@ func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_SetCurrentVersion() version1CreateTime := timestamppb.Now() // Start poller with cancellable context for deterministic control - pollerCtx, pollerCancel := context.WithCancel(s.Context()) + pollerCancel := s.startDeploymentPoller(env, firstVersion) defer pollerCancel() - go s.pollFromDeployment(pollerCtx, env, firstVersion) // Wait for version to be created deterministically s.ensureCreateVersionInDeployment(env, firstVersion) @@ -1582,9 +1595,8 @@ func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_SetCurrentVersion() // Set a new second version and set it as the current version version2CreateTime := timestamppb.Now() // Start second poller with cancellable context - poller2Ctx, poller2Cancel := context.WithCancel(s.Context()) + poller2Cancel := s.startDeploymentPoller(env, secondVersion) defer poller2Cancel() - go s.pollFromDeployment(poller2Ctx, env, secondVersion) secondVersionCurrentUpdateTime := timestamppb.Now() s.setCurrentVersion(env, secondVersion, true, "") @@ -1643,7 +1655,7 @@ func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Batching() { versionCreateTime := timestamppb.Now() taskQueues := 5 for i := range taskQueues { - go s.pollFromDeploymentWithTaskQueueNumber(s.Context(), env, s.tv(), i) + go s.pollFromDeploymentWithTaskQueueNumber(env, s.tv(), i) } // ensure the version has been created in the deployment with the right number of task-queues @@ -1706,7 +1718,7 @@ func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Batching() { func (s *WorkerDeploymentSuite) TestSetManagerIdentity_RW() { env := s.newTestEnv() - go s.pollFromDeployment(s.Context(), env, s.tv().WithBuildIDNumber(1)) + go s.pollFromDeployment(env, s.tv().WithBuildIDNumber(1)) s.ensureCreateVersionInDeployment(env, s.tv().WithBuildIDNumber(1)) // set identity to self @@ -1728,7 +1740,7 @@ func (s *WorkerDeploymentSuite) TestSetManagerIdentity_RW() { func (s *WorkerDeploymentSuite) TestSetManagerIdentity_WithSetRampSetCurrent() { env := s.newTestEnv() - go s.pollFromDeployment(s.Context(), env, s.tv().WithBuildIDNumber(1)) + go s.pollFromDeployment(env, s.tv().WithBuildIDNumber(1)) s.ensureCreateVersionInDeployment(env, s.tv().WithBuildIDNumber(1)) // set identity to self @@ -1758,8 +1770,7 @@ func (s *WorkerDeploymentSuite) TestSetManagerIdentity_WithDeleteVersion() { env := s.newTestEnv(testcore.WithDynamicConfig(dynamicconfig.PollerHistoryTTL, 500*time.Millisecond)) // start and stop polling so that version is eligible for deletion - pollerCtx, pollerCancel := context.WithCancel(s.Context()) - go s.pollFromDeployment(pollerCtx, env, s.tv().WithBuildIDNumber(1)) + pollerCancel := s.startDeploymentPoller(env, s.tv().WithBuildIDNumber(1)) s.ensureCreateVersionInDeployment(env, s.tv().WithBuildIDNumber(1)) pollerCancel() @@ -1787,8 +1798,7 @@ func (s *WorkerDeploymentSuite) TestDeleteVersion_ServerDeleteMaxVersionsReached tv2 := s.tv().WithBuildIDNumber(2) // start and stop polling so that version is eligible for deletion - pollerCtx, pollerCancel := context.WithCancel(s.Context()) - go s.pollFromDeployment(pollerCtx, env, tv1) + pollerCancel := s.startDeploymentPoller(env, tv1) s.ensureCreateVersionInDeployment(env, tv1) pollerCancel() @@ -1797,8 +1807,7 @@ func (s *WorkerDeploymentSuite) TestDeleteVersion_ServerDeleteMaxVersionsReached s.setAndValidateManagerIdentity(env, tv1, false, false, "other", "") // Start another poller which shall aim to create a new version. This should, in turn, delete the first version. - pollerCtx2, pollerCancel2 := context.WithCancel(s.Context()) - go s.pollFromDeployment(pollerCtx2, env, tv2) + pollerCancel2 := s.startDeploymentPoller(env, tv2) s.ensureCreateVersionInDeployment(env, tv2) pollerCancel2() @@ -1825,7 +1834,7 @@ func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Unversioned_NoRamp() { currentVars := s.tv().WithBuildIDNumber(1) versionCreateTime := timestamppb.Now() - go s.pollFromDeployment(s.Context(), env, currentVars) + go s.pollFromDeployment(env, currentVars) s.ensureCreateVersionInDeployment(env, currentVars) // check that the current version's task queues have current version unversioned to start @@ -1880,7 +1889,7 @@ func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Unversioned_PromoteUnversi currentVars := s.tv().WithBuildIDNumber(1) - go s.pollFromDeployment(s.Context(), env, currentVars) + go s.pollFromDeployment(env, currentVars) s.ensureCreateVersionInDeployment(env, currentVars) // make the current version versioned, so that we can set ramp to unversioned @@ -1904,7 +1913,7 @@ func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Concurrent_DifferentVersio versions := 10 for i := range versions { - s.startVersionWorkflow(s.Context(), env, s.tv().WithBuildIDNumber(i)) + s.startVersionWorkflow(env, s.tv().WithBuildIDNumber(i)) } // Concurrently set 10 different versions as current version @@ -1949,7 +1958,7 @@ func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Concurrent_SameVersion_NoU errChan := make(chan error) - s.startVersionWorkflow(s.Context(), env, s.tv()) // create version + s.startVersionWorkflow(env, s.tv()) // create version // Concurrently set the same version as current version 10 times. for range 10 { @@ -1998,7 +2007,7 @@ func (s *WorkerDeploymentSuite) TestConcurrentPollers_DifferentTaskQueues_SameVe tqs := 10 // Start all pollers concurrently (pollFromDeployment has no assertions, so it's safe to call from goroutines) for i := range tqs { - go s.pollFromDeployment(s.Context(), env, s.tv().WithTaskQueueNumber(i)) + go s.pollFromDeployment(env, s.tv().WithTaskQueueNumber(i)) } // Wait for all version workflows to appear (must run in the test goroutine due to assertions) for i := range tqs { @@ -2030,7 +2039,7 @@ func (s *WorkerDeploymentSuite) TestSetRampingVersion_Concurrent_DifferentVersio versions := 10 for i := range versions { - s.startVersionWorkflow(s.Context(), env, s.tv().WithBuildIDNumber(i)) + s.startVersionWorkflow(env, s.tv().WithBuildIDNumber(i)) } // Concurrently set 10 different versions as ramping version @@ -2076,7 +2085,7 @@ func (s *WorkerDeploymentSuite) TestSetRampingVersion_Concurrent_SameVersion_NoU errChan := make(chan error) - s.startVersionWorkflow(s.Context(), env, s.tv()) // create version + s.startVersionWorkflow(env, s.tv()) // create version // Concurrently set the same version as ramping version 10 times. for range 10 { @@ -2149,7 +2158,7 @@ func (s *WorkerDeploymentSuite) TestConcurrentPollers_ManyTaskQueues_RapidRoutin sendPollers := func() { for j := range numTaskQueues { - go s.pollFromDeployment(pollCtx, env, s.tv().WithBuildIDNumber(i).WithTaskQueueNumber(j)) + go s.pollFromDeploymentWithContext(pollCtx, env, s.tv().WithBuildIDNumber(i).WithTaskQueueNumber(j)) } } @@ -2281,7 +2290,7 @@ func (s *WorkerDeploymentSuite) TestResourceExhaustedErrors_Converted_To_Readabl // Start all version workflows first for i := range versions { - s.startVersionWorkflow(s.Context(), env, s.tv().WithBuildIDNumber(i)) + s.startVersionWorkflow(env, s.tv().WithBuildIDNumber(i)) } // Test SetRampingVersion @@ -2357,7 +2366,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Unversione env := s.newTestEnv() rampingVars := s.tv().WithBuildIDNumber(1) - s.startVersionWorkflow(s.Context(), env, rampingVars) + s.startVersionWorkflow(env, rampingVars) s.setAndVerifyRampingVersionUnversionedOption(env, rampingVars, true, false, 50, true, false, true, "ramping version __unversioned__ is already current") } @@ -2367,7 +2376,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Unversione currentVars := s.tv().WithBuildIDNumber(1) - go s.pollFromDeployment(s.Context(), env, currentVars) + go s.pollFromDeployment(env, currentVars) s.ensureCreateVersionInDeployment(env, currentVars) // check that the current version's task queues have ramping version == "" @@ -2404,7 +2413,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentCurrentVersion_NoPollers( s.setCurrentVersionAllowNoPollersOption(env, s.tv().WithBuildIDNumber(1), true, allowNoPollers, false, expectedErr) // let a poller arrive with that version --> triggers user data propagation - go s.pollFromDeployment(s.Context(), env, s.tv().WithBuildIDNumber(1)) + go s.pollFromDeployment(env, s.tv().WithBuildIDNumber(1)) s.Await(func(s *WorkerDeploymentSuite) { // check describe worker deployment @@ -2457,7 +2466,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_NoPollers( s.setAndVerifyRampingVersionUnversionedOption(env, s.tv().WithBuildIDNumber(1), false, false, 5, true, allowNoPollers, false, expectedErr) // let a poller arrive with that version --> triggers user data propagation - go s.pollFromDeployment(s.Context(), env, s.tv().WithBuildIDNumber(1)) + go s.pollFromDeployment(env, s.tv().WithBuildIDNumber(1)) s.Await(func(s *WorkerDeploymentSuite) { // check describe worker deployment @@ -2504,8 +2513,8 @@ func (s *WorkerDeploymentSuite) TestTwoPollers_EnsureCreateVersion() { tv1 := s.tv().WithBuildIDNumber(1) tv2 := s.tv().WithBuildIDNumber(2) - go s.pollFromDeployment(s.Context(), env, tv1) - go s.pollFromDeployment(s.Context(), env, tv2) + go s.pollFromDeployment(env, tv1) + go s.pollFromDeployment(env, tv2) s.ensureCreateVersionWithExpectedTaskQueues(env, tv1, 1) s.ensureCreateVersionWithExpectedTaskQueues(env, tv2, 1) } @@ -2540,7 +2549,7 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { // Start deployment workflow 1 and wait for the deployment version to exist v1CreateTime := timestamppb.New(time.Now()) - s.startVersionWorkflow(s.Context(), env, tv1) + s.startVersionWorkflow(env, tv1) // Set v1 as current version setCurrentV1UpdateTime := timestamppb.Now() @@ -2578,7 +2587,7 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { // Start deployment workflow 2 and set v2 to current so that v1 can start draining v2CreateTime := timestamppb.New(time.Now()) - s.startVersionWorkflow(s.Context(), env, tv2) + s.startVersionWorkflow(env, tv2) setCurrentV2UpdateTime := timestamppb.New(time.Now()) s.setCurrentVersion(env, tv2, true, "") @@ -2812,7 +2821,7 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { // Roll out a new version v3 and set it to current v3CreateTime := timestamppb.Now() - s.startVersionWorkflow(s.Context(), env, tv3) + s.startVersionWorkflow(env, tv3) newCurrentV3UpdateTime := timestamppb.Now() s.setCurrentVersion(env, tv3, true, "") @@ -2901,7 +2910,7 @@ func (s *WorkerDeploymentSuite) TestSetRampingVersion_AfterDrained() { // Start deployment workflow 1 and wait for the deployment version to exist v1CreateTime := timestamppb.New(time.Now()) - s.startVersionWorkflow(s.Context(), env, tv1) + s.startVersionWorkflow(env, tv1) // Set v1 as current version setCurrentV1UpdateTime := timestamppb.Now() @@ -2939,7 +2948,7 @@ func (s *WorkerDeploymentSuite) TestSetRampingVersion_AfterDrained() { // Start deployment workflow 2 and set v2 to current so that v1 can start draining v2CreateTime := timestamppb.New(time.Now()) - s.startVersionWorkflow(s.Context(), env, tv2) + s.startVersionWorkflow(env, tv2) setCurrentV2UpdateTime := timestamppb.New(time.Now()) s.setCurrentVersion(env, tv2, true, "") @@ -3114,9 +3123,9 @@ func (s *WorkerDeploymentSuite) TestDeleteWorkerDeployment_ValidDelete() { // Start deployment workflow 1 and wait for the deployment version to exist // Use a cancellable context so we can stop the poller before checking pollers disappeared - pollerCtx, pollerCancel := context.WithCancel(s.Context()) + pollerCancel := s.startDeploymentPoller(env, tv1) defer pollerCancel() - s.startVersionWorkflow(pollerCtx, env, tv1) + s.waitForDeploymentVersion(env, tv1) // Signal the first version to be drained. Only do this in tests. versionWorkflowID := workerdeployment.GenerateVersionWorkflowID(tv1.DeploymentSeries(), tv1.BuildID()) @@ -3231,7 +3240,7 @@ func (s *WorkerDeploymentSuite) TestDeleteWorkerDeployment_InvalidDelete() { tv1 := s.tv().WithBuildIDNumber(1) // Start deployment workflow 1 and wait for the deployment version and deployment workflow to exist - go s.pollFromDeployment(s.Context(), env, tv1) + go s.pollFromDeployment(env, tv1) s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) resp, err := env.FrontendClient().DescribeWorkerDeploymentVersion(s.Context(), &workflowservice.DescribeWorkerDeploymentVersionRequest{ @@ -3533,7 +3542,7 @@ func (s *WorkerDeploymentSuite) createVersionsInDeployments(env *testcore.TestEn version := deployment.WithBuildIDNumber(i) startTime := timestamppb.Now() - s.startVersionWorkflow(s.Context(), env, version) + s.startVersionWorkflow(env, version) setCurrentTime := timestamppb.Now() s.setCurrentVersion(env, version, true, "") @@ -3768,7 +3777,7 @@ func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_AutoCreatedByPoller_C env := s.newTestEnv() // First, create deployment via polling - go s.pollFromDeployment(s.Context(), env, s.tv()) + go s.pollFromDeployment(env, s.tv()) s.ensureCreateDeployment(env, s.tv()) // Try to explicitly create the same deployment From 658cbadc4e1e0d86b7af3c899c522e51b41ac3a4 Mon Sep 17 00:00:00 2001 From: Stephan Behnke Date: Thu, 18 Jun 2026 16:28:52 -0700 Subject: [PATCH 07/27] rename --- tests/worker_deployment_test.go | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/tests/worker_deployment_test.go b/tests/worker_deployment_test.go index fed4c7cc9db..f69993370b3 100644 --- a/tests/worker_deployment_test.go +++ b/tests/worker_deployment_test.go @@ -70,10 +70,10 @@ func (s *WorkerDeploymentSuite) newTestEnv(opts ...testcore.TestOption) *testcor // pollFromDeployment calls PollWorkflowTaskQueue to start deployment related workflows func (s *WorkerDeploymentSuite) pollFromDeployment(env *testcore.TestEnv, tv *testvars.TestVars) { - s.pollFromDeploymentWithContext(s.Context(), env, tv) + s.pollFromDeploymentUntil(s.Context(), env, tv) } -func (s *WorkerDeploymentSuite) pollFromDeploymentWithContext(ctx context.Context, env *testcore.TestEnv, tv *testvars.TestVars) { +func (s *WorkerDeploymentSuite) pollFromDeploymentUntil(ctx context.Context, env *testcore.TestEnv, tv *testvars.TestVars) { _, _ = env.FrontendClient().PollWorkflowTaskQueue(ctx, &workflowservice.PollWorkflowTaskQueueRequest{ Namespace: env.Namespace().String(), TaskQueue: tv.TaskQueue(), @@ -84,7 +84,7 @@ func (s *WorkerDeploymentSuite) pollFromDeploymentWithContext(ctx context.Contex func (s *WorkerDeploymentSuite) startDeploymentPoller(env *testcore.TestEnv, tv *testvars.TestVars) context.CancelFunc { ctx, cancel := context.WithCancel(s.Context()) - go s.pollFromDeploymentWithContext(ctx, env, tv) + go s.pollFromDeploymentUntil(ctx, env, tv) return cancel } @@ -2158,7 +2158,7 @@ func (s *WorkerDeploymentSuite) TestConcurrentPollers_ManyTaskQueues_RapidRoutin sendPollers := func() { for j := range numTaskQueues { - go s.pollFromDeploymentWithContext(pollCtx, env, s.tv().WithBuildIDNumber(i).WithTaskQueueNumber(j)) + go s.pollFromDeploymentUntil(pollCtx, env, s.tv().WithBuildIDNumber(i).WithTaskQueueNumber(j)) } } From 5c20a94482ba135f45d8e1fef545dc6edc8c3e9f Mon Sep 17 00:00:00 2001 From: Stephan Behnke Date: Thu, 18 Jun 2026 16:33:50 -0700 Subject: [PATCH 08/27] Update worker_deployment_test.go --- tests/worker_deployment_test.go | 588 ++++++++++++++++---------------- 1 file changed, 294 insertions(+), 294 deletions(-) diff --git a/tests/worker_deployment_test.go b/tests/worker_deployment_test.go index f69993370b3..7a4912ccf79 100644 --- a/tests/worker_deployment_test.go +++ b/tests/worker_deployment_test.go @@ -64,6 +64,10 @@ func (s *WorkerDeploymentSuite) newTestEnv(opts ...testcore.TestOption) *testcor }), testcore.WithDynamicConfig(dynamicconfig.MatchingMaxTaskQueuesInDeploymentVersion, 1000), + + testcore.WithTestVars(func(tv *testvars.TestVars) *testvars.TestVars { + return tv.WithBuildIDNumber(1) + }), } return testcore.NewEnv(s.T(), append(baseOpts, opts...)...) } @@ -186,24 +190,24 @@ func (s *WorkerDeploymentSuite) TestForceCAN_NoOpenWFS() { env := s.newTestEnv() // Start a version workflow - s.startVersionWorkflow(env, s.tv()) - s.ensureCreateVersionInDeployment(env, s.tv()) + s.startVersionWorkflow(env, env.Tv()) + s.ensureCreateVersionInDeployment(env, env.Tv()) // Set the version as current _, err := env.FrontendClient().SetWorkerDeploymentCurrentVersion(s.Context(), &workflowservice.SetWorkerDeploymentCurrentVersionRequest{ Namespace: env.Namespace().String(), - DeploymentName: s.tv().DeploymentSeries(), - Version: s.tv().DeploymentVersionString(), + DeploymentName: env.Tv().DeploymentSeries(), + Version: env.Tv().DeploymentVersionString(), }) s.NoError(err) // ForceCAN - workflowID := workerdeployment.GenerateDeploymentWorkflowID(s.tv().DeploymentSeries()) + workflowID := workerdeployment.GenerateDeploymentWorkflowID(env.Tv().DeploymentSeries()) workflowExecution := &commonpb.WorkflowExecution{ WorkflowId: workflowID, } - err = env.SendSignal(env.Namespace().String(), workflowExecution, workerdeployment.ForceCANSignalName, nil, s.tv().ClientIdentity()) + err = env.SendSignal(env.Namespace().String(), workflowExecution, workerdeployment.ForceCANSignalName, nil, env.Tv().ClientIdentity()) s.NoError(err) // Verify if the state is intact even after a CAN @@ -211,10 +215,10 @@ func (s *WorkerDeploymentSuite) TestForceCAN_NoOpenWFS() { a := require.New(t) resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: s.tv().DeploymentSeries(), + DeploymentName: env.Tv().DeploymentSeries(), }) a.NoError(err) - a.Equal(s.tv().DeploymentVersionString(), resp.GetWorkerDeploymentInfo().GetRoutingConfig().GetCurrentVersion()) //nolint:staticcheck // SA1019: old worker versioning + a.Equal(env.Tv().DeploymentVersionString(), resp.GetWorkerDeploymentInfo().GetRoutingConfig().GetCurrentVersion()) //nolint:staticcheck // SA1019: old worker versioning }, time.Second*10, time.Millisecond*1000) } @@ -222,22 +226,22 @@ func (s *WorkerDeploymentSuite) TestForceCAN_WithOverrideState() { env := s.newTestEnv() // Start a version workflow - s.startVersionWorkflow(env, s.tv()) - s.ensureCreateVersionInDeployment(env, s.tv()) + s.startVersionWorkflow(env, env.Tv()) + s.ensureCreateVersionInDeployment(env, env.Tv()) // Set the version as current _, err := env.FrontendClient().SetWorkerDeploymentCurrentVersion(s.Context(), &workflowservice.SetWorkerDeploymentCurrentVersionRequest{ Namespace: env.Namespace().String(), - DeploymentName: s.tv().DeploymentSeries(), - Version: s.tv().DeploymentVersionString(), + DeploymentName: env.Tv().DeploymentSeries(), + Version: env.Tv().DeploymentVersionString(), }) s.NoError(err) // Create a modified state with a different manager identity overrideState := &deploymentspb.WorkerDeploymentLocalState{ CreateTime: timestamppb.New(time.Now()), - RoutingConfig: &deploymentpb.RoutingConfig{CurrentVersion: s.tv().DeploymentVersionString()}, - Versions: map[string]*deploymentspb.WorkerDeploymentVersionSummary{s.tv().DeploymentVersionString(): {Version: s.tv().DeploymentVersionString(), CreateTime: timestamppb.New(time.Now())}}, + RoutingConfig: &deploymentpb.RoutingConfig{CurrentVersion: env.Tv().DeploymentVersionString()}, + Versions: map[string]*deploymentspb.WorkerDeploymentVersionSummary{env.Tv().DeploymentVersionString(): {Version: env.Tv().DeploymentVersionString(), CreateTime: timestamppb.New(time.Now())}}, LastModifierIdentity: "override-test-identity", ManagerIdentity: "override-manager-identity", } @@ -260,12 +264,12 @@ func (s *WorkerDeploymentSuite) TestForceCAN_WithOverrideState() { } // Send ForceCAN signal with override state - workflowID := workerdeployment.GenerateDeploymentWorkflowID(s.tv().DeploymentSeries()) + workflowID := workerdeployment.GenerateDeploymentWorkflowID(env.Tv().DeploymentSeries()) workflowExecution := &commonpb.WorkflowExecution{ WorkflowId: workflowID, } - err = env.SendSignal(env.Namespace().String(), workflowExecution, workerdeployment.ForceCANSignalName, signalPayload, s.tv().ClientIdentity()) + err = env.SendSignal(env.Namespace().String(), workflowExecution, workerdeployment.ForceCANSignalName, signalPayload, env.Tv().ClientIdentity()) s.NoError(err) // Verify that the override state is used after CAN @@ -273,7 +277,7 @@ func (s *WorkerDeploymentSuite) TestForceCAN_WithOverrideState() { a := require.New(t) resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: s.tv().DeploymentSeries(), + DeploymentName: env.Tv().DeploymentSeries(), }) a.NoError(err) a.Equal("override-manager-identity", resp.GetWorkerDeploymentInfo().GetManagerIdentity()) @@ -286,8 +290,8 @@ func (s *WorkerDeploymentSuite) TestDeploymentVersionLimits() { testcore.WithDynamicConfig(dynamicconfig.MatchingMaxTaskQueuesInDeploymentVersion, 1), ) - firstDeployment := s.tv().WithDeploymentSeriesNumber(1) - secondDeployment := s.tv().WithDeploymentSeriesNumber(2) + firstDeployment := env.Tv().WithDeploymentSeriesNumber(1) + secondDeployment := env.Tv().WithDeploymentSeriesNumber(2) firstDeploymentVersionOne := firstDeployment.WithBuildIDNumber(1) firstDeploymentVersionTwo := firstDeployment.WithBuildIDNumber(2) @@ -320,22 +324,22 @@ func (s *WorkerDeploymentSuite) TestNamespaceDeploymentsLimit() { env := s.newTestEnv(testcore.WithDynamicConfig(dynamicconfig.MatchingMaxDeployments, 1)) // First deployment version should be fine - go s.pollFromDeployment(env, s.tv()) - s.ensureCreateVersionInDeployment(env, s.tv()) + go s.pollFromDeployment(env, env.Tv()) + s.ensureCreateVersionInDeployment(env, env.Tv()) // wait for all existing deployments to show up in visibility s.validateWorkerDeploymentCount(env, &workflowservice.ListWorkerDeploymentsRequest{Namespace: env.Namespace().String()}, 1) // pollers of the second deployment version should be rejected - s.pollFromDeploymentExpectFail(env, s.tv().WithDeploymentSeriesNumber(2), "reached maximum deployments in namespace (1)") + s.pollFromDeploymentExpectFail(env, env.Tv().WithDeploymentSeriesNumber(2), "reached maximum deployments in namespace (1)") } func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_TwoVersions_Sorted() { env := s.newTestEnv() // Starting two versions of the deployment - firstVersion := s.tv().WithBuildIDNumber(1) - secondVersion := s.tv().WithBuildIDNumber(2) + firstVersion := env.Tv() + secondVersion := env.Tv().WithBuildIDNumber(2) go s.pollFromDeployment(env, firstVersion) @@ -353,11 +357,11 @@ func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_TwoVersions_Sorted( resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: s.tv().DeploymentSeries(), + DeploymentName: env.Tv().DeploymentSeries(), }) a.NoError(err) a.NotNil(resp.GetWorkerDeploymentInfo()) - a.Equal(s.tv().DeploymentSeries(), resp.GetWorkerDeploymentInfo().GetName()) + a.Equal(env.Tv().DeploymentSeries(), resp.GetWorkerDeploymentInfo().GetName()) a.NotNil(resp.GetWorkerDeploymentInfo().GetVersionSummaries()) a.Len(resp.GetWorkerDeploymentInfo().GetVersionSummaries(), 2) @@ -386,7 +390,7 @@ func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_MultipleVersions_So numVersions := 10 for i := range numVersions { - go s.pollFromDeployment(env, s.tv().WithBuildIDNumber(i)) + go s.pollFromDeployment(env, env.Tv().WithBuildIDNumber(i)) // waiting for 1ms to start the next version later. startTime := time.Now() @@ -401,7 +405,7 @@ func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_MultipleVersions_So resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: s.tv().DeploymentSeries(), + DeploymentName: env.Tv().DeploymentSeries(), }) a.NoError(err) @@ -420,8 +424,8 @@ func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_MultipleVersions_So func (s *WorkerDeploymentSuite) TestConflictToken_Describe_SetCurrent_SetRamping() { env := s.newTestEnv() - firstVersion := s.tv().WithBuildIDNumber(1) - secondVersion := s.tv().WithBuildIDNumber(2) + firstVersion := env.Tv() + secondVersion := env.Tv().WithBuildIDNumber(2) // Start deployment version workflow + worker-deployment workflow. go s.pollFromDeployment(env, firstVersion) @@ -434,7 +438,7 @@ func (s *WorkerDeploymentSuite) TestConflictToken_Describe_SetCurrent_SetRamping resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: s.tv().DeploymentSeries(), + DeploymentName: env.Tv().DeploymentSeries(), }) a.NoError(err) a.Equal(worker_versioning.UnversionedVersionId, resp.GetWorkerDeploymentInfo().GetRoutingConfig().GetCurrentVersion()) @@ -445,7 +449,7 @@ func (s *WorkerDeploymentSuite) TestConflictToken_Describe_SetCurrent_SetRamping // Set first version as current version _, err := env.FrontendClient().SetWorkerDeploymentCurrentVersion(s.Context(), &workflowservice.SetWorkerDeploymentCurrentVersionRequest{ Namespace: env.Namespace().String(), - DeploymentName: s.tv().DeploymentSeries(), + DeploymentName: env.Tv().DeploymentSeries(), Version: firstVersion.DeploymentVersionString(), ConflictToken: cT, }) @@ -456,7 +460,7 @@ func (s *WorkerDeploymentSuite) TestConflictToken_Describe_SetCurrent_SetRamping resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: s.tv().DeploymentSeries(), + DeploymentName: env.Tv().DeploymentSeries(), }) a.NoError(err) a.Equal(firstVersion.DeploymentVersionString(), resp.GetWorkerDeploymentInfo().GetRoutingConfig().GetCurrentVersion()) @@ -467,7 +471,7 @@ func (s *WorkerDeploymentSuite) TestConflictToken_Describe_SetCurrent_SetRamping go s.pollFromDeployment(env, secondVersion) _, _ = env.FrontendClient().SetWorkerDeploymentRampingVersion(s.Context(), &workflowservice.SetWorkerDeploymentRampingVersionRequest{ Namespace: env.Namespace().String(), - DeploymentName: s.tv().DeploymentSeries(), + DeploymentName: env.Tv().DeploymentSeries(), Version: secondVersion.DeploymentVersionString(), Percentage: 5, ConflictToken: cT, @@ -479,7 +483,7 @@ func (s *WorkerDeploymentSuite) TestConflictToken_Describe_SetCurrent_SetRamping a := require.New(t) resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: s.tv().DeploymentSeries(), + DeploymentName: env.Tv().DeploymentSeries(), }) a.NoError(err) a.Equal(secondVersion.DeploymentVersionString(), resp.GetWorkerDeploymentInfo().GetRoutingConfig().GetRampingVersion()) @@ -491,7 +495,7 @@ func (s *WorkerDeploymentSuite) TestConflictToken_SetCurrent_SetRamping_Wrong() expectedError := "conflict token mismatch" - firstVersion := s.tv().WithBuildIDNumber(1) + firstVersion := env.Tv() // Start deployment version workflow + worker-deployment workflow. go s.pollFromDeployment(env, firstVersion) @@ -502,7 +506,7 @@ func (s *WorkerDeploymentSuite) TestConflictToken_SetCurrent_SetRamping_Wrong() a := require.New(t) resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: s.tv().DeploymentSeries(), + DeploymentName: env.Tv().DeploymentSeries(), }) a.NoError(err) a.Equal(worker_versioning.UnversionedVersionId, resp.GetWorkerDeploymentInfo().GetRoutingConfig().GetCurrentVersion()) @@ -511,7 +515,7 @@ func (s *WorkerDeploymentSuite) TestConflictToken_SetCurrent_SetRamping_Wrong() // Set first version as current version with wrong token _, err := env.FrontendClient().SetWorkerDeploymentCurrentVersion(s.Context(), &workflowservice.SetWorkerDeploymentCurrentVersionRequest{ Namespace: env.Namespace().String(), - DeploymentName: s.tv().DeploymentSeries(), + DeploymentName: env.Tv().DeploymentSeries(), Version: firstVersion.DeploymentVersionString(), ConflictToken: cTWrong, }) @@ -520,7 +524,7 @@ func (s *WorkerDeploymentSuite) TestConflictToken_SetCurrent_SetRamping_Wrong() // Set first version as ramping version with wrong token _, err = env.FrontendClient().SetWorkerDeploymentRampingVersion(s.Context(), &workflowservice.SetWorkerDeploymentRampingVersionRequest{ Namespace: env.Namespace().String(), - DeploymentName: s.tv().DeploymentSeries(), + DeploymentName: env.Tv().DeploymentSeries(), Version: firstVersion.DeploymentVersionString(), Percentage: 5, ConflictToken: cTWrong, @@ -535,11 +539,11 @@ func (s *WorkerDeploymentSuite) TestListWorkerDeployments_OneVersion_OneDeployme startTime := timestamppb.Now() - s.startVersionWorkflow(env, s.tv()) - s.ensureCreateVersionInDeployment(env, s.tv()) + s.startVersionWorkflow(env, env.Tv()) + s.ensureCreateVersionInDeployment(env, env.Tv()) latestVersionSummary := &deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ - Version: s.tv().DeploymentVersionString(), + Version: env.Tv().DeploymentVersionString(), CreateTime: startTime, DrainageInfo: nil, RampingSinceTime: nil, @@ -551,7 +555,7 @@ func (s *WorkerDeploymentSuite) TestListWorkerDeployments_OneVersion_OneDeployme } expectedDeploymentSummaries := s.buildWorkerDeploymentSummary( - s.tv().DeploymentSeries(), + env.Tv().DeploymentSeries(), startTime, &deploymentpb.RoutingConfig{ CurrentVersion: worker_versioning.UnversionedVersionId, // default current version is __unversioned__ @@ -569,8 +573,8 @@ func (s *WorkerDeploymentSuite) TestListWorkerDeployments_OneVersion_OneDeployme func (s *WorkerDeploymentSuite) TestListWorkerDeployments_TwoVersions_SameDeployment_OneCurrent_NoRamping() { env := s.newTestEnv() - firstVersion := s.tv().WithBuildIDNumber(1) - secondVersion := s.tv().WithBuildIDNumber(2) + firstVersion := env.Tv() + secondVersion := env.Tv().WithBuildIDNumber(2) createVersion1Time := timestamppb.Now() s.startVersionWorkflow(env, firstVersion) @@ -613,7 +617,7 @@ func (s *WorkerDeploymentSuite) TestListWorkerDeployments_TwoVersions_SameDeploy } expectedDeploymentSummary := s.buildWorkerDeploymentSummary( - s.tv().DeploymentSeries(), + env.Tv().DeploymentSeries(), createVersion1Time, routingInfo, latestVersionSummary, @@ -631,8 +635,8 @@ func (s *WorkerDeploymentSuite) TestListWorkerDeployments_TwoVersions_SameDeploy func (s *WorkerDeploymentSuite) TestListWorkerDeployments_TwoVersions_SameDeployment_OneCurrent_OneRamping() { env := s.newTestEnv() - currentVersionVars := s.tv().WithBuildIDNumber(1) - rampingVersionVars := s.tv().WithBuildIDNumber(2) + currentVersionVars := env.Tv() + rampingVersionVars := env.Tv().WithBuildIDNumber(2) createVersion1Time := timestamppb.Now() s.startVersionWorkflow(env, currentVersionVars) @@ -679,7 +683,7 @@ func (s *WorkerDeploymentSuite) TestListWorkerDeployments_TwoVersions_SameDeploy } expectedDeploymentSummary := s.buildWorkerDeploymentSummary( - s.tv().DeploymentSeries(), + env.Tv().DeploymentSeries(), createVersion1Time, routingInfo, latestVersionSummary, @@ -698,14 +702,14 @@ func (s *WorkerDeploymentSuite) TestListWorkerDeployments_RampingVersionPercenta env := s.newTestEnv() startTime := timestamppb.Now() - s.startVersionWorkflow(env, s.tv()) + s.startVersionWorkflow(env, env.Tv()) setRampTime := timestamppb.Now() - s.setAndVerifyRampingVersion(env, s.tv(), false, 50, true, "") // set version as ramping + s.setAndVerifyRampingVersion(env, env.Tv(), false, 50, true, "") // set version as ramping routingInfo := &deploymentpb.RoutingConfig{ CurrentVersion: worker_versioning.UnversionedVersionId, CurrentVersionChangedTime: nil, - RampingVersion: s.tv().DeploymentVersionString(), + RampingVersion: env.Tv().DeploymentVersionString(), RampingVersionPercentage: 50, RampingVersionChangedTime: setRampTime, RampingVersionPercentageChangedTime: setRampTime, @@ -717,7 +721,7 @@ func (s *WorkerDeploymentSuite) TestListWorkerDeployments_RampingVersionPercenta changeRampTime := timestamppb.Now() // modify ramping version percentage - s.setAndVerifyRampingVersion(env, s.tv(), false, 75, true, "") + s.setAndVerifyRampingVersion(env, env.Tv(), false, 75, true, "") // only the ramping version percentage should be updated, not the ramping version update time // since we are not changing the ramping version @@ -725,7 +729,7 @@ func (s *WorkerDeploymentSuite) TestListWorkerDeployments_RampingVersionPercenta routingInfo.RampingVersionPercentageChangedTime = changeRampTime rampingVersionSummary := &deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ - Version: s.tv().DeploymentVersionString(), + Version: env.Tv().DeploymentVersionString(), CreateTime: startTime, DrainageInfo: nil, RampingSinceTime: setRampTime, @@ -737,7 +741,7 @@ func (s *WorkerDeploymentSuite) TestListWorkerDeployments_RampingVersionPercenta } expectedDeploymentSummary := s.buildWorkerDeploymentSummary( - s.tv().DeploymentSeries(), + env.Tv().DeploymentSeries(), startTime, routingInfo, rampingVersionSummary, // latest version added is the ramping version @@ -756,7 +760,7 @@ func (s *WorkerDeploymentSuite) TestListWorkerDeployments_RampingVersionPercenta func (s *WorkerDeploymentSuite) TestListWorkerDeployments_MultipleVersions_MultipleDeployments_OnePage() { env := s.newTestEnv() - expectedDeploymentSummaries := s.createVersionsInDeployments(env, s.tv(), 2) + expectedDeploymentSummaries := s.createVersionsInDeployments(env, env.Tv(), 2) s.startAndValidateWorkerDeployments(env, &workflowservice.ListWorkerDeploymentsRequest{ Namespace: env.Namespace().String(), @@ -767,7 +771,7 @@ func (s *WorkerDeploymentSuite) TestListWorkerDeployments_MultipleVersions_Multi env := s.newTestEnv() - expectedDeploymentSummaries := s.createVersionsInDeployments(env, s.tv(), 5) + expectedDeploymentSummaries := s.createVersionsInDeployments(env, env.Tv(), 5) s.startAndValidateWorkerDeployments(env, &workflowservice.ListWorkerDeploymentsRequest{ Namespace: env.Namespace().String(), @@ -780,8 +784,8 @@ func (s *WorkerDeploymentSuite) TestListWorkerDeployments_MultipleVersions_Multi func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Ramping_With_Current() { env := s.newTestEnv() - rampingVersionVars := s.tv().WithBuildIDNumber(1) - currentVersionVars := s.tv().WithBuildIDNumber(2) + rampingVersionVars := env.Tv() + currentVersionVars := env.Tv().WithBuildIDNumber(2) versionCreateTime := timestamppb.Now() s.startVersionWorkflow(env, rampingVersionVars) @@ -792,12 +796,12 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Ramping_Wi s.setAndVerifyRampingVersion(env, rampingVersionVars, false, 50, true, "") resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: s.tv().DeploymentSeries(), + DeploymentName: env.Tv().DeploymentSeries(), }) s.NoError(err) s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ - Name: s.tv().DeploymentSeries(), + Name: env.Tv().DeploymentSeries(), CreateTime: versionCreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ RampingVersion: rampingVersionVars.DeploymentVersionString(), @@ -820,7 +824,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Ramping_Wi Status: enumspb.WORKER_DEPLOYMENT_VERSION_STATUS_RAMPING, }, }, - LastModifierIdentity: s.tv().ClientIdentity(), + LastModifierIdentity: env.Tv().ClientIdentity(), }, }) @@ -831,12 +835,12 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Ramping_Wi // fresh DescribeWorkerDeployment call resp, err = env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: s.tv().DeploymentSeries(), + DeploymentName: env.Tv().DeploymentSeries(), }) s.NoError(err) s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ - Name: s.tv().DeploymentSeries(), + Name: env.Tv().DeploymentSeries(), CreateTime: versionCreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ RampingVersion: rampingVersionVars.DeploymentVersionString(), @@ -871,7 +875,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Ramping_Wi Status: enumspb.WORKER_DEPLOYMENT_VERSION_STATUS_RAMPING, }, }, - LastModifierIdentity: s.tv().ClientIdentity(), + LastModifierIdentity: env.Tv().ClientIdentity(), }, }) @@ -881,12 +885,12 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Ramping_Wi // fresh DescribeWorkerDeployment call resp, err = env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: s.tv().DeploymentSeries(), + DeploymentName: env.Tv().DeploymentSeries(), }) s.NoError(err) s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ - Name: s.tv().DeploymentSeries(), + Name: env.Tv().DeploymentSeries(), CreateTime: versionCreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ RampingVersion: "", @@ -924,7 +928,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Ramping_Wi Status: enumspb.WORKER_DEPLOYMENT_VERSION_STATUS_CURRENT, }, }, - LastModifierIdentity: s.tv().ClientIdentity(), + LastModifierIdentity: env.Tv().ClientIdentity(), }, }) @@ -934,12 +938,12 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Ramping_Wi // fresh DescribeWorkerDeployment call resp, err = env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: s.tv().DeploymentSeries(), + DeploymentName: env.Tv().DeploymentSeries(), }) s.NoError(err) s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ - Name: s.tv().DeploymentSeries(), + Name: env.Tv().DeploymentSeries(), CreateTime: versionCreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ RampingVersion: "", @@ -977,7 +981,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Ramping_Wi Status: enumspb.WORKER_DEPLOYMENT_VERSION_STATUS_DRAINING, }, }, - LastModifierIdentity: s.tv().ClientIdentity(), + LastModifierIdentity: env.Tv().ClientIdentity(), }, }) @@ -986,7 +990,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Ramping_Wi func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_DuplicateRamp() { env := s.newTestEnv() - rampingVersionVars := s.tv().WithBuildIDNumber(1) + rampingVersionVars := env.Tv() versionCreateTime := timestamppb.Now() s.startVersionWorkflow(env, rampingVersionVars) @@ -1036,7 +1040,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Invalid_Se env := s.newTestEnv() versionCreateTime := timestamppb.Now() - currentVersionVars := s.tv().WithBuildIDNumber(1) + currentVersionVars := env.Tv() s.startVersionWorkflow(env, currentVersionVars) setCurrentUpdateTime := timestamppb.Now() @@ -1119,23 +1123,23 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Invalid_Se func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Valid_SetNilCurrent_To_Ramping() { env := s.newTestEnv() - s.startVersionWorkflow(env, s.tv().WithBuildIDNumber(1)) + s.startVersionWorkflow(env, env.Tv()) // set ramping version to unversioned will change the modifier identity, so it's not a no-op - s.setAndVerifyRampingVersion(env, s.tv().WithBuildIDNumber(1), true, 0, false, "") + s.setAndVerifyRampingVersion(env, env.Tv(), true, 0, false, "") // set a non-nil ramping version so that we can unset it in the next step - s.setAndVerifyRampingVersion(env, s.tv().WithBuildIDNumber(1), false, 5, false, "") + s.setAndVerifyRampingVersion(env, env.Tv(), false, 5, false, "") // should be able to unset ramping version while current version is nil with no error - s.setAndVerifyRampingVersion(env, s.tv().WithBuildIDNumber(1), true, 0, true, "") + s.setAndVerifyRampingVersion(env, env.Tv(), true, 0, true, "") } func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_ModifyExistingRampVersionPercentage() { env := s.newTestEnv() versionCreateTime := timestamppb.Now() - rampingVersionVars := s.tv().WithBuildIDNumber(1) + rampingVersionVars := env.Tv() s.startVersionWorkflow(env, rampingVersionVars) // set version as ramping @@ -1143,12 +1147,12 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_ModifyExis s.setAndVerifyRampingVersion(env, rampingVersionVars, false, 50, true, "") resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: s.tv().DeploymentSeries(), + DeploymentName: env.Tv().DeploymentSeries(), }) s.NoError(err) s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ - Name: s.tv().DeploymentSeries(), + Name: env.Tv().DeploymentSeries(), CreateTime: versionCreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ RampingVersion: rampingVersionVars.DeploymentVersionString(), @@ -1171,7 +1175,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_ModifyExis Status: enumspb.WORKER_DEPLOYMENT_VERSION_STATUS_RAMPING, }, }, - LastModifierIdentity: s.tv().ClientIdentity(), + LastModifierIdentity: env.Tv().ClientIdentity(), }, }) @@ -1182,12 +1186,12 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_ModifyExis // RampingVersionPercentage and RampingVersionPercentageChangedTime should be updated resp, err = env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: s.tv().DeploymentSeries(), + DeploymentName: env.Tv().DeploymentSeries(), }) s.NoError(err) s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ - Name: s.tv().DeploymentSeries(), + Name: env.Tv().DeploymentSeries(), CreateTime: versionCreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ RampingVersion: rampingVersionVars.DeploymentVersionString(), @@ -1210,7 +1214,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_ModifyExis Status: enumspb.WORKER_DEPLOYMENT_VERSION_STATUS_RAMPING, }, }, - LastModifierIdentity: s.tv().ClientIdentity(), + LastModifierIdentity: env.Tv().ClientIdentity(), }, }) @@ -1219,8 +1223,8 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_ModifyExis func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_WithCurrent_Unset_Ramp() { env := s.newTestEnv() - rampingVersionVars := s.tv().WithBuildIDNumber(1) - currentVersionVars := s.tv().WithBuildIDNumber(2) + rampingVersionVars := env.Tv() + currentVersionVars := env.Tv().WithBuildIDNumber(2) version1CreateTime := timestamppb.Now() s.startVersionWorkflow(env, rampingVersionVars) @@ -1235,12 +1239,12 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_WithCurren resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: s.tv().DeploymentSeries(), + DeploymentName: env.Tv().DeploymentSeries(), }) s.NoError(err) s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ - Name: s.tv().DeploymentSeries(), + Name: env.Tv().DeploymentSeries(), CreateTime: version1CreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ RampingVersion: rampingVersionVars.DeploymentVersionString(), @@ -1275,7 +1279,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_WithCurren Status: enumspb.WORKER_DEPLOYMENT_VERSION_STATUS_CURRENT, }, }, - LastModifierIdentity: s.tv().ClientIdentity(), + LastModifierIdentity: env.Tv().ClientIdentity(), }, }) @@ -1285,12 +1289,12 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_WithCurren resp, err = env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: s.tv().DeploymentSeries(), + DeploymentName: env.Tv().DeploymentSeries(), }) s.NoError(err) s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ - Name: s.tv().DeploymentSeries(), + Name: env.Tv().DeploymentSeries(), CreateTime: version1CreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ RampingVersion: "", @@ -1325,7 +1329,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_WithCurren Status: enumspb.WORKER_DEPLOYMENT_VERSION_STATUS_CURRENT, }, }, - LastModifierIdentity: s.tv().ClientIdentity(), + LastModifierIdentity: env.Tv().ClientIdentity(), }, }) } @@ -1334,7 +1338,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_SetRamping env := s.newTestEnv() versionCreateTime := timestamppb.Now() - rampingVersionVars := s.tv().WithBuildIDNumber(1) + rampingVersionVars := env.Tv() s.startVersionWorkflow(env, rampingVersionVars) setRampingUpdateTime := timestamppb.Now() @@ -1346,12 +1350,12 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_SetRamping resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: s.tv().DeploymentSeries(), + DeploymentName: env.Tv().DeploymentSeries(), }) s.NoError(err) s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ - Name: s.tv().DeploymentSeries(), + Name: env.Tv().DeploymentSeries(), CreateTime: versionCreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ RampingVersion: "", // no ramping info should be set @@ -1375,7 +1379,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_SetRamping Status: enumspb.WORKER_DEPLOYMENT_VERSION_STATUS_CURRENT, }, }, - LastModifierIdentity: s.tv().ClientIdentity(), + LastModifierIdentity: env.Tv().ClientIdentity(), }, }) } @@ -1383,7 +1387,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_SetRamping func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_NoCurrent_Unset_Ramp() { env := s.newTestEnv() - rampingVersionVars := s.tv().WithBuildIDNumber(1) + rampingVersionVars := env.Tv() s.startVersionWorkflow(env, rampingVersionVars) s.setAndVerifyRampingVersion(env, rampingVersionVars, false, 50, true, "") @@ -1399,41 +1403,41 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Batching() versionCreateTime := timestamppb.Now() taskQueues := 5 for i := range taskQueues { - go s.pollFromDeploymentWithTaskQueueNumber(env, s.tv(), i) + go s.pollFromDeploymentWithTaskQueueNumber(env, env.Tv(), i) } // ensure the version has been created in the deployment with the right number of task-queues - s.ensureCreateVersionInDeployment(env, s.tv()) - s.ensureCreateVersionWithExpectedTaskQueues(env, s.tv(), taskQueues) + s.ensureCreateVersionInDeployment(env, env.Tv()) + s.ensureCreateVersionWithExpectedTaskQueues(env, env.Tv(), taskQueues) // verify that all the registered task-queues have "" set as their ramping version for i := range taskQueues { - s.verifyTaskQueueVersioningInfo(env, s.tv().WithTaskQueueNumber(i).TaskQueue(), worker_versioning.UnversionedVersionId, "", 0) + s.verifyTaskQueueVersioningInfo(env, env.Tv().WithTaskQueueNumber(i).TaskQueue(), worker_versioning.UnversionedVersionId, "", 0) } // set ramping version to 50% setRampingUpdateTime := timestamppb.Now() - s.setAndVerifyRampingVersion(env, s.tv(), false, 50, true, "") + s.setAndVerifyRampingVersion(env, env.Tv(), false, 50, true, "") // verify the task queues have new ramping version for i := range taskQueues { - s.verifyTaskQueueVersioningInfo(env, s.tv().WithTaskQueueNumber(i).TaskQueue(), worker_versioning.UnversionedVersionId, s.tv().DeploymentVersionString(), 50) + s.verifyTaskQueueVersioningInfo(env, env.Tv().WithTaskQueueNumber(i).TaskQueue(), worker_versioning.UnversionedVersionId, env.Tv().DeploymentVersionString(), 50) } // verify if the worker-deployment has the right ramping version set resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: s.tv().DeploymentSeries(), + DeploymentName: env.Tv().DeploymentSeries(), }) s.NoError(err) - s.Equal(s.tv().DeploymentVersionString(), resp.GetWorkerDeploymentInfo().GetRoutingConfig().GetRampingVersion()) //nolint:staticcheck // SA1019: old worker versioning + s.Equal(env.Tv().DeploymentVersionString(), resp.GetWorkerDeploymentInfo().GetRoutingConfig().GetRampingVersion()) //nolint:staticcheck // SA1019: old worker versioning s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ - Name: s.tv().DeploymentSeries(), + Name: env.Tv().DeploymentSeries(), CreateTime: versionCreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ - RampingVersion: s.tv().DeploymentVersionString(), + RampingVersion: env.Tv().DeploymentVersionString(), RampingVersionPercentage: 50, RampingVersionChangedTime: setRampingUpdateTime, RampingVersionPercentageChangedTime: setRampingUpdateTime, @@ -1442,7 +1446,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Batching() }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ { - Version: s.tv().DeploymentVersionString(), + Version: env.Tv().DeploymentVersionString(), CreateTime: versionCreateTime, DrainageInfo: nil, RoutingUpdateTime: setRampingUpdateTime, @@ -1453,7 +1457,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Batching() Status: enumspb.WORKER_DEPLOYMENT_VERSION_STATUS_RAMPING, }, }, - LastModifierIdentity: s.tv().ClientIdentity(), + LastModifierIdentity: env.Tv().ClientIdentity(), }, }) @@ -1470,30 +1474,30 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Unversione versionCreateTime := timestamppb.Now() taskQueues := 5 for i := range taskQueues { - go s.pollFromDeploymentWithTaskQueueNumber(env, s.tv(), i) + go s.pollFromDeploymentWithTaskQueueNumber(env, env.Tv(), i) } // ensure the version has been created in the deployment with the right number of task-queues - s.ensureCreateVersionInDeployment(env, s.tv()) - s.ensureCreateVersionWithExpectedTaskQueues(env, s.tv(), taskQueues) + s.ensureCreateVersionInDeployment(env, env.Tv()) + s.ensureCreateVersionWithExpectedTaskQueues(env, env.Tv(), taskQueues) // make the current version versioned, so that we can set ramp to unversioned later setCurrentUpdateTime := timestamppb.Now() - s.setCurrentVersion(env, s.tv(), true, "") + s.setCurrentVersion(env, env.Tv(), true, "") // set ramp to unversioned which should trigger a batch of SyncDeploymentVersionUserData requests. setRampingUpdateTime := timestamppb.Now() - s.setAndVerifyRampingVersionUnversionedOption(env, s.tv(), true, false, 75, true, false, true, "") + s.setAndVerifyRampingVersionUnversionedOption(env, env.Tv(), true, false, 75, true, false, true, "") // check that the current version's task queues have ramping version == __unversioned__ for i := range taskQueues { - s.verifyTaskQueueVersioningInfo(env, s.tv().WithTaskQueueNumber(i).TaskQueue(), s.tv().DeploymentVersionString(), worker_versioning.UnversionedVersionId, 75) + s.verifyTaskQueueVersioningInfo(env, env.Tv().WithTaskQueueNumber(i).TaskQueue(), env.Tv().DeploymentVersionString(), worker_versioning.UnversionedVersionId, 75) } // verify if the worker-deployment has the right ramping version set resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: s.tv().DeploymentSeries(), + DeploymentName: env.Tv().DeploymentSeries(), }) s.NoError(err) // nolint:staticcheck // SA1019: old worker versioning @@ -1502,19 +1506,19 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Unversione s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ - Name: s.tv().DeploymentSeries(), + Name: env.Tv().DeploymentSeries(), CreateTime: versionCreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ RampingVersion: worker_versioning.UnversionedVersionId, RampingVersionPercentage: 75, RampingVersionChangedTime: setRampingUpdateTime, RampingVersionPercentageChangedTime: setRampingUpdateTime, - CurrentVersion: s.tv().DeploymentVersionString(), + CurrentVersion: env.Tv().DeploymentVersionString(), CurrentVersionChangedTime: setCurrentUpdateTime, }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ { - Version: s.tv().DeploymentVersionString(), + Version: env.Tv().DeploymentVersionString(), CreateTime: versionCreateTime, DrainageInfo: nil, RoutingUpdateTime: setCurrentUpdateTime, @@ -1526,7 +1530,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Unversione Status: enumspb.WORKER_DEPLOYMENT_VERSION_STATUS_CURRENT, }, }, - LastModifierIdentity: s.tv().ClientIdentity(), + LastModifierIdentity: env.Tv().ClientIdentity(), }, }) @@ -1537,8 +1541,8 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Unversione func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_SetCurrentVersion() { env := s.newTestEnv() - firstVersion := s.tv().WithBuildIDNumber(1) - secondVersion := s.tv().WithBuildIDNumber(2) + firstVersion := env.Tv() + secondVersion := env.Tv().WithBuildIDNumber(2) version1CreateTime := timestamppb.Now() // Start poller with cancellable context for deterministic control @@ -1551,7 +1555,7 @@ func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_SetCurrentVersion() // Verify no current deployment version is set initially resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: s.tv().DeploymentSeries(), + DeploymentName: env.Tv().DeploymentSeries(), }) s.NoError(err) s.Equal(worker_versioning.UnversionedVersionId, resp.GetWorkerDeploymentInfo().GetRoutingConfig().GetCurrentVersion()) //nolint:staticcheck // SA1019: old worker versioning @@ -1563,12 +1567,12 @@ func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_SetCurrentVersion() resp, err = env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: s.tv().DeploymentSeries(), + DeploymentName: env.Tv().DeploymentSeries(), }) s.NoError(err) s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ - Name: s.tv().DeploymentSeries(), + Name: env.Tv().DeploymentSeries(), CreateTime: version1CreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ CurrentVersion: firstVersion.DeploymentVersionString(), @@ -1588,7 +1592,7 @@ func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_SetCurrentVersion() Status: enumspb.WORKER_DEPLOYMENT_VERSION_STATUS_CURRENT, }, }, - LastModifierIdentity: s.tv().ClientIdentity(), + LastModifierIdentity: env.Tv().ClientIdentity(), }, }) @@ -1603,12 +1607,12 @@ func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_SetCurrentVersion() // Verify that the first version is draining, has an updated last deactivation time + second version is current, has an updated first activation time. resp, err = env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: s.tv().DeploymentSeries(), + DeploymentName: env.Tv().DeploymentSeries(), }) s.NoError(err) s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ - Name: s.tv().DeploymentSeries(), + Name: env.Tv().DeploymentSeries(), CreateTime: version1CreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ CurrentVersion: secondVersion.DeploymentVersionString(), @@ -1640,7 +1644,7 @@ func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_SetCurrentVersion() Status: enumspb.WORKER_DEPLOYMENT_VERSION_STATUS_CURRENT, }, }, - LastModifierIdentity: s.tv().ClientIdentity(), + LastModifierIdentity: env.Tv().ClientIdentity(), }, }) @@ -1655,49 +1659,49 @@ func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Batching() { versionCreateTime := timestamppb.Now() taskQueues := 5 for i := range taskQueues { - go s.pollFromDeploymentWithTaskQueueNumber(env, s.tv(), i) + go s.pollFromDeploymentWithTaskQueueNumber(env, env.Tv(), i) } // ensure the version has been created in the deployment with the right number of task-queues - s.ensureCreateVersionInDeployment(env, s.tv()) - s.ensureCreateVersionWithExpectedTaskQueues(env, s.tv(), taskQueues) + s.ensureCreateVersionInDeployment(env, env.Tv()) + s.ensureCreateVersionWithExpectedTaskQueues(env, env.Tv(), taskQueues) // verify that all the registered task-queues have "__unversioned__" as their current version for i := range taskQueues { - s.verifyTaskQueueVersioningInfo(env, s.tv().WithTaskQueueNumber(i).TaskQueue(), worker_versioning.UnversionedVersionId, "", 0) + s.verifyTaskQueueVersioningInfo(env, env.Tv().WithTaskQueueNumber(i).TaskQueue(), worker_versioning.UnversionedVersionId, "", 0) } // set current and check that the current version's task queues have new current version setCurrentUpdateTime := timestamppb.Now() - s.setCurrentVersion(env, s.tv(), true, "") + s.setCurrentVersion(env, env.Tv(), true, "") // verify the current version has propogated to all the registered task-queues userData for i := range taskQueues { - s.verifyTaskQueueVersioningInfo(env, s.tv().WithTaskQueueNumber(i).TaskQueue(), s.tv().DeploymentVersionString(), "", 0) + s.verifyTaskQueueVersioningInfo(env, env.Tv().WithTaskQueueNumber(i).TaskQueue(), env.Tv().DeploymentVersionString(), "", 0) } // verify if the worker-deployment has the right current version set resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: s.tv().DeploymentSeries(), + DeploymentName: env.Tv().DeploymentSeries(), }) s.NoError(err) s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ - Name: s.tv().DeploymentSeries(), + Name: env.Tv().DeploymentSeries(), CreateTime: versionCreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ RampingVersion: "", RampingVersionPercentage: 0, RampingVersionChangedTime: nil, RampingVersionPercentageChangedTime: nil, - CurrentVersion: s.tv().DeploymentVersionString(), + CurrentVersion: env.Tv().DeploymentVersionString(), CurrentVersionChangedTime: setCurrentUpdateTime, }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ { - Version: s.tv().DeploymentVersionString(), + Version: env.Tv().DeploymentVersionString(), CreateTime: versionCreateTime, DrainageInfo: nil, RoutingUpdateTime: setCurrentUpdateTime, @@ -1709,7 +1713,7 @@ func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Batching() { Status: enumspb.WORKER_DEPLOYMENT_VERSION_STATUS_CURRENT, }, }, - LastModifierIdentity: s.tv().ClientIdentity(), + LastModifierIdentity: env.Tv().ClientIdentity(), }, }) @@ -1717,72 +1721,75 @@ func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Batching() { func (s *WorkerDeploymentSuite) TestSetManagerIdentity_RW() { env := s.newTestEnv() + tv := env.Tv() - go s.pollFromDeployment(env, s.tv().WithBuildIDNumber(1)) - s.ensureCreateVersionInDeployment(env, s.tv().WithBuildIDNumber(1)) + go s.pollFromDeployment(env, tv) + s.ensureCreateVersionInDeployment(env, tv) // set identity to self - s.setAndValidateManagerIdentity(env, s.tv().WithBuildIDNumber(1), true, false, "", "") + s.setAndValidateManagerIdentity(env, tv, true, false, "", "") // set identity to other - s.setAndValidateManagerIdentity(env, s.tv().WithBuildIDNumber(1), false, false, "other", "") + s.setAndValidateManagerIdentity(env, tv, false, false, "other", "") // set identity to other again (should be idempotent) - s.setAndValidateManagerIdentity(env, s.tv().WithBuildIDNumber(1), false, false, "other", "") + s.setAndValidateManagerIdentity(env, tv, false, false, "other", "") // unset identity - s.setAndValidateManagerIdentity(env, s.tv().WithBuildIDNumber(1), false, false, "", "") + s.setAndValidateManagerIdentity(env, tv, false, false, "", "") // set identity with bad conflict token - s.setAndValidateManagerIdentity(env, s.tv().WithBuildIDNumber(1), true, true, "", "conflict token mismatch") + s.setAndValidateManagerIdentity(env, tv, true, true, "", "conflict token mismatch") } func (s *WorkerDeploymentSuite) TestSetManagerIdentity_WithSetRampSetCurrent() { env := s.newTestEnv() + tv := env.Tv() - go s.pollFromDeployment(env, s.tv().WithBuildIDNumber(1)) - s.ensureCreateVersionInDeployment(env, s.tv().WithBuildIDNumber(1)) + go s.pollFromDeployment(env, tv) + s.ensureCreateVersionInDeployment(env, tv) // set identity to self - s.setAndValidateManagerIdentity(env, s.tv().WithBuildIDNumber(1), true, false, "", "") + s.setAndValidateManagerIdentity(env, tv, true, false, "", "") // -> self can successfully set ramp - s.setAndVerifyRampingVersion(env, s.tv().WithBuildIDNumber(1), false, 1, true, "") + s.setAndVerifyRampingVersion(env, tv, false, 1, true, "") // set identity to other - s.setAndValidateManagerIdentity(env, s.tv().WithBuildIDNumber(1), false, false, "other", "") + s.setAndValidateManagerIdentity(env, tv, false, false, "other", "") // -> self cannot set ramp - s.setAndVerifyRampingVersion(env, s.tv().WithBuildIDNumber(1), false, 2, true, fmt.Sprintf(workerdeployment.ErrManagerIdentityMismatch, "other", s.tv().WithBuildIDNumber(1).ClientIdentity())) + s.setAndVerifyRampingVersion(env, tv, false, 2, true, fmt.Sprintf(workerdeployment.ErrManagerIdentityMismatch, "other", tv.ClientIdentity())) // -> self cannot set current - s.setCurrentVersion(env, s.tv().WithBuildIDNumber(1), true, fmt.Sprintf(workerdeployment.ErrManagerIdentityMismatch, "other", s.tv().WithBuildIDNumber(1).ClientIdentity())) + s.setCurrentVersion(env, tv, true, fmt.Sprintf(workerdeployment.ErrManagerIdentityMismatch, "other", tv.ClientIdentity())) // unset identity - s.setAndValidateManagerIdentity(env, s.tv().WithBuildIDNumber(1), false, false, "", "") + s.setAndValidateManagerIdentity(env, tv, false, false, "", "") // -> self can now set ramp - s.setAndVerifyRampingVersion(env, s.tv().WithBuildIDNumber(1), false, 2, true, "") + s.setAndVerifyRampingVersion(env, tv, false, 2, true, "") // set identity to self - s.setAndValidateManagerIdentity(env, s.tv().WithBuildIDNumber(1), true, false, "", "") + s.setAndValidateManagerIdentity(env, tv, true, false, "", "") // -> self can now set current - s.setCurrentVersion(env, s.tv().WithBuildIDNumber(1), true, "") + s.setCurrentVersion(env, tv, true, "") } func (s *WorkerDeploymentSuite) TestSetManagerIdentity_WithDeleteVersion() { env := s.newTestEnv(testcore.WithDynamicConfig(dynamicconfig.PollerHistoryTTL, 500*time.Millisecond)) + tv := env.Tv() // start and stop polling so that version is eligible for deletion - pollerCancel := s.startDeploymentPoller(env, s.tv().WithBuildIDNumber(1)) - s.ensureCreateVersionInDeployment(env, s.tv().WithBuildIDNumber(1)) + pollerCancel := s.startDeploymentPoller(env, tv) + s.ensureCreateVersionInDeployment(env, tv) pollerCancel() // set identity to other - s.setAndValidateManagerIdentity(env, s.tv().WithBuildIDNumber(1), false, false, "other", "") + s.setAndValidateManagerIdentity(env, tv, false, false, "other", "") // -> self cannot delete version - s.tryDeleteVersion(env, s.tv().WithBuildIDNumber(1), fmt.Sprintf(workerdeployment.ErrManagerIdentityMismatch, "other", s.tv().WithBuildIDNumber(1).ClientIdentity())) + s.tryDeleteVersion(env, tv, fmt.Sprintf(workerdeployment.ErrManagerIdentityMismatch, "other", tv.ClientIdentity())) // set identity to self - s.setAndValidateManagerIdentity(env, s.tv().WithBuildIDNumber(1), true, false, "", "") + s.setAndValidateManagerIdentity(env, tv, true, false, "", "") // -> self can now delete version - s.tryDeleteVersion(env, s.tv().WithBuildIDNumber(1), "") + s.tryDeleteVersion(env, tv, "") } // TestDeleteVersion_ServerDeleteMaxVersionsReached tests that when the internal limit for the number of versions @@ -1794,8 +1801,8 @@ func (s *WorkerDeploymentSuite) TestDeleteVersion_ServerDeleteMaxVersionsReached testcore.WithDynamicConfig(dynamicconfig.MatchingMaxVersionsInDeployment, 1), ) - tv1 := s.tv().WithBuildIDNumber(1) - tv2 := s.tv().WithBuildIDNumber(2) + tv1 := env.Tv() + tv2 := env.Tv().WithBuildIDNumber(2) // start and stop polling so that version is eligible for deletion pollerCancel := s.startDeploymentPoller(env, tv1) @@ -1830,35 +1837,32 @@ func (s *WorkerDeploymentSuite) TestDeleteVersion_ServerDeleteMaxVersionsReached // Should see that the current version of the task queues becomes unversioned func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Unversioned_NoRamp() { env := s.newTestEnv() - - currentVars := s.tv().WithBuildIDNumber(1) - versionCreateTime := timestamppb.Now() - go s.pollFromDeployment(env, currentVars) - s.ensureCreateVersionInDeployment(env, currentVars) + go s.pollFromDeployment(env, env.Tv()) + s.ensureCreateVersionInDeployment(env, env.Tv()) // check that the current version's task queues have current version unversioned to start - s.verifyTaskQueueVersioningInfo(env, currentVars.TaskQueue(), worker_versioning.UnversionedVersionId, "", 0) + s.verifyTaskQueueVersioningInfo(env, env.Tv().TaskQueue(), worker_versioning.UnversionedVersionId, "", 0) // set current and check that the current version's task queues have new current version firstCurrentUpdateTime := timestamppb.Now() - s.setCurrentVersion(env, currentVars, true, "") - s.verifyTaskQueueVersioningInfo(env, currentVars.TaskQueue(), currentVars.DeploymentVersionString(), "", 0) + s.setCurrentVersion(env, env.Tv(), true, "") + s.verifyTaskQueueVersioningInfo(env, env.Tv().TaskQueue(), env.Tv().DeploymentVersionString(), "", 0) // set current unversioned and check that the current version's task queues have current version unversioned again secondCurrentUpdateTime := timestamppb.Now() - s.setCurrentVersionUnversionedOption(env, currentVars, true, true, false, true, "") - s.verifyTaskQueueVersioningInfo(env, currentVars.TaskQueue(), worker_versioning.UnversionedVersionId, "", 0) + s.setCurrentVersionUnversionedOption(env, env.Tv(), true, true, false, true, "") + s.verifyTaskQueueVersioningInfo(env, env.Tv().TaskQueue(), worker_versioning.UnversionedVersionId, "", 0) // check that deployment has current version == __unversioned__ resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: currentVars.DeploymentSeries(), + DeploymentName: env.Tv().DeploymentSeries(), }) s.NoError(err) s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ - Name: currentVars.DeploymentSeries(), + Name: env.Tv().DeploymentSeries(), CreateTime: versionCreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ CurrentVersion: worker_versioning.UnversionedVersionId, @@ -1866,7 +1870,7 @@ func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Unversioned_NoRamp() { }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ { - Version: currentVars.DeploymentVersionString(), + Version: env.Tv().DeploymentVersionString(), CreateTime: versionCreateTime, DrainageInfo: &deploymentpb.VersionDrainageInfo{Status: enumspb.VERSION_DRAINAGE_STATUS_DRAINING}, RoutingUpdateTime: secondCurrentUpdateTime, @@ -1878,7 +1882,7 @@ func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Unversioned_NoRamp() { Status: enumspb.WORKER_DEPLOYMENT_VERSION_STATUS_DRAINING, }, }, - LastModifierIdentity: currentVars.ClientIdentity(), + LastModifierIdentity: env.Tv().ClientIdentity(), }, }) } @@ -1886,24 +1890,21 @@ func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Unversioned_NoRamp() { // Should see that the current version of the task queue becomes unversioned, and the unversioned ramping version of the task queue is removed func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Unversioned_PromoteUnversionedRamp() { env := s.newTestEnv() - - currentVars := s.tv().WithBuildIDNumber(1) - - go s.pollFromDeployment(env, currentVars) - s.ensureCreateVersionInDeployment(env, currentVars) + go s.pollFromDeployment(env, env.Tv()) + s.ensureCreateVersionInDeployment(env, env.Tv()) // make the current version versioned, so that we can set ramp to unversioned - s.setCurrentVersion(env, currentVars, true, "") + s.setCurrentVersion(env, env.Tv(), true, "") // set ramp to unversioned - s.setAndVerifyRampingVersionUnversionedOption(env, s.tv(), true, false, 75, true, false, true, "") + s.setAndVerifyRampingVersionUnversionedOption(env, env.Tv(), true, false, 75, true, false, true, "") // check that the current version's task queues have ramping version == __unversioned__ - s.verifyTaskQueueVersioningInfo(env, currentVars.TaskQueue(), currentVars.DeploymentVersionString(), worker_versioning.UnversionedVersionId, 75) + s.verifyTaskQueueVersioningInfo(env, env.Tv().TaskQueue(), env.Tv().DeploymentVersionString(), worker_versioning.UnversionedVersionId, 75) // set current to unversioned - s.setCurrentVersionUnversionedOption(env, s.tv(), true, true, false, true, "") + s.setCurrentVersionUnversionedOption(env, env.Tv(), true, true, false, true, "") // check that the current version's task queues have ramping version == "" and current version == "__unversioned__" - s.verifyTaskQueueVersioningInfo(env, currentVars.TaskQueue(), worker_versioning.UnversionedVersionId, "", 0) + s.verifyTaskQueueVersioningInfo(env, env.Tv().TaskQueue(), worker_versioning.UnversionedVersionId, "", 0) } func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Concurrent_DifferentVersions_NoUnexpectedErrors() { @@ -1913,7 +1914,7 @@ func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Concurrent_DifferentVersio versions := 10 for i := range versions { - s.startVersionWorkflow(env, s.tv().WithBuildIDNumber(i)) + s.startVersionWorkflow(env, env.Tv().WithBuildIDNumber(i)) } // Concurrently set 10 different versions as current version @@ -1921,10 +1922,10 @@ func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Concurrent_DifferentVersio go func() { _, err := env.FrontendClient().SetWorkerDeploymentCurrentVersion(s.Context(), &workflowservice.SetWorkerDeploymentCurrentVersionRequest{ Namespace: env.Namespace().String(), - DeploymentName: s.tv().DeploymentVersion().GetDeploymentName(), - Version: s.tv().WithBuildIDNumber(i).DeploymentVersionString(), + DeploymentName: env.Tv().DeploymentVersion().GetDeploymentName(), + Version: env.Tv().WithBuildIDNumber(i).DeploymentVersionString(), IgnoreMissingTaskQueues: true, - Identity: s.tv().ClientIdentity(), + Identity: env.Tv().ClientIdentity(), }) errChan <- err }() @@ -1947,7 +1948,7 @@ func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Concurrent_DifferentVersio // Verify that the current version is set. resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: s.tv().DeploymentVersion().GetDeploymentName(), + DeploymentName: env.Tv().DeploymentVersion().GetDeploymentName(), }) s.NoError(err) s.NotEqual(worker_versioning.UnversionedVersionId, resp.GetWorkerDeploymentInfo().GetRoutingConfig().GetCurrentVersion()) @@ -1958,17 +1959,17 @@ func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Concurrent_SameVersion_NoU errChan := make(chan error) - s.startVersionWorkflow(env, s.tv()) // create version + s.startVersionWorkflow(env, env.Tv()) // create version // Concurrently set the same version as current version 10 times. for range 10 { go func() { _, err := env.FrontendClient().SetWorkerDeploymentCurrentVersion(s.Context(), &workflowservice.SetWorkerDeploymentCurrentVersionRequest{ Namespace: env.Namespace().String(), - DeploymentName: s.tv().DeploymentVersion().GetDeploymentName(), - Version: s.tv().DeploymentVersionString(), + DeploymentName: env.Tv().DeploymentVersion().GetDeploymentName(), + Version: env.Tv().DeploymentVersionString(), IgnoreMissingTaskQueues: true, - Identity: s.tv().ClientIdentity(), + Identity: env.Tv().ClientIdentity(), }) errChan <- err }() @@ -1991,10 +1992,10 @@ func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Concurrent_SameVersion_NoU // Verify that the current version is set. resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: s.tv().DeploymentVersion().GetDeploymentName(), + DeploymentName: env.Tv().DeploymentVersion().GetDeploymentName(), }) s.NoError(err) - s.Equal(s.tv().DeploymentVersionString(), resp.GetWorkerDeploymentInfo().GetRoutingConfig().GetCurrentVersion()) //nolint:staticcheck // SA1019: old worker versioning + s.Equal(env.Tv().DeploymentVersionString(), resp.GetWorkerDeploymentInfo().GetRoutingConfig().GetCurrentVersion()) //nolint:staticcheck // SA1019: old worker versioning } // TestConcurrentPollers_DifferentTaskQueues_SameVersion_SetCurrentVersion aims to test that when there are multiple pollers polling on different task queues, @@ -2007,11 +2008,11 @@ func (s *WorkerDeploymentSuite) TestConcurrentPollers_DifferentTaskQueues_SameVe tqs := 10 // Start all pollers concurrently (pollFromDeployment has no assertions, so it's safe to call from goroutines) for i := range tqs { - go s.pollFromDeployment(env, s.tv().WithTaskQueueNumber(i)) + go s.pollFromDeployment(env, env.Tv().WithTaskQueueNumber(i)) } // Wait for all version workflows to appear (must run in the test goroutine due to assertions) for i := range tqs { - tvI := s.tv().WithTaskQueueNumber(i) + tvI := env.Tv().WithTaskQueueNumber(i) s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) resp, err := env.FrontendClient().DescribeWorkerDeploymentVersion(s.Context(), &workflowservice.DescribeWorkerDeploymentVersionRequest{ @@ -2024,11 +2025,11 @@ func (s *WorkerDeploymentSuite) TestConcurrentPollers_DifferentTaskQueues_SameVe } // set this version as current version - s.setCurrentVersion(env, s.tv(), false, "") + s.setCurrentVersion(env, env.Tv(), false, "") // verify that the task queues, eventually, have this version as the current version in their versioning info for i := range tqs { - s.verifyTaskQueueVersioningInfo(env, s.tv().WithTaskQueueNumber(i).TaskQueue(), s.tv().DeploymentVersionString(), "", 0) + s.verifyTaskQueueVersioningInfo(env, env.Tv().WithTaskQueueNumber(i).TaskQueue(), env.Tv().DeploymentVersionString(), "", 0) } } @@ -2039,7 +2040,7 @@ func (s *WorkerDeploymentSuite) TestSetRampingVersion_Concurrent_DifferentVersio versions := 10 for i := range versions { - s.startVersionWorkflow(env, s.tv().WithBuildIDNumber(i)) + s.startVersionWorkflow(env, env.Tv().WithBuildIDNumber(i)) } // Concurrently set 10 different versions as ramping version @@ -2047,10 +2048,10 @@ func (s *WorkerDeploymentSuite) TestSetRampingVersion_Concurrent_DifferentVersio go func() { _, err := env.FrontendClient().SetWorkerDeploymentRampingVersion(s.Context(), &workflowservice.SetWorkerDeploymentRampingVersionRequest{ Namespace: env.Namespace().String(), - DeploymentName: s.tv().DeploymentVersion().GetDeploymentName(), - Version: s.tv().WithBuildIDNumber(i).DeploymentVersionString(), + DeploymentName: env.Tv().DeploymentVersion().GetDeploymentName(), + Version: env.Tv().WithBuildIDNumber(i).DeploymentVersionString(), IgnoreMissingTaskQueues: true, - Identity: s.tv().ClientIdentity(), + Identity: env.Tv().ClientIdentity(), Percentage: 50, }) errChan <- err @@ -2074,7 +2075,7 @@ func (s *WorkerDeploymentSuite) TestSetRampingVersion_Concurrent_DifferentVersio // Verify that the ramping version is set. resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: s.tv().DeploymentVersion().GetDeploymentName(), + DeploymentName: env.Tv().DeploymentVersion().GetDeploymentName(), }) s.NoError(err) s.NotNil(resp.GetWorkerDeploymentInfo().GetRoutingConfig().GetRampingVersion()) @@ -2085,17 +2086,17 @@ func (s *WorkerDeploymentSuite) TestSetRampingVersion_Concurrent_SameVersion_NoU errChan := make(chan error) - s.startVersionWorkflow(env, s.tv()) // create version + s.startVersionWorkflow(env, env.Tv()) // create version // Concurrently set the same version as ramping version 10 times. for range 10 { go func() { _, err := env.FrontendClient().SetWorkerDeploymentRampingVersion(s.Context(), &workflowservice.SetWorkerDeploymentRampingVersionRequest{ Namespace: env.Namespace().String(), - DeploymentName: s.tv().DeploymentVersion().GetDeploymentName(), - Version: s.tv().DeploymentVersionString(), + DeploymentName: env.Tv().DeploymentVersion().GetDeploymentName(), + Version: env.Tv().DeploymentVersionString(), IgnoreMissingTaskQueues: true, - Identity: s.tv().ClientIdentity(), + Identity: env.Tv().ClientIdentity(), Percentage: 50, }) errChan <- err @@ -2119,10 +2120,10 @@ func (s *WorkerDeploymentSuite) TestSetRampingVersion_Concurrent_SameVersion_NoU // Verify that the ramping version is set. resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: s.tv().DeploymentVersion().GetDeploymentName(), + DeploymentName: env.Tv().DeploymentVersion().GetDeploymentName(), }) s.NoError(err) - s.Equal(s.tv().DeploymentVersionString(), resp.GetWorkerDeploymentInfo().GetRoutingConfig().GetRampingVersion()) //nolint:staticcheck // SA1019: old worker versioning + s.Equal(env.Tv().DeploymentVersionString(), resp.GetWorkerDeploymentInfo().GetRoutingConfig().GetRampingVersion()) //nolint:staticcheck // SA1019: old worker versioning } // TODO: this test reliably produces a rare error seemingly about speculative tasks. use it for debugging the error @@ -2149,7 +2150,7 @@ func (s *WorkerDeploymentSuite) TestConcurrentPollers_ManyTaskQueues_RapidRoutin testcore.WithTestHook(testhooks.NewHook(testhooks.MatchingDeploymentRegisterErrorBackoff, time.Millisecond*500)), ) - dn := s.tv().DeploymentVersion().GetDeploymentName() + dn := env.Tv().DeploymentVersion().GetDeploymentName() start := time.Now() // For each version send pollers regularly until all TQs are registered from DescribeVersion POV @@ -2158,7 +2159,7 @@ func (s *WorkerDeploymentSuite) TestConcurrentPollers_ManyTaskQueues_RapidRoutin sendPollers := func() { for j := range numTaskQueues { - go s.pollFromDeploymentUntil(pollCtx, env, s.tv().WithBuildIDNumber(i).WithTaskQueueNumber(j)) + go s.pollFromDeploymentUntil(pollCtx, env, env.Tv().WithBuildIDNumber(i).WithTaskQueueNumber(j)) } } @@ -2197,7 +2198,7 @@ func (s *WorkerDeploymentSuite) TestConcurrentPollers_ManyTaskQueues_RapidRoutin a := require.New(t) resp, err := env.FrontendClient().DescribeWorkerDeploymentVersion(pollCtx, &workflowservice.DescribeWorkerDeploymentVersionRequest{ Namespace: env.Namespace().String(), - DeploymentVersion: s.tv().WithBuildIDNumber(i).ExternalDeploymentVersion(), + DeploymentVersion: env.Tv().WithBuildIDNumber(i).ExternalDeploymentVersion(), }) a.NoError(err) a.Len(resp.GetVersionTaskQueues(), numTaskQueues) @@ -2213,7 +2214,7 @@ func (s *WorkerDeploymentSuite) TestConcurrentPollers_ManyTaskQueues_RapidRoutin for i := range numOperations { // Alternate between setCurrent and setRamping targetVersion := i % numVersions - versionTV := s.tv().WithBuildIDNumber(targetVersion) + versionTV := env.Tv().WithBuildIDNumber(targetVersion) for { var err error if i%2 == 0 { @@ -2223,7 +2224,7 @@ func (s *WorkerDeploymentSuite) TestConcurrentPollers_ManyTaskQueues_RapidRoutin DeploymentName: dn, BuildId: versionTV.DeploymentVersion().GetBuildId(), IgnoreMissingTaskQueues: true, - Identity: s.tv().ClientIdentity(), + Identity: env.Tv().ClientIdentity(), }) } else { // setRamping operation @@ -2232,7 +2233,7 @@ func (s *WorkerDeploymentSuite) TestConcurrentPollers_ManyTaskQueues_RapidRoutin DeploymentName: dn, BuildId: versionTV.DeploymentVersion().GetBuildId(), IgnoreMissingTaskQueues: true, - Identity: s.tv().ClientIdentity(), + Identity: env.Tv().ClientIdentity(), Percentage: float32(50 + (i % 50)), }) } @@ -2269,7 +2270,7 @@ func (s *WorkerDeploymentSuite) TestConcurrentPollers_ManyTaskQueues_RapidRoutin // Note: The public API doesn't expose revision numbers at the task queue level, so we verify that the // versioning info has been propagated correctly by checking the current/ramping versions for j := range numTaskQueues { - tqTV := s.tv().WithTaskQueueNumber(j) + tqTV := env.Tv().WithTaskQueueNumber(j) tqUD, err := env.GetTestCluster().MatchingClient().GetTaskQueueUserData(s.Context(), &matchingservice.GetTaskQueueUserDataRequest{ NamespaceId: env.NamespaceID().String(), TaskQueueType: tqTypeWf, @@ -2290,17 +2291,17 @@ func (s *WorkerDeploymentSuite) TestResourceExhaustedErrors_Converted_To_Readabl // Start all version workflows first for i := range versions { - s.startVersionWorkflow(env, s.tv().WithBuildIDNumber(i)) + s.startVersionWorkflow(env, env.Tv().WithBuildIDNumber(i)) } // Test SetRampingVersion s.testConcurrentRequestsResourceExhausted(versions, errChan, "SetWorkerDeploymentRampingVersion", func(i int) error { _, err := env.FrontendClient().SetWorkerDeploymentRampingVersion(s.Context(), &workflowservice.SetWorkerDeploymentRampingVersionRequest{ Namespace: env.Namespace().String(), - DeploymentName: s.tv().DeploymentVersion().GetDeploymentName(), - Version: s.tv().WithBuildIDNumber(i).DeploymentVersionString(), + DeploymentName: env.Tv().DeploymentVersion().GetDeploymentName(), + Version: env.Tv().WithBuildIDNumber(i).DeploymentVersionString(), IgnoreMissingTaskQueues: true, - Identity: s.tv().ClientIdentity(), + Identity: env.Tv().ClientIdentity(), Percentage: 50, }) return err @@ -2310,10 +2311,10 @@ func (s *WorkerDeploymentSuite) TestResourceExhaustedErrors_Converted_To_Readabl s.testConcurrentRequestsResourceExhausted(versions, errChan, "SetWorkerDeploymentCurrentVersion", func(i int) error { _, err := env.FrontendClient().SetWorkerDeploymentCurrentVersion(s.Context(), &workflowservice.SetWorkerDeploymentCurrentVersionRequest{ Namespace: env.Namespace().String(), - DeploymentName: s.tv().DeploymentVersion().GetDeploymentName(), - Version: s.tv().WithBuildIDNumber(i).DeploymentVersionString(), + DeploymentName: env.Tv().DeploymentVersion().GetDeploymentName(), + Version: env.Tv().WithBuildIDNumber(i).DeploymentVersionString(), IgnoreMissingTaskQueues: true, - Identity: s.tv().ClientIdentity(), + Identity: env.Tv().ClientIdentity(), }) return err }) @@ -2326,7 +2327,7 @@ func (s *WorkerDeploymentSuite) TestResourceExhaustedErrors_Converted_To_Readabl s.testConcurrentRequestsResourceExhausted(versions, errChan, "UpdateWorkerDeploymentVersionMetadata", func(i int) error { _, err := env.FrontendClient().UpdateWorkerDeploymentVersionMetadata(s.Context(), &workflowservice.UpdateWorkerDeploymentVersionMetadataRequest{ Namespace: env.Namespace().String(), - Version: s.tv().WithBuildIDNumber(i).DeploymentVersionString(), + Version: env.Tv().WithBuildIDNumber(i).DeploymentVersionString(), UpsertEntries: metadata, }) return err @@ -2365,7 +2366,7 @@ func (s *WorkerDeploymentSuite) testConcurrentRequestsResourceExhausted( func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Unversioned_UnversionedCurrent() { env := s.newTestEnv() - rampingVars := s.tv().WithBuildIDNumber(1) + rampingVars := env.Tv() s.startVersionWorkflow(env, rampingVars) s.setAndVerifyRampingVersionUnversionedOption(env, rampingVars, true, false, 50, true, false, true, "ramping version __unversioned__ is already current") } @@ -2373,65 +2374,63 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Unversione // Should see that the ramping version of the task queues in the current version is unversioned func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Unversioned_VersionedCurrent() { env := s.newTestEnv() - - currentVars := s.tv().WithBuildIDNumber(1) - - go s.pollFromDeployment(env, currentVars) - s.ensureCreateVersionInDeployment(env, currentVars) + go s.pollFromDeployment(env, env.Tv()) + s.ensureCreateVersionInDeployment(env, env.Tv()) // check that the current version's task queues have ramping version == "" - s.setCurrentVersion(env, currentVars, true, "") - s.verifyTaskQueueVersioningInfo(env, currentVars.TaskQueue(), currentVars.DeploymentVersionString(), "", 0) + s.setCurrentVersion(env, env.Tv(), true, "") + s.verifyTaskQueueVersioningInfo(env, env.Tv().TaskQueue(), env.Tv().DeploymentVersionString(), "", 0) // set ramp to unversioned - s.setAndVerifyRampingVersionUnversionedOption(env, s.tv(), true, false, 75, true, false, true, "") + s.setAndVerifyRampingVersionUnversionedOption(env, env.Tv(), true, false, 75, true, false, true, "") // check that deployment has ramping version == __unversioned__ resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: s.tv().DeploymentSeries(), + DeploymentName: env.Tv().DeploymentSeries(), }) s.NoError(err) s.Equal(worker_versioning.UnversionedVersionId, resp.GetWorkerDeploymentInfo().GetRoutingConfig().GetRampingVersion()) // check that the current version's task queues have ramping version == __unversioned__ - s.verifyTaskQueueVersioningInfo(env, currentVars.TaskQueue(), currentVars.DeploymentVersionString(), worker_versioning.UnversionedVersionId, 75) + s.verifyTaskQueueVersioningInfo(env, env.Tv().TaskQueue(), env.Tv().DeploymentVersionString(), worker_versioning.UnversionedVersionId, 75) } func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentCurrentVersion_NoPollers() { env := s.newTestEnv() + tv := env.Tv() // try to set current with allowNoPollers=false --> error allowNoPollers := false - expectedErr := fmt.Sprintf(workerdeployment.ErrWorkerDeploymentNotFound, s.tv().WithBuildIDNumber(1).DeploymentVersion().GetDeploymentName()) - s.setCurrentVersionAllowNoPollersOption(env, s.tv().WithBuildIDNumber(1), true, allowNoPollers, false, expectedErr) + expectedErr := fmt.Sprintf(workerdeployment.ErrWorkerDeploymentNotFound, tv.DeploymentVersion().GetDeploymentName()) + s.setCurrentVersionAllowNoPollersOption(env, tv, true, allowNoPollers, false, expectedErr) // try to set current with allowNoPollers=true --> success allowNoPollers = true expectedErr = "" versionCreateTime := timestamppb.Now() - s.setCurrentVersionAllowNoPollersOption(env, s.tv().WithBuildIDNumber(1), true, allowNoPollers, false, expectedErr) + s.setCurrentVersionAllowNoPollersOption(env, tv, true, allowNoPollers, false, expectedErr) // let a poller arrive with that version --> triggers user data propagation - go s.pollFromDeployment(env, s.tv().WithBuildIDNumber(1)) + go s.pollFromDeployment(env, tv) s.Await(func(s *WorkerDeploymentSuite) { // check describe worker deployment resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: s.tv().WithBuildIDNumber(1).DeploymentSeries(), + DeploymentName: tv.DeploymentSeries(), }) s.NoError(err) s.verifyWorkerDeploymentInfo(&deploymentpb.WorkerDeploymentInfo{ - Name: s.tv().WithBuildIDNumber(1).DeploymentSeries(), + Name: tv.DeploymentSeries(), CreateTime: versionCreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ - CurrentVersion: s.tv().WithBuildIDNumber(1).DeploymentVersionString(), + CurrentVersion: tv.DeploymentVersionString(), CurrentVersionChangedTime: versionCreateTime, }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ { - Version: s.tv().WithBuildIDNumber(1).DeploymentVersionString(), + Version: tv.DeploymentVersionString(), CreateTime: versionCreateTime, DrainageInfo: nil, RoutingUpdateTime: versionCreateTime, @@ -2443,43 +2442,44 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentCurrentVersion_NoPollers( Status: enumspb.WORKER_DEPLOYMENT_VERSION_STATUS_CURRENT, }, }, - LastModifierIdentity: s.tv().WithBuildIDNumber(1).ClientIdentity(), + LastModifierIdentity: tv.ClientIdentity(), }, resp.GetWorkerDeploymentInfo()) }, 10*time.Second, 100*time.Millisecond) // that poller's task queue should have the current versioning info - s.verifyTaskQueueVersioningInfo(env, s.tv().WithBuildIDNumber(1).TaskQueue(), s.tv().WithBuildIDNumber(1).DeploymentVersionString(), "", 0) + s.verifyTaskQueueVersioningInfo(env, tv.TaskQueue(), tv.DeploymentVersionString(), "", 0) } func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_NoPollers() { env := s.newTestEnv() + tv := env.Tv() // try to set ramping with allowNoPollers=false --> error allowNoPollers := false - expectedErr := fmt.Sprintf(workerdeployment.ErrWorkerDeploymentNotFound, s.tv().WithBuildIDNumber(1).DeploymentVersion().GetDeploymentName()) - s.setAndVerifyRampingVersionUnversionedOption(env, s.tv().WithBuildIDNumber(1), false, false, 5, true, allowNoPollers, false, expectedErr) + expectedErr := fmt.Sprintf(workerdeployment.ErrWorkerDeploymentNotFound, tv.DeploymentVersion().GetDeploymentName()) + s.setAndVerifyRampingVersionUnversionedOption(env, tv, false, false, 5, true, allowNoPollers, false, expectedErr) // try to set ramping with allowNoPollers=true --> success allowNoPollers = true expectedErr = "" versionCreateTime := timestamppb.Now() - s.setAndVerifyRampingVersionUnversionedOption(env, s.tv().WithBuildIDNumber(1), false, false, 5, true, allowNoPollers, false, expectedErr) + s.setAndVerifyRampingVersionUnversionedOption(env, tv, false, false, 5, true, allowNoPollers, false, expectedErr) // let a poller arrive with that version --> triggers user data propagation - go s.pollFromDeployment(env, s.tv().WithBuildIDNumber(1)) + go s.pollFromDeployment(env, tv) s.Await(func(s *WorkerDeploymentSuite) { // check describe worker deployment resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: s.tv().WithBuildIDNumber(1).DeploymentSeries(), + DeploymentName: tv.DeploymentSeries(), }) s.NoError(err) s.verifyWorkerDeploymentInfo(&deploymentpb.WorkerDeploymentInfo{ - Name: s.tv().WithBuildIDNumber(1).DeploymentSeries(), + Name: tv.DeploymentSeries(), CreateTime: versionCreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ - RampingVersion: s.tv().WithBuildIDNumber(1).DeploymentVersionString(), + RampingVersion: tv.DeploymentVersionString(), RampingVersionPercentage: 5, RampingVersionChangedTime: versionCreateTime, RampingVersionPercentageChangedTime: versionCreateTime, @@ -2488,7 +2488,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_NoPollers( }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ { - Version: s.tv().WithBuildIDNumber(1).DeploymentVersionString(), + Version: tv.DeploymentVersionString(), CreateTime: versionCreateTime, DrainageInfo: nil, RoutingUpdateTime: versionCreateTime, @@ -2499,19 +2499,19 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_NoPollers( Status: enumspb.WORKER_DEPLOYMENT_VERSION_STATUS_RAMPING, }, }, - LastModifierIdentity: s.tv().WithBuildIDNumber(1).ClientIdentity(), + LastModifierIdentity: tv.ClientIdentity(), }, resp.GetWorkerDeploymentInfo()) }, 10*time.Second, 100*time.Millisecond) // that poller's task queue should have the ramping version info - s.verifyTaskQueueVersioningInfo(env, s.tv().WithBuildIDNumber(1).TaskQueue(), worker_versioning.UnversionedVersionId, s.tv().WithBuildIDNumber(1).DeploymentVersionString(), 5) + s.verifyTaskQueueVersioningInfo(env, tv.TaskQueue(), worker_versioning.UnversionedVersionId, tv.DeploymentVersionString(), 5) } func (s *WorkerDeploymentSuite) TestTwoPollers_EnsureCreateVersion() { env := s.newTestEnv() - tv1 := s.tv().WithBuildIDNumber(1) - tv2 := s.tv().WithBuildIDNumber(2) + tv1 := env.Tv() + tv2 := env.Tv().WithBuildIDNumber(2) go s.pollFromDeployment(env, tv1) go s.pollFromDeployment(env, tv2) @@ -2543,9 +2543,9 @@ func (s *WorkerDeploymentSuite) verifyTaskQueueVersioningInfo(env *testcore.Test func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { env := s.newTestEnv(testcore.WithDynamicConfig(dynamicconfig.PollerHistoryTTL, 500*time.Millisecond)) - tv1 := s.tv().WithBuildIDNumber(1) - tv2 := s.tv().WithBuildIDNumber(2) - tv3 := s.tv().WithBuildIDNumber(3) + tv1 := env.Tv() + tv2 := env.Tv().WithBuildIDNumber(2) + tv3 := env.Tv().WithBuildIDNumber(3) // Start deployment workflow 1 and wait for the deployment version to exist v1CreateTime := timestamppb.New(time.Now()) @@ -2905,8 +2905,8 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { func (s *WorkerDeploymentSuite) TestSetRampingVersion_AfterDrained() { env := s.newTestEnv(testcore.WithDynamicConfig(dynamicconfig.PollerHistoryTTL, 500*time.Millisecond)) - tv1 := s.tv().WithBuildIDNumber(1) - tv2 := s.tv().WithBuildIDNumber(2) + tv1 := env.Tv() + tv2 := env.Tv().WithBuildIDNumber(2) // Start deployment workflow 1 and wait for the deployment version to exist v1CreateTime := timestamppb.New(time.Now()) @@ -3119,7 +3119,7 @@ func (s *WorkerDeploymentSuite) TestSetRampingVersion_AfterDrained() { func (s *WorkerDeploymentSuite) TestDeleteWorkerDeployment_ValidDelete() { env := s.newTestEnv(testcore.WithDynamicConfig(dynamicconfig.PollerHistoryTTL, 500*time.Millisecond)) - tv1 := s.tv().WithBuildIDNumber(1) + tv1 := env.Tv() // Start deployment workflow 1 and wait for the deployment version to exist // Use a cancellable context so we can stop the poller before checking pollers disappeared @@ -3221,7 +3221,7 @@ func (s *WorkerDeploymentSuite) TestDeleteWorkerDeployment_ValidDelete() { func (s *WorkerDeploymentSuite) TestDeleteWorkerDeployment_Idempotent() { env := s.newTestEnv() - tv1 := s.tv().WithBuildIDNumber(1) + tv1 := env.Tv() s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) @@ -3237,7 +3237,7 @@ func (s *WorkerDeploymentSuite) TestDeleteWorkerDeployment_Idempotent() { func (s *WorkerDeploymentSuite) TestDeleteWorkerDeployment_InvalidDelete() { env := s.newTestEnv() - tv1 := s.tv().WithBuildIDNumber(1) + tv1 := env.Tv() // Start deployment workflow 1 and wait for the deployment version and deployment workflow to exist go s.pollFromDeployment(env, tv1) @@ -3689,9 +3689,9 @@ func (s *WorkerDeploymentSuite) buildWorkerDeploymentSummary( func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_Success() { env := s.newTestEnv() - deploymentName := s.tv().DeploymentSeries() - requestID := s.tv().Any().String() - identity := s.tv().Any().String() + deploymentName := env.Tv().DeploymentSeries() + requestID := env.Tv().Any().String() + identity := env.Tv().Any().String() // Create a new worker deployment resp, err := env.FrontendClient().CreateWorkerDeployment(s.Context(), &workflowservice.CreateWorkerDeploymentRequest{ @@ -3722,8 +3722,8 @@ func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_Success() { func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_Idempotent() { env := s.newTestEnv() - deploymentName := s.tv().DeploymentSeries() - requestID := s.tv().Any().String() + deploymentName := env.Tv().DeploymentSeries() + requestID := env.Tv().Any().String() // Create a worker deployment resp1, err := env.FrontendClient().CreateWorkerDeployment(s.Context(), &workflowservice.CreateWorkerDeploymentRequest{ @@ -3749,9 +3749,9 @@ func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_Idempotent() { func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_AlreadyExists_DifferentRequestID() { env := s.newTestEnv() - deploymentName := s.tv().DeploymentSeries() - requestID1 := s.tv().Any().String() - requestID2 := s.tv().Any().String() + deploymentName := env.Tv().DeploymentSeries() + requestID1 := env.Tv().Any().String() + requestID2 := env.Tv().Any().String() // Create a worker deployment _, err := env.FrontendClient().CreateWorkerDeployment(s.Context(), &workflowservice.CreateWorkerDeploymentRequest{ @@ -3777,14 +3777,14 @@ func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_AutoCreatedByPoller_C env := s.newTestEnv() // First, create deployment via polling - go s.pollFromDeployment(env, s.tv()) - s.ensureCreateDeployment(env, s.tv()) + go s.pollFromDeployment(env, env.Tv()) + s.ensureCreateDeployment(env, env.Tv()) // Try to explicitly create the same deployment _, err := env.FrontendClient().CreateWorkerDeployment(s.Context(), &workflowservice.CreateWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: s.tv().DeploymentSeries(), - RequestId: s.tv().Any().String(), + DeploymentName: env.Tv().DeploymentSeries(), + RequestId: env.Tv().Any().String(), }) s.Error(err) var alreadyExists *serviceerror.AlreadyExists @@ -3826,7 +3826,7 @@ func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_InvalidDeploymentName _, err := env.FrontendClient().CreateWorkerDeployment(s.Context(), &workflowservice.CreateWorkerDeploymentRequest{ Namespace: env.Namespace().String(), DeploymentName: tc.deploymentName, - RequestId: s.tv().Any().String(), + RequestId: env.Tv().Any().String(), }) s.Error(err) var invalidArg *serviceerror.InvalidArgument @@ -3847,16 +3847,16 @@ func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_MaxDeploymentsLimit() // Create first deployment _, err := env.FrontendClient().CreateWorkerDeployment(s.Context(), &workflowservice.CreateWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: s.tv().DeploymentSeries() + "_1", - RequestId: s.tv().Any().String(), + DeploymentName: env.Tv().DeploymentSeries() + "_1", + RequestId: env.Tv().Any().String(), }) s.NoError(err) // Create second deployment _, err = env.FrontendClient().CreateWorkerDeployment(s.Context(), &workflowservice.CreateWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: s.tv().DeploymentSeries() + "_2", - RequestId: s.tv().Any().String(), + DeploymentName: env.Tv().DeploymentSeries() + "_2", + RequestId: env.Tv().Any().String(), }) s.NoError(err) @@ -3866,8 +3866,8 @@ func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_MaxDeploymentsLimit() // Try to create third deployment - should fail _, err = env.FrontendClient().CreateWorkerDeployment(s.Context(), &workflowservice.CreateWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: s.tv().DeploymentSeries() + "_3", - RequestId: s.tv().Any().String(), + DeploymentName: env.Tv().DeploymentSeries() + "_3", + RequestId: env.Tv().Any().String(), }) s.Error(err) var resourceExhausted *serviceerror.ResourceExhausted @@ -3880,9 +3880,9 @@ func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_MaxDeploymentsLimit() func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_AfterDelete_CanRecreate() { env := s.newTestEnv() - deploymentName := s.tv().DeploymentSeries() - requestID1 := s.tv().Any().String() - requestID2 := s.tv().Any().String() + deploymentName := env.Tv().DeploymentSeries() + requestID1 := env.Tv().Any().String() + requestID2 := env.Tv().Any().String() // Create a worker deployment resp1, err := env.FrontendClient().CreateWorkerDeployment(s.Context(), &workflowservice.CreateWorkerDeploymentRequest{ From 4ca925cf48c7d3d50f2724edbf4d1411339ce624 Mon Sep 17 00:00:00 2001 From: Stephan Behnke Date: Thu, 18 Jun 2026 16:34:08 -0700 Subject: [PATCH 09/27] Update worker_deployment_test.go --- tests/worker_deployment_test.go | 24 +++++++++--------------- 1 file changed, 9 insertions(+), 15 deletions(-) diff --git a/tests/worker_deployment_test.go b/tests/worker_deployment_test.go index 7a4912ccf79..819d9b1d0e9 100644 --- a/tests/worker_deployment_test.go +++ b/tests/worker_deployment_test.go @@ -495,10 +495,8 @@ func (s *WorkerDeploymentSuite) TestConflictToken_SetCurrent_SetRamping_Wrong() expectedError := "conflict token mismatch" - firstVersion := env.Tv() - // Start deployment version workflow + worker-deployment workflow. - go s.pollFromDeployment(env, firstVersion) + go s.pollFromDeployment(env, env.Tv()) cTWrong, _ := time.Now().MarshalBinary() // wrong token // Wait until deployment exists @@ -990,17 +988,15 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Ramping_Wi func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_DuplicateRamp() { env := s.newTestEnv() - rampingVersionVars := env.Tv() - versionCreateTime := timestamppb.Now() - s.startVersionWorkflow(env, rampingVersionVars) + s.startVersionWorkflow(env, env.Tv()) // set version as ramping setRampingUpdateTime := timestamppb.Now() - s.setAndVerifyRampingVersion(env, rampingVersionVars, false, 50, true, "") + s.setAndVerifyRampingVersion(env, env.Tv(), false, 50, true, "") resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: rampingVersionVars.DeploymentSeries(), + DeploymentName: env.Tv().DeploymentSeries(), }) s.NoError(err) s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ @@ -1040,15 +1036,14 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Invalid_Se env := s.newTestEnv() versionCreateTime := timestamppb.Now() - currentVersionVars := env.Tv() - s.startVersionWorkflow(env, currentVersionVars) + s.startVersionWorkflow(env, env.Tv()) setCurrentUpdateTime := timestamppb.Now() - s.setCurrentVersion(env, currentVersionVars, true, "") + s.setCurrentVersion(env, env.Tv(), true, "") resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: currentVersionVars.DeploymentSeries(), + DeploymentName: env.Tv().DeploymentSeries(), }) s.NoError(err) s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ @@ -1139,12 +1134,11 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_ModifyExis env := s.newTestEnv() versionCreateTime := timestamppb.Now() - rampingVersionVars := env.Tv() - s.startVersionWorkflow(env, rampingVersionVars) + s.startVersionWorkflow(env, env.Tv()) // set version as ramping setRampingUpdateTime := timestamppb.Now() - s.setAndVerifyRampingVersion(env, rampingVersionVars, false, 50, true, "") + s.setAndVerifyRampingVersion(env, env.Tv(), false, 50, true, "") resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), DeploymentName: env.Tv().DeploymentSeries(), From b7fe93ed6eefa6b30a8d2244997e57b0f4fb2730 Mon Sep 17 00:00:00 2001 From: Stephan Behnke Date: Thu, 18 Jun 2026 16:34:32 -0700 Subject: [PATCH 10/27] Update worker_deployment_test.go --- tests/worker_deployment_test.go | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/tests/worker_deployment_test.go b/tests/worker_deployment_test.go index 819d9b1d0e9..02168109976 100644 --- a/tests/worker_deployment_test.go +++ b/tests/worker_deployment_test.go @@ -372,7 +372,7 @@ func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_TwoVersions_Sorted( a.NotNil(versionSummaries[0].GetVersion()) a.NotNil(versionSummaries[1].GetVersion()) a.Equal(versionSummaries[0].GetVersion(), secondVersion.DeploymentVersionString()) - a.Equal(versionSummaries[1].GetVersion(), firstVersion.DeploymentVersionString()) + a.Equal(versionSummaries[1].GetVersion(), env.Tv().DeploymentVersionString()) a.NotNil(resp.GetWorkerDeploymentInfo().GetVersionSummaries()[0].GetCreateTime()) a.NotNil(resp.GetWorkerDeploymentInfo().GetVersionSummaries()[1].GetCreateTime()) @@ -450,7 +450,7 @@ func (s *WorkerDeploymentSuite) TestConflictToken_Describe_SetCurrent_SetRamping _, err := env.FrontendClient().SetWorkerDeploymentCurrentVersion(s.Context(), &workflowservice.SetWorkerDeploymentCurrentVersionRequest{ Namespace: env.Namespace().String(), DeploymentName: env.Tv().DeploymentSeries(), - Version: firstVersion.DeploymentVersionString(), + Version: env.Tv().DeploymentVersionString(), ConflictToken: cT, }) s.NoError(err) @@ -463,7 +463,7 @@ func (s *WorkerDeploymentSuite) TestConflictToken_Describe_SetCurrent_SetRamping DeploymentName: env.Tv().DeploymentSeries(), }) a.NoError(err) - a.Equal(firstVersion.DeploymentVersionString(), resp.GetWorkerDeploymentInfo().GetRoutingConfig().GetCurrentVersion()) + a.Equal(env.Tv().DeploymentVersionString(), resp.GetWorkerDeploymentInfo().GetRoutingConfig().GetCurrentVersion()) cT = resp.GetConflictToken() }, time.Second*10, time.Millisecond*1000) @@ -514,7 +514,7 @@ func (s *WorkerDeploymentSuite) TestConflictToken_SetCurrent_SetRamping_Wrong() _, err := env.FrontendClient().SetWorkerDeploymentCurrentVersion(s.Context(), &workflowservice.SetWorkerDeploymentCurrentVersionRequest{ Namespace: env.Namespace().String(), DeploymentName: env.Tv().DeploymentSeries(), - Version: firstVersion.DeploymentVersionString(), + Version: env.Tv().DeploymentVersionString(), ConflictToken: cTWrong, }) s.Equal(expectedError, err.Error()) @@ -523,7 +523,7 @@ func (s *WorkerDeploymentSuite) TestConflictToken_SetCurrent_SetRamping_Wrong() _, err = env.FrontendClient().SetWorkerDeploymentRampingVersion(s.Context(), &workflowservice.SetWorkerDeploymentRampingVersionRequest{ Namespace: env.Namespace().String(), DeploymentName: env.Tv().DeploymentSeries(), - Version: firstVersion.DeploymentVersionString(), + Version: env.Tv().DeploymentVersionString(), Percentage: 5, ConflictToken: cTWrong, }) @@ -586,7 +586,7 @@ func (s *WorkerDeploymentSuite) TestListWorkerDeployments_TwoVersions_SameDeploy s.setCurrentVersion(env, firstVersion, true, "") routingInfo := &deploymentpb.RoutingConfig{ - CurrentVersion: firstVersion.DeploymentVersionString(), + CurrentVersion: env.Tv().DeploymentVersionString(), CurrentVersionChangedTime: setCurrentTime, } @@ -602,7 +602,7 @@ func (s *WorkerDeploymentSuite) TestListWorkerDeployments_TwoVersions_SameDeploy Status: enumspb.WORKER_DEPLOYMENT_VERSION_STATUS_INACTIVE, } currentVersionSummary := &deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ - Version: firstVersion.DeploymentVersionString(), + Version: env.Tv().DeploymentVersionString(), CreateTime: createVersion1Time, DrainageInfo: nil, RampingSinceTime: nil, @@ -1569,12 +1569,12 @@ func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_SetCurrentVersion() Name: env.Tv().DeploymentSeries(), CreateTime: version1CreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ - CurrentVersion: firstVersion.DeploymentVersionString(), + CurrentVersion: env.Tv().DeploymentVersionString(), CurrentVersionChangedTime: firstVersionCurrentUpdateTime, }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ { - Version: firstVersion.DeploymentVersionString(), + Version: env.Tv().DeploymentVersionString(), CreateTime: version1CreateTime, DrainageInfo: nil, RoutingUpdateTime: firstVersionCurrentUpdateTime, @@ -1614,7 +1614,7 @@ func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_SetCurrentVersion() }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ { - Version: firstVersion.DeploymentVersionString(), + Version: env.Tv().DeploymentVersionString(), CreateTime: version1CreateTime, DrainageInfo: &deploymentpb.VersionDrainageInfo{Status: enumspb.VERSION_DRAINAGE_STATUS_DRAINING}, RoutingUpdateTime: firstVersionCurrentUpdateTime, From cb703c7810bd750e445ec8d0a54a4b326b500499 Mon Sep 17 00:00:00 2001 From: Stephan Behnke Date: Thu, 18 Jun 2026 16:34:51 -0700 Subject: [PATCH 11/27] Update worker_deployment_test.go --- tests/worker_deployment_test.go | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/tests/worker_deployment_test.go b/tests/worker_deployment_test.go index 02168109976..9e384148196 100644 --- a/tests/worker_deployment_test.go +++ b/tests/worker_deployment_test.go @@ -1001,10 +1001,10 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_DuplicateR s.NoError(err) s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ - Name: rampingVersionVars.DeploymentSeries(), + Name: env.Tv().DeploymentSeries(), CreateTime: versionCreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ - RampingVersion: rampingVersionVars.DeploymentVersionString(), + RampingVersion: env.Tv().DeploymentVersionString(), RampingVersionPercentage: 50, RampingVersionChangedTime: setRampingUpdateTime, RampingVersionPercentageChangedTime: setRampingUpdateTime, @@ -1013,7 +1013,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_DuplicateR }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ { - Version: rampingVersionVars.DeploymentVersionString(), + Version: env.Tv().DeploymentVersionString(), CreateTime: versionCreateTime, DrainageInfo: nil, RampingSinceTime: setRampingUpdateTime, @@ -1024,12 +1024,12 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_DuplicateR Status: enumspb.WORKER_DEPLOYMENT_VERSION_STATUS_RAMPING, }, }, - LastModifierIdentity: rampingVersionVars.ClientIdentity(), + LastModifierIdentity: env.Tv().ClientIdentity(), }, }) // setting version as ramping again - s.setAndVerifyRampingVersion(env, rampingVersionVars, false, 50, true, "") + s.setAndVerifyRampingVersion(env, env.Tv(), false, 50, true, "") } func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Invalid_SetCurrent_To_Ramping() { @@ -1048,19 +1048,19 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Invalid_Se s.NoError(err) s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ - Name: currentVersionVars.DeploymentSeries(), + Name: env.Tv().DeploymentSeries(), CreateTime: versionCreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ RampingVersion: "", // no ramping info should be set RampingVersionPercentage: 0, // no ramping info should be set RampingVersionChangedTime: nil, // no ramping info should be set RampingVersionPercentageChangedTime: nil, // no ramping info should be set - CurrentVersion: currentVersionVars.DeploymentVersionString(), + CurrentVersion: env.Tv().DeploymentVersionString(), CurrentVersionChangedTime: setCurrentUpdateTime, }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ { - Version: currentVersionVars.DeploymentVersionString(), + Version: env.Tv().DeploymentVersionString(), CreateTime: versionCreateTime, DrainageInfo: nil, RoutingUpdateTime: setCurrentUpdateTime, From e0730fed05851a9e7453ebfc9ca6a1f339b51fa5 Mon Sep 17 00:00:00 2001 From: Stephan Behnke Date: Thu, 18 Jun 2026 16:35:18 -0700 Subject: [PATCH 12/27] Update worker_deployment_test.go --- tests/worker_deployment_test.go | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/tests/worker_deployment_test.go b/tests/worker_deployment_test.go index 9e384148196..69abf706e99 100644 --- a/tests/worker_deployment_test.go +++ b/tests/worker_deployment_test.go @@ -1072,33 +1072,33 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Invalid_Se Status: enumspb.WORKER_DEPLOYMENT_VERSION_STATUS_CURRENT, }, }, - LastModifierIdentity: currentVersionVars.ClientIdentity(), + LastModifierIdentity: env.Tv().ClientIdentity(), }, }) - expectedError := fmt.Errorf("ramping version %s is already current", currentVersionVars.DeploymentVersionString()) - s.setAndVerifyRampingVersion(env, currentVersionVars, false, 50, true, expectedError.Error()) // setting current version to ramping should fail + expectedError := fmt.Errorf("ramping version %s is already current", env.Tv().DeploymentVersionString()) + s.setAndVerifyRampingVersion(env, env.Tv(), false, 50, true, expectedError.Error()) // setting current version to ramping should fail resp, err = env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: currentVersionVars.DeploymentSeries(), + DeploymentName: env.Tv().DeploymentSeries(), }) s.NoError(err) s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ - Name: currentVersionVars.DeploymentSeries(), + Name: env.Tv().DeploymentSeries(), CreateTime: versionCreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ RampingVersion: "", // no ramping info should be set RampingVersionPercentage: 0, // no ramping info should be set RampingVersionChangedTime: nil, // no ramping info should be set RampingVersionPercentageChangedTime: nil, // no ramping info should be set - CurrentVersion: currentVersionVars.DeploymentVersionString(), + CurrentVersion: env.Tv().DeploymentVersionString(), CurrentVersionChangedTime: versionCreateTime, }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ { - Version: currentVersionVars.DeploymentVersionString(), + Version: env.Tv().DeploymentVersionString(), CreateTime: versionCreateTime, DrainageInfo: nil, RoutingUpdateTime: setCurrentUpdateTime, @@ -1110,7 +1110,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Invalid_Se Status: enumspb.WORKER_DEPLOYMENT_VERSION_STATUS_CURRENT, }, }, - LastModifierIdentity: currentVersionVars.ClientIdentity(), + LastModifierIdentity: env.Tv().ClientIdentity(), }, }) } @@ -1149,7 +1149,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_ModifyExis Name: env.Tv().DeploymentSeries(), CreateTime: versionCreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ - RampingVersion: rampingVersionVars.DeploymentVersionString(), + RampingVersion: env.Tv().DeploymentVersionString(), RampingVersionPercentage: 50, RampingVersionChangedTime: setRampingUpdateTime, RampingVersionPercentageChangedTime: setRampingUpdateTime, @@ -1158,7 +1158,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_ModifyExis }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ { - Version: rampingVersionVars.DeploymentVersionString(), + Version: env.Tv().DeploymentVersionString(), CreateTime: versionCreateTime, DrainageInfo: nil, RampingSinceTime: setRampingUpdateTime, @@ -1175,7 +1175,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_ModifyExis // modify ramping version percentage modifyRampingPercentageTime := timestamppb.Now() - s.setAndVerifyRampingVersion(env, rampingVersionVars, false, 75, true, "") + s.setAndVerifyRampingVersion(env, env.Tv(), false, 75, true, "") // RampingVersionPercentage and RampingVersionPercentageChangedTime should be updated resp, err = env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ From b2df3b3d94977ae2186702f3f629d6cbf24be031 Mon Sep 17 00:00:00 2001 From: Stephan Behnke Date: Thu, 18 Jun 2026 16:37:18 -0700 Subject: [PATCH 13/27] Update worker_deployment_test.go --- tests/worker_deployment_test.go | 46 ++++++++++++++------------------- 1 file changed, 20 insertions(+), 26 deletions(-) diff --git a/tests/worker_deployment_test.go b/tests/worker_deployment_test.go index 69abf706e99..6baff29e4e7 100644 --- a/tests/worker_deployment_test.go +++ b/tests/worker_deployment_test.go @@ -802,7 +802,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Ramping_Wi Name: env.Tv().DeploymentSeries(), CreateTime: versionCreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ - RampingVersion: rampingVersionVars.DeploymentVersionString(), + RampingVersion: env.Tv().DeploymentVersionString(), RampingVersionPercentage: 50, RampingVersionChangedTime: setRampingUpdateTime, RampingVersionPercentageChangedTime: setRampingUpdateTime, @@ -811,7 +811,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Ramping_Wi }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ { - Version: rampingVersionVars.DeploymentVersionString(), + Version: env.Tv().DeploymentVersionString(), CreateTime: versionCreateTime, DrainageInfo: nil, RampingSinceTime: setRampingUpdateTime, @@ -841,7 +841,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Ramping_Wi Name: env.Tv().DeploymentSeries(), CreateTime: versionCreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ - RampingVersion: rampingVersionVars.DeploymentVersionString(), + RampingVersion: env.Tv().DeploymentVersionString(), RampingVersionPercentage: 50, RampingVersionChangedTime: setRampingUpdateTime, RampingVersionPercentageChangedTime: setRampingUpdateTime, @@ -862,7 +862,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Ramping_Wi Status: enumspb.WORKER_DEPLOYMENT_VERSION_STATUS_CURRENT, }, { - Version: rampingVersionVars.DeploymentVersionString(), + Version: env.Tv().DeploymentVersionString(), CreateTime: versionCreateTime, DrainageInfo: nil, RoutingUpdateTime: setRampingUpdateTime, @@ -895,7 +895,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Ramping_Wi RampingVersionPercentage: 0, RampingVersionChangedTime: setRampingAsCurrentUpdateTime, RampingVersionPercentageChangedTime: setRampingAsCurrentUpdateTime, - CurrentVersion: rampingVersionVars.DeploymentVersionString(), + CurrentVersion: env.Tv().DeploymentVersionString(), CurrentVersionChangedTime: setRampingAsCurrentUpdateTime, }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ @@ -914,7 +914,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Ramping_Wi Status: enumspb.WORKER_DEPLOYMENT_VERSION_STATUS_DRAINING, }, { - Version: rampingVersionVars.DeploymentVersionString(), + Version: env.Tv().DeploymentVersionString(), CreateTime: versionCreateTime, DrainageInfo: nil, RoutingUpdateTime: setRampingAsCurrentUpdateTime, @@ -965,7 +965,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Ramping_Wi Status: enumspb.WORKER_DEPLOYMENT_VERSION_STATUS_CURRENT, }, { - Version: rampingVersionVars.DeploymentVersionString(), + Version: env.Tv().DeploymentVersionString(), CreateTime: versionCreateTime, DrainageInfo: &deploymentpb.VersionDrainageInfo{ Status: enumspb.VERSION_DRAINAGE_STATUS_DRAINING, @@ -1188,7 +1188,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_ModifyExis Name: env.Tv().DeploymentSeries(), CreateTime: versionCreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ - RampingVersion: rampingVersionVars.DeploymentVersionString(), + RampingVersion: env.Tv().DeploymentVersionString(), RampingVersionPercentage: 75, // ramping version percentage is updated to 75 RampingVersionChangedTime: setRampingUpdateTime, RampingVersionPercentageChangedTime: modifyRampingPercentageTime, // timestamp is updated as the ramp percentage changed from 50 -> 75 @@ -1197,7 +1197,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_ModifyExis }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ { - Version: rampingVersionVars.DeploymentVersionString(), + Version: env.Tv().DeploymentVersionString(), CreateTime: versionCreateTime, DrainageInfo: nil, RoutingUpdateTime: modifyRampingPercentageTime, @@ -1241,7 +1241,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_WithCurren Name: env.Tv().DeploymentSeries(), CreateTime: version1CreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ - RampingVersion: rampingVersionVars.DeploymentVersionString(), + RampingVersion: env.Tv().DeploymentVersionString(), RampingVersionPercentage: 50, RampingVersionChangedTime: setRampingUpdateTime, RampingVersionPercentageChangedTime: setRampingUpdateTime, @@ -1250,7 +1250,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_WithCurren }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ { - Version: rampingVersionVars.DeploymentVersionString(), + Version: env.Tv().DeploymentVersionString(), CreateTime: version1CreateTime, DrainageInfo: nil, RoutingUpdateTime: setRampingUpdateTime, @@ -1300,7 +1300,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_WithCurren }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ { - Version: rampingVersionVars.DeploymentVersionString(), + Version: env.Tv().DeploymentVersionString(), CreateTime: version1CreateTime, DrainageInfo: &deploymentpb.VersionDrainageInfo{Status: enumspb.VERSION_DRAINAGE_STATUS_DRAINING}, RoutingUpdateTime: unsetRampingUpdateTime, @@ -1332,15 +1332,14 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_SetRamping env := s.newTestEnv() versionCreateTime := timestamppb.Now() - rampingVersionVars := env.Tv() - s.startVersionWorkflow(env, rampingVersionVars) + s.startVersionWorkflow(env, env.Tv()) setRampingUpdateTime := timestamppb.Now() - s.setAndVerifyRampingVersion(env, rampingVersionVars, false, 50, true, "") + s.setAndVerifyRampingVersion(env, env.Tv(), false, 50, true, "") // set ramping version as current setCurrentUpdateTime := timestamppb.Now() - s.setCurrentVersion(env, rampingVersionVars, true, "") + s.setCurrentVersion(env, env.Tv(), true, "") resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), @@ -1356,12 +1355,12 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_SetRamping RampingVersionPercentage: 0, // no ramping info should be set RampingVersionChangedTime: setCurrentUpdateTime, // ramping version got updated to "" RampingVersionPercentageChangedTime: setCurrentUpdateTime, // ramping version got updated to "" - CurrentVersion: rampingVersionVars.DeploymentVersionString(), + CurrentVersion: env.Tv().DeploymentVersionString(), CurrentVersionChangedTime: setCurrentUpdateTime, }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ { - Version: rampingVersionVars.DeploymentVersionString(), + Version: env.Tv().DeploymentVersionString(), CreateTime: versionCreateTime, DrainageInfo: nil, RoutingUpdateTime: setCurrentUpdateTime, @@ -1381,11 +1380,10 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_SetRamping func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_NoCurrent_Unset_Ramp() { env := s.newTestEnv() - rampingVersionVars := env.Tv() - s.startVersionWorkflow(env, rampingVersionVars) + s.startVersionWorkflow(env, env.Tv()) - s.setAndVerifyRampingVersion(env, rampingVersionVars, false, 50, true, "") - s.setAndVerifyRampingVersion(env, rampingVersionVars, true, 0, true, "") + s.setAndVerifyRampingVersion(env, env.Tv(), false, 50, true, "") + s.setAndVerifyRampingVersion(env, env.Tv(), true, 0, true, "") } func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Batching() { @@ -3918,10 +3916,6 @@ func (s *WorkerDeploymentSuite) TestCreateWorkerDeployment_AfterDelete_CanRecrea s.Empty(descResp.WorkerDeploymentInfo.VersionSummaries) // No versions initially } -func (s *WorkerDeploymentSuite) tv() *testvars.TestVars { - return testvars.New(s.T()) -} - func (s *WorkerDeploymentSuite) skipBeforeVersion(version workerdeployment.DeploymentWorkflowVersion) { if workerdeployment.VersionDataRevisionNumber < version { s.T().Skipf("test supports version %v and newer", version) From ae6a5b13aa191cb2ed61f8a6e1e3c2ee07398543 Mon Sep 17 00:00:00 2001 From: Stephan Behnke Date: Thu, 18 Jun 2026 16:39:07 -0700 Subject: [PATCH 14/27] Update worker_deployment_test.go --- tests/worker_deployment_test.go | 227 +++++++++++++++----------------- 1 file changed, 108 insertions(+), 119 deletions(-) diff --git a/tests/worker_deployment_test.go b/tests/worker_deployment_test.go index 6baff29e4e7..fdc5041fcee 100644 --- a/tests/worker_deployment_test.go +++ b/tests/worker_deployment_test.go @@ -338,7 +338,7 @@ func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_TwoVersions_Sorted( env := s.newTestEnv() // Starting two versions of the deployment - firstVersion := env.Tv() + firstVersion := env.Tv().WithBuildIDNumber(1) secondVersion := env.Tv().WithBuildIDNumber(2) go s.pollFromDeployment(env, firstVersion) @@ -424,7 +424,7 @@ func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_MultipleVersions_So func (s *WorkerDeploymentSuite) TestConflictToken_Describe_SetCurrent_SetRamping() { env := s.newTestEnv() - firstVersion := env.Tv() + firstVersion := env.Tv().WithBuildIDNumber(1) secondVersion := env.Tv().WithBuildIDNumber(2) // Start deployment version workflow + worker-deployment workflow. @@ -571,7 +571,7 @@ func (s *WorkerDeploymentSuite) TestListWorkerDeployments_OneVersion_OneDeployme func (s *WorkerDeploymentSuite) TestListWorkerDeployments_TwoVersions_SameDeployment_OneCurrent_NoRamping() { env := s.newTestEnv() - firstVersion := env.Tv() + firstVersion := env.Tv().WithBuildIDNumber(1) secondVersion := env.Tv().WithBuildIDNumber(2) createVersion1Time := timestamppb.Now() @@ -633,7 +633,7 @@ func (s *WorkerDeploymentSuite) TestListWorkerDeployments_TwoVersions_SameDeploy func (s *WorkerDeploymentSuite) TestListWorkerDeployments_TwoVersions_SameDeployment_OneCurrent_OneRamping() { env := s.newTestEnv() - currentVersionVars := env.Tv() + currentVersionVars := env.Tv().WithBuildIDNumber(1) rampingVersionVars := env.Tv().WithBuildIDNumber(2) createVersion1Time := timestamppb.Now() @@ -782,7 +782,7 @@ func (s *WorkerDeploymentSuite) TestListWorkerDeployments_MultipleVersions_Multi func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Ramping_With_Current() { env := s.newTestEnv() - rampingVersionVars := env.Tv() + rampingVersionVars := env.Tv().WithBuildIDNumber(1) currentVersionVars := env.Tv().WithBuildIDNumber(2) versionCreateTime := timestamppb.Now() @@ -1217,7 +1217,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_ModifyExis func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_WithCurrent_Unset_Ramp() { env := s.newTestEnv() - rampingVersionVars := env.Tv() + rampingVersionVars := env.Tv().WithBuildIDNumber(1) currentVersionVars := env.Tv().WithBuildIDNumber(2) version1CreateTime := timestamppb.Now() @@ -1533,7 +1533,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Unversione func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_SetCurrentVersion() { env := s.newTestEnv() - firstVersion := env.Tv() + firstVersion := env.Tv().WithBuildIDNumber(1) secondVersion := env.Tv().WithBuildIDNumber(2) version1CreateTime := timestamppb.Now() @@ -1713,75 +1713,72 @@ func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Batching() { func (s *WorkerDeploymentSuite) TestSetManagerIdentity_RW() { env := s.newTestEnv() - tv := env.Tv() - go s.pollFromDeployment(env, tv) - s.ensureCreateVersionInDeployment(env, tv) + go s.pollFromDeployment(env, env.Tv()) + s.ensureCreateVersionInDeployment(env, env.Tv()) // set identity to self - s.setAndValidateManagerIdentity(env, tv, true, false, "", "") + s.setAndValidateManagerIdentity(env, env.Tv(), true, false, "", "") // set identity to other - s.setAndValidateManagerIdentity(env, tv, false, false, "other", "") + s.setAndValidateManagerIdentity(env, env.Tv(), false, false, "other", "") // set identity to other again (should be idempotent) - s.setAndValidateManagerIdentity(env, tv, false, false, "other", "") + s.setAndValidateManagerIdentity(env, env.Tv(), false, false, "other", "") // unset identity - s.setAndValidateManagerIdentity(env, tv, false, false, "", "") + s.setAndValidateManagerIdentity(env, env.Tv(), false, false, "", "") // set identity with bad conflict token - s.setAndValidateManagerIdentity(env, tv, true, true, "", "conflict token mismatch") + s.setAndValidateManagerIdentity(env, env.Tv(), true, true, "", "conflict token mismatch") } func (s *WorkerDeploymentSuite) TestSetManagerIdentity_WithSetRampSetCurrent() { env := s.newTestEnv() - tv := env.Tv() - go s.pollFromDeployment(env, tv) - s.ensureCreateVersionInDeployment(env, tv) + go s.pollFromDeployment(env, env.Tv()) + s.ensureCreateVersionInDeployment(env, env.Tv()) // set identity to self - s.setAndValidateManagerIdentity(env, tv, true, false, "", "") + s.setAndValidateManagerIdentity(env, env.Tv(), true, false, "", "") // -> self can successfully set ramp - s.setAndVerifyRampingVersion(env, tv, false, 1, true, "") + s.setAndVerifyRampingVersion(env, env.Tv(), false, 1, true, "") // set identity to other - s.setAndValidateManagerIdentity(env, tv, false, false, "other", "") + s.setAndValidateManagerIdentity(env, env.Tv(), false, false, "other", "") // -> self cannot set ramp - s.setAndVerifyRampingVersion(env, tv, false, 2, true, fmt.Sprintf(workerdeployment.ErrManagerIdentityMismatch, "other", tv.ClientIdentity())) + s.setAndVerifyRampingVersion(env, env.Tv(), false, 2, true, fmt.Sprintf(workerdeployment.ErrManagerIdentityMismatch, "other", env.Tv().ClientIdentity())) // -> self cannot set current - s.setCurrentVersion(env, tv, true, fmt.Sprintf(workerdeployment.ErrManagerIdentityMismatch, "other", tv.ClientIdentity())) + s.setCurrentVersion(env, env.Tv(), true, fmt.Sprintf(workerdeployment.ErrManagerIdentityMismatch, "other", env.Tv().ClientIdentity())) // unset identity - s.setAndValidateManagerIdentity(env, tv, false, false, "", "") + s.setAndValidateManagerIdentity(env, env.Tv(), false, false, "", "") // -> self can now set ramp - s.setAndVerifyRampingVersion(env, tv, false, 2, true, "") + s.setAndVerifyRampingVersion(env, env.Tv(), false, 2, true, "") // set identity to self - s.setAndValidateManagerIdentity(env, tv, true, false, "", "") + s.setAndValidateManagerIdentity(env, env.Tv(), true, false, "", "") // -> self can now set current - s.setCurrentVersion(env, tv, true, "") + s.setCurrentVersion(env, env.Tv(), true, "") } func (s *WorkerDeploymentSuite) TestSetManagerIdentity_WithDeleteVersion() { env := s.newTestEnv(testcore.WithDynamicConfig(dynamicconfig.PollerHistoryTTL, 500*time.Millisecond)) - tv := env.Tv() // start and stop polling so that version is eligible for deletion - pollerCancel := s.startDeploymentPoller(env, tv) - s.ensureCreateVersionInDeployment(env, tv) + pollerCancel := s.startDeploymentPoller(env, env.Tv()) + s.ensureCreateVersionInDeployment(env, env.Tv()) pollerCancel() // set identity to other - s.setAndValidateManagerIdentity(env, tv, false, false, "other", "") + s.setAndValidateManagerIdentity(env, env.Tv(), false, false, "other", "") // -> self cannot delete version - s.tryDeleteVersion(env, tv, fmt.Sprintf(workerdeployment.ErrManagerIdentityMismatch, "other", tv.ClientIdentity())) + s.tryDeleteVersion(env, env.Tv(), fmt.Sprintf(workerdeployment.ErrManagerIdentityMismatch, "other", env.Tv().ClientIdentity())) // set identity to self - s.setAndValidateManagerIdentity(env, tv, true, false, "", "") + s.setAndValidateManagerIdentity(env, env.Tv(), true, false, "", "") // -> self can now delete version - s.tryDeleteVersion(env, tv, "") + s.tryDeleteVersion(env, env.Tv(), "") } // TestDeleteVersion_ServerDeleteMaxVersionsReached tests that when the internal limit for the number of versions @@ -1793,7 +1790,7 @@ func (s *WorkerDeploymentSuite) TestDeleteVersion_ServerDeleteMaxVersionsReached testcore.WithDynamicConfig(dynamicconfig.MatchingMaxVersionsInDeployment, 1), ) - tv1 := env.Tv() + tv1 := env.Tv().WithBuildIDNumber(1) tv2 := env.Tv().WithBuildIDNumber(2) // start and stop polling so that version is eligible for deletion @@ -1815,14 +1812,14 @@ func (s *WorkerDeploymentSuite) TestDeleteVersion_ServerDeleteMaxVersionsReached a := require.New(t) resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv1.DeploymentSeries(), + DeploymentName: env.Tv().DeploymentSeries(), }) a.NoError(err) a.Len(resp.GetWorkerDeploymentInfo().GetVersionSummaries(), 1) a.Equal(tv2.ExternalDeploymentVersion().GetBuildId(), resp.GetWorkerDeploymentInfo().GetVersionSummaries()[0].GetDeploymentVersion().GetBuildId()) // Also verify that the last modifier identity is not set to the identity of the worker-deployment workflow. - a.NotEqual(tv1.ClientIdentity(), resp.GetWorkerDeploymentInfo().GetLastModifierIdentity()) + a.NotEqual(env.Tv().ClientIdentity(), resp.GetWorkerDeploymentInfo().GetLastModifierIdentity()) }, time.Second*5, time.Millisecond*200) } @@ -2390,39 +2387,38 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Unversione func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentCurrentVersion_NoPollers() { env := s.newTestEnv() - tv := env.Tv() // try to set current with allowNoPollers=false --> error allowNoPollers := false - expectedErr := fmt.Sprintf(workerdeployment.ErrWorkerDeploymentNotFound, tv.DeploymentVersion().GetDeploymentName()) - s.setCurrentVersionAllowNoPollersOption(env, tv, true, allowNoPollers, false, expectedErr) + expectedErr := fmt.Sprintf(workerdeployment.ErrWorkerDeploymentNotFound, env.Tv().DeploymentVersion().GetDeploymentName()) + s.setCurrentVersionAllowNoPollersOption(env, env.Tv(), true, allowNoPollers, false, expectedErr) // try to set current with allowNoPollers=true --> success allowNoPollers = true expectedErr = "" versionCreateTime := timestamppb.Now() - s.setCurrentVersionAllowNoPollersOption(env, tv, true, allowNoPollers, false, expectedErr) + s.setCurrentVersionAllowNoPollersOption(env, env.Tv(), true, allowNoPollers, false, expectedErr) // let a poller arrive with that version --> triggers user data propagation - go s.pollFromDeployment(env, tv) + go s.pollFromDeployment(env, env.Tv()) s.Await(func(s *WorkerDeploymentSuite) { // check describe worker deployment resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv.DeploymentSeries(), + DeploymentName: env.Tv().DeploymentSeries(), }) s.NoError(err) s.verifyWorkerDeploymentInfo(&deploymentpb.WorkerDeploymentInfo{ - Name: tv.DeploymentSeries(), + Name: env.Tv().DeploymentSeries(), CreateTime: versionCreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ - CurrentVersion: tv.DeploymentVersionString(), + CurrentVersion: env.Tv().DeploymentVersionString(), CurrentVersionChangedTime: versionCreateTime, }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ { - Version: tv.DeploymentVersionString(), + Version: env.Tv().DeploymentVersionString(), CreateTime: versionCreateTime, DrainageInfo: nil, RoutingUpdateTime: versionCreateTime, @@ -2434,44 +2430,43 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentCurrentVersion_NoPollers( Status: enumspb.WORKER_DEPLOYMENT_VERSION_STATUS_CURRENT, }, }, - LastModifierIdentity: tv.ClientIdentity(), + LastModifierIdentity: env.Tv().ClientIdentity(), }, resp.GetWorkerDeploymentInfo()) }, 10*time.Second, 100*time.Millisecond) // that poller's task queue should have the current versioning info - s.verifyTaskQueueVersioningInfo(env, tv.TaskQueue(), tv.DeploymentVersionString(), "", 0) + s.verifyTaskQueueVersioningInfo(env, env.Tv().TaskQueue(), env.Tv().DeploymentVersionString(), "", 0) } func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_NoPollers() { env := s.newTestEnv() - tv := env.Tv() // try to set ramping with allowNoPollers=false --> error allowNoPollers := false - expectedErr := fmt.Sprintf(workerdeployment.ErrWorkerDeploymentNotFound, tv.DeploymentVersion().GetDeploymentName()) - s.setAndVerifyRampingVersionUnversionedOption(env, tv, false, false, 5, true, allowNoPollers, false, expectedErr) + expectedErr := fmt.Sprintf(workerdeployment.ErrWorkerDeploymentNotFound, env.Tv().DeploymentVersion().GetDeploymentName()) + s.setAndVerifyRampingVersionUnversionedOption(env, env.Tv(), false, false, 5, true, allowNoPollers, false, expectedErr) // try to set ramping with allowNoPollers=true --> success allowNoPollers = true expectedErr = "" versionCreateTime := timestamppb.Now() - s.setAndVerifyRampingVersionUnversionedOption(env, tv, false, false, 5, true, allowNoPollers, false, expectedErr) + s.setAndVerifyRampingVersionUnversionedOption(env, env.Tv(), false, false, 5, true, allowNoPollers, false, expectedErr) // let a poller arrive with that version --> triggers user data propagation - go s.pollFromDeployment(env, tv) + go s.pollFromDeployment(env, env.Tv()) s.Await(func(s *WorkerDeploymentSuite) { // check describe worker deployment resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv.DeploymentSeries(), + DeploymentName: env.Tv().DeploymentSeries(), }) s.NoError(err) s.verifyWorkerDeploymentInfo(&deploymentpb.WorkerDeploymentInfo{ - Name: tv.DeploymentSeries(), + Name: env.Tv().DeploymentSeries(), CreateTime: versionCreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ - RampingVersion: tv.DeploymentVersionString(), + RampingVersion: env.Tv().DeploymentVersionString(), RampingVersionPercentage: 5, RampingVersionChangedTime: versionCreateTime, RampingVersionPercentageChangedTime: versionCreateTime, @@ -2480,7 +2475,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_NoPollers( }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ { - Version: tv.DeploymentVersionString(), + Version: env.Tv().DeploymentVersionString(), CreateTime: versionCreateTime, DrainageInfo: nil, RoutingUpdateTime: versionCreateTime, @@ -2491,18 +2486,18 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_NoPollers( Status: enumspb.WORKER_DEPLOYMENT_VERSION_STATUS_RAMPING, }, }, - LastModifierIdentity: tv.ClientIdentity(), + LastModifierIdentity: env.Tv().ClientIdentity(), }, resp.GetWorkerDeploymentInfo()) }, 10*time.Second, 100*time.Millisecond) // that poller's task queue should have the ramping version info - s.verifyTaskQueueVersioningInfo(env, tv.TaskQueue(), worker_versioning.UnversionedVersionId, tv.DeploymentVersionString(), 5) + s.verifyTaskQueueVersioningInfo(env, env.Tv().TaskQueue(), worker_versioning.UnversionedVersionId, env.Tv().DeploymentVersionString(), 5) } func (s *WorkerDeploymentSuite) TestTwoPollers_EnsureCreateVersion() { env := s.newTestEnv() - tv1 := env.Tv() + tv1 := env.Tv().WithBuildIDNumber(1) tv2 := env.Tv().WithBuildIDNumber(2) go s.pollFromDeployment(env, tv1) @@ -2535,7 +2530,7 @@ func (s *WorkerDeploymentSuite) verifyTaskQueueVersioningInfo(env *testcore.Test func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { env := s.newTestEnv(testcore.WithDynamicConfig(dynamicconfig.PollerHistoryTTL, 500*time.Millisecond)) - tv1 := env.Tv() + tv1 := env.Tv().WithBuildIDNumber(1) tv2 := env.Tv().WithBuildIDNumber(2) tv3 := env.Tv().WithBuildIDNumber(3) @@ -2548,20 +2543,20 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { s.setCurrentVersion(env, tv1, true, "") resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv1.DeploymentSeries(), + DeploymentName: env.Tv().DeploymentSeries(), }) s.NoError(err) s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ - Name: tv1.DeploymentSeries(), + Name: env.Tv().DeploymentSeries(), CreateTime: v1CreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ - CurrentVersion: tv1.DeploymentVersionString(), + CurrentVersion: env.Tv().DeploymentVersionString(), CurrentVersionChangedTime: setCurrentV1UpdateTime, }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ { - Version: tv1.DeploymentVersionString(), + Version: env.Tv().DeploymentVersionString(), CreateTime: v1CreateTime, DrainageInfo: nil, RoutingUpdateTime: setCurrentV1UpdateTime, @@ -2573,7 +2568,7 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { Status: enumspb.WORKER_DEPLOYMENT_VERSION_STATUS_CURRENT, }, }, - LastModifierIdentity: tv1.ClientIdentity(), + LastModifierIdentity: env.Tv().ClientIdentity(), }, }) @@ -2603,7 +2598,7 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ { - Version: tv1.DeploymentVersionString(), + Version: env.Tv().DeploymentVersionString(), CreateTime: v1CreateTime, DrainageInfo: &deploymentpb.VersionDrainageInfo{Status: enumspb.VERSION_DRAINAGE_STATUS_DRAINING}, RoutingUpdateTime: setCurrentV2UpdateTime, @@ -2636,7 +2631,7 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { a := require.New(t) resp, err := env.FrontendClient().DescribeWorkerDeploymentVersion(s.Context(), &workflowservice.DescribeWorkerDeploymentVersionRequest{ Namespace: env.Namespace().String(), - Version: tv1.DeploymentVersionString(), + Version: env.Tv().DeploymentVersionString(), }) a.NoError(err) a.Equal(enumspb.VERSION_DRAINAGE_STATUS_DRAINED, resp.GetWorkerDeploymentVersionInfo().GetDrainageInfo().GetStatus()) @@ -2663,7 +2658,7 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ { - Version: tv1.DeploymentVersionString(), + Version: env.Tv().DeploymentVersionString(), CreateTime: v1CreateTime, DrainageInfo: &deploymentpb.VersionDrainageInfo{Status: enumspb.VERSION_DRAINAGE_STATUS_DRAINED}, RoutingUpdateTime: setCurrentV2UpdateTime, @@ -2708,7 +2703,7 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { Name: tv2.DeploymentSeries(), CreateTime: v1CreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ - RampingVersion: tv1.DeploymentVersionString(), + RampingVersion: env.Tv().DeploymentVersionString(), RampingVersionPercentage: 10, RampingVersionChangedTime: setRampingUpdateTime, RampingVersionPercentageChangedTime: setRampingUpdateTime, @@ -2717,7 +2712,7 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ { - Version: tv1.DeploymentVersionString(), + Version: env.Tv().DeploymentVersionString(), CreateTime: v1CreateTime, DrainageInfo: nil, RoutingUpdateTime: setRampingUpdateTime, @@ -2765,15 +2760,15 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { s.Await(func(s *WorkerDeploymentSuite) { resp, err = env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv1.DeploymentSeries(), + DeploymentName: env.Tv().DeploymentSeries(), }) s.NoError(err) s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ - Name: tv1.DeploymentSeries(), + Name: env.Tv().DeploymentSeries(), CreateTime: v1CreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ - CurrentVersion: tv1.DeploymentVersionString(), + CurrentVersion: env.Tv().DeploymentVersionString(), CurrentVersionChangedTime: newCurrentV1UpdateTime, RampingVersion: "", RampingVersionPercentage: 0, @@ -2782,7 +2777,7 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ { - Version: tv1.DeploymentVersionString(), + Version: env.Tv().DeploymentVersionString(), CreateTime: v1CreateTime, DrainageInfo: nil, RoutingUpdateTime: newCurrentV1UpdateTime, @@ -2823,7 +2818,7 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { a := require.New(t) resp, err := env.FrontendClient().DescribeWorkerDeploymentVersion(s.Context(), &workflowservice.DescribeWorkerDeploymentVersionRequest{ Namespace: env.Namespace().String(), - Version: tv1.DeploymentVersionString(), + Version: env.Tv().DeploymentVersionString(), }) a.NoError(err) a.Equal(enumspb.VERSION_DRAINAGE_STATUS_DRAINED, resp.GetWorkerDeploymentVersionInfo().GetDrainageInfo().GetStatus()) @@ -2834,12 +2829,12 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { s.Await(func(s *WorkerDeploymentSuite) { resp, err = env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv1.DeploymentSeries(), + DeploymentName: env.Tv().DeploymentSeries(), }) s.NoError(err) s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ - Name: tv1.DeploymentSeries(), + Name: env.Tv().DeploymentSeries(), CreateTime: v1CreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ CurrentVersion: tv3.DeploymentVersionString(), @@ -2851,7 +2846,7 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ { - Version: tv1.DeploymentVersionString(), + Version: env.Tv().DeploymentVersionString(), CreateTime: v1CreateTime, RoutingUpdateTime: newCurrentV3UpdateTime, DrainageInfo: &deploymentpb.VersionDrainageInfo{Status: enumspb.VERSION_DRAINAGE_STATUS_DRAINED}, @@ -2897,7 +2892,7 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { func (s *WorkerDeploymentSuite) TestSetRampingVersion_AfterDrained() { env := s.newTestEnv(testcore.WithDynamicConfig(dynamicconfig.PollerHistoryTTL, 500*time.Millisecond)) - tv1 := env.Tv() + tv1 := env.Tv().WithBuildIDNumber(1) tv2 := env.Tv().WithBuildIDNumber(2) // Start deployment workflow 1 and wait for the deployment version to exist @@ -2909,20 +2904,20 @@ func (s *WorkerDeploymentSuite) TestSetRampingVersion_AfterDrained() { s.setCurrentVersion(env, tv1, true, "") resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv1.DeploymentSeries(), + DeploymentName: env.Tv().DeploymentSeries(), }) s.NoError(err) s.verifyDescribeWorkerDeployment(resp, &workflowservice.DescribeWorkerDeploymentResponse{ WorkerDeploymentInfo: &deploymentpb.WorkerDeploymentInfo{ - Name: tv1.DeploymentSeries(), + Name: env.Tv().DeploymentSeries(), CreateTime: v1CreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ - CurrentVersion: tv1.DeploymentVersionString(), + CurrentVersion: env.Tv().DeploymentVersionString(), CurrentVersionChangedTime: setCurrentV1UpdateTime, }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ { - Version: tv1.DeploymentVersionString(), + Version: env.Tv().DeploymentVersionString(), CreateTime: v1CreateTime, DrainageInfo: nil, RoutingUpdateTime: setCurrentV1UpdateTime, @@ -2934,7 +2929,7 @@ func (s *WorkerDeploymentSuite) TestSetRampingVersion_AfterDrained() { Status: enumspb.WORKER_DEPLOYMENT_VERSION_STATUS_CURRENT, }, }, - LastModifierIdentity: tv1.ClientIdentity(), + LastModifierIdentity: env.Tv().ClientIdentity(), }, }) @@ -2964,7 +2959,7 @@ func (s *WorkerDeploymentSuite) TestSetRampingVersion_AfterDrained() { }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ { - Version: tv1.DeploymentVersionString(), + Version: env.Tv().DeploymentVersionString(), CreateTime: v1CreateTime, DrainageInfo: &deploymentpb.VersionDrainageInfo{Status: enumspb.VERSION_DRAINAGE_STATUS_DRAINING}, RoutingUpdateTime: setCurrentV2UpdateTime, @@ -2997,7 +2992,7 @@ func (s *WorkerDeploymentSuite) TestSetRampingVersion_AfterDrained() { a := require.New(t) resp, err := env.FrontendClient().DescribeWorkerDeploymentVersion(s.Context(), &workflowservice.DescribeWorkerDeploymentVersionRequest{ Namespace: env.Namespace().String(), - Version: tv1.DeploymentVersionString(), + Version: env.Tv().DeploymentVersionString(), }) a.NoError(err) a.Equal(enumspb.VERSION_DRAINAGE_STATUS_DRAINED, resp.GetWorkerDeploymentVersionInfo().GetDrainageInfo().GetStatus()) @@ -3024,7 +3019,7 @@ func (s *WorkerDeploymentSuite) TestSetRampingVersion_AfterDrained() { }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ { - Version: tv1.DeploymentVersionString(), + Version: env.Tv().DeploymentVersionString(), CreateTime: v1CreateTime, DrainageInfo: &deploymentpb.VersionDrainageInfo{Status: enumspb.VERSION_DRAINAGE_STATUS_DRAINED}, RoutingUpdateTime: setCurrentV2UpdateTime, @@ -3069,7 +3064,7 @@ func (s *WorkerDeploymentSuite) TestSetRampingVersion_AfterDrained() { Name: tv2.DeploymentSeries(), CreateTime: v1CreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ - RampingVersion: tv1.DeploymentVersionString(), + RampingVersion: env.Tv().DeploymentVersionString(), RampingVersionPercentage: 10, RampingVersionChangedTime: setRampingUpdateTime, RampingVersionPercentageChangedTime: setRampingUpdateTime, @@ -3078,7 +3073,7 @@ func (s *WorkerDeploymentSuite) TestSetRampingVersion_AfterDrained() { }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ { - Version: tv1.DeploymentVersionString(), + Version: env.Tv().DeploymentVersionString(), CreateTime: v1CreateTime, DrainageInfo: nil, RoutingUpdateTime: setRampingUpdateTime, @@ -3111,16 +3106,14 @@ func (s *WorkerDeploymentSuite) TestSetRampingVersion_AfterDrained() { func (s *WorkerDeploymentSuite) TestDeleteWorkerDeployment_ValidDelete() { env := s.newTestEnv(testcore.WithDynamicConfig(dynamicconfig.PollerHistoryTTL, 500*time.Millisecond)) - tv1 := env.Tv() - // Start deployment workflow 1 and wait for the deployment version to exist // Use a cancellable context so we can stop the poller before checking pollers disappeared - pollerCancel := s.startDeploymentPoller(env, tv1) + pollerCancel := s.startDeploymentPoller(env, env.Tv()) defer pollerCancel() - s.waitForDeploymentVersion(env, tv1) + s.waitForDeploymentVersion(env, env.Tv()) // Signal the first version to be drained. Only do this in tests. - versionWorkflowID := workerdeployment.GenerateVersionWorkflowID(tv1.DeploymentSeries(), tv1.BuildID()) + versionWorkflowID := workerdeployment.GenerateVersionWorkflowID(env.Tv().DeploymentSeries(), env.Tv().BuildID()) workflowExecution := &commonpb.WorkflowExecution{ WorkflowId: versionWorkflowID, } @@ -3142,7 +3135,7 @@ func (s *WorkerDeploymentSuite) TestDeleteWorkerDeployment_ValidDelete() { }, } - err = env.SendSignal(env.Namespace().String(), workflowExecution, workerdeployment.SyncDrainageSignalName, signalPayload, tv1.ClientIdentity()) + err = env.SendSignal(env.Namespace().String(), workflowExecution, workerdeployment.SyncDrainageSignalName, signalPayload, env.Tv().ClientIdentity()) s.NoError(err) // Stop the poller so it doesn't keep polling @@ -3152,7 +3145,7 @@ func (s *WorkerDeploymentSuite) TestDeleteWorkerDeployment_ValidDelete() { s.EventuallyWithT(func(t *assert.CollectT) { resp, err := env.FrontendClient().DescribeTaskQueue(s.Context(), &workflowservice.DescribeTaskQueueRequest{ Namespace: env.Namespace().String(), - TaskQueue: tv1.TaskQueue(), + TaskQueue: env.Tv().TaskQueue(), TaskQueueType: enumspb.TASK_QUEUE_TYPE_WORKFLOW, }) require.NoError(t, err) @@ -3160,28 +3153,28 @@ func (s *WorkerDeploymentSuite) TestDeleteWorkerDeployment_ValidDelete() { }, 5*time.Second, time.Second) // delete succeeds - s.tryDeleteVersion(env, tv1, "") + s.tryDeleteVersion(env, env.Tv(), "") // deployment version does not exist in the deployment list s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv1.DeploymentSeries(), + DeploymentName: env.Tv().DeploymentSeries(), }) a.NoError(err) for _, vs := range resp.GetWorkerDeploymentInfo().GetVersionSummaries() { //nolint:staticcheck // SA1019 deprecated Version will clean up later - a.NotEqual(tv1.DeploymentVersionString(), vs.Version) - a.False(proto.Equal(tv1.ExternalDeploymentVersion(), vs.GetDeploymentVersion())) + a.NotEqual(env.Tv().DeploymentVersionString(), vs.Version) + a.False(proto.Equal(env.Tv().ExternalDeploymentVersion(), vs.GetDeploymentVersion())) } }, time.Second*5, time.Millisecond*200) // Deleting the worker deployment should succeed since there are no associated versions left _, err = env.FrontendClient().DeleteWorkerDeployment(s.Context(), &workflowservice.DeleteWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv1.DeploymentSeries(), - Identity: tv1.ClientIdentity(), + DeploymentName: env.Tv().DeploymentSeries(), + Identity: env.Tv().ClientIdentity(), }) s.NoError(err) @@ -3190,7 +3183,7 @@ func (s *WorkerDeploymentSuite) TestDeleteWorkerDeployment_ValidDelete() { a := require.New(t) _, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv1.DeploymentSeries(), + DeploymentName: env.Tv().DeploymentSeries(), }) a.Error(err) var nfe *serviceerror.NotFound @@ -3205,7 +3198,7 @@ func (s *WorkerDeploymentSuite) TestDeleteWorkerDeployment_ValidDelete() { }) a.NoError(err) for _, dInfo := range listResp.GetWorkerDeployments() { - a.NotEqual(tv1.DeploymentSeries(), dInfo.GetName()) + a.NotEqual(env.Tv().DeploymentSeries(), dInfo.GetName()) } }, time.Second*5, time.Millisecond*200) } @@ -3213,14 +3206,12 @@ func (s *WorkerDeploymentSuite) TestDeleteWorkerDeployment_ValidDelete() { func (s *WorkerDeploymentSuite) TestDeleteWorkerDeployment_Idempotent() { env := s.newTestEnv() - tv1 := env.Tv() - s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) _, err := env.FrontendClient().DeleteWorkerDeployment(s.Context(), &workflowservice.DeleteWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv1.DeploymentSeries(), - Identity: tv1.ClientIdentity(), + DeploymentName: env.Tv().DeploymentSeries(), + Identity: env.Tv().ClientIdentity(), }) a.NoError(err) }, time.Second*5, time.Millisecond*200) @@ -3229,38 +3220,36 @@ func (s *WorkerDeploymentSuite) TestDeleteWorkerDeployment_Idempotent() { func (s *WorkerDeploymentSuite) TestDeleteWorkerDeployment_InvalidDelete() { env := s.newTestEnv() - tv1 := env.Tv() - // Start deployment workflow 1 and wait for the deployment version and deployment workflow to exist - go s.pollFromDeployment(env, tv1) + go s.pollFromDeployment(env, env.Tv()) s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) resp, err := env.FrontendClient().DescribeWorkerDeploymentVersion(s.Context(), &workflowservice.DescribeWorkerDeploymentVersionRequest{ Namespace: env.Namespace().String(), - Version: tv1.DeploymentVersionString(), + Version: env.Tv().DeploymentVersionString(), }) a.NoError(err) - a.Equal(tv1.DeploymentVersionString(), resp.GetWorkerDeploymentVersionInfo().GetVersion()) + a.Equal(env.Tv().DeploymentVersionString(), resp.GetWorkerDeploymentVersionInfo().GetVersion()) }, time.Second*5, time.Millisecond*200) s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv1.DeploymentSeries(), + DeploymentName: env.Tv().DeploymentSeries(), }) a.NoError(err) a.NotEmpty(resp.GetWorkerDeploymentInfo().GetVersionSummaries()) //nolint:staticcheck // SA1019 deprecated Version will clean up later - a.Equal(tv1.DeploymentVersionString(), resp.GetWorkerDeploymentInfo().GetVersionSummaries()[0].Version) - s.ProtoEqual(tv1.ExternalDeploymentVersion(), resp.GetWorkerDeploymentInfo().GetVersionSummaries()[0].GetDeploymentVersion()) + a.Equal(env.Tv().DeploymentVersionString(), resp.GetWorkerDeploymentInfo().GetVersionSummaries()[0].Version) + s.ProtoEqual(env.Tv().ExternalDeploymentVersion(), resp.GetWorkerDeploymentInfo().GetVersionSummaries()[0].GetDeploymentVersion()) }, time.Second*5, time.Millisecond*200) // Delete the worker deployment should fail since there are versions associated with it _, err := env.FrontendClient().DeleteWorkerDeployment(s.Context(), &workflowservice.DeleteWorkerDeploymentRequest{ Namespace: env.Namespace().String(), - DeploymentName: tv1.DeploymentSeries(), - Identity: tv1.ClientIdentity(), + DeploymentName: env.Tv().DeploymentSeries(), + Identity: env.Tv().ClientIdentity(), }) s.Error(err) } From 70fb01c4b2adea54f035af36cddc02d005ea0bd6 Mon Sep 17 00:00:00 2001 From: Stephan Behnke Date: Thu, 18 Jun 2026 16:40:49 -0700 Subject: [PATCH 15/27] Update worker_deployment_test.go --- tests/worker_deployment_test.go | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tests/worker_deployment_test.go b/tests/worker_deployment_test.go index fdc5041fcee..1d5d3ee59b5 100644 --- a/tests/worker_deployment_test.go +++ b/tests/worker_deployment_test.go @@ -372,7 +372,7 @@ func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_TwoVersions_Sorted( a.NotNil(versionSummaries[0].GetVersion()) a.NotNil(versionSummaries[1].GetVersion()) a.Equal(versionSummaries[0].GetVersion(), secondVersion.DeploymentVersionString()) - a.Equal(versionSummaries[1].GetVersion(), env.Tv().DeploymentVersionString()) + a.Equal(versionSummaries[1].GetVersion(), env.Tv().DeploymentVersionString()) //nolint:staticcheck // SA1019: old worker versioning a.NotNil(resp.GetWorkerDeploymentInfo().GetVersionSummaries()[0].GetCreateTime()) a.NotNil(resp.GetWorkerDeploymentInfo().GetVersionSummaries()[1].GetCreateTime()) @@ -463,7 +463,7 @@ func (s *WorkerDeploymentSuite) TestConflictToken_Describe_SetCurrent_SetRamping DeploymentName: env.Tv().DeploymentSeries(), }) a.NoError(err) - a.Equal(env.Tv().DeploymentVersionString(), resp.GetWorkerDeploymentInfo().GetRoutingConfig().GetCurrentVersion()) + a.Equal(env.Tv().DeploymentVersionString(), resp.GetWorkerDeploymentInfo().GetRoutingConfig().GetCurrentVersion()) //nolint:staticcheck // SA1019: old worker versioning cT = resp.GetConflictToken() }, time.Second*10, time.Millisecond*1000) @@ -3229,7 +3229,7 @@ func (s *WorkerDeploymentSuite) TestDeleteWorkerDeployment_InvalidDelete() { Version: env.Tv().DeploymentVersionString(), }) a.NoError(err) - a.Equal(env.Tv().DeploymentVersionString(), resp.GetWorkerDeploymentVersionInfo().GetVersion()) + a.Equal(env.Tv().DeploymentVersionString(), resp.GetWorkerDeploymentVersionInfo().GetVersion()) //nolint:staticcheck // SA1019: old worker versioning }, time.Second*5, time.Millisecond*200) s.EventuallyWithT(func(t *assert.CollectT) { From 920d5e3d4207bcd0786546ea5cbd0d8e936c1f00 Mon Sep 17 00:00:00 2001 From: Stephan Behnke Date: Thu, 18 Jun 2026 17:41:23 -0700 Subject: [PATCH 16/27] remove dc --- tests/worker_deployment_test.go | 1 - 1 file changed, 1 deletion(-) diff --git a/tests/worker_deployment_test.go b/tests/worker_deployment_test.go index 1d5d3ee59b5..5d0ba856a96 100644 --- a/tests/worker_deployment_test.go +++ b/tests/worker_deployment_test.go @@ -50,7 +50,6 @@ func (s *WorkerDeploymentSuite) newTestEnv(opts ...testcore.TestOption) *testcor // Make sure we don't hit the rate limiter in tests testcore.WithDynamicConfig(dynamicconfig.FrontendGlobalNamespaceNamespaceReplicationInducingAPIsRPS, 1000), testcore.WithDynamicConfig(dynamicconfig.FrontendMaxNamespaceNamespaceReplicationInducingAPIsBurstRatioPerInstance, 1), - testcore.WithDynamicConfig(dynamicconfig.FrontendNamespaceReplicationInducingAPIsRPS, 1000), // Make drainage happen sooner testcore.WithDynamicConfig(dynamicconfig.VersionDrainageStatusRefreshInterval, testVersionDrainageRefreshInterval), From f7d8552a38711472a2476e192f810831e0fe4e1e Mon Sep 17 00:00:00 2001 From: Stephan Behnke Date: Thu, 18 Jun 2026 17:44:39 -0700 Subject: [PATCH 17/27] Update worker_deployment_test.go --- tests/worker_deployment_test.go | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tests/worker_deployment_test.go b/tests/worker_deployment_test.go index 5d0ba856a96..1837c664a3d 100644 --- a/tests/worker_deployment_test.go +++ b/tests/worker_deployment_test.go @@ -64,8 +64,9 @@ func (s *WorkerDeploymentSuite) newTestEnv(opts ...testcore.TestOption) *testcor testcore.WithDynamicConfig(dynamicconfig.MatchingMaxTaskQueuesInDeploymentVersion, 1000), + // Keep deployment versions short because worker-deployment system workflow IDs must fit into 255 characters (database constraint). testcore.WithTestVars(func(tv *testvars.TestVars) *testvars.TestVars { - return tv.WithBuildIDNumber(1) + return tv.WithDeploymentSeries("worker_deployment").WithBuildID("1") }), } return testcore.NewEnv(s.T(), append(baseOpts, opts...)...) From ebf0db4ba2b8afa6d6a18086a17a99bee89756ff Mon Sep 17 00:00:00 2001 From: Stephan Behnke Date: Thu, 18 Jun 2026 18:00:33 -0700 Subject: [PATCH 18/27] Update worker_deployment_test.go --- tests/worker_deployment_test.go | 54 ++++++++++++++++----------------- 1 file changed, 27 insertions(+), 27 deletions(-) diff --git a/tests/worker_deployment_test.go b/tests/worker_deployment_test.go index 1837c664a3d..04fe50b6918 100644 --- a/tests/worker_deployment_test.go +++ b/tests/worker_deployment_test.go @@ -802,7 +802,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Ramping_Wi Name: env.Tv().DeploymentSeries(), CreateTime: versionCreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ - RampingVersion: env.Tv().DeploymentVersionString(), + RampingVersion: rampingVersionVars.DeploymentVersionString(), RampingVersionPercentage: 50, RampingVersionChangedTime: setRampingUpdateTime, RampingVersionPercentageChangedTime: setRampingUpdateTime, @@ -811,7 +811,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Ramping_Wi }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ { - Version: env.Tv().DeploymentVersionString(), + Version: rampingVersionVars.DeploymentVersionString(), CreateTime: versionCreateTime, DrainageInfo: nil, RampingSinceTime: setRampingUpdateTime, @@ -841,7 +841,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Ramping_Wi Name: env.Tv().DeploymentSeries(), CreateTime: versionCreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ - RampingVersion: env.Tv().DeploymentVersionString(), + RampingVersion: rampingVersionVars.DeploymentVersionString(), RampingVersionPercentage: 50, RampingVersionChangedTime: setRampingUpdateTime, RampingVersionPercentageChangedTime: setRampingUpdateTime, @@ -862,7 +862,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Ramping_Wi Status: enumspb.WORKER_DEPLOYMENT_VERSION_STATUS_CURRENT, }, { - Version: env.Tv().DeploymentVersionString(), + Version: rampingVersionVars.DeploymentVersionString(), CreateTime: versionCreateTime, DrainageInfo: nil, RoutingUpdateTime: setRampingUpdateTime, @@ -895,7 +895,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Ramping_Wi RampingVersionPercentage: 0, RampingVersionChangedTime: setRampingAsCurrentUpdateTime, RampingVersionPercentageChangedTime: setRampingAsCurrentUpdateTime, - CurrentVersion: env.Tv().DeploymentVersionString(), + CurrentVersion: rampingVersionVars.DeploymentVersionString(), CurrentVersionChangedTime: setRampingAsCurrentUpdateTime, }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ @@ -914,7 +914,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Ramping_Wi Status: enumspb.WORKER_DEPLOYMENT_VERSION_STATUS_DRAINING, }, { - Version: env.Tv().DeploymentVersionString(), + Version: rampingVersionVars.DeploymentVersionString(), CreateTime: versionCreateTime, DrainageInfo: nil, RoutingUpdateTime: setRampingAsCurrentUpdateTime, @@ -965,7 +965,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Ramping_Wi Status: enumspb.WORKER_DEPLOYMENT_VERSION_STATUS_CURRENT, }, { - Version: env.Tv().DeploymentVersionString(), + Version: rampingVersionVars.DeploymentVersionString(), CreateTime: versionCreateTime, DrainageInfo: &deploymentpb.VersionDrainageInfo{ Status: enumspb.VERSION_DRAINAGE_STATUS_DRAINING, @@ -1241,7 +1241,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_WithCurren Name: env.Tv().DeploymentSeries(), CreateTime: version1CreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ - RampingVersion: env.Tv().DeploymentVersionString(), + RampingVersion: rampingVersionVars.DeploymentVersionString(), RampingVersionPercentage: 50, RampingVersionChangedTime: setRampingUpdateTime, RampingVersionPercentageChangedTime: setRampingUpdateTime, @@ -1250,7 +1250,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_WithCurren }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ { - Version: env.Tv().DeploymentVersionString(), + Version: rampingVersionVars.DeploymentVersionString(), CreateTime: version1CreateTime, DrainageInfo: nil, RoutingUpdateTime: setRampingUpdateTime, @@ -1300,7 +1300,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_WithCurren }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ { - Version: env.Tv().DeploymentVersionString(), + Version: rampingVersionVars.DeploymentVersionString(), CreateTime: version1CreateTime, DrainageInfo: &deploymentpb.VersionDrainageInfo{Status: enumspb.VERSION_DRAINAGE_STATUS_DRAINING}, RoutingUpdateTime: unsetRampingUpdateTime, @@ -1567,12 +1567,12 @@ func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_SetCurrentVersion() Name: env.Tv().DeploymentSeries(), CreateTime: version1CreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ - CurrentVersion: env.Tv().DeploymentVersionString(), + CurrentVersion: firstVersion.DeploymentVersionString(), CurrentVersionChangedTime: firstVersionCurrentUpdateTime, }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ { - Version: env.Tv().DeploymentVersionString(), + Version: firstVersion.DeploymentVersionString(), CreateTime: version1CreateTime, DrainageInfo: nil, RoutingUpdateTime: firstVersionCurrentUpdateTime, @@ -1612,7 +1612,7 @@ func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_SetCurrentVersion() }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ { - Version: env.Tv().DeploymentVersionString(), + Version: firstVersion.DeploymentVersionString(), CreateTime: version1CreateTime, DrainageInfo: &deploymentpb.VersionDrainageInfo{Status: enumspb.VERSION_DRAINAGE_STATUS_DRAINING}, RoutingUpdateTime: firstVersionCurrentUpdateTime, @@ -2551,12 +2551,12 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { Name: env.Tv().DeploymentSeries(), CreateTime: v1CreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ - CurrentVersion: env.Tv().DeploymentVersionString(), + CurrentVersion: tv1.DeploymentVersionString(), CurrentVersionChangedTime: setCurrentV1UpdateTime, }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ { - Version: env.Tv().DeploymentVersionString(), + Version: tv1.DeploymentVersionString(), CreateTime: v1CreateTime, DrainageInfo: nil, RoutingUpdateTime: setCurrentV1UpdateTime, @@ -2598,7 +2598,7 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ { - Version: env.Tv().DeploymentVersionString(), + Version: tv1.DeploymentVersionString(), CreateTime: v1CreateTime, DrainageInfo: &deploymentpb.VersionDrainageInfo{Status: enumspb.VERSION_DRAINAGE_STATUS_DRAINING}, RoutingUpdateTime: setCurrentV2UpdateTime, @@ -2631,7 +2631,7 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { a := require.New(t) resp, err := env.FrontendClient().DescribeWorkerDeploymentVersion(s.Context(), &workflowservice.DescribeWorkerDeploymentVersionRequest{ Namespace: env.Namespace().String(), - Version: env.Tv().DeploymentVersionString(), + Version: tv1.DeploymentVersionString(), }) a.NoError(err) a.Equal(enumspb.VERSION_DRAINAGE_STATUS_DRAINED, resp.GetWorkerDeploymentVersionInfo().GetDrainageInfo().GetStatus()) @@ -2658,7 +2658,7 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ { - Version: env.Tv().DeploymentVersionString(), + Version: tv1.DeploymentVersionString(), CreateTime: v1CreateTime, DrainageInfo: &deploymentpb.VersionDrainageInfo{Status: enumspb.VERSION_DRAINAGE_STATUS_DRAINED}, RoutingUpdateTime: setCurrentV2UpdateTime, @@ -2703,7 +2703,7 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { Name: tv2.DeploymentSeries(), CreateTime: v1CreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ - RampingVersion: env.Tv().DeploymentVersionString(), + RampingVersion: tv1.DeploymentVersionString(), RampingVersionPercentage: 10, RampingVersionChangedTime: setRampingUpdateTime, RampingVersionPercentageChangedTime: setRampingUpdateTime, @@ -2712,7 +2712,7 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ { - Version: env.Tv().DeploymentVersionString(), + Version: tv1.DeploymentVersionString(), CreateTime: v1CreateTime, DrainageInfo: nil, RoutingUpdateTime: setRampingUpdateTime, @@ -2912,12 +2912,12 @@ func (s *WorkerDeploymentSuite) TestSetRampingVersion_AfterDrained() { Name: env.Tv().DeploymentSeries(), CreateTime: v1CreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ - CurrentVersion: env.Tv().DeploymentVersionString(), + CurrentVersion: tv1.DeploymentVersionString(), CurrentVersionChangedTime: setCurrentV1UpdateTime, }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ { - Version: env.Tv().DeploymentVersionString(), + Version: tv1.DeploymentVersionString(), CreateTime: v1CreateTime, DrainageInfo: nil, RoutingUpdateTime: setCurrentV1UpdateTime, @@ -2959,7 +2959,7 @@ func (s *WorkerDeploymentSuite) TestSetRampingVersion_AfterDrained() { }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ { - Version: env.Tv().DeploymentVersionString(), + Version: tv1.DeploymentVersionString(), CreateTime: v1CreateTime, DrainageInfo: &deploymentpb.VersionDrainageInfo{Status: enumspb.VERSION_DRAINAGE_STATUS_DRAINING}, RoutingUpdateTime: setCurrentV2UpdateTime, @@ -2992,7 +2992,7 @@ func (s *WorkerDeploymentSuite) TestSetRampingVersion_AfterDrained() { a := require.New(t) resp, err := env.FrontendClient().DescribeWorkerDeploymentVersion(s.Context(), &workflowservice.DescribeWorkerDeploymentVersionRequest{ Namespace: env.Namespace().String(), - Version: env.Tv().DeploymentVersionString(), + Version: tv1.DeploymentVersionString(), }) a.NoError(err) a.Equal(enumspb.VERSION_DRAINAGE_STATUS_DRAINED, resp.GetWorkerDeploymentVersionInfo().GetDrainageInfo().GetStatus()) @@ -3019,7 +3019,7 @@ func (s *WorkerDeploymentSuite) TestSetRampingVersion_AfterDrained() { }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ { - Version: env.Tv().DeploymentVersionString(), + Version: tv1.DeploymentVersionString(), CreateTime: v1CreateTime, DrainageInfo: &deploymentpb.VersionDrainageInfo{Status: enumspb.VERSION_DRAINAGE_STATUS_DRAINED}, RoutingUpdateTime: setCurrentV2UpdateTime, @@ -3064,7 +3064,7 @@ func (s *WorkerDeploymentSuite) TestSetRampingVersion_AfterDrained() { Name: tv2.DeploymentSeries(), CreateTime: v1CreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ - RampingVersion: env.Tv().DeploymentVersionString(), + RampingVersion: tv1.DeploymentVersionString(), RampingVersionPercentage: 10, RampingVersionChangedTime: setRampingUpdateTime, RampingVersionPercentageChangedTime: setRampingUpdateTime, @@ -3073,7 +3073,7 @@ func (s *WorkerDeploymentSuite) TestSetRampingVersion_AfterDrained() { }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ { - Version: env.Tv().DeploymentVersionString(), + Version: tv1.DeploymentVersionString(), CreateTime: v1CreateTime, DrainageInfo: nil, RoutingUpdateTime: setRampingUpdateTime, From 966b51d852727a3d531be9928d7c4cbf6bf75226 Mon Sep 17 00:00:00 2001 From: Stephan Behnke Date: Thu, 18 Jun 2026 18:02:31 -0700 Subject: [PATCH 19/27] Update worker_deployment_test.go --- tests/worker_deployment_test.go | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/tests/worker_deployment_test.go b/tests/worker_deployment_test.go index 04fe50b6918..2557e4443c5 100644 --- a/tests/worker_deployment_test.go +++ b/tests/worker_deployment_test.go @@ -66,7 +66,7 @@ func (s *WorkerDeploymentSuite) newTestEnv(opts ...testcore.TestOption) *testcor // Keep deployment versions short because worker-deployment system workflow IDs must fit into 255 characters (database constraint). testcore.WithTestVars(func(tv *testvars.TestVars) *testvars.TestVars { - return tv.WithDeploymentSeries("worker_deployment").WithBuildID("1") + return tv.WithDeploymentSeries("wv").WithBuildID("b") }), } return testcore.NewEnv(s.T(), append(baseOpts, opts...)...) @@ -2768,7 +2768,7 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { Name: env.Tv().DeploymentSeries(), CreateTime: v1CreateTime, RoutingConfig: &deploymentpb.RoutingConfig{ - CurrentVersion: env.Tv().DeploymentVersionString(), + CurrentVersion: tv1.DeploymentVersionString(), CurrentVersionChangedTime: newCurrentV1UpdateTime, RampingVersion: "", RampingVersionPercentage: 0, @@ -2777,7 +2777,7 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ { - Version: env.Tv().DeploymentVersionString(), + Version: tv1.DeploymentVersionString(), CreateTime: v1CreateTime, DrainageInfo: nil, RoutingUpdateTime: newCurrentV1UpdateTime, @@ -2818,7 +2818,7 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { a := require.New(t) resp, err := env.FrontendClient().DescribeWorkerDeploymentVersion(s.Context(), &workflowservice.DescribeWorkerDeploymentVersionRequest{ Namespace: env.Namespace().String(), - Version: env.Tv().DeploymentVersionString(), + Version: tv1.DeploymentVersionString(), }) a.NoError(err) a.Equal(enumspb.VERSION_DRAINAGE_STATUS_DRAINED, resp.GetWorkerDeploymentVersionInfo().GetDrainageInfo().GetStatus()) @@ -2846,7 +2846,7 @@ func (s *WorkerDeploymentSuite) TestDrainRollbackedVersion() { }, VersionSummaries: []*deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ { - Version: env.Tv().DeploymentVersionString(), + Version: tv1.DeploymentVersionString(), CreateTime: v1CreateTime, RoutingUpdateTime: newCurrentV3UpdateTime, DrainageInfo: &deploymentpb.VersionDrainageInfo{Status: enumspb.VERSION_DRAINAGE_STATUS_DRAINED}, From 3c8a8082af6d1b385484ea5cc580bf8f3108c7eb Mon Sep 17 00:00:00 2001 From: Stephan Behnke Date: Thu, 18 Jun 2026 18:03:13 -0700 Subject: [PATCH 20/27] Update worker_deployment_test.go --- tests/worker_deployment_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/worker_deployment_test.go b/tests/worker_deployment_test.go index 2557e4443c5..13ac64487ae 100644 --- a/tests/worker_deployment_test.go +++ b/tests/worker_deployment_test.go @@ -66,7 +66,7 @@ func (s *WorkerDeploymentSuite) newTestEnv(opts ...testcore.TestOption) *testcor // Keep deployment versions short because worker-deployment system workflow IDs must fit into 255 characters (database constraint). testcore.WithTestVars(func(tv *testvars.TestVars) *testvars.TestVars { - return tv.WithDeploymentSeries("wv").WithBuildID("b") + return tv.WithDeploymentSeries("wd").WithBuildID("b") }), } return testcore.NewEnv(s.T(), append(baseOpts, opts...)...) From 584b0e3cd730cac6798607ed425d975e5aa5d8ea Mon Sep 17 00:00:00 2001 From: Stephan Behnke Date: Thu, 18 Jun 2026 18:14:35 -0700 Subject: [PATCH 21/27] Allow suite-scoped test hooks --- tests/testcore/test_cluster_pool.go | 6 ++++++ tests/testcore/test_env.go | 28 +++++++++++++++++----------- tests/worker_deployment_test.go | 12 +++--------- 3 files changed, 26 insertions(+), 20 deletions(-) diff --git a/tests/testcore/test_cluster_pool.go b/tests/testcore/test_cluster_pool.go index eddf8b768f8..8211c7fe403 100644 --- a/tests/testcore/test_cluster_pool.go +++ b/tests/testcore/test_cluster_pool.go @@ -217,6 +217,12 @@ func (p *clusterRouter) getShared(t *testing.T) *FunctionalTestBase { }) } +func (p *clusterRouter) hasSuiteScoped(t *testing.T) bool { + rootName, _, _ := strings.Cut(t.Name(), "/") + _, ok := p.suiteScoped.Load(rootName) + return ok +} + func (p *clusterRouter) getSuiteScoped(t *testing.T) *FunctionalTestBase { rootName, _, _ := strings.Cut(t.Name(), "/") if _, ok := p.suiteScoped.Load(rootName); !ok { diff --git a/tests/testcore/test_env.go b/tests/testcore/test_env.go index 44ba4fbfe0d..74603533038 100644 --- a/tests/testcore/test_env.go +++ b/tests/testcore/test_env.go @@ -72,14 +72,15 @@ type TestEnv struct { Logger log.Logger - cluster *TestCluster - nsName namespace.Name - nsID namespace.ID - taskPoller *taskpoller.TaskPoller - t *testing.T - tv *testvars.TestVars - ctx context.Context - dedicatedGuard *dedicatedClusterGuard + cluster *TestCluster + nsName namespace.Name + nsID namespace.ID + taskPoller *taskpoller.TaskPoller + t *testing.T + tv *testvars.TestVars + ctx context.Context + dedicatedGuard *dedicatedClusterGuard + allowGlobalHooks bool sdkClientOnce sync.Once sdkClient sdkclient.Client @@ -96,6 +97,7 @@ type testOptions struct { disableTestloggerFailure bool dynamicConfigSettings []dynamicConfigOverride testHooks []testhooks.Hook + hasGlobalTestHook bool clusterOptions []TestClusterOption testVars func(*testvars.TestVars) *testvars.TestVars } @@ -220,7 +222,7 @@ func WithDynamicConfig(setting dynamicconfig.GenericSetting, value any) TestOpti func WithTestHook(hook testhooks.Hook) TestOption { return func(o *testOptions) { if hook.Scope() == testhooks.ScopeGlobal { - o.dedicatedCluster = true + o.hasGlobalTestHook = true } o.testHooks = append(o.testHooks, hook) } @@ -237,6 +239,9 @@ func NewEnv(t *testing.T, opts ...TestOption) *TestEnv { for _, opt := range opts { opt(&options) } + if options.hasGlobalTestHook && !testClusterRouter.hasSuiteScoped(t) { + options.dedicatedCluster = true + } dedicatedGuard := newDedicatedClusterGuard(options.dedicatedCluster) if options.dedicatedReason != "" { dedicatedGuard.record(options.dedicatedReason) @@ -290,6 +295,7 @@ func NewEnv(t *testing.T, opts ...TestOption) *TestEnv { ctx: setupTestTimeoutWithContext(t), sdkWorkerTQ: RandomizeStr("tq-" + t.Name()), dedicatedGuard: dedicatedGuard, + allowGlobalHooks: testClusterRouter.hasSuiteScoped(t), } t.Cleanup(func() { if err := env.dedicatedGuard.validate(); err != nil && !t.Failed() { @@ -332,14 +338,14 @@ func (e *TestEnv) NamespaceID() namespace.ID { // // It auto-detects the scope from the hook: // - For namespace-scoped hooks: scopes it to the test's namespace -// - For global hooks: requires a dedicated cluster (fails early if used on shared cluster) +// - For global hooks: requires a dedicated cluster, except for suite-scoped legacy clusters. func (e *TestEnv) InjectHook(hook testhooks.Hook) (cleanup func()) { var scope any switch hook.Scope() { case testhooks.ScopeNamespace: scope = e.nsID case testhooks.ScopeGlobal: - if e.isShared { + if e.isShared && !e.allowGlobalHooks { e.t.Fatal("InjectHook: global hooks require a dedicated cluster; use testcore.WithDedicatedCluster()") } e.dedicatedGuard.record("global hook injected") diff --git a/tests/worker_deployment_test.go b/tests/worker_deployment_test.go index 13ac64487ae..7da0bf73d02 100644 --- a/tests/worker_deployment_test.go +++ b/tests/worker_deployment_test.go @@ -1387,9 +1387,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_NoCurrent_ } func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Batching() { - env := s.newTestEnv() - - env.InjectHook(testhooks.NewHook(testhooks.TaskQueuesInDeploymentSyncBatchSize, 1)) + env := s.newTestEnv(testcore.WithTestHook(testhooks.NewHook(testhooks.TaskQueuesInDeploymentSyncBatchSize, 1))) // registering 5 task-queues in the version which would result in the creation of 5 batches, each with 1 task-queue, during the SyncState call. versionCreateTime := timestamppb.Now() @@ -1458,9 +1456,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Batching() // TestSetWorkerDeploymentRampingVersion_UnversionedRamp_Batching verifies that the batching functionality works // when ramping unversioned. func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_UnversionedRamp_Batching() { - env := s.newTestEnv() - - env.InjectHook(testhooks.NewHook(testhooks.TaskQueuesInDeploymentSyncBatchSize, 1)) + env := s.newTestEnv(testcore.WithTestHook(testhooks.NewHook(testhooks.TaskQueuesInDeploymentSyncBatchSize, 1))) // registering 5 task-queues in the version which would result in the creation of 5 batches, each with 1 task-queue, during the SyncState call. versionCreateTime := timestamppb.Now() @@ -1643,9 +1639,7 @@ func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_SetCurrentVersion() } func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Batching() { - env := s.newTestEnv() - - env.InjectHook(testhooks.NewHook(testhooks.TaskQueuesInDeploymentSyncBatchSize, 1)) + env := s.newTestEnv(testcore.WithTestHook(testhooks.NewHook(testhooks.TaskQueuesInDeploymentSyncBatchSize, 1))) // registering 5 task-queues in the version which would result in the creation of 5 batches, each with 1 task-queue, during the SyncState call. versionCreateTime := timestamppb.Now() From 0e39b46dcf8b544c1875d05eefea4735415ee659 Mon Sep 17 00:00:00 2001 From: Stephan Behnke Date: Thu, 18 Jun 2026 18:19:47 -0700 Subject: [PATCH 22/27] Fix worker deployment list expectation --- tests/worker_deployment_test.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/worker_deployment_test.go b/tests/worker_deployment_test.go index 7da0bf73d02..e2ae1200e42 100644 --- a/tests/worker_deployment_test.go +++ b/tests/worker_deployment_test.go @@ -586,7 +586,7 @@ func (s *WorkerDeploymentSuite) TestListWorkerDeployments_TwoVersions_SameDeploy s.setCurrentVersion(env, firstVersion, true, "") routingInfo := &deploymentpb.RoutingConfig{ - CurrentVersion: env.Tv().DeploymentVersionString(), + CurrentVersion: firstVersion.DeploymentVersionString(), CurrentVersionChangedTime: setCurrentTime, } @@ -602,7 +602,7 @@ func (s *WorkerDeploymentSuite) TestListWorkerDeployments_TwoVersions_SameDeploy Status: enumspb.WORKER_DEPLOYMENT_VERSION_STATUS_INACTIVE, } currentVersionSummary := &deploymentpb.WorkerDeploymentInfo_WorkerDeploymentVersionSummary{ - Version: env.Tv().DeploymentVersionString(), + Version: firstVersion.DeploymentVersionString(), CreateTime: createVersion1Time, DrainageInfo: nil, RampingSinceTime: nil, From ec2eaceec269d9b27bbf612e12d70e77d06261e3 Mon Sep 17 00:00:00 2001 From: Stephan Behnke Date: Thu, 18 Jun 2026 18:24:33 -0700 Subject: [PATCH 23/27] Fix worker deployment sorted version expectation --- tests/worker_deployment_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/worker_deployment_test.go b/tests/worker_deployment_test.go index e2ae1200e42..3ac272594a1 100644 --- a/tests/worker_deployment_test.go +++ b/tests/worker_deployment_test.go @@ -372,7 +372,7 @@ func (s *WorkerDeploymentSuite) TestDescribeWorkerDeployment_TwoVersions_Sorted( a.NotNil(versionSummaries[0].GetVersion()) a.NotNil(versionSummaries[1].GetVersion()) a.Equal(versionSummaries[0].GetVersion(), secondVersion.DeploymentVersionString()) - a.Equal(versionSummaries[1].GetVersion(), env.Tv().DeploymentVersionString()) //nolint:staticcheck // SA1019: old worker versioning + a.Equal(versionSummaries[1].GetVersion(), firstVersion.DeploymentVersionString()) a.NotNil(resp.GetWorkerDeploymentInfo().GetVersionSummaries()[0].GetCreateTime()) a.NotNil(resp.GetWorkerDeploymentInfo().GetVersionSummaries()[1].GetCreateTime()) From f619d24258b048afe76f311071871d096cb88548 Mon Sep 17 00:00:00 2001 From: Stephan Behnke Date: Thu, 18 Jun 2026 18:29:11 -0700 Subject: [PATCH 24/27] Fix worker deployment conflict token version --- tests/worker_deployment_test.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/worker_deployment_test.go b/tests/worker_deployment_test.go index 3ac272594a1..760496a8cea 100644 --- a/tests/worker_deployment_test.go +++ b/tests/worker_deployment_test.go @@ -450,7 +450,7 @@ func (s *WorkerDeploymentSuite) TestConflictToken_Describe_SetCurrent_SetRamping _, err := env.FrontendClient().SetWorkerDeploymentCurrentVersion(s.Context(), &workflowservice.SetWorkerDeploymentCurrentVersionRequest{ Namespace: env.Namespace().String(), DeploymentName: env.Tv().DeploymentSeries(), - Version: env.Tv().DeploymentVersionString(), + Version: firstVersion.DeploymentVersionString(), ConflictToken: cT, }) s.NoError(err) @@ -463,7 +463,7 @@ func (s *WorkerDeploymentSuite) TestConflictToken_Describe_SetCurrent_SetRamping DeploymentName: env.Tv().DeploymentSeries(), }) a.NoError(err) - a.Equal(env.Tv().DeploymentVersionString(), resp.GetWorkerDeploymentInfo().GetRoutingConfig().GetCurrentVersion()) //nolint:staticcheck // SA1019: old worker versioning + a.Equal(firstVersion.DeploymentVersionString(), resp.GetWorkerDeploymentInfo().GetRoutingConfig().GetCurrentVersion()) //nolint:staticcheck // SA1019: old worker versioning cT = resp.GetConflictToken() }, time.Second*10, time.Millisecond*1000) From 00d709028a45ff089da62253bd059b74a3ee599d Mon Sep 17 00:00:00 2001 From: Stephan Behnke Date: Thu, 18 Jun 2026 16:46:40 -0700 Subject: [PATCH 25/27] Fix task queue stats versioning test flake --- tests/task_queue_stats_test.go | 118 ++++++++++++++++++-------------- tests/versioning_test_env.go | 48 +++++++++++++ tests/worker_deployment_test.go | 94 ++++++++++--------------- 3 files changed, 154 insertions(+), 106 deletions(-) create mode 100644 tests/versioning_test_env.go diff --git a/tests/task_queue_stats_test.go b/tests/task_queue_stats_test.go index 664cc6c62c3..f76ff8ef44c 100644 --- a/tests/task_queue_stats_test.go +++ b/tests/task_queue_stats_test.go @@ -49,8 +49,7 @@ type workflowTasksAndActivitiesPollerParams struct { // taskQueueStatsContext holds the per-test environment and configuration for task queue stats tests. type taskQueueStatsContext struct { - testcore.Env - *require.Assertions + *VersioningTestEnv tb testing.TB ctx context.Context usePriMatcher bool @@ -75,18 +74,17 @@ func newTaskQueueStatsContext( } opts = append(opts, behavior.Options()...) opts = append(opts, extraOpts...) - env := testcore.NewEnv(t, opts...) + env := newVersioningTestEnv(t, opts...) behavior.InjectHooks(env) return &taskQueueStatsContext{ - Env: env, - Assertions: require.New(t), - tb: t, - ctx: ctx, - usePriMatcher: usePriMatcher, - minPriority: 1, - maxPriority: 5, - defaultPriority: 3, - partitionCount: 2, // kept low to reduce test time on CI + VersioningTestEnv: env, + tb: t, + ctx: ctx, + usePriMatcher: usePriMatcher, + minPriority: 1, + maxPriority: 5, + defaultPriority: 3, + partitionCount: 2, // kept low to reduce test time on CI } } @@ -309,18 +307,16 @@ func (s *TaskQueueStatsVersionSuite) TestRampingAndCurrentAbsorbUnversionedBackl env.OverrideDynamicConfig(dynamicconfig.MatchingLongPollExpirationInterval, 10*time.Second) env.OverrideDynamicConfig(dynamicconfig.TaskQueueInfoByBuildIdTTL, 1*time.Millisecond) // zero means no TTL - ctx, cancel := context.WithTimeout(s.Context(), 120*time.Second) - defer cancel() - tqName := "tq-" + common.GenerateRandomString(5) deploymentName := testcore.RandomizeStr("deployment") currentBuildID := "v1" rampingBuildID := "v2" - pollCtx, cancelPoll := context.WithCancel(ctx) - s.createVersionsInTaskQueue(pollCtx, env, tqName, deploymentName, currentBuildID) - s.createVersionsInTaskQueue(pollCtx, env, tqName, deploymentName, rampingBuildID) - cancelPoll() // cancel the pollers so that we can verify the backlog expectations + pollerCtx, cancelPoller := context.WithCancel(s.Context()) + s.createVersionsInTaskQueue(pollerCtx, env, tqName, deploymentName, currentBuildID) + s.createVersionsInTaskQueue(pollerCtx, env, tqName, deploymentName, rampingBuildID) + // Stopping the pollers so that we verify the backlog expectations + cancelPoller() // Set ramping version to 30% rampPercentage := 30 @@ -328,6 +324,20 @@ func (s *TaskQueueStatsVersionSuite) TestRampingAndCurrentAbsorbUnversionedBackl // Set current version s.setCurrentVersion(env, deploymentName, currentBuildID) + env.waitForTaskQueueVersioningInfo( + s.T(), + s.Context(), + &taskqueuepb.TaskQueue{Name: tqName, Kind: enumspb.TASK_QUEUE_KIND_NORMAL}, + worker_versioning.ExternalWorkerDeploymentVersionToStringV31(&deploymentpb.WorkerDeploymentVersion{ + DeploymentName: deploymentName, + BuildId: currentBuildID, + }), + worker_versioning.ExternalWorkerDeploymentVersionToStringV31(&deploymentpb.WorkerDeploymentVersion{ + DeploymentName: deploymentName, + BuildId: rampingBuildID, + }), + float32(rampPercentage), + ) // Enqueue unversioned backlog. unversionedWorkflowCount := 10 * env.partitionCount @@ -460,16 +470,14 @@ func (s *TaskQueueStatsVersionSuite) TestCurrentAbsorbsUnversionedBacklog_WhenRa env.OverrideDynamicConfig(dynamicconfig.MatchingLongPollExpirationInterval, 10*time.Second) env.OverrideDynamicConfig(dynamicconfig.TaskQueueInfoByBuildIdTTL, 1*time.Millisecond) // zero means no TTL - ctx, cancel := context.WithTimeout(s.Context(), 60*time.Second) - defer cancel() - deploymentName := testcore.RandomizeStr("deployment") tqName := "tq-" + common.GenerateRandomString(5) currentBuildID := "v1" - pollCtx, cancelPoll := context.WithCancel(ctx) - s.createVersionsInTaskQueue(pollCtx, env, tqName, deploymentName, currentBuildID) - cancelPoll() // cancel the pollers so that we can verify the backlog expectations + pollerCtx, cancelPoller := context.WithCancel(s.Context()) + s.createVersionsInTaskQueue(pollerCtx, env, tqName, deploymentName, currentBuildID) + // Stopping the pollers so that we verify the backlog expectations + cancelPoller() // Set current version. s.setCurrentVersion(env, deploymentName, currentBuildID) @@ -522,16 +530,14 @@ func (s *TaskQueueStatsVersionSuite) TestRampingAbsorbsUnversionedBacklog_WhenCu env.OverrideDynamicConfig(dynamicconfig.MatchingLongPollExpirationInterval, 10*time.Second) env.OverrideDynamicConfig(dynamicconfig.TaskQueueInfoByBuildIdTTL, 1*time.Millisecond) // zero means no TTL - ctx, cancel := context.WithTimeout(s.Context(), 60*time.Second) - defer cancel() - deploymentName := testcore.RandomizeStr("deployment") tqName := "tq-" + common.GenerateRandomString(5) rampingBuildID := "v2" - pollCtx, cancelPoll := context.WithCancel(ctx) - s.createVersionsInTaskQueue(pollCtx, env, tqName, deploymentName, rampingBuildID) - cancelPoll() // cancel the pollers so that we can verify the backlog expectations + pollerCtx, cancelPoller := context.WithCancel(s.Context()) + s.createVersionsInTaskQueue(pollerCtx, env, tqName, deploymentName, rampingBuildID) + // Stopping the pollers so that we verify the backlog expectations + cancelPoller() // Set current to unversioned (nil current version). s.setCurrentVersion(env, deploymentName, "") @@ -590,16 +596,15 @@ func (s *TaskQueueStatsVersionSuite) TestInactiveVersionDoesNotAbsorbUnversioned currentBuildID := "v1" inactiveBuildID := "v2" - pollCtx, cancelPoll := context.WithCancel(s.Context()) - - s.createVersionsInTaskQueue(pollCtx, env, tqName, deploymentName, currentBuildID) - s.createVersionsInTaskQueue(pollCtx, env, tqName, deploymentName, inactiveBuildID) + pollerCtx, cancelPoller := context.WithCancel(s.Context()) + s.createVersionsInTaskQueue(pollerCtx, env, tqName, deploymentName, currentBuildID) + s.createVersionsInTaskQueue(pollerCtx, env, tqName, deploymentName, inactiveBuildID) // Set current version s.setCurrentVersion(env, deploymentName, currentBuildID) // Stopping the pollers so that we verify the backlog expectations - cancelPoll() + cancelPoller() // Enqueue unversioned backlog. unversionedWorkflows := 10 * env.partitionCount @@ -759,7 +764,7 @@ func (s *TaskQueueStatsVersionSuite) requireWDVTaskQueueStatsRelaxed( // Use the existing validateTaskQueueStats with MaxExtraTasks set to numPartitions // to account for ceiling operations across partitions expectation.MaxExtraTasks = env.partitionCount - validateTaskQueueStats(s.T(), label, stats, expectation) + validateTaskQueueStats(s.Assertions, label, stats, expectation) } // requireLegacyTaskQueueStatsRelaxed asserts task queue statistics by allowing for over-counting in multi-partition scenarios. @@ -780,7 +785,7 @@ func (s *TaskQueueStatsVersionSuite) requireLegacyTaskQueueStatsRelaxed( // Use the existing validateTaskQueueStats with MaxExtraTasks set to numPartitions // to account for ceiling operations across partitions expectation.MaxExtraTasks = env.partitionCount - validateTaskQueueStats(s.T(), label, stats, expectation) + validateTaskQueueStats(s.Assertions, label, stats, expectation) } // Publishes versioned and unversioned entities; with one entity per priority (plus default priority). Multiplied by `sets`. @@ -1092,10 +1097,8 @@ func (s *taskQueueStatsContext) describeWDVTaskQueueStats( if err != nil { return nil, false, err } - for _, tq := range resp.GetVersionTaskQueues() { - if tq.GetName() == tqName && tq.GetType() == tqType { - return tq.GetStats(), true, nil - } + if tq := s.findVersionTaskQueue(resp.GetVersionTaskQueues(), tqName, tqType); tq != nil { + return tq.GetStats(), true, nil } return nil, false, nil } @@ -1198,9 +1201,24 @@ func (s *TaskQueueStatsVersionSuite) createVersionsInTaskQueue(ctx context.Conte }) s.NoError(err) s.NotNil(resp) + s.NotNil(env.findVersionTaskQueue(resp.GetVersionTaskQueues(), tqName, enumspb.TASK_QUEUE_TYPE_WORKFLOW)) + s.NotNil(env.findVersionTaskQueue(resp.GetVersionTaskQueues(), tqName, enumspb.TASK_QUEUE_TYPE_ACTIVITY)) }, 10*time.Second, 200*time.Millisecond) } +func (s *taskQueueStatsContext) findVersionTaskQueue( + taskQueues []*workflowservice.DescribeWorkerDeploymentVersionResponse_VersionTaskQueue, + tqName string, + tqType enumspb.TaskQueueType, +) *workflowservice.DescribeWorkerDeploymentVersionResponse_VersionTaskQueue { + for _, tq := range taskQueues { + if tq.GetName() == tqName && tq.GetType() == tqType { + return tq + } + } + return nil +} + // TODO (Shivam): Remove this guy. func (s *taskQueueStatsContext) createDeploymentInTaskQueue(tqName string) { // Using old DeploymentData format @@ -1410,7 +1428,7 @@ func (s *taskQueueStatsContext) validateDescribeTaskQueueWithDefaultMode( require.EqualValuesf(t, expected, actual, "%s: backlog hint should be %d, got %d", label, expected, actual) } - validateTaskQueueStats(t, label, resp.Stats, expectation) + validateTaskQueueStats(require.New(t), label, resp.Stats, expectation) if s.usePriMatcher && expectation.BacklogCount > 0 { // Per priority stats are only available with the priority matcher and when they've been actively used. s.validateTaskQueueStatsByPriority(t, label, resp.StatsByPriorityKey, expectation) @@ -1471,7 +1489,7 @@ func (s *taskQueueStatsContext) validateDescribeTaskQueueWithEnhancedMode( return } - validateTaskQueueStats(t, "DescribeTaskQueue_EnhancedMode["+tqType.String()+"]", info.Stats, expectation) + validateTaskQueueStats(require.New(t), "DescribeTaskQueue_EnhancedMode["+tqType.String()+"]", info.Stats, expectation) } }, 5*time.Second, 100*time.Millisecond) } @@ -1507,7 +1525,7 @@ func (s *taskQueueStatsContext) validateDescribeWorkerDeploymentVersion( for _, info := range resp.VersionTaskQueues { if info.Name == tqName || info.Type == tqType { label := "DescribeWorkerDeploymentVersion[" + tqType.String() + "]" - validateTaskQueueStats(t, label, info.Stats, expectation) + validateTaskQueueStats(require.New(t), label, info.Stats, expectation) if s.usePriMatcher && expectation.BacklogCount > 0 { // Per priority stats are only available with the priority matcher and when they've been actively used. s.validateTaskQueueStatsByPriority(t, label, info.StatsByPriorityKey, expectation) @@ -1551,7 +1569,7 @@ func (s *taskQueueStatsContext) validateTaskQueueStatsByPriority( } require.Containsf(t, stats, i, "%s: stats should contain priority %d", label, i) - validateTaskQueueStats(t, fmt.Sprintf("%s_Pri[%d]", label, i), stats[i], priExpectation) + validateTaskQueueStats(require.New(t), fmt.Sprintf("%s_Pri[%d]", label, i), stats[i], priExpectation) accBacklogCount += int(stats[i].ApproximateBacklogCount) } require.GreaterOrEqualf(t, taskQueueExpectation.BacklogCount, accBacklogCount, @@ -1584,23 +1602,23 @@ func validateTaskQueueStatsStrict( } func validateTaskQueueStats( - t require.TestingT, + require *require.Assertions, label string, stats *taskqueuepb.TaskQueueStats, expectation taskQueueExpectations, ) { // Actual counter can be greater than the expected due to history retries. We make sure the counter is in // range [expected, expected+maxBacklogExtraTasks] - require.GreaterOrEqual(t, stats.ApproximateBacklogCount, int64(expectation.BacklogCount), + require.GreaterOrEqual(stats.ApproximateBacklogCount, int64(expectation.BacklogCount), "%s: ApproximateBacklogCount should be at least %d, got %d", label, expectation.BacklogCount, stats.ApproximateBacklogCount) maxApproximateBacklogCount := int64(expectation.BacklogCount + expectation.MaxExtraTasks) - require.LessOrEqual(t, stats.ApproximateBacklogCount, maxApproximateBacklogCount, + require.LessOrEqual(stats.ApproximateBacklogCount, maxApproximateBacklogCount, "%s: ApproximateBacklogCount should be at most %d, got %d", label, maxApproximateBacklogCount, stats.ApproximateBacklogCount) - require.Equal(t, stats.ApproximateBacklogCount == 0, stats.ApproximateBacklogAge.AsDuration() == time.Duration(0), + require.Equal(stats.ApproximateBacklogCount == 0, stats.ApproximateBacklogAge.AsDuration() == time.Duration(0), "%s: ApproximateBacklogAge should be 0 when ApproximateBacklogCount is 0, got %s", label, stats.ApproximateBacklogAge.AsDuration()) } diff --git a/tests/versioning_test_env.go b/tests/versioning_test_env.go new file mode 100644 index 00000000000..59315ec4b25 --- /dev/null +++ b/tests/versioning_test_env.go @@ -0,0 +1,48 @@ +package tests + +import ( + "context" + "testing" + "time" + + "github.com/stretchr/testify/require" + taskqueuepb "go.temporal.io/api/taskqueue/v1" + "go.temporal.io/api/workflowservice/v1" + "go.temporal.io/server/common/testing/await" + "go.temporal.io/server/common/testing/protorequire" + "go.temporal.io/server/common/worker_versioning" + "go.temporal.io/server/tests/testcore" +) + +type VersioningTestEnv struct { + *testcore.TestEnv +} + +func newVersioningTestEnv(t *testing.T, opts ...testcore.TestOption) *VersioningTestEnv { + return &VersioningTestEnv{ + TestEnv: testcore.NewEnv(t, opts...), + } +} + +func (env *VersioningTestEnv) waitForTaskQueueVersioningInfo( + tb testing.TB, + ctx context.Context, + tq *taskqueuepb.TaskQueue, + expectedCurrentVersion string, + expectedRampingVersion string, + rampingPercentage float32, +) { + await.Require(ctx, tb, func(t *await.T) { + resp, err := env.FrontendClient().DescribeTaskQueue(t.Context(), &workflowservice.DescribeTaskQueueRequest{ + Namespace: env.Namespace().String(), + TaskQueue: tq, + }) + require.NoError(t, err) + require.NotNil(t, resp) + protorequire.ProtoEqual(t, worker_versioning.ExternalWorkerDeploymentVersionFromStringV31(expectedCurrentVersion), resp.GetVersioningInfo().GetCurrentDeploymentVersion()) + protorequire.ProtoEqual(t, worker_versioning.ExternalWorkerDeploymentVersionFromStringV31(expectedRampingVersion), resp.GetVersioningInfo().GetRampingDeploymentVersion()) + require.Equal(t, expectedCurrentVersion, resp.GetVersioningInfo().GetCurrentVersion()) //nolint:staticcheck // SA1019: old worker versioning + require.Equal(t, expectedRampingVersion, resp.GetVersioningInfo().GetRampingVersion()) //nolint:staticcheck // SA1019: old worker versioning + require.Equal(t, rampingPercentage, resp.GetVersioningInfo().GetRampingVersionPercentage()) + }, 10*time.Second, 200*time.Millisecond) +} diff --git a/tests/worker_deployment_test.go b/tests/worker_deployment_test.go index 760496a8cea..dbcc3b5dc27 100644 --- a/tests/worker_deployment_test.go +++ b/tests/worker_deployment_test.go @@ -13,7 +13,6 @@ import ( deploymentpb "go.temporal.io/api/deployment/v1" enumspb "go.temporal.io/api/enums/v1" "go.temporal.io/api/serviceerror" - taskqueuepb "go.temporal.io/api/taskqueue/v1" "go.temporal.io/api/workflowservice/v1" sdkworker "go.temporal.io/sdk/worker" deploymentspb "go.temporal.io/server/api/deployment/v1" @@ -43,7 +42,7 @@ func TestWorkerDeploymentSuite(t *testing.T) { // newTestEnv creates a TestEnv with the dynamic config this suite needs. // Additional per-test options may be passed in opts. -func (s *WorkerDeploymentSuite) newTestEnv(opts ...testcore.TestOption) *testcore.TestEnv { +func (s *WorkerDeploymentSuite) newTestEnv(opts ...testcore.TestOption) *VersioningTestEnv { baseOpts := []testcore.TestOption{ testcore.WithDynamicConfig(dynamicconfig.MatchingDeploymentWorkflowVersion, int(workerdeployment.VersionDataRevisionNumber)), @@ -69,15 +68,15 @@ func (s *WorkerDeploymentSuite) newTestEnv(opts ...testcore.TestOption) *testcor return tv.WithDeploymentSeries("wd").WithBuildID("b") }), } - return testcore.NewEnv(s.T(), append(baseOpts, opts...)...) + return newVersioningTestEnv(s.T(), append(baseOpts, opts...)...) } // pollFromDeployment calls PollWorkflowTaskQueue to start deployment related workflows -func (s *WorkerDeploymentSuite) pollFromDeployment(env *testcore.TestEnv, tv *testvars.TestVars) { +func (s *WorkerDeploymentSuite) pollFromDeployment(env *VersioningTestEnv, tv *testvars.TestVars) { s.pollFromDeploymentUntil(s.Context(), env, tv) } -func (s *WorkerDeploymentSuite) pollFromDeploymentUntil(ctx context.Context, env *testcore.TestEnv, tv *testvars.TestVars) { +func (s *WorkerDeploymentSuite) pollFromDeploymentUntil(ctx context.Context, env *VersioningTestEnv, tv *testvars.TestVars) { _, _ = env.FrontendClient().PollWorkflowTaskQueue(ctx, &workflowservice.PollWorkflowTaskQueueRequest{ Namespace: env.Namespace().String(), TaskQueue: tv.TaskQueue(), @@ -86,13 +85,13 @@ func (s *WorkerDeploymentSuite) pollFromDeploymentUntil(ctx context.Context, env }) } -func (s *WorkerDeploymentSuite) startDeploymentPoller(env *testcore.TestEnv, tv *testvars.TestVars) context.CancelFunc { +func (s *WorkerDeploymentSuite) startDeploymentPoller(env *VersioningTestEnv, tv *testvars.TestVars) context.CancelFunc { ctx, cancel := context.WithCancel(s.Context()) go s.pollFromDeploymentUntil(ctx, env, tv) return cancel } -func (s *WorkerDeploymentSuite) pollFromDeploymentWithTaskQueueNumber(env *testcore.TestEnv, tv *testvars.TestVars, taskQueueNumber int) { +func (s *WorkerDeploymentSuite) pollFromDeploymentWithTaskQueueNumber(env *VersioningTestEnv, tv *testvars.TestVars, taskQueueNumber int) { _, _ = env.FrontendClient().PollWorkflowTaskQueue(s.Context(), &workflowservice.PollWorkflowTaskQueueRequest{ Namespace: env.Namespace().String(), TaskQueue: tv.WithTaskQueueNumber(taskQueueNumber).TaskQueue(), @@ -101,7 +100,7 @@ func (s *WorkerDeploymentSuite) pollFromDeploymentWithTaskQueueNumber(env *testc }) } -func (s *WorkerDeploymentSuite) pollFromDeploymentExpectFail(env *testcore.TestEnv, tv *testvars.TestVars, expectedError string) { +func (s *WorkerDeploymentSuite) pollFromDeploymentExpectFail(env *VersioningTestEnv, tv *testvars.TestVars, expectedError string) { _, err := env.FrontendClient().PollWorkflowTaskQueue(s.Context(), &workflowservice.PollWorkflowTaskQueueRequest{ Namespace: env.Namespace().String(), TaskQueue: tv.TaskQueue(), @@ -112,7 +111,7 @@ func (s *WorkerDeploymentSuite) pollFromDeploymentExpectFail(env *testcore.TestE s.Equal(expectedError, err.Error()) } -func (s *WorkerDeploymentSuite) ensureCreateVersionWithExpectedTaskQueues(env *testcore.TestEnv, tv *testvars.TestVars, expectedTaskQueues int) { +func (s *WorkerDeploymentSuite) ensureCreateVersionWithExpectedTaskQueues(env *VersioningTestEnv, tv *testvars.TestVars, expectedTaskQueues int) { s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) respV, _ := env.FrontendClient().DescribeWorkerDeploymentVersion(s.Context(), &workflowservice.DescribeWorkerDeploymentVersionRequest{ @@ -125,7 +124,7 @@ func (s *WorkerDeploymentSuite) ensureCreateVersionWithExpectedTaskQueues(env *t } func (s *WorkerDeploymentSuite) ensureCreateVersionInDeployment( - env *testcore.TestEnv, + env *VersioningTestEnv, tv *testvars.TestVars, ) { v := tv.DeploymentVersionString() @@ -152,7 +151,7 @@ func (s *WorkerDeploymentSuite) ensureCreateVersionInDeployment( } func (s *WorkerDeploymentSuite) ensureCreateDeployment( - env *testcore.TestEnv, + env *VersioningTestEnv, tv *testvars.TestVars, ) { ctx, cancel := context.WithTimeout(s.Context(), 5*time.Second) @@ -168,12 +167,12 @@ func (s *WorkerDeploymentSuite) ensureCreateDeployment( }, 5*time.Second, 100*time.Millisecond) } -func (s *WorkerDeploymentSuite) startVersionWorkflow(env *testcore.TestEnv, tv *testvars.TestVars) { +func (s *WorkerDeploymentSuite) startVersionWorkflow(env *VersioningTestEnv, tv *testvars.TestVars) { go s.pollFromDeployment(env, tv) s.waitForDeploymentVersion(env, tv) } -func (s *WorkerDeploymentSuite) waitForDeploymentVersion(env *testcore.TestEnv, tv *testvars.TestVars) { +func (s *WorkerDeploymentSuite) waitForDeploymentVersion(env *VersioningTestEnv, tv *testvars.TestVars) { s.EventuallyWithT(func(t *assert.CollectT) { a := require.New(t) resp, err := env.FrontendClient().DescribeWorkerDeploymentVersion(s.Context(), &workflowservice.DescribeWorkerDeploymentVersionRequest{ @@ -1402,7 +1401,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Batching() // verify that all the registered task-queues have "" set as their ramping version for i := range taskQueues { - s.verifyTaskQueueVersioningInfo(env, env.Tv().WithTaskQueueNumber(i).TaskQueue(), worker_versioning.UnversionedVersionId, "", 0) + env.waitForTaskQueueVersioningInfo(s.T(), s.Context(), env.Tv().WithTaskQueueNumber(i).TaskQueue(), worker_versioning.UnversionedVersionId, "", 0) } // set ramping version to 50% @@ -1411,7 +1410,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Batching() // verify the task queues have new ramping version for i := range taskQueues { - s.verifyTaskQueueVersioningInfo(env, env.Tv().WithTaskQueueNumber(i).TaskQueue(), worker_versioning.UnversionedVersionId, env.Tv().DeploymentVersionString(), 50) + env.waitForTaskQueueVersioningInfo(s.T(), s.Context(), env.Tv().WithTaskQueueNumber(i).TaskQueue(), worker_versioning.UnversionedVersionId, env.Tv().DeploymentVersionString(), 50) } // verify if the worker-deployment has the right ramping version set @@ -1479,7 +1478,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Unversione // check that the current version's task queues have ramping version == __unversioned__ for i := range taskQueues { - s.verifyTaskQueueVersioningInfo(env, env.Tv().WithTaskQueueNumber(i).TaskQueue(), env.Tv().DeploymentVersionString(), worker_versioning.UnversionedVersionId, 75) + env.waitForTaskQueueVersioningInfo(s.T(), s.Context(), env.Tv().WithTaskQueueNumber(i).TaskQueue(), env.Tv().DeploymentVersionString(), worker_versioning.UnversionedVersionId, 75) } // verify if the worker-deployment has the right ramping version set @@ -1654,7 +1653,7 @@ func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Batching() { // verify that all the registered task-queues have "__unversioned__" as their current version for i := range taskQueues { - s.verifyTaskQueueVersioningInfo(env, env.Tv().WithTaskQueueNumber(i).TaskQueue(), worker_versioning.UnversionedVersionId, "", 0) + env.waitForTaskQueueVersioningInfo(s.T(), s.Context(), env.Tv().WithTaskQueueNumber(i).TaskQueue(), worker_versioning.UnversionedVersionId, "", 0) } // set current and check that the current version's task queues have new current version @@ -1663,7 +1662,7 @@ func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Batching() { // verify the current version has propogated to all the registered task-queues userData for i := range taskQueues { - s.verifyTaskQueueVersioningInfo(env, env.Tv().WithTaskQueueNumber(i).TaskQueue(), env.Tv().DeploymentVersionString(), "", 0) + env.waitForTaskQueueVersioningInfo(s.T(), s.Context(), env.Tv().WithTaskQueueNumber(i).TaskQueue(), env.Tv().DeploymentVersionString(), "", 0) } // verify if the worker-deployment has the right current version set @@ -1825,17 +1824,17 @@ func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Unversioned_NoRamp() { s.ensureCreateVersionInDeployment(env, env.Tv()) // check that the current version's task queues have current version unversioned to start - s.verifyTaskQueueVersioningInfo(env, env.Tv().TaskQueue(), worker_versioning.UnversionedVersionId, "", 0) + env.waitForTaskQueueVersioningInfo(s.T(), s.Context(), env.Tv().TaskQueue(), worker_versioning.UnversionedVersionId, "", 0) // set current and check that the current version's task queues have new current version firstCurrentUpdateTime := timestamppb.Now() s.setCurrentVersion(env, env.Tv(), true, "") - s.verifyTaskQueueVersioningInfo(env, env.Tv().TaskQueue(), env.Tv().DeploymentVersionString(), "", 0) + env.waitForTaskQueueVersioningInfo(s.T(), s.Context(), env.Tv().TaskQueue(), env.Tv().DeploymentVersionString(), "", 0) // set current unversioned and check that the current version's task queues have current version unversioned again secondCurrentUpdateTime := timestamppb.Now() s.setCurrentVersionUnversionedOption(env, env.Tv(), true, true, false, true, "") - s.verifyTaskQueueVersioningInfo(env, env.Tv().TaskQueue(), worker_versioning.UnversionedVersionId, "", 0) + env.waitForTaskQueueVersioningInfo(s.T(), s.Context(), env.Tv().TaskQueue(), worker_versioning.UnversionedVersionId, "", 0) // check that deployment has current version == __unversioned__ resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ @@ -1881,13 +1880,13 @@ func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Unversioned_PromoteUnversi // set ramp to unversioned s.setAndVerifyRampingVersionUnversionedOption(env, env.Tv(), true, false, 75, true, false, true, "") // check that the current version's task queues have ramping version == __unversioned__ - s.verifyTaskQueueVersioningInfo(env, env.Tv().TaskQueue(), env.Tv().DeploymentVersionString(), worker_versioning.UnversionedVersionId, 75) + env.waitForTaskQueueVersioningInfo(s.T(), s.Context(), env.Tv().TaskQueue(), env.Tv().DeploymentVersionString(), worker_versioning.UnversionedVersionId, 75) // set current to unversioned s.setCurrentVersionUnversionedOption(env, env.Tv(), true, true, false, true, "") // check that the current version's task queues have ramping version == "" and current version == "__unversioned__" - s.verifyTaskQueueVersioningInfo(env, env.Tv().TaskQueue(), worker_versioning.UnversionedVersionId, "", 0) + env.waitForTaskQueueVersioningInfo(s.T(), s.Context(), env.Tv().TaskQueue(), worker_versioning.UnversionedVersionId, "", 0) } func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Concurrent_DifferentVersions_NoUnexpectedErrors() { @@ -2012,7 +2011,7 @@ func (s *WorkerDeploymentSuite) TestConcurrentPollers_DifferentTaskQueues_SameVe // verify that the task queues, eventually, have this version as the current version in their versioning info for i := range tqs { - s.verifyTaskQueueVersioningInfo(env, env.Tv().WithTaskQueueNumber(i).TaskQueue(), env.Tv().DeploymentVersionString(), "", 0) + env.waitForTaskQueueVersioningInfo(s.T(), s.Context(), env.Tv().WithTaskQueueNumber(i).TaskQueue(), env.Tv().DeploymentVersionString(), "", 0) } } @@ -2362,7 +2361,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Unversione // check that the current version's task queues have ramping version == "" s.setCurrentVersion(env, env.Tv(), true, "") - s.verifyTaskQueueVersioningInfo(env, env.Tv().TaskQueue(), env.Tv().DeploymentVersionString(), "", 0) + env.waitForTaskQueueVersioningInfo(s.T(), s.Context(), env.Tv().TaskQueue(), env.Tv().DeploymentVersionString(), "", 0) // set ramp to unversioned s.setAndVerifyRampingVersionUnversionedOption(env, env.Tv(), true, false, 75, true, false, true, "") @@ -2376,7 +2375,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Unversione s.Equal(worker_versioning.UnversionedVersionId, resp.GetWorkerDeploymentInfo().GetRoutingConfig().GetRampingVersion()) // check that the current version's task queues have ramping version == __unversioned__ - s.verifyTaskQueueVersioningInfo(env, env.Tv().TaskQueue(), env.Tv().DeploymentVersionString(), worker_versioning.UnversionedVersionId, 75) + env.waitForTaskQueueVersioningInfo(s.T(), s.Context(), env.Tv().TaskQueue(), env.Tv().DeploymentVersionString(), worker_versioning.UnversionedVersionId, 75) } func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentCurrentVersion_NoPollers() { @@ -2429,7 +2428,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentCurrentVersion_NoPollers( }, 10*time.Second, 100*time.Millisecond) // that poller's task queue should have the current versioning info - s.verifyTaskQueueVersioningInfo(env, env.Tv().TaskQueue(), env.Tv().DeploymentVersionString(), "", 0) + env.waitForTaskQueueVersioningInfo(s.T(), s.Context(), env.Tv().TaskQueue(), env.Tv().DeploymentVersionString(), "", 0) } func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_NoPollers() { @@ -2485,7 +2484,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_NoPollers( }, 10*time.Second, 100*time.Millisecond) // that poller's task queue should have the ramping version info - s.verifyTaskQueueVersioningInfo(env, env.Tv().TaskQueue(), worker_versioning.UnversionedVersionId, env.Tv().DeploymentVersionString(), 5) + env.waitForTaskQueueVersioningInfo(s.T(), s.Context(), env.Tv().TaskQueue(), worker_versioning.UnversionedVersionId, env.Tv().DeploymentVersionString(), 5) } func (s *WorkerDeploymentSuite) TestTwoPollers_EnsureCreateVersion() { @@ -2500,23 +2499,6 @@ func (s *WorkerDeploymentSuite) TestTwoPollers_EnsureCreateVersion() { s.ensureCreateVersionWithExpectedTaskQueues(env, tv2, 1) } -func (s *WorkerDeploymentSuite) verifyTaskQueueVersioningInfo(env *testcore.TestEnv, tq *taskqueuepb.TaskQueue, expectedCurrentVersion, expectedRampingVersion string, expectedPercentage float32) { - s.EventuallyWithT(func(t *assert.CollectT) { - tqDesc, err := env.FrontendClient().DescribeTaskQueue(s.Context(), &workflowservice.DescribeTaskQueueRequest{ - Namespace: env.Namespace().String(), - TaskQueue: tq, - }) - a := require.New(t) - a.NoError(err) - a.Equal(worker_versioning.ExternalWorkerDeploymentVersionFromStringV31(expectedCurrentVersion), tqDesc.GetVersioningInfo().GetCurrentDeploymentVersion()) - a.Equal(worker_versioning.ExternalWorkerDeploymentVersionFromStringV31(expectedRampingVersion), tqDesc.GetVersioningInfo().GetRampingDeploymentVersion()) - a.Equal(expectedCurrentVersion, tqDesc.GetVersioningInfo().GetCurrentVersion()) //nolint:staticcheck // SA1019: old worker versioning - a.Equal(expectedRampingVersion, tqDesc.GetVersioningInfo().GetRampingVersion()) //nolint:staticcheck // SA1019: old worker versioning - a.Equal(expectedPercentage, tqDesc.GetVersioningInfo().GetRampingVersionPercentage()) - - }, time.Second*10, time.Millisecond*1000) -} - // This test shall first rollback a drained version to a current version. After that, it shall deploy a new version // which shall further drain this current version. // Note: This test reproduces a bug we saw in production where the drainage status was not being properly cleared when a draining version @@ -3249,7 +3231,7 @@ func (s *WorkerDeploymentSuite) TestDeleteWorkerDeployment_InvalidDelete() { } func (s *WorkerDeploymentSuite) tryDeleteVersion( - env *testcore.TestEnv, + env *VersioningTestEnv, tv *testvars.TestVars, expectedError string, ) { @@ -3356,7 +3338,7 @@ func (s *WorkerDeploymentSuite) verifyDescribeWorkerDeployment( } func (s *WorkerDeploymentSuite) setAndVerifyRampingVersion( - env *testcore.TestEnv, + env *VersioningTestEnv, tv *testvars.TestVars, unset bool, percentage int, @@ -3368,7 +3350,7 @@ func (s *WorkerDeploymentSuite) setAndVerifyRampingVersion( //nolint:staticcheck // SA1019 func (s *WorkerDeploymentSuite) setAndVerifyRampingVersionUnversionedOption( - env *testcore.TestEnv, + env *VersioningTestEnv, tv *testvars.TestVars, unversioned, unset bool, percentage int, @@ -3406,12 +3388,12 @@ func (s *WorkerDeploymentSuite) setAndVerifyRampingVersionUnversionedOption( s.NoError(err) } -func (s *WorkerDeploymentSuite) setCurrentVersion(env *testcore.TestEnv, tv *testvars.TestVars, ignoreMissingTaskQueues bool, expectedError string) { +func (s *WorkerDeploymentSuite) setCurrentVersion(env *VersioningTestEnv, tv *testvars.TestVars, ignoreMissingTaskQueues bool, expectedError string) { s.setCurrentVersionUnversionedOption(env, tv, false, ignoreMissingTaskQueues, false, true, expectedError) } func (s *WorkerDeploymentSuite) setCurrentVersionAllowNoPollersOption( - env *testcore.TestEnv, + env *VersioningTestEnv, tv *testvars.TestVars, ignoreMissingTaskQueues, allowNoPollers, ensureSystemWorkflowsExist bool, expectedError string, @@ -3420,7 +3402,7 @@ func (s *WorkerDeploymentSuite) setCurrentVersionAllowNoPollersOption( } func (s *WorkerDeploymentSuite) setCurrentVersionUnversionedOption( - env *testcore.TestEnv, + env *VersioningTestEnv, tv *testvars.TestVars, unversioned, ignoreMissingTaskQueues, allowNoPollers, ensureSystemWorkflowsExist bool, expectedError string, @@ -3453,7 +3435,7 @@ func (s *WorkerDeploymentSuite) setCurrentVersionUnversionedOption( s.NoError(err) } -func (s *WorkerDeploymentSuite) setAndValidateManagerIdentity(env *testcore.TestEnv, tv *testvars.TestVars, self, useWrongConflictToken bool, newManager, expectedError string) { +func (s *WorkerDeploymentSuite) setAndValidateManagerIdentity(env *VersioningTestEnv, tv *testvars.TestVars, self, useWrongConflictToken bool, newManager, expectedError string) { s.ensureCreateDeployment(env, tv) s.ensureCreateVersionInDeployment(env, tv) @@ -3509,7 +3491,7 @@ func (s *WorkerDeploymentSuite) setAndValidateManagerIdentity(env *testcore.Test s.Equal(expectedManagerIdentity, desc.GetWorkerDeploymentInfo().GetManagerIdentity()) } -func (s *WorkerDeploymentSuite) createVersionsInDeployments(env *testcore.TestEnv, tv *testvars.TestVars, n int) []*workflowservice.ListWorkerDeploymentsResponse_WorkerDeploymentSummary { +func (s *WorkerDeploymentSuite) createVersionsInDeployments(env *VersioningTestEnv, tv *testvars.TestVars, n int) []*workflowservice.ListWorkerDeploymentsResponse_WorkerDeploymentSummary { var expectedDeploymentSummaries []*workflowservice.ListWorkerDeploymentsResponse_WorkerDeploymentSummary for i := range n { @@ -3585,7 +3567,7 @@ func (s *WorkerDeploymentSuite) verifyWorkerDeploymentSummary( return true } -func (s *WorkerDeploymentSuite) listWorkerDeployments(env *testcore.TestEnv, request *workflowservice.ListWorkerDeploymentsRequest) ([]*workflowservice.ListWorkerDeploymentsResponse_WorkerDeploymentSummary, error) { +func (s *WorkerDeploymentSuite) listWorkerDeployments(env *VersioningTestEnv, request *workflowservice.ListWorkerDeploymentsRequest) ([]*workflowservice.ListWorkerDeploymentsResponse_WorkerDeploymentSummary, error) { var resp *workflowservice.ListWorkerDeploymentsResponse var err error var deploymentSummaries []*workflowservice.ListWorkerDeploymentsResponse_WorkerDeploymentSummary @@ -3601,7 +3583,7 @@ func (s *WorkerDeploymentSuite) listWorkerDeployments(env *testcore.TestEnv, req } func (s *WorkerDeploymentSuite) startAndValidateWorkerDeployments( - env *testcore.TestEnv, + env *VersioningTestEnv, request *workflowservice.ListWorkerDeploymentsRequest, expectedDeploymentSummaries []*workflowservice.ListWorkerDeploymentsResponse_WorkerDeploymentSummary, ) { @@ -3632,7 +3614,7 @@ func (s *WorkerDeploymentSuite) startAndValidateWorkerDeployments( } func (s *WorkerDeploymentSuite) validateWorkerDeploymentCount( - env *testcore.TestEnv, + env *VersioningTestEnv, request *workflowservice.ListWorkerDeploymentsRequest, expectedCount int, ) { From cc630869b1abe4fe2efef40c36de045fc11201e3 Mon Sep 17 00:00:00 2001 From: Stephan Behnke Date: Thu, 18 Jun 2026 16:58:44 -0700 Subject: [PATCH 26/27] ctx first --- tests/task_queue_stats_test.go | 15 +-------------- tests/versioning_test_env.go | 16 +++++++++++++++- tests/worker_deployment_test.go | 30 +++++++++++++++--------------- 3 files changed, 31 insertions(+), 30 deletions(-) diff --git a/tests/task_queue_stats_test.go b/tests/task_queue_stats_test.go index f76ff8ef44c..0d2162d22b9 100644 --- a/tests/task_queue_stats_test.go +++ b/tests/task_queue_stats_test.go @@ -325,8 +325,8 @@ func (s *TaskQueueStatsVersionSuite) TestRampingAndCurrentAbsorbUnversionedBackl // Set current version s.setCurrentVersion(env, deploymentName, currentBuildID) env.waitForTaskQueueVersioningInfo( - s.T(), s.Context(), + s.T(), &taskqueuepb.TaskQueue{Name: tqName, Kind: enumspb.TASK_QUEUE_KIND_NORMAL}, worker_versioning.ExternalWorkerDeploymentVersionToStringV31(&deploymentpb.WorkerDeploymentVersion{ DeploymentName: deploymentName, @@ -1206,19 +1206,6 @@ func (s *TaskQueueStatsVersionSuite) createVersionsInTaskQueue(ctx context.Conte }, 10*time.Second, 200*time.Millisecond) } -func (s *taskQueueStatsContext) findVersionTaskQueue( - taskQueues []*workflowservice.DescribeWorkerDeploymentVersionResponse_VersionTaskQueue, - tqName string, - tqType enumspb.TaskQueueType, -) *workflowservice.DescribeWorkerDeploymentVersionResponse_VersionTaskQueue { - for _, tq := range taskQueues { - if tq.GetName() == tqName && tq.GetType() == tqType { - return tq - } - } - return nil -} - // TODO (Shivam): Remove this guy. func (s *taskQueueStatsContext) createDeploymentInTaskQueue(tqName string) { // Using old DeploymentData format diff --git a/tests/versioning_test_env.go b/tests/versioning_test_env.go index 59315ec4b25..149c211c5fd 100644 --- a/tests/versioning_test_env.go +++ b/tests/versioning_test_env.go @@ -6,6 +6,7 @@ import ( "time" "github.com/stretchr/testify/require" + enumspb "go.temporal.io/api/enums/v1" taskqueuepb "go.temporal.io/api/taskqueue/v1" "go.temporal.io/api/workflowservice/v1" "go.temporal.io/server/common/testing/await" @@ -25,8 +26,8 @@ func newVersioningTestEnv(t *testing.T, opts ...testcore.TestOption) *Versioning } func (env *VersioningTestEnv) waitForTaskQueueVersioningInfo( - tb testing.TB, ctx context.Context, + tb testing.TB, tq *taskqueuepb.TaskQueue, expectedCurrentVersion string, expectedRampingVersion string, @@ -46,3 +47,16 @@ func (env *VersioningTestEnv) waitForTaskQueueVersioningInfo( require.Equal(t, rampingPercentage, resp.GetVersioningInfo().GetRampingVersionPercentage()) }, 10*time.Second, 200*time.Millisecond) } + +func (env *VersioningTestEnv) findVersionTaskQueue( + taskQueues []*workflowservice.DescribeWorkerDeploymentVersionResponse_VersionTaskQueue, + tqName string, + tqType enumspb.TaskQueueType, +) *workflowservice.DescribeWorkerDeploymentVersionResponse_VersionTaskQueue { + for _, tq := range taskQueues { + if tq.GetName() == tqName && tq.GetType() == tqType { + return tq + } + } + return nil +} diff --git a/tests/worker_deployment_test.go b/tests/worker_deployment_test.go index dbcc3b5dc27..c114fc53dd6 100644 --- a/tests/worker_deployment_test.go +++ b/tests/worker_deployment_test.go @@ -1401,7 +1401,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Batching() // verify that all the registered task-queues have "" set as their ramping version for i := range taskQueues { - env.waitForTaskQueueVersioningInfo(s.T(), s.Context(), env.Tv().WithTaskQueueNumber(i).TaskQueue(), worker_versioning.UnversionedVersionId, "", 0) + env.waitForTaskQueueVersioningInfo(s.Context(), s.T(), env.Tv().WithTaskQueueNumber(i).TaskQueue(), worker_versioning.UnversionedVersionId, "", 0) } // set ramping version to 50% @@ -1410,7 +1410,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Batching() // verify the task queues have new ramping version for i := range taskQueues { - env.waitForTaskQueueVersioningInfo(s.T(), s.Context(), env.Tv().WithTaskQueueNumber(i).TaskQueue(), worker_versioning.UnversionedVersionId, env.Tv().DeploymentVersionString(), 50) + env.waitForTaskQueueVersioningInfo(s.Context(), s.T(), env.Tv().WithTaskQueueNumber(i).TaskQueue(), worker_versioning.UnversionedVersionId, env.Tv().DeploymentVersionString(), 50) } // verify if the worker-deployment has the right ramping version set @@ -1478,7 +1478,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Unversione // check that the current version's task queues have ramping version == __unversioned__ for i := range taskQueues { - env.waitForTaskQueueVersioningInfo(s.T(), s.Context(), env.Tv().WithTaskQueueNumber(i).TaskQueue(), env.Tv().DeploymentVersionString(), worker_versioning.UnversionedVersionId, 75) + env.waitForTaskQueueVersioningInfo(s.Context(), s.T(), env.Tv().WithTaskQueueNumber(i).TaskQueue(), env.Tv().DeploymentVersionString(), worker_versioning.UnversionedVersionId, 75) } // verify if the worker-deployment has the right ramping version set @@ -1653,7 +1653,7 @@ func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Batching() { // verify that all the registered task-queues have "__unversioned__" as their current version for i := range taskQueues { - env.waitForTaskQueueVersioningInfo(s.T(), s.Context(), env.Tv().WithTaskQueueNumber(i).TaskQueue(), worker_versioning.UnversionedVersionId, "", 0) + env.waitForTaskQueueVersioningInfo(s.Context(), s.T(), env.Tv().WithTaskQueueNumber(i).TaskQueue(), worker_versioning.UnversionedVersionId, "", 0) } // set current and check that the current version's task queues have new current version @@ -1662,7 +1662,7 @@ func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Batching() { // verify the current version has propogated to all the registered task-queues userData for i := range taskQueues { - env.waitForTaskQueueVersioningInfo(s.T(), s.Context(), env.Tv().WithTaskQueueNumber(i).TaskQueue(), env.Tv().DeploymentVersionString(), "", 0) + env.waitForTaskQueueVersioningInfo(s.Context(), s.T(), env.Tv().WithTaskQueueNumber(i).TaskQueue(), env.Tv().DeploymentVersionString(), "", 0) } // verify if the worker-deployment has the right current version set @@ -1824,17 +1824,17 @@ func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Unversioned_NoRamp() { s.ensureCreateVersionInDeployment(env, env.Tv()) // check that the current version's task queues have current version unversioned to start - env.waitForTaskQueueVersioningInfo(s.T(), s.Context(), env.Tv().TaskQueue(), worker_versioning.UnversionedVersionId, "", 0) + env.waitForTaskQueueVersioningInfo(s.Context(), s.T(), env.Tv().TaskQueue(), worker_versioning.UnversionedVersionId, "", 0) // set current and check that the current version's task queues have new current version firstCurrentUpdateTime := timestamppb.Now() s.setCurrentVersion(env, env.Tv(), true, "") - env.waitForTaskQueueVersioningInfo(s.T(), s.Context(), env.Tv().TaskQueue(), env.Tv().DeploymentVersionString(), "", 0) + env.waitForTaskQueueVersioningInfo(s.Context(), s.T(), env.Tv().TaskQueue(), env.Tv().DeploymentVersionString(), "", 0) // set current unversioned and check that the current version's task queues have current version unversioned again secondCurrentUpdateTime := timestamppb.Now() s.setCurrentVersionUnversionedOption(env, env.Tv(), true, true, false, true, "") - env.waitForTaskQueueVersioningInfo(s.T(), s.Context(), env.Tv().TaskQueue(), worker_versioning.UnversionedVersionId, "", 0) + env.waitForTaskQueueVersioningInfo(s.Context(), s.T(), env.Tv().TaskQueue(), worker_versioning.UnversionedVersionId, "", 0) // check that deployment has current version == __unversioned__ resp, err := env.FrontendClient().DescribeWorkerDeployment(s.Context(), &workflowservice.DescribeWorkerDeploymentRequest{ @@ -1880,13 +1880,13 @@ func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Unversioned_PromoteUnversi // set ramp to unversioned s.setAndVerifyRampingVersionUnversionedOption(env, env.Tv(), true, false, 75, true, false, true, "") // check that the current version's task queues have ramping version == __unversioned__ - env.waitForTaskQueueVersioningInfo(s.T(), s.Context(), env.Tv().TaskQueue(), env.Tv().DeploymentVersionString(), worker_versioning.UnversionedVersionId, 75) + env.waitForTaskQueueVersioningInfo(s.Context(), s.T(), env.Tv().TaskQueue(), env.Tv().DeploymentVersionString(), worker_versioning.UnversionedVersionId, 75) // set current to unversioned s.setCurrentVersionUnversionedOption(env, env.Tv(), true, true, false, true, "") // check that the current version's task queues have ramping version == "" and current version == "__unversioned__" - env.waitForTaskQueueVersioningInfo(s.T(), s.Context(), env.Tv().TaskQueue(), worker_versioning.UnversionedVersionId, "", 0) + env.waitForTaskQueueVersioningInfo(s.Context(), s.T(), env.Tv().TaskQueue(), worker_versioning.UnversionedVersionId, "", 0) } func (s *WorkerDeploymentSuite) TestSetCurrentVersion_Concurrent_DifferentVersions_NoUnexpectedErrors() { @@ -2011,7 +2011,7 @@ func (s *WorkerDeploymentSuite) TestConcurrentPollers_DifferentTaskQueues_SameVe // verify that the task queues, eventually, have this version as the current version in their versioning info for i := range tqs { - env.waitForTaskQueueVersioningInfo(s.T(), s.Context(), env.Tv().WithTaskQueueNumber(i).TaskQueue(), env.Tv().DeploymentVersionString(), "", 0) + env.waitForTaskQueueVersioningInfo(s.Context(), s.T(), env.Tv().WithTaskQueueNumber(i).TaskQueue(), env.Tv().DeploymentVersionString(), "", 0) } } @@ -2361,7 +2361,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Unversione // check that the current version's task queues have ramping version == "" s.setCurrentVersion(env, env.Tv(), true, "") - env.waitForTaskQueueVersioningInfo(s.T(), s.Context(), env.Tv().TaskQueue(), env.Tv().DeploymentVersionString(), "", 0) + env.waitForTaskQueueVersioningInfo(s.Context(), s.T(), env.Tv().TaskQueue(), env.Tv().DeploymentVersionString(), "", 0) // set ramp to unversioned s.setAndVerifyRampingVersionUnversionedOption(env, env.Tv(), true, false, 75, true, false, true, "") @@ -2375,7 +2375,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_Unversione s.Equal(worker_versioning.UnversionedVersionId, resp.GetWorkerDeploymentInfo().GetRoutingConfig().GetRampingVersion()) // check that the current version's task queues have ramping version == __unversioned__ - env.waitForTaskQueueVersioningInfo(s.T(), s.Context(), env.Tv().TaskQueue(), env.Tv().DeploymentVersionString(), worker_versioning.UnversionedVersionId, 75) + env.waitForTaskQueueVersioningInfo(s.Context(), s.T(), env.Tv().TaskQueue(), env.Tv().DeploymentVersionString(), worker_versioning.UnversionedVersionId, 75) } func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentCurrentVersion_NoPollers() { @@ -2428,7 +2428,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentCurrentVersion_NoPollers( }, 10*time.Second, 100*time.Millisecond) // that poller's task queue should have the current versioning info - env.waitForTaskQueueVersioningInfo(s.T(), s.Context(), env.Tv().TaskQueue(), env.Tv().DeploymentVersionString(), "", 0) + env.waitForTaskQueueVersioningInfo(s.Context(), s.T(), env.Tv().TaskQueue(), env.Tv().DeploymentVersionString(), "", 0) } func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_NoPollers() { @@ -2484,7 +2484,7 @@ func (s *WorkerDeploymentSuite) TestSetWorkerDeploymentRampingVersion_NoPollers( }, 10*time.Second, 100*time.Millisecond) // that poller's task queue should have the ramping version info - env.waitForTaskQueueVersioningInfo(s.T(), s.Context(), env.Tv().TaskQueue(), worker_versioning.UnversionedVersionId, env.Tv().DeploymentVersionString(), 5) + env.waitForTaskQueueVersioningInfo(s.Context(), s.T(), env.Tv().TaskQueue(), worker_versioning.UnversionedVersionId, env.Tv().DeploymentVersionString(), 5) } func (s *WorkerDeploymentSuite) TestTwoPollers_EnsureCreateVersion() { From bf8f0228459fee093048509b18a49715c9856fc0 Mon Sep 17 00:00:00 2001 From: Stephan Behnke Date: Thu, 18 Jun 2026 17:08:12 -0700 Subject: [PATCH 27/27] lint --- tests/task_queue_stats_test.go | 8 ++++---- tests/versioning_test_env.go | 2 +- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/tests/task_queue_stats_test.go b/tests/task_queue_stats_test.go index 0d2162d22b9..22a2fde478e 100644 --- a/tests/task_queue_stats_test.go +++ b/tests/task_queue_stats_test.go @@ -1589,23 +1589,23 @@ func validateTaskQueueStatsStrict( } func validateTaskQueueStats( - require *require.Assertions, + a *require.Assertions, label string, stats *taskqueuepb.TaskQueueStats, expectation taskQueueExpectations, ) { // Actual counter can be greater than the expected due to history retries. We make sure the counter is in // range [expected, expected+maxBacklogExtraTasks] - require.GreaterOrEqual(stats.ApproximateBacklogCount, int64(expectation.BacklogCount), + a.GreaterOrEqual(stats.ApproximateBacklogCount, int64(expectation.BacklogCount), "%s: ApproximateBacklogCount should be at least %d, got %d", label, expectation.BacklogCount, stats.ApproximateBacklogCount) maxApproximateBacklogCount := int64(expectation.BacklogCount + expectation.MaxExtraTasks) - require.LessOrEqual(stats.ApproximateBacklogCount, maxApproximateBacklogCount, + a.LessOrEqual(stats.ApproximateBacklogCount, maxApproximateBacklogCount, "%s: ApproximateBacklogCount should be at most %d, got %d", label, maxApproximateBacklogCount, stats.ApproximateBacklogCount) - require.Equal(stats.ApproximateBacklogCount == 0, stats.ApproximateBacklogAge.AsDuration() == time.Duration(0), + a.Equal(stats.ApproximateBacklogCount == 0, stats.ApproximateBacklogAge.AsDuration() == time.Duration(0), "%s: ApproximateBacklogAge should be 0 when ApproximateBacklogCount is 0, got %s", label, stats.ApproximateBacklogAge.AsDuration()) } diff --git a/tests/versioning_test_env.go b/tests/versioning_test_env.go index 149c211c5fd..7a106de7b4c 100644 --- a/tests/versioning_test_env.go +++ b/tests/versioning_test_env.go @@ -44,7 +44,7 @@ func (env *VersioningTestEnv) waitForTaskQueueVersioningInfo( protorequire.ProtoEqual(t, worker_versioning.ExternalWorkerDeploymentVersionFromStringV31(expectedRampingVersion), resp.GetVersioningInfo().GetRampingDeploymentVersion()) require.Equal(t, expectedCurrentVersion, resp.GetVersioningInfo().GetCurrentVersion()) //nolint:staticcheck // SA1019: old worker versioning require.Equal(t, expectedRampingVersion, resp.GetVersioningInfo().GetRampingVersion()) //nolint:staticcheck // SA1019: old worker versioning - require.Equal(t, rampingPercentage, resp.GetVersioningInfo().GetRampingVersionPercentage()) + require.InDelta(t, rampingPercentage, resp.GetVersioningInfo().GetRampingVersionPercentage(), 0.001) }, 10*time.Second, 200*time.Millisecond) }