From f7cde006ffcbeddd7979a4997aff4c3aa93c1603 Mon Sep 17 00:00:00 2001 From: Daniel Schmidt Date: Fri, 13 Feb 2026 14:43:54 +0100 Subject: [PATCH] refactor state-show command argument parsing --- internal/command/arguments/state_show.go | 54 +++++++++ internal/command/arguments/state_show_test.go | 110 ++++++++++++++++++ internal/command/state_show.go | 21 ++-- 3 files changed, 171 insertions(+), 14 deletions(-) create mode 100644 internal/command/arguments/state_show.go create mode 100644 internal/command/arguments/state_show_test.go diff --git a/internal/command/arguments/state_show.go b/internal/command/arguments/state_show.go new file mode 100644 index 0000000000..afd2798fc9 --- /dev/null +++ b/internal/command/arguments/state_show.go @@ -0,0 +1,54 @@ +// Copyright (c) HashiCorp, Inc. +// SPDX-License-Identifier: BUSL-1.1 + +package arguments + +import ( + "github.com/hashicorp/terraform/internal/tfdiags" +) + +// StateShow represents the command-line arguments for the state show command. +type StateShow struct { + // StatePath is an optional path to a state file, overriding the default. + StatePath string + + // Address is the resource instance address to show. + Address string +} + +// ParseStateShow processes CLI arguments, returning a StateShow value and +// diagnostics. If errors are encountered, a StateShow value is still returned +// representing the best effort interpretation of the arguments. +func ParseStateShow(args []string) (*StateShow, tfdiags.Diagnostics) { + var diags tfdiags.Diagnostics + show := &StateShow{} + + var statePath string + cmdFlags := defaultFlagSet("state show") + cmdFlags.StringVar(&statePath, "state", "", "path") + + if err := cmdFlags.Parse(args); err != nil { + diags = diags.Append(tfdiags.Sourceless( + tfdiags.Error, + "Failed to parse command-line flags", + err.Error(), + )) + } + + args = cmdFlags.Args() + if len(args) != 1 { + diags = diags.Append(tfdiags.Sourceless( + tfdiags.Error, + "Required argument missing", + "Exactly one argument expected: the address of a resource instance to show.", + )) + } + + show.StatePath = statePath + + if len(args) > 0 { + show.Address = args[0] + } + + return show, diags +} diff --git a/internal/command/arguments/state_show_test.go b/internal/command/arguments/state_show_test.go new file mode 100644 index 0000000000..2358b29834 --- /dev/null +++ b/internal/command/arguments/state_show_test.go @@ -0,0 +1,110 @@ +// Copyright (c) HashiCorp, Inc. +// SPDX-License-Identifier: BUSL-1.1 + +package arguments + +import ( + "testing" + + "github.com/hashicorp/terraform/internal/tfdiags" +) + +func TestParseStateShow_valid(t *testing.T) { + testCases := map[string]struct { + args []string + want *StateShow + }{ + "address only": { + []string{"test_instance.foo"}, + &StateShow{ + StatePath: "", + Address: "test_instance.foo", + }, + }, + "with state path": { + []string{"-state=foobar.tfstate", "test_instance.foo"}, + &StateShow{ + StatePath: "foobar.tfstate", + Address: "test_instance.foo", + }, + }, + } + + for name, tc := range testCases { + t.Run(name, func(t *testing.T) { + got, diags := ParseStateShow(tc.args) + if len(diags) > 0 { + t.Fatalf("unexpected diags: %v", diags) + } + if *got != *tc.want { + t.Fatalf("unexpected result\n got: %#v\nwant: %#v", got, tc.want) + } + }) + } +} + +func TestParseStateShow_invalid(t *testing.T) { + testCases := map[string]struct { + args []string + want *StateShow + wantDiags tfdiags.Diagnostics + }{ + "no arguments": { + nil, + &StateShow{ + StatePath: "", + Address: "", + }, + tfdiags.Diagnostics{ + tfdiags.Sourceless( + tfdiags.Error, + "Required argument missing", + "Exactly one argument expected: the address of a resource instance to show.", + ), + }, + }, + "too many arguments": { + []string{"test_instance.foo", "test_instance.bar"}, + &StateShow{ + StatePath: "", + Address: "test_instance.foo", + }, + tfdiags.Diagnostics{ + tfdiags.Sourceless( + tfdiags.Error, + "Required argument missing", + "Exactly one argument expected: the address of a resource instance to show.", + ), + }, + }, + "unknown flag": { + []string{"-boop"}, + &StateShow{ + StatePath: "", + Address: "", + }, + tfdiags.Diagnostics{ + tfdiags.Sourceless( + tfdiags.Error, + "Failed to parse command-line flags", + "flag provided but not defined: -boop", + ), + tfdiags.Sourceless( + tfdiags.Error, + "Required argument missing", + "Exactly one argument expected: the address of a resource instance to show.", + ), + }, + }, + } + + for name, tc := range testCases { + t.Run(name, func(t *testing.T) { + got, gotDiags := ParseStateShow(tc.args) + if *got != *tc.want { + t.Fatalf("unexpected result\n got: %#v\nwant: %#v", got, tc.want) + } + tfdiags.AssertDiagnosticsMatch(t, gotDiags, tc.wantDiags) + }) + } +} diff --git a/internal/command/state_show.go b/internal/command/state_show.go index 7a5b4d8dfc..e25f42d2e5 100644 --- a/internal/command/state_show.go +++ b/internal/command/state_show.go @@ -8,8 +8,6 @@ import ( "os" "strings" - "github.com/hashicorp/cli" - "github.com/hashicorp/terraform/internal/addrs" "github.com/hashicorp/terraform/internal/backend/backendrun" "github.com/hashicorp/terraform/internal/command/arguments" @@ -27,18 +25,13 @@ type StateShowCommand struct { } func (c *StateShowCommand) Run(args []string) int { - args = c.Meta.process(args) - cmdFlags := c.Meta.defaultFlagSet("state show") - cmdFlags.StringVar(&c.Meta.statePath, "state", "", "path") - if err := cmdFlags.Parse(args); err != nil { - c.Streams.Eprintf("Error parsing command-line flags: %s\n", err.Error()) + parsedArgs, diags := arguments.ParseStateShow(c.Meta.process(args)) + if diags.HasErrors() { + c.showDiagnostics(diags) return 1 } - args = cmdFlags.Args() - if len(args) != 1 { - c.Streams.Eprint("Exactly one argument expected.\n") - return cli.RunResultHelp - } + + c.Meta.statePath = parsedArgs.StatePath // Check for user-supplied plugin path var err error @@ -66,9 +59,9 @@ func (c *StateShowCommand) Run(args []string) int { c.ignoreRemoteVersionConflict(b) // Check if the address can be parsed - addr, addrDiags := addrs.ParseAbsResourceInstanceStr(args[0]) + addr, addrDiags := addrs.ParseAbsResourceInstanceStr(parsedArgs.Address) if addrDiags.HasErrors() { - c.Streams.Eprintln(fmt.Sprintf(errParsingAddress, args[0])) + c.Streams.Eprintln(fmt.Sprintf(errParsingAddress, parsedArgs.Address)) return 1 }