diff --git a/.nextchanges/air/list-json-filter-errors.md b/.nextchanges/air/list-json-filter-errors.md new file mode 100644 index 00000000000..d80e7babf7a --- /dev/null +++ b/.nextchanges/air/list-json-filter-errors.md @@ -0,0 +1 @@ +* Return structured JSON errors for invalid `air list --filter` values when `-o json` is used. ([#7612](https://github.com/databricks/cli/pull/7612)) diff --git a/acceptance/air/list/output.txt b/acceptance/air/list/output.txt index 4c0c7ed3542..5f76708bf45 100644 --- a/acceptance/air/list/output.txt +++ b/acceptance/air/list/output.txt @@ -60,3 +60,22 @@ ] } } + +=== invalid filter (text) + +>>> musterr [CLI] air list --filter bogus=1 +Error: unsupported --filter key "bogus": supported keys are accelerator_type, experiment, num_accelerators, user + +=== invalid filter (json) + +>>> musterr [CLI] air list --filter bogus=1 -o json +{ + "v": 1, + "ts": "[TIMESTAMP]", + "error": { + "code": "INVALID_ARGS", + "kind": "PERMANENT", + "message": "unsupported --filter key \"bogus\": supported keys are accelerator_type, experiment, num_accelerators, user", + "retryable": false + } +} diff --git a/acceptance/air/list/script b/acceptance/air/list/script index 449b2a936e0..d22fca13ad6 100644 --- a/acceptance/air/list/script +++ b/acceptance/air/list/script @@ -9,3 +9,9 @@ trace $CLI air list --all-status title "list --all-status (json)" trace $CLI air list --all-status -o json + +title "invalid filter (text)" +trace musterr $CLI air list --filter bogus=1 + +title "invalid filter (json)" +trace musterr $CLI air list --filter bogus=1 -o json diff --git a/cmd/air/list.go b/cmd/air/list.go index a24e9f9f54b..0fa50c6a8d3 100644 --- a/cmd/air/list.go +++ b/cmd/air/list.go @@ -2,6 +2,7 @@ package aircmd import ( "context" + "errors" "fmt" "github.com/databricks/cli/cmd/root" @@ -134,7 +135,7 @@ Filters: f, err := parseListFilters(filters) if err != nil { - return err + return renderError(ctx, cmd, "INVALID_ARGS", "PERMANENT", false, err) } if f.AcceleratorType != "" { configureAcceleratorFilter(&f) @@ -185,7 +186,7 @@ Filters: if root.OutputType(cmd) == flags.OutputJSON { rows, err := fetcher.next(limit) if err != nil { - return err + return renderListFilterValidationError(ctx, cmd, err) } warnIfTruncated(ctx, fetcher) return renderEnvelope(ctx, listData{Rows: rows}) @@ -196,13 +197,45 @@ Filters: return cmd } +type listFilterValidationError struct { + message string + cause error + transient bool +} + +func (e *listFilterValidationError) Error() string { + return e.message +} + +func (e *listFilterValidationError) Unwrap() error { + return e.cause +} + +func renderListFilterValidationError(ctx context.Context, cmd *cobra.Command, err error) error { + validationErr, ok := errors.AsType[*listFilterValidationError](err) + if !ok { + return err + } + if validationErr.transient { + return renderError(ctx, cmd, "INTERNAL_ERROR", "TRANSIENT", true, err) + } + return renderError(ctx, cmd, "INVALID_ARGS", "PERMANENT", false, err) +} + func validateEmptyAcceleratorFilter(ctx context.Context, w *databricks.WorkspaceClient, value string) error { options, err := listWorkspaceComputeOptions(ctx, w) if err != nil { log.Debugf(ctx, "air list: could not validate accelerator filter against workspace compute options: %v", err) - return fmt.Errorf("no runs matched --filter accelerator_type=%q\nRetry or run 'databricks air run -h config.compute.accelerator_type' to check available types", value) + return &listFilterValidationError{ + message: fmt.Sprintf("no runs matched --filter accelerator_type=%q\nRetry or run 'databricks air run -h config.compute.accelerator_type' to check available types", value), + cause: err, + transient: true, + } + } + if err := validateAcceleratorFilter(value, options); err != nil { + return &listFilterValidationError{message: err.Error(), cause: err} } - return validateAcceleratorFilter(value, options) + return nil } // listStrategy is a source of matching runs, pulled in batches. Two implement it: diff --git a/cmd/air/list_test.go b/cmd/air/list_test.go index 81bdfd27c34..7afdd7d60c0 100644 --- a/cmd/air/list_test.go +++ b/cmd/air/list_test.go @@ -1,12 +1,14 @@ package aircmd import ( + "bytes" "encoding/json" "net/http" "net/http/httptest" "strconv" "testing" + "github.com/databricks/cli/cmd/root" "github.com/databricks/cli/libs/cmdctx" "github.com/databricks/cli/libs/cmdio" "github.com/databricks/cli/libs/flags" @@ -287,7 +289,7 @@ func TestListInvalidLimit(t *testing.T) { func TestListInvalidFilter(t *testing.T) { m := mocks.NewMockWorkspaceClient(t) ctx := cmdctx.SetWorkspaceClient(cmdio.MockDiscard(t.Context()), m.WorkspaceClient) - cmd := newListCommand() + cmd := withOutput(newListCommand(), flags.OutputText) cmd.SetContext(ctx) require.NoError(t, cmd.Flags().Set("filter", "bogus=1")) @@ -296,6 +298,57 @@ func TestListInvalidFilter(t *testing.T) { assert.Contains(t, err.Error(), "unsupported --filter key") } +func TestListInvalidFilterJSON(t *testing.T) { + tests := []struct { + name string + filter string + message string + }{ + { + name: "unsupported key", + filter: "bogus=1", + message: "unsupported --filter key \"bogus\": supported keys are accelerator_type, experiment, num_accelerators, user", + }, + { + name: "empty value", + filter: "user=", + message: "invalid --filter user=\"\": value cannot be empty", + }, + { + name: "invalid accelerator count", + filter: "num_accelerators=lots", + message: "invalid --filter num_accelerators=\"lots\": must be a positive integer", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + var buf bytes.Buffer + m := mocks.NewMockWorkspaceClient(t) + ctx := cmdio.InContext(t.Context(), cmdio.NewIO(t.Context(), flags.OutputJSON, nil, &buf, &buf, "", "")) + ctx = cmdctx.SetWorkspaceClient(ctx, m.WorkspaceClient) + cmd := withOutput(newListCommand(), flags.OutputJSON) + cmd.SetContext(ctx) + require.NoError(t, cmd.Flags().Set("filter", tt.filter)) + + err := cmd.RunE(cmd, nil) + require.ErrorIs(t, err, root.ErrAlreadyPrinted) + + var got map[string]any + require.NoError(t, json.Unmarshal(buf.Bytes(), &got)) + assert.Len(t, got, 3) + assert.InDelta(t, 1, got["v"], 0) + assert.NotEmpty(t, got["ts"]) + assert.Equal(t, map[string]any{ + "code": "INVALID_ARGS", + "kind": "PERMANENT", + "message": tt.message, + "retryable": false, + }, got["error"]) + }) + } +} + func TestListInvalidAcceleratorFilter(t *testing.T) { jobsCalled := false srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { @@ -326,6 +379,40 @@ func TestListInvalidAcceleratorFilter(t *testing.T) { assert.True(t, jobsCalled) } +func TestListInvalidAcceleratorFilterJSON(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + switch r.URL.Path { + case "/api/2.2/jobs/runs/list": + _, _ = w.Write([]byte(runsListBody(t, ""))) + case computeOptionsPath: + _, _ = w.Write([]byte(`{"compute_options":[{"hardware_accelerator":"GPU_8xH100","display_name":"8x H100"}]}`)) + default: + _, _ = w.Write([]byte(`{}`)) + } + })) + t.Cleanup(srv.Close) + + var buf bytes.Buffer + ctx := cmdio.InContext(t.Context(), cmdio.NewIO(t.Context(), flags.OutputJSON, nil, &buf, &buf, "", "")) + ctx = cmdctx.SetWorkspaceClient(ctx, newTestWorkspaceClient(t, srv.URL)) + cmd := withOutput(newListCommand(), flags.OutputJSON) + cmd.SetContext(ctx) + require.NoError(t, cmd.Flags().Set("all-users", "true")) + require.NoError(t, cmd.Flags().Set("filter", "accelerator_type=GPU_1xV100")) + + err := cmd.RunE(cmd, nil) + require.ErrorIs(t, err, root.ErrAlreadyPrinted) + + var got errorEnvelope + require.NoError(t, json.Unmarshal(buf.Bytes(), &got)) + assert.Equal(t, jsonError{ + Code: "INVALID_ARGS", + Kind: "PERMANENT", + Message: `invalid --filter accelerator_type="GPU_1xV100": valid values for this workspace include families (H100), full types (GPU_8xH100)`, + Retryable: false, + }, got.Error) +} + func TestListValidatesAcceleratorOnlyAfterNoMatches(t *testing.T) { for _, tc := range []struct { name string @@ -350,7 +437,9 @@ func TestListValidatesAcceleratorOnlyAfterNoMatches(t *testing.T) { })) t.Cleanup(srv.Close) - ctx := cmdctx.SetWorkspaceClient(cmdio.MockDiscard(t.Context()), newTestWorkspaceClient(t, srv.URL)) + var buf bytes.Buffer + ctx := cmdio.InContext(t.Context(), cmdio.NewIO(t.Context(), flags.OutputJSON, nil, &buf, &buf, "", "")) + ctx = cmdctx.SetWorkspaceClient(ctx, newTestWorkspaceClient(t, srv.URL)) cmd := withOutput(newListCommand(), flags.OutputJSON) cmd.SetContext(ctx) require.NoError(t, cmd.Flags().Set("all-users", "true")) @@ -358,8 +447,15 @@ func TestListValidatesAcceleratorOnlyAfterNoMatches(t *testing.T) { err := cmd.RunE(cmd, nil) if tc.wantErr { - require.Error(t, err) - assert.Equal(t, "no runs matched --filter accelerator_type=\"A10\"\nRetry or run 'databricks air run -h config.compute.accelerator_type' to check available types", err.Error()) + require.ErrorIs(t, err, root.ErrAlreadyPrinted) + var got errorEnvelope + require.NoError(t, json.Unmarshal(buf.Bytes(), &got)) + assert.Equal(t, jsonError{ + Code: "INTERNAL_ERROR", + Kind: "TRANSIENT", + Message: "no runs matched --filter accelerator_type=\"A10\"\nRetry or run 'databricks air run -h config.compute.accelerator_type' to check available types", + Retryable: true, + }, got.Error) assert.True(t, computeOptionsCalled) } else { require.NoError(t, err)