fix: round 7 — plugin-metadata raw map format, config-sync service_id, validate paths, test timeout

- Plugin metadata: send/receive raw map instead of wrapped struct (API7 EE format)
- Config sync tests: create service first, include service_id in routes
- Validator: accept 'paths' field (API7 EE) in addition to uri/uris
- Add createTestRouteWithServiceViaCLI helper for config sync tests
- Increase e2e test timeout from 15m to 25m to prevent panic

Author: moonming

Makefile

@@ -44,4 +44,4 @@ docker-down:
 	docker compose -f test/e2e/docker-compose.yml down -v
 
 test-e2e:
-	go test ./test/e2e/... -count=1 -v -tags=e2e -timeout 15m
+	go test ./test/e2e/... -count=1 -v -tags=e2e -timeout 25m

pkg/cmd/config/validate/validate.go

@@ -208,6 +208,12 @@ func hasRouteURI(r api.Route) bool {
 			return true
 		}
 	}
+	// API7 EE uses "paths" instead of "uri"/"uris".
+	for _, p := range r.Paths {
+		if strings.TrimSpace(p) != "" {
+			return true
+		}
+	}
 	return false
 }
 

pkg/cmd/plugin-metadata/create/create.go

@@ -103,30 +103,23 @@ func actionRun(opts *Options) error {
 		return err
 	}
 
+	// API7 EE expects raw metadata map as request body (e.g., {"log_format": {...}}).
 	metadata := map[string]interface{}{}
 	if opts.MetadataJSON != "" {
 		if err := json.Unmarshal([]byte(opts.MetadataJSON), &metadata); err != nil {
 			return fmt.Errorf("invalid --metadata-json: %w", err)
 		}
 	}
 
-	bodyReq := api.PluginMetadata{Metadata: metadata}
-
 	client := api.NewClient(httpClient, cfg.BaseURL())
-	body, err := client.Put("/apisix/admin/plugin_metadata/"+opts.PluginName+"?gateway_group_id="+ggID, bodyReq)
+	body, err := client.Put("/apisix/admin/plugin_metadata/"+opts.PluginName+"?gateway_group_id="+ggID, metadata)
 	if err != nil {
 		return fmt.Errorf("%s", cmdutil.FormatAPIError(err))
 	}
 
-	var created api.PluginMetadata
-	if err := json.Unmarshal(body, &created); err != nil {
-		return fmt.Errorf("failed to decode response: %w", err)
-	}
-
 	format := opts.Output
 	if format == "" {
 		format = "json"
 	}
-	exporter := cmdutil.NewExporter(format, opts.IO.Out)
-	return exporter.Write(created)
+	return cmdutil.NewExporter(format, opts.IO.Out).Write(json.RawMessage(body))
 }

pkg/cmd/plugin-metadata/get/get.go

@@ -66,20 +66,22 @@ func actionRun(opts *Options) error {
 		return fmt.Errorf("%s", cmdutil.FormatAPIError(err))
 	}
 
-	var item api.PluginMetadata
-	if err := json.Unmarshal(body, &item); err != nil {
+	// API7 EE returns plugin metadata as a raw map (e.g., {"log_format": {...}}).
+	// After unwrapValueEnvelope, `body` is the raw metadata map directly.
+	var metadata map[string]interface{}
+	if err := json.Unmarshal(body, &metadata); err != nil {
 		return fmt.Errorf("failed to decode response: %w", err)
 	}
 
 	if opts.Output != "" {
 		exporter := cmdutil.NewExporter(opts.Output, opts.IO.Out)
-		return exporter.Write(item)
+		return exporter.Write(json.RawMessage(body))
 	}
 
-	metaJSON, _ := json.Marshal(item.Metadata)
+	metaJSON, _ := json.MarshalIndent(metadata, "", "  ")
 	tp := tableprinter.New(opts.IO.Out)
 	tp.SetHeaders("FIELD", "VALUE")
-	tp.AddRow("id", item.ID)
+	tp.AddRow("plugin", opts.PluginName)
 	tp.AddRow("metadata", string(metaJSON))
 	return tp.Render()
 }

pkg/cmd/plugin-metadata/update/update.go

@@ -88,23 +88,15 @@ func actionRun(opts *Options) error {
 		}
 	}
 
-	bodyReq := api.PluginMetadata{Metadata: metadata}
-
 	client := api.NewClient(httpClient, cfg.BaseURL())
-	body, err := client.Put("/apisix/admin/plugin_metadata/"+opts.PluginName+"?gateway_group_id="+ggID, bodyReq)
+	body, err := client.Put("/apisix/admin/plugin_metadata/"+opts.PluginName+"?gateway_group_id="+ggID, metadata)
 	if err != nil {
 		return fmt.Errorf("%s", cmdutil.FormatAPIError(err))
 	}
 
-	var updated api.PluginMetadata
-	if err := json.Unmarshal(body, &updated); err != nil {
-		return fmt.Errorf("failed to decode response: %w", err)
-	}
-
 	format := opts.Output
 	if format == "" {
 		format = "json"
 	}
-	exporter := cmdutil.NewExporter(format, opts.IO.Out)
-	return exporter.Write(updated)
+	return cmdutil.NewExporter(format, opts.IO.Out).Write(json.RawMessage(body))
 }

test/e2e/config_sync_test.go

@@ -15,11 +15,15 @@ import (
 func TestConfigSync_DryRun(t *testing.T) {
 	env := setupEnv(t)
 
-	// Create a config with a new route to sync.
-	syncYAML := `version: "1"
+	svcID := "e2e-sync-dryrun-svc"
+	createTestServiceViaCLI(t, env, svcID)
+	t.Cleanup(func() { deleteServiceViaAdmin(t, svcID) })
+
+	syncYAML := fmt.Sprintf(`version: "1"
 routes:
   - id: e2e-sync-dryrun-route
     name: e2e-sync-dryrun-route
+    service_id: %s
     paths:
       - /sync-dryrun
     upstream:
@@ -28,30 +32,32 @@ routes:
         - host: "127.0.0.1"
           port: 8080
           weight: 1
-`
+`, svcID)
 	tmpFile := filepath.Join(t.TempDir(), "sync-dryrun.yaml")
 	require.NoError(t, os.WriteFile(tmpFile, []byte(syncYAML), 0644))
 
-	// --dry-run should show what would change without applying.
 	stdout, stderr, err := runA7WithEnv(env, "config", "sync", "-f", tmpFile, "--dry-run", "-g", gatewayGroup)
 	require.NoError(t, err, "stdout=%s stderr=%s", stdout, stderr)
 
-	// The route should NOT exist after dry-run.
 	_, _, getErr := runA7WithEnv(env, "route", "get", "e2e-sync-dryrun-route", "-g", gatewayGroup)
 	assert.Error(t, getErr, "dry-run should not create resources")
 }
 
 func TestConfigSync_CreateAndCleanup(t *testing.T) {
 	env := setupEnv(t)
+	svcID := "e2e-sync-create-svc"
 	routeID := "e2e-sync-create-route"
-	t.Cleanup(func() { deleteRouteViaAdmin(t, routeID) })
+	createTestServiceViaCLI(t, env, svcID)
+	t.Cleanup(func() {
+		deleteRouteViaAdmin(t, routeID)
+		deleteServiceViaAdmin(t, svcID)
+	})
 
-	// Create a minimal config with just the new route
-	// and use --delete=false to avoid removing existing resources.
 	minimalYAML := fmt.Sprintf(`version: "1"
 routes:
   - id: %s
     name: %s
+    service_id: %s
     paths:
       - /sync-create-test
     upstream:
@@ -60,31 +66,32 @@ routes:
         - host: "127.0.0.1"
           port: 8080
           weight: 1
-`, routeID, routeID)
+`, routeID, routeID, svcID)
 
 	syncFile := filepath.Join(t.TempDir(), "sync-create.yaml")
 	require.NoError(t, os.WriteFile(syncFile, []byte(minimalYAML), 0644))
 
-	// Sync with --delete=false so we only create, not remove existing resources.
 	stdout, stderr, err := runA7WithEnv(env, "config", "sync", "-f", syncFile, "--delete=false", "-g", gatewayGroup)
 	require.NoError(t, err, "stdout=%s stderr=%s", stdout, stderr)
 	assert.Contains(t, stdout, "Sync completed")
 
-	// Verify route was created.
 	stdout, stderr, err = runA7WithEnv(env, "route", "get", routeID, "-g", gatewayGroup)
 	require.NoError(t, err, stderr)
 	assert.Contains(t, stdout, routeID)
 }
 
 func TestConfigSync_DeleteFalse(t *testing.T) {
 	env := setupEnv(t)
+	svcID := "e2e-sync-nodelete-svc"
 	routeID := "e2e-sync-nodelete-route"
-	t.Cleanup(func() { deleteRouteViaAdmin(t, routeID) })
+	createTestServiceViaCLI(t, env, svcID)
+	t.Cleanup(func() {
+		deleteRouteViaAdmin(t, routeID)
+		deleteServiceViaAdmin(t, svcID)
+	})
 
-	// First create a route via CLI.
-	createTestRouteViaCLI(t, env, routeID)
+	createTestRouteWithServiceViaCLI(t, env, routeID, svcID)
 
-	// Now sync an empty config with --delete=false.
 	emptyYAML := `version: "1"
 `
 	syncFile := filepath.Join(t.TempDir(), "sync-empty.yaml")
@@ -93,21 +100,23 @@ func TestConfigSync_DeleteFalse(t *testing.T) {
 	stdout, stderr, err := runA7WithEnv(env, "config", "sync", "-f", syncFile, "--delete=false", "-g", gatewayGroup)
 	require.NoError(t, err, "stdout=%s stderr=%s", stdout, stderr)
 
-	// Route should STILL exist because --delete=false.
 	stdout, stderr, err = runA7WithEnv(env, "route", "get", routeID, "-g", gatewayGroup)
 	require.NoError(t, err, stderr)
 	assert.Contains(t, stdout, routeID)
 }
 
 func TestConfigSync_FullRoundtrip(t *testing.T) {
 	env := setupEnv(t)
+	svcID := "e2e-sync-roundtrip-svc"
 	routeID := "e2e-sync-roundtrip-route"
-	t.Cleanup(func() { deleteRouteViaAdmin(t, routeID) })
+	createTestServiceViaCLI(t, env, svcID)
+	t.Cleanup(func() {
+		deleteRouteViaAdmin(t, routeID)
+		deleteServiceViaAdmin(t, svcID)
+	})
 
-	// Step 1: Create route via CLI.
-	createTestRouteViaCLI(t, env, routeID)
+	createTestRouteWithServiceViaCLI(t, env, routeID, svcID)
 
-	// Step 2: Dump current config.
 	dumpFile := filepath.Join(t.TempDir(), "roundtrip-dump.yaml")
 	_, stderr, err := runA7WithEnv(env, "config", "dump", "-g", gatewayGroup, "-f", dumpFile)
 	require.NoError(t, err, stderr)
@@ -116,11 +125,9 @@ func TestConfigSync_FullRoundtrip(t *testing.T) {
 	require.NoError(t, err)
 	assert.Contains(t, string(data), routeID)
 
-	// Step 3: Diff should show no differences.
 	stdout, stderr, err := runA7WithEnv(env, "config", "diff", "-f", dumpFile, "-g", gatewayGroup)
 	require.NoError(t, err, "stdout=%s stderr=%s", stdout, stderr)
 
-	// Step 4: Sync same config — should be a no-op.
 	stdout, stderr, err = runA7WithEnv(env, "config", "sync", "-f", dumpFile, "-g", gatewayGroup)
 	require.NoError(t, err, "stdout=%s stderr=%s", stdout, stderr)
 	assert.Contains(t, stdout, "Sync completed")

test/e2e/setup_test.go

@@ -299,6 +299,28 @@ func upstreamNodePort() int {
 	return 80
 }
 
+// createTestRouteWithServiceViaCLI creates a route that belongs to an existing service.
+// The service must already exist. This is needed because API7 EE requires service_id for routes.
+func createTestRouteWithServiceViaCLI(t *testing.T, env []string, routeID, serviceID string) {
+	t.Helper()
+	routeJSON := fmt.Sprintf(`{
+		"id": %q,
+		"name": "e2e-route-%s",
+		"service_id": %q,
+		"paths": ["/test-%s"],
+		"upstream": {
+			"type": "roundrobin",
+			"nodes": [{"host": %q, "port": %d, "weight": 1}]
+		}
+	}`, routeID, routeID, serviceID, routeID, upstreamNodeHost(), upstreamNodePort())
+
+	tmpFile := filepath.Join(t.TempDir(), "route.json")
+	require.NoError(t, os.WriteFile(tmpFile, []byte(routeJSON), 0644))
+
+	stdout, stderr, err := runA7WithEnv(env, "route", "create", "-f", tmpFile, "-g", gatewayGroup)
+	require.NoError(t, err, "stdout=%s stderr=%s", stdout, stderr)
+}
+
 func resolveFirstGatewayGroupID() (string, error) {
 	req, err := http.NewRequest(http.MethodGet, adminURL+"/api/gateway_groups", nil)
 	if err != nil {