refactor(monit): remove retired API commands

Author: UlricQin

internal/cli/coverage_test.go

@@ -24,6 +24,14 @@ var curatedOperationIDs = map[string]bool{
 	"automation-trigger-write-fire": true,
 }
 
+// retiredOperationIDs bridges the release window where the server-side route
+// is gone but the CLI still compiles against the previous released SDK spec.
+var retiredOperationIDs = map[string]bool{
+	"monit-preview-sync":      true,
+	"monit-read-query-rows":   true,
+	"monit-rule-write-status": true,
+}
+
 // loadSpecOps reads every public GET/POST operation from the openapi spec
 // shipped in the linked go-flashduty module — the same spec cligen generates
 // against — recording each op's id, path, and whether its 200 response is a
@@ -80,6 +88,9 @@ func loadSpecPaths(t *testing.T) map[string]string {
 	t.Helper()
 	ids := map[string]string{}
 	for _, op := range loadSpecOps(t) {
+		if retiredOperationIDs[op.id] {
+			continue
+		}
 		ids[op.id] = op.path
 	}
 	return ids
@@ -158,6 +169,9 @@ func TestGeneratorTargetsFullSpec(t *testing.T) {
 	curated := map[string]bool{}
 	wantGenerated := map[string]bool{}
 	for _, op := range ops {
+		if retiredOperationIDs[op.id] {
+			continue
+		}
 		if op.streaming {
 			streaming[op.id] = true
 			continue

internal/cli/monit_query.go

@@ -1,7 +1,6 @@
 package cli
 
 import (
-	"encoding/json"
 	"fmt"
 	"strconv"
 
@@ -15,7 +14,6 @@ func newMonitQueryCmd() *cobra.Command {
 	cmd := newGroupCmd("monit-query", "Probe monit-backed datasources (9 types via data; diagnose: loki|victorialogs log patterns, prometheus metric trends)")
 	cmd.AddCommand(newMonitQueryDiagnoseCmd())
 	cmd.AddCommand(newMonitQueryDataCmd())
-	cmd.AddCommand(newMonitQueryRowsCmd())
 	return cmd
 }
 
@@ -135,74 +133,8 @@ func newMonitQueryDataCmd() *cobra.Command {
 	return cmd
 }
 
-func newMonitQueryRowsCmd() *cobra.Command {
-	var (
-		dsType, dsName, expr string
-		argsKV               []string
-	)
-
-	cmd := &cobra.Command{
-		Use:        "rows",
-		Short:      "Raw datasource passthrough (returns values/rows as the datasource itself would). Deprecated — prefer 'monit-query data'",
-		Deprecated: "use 'monit-query data' instead",
-		Long:       curatedLong("Deprecated. Raw datasource passthrough returning values/rows as the datasource itself would. Migrate to 'monit-query data', which preserves frames/records/samples without forcing results into legacy rows.", "Diagnostics", "QueryRows"),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			if dsType == "" || dsName == "" || expr == "" {
-				return fmt.Errorf("--ds-type, --ds-name, --expr are required")
-			}
-			argsMap, err := parseKVSlice(argsKV)
-			if err != nil {
-				return fmt.Errorf("invalid --args: %w", err)
-			}
-			if err := normalizeRawTimeArgs(dsType, argsMap); err != nil {
-				return err
-			}
-
-			return runCommand(cmd, args, func(ctx *RunContext) error {
-				input := &flashduty.QueryRowsRequest{
-					DsType: dsType,
-					DsName: dsName,
-					Expr:   expr,
-					Args:   argsMap,
-				}
-				result, _, err := ctx.Client.Diagnostics.QueryRows(cmdContext(ctx.Cmd), input)
-				if err != nil {
-					return err
-				}
-				// This command is a raw datasource passthrough. The legacy SDK
-				// captured the response body (a JSON array of {fields,values}
-				// objects) as a RawMessage and wrote it through verbatim,
-				// independent of the --json/--toon output format. go-flashduty
-				// decodes that same array into []QueryRow, so re-marshal it to
-				// the equivalent JSON array and write it through unchanged to
-				// preserve the legacy single-blob output shape.
-				if result == nil {
-					_, err = fmt.Fprintln(ctx.Writer, "{}")
-					return err
-				}
-				body, err := json.Marshal(*result)
-				if err != nil {
-					return fmt.Errorf("failed to marshal query rows: %w", err)
-				}
-				_, err = fmt.Fprintln(ctx.Writer, string(body))
-				return err
-			})
-		},
-	}
-
-	cmd.Flags().StringVar(&dsType, "ds-type", "", "Datasource type (required)")
-	cmd.Flags().StringVar(&dsName, "ds-name", "", "Datasource name (required)")
-	registerEnumFlag(cmd, "ds-type", "prometheus", "victorialogs", "loki", "mysql")
-	cmd.Flags().StringVar(&expr, "expr", "", "Query expression (required)")
-	cmd.Flags().StringSliceVar(&argsKV, "args", nil, "Arg entries KEY=VALUE (repeatable; values must be strings per monit-query contract). "+
-		"For loki/victorialogs raw mode, <ds-type>.start/<ds-type>.end accept a relative duration ('15m'), 'now', a date/RFC3339 timestamp, "+
-		"or a unix epoch in seconds or milliseconds — normalized to the form the datasource requires before sending")
-
-	return cmd
-}
-
 // normalizeRawTimeArgs rewrites the raw-mode time-window args of a
-// monit-query rows call (<ds-type>.start / <ds-type>.end) into the unix-
+// monit-query data call (<ds-type>.start / <ds-type>.end) into the unix-
 // seconds form the server requires, accepting any format timeutil.Parse
 // understands (RFC3339, date/datetime, relative duration, unix seconds or
 // milliseconds). Loki and VictoriaLogs are the only ds-types whose raw mode

internal/cli/monit_query_test.go

@@ -22,15 +22,6 @@ func TestMonitQueryDiagnoseFlags(t *testing.T) {
 	}
 }
 
-func TestMonitQueryRowsFlags(t *testing.T) {
-	cmd := newMonitQueryRowsCmd()
-	for _, name := range []string{"ds-type", "ds-name", "expr", "args"} {
-		if cmd.Flags().Lookup(name) == nil {
-			t.Errorf("flag --%s missing", name)
-		}
-	}
-}
-
 func TestMonitQueryDataFlags(t *testing.T) {
 	cmd := newMonitQueryDataCmd()
 	for _, name := range []string{"ds-type", "ds-name", "expr", "args", "delay-seconds"} {
@@ -209,7 +200,7 @@ func TestMonitQueryDiagnoseInvalidTimeStart(t *testing.T) {
 	}
 }
 
-// --- monit-query rows -----------------------------------------------------
+// --- monit-query data -----------------------------------------------------
 
 func TestMonitQueryDataHappyPath(t *testing.T) {
 	saveAndResetGlobals(t)
@@ -309,96 +300,6 @@ func TestMonitQueryDataRequiredFlags(t *testing.T) {
 	}
 }
 
-func TestMonitQueryRowsHappyPath(t *testing.T) {
-	saveAndResetGlobals(t)
-	stub := newGFStub(t)
-	// rows is a raw datasource passthrough: the response envelope "data" is a
-	// JSON array of QueryRow ({fields,values}) objects, decoded into
-	// QueryRowsResponse ([]QueryRow) and re-marshalled verbatim to the writer.
-	stub.data = []any{
-		map[string]any{
-			"fields": map[string]any{"instance": "node-1"},
-			"values": map[string]any{"__value__": 1},
-		},
-	}
-
-	out, err := execCommand(
-		"monit-query", "rows",
-		"--ds-type", "prometheus",
-		"--ds-name", "prom-prod",
-		"--expr", "up",
-		"--args", "step=15s",
-		"--args", "tenant=acme",
-	)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if stub.lastPath != "/monit/query/rows" {
-		t.Fatalf("expected /monit/query/rows, got %q", stub.lastPath)
-	}
-	body := stub.lastBody
-	if body["ds_type"] != "prometheus" || body["ds_name"] != "prom-prod" || body["expr"] != "up" {
-		t.Errorf("unexpected rows input: %#v", body)
-	}
-	args, _ := body["args"].(map[string]any)
-	if args["step"] != "15s" || args["tenant"] != "acme" {
-		t.Errorf("expected args step=15s tenant=acme, got %#v", args)
-	}
-	// The rendered output is the re-marshalled row array (passthrough shape).
-	if !strings.Contains(out, "node-1") || !strings.Contains(out, "__value__") {
-		t.Errorf("expected rendered rows to carry the datasource payload, got:\n%s", out)
-	}
-}
-
-func TestMonitQueryRowsRequiredFlags(t *testing.T) {
-	cases := []struct {
-		name string
-		args []string
-	}{
-		{
-			name: "missing ds-type",
-			args: []string{
-				"monit-query", "rows",
-				"--ds-name", "prom-prod",
-				"--expr", "up",
-			},
-		},
-		{
-			name: "missing ds-name",
-			args: []string{
-				"monit-query", "rows",
-				"--ds-type", "prometheus",
-				"--expr", "up",
-			},
-		},
-		{
-			name: "missing expr",
-			args: []string{
-				"monit-query", "rows",
-				"--ds-type", "prometheus",
-				"--ds-name", "prom-prod",
-			},
-		},
-	}
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			saveAndResetGlobals(t)
-			stub := newGFStub(t)
-
-			_, err := execCommand(tc.args...)
-			if err == nil {
-				t.Fatal("expected required-flag error, got nil")
-			}
-			if !strings.Contains(err.Error(), "required") {
-				t.Errorf("expected error to mention 'required', got %q", err.Error())
-			}
-			if stub.requests != 0 {
-				t.Errorf("rows should not have been called: %d request(s)", stub.requests)
-			}
-		})
-	}
-}
-
 // --- normalizeRawTimeArgs --------------------------------------------------
 
 func TestNormalizeRawTimeArgsAcceptedFormats(t *testing.T) {
@@ -469,17 +370,17 @@ func TestNormalizeRawTimeArgsInvalidValue(t *testing.T) {
 	}
 }
 
-// TestMonitQueryRowsRawModeNormalizesRFC3339 is the regression test for the
+// TestMonitQueryDataRawModeNormalizesRFC3339 is the regression test for the
 // raw-vs-stats time format inconsistency: a raw-mode VictoriaLogs query given
 // RFC3339 --args timestamps must reach the server as the unix-seconds form
 // the raw query path requires.
-func TestMonitQueryRowsRawModeNormalizesRFC3339(t *testing.T) {
+func TestMonitQueryDataRawModeNormalizesRFC3339(t *testing.T) {
 	saveAndResetGlobals(t)
 	stub := newGFStub(t)
-	stub.data = []any{}
+	stub.data = map[string]any{"format": "query_result.v1", "result": map[string]any{"kind": "records", "records": []any{}}}
 
 	_, err := execCommand(
-		"monit-query", "rows",
+		"monit-query", "data",
 		"--ds-type", "victorialogs",
 		"--ds-name", "vl-prod",
 		"--expr", `{app="api"} |= "error"`,
@@ -534,25 +435,3 @@ func TestMonitQueryDataInvalidArgs(t *testing.T) {
 		t.Errorf("data should not have been called: %d request(s)", stub.requests)
 	}
 }
-
-func TestMonitQueryRowsInvalidArgs(t *testing.T) {
-	saveAndResetGlobals(t)
-	stub := newGFStub(t)
-
-	_, err := execCommand(
-		"monit-query", "rows",
-		"--ds-type", "prometheus",
-		"--ds-name", "prom-prod",
-		"--expr", "up",
-		"--args", "no-equals-sign",
-	)
-	if err == nil {
-		t.Fatal("expected error for malformed --args, got nil")
-	}
-	if !strings.Contains(err.Error(), "--args") {
-		t.Errorf("expected error to mention --args, got %q", err.Error())
-	}
-	if stub.requests != 0 {
-		t.Errorf("rows should not have been called: %d request(s)", stub.requests)
-	}
-}