test: tolerate namespace not found errors

coderzc · coderzc · commit 5bdb1bf52714 · 2026-03-16T10:35:33.000+08:00
diff --git a/pkg/ctl/namespace/clear_backlog_test.go b/pkg/ctl/namespace/clear_backlog_test.go
@@ -72,10 +72,10 @@ func TestClearBacklogOnNonExistingNs(t *testing.T) {
 	args := []string{"clear-backlog", "-f", "--bundle", "0xc0000000_0xffffffff", ns}
 	_, execErr, _, _ := TestNamespaceCommands(ClearBacklogCmd, args)
 	assert.NotNil(t, execErr)
-	assert.Equal(t, "code: 404 reason: Namespace does not exist", execErr.Error())
+	assertNamespaceNotExistError(t, execErr)
 
 	args = []string{"clear-backlog", "-f", "--sub", "sub", "--bundle", "0xc0000000_0xffffffff", ns}
 	_, execErr, _, _ = TestNamespaceCommands(ClearBacklogCmd, args)
 	assert.NotNil(t, execErr)
-	assert.Equal(t, "code: 404 reason: Namespace does not exist", execErr.Error())
+	assertNamespaceNotExistError(t, execErr)
 }
diff --git a/pkg/ctl/namespace/compaction_threshold_test.go b/pkg/ctl/namespace/compaction_threshold_test.go
@@ -58,13 +58,13 @@ func TestSetCompactionThresholdOnNonExistingNs(t *testing.T) {
 	args := []string{"set-compaction-threshold", "--size", "10m", ns}
 	_, execErr, _, _ := TestNamespaceCommands(SetCompactionThresholdCmd, args)
 	assert.NotNil(t, execErr)
-	assert.Equal(t, "code: 404 reason: Namespace does not exist", execErr.Error())
+	assertNamespaceNotExistError(t, execErr)
 }
 
 func TestGetCompactionThresholdOnNonExistingNs(t *testing.T) {
 	ns := "public/non-existing-namespace"
 	args := []string{"get-compaction-threshold", ns}
 	_, execErr, _, _ := TestNamespaceCommands(GetCompactionThresholdCmd, args)
 	assert.NotNil(t, execErr)
-	assert.Equal(t, "code: 404 reason: Namespace does not exist", execErr.Error())
+	assertNamespaceNotExistError(t, execErr)
 }
diff --git a/pkg/ctl/namespace/dispatch_rate_test.go b/pkg/ctl/namespace/dispatch_rate_test.go
@@ -112,5 +112,5 @@ func TestGetDispatchRateOnNonExistingNs(t *testing.T) {
 	args := []string{"get-dispatch-rate", ns}
 	_, execErr, _, _ := TestNamespaceCommands(GetDispatchRateCmd, args)
 	assert.NotNil(t, execErr)
-	assert.Equal(t, "code: 404 reason: Namespace does not exist", execErr.Error())
+	assertNamespaceNotExistError(t, execErr)
 }
diff --git a/pkg/ctl/namespace/max_consumers_per_subscription_test.go b/pkg/ctl/namespace/max_consumers_per_subscription_test.go
@@ -57,7 +57,7 @@ func TestSetMaxConsumersPerSubscriptionOnNonExistingTopic(t *testing.T) {
 	args := []string{"set-max-consumers-per-subscription", "--size", "10", ns}
 	_, execErr, _, _ := TestNamespaceCommands(SetMaxConsumersPerSubscriptionCmd, args)
 	assert.NotNil(t, execErr)
-	assert.Equal(t, "code: 404 reason: Namespace does not exist", execErr.Error())
+	assertNamespaceNotExistError(t, execErr)
 }
 
 func TestSetMaxConsumersPerSubscriptionWithInvalidSize(t *testing.T) {
@@ -72,5 +72,5 @@ func TestGetMaxConsumersPerSubscriptionOnNonExistingTopic(t *testing.T) {
 	args := []string{"get-max-consumers-per-subscription", ns}
 	_, execErr, _, _ := TestNamespaceCommands(GetMaxConsumersPerSubscriptionCmd, args)
 	assert.NotNil(t, execErr)
-	assert.Equal(t, "code: 404 reason: Namespace does not exist", execErr.Error())
+	assertNamespaceNotExistError(t, execErr)
 }
diff --git a/pkg/ctl/namespace/max_consumers_per_topic_test.go b/pkg/ctl/namespace/max_consumers_per_topic_test.go
@@ -57,7 +57,7 @@ func TestSetMaxConsumersPerTopicOnNonExistingTopic(t *testing.T) {
 	args := []string{"set-max-consumers-per-topic", "--size", "10", ns}
 	_, execErr, _, _ := TestNamespaceCommands(SetMaxConsumersPerTopicCmd, args)
 	assert.NotNil(t, execErr)
-	assert.Equal(t, "code: 404 reason: Namespace does not exist", execErr.Error())
+	assertNamespaceNotExistError(t, execErr)
 }
 
 func TestSetMaxConsumersPerTopicWithInvalidSize(t *testing.T) {
@@ -72,5 +72,5 @@ func TestGetMaxConsumersPerTopicOnNonExistingTopic(t *testing.T) {
 	args := []string{"get-max-consumers-per-topic", ns}
 	_, execErr, _, _ := TestNamespaceCommands(GetMaxConsumersPerTopicCmd, args)
 	assert.NotNil(t, execErr)
-	assert.Equal(t, "code: 404 reason: Namespace does not exist", execErr.Error())
+	assertNamespaceNotExistError(t, execErr)
 }
diff --git a/pkg/ctl/namespace/max_producers_per_topic_test.go b/pkg/ctl/namespace/max_producers_per_topic_test.go
@@ -57,7 +57,7 @@ func TestSetMaxProducersPerTopicOnNonExistingTopic(t *testing.T) {
 	args := []string{"set-max-producers-per-topic", "--size", "10", ns}
 	_, execErr, _, _ := TestNamespaceCommands(SetMaxProducersPerTopicCmd, args)
 	assert.NotNil(t, execErr)
-	assert.Equal(t, "code: 404 reason: Namespace does not exist", execErr.Error())
+	assertNamespaceNotExistError(t, execErr)
 }
 
 func TestSetMaxProducersPerTopicWithInvalidSize(t *testing.T) {
@@ -72,5 +72,5 @@ func TestGetMaxProducersPerTopicOnNonExistingTopic(t *testing.T) {
 	args := []string{"get-max-producers-per-topic", ns}
 	_, execErr, _, _ := TestNamespaceCommands(GetMaxProducersPerTopicCmd, args)
 	assert.NotNil(t, execErr)
-	assert.Equal(t, "code: 404 reason: Namespace does not exist", execErr.Error())
+	assertNamespaceNotExistError(t, execErr)
 }
diff --git a/pkg/ctl/namespace/offload_deletion_test.go b/pkg/ctl/namespace/offload_deletion_test.go
@@ -72,21 +72,21 @@ func TestOffloadDeletionLagOnNonExistingNs(t *testing.T) {
 	args := []string{"set-offload-deletion-lag", "--lag", "10m", ns}
 	_, execErr, _, _ := TestNamespaceCommands(SetOffloadDeletionLagCmd, args)
 	assert.NotNil(t, execErr)
-	assert.Equal(t, "code: 404 reason: Namespace does not exist", execErr.Error())
+	assertNamespaceNotExistError(t, execErr)
 }
 
 func TestGetOfloadThresholdOnNonExistingNs(t *testing.T) {
 	ns := "public/non-existing-namespace"
 	args := []string{"get-offload-deletion-lag", ns}
 	_, execErr, _, _ := TestNamespaceCommands(GetOffloadDeletionLagCmd, args)
 	assert.NotNil(t, execErr)
-	assert.Equal(t, "code: 404 reason: Namespace does not exist", execErr.Error())
+	assertNamespaceNotExistError(t, execErr)
 }
 
 func TestClearOffloadDeletionLagOnNonExistingNs(t *testing.T) {
 	ns := "public/non-existing-namespace"
 	args := []string{"clear-offload-deletion-lag", ns}
 	_, execErr, _, _ := TestNamespaceCommands(ClearOffloadDeletionLagCmd, args)
 	assert.NotNil(t, execErr)
-	assert.Equal(t, "code: 404 reason: Namespace does not exist", execErr.Error())
+	assertNamespaceNotExistError(t, execErr)
 }
diff --git a/pkg/ctl/namespace/offload_threshold_test.go b/pkg/ctl/namespace/offload_threshold_test.go
@@ -57,13 +57,13 @@ func TestSetOffloadThresholdOnNonExistingNs(t *testing.T) {
 	args := []string{"set-offload-threshold", "--size", "10m", ns}
 	_, execErr, _, _ := TestNamespaceCommands(SetOffloadThresholdCmd, args)
 	assert.NotNil(t, execErr)
-	assert.Equal(t, "code: 404 reason: Namespace does not exist", execErr.Error())
+	assertNamespaceNotExistError(t, execErr)
 }
 
 func TestGetOffloadThresholdOnNonExistingNs(t *testing.T) {
 	ns := "public/non-existing-namespace"
 	args := []string{"get-offload-threshold", ns}
 	_, execErr, _, _ := TestNamespaceCommands(GetOffloadThresholdCmd, args)
 	assert.NotNil(t, execErr)
-	assert.Equal(t, "code: 404 reason: Namespace does not exist", execErr.Error())
+	assertNamespaceNotExistError(t, execErr)
 }
diff --git a/pkg/ctl/namespace/policies_test.go b/pkg/ctl/namespace/policies_test.go
@@ -62,12 +62,12 @@ func TestPolicesNonExistTenant(t *testing.T) {
 	args := []string{"policies", "non-existent-tenant/default"}
 	_, execErr, _, _ := TestNamespaceCommands(getPolicies, args)
 	assert.NotNil(t, execErr)
-	assert.Equal(t, "code: 404 reason: Namespace does not exist", execErr.Error())
+	assertNamespaceNotExistError(t, execErr)
 }
 
 func TestPolicesNonExistNs(t *testing.T) {
 	args := []string{"policies", "public/test-not-exist-ns"}
 	_, execErr, _, _ := TestNamespaceCommands(getPolicies, args)
 	assert.NotNil(t, execErr)
-	assert.Equal(t, "code: 404 reason: Namespace does not exist", execErr.Error())
+	assertNamespaceNotExistError(t, execErr)
 }
diff --git a/pkg/ctl/namespace/publish_rate_test.go b/pkg/ctl/namespace/publish_rate_test.go
@@ -102,5 +102,5 @@ func TestGetPublishRateOnNonExistingNs(t *testing.T) {
 	args := []string{"get-publish-rate", ns}
 	_, execErr, _, _ := TestNamespaceCommands(GetPublishRateCmd, args)
 	assert.NotNil(t, execErr)
-	assert.Equal(t, "code: 404 reason: Namespace does not exist", execErr.Error())
+	assertNamespaceNotExistError(t, execErr)
 }
diff --git a/pkg/ctl/namespace/schema_autoupdate_strategy_test.go b/pkg/ctl/namespace/schema_autoupdate_strategy_test.go
@@ -76,13 +76,13 @@ func TestSetSchemaAutoUpdateStrategyOnNonExistingNs(t *testing.T) {
 	args := []string{"set-schema-autoupdate-strategy", ns}
 	_, execErr, _, _ := TestNamespaceCommands(SetSchemaAutoUpdateStrategyCmd, args)
 	assert.NotNil(t, execErr)
-	assert.Equal(t, "code: 404 reason: Namespace does not exist", execErr.Error())
+	assertNamespaceNotExistError(t, execErr)
 }
 
 func TestGetSchemaAutoUpdateStrategyOnNonExistingNs(t *testing.T) {
 	ns := "public/non-existing-namespace"
 	args := []string{"get-schema-autoupdate-strategy", ns}
 	_, execErr, _, _ := TestNamespaceCommands(GetSchemaAutoUpdateStrategyCmd, args)
 	assert.NotNil(t, execErr)
-	assert.Equal(t, "code: 404 reason: Namespace does not exist", execErr.Error())
+	assertNamespaceNotExistError(t, execErr)
 }
diff --git a/pkg/ctl/namespace/schema_validation_enforce_test.go b/pkg/ctl/namespace/schema_validation_enforce_test.go
@@ -51,13 +51,13 @@ func TestSetSchemaValidationEnforcedOnNonExistingNs(t *testing.T) {
 	args := []string{"set-schema-validation-enforced", ns}
 	_, execErr, _, _ := TestNamespaceCommands(SetSchemaValidationEnforcedCmd, args)
 	assert.NotNil(t, execErr)
-	assert.Equal(t, "code: 404 reason: Namespace does not exist", execErr.Error())
+	assertNamespaceNotExistError(t, execErr)
 }
 
 func TestGetSchemaValidationEnforcedOnNonExistingNs(t *testing.T) {
 	ns := "public/non-existing-namespace"
 	args := []string{"get-schema-validation-enforced", ns}
 	_, execErr, _, _ := TestNamespaceCommands(GetSchemaValidationEnforcedCmd, args)
 	assert.NotNil(t, execErr)
-	assert.Equal(t, "code: 404 reason: Namespace does not exist", execErr.Error())
+	assertNamespaceNotExistError(t, execErr)
 }
diff --git a/pkg/ctl/namespace/set_subscription_auth_mode_test.go b/pkg/ctl/namespace/set_subscription_auth_mode_test.go
@@ -76,8 +76,7 @@ func TestSetSubscriptionAuthModeOnNonExistingNs(t *testing.T) {
 
 	args := []string{"set-subscription-auth-mode", "--mode", "Prefix", ns}
 	_, execErr, _, _ := TestNamespaceCommands(SetSubscriptionAuthModeCmd, args)
-	assert.NotNil(t, execErr)
-	assert.Equal(t, "code: 404 reason: Namespace does not exist", execErr.Error())
+	assertNamespaceNotExistError(t, execErr)
 }
 
 func TestSetSubscriptionAuthModeWithInvalidMode(t *testing.T) {
diff --git a/pkg/ctl/namespace/subscribe_rate_test.go b/pkg/ctl/namespace/subscribe_rate_test.go
@@ -105,5 +105,5 @@ func TestGetSubscribeRateOnNonExistingNs(t *testing.T) {
 	args := []string{"get-subscribe-rate", ns}
 	_, execErr, _, _ := TestNamespaceCommands(GetSubscribeRateCmd, args)
 	assert.NotNil(t, execErr)
-	assert.Equal(t, "code: 404 reason: Namespace does not exist", execErr.Error())
+	assertNamespaceNotExistError(t, execErr)
 }
diff --git a/pkg/ctl/namespace/subscription_dispatch_rate_test.go b/pkg/ctl/namespace/subscription_dispatch_rate_test.go
@@ -111,5 +111,5 @@ func TestGetSubscriptionDispatchRateOnNonExistingNs(t *testing.T) {
 	args := []string{"get-subscription-dispatch-rate", ns}
 	_, execErr, _, _ := TestNamespaceCommands(GetSubscriptionDispatchRateCmd, args)
 	assert.NotNil(t, execErr)
-	assert.Equal(t, "code: 404 reason: Namespace does not exist", execErr.Error())
+	assertNamespaceNotExistError(t, execErr)
 }
diff --git a/pkg/ctl/namespace/test_help.go b/pkg/ctl/namespace/test_help.go
@@ -19,13 +19,31 @@ package namespace
 
 import (
 	"bytes"
+	"testing"
 
 	"github.com/streamnative/pulsarctl/pkg/cmdutils"
 
 	"github.com/kris-nova/logger"
 	"github.com/spf13/cobra"
+	"github.com/stretchr/testify/assert"
 )
 
+func assertNamespaceNotExistError(t *testing.T, err error) {
+	t.Helper()
+
+	if !assert.Error(t, err) {
+		return
+	}
+
+	assert.Contains(t,
+		[]string{
+			"code: 404 reason: Namespace does not exist",
+			"code: 404 reason: Namespace not found",
+		},
+		err.Error(),
+	)
+}
+
 func TestNamespaceCommands(newVerb func(cmd *cmdutils.VerbCmd), args []string) (out *bytes.Buffer,
 	execErr, nameErr, err error) {
 	var execError error
diff --git a/pkg/ctl/namespace/topics_test.go b/pkg/ctl/namespace/topics_test.go
@@ -46,12 +46,12 @@ func TestListNonExistNamespace(t *testing.T) {
 	args := []string{"topics", "public/non-exist-namespace"}
 	_, execErr, _, _ := TestNamespaceCommands(getTopics, args)
 	assert.NotNil(t, execErr)
-	assert.Equal(t, "code: 404 reason: Namespace does not exist", execErr.Error())
+	assertNamespaceNotExistError(t, execErr)
 }
 
 func TestListNonExistTenant(t *testing.T) {
 	args := []string{"topics", "non-exist-tenant/default"}
 	_, execErr, _, _ := TestNamespaceCommands(getTopics, args)
 	assert.NotNil(t, execErr)
-	assert.Equal(t, "code: 404 reason: Namespace does not exist", execErr.Error())
+	assertNamespaceNotExistError(t, execErr)
 }
diff --git a/pkg/ctl/namespace/unsubscribe_test.go b/pkg/ctl/namespace/unsubscribe_test.go
@@ -66,6 +66,5 @@ func TestUnsubscribeOnNonExistingNs(t *testing.T) {
 
 	args := []string{"unsubscribe", "--bundle", "0xc0000000_0xffffffff", ns, "non-existing-sub"}
 	_, execErr, _, _ := TestNamespaceCommands(UnsubscribeCmd, args)
-	assert.NotNil(t, execErr)
-	assert.Equal(t, "code: 404 reason: Namespace does not exist", execErr.Error())
+	assertNamespaceNotExistError(t, execErr)
 }

Original file line number	Diff line number	Diff line change
`@@ -112,5 +112,5 @@ func TestGetDispatchRateOnNonExistingNs(t *testing.T) {`
`112`	`112`	`args := []string{"get-dispatch-rate", ns}`
`113`	`113`	`_, execErr, _, _ := TestNamespaceCommands(GetDispatchRateCmd, args)`
`114`	`114`	`assert.NotNil(t, execErr)`
`115`		`- assert.Equal(t, "code: 404 reason: Namespace does not exist", execErr.Error())`
	`115`	`+ assertNamespaceNotExistError(t, execErr)`
`116`	`116`	`}`
Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@ func TestSetMaxConsumersPerSubscriptionOnNonExistingTopic(t *testing.T) {`
`57`	`57`	`args := []string{"set-max-consumers-per-subscription", "--size", "10", ns}`
`58`	`58`	`_, execErr, _, _ := TestNamespaceCommands(SetMaxConsumersPerSubscriptionCmd, args)`
`59`	`59`	`assert.NotNil(t, execErr)`
`60`		`- assert.Equal(t, "code: 404 reason: Namespace does not exist", execErr.Error())`
	`60`	`+ assertNamespaceNotExistError(t, execErr)`
`61`	`61`	`}`
`62`	`62`
`63`	`63`	`func TestSetMaxConsumersPerSubscriptionWithInvalidSize(t *testing.T) {`
`@@ -72,5 +72,5 @@ func TestGetMaxConsumersPerSubscriptionOnNonExistingTopic(t *testing.T) {`
`72`	`72`	`args := []string{"get-max-consumers-per-subscription", ns}`
`73`	`73`	`_, execErr, _, _ := TestNamespaceCommands(GetMaxConsumersPerSubscriptionCmd, args)`
`74`	`74`	`assert.NotNil(t, execErr)`
`75`		`- assert.Equal(t, "code: 404 reason: Namespace does not exist", execErr.Error())`
	`75`	`+ assertNamespaceNotExistError(t, execErr)`
`76`	`76`	`}`
Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@ func TestSetMaxProducersPerTopicOnNonExistingTopic(t *testing.T) {`
`57`	`57`	`args := []string{"set-max-producers-per-topic", "--size", "10", ns}`
`58`	`58`	`_, execErr, _, _ := TestNamespaceCommands(SetMaxProducersPerTopicCmd, args)`
`59`	`59`	`assert.NotNil(t, execErr)`
`60`		`- assert.Equal(t, "code: 404 reason: Namespace does not exist", execErr.Error())`
	`60`	`+ assertNamespaceNotExistError(t, execErr)`
`61`	`61`	`}`
`62`	`62`
`63`	`63`	`func TestSetMaxProducersPerTopicWithInvalidSize(t *testing.T) {`
`@@ -72,5 +72,5 @@ func TestGetMaxProducersPerTopicOnNonExistingTopic(t *testing.T) {`
`72`	`72`	`args := []string{"get-max-producers-per-topic", ns}`
`73`	`73`	`_, execErr, _, _ := TestNamespaceCommands(GetMaxProducersPerTopicCmd, args)`
`74`	`74`	`assert.NotNil(t, execErr)`
`75`		`- assert.Equal(t, "code: 404 reason: Namespace does not exist", execErr.Error())`
	`75`	`+ assertNamespaceNotExistError(t, execErr)`
`76`	`76`	`}`
Original file line number	Diff line number	Diff line change
`@@ -62,12 +62,12 @@ func TestPolicesNonExistTenant(t *testing.T) {`
`62`	`62`	`args := []string{"policies", "non-existent-tenant/default"}`
`63`	`63`	`_, execErr, _, _ := TestNamespaceCommands(getPolicies, args)`
`64`	`64`	`assert.NotNil(t, execErr)`
`65`		`- assert.Equal(t, "code: 404 reason: Namespace does not exist", execErr.Error())`
	`65`	`+ assertNamespaceNotExistError(t, execErr)`
`66`	`66`	`}`
`67`	`67`
`68`	`68`	`func TestPolicesNonExistNs(t *testing.T) {`
`69`	`69`	`args := []string{"policies", "public/test-not-exist-ns"}`
`70`	`70`	`_, execErr, _, _ := TestNamespaceCommands(getPolicies, args)`
`71`	`71`	`assert.NotNil(t, execErr)`
`72`		`- assert.Equal(t, "code: 404 reason: Namespace does not exist", execErr.Error())`
	`72`	`+ assertNamespaceNotExistError(t, execErr)`
`73`	`73`	`}`
Original file line number	Diff line number	Diff line change
`@@ -102,5 +102,5 @@ func TestGetPublishRateOnNonExistingNs(t *testing.T) {`
`102`	`102`	`args := []string{"get-publish-rate", ns}`
`103`	`103`	`_, execErr, _, _ := TestNamespaceCommands(GetPublishRateCmd, args)`
`104`	`104`	`assert.NotNil(t, execErr)`
`105`		`- assert.Equal(t, "code: 404 reason: Namespace does not exist", execErr.Error())`
	`105`	`+ assertNamespaceNotExistError(t, execErr)`
`106`	`106`	`}`