tasks/service/worker/deletenamespace/workflow_test.go at release/v1.27.x

mirror of https://github.com/hanzoai/tasks.git synced 2026-10-04 02:04:03 +00:00

Files

T

Alex ShtinandGitHub 570dc924bd Delete Namespace: fix validation of replicated namespace (#7069 )

## What changed?
<!-- Describe what has changed in this PR -->
Delete Namespace: fix validation of replicated namespace.

## Why?
<!-- Tell your future self why have you made these changes -->
Namespace should be deletable when:
1. It is active in the current cluster (even if replicated),
2. Doesn't belong to current cluster (current cluster was removed from
cluster list).

## How did you test it?
<!-- How have you verified this change? Tested locally? Added a unit
test? Checked in staging env? -->
Added new tests, existing tests, manual run.

## Potential risks
<!-- Assuming the worst case, what can be broken when deploying this
change to production? -->
No risks.

## Documentation
<!-- Have you made sure this change doesn't falsify anything currently
stated in `docs/`? If significant
new behavior is added, have you described that in `docs/`? -->
No.

## Is hotfix candidate?
<!-- Is this PR a hotfix candidate or does it require a notification to
be sent to the broader community? (Yes/No) -->
No.

2025-01-10 14:16:27 -08:00

308 lines

14 KiB

Go

Raw Permalink Blame History

 // The MIT License
 //
 // Copyright (c) 2020 Temporal Technologies Inc.  All rights reserved.
 //
 // Copyright (c) 2020 Uber Technologies, Inc.
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in
 // all copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 package deletenamespace
 import (
 	"testing"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
 	"go.temporal.io/sdk/temporal"
 	"go.temporal.io/sdk/testsuite"
 	"go.temporal.io/server/common/log"
 	"go.temporal.io/server/common/namespace"
 	"go.temporal.io/server/common/primitives"
 	"go.temporal.io/server/service/worker/deletenamespace/deleteexecutions"
 	"go.temporal.io/server/service/worker/deletenamespace/errors"
 	"go.temporal.io/server/service/worker/deletenamespace/reclaimresources"
 )
 func Test_DeleteNamespaceWorkflow_ByName(t *testing.T) {
 	testSuite := &testsuite.WorkflowTestSuite{}
 	testSuite.SetLogger(log.NewSdkLogger(log.NewTestLogger()))
 	env := testSuite.NewTestWorkflowEnvironment()
 	var la *localActivities
 	env.OnActivity(la.GetNamespaceInfoActivity, mock.Anything, namespace.EmptyID, namespace.Name("namespace")).Return(
 		getNamespaceInfoResult{
 			NamespaceID: "namespace-id",
 			Namespace:   "namespace",
 		}, nil).Once()
 	env.OnActivity(la.ValidateProtectedNamespacesActivity, mock.Anything, mock.Anything).Return(nil).Once()
 	env.OnActivity(la.ValidateNexusEndpointsActivity, mock.Anything, mock.Anything, mock.Anything).Return(nil).Once()
 	env.OnActivity(la.MarkNamespaceDeletedActivity, mock.Anything, namespace.Name("namespace")).Return(nil).Once()
 	env.OnActivity(la.GenerateDeletedNamespaceNameActivity, mock.Anything, namespace.ID("namespace-id"), namespace.Name("namespace")).Return(namespace.Name("namespace-delete-220878"), nil).Once()
 	env.OnActivity(la.RenameNamespaceActivity, mock.Anything, namespace.Name("namespace"), namespace.Name("namespace-delete-220878")).Return(nil).Once()
 	env.RegisterWorkflow(reclaimresources.ReclaimResourcesWorkflow)
 	env.OnWorkflow(reclaimresources.ReclaimResourcesWorkflow, mock.Anything, reclaimresources.ReclaimResourcesParams{DeleteExecutionsParams: deleteexecutions.DeleteExecutionsParams{
 		Namespace:   "namespace-delete-220878",
 		NamespaceID: "namespace-id",
 		Config: deleteexecutions.DeleteExecutionsConfig{
 			DeleteActivityRPS:                    100,
 			PageSize:                             1000,
 			PagesPerExecution:                    256,
 			ConcurrentDeleteExecutionsActivities: 4,
 		},
 		PreviousSuccessCount: 0,
 		PreviousErrorCount:   0,
 	}}).Return(reclaimresources.ReclaimResourcesResult{}, nil).
 		Once()
 	// Delete by name.
 	env.ExecuteWorkflow(DeleteNamespaceWorkflow, DeleteNamespaceWorkflowParams{
 		Namespace:              "namespace",
 		DeleteExecutionsConfig: deleteexecutions.DeleteExecutionsConfig{},
 	})
 	require.True(t, env.IsWorkflowCompleted())
 	require.NoError(t, env.GetWorkflowError())
 	var result DeleteNamespaceWorkflowResult
 	require.NoError(t, env.GetWorkflowResult(&result))
 	require.Equal(t, namespace.Name("namespace-delete-220878"), result.DeletedNamespace)
 	require.Equal(t, namespace.ID("namespace-id"), result.DeletedNamespaceID)
 }
 func Test_DeleteNamespaceWorkflow_ByID(t *testing.T) {
 	testSuite := &testsuite.WorkflowTestSuite{}
 	testSuite.SetLogger(log.NewSdkLogger(log.NewTestLogger()))
 	env := testSuite.NewTestWorkflowEnvironment()
 	var la *localActivities
 	env.OnActivity(la.GetNamespaceInfoActivity, mock.Anything, namespace.ID("namespace-id"), namespace.EmptyName).Return(
 		getNamespaceInfoResult{
 			NamespaceID: "namespace-id",
 			Namespace:   "namespace",
 		}, nil).Once()
 	env.OnActivity(la.ValidateProtectedNamespacesActivity, mock.Anything, mock.Anything).Return(nil).Once()
 	env.OnActivity(la.ValidateNexusEndpointsActivity, mock.Anything, mock.Anything, mock.Anything).Return(nil).Once()
 	env.OnActivity(la.MarkNamespaceDeletedActivity, mock.Anything, namespace.Name("namespace")).Return(nil).Once()
 	env.OnActivity(la.GenerateDeletedNamespaceNameActivity, mock.Anything, namespace.ID("namespace-id"), namespace.Name("namespace")).Return(namespace.Name("namespace-delete-220878"), nil).Once()
 	env.OnActivity(la.RenameNamespaceActivity, mock.Anything, namespace.Name("namespace"), namespace.Name("namespace-delete-220878")).Return(nil).Once()
 	env.RegisterWorkflow(reclaimresources.ReclaimResourcesWorkflow)
 	env.OnWorkflow(reclaimresources.ReclaimResourcesWorkflow, mock.Anything, reclaimresources.ReclaimResourcesParams{DeleteExecutionsParams: deleteexecutions.DeleteExecutionsParams{
 		Namespace:   "namespace-delete-220878",
 		NamespaceID: "namespace-id",
 		Config: deleteexecutions.DeleteExecutionsConfig{
 			DeleteActivityRPS:                    100,
 			PageSize:                             1000,
 			PagesPerExecution:                    256,
 			ConcurrentDeleteExecutionsActivities: 4,
 		},
 		PreviousSuccessCount: 0,
 		PreviousErrorCount:   0,
 	}}).Return(reclaimresources.ReclaimResourcesResult{}, nil).
 		Once()
 	// Delete by name.
 	env.ExecuteWorkflow(DeleteNamespaceWorkflow, DeleteNamespaceWorkflowParams{
 		NamespaceID: "namespace-id",
 	})
 	require.True(t, env.IsWorkflowCompleted())
 	require.NoError(t, env.GetWorkflowError())
 	var result DeleteNamespaceWorkflowResult
 	require.NoError(t, env.GetWorkflowResult(&result))
 	require.Equal(t, namespace.Name("namespace-delete-220878"), result.DeletedNamespace)
 	require.Equal(t, namespace.ID("namespace-id"), result.DeletedNamespaceID)
 }
 func Test_DeleteNamespaceWorkflow_ByNameAndID(t *testing.T) {
 	testSuite := &testsuite.WorkflowTestSuite{}
 	testSuite.SetLogger(log.NewSdkLogger(log.NewTestLogger()))
 	env := testSuite.NewTestWorkflowEnvironment()
 	// Delete by name and ID.
 	env.ExecuteWorkflow(DeleteNamespaceWorkflow, DeleteNamespaceWorkflowParams{
 		NamespaceID: "namespace-id",
 		Namespace:   "namespace",
 	})
 	require.True(t, env.IsWorkflowCompleted())
 	wfErr := env.GetWorkflowError()
 	require.Error(t, wfErr)
 	var applicationErr *temporal.ApplicationError
 	require.ErrorAs(t, wfErr, &applicationErr)
 }
 func Test_DeleteReplicatedNamespace(t *testing.T) {
 	testSuite := &testsuite.WorkflowTestSuite{}
 	var la *localActivities
 	t.Run("namespace that active in the current cluster should be deleted", func(t *testing.T) {
 		env := testSuite.NewTestWorkflowEnvironment()
 		env.OnActivity(la.GetNamespaceInfoActivity, mock.Anything, namespace.ID("namespace-id"), namespace.EmptyName).Return(
 			getNamespaceInfoResult{
 				NamespaceID:    "namespace-id",
 				Namespace:      "namespace",
 				Clusters:       []string{"active", "passive"},
 				ActiveCluster:  "active",
 				CurrentCluster: "active",
 			}, nil).Once()
 		env.OnActivity(la.ValidateProtectedNamespacesActivity, mock.Anything, mock.Anything).Return(nil).Once()
 		env.OnActivity(la.ValidateNexusEndpointsActivity, mock.Anything, mock.Anything, mock.Anything).Return(nil).Once()
 		env.OnActivity(la.MarkNamespaceDeletedActivity, mock.Anything, mock.Anything).Return(nil).Once()
 		env.OnActivity(la.GenerateDeletedNamespaceNameActivity, mock.Anything, mock.Anything, mock.Anything).Return(namespace.EmptyName, nil).Once()
 		env.OnActivity(la.RenameNamespaceActivity, mock.Anything, mock.Anything, mock.Anything).Return(nil).Once()
 		env.RegisterWorkflow(reclaimresources.ReclaimResourcesWorkflow)
 		env.OnWorkflow(reclaimresources.ReclaimResourcesWorkflow, mock.Anything, mock.Anything).Return(reclaimresources.ReclaimResourcesResult{}, nil).Once()
 		env.ExecuteWorkflow(DeleteNamespaceWorkflow, DeleteNamespaceWorkflowParams{
 			NamespaceID: "namespace-id",
 		})
 		require.True(t, env.IsWorkflowCompleted())
 		err := env.GetWorkflowError()
 		require.NoError(t, err)
 	})
 	t.Run("namespace that passive in the current cluster should NOT be deleted", func(t *testing.T) {
 		env := testSuite.NewTestWorkflowEnvironment()
 		env.OnActivity(la.GetNamespaceInfoActivity, mock.Anything, namespace.ID("namespace-id"), namespace.EmptyName).Return(
 			getNamespaceInfoResult{
 				NamespaceID:    "namespace-id",
 				Namespace:      "namespace",
 				Clusters:       []string{"active", "passive"},
 				ActiveCluster:  "active",
 				CurrentCluster: "passive",
 			}, nil).Once()
 		env.ExecuteWorkflow(DeleteNamespaceWorkflow, DeleteNamespaceWorkflowParams{
 			NamespaceID: "namespace-id",
 		})
 		require.True(t, env.IsWorkflowCompleted())
 		err := env.GetWorkflowError()
 		require.Error(t, err)
 		require.Contains(t, err.Error(), "namespace namespace is passive in current cluster passive: remove cluster passive from cluster list or make namespace active in this cluster and retry")
 	})
 	t.Run("namespace that doesn't have current cluster in the cluster list should be deleted", func(t *testing.T) {
 		env := testSuite.NewTestWorkflowEnvironment()
 		env.OnActivity(la.GetNamespaceInfoActivity, mock.Anything, namespace.ID("namespace-id"), namespace.EmptyName).Return(
 			getNamespaceInfoResult{
 				NamespaceID:    "namespace-id",
 				Namespace:      "namespace",
 				Clusters:       []string{"active", "passive"},
 				ActiveCluster:  "active",
 				CurrentCluster: "another-cluster",
 			}, nil).Once()
 		env.OnActivity(la.ValidateProtectedNamespacesActivity, mock.Anything, mock.Anything).Return(nil).Once()
 		env.OnActivity(la.ValidateNexusEndpointsActivity, mock.Anything, mock.Anything, mock.Anything).Return(nil).Once()
 		env.OnActivity(la.MarkNamespaceDeletedActivity, mock.Anything, mock.Anything).Return(nil).Once()
 		env.OnActivity(la.GenerateDeletedNamespaceNameActivity, mock.Anything, mock.Anything, mock.Anything).Return(namespace.EmptyName, nil).Once()
 		env.OnActivity(la.RenameNamespaceActivity, mock.Anything, mock.Anything, mock.Anything).Return(nil).Once()
 		env.RegisterWorkflow(reclaimresources.ReclaimResourcesWorkflow)
 		env.OnWorkflow(reclaimresources.ReclaimResourcesWorkflow, mock.Anything, mock.Anything).Return(reclaimresources.ReclaimResourcesResult{}, nil).Once()
 		env.ExecuteWorkflow(DeleteNamespaceWorkflow, DeleteNamespaceWorkflowParams{
 			NamespaceID: "namespace-id",
 		})
 		require.True(t, env.IsWorkflowCompleted())
 		err := env.GetWorkflowError()
 		require.NoError(t, err)
 	})
 }
 func Test_DeleteSystemNamespace(t *testing.T) {
 	testSuite := &testsuite.WorkflowTestSuite{}
 	env := testSuite.NewTestWorkflowEnvironment()
 	var la *localActivities
 	env.OnActivity(la.GetNamespaceInfoActivity, mock.Anything, namespace.EmptyID, namespace.Name(primitives.SystemLocalNamespace)).Return(
 		getNamespaceInfoResult{
 			NamespaceID: primitives.SystemNamespaceID,
 			Namespace:   primitives.SystemLocalNamespace,
 		}, nil).Once()
 	env.ExecuteWorkflow(DeleteNamespaceWorkflow, DeleteNamespaceWorkflowParams{
 		Namespace: primitives.SystemLocalNamespace,
 	})
 	require.True(t, env.IsWorkflowCompleted())
 	err := env.GetWorkflowError()
 	require.Error(t, err)
 	require.Contains(t, err.Error(), "unable to delete system namespace")
 }
 func Test_DeleteProtectedNamespace(t *testing.T) {
 	testSuite := &testsuite.WorkflowTestSuite{}
 	env := testSuite.NewTestWorkflowEnvironment()
 	la := &localActivities{
 		protectedNamespaces: func() []string {
 			return []string{"namespace"}
 		},
 	}
 	env.OnActivity(la.GetNamespaceInfoActivity, mock.Anything, namespace.ID("namespace-id"), namespace.EmptyName).Return(
 		getNamespaceInfoResult{
 			NamespaceID: "namespace-id",
 			Namespace:   "namespace",
 		}, nil).Once()
 	env.RegisterActivity(la.ValidateProtectedNamespacesActivity)
 	env.ExecuteWorkflow(DeleteNamespaceWorkflow, DeleteNamespaceWorkflowParams{
 		NamespaceID: "namespace-id",
 	})
 	require.True(t, env.IsWorkflowCompleted())
 	err := env.GetWorkflowError()
 	require.Error(t, err)
 	var appErr *temporal.ApplicationError
 	require.ErrorAs(t, err, &appErr)
 	require.Equal(t, appErr.Message(), "namespace namespace is protected from deletion")
 }
 func Test_DeleteNamespaceUsedByNexus(t *testing.T) {
 	testSuite := &testsuite.WorkflowTestSuite{}
 	env := testSuite.NewTestWorkflowEnvironment()
 	la := &localActivities{}
 	env.OnActivity(la.GetNamespaceInfoActivity, mock.Anything, namespace.ID("namespace-id"), namespace.EmptyName).Return(
 		getNamespaceInfoResult{
 			NamespaceID: "namespace-id",
 			Namespace:   "namespace",
 		}, nil).Once()
 	env.OnActivity(la.ValidateProtectedNamespacesActivity, mock.Anything, mock.Anything).Return(nil).Once()
 	env.OnActivity(la.ValidateNexusEndpointsActivity, mock.Anything, mock.Anything, mock.Anything).
 		Return(errors.NewFailedPrecondition("cannot delete a namespace that is a target of a Nexus endpoint", nil)).
 		Once()
 	env.ExecuteWorkflow(DeleteNamespaceWorkflow, DeleteNamespaceWorkflowParams{
 		NamespaceID: "namespace-id",
 	})
 	require.True(t, env.IsWorkflowCompleted())
 	err := env.GetWorkflowError()
 	require.Error(t, err)
 	var appErr *temporal.ApplicationError
 	require.ErrorAs(t, err, &appErr)
 	require.Equal(t, appErr.Message(), "cannot delete a namespace that is a target of a Nexus endpoint")
 }

308 lines 14 KiB Go Raw Permalink Blame History

308 lines

14 KiB

Go

Raw Permalink Blame History