fix(tests): migrate NexusApiTestSuite to parallelsuite, fix versioning flag and query pagination (#9910)

## What changed?

Two test fixes targeting consistent CI failures across all recent runs,
plus a migration of `NexusApiTestSuite` to `parallelsuite`.

## Why?

Both failures reproduced in 9–10/10 of the last 10 CI runs:

**1.
`TestNexusStartOperation_WithNamespaceAndTaskQueue_SupportsVersioning`**
(10/10 runs)
The test calls `UpdateWorkerBuildIdCompatibility`, which is the v0.1
(Version Set / Build ID compat) API gated by
`FrontendEnableWorkerVersioningDataAPIs`. The test only enabled
`FrontendEnableWorkerVersioningRuleAPIs` (the v0.2 Rules API), so the
v0.1 call was rejected with a `PermissionDenied` error.

**2. `TestQueryWorkflow_NonStickyMultiPageHistory`** (9/10 runs)
The test asserted `NextPageToken != nil` after fetching workflow
history. The shared functional test cluster sets
`SendRawHistoryBetweenInternalServices=true` (in
`tests/testcore/dynamic_config_overrides.go`), which causes the history
service to return all events in one shot — making `NextPageToken` always
nil regardless of the `MatchingHistoryMaxPageSize=2` override.

## How did you test it?

**Fix 1 — nexus versioning test (`tests/nexus_api_test.go`):**
Added
`env.OverrideDynamicConfig(dynamicconfig.FrontendEnableWorkerVersioningDataAPIs,
true)` alongside the existing `RuleAPIs` override so the v0.1 API is
available for the test.

Also migrated `NexusApiTestSuite` from the custom `NexusTestBaseSuite`
(which used a `useTemporalFailures` field mutated before `suite.Run`) to
`parallelsuite.Suite[*NexusApiTestSuite]`. The `useTemporalFailures`
flag is now a typed parameter passed through `parallelsuite.Run`,
eliminating shared mutable state between the two suite invocations.

**Fix 2 — query pagination test (`tests/query_workflow_test.go`):**
Extracted `TestQueryWorkflow_NonStickyMultiPageHistory` from
`QueryWorkflowSuite` into a standalone top-level test that uses
`testcore.NewEnv` with:
- `testcore.WithDedicatedCluster()` — isolated cluster not affected by
the global config override
-
`testcore.WithDynamicConfig(dynamicconfig.SendRawHistoryBetweenInternalServices,
false)` — disables raw history so pagination happens normally
- `testcore.WithDynamicConfig(dynamicconfig.MatchingHistoryMaxPageSize,
2)` — forces multi-page history

- [x] built
- [x] added new functional test(s) (standalone query test)
- [x] covered by existing tests (nexus suite)

## Potential risks

The `NexusApiTestSuite` migration to `parallelsuite` changes how
`useTemporalFailures` is threaded through tests. The two existing
top-level runners (`TestNexusApiTestSuiteWithLegacyErrorPaths` /
`WithTemporalFailures`) are preserved; the flag is now a
compile-time-checked parameter rather than a struct field.

Author: spkane31

tests/nexus_api_test.go

@@ -610,8 +610,13 @@ func (s *NexusApiTestSuite) TestNexusCancelOperation_Outcomes(useTemporalFailure
 }
 
 func (s *NexusApiTestSuite) TestNexusStartOperation_WithNamespaceAndTaskQueue_SupportsVersioning(useTemporalFailures bool) {
-	env := newNexusTestEnv(s.T(), useTemporalFailures, testcore.WithDedicatedCluster())
-	env.OverrideDynamicConfig(dynamicconfig.FrontendEnableWorkerVersioningRuleAPIs, true)
+	env := newNexusTestEnv(s.T(), useTemporalFailures,
+		testcore.WithDedicatedCluster(),
+		testcore.WithDynamicConfig(dynamicconfig.FrontendEnableWorkerVersioningRuleAPIs, true),
+		// UpdateWorkerBuildIdCompatibility is the v0.1 (Version Set-based) API gated by DataAPIs.
+		testcore.WithDynamicConfig(dynamicconfig.FrontendEnableWorkerVersioningDataAPIs, true),
+	)
+
 	ctx, cancel := context.WithCancel(testcore.NewContext())
 	defer cancel()
 	taskQueue := testcore.RandomizeStr("task-queue")

tests/nexus_test_base.go

@@ -47,6 +47,13 @@ func (env *NexusTestEnv) createNexusEndpoint(t *testing.T, name string, taskQueu
 		},
 	})
 	require.NoError(t, err)
+	t.Cleanup(func() {
+		// Delete the endpoint so the cluster can be safely reused by subsequent tests.
+		_, _ = env.OperatorClient().DeleteNexusEndpoint(testcore.NewContext(), &operatorservice.DeleteNexusEndpointRequest{
+			Id:      resp.Endpoint.Id,
+			Version: resp.Endpoint.Version,
+		})
+	})
 	return resp.Endpoint
 }
 

tests/query_workflow_test.go

@@ -343,11 +343,18 @@ func (s *QueryWorkflowSuite) TestQueryWorkflow_ClosedWithoutWorkflowTaskStarted(
 // non-sticky query task poll is a valid HistoryContinuation token usable with
 // GetWorkflowExecutionHistory. Fails with "Invalid NextPageToken" if matching service
 // returns a RawHistoryContinuation token instead.
-func (s *QueryWorkflowSuite) TestQueryWorkflow_NonStickyMultiPageHistory() {
-	// Small page size forces pagination in matching service.
-	s.OverrideDynamicConfig(dynamicconfig.MatchingHistoryMaxPageSize, 2)
-
-	s.SdkWorker().Stop()
+//
+// Uses a dedicated cluster with MatchingHistoryMaxPageSize=2. With the default
+// SendRawHistoryBetweenInternalServices=true, the raw blob path paginates at the blob
+// level: ReadFullPageRawEvents stops after 2 blobs, leaving a non-empty PersistenceToken
+// even when all events fit in a single Cassandra logical page. This ensures NextPageToken
+// is non-empty, which is what we need to verify it's a valid HistoryContinuation token.
+func TestQueryWorkflow_NonStickyMultiPageHistory(t *testing.T) {
+	t.Parallel()
+	env := testcore.NewEnv(t,
+		testcore.WithDedicatedCluster(),
+		testcore.WithDynamicConfig(dynamicconfig.MatchingHistoryMaxPageSize, 2),
+	)
 
 	activityFn := func(ctx context.Context) error { return nil }
 	workflowFn := func(ctx workflow.Context) (string, error) {
@@ -365,27 +372,28 @@ func (s *QueryWorkflowSuite) TestQueryWorkflow_NonStickyMultiPageHistory() {
 		return "done", nil
 	}
 
+	tq := env.WorkerTaskQueue()
 	id := "test-query-non-sticky-multi-page"
-	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	ctx, cancel := context.WithTimeout(env.Context(), 30*time.Second)
 	defer cancel()
 
-	queryWorker := worker.New(s.SdkClient(), s.TaskQueue(), worker.Options{})
+	queryWorker := worker.New(env.SdkClient(), tq, worker.Options{})
 	queryWorker.RegisterWorkflow(workflowFn)
 	queryWorker.RegisterActivity(activityFn)
-	s.NoError(queryWorker.Start())
+	env.NoError(queryWorker.Start())
 
-	workflowRun, err := s.SdkClient().ExecuteWorkflow(ctx, sdkclient.StartWorkflowOptions{
+	workflowRun, err := env.SdkClient().ExecuteWorkflow(ctx, sdkclient.StartWorkflowOptions{
 		ID:                 id,
-		TaskQueue:          s.TaskQueue(),
+		TaskQueue:          tq,
 		WorkflowRunTimeout: 20 * time.Second,
 	}, workflowFn)
-	s.NoError(err)
-	s.NotNil(workflowRun)
+	env.NoError(err)
+	env.NotNil(workflowRun)
 
 	// Wait for all activities to complete, generating many event batches.
-	s.Eventually(func() bool {
-		resp, err := s.FrontendClient().DescribeWorkflowExecution(ctx, &workflowservice.DescribeWorkflowExecutionRequest{
-			Namespace: s.Namespace().String(),
+	env.Eventually(func() bool {
+		resp, err := env.FrontendClient().DescribeWorkflowExecution(ctx, &workflowservice.DescribeWorkflowExecutionRequest{
+			Namespace: env.Namespace().String(),
 			Execution: &commonpb.WorkflowExecution{WorkflowId: id},
 		})
 		return err == nil && resp.GetWorkflowExecutionInfo().GetHistoryLength() > 10
@@ -395,33 +403,34 @@ func (s *QueryWorkflowSuite) TestQueryWorkflow_NonStickyMultiPageHistory() {
 	queryWorker.Stop()
 
 	// Issue a query in background; we'll poll for the task manually below.
-	go func() { _, _ = s.SdkClient().QueryWorkflow(ctx, id, "", "test") }()
+	// Don't assert inside the goroutine — it would panic if the test completes first.
+	go func() { _, _ = env.SdkClient().QueryWorkflow(ctx, id, "", "test") }()
 
 	// Poll for the query task on the normal (non-sticky) task queue.
 	var pollResp *workflowservice.PollWorkflowTaskQueueResponse
-	s.Eventually(func() bool {
+	env.Eventually(func() bool {
 		pollCtx, pollCancel := context.WithTimeout(ctx, 3*time.Second)
 		defer pollCancel()
-		pollResp, err = s.FrontendClient().PollWorkflowTaskQueue(pollCtx, &workflowservice.PollWorkflowTaskQueueRequest{
-			Namespace: s.Namespace().String(),
-			TaskQueue: &taskqueuepb.TaskQueue{Name: s.TaskQueue(), Kind: enumspb.TASK_QUEUE_KIND_NORMAL},
+		pollResp, err = env.FrontendClient().PollWorkflowTaskQueue(pollCtx, &workflowservice.PollWorkflowTaskQueueRequest{
+			Namespace: env.Namespace().String(),
+			TaskQueue: &taskqueuepb.TaskQueue{Name: tq, Kind: enumspb.TASK_QUEUE_KIND_NORMAL},
 			Identity:  "test-worker",
 		})
 		return err == nil && len(pollResp.GetTaskToken()) > 0
 	}, 10*time.Second, 100*time.Millisecond)
 
-	s.NotNil(pollResp.GetHistory())
-	s.NotEmpty(pollResp.GetNextPageToken(), "multi-page history should have NextPageToken")
+	env.NotNil(pollResp.GetHistory())
+	env.NotEmpty(pollResp.GetNextPageToken(), "multi-page history should have NextPageToken")
 
 	// Use the token with GetWorkflowExecutionHistory — this is what the worker SDK does.
 	// Fails with "Invalid NextPageToken" if the token is a RawHistoryContinuation.
-	histResp, err := s.FrontendClient().GetWorkflowExecutionHistory(ctx, &workflowservice.GetWorkflowExecutionHistoryRequest{
-		Namespace:     s.Namespace().String(),
+	histResp, err := env.FrontendClient().GetWorkflowExecutionHistory(ctx, &workflowservice.GetWorkflowExecutionHistoryRequest{
+		Namespace:     env.Namespace().String(),
 		Execution:     &commonpb.WorkflowExecution{WorkflowId: id},
 		NextPageToken: pollResp.GetNextPageToken(),
 	})
-	s.NoError(err)
-	s.NotNil(histResp)
+	env.NoError(err)
+	env.NotNil(histResp)
 }
 
 func (s *QueryWorkflowSuite) TestQueryWorkflow_FailurePropagated() {