diff --git a/cmd/internal/config.go b/cmd/internal/config.go index 337c2cd237ec..97920f4b78c1 100644 --- a/cmd/internal/config.go +++ b/cmd/internal/config.go @@ -39,6 +39,7 @@ type Config struct { Tools server.ToolConfigs `yaml:"tools"` Toolsets server.ToolsetConfigs `yaml:"toolsets"` Prompts server.PromptConfigs `yaml:"prompts"` + PiiPolicies server.PiiPolicyConfigs `yaml:"piiPolicies"` } type ConfigParser struct { @@ -150,7 +151,7 @@ func (p *ConfigParser) ParseConfig(ctx context.Context, raw []byte) (Config, err } // Parse contents - config.Sources, config.AuthServices, config.EmbeddingModels, config.Tools, config.Toolsets, config.Prompts, err = server.UnmarshalResourceConfig(ctx, raw) + config.Sources, config.AuthServices, config.EmbeddingModels, config.Tools, config.Toolsets, config.Prompts, config.PiiPolicies, err = server.UnmarshalResourceConfig(ctx, raw) if err != nil { return config, err } @@ -180,7 +181,7 @@ func ConvertConfig(raw []byte) ([]byte, error) { decoder := yaml.NewDecoder(bytes.NewReader(raw), yaml.UseOrderedMap()) encoder := yaml.NewEncoder(&buf, yaml.UseLiteralStyleIfMultiline(true)) - nestedFormatKey := []string{"sources", "authServices", "embeddingModels", "tools", "toolsets", "prompts"} + nestedFormatKey := []string{"sources", "authServices", "embeddingModels", "tools", "toolsets", "prompts", "piiPolicies"} docIndex := 0 for { if err := decoder.Decode(&input); err != nil { @@ -217,6 +218,8 @@ func ConvertConfig(raw []byte) ([]byte, error) { key = "toolset" case "prompts": key = "prompt" + case "piiPolicies": + key = "piiPolicy" } transformed, err := transformDocs(key, slice) if err != nil { @@ -316,6 +319,7 @@ func mergeConfigs(files ...Config) (Config, error) { Tools: make(server.ToolConfigs), Toolsets: make(server.ToolsetConfigs), Prompts: make(server.PromptConfigs), + PiiPolicies: make(server.PiiPolicyConfigs), } var conflicts []string @@ -376,11 +380,20 @@ func mergeConfigs(files ...Config) (Config, error) { merged.Prompts[name] = prompt } } + + // Check for conflicts and merge piiPolicies + for name, piiPolicy := range file.PiiPolicies { + if _, exists := merged.PiiPolicies[name]; exists { + conflicts = append(conflicts, fmt.Sprintf("piiPolicy '%s' (file #%d)", name, fileIndex+1)) + } else { + merged.PiiPolicies[name] = piiPolicy + } + } } // If conflicts were detected, return an error if len(conflicts) > 0 { - return Config{}, fmt.Errorf("resource conflicts detected:\n - %s\n\nPlease ensure each source, authService, tool, toolset and prompt has a unique name across all files", strings.Join(conflicts, "\n - ")) + return Config{}, fmt.Errorf("resource conflicts detected:\n - %s\n\nPlease ensure each source, authService, tool, toolset, prompt and piiPolicy has a unique name across all files", strings.Join(conflicts, "\n - ")) } // Ensure only one authService has mcpEnabled = true diff --git a/cmd/internal/invoke/command.go b/cmd/internal/invoke/command.go index 531fbfcfd70c..df4ba3be3f4c 100644 --- a/cmd/internal/invoke/command.go +++ b/cmd/internal/invoke/command.go @@ -64,14 +64,14 @@ func runInvoke(cmd *cobra.Command, args []string, opts *internal.ToolboxOptions) } // Initialize Resources - sourcesMap, authServicesMap, embeddingModelsMap, toolsMap, toolsetsMap, promptsMap, promptsetsMap, err := server.InitializeConfigs(ctx, opts.Cfg) + sourcesMap, authServicesMap, embeddingModelsMap, toolsMap, toolsetsMap, promptsMap, promptsetsMap, _, err := server.InitializeConfigs(ctx, opts.Cfg) if err != nil { errMsg := fmt.Errorf("failed to initialize resources: %w", err) opts.Logger.ErrorContext(ctx, errMsg.Error()) return errMsg } - resourceMgr := resources.NewResourceManager(sourcesMap, authServicesMap, embeddingModelsMap, toolsMap, toolsetsMap, promptsMap, promptsetsMap) + resourceMgr := resources.NewResourceManager(sourcesMap, authServicesMap, embeddingModelsMap, toolsMap, toolsetsMap, promptsMap, promptsetsMap, nil) // Execute Tool toolName := args[0] diff --git a/cmd/internal/options.go b/cmd/internal/options.go index 3affd3aaf4ee..6fd5eecd2d1c 100644 --- a/cmd/internal/options.go +++ b/cmd/internal/options.go @@ -304,6 +304,7 @@ func (opts *ToolboxOptions) LoadConfig(ctx context.Context, parser *ConfigParser opts.Cfg.ToolConfigs = finalConfig.Tools opts.Cfg.ToolsetConfigs = finalConfig.Toolsets opts.Cfg.PromptConfigs = finalConfig.Prompts + opts.Cfg.PiiPolicyConfigs = finalConfig.PiiPolicies return isCustomConfigured, nil } diff --git a/cmd/internal/skills/command.go b/cmd/internal/skills/command.go index a51196c0de9f..2c94332ade3a 100644 --- a/cmd/internal/skills/command.go +++ b/cmd/internal/skills/command.go @@ -236,7 +236,7 @@ func (c *skillsCmd) collectTools(ctx context.Context, opts *internal.ToolboxOpti return nil, fmt.Errorf("failed to initialize resources: %w", err) } - resourceMgr := resources.NewResourceManager(nil, nil, nil, toolsMap, toolsetsMap, nil, nil) + resourceMgr := resources.NewResourceManager(nil, nil, nil, toolsMap, toolsetsMap, nil, nil, nil) skillsToTools := make(map[string]map[string]tools.Tool) diff --git a/cmd/root.go b/cmd/root.go index d5d8f40e7de0..4a8205fd948f 100644 --- a/cmd/root.go +++ b/cmd/root.go @@ -38,6 +38,7 @@ import ( "github.com/googleapis/mcp-toolbox/cmd/internal/skills" "github.com/googleapis/mcp-toolbox/internal/auth" "github.com/googleapis/mcp-toolbox/internal/embeddingmodels" + "github.com/googleapis/mcp-toolbox/internal/piipolicy" "github.com/googleapis/mcp-toolbox/internal/prompts" "github.com/googleapis/mcp-toolbox/internal/server" "github.com/googleapis/mcp-toolbox/internal/sources" @@ -138,14 +139,14 @@ func handleDynamicReload(ctx context.Context, toolsFile internal.Config, s *serv panic(err) } - sourcesMap, authServicesMap, embeddingModelsMap, toolsMap, toolsetsMap, promptsMap, promptsetsMap, err := validateReloadEdits(ctx, toolsFile) + sourcesMap, authServicesMap, embeddingModelsMap, toolsMap, toolsetsMap, promptsMap, promptsetsMap, piiPoliciesMap, err := validateReloadEdits(ctx, toolsFile) if err != nil { errMsg := fmt.Errorf("unable to validate reloaded edits: %w", err) logger.WarnContext(ctx, errMsg.Error()) return err } - s.ResourceMgr.SetResources(sourcesMap, authServicesMap, embeddingModelsMap, toolsMap, toolsetsMap, promptsMap, promptsetsMap) + s.ResourceMgr.SetResources(sourcesMap, authServicesMap, embeddingModelsMap, toolsMap, toolsetsMap, promptsMap, promptsetsMap, piiPoliciesMap) return nil } @@ -153,7 +154,7 @@ func handleDynamicReload(ctx context.Context, toolsFile internal.Config, s *serv // validateReloadEdits checks that the reloaded config configs can initialized without failing func validateReloadEdits( ctx context.Context, toolsFile internal.Config, -) (map[string]sources.Source, map[string]auth.AuthService, map[string]embeddingmodels.EmbeddingModel, map[string]tools.Tool, map[string]tools.Toolset, map[string]prompts.Prompt, map[string]prompts.Promptset, error, +) (map[string]sources.Source, map[string]auth.AuthService, map[string]embeddingmodels.EmbeddingModel, map[string]tools.Tool, map[string]tools.Toolset, map[string]prompts.Prompt, map[string]prompts.Promptset, map[string]piipolicy.Config, error, ) { logger, err := util.LoggerFromContext(ctx) if err != nil { @@ -181,14 +182,14 @@ func validateReloadEdits( IgnoreUnknownTools: util.IgnoreUnknownToolsFromContext(ctx), } - sourcesMap, authServicesMap, embeddingModelsMap, toolsMap, toolsetsMap, promptsMap, promptsetsMap, err := server.InitializeConfigs(ctx, reloadedConfig) + sourcesMap, authServicesMap, embeddingModelsMap, toolsMap, toolsetsMap, promptsMap, promptsetsMap, piiPoliciesMap, err := server.InitializeConfigs(ctx, reloadedConfig) if err != nil { errMsg := fmt.Errorf("unable to initialize reloaded configs: %w", err) logger.WarnContext(ctx, errMsg.Error()) - return nil, nil, nil, nil, nil, nil, nil, err + return nil, nil, nil, nil, nil, nil, nil, nil, err } - return sourcesMap, authServicesMap, embeddingModelsMap, toolsMap, toolsetsMap, promptsMap, promptsetsMap, nil + return sourcesMap, authServicesMap, embeddingModelsMap, toolsMap, toolsetsMap, promptsMap, promptsetsMap, piiPoliciesMap, nil } // Helper to check if a file has a newer ModTime than stored in the map diff --git a/internal/embeddingmodels/gemini/gemini_test.go b/internal/embeddingmodels/gemini/gemini_test.go index 707cbb09636f..ba014d8f3603 100644 --- a/internal/embeddingmodels/gemini/gemini_test.go +++ b/internal/embeddingmodels/gemini/gemini_test.go @@ -94,7 +94,7 @@ func TestParseFromYamlGemini(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, got, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + _, _, got, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -149,7 +149,7 @@ func TestFailParseFromYamlGemini(t *testing.T) { t.Setenv("GOOGLE_CLOUD_PROJECT", "") t.Setenv("GOOGLE_CLOUD_LOCATION", "") - _, embeddingConfigs, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + _, embeddingConfigs, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err != nil { if err.Error() != tc.err { t.Fatalf("unexpected unmarshal error:\ngot: %q\nwant: %q", err.Error(), tc.err) diff --git a/internal/piipolicy/engine.go b/internal/piipolicy/engine.go new file mode 100644 index 000000000000..c8c98fc6a072 --- /dev/null +++ b/internal/piipolicy/engine.go @@ -0,0 +1,192 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package piipolicy + +import ( + "context" + "encoding/json" + "fmt" + "regexp" + "strings" +) + +// ApplyPolicy evaluates the PII policy against the provided data given the user's claims. +func ApplyPolicy(ctx context.Context, config Config, claims map[string]any, data any) (any, error) { + if len(config.Rules) == 0 { + return data, nil // Nothing to do + } + + // Determine the user's tier based on the claim + tier := "" + if config.TierClaim != "" && claims != nil { + if val, ok := claims[config.TierClaim]; ok { + if strVal, ok := val.(string); ok { + tier = strVal + } + } + } + + switch v := data.(type) { + case string: + return applyToString(v, config.Rules, tier) + case map[string]any: + return applyToMap(ctx, config, claims, tier, v) + case []map[string]any: + return applyToMapSlice(ctx, config, claims, tier, v) + case []any: + var out []any + for _, el := range v { + res, err := ApplyPolicy(ctx, config, claims, el) + if err != nil { + return nil, err + } + out = append(out, res) + } + return out, nil + default: + // Attempt to convert struct to map/slice using JSON + bytes, err := json.Marshal(data) + if err == nil { + var parsed any + if err := json.Unmarshal(bytes, &parsed); err == nil { + // Prevent infinite loop if type doesn't change + if fmt.Sprintf("%T", parsed) != fmt.Sprintf("%T", data) { + return ApplyPolicy(ctx, config, claims, parsed) + } + } + } + // Unsupported type, return as is + return data, nil + } +} + +func getActionForRule(rule Rule, tier string) Action { + if action, ok := rule.Actions[tier]; ok && tier != "" { + return action + } + if action, ok := rule.Actions["default"]; ok { + return action + } + // Fallback secure default + return MaskFull +} + +func applyToString(data string, rules []Rule, tier string) (string, error) { + result := data + for _, rule := range rules { + if rule.Pattern == "" { + continue // Column-based rule, skip for unstructured text + } + action := getActionForRule(rule, tier) + if action == Unmask { + continue + } + + re, err := regexp.Compile(rule.Pattern) + if err != nil { + return "", fmt.Errorf("invalid pattern in rule %q: %w", rule.Name, err) + } + + result = re.ReplaceAllStringFunc(result, func(match string) string { + return applyActionToString(action, match) + }) + } + return result, nil +} + +func applyToMapSlice(ctx context.Context, config Config, claims map[string]any, tier string, data []map[string]any) ([]map[string]any, error) { + var out []map[string]any + for _, m := range data { + res, err := applyToMap(ctx, config, claims, tier, m) + if err != nil { + return nil, err + } + out = append(out, res) + } + return out, nil +} + +func applyToMap(ctx context.Context, config Config, claims map[string]any, tier string, data map[string]any) (map[string]any, error) { + out := make(map[string]any, len(data)) + for k, v := range data { + res, err := ApplyPolicy(ctx, config, claims, v) + if err != nil { + return nil, err + } + out[k] = res + } + + for _, rule := range config.Rules { + if rule.Column == "" { + // Try applying pattern if value is a string, even in structured data + if rule.Pattern != "" { + for k, v := range out { + if strVal, ok := v.(string); ok { + action := getActionForRule(rule, tier) + if action == Unmask { + continue + } + re, err := regexp.Compile(rule.Pattern) + if err != nil { + return nil, fmt.Errorf("invalid pattern in rule %q: %w", rule.Name, err) + } + out[k] = re.ReplaceAllStringFunc(strVal, func(match string) string { + return applyActionToString(action, match) + }) + } + } + } + continue + } + + // Exact column match + if val, exists := out[rule.Column]; exists { + action := getActionForRule(rule, tier) + if action == Unmask { + continue + } + if action == DenyField { + out[rule.Column] = "[DENIED]" + continue + } + + // Apply masking + if strVal, ok := val.(string); ok { + out[rule.Column] = applyActionToString(action, strVal) + } else { + // Non-string value masked entirely + out[rule.Column] = "***" + } + } + } + return out, nil +} + +func applyActionToString(action Action, val string) string { + switch action { + case MaskFull: + return strings.Repeat("*", len(val)) + case MaskPartial: + if len(val) <= 2 { + return strings.Repeat("*", len(val)) + } + visibleLen := len(val) / 2 + return val[:visibleLen] + strings.Repeat("*", len(val)-visibleLen) + case DenyField: + return "[DENIED]" + default: + return val // Unmask or unknown + } +} diff --git a/internal/piipolicy/engine_test.go b/internal/piipolicy/engine_test.go new file mode 100644 index 000000000000..a4fcbda5822d --- /dev/null +++ b/internal/piipolicy/engine_test.go @@ -0,0 +1,117 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package piipolicy + +import ( + "context" + "testing" + + "github.com/google/go-cmp/cmp" +) + +func TestApplyPolicy(t *testing.T) { + ctx := context.Background() + + config := Config{ + Name: "test_policy", + TierClaim: "role", + Rules: []Rule{ + { + Name: "mask_emails", + Pattern: `[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}`, + Actions: map[string]Action{ + "admin": Unmask, + "user": MaskPartial, + "default": MaskFull, + }, + }, + { + Name: "mask_ssn_column", + Column: "ssn", + Actions: map[string]Action{ + "admin": Unmask, + "default": MaskFull, + }, + }, + { + Name: "deny_password_column", + Column: "password", + Actions: map[string]Action{ + "default": DenyField, + }, + }, + }, + } + + tests := []struct { + name string + claims map[string]any + data any + wantResult any + wantErr bool + }{ + { + name: "unstructured_admin_unmask", + claims: map[string]any{"role": "admin"}, + data: "Contact me at admin@example.com for more info.", + wantResult: "Contact me at admin@example.com for more info.", + }, + { + name: "unstructured_user_partial", + claims: map[string]any{"role": "user"}, + data: "Contact me at test@example.com for more info.", + wantResult: "Contact me at test@exa******** for more info.", + }, + { + name: "unstructured_guest_full", + claims: map[string]any{"role": "guest"}, + data: "Contact me at test@example.com.", + wantResult: "Contact me at ****************.", + }, + { + name: "structured_admin_unmask", + claims: map[string]any{"role": "admin"}, + data: []map[string]any{ + {"name": "Alice", "ssn": "123-45-678", "password": "secret_password"}, + }, + wantResult: []map[string]any{ + {"name": "Alice", "ssn": "123-45-678", "password": "[DENIED]"}, + }, + }, + { + name: "structured_user_full_mask_ssn", + claims: map[string]any{"role": "user"}, + data: []map[string]any{ + {"name": "Alice", "email": "alice@example.com", "ssn": "123-45-678", "password": "secret_password"}, + }, + wantResult: []map[string]any{ + {"name": "Alice", "email": "alice@ex*********", "ssn": "**********", "password": "[DENIED]"}, + }, + }, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + got, err := ApplyPolicy(ctx, config, tc.claims, tc.data) + if (err != nil) != tc.wantErr { + t.Errorf("ApplyPolicy() error = %v, wantErr %v", err, tc.wantErr) + return + } + if !cmp.Equal(got, tc.wantResult) { + t.Errorf("ApplyPolicy() diff = %v", cmp.Diff(tc.wantResult, got)) + } + }) + } +} diff --git a/internal/piipolicy/piipolicy.go b/internal/piipolicy/piipolicy.go new file mode 100644 index 000000000000..0465f66e0e21 --- /dev/null +++ b/internal/piipolicy/piipolicy.go @@ -0,0 +1,37 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package piipolicy + +type Action string + +const ( + Unmask Action = "UNMASK" + MaskPartial Action = "MASK_PARTIAL" + MaskFull Action = "MASK_FULL" + DenyField Action = "DENY_FIELD" +) + +type Rule struct { + Name string `yaml:"name"` + Pattern string `yaml:"pattern,omitempty"` // Regex pattern for unstructured text + Column string `yaml:"column,omitempty"` // Column name for structured data + Actions map[string]Action `yaml:"actions"` // e.g., "admin": UNMASK, "default": MASK_FULL +} + +type Config struct { + Name string `yaml:"name"` + TierClaim string `yaml:"tierClaim"` // e.g., "role" + Rules []Rule `yaml:"rules"` +} diff --git a/internal/server/common_test.go b/internal/server/common_test.go index 2e4251788f02..30bd5a655019 100644 --- a/internal/server/common_test.go +++ b/internal/server/common_test.go @@ -59,7 +59,7 @@ func setUpServer(t *testing.T, router string, tools map[string]tools.Tool, tools sseManager := newSseManager(ctx) - resourceManager := resources.NewResourceManager(nil, nil, nil, tools, toolsets, prompts, promptsets) + resourceManager := resources.NewResourceManager(nil, nil, nil, tools, toolsets, prompts, promptsets, nil) server := Server{ version: testutils.MockVersionString, diff --git a/internal/server/config.go b/internal/server/config.go index e0a7e794e335..155649dd9e27 100644 --- a/internal/server/config.go +++ b/internal/server/config.go @@ -30,6 +30,7 @@ import ( "github.com/googleapis/mcp-toolbox/internal/auth/google" "github.com/googleapis/mcp-toolbox/internal/embeddingmodels" "github.com/googleapis/mcp-toolbox/internal/embeddingmodels/gemini" + "github.com/googleapis/mcp-toolbox/internal/piipolicy" "github.com/googleapis/mcp-toolbox/internal/prompts" "github.com/googleapis/mcp-toolbox/internal/sources" "github.com/googleapis/mcp-toolbox/internal/tools" @@ -61,6 +62,8 @@ type ServerConfig struct { PromptConfigs PromptConfigs // PromptsetConfigs defines what prompts are available PromptsetConfigs PromptsetConfigs + // PiiPolicyConfigs defines what PII masking policies are available. + PiiPolicyConfigs PiiPolicyConfigs // IgnoreUnknownTools logs warnings and skips unknown/unsupported tool types instead of failing to start. IgnoreUnknownTools bool // LoggingFormat defines whether structured loggings are used. @@ -160,8 +163,9 @@ type ToolConfigs map[string]tools.ToolConfig type ToolsetConfigs map[string]tools.ToolsetConfig type PromptConfigs map[string]prompts.PromptConfig type PromptsetConfigs map[string]prompts.PromptsetConfig +type PiiPolicyConfigs map[string]piipolicy.Config -func UnmarshalResourceConfig(ctx context.Context, raw []byte) (SourceConfigs, AuthServiceConfigs, EmbeddingModelConfigs, ToolConfigs, ToolsetConfigs, PromptConfigs, error) { +func UnmarshalResourceConfig(ctx context.Context, raw []byte) (SourceConfigs, AuthServiceConfigs, EmbeddingModelConfigs, ToolConfigs, ToolsetConfigs, PromptConfigs, PiiPolicyConfigs, error) { // prepare configs map var sourceConfigs SourceConfigs var authServiceConfigs AuthServiceConfigs @@ -169,11 +173,12 @@ func UnmarshalResourceConfig(ctx context.Context, raw []byte) (SourceConfigs, Au var toolConfigs ToolConfigs var toolsetConfigs ToolsetConfigs var promptConfigs PromptConfigs + var piiPolicyConfigs PiiPolicyConfigs // promptset configs is not yet supported file, err := parser.ParseBytes(raw, 0) if err != nil { - return nil, nil, nil, nil, nil, nil, fmt.Errorf("unable to parse YAML: %s", yaml.FormatError(err, false, false)) + return nil, nil, nil, nil, nil, nil, nil, fmt.Errorf("unable to parse YAML: %s", yaml.FormatError(err, false, false)) } decoder := yaml.NewDecoder(bytes.NewReader(raw)) @@ -185,17 +190,17 @@ func UnmarshalResourceConfig(ctx context.Context, raw []byte) (SourceConfigs, Au var resource map[string]any if err := decoder.DecodeFromNodeContext(ctx, doc.Body, &resource); err != nil { if len(file.Docs) > 1 { - return nil, nil, nil, nil, nil, nil, fmt.Errorf("document %d: %s", docIndex, yaml.FormatError(err, false, false)) + return nil, nil, nil, nil, nil, nil, nil, fmt.Errorf("document %d: %s", docIndex, yaml.FormatError(err, false, false)) } - return nil, nil, nil, nil, nil, nil, fmt.Errorf("unable to decode YAML document: %s", yaml.FormatError(err, false, false)) + return nil, nil, nil, nil, nil, nil, nil, fmt.Errorf("unable to decode YAML document: %s", yaml.FormatError(err, false, false)) } var kind, name string var ok bool if kind, ok = resource["kind"].(string); !ok { if len(file.Docs) > 1 { - return nil, nil, nil, nil, nil, nil, fmt.Errorf("%s missing 'kind' field or it is not a string", formatDocLocation(docIndex, keyToken(doc.Body, "kind"), doc.Body)) + return nil, nil, nil, nil, nil, nil, nil, fmt.Errorf("%s missing 'kind' field or it is not a string", formatDocLocation(docIndex, keyToken(doc.Body, "kind"), doc.Body)) } - return nil, nil, nil, nil, nil, nil, fmt.Errorf("missing 'kind' field or it is not a string: %v", resource) + return nil, nil, nil, nil, nil, nil, nil, fmt.Errorf("missing 'kind' field or it is not a string: %v", resource) } if name, ok = resource["name"].(string); !ok { if len(file.Docs) > 1 { @@ -203,9 +208,9 @@ func UnmarshalResourceConfig(ctx context.Context, raw []byte) (SourceConfigs, Au if fallbackToken == nil { fallbackToken = keyToken(doc.Body, "kind") } - return nil, nil, nil, nil, nil, nil, fmt.Errorf("%s missing 'name' field or it is not a string", formatDocLocation(docIndex, fallbackToken, doc.Body)) + return nil, nil, nil, nil, nil, nil, nil, fmt.Errorf("%s missing 'name' field or it is not a string", formatDocLocation(docIndex, fallbackToken, doc.Body)) } - return nil, nil, nil, nil, nil, nil, fmt.Errorf("missing 'name' field or it is not a string") + return nil, nil, nil, nil, nil, nil, nil, fmt.Errorf("missing 'name' field or it is not a string") } // remove 'kind' from map for strict unmarshaling delete(resource, "kind") @@ -215,9 +220,9 @@ func UnmarshalResourceConfig(ctx context.Context, raw []byte) (SourceConfigs, Au c, err := UnmarshalYAMLSourceConfig(ctx, name, resource) if err != nil { if len(file.Docs) > 1 { - return nil, nil, nil, nil, nil, nil, fmt.Errorf("document %d: error unmarshaling %s %q: %w", docIndex, kind, name, err) + return nil, nil, nil, nil, nil, nil, nil, fmt.Errorf("document %d: error unmarshaling %s %q: %w", docIndex, kind, name, err) } - return nil, nil, nil, nil, nil, nil, fmt.Errorf("error unmarshaling %s: %w", kind, err) + return nil, nil, nil, nil, nil, nil, nil, fmt.Errorf("error unmarshaling %s: %w", kind, err) } if sourceConfigs == nil { sourceConfigs = make(SourceConfigs) @@ -227,9 +232,9 @@ func UnmarshalResourceConfig(ctx context.Context, raw []byte) (SourceConfigs, Au c, err := UnmarshalYAMLAuthServiceConfig(ctx, name, resource) if err != nil { if len(file.Docs) > 1 { - return nil, nil, nil, nil, nil, nil, fmt.Errorf("document %d: error unmarshaling %s %q: %w", docIndex, kind, name, err) + return nil, nil, nil, nil, nil, nil, nil, fmt.Errorf("document %d: error unmarshaling %s %q: %w", docIndex, kind, name, err) } - return nil, nil, nil, nil, nil, nil, fmt.Errorf("error unmarshaling %s: %w", kind, err) + return nil, nil, nil, nil, nil, nil, nil, fmt.Errorf("error unmarshaling %s: %w", kind, err) } if authServiceConfigs == nil { authServiceConfigs = make(AuthServiceConfigs) @@ -239,9 +244,9 @@ func UnmarshalResourceConfig(ctx context.Context, raw []byte) (SourceConfigs, Au c, err := UnmarshalYAMLToolConfig(ctx, name, resource) if err != nil { if len(file.Docs) > 1 { - return nil, nil, nil, nil, nil, nil, fmt.Errorf("document %d: error unmarshaling %s %q: %w", docIndex, kind, name, err) + return nil, nil, nil, nil, nil, nil, nil, fmt.Errorf("document %d: error unmarshaling %s %q: %w", docIndex, kind, name, err) } - return nil, nil, nil, nil, nil, nil, fmt.Errorf("error unmarshaling %s: %w", kind, err) + return nil, nil, nil, nil, nil, nil, nil, fmt.Errorf("error unmarshaling %s: %w", kind, err) } if c == nil { continue @@ -254,9 +259,9 @@ func UnmarshalResourceConfig(ctx context.Context, raw []byte) (SourceConfigs, Au c, err := UnmarshalYAMLToolsetConfig(ctx, name, resource) if err != nil { if len(file.Docs) > 1 { - return nil, nil, nil, nil, nil, nil, fmt.Errorf("document %d: error unmarshaling %s %q: %w", docIndex, kind, name, err) + return nil, nil, nil, nil, nil, nil, nil, fmt.Errorf("document %d: error unmarshaling %s %q: %w", docIndex, kind, name, err) } - return nil, nil, nil, nil, nil, nil, fmt.Errorf("error unmarshaling %s: %w", kind, err) + return nil, nil, nil, nil, nil, nil, nil, fmt.Errorf("error unmarshaling %s: %w", kind, err) } if toolsetConfigs == nil { toolsetConfigs = make(ToolsetConfigs) @@ -266,9 +271,9 @@ func UnmarshalResourceConfig(ctx context.Context, raw []byte) (SourceConfigs, Au c, err := UnmarshalYAMLEmbeddingModelConfig(ctx, name, resource) if err != nil { if len(file.Docs) > 1 { - return nil, nil, nil, nil, nil, nil, fmt.Errorf("document %d: error unmarshaling %s %q: %w", docIndex, kind, name, err) + return nil, nil, nil, nil, nil, nil, nil, fmt.Errorf("document %d: error unmarshaling %s %q: %w", docIndex, kind, name, err) } - return nil, nil, nil, nil, nil, nil, fmt.Errorf("error unmarshaling %s: %w", kind, err) + return nil, nil, nil, nil, nil, nil, nil, fmt.Errorf("error unmarshaling %s: %w", kind, err) } if embeddingModelConfigs == nil { embeddingModelConfigs = make(EmbeddingModelConfigs) @@ -278,22 +283,34 @@ func UnmarshalResourceConfig(ctx context.Context, raw []byte) (SourceConfigs, Au c, err := UnmarshalYAMLPromptConfig(ctx, name, resource) if err != nil { if len(file.Docs) > 1 { - return nil, nil, nil, nil, nil, nil, fmt.Errorf("document %d: error unmarshaling %s %q: %w", docIndex, kind, name, err) + return nil, nil, nil, nil, nil, nil, nil, fmt.Errorf("document %d: error unmarshaling %s %q: %w", docIndex, kind, name, err) } - return nil, nil, nil, nil, nil, nil, fmt.Errorf("error unmarshaling %s: %w", kind, err) + return nil, nil, nil, nil, nil, nil, nil, fmt.Errorf("error unmarshaling %s: %w", kind, err) } if promptConfigs == nil { promptConfigs = make(PromptConfigs) } promptConfigs[name] = c + case "piiPolicy": + c, err := UnmarshalYAMLPiiPolicyConfig(ctx, name, resource) + if err != nil { + if len(file.Docs) > 1 { + return nil, nil, nil, nil, nil, nil, nil, fmt.Errorf("document %d: error unmarshaling %s %q: %w", docIndex, kind, name, err) + } + return nil, nil, nil, nil, nil, nil, nil, fmt.Errorf("error unmarshaling %s: %w", kind, err) + } + if piiPolicyConfigs == nil { + piiPolicyConfigs = make(PiiPolicyConfigs) + } + piiPolicyConfigs[name] = c default: if len(file.Docs) > 1 { - return nil, nil, nil, nil, nil, nil, fmt.Errorf("%s invalid kind %q", formatDocLocation(docIndex, keyToken(doc.Body, "kind"), doc.Body), kind) + return nil, nil, nil, nil, nil, nil, nil, fmt.Errorf("%s invalid kind %q", formatDocLocation(docIndex, keyToken(doc.Body, "kind"), doc.Body), kind) } - return nil, nil, nil, nil, nil, nil, fmt.Errorf("invalid kind %s", kind) + return nil, nil, nil, nil, nil, nil, nil, fmt.Errorf("invalid kind %s", kind) } } - return sourceConfigs, authServiceConfigs, embeddingModelConfigs, toolConfigs, toolsetConfigs, promptConfigs, nil + return sourceConfigs, authServiceConfigs, embeddingModelConfigs, toolConfigs, toolsetConfigs, promptConfigs, piiPolicyConfigs, nil } func UnmarshalYAMLSourceConfig(ctx context.Context, name string, r map[string]any) (sources.SourceConfig, error) { @@ -564,3 +581,16 @@ func keyToken(body ast.Node, key string) *token.Token { } return nil } + +func UnmarshalYAMLPiiPolicyConfig(ctx context.Context, name string, r map[string]any) (piipolicy.Config, error) { + dec, err := util.NewStrictDecoder(r) + if err != nil { + return piipolicy.Config{}, fmt.Errorf("error creating decoder: %w", err) + } + var actual piipolicy.Config + if err := dec.DecodeContext(ctx, &actual); err != nil { + return piipolicy.Config{}, fmt.Errorf("unable to parse as %s: %w", name, err) + } + actual.Name = name + return actual, nil +} diff --git a/internal/server/mcp/v20241105/method.go b/internal/server/mcp/v20241105/method.go index f97596b7bb5f..46757dce829d 100644 --- a/internal/server/mcp/v20241105/method.go +++ b/internal/server/mcp/v20241105/method.go @@ -25,6 +25,7 @@ import ( "time" "github.com/googleapis/mcp-toolbox/internal/auth" + "github.com/googleapis/mcp-toolbox/internal/piipolicy" "github.com/googleapis/mcp-toolbox/internal/prompts" "github.com/googleapis/mcp-toolbox/internal/server/mcp/jsonrpc" mcputil "github.com/googleapis/mcp-toolbox/internal/server/mcp/util" @@ -305,6 +306,33 @@ func toolsCallHandler(ctx context.Context, id jsonrpc.RequestId, toolset tools.T results, err := tool.Invoke(ctx, resourceMgr, params, accessToken) executionDuration := time.Since(executionStart).Seconds() + // Apply PII policy masking if configured + if err == nil { + if piiPolicyName := tool.GetPiiPolicy(); piiPolicyName != "" { + if policy, exists := resourceMgr.GetPiiPolicy(piiPolicyName); exists { + var combinedClaims map[string]any + if len(claimsFromAuth) > 0 { + // Merge all claims for policy evaluation + combinedClaims = make(map[string]any) + for _, claims := range claimsFromAuth { + for k, v := range claims { + combinedClaims[k] = v + } + } + } + results, err = piipolicy.ApplyPolicy(ctx, policy, combinedClaims, results) + if err != nil { + err = fmt.Errorf("error applying pii policy %q: %w", piiPolicyName, err) + return jsonrpc.NewError(id, jsonrpc.INTERNAL_ERROR, err.Error(), nil), err + } + } else { + err = fmt.Errorf("pii policy %q not found", piiPolicyName) + return jsonrpc.NewError(id, jsonrpc.INTERNAL_ERROR, err.Error(), nil), err + } + } + } + + // Record tool execution duration metric if instrumentationErr == nil { execAttrs := []attribute.KeyValue{ diff --git a/internal/server/mcp/v20241105/method_test.go b/internal/server/mcp/v20241105/method_test.go index b4b66033d1fe..9983e4d8ba68 100644 --- a/internal/server/mcp/v20241105/method_test.go +++ b/internal/server/mcp/v20241105/method_test.go @@ -168,7 +168,7 @@ func TestToolsListHandler(t *testing.T) { // Initialize tools using provided testutils mock instances mockTools := []testutils.MockTool{testutils.MockTool1, testutils.MockTool2} toolsMap, toolsets, promptsMap, promptsets := testutils.SetUpResources(t, mockTools, nil) - resourceMgr := resources.NewResourceManager(nil, nil, nil, toolsMap, toolsets, promptsMap, promptsets) + resourceMgr := resources.NewResourceManager(nil, nil, nil, toolsMap, toolsets, promptsMap, promptsets, nil) tests := []struct { name string @@ -257,7 +257,7 @@ func TestToolsCallHandler(t *testing.T) { testutils.MockTool5, } toolsMap, toolsets, promptsMap, promptsets := testutils.SetUpResources(t, mockTools, nil) - resourceMgr := resources.NewResourceManager(nil, nil, nil, toolsMap, toolsets, promptsMap, promptsets) + resourceMgr := resources.NewResourceManager(nil, nil, nil, toolsMap, toolsets, promptsMap, promptsets, nil) tests := []struct { name string @@ -385,7 +385,7 @@ func TestPromptsListHandler(t *testing.T) { // Initialize prompts mockPrompts := []testutils.MockPrompt{testutils.MockPrompt1, testutils.MockPrompt2} toolsMap, toolsets, promptsMap, promptsets := testutils.SetUpResources(t, nil, mockPrompts) - resourceMgr := resources.NewResourceManager(nil, nil, nil, toolsMap, toolsets, promptsMap, promptsets) + resourceMgr := resources.NewResourceManager(nil, nil, nil, toolsMap, toolsets, promptsMap, promptsets, nil) tests := []struct { name string body ListPromptsRequest @@ -454,7 +454,7 @@ func TestPromptsGetHandler(t *testing.T) { // Initialize prompts mockPrompts := []testutils.MockPrompt{testutils.MockPrompt1, testutils.MockPrompt2} toolsMap, toolsets, promptsMap, promptsets := testutils.SetUpResources(t, nil, mockPrompts) - resourceMgr := resources.NewResourceManager(nil, nil, nil, toolsMap, toolsets, promptsMap, promptsets) + resourceMgr := resources.NewResourceManager(nil, nil, nil, toolsMap, toolsets, promptsMap, promptsets, nil) tests := []struct { name string body GetPromptRequest diff --git a/internal/server/mcp/v20250326/method.go b/internal/server/mcp/v20250326/method.go index fe1dbf8d5b2c..ec5a4eba2544 100644 --- a/internal/server/mcp/v20250326/method.go +++ b/internal/server/mcp/v20250326/method.go @@ -25,6 +25,7 @@ import ( "time" "github.com/googleapis/mcp-toolbox/internal/auth" + "github.com/googleapis/mcp-toolbox/internal/piipolicy" "github.com/googleapis/mcp-toolbox/internal/prompts" "github.com/googleapis/mcp-toolbox/internal/server/mcp/jsonrpc" mcputil "github.com/googleapis/mcp-toolbox/internal/server/mcp/util" @@ -305,6 +306,33 @@ func toolsCallHandler(ctx context.Context, id jsonrpc.RequestId, toolset tools.T results, err := tool.Invoke(ctx, resourceMgr, params, accessToken) executionDuration := time.Since(executionStart).Seconds() + // Apply PII policy masking if configured + if err == nil { + if piiPolicyName := tool.GetPiiPolicy(); piiPolicyName != "" { + if policy, exists := resourceMgr.GetPiiPolicy(piiPolicyName); exists { + var combinedClaims map[string]any + if len(claimsFromAuth) > 0 { + // Merge all claims for policy evaluation + combinedClaims = make(map[string]any) + for _, claims := range claimsFromAuth { + for k, v := range claims { + combinedClaims[k] = v + } + } + } + results, err = piipolicy.ApplyPolicy(ctx, policy, combinedClaims, results) + if err != nil { + err = fmt.Errorf("error applying pii policy %q: %w", piiPolicyName, err) + return jsonrpc.NewError(id, jsonrpc.INTERNAL_ERROR, err.Error(), nil), err + } + } else { + err = fmt.Errorf("pii policy %q not found", piiPolicyName) + return jsonrpc.NewError(id, jsonrpc.INTERNAL_ERROR, err.Error(), nil), err + } + } + } + + // Record tool execution duration metric if instrumentationErr == nil { execAttrs := []attribute.KeyValue{ diff --git a/internal/server/mcp/v20250326/method_test.go b/internal/server/mcp/v20250326/method_test.go index 17cc81136502..5503bb5d5986 100644 --- a/internal/server/mcp/v20250326/method_test.go +++ b/internal/server/mcp/v20250326/method_test.go @@ -168,7 +168,7 @@ func TestToolsListHandler(t *testing.T) { // Initialize tools using provided testutils mock instances mockTools := []testutils.MockTool{testutils.MockTool1, testutils.MockTool2} toolsMap, toolsets, promptsMap, promptsets := testutils.SetUpResources(t, mockTools, nil) - resourceMgr := resources.NewResourceManager(nil, nil, nil, toolsMap, toolsets, promptsMap, promptsets) + resourceMgr := resources.NewResourceManager(nil, nil, nil, toolsMap, toolsets, promptsMap, promptsets, nil) tests := []struct { name string @@ -257,7 +257,7 @@ func TestToolsCallHandler(t *testing.T) { testutils.MockTool5, } toolsMap, toolsets, promptsMap, promptsets := testutils.SetUpResources(t, mockTools, nil) - resourceMgr := resources.NewResourceManager(nil, nil, nil, toolsMap, toolsets, promptsMap, promptsets) + resourceMgr := resources.NewResourceManager(nil, nil, nil, toolsMap, toolsets, promptsMap, promptsets, nil) tests := []struct { name string @@ -385,7 +385,7 @@ func TestPromptsListHandler(t *testing.T) { // Initialize prompts mockPrompts := []testutils.MockPrompt{testutils.MockPrompt1, testutils.MockPrompt2} toolsMap, toolsets, promptsMap, promptsets := testutils.SetUpResources(t, nil, mockPrompts) - resourceMgr := resources.NewResourceManager(nil, nil, nil, toolsMap, toolsets, promptsMap, promptsets) + resourceMgr := resources.NewResourceManager(nil, nil, nil, toolsMap, toolsets, promptsMap, promptsets, nil) tests := []struct { name string body ListPromptsRequest @@ -454,7 +454,7 @@ func TestPromptsGetHandler(t *testing.T) { // Initialize prompts mockPrompts := []testutils.MockPrompt{testutils.MockPrompt1, testutils.MockPrompt2} toolsMap, toolsets, promptsMap, promptsets := testutils.SetUpResources(t, nil, mockPrompts) - resourceMgr := resources.NewResourceManager(nil, nil, nil, toolsMap, toolsets, promptsMap, promptsets) + resourceMgr := resources.NewResourceManager(nil, nil, nil, toolsMap, toolsets, promptsMap, promptsets, nil) tests := []struct { name string body GetPromptRequest diff --git a/internal/server/mcp/v20250618/method.go b/internal/server/mcp/v20250618/method.go index a950239bf2ca..8806bed63678 100644 --- a/internal/server/mcp/v20250618/method.go +++ b/internal/server/mcp/v20250618/method.go @@ -25,6 +25,7 @@ import ( "time" "github.com/googleapis/mcp-toolbox/internal/auth" + "github.com/googleapis/mcp-toolbox/internal/piipolicy" "github.com/googleapis/mcp-toolbox/internal/prompts" "github.com/googleapis/mcp-toolbox/internal/server/mcp/jsonrpc" mcputil "github.com/googleapis/mcp-toolbox/internal/server/mcp/util" @@ -304,6 +305,33 @@ func toolsCallHandler(ctx context.Context, id jsonrpc.RequestId, toolset tools.T results, err := tool.Invoke(ctx, resourceMgr, params, accessToken) executionDuration := time.Since(executionStart).Seconds() + // Apply PII policy masking if configured + if err == nil { + if piiPolicyName := tool.GetPiiPolicy(); piiPolicyName != "" { + if policy, exists := resourceMgr.GetPiiPolicy(piiPolicyName); exists { + var combinedClaims map[string]any + if len(claimsFromAuth) > 0 { + // Merge all claims for policy evaluation + combinedClaims = make(map[string]any) + for _, claims := range claimsFromAuth { + for k, v := range claims { + combinedClaims[k] = v + } + } + } + results, err = piipolicy.ApplyPolicy(ctx, policy, combinedClaims, results) + if err != nil { + err = fmt.Errorf("error applying pii policy %q: %w", piiPolicyName, err) + return jsonrpc.NewError(id, jsonrpc.INTERNAL_ERROR, err.Error(), nil), err + } + } else { + err = fmt.Errorf("pii policy %q not found", piiPolicyName) + return jsonrpc.NewError(id, jsonrpc.INTERNAL_ERROR, err.Error(), nil), err + } + } + } + + // Record tool execution duration metric if instrumentationErr == nil { execAttrs := []attribute.KeyValue{ diff --git a/internal/server/mcp/v20250618/method_test.go b/internal/server/mcp/v20250618/method_test.go index 03912164d41c..2d1eb6e6a653 100644 --- a/internal/server/mcp/v20250618/method_test.go +++ b/internal/server/mcp/v20250618/method_test.go @@ -168,7 +168,7 @@ func TestToolsListHandler(t *testing.T) { // Initialize tools using provided testutils mock instances mockTools := []testutils.MockTool{testutils.MockTool1, testutils.MockTool2} toolsMap, toolsets, promptsMap, promptsets := testutils.SetUpResources(t, mockTools, nil) - resourceMgr := resources.NewResourceManager(nil, nil, nil, toolsMap, toolsets, promptsMap, promptsets) + resourceMgr := resources.NewResourceManager(nil, nil, nil, toolsMap, toolsets, promptsMap, promptsets, nil) tests := []struct { name string @@ -257,7 +257,7 @@ func TestToolsCallHandler(t *testing.T) { testutils.MockTool5, } toolsMap, toolsets, promptsMap, promptsets := testutils.SetUpResources(t, mockTools, nil) - resourceMgr := resources.NewResourceManager(nil, nil, nil, toolsMap, toolsets, promptsMap, promptsets) + resourceMgr := resources.NewResourceManager(nil, nil, nil, toolsMap, toolsets, promptsMap, promptsets, nil) tests := []struct { name string @@ -385,7 +385,7 @@ func TestPromptsListHandler(t *testing.T) { // Initialize prompts mockPrompts := []testutils.MockPrompt{testutils.MockPrompt1, testutils.MockPrompt2} toolsMap, toolsets, promptsMap, promptsets := testutils.SetUpResources(t, nil, mockPrompts) - resourceMgr := resources.NewResourceManager(nil, nil, nil, toolsMap, toolsets, promptsMap, promptsets) + resourceMgr := resources.NewResourceManager(nil, nil, nil, toolsMap, toolsets, promptsMap, promptsets, nil) tests := []struct { name string body ListPromptsRequest @@ -454,7 +454,7 @@ func TestPromptsGetHandler(t *testing.T) { // Initialize prompts mockPrompts := []testutils.MockPrompt{testutils.MockPrompt1, testutils.MockPrompt2} toolsMap, toolsets, promptsMap, promptsets := testutils.SetUpResources(t, nil, mockPrompts) - resourceMgr := resources.NewResourceManager(nil, nil, nil, toolsMap, toolsets, promptsMap, promptsets) + resourceMgr := resources.NewResourceManager(nil, nil, nil, toolsMap, toolsets, promptsMap, promptsets, nil) tests := []struct { name string body GetPromptRequest diff --git a/internal/server/mcp/v20251125/method.go b/internal/server/mcp/v20251125/method.go index 295f60ba06da..e61a7d99c0c9 100644 --- a/internal/server/mcp/v20251125/method.go +++ b/internal/server/mcp/v20251125/method.go @@ -25,6 +25,7 @@ import ( "time" "github.com/googleapis/mcp-toolbox/internal/auth" + "github.com/googleapis/mcp-toolbox/internal/piipolicy" "github.com/googleapis/mcp-toolbox/internal/prompts" "github.com/googleapis/mcp-toolbox/internal/server/mcp/jsonrpc" mcputil "github.com/googleapis/mcp-toolbox/internal/server/mcp/util" @@ -304,6 +305,33 @@ func toolsCallHandler(ctx context.Context, id jsonrpc.RequestId, toolset tools.T results, err := tool.Invoke(ctx, resourceMgr, params, accessToken) executionDuration := time.Since(executionStart).Seconds() + // Apply PII policy masking if configured + if err == nil { + if piiPolicyName := tool.GetPiiPolicy(); piiPolicyName != "" { + if policy, exists := resourceMgr.GetPiiPolicy(piiPolicyName); exists { + var combinedClaims map[string]any + if len(claimsFromAuth) > 0 { + // Merge all claims for policy evaluation + combinedClaims = make(map[string]any) + for _, claims := range claimsFromAuth { + for k, v := range claims { + combinedClaims[k] = v + } + } + } + results, err = piipolicy.ApplyPolicy(ctx, policy, combinedClaims, results) + if err != nil { + err = fmt.Errorf("error applying pii policy %q: %w", piiPolicyName, err) + return jsonrpc.NewError(id, jsonrpc.INTERNAL_ERROR, err.Error(), nil), err + } + } else { + err = fmt.Errorf("pii policy %q not found", piiPolicyName) + return jsonrpc.NewError(id, jsonrpc.INTERNAL_ERROR, err.Error(), nil), err + } + } + } + + // Record tool execution duration metric if instrumentationErr == nil { execAttrs := []attribute.KeyValue{ diff --git a/internal/server/mcp/v20251125/method_test.go b/internal/server/mcp/v20251125/method_test.go index 5faeeff3f654..743d60ba4c5a 100644 --- a/internal/server/mcp/v20251125/method_test.go +++ b/internal/server/mcp/v20251125/method_test.go @@ -168,7 +168,7 @@ func TestToolsListHandler(t *testing.T) { // Initialize tools using provided testutils mock instances mockTools := []testutils.MockTool{testutils.MockTool1, testutils.MockTool2} toolsMap, toolsets, promptsMap, promptsets := testutils.SetUpResources(t, mockTools, nil) - resourceMgr := resources.NewResourceManager(nil, nil, nil, toolsMap, toolsets, promptsMap, promptsets) + resourceMgr := resources.NewResourceManager(nil, nil, nil, toolsMap, toolsets, promptsMap, promptsets, nil) tests := []struct { name string @@ -257,7 +257,7 @@ func TestToolsCallHandler(t *testing.T) { testutils.MockTool5, } toolsMap, toolsets, promptsMap, promptsets := testutils.SetUpResources(t, mockTools, nil) - resourceMgr := resources.NewResourceManager(nil, nil, nil, toolsMap, toolsets, promptsMap, promptsets) + resourceMgr := resources.NewResourceManager(nil, nil, nil, toolsMap, toolsets, promptsMap, promptsets, nil) tests := []struct { name string @@ -385,7 +385,7 @@ func TestPromptsListHandler(t *testing.T) { // Initialize prompts mockPrompts := []testutils.MockPrompt{testutils.MockPrompt1, testutils.MockPrompt2} toolsMap, toolsets, promptsMap, promptsets := testutils.SetUpResources(t, nil, mockPrompts) - resourceMgr := resources.NewResourceManager(nil, nil, nil, toolsMap, toolsets, promptsMap, promptsets) + resourceMgr := resources.NewResourceManager(nil, nil, nil, toolsMap, toolsets, promptsMap, promptsets, nil) tests := []struct { name string body ListPromptsRequest @@ -454,7 +454,7 @@ func TestPromptsGetHandler(t *testing.T) { // Initialize prompts mockPrompts := []testutils.MockPrompt{testutils.MockPrompt1, testutils.MockPrompt2} toolsMap, toolsets, promptsMap, promptsets := testutils.SetUpResources(t, nil, mockPrompts) - resourceMgr := resources.NewResourceManager(nil, nil, nil, toolsMap, toolsets, promptsMap, promptsets) + resourceMgr := resources.NewResourceManager(nil, nil, nil, toolsMap, toolsets, promptsMap, promptsets, nil) tests := []struct { name string body GetPromptRequest diff --git a/internal/server/mcp_test.go b/internal/server/mcp_test.go index 6faad0bcbb1f..e690df1d0304 100644 --- a/internal/server/mcp_test.go +++ b/internal/server/mcp_test.go @@ -1327,7 +1327,7 @@ func TestStdioSession(t *testing.T) { sseManager := newSseManager(ctx) - resourceManager := resources.NewResourceManager(nil, nil, nil, toolsMap, toolsets, promptsMap, promptsets) + resourceManager := resources.NewResourceManager(nil, nil, nil, toolsMap, toolsets, promptsMap, promptsets, nil) server := &Server{ version: testutils.MockVersionString, diff --git a/internal/server/resources/resources.go b/internal/server/resources/resources.go index be3a938bef72..dbc7db5b7fbe 100644 --- a/internal/server/resources/resources.go +++ b/internal/server/resources/resources.go @@ -22,6 +22,7 @@ import ( "github.com/googleapis/mcp-toolbox/internal/prompts" "github.com/googleapis/mcp-toolbox/internal/sources" "github.com/googleapis/mcp-toolbox/internal/tools" + "github.com/googleapis/mcp-toolbox/internal/piipolicy" ) // ResourceManager contains available resources for the server. Should be initialized with NewResourceManager(). @@ -34,6 +35,7 @@ type ResourceManager struct { toolsets map[string]tools.Toolset prompts map[string]prompts.Prompt promptsets map[string]prompts.Promptset + piiPolicies map[string]piipolicy.Config } func NewResourceManager( @@ -42,7 +44,7 @@ func NewResourceManager( embeddingModelsMap map[string]embeddingmodels.EmbeddingModel, toolsMap map[string]tools.Tool, toolsetsMap map[string]tools.Toolset, promptsMap map[string]prompts.Prompt, promptsetsMap map[string]prompts.Promptset, - + piiPoliciesMap map[string]piipolicy.Config, ) *ResourceManager { resourceMgr := &ResourceManager{ mu: sync.RWMutex{}, @@ -53,6 +55,7 @@ func NewResourceManager( toolsets: toolsetsMap, prompts: promptsMap, promptsets: promptsetsMap, + piiPolicies: piiPoliciesMap, } return resourceMgr @@ -107,7 +110,14 @@ func (r *ResourceManager) GetPromptset(promptsetName string) (prompts.Promptset, return promptset, ok } -func (r *ResourceManager) SetResources(sourcesMap map[string]sources.Source, authServicesMap map[string]auth.AuthService, embeddingModelsMap map[string]embeddingmodels.EmbeddingModel, toolsMap map[string]tools.Tool, toolsetsMap map[string]tools.Toolset, promptsMap map[string]prompts.Prompt, promptsetsMap map[string]prompts.Promptset) { +func (r *ResourceManager) GetPiiPolicy(policyName string) (piipolicy.Config, bool) { + r.mu.RLock() + defer r.mu.RUnlock() + policy, ok := r.piiPolicies[policyName] + return policy, ok +} + +func (r *ResourceManager) SetResources(sourcesMap map[string]sources.Source, authServicesMap map[string]auth.AuthService, embeddingModelsMap map[string]embeddingmodels.EmbeddingModel, toolsMap map[string]tools.Tool, toolsetsMap map[string]tools.Toolset, promptsMap map[string]prompts.Prompt, promptsetsMap map[string]prompts.Promptset, piiPoliciesMap map[string]piipolicy.Config) { r.mu.Lock() defer r.mu.Unlock() r.sources = sourcesMap @@ -117,6 +127,7 @@ func (r *ResourceManager) SetResources(sourcesMap map[string]sources.Source, aut r.toolsets = toolsetsMap r.prompts = promptsMap r.promptsets = promptsetsMap + r.piiPolicies = piiPoliciesMap } func (r *ResourceManager) GetSourcesMap() map[string]sources.Source { @@ -168,3 +179,13 @@ func (r *ResourceManager) GetPromptsMap() map[string]prompts.Prompt { } return copiedMap } + +func (r *ResourceManager) GetPiiPoliciesMap() map[string]piipolicy.Config { + r.mu.RLock() + defer r.mu.RUnlock() + copiedMap := make(map[string]piipolicy.Config, len(r.piiPolicies)) + for k, v := range r.piiPolicies { + copiedMap[k] = v + } + return copiedMap +} diff --git a/internal/server/resources/resources_test.go b/internal/server/resources/resources_test.go index 64940e2e881f..6e85e21d540e 100644 --- a/internal/server/resources/resources_test.go +++ b/internal/server/resources/resources_test.go @@ -56,7 +56,7 @@ func TestUpdateServer(t *testing.T) { Prompts: []*prompts.Prompt{}, }, } - resMgr := resources.NewResourceManager(newSources, newAuth, newEmbeddingModels, newTools, newToolsets, newPrompts, newPromptsets) + resMgr := resources.NewResourceManager(newSources, newAuth, newEmbeddingModels, newTools, newToolsets, newPrompts, newPromptsets, nil) gotSource, _ := resMgr.GetSource("example-source") if diff := cmp.Diff(gotSource, newSources["example-source"]); diff != "" { @@ -97,7 +97,7 @@ func TestUpdateServer(t *testing.T) { }, } - resMgr.SetResources(updateSource, newAuth, newEmbeddingModels, newTools, newToolsets, newPrompts, newPromptsets) + resMgr.SetResources(updateSource, newAuth, newEmbeddingModels, newTools, newToolsets, newPrompts, newPromptsets, nil) gotSource, _ = resMgr.GetSource("example-source2") if diff := cmp.Diff(gotSource, updateSource["example-source2"]); diff != "" { t.Errorf("error updating server, sources (-want +got):\n%s", diff) diff --git a/internal/server/server.go b/internal/server/server.go index 7d87bb2d015d..d2ffd0d94e7d 100644 --- a/internal/server/server.go +++ b/internal/server/server.go @@ -37,6 +37,7 @@ import ( "github.com/googleapis/mcp-toolbox/internal/auth" "github.com/googleapis/mcp-toolbox/internal/embeddingmodels" "github.com/googleapis/mcp-toolbox/internal/log" + "github.com/googleapis/mcp-toolbox/internal/piipolicy" "github.com/googleapis/mcp-toolbox/internal/prompts" "github.com/googleapis/mcp-toolbox/internal/server/mcp/jsonrpc" "github.com/googleapis/mcp-toolbox/internal/server/resources" @@ -72,12 +73,13 @@ func InitializeConfigs(ctx context.Context, cfg ServerConfig) ( map[string]tools.Toolset, map[string]prompts.Prompt, map[string]prompts.Promptset, + map[string]piipolicy.Config, error, ) { if cfg.EnableAPI { for _, sc := range cfg.AuthServiceConfigs { if sc.IsMCPEnabled() { - return nil, nil, nil, nil, nil, nil, nil, fmt.Errorf("MCP Auth cannot be enabled together with the legacy HTTP API (EnableAPI)") + return nil, nil, nil, nil, nil, nil, nil, nil, fmt.Errorf("MCP Auth cannot be enabled together with the legacy HTTP API (EnableAPI)") } } } @@ -89,12 +91,12 @@ func InitializeConfigs(ctx context.Context, cfg ServerConfig) ( ctx = util.WithUserAgent(ctx, metadataStr) instrumentation, err := util.InstrumentationFromContext(ctx) if err != nil { - return nil, nil, nil, nil, nil, nil, nil, fmt.Errorf("failed to get instrumentation from context: %w", err) + return nil, nil, nil, nil, nil, nil, nil, nil, fmt.Errorf("failed to get instrumentation from context: %w", err) } l, err := util.LoggerFromContext(ctx) if err != nil { - return nil, nil, nil, nil, nil, nil, nil, fmt.Errorf("failed to get logger from context: %w", err) + return nil, nil, nil, nil, nil, nil, nil, nil, fmt.Errorf("failed to get logger from context: %w", err) } // initialize and validate the sources from configs @@ -115,7 +117,7 @@ func InitializeConfigs(ctx context.Context, cfg ServerConfig) ( return s, nil }() if err != nil { - return nil, nil, nil, nil, nil, nil, nil, err + return nil, nil, nil, nil, nil, nil, nil, nil, err } sourcesMap[name] = s } @@ -143,7 +145,7 @@ func InitializeConfigs(ctx context.Context, cfg ServerConfig) ( return a, nil }() if err != nil { - return nil, nil, nil, nil, nil, nil, nil, err + return nil, nil, nil, nil, nil, nil, nil, nil, err } authServicesMap[name] = a } @@ -172,7 +174,7 @@ func InitializeConfigs(ctx context.Context, cfg ServerConfig) ( return em, nil }() if err != nil { - return nil, nil, nil, nil, nil, nil, nil, err + return nil, nil, nil, nil, nil, nil, nil, nil, err } embeddingModelsMap[name] = em } @@ -184,12 +186,12 @@ func InitializeConfigs(ctx context.Context, cfg ServerConfig) ( toolsMap, err := initializeTools(ctx, cfg, instrumentation, l) if err != nil { - return nil, nil, nil, nil, nil, nil, nil, err + return nil, nil, nil, nil, nil, nil, nil, nil, err } toolsetsMap, err := initializeToolsets(ctx, cfg, toolsMap, instrumentation, l) if err != nil { - return nil, nil, nil, nil, nil, nil, nil, err + return nil, nil, nil, nil, nil, nil, nil, nil, err } // initialize and validate the prompts from configs @@ -210,7 +212,7 @@ func InitializeConfigs(ctx context.Context, cfg ServerConfig) ( return p, nil }() if err != nil { - return nil, nil, nil, nil, nil, nil, nil, err + return nil, nil, nil, nil, nil, nil, nil, nil, err } promptsMap[name] = p } @@ -232,6 +234,12 @@ func InitializeConfigs(ctx context.Context, cfg ServerConfig) ( // initialize and validate the promptsets from configs promptsetsMap := make(map[string]prompts.Promptset) + + piiPoliciesMap := make(map[string]piipolicy.Config) + for name, policyCfg := range cfg.PiiPolicyConfigs { + piiPoliciesMap[name] = policyCfg + } + for name, pc := range cfg.PromptsetConfigs { p, err := func() (prompts.Promptset, error) { _, span := instrumentation.Tracer.Start( @@ -247,7 +255,7 @@ func InitializeConfigs(ctx context.Context, cfg ServerConfig) ( return p, err }() if err != nil { - return nil, nil, nil, nil, nil, nil, nil, err + return nil, nil, nil, nil, nil, nil, nil, nil, err } promptsetsMap[name] = p } @@ -261,7 +269,7 @@ func InitializeConfigs(ctx context.Context, cfg ServerConfig) ( } l.InfoContext(ctx, fmt.Sprintf("Initialized %d promptsets: %s", len(promptsetsMap), strings.Join(promptsetNames, ", "))) - return sourcesMap, authServicesMap, embeddingModelsMap, toolsMap, toolsetsMap, promptsMap, promptsetsMap, nil + return sourcesMap, authServicesMap, embeddingModelsMap, toolsMap, toolsetsMap, promptsMap, promptsetsMap, piiPoliciesMap, nil } // InitializeOfflineConfigs initializes only tools and toolsets from the config, @@ -439,7 +447,7 @@ func NewServer(ctx context.Context, cfg ServerConfig) (*Server, error) { logger := l.SlogLogger() r.Use(httplog.RequestLogger(logger, httpOpts)) - sourcesMap, authServicesMap, embeddingModelsMap, toolsMap, toolsetsMap, promptsMap, promptsetsMap, err := InitializeConfigs(ctx, cfg) + sourcesMap, authServicesMap, embeddingModelsMap, toolsMap, toolsetsMap, promptsMap, promptsetsMap, piiPoliciesMap, err := InitializeConfigs(ctx, cfg) if err != nil { return nil, fmt.Errorf("unable to initialize configs: %w", err) } @@ -449,7 +457,7 @@ func NewServer(ctx context.Context, cfg ServerConfig) (*Server, error) { sseManager := newSseManager(ctx) - resourceManager := resources.NewResourceManager(sourcesMap, authServicesMap, embeddingModelsMap, toolsMap, toolsetsMap, promptsMap, promptsetsMap) + resourceManager := resources.NewResourceManager(sourcesMap, authServicesMap, embeddingModelsMap, toolsMap, toolsetsMap, promptsMap, promptsetsMap, piiPoliciesMap) limit := cfg.HttpMaxRequestBytes if limit <= 0 { diff --git a/internal/server/server_test.go b/internal/server/server_test.go index 49849f8b130f..cb78a0ded5a0 100644 --- a/internal/server/server_test.go +++ b/internal/server/server_test.go @@ -268,7 +268,7 @@ func TestUpdateServer(t *testing.T) { Prompts: []*prompts.Prompt{}, }, } - s.ResourceMgr.SetResources(newSources, newAuth, newEmbeddingModels, newTools, newToolsets, newPrompts, newPromptsets) + s.ResourceMgr.SetResources(newSources, newAuth, newEmbeddingModels, newTools, newToolsets, newPrompts, newPromptsets, nil) if err != nil { t.Errorf("error updating server: %s", err) } @@ -1237,7 +1237,7 @@ mcpEnabled: true for _, tc := range tests { t.Run(tc.name, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, []byte(tc.yaml)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, []byte(tc.yaml)) if (err != nil) != tc.wantError { t.Fatalf("UnmarshalResourceConfig() returned error: %v, wantError: %v", err, tc.wantError) } @@ -1329,7 +1329,7 @@ scopesRequired: for _, tc := range tests { t.Run(tc.name, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, []byte(tc.yaml)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, []byte(tc.yaml)) if (err != nil) != tc.wantError { t.Fatalf("UnmarshalResourceConfig() returned error: %v, wantError: %v", err, tc.wantError) } diff --git a/internal/sources/alloydbadmin/alloydbadmin_test.go b/internal/sources/alloydbadmin/alloydbadmin_test.go index 4aad82eb946b..e2352f10065a 100644 --- a/internal/sources/alloydbadmin/alloydbadmin_test.go +++ b/internal/sources/alloydbadmin/alloydbadmin_test.go @@ -66,7 +66,7 @@ func TestParseFromYamlAlloyDBAdmin(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - got, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + got, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -106,7 +106,7 @@ func TestFailParseFromYaml(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/sources/alloydbpg/alloydb_pg_test.go b/internal/sources/alloydbpg/alloydb_pg_test.go index 9378aab2f6a4..f7d74bade341 100644 --- a/internal/sources/alloydbpg/alloydb_pg_test.go +++ b/internal/sources/alloydbpg/alloydb_pg_test.go @@ -124,7 +124,7 @@ func TestParseFromYamlAlloyDBPg(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - got, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + got, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -193,7 +193,7 @@ func TestFailParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/sources/bigquery/bigquery_test.go b/internal/sources/bigquery/bigquery_test.go index 399ec9078a09..e01b5b375698 100644 --- a/internal/sources/bigquery/bigquery_test.go +++ b/internal/sources/bigquery/bigquery_test.go @@ -260,7 +260,7 @@ func TestParseFromYamlBigQuery(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - got, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + got, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -313,7 +313,7 @@ func TestFailParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/sources/bigtable/bigtable_test.go b/internal/sources/bigtable/bigtable_test.go index 0d6174bfff5b..ddcd50545682 100644 --- a/internal/sources/bigtable/bigtable_test.go +++ b/internal/sources/bigtable/bigtable_test.go @@ -52,7 +52,7 @@ func TestParseFromYamlBigtableDb(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - got, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + got, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -95,7 +95,7 @@ func TestFailParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/sources/cassandra/cassandra_test.go b/internal/sources/cassandra/cassandra_test.go index dc3b85b65709..557a8d1edd94 100644 --- a/internal/sources/cassandra/cassandra_test.go +++ b/internal/sources/cassandra/cassandra_test.go @@ -94,7 +94,7 @@ func TestParseFromYamlCassandra(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - got, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + got, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -137,7 +137,7 @@ func TestFailParseFromYaml(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/sources/clickhouse/clickhouse_test.go b/internal/sources/clickhouse/clickhouse_test.go index badb19e5ac4d..80b5057456db 100644 --- a/internal/sources/clickhouse/clickhouse_test.go +++ b/internal/sources/clickhouse/clickhouse_test.go @@ -89,7 +89,7 @@ func TestParseFromYamlClickhouse(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - got, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + got, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -121,7 +121,7 @@ func TestFailParseFromYaml(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/sources/cloudgda/cloud_gda_test.go b/internal/sources/cloudgda/cloud_gda_test.go index 8b79c70af1e5..b7843686e6a8 100644 --- a/internal/sources/cloudgda/cloud_gda_test.go +++ b/internal/sources/cloudgda/cloud_gda_test.go @@ -75,7 +75,7 @@ func TestParseFromYamlCloudGDA(t *testing.T) { tc := tc t.Run(tc.desc, func(t *testing.T) { t.Parallel() - got, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + got, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -107,7 +107,7 @@ func TestFailParseFromYaml(t *testing.T) { tc := tc t.Run(tc.desc, func(t *testing.T) { t.Parallel() - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/sources/cloudhealthcare/cloud_healthcare_test.go b/internal/sources/cloudhealthcare/cloud_healthcare_test.go index bda6cd11bce9..7b9b8c53e559 100644 --- a/internal/sources/cloudhealthcare/cloud_healthcare_test.go +++ b/internal/sources/cloudhealthcare/cloud_healthcare_test.go @@ -103,7 +103,7 @@ func TestParseFromYamlCloudHealthcare(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - got, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + got, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -147,7 +147,7 @@ func TestFailParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/sources/cloudloggingadmin/cloud_logging_admin_test.go b/internal/sources/cloudloggingadmin/cloud_logging_admin_test.go index c91526bdee76..a40cbe5e946e 100644 --- a/internal/sources/cloudloggingadmin/cloud_logging_admin_test.go +++ b/internal/sources/cloudloggingadmin/cloud_logging_admin_test.go @@ -84,7 +84,7 @@ func TestParseFromYamlCloudLoggingAdmin(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - got, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + got, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -124,7 +124,7 @@ func TestFailParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/sources/cloudmonitoring/cloud_monitoring_test.go b/internal/sources/cloudmonitoring/cloud_monitoring_test.go index 262c9b4b004b..76ea831a011b 100644 --- a/internal/sources/cloudmonitoring/cloud_monitoring_test.go +++ b/internal/sources/cloudmonitoring/cloud_monitoring_test.go @@ -68,7 +68,7 @@ func TestParseFromYamlCloudMonitoring(t *testing.T) { tc := tc t.Run(tc.desc, func(t *testing.T) { t.Parallel() - got, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + got, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -110,7 +110,7 @@ func TestFailParseFromYaml(t *testing.T) { tc := tc t.Run(tc.desc, func(t *testing.T) { t.Parallel() - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/sources/cloudsqladmin/cloud_sql_admin_test.go b/internal/sources/cloudsqladmin/cloud_sql_admin_test.go index 4ad4f26ab123..42475dc36072 100644 --- a/internal/sources/cloudsqladmin/cloud_sql_admin_test.go +++ b/internal/sources/cloudsqladmin/cloud_sql_admin_test.go @@ -68,7 +68,7 @@ func TestParseFromYamlCloudSQLAdmin(t *testing.T) { tc := tc t.Run(tc.desc, func(t *testing.T) { t.Parallel() - got, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + got, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -110,7 +110,7 @@ func TestFailParseFromYaml(t *testing.T) { tc := tc t.Run(tc.desc, func(t *testing.T) { t.Parallel() - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/sources/cloudsqlmssql/cloud_sql_mssql_test.go b/internal/sources/cloudsqlmssql/cloud_sql_mssql_test.go index 4770d23667cb..842a3f31dc25 100644 --- a/internal/sources/cloudsqlmssql/cloud_sql_mssql_test.go +++ b/internal/sources/cloudsqlmssql/cloud_sql_mssql_test.go @@ -89,7 +89,7 @@ func TestParseFromYamlCloudSQLMssql(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - got, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + got, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -156,7 +156,7 @@ func TestFailParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/sources/cloudsqlmysql/cloud_sql_mysql_test.go b/internal/sources/cloudsqlmysql/cloud_sql_mysql_test.go index 4cb0ba8acd9d..d807f590161b 100644 --- a/internal/sources/cloudsqlmysql/cloud_sql_mysql_test.go +++ b/internal/sources/cloudsqlmysql/cloud_sql_mysql_test.go @@ -143,7 +143,7 @@ func TestParseFromYamlCloudSQLMySQL(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - got, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + got, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -210,7 +210,7 @@ func TestFailParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/sources/cloudsqlpg/cloud_sql_pg_test.go b/internal/sources/cloudsqlpg/cloud_sql_pg_test.go index 27084281165a..dd5b5d152a36 100644 --- a/internal/sources/cloudsqlpg/cloud_sql_pg_test.go +++ b/internal/sources/cloudsqlpg/cloud_sql_pg_test.go @@ -145,7 +145,7 @@ func TestParseFromYamlCloudSQLPg(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - got, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + got, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -212,7 +212,7 @@ func TestFailParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/sources/cloudstorage/cloudstorage_test.go b/internal/sources/cloudstorage/cloudstorage_test.go index ae3b1c9ffe5a..1e202c618384 100644 --- a/internal/sources/cloudstorage/cloudstorage_test.go +++ b/internal/sources/cloudstorage/cloudstorage_test.go @@ -74,7 +74,7 @@ func TestParseFromYamlCloudStorage(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - got, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + got, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -114,7 +114,7 @@ func TestFailParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/sources/couchbase/couchbase_test.go b/internal/sources/couchbase/couchbase_test.go index 29a3fee619d1..e0d2cfbfa55e 100644 --- a/internal/sources/couchbase/couchbase_test.go +++ b/internal/sources/couchbase/couchbase_test.go @@ -92,7 +92,7 @@ func TestParseFromYamlCouchbase(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - got, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + got, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -140,7 +140,7 @@ func TestFailParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/sources/datalineage/datalineage_test.go b/internal/sources/datalineage/datalineage_test.go index 1e5fb290c241..cfac72779f46 100644 --- a/internal/sources/datalineage/datalineage_test.go +++ b/internal/sources/datalineage/datalineage_test.go @@ -50,7 +50,7 @@ func TestParseFromYamlDatalineage(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - got, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + got, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -90,7 +90,7 @@ func TestFailParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/sources/dataplex/dataplex_test.go b/internal/sources/dataplex/dataplex_test.go index 0927bed2df59..c3b8a595ff56 100644 --- a/internal/sources/dataplex/dataplex_test.go +++ b/internal/sources/dataplex/dataplex_test.go @@ -68,7 +68,7 @@ func TestParseFromYamlDataplex(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - got, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + got, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -109,7 +109,7 @@ func TestFailParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/sources/dataproc/dataproc_test.go b/internal/sources/dataproc/dataproc_test.go index 77d82d193c49..9a0e2a6c34f5 100644 --- a/internal/sources/dataproc/dataproc_test.go +++ b/internal/sources/dataproc/dataproc_test.go @@ -51,7 +51,7 @@ func TestParseFromYamlDataproc(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - got, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + got, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -104,7 +104,7 @@ func TestFailParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/sources/dgraph/dgraph_test.go b/internal/sources/dgraph/dgraph_test.go index 8a2802f32d34..a42742555840 100644 --- a/internal/sources/dgraph/dgraph_test.go +++ b/internal/sources/dgraph/dgraph_test.go @@ -75,7 +75,7 @@ func TestParseFromYamlDgraph(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - got, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + got, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -117,7 +117,7 @@ func TestFailParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/sources/elasticsearch/elasticsearch_test.go b/internal/sources/elasticsearch/elasticsearch_test.go index dc43002b5942..aed1e30a0c46 100644 --- a/internal/sources/elasticsearch/elasticsearch_test.go +++ b/internal/sources/elasticsearch/elasticsearch_test.go @@ -54,7 +54,7 @@ func TestParseFromYamlElasticsearch(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - got, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + got, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("failed to parse yaml: %v", err) } @@ -86,7 +86,7 @@ func TestFailParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/sources/firebird/firebird_test.go b/internal/sources/firebird/firebird_test.go index f6c7aca31e7c..0cd46b854dda 100644 --- a/internal/sources/firebird/firebird_test.go +++ b/internal/sources/firebird/firebird_test.go @@ -58,7 +58,7 @@ func TestParseFromYamlFirebird(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - got, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + got, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -107,7 +107,7 @@ func TestFailParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/sources/firestore/firestore_test.go b/internal/sources/firestore/firestore_test.go index 3be14530412a..2cfc0e0e7564 100644 --- a/internal/sources/firestore/firestore_test.go +++ b/internal/sources/firestore/firestore_test.go @@ -70,7 +70,7 @@ func TestParseFromYamlFirestore(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - got, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + got, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -110,7 +110,7 @@ func TestFailParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/sources/http/http_test.go b/internal/sources/http/http_test.go index 61146989f2cb..489f38986fd6 100644 --- a/internal/sources/http/http_test.go +++ b/internal/sources/http/http_test.go @@ -89,7 +89,7 @@ func TestParseFromYamlHttp(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - got, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + got, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -134,7 +134,7 @@ func TestFailParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/sources/looker/looker_test.go b/internal/sources/looker/looker_test.go index f30bed259975..ec6b3ce92423 100644 --- a/internal/sources/looker/looker_test.go +++ b/internal/sources/looker/looker_test.go @@ -68,7 +68,7 @@ func TestParseFromYamlLooker(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - got, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + got, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -111,7 +111,7 @@ func TestFailParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/sources/mindsdb/mindsdb_test.go b/internal/sources/mindsdb/mindsdb_test.go index 85a269b63cba..dc81a0e3aa50 100644 --- a/internal/sources/mindsdb/mindsdb_test.go +++ b/internal/sources/mindsdb/mindsdb_test.go @@ -84,7 +84,7 @@ func TestParseFromYamlMindsDB(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - got, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + got, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -133,7 +133,7 @@ func TestFailParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/sources/mongodb/mongodb_test.go b/internal/sources/mongodb/mongodb_test.go index c8a54553e5d1..a4fc162c8ceb 100644 --- a/internal/sources/mongodb/mongodb_test.go +++ b/internal/sources/mongodb/mongodb_test.go @@ -50,7 +50,7 @@ func TestParseFromYamlMongoDB(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - got, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + got, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -91,7 +91,7 @@ func TestFailParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/sources/mssql/mssql_test.go b/internal/sources/mssql/mssql_test.go index fed848f50c62..36cf8ebaa62e 100644 --- a/internal/sources/mssql/mssql_test.go +++ b/internal/sources/mssql/mssql_test.go @@ -84,7 +84,7 @@ func TestParseFromYamlMssql(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - got, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + got, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -132,7 +132,7 @@ func TestFailParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/sources/mysql/mysql_test.go b/internal/sources/mysql/mysql_test.go index ef037b1480b7..ac17fd3f6825 100644 --- a/internal/sources/mysql/mysql_test.go +++ b/internal/sources/mysql/mysql_test.go @@ -114,7 +114,7 @@ func TestParseFromYamlCloudSQLMySQL(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { t.Parallel() - got, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + got, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -179,7 +179,7 @@ func TestFailParseFromYaml(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { t.Parallel() - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/sources/neo4j/neo4j_test.go b/internal/sources/neo4j/neo4j_test.go index 69f4f552fb64..fc9525ab64b7 100644 --- a/internal/sources/neo4j/neo4j_test.go +++ b/internal/sources/neo4j/neo4j_test.go @@ -56,7 +56,7 @@ func TestParseFromYamlNeo4j(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - got, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + got, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -103,7 +103,7 @@ func TestFailParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/sources/oceanbase/oceanbase_test.go b/internal/sources/oceanbase/oceanbase_test.go index 8f35a3435489..3ec04c95a4b1 100644 --- a/internal/sources/oceanbase/oceanbase_test.go +++ b/internal/sources/oceanbase/oceanbase_test.go @@ -85,7 +85,7 @@ func TestParseFromYamlOceanBase(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - got, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + got, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -134,7 +134,7 @@ func TestFailParseFromYamlOceanBase(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/sources/oracle/oracle_test.go b/internal/sources/oracle/oracle_test.go index dca3628db888..f6d16aa0b7df 100644 --- a/internal/sources/oracle/oracle_test.go +++ b/internal/sources/oracle/oracle_test.go @@ -94,7 +94,7 @@ func TestParseFromYamlOracle(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - got, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + got, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -241,7 +241,7 @@ func TestFailParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/sources/postgres/postgres_test.go b/internal/sources/postgres/postgres_test.go index 2d6bd96fc5cc..4ab110afd915 100644 --- a/internal/sources/postgres/postgres_test.go +++ b/internal/sources/postgres/postgres_test.go @@ -116,7 +116,7 @@ func TestParseFromYamlPostgres(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - got, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + got, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -180,7 +180,7 @@ func TestFailParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/sources/redis/redis_test.go b/internal/sources/redis/redis_test.go index 0920dcaa888c..1e3ed4515838 100644 --- a/internal/sources/redis/redis_test.go +++ b/internal/sources/redis/redis_test.go @@ -86,7 +86,7 @@ func TestParseFromYamlRedis(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - got, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + got, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -143,7 +143,7 @@ func TestFailParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/sources/scylladb/scylladb_test.go b/internal/sources/scylladb/scylladb_test.go index b18270cc3047..e295bf49e3c8 100644 --- a/internal/sources/scylladb/scylladb_test.go +++ b/internal/sources/scylladb/scylladb_test.go @@ -99,7 +99,7 @@ func TestParseFromYamlScyllaDB(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - got, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + got, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -141,7 +141,7 @@ func TestFailParseFromYaml(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/sources/serverlessspark/serverlessspark_test.go b/internal/sources/serverlessspark/serverlessspark_test.go index bd6896778fd8..081d4f06349e 100644 --- a/internal/sources/serverlessspark/serverlessspark_test.go +++ b/internal/sources/serverlessspark/serverlessspark_test.go @@ -52,7 +52,7 @@ func TestParseFromYamlServerlessSpark(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - got, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + got, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -105,7 +105,7 @@ func TestFailParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/sources/singlestore/singlestore_test.go b/internal/sources/singlestore/singlestore_test.go index 4838f6304862..61163f579968 100644 --- a/internal/sources/singlestore/singlestore_test.go +++ b/internal/sources/singlestore/singlestore_test.go @@ -146,7 +146,7 @@ func TestParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - got, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + got, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -195,7 +195,7 @@ func TestFailParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/sources/snowflake/snowflake_test.go b/internal/sources/snowflake/snowflake_test.go index 0b3eb2ba282d..63806437aa7b 100644 --- a/internal/sources/snowflake/snowflake_test.go +++ b/internal/sources/snowflake/snowflake_test.go @@ -60,7 +60,7 @@ func TestParseFromYamlSnowflake(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - got, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + got, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -109,7 +109,7 @@ func TestFailParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/sources/spanner/spanner_test.go b/internal/sources/spanner/spanner_test.go index b1bb7c1ea698..5721a414ebd9 100644 --- a/internal/sources/spanner/spanner_test.go +++ b/internal/sources/spanner/spanner_test.go @@ -100,7 +100,7 @@ func TestParseFromYamlSpannerDb(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - got, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + got, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -158,7 +158,7 @@ func TestFailParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/sources/sqlite/sqlite_test.go b/internal/sources/sqlite/sqlite_test.go index 674d747d8024..7c40feb10ef8 100644 --- a/internal/sources/sqlite/sqlite_test.go +++ b/internal/sources/sqlite/sqlite_test.go @@ -50,7 +50,7 @@ func TestParseFromYamlSQLite(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - got, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + got, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -90,7 +90,7 @@ func TestFailParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/sources/tidb/tidb_test.go b/internal/sources/tidb/tidb_test.go index d73206427cd5..c3b21a53d14a 100644 --- a/internal/sources/tidb/tidb_test.go +++ b/internal/sources/tidb/tidb_test.go @@ -110,7 +110,7 @@ func TestParseFromYamlTiDB(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - got, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + got, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -161,7 +161,7 @@ func TestFailParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/sources/trino/trino_test.go b/internal/sources/trino/trino_test.go index fbe4c3657274..f4ccc30e0ced 100644 --- a/internal/sources/trino/trino_test.go +++ b/internal/sources/trino/trino_test.go @@ -269,7 +269,7 @@ func TestParseFromYamlTrino(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - got, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + got, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/sources/valkey/valkey_test.go b/internal/sources/valkey/valkey_test.go index 8d700ac08f05..c8521a00e88d 100644 --- a/internal/sources/valkey/valkey_test.go +++ b/internal/sources/valkey/valkey_test.go @@ -84,7 +84,7 @@ func TestParseFromYamlValkey(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - got, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + got, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -140,7 +140,7 @@ func TestFailParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/sources/yugabytedb/yugabytedb_test.go b/internal/sources/yugabytedb/yugabytedb_test.go index 32030c52950d..7a4482c0161c 100644 --- a/internal/sources/yugabytedb/yugabytedb_test.go +++ b/internal/sources/yugabytedb/yugabytedb_test.go @@ -210,7 +210,7 @@ func TestParseFromYamlYugabyteDB(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - got, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + got, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -271,7 +271,7 @@ func TestFailParseFromYamlYugabyteDB(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expected parsing to fail") } diff --git a/internal/testutils/mocks.go b/internal/testutils/mocks.go index d6d860d3bfad..d65326320f84 100644 --- a/internal/testutils/mocks.go +++ b/internal/testutils/mocks.go @@ -122,6 +122,10 @@ func (t MockTool) GetAuthTokenHeaderName(tools.SourceProvider) (string, error) { return "Authorization", nil } +func (m MockTool) GetPiiPolicy() string { + return "" +} + func (t MockTool) GetScopesRequired() []string { return nil } diff --git a/internal/tools/alloydb/alloydbcreatecluster/alloydbcreatecluster_test.go b/internal/tools/alloydb/alloydbcreatecluster/alloydbcreatecluster_test.go index ffb0977fe552..ea1c5abe31c9 100644 --- a/internal/tools/alloydb/alloydbcreatecluster/alloydbcreatecluster_test.go +++ b/internal/tools/alloydb/alloydbcreatecluster/alloydbcreatecluster_test.go @@ -83,7 +83,7 @@ func TestParseFromYaml(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/alloydb/alloydbcreateinstance/alloydbcreateinstance_test.go b/internal/tools/alloydb/alloydbcreateinstance/alloydbcreateinstance_test.go index 0d3547a20622..f207a3fdacf3 100644 --- a/internal/tools/alloydb/alloydbcreateinstance/alloydbcreateinstance_test.go +++ b/internal/tools/alloydb/alloydbcreateinstance/alloydbcreateinstance_test.go @@ -83,7 +83,7 @@ func TestParseFromYaml(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/alloydb/alloydbcreateuser/alloydbcreateuser_test.go b/internal/tools/alloydb/alloydbcreateuser/alloydbcreateuser_test.go index 6b2b25fbfff3..6be052947927 100644 --- a/internal/tools/alloydb/alloydbcreateuser/alloydbcreateuser_test.go +++ b/internal/tools/alloydb/alloydbcreateuser/alloydbcreateuser_test.go @@ -83,7 +83,7 @@ func TestParseFromYaml(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/alloydb/alloydbgetcluster/alloydbgetcluster_test.go b/internal/tools/alloydb/alloydbgetcluster/alloydbgetcluster_test.go index 0905d9fa494b..f580490989f0 100644 --- a/internal/tools/alloydb/alloydbgetcluster/alloydbgetcluster_test.go +++ b/internal/tools/alloydb/alloydbgetcluster/alloydbgetcluster_test.go @@ -83,7 +83,7 @@ func TestParseFromYaml(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/alloydb/alloydbgetinstance/alloydbgetinstance_test.go b/internal/tools/alloydb/alloydbgetinstance/alloydbgetinstance_test.go index 845a73bb1608..7d79be9756ec 100644 --- a/internal/tools/alloydb/alloydbgetinstance/alloydbgetinstance_test.go +++ b/internal/tools/alloydb/alloydbgetinstance/alloydbgetinstance_test.go @@ -83,7 +83,7 @@ func TestParseFromYaml(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/alloydb/alloydbgetuser/alloydbgetuser_test.go b/internal/tools/alloydb/alloydbgetuser/alloydbgetuser_test.go index 9679165d2213..185504647399 100644 --- a/internal/tools/alloydb/alloydbgetuser/alloydbgetuser_test.go +++ b/internal/tools/alloydb/alloydbgetuser/alloydbgetuser_test.go @@ -83,7 +83,7 @@ func TestParseFromYaml(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/alloydb/alloydblistclusters/alloydblistclusters_test.go b/internal/tools/alloydb/alloydblistclusters/alloydblistclusters_test.go index 6eecc82fae6c..71359a699a10 100644 --- a/internal/tools/alloydb/alloydblistclusters/alloydblistclusters_test.go +++ b/internal/tools/alloydb/alloydblistclusters/alloydblistclusters_test.go @@ -83,7 +83,7 @@ func TestParseFromYaml(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/alloydb/alloydblistinstances/alloydblistinstances_test.go b/internal/tools/alloydb/alloydblistinstances/alloydblistinstances_test.go index 72001edd1542..fc037ff924de 100644 --- a/internal/tools/alloydb/alloydblistinstances/alloydblistinstances_test.go +++ b/internal/tools/alloydb/alloydblistinstances/alloydblistinstances_test.go @@ -83,7 +83,7 @@ func TestParseFromYaml(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/alloydb/alloydblistusers/alloydblistusers_test.go b/internal/tools/alloydb/alloydblistusers/alloydblistusers_test.go index 0b38f3559199..26b6ad72f771 100644 --- a/internal/tools/alloydb/alloydblistusers/alloydblistusers_test.go +++ b/internal/tools/alloydb/alloydblistusers/alloydblistusers_test.go @@ -83,7 +83,7 @@ func TestParseFromYaml(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/alloydb/alloydbwaitforoperation/alloydbwaitforoperation_test.go b/internal/tools/alloydb/alloydbwaitforoperation/alloydbwaitforoperation_test.go index d7ef0feac2f2..74785ec6f272 100644 --- a/internal/tools/alloydb/alloydbwaitforoperation/alloydbwaitforoperation_test.go +++ b/internal/tools/alloydb/alloydbwaitforoperation/alloydbwaitforoperation_test.go @@ -67,7 +67,7 @@ func TestParseFromYaml(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/alloydbainl/alloydbainl_test.go b/internal/tools/alloydbainl/alloydbainl_test.go index 1ff503432693..571e817be23e 100644 --- a/internal/tools/alloydbainl/alloydbainl_test.go +++ b/internal/tools/alloydbainl/alloydbainl_test.go @@ -120,7 +120,7 @@ func TestParseFromYamlAlloyDBNLA(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/bigquery/bigqueryanalyzecontribution/bigqueryanalyzecontribution_test.go b/internal/tools/bigquery/bigqueryanalyzecontribution/bigqueryanalyzecontribution_test.go index a73728021ecf..6e4b32e3fa97 100644 --- a/internal/tools/bigquery/bigqueryanalyzecontribution/bigqueryanalyzecontribution_test.go +++ b/internal/tools/bigquery/bigqueryanalyzecontribution/bigqueryanalyzecontribution_test.go @@ -70,7 +70,7 @@ func TestParseFromYamlBigQueryAnalyzeContribution(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/bigquery/bigqueryconversationalanalytics/bigqueryconversationalanalytics_test.go b/internal/tools/bigquery/bigqueryconversationalanalytics/bigqueryconversationalanalytics_test.go index 135cb72597f7..7b4686f153cb 100644 --- a/internal/tools/bigquery/bigqueryconversationalanalytics/bigqueryconversationalanalytics_test.go +++ b/internal/tools/bigquery/bigqueryconversationalanalytics/bigqueryconversationalanalytics_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlBigQueryConversationalAnalytics(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/bigquery/bigqueryexecutesql/bigqueryexecutesql_test.go b/internal/tools/bigquery/bigqueryexecutesql/bigqueryexecutesql_test.go index 78d45943c462..06c805c65096 100644 --- a/internal/tools/bigquery/bigqueryexecutesql/bigqueryexecutesql_test.go +++ b/internal/tools/bigquery/bigqueryexecutesql/bigqueryexecutesql_test.go @@ -69,7 +69,7 @@ func TestParseFromYamlBigQueryExecuteSql(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/bigquery/bigqueryforecast/bigqueryforecast_test.go b/internal/tools/bigquery/bigqueryforecast/bigqueryforecast_test.go index 242af97f9d14..f7419321de2a 100644 --- a/internal/tools/bigquery/bigqueryforecast/bigqueryforecast_test.go +++ b/internal/tools/bigquery/bigqueryforecast/bigqueryforecast_test.go @@ -69,7 +69,7 @@ func TestParseFromYamlBigQueryForecast(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/bigquery/bigquerygetdatasetinfo/bigquerygetdatasetinfo_test.go b/internal/tools/bigquery/bigquerygetdatasetinfo/bigquerygetdatasetinfo_test.go index 063843d914bf..f79fcc670986 100644 --- a/internal/tools/bigquery/bigquerygetdatasetinfo/bigquerygetdatasetinfo_test.go +++ b/internal/tools/bigquery/bigquerygetdatasetinfo/bigquerygetdatasetinfo_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlBigQueryGetDatasetInfo(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/bigquery/bigquerygettableinfo/bigquerygettableinfo_test.go b/internal/tools/bigquery/bigquerygettableinfo/bigquerygettableinfo_test.go index c114176dbcda..b473cdf4a0cd 100644 --- a/internal/tools/bigquery/bigquerygettableinfo/bigquerygettableinfo_test.go +++ b/internal/tools/bigquery/bigquerygettableinfo/bigquerygettableinfo_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlBigQueryGetTableInfo(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/bigquery/bigquerylistdatasetids/bigquerylistdatasetids_test.go b/internal/tools/bigquery/bigquerylistdatasetids/bigquerylistdatasetids_test.go index 475a844d6b6e..ccfbdc9d47b1 100644 --- a/internal/tools/bigquery/bigquerylistdatasetids/bigquerylistdatasetids_test.go +++ b/internal/tools/bigquery/bigquerylistdatasetids/bigquerylistdatasetids_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlBigQueryListDatasetIds(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/bigquery/bigquerylisttableids/bigquerylisttableids_test.go b/internal/tools/bigquery/bigquerylisttableids/bigquerylisttableids_test.go index 7876e1afad45..57a5a39094d9 100644 --- a/internal/tools/bigquery/bigquerylisttableids/bigquerylisttableids_test.go +++ b/internal/tools/bigquery/bigquerylisttableids/bigquerylisttableids_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlBigQueryListTableIds(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/bigquery/bigquerysearchcatalog/bigquerysearchcatalog_test.go b/internal/tools/bigquery/bigquerysearchcatalog/bigquerysearchcatalog_test.go index 35067258560a..482c8a1f5705 100644 --- a/internal/tools/bigquery/bigquerysearchcatalog/bigquerysearchcatalog_test.go +++ b/internal/tools/bigquery/bigquerysearchcatalog/bigquerysearchcatalog_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlBigQuerySearch(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/bigquery/bigquerysql/bigquerysql_test.go b/internal/tools/bigquery/bigquerysql/bigquerysql_test.go index c01db13a2481..4e2a4504aec9 100644 --- a/internal/tools/bigquery/bigquerysql/bigquerysql_test.go +++ b/internal/tools/bigquery/bigquerysql/bigquerysql_test.go @@ -71,7 +71,7 @@ func TestParseFromYamlBigQuery(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -142,7 +142,7 @@ func TestParseFromYamlWithTemplateBigQuery(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/bigtable/bigtable_test.go b/internal/tools/bigtable/bigtable_test.go index 263128e1a4ea..4cfbd775d111 100644 --- a/internal/tools/bigtable/bigtable_test.go +++ b/internal/tools/bigtable/bigtable_test.go @@ -69,7 +69,7 @@ func TestParseFromYamlBigtable(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -140,7 +140,7 @@ func TestParseFromYamlWithTemplateBigtable(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cassandra/cassandracql/cassandracql_test.go b/internal/tools/cassandra/cassandracql/cassandracql_test.go index 663f53d8a07b..74cc3d8ecf1e 100644 --- a/internal/tools/cassandra/cassandracql/cassandracql_test.go +++ b/internal/tools/cassandra/cassandracql/cassandracql_test.go @@ -162,7 +162,7 @@ func TestParseFromYamlCassandra(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/clickhouse/clickhouseexecutesql/clickhouseexecutesql_test.go b/internal/tools/clickhouse/clickhouseexecutesql/clickhouseexecutesql_test.go index 7496813fc810..e6dbb0b49ad4 100644 --- a/internal/tools/clickhouse/clickhouseexecutesql/clickhouseexecutesql_test.go +++ b/internal/tools/clickhouse/clickhouseexecutesql/clickhouseexecutesql_test.go @@ -58,7 +58,7 @@ func TestParseFromYamlClickHouseExecuteSQL(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/clickhouse/clickhouselistdatabases/clickhouselistdatabases_test.go b/internal/tools/clickhouse/clickhouselistdatabases/clickhouselistdatabases_test.go index c8c356b4aefd..77280b957217 100644 --- a/internal/tools/clickhouse/clickhouselistdatabases/clickhouselistdatabases_test.go +++ b/internal/tools/clickhouse/clickhouselistdatabases/clickhouselistdatabases_test.go @@ -66,7 +66,7 @@ func TestParseFromYamlClickHouseListDatabases(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/clickhouse/clickhouselisttables/clickhouselisttables_test.go b/internal/tools/clickhouse/clickhouselisttables/clickhouselisttables_test.go index 245888f94eaa..440ca8c8aac0 100644 --- a/internal/tools/clickhouse/clickhouselisttables/clickhouselisttables_test.go +++ b/internal/tools/clickhouse/clickhouselisttables/clickhouselisttables_test.go @@ -66,7 +66,7 @@ func TestParseFromYamlClickHouseListTables(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/clickhouse/clickhousesql/clickhousesql_test.go b/internal/tools/clickhouse/clickhousesql/clickhousesql_test.go index c64b12110eab..cc63df1e7325 100644 --- a/internal/tools/clickhouse/clickhousesql/clickhousesql_test.go +++ b/internal/tools/clickhouse/clickhousesql/clickhousesql_test.go @@ -98,7 +98,7 @@ func TestParseFromYamlClickHouseSQL(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudgda/cloudgda_test.go b/internal/tools/cloudgda/cloudgda_test.go index 906b0551d9c4..3f09ba92c495 100644 --- a/internal/tools/cloudgda/cloudgda_test.go +++ b/internal/tools/cloudgda/cloudgda_test.go @@ -108,7 +108,7 @@ func TestParseFromYaml(t *testing.T) { tc := tc t.Run(tc.desc, func(t *testing.T) { t.Parallel() - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudhealthcare/cloudhealthcarefhirfetchpage/cloudhealthcarefhirfetchpage_test.go b/internal/tools/cloudhealthcare/cloudhealthcarefhirfetchpage/cloudhealthcarefhirfetchpage_test.go index 38a80ce91b6a..482878204b61 100644 --- a/internal/tools/cloudhealthcare/cloudhealthcarefhirfetchpage/cloudhealthcarefhirfetchpage_test.go +++ b/internal/tools/cloudhealthcare/cloudhealthcarefhirfetchpage/cloudhealthcarefhirfetchpage_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlHealthcareFHIRFetchPage(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudhealthcare/cloudhealthcarefhirpatienteverything/cloudhealthcarefhirpatienteverything_test.go b/internal/tools/cloudhealthcare/cloudhealthcarefhirpatienteverything/cloudhealthcarefhirpatienteverything_test.go index 77463888dced..6b6757758a3c 100644 --- a/internal/tools/cloudhealthcare/cloudhealthcarefhirpatienteverything/cloudhealthcarefhirpatienteverything_test.go +++ b/internal/tools/cloudhealthcare/cloudhealthcarefhirpatienteverything/cloudhealthcarefhirpatienteverything_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlHealthcareFHIRPatientEverything(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudhealthcare/cloudhealthcarefhirpatientsearch/cloudhealthcarefhirpatientsearch_test.go b/internal/tools/cloudhealthcare/cloudhealthcarefhirpatientsearch/cloudhealthcarefhirpatientsearch_test.go index 1455ba3a2ed3..47c579de1f22 100644 --- a/internal/tools/cloudhealthcare/cloudhealthcarefhirpatientsearch/cloudhealthcarefhirpatientsearch_test.go +++ b/internal/tools/cloudhealthcare/cloudhealthcarefhirpatientsearch/cloudhealthcarefhirpatientsearch_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlHealthcareFHIRPatientSearch(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudhealthcare/cloudhealthcaregetdataset/cloudhealthcaregetdataset_test.go b/internal/tools/cloudhealthcare/cloudhealthcaregetdataset/cloudhealthcaregetdataset_test.go index c2380483cba6..b80aa18ccd10 100644 --- a/internal/tools/cloudhealthcare/cloudhealthcaregetdataset/cloudhealthcaregetdataset_test.go +++ b/internal/tools/cloudhealthcare/cloudhealthcaregetdataset/cloudhealthcaregetdataset_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlGetHealthcareDataset(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudhealthcare/cloudhealthcaregetdicomstore/cloudhealthcaregetdicomstore_test.go b/internal/tools/cloudhealthcare/cloudhealthcaregetdicomstore/cloudhealthcaregetdicomstore_test.go index 1b949aa1bf9c..5b62e241cc04 100644 --- a/internal/tools/cloudhealthcare/cloudhealthcaregetdicomstore/cloudhealthcaregetdicomstore_test.go +++ b/internal/tools/cloudhealthcare/cloudhealthcaregetdicomstore/cloudhealthcaregetdicomstore_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlHealthcareGetDICOMStore(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudhealthcare/cloudhealthcaregetdicomstoremetrics/cloudhealthcaregetdicomstoremetrics_test.go b/internal/tools/cloudhealthcare/cloudhealthcaregetdicomstoremetrics/cloudhealthcaregetdicomstoremetrics_test.go index 49c26fa969ec..91c90eabc800 100644 --- a/internal/tools/cloudhealthcare/cloudhealthcaregetdicomstoremetrics/cloudhealthcaregetdicomstoremetrics_test.go +++ b/internal/tools/cloudhealthcare/cloudhealthcaregetdicomstoremetrics/cloudhealthcaregetdicomstoremetrics_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlHealthcareGetDICOMStoreMetrics(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudhealthcare/cloudhealthcaregetfhirresource/cloudhealthcaregetfhirresource_test.go b/internal/tools/cloudhealthcare/cloudhealthcaregetfhirresource/cloudhealthcaregetfhirresource_test.go index 18c3a4404b0a..8e6f2753074a 100644 --- a/internal/tools/cloudhealthcare/cloudhealthcaregetfhirresource/cloudhealthcaregetfhirresource_test.go +++ b/internal/tools/cloudhealthcare/cloudhealthcaregetfhirresource/cloudhealthcaregetfhirresource_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlHealthcareGetFHIRResource(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudhealthcare/cloudhealthcaregetfhirstore/cloudhealthcaregetfhirstore_test.go b/internal/tools/cloudhealthcare/cloudhealthcaregetfhirstore/cloudhealthcaregetfhirstore_test.go index d62114d0112d..3d23fb115a07 100644 --- a/internal/tools/cloudhealthcare/cloudhealthcaregetfhirstore/cloudhealthcaregetfhirstore_test.go +++ b/internal/tools/cloudhealthcare/cloudhealthcaregetfhirstore/cloudhealthcaregetfhirstore_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlHealthcareGetFHIRStore(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudhealthcare/cloudhealthcaregetfhirstoremetrics/cloudhealthcaregetfhirstoremetrics_test.go b/internal/tools/cloudhealthcare/cloudhealthcaregetfhirstoremetrics/cloudhealthcaregetfhirstoremetrics_test.go index 9df54ba89f75..8862b4a42f9e 100644 --- a/internal/tools/cloudhealthcare/cloudhealthcaregetfhirstoremetrics/cloudhealthcaregetfhirstoremetrics_test.go +++ b/internal/tools/cloudhealthcare/cloudhealthcaregetfhirstoremetrics/cloudhealthcaregetfhirstoremetrics_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlHealthcareGetFHIRStoreMetrics(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudhealthcare/cloudhealthcarelistdicomstores/cloudhealthcarelistdicomstores_test.go b/internal/tools/cloudhealthcare/cloudhealthcarelistdicomstores/cloudhealthcarelistdicomstores_test.go index 220a8be05e5d..bdcf6b08d897 100644 --- a/internal/tools/cloudhealthcare/cloudhealthcarelistdicomstores/cloudhealthcarelistdicomstores_test.go +++ b/internal/tools/cloudhealthcare/cloudhealthcarelistdicomstores/cloudhealthcarelistdicomstores_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlHealthcareListDICOMStores(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudhealthcare/cloudhealthcarelistfhirstores/cloudhealthcarelistfhirstores_test.go b/internal/tools/cloudhealthcare/cloudhealthcarelistfhirstores/cloudhealthcarelistfhirstores_test.go index 8f9d4b2ad25d..e1415f467e17 100644 --- a/internal/tools/cloudhealthcare/cloudhealthcarelistfhirstores/cloudhealthcarelistfhirstores_test.go +++ b/internal/tools/cloudhealthcare/cloudhealthcarelistfhirstores/cloudhealthcarelistfhirstores_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlHealthcareListFHIRStores(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudhealthcare/cloudhealthcareretrieverendereddicominstance/cloudhealthcareretrieverendereddicominstance_test.go b/internal/tools/cloudhealthcare/cloudhealthcareretrieverendereddicominstance/cloudhealthcareretrieverendereddicominstance_test.go index 931e629fb160..125ca72e4f78 100644 --- a/internal/tools/cloudhealthcare/cloudhealthcareretrieverendereddicominstance/cloudhealthcareretrieverendereddicominstance_test.go +++ b/internal/tools/cloudhealthcare/cloudhealthcareretrieverendereddicominstance/cloudhealthcareretrieverendereddicominstance_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlHealthcareRetrieveRenderedDICOMInstance(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudhealthcare/cloudhealthcaresearchdicominstances/cloudhealthcaresearchdicominstances_test.go b/internal/tools/cloudhealthcare/cloudhealthcaresearchdicominstances/cloudhealthcaresearchdicominstances_test.go index 21f4fec1aa96..492d51a11397 100644 --- a/internal/tools/cloudhealthcare/cloudhealthcaresearchdicominstances/cloudhealthcaresearchdicominstances_test.go +++ b/internal/tools/cloudhealthcare/cloudhealthcaresearchdicominstances/cloudhealthcaresearchdicominstances_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlHealthcareSearchDICOMInstances(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudhealthcare/cloudhealthcaresearchdicomseries/cloudhealthcaresearchdicomseries_test.go b/internal/tools/cloudhealthcare/cloudhealthcaresearchdicomseries/cloudhealthcaresearchdicomseries_test.go index 55eee6e601be..5dbbb1fd7bb8 100644 --- a/internal/tools/cloudhealthcare/cloudhealthcaresearchdicomseries/cloudhealthcaresearchdicomseries_test.go +++ b/internal/tools/cloudhealthcare/cloudhealthcaresearchdicomseries/cloudhealthcaresearchdicomseries_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlHealthcareSearchDICOMSeries(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudhealthcare/cloudhealthcaresearchdicomstudies/cloudhealthcaresearchdicomstudies_test.go b/internal/tools/cloudhealthcare/cloudhealthcaresearchdicomstudies/cloudhealthcaresearchdicomstudies_test.go index 7cbabf7058dd..3b3bac17704d 100644 --- a/internal/tools/cloudhealthcare/cloudhealthcaresearchdicomstudies/cloudhealthcaresearchdicomstudies_test.go +++ b/internal/tools/cloudhealthcare/cloudhealthcaresearchdicomstudies/cloudhealthcaresearchdicomstudies_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlHealthcareSearchDICOMStudies(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudloggingadmin/cloudloggingadminlistlognames/cloudloggingadminlistlognames_test.go b/internal/tools/cloudloggingadmin/cloudloggingadminlistlognames/cloudloggingadminlistlognames_test.go index a1c6e55c7cc7..8fdc56707da9 100644 --- a/internal/tools/cloudloggingadmin/cloudloggingadminlistlognames/cloudloggingadminlistlognames_test.go +++ b/internal/tools/cloudloggingadmin/cloudloggingadminlistlognames/cloudloggingadminlistlognames_test.go @@ -57,7 +57,7 @@ func TestParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -102,7 +102,7 @@ func TestFailParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/cloudloggingadmin/cloudloggingadminlistresourcetypes/cloudloggingadminlistresourcetypes_test.go b/internal/tools/cloudloggingadmin/cloudloggingadminlistresourcetypes/cloudloggingadminlistresourcetypes_test.go index d2755179fea8..43354c9364c1 100644 --- a/internal/tools/cloudloggingadmin/cloudloggingadminlistresourcetypes/cloudloggingadminlistresourcetypes_test.go +++ b/internal/tools/cloudloggingadmin/cloudloggingadminlistresourcetypes/cloudloggingadminlistresourcetypes_test.go @@ -57,7 +57,7 @@ func TestParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -102,7 +102,7 @@ func TestFailParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/cloudloggingadmin/cloudloggingadminquerylogs/cloudloggingadminquerylogs_test.go b/internal/tools/cloudloggingadmin/cloudloggingadminquerylogs/cloudloggingadminquerylogs_test.go index 762fc63214dc..0d9f25d48010 100644 --- a/internal/tools/cloudloggingadmin/cloudloggingadminquerylogs/cloudloggingadminquerylogs_test.go +++ b/internal/tools/cloudloggingadmin/cloudloggingadminquerylogs/cloudloggingadminquerylogs_test.go @@ -57,7 +57,7 @@ func TestParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -102,7 +102,7 @@ func TestFailParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/cloudmonitoring/cloudmonitoring_test.go b/internal/tools/cloudmonitoring/cloudmonitoring_test.go index 44d87baa142a..789ef26e54e4 100644 --- a/internal/tools/cloudmonitoring/cloudmonitoring_test.go +++ b/internal/tools/cloudmonitoring/cloudmonitoring_test.go @@ -164,7 +164,7 @@ func TestParseFromYamlCloudMonitoring(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -209,7 +209,7 @@ func TestFailParseFromYamlCloudMonitoring(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/cloudsql/cloudsqlcloneinstance/cloudsqlcloneinstance_test.go b/internal/tools/cloudsql/cloudsqlcloneinstance/cloudsqlcloneinstance_test.go index 0880974a85ec..c6831a96a937 100644 --- a/internal/tools/cloudsql/cloudsqlcloneinstance/cloudsqlcloneinstance_test.go +++ b/internal/tools/cloudsql/cloudsqlcloneinstance/cloudsqlcloneinstance_test.go @@ -59,7 +59,7 @@ func TestParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudsql/cloudsqlcreatebackup/cloudsqlcreatebackup_test.go b/internal/tools/cloudsql/cloudsqlcreatebackup/cloudsqlcreatebackup_test.go index 153e69112d2b..c6ff87205069 100644 --- a/internal/tools/cloudsql/cloudsqlcreatebackup/cloudsqlcreatebackup_test.go +++ b/internal/tools/cloudsql/cloudsqlcreatebackup/cloudsqlcreatebackup_test.go @@ -58,7 +58,7 @@ func TestParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudsql/cloudsqlcreatedatabase/cloudsqlcreatedatabase_test.go b/internal/tools/cloudsql/cloudsqlcreatedatabase/cloudsqlcreatedatabase_test.go index b63885c8740b..5bc695dd180c 100644 --- a/internal/tools/cloudsql/cloudsqlcreatedatabase/cloudsqlcreatedatabase_test.go +++ b/internal/tools/cloudsql/cloudsqlcreatedatabase/cloudsqlcreatedatabase_test.go @@ -58,7 +58,7 @@ func TestParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudsql/cloudsqlcreateusers/cloudsqlcreateusers_test.go b/internal/tools/cloudsql/cloudsqlcreateusers/cloudsqlcreateusers_test.go index 2716fae104cc..b33dafb53e14 100644 --- a/internal/tools/cloudsql/cloudsqlcreateusers/cloudsqlcreateusers_test.go +++ b/internal/tools/cloudsql/cloudsqlcreateusers/cloudsqlcreateusers_test.go @@ -58,7 +58,7 @@ func TestParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudsql/cloudsqlgetinstances/cloudsqlgetinstances_test.go b/internal/tools/cloudsql/cloudsqlgetinstances/cloudsqlgetinstances_test.go index 5d8cc6fd612a..5fc8813cff6d 100644 --- a/internal/tools/cloudsql/cloudsqlgetinstances/cloudsqlgetinstances_test.go +++ b/internal/tools/cloudsql/cloudsqlgetinstances/cloudsqlgetinstances_test.go @@ -58,7 +58,7 @@ func TestParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudsql/cloudsqllistdatabases/cloudsqllistdatabases_test.go b/internal/tools/cloudsql/cloudsqllistdatabases/cloudsqllistdatabases_test.go index d65a9dafbd33..64b3890fde0d 100644 --- a/internal/tools/cloudsql/cloudsqllistdatabases/cloudsqllistdatabases_test.go +++ b/internal/tools/cloudsql/cloudsqllistdatabases/cloudsqllistdatabases_test.go @@ -58,7 +58,7 @@ func TestParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudsql/cloudsqllistinstances/cloudsqllistinstances_test.go b/internal/tools/cloudsql/cloudsqllistinstances/cloudsqllistinstances_test.go index 4365956023b9..e7b5b6ad97e9 100644 --- a/internal/tools/cloudsql/cloudsqllistinstances/cloudsqllistinstances_test.go +++ b/internal/tools/cloudsql/cloudsqllistinstances/cloudsqllistinstances_test.go @@ -57,7 +57,7 @@ func TestParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudsql/cloudsqlrestorebackup/cloudsqlrestorebackup_test.go b/internal/tools/cloudsql/cloudsqlrestorebackup/cloudsqlrestorebackup_test.go index 7240d42e7128..68db1e8496bc 100644 --- a/internal/tools/cloudsql/cloudsqlrestorebackup/cloudsqlrestorebackup_test.go +++ b/internal/tools/cloudsql/cloudsqlrestorebackup/cloudsqlrestorebackup_test.go @@ -58,7 +58,7 @@ func TestParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudsql/cloudsqlwaitforoperation/cloudsqlwaitforoperation_test.go b/internal/tools/cloudsql/cloudsqlwaitforoperation/cloudsqlwaitforoperation_test.go index 53b8480a308e..d78c99670857 100644 --- a/internal/tools/cloudsql/cloudsqlwaitforoperation/cloudsqlwaitforoperation_test.go +++ b/internal/tools/cloudsql/cloudsqlwaitforoperation/cloudsqlwaitforoperation_test.go @@ -66,7 +66,7 @@ func TestParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudsqladmin/cloudsqladminexecutemany/cloudsqladminexecutemany_test.go b/internal/tools/cloudsqladmin/cloudsqladminexecutemany/cloudsqladminexecutemany_test.go index 7d8f2370b755..f6d8db3c8676 100644 --- a/internal/tools/cloudsqladmin/cloudsqladminexecutemany/cloudsqladminexecutemany_test.go +++ b/internal/tools/cloudsqladmin/cloudsqladminexecutemany/cloudsqladminexecutemany_test.go @@ -60,7 +60,7 @@ func TestParseFromYamlExecuteSqlMany(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudsqladmin/cloudsqladminsqlmany/cloudsqladminsqlmany_test.go b/internal/tools/cloudsqladmin/cloudsqladminsqlmany/cloudsqladminsqlmany_test.go index b5a58905cdd8..260374169fa1 100644 --- a/internal/tools/cloudsqladmin/cloudsqladminsqlmany/cloudsqladminsqlmany_test.go +++ b/internal/tools/cloudsqladmin/cloudsqladminsqlmany/cloudsqladminsqlmany_test.go @@ -100,7 +100,7 @@ func TestParseFromYamlSqlMany(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudsqlmssql/cloudsqlmssqlcreateinstance/cloudsqlmssqlcreateinstance_test.go b/internal/tools/cloudsqlmssql/cloudsqlmssqlcreateinstance/cloudsqlmssqlcreateinstance_test.go index 5e1d37971d82..c2e703d69b9a 100644 --- a/internal/tools/cloudsqlmssql/cloudsqlmssqlcreateinstance/cloudsqlmssqlcreateinstance_test.go +++ b/internal/tools/cloudsqlmssql/cloudsqlmssqlcreateinstance/cloudsqlmssqlcreateinstance_test.go @@ -58,7 +58,7 @@ func TestParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudsqlmysql/cloudsqlmysqlcreateinstance/cloudsqlmysqlcreateinstance_test.go b/internal/tools/cloudsqlmysql/cloudsqlmysqlcreateinstance/cloudsqlmysqlcreateinstance_test.go index 35bc66e41b9c..3b76d1f04352 100644 --- a/internal/tools/cloudsqlmysql/cloudsqlmysqlcreateinstance/cloudsqlmysqlcreateinstance_test.go +++ b/internal/tools/cloudsqlmysql/cloudsqlmysqlcreateinstance/cloudsqlmysqlcreateinstance_test.go @@ -58,7 +58,7 @@ func TestParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudsqlpg/cloudsqlpgcreateinstances/cloudsqlpgcreateinstances_test.go b/internal/tools/cloudsqlpg/cloudsqlpgcreateinstances/cloudsqlpgcreateinstances_test.go index 05528709933d..db41d16669fe 100644 --- a/internal/tools/cloudsqlpg/cloudsqlpgcreateinstances/cloudsqlpgcreateinstances_test.go +++ b/internal/tools/cloudsqlpg/cloudsqlpgcreateinstances/cloudsqlpgcreateinstances_test.go @@ -58,7 +58,7 @@ func TestParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudsqlpg/cloudsqlpgupgradeprecheck/cloudsqlpgupgradeprecheck_test.go b/internal/tools/cloudsqlpg/cloudsqlpgupgradeprecheck/cloudsqlpgupgradeprecheck_test.go index 1e0aaf649951..3dd0a53c9c83 100644 --- a/internal/tools/cloudsqlpg/cloudsqlpgupgradeprecheck/cloudsqlpgupgradeprecheck_test.go +++ b/internal/tools/cloudsqlpg/cloudsqlpgupgradeprecheck/cloudsqlpgupgradeprecheck_test.go @@ -81,7 +81,7 @@ func TestParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudsqlpg/vectorassistapplyspec/vectorassistapplyspec_test.go b/internal/tools/cloudsqlpg/vectorassistapplyspec/vectorassistapplyspec_test.go index 5494c58dc9a1..014c4e0f8348 100644 --- a/internal/tools/cloudsqlpg/vectorassistapplyspec/vectorassistapplyspec_test.go +++ b/internal/tools/cloudsqlpg/vectorassistapplyspec/vectorassistapplyspec_test.go @@ -58,7 +58,7 @@ func TestParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudsqlpg/vectorassistdefinespec/vectorassistdefinespec_test.go b/internal/tools/cloudsqlpg/vectorassistdefinespec/vectorassistdefinespec_test.go index f6d4b2d12403..917bfa52c601 100644 --- a/internal/tools/cloudsqlpg/vectorassistdefinespec/vectorassistdefinespec_test.go +++ b/internal/tools/cloudsqlpg/vectorassistdefinespec/vectorassistdefinespec_test.go @@ -58,7 +58,7 @@ func TestParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudsqlpg/vectorassistdeletespec/vectorassistdeletespec_test.go b/internal/tools/cloudsqlpg/vectorassistdeletespec/vectorassistdeletespec_test.go index c9325f54c834..99bc89580f48 100644 --- a/internal/tools/cloudsqlpg/vectorassistdeletespec/vectorassistdeletespec_test.go +++ b/internal/tools/cloudsqlpg/vectorassistdeletespec/vectorassistdeletespec_test.go @@ -58,7 +58,7 @@ func TestParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudsqlpg/vectorassistgeneratequery/vectorassistgeneratequery_test.go b/internal/tools/cloudsqlpg/vectorassistgeneratequery/vectorassistgeneratequery_test.go index d6bea9e0d2a7..3560662990d9 100644 --- a/internal/tools/cloudsqlpg/vectorassistgeneratequery/vectorassistgeneratequery_test.go +++ b/internal/tools/cloudsqlpg/vectorassistgeneratequery/vectorassistgeneratequery_test.go @@ -58,7 +58,7 @@ func TestParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudsqlpg/vectorassistgetspec/vectorassistgetspec_test.go b/internal/tools/cloudsqlpg/vectorassistgetspec/vectorassistgetspec_test.go index d92a490e36d5..da413556b884 100644 --- a/internal/tools/cloudsqlpg/vectorassistgetspec/vectorassistgetspec_test.go +++ b/internal/tools/cloudsqlpg/vectorassistgetspec/vectorassistgetspec_test.go @@ -58,7 +58,7 @@ func TestParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudsqlpg/vectorassistimprovequeryrecall/vectorassistimprovequeryrecall_test.go b/internal/tools/cloudsqlpg/vectorassistimprovequeryrecall/vectorassistimprovequeryrecall_test.go index 69e8ce85b0e7..c4e832b9f83b 100644 --- a/internal/tools/cloudsqlpg/vectorassistimprovequeryrecall/vectorassistimprovequeryrecall_test.go +++ b/internal/tools/cloudsqlpg/vectorassistimprovequeryrecall/vectorassistimprovequeryrecall_test.go @@ -58,7 +58,7 @@ func TestParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudsqlpg/vectorassistlistspecs/vectorassistlistspecs_test.go b/internal/tools/cloudsqlpg/vectorassistlistspecs/vectorassistlistspecs_test.go index 4f22cd8acc15..37d80fe26709 100644 --- a/internal/tools/cloudsqlpg/vectorassistlistspecs/vectorassistlistspecs_test.go +++ b/internal/tools/cloudsqlpg/vectorassistlistspecs/vectorassistlistspecs_test.go @@ -58,7 +58,7 @@ func TestParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudsqlpg/vectorassistmodifyspec/vectorassistmodifyspec_test.go b/internal/tools/cloudsqlpg/vectorassistmodifyspec/vectorassistmodifyspec_test.go index 12442532477d..f10b6973522a 100644 --- a/internal/tools/cloudsqlpg/vectorassistmodifyspec/vectorassistmodifyspec_test.go +++ b/internal/tools/cloudsqlpg/vectorassistmodifyspec/vectorassistmodifyspec_test.go @@ -58,7 +58,7 @@ func TestParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudstorage/cloudstoragecopyobject/cloudstoragecopyobject_test.go b/internal/tools/cloudstorage/cloudstoragecopyobject/cloudstoragecopyobject_test.go index 53b2faedf613..7e44d5b5def5 100644 --- a/internal/tools/cloudstorage/cloudstoragecopyobject/cloudstoragecopyobject_test.go +++ b/internal/tools/cloudstorage/cloudstoragecopyobject/cloudstoragecopyobject_test.go @@ -86,7 +86,7 @@ func TestParseFromYamlCloudStorageCopyObject(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudstorage/cloudstoragecreatebucket/cloudstoragecreatebucket_test.go b/internal/tools/cloudstorage/cloudstoragecreatebucket/cloudstoragecreatebucket_test.go index 3dea3b98c614..0a39b4a72fa1 100644 --- a/internal/tools/cloudstorage/cloudstoragecreatebucket/cloudstoragecreatebucket_test.go +++ b/internal/tools/cloudstorage/cloudstoragecreatebucket/cloudstoragecreatebucket_test.go @@ -86,7 +86,7 @@ func TestParseFromYamlCloudStorageCreateBucket(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudstorage/cloudstoragedeletebucket/cloudstoragedeletebucket_test.go b/internal/tools/cloudstorage/cloudstoragedeletebucket/cloudstoragedeletebucket_test.go index e5031ae37bcb..4734616af13b 100644 --- a/internal/tools/cloudstorage/cloudstoragedeletebucket/cloudstoragedeletebucket_test.go +++ b/internal/tools/cloudstorage/cloudstoragedeletebucket/cloudstoragedeletebucket_test.go @@ -86,7 +86,7 @@ func TestParseFromYamlCloudStorageDeleteBucket(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudstorage/cloudstoragedeleteobject/cloudstoragedeleteobject_test.go b/internal/tools/cloudstorage/cloudstoragedeleteobject/cloudstoragedeleteobject_test.go index 05ca92f44729..7cd92851445e 100644 --- a/internal/tools/cloudstorage/cloudstoragedeleteobject/cloudstoragedeleteobject_test.go +++ b/internal/tools/cloudstorage/cloudstoragedeleteobject/cloudstoragedeleteobject_test.go @@ -86,7 +86,7 @@ func TestParseFromYamlCloudStorageDeleteObject(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudstorage/cloudstoragedownloadobject/cloudstoragedownloadobject_test.go b/internal/tools/cloudstorage/cloudstoragedownloadobject/cloudstoragedownloadobject_test.go index e32debf5d699..a41b1a554944 100644 --- a/internal/tools/cloudstorage/cloudstoragedownloadobject/cloudstoragedownloadobject_test.go +++ b/internal/tools/cloudstorage/cloudstoragedownloadobject/cloudstoragedownloadobject_test.go @@ -87,7 +87,7 @@ func TestParseFromYamlCloudStorageDownloadObject(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudstorage/cloudstoragegetbucketiampolicy/cloudstoragegetbucketiampolicy_test.go b/internal/tools/cloudstorage/cloudstoragegetbucketiampolicy/cloudstoragegetbucketiampolicy_test.go index 5bbeec344041..1a7bb2b41acb 100644 --- a/internal/tools/cloudstorage/cloudstoragegetbucketiampolicy/cloudstoragegetbucketiampolicy_test.go +++ b/internal/tools/cloudstorage/cloudstoragegetbucketiampolicy/cloudstoragegetbucketiampolicy_test.go @@ -86,7 +86,7 @@ func TestParseFromYamlCloudStorageGetBucketIAMPolicy(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudstorage/cloudstoragegetbucketmetadata/cloudstoragegetbucketmetadata_test.go b/internal/tools/cloudstorage/cloudstoragegetbucketmetadata/cloudstoragegetbucketmetadata_test.go index 2cc825f562cd..edeccfe05a22 100644 --- a/internal/tools/cloudstorage/cloudstoragegetbucketmetadata/cloudstoragegetbucketmetadata_test.go +++ b/internal/tools/cloudstorage/cloudstoragegetbucketmetadata/cloudstoragegetbucketmetadata_test.go @@ -87,7 +87,7 @@ func TestParseFromYamlCloudStorageGetBucketMetadata(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudstorage/cloudstoragegetobjectmetadata/cloudstoragegetobjectmetadata_test.go b/internal/tools/cloudstorage/cloudstoragegetobjectmetadata/cloudstoragegetobjectmetadata_test.go index 2f93cec5e5e3..fb924226219a 100644 --- a/internal/tools/cloudstorage/cloudstoragegetobjectmetadata/cloudstoragegetobjectmetadata_test.go +++ b/internal/tools/cloudstorage/cloudstoragegetobjectmetadata/cloudstoragegetobjectmetadata_test.go @@ -87,7 +87,7 @@ func TestParseFromYamlCloudStorageGetObjectMetadata(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudstorage/cloudstoragelistbuckets/cloudstoragelistbuckets_test.go b/internal/tools/cloudstorage/cloudstoragelistbuckets/cloudstoragelistbuckets_test.go index a8ff2931dc41..2997ddbbc772 100644 --- a/internal/tools/cloudstorage/cloudstoragelistbuckets/cloudstoragelistbuckets_test.go +++ b/internal/tools/cloudstorage/cloudstoragelistbuckets/cloudstoragelistbuckets_test.go @@ -86,7 +86,7 @@ func TestParseFromYamlCloudStorageListBuckets(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudstorage/cloudstoragelistobjects/cloudstoragelistobjects_test.go b/internal/tools/cloudstorage/cloudstoragelistobjects/cloudstoragelistobjects_test.go index 6328333e831e..d4a03ea2c9af 100644 --- a/internal/tools/cloudstorage/cloudstoragelistobjects/cloudstoragelistobjects_test.go +++ b/internal/tools/cloudstorage/cloudstoragelistobjects/cloudstoragelistobjects_test.go @@ -87,7 +87,7 @@ func TestParseFromYamlCloudStorageListObjects(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudstorage/cloudstoragemoveobject/cloudstoragemoveobject_test.go b/internal/tools/cloudstorage/cloudstoragemoveobject/cloudstoragemoveobject_test.go index 5f317a060fd3..3ba86c0e350a 100644 --- a/internal/tools/cloudstorage/cloudstoragemoveobject/cloudstoragemoveobject_test.go +++ b/internal/tools/cloudstorage/cloudstoragemoveobject/cloudstoragemoveobject_test.go @@ -86,7 +86,7 @@ func TestParseFromYamlCloudStorageMoveObject(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudstorage/cloudstoragereadobject/cloudstoragereadobject_test.go b/internal/tools/cloudstorage/cloudstoragereadobject/cloudstoragereadobject_test.go index f65e6691fc8d..8b59452b9628 100644 --- a/internal/tools/cloudstorage/cloudstoragereadobject/cloudstoragereadobject_test.go +++ b/internal/tools/cloudstorage/cloudstoragereadobject/cloudstoragereadobject_test.go @@ -80,7 +80,7 @@ func TestParseFromYamlCloudStorageReadObject(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudstorage/cloudstorageuploadobject/cloudstorageuploadobject_test.go b/internal/tools/cloudstorage/cloudstorageuploadobject/cloudstorageuploadobject_test.go index ffeb23827532..e24e5d6cddfd 100644 --- a/internal/tools/cloudstorage/cloudstorageuploadobject/cloudstorageuploadobject_test.go +++ b/internal/tools/cloudstorage/cloudstorageuploadobject/cloudstorageuploadobject_test.go @@ -87,7 +87,7 @@ func TestParseFromYamlCloudStorageUploadObject(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cloudstorage/cloudstoragewriteobject/cloudstoragewriteobject_test.go b/internal/tools/cloudstorage/cloudstoragewriteobject/cloudstoragewriteobject_test.go index 4a2d7f9a86e5..35f2730b4ec7 100644 --- a/internal/tools/cloudstorage/cloudstoragewriteobject/cloudstoragewriteobject_test.go +++ b/internal/tools/cloudstorage/cloudstoragewriteobject/cloudstoragewriteobject_test.go @@ -86,7 +86,7 @@ func TestParseFromYamlCloudStorageWriteObject(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cockroachdb/cockroachdbexecutesql/cockroachdbexecutesql_test.go b/internal/tools/cockroachdb/cockroachdbexecutesql/cockroachdbexecutesql_test.go index 5a7bfa83007f..00c40f3dab9c 100644 --- a/internal/tools/cockroachdb/cockroachdbexecutesql/cockroachdbexecutesql_test.go +++ b/internal/tools/cockroachdb/cockroachdbexecutesql/cockroachdbexecutesql_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlCockroachDBExecuteSQL(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cockroachdb/cockroachdblistschemas/cockroachdblistschemas_test.go b/internal/tools/cockroachdb/cockroachdblistschemas/cockroachdblistschemas_test.go index d1727d34bdf3..50e27dc57a61 100644 --- a/internal/tools/cockroachdb/cockroachdblistschemas/cockroachdblistschemas_test.go +++ b/internal/tools/cockroachdb/cockroachdblistschemas/cockroachdblistschemas_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlCockroachDBListSchemas(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cockroachdb/cockroachdblisttables/cockroachdblisttables_test.go b/internal/tools/cockroachdb/cockroachdblisttables/cockroachdblisttables_test.go index cf776342e16a..269676e6e8c0 100644 --- a/internal/tools/cockroachdb/cockroachdblisttables/cockroachdblisttables_test.go +++ b/internal/tools/cockroachdb/cockroachdblisttables/cockroachdblisttables_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlCockroachDBListTables(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/cockroachdb/cockroachdbsql/cockroachdbsql_test.go b/internal/tools/cockroachdb/cockroachdbsql/cockroachdbsql_test.go index 10e587031db3..72ef19eb839f 100644 --- a/internal/tools/cockroachdb/cockroachdbsql/cockroachdbsql_test.go +++ b/internal/tools/cockroachdb/cockroachdbsql/cockroachdbsql_test.go @@ -70,7 +70,7 @@ func TestParseFromYamlCockroachDB(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/conversationalanalytics/conversationalanalyticsaskdataagent/conversationalanalyticsaskdataagent_test.go b/internal/tools/conversationalanalytics/conversationalanalyticsaskdataagent/conversationalanalyticsaskdataagent_test.go index e50015eff56e..bb0e2a19d856 100644 --- a/internal/tools/conversationalanalytics/conversationalanalyticsaskdataagent/conversationalanalyticsaskdataagent_test.go +++ b/internal/tools/conversationalanalytics/conversationalanalyticsaskdataagent/conversationalanalyticsaskdataagent_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlConversationalAnalyticsAskDataAgent(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/conversationalanalytics/conversationalanalyticsgetdataagentinfo/conversationalanalyticsgetdataagentinfo_test.go b/internal/tools/conversationalanalytics/conversationalanalyticsgetdataagentinfo/conversationalanalyticsgetdataagentinfo_test.go index 5e6dc6d09d36..aec5f7c801ee 100644 --- a/internal/tools/conversationalanalytics/conversationalanalyticsgetdataagentinfo/conversationalanalyticsgetdataagentinfo_test.go +++ b/internal/tools/conversationalanalytics/conversationalanalyticsgetdataagentinfo/conversationalanalyticsgetdataagentinfo_test.go @@ -84,7 +84,7 @@ func TestParseFromYamlConversationalAnalyticsGetDataAgent(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/conversationalanalytics/conversationalanalyticslistaccessibledataagents/conversationalanalyticslistaccessibledataagents_test.go b/internal/tools/conversationalanalytics/conversationalanalyticslistaccessibledataagents/conversationalanalyticslistaccessibledataagents_test.go index f54d582d73c2..3b3f2d187abc 100644 --- a/internal/tools/conversationalanalytics/conversationalanalyticslistaccessibledataagents/conversationalanalyticslistaccessibledataagents_test.go +++ b/internal/tools/conversationalanalytics/conversationalanalyticslistaccessibledataagents/conversationalanalyticslistaccessibledataagents_test.go @@ -84,7 +84,7 @@ func TestParseFromYamlConversationalAnalyticsListDataAgents(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/couchbase/couchbase_test.go b/internal/tools/couchbase/couchbase_test.go index 047a7c63c0ce..21af5f742443 100644 --- a/internal/tools/couchbase/couchbase_test.go +++ b/internal/tools/couchbase/couchbase_test.go @@ -108,7 +108,7 @@ func TestParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/dataform/dataformcompilelocal/dataformcompilelocal_test.go b/internal/tools/dataform/dataformcompilelocal/dataformcompilelocal_test.go index 1fc972eabb80..a89358b22e77 100644 --- a/internal/tools/dataform/dataformcompilelocal/dataformcompilelocal_test.go +++ b/internal/tools/dataform/dataformcompilelocal/dataformcompilelocal_test.go @@ -56,7 +56,7 @@ func TestParseFromYamlDataformCompile(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/datalineage/datalineagesearchlineage/datalineagesearchlineage_test.go b/internal/tools/datalineage/datalineagesearchlineage/datalineagesearchlineage_test.go index 6c1d2fe2ddf0..a2f9abc61895 100644 --- a/internal/tools/datalineage/datalineagesearchlineage/datalineagesearchlineage_test.go +++ b/internal/tools/datalineage/datalineagesearchlineage/datalineagesearchlineage_test.go @@ -65,7 +65,7 @@ func TestParseFromYamlDatalineageSearchLineage(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/dataplex/dataplexcheckdataquality/dataplexcheckdataquality_test.go b/internal/tools/dataplex/dataplexcheckdataquality/dataplexcheckdataquality_test.go index 838dcd56ed00..5ed974908d6e 100644 --- a/internal/tools/dataplex/dataplexcheckdataquality/dataplexcheckdataquality_test.go +++ b/internal/tools/dataplex/dataplexcheckdataquality/dataplexcheckdataquality_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlDataplexCheckDataQuality(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/dataplex/dataplexgeneratedatainsights/dataplexgeneratedatainsights_test.go b/internal/tools/dataplex/dataplexgeneratedatainsights/dataplexgeneratedatainsights_test.go index bfb434c3a431..5421f7770640 100644 --- a/internal/tools/dataplex/dataplexgeneratedatainsights/dataplexgeneratedatainsights_test.go +++ b/internal/tools/dataplex/dataplexgeneratedatainsights/dataplexgeneratedatainsights_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlDataplexGenerateDataInsights(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/dataplex/dataplexgeneratedataprofile/dataplexgeneratedataprofile_test.go b/internal/tools/dataplex/dataplexgeneratedataprofile/dataplexgeneratedataprofile_test.go index d82e2241db62..63390d9ce4c6 100644 --- a/internal/tools/dataplex/dataplexgeneratedataprofile/dataplexgeneratedataprofile_test.go +++ b/internal/tools/dataplex/dataplexgeneratedataprofile/dataplexgeneratedataprofile_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlDataplexGenerateDataProfile(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/dataplex/dataplexgetdatainsights/dataplexgetdatainsights_test.go b/internal/tools/dataplex/dataplexgetdatainsights/dataplexgetdatainsights_test.go index be6e8fe8b97e..3dcbe09cee9f 100644 --- a/internal/tools/dataplex/dataplexgetdatainsights/dataplexgetdatainsights_test.go +++ b/internal/tools/dataplex/dataplexgetdatainsights/dataplexgetdatainsights_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlDataplexGetDataInsights(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/dataplex/dataplexgetdataprofile/dataplexgetdataprofile_test.go b/internal/tools/dataplex/dataplexgetdataprofile/dataplexgetdataprofile_test.go index d4e87e39f8fc..e82034fe564e 100644 --- a/internal/tools/dataplex/dataplexgetdataprofile/dataplexgetdataprofile_test.go +++ b/internal/tools/dataplex/dataplexgetdataprofile/dataplexgetdataprofile_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlDataplexGetDataProfile(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/dataplex/dataplexgetdataqualityresults/dataplexgetdataqualityresults_test.go b/internal/tools/dataplex/dataplexgetdataqualityresults/dataplexgetdataqualityresults_test.go index 29c8aeafda11..75f255058894 100644 --- a/internal/tools/dataplex/dataplexgetdataqualityresults/dataplexgetdataqualityresults_test.go +++ b/internal/tools/dataplex/dataplexgetdataqualityresults/dataplexgetdataqualityresults_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlDataplexGetDataQualityResults(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/dataplex/dataplexgetdiscoveryresults/dataplexgetdiscoveryresults_test.go b/internal/tools/dataplex/dataplexgetdiscoveryresults/dataplexgetdiscoveryresults_test.go index 5343a991f96a..3d99f1e8a256 100644 --- a/internal/tools/dataplex/dataplexgetdiscoveryresults/dataplexgetdiscoveryresults_test.go +++ b/internal/tools/dataplex/dataplexgetdiscoveryresults/dataplexgetdiscoveryresults_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlDataplexGetDiscoveryResults(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/dataplex/dataplexgetoperation/dataplexgetoperation_test.go b/internal/tools/dataplex/dataplexgetoperation/dataplexgetoperation_test.go index e3bcbaaf361e..cd9d370c142b 100644 --- a/internal/tools/dataplex/dataplexgetoperation/dataplexgetoperation_test.go +++ b/internal/tools/dataplex/dataplexgetoperation/dataplexgetoperation_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlDataplexGetOperation(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/dataplex/dataplexgetrunstatus/dataplexgetrunstatus_test.go b/internal/tools/dataplex/dataplexgetrunstatus/dataplexgetrunstatus_test.go index c4e4862ede4a..2faa3a755d0b 100644 --- a/internal/tools/dataplex/dataplexgetrunstatus/dataplexgetrunstatus_test.go +++ b/internal/tools/dataplex/dataplexgetrunstatus/dataplexgetrunstatus_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlDataplexGetRunStatus(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/dataplex/dataplexlookupcontext/dataplexlookupcontext_test.go b/internal/tools/dataplex/dataplexlookupcontext/dataplexlookupcontext_test.go index 56e3bfc72ace..14fe982eaf4b 100644 --- a/internal/tools/dataplex/dataplexlookupcontext/dataplexlookupcontext_test.go +++ b/internal/tools/dataplex/dataplexlookupcontext/dataplexlookupcontext_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlDataplexLookupContext(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/dataplex/dataplexlookupentry/dataplexlookupentry_test.go b/internal/tools/dataplex/dataplexlookupentry/dataplexlookupentry_test.go index 8e53ef867c1e..f3c0af9984ee 100644 --- a/internal/tools/dataplex/dataplexlookupentry/dataplexlookupentry_test.go +++ b/internal/tools/dataplex/dataplexlookupentry/dataplexlookupentry_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlDataplexLookupEntry(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/dataplex/dataplexsearchaspecttypes/dataplexsearchaspecttypes_test.go b/internal/tools/dataplex/dataplexsearchaspecttypes/dataplexsearchaspecttypes_test.go index ff24b2842b3d..c7a48c53aaf0 100644 --- a/internal/tools/dataplex/dataplexsearchaspecttypes/dataplexsearchaspecttypes_test.go +++ b/internal/tools/dataplex/dataplexsearchaspecttypes/dataplexsearchaspecttypes_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlDataplexSearchAspectTypes(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/dataplex/dataplexsearchdqscans/dataplexsearchdqscans_test.go b/internal/tools/dataplex/dataplexsearchdqscans/dataplexsearchdqscans_test.go index bf0d6e3d83a6..a650b55ce37f 100644 --- a/internal/tools/dataplex/dataplexsearchdqscans/dataplexsearchdqscans_test.go +++ b/internal/tools/dataplex/dataplexsearchdqscans/dataplexsearchdqscans_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlDataplexSearchDQScans(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/dataplex/dataplexsearchentries/dataplexsearchentries_test.go b/internal/tools/dataplex/dataplexsearchentries/dataplexsearchentries_test.go index 810b220a5306..850904692c6f 100644 --- a/internal/tools/dataplex/dataplexsearchentries/dataplexsearchentries_test.go +++ b/internal/tools/dataplex/dataplexsearchentries/dataplexsearchentries_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlDataplexSearchEntries(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/dataproc/dataprocgetcluster/dataprocgetcluster_test.go b/internal/tools/dataproc/dataprocgetcluster/dataprocgetcluster_test.go index e70caf3bd3b4..d075d96d5efd 100644 --- a/internal/tools/dataproc/dataprocgetcluster/dataprocgetcluster_test.go +++ b/internal/tools/dataproc/dataprocgetcluster/dataprocgetcluster_test.go @@ -58,7 +58,7 @@ func TestParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/dataproc/dataprocgetjob/dataprocgetjob_test.go b/internal/tools/dataproc/dataprocgetjob/dataprocgetjob_test.go index e702c165c54b..6cc5cb085caf 100644 --- a/internal/tools/dataproc/dataprocgetjob/dataprocgetjob_test.go +++ b/internal/tools/dataproc/dataprocgetjob/dataprocgetjob_test.go @@ -58,7 +58,7 @@ func TestParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/dataproc/dataproclistclusters/dataproclistclusters_test.go b/internal/tools/dataproc/dataproclistclusters/dataproclistclusters_test.go index 2a8e4b812845..0bc42597ee89 100644 --- a/internal/tools/dataproc/dataproclistclusters/dataproclistclusters_test.go +++ b/internal/tools/dataproc/dataproclistclusters/dataproclistclusters_test.go @@ -58,7 +58,7 @@ func TestParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/dataproc/dataproclistjobs/dataproclistjobs_test.go b/internal/tools/dataproc/dataproclistjobs/dataproclistjobs_test.go index 056523c33ec3..40c5884eeabe 100644 --- a/internal/tools/dataproc/dataproclistjobs/dataproclistjobs_test.go +++ b/internal/tools/dataproc/dataproclistjobs/dataproclistjobs_test.go @@ -58,7 +58,7 @@ func TestParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/dgraph/dgraph_test.go b/internal/tools/dgraph/dgraph_test.go index 92910e201781..55f6e6653c1d 100644 --- a/internal/tools/dgraph/dgraph_test.go +++ b/internal/tools/dgraph/dgraph_test.go @@ -89,7 +89,7 @@ func TestParseFromYamlDgraph(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/elasticsearch/elasticsearchesql/elasticsearchesql_test.go b/internal/tools/elasticsearch/elasticsearchesql/elasticsearchesql_test.go index be69db7cd365..83a0fad6f52b 100644 --- a/internal/tools/elasticsearch/elasticsearchesql/elasticsearchesql_test.go +++ b/internal/tools/elasticsearch/elasticsearchesql/elasticsearchesql_test.go @@ -96,7 +96,7 @@ func TestParseFromYamlElasticsearchEsql(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/elasticsearch/elasticsearchexecuteesql/elasticsearchexecuteesql_test.go b/internal/tools/elasticsearch/elasticsearchexecuteesql/elasticsearchexecuteesql_test.go index 1f315eade644..02374932c486 100644 --- a/internal/tools/elasticsearch/elasticsearchexecuteesql/elasticsearchexecuteesql_test.go +++ b/internal/tools/elasticsearch/elasticsearchexecuteesql/elasticsearchexecuteesql_test.go @@ -81,7 +81,7 @@ func TestParseFromYamlElasticsearchExecuteEsql(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/firebird/firebirdexecutesql/firebirdexecutesql_test.go b/internal/tools/firebird/firebirdexecutesql/firebirdexecutesql_test.go index 475ae885387b..1f718e3024ee 100644 --- a/internal/tools/firebird/firebirdexecutesql/firebirdexecutesql_test.go +++ b/internal/tools/firebird/firebirdexecutesql/firebirdexecutesql_test.go @@ -62,7 +62,7 @@ func TestParseFromYamlExecuteSql(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/firebird/firebirdsql/firebirdsql_test.go b/internal/tools/firebird/firebirdsql/firebirdsql_test.go index c56869daefc0..37d76b0858b6 100644 --- a/internal/tools/firebird/firebirdsql/firebirdsql_test.go +++ b/internal/tools/firebird/firebirdsql/firebirdsql_test.go @@ -80,7 +80,7 @@ func TestParseFromYamlFirebird(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -152,7 +152,7 @@ func TestParseFromYamlWithTemplateParamsFirebird(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/firestore/firestoreadddocuments/firestoreadddocuments_test.go b/internal/tools/firestore/firestoreadddocuments/firestoreadddocuments_test.go index 06d4ae07cab4..33457f64f843 100644 --- a/internal/tools/firestore/firestoreadddocuments/firestoreadddocuments_test.go +++ b/internal/tools/firestore/firestoreadddocuments/firestoreadddocuments_test.go @@ -82,7 +82,7 @@ func TestParseFromYamlFirestoreAddDocuments(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -151,7 +151,7 @@ func TestParseFromYamlMultipleTools(t *testing.T) { Source: "orders-firestore", }, } - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/firestore/firestoredeletedocuments/firestoredeletedocuments_test.go b/internal/tools/firestore/firestoredeletedocuments/firestoredeletedocuments_test.go index 2a3b882f41c2..1009563e9798 100644 --- a/internal/tools/firestore/firestoredeletedocuments/firestoredeletedocuments_test.go +++ b/internal/tools/firestore/firestoredeletedocuments/firestoredeletedocuments_test.go @@ -82,7 +82,7 @@ func TestParseFromYamlFirestoreDeleteDocuments(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -152,7 +152,7 @@ func TestParseFromYamlMultipleTools(t *testing.T) { }, } - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/firestore/firestoregetdocuments/firestoregetdocuments_test.go b/internal/tools/firestore/firestoregetdocuments/firestoregetdocuments_test.go index 30e235f61997..cd54a5db676a 100644 --- a/internal/tools/firestore/firestoregetdocuments/firestoregetdocuments_test.go +++ b/internal/tools/firestore/firestoregetdocuments/firestoregetdocuments_test.go @@ -82,7 +82,7 @@ func TestParseFromYamlFirestoreGetDocuments(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -152,7 +152,7 @@ func TestParseFromYamlMultipleTools(t *testing.T) { }, } - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/firestore/firestoregetrules/firestoregetrules_test.go b/internal/tools/firestore/firestoregetrules/firestoregetrules_test.go index 00106f7ce87f..e985c13caca1 100644 --- a/internal/tools/firestore/firestoregetrules/firestoregetrules_test.go +++ b/internal/tools/firestore/firestoregetrules/firestoregetrules_test.go @@ -82,7 +82,7 @@ func TestParseFromYamlFirestoreGetRules(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -152,7 +152,7 @@ func TestParseFromYamlMultipleTools(t *testing.T) { }, } - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/firestore/firestorelistcollections/firestorelistcollections_test.go b/internal/tools/firestore/firestorelistcollections/firestorelistcollections_test.go index f5f7c0a8d68f..8829496cb0b3 100644 --- a/internal/tools/firestore/firestorelistcollections/firestorelistcollections_test.go +++ b/internal/tools/firestore/firestorelistcollections/firestorelistcollections_test.go @@ -82,7 +82,7 @@ func TestParseFromYamlFirestoreListCollections(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -152,7 +152,7 @@ func TestParseFromYamlMultipleTools(t *testing.T) { }, } - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/firestore/firestorequery/firestorequery_test.go b/internal/tools/firestore/firestorequery/firestorequery_test.go index e73f51e4f1bf..5a9af728254a 100644 --- a/internal/tools/firestore/firestorequery/firestorequery_test.go +++ b/internal/tools/firestore/firestorequery/firestorequery_test.go @@ -318,7 +318,7 @@ func TestParseFromYamlFirestoreQuery(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -495,7 +495,7 @@ func TestParseFromYamlMultipleQueryTools(t *testing.T) { }, } - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/firestore/firestorequerycollection/firestorequerycollection_test.go b/internal/tools/firestore/firestorequerycollection/firestorequerycollection_test.go index df31ce3a9490..d45fc5a31718 100644 --- a/internal/tools/firestore/firestorequerycollection/firestorequerycollection_test.go +++ b/internal/tools/firestore/firestorequerycollection/firestorequerycollection_test.go @@ -83,7 +83,7 @@ func TestParseFromYamlFirestoreQueryCollection(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -153,7 +153,7 @@ func TestParseFromYamlMultipleTools(t *testing.T) { }, } - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/firestore/firestoreupdatedocument/firestoreupdatedocument_test.go b/internal/tools/firestore/firestoreupdatedocument/firestoreupdatedocument_test.go index dd077369cfec..77aff9ac41f3 100644 --- a/internal/tools/firestore/firestoreupdatedocument/firestoreupdatedocument_test.go +++ b/internal/tools/firestore/firestoreupdatedocument/firestoreupdatedocument_test.go @@ -94,7 +94,7 @@ func TestNewConfig(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tt.yaml)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(context.Background(), testutils.FormatYaml(tt.yaml)) if tt.wantErr { if err == nil { t.Fatalf("expected error but got none") diff --git a/internal/tools/firestore/firestorevalidaterules/firestorevalidaterules_test.go b/internal/tools/firestore/firestorevalidaterules/firestorevalidaterules_test.go index 2e7c696077d3..39056c605b5d 100644 --- a/internal/tools/firestore/firestorevalidaterules/firestorevalidaterules_test.go +++ b/internal/tools/firestore/firestorevalidaterules/firestorevalidaterules_test.go @@ -82,7 +82,7 @@ func TestParseFromYamlFirestoreValidateRules(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -152,7 +152,7 @@ func TestParseFromYamlMultipleTools(t *testing.T) { }, } - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/http/http_test.go b/internal/tools/http/http_test.go index 873118bc0c7d..fec0d29fce2c 100644 --- a/internal/tools/http/http_test.go +++ b/internal/tools/http/http_test.go @@ -144,7 +144,7 @@ func TestParseFromYamlHTTP(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -213,7 +213,7 @@ func TestFailParseFromYamlHTTP(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookeradddashboardelement/lookeradddashboardelement_test.go b/internal/tools/looker/lookeradddashboardelement/lookeradddashboardelement_test.go index c73c9d3f92d8..0312525f827e 100644 --- a/internal/tools/looker/lookeradddashboardelement/lookeradddashboardelement_test.go +++ b/internal/tools/looker/lookeradddashboardelement/lookeradddashboardelement_test.go @@ -60,7 +60,7 @@ func TestParseFromYamlLookerAddDashboardElement(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -98,7 +98,7 @@ func TestFailParseFromYamlLookerAddDashboardElement(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookeradddashboardfilter/lookeradddashboardfilter_test.go b/internal/tools/looker/lookeradddashboardfilter/lookeradddashboardfilter_test.go index e8cb9338f1df..19423e0577a8 100644 --- a/internal/tools/looker/lookeradddashboardfilter/lookeradddashboardfilter_test.go +++ b/internal/tools/looker/lookeradddashboardfilter/lookeradddashboardfilter_test.go @@ -60,7 +60,7 @@ func TestParseFromYamlLookerAddDashboardFilter(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -98,7 +98,7 @@ func TestFailParseFromYamlLookerAddDashboardFilter(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookerconversationalanalytics/lookerconversationalanalytics_test.go b/internal/tools/looker/lookerconversationalanalytics/lookerconversationalanalytics_test.go index e4077dc48dd0..8fda505318d3 100644 --- a/internal/tools/looker/lookerconversationalanalytics/lookerconversationalanalytics_test.go +++ b/internal/tools/looker/lookerconversationalanalytics/lookerconversationalanalytics_test.go @@ -58,7 +58,7 @@ func TestParseFromYamlLookerConversationalAnalytics(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/looker/lookercreateagent/lookercreateagent_test.go b/internal/tools/looker/lookercreateagent/lookercreateagent_test.go index 26d1016ac9b4..7008c029d3c3 100644 --- a/internal/tools/looker/lookercreateagent/lookercreateagent_test.go +++ b/internal/tools/looker/lookercreateagent/lookercreateagent_test.go @@ -64,7 +64,7 @@ func TestParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -100,7 +100,7 @@ func TestFailParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookercreategitbranch/lookercreategitbranch_test.go b/internal/tools/looker/lookercreategitbranch/lookercreategitbranch_test.go index cfa55bcb65fa..83161744a7bc 100644 --- a/internal/tools/looker/lookercreategitbranch/lookercreategitbranch_test.go +++ b/internal/tools/looker/lookercreategitbranch/lookercreategitbranch_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlLookerCreateGitBranch(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -95,7 +95,7 @@ func TestFailParseFromYamlLookerCreateGitBranch(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookercreateprojectdirectory/lookercreateprojectdirectory_test.go b/internal/tools/looker/lookercreateprojectdirectory/lookercreateprojectdirectory_test.go index c33df8f7007e..6b09121d43a7 100644 --- a/internal/tools/looker/lookercreateprojectdirectory/lookercreateprojectdirectory_test.go +++ b/internal/tools/looker/lookercreateprojectdirectory/lookercreateprojectdirectory_test.go @@ -60,7 +60,7 @@ func TestParseFromYamlLookerCreateProjectDirectory(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -97,7 +97,7 @@ func TestFailParseFromYamlLookerCreateProjectDirectory(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookercreateprojectfile/lookercreateprojectfile_test.go b/internal/tools/looker/lookercreateprojectfile/lookercreateprojectfile_test.go index 94633653be56..baf7d23e1456 100644 --- a/internal/tools/looker/lookercreateprojectfile/lookercreateprojectfile_test.go +++ b/internal/tools/looker/lookercreateprojectfile/lookercreateprojectfile_test.go @@ -60,7 +60,7 @@ func TestParseFromYamlLookerCreateProjectFile(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -98,7 +98,7 @@ func TestFailParseFromYamlLookerCreateProjectFile(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookercreateviewfromtable/lookercreateviewfromtable_test.go b/internal/tools/looker/lookercreateviewfromtable/lookercreateviewfromtable_test.go index 60ee14bf9c49..39cc056a75f5 100644 --- a/internal/tools/looker/lookercreateviewfromtable/lookercreateviewfromtable_test.go +++ b/internal/tools/looker/lookercreateviewfromtable/lookercreateviewfromtable_test.go @@ -60,7 +60,7 @@ func TestParseFromYamlLookerCreateViewFromTable(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -98,7 +98,7 @@ func TestFailParseFromYamlLookerCreateViewFromTable(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookerdeleteagent/lookerdeleteagent_test.go b/internal/tools/looker/lookerdeleteagent/lookerdeleteagent_test.go index ac9131cd8a35..ae1af6b6698b 100644 --- a/internal/tools/looker/lookerdeleteagent/lookerdeleteagent_test.go +++ b/internal/tools/looker/lookerdeleteagent/lookerdeleteagent_test.go @@ -64,7 +64,7 @@ func TestParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -100,7 +100,7 @@ func TestFailParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookerdeletegitbranch/lookerdeletegitbranch_test.go b/internal/tools/looker/lookerdeletegitbranch/lookerdeletegitbranch_test.go index 134aaffc2f67..f36c497e361f 100644 --- a/internal/tools/looker/lookerdeletegitbranch/lookerdeletegitbranch_test.go +++ b/internal/tools/looker/lookerdeletegitbranch/lookerdeletegitbranch_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlLookerDeleteGitBranch(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -95,7 +95,7 @@ func TestFailParseFromYamlLookerDeleteGitBranch(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookerdeleteprojectdirectory/lookerdeleteprojectdirectory_test.go b/internal/tools/looker/lookerdeleteprojectdirectory/lookerdeleteprojectdirectory_test.go index 709e0462b745..e69ad79723bd 100644 --- a/internal/tools/looker/lookerdeleteprojectdirectory/lookerdeleteprojectdirectory_test.go +++ b/internal/tools/looker/lookerdeleteprojectdirectory/lookerdeleteprojectdirectory_test.go @@ -60,7 +60,7 @@ func TestParseFromYamlLookerDeleteProjectDirectory(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -97,7 +97,7 @@ func TestFailParseFromYamlLookerDeleteProjectDirectory(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookerdeleteprojectfile/lookerdeleteprojectfile_test.go b/internal/tools/looker/lookerdeleteprojectfile/lookerdeleteprojectfile_test.go index a4ff51019023..b8702ca4db3e 100644 --- a/internal/tools/looker/lookerdeleteprojectfile/lookerdeleteprojectfile_test.go +++ b/internal/tools/looker/lookerdeleteprojectfile/lookerdeleteprojectfile_test.go @@ -60,7 +60,7 @@ func TestParseFromYamlLookerDeleteProjectFile(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -98,7 +98,7 @@ func TestFailParseFromYamlLookerDeleteProjectFile(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookerdevmode/lookerdevmode_test.go b/internal/tools/looker/lookerdevmode/lookerdevmode_test.go index 3590937cc33c..f7c86b615ff0 100644 --- a/internal/tools/looker/lookerdevmode/lookerdevmode_test.go +++ b/internal/tools/looker/lookerdevmode/lookerdevmode_test.go @@ -60,7 +60,7 @@ func TestParseFromYamlLookerDevMode(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -98,7 +98,7 @@ func TestFailParseFromYamlLookerDevMode(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookergenerateembedurl/lookergenerateembedurl_test.go b/internal/tools/looker/lookergenerateembedurl/lookergenerateembedurl_test.go index 8ecad1f7d557..7cf3359e51c6 100644 --- a/internal/tools/looker/lookergenerateembedurl/lookergenerateembedurl_test.go +++ b/internal/tools/looker/lookergenerateembedurl/lookergenerateembedurl_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlLookerGenerateEmbedUrl(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -95,7 +95,7 @@ func TestFailParseFromYamlLookerGenerateEmbedUrl(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookergetagent/lookergetagent_test.go b/internal/tools/looker/lookergetagent/lookergetagent_test.go index 615d4599f6e7..f4afc6b66913 100644 --- a/internal/tools/looker/lookergetagent/lookergetagent_test.go +++ b/internal/tools/looker/lookergetagent/lookergetagent_test.go @@ -64,7 +64,7 @@ func TestParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -100,7 +100,7 @@ func TestFailParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookergetconnectiondatabases/lookergetconnectiondatabases_test.go b/internal/tools/looker/lookergetconnectiondatabases/lookergetconnectiondatabases_test.go index ad08ff418167..4257d46da390 100644 --- a/internal/tools/looker/lookergetconnectiondatabases/lookergetconnectiondatabases_test.go +++ b/internal/tools/looker/lookergetconnectiondatabases/lookergetconnectiondatabases_test.go @@ -60,7 +60,7 @@ func TestParseFromYamlLookerGetConnectionDatabases(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -98,7 +98,7 @@ func TestFailParseFromYamlLookerGetConnectionDatabases(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookergetconnections/lookergetconnections_test.go b/internal/tools/looker/lookergetconnections/lookergetconnections_test.go index 393632afecf5..15e34797f36a 100644 --- a/internal/tools/looker/lookergetconnections/lookergetconnections_test.go +++ b/internal/tools/looker/lookergetconnections/lookergetconnections_test.go @@ -60,7 +60,7 @@ func TestParseFromYamlLookerGetConnections(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -98,7 +98,7 @@ func TestFailParseFromYamlLookerGetConnections(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookergetconnectionschemas/lookergetconnectionschemas_test.go b/internal/tools/looker/lookergetconnectionschemas/lookergetconnectionschemas_test.go index b55864a87fe6..8dd663d12c09 100644 --- a/internal/tools/looker/lookergetconnectionschemas/lookergetconnectionschemas_test.go +++ b/internal/tools/looker/lookergetconnectionschemas/lookergetconnectionschemas_test.go @@ -60,7 +60,7 @@ func TestParseFromYamlLookerGetConnectionSchemas(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -98,7 +98,7 @@ func TestFailParseFromYamlLookerGetConnectionSchemas(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookergetconnectiontablecolumns/lookergetconnectiontablecolumns_test.go b/internal/tools/looker/lookergetconnectiontablecolumns/lookergetconnectiontablecolumns_test.go index d59ead002378..b8ef5caa1d8e 100644 --- a/internal/tools/looker/lookergetconnectiontablecolumns/lookergetconnectiontablecolumns_test.go +++ b/internal/tools/looker/lookergetconnectiontablecolumns/lookergetconnectiontablecolumns_test.go @@ -60,7 +60,7 @@ func TestParseFromYamlLookerGetConnectionTableColumns(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -98,7 +98,7 @@ func TestFailParseFromYamlLookerGetConnectionTableColumns(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookergetconnectiontables/lookergetconnectiontables_test.go b/internal/tools/looker/lookergetconnectiontables/lookergetconnectiontables_test.go index 7a70bfa95a45..0b5ed24fc5fc 100644 --- a/internal/tools/looker/lookergetconnectiontables/lookergetconnectiontables_test.go +++ b/internal/tools/looker/lookergetconnectiontables/lookergetconnectiontables_test.go @@ -60,7 +60,7 @@ func TestParseFromYamlLookerGetConnectionTables(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -98,7 +98,7 @@ func TestFailParseFromYamlLookerGetConnectionTables(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookergetdashboards/lookergetdashboards_test.go b/internal/tools/looker/lookergetdashboards/lookergetdashboards_test.go index 2f05f857e9f1..b79ffa81d9cd 100644 --- a/internal/tools/looker/lookergetdashboards/lookergetdashboards_test.go +++ b/internal/tools/looker/lookergetdashboards/lookergetdashboards_test.go @@ -60,7 +60,7 @@ func TestParseFromYamlLookerGetDashboards(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -98,7 +98,7 @@ func TestFailParseFromYamlLookerGetDashboards(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookergetdimensions/lookergetdimensions_test.go b/internal/tools/looker/lookergetdimensions/lookergetdimensions_test.go index 2c78d110808d..86efe8d17bdc 100644 --- a/internal/tools/looker/lookergetdimensions/lookergetdimensions_test.go +++ b/internal/tools/looker/lookergetdimensions/lookergetdimensions_test.go @@ -60,7 +60,7 @@ func TestParseFromYamlLookerGetDimensions(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -98,7 +98,7 @@ func TestFailParseFromYamlLookerGetDimensions(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookergetexplores/lookergetexplores_test.go b/internal/tools/looker/lookergetexplores/lookergetexplores_test.go index 1f479fee8b6d..04c3ca80213a 100644 --- a/internal/tools/looker/lookergetexplores/lookergetexplores_test.go +++ b/internal/tools/looker/lookergetexplores/lookergetexplores_test.go @@ -60,7 +60,7 @@ func TestParseFromYamlLookerGetExplores(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -98,7 +98,7 @@ func TestFailParseFromYamlLookerGetFilters(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookergetfilters/lookergetfilters_test.go b/internal/tools/looker/lookergetfilters/lookergetfilters_test.go index 68f36416395c..a26c989a4dec 100644 --- a/internal/tools/looker/lookergetfilters/lookergetfilters_test.go +++ b/internal/tools/looker/lookergetfilters/lookergetfilters_test.go @@ -60,7 +60,7 @@ func TestParseFromYamlLookerGetFilters(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -98,7 +98,7 @@ func TestFailParseFromYamlLookerGetFilters(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookergetgitbranch/lookergetgitbranch_test.go b/internal/tools/looker/lookergetgitbranch/lookergetgitbranch_test.go index d5bb6c7af564..9ef1f42404ad 100644 --- a/internal/tools/looker/lookergetgitbranch/lookergetgitbranch_test.go +++ b/internal/tools/looker/lookergetgitbranch/lookergetgitbranch_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlLookerGetGitBranch(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -95,7 +95,7 @@ func TestFailParseFromYamlLookerGetGitBranch(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookergetlookmltests/lookergetlookmltests_test.go b/internal/tools/looker/lookergetlookmltests/lookergetlookmltests_test.go index 8c371dc88a9e..f898b361dad3 100644 --- a/internal/tools/looker/lookergetlookmltests/lookergetlookmltests_test.go +++ b/internal/tools/looker/lookergetlookmltests/lookergetlookmltests_test.go @@ -60,7 +60,7 @@ func TestParseFromYamlLookerGetLookmlTests(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -98,7 +98,7 @@ func TestFailParseFromYamlLookerGetAllLookmlTests(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookergetlooks/lookergetlooks_test.go b/internal/tools/looker/lookergetlooks/lookergetlooks_test.go index 22466e3e2aab..26a22a219884 100644 --- a/internal/tools/looker/lookergetlooks/lookergetlooks_test.go +++ b/internal/tools/looker/lookergetlooks/lookergetlooks_test.go @@ -60,7 +60,7 @@ func TestParseFromYamlLookerGetLooks(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -98,7 +98,7 @@ func TestFailParseFromYamlLookerGetLooks(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookergetmeasures/lookergetmeasures_test.go b/internal/tools/looker/lookergetmeasures/lookergetmeasures_test.go index b0563d50a70e..c8afafa91e0d 100644 --- a/internal/tools/looker/lookergetmeasures/lookergetmeasures_test.go +++ b/internal/tools/looker/lookergetmeasures/lookergetmeasures_test.go @@ -60,7 +60,7 @@ func TestParseFromYamlLookerGetMeasures(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -98,7 +98,7 @@ func TestFailParseFromYamlLookerGetMeasures(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookergetmodels/lookergetmodels_test.go b/internal/tools/looker/lookergetmodels/lookergetmodels_test.go index 29b496a88ed8..a1bb0d7af027 100644 --- a/internal/tools/looker/lookergetmodels/lookergetmodels_test.go +++ b/internal/tools/looker/lookergetmodels/lookergetmodels_test.go @@ -60,7 +60,7 @@ func TestParseFromYamlLookerGetModels(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -98,7 +98,7 @@ func TestFailParseFromYamlLookerGetModels(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookergetparameters/lookergetparameters_test.go b/internal/tools/looker/lookergetparameters/lookergetparameters_test.go index 224ad324b41f..7dd27868c6a4 100644 --- a/internal/tools/looker/lookergetparameters/lookergetparameters_test.go +++ b/internal/tools/looker/lookergetparameters/lookergetparameters_test.go @@ -60,7 +60,7 @@ func TestParseFromYamlLookerGetParameters(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -98,7 +98,7 @@ func TestFailParseFromYamlLookerGetParameters(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookergetprojectdirectories/lookergetprojectdirectories_test.go b/internal/tools/looker/lookergetprojectdirectories/lookergetprojectdirectories_test.go index a901bc39c447..49ca260ce83a 100644 --- a/internal/tools/looker/lookergetprojectdirectories/lookergetprojectdirectories_test.go +++ b/internal/tools/looker/lookergetprojectdirectories/lookergetprojectdirectories_test.go @@ -60,7 +60,7 @@ func TestParseFromYamlLookerGetProjectDirectories(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -97,7 +97,7 @@ func TestFailParseFromYamlLookerGetProjectDirectories(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookergetprojectfile/lookergetprojectfile_test.go b/internal/tools/looker/lookergetprojectfile/lookergetprojectfile_test.go index 041f02897c8a..1d2512fd05a1 100644 --- a/internal/tools/looker/lookergetprojectfile/lookergetprojectfile_test.go +++ b/internal/tools/looker/lookergetprojectfile/lookergetprojectfile_test.go @@ -60,7 +60,7 @@ func TestParseFromYamlLookerGetProjectFile(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -97,7 +97,7 @@ func TestFailParseFromYamlLookerGetProjectFile(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookergetprojectfiles/lookergetprojectfiles_test.go b/internal/tools/looker/lookergetprojectfiles/lookergetprojectfiles_test.go index 16a9fca3c932..8c32f819bff2 100644 --- a/internal/tools/looker/lookergetprojectfiles/lookergetprojectfiles_test.go +++ b/internal/tools/looker/lookergetprojectfiles/lookergetprojectfiles_test.go @@ -60,7 +60,7 @@ func TestParseFromYamlLookerGetProjectFiles(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -98,7 +98,7 @@ func TestFailParseFromYamlLookerGetProjectFiles(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookergetprojects/lookergetprojects_test.go b/internal/tools/looker/lookergetprojects/lookergetprojects_test.go index 277cf6f266a3..9c824fb21c02 100644 --- a/internal/tools/looker/lookergetprojects/lookergetprojects_test.go +++ b/internal/tools/looker/lookergetprojects/lookergetprojects_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlLookerGetProjects(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -96,7 +96,7 @@ func TestFailParseFromYamlLookerGetProjecProjects(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookerhealthanalyze/lookerhealthanalyze_test.go b/internal/tools/looker/lookerhealthanalyze/lookerhealthanalyze_test.go index ba6664366c95..505afd2efffc 100644 --- a/internal/tools/looker/lookerhealthanalyze/lookerhealthanalyze_test.go +++ b/internal/tools/looker/lookerhealthanalyze/lookerhealthanalyze_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlLookerHealthAnalyze(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -94,7 +94,7 @@ func TestFailParseFromYamlLookerHealthAnalyze(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookerhealthpulse/lookerhealthpulse_test.go b/internal/tools/looker/lookerhealthpulse/lookerhealthpulse_test.go index 071cdcc7c1dc..8b4133376798 100644 --- a/internal/tools/looker/lookerhealthpulse/lookerhealthpulse_test.go +++ b/internal/tools/looker/lookerhealthpulse/lookerhealthpulse_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlLookerHealthPulse(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -94,7 +94,7 @@ func TestFailParseFromYamlLookerHealthPulse(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookerhealthvacuum/lookerhealthvacuum_test.go b/internal/tools/looker/lookerhealthvacuum/lookerhealthvacuum_test.go index d4c83721a705..52295b9a1efe 100644 --- a/internal/tools/looker/lookerhealthvacuum/lookerhealthvacuum_test.go +++ b/internal/tools/looker/lookerhealthvacuum/lookerhealthvacuum_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlLookerHealthVacuum(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -94,7 +94,7 @@ func TestFailParseFromYamlLookerHealthVacuum(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookerlistagents/lookerlistagents_test.go b/internal/tools/looker/lookerlistagents/lookerlistagents_test.go index 8729698e7b5d..f52961a8254a 100644 --- a/internal/tools/looker/lookerlistagents/lookerlistagents_test.go +++ b/internal/tools/looker/lookerlistagents/lookerlistagents_test.go @@ -63,7 +63,7 @@ func TestParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -99,7 +99,7 @@ func TestFailParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookerlistgitbranches/lookerlistgitbranches_test.go b/internal/tools/looker/lookerlistgitbranches/lookerlistgitbranches_test.go index 3618d54d86f7..fdb721c1bed7 100644 --- a/internal/tools/looker/lookerlistgitbranches/lookerlistgitbranches_test.go +++ b/internal/tools/looker/lookerlistgitbranches/lookerlistgitbranches_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlLookerListGitBranches(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -95,7 +95,7 @@ func TestFailParseFromYamlLookerListGitBranches(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookermakedashboard/lookermakedashboard_test.go b/internal/tools/looker/lookermakedashboard/lookermakedashboard_test.go index 5892b2075ec5..c211ab103e02 100644 --- a/internal/tools/looker/lookermakedashboard/lookermakedashboard_test.go +++ b/internal/tools/looker/lookermakedashboard/lookermakedashboard_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlLookerMakeDashboard(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -96,7 +96,7 @@ func TestFailParseFromYamlMakeDashboard(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookermakelook/lookermakelook_test.go b/internal/tools/looker/lookermakelook/lookermakelook_test.go index c67dc69898f9..a9c96735c04e 100644 --- a/internal/tools/looker/lookermakelook/lookermakelook_test.go +++ b/internal/tools/looker/lookermakelook/lookermakelook_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlLookerMakeLook(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -96,7 +96,7 @@ func TestFailParseFromYamlLookerMakeLook(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookerquery/lookerquery_test.go b/internal/tools/looker/lookerquery/lookerquery_test.go index f4abc9797968..05bcae9ead3a 100644 --- a/internal/tools/looker/lookerquery/lookerquery_test.go +++ b/internal/tools/looker/lookerquery/lookerquery_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlLookerQuery(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -96,7 +96,7 @@ func TestFailParseFromYamlLookerQuery(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookerquerysql/lookerquerysql_test.go b/internal/tools/looker/lookerquerysql/lookerquerysql_test.go index f5462d8642d3..c8769b784b70 100644 --- a/internal/tools/looker/lookerquerysql/lookerquerysql_test.go +++ b/internal/tools/looker/lookerquerysql/lookerquerysql_test.go @@ -60,7 +60,7 @@ func TestParseFromYamlLookerQuerySql(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -98,7 +98,7 @@ func TestFailParseFromYamlLookerQuerySql(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookerqueryurl/lookerqueryurl_test.go b/internal/tools/looker/lookerqueryurl/lookerqueryurl_test.go index 0101bbaa6e59..184665fd02a2 100644 --- a/internal/tools/looker/lookerqueryurl/lookerqueryurl_test.go +++ b/internal/tools/looker/lookerqueryurl/lookerqueryurl_test.go @@ -60,7 +60,7 @@ func TestParseFromYamlLookerQueryUrl(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -98,7 +98,7 @@ func TestFailParseFromYamlLookerQueryUrl(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookerrundashboard/lookerrundashboard_test.go b/internal/tools/looker/lookerrundashboard/lookerrundashboard_test.go index db104807bb5b..149f1d4d3f90 100644 --- a/internal/tools/looker/lookerrundashboard/lookerrundashboard_test.go +++ b/internal/tools/looker/lookerrundashboard/lookerrundashboard_test.go @@ -60,7 +60,7 @@ func TestParseFromYamlLookerRunDashboard(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -98,7 +98,7 @@ func TestFailParseFromYamlLookerRunDashboard(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookerrunlook/lookerrunlook_test.go b/internal/tools/looker/lookerrunlook/lookerrunlook_test.go index 747e78ab64e8..cccb10ee4ec9 100644 --- a/internal/tools/looker/lookerrunlook/lookerrunlook_test.go +++ b/internal/tools/looker/lookerrunlook/lookerrunlook_test.go @@ -60,7 +60,7 @@ func TestParseFromYamlLookerRunLook(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -98,7 +98,7 @@ func TestFailParseFromYamlLookerRunLook(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookerrunlookmltests/lookerrunlookmltests_test.go b/internal/tools/looker/lookerrunlookmltests/lookerrunlookmltests_test.go index 7a77485ee06c..f8e00d89e240 100644 --- a/internal/tools/looker/lookerrunlookmltests/lookerrunlookmltests_test.go +++ b/internal/tools/looker/lookerrunlookmltests/lookerrunlookmltests_test.go @@ -60,7 +60,7 @@ func TestParseFromYamlLookerRunLookmlTests(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -98,7 +98,7 @@ func TestFailParseFromYamlLookerRunLookmlTests(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookerswitchgitbranch/lookerswitchgitbranch_test.go b/internal/tools/looker/lookerswitchgitbranch/lookerswitchgitbranch_test.go index d7e0157e25f0..5efc8a7e839d 100644 --- a/internal/tools/looker/lookerswitchgitbranch/lookerswitchgitbranch_test.go +++ b/internal/tools/looker/lookerswitchgitbranch/lookerswitchgitbranch_test.go @@ -59,7 +59,7 @@ func TestParseFromYamlLookerSwitchGitBranch(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -95,7 +95,7 @@ func TestFailParseFromYamlLookerSwitchGitBranch(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookerupdateagent/lookerupdateagent_test.go b/internal/tools/looker/lookerupdateagent/lookerupdateagent_test.go index 341a7c01926c..4c22878a95a1 100644 --- a/internal/tools/looker/lookerupdateagent/lookerupdateagent_test.go +++ b/internal/tools/looker/lookerupdateagent/lookerupdateagent_test.go @@ -64,7 +64,7 @@ func TestParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -100,7 +100,7 @@ func TestFailParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookerupdateprojectfile/lookerupdateprojectfile_test.go b/internal/tools/looker/lookerupdateprojectfile/lookerupdateprojectfile_test.go index ba25b4273919..0d09c92deb61 100644 --- a/internal/tools/looker/lookerupdateprojectfile/lookerupdateprojectfile_test.go +++ b/internal/tools/looker/lookerupdateprojectfile/lookerupdateprojectfile_test.go @@ -60,7 +60,7 @@ func TestParseFromYamlLookerUpdateProjectFile(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -98,7 +98,7 @@ func TestFailParseFromYamlLookerUpdateProjectFile(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/looker/lookervalidateproject/lookervalidateproject_test.go b/internal/tools/looker/lookervalidateproject/lookervalidateproject_test.go index da48d6b576b4..10ae3e00deea 100644 --- a/internal/tools/looker/lookervalidateproject/lookervalidateproject_test.go +++ b/internal/tools/looker/lookervalidateproject/lookervalidateproject_test.go @@ -60,7 +60,7 @@ func TestParseFromYamlLookerValidateProject(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -98,7 +98,7 @@ func TestFailParseFromYamlLookerValidateProject(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/mindsdb/mindsdbexecutesql/mindsdbexecutesql_test.go b/internal/tools/mindsdb/mindsdbexecutesql/mindsdbexecutesql_test.go index cbf9e4a917a4..152fc2a65cd9 100644 --- a/internal/tools/mindsdb/mindsdbexecutesql/mindsdbexecutesql_test.go +++ b/internal/tools/mindsdb/mindsdbexecutesql/mindsdbexecutesql_test.go @@ -62,7 +62,7 @@ func TestParseFromYamlExecuteSql(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/mindsdb/mindsdbsql/mindsdbsql_test.go b/internal/tools/mindsdb/mindsdbsql/mindsdbsql_test.go index 6cc358b2588f..c528f7842a78 100644 --- a/internal/tools/mindsdb/mindsdbsql/mindsdbsql_test.go +++ b/internal/tools/mindsdb/mindsdbsql/mindsdbsql_test.go @@ -80,7 +80,7 @@ func TestParseFromYamlmindsdbsql(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -161,7 +161,7 @@ func TestParseFromYamlWithTemplateParamsmindsdbsql(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/mongodb/mongodbaggregate/mongodbaggregate_test.go b/internal/tools/mongodb/mongodbaggregate/mongodbaggregate_test.go index 2c2aac023aa3..92248e71a8c2 100644 --- a/internal/tools/mongodb/mongodbaggregate/mongodbaggregate_test.go +++ b/internal/tools/mongodb/mongodbaggregate/mongodbaggregate_test.go @@ -84,7 +84,7 @@ func TestParseFromYamlMongoQuery(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -146,7 +146,7 @@ func TestFailParseFromYamlMongoQuery(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/mongodb/mongodbdeletemany/mongodbdeletemany_test.go b/internal/tools/mongodb/mongodbdeletemany/mongodbdeletemany_test.go index f80a4391bd4b..e3f23c6c499f 100644 --- a/internal/tools/mongodb/mongodbdeletemany/mongodbdeletemany_test.go +++ b/internal/tools/mongodb/mongodbdeletemany/mongodbdeletemany_test.go @@ -81,7 +81,7 @@ func TestParseFromYamlMongoQuery(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -146,7 +146,7 @@ func TestFailParseFromYamlMongoQuery(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/mongodb/mongodbdeleteone/mongodbdeleteone_test.go b/internal/tools/mongodb/mongodbdeleteone/mongodbdeleteone_test.go index 2358fbbec46b..25eb1a4ecc0b 100644 --- a/internal/tools/mongodb/mongodbdeleteone/mongodbdeleteone_test.go +++ b/internal/tools/mongodb/mongodbdeleteone/mongodbdeleteone_test.go @@ -81,7 +81,7 @@ func TestParseFromYamlMongoQuery(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -146,7 +146,7 @@ func TestFailParseFromYamlMongoQuery(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/mongodb/mongodbfind/mongodbfind_test.go b/internal/tools/mongodb/mongodbfind/mongodbfind_test.go index a2bda77bd4e1..ef89a0161ec2 100644 --- a/internal/tools/mongodb/mongodbfind/mongodbfind_test.go +++ b/internal/tools/mongodb/mongodbfind/mongodbfind_test.go @@ -91,7 +91,7 @@ func TestParseFromYamlMongoQuery(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -153,7 +153,7 @@ func TestFailParseFromYamlMongoQuery(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/mongodb/mongodbfindone/mongodbfindone_test.go b/internal/tools/mongodb/mongodbfindone/mongodbfindone_test.go index 82b94dc98653..aa622c5a113b 100644 --- a/internal/tools/mongodb/mongodbfindone/mongodbfindone_test.go +++ b/internal/tools/mongodb/mongodbfindone/mongodbfindone_test.go @@ -86,7 +86,7 @@ func TestParseFromYamlMongoQuery(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -148,7 +148,7 @@ func TestFailParseFromYamlMongoQuery(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/mongodb/mongodbinsertmany/mongodbinsertmany_test.go b/internal/tools/mongodb/mongodbinsertmany/mongodbinsertmany_test.go index e53b4a51e815..67c03fccc217 100644 --- a/internal/tools/mongodb/mongodbinsertmany/mongodbinsertmany_test.go +++ b/internal/tools/mongodb/mongodbinsertmany/mongodbinsertmany_test.go @@ -119,7 +119,7 @@ func TestParseFromYamlMongoQuery(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -182,7 +182,7 @@ func TestFailParseFromYamlMongoQuery(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/mongodb/mongodbinsertone/mongodbinsertone_test.go b/internal/tools/mongodb/mongodbinsertone/mongodbinsertone_test.go index d123e8c68858..11a7f0573bc3 100644 --- a/internal/tools/mongodb/mongodbinsertone/mongodbinsertone_test.go +++ b/internal/tools/mongodb/mongodbinsertone/mongodbinsertone_test.go @@ -119,7 +119,7 @@ func TestParseFromYamlMongoQuery(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -183,7 +183,7 @@ func TestFailParseFromYamlMongoQuery(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/mongodb/mongodbupdatemany/mongodbupdatemany_test.go b/internal/tools/mongodb/mongodbupdatemany/mongodbupdatemany_test.go index d3009c5133ae..6c4f76f2bddf 100644 --- a/internal/tools/mongodb/mongodbupdatemany/mongodbupdatemany_test.go +++ b/internal/tools/mongodb/mongodbupdatemany/mongodbupdatemany_test.go @@ -216,7 +216,7 @@ func TestParseFromYamlMongoQuery(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -292,7 +292,7 @@ func TestFailParseFromYamlMongoQuery(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/mongodb/mongodbupdateone/mongodbupdateone_test.go b/internal/tools/mongodb/mongodbupdateone/mongodbupdateone_test.go index 38953bc152f0..cdac834a5d3c 100644 --- a/internal/tools/mongodb/mongodbupdateone/mongodbupdateone_test.go +++ b/internal/tools/mongodb/mongodbupdateone/mongodbupdateone_test.go @@ -222,7 +222,7 @@ func TestParseFromYamlMongoQuery(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -286,7 +286,7 @@ func TestFailParseFromYamlMongoQuery(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/mssql/mssqlexecutesql/mssqlexecutesql_test.go b/internal/tools/mssql/mssqlexecutesql/mssqlexecutesql_test.go index e7f7c16a543c..5145820736a3 100644 --- a/internal/tools/mssql/mssqlexecutesql/mssqlexecutesql_test.go +++ b/internal/tools/mssql/mssqlexecutesql/mssqlexecutesql_test.go @@ -62,7 +62,7 @@ func TestParseFromYamlExecuteSql(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/mssql/mssqllisttables/mssqllisttables_test.go b/internal/tools/mssql/mssqllisttables/mssqllisttables_test.go index 085da79a1cfe..065e3d8639df 100644 --- a/internal/tools/mssql/mssqllisttables/mssqllisttables_test.go +++ b/internal/tools/mssql/mssqllisttables/mssqllisttables_test.go @@ -62,7 +62,7 @@ func TestParseFromYamlmssqlListTables(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/mssql/mssqlsql/mssqlsql_test.go b/internal/tools/mssql/mssqlsql/mssqlsql_test.go index 1550cdea9530..63528a8fe586 100644 --- a/internal/tools/mssql/mssqlsql/mssqlsql_test.go +++ b/internal/tools/mssql/mssqlsql/mssqlsql_test.go @@ -80,7 +80,7 @@ func TestParseFromYamlMssql(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -161,7 +161,7 @@ func TestParseFromYamlWithTemplateMssql(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/mysql/mysqlexecutesql/mysqlexecutesql_test.go b/internal/tools/mysql/mysqlexecutesql/mysqlexecutesql_test.go index aa4a80701bf5..914e66c8c063 100644 --- a/internal/tools/mysql/mysqlexecutesql/mysqlexecutesql_test.go +++ b/internal/tools/mysql/mysqlexecutesql/mysqlexecutesql_test.go @@ -62,7 +62,7 @@ func TestParseFromYamlExecuteSql(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/mysql/mysqlgetqueryplan/mysqlgetqueryplan_test.go b/internal/tools/mysql/mysqlgetqueryplan/mysqlgetqueryplan_test.go index bfd4417a6ceb..2d207c54ca6b 100644 --- a/internal/tools/mysql/mysqlgetqueryplan/mysqlgetqueryplan_test.go +++ b/internal/tools/mysql/mysqlgetqueryplan/mysqlgetqueryplan_test.go @@ -62,7 +62,7 @@ func TestParseFromYamlGetQueryPlan(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/mysql/mysqllistactivequeries/mysqllistactivequeries_test.go b/internal/tools/mysql/mysqllistactivequeries/mysqllistactivequeries_test.go index 447bbfb154af..67e62217c3e9 100644 --- a/internal/tools/mysql/mysqllistactivequeries/mysqllistactivequeries_test.go +++ b/internal/tools/mysql/mysqllistactivequeries/mysqllistactivequeries_test.go @@ -62,7 +62,7 @@ func TestParseFromYamlExecuteSql(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/mysql/mysqllistalllocks/mysqllistalllocks_test.go b/internal/tools/mysql/mysqllistalllocks/mysqllistalllocks_test.go index 33aff7b4fafc..d34238d513b3 100644 --- a/internal/tools/mysql/mysqllistalllocks/mysqllistalllocks_test.go +++ b/internal/tools/mysql/mysqllistalllocks/mysqllistalllocks_test.go @@ -62,7 +62,7 @@ func TestParseFromYamlMySQLListAllLocks(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/mysql/mysqllisttablefragmentation/mysqllisttablefragmentation_test.go b/internal/tools/mysql/mysqllisttablefragmentation/mysqllisttablefragmentation_test.go index 44c731db5ecc..ce504757da8e 100644 --- a/internal/tools/mysql/mysqllisttablefragmentation/mysqllisttablefragmentation_test.go +++ b/internal/tools/mysql/mysqllisttablefragmentation/mysqllisttablefragmentation_test.go @@ -62,7 +62,7 @@ func TestParseFromYamlExecuteSql(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/mysql/mysqllisttables/mysqllisttables_test.go b/internal/tools/mysql/mysqllisttables/mysqllisttables_test.go index 1bbe0d295f4d..c8e46e12bb2b 100644 --- a/internal/tools/mysql/mysqllisttables/mysqllisttables_test.go +++ b/internal/tools/mysql/mysqllisttables/mysqllisttables_test.go @@ -62,7 +62,7 @@ func TestParseFromYamlMySQLListTables(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/mysql/mysqllisttablesmissinguniqueindexes/mysqllisttablesmissinguniqueindexes_test.go b/internal/tools/mysql/mysqllisttablesmissinguniqueindexes/mysqllisttablesmissinguniqueindexes_test.go index 3f7605ec8c30..2622eb28bfff 100644 --- a/internal/tools/mysql/mysqllisttablesmissinguniqueindexes/mysqllisttablesmissinguniqueindexes_test.go +++ b/internal/tools/mysql/mysqllisttablesmissinguniqueindexes/mysqllisttablesmissinguniqueindexes_test.go @@ -62,7 +62,7 @@ func TestParseFromYamlExecuteSql(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/mysql/mysqllisttablestats/mysqllisttablestats_test.go b/internal/tools/mysql/mysqllisttablestats/mysqllisttablestats_test.go index fa35b197f45f..fb0358ec5239 100644 --- a/internal/tools/mysql/mysqllisttablestats/mysqllisttablestats_test.go +++ b/internal/tools/mysql/mysqllisttablestats/mysqllisttablestats_test.go @@ -62,7 +62,7 @@ func TestParseFromYamlMySQLListTableStats(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/mysql/mysqlshowquerystats/mysqlshowquerystats_test.go b/internal/tools/mysql/mysqlshowquerystats/mysqlshowquerystats_test.go index 1d271cf76a64..37c748510551 100644 --- a/internal/tools/mysql/mysqlshowquerystats/mysqlshowquerystats_test.go +++ b/internal/tools/mysql/mysqlshowquerystats/mysqlshowquerystats_test.go @@ -62,7 +62,7 @@ func TestParseFromYamlMySQLShowQueryStats(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/mysql/mysqlsql/mysqlsql_test.go b/internal/tools/mysql/mysqlsql/mysqlsql_test.go index 3de0394cdf56..24b37e564c53 100644 --- a/internal/tools/mysql/mysqlsql/mysqlsql_test.go +++ b/internal/tools/mysql/mysqlsql/mysqlsql_test.go @@ -80,7 +80,7 @@ func TestParseFromYamlMySQL(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -161,7 +161,7 @@ func TestParseFromYamlWithTemplateParamsMySQL(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/neo4j/neo4jcypher/neo4jcypher_test.go b/internal/tools/neo4j/neo4jcypher/neo4jcypher_test.go index a66fc3b7e818..776ee07db152 100644 --- a/internal/tools/neo4j/neo4jcypher/neo4jcypher_test.go +++ b/internal/tools/neo4j/neo4jcypher/neo4jcypher_test.go @@ -72,7 +72,7 @@ func TestParseFromYamlNeo4j(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/neo4j/neo4jexecutecypher/neo4jexecutecypher_test.go b/internal/tools/neo4j/neo4jexecutecypher/neo4jexecutecypher_test.go index c81f4bb81c1f..7eef4ad40bd5 100644 --- a/internal/tools/neo4j/neo4jexecutecypher/neo4jexecutecypher_test.go +++ b/internal/tools/neo4j/neo4jexecutecypher/neo4jexecutecypher_test.go @@ -87,7 +87,7 @@ func TestParseFromYamlNeo4j(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/neo4j/neo4jschema/neo4jschema_test.go b/internal/tools/neo4j/neo4jschema/neo4jschema_test.go index b8503055a01c..a6d22b13cd97 100644 --- a/internal/tools/neo4j/neo4jschema/neo4jschema_test.go +++ b/internal/tools/neo4j/neo4jschema/neo4jschema_test.go @@ -88,7 +88,7 @@ func TestParseFromYamlNeo4j(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/oceanbase/oceanbaseexecutesql/oceanbaseexecutesql_test.go b/internal/tools/oceanbase/oceanbaseexecutesql/oceanbaseexecutesql_test.go index f2cb57c7f319..d0a79709ad20 100644 --- a/internal/tools/oceanbase/oceanbaseexecutesql/oceanbaseexecutesql_test.go +++ b/internal/tools/oceanbase/oceanbaseexecutesql/oceanbaseexecutesql_test.go @@ -63,7 +63,7 @@ func TestParseFromYamlExecuteSql(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/oceanbase/oceanbasesql/oceanbasesql_test.go b/internal/tools/oceanbase/oceanbasesql/oceanbasesql_test.go index 1ecd4706f2e0..72aec729cd76 100644 --- a/internal/tools/oceanbase/oceanbasesql/oceanbasesql_test.go +++ b/internal/tools/oceanbase/oceanbasesql/oceanbasesql_test.go @@ -70,7 +70,7 @@ func TestParseFromYamlOceanBaseSql(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/oracle/oracleexecutesql/oracleexecutesql_test.go b/internal/tools/oracle/oracleexecutesql/oracleexecutesql_test.go index 3a8de44df0a0..ce50d990f9fe 100644 --- a/internal/tools/oracle/oracleexecutesql/oracleexecutesql_test.go +++ b/internal/tools/oracle/oracleexecutesql/oracleexecutesql_test.go @@ -119,7 +119,7 @@ func TestParseFromYamlOracleExecuteSql(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/oracle/oraclesql/oraclesql_test.go b/internal/tools/oracle/oraclesql/oraclesql_test.go index f4652eb8e849..44225356c9f9 100644 --- a/internal/tools/oracle/oraclesql/oraclesql_test.go +++ b/internal/tools/oracle/oraclesql/oraclesql_test.go @@ -129,7 +129,7 @@ func TestParseFromYamlOracleSql(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/postgres/postgresdatabaseoverview/postgresdatabaseoverview_test.go b/internal/tools/postgres/postgresdatabaseoverview/postgresdatabaseoverview_test.go index 75fa510344f9..d8bede78b2fb 100644 --- a/internal/tools/postgres/postgresdatabaseoverview/postgresdatabaseoverview_test.go +++ b/internal/tools/postgres/postgresdatabaseoverview/postgresdatabaseoverview_test.go @@ -83,7 +83,7 @@ func TestParseFromYamlPostgresDatabaseOverview(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/postgres/postgresexecutesql/postgresexecutesql_test.go b/internal/tools/postgres/postgresexecutesql/postgresexecutesql_test.go index 9f6554bab2b5..406484c428b3 100644 --- a/internal/tools/postgres/postgresexecutesql/postgresexecutesql_test.go +++ b/internal/tools/postgres/postgresexecutesql/postgresexecutesql_test.go @@ -62,7 +62,7 @@ func TestParseFromYamlExecuteSql(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/postgres/postgresgetcolumncardinality/postgresgetcolumncardinality_test.go b/internal/tools/postgres/postgresgetcolumncardinality/postgresgetcolumncardinality_test.go index a1d70c2371ea..21f40e4a683d 100644 --- a/internal/tools/postgres/postgresgetcolumncardinality/postgresgetcolumncardinality_test.go +++ b/internal/tools/postgres/postgresgetcolumncardinality/postgresgetcolumncardinality_test.go @@ -83,7 +83,7 @@ func TestParseFromYamlPostgresGetColumnCardinality(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/postgres/postgreslistactivequeries/postgreslistactivequeries_test.go b/internal/tools/postgres/postgreslistactivequeries/postgreslistactivequeries_test.go index 176190d9ee3c..88244a95133b 100644 --- a/internal/tools/postgres/postgreslistactivequeries/postgreslistactivequeries_test.go +++ b/internal/tools/postgres/postgreslistactivequeries/postgreslistactivequeries_test.go @@ -82,7 +82,7 @@ func TestParseFromYamlPostgresListTables(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/postgres/postgreslistavailableextensions/postgreslistavailableextensions_test.go b/internal/tools/postgres/postgreslistavailableextensions/postgreslistavailableextensions_test.go index 29f49668805d..a77e71ac5ffe 100644 --- a/internal/tools/postgres/postgreslistavailableextensions/postgreslistavailableextensions_test.go +++ b/internal/tools/postgres/postgreslistavailableextensions/postgreslistavailableextensions_test.go @@ -82,7 +82,7 @@ func TestParseFromYamlPostgres(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/postgres/postgreslistdatabasestats/postgreslistdatabasestats_test.go b/internal/tools/postgres/postgreslistdatabasestats/postgreslistdatabasestats_test.go index f8b93f69a082..8424105ddff2 100644 --- a/internal/tools/postgres/postgreslistdatabasestats/postgreslistdatabasestats_test.go +++ b/internal/tools/postgres/postgreslistdatabasestats/postgreslistdatabasestats_test.go @@ -82,7 +82,7 @@ func TestParseFromYamlPostgresListDatabaseStats(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/postgres/postgreslistindexes/postgreslistindexes_test.go b/internal/tools/postgres/postgreslistindexes/postgreslistindexes_test.go index 8fbd98043030..f9af654025ed 100644 --- a/internal/tools/postgres/postgreslistindexes/postgreslistindexes_test.go +++ b/internal/tools/postgres/postgreslistindexes/postgreslistindexes_test.go @@ -83,7 +83,7 @@ func TestParseFromYamlPostgresListIndexes(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/postgres/postgreslistinstalledextensions/postgreslistinstalledextensions_test.go b/internal/tools/postgres/postgreslistinstalledextensions/postgreslistinstalledextensions_test.go index 8c7be5e709b0..c088381b6216 100644 --- a/internal/tools/postgres/postgreslistinstalledextensions/postgreslistinstalledextensions_test.go +++ b/internal/tools/postgres/postgreslistinstalledextensions/postgreslistinstalledextensions_test.go @@ -83,7 +83,7 @@ func TestParseFromYamlPostgres(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/postgres/postgreslistlocks/postgreslistlocks_test.go b/internal/tools/postgres/postgreslistlocks/postgreslistlocks_test.go index 97f16c006b2a..0bd30b859932 100644 --- a/internal/tools/postgres/postgreslistlocks/postgreslistlocks_test.go +++ b/internal/tools/postgres/postgreslistlocks/postgreslistlocks_test.go @@ -83,7 +83,7 @@ func TestParseFromYamlPostgresListLocks(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/postgres/postgreslistpgsettings/postgreslistpgsettings_test.go b/internal/tools/postgres/postgreslistpgsettings/postgreslistpgsettings_test.go index 60b12e2a0e0b..ff12f16af0dd 100644 --- a/internal/tools/postgres/postgreslistpgsettings/postgreslistpgsettings_test.go +++ b/internal/tools/postgres/postgreslistpgsettings/postgreslistpgsettings_test.go @@ -82,7 +82,7 @@ func TestParseFromYamlPostgreslistPgSettings(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/postgres/postgreslistpublicationtables/postgreslistpublicationtables_test.go b/internal/tools/postgres/postgreslistpublicationtables/postgreslistpublicationtables_test.go index 39dc95988288..31894cff0867 100644 --- a/internal/tools/postgres/postgreslistpublicationtables/postgreslistpublicationtables_test.go +++ b/internal/tools/postgres/postgreslistpublicationtables/postgreslistpublicationtables_test.go @@ -82,7 +82,7 @@ func TestParseFromYamlPostgresListPublicationTables(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/postgres/postgreslistquerystats/postgreslistquerystats_test.go b/internal/tools/postgres/postgreslistquerystats/postgreslistquerystats_test.go index d82c90d67b63..262cb6498f02 100644 --- a/internal/tools/postgres/postgreslistquerystats/postgreslistquerystats_test.go +++ b/internal/tools/postgres/postgreslistquerystats/postgreslistquerystats_test.go @@ -82,7 +82,7 @@ func TestParseFromYamlPostgresListQueryStats(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/postgres/postgreslistroles/postgreslistroles_test.go b/internal/tools/postgres/postgreslistroles/postgreslistroles_test.go index c13cdd38363d..e1df13b3f104 100644 --- a/internal/tools/postgres/postgreslistroles/postgreslistroles_test.go +++ b/internal/tools/postgres/postgreslistroles/postgreslistroles_test.go @@ -82,7 +82,7 @@ func TestParseFromYamlPostgresListRoles(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/postgres/postgreslistschemas/postgreslistschemas_test.go b/internal/tools/postgres/postgreslistschemas/postgreslistschemas_test.go index 448a18695804..ac732ede8f81 100644 --- a/internal/tools/postgres/postgreslistschemas/postgreslistschemas_test.go +++ b/internal/tools/postgres/postgreslistschemas/postgreslistschemas_test.go @@ -82,7 +82,7 @@ func TestParseFromYamlPostgreslistSchemas(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/postgres/postgreslistsequences/postgreslistsequences_test.go b/internal/tools/postgres/postgreslistsequences/postgreslistsequences_test.go index c0022100ad3b..f5e498ec2948 100644 --- a/internal/tools/postgres/postgreslistsequences/postgreslistsequences_test.go +++ b/internal/tools/postgres/postgreslistsequences/postgreslistsequences_test.go @@ -82,7 +82,7 @@ func TestParseFromYamlPostgresListSequences(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/postgres/postgresliststoredprocedure/postgresliststoredprocedure_test.go b/internal/tools/postgres/postgresliststoredprocedure/postgresliststoredprocedure_test.go index 09704467dfec..3b0f7f65313b 100644 --- a/internal/tools/postgres/postgresliststoredprocedure/postgresliststoredprocedure_test.go +++ b/internal/tools/postgres/postgresliststoredprocedure/postgresliststoredprocedure_test.go @@ -82,7 +82,7 @@ func TestParseFromYamlPostgresListStoredProcedure(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/postgres/postgreslisttables/postgreslisttables_test.go b/internal/tools/postgres/postgreslisttables/postgreslisttables_test.go index b18475dfb383..0851f3f337c2 100644 --- a/internal/tools/postgres/postgreslisttables/postgreslisttables_test.go +++ b/internal/tools/postgres/postgreslisttables/postgreslisttables_test.go @@ -62,7 +62,7 @@ func TestParseFromYamlPostgresListTables(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/postgres/postgreslisttablespaces/postgreslisttablespaces_test.go b/internal/tools/postgres/postgreslisttablespaces/postgreslisttablespaces_test.go index 25c60cb03d25..bae0ab10f29e 100644 --- a/internal/tools/postgres/postgreslisttablespaces/postgreslisttablespaces_test.go +++ b/internal/tools/postgres/postgreslisttablespaces/postgreslisttablespaces_test.go @@ -83,7 +83,7 @@ func TestParseFromYamlPostgresListTablespaces(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/postgres/postgreslisttablestats/postgreslisttablestats_test.go b/internal/tools/postgres/postgreslisttablestats/postgreslisttablestats_test.go index 998ed5486192..ffb9adafbd43 100644 --- a/internal/tools/postgres/postgreslisttablestats/postgreslisttablestats_test.go +++ b/internal/tools/postgres/postgreslisttablestats/postgreslisttablestats_test.go @@ -82,7 +82,7 @@ func TestParseFromYamlPostgresListTableStats(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/postgres/postgreslisttriggers/postgreslisttriggers_test.go b/internal/tools/postgres/postgreslisttriggers/postgreslisttriggers_test.go index f24c0360f58d..8d67b0cc0a7d 100644 --- a/internal/tools/postgres/postgreslisttriggers/postgreslisttriggers_test.go +++ b/internal/tools/postgres/postgreslisttriggers/postgreslisttriggers_test.go @@ -83,7 +83,7 @@ func TestParseFromYamlPostgreslistTriggers(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/postgres/postgreslistviews/postgreslistviews_test.go b/internal/tools/postgres/postgreslistviews/postgreslistviews_test.go index 18d4936fa9a0..006d6de87442 100644 --- a/internal/tools/postgres/postgreslistviews/postgreslistviews_test.go +++ b/internal/tools/postgres/postgreslistviews/postgreslistviews_test.go @@ -83,7 +83,7 @@ func TestParseFromYamlPostgresListViews(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/postgres/postgreslongrunningtransactions/postgreslongrunningtransactions_test.go b/internal/tools/postgres/postgreslongrunningtransactions/postgreslongrunningtransactions_test.go index b3b8e9442e62..b505bb36bce2 100644 --- a/internal/tools/postgres/postgreslongrunningtransactions/postgreslongrunningtransactions_test.go +++ b/internal/tools/postgres/postgreslongrunningtransactions/postgreslongrunningtransactions_test.go @@ -82,7 +82,7 @@ func TestParseFromYamlPostgresLongRunningTransactions(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/postgres/postgresreplicationstats/postgresreplicationstats_test.go b/internal/tools/postgres/postgresreplicationstats/postgresreplicationstats_test.go index e6a54654778f..485530f00c35 100644 --- a/internal/tools/postgres/postgresreplicationstats/postgresreplicationstats_test.go +++ b/internal/tools/postgres/postgresreplicationstats/postgresreplicationstats_test.go @@ -83,7 +83,7 @@ func TestParseFromYamlPostgresReplicationStats(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/postgres/postgressql/postgressql_test.go b/internal/tools/postgres/postgressql/postgressql_test.go index fc9375e57cb3..ac0f72258a3f 100644 --- a/internal/tools/postgres/postgressql/postgressql_test.go +++ b/internal/tools/postgres/postgressql/postgressql_test.go @@ -80,7 +80,7 @@ func TestParseFromYamlPostgres(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -152,7 +152,7 @@ func TestParseFromYamlWithTemplateParamsPostgres(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/redis/redis_test.go b/internal/tools/redis/redis_test.go index 53e2076e6030..db24ba4e8dee 100644 --- a/internal/tools/redis/redis_test.go +++ b/internal/tools/redis/redis_test.go @@ -70,7 +70,7 @@ func TestParseFromYamlRedis(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/scylladb/scyllacql/scyllacql_test.go b/internal/tools/scylladb/scyllacql/scyllacql_test.go index 1c18c8983b75..98bf2d172142 100644 --- a/internal/tools/scylladb/scyllacql/scyllacql_test.go +++ b/internal/tools/scylladb/scyllacql/scyllacql_test.go @@ -162,7 +162,7 @@ func TestParseFromYamlScyllaDBCQL(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/serverlessspark/serverlesssparkcancelbatch/serverlesssparkcancelbatch_test.go b/internal/tools/serverlessspark/serverlesssparkcancelbatch/serverlesssparkcancelbatch_test.go index 24c9f6f4b763..aee792de6fb1 100644 --- a/internal/tools/serverlessspark/serverlesssparkcancelbatch/serverlesssparkcancelbatch_test.go +++ b/internal/tools/serverlessspark/serverlesssparkcancelbatch/serverlesssparkcancelbatch_test.go @@ -58,7 +58,7 @@ func TestParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/serverlessspark/serverlesssparkgetbatch/serverlesssparkgetbatch_test.go b/internal/tools/serverlessspark/serverlesssparkgetbatch/serverlesssparkgetbatch_test.go index 6524b36d823a..0ebda0b3bf4e 100644 --- a/internal/tools/serverlessspark/serverlesssparkgetbatch/serverlesssparkgetbatch_test.go +++ b/internal/tools/serverlessspark/serverlesssparkgetbatch/serverlesssparkgetbatch_test.go @@ -58,7 +58,7 @@ func TestParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/serverlessspark/serverlesssparkgetsession/serverlesssparkgetsession_test.go b/internal/tools/serverlessspark/serverlesssparkgetsession/serverlesssparkgetsession_test.go index 93f963f32d89..fc80ce1a8695 100644 --- a/internal/tools/serverlessspark/serverlesssparkgetsession/serverlesssparkgetsession_test.go +++ b/internal/tools/serverlessspark/serverlesssparkgetsession/serverlesssparkgetsession_test.go @@ -58,7 +58,7 @@ func TestParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/serverlessspark/serverlesssparkgetsessiontemplate/serverlesssparkgetsessiontemplate_test.go b/internal/tools/serverlessspark/serverlesssparkgetsessiontemplate/serverlesssparkgetsessiontemplate_test.go index fde2cc005725..6a5217be1096 100644 --- a/internal/tools/serverlessspark/serverlesssparkgetsessiontemplate/serverlesssparkgetsessiontemplate_test.go +++ b/internal/tools/serverlessspark/serverlesssparkgetsessiontemplate/serverlesssparkgetsessiontemplate_test.go @@ -58,7 +58,7 @@ func TestParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/serverlessspark/serverlesssparklistbatches/serverlesssparklistbatches_test.go b/internal/tools/serverlessspark/serverlesssparklistbatches/serverlesssparklistbatches_test.go index 0230e1ddb43b..85af0869e2f9 100644 --- a/internal/tools/serverlessspark/serverlesssparklistbatches/serverlesssparklistbatches_test.go +++ b/internal/tools/serverlessspark/serverlesssparklistbatches/serverlesssparklistbatches_test.go @@ -58,7 +58,7 @@ func TestParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/serverlessspark/serverlesssparklistsessions/serverlesssparklistsessions_test.go b/internal/tools/serverlessspark/serverlesssparklistsessions/serverlesssparklistsessions_test.go index bcd8bd905095..78a40f6c8806 100644 --- a/internal/tools/serverlessspark/serverlesssparklistsessions/serverlesssparklistsessions_test.go +++ b/internal/tools/serverlessspark/serverlesssparklistsessions/serverlesssparklistsessions_test.go @@ -58,7 +58,7 @@ func TestParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/serverlessspark/testutils/testutils.go b/internal/tools/serverlessspark/testutils/testutils.go index 3f5f69a3b921..c4180d61ea5a 100644 --- a/internal/tools/serverlessspark/testutils/testutils.go +++ b/internal/tools/serverlessspark/testutils/testutils.go @@ -127,7 +127,7 @@ func RunParseFromYAMLTests(t *testing.T, resourceType string, newConfig func(c c } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, _, got, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if tc.wantErr != "" { if err == nil { t.Fatal("expected error, got nil") diff --git a/internal/tools/singlestore/singlestoreexecutesql/singlestoreexecutesql_test.go b/internal/tools/singlestore/singlestoreexecutesql/singlestoreexecutesql_test.go index 2dbc6031a932..cd7bf775fcb2 100644 --- a/internal/tools/singlestore/singlestoreexecutesql/singlestoreexecutesql_test.go +++ b/internal/tools/singlestore/singlestoreexecutesql/singlestoreexecutesql_test.go @@ -61,7 +61,7 @@ func TestParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/singlestore/singlestoresql/singlestoresql_test.go b/internal/tools/singlestore/singlestoresql/singlestoresql_test.go index bdbfece2c7e5..be91ac5689dd 100644 --- a/internal/tools/singlestore/singlestoresql/singlestoresql_test.go +++ b/internal/tools/singlestore/singlestoresql/singlestoresql_test.go @@ -135,7 +135,7 @@ func TestParseFromYaml(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/snowflake/snowflakeexecutesql/snowflakeexecutesql_test.go b/internal/tools/snowflake/snowflakeexecutesql/snowflakeexecutesql_test.go index c4d523db12c8..fda39760eeca 100644 --- a/internal/tools/snowflake/snowflakeexecutesql/snowflakeexecutesql_test.go +++ b/internal/tools/snowflake/snowflakeexecutesql/snowflakeexecutesql_test.go @@ -60,7 +60,7 @@ func TestParseFromYaml(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/snowflake/snowflakesql/snowflakesql_test.go b/internal/tools/snowflake/snowflakesql/snowflakesql_test.go index beb53943029b..ce5c38463fb8 100644 --- a/internal/tools/snowflake/snowflakesql/snowflakesql_test.go +++ b/internal/tools/snowflake/snowflakesql/snowflakesql_test.go @@ -63,7 +63,7 @@ func TestParseFromYaml(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -99,7 +99,7 @@ func TestFailParseFromYaml(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expect parsing to fail") } diff --git a/internal/tools/spanner/spannerexecutesql/spannerexecutesql_test.go b/internal/tools/spanner/spannerexecutesql/spannerexecutesql_test.go index e1bd10a7d37d..886f88f66da1 100644 --- a/internal/tools/spanner/spannerexecutesql/spannerexecutesql_test.go +++ b/internal/tools/spanner/spannerexecutesql/spannerexecutesql_test.go @@ -83,7 +83,7 @@ func TestParseFromYamlExecuteSql(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/spanner/spannerlistgraphs/spannerlistgraphs_test.go b/internal/tools/spanner/spannerlistgraphs/spannerlistgraphs_test.go index 7fb239a5dff8..35b9be392fdf 100644 --- a/internal/tools/spanner/spannerlistgraphs/spannerlistgraphs_test.go +++ b/internal/tools/spanner/spannerlistgraphs/spannerlistgraphs_test.go @@ -103,7 +103,7 @@ func TestParseFromYamlListGraphs(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/spanner/spannerlisttables/spannerlisttables_test.go b/internal/tools/spanner/spannerlisttables/spannerlisttables_test.go index c191f932c196..4f706f9c7360 100644 --- a/internal/tools/spanner/spannerlisttables/spannerlisttables_test.go +++ b/internal/tools/spanner/spannerlisttables/spannerlisttables_test.go @@ -103,7 +103,7 @@ func TestParseFromYamlListTables(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/spanner/spannersearchcatalog/spannersearchcatalog_test.go b/internal/tools/spanner/spannersearchcatalog/spannersearchcatalog_test.go index 69b1ad611569..03296386d2a5 100644 --- a/internal/tools/spanner/spannersearchcatalog/spannersearchcatalog_test.go +++ b/internal/tools/spanner/spannersearchcatalog/spannersearchcatalog_test.go @@ -64,7 +64,7 @@ func TestParseFromYamlSpannerSearch(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/spanner/spannersql/spanner_test.go b/internal/tools/spanner/spannersql/spanner_test.go index 2036642bba00..42c484c55fb1 100644 --- a/internal/tools/spanner/spannersql/spanner_test.go +++ b/internal/tools/spanner/spannersql/spanner_test.go @@ -103,7 +103,7 @@ func TestParseFromYamlSpanner(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -208,7 +208,7 @@ func TestParseFromYamlWithTemplateParamsSpanner(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/sqlite/sqliteexecutesql/sqliteexecutesql_test.go b/internal/tools/sqlite/sqliteexecutesql/sqliteexecutesql_test.go index 2c5adfa43b33..dd9fb358097c 100644 --- a/internal/tools/sqlite/sqliteexecutesql/sqliteexecutesql_test.go +++ b/internal/tools/sqlite/sqliteexecutesql/sqliteexecutesql_test.go @@ -63,7 +63,7 @@ func TestParseFromYamlExecuteSql(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/sqlite/sqlitesql/sqlitesql_test.go b/internal/tools/sqlite/sqlitesql/sqlitesql_test.go index e471c65a7ceb..b21ce079779e 100644 --- a/internal/tools/sqlite/sqlitesql/sqlitesql_test.go +++ b/internal/tools/sqlite/sqlitesql/sqlitesql_test.go @@ -81,7 +81,7 @@ func TestParseFromYamlSQLite(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -163,7 +163,7 @@ func TestParseFromYamlWithTemplateSqlite(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/tidb/tidbexecutesql/tidbexecutesql_test.go b/internal/tools/tidb/tidbexecutesql/tidbexecutesql_test.go index 1a3bd57e9f80..2097dcb1ddbb 100644 --- a/internal/tools/tidb/tidbexecutesql/tidbexecutesql_test.go +++ b/internal/tools/tidb/tidbexecutesql/tidbexecutesql_test.go @@ -62,7 +62,7 @@ func TestParseFromYamlExecuteSql(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/tidb/tidbsql/tidbsql_test.go b/internal/tools/tidb/tidbsql/tidbsql_test.go index 549382561555..18ee2dea1429 100644 --- a/internal/tools/tidb/tidbsql/tidbsql_test.go +++ b/internal/tools/tidb/tidbsql/tidbsql_test.go @@ -80,7 +80,7 @@ func TestParseFromYamlTiDB(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -161,7 +161,7 @@ func TestParseFromYamlWithTemplateParamsTiDB(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { // Parse contents - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/tools.go b/internal/tools/tools.go index 3028a13be1ad..b4c257810211 100644 --- a/internal/tools/tools.go +++ b/internal/tools/tools.go @@ -137,6 +137,7 @@ type Tool interface { GetAuthTokenHeaderName(SourceProvider) (string, error) GetParameters(map[string]sources.Source) (parameters.Parameters, error) GetScopesRequired() []string + GetPiiPolicy() string } // SourceProvider defines the minimal view of the server.ResourceManager @@ -204,6 +205,7 @@ type ToolMeta interface { GetDescription() string GetAuthRequired() []string GetScopesRequired() []string + GetPiiPolicy() string } // ConfigBase owns the YAML fields that every tool's Config shares and that @@ -216,12 +218,14 @@ type ConfigBase struct { Description string `yaml:"description"` AuthRequired []string `yaml:"authRequired"` ScopesRequired []string `yaml:"scopesRequired"` + PiiPolicy string `yaml:"piiPolicy,omitempty"` } func (c ConfigBase) GetName() string { return c.Name } func (c ConfigBase) GetDescription() string { return c.Description } func (c ConfigBase) GetAuthRequired() []string { return c.AuthRequired } func (c ConfigBase) GetScopesRequired() []string { return c.ScopesRequired } +func (c ConfigBase) GetPiiPolicy() string { return c.PiiPolicy } // BaseTool provides default implementations of various methods on the Tool // interface. Tools embed BaseTool to drop their boilerplate and override @@ -249,6 +253,7 @@ func (b BaseTool[T]) GetName() string { return b.Cfg.GetName() func (b BaseTool[T]) GetDescription() string { return b.Cfg.GetDescription() } func (b BaseTool[T]) GetAuthRequired() []string { return b.Cfg.GetAuthRequired() } func (b BaseTool[T]) GetScopesRequired() []string { return b.Cfg.GetScopesRequired() } +func (b BaseTool[T]) GetPiiPolicy() string { return b.Cfg.GetPiiPolicy() } func (b BaseTool[T]) GetAnnotations() *ToolAnnotations { return b.annotations } // Manifest returns the precomputed metadata. It and GetParameters stay trivial diff --git a/internal/tools/trino/trinoexecutesql/trinoexecutesql_test.go b/internal/tools/trino/trinoexecutesql/trinoexecutesql_test.go index ddcea20cab11..a843c7e35b76 100644 --- a/internal/tools/trino/trinoexecutesql/trinoexecutesql_test.go +++ b/internal/tools/trino/trinoexecutesql/trinoexecutesql_test.go @@ -61,7 +61,7 @@ func TestParseFromYamlTrinoExecuteSQL(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/trino/trinosql/trinosql_test.go b/internal/tools/trino/trinosql/trinosql_test.go index b68bec79b095..45694d8ac0c3 100644 --- a/internal/tools/trino/trinosql/trinosql_test.go +++ b/internal/tools/trino/trinosql/trinosql_test.go @@ -79,7 +79,7 @@ func TestParseFromYamlTrino(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -167,7 +167,7 @@ func TestParseFromYamlWithTemplateParamsTrino(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/utility/wait/wait_test.go b/internal/tools/utility/wait/wait_test.go index 6fe36610420d..3dd2d18e1f26 100644 --- a/internal/tools/utility/wait/wait_test.go +++ b/internal/tools/utility/wait/wait_test.go @@ -61,7 +61,7 @@ func TestParseFromYamlWait(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/internal/tools/valkey/valkey_test.go b/internal/tools/valkey/valkey_test.go index 0095fd502d44..8e38652c8e62 100644 --- a/internal/tools/valkey/valkey_test.go +++ b/internal/tools/valkey/valkey_test.go @@ -70,7 +70,7 @@ func TestParseFromYamlvalkey(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -81,3 +81,215 @@ func TestParseFromYamlvalkey(t *testing.T) { } } + +type mockEmbeddingModel struct { + embedFn func(context.Context, []string) ([][]float32, error) +} + +func (m mockEmbeddingModel) EmbeddingModelType() string { + return "mock" +} + +func (m mockEmbeddingModel) ToConfig() embeddingmodels.EmbeddingModelConfig { + return nil +} + +func (m mockEmbeddingModel) EmbedParameters(ctx context.Context, texts []string) ([][]float32, error) { + return m.embedFn(ctx, texts) +} + +func TestValkeyEmbedParams(t *testing.T) { + ctx := context.Background() + + cfg := valkey.Config{ + ConfigBase: tools.ConfigBase{ + Name: "valkey_tool", + Description: "some description", + }, + Type: "valkey", + Source: "my-source", + Commands: [][]string{{"HSET", "doc:1", "vec", "$query"}}, + Parameters: parameters.Parameters{ + ¶meters.StringParameter{ + CommonParameter: parameters.CommonParameter{ + Name: "query", + Type: parameters.TypeString, + Desc: "some description", + EmbeddedBy: "my_model", + }, + }, + }, + } + + tool, err := cfg.Initialize(nil) + if err != nil { + t.Fatalf("failed to initialize tool: %v", err) + } + + mockModel := mockEmbeddingModel{ + embedFn: func(ctx context.Context, texts []string) ([][]float32, error) { + if len(texts) != 1 || texts[0] != "hello" { + return nil, fmt.Errorf("unexpected texts: %v", texts) + } + return [][]float32{{0.1, -0.2, 0.3}}, nil + }, + } + + embeddingModelsMap := map[string]embeddingmodels.EmbeddingModel{ + "my_model": mockModel, + } + + paramValues := parameters.ParamValues{ + { + Name: "query", + Value: "hello", + }, + } + + gotParams, err := tool.EmbedParams(ctx, paramValues, embeddingModelsMap) + if err != nil { + t.Fatalf("EmbedParams failed: %v", err) + } + + if len(gotParams) != 1 { + t.Fatalf("expected 1 param value, got %d", len(gotParams)) + } + + gotVal, ok := gotParams[0].Value.(string) + if !ok { + t.Fatalf("expected string value, got %T", gotParams[0].Value) + } + + if len(gotVal) != 12 { // 3 floats * 4 bytes each + t.Fatalf("expected binary string length of 12, got %d", len(gotVal)) + } + + floats := make([]float32, 3) + for i := 0; i < 3; i++ { + bits := binary.LittleEndian.Uint32([]byte(gotVal[i*4 : (i+1)*4])) + floats[i] = math.Float32frombits(bits) + } + + wantFloats := []float32{0.1, -0.2, 0.3} + if diff := cmp.Diff(wantFloats, floats); diff != "" { + t.Fatalf("incorrect floats: diff %s", diff) + } +} + +type mockSource struct { + executedCmds [][]string +} + +func (m *mockSource) SourceType() string { + return "valkey" +} + +func (m *mockSource) ToConfig() sources.SourceConfig { + return nil +} + +func (m *mockSource) ValkeyClient() valkeyio.Client { + return nil +} + +func (m *mockSource) RunCommand(ctx context.Context, cmds [][]string) (any, error) { + m.executedCmds = cmds + return "ok", nil +} + +type mockSourceProvider struct { + src sources.Source +} + +func (p mockSourceProvider) GetSource(name string) (sources.Source, bool) { + return p.src, true +} + +func TestValkeyToolInvokeWithEmbedding(t *testing.T) { + ctx := context.Background() + + cfg := valkey.Config{ + ConfigBase: tools.ConfigBase{ + Name: "search_products", + Description: "Search products using vector similarity", + }, + Type: "valkey", + Source: "my-valkey", + Commands: [][]string{{"FT.SEARCH", "idx:products", "(*)=>[KNN 5 @vector_field $query_vec]", "PARAMS", "2", "query_vec", "$query_vec", "DIALECT", "2"}}, + Parameters: parameters.Parameters{ + ¶meters.StringParameter{ + CommonParameter: parameters.CommonParameter{ + Name: "query_vec", + Type: parameters.TypeString, + Desc: "The query text to embed", + EmbeddedBy: "gemini_model", + }, + }, + }, + } + + tool, err := cfg.Initialize(nil) + if err != nil { + t.Fatalf("failed to initialize tool: %v", err) + } + + mockModel := mockEmbeddingModel{ + embedFn: func(ctx context.Context, texts []string) ([][]float32, error) { + return [][]float32{{0.1, -0.2, 0.3}}, nil + }, + } + embeddingModelsMap := map[string]embeddingmodels.EmbeddingModel{ + "gemini_model": mockModel, + } + + mSrc := &mockSource{} + provider := mockSourceProvider{src: mSrc} + + rawParams := map[string]any{ + "query_vec": "hello", + } + parsedParams, err := parameters.ParseParams(tool.GetParameters(nil), rawParams, nil) + if err != nil { + t.Fatalf("failed to parse params: %v", err) + } + + embeddedParams, err := tool.EmbedParams(ctx, parsedParams, embeddingModelsMap) + if err != nil { + t.Fatalf("failed to embed params: %v", err) + } + + _, tbErr := tool.Invoke(ctx, provider, embeddedParams, "") + if tbErr != nil { + t.Fatalf("tool invocation failed: %v", tbErr) + } + + if len(mSrc.executedCmds) != 1 { + t.Fatalf("expected 1 command, got %d", len(mSrc.executedCmds)) + } + cmd := mSrc.executedCmds[0] + + if len(cmd) != 9 { + t.Fatalf("expected 9 args, got %d", len(cmd)) + } + + binStr := cmd[6] + if len(binStr) != 12 { + t.Fatalf("expected binary string length 12, got %d", len(binStr)) + } + + floats := make([]float32, 3) + for i := 0; i < 3; i++ { + bits := binary.LittleEndian.Uint32([]byte(binStr[i*4 : (i+1)*4])) + floats[i] = math.Float32frombits(bits) + } + wantFloats := []float32{0.1, -0.2, 0.3} + if diff := cmp.Diff(wantFloats, floats); diff != "" { + t.Fatalf("incorrect floats in executed command: diff %s", diff) + } + + wantCmd := []string{"FT.SEARCH", "idx:products", "(*)=>[KNN 5 @vector_field $query_vec]", "PARAMS", "2", "query_vec", binStr, "DIALECT", "2"} + if diff := cmp.Diff(wantCmd, cmd); diff != "" { + t.Fatalf("command mismatch (-want +got):\n%s", diff) + } +} + diff --git a/internal/tools/yugabytedbsql/yugabytedbsql_test.go b/internal/tools/yugabytedbsql/yugabytedbsql_test.go index b737717e4e6c..79efe7ec8368 100644 --- a/internal/tools/yugabytedbsql/yugabytedbsql_test.go +++ b/internal/tools/yugabytedbsql/yugabytedbsql_test.go @@ -83,7 +83,7 @@ func TestParseFromYamlYugabyteDBSQL(t *testing.T) { for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } @@ -128,7 +128,7 @@ func TestFailParseFromYamlYugabyteDBSQL(t *testing.T) { } for _, tc := range cases { t.Run(tc.desc, func(t *testing.T) { - _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, _, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err == nil { t.Fatalf("expected error but got none") } @@ -195,7 +195,7 @@ func TestParseFromYamlWithTemplateParamsYugabyteDB(t *testing.T) { } for _, tc := range tcs { t.Run(tc.desc, func(t *testing.T) { - _, _, _, got, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) + _, _, _, got, _, _, _, err := server.UnmarshalResourceConfig(ctx, testutils.FormatYaml(tc.in)) if err != nil { t.Fatalf("unable to unmarshal: %s", err) } diff --git a/tests/cloudmonitoring/cloud_monitoring_integration_test.go b/tests/cloudmonitoring/cloud_monitoring_integration_test.go index 1e087d45564c..ba05acfb71cb 100644 --- a/tests/cloudmonitoring/cloud_monitoring_integration_test.go +++ b/tests/cloudmonitoring/cloud_monitoring_integration_test.go @@ -23,6 +23,7 @@ import ( "time" "github.com/google/go-cmp/cmp" + "github.com/googleapis/mcp-toolbox/internal/testutils" "github.com/googleapis/mcp-toolbox/internal/tools" "github.com/googleapis/mcp-toolbox/internal/tools/cloudmonitoring" "github.com/googleapis/mcp-toolbox/internal/util/parameters" @@ -77,7 +78,7 @@ func TestTool_Invoke(t *testing.T) { } // Invoke the tool - result, err := tool.Invoke(ctx, nil, params, "") + result, err := tool.Invoke(ctx, &testutils.MockResourceMgr{}, params, "") if err != nil { t.Fatalf("Invoke() error = %v", err) } @@ -117,7 +118,7 @@ func TestTool_Invoke_Error(t *testing.T) { } // Invoke the tool - _, err := tool.Invoke(ctx, nil, params, "") + _, err := tool.Invoke(ctx, &testutils.MockResourceMgr{}, params, "") if err == nil { t.Fatal("Invoke() error = nil, want error") }