opentofu/command/views/output_test.go

package views

import (
	"strings"
	"testing"

	"github.com/hashicorp/terraform/command/arguments"
	"github.com/hashicorp/terraform/internal/terminal"
	"github.com/hashicorp/terraform/states"
	"github.com/zclconf/go-cty/cty"
)

// Test various single output values for human-readable UI. Note that since
// OutputHuman defers to repl.FormatValue to render a single value, most of the
// test coverage should be in that package.
func TestOutputHuman_single(t *testing.T) {
	testCases := map[string]struct {
		value   cty.Value
		want    string
		wantErr bool
	}{
		"string": {
			value: cty.StringVal("hello"),
			want:  "\"hello\"\n",
		},
		"list of maps": {
			value: cty.ListVal([]cty.Value{
				cty.MapVal(map[string]cty.Value{
					"key":  cty.StringVal("value"),
					"key2": cty.StringVal("value2"),
				}),
				cty.MapVal(map[string]cty.Value{
					"key": cty.StringVal("value"),
				}),
			}),
			want: `tolist([
  tomap({
    "key" = "value"
    "key2" = "value2"
  }),
  tomap({
    "key" = "value"
  }),
])
`,
		},
	}

	for name, tc := range testCases {
		t.Run(name, func(t *testing.T) {
			streams, done := terminal.StreamsForTesting(t)
			v := NewOutput(arguments.ViewHuman, NewView(streams))

			outputs := map[string]*states.OutputValue{
				"foo": {Value: tc.value},
			}
			diags := v.Output("foo", outputs)

			if diags.HasErrors() {
				if !tc.wantErr {
					t.Fatalf("unexpected diagnostics: %s", diags)
				}
			} else if tc.wantErr {
				t.Fatalf("succeeded, but want error")
			}

			if got, want := done(t).Stdout(), tc.want; got != want {
				t.Errorf("wrong result\ngot:  %q\nwant: %q", got, want)
			}
		})
	}
}

// Sensitive output values are rendered to the console intentionally when
// requesting a single output.
func TestOutput_sensitive(t *testing.T) {
	testCases := map[string]arguments.ViewType{
		"human": arguments.ViewHuman,
		"json":  arguments.ViewJSON,
		"raw":   arguments.ViewRaw,
	}
	for name, vt := range testCases {
		t.Run(name, func(t *testing.T) {
			streams, done := terminal.StreamsForTesting(t)
			v := NewOutput(vt, NewView(streams))

			outputs := map[string]*states.OutputValue{
				"foo": {
					Value:     cty.StringVal("secret"),
					Sensitive: true,
				},
			}
			diags := v.Output("foo", outputs)

			if diags.HasErrors() {
				t.Fatalf("unexpected diagnostics: %s", diags)
			}

			// Test for substring match here because we don't care about exact
			// output format in this test, just the presence of the sensitive
			// value.
			if got, want := done(t).Stdout(), "secret"; !strings.Contains(got, want) {
				t.Errorf("wrong result\ngot:  %q\nwant: %q", got, want)
			}
		})
	}
}

// Showing all outputs is supported by human and JSON output format.
func TestOutput_all(t *testing.T) {
	outputs := map[string]*states.OutputValue{
		"foo": {
			Value:     cty.StringVal("secret"),
			Sensitive: true,
		},
		"bar": {
			Value: cty.ListVal([]cty.Value{cty.True, cty.False, cty.True}),
		},
		"baz": {
			Value: cty.ObjectVal(map[string]cty.Value{
				"boop": cty.NumberIntVal(5),
				"beep": cty.StringVal("true"),
			}),
		},
	}

	testCases := map[string]struct {
		vt   arguments.ViewType
		want string
	}{
		"human": {
			arguments.ViewHuman,
			`bar = tolist([
  true,
  false,
  true,
])
baz = {
  "beep" = "true"
  "boop" = 5
}
foo = <sensitive>
`,
		},
		"json": {
			arguments.ViewJSON,
			`{
  "bar": {
    "sensitive": false,
    "type": [
      "list",
      "bool"
    ],
    "value": [
      true,
      false,
      true
    ]
  },
  "baz": {
    "sensitive": false,
    "type": [
      "object",
      {
        "beep": "string",
        "boop": "number"
      }
    ],
    "value": {
      "beep": "true",
      "boop": 5
    }
  },
  "foo": {
    "sensitive": true,
    "type": "string",
    "value": "secret"
  }
}
`,
		},
	}

	for name, tc := range testCases {
		t.Run(name, func(t *testing.T) {
			streams, done := terminal.StreamsForTesting(t)
			v := NewOutput(tc.vt, NewView(streams))
			diags := v.Output("", outputs)

			if diags.HasErrors() {
				t.Fatalf("unexpected diagnostics: %s", diags)
			}

			if got := done(t).Stdout(); got != tc.want {
				t.Errorf("wrong result\ngot:  %q\nwant: %q", got, tc.want)
			}
		})
	}
}

// JSON output format supports empty outputs by rendering an empty object
// without diagnostics.
func TestOutputJSON_empty(t *testing.T) {
	streams, done := terminal.StreamsForTesting(t)
	v := NewOutput(arguments.ViewJSON, NewView(streams))

	diags := v.Output("", map[string]*states.OutputValue{})

	if diags.HasErrors() {
		t.Fatalf("unexpected diagnostics: %s", diags)
	}

	if got, want := done(t).Stdout(), "{}\n"; got != want {
		t.Errorf("wrong result\ngot:  %q\nwant: %q", got, want)
	}
}

// Human and raw formats render a warning if there are no outputs.
func TestOutput_emptyWarning(t *testing.T) {
	testCases := map[string]arguments.ViewType{
		"human": arguments.ViewHuman,
		"raw":   arguments.ViewRaw,
	}

	for name, vt := range testCases {
		t.Run(name, func(t *testing.T) {
			streams, done := terminal.StreamsForTesting(t)
			v := NewOutput(vt, NewView(streams))

			diags := v.Output("", map[string]*states.OutputValue{})

			if got, want := done(t).Stdout(), ""; got != want {
				t.Errorf("wrong result\ngot:  %q\nwant: %q", got, want)
			}

			if len(diags) != 1 {
				t.Fatalf("expected 1 diagnostic, got %d", len(diags))
			}

			if diags.HasErrors() {
				t.Fatalf("unexpected error diagnostics: %s", diags)
			}

			if got, want := diags[0].Description().Summary, "No outputs found"; got != want {
				t.Errorf("unexpected diagnostics: %s", diags)
			}
		})
	}
}

// Raw output is a simple unquoted output format designed for shell scripts,
// which relies on the cty.AsString() implementation. This test covers
// formatting for supported value types.
func TestOutputRaw(t *testing.T) {
	values := map[string]cty.Value{
		"str":      cty.StringVal("bar"),
		"multistr": cty.StringVal("bar\nbaz"),
		"num":      cty.NumberIntVal(2),
		"bool":     cty.True,
		"obj":      cty.EmptyObjectVal,
		"null":     cty.NullVal(cty.String),
		"unknown":  cty.UnknownVal(cty.String),
	}

	tests := map[string]struct {
		WantOutput string
		WantErr    bool
	}{
		"str":      {WantOutput: "bar"},
		"multistr": {WantOutput: "bar\nbaz"},
		"num":      {WantOutput: "2"},
		"bool":     {WantOutput: "true"},
		"obj":      {WantErr: true},
		"null":     {WantErr: true},
		"unknown":  {WantErr: true},
	}

	for name, test := range tests {
		t.Run(name, func(t *testing.T) {
			streams, done := terminal.StreamsForTesting(t)
			v := NewOutput(arguments.ViewRaw, NewView(streams))

			value := values[name]
			outputs := map[string]*states.OutputValue{
				name: {Value: value},
			}
			diags := v.Output(name, outputs)

			if diags.HasErrors() {
				if !test.WantErr {
					t.Fatalf("unexpected diagnostics: %s", diags)
				}
			} else if test.WantErr {
				t.Fatalf("succeeded, but want error")
			}

			if got, want := done(t).Stdout(), test.WantOutput; got != want {
				t.Errorf("wrong result\ngot:  %q\nwant: %q", got, want)
			}
		})
	}
}

// Raw cannot render all outputs.
func TestOutputRaw_all(t *testing.T) {
	streams, done := terminal.StreamsForTesting(t)
	v := NewOutput(arguments.ViewRaw, NewView(streams))

	outputs := map[string]*states.OutputValue{
		"foo": {Value: cty.StringVal("secret")},
		"bar": {Value: cty.True},
	}
	diags := v.Output("", outputs)

	if got, want := done(t).Stdout(), ""; got != want {
		t.Errorf("wrong result\ngot:  %q\nwant: %q", got, want)
	}

	if !diags.HasErrors() {
		t.Fatalf("expected diagnostics, got %s", diags)
	}

	if got, want := diags.Err().Error(), "Raw output format is only supported for single outputs"; got != want {
		t.Errorf("unexpected diagnostics: %s", diags)
	}
}

// All outputs render an error if a specific output is requested which is
// missing from the map of outputs.
func TestOutput_missing(t *testing.T) {
	testCases := map[string]arguments.ViewType{
		"human": arguments.ViewHuman,
		"json":  arguments.ViewJSON,
		"raw":   arguments.ViewRaw,
	}

	for name, vt := range testCases {
		t.Run(name, func(t *testing.T) {
			streams, done := terminal.StreamsForTesting(t)
			v := NewOutput(vt, NewView(streams))

			diags := v.Output("foo", map[string]*states.OutputValue{
				"bar": {Value: cty.StringVal("boop")},
			})

			if len(diags) != 1 {
				t.Fatalf("expected 1 diagnostic, got %d", len(diags))
			}

			if !diags.HasErrors() {
				t.Fatalf("expected error diagnostics, got %s", diags)
			}

			if got, want := diags[0].Description().Summary, `Output "foo" not found`; got != want {
				t.Errorf("unexpected diagnostics: %s", diags)
			}

			if got, want := done(t).Stdout(), ""; got != want {
				t.Errorf("wrong result\ngot:  %q\nwant: %q", got, want)
			}
		})
	}
}