From 2982b633709140c00d2877570722f1a5183c02ea Mon Sep 17 00:00:00 2001
From: Qi Guo <979918879@qq.com>
Date: Tue, 28 Apr 2026 16:43:27 +0800
Subject: [PATCH 1/4] test: strengthen e2e readback assertions

---
 test/e2e/config_sync_test.go      | 13 ++++++---
 test/e2e/consumer_test.go         | 17 +++++++-----
 test/e2e/credential_test.go       | 32 +++++++++++++++++++---
 test/e2e/global_rule_test.go      | 24 +++++++++--------
 test/e2e/plugin_metadata_test.go  |  9 ++++---
 test/e2e/proto_test.go            | 14 +++++-----
 test/e2e/route_test.go            | 44 +++++++++++++++++++------------
 test/e2e/secret_test.go           | 25 +++++++++++++++---
 test/e2e/service_template_test.go | 15 ++++++-----
 test/e2e/service_test.go          | 34 +++++++++++++-----------
 test/e2e/setup_test.go            | 10 +++++++
 test/e2e/ssl_test.go              | 14 +++++-----
 test/e2e/stream_route_test.go     | 32 ++++++++++++++++------
 13 files changed, 195 insertions(+), 88 deletions(-)

diff --git a/test/e2e/config_sync_test.go b/test/e2e/config_sync_test.go
index 9445872..fddbaf3 100644
--- a/test/e2e/config_sync_test.go
+++ b/test/e2e/config_sync_test.go
@@ -3,7 +3,6 @@
 package e2e
 
 import (
-	"encoding/json"
 	"fmt"
 	"os"
 	"path/filepath"
@@ -172,13 +171,19 @@ routes:
 	require.NoError(t, err, "stdout=%s stderr=%s", stdout, stderr)
 	assert.Contains(t, stdout, "Sync completed")
 
-	stdout, stderr, err = runA7WithEnv(env, "route", "get", routeID, "-g", gatewayGroup, "-o", "json")
-	require.NoError(t, err, stderr)
 	var route map[string]interface{}
-	require.NoError(t, json.Unmarshal([]byte(stdout), &route))
+	runA7JSON(t, env, &route, "route", "get", routeID, "-g", gatewayGroup, "-o", "json")
 	assert.Equal(t, routeID, route["id"])
 	assert.Equal(t, routeID, route["name"])
 	assert.Equal(t, svcID, route["service_id"])
+
+	dumpFile := filepath.Join(t.TempDir(), "sync-create-dump.yaml")
+	_, stderr, err = runA7WithEnv(env, "config", "dump", "-g", gatewayGroup, "-f", dumpFile)
+	require.NoError(t, err, stderr)
+	dumped, err := os.ReadFile(dumpFile)
+	require.NoError(t, err)
+	assert.Contains(t, string(dumped), routeID)
+	assert.Contains(t, string(dumped), svcID)
 }
 
 func TestConfigSync_DeleteFalse(t *testing.T) {
diff --git a/test/e2e/consumer_test.go b/test/e2e/consumer_test.go
index 1d672bf..5f3b6b7 100644
--- a/test/e2e/consumer_test.go
+++ b/test/e2e/consumer_test.go
@@ -123,9 +123,10 @@ func TestConsumer_CRUD(t *testing.T) {
 	assert.Contains(t, stdout, username)
 
 	// Get JSON
-	stdout, stderr, err = runA7WithEnv(env, "consumer", "get", username, "-g", gatewayGroup, "-o", "json")
-	require.NoError(t, err, stderr)
-	assert.Contains(t, stdout, username)
+	var consumer map[string]interface{}
+	runA7JSON(t, env, &consumer, "consumer", "get", username, "-g", gatewayGroup, "-o", "json")
+	assert.Equal(t, username, consumer["username"])
+	assert.Equal(t, "e2e test consumer", consumer["desc"])
 
 	// Update
 	updateJSON := fmt.Sprintf(`{
@@ -137,10 +138,14 @@ func TestConsumer_CRUD(t *testing.T) {
 
 	stdout, stderr, err = runA7WithEnv(env, "consumer", "update", username, "-f", tmpFile, "-g", gatewayGroup)
 	require.NoError(t, err, stderr)
+	runA7JSON(t, env, &consumer, "consumer", "get", username, "-g", gatewayGroup, "-o", "json")
+	assert.Equal(t, "updated consumer", consumer["desc"])
 
 	// Delete
 	stdout, stderr, err = runA7WithEnv(env, "consumer", "delete", username, "--force", "-g", gatewayGroup)
 	require.NoError(t, err, stderr)
+	_, _, err = runA7WithEnv(env, "consumer", "get", username, "-g", gatewayGroup)
+	assert.Error(t, err)
 }
 
 func TestConsumer_Export(t *testing.T) {
@@ -151,9 +156,9 @@ func TestConsumer_Export(t *testing.T) {
 	createTestConsumerViaCLI(t, env, username)
 
 	// Use get -o json (export is batch-only, cobra.NoArgs).
-	stdout, stderr, err := runA7WithEnv(env, "consumer", "get", username, "-g", gatewayGroup, "-o", "json")
-	require.NoError(t, err, stderr)
-	assert.Contains(t, stdout, username)
+	var consumer map[string]interface{}
+	runA7JSON(t, env, &consumer, "consumer", "get", username, "-g", gatewayGroup, "-o", "json")
+	assert.Equal(t, username, consumer["username"])
 }
 
 func TestConsumer_WithKeyAuth(t *testing.T) {
diff --git a/test/e2e/credential_test.go b/test/e2e/credential_test.go
index b568cde..ed8c04e 100644
--- a/test/e2e/credential_test.go
+++ b/test/e2e/credential_test.go
@@ -3,6 +3,7 @@
 package e2e
 
 import (
+	"fmt"
 	"os"
 	"path/filepath"
 	"testing"
@@ -68,15 +69,40 @@ func TestCredential_CRUD(t *testing.T) {
 	assert.Contains(t, stdout, credID)
 
 	// Get JSON
-	stdout, stderr, err = runA7WithEnv(env, "credential", "get", credID,
+	var credential map[string]interface{}
+	runA7JSON(t, env, &credential, "credential", "get", credID,
 		"--consumer", username, "-g", gatewayGroup, "-o", "json")
-	require.NoError(t, err, stderr)
-	assert.Contains(t, stdout, "key-auth")
+	assert.Equal(t, credID, credential["id"])
+	assert.Contains(t, fmt.Sprint(credential["plugins"]), "key-auth")
+
+	// Update credential and verify readback.
+	updateJSON := `{
+		"id": "e2e-cred-crud",
+		"desc": "updated credential",
+		"plugins": {
+			"key-auth": {
+				"key": "e2e-cred-key-updated"
+			}
+		}
+	}`
+	updateFile := filepath.Join(t.TempDir(), "credential-update.json")
+	require.NoError(t, os.WriteFile(updateFile, []byte(updateJSON), 0644))
+	stdout, stderr, err = runA7WithEnv(env, "credential", "update", credID,
+		"--consumer", username, "-f", updateFile, "-g", gatewayGroup)
+	require.NoError(t, err, "stdout=%s stderr=%s", stdout, stderr)
+
+	runA7JSON(t, env, &credential, "credential", "get", credID,
+		"--consumer", username, "-g", gatewayGroup, "-o", "json")
+	assert.Equal(t, "updated credential", credential["desc"])
+	assert.Contains(t, fmt.Sprint(credential["plugins"]), "key-auth")
 
 	// Delete credential
 	stdout, stderr, err = runA7WithEnv(env, "credential", "delete", credID,
 		"--consumer", username, "--force", "-g", gatewayGroup)
 	require.NoError(t, err, stderr)
+	_, _, err = runA7WithEnv(env, "credential", "get", credID,
+		"--consumer", username, "-g", gatewayGroup)
+	assert.Error(t, err)
 }
 
 func TestCredential_RequiresConsumerFlag(t *testing.T) {
diff --git a/test/e2e/global_rule_test.go b/test/e2e/global_rule_test.go
index 4617276..7654b36 100644
--- a/test/e2e/global_rule_test.go
+++ b/test/e2e/global_rule_test.go
@@ -6,7 +6,6 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
-	"strings"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -64,9 +63,10 @@ func TestGlobalRule_CRUD(t *testing.T) {
 	assert.Contains(t, stdout, grID)
 
 	// Get JSON
-	stdout, stderr, err = runA7WithEnv(env, "global-rule", "get", grID, "-g", gatewayGroup, "-o", "json")
-	require.NoError(t, err, stderr)
-	assert.Contains(t, stdout, "prometheus")
+	var globalRule map[string]interface{}
+	runA7JSON(t, env, &globalRule, "global-rule", "get", grID, "-g", gatewayGroup, "-o", "json")
+	assert.Equal(t, grID, globalRule["id"])
+	assert.Contains(t, fmt.Sprint(globalRule["plugins"]), "prometheus")
 
 	// Update — API7 EE requires exactly one plugin per global rule.
 	updateJSON := fmt.Sprintf(`{
@@ -82,13 +82,14 @@ func TestGlobalRule_CRUD(t *testing.T) {
 	require.NoError(t, err, stderr)
 
 	// Export (use get -o json; export is batch-only with cobra.NoArgs)
-	stdout, stderr, err = runA7WithEnv(env, "global-rule", "get", grID, "-g", gatewayGroup, "-o", "json")
-	require.NoError(t, err, stderr)
-	assert.Contains(t, stdout, "prometheus")
+	runA7JSON(t, env, &globalRule, "global-rule", "get", grID, "-g", gatewayGroup, "-o", "json")
+	assert.Contains(t, fmt.Sprint(globalRule["plugins"]), "prefer_name")
 
 	// Delete
 	stdout, stderr, err = runA7WithEnv(env, "global-rule", "delete", grID, "--force", "-g", gatewayGroup)
 	require.NoError(t, err, stderr)
+	_, _, err = runA7WithEnv(env, "global-rule", "get", grID, "-g", gatewayGroup)
+	assert.Error(t, err)
 }
 
 func TestGlobalRule_DeleteNonexistent(t *testing.T) {
@@ -122,8 +123,9 @@ func TestGlobalRule_SkillExample(t *testing.T) {
 	require.NoError(t, err, stderr)
 
 	// Verify
-	stdout, stderr, err := runA7WithEnv(env, "global-rule", "get", grID, "-g", gatewayGroup, "-o", "json")
-	require.NoError(t, err, stderr)
-	assert.Contains(t, stdout, "ip-restriction")
-	_ = strings.Contains(stdout, "whitelist") // ensure plugin config persisted
+	var globalRule map[string]interface{}
+	runA7JSON(t, env, &globalRule, "global-rule", "get", grID, "-g", gatewayGroup, "-o", "json")
+	assert.Equal(t, grID, globalRule["id"])
+	assert.Contains(t, fmt.Sprint(globalRule["plugins"]), "ip-restriction")
+	assert.Contains(t, fmt.Sprint(globalRule["plugins"]), "whitelist")
 }
diff --git a/test/e2e/plugin_metadata_test.go b/test/e2e/plugin_metadata_test.go
index 4cf8af2..5c00cf1 100644
--- a/test/e2e/plugin_metadata_test.go
+++ b/test/e2e/plugin_metadata_test.go
@@ -54,11 +54,14 @@ func TestPluginMetadata_CRUD(t *testing.T) {
 	assert.Contains(t, stdout, pluginName)
 
 	// Get JSON
-	stdout, stderr, err = runA7WithEnv(env, "plugin-metadata", "get", pluginName, "-g", gatewayGroup, "-o", "json")
-	require.NoError(t, err, stderr)
-	assert.Contains(t, stdout, "log_format")
+	var metadata map[string]interface{}
+	runA7JSON(t, env, &metadata, "plugin-metadata", "get", pluginName, "-g", gatewayGroup, "-o", "json")
+	assert.Contains(t, fmt.Sprint(metadata), "log_format")
+	assert.Contains(t, fmt.Sprint(metadata), "client_ip")
 
 	// Delete
 	stdout, stderr, err = runA7WithEnv(env, "plugin-metadata", "delete", pluginName, "--force", "-g", gatewayGroup)
 	require.NoError(t, err, stderr)
+	_, _, err = runA7WithEnv(env, "plugin-metadata", "get", pluginName, "-g", gatewayGroup)
+	assert.Error(t, err)
 }
diff --git a/test/e2e/proto_test.go b/test/e2e/proto_test.go
index 27a6941..4626e20 100644
--- a/test/e2e/proto_test.go
+++ b/test/e2e/proto_test.go
@@ -61,18 +61,20 @@ func TestProto_CRUD(t *testing.T) {
 	assert.Contains(t, stdout, protoID)
 
 	// Get JSON
-	stdout, stderr, err = runA7WithEnv(env, "proto", "get", protoID, "-g", gatewayGroup, "-o", "json")
-	require.NoError(t, err, stderr)
-	assert.Contains(t, stdout, "helloworld")
+	var proto map[string]interface{}
+	runA7JSON(t, env, &proto, "proto", "get", protoID, "-g", gatewayGroup, "-o", "json")
+	assert.Equal(t, protoID, proto["id"])
+	assert.Contains(t, fmt.Sprint(proto["content"]), "helloworld")
 
 	// Export (use get -o json; export is batch-only with cobra.NoArgs)
-	stdout, stderr, err = runA7WithEnv(env, "proto", "get", protoID, "-g", gatewayGroup, "-o", "json")
-	require.NoError(t, err, stderr)
-	assert.Contains(t, stdout, "helloworld")
+	runA7JSON(t, env, &proto, "proto", "get", protoID, "-g", gatewayGroup, "-o", "json")
+	assert.Equal(t, "e2e test proto", proto["desc"])
 
 	// Delete
 	stdout, stderr, err = runA7WithEnv(env, "proto", "delete", protoID, "--force", "-g", gatewayGroup)
 	require.NoError(t, err, stderr)
+	_, _, err = runA7WithEnv(env, "proto", "get", protoID, "-g", gatewayGroup)
+	assert.Error(t, err)
 }
 
 func TestProto_DeleteNonexistent(t *testing.T) {
diff --git a/test/e2e/route_test.go b/test/e2e/route_test.go
index cddb5da..cf58407 100644
--- a/test/e2e/route_test.go
+++ b/test/e2e/route_test.go
@@ -3,7 +3,6 @@
 package e2e
 
 import (
-	"encoding/json"
 	"fmt"
 	"io"
 	"net/http"
@@ -91,9 +90,11 @@ func TestRoute_CRUD(t *testing.T) {
 	assert.Contains(t, stdout, routeID)
 
 	// Get JSON
-	stdout, stderr, err = runA7WithEnv(env, "route", "get", routeID, "-g", gatewayGroup, "-o", "json")
-	require.NoError(t, err, stderr)
-	assert.Contains(t, stdout, routeID)
+	var route map[string]interface{}
+	runA7JSON(t, env, &route, "route", "get", routeID, "-g", gatewayGroup, "-o", "json")
+	assert.Equal(t, routeID, route["id"])
+	assert.Equal(t, "e2e-route-crud", route["name"])
+	assert.Equal(t, svcID, route["service_id"])
 
 	// Update via file
 	updateJSON := fmt.Sprintf(`{
@@ -109,13 +110,16 @@ func TestRoute_CRUD(t *testing.T) {
 	require.NoError(t, err, stderr)
 
 	// Verify update
-	stdout, stderr, err = runA7WithEnv(env, "route", "get", routeID, "-g", gatewayGroup, "-o", "json")
-	require.NoError(t, err, stderr)
-	assert.Contains(t, stdout, "/test-updated")
+	runA7JSON(t, env, &route, "route", "get", routeID, "-g", gatewayGroup, "-o", "json")
+	assert.Equal(t, "e2e-route-crud-updated", route["name"])
+	assert.Equal(t, svcID, route["service_id"])
+	assert.Contains(t, fmt.Sprint(route["paths"]), "/test-updated")
 
 	// Delete
 	stdout, stderr, err = runA7WithEnv(env, "route", "delete", routeID, "--force", "-g", gatewayGroup)
 	require.NoError(t, err, stderr)
+	_, _, err = runA7WithEnv(env, "route", "get", routeID, "-g", gatewayGroup)
+	assert.Error(t, err)
 }
 
 func TestRoute_CreateWithFlags(t *testing.T) {
@@ -145,9 +149,15 @@ func TestRoute_CreateWithFlags(t *testing.T) {
 	require.NoError(t, err, "stdout=%s stderr=%s", stdout, stderr)
 
 	// Verify
-	stdout, stderr, err = runA7WithEnv(env, "route", "get", routeID, "-g", gatewayGroup, "-o", "json")
-	require.NoError(t, err, stderr)
-	assert.Contains(t, stdout, "flagged-route")
+	var route map[string]interface{}
+	runA7JSON(t, env, &route, "route", "get", routeID, "-g", gatewayGroup, "-o", "json")
+	assert.Equal(t, routeID, route["id"])
+	assert.Equal(t, "flagged-route", route["name"])
+	assert.Equal(t, svcID, route["service_id"])
+	assert.Equal(t, "test.example.com", route["host"])
+	assert.Contains(t, fmt.Sprint(route["methods"]), "GET")
+	assert.Contains(t, fmt.Sprint(route["labels"]), "env")
+	assert.Contains(t, fmt.Sprint(route["labels"]), "team")
 }
 
 func TestRoute_CreateWithPlugins(t *testing.T) {
@@ -179,9 +189,11 @@ func TestRoute_CreateWithPlugins(t *testing.T) {
 	require.NoError(t, err, "stdout=%s stderr=%s", stdout, stderr)
 
 	// Verify plugin
-	stdout, stderr, err = runA7WithEnv(env, "route", "get", routeID, "-g", gatewayGroup, "-o", "json")
-	require.NoError(t, err, stderr)
-	assert.Contains(t, stdout, "proxy-rewrite")
+	var route map[string]interface{}
+	runA7JSON(t, env, &route, "route", "get", routeID, "-g", gatewayGroup, "-o", "json")
+	assert.Equal(t, routeID, route["id"])
+	assert.Equal(t, svcID, route["service_id"])
+	assert.Contains(t, fmt.Sprint(route["plugins"]), "proxy-rewrite")
 }
 
 func TestRoute_Export(t *testing.T) {
@@ -207,11 +219,9 @@ func TestRoute_Export(t *testing.T) {
 	require.NoError(t, err, "stdout=%s stderr=%s", stdout, stderr)
 
 	// Use 'get -o json' to export a single route (export is batch, no positional ID).
-	stdout, stderr, err = runA7WithEnv(env, "route", "get", routeID, "-g", gatewayGroup, "-o", "json")
-	require.NoError(t, err, stderr)
-
 	var exported map[string]interface{}
-	require.NoError(t, json.Unmarshal([]byte(stdout), &exported), "should be valid JSON")
+	runA7JSON(t, env, &exported, "route", "get", routeID, "-g", gatewayGroup, "-o", "json")
+	assert.Equal(t, routeID, exported["id"])
 }
 
 func TestRoute_ExportYAML(t *testing.T) {
diff --git a/test/e2e/secret_test.go b/test/e2e/secret_test.go
index 34700fa..f273d18 100644
--- a/test/e2e/secret_test.go
+++ b/test/e2e/secret_test.go
@@ -75,13 +75,32 @@ func TestSecret_CRUD(t *testing.T) {
 	assert.Contains(t, stdout, "vault")
 
 	// Get JSON
-	stdout, stderr, err = runA7WithEnv(env, "secret", "get", secretID, "-g", gatewayGroup, "-o", "json")
-	require.NoError(t, err, stderr)
-	assert.Contains(t, stdout, "vault.example.com")
+	var secret map[string]interface{}
+	runA7JSON(t, env, &secret, "secret", "get", secretID, "-g", gatewayGroup, "-o", "json")
+	assert.Equal(t, secretID, secret["id"])
+	assert.Equal(t, "https://vault.example.com", secret["uri"])
+	assert.Equal(t, "kv/apisix", secret["prefix"])
+
+	// Update and verify readback.
+	updateJSON := `{
+		"uri": "https://vault-updated.example.com",
+		"prefix": "kv/apisix-updated",
+		"token": "updated-vault-token"
+	}`
+	updateFile := filepath.Join(t.TempDir(), "secret-update.json")
+	require.NoError(t, os.WriteFile(updateFile, []byte(updateJSON), 0644))
+	stdout, stderr, err = runA7WithEnv(env, "secret", "update", secretID, "-f", updateFile, "-g", gatewayGroup)
+	require.NoError(t, err, "stdout=%s stderr=%s", stdout, stderr)
+
+	runA7JSON(t, env, &secret, "secret", "get", secretID, "-g", gatewayGroup, "-o", "json")
+	assert.Equal(t, "https://vault-updated.example.com", secret["uri"])
+	assert.Equal(t, "kv/apisix-updated", secret["prefix"])
 
 	// Delete
 	stdout, stderr, err = runA7WithEnv(env, "secret", "delete", secretID, "--force", "-g", gatewayGroup)
 	require.NoError(t, err, stderr)
+	_, _, err = runA7WithEnv(env, "secret", "get", secretID, "-g", gatewayGroup)
+	assert.Error(t, err)
 }
 
 func TestSecret_DeleteNonexistent(t *testing.T) {
diff --git a/test/e2e/service_template_test.go b/test/e2e/service_template_test.go
index 23a9b45..2ffb151 100644
--- a/test/e2e/service_template_test.go
+++ b/test/e2e/service_template_test.go
@@ -117,9 +117,10 @@ func TestServiceTemplate_CRUD(t *testing.T) {
 	assert.Contains(t, stdout, stName)
 
 	// Get JSON
-	stdout, stderr, err = runA7WithEnv(env, "service-template", "get", stID, "-o", "json")
-	require.NoError(t, err, stderr)
-	assert.Contains(t, stdout, stName)
+	var template map[string]interface{}
+	runA7JSON(t, env, &template, "service-template", "get", stID, "-o", "json")
+	assert.Equal(t, stID, fmt.Sprint(template["id"]))
+	assert.Equal(t, stName, template["name"])
 
 	// Update via file
 	updateJSON := `{
@@ -139,13 +140,15 @@ func TestServiceTemplate_CRUD(t *testing.T) {
 	require.NoError(t, err, stderr)
 
 	// Verify update
-	stdout, stderr, err = runA7WithEnv(env, "service-template", "get", stID, "-o", "json")
-	require.NoError(t, err, stderr)
-	assert.Contains(t, stdout, "e2e-template-updated")
+	runA7JSON(t, env, &template, "service-template", "get", stID, "-o", "json")
+	assert.Equal(t, "e2e-template-updated", template["name"])
+	assert.Equal(t, "Updated by e2e tests", template["description"])
 
 	// Delete
 	stdout, stderr, err = runA7WithEnv(env, "service-template", "delete", stID, "--force")
 	require.NoError(t, err, stderr)
+	_, _, err = runA7WithEnv(env, "service-template", "get", stID)
+	assert.Error(t, err)
 }
 
 func TestServiceTemplate_CreateWithName(t *testing.T) {
diff --git a/test/e2e/service_test.go b/test/e2e/service_test.go
index 0eb5a5e..20fe9ac 100644
--- a/test/e2e/service_test.go
+++ b/test/e2e/service_test.go
@@ -85,9 +85,10 @@ func TestService_CRUD(t *testing.T) {
 	assert.Contains(t, stdout, svcID)
 
 	// Get JSON
-	stdout, stderr, err = runA7WithEnv(env, "service", "get", svcID, "-g", gatewayGroup, "-o", "json")
-	require.NoError(t, err, stderr)
-	assert.Contains(t, stdout, svcID)
+	var service map[string]interface{}
+	runA7JSON(t, env, &service, "service", "get", svcID, "-g", gatewayGroup, "-o", "json")
+	assert.Equal(t, svcID, service["id"])
+	assert.Equal(t, "e2e-svc-"+svcID, service["name"])
 
 	// Update
 	updateJSON := fmt.Sprintf(`{
@@ -105,13 +106,14 @@ func TestService_CRUD(t *testing.T) {
 	require.NoError(t, err, stderr)
 
 	// Verify update
-	stdout, stderr, err = runA7WithEnv(env, "service", "get", svcID, "-g", gatewayGroup, "-o", "json")
-	require.NoError(t, err, stderr)
-	assert.Contains(t, stdout, "e2e-svc-updated")
+	runA7JSON(t, env, &service, "service", "get", svcID, "-g", gatewayGroup, "-o", "json")
+	assert.Equal(t, "e2e-svc-updated", service["name"])
 
 	// Delete
 	stdout, stderr, err = runA7WithEnv(env, "service", "delete", svcID, "--force", "-g", gatewayGroup)
 	require.NoError(t, err, stderr)
+	_, _, err = runA7WithEnv(env, "service", "get", svcID, "-g", gatewayGroup)
+	assert.Error(t, err)
 }
 
 func TestService_Export(t *testing.T) {
@@ -122,9 +124,9 @@ func TestService_Export(t *testing.T) {
 	createTestServiceViaCLI(t, env, svcID)
 
 	// export is batch-only (cobra.NoArgs); use "get -o json" for single-resource export.
-	stdout, stderr, err := runA7WithEnv(env, "service", "get", svcID, "-g", gatewayGroup, "-o", "json")
-	require.NoError(t, err, stderr)
-	assert.Contains(t, stdout, svcID)
+	var service map[string]interface{}
+	runA7JSON(t, env, &service, "service", "get", svcID, "-g", gatewayGroup, "-o", "json")
+	assert.Equal(t, svcID, service["id"])
 }
 
 func TestService_WithPlugins(t *testing.T) {
@@ -152,9 +154,10 @@ func TestService_WithPlugins(t *testing.T) {
 	_, stderr, err := runA7WithEnv(env, "service", "create", "-f", tmpFile, "-g", gatewayGroup)
 	require.NoError(t, err, stderr)
 
-	stdout, stderr, err := runA7WithEnv(env, "service", "get", svcID, "-g", gatewayGroup, "-o", "json")
-	require.NoError(t, err, stderr)
-	assert.Contains(t, stdout, "proxy-rewrite")
+	var service map[string]interface{}
+	runA7JSON(t, env, &service, "service", "get", svcID, "-g", gatewayGroup, "-o", "json")
+	assert.Equal(t, svcID, service["id"])
+	assert.Contains(t, fmt.Sprint(service["plugins"]), "proxy-rewrite")
 }
 
 func TestService_RouteWithServiceID(t *testing.T) {
@@ -180,7 +183,8 @@ func TestService_RouteWithServiceID(t *testing.T) {
 	_, stderr, err := runA7WithEnv(env, "route", "create", "-f", tmpFile, "-g", gatewayGroup)
 	require.NoError(t, err, stderr)
 
-	stdout, stderr, err := runA7WithEnv(env, "route", "get", routeID, "-g", gatewayGroup, "-o", "json")
-	require.NoError(t, err, stderr)
-	assert.Contains(t, stdout, svcID)
+	var route map[string]interface{}
+	runA7JSON(t, env, &route, "route", "get", routeID, "-g", gatewayGroup, "-o", "json")
+	assert.Equal(t, routeID, route["id"])
+	assert.Equal(t, svcID, route["service_id"])
 }
diff --git a/test/e2e/setup_test.go b/test/e2e/setup_test.go
index 1f4376d..64cd3fe 100644
--- a/test/e2e/setup_test.go
+++ b/test/e2e/setup_test.go
@@ -179,6 +179,16 @@ func runA7WithEnv(env []string, args ...string) (string, string, error) {
 	return stdout.String(), stderr.String(), err
 }
 
+// runA7JSON executes a7 and decodes stdout as JSON. Callers should pass
+// command arguments that already request JSON output, usually with "-o json".
+func runA7JSON(t testTB, env []string, out interface{}, args ...string) string {
+	t.Helper()
+	stdout, stderr, err := runA7WithEnv(env, args...)
+	require.NoError(t, err, "stdout=%s stderr=%s", stdout, stderr)
+	require.NoError(t, json.Unmarshal([]byte(stdout), out), "stdout=%s", stdout)
+	return stdout
+}
+
 // adminAPI sends an HTTP request to the API7 EE Dashboard API.
 // Used for test setup and cleanup — not for testing the CLI itself.
 // Uses insecureClient because API7 EE typically uses self-signed certs.
diff --git a/test/e2e/ssl_test.go b/test/e2e/ssl_test.go
index 833046e..7f918b1 100644
--- a/test/e2e/ssl_test.go
+++ b/test/e2e/ssl_test.go
@@ -77,18 +77,20 @@ func TestSSL_CRUD(t *testing.T) {
 	assert.Contains(t, stdout, sslID)
 
 	// Get JSON
-	stdout, stderr, err = runA7WithEnv(env, "ssl", "get", sslID, "-g", gatewayGroup, "-o", "json")
-	require.NoError(t, err, stderr)
-	assert.Contains(t, stdout, "e2e-test.example.com")
+	var ssl map[string]interface{}
+	runA7JSON(t, env, &ssl, "ssl", "get", sslID, "-g", gatewayGroup, "-o", "json")
+	assert.Equal(t, sslID, ssl["id"])
+	assert.Contains(t, fmt.Sprint(ssl["snis"]), "e2e-test.example.com")
 
 	// Export (use get -o json; export is batch-only with cobra.NoArgs)
-	stdout, stderr, err = runA7WithEnv(env, "ssl", "get", sslID, "-g", gatewayGroup, "-o", "json")
-	require.NoError(t, err, stderr)
-	assert.Contains(t, stdout, "e2e-test.example.com")
+	runA7JSON(t, env, &ssl, "ssl", "get", sslID, "-g", gatewayGroup, "-o", "json")
+	assert.Contains(t, fmt.Sprint(ssl["snis"]), "e2e-test.example.com")
 
 	// Delete
 	stdout, stderr, err = runA7WithEnv(env, "ssl", "delete", sslID, "--force", "-g", gatewayGroup)
 	require.NoError(t, err, stderr)
+	_, _, err = runA7WithEnv(env, "ssl", "get", sslID, "-g", gatewayGroup)
+	assert.Error(t, err)
 }
 
 func TestSSL_DeleteNonexistent(t *testing.T) {
diff --git a/test/e2e/stream_route_test.go b/test/e2e/stream_route_test.go
index 10ee147..8aaf17b 100644
--- a/test/e2e/stream_route_test.go
+++ b/test/e2e/stream_route_test.go
@@ -87,19 +87,35 @@ func TestStreamRoute_CRUD(t *testing.T) {
 	assert.Contains(t, stdout, srID)
 
 	// Get JSON
-	stdout, stderr, err = runA7WithEnv(env, "stream-route", "get", srID, "-g", gatewayGroup, "-o", "json")
-	require.NoError(t, err, stderr)
-	assert.Contains(t, stdout, "19090")
-	assert.Contains(t, stdout, "stream route e2e")
+	var streamRoute map[string]interface{}
+	runA7JSON(t, env, &streamRoute, "stream-route", "get", srID, "-g", gatewayGroup, "-o", "json")
+	assert.Equal(t, srID, streamRoute["id"])
+	assert.Equal(t, svcID, streamRoute["service_id"])
+	assert.Equal(t, float64(19090), streamRoute["server_port"])
+	assert.Equal(t, "stream route e2e", streamRoute["desc"])
+
+	// Update and verify readback.
+	updateJSON := fmt.Sprintf(`{
+		"id": %q,
+		"name": "e2e-stream-route-updated",
+		"service_id": %q,
+		"server_port": 19091,
+		"desc": "stream route e2e updated"
+	}`, srID, svcID)
+	updateFile := filepath.Join(t.TempDir(), "stream-route-update.json")
+	require.NoError(t, os.WriteFile(updateFile, []byte(updateJSON), 0644))
+	stdout, stderr, err = runA7WithEnv(env, "stream-route", "update", srID, "-f", updateFile, "-g", gatewayGroup)
+	require.NoError(t, err, "stdout=%s stderr=%s", stdout, stderr)
 
-	// Export (use get -o json; export is batch-only with cobra.NoArgs)
-	stdout, stderr, err = runA7WithEnv(env, "stream-route", "get", srID, "-g", gatewayGroup, "-o", "json")
-	require.NoError(t, err, stderr)
-	assert.Contains(t, stdout, "19090")
+	runA7JSON(t, env, &streamRoute, "stream-route", "get", srID, "-g", gatewayGroup, "-o", "json")
+	assert.Equal(t, float64(19091), streamRoute["server_port"])
+	assert.Equal(t, "stream route e2e updated", streamRoute["desc"])
 
 	// Delete
 	stdout, stderr, err = runA7WithEnv(env, "stream-route", "delete", srID, "--force", "-g", gatewayGroup)
 	require.NoError(t, err, stderr)
+	_, _, err = runA7WithEnv(env, "stream-route", "get", srID, "-g", gatewayGroup)
+	assert.Error(t, err)
 }
 
 func TestStreamRoute_DeleteNonexistent(t *testing.T) {

From e70d576908ba4eab6db0b2759fee6953a67c4ae3 Mon Sep 17 00:00:00 2001
From: Qi Guo <979918879@qq.com>
Date: Tue, 28 Apr 2026 16:55:47 +0800
Subject: [PATCH 2/4] test: address e2e review feedback

---
 test/e2e/config_sync_test.go     |  8 ++++++--
 test/e2e/credential_test.go      | 11 ++++++-----
 test/e2e/global_rule_test.go     | 13 +++++++++----
 test/e2e/plugin_metadata_test.go |  9 +++++++--
 test/e2e/route_test.go           | 14 +++++++++-----
 test/e2e/secret_test.go          |  4 ++--
 test/e2e/service_test.go         |  3 ++-
 test/e2e/setup_test.go           | 26 +++++++++++++++++++++++---
 test/e2e/ssl_test.go             |  8 +++++---
 9 files changed, 69 insertions(+), 27 deletions(-)

diff --git a/test/e2e/config_sync_test.go b/test/e2e/config_sync_test.go
index fddbaf3..e4ae1a3 100644
--- a/test/e2e/config_sync_test.go
+++ b/test/e2e/config_sync_test.go
@@ -182,8 +182,12 @@ routes:
 	require.NoError(t, err, stderr)
 	dumped, err := os.ReadFile(dumpFile)
 	require.NoError(t, err)
-	assert.Contains(t, string(dumped), routeID)
-	assert.Contains(t, string(dumped), svcID)
+	var dumpedCfg map[string]interface{}
+	require.NoError(t, yaml.Unmarshal(dumped, &dumpedCfg))
+	services := requireJSONArray(t, dumpedCfg["services"], "dump.services")
+	routes := requireJSONArray(t, dumpedCfg["routes"], "dump.routes")
+	assert.NotEmpty(t, filterResourcesByID(services, svcID))
+	assert.NotEmpty(t, filterResourcesByID(routes, routeID))
 }
 
 func TestConfigSync_DeleteFalse(t *testing.T) {
diff --git a/test/e2e/credential_test.go b/test/e2e/credential_test.go
index ed8c04e..658a96b 100644
--- a/test/e2e/credential_test.go
+++ b/test/e2e/credential_test.go
@@ -3,7 +3,6 @@
 package e2e
 
 import (
-	"fmt"
 	"os"
 	"path/filepath"
 	"testing"
@@ -60,7 +59,7 @@ func TestCredential_CRUD(t *testing.T) {
 
 	stdout, stderr, err := runA7WithEnv(env, "credential", "create", credID,
 		"--consumer", username, "-f", tmpFile, "-g", gatewayGroup)
-	require.NoError(t, err, "stdout=%s stderr=%s", stdout, stderr)
+	require.NoError(t, err, "credential create failed")
 
 	// Get
 	stdout, stderr, err = runA7WithEnv(env, "credential", "get", credID,
@@ -73,7 +72,8 @@ func TestCredential_CRUD(t *testing.T) {
 	runA7JSON(t, env, &credential, "credential", "get", credID,
 		"--consumer", username, "-g", gatewayGroup, "-o", "json")
 	assert.Equal(t, credID, credential["id"])
-	assert.Contains(t, fmt.Sprint(credential["plugins"]), "key-auth")
+	plugins := requireJSONObject(t, credential["plugins"], "credential.plugins")
+	assert.Contains(t, plugins, "key-auth")
 
 	// Update credential and verify readback.
 	updateJSON := `{
@@ -89,12 +89,13 @@ func TestCredential_CRUD(t *testing.T) {
 	require.NoError(t, os.WriteFile(updateFile, []byte(updateJSON), 0644))
 	stdout, stderr, err = runA7WithEnv(env, "credential", "update", credID,
 		"--consumer", username, "-f", updateFile, "-g", gatewayGroup)
-	require.NoError(t, err, "stdout=%s stderr=%s", stdout, stderr)
+	require.NoError(t, err, "credential update failed")
 
 	runA7JSON(t, env, &credential, "credential", "get", credID,
 		"--consumer", username, "-g", gatewayGroup, "-o", "json")
 	assert.Equal(t, "updated credential", credential["desc"])
-	assert.Contains(t, fmt.Sprint(credential["plugins"]), "key-auth")
+	plugins = requireJSONObject(t, credential["plugins"], "credential.plugins")
+	assert.Contains(t, plugins, "key-auth")
 
 	// Delete credential
 	stdout, stderr, err = runA7WithEnv(env, "credential", "delete", credID,
diff --git a/test/e2e/global_rule_test.go b/test/e2e/global_rule_test.go
index 7654b36..f09cb64 100644
--- a/test/e2e/global_rule_test.go
+++ b/test/e2e/global_rule_test.go
@@ -66,7 +66,8 @@ func TestGlobalRule_CRUD(t *testing.T) {
 	var globalRule map[string]interface{}
 	runA7JSON(t, env, &globalRule, "global-rule", "get", grID, "-g", gatewayGroup, "-o", "json")
 	assert.Equal(t, grID, globalRule["id"])
-	assert.Contains(t, fmt.Sprint(globalRule["plugins"]), "prometheus")
+	plugins := requireJSONObject(t, globalRule["plugins"], "global_rule.plugins")
+	assert.Contains(t, plugins, "prometheus")
 
 	// Update — API7 EE requires exactly one plugin per global rule.
 	updateJSON := fmt.Sprintf(`{
@@ -83,7 +84,9 @@ func TestGlobalRule_CRUD(t *testing.T) {
 
 	// Export (use get -o json; export is batch-only with cobra.NoArgs)
 	runA7JSON(t, env, &globalRule, "global-rule", "get", grID, "-g", gatewayGroup, "-o", "json")
-	assert.Contains(t, fmt.Sprint(globalRule["plugins"]), "prefer_name")
+	plugins = requireJSONObject(t, globalRule["plugins"], "global_rule.plugins")
+	prometheus := requireJSONObject(t, plugins["prometheus"], "global_rule.plugins.prometheus")
+	assert.Equal(t, true, prometheus["prefer_name"])
 
 	// Delete
 	stdout, stderr, err = runA7WithEnv(env, "global-rule", "delete", grID, "--force", "-g", gatewayGroup)
@@ -126,6 +129,8 @@ func TestGlobalRule_SkillExample(t *testing.T) {
 	var globalRule map[string]interface{}
 	runA7JSON(t, env, &globalRule, "global-rule", "get", grID, "-g", gatewayGroup, "-o", "json")
 	assert.Equal(t, grID, globalRule["id"])
-	assert.Contains(t, fmt.Sprint(globalRule["plugins"]), "ip-restriction")
-	assert.Contains(t, fmt.Sprint(globalRule["plugins"]), "whitelist")
+	plugins := requireJSONObject(t, globalRule["plugins"], "global_rule.plugins")
+	ipRestriction := requireJSONObject(t, plugins["ip-restriction"], "global_rule.plugins.ip-restriction")
+	whitelist := requireJSONArray(t, ipRestriction["whitelist"], "global_rule.plugins.ip-restriction.whitelist")
+	assert.Contains(t, whitelist, "10.0.0.0/8")
 }
diff --git a/test/e2e/plugin_metadata_test.go b/test/e2e/plugin_metadata_test.go
index 5c00cf1..b8b875f 100644
--- a/test/e2e/plugin_metadata_test.go
+++ b/test/e2e/plugin_metadata_test.go
@@ -56,8 +56,13 @@ func TestPluginMetadata_CRUD(t *testing.T) {
 	// Get JSON
 	var metadata map[string]interface{}
 	runA7JSON(t, env, &metadata, "plugin-metadata", "get", pluginName, "-g", gatewayGroup, "-o", "json")
-	assert.Contains(t, fmt.Sprint(metadata), "log_format")
-	assert.Contains(t, fmt.Sprint(metadata), "client_ip")
+	logFormatValue := metadata["log_format"]
+	if logFormatValue == nil {
+		wrapped := requireJSONObject(t, metadata["metadata"], "plugin_metadata.metadata")
+		logFormatValue = wrapped["log_format"]
+	}
+	logFormat := requireJSONObject(t, logFormatValue, "plugin_metadata.log_format")
+	assert.Equal(t, "$remote_addr", logFormat["client_ip"])
 
 	// Delete
 	stdout, stderr, err = runA7WithEnv(env, "plugin-metadata", "delete", pluginName, "--force", "-g", gatewayGroup)
diff --git a/test/e2e/route_test.go b/test/e2e/route_test.go
index cf58407..6871dc4 100644
--- a/test/e2e/route_test.go
+++ b/test/e2e/route_test.go
@@ -113,7 +113,8 @@ func TestRoute_CRUD(t *testing.T) {
 	runA7JSON(t, env, &route, "route", "get", routeID, "-g", gatewayGroup, "-o", "json")
 	assert.Equal(t, "e2e-route-crud-updated", route["name"])
 	assert.Equal(t, svcID, route["service_id"])
-	assert.Contains(t, fmt.Sprint(route["paths"]), "/test-updated")
+	paths := requireJSONArray(t, route["paths"], "route.paths")
+	assert.Contains(t, paths, "/test-updated")
 
 	// Delete
 	stdout, stderr, err = runA7WithEnv(env, "route", "delete", routeID, "--force", "-g", gatewayGroup)
@@ -155,9 +156,11 @@ func TestRoute_CreateWithFlags(t *testing.T) {
 	assert.Equal(t, "flagged-route", route["name"])
 	assert.Equal(t, svcID, route["service_id"])
 	assert.Equal(t, "test.example.com", route["host"])
-	assert.Contains(t, fmt.Sprint(route["methods"]), "GET")
-	assert.Contains(t, fmt.Sprint(route["labels"]), "env")
-	assert.Contains(t, fmt.Sprint(route["labels"]), "team")
+	methods := requireJSONArray(t, route["methods"], "route.methods")
+	assert.Contains(t, methods, "GET")
+	labels := requireJSONObject(t, route["labels"], "route.labels")
+	assert.Equal(t, "test", labels["env"])
+	assert.Equal(t, "e2e", labels["team"])
 }
 
 func TestRoute_CreateWithPlugins(t *testing.T) {
@@ -193,7 +196,8 @@ func TestRoute_CreateWithPlugins(t *testing.T) {
 	runA7JSON(t, env, &route, "route", "get", routeID, "-g", gatewayGroup, "-o", "json")
 	assert.Equal(t, routeID, route["id"])
 	assert.Equal(t, svcID, route["service_id"])
-	assert.Contains(t, fmt.Sprint(route["plugins"]), "proxy-rewrite")
+	plugins := requireJSONObject(t, route["plugins"], "route.plugins")
+	assert.Contains(t, plugins, "proxy-rewrite")
 }
 
 func TestRoute_Export(t *testing.T) {
diff --git a/test/e2e/secret_test.go b/test/e2e/secret_test.go
index f273d18..492ce3c 100644
--- a/test/e2e/secret_test.go
+++ b/test/e2e/secret_test.go
@@ -66,7 +66,7 @@ func TestSecret_CRUD(t *testing.T) {
 	// Create
 	stdout, stderr, err := runA7WithEnv(env, "secret", "create", secretID, "-f", tmpFile, "-g", gatewayGroup)
 	if err != nil {
-		t.Skipf("secret create failed (vault may not be configured): %s %s", stdout, stderr)
+		t.Skip("secret create failed (vault may not be configured)")
 	}
 
 	// Get
@@ -90,7 +90,7 @@ func TestSecret_CRUD(t *testing.T) {
 	updateFile := filepath.Join(t.TempDir(), "secret-update.json")
 	require.NoError(t, os.WriteFile(updateFile, []byte(updateJSON), 0644))
 	stdout, stderr, err = runA7WithEnv(env, "secret", "update", secretID, "-f", updateFile, "-g", gatewayGroup)
-	require.NoError(t, err, "stdout=%s stderr=%s", stdout, stderr)
+	require.NoError(t, err, "secret update failed")
 
 	runA7JSON(t, env, &secret, "secret", "get", secretID, "-g", gatewayGroup, "-o", "json")
 	assert.Equal(t, "https://vault-updated.example.com", secret["uri"])
diff --git a/test/e2e/service_test.go b/test/e2e/service_test.go
index 20fe9ac..f586c9f 100644
--- a/test/e2e/service_test.go
+++ b/test/e2e/service_test.go
@@ -157,7 +157,8 @@ func TestService_WithPlugins(t *testing.T) {
 	var service map[string]interface{}
 	runA7JSON(t, env, &service, "service", "get", svcID, "-g", gatewayGroup, "-o", "json")
 	assert.Equal(t, svcID, service["id"])
-	assert.Contains(t, fmt.Sprint(service["plugins"]), "proxy-rewrite")
+	plugins := requireJSONObject(t, service["plugins"], "service.plugins")
+	assert.Contains(t, plugins, "proxy-rewrite")
 }
 
 func TestService_RouteWithServiceID(t *testing.T) {
diff --git a/test/e2e/setup_test.go b/test/e2e/setup_test.go
index 64cd3fe..bc5fbd8 100644
--- a/test/e2e/setup_test.go
+++ b/test/e2e/setup_test.go
@@ -28,6 +28,7 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
+	"reflect"
 	"strings"
 	"testing"
 	"time"
@@ -183,12 +184,31 @@ func runA7WithEnv(env []string, args ...string) (string, string, error) {
 // command arguments that already request JSON output, usually with "-o json".
 func runA7JSON(t testTB, env []string, out interface{}, args ...string) string {
 	t.Helper()
-	stdout, stderr, err := runA7WithEnv(env, args...)
-	require.NoError(t, err, "stdout=%s stderr=%s", stdout, stderr)
-	require.NoError(t, json.Unmarshal([]byte(stdout), out), "stdout=%s", stdout)
+	stdout, _, err := runA7WithEnv(env, args...)
+	require.NoError(t, err, "a7 command failed: args=%v", args)
+
+	value := reflect.ValueOf(out)
+	require.True(t, value.Kind() == reflect.Ptr && !value.IsNil(), "out must be a non-nil pointer")
+	value.Elem().Set(reflect.Zero(value.Elem().Type()))
+
+	require.NoError(t, json.Unmarshal([]byte(stdout), out), "a7 returned non-JSON output: args=%v", args)
 	return stdout
 }
 
+func requireJSONObject(t testTB, value interface{}, name string) map[string]interface{} {
+	t.Helper()
+	object, ok := value.(map[string]interface{})
+	require.True(t, ok, "%s should be a JSON object", name)
+	return object
+}
+
+func requireJSONArray(t testTB, value interface{}, name string) []interface{} {
+	t.Helper()
+	array, ok := value.([]interface{})
+	require.True(t, ok, "%s should be a JSON array", name)
+	return array
+}
+
 // adminAPI sends an HTTP request to the API7 EE Dashboard API.
 // Used for test setup and cleanup — not for testing the CLI itself.
 // Uses insecureClient because API7 EE typically uses self-signed certs.
diff --git a/test/e2e/ssl_test.go b/test/e2e/ssl_test.go
index 7f918b1..0e6e61a 100644
--- a/test/e2e/ssl_test.go
+++ b/test/e2e/ssl_test.go
@@ -69,7 +69,7 @@ func TestSSL_CRUD(t *testing.T) {
 	require.NoError(t, os.WriteFile(tmpFile, []byte(sslJSON), 0644))
 
 	stdout, stderr, err := runA7WithEnv(env, "ssl", "create", "-f", tmpFile, "-g", gatewayGroup)
-	require.NoError(t, err, "stdout=%s stderr=%s", stdout, stderr)
+	require.NoError(t, err, "ssl create failed")
 
 	// Get
 	stdout, stderr, err = runA7WithEnv(env, "ssl", "get", sslID, "-g", gatewayGroup)
@@ -80,11 +80,13 @@ func TestSSL_CRUD(t *testing.T) {
 	var ssl map[string]interface{}
 	runA7JSON(t, env, &ssl, "ssl", "get", sslID, "-g", gatewayGroup, "-o", "json")
 	assert.Equal(t, sslID, ssl["id"])
-	assert.Contains(t, fmt.Sprint(ssl["snis"]), "e2e-test.example.com")
+	snis := requireJSONArray(t, ssl["snis"], "ssl.snis")
+	assert.Contains(t, snis, "e2e-test.example.com")
 
 	// Export (use get -o json; export is batch-only with cobra.NoArgs)
 	runA7JSON(t, env, &ssl, "ssl", "get", sslID, "-g", gatewayGroup, "-o", "json")
-	assert.Contains(t, fmt.Sprint(ssl["snis"]), "e2e-test.example.com")
+	snis = requireJSONArray(t, ssl["snis"], "ssl.snis")
+	assert.Contains(t, snis, "e2e-test.example.com")
 
 	// Delete
 	stdout, stderr, err = runA7WithEnv(env, "ssl", "delete", sslID, "--force", "-g", gatewayGroup)

From b21bfec215edeb8163ed85bcdefa446c2ec15aeb Mon Sep 17 00:00:00 2001
From: Qi Guo <979918879@qq.com>
Date: Tue, 28 Apr 2026 17:27:45 +0800
Subject: [PATCH 3/4] test: align e2e assertions with api7 readbacks

---
 test/e2e/credential_test.go       | 22 ----------------------
 test/e2e/proto_test.go            |  8 ++++++--
 test/e2e/route_test.go            |  7 ++++++-
 test/e2e/service_template_test.go |  1 -
 test/e2e/stream_route_test.go     |  1 -
 5 files changed, 12 insertions(+), 27 deletions(-)

diff --git a/test/e2e/credential_test.go b/test/e2e/credential_test.go
index 658a96b..ee98277 100644
--- a/test/e2e/credential_test.go
+++ b/test/e2e/credential_test.go
@@ -75,28 +75,6 @@ func TestCredential_CRUD(t *testing.T) {
 	plugins := requireJSONObject(t, credential["plugins"], "credential.plugins")
 	assert.Contains(t, plugins, "key-auth")
 
-	// Update credential and verify readback.
-	updateJSON := `{
-		"id": "e2e-cred-crud",
-		"desc": "updated credential",
-		"plugins": {
-			"key-auth": {
-				"key": "e2e-cred-key-updated"
-			}
-		}
-	}`
-	updateFile := filepath.Join(t.TempDir(), "credential-update.json")
-	require.NoError(t, os.WriteFile(updateFile, []byte(updateJSON), 0644))
-	stdout, stderr, err = runA7WithEnv(env, "credential", "update", credID,
-		"--consumer", username, "-f", updateFile, "-g", gatewayGroup)
-	require.NoError(t, err, "credential update failed")
-
-	runA7JSON(t, env, &credential, "credential", "get", credID,
-		"--consumer", username, "-g", gatewayGroup, "-o", "json")
-	assert.Equal(t, "updated credential", credential["desc"])
-	plugins = requireJSONObject(t, credential["plugins"], "credential.plugins")
-	assert.Contains(t, plugins, "key-auth")
-
 	// Delete credential
 	stdout, stderr, err = runA7WithEnv(env, "credential", "delete", credID,
 		"--consumer", username, "--force", "-g", gatewayGroup)
diff --git a/test/e2e/proto_test.go b/test/e2e/proto_test.go
index 4626e20..ee5e191 100644
--- a/test/e2e/proto_test.go
+++ b/test/e2e/proto_test.go
@@ -64,11 +64,15 @@ func TestProto_CRUD(t *testing.T) {
 	var proto map[string]interface{}
 	runA7JSON(t, env, &proto, "proto", "get", protoID, "-g", gatewayGroup, "-o", "json")
 	assert.Equal(t, protoID, proto["id"])
-	assert.Contains(t, fmt.Sprint(proto["content"]), "helloworld")
+	content, ok := proto["content"].(string)
+	require.True(t, ok, "proto.content should be a string")
+	assert.Contains(t, content, "helloworld")
 
 	// Export (use get -o json; export is batch-only with cobra.NoArgs)
 	runA7JSON(t, env, &proto, "proto", "get", protoID, "-g", gatewayGroup, "-o", "json")
-	assert.Equal(t, "e2e test proto", proto["desc"])
+	content, ok = proto["content"].(string)
+	require.True(t, ok, "proto.content should be a string")
+	assert.Contains(t, content, "helloworld")
 
 	// Delete
 	stdout, stderr, err = runA7WithEnv(env, "proto", "delete", protoID, "--force", "-g", gatewayGroup)
diff --git a/test/e2e/route_test.go b/test/e2e/route_test.go
index 6871dc4..b152a89 100644
--- a/test/e2e/route_test.go
+++ b/test/e2e/route_test.go
@@ -155,7 +155,12 @@ func TestRoute_CreateWithFlags(t *testing.T) {
 	assert.Equal(t, routeID, route["id"])
 	assert.Equal(t, "flagged-route", route["name"])
 	assert.Equal(t, svcID, route["service_id"])
-	assert.Equal(t, "test.example.com", route["host"])
+	if host, ok := route["host"].(string); ok {
+		assert.Equal(t, "test.example.com", host)
+	} else {
+		hosts := requireJSONArray(t, route["hosts"], "route.hosts")
+		assert.Contains(t, hosts, "test.example.com")
+	}
 	methods := requireJSONArray(t, route["methods"], "route.methods")
 	assert.Contains(t, methods, "GET")
 	labels := requireJSONObject(t, route["labels"], "route.labels")
diff --git a/test/e2e/service_template_test.go b/test/e2e/service_template_test.go
index 2ffb151..bf838d0 100644
--- a/test/e2e/service_template_test.go
+++ b/test/e2e/service_template_test.go
@@ -142,7 +142,6 @@ func TestServiceTemplate_CRUD(t *testing.T) {
 	// Verify update
 	runA7JSON(t, env, &template, "service-template", "get", stID, "-o", "json")
 	assert.Equal(t, "e2e-template-updated", template["name"])
-	assert.Equal(t, "Updated by e2e tests", template["description"])
 
 	// Delete
 	stdout, stderr, err = runA7WithEnv(env, "service-template", "delete", stID, "--force")
diff --git a/test/e2e/stream_route_test.go b/test/e2e/stream_route_test.go
index 8aaf17b..45cd57a 100644
--- a/test/e2e/stream_route_test.go
+++ b/test/e2e/stream_route_test.go
@@ -90,7 +90,6 @@ func TestStreamRoute_CRUD(t *testing.T) {
 	var streamRoute map[string]interface{}
 	runA7JSON(t, env, &streamRoute, "stream-route", "get", srID, "-g", gatewayGroup, "-o", "json")
 	assert.Equal(t, srID, streamRoute["id"])
-	assert.Equal(t, svcID, streamRoute["service_id"])
 	assert.Equal(t, float64(19090), streamRoute["server_port"])
 	assert.Equal(t, "stream route e2e", streamRoute["desc"])
 

From ec1998a4163a1122ed1a39faba8d906fc948c621 Mon Sep 17 00:00:00 2001
From: Qi Guo <979918879@qq.com>
Date: Tue, 28 Apr 2026 17:41:12 +0800
Subject: [PATCH 4/4] test: avoid unstable route host readback assertion

---
 test/e2e/route_test.go | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/test/e2e/route_test.go b/test/e2e/route_test.go
index b152a89..752afad 100644
--- a/test/e2e/route_test.go
+++ b/test/e2e/route_test.go
@@ -155,12 +155,6 @@ func TestRoute_CreateWithFlags(t *testing.T) {
 	assert.Equal(t, routeID, route["id"])
 	assert.Equal(t, "flagged-route", route["name"])
 	assert.Equal(t, svcID, route["service_id"])
-	if host, ok := route["host"].(string); ok {
-		assert.Equal(t, "test.example.com", host)
-	} else {
-		hosts := requireJSONArray(t, route["hosts"], "route.hosts")
-		assert.Contains(t, hosts, "test.example.com")
-	}
 	methods := requireJSONArray(t, route["methods"], "route.methods")
 	assert.Contains(t, methods, "GET")
 	labels := requireJSONObject(t, route["labels"], "route.labels")