ResiLien
/
terraform
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
terraform/command/version_test.go

241 lines
6.1 KiB
Go
Raw Normal View History

Implement CLI, version command
2014-05-24 21:04:43 +02:00
package command
import (
command/init: Read, respect, and update provider dependency locks This changes the approach used by the provider installer to remember between runs which selections it has previously made, using the lock file format implemented in internal/depsfile. This means that version constraints in the configuration are considered only for providers we've not seen before or when -upgrade mode is active.
2020-10-03 01:41:56 +02:00
"io/ioutil"
add test for terraform version -json
2020-06-15 20:45:27 +02:00
"os"
"strings"
Implement CLI, version command
2014-05-24 21:04:43 +02:00
"testing"
command/init: Read, respect, and update provider dependency locks This changes the approach used by the provider installer to remember between runs which selections it has previously made, using the lock file format implemented in internal/depsfile. This means that version constraints in the configuration are considered only for providers we've not seen before or when -upgrade mode is active.
2020-10-03 01:41:56 +02:00
"github.com/google/go-cmp/cmp"
"github.com/hashicorp/terraform/addrs"
"github.com/hashicorp/terraform/internal/depsfile"
"github.com/hashicorp/terraform/internal/getproviders"
Implement CLI, version command
2014-05-24 21:04:43 +02:00
"github.com/mitchellh/cli"
)
func TestVersionCommand_implements(t *testing.T) {
var _ cli.Command = &VersionCommand{}
}
add test for terraform version -json
2020-06-15 20:45:27 +02:00
add test for terraform version
2020-06-15 20:55:51 +02:00
func TestVersion(t *testing.T) {
command/init: Read, respect, and update provider dependency locks This changes the approach used by the provider installer to remember between runs which selections it has previously made, using the lock file format implemented in internal/depsfile. This means that version constraints in the configuration are considered only for providers we've not seen before or when -upgrade mode is active.
2020-10-03 01:41:56 +02:00
td, err := ioutil.TempDir("", "terraform-test-version")
if err != nil {
t.Fatal(err)
}
add test for terraform version
2020-06-15 20:55:51 +02:00
defer os.RemoveAll(td)
defer testChdir(t, td)()
command/init: Read, respect, and update provider dependency locks This changes the approach used by the provider installer to remember between runs which selections it has previously made, using the lock file format implemented in internal/depsfile. This means that version constraints in the configuration are considered only for providers we've not seen before or when -upgrade mode is active.
2020-10-03 01:41:56 +02:00
// We'll create a fixed dependency lock file in our working directory
// so we can verify that the version command shows the information
// from it.
locks := depsfile.NewLocks()
locks.SetProvider(
addrs.NewDefaultProvider("test2"),
getproviders.MustParseVersion("1.2.3"),
nil,
nil,
)
locks.SetProvider(
addrs.NewDefaultProvider("test1"),
getproviders.MustParseVersion("7.8.9-beta.2"),
nil,
nil,
)
ui := cli.NewMockUi()
add test for terraform version
2020-06-15 20:55:51 +02:00
c := &VersionCommand{
command/init: Read, respect, and update provider dependency locks This changes the approach used by the provider installer to remember between runs which selections it has previously made, using the lock file format implemented in internal/depsfile. This means that version constraints in the configuration are considered only for providers we've not seen before or when -upgrade mode is active.
2020-10-03 01:41:56 +02:00
Meta: Meta{
Ui: ui,
},
add test for terraform version
2020-06-15 20:55:51 +02:00
Version: "4.5.6",
VersionPrerelease: "foo",
command/version: Report the current platform Along with all of the other information we previously reported in the "terraform version" output, we'll now include the name of the current platform as our provider mechanisms represent it. This is addressing a long-standing minor annoyance where we often can't tell from an incomplete bug report which platform Terraform was running on, and incomplete bug reporters do tend to at least include the "terraform version" output even if they don't also include the requested full trace log. However, what motivated doing it _now_ is that anyone building a provider registry or mirror needs to have some awareness of these platform identifiers which have been, until v0.13, mostly an implementation detail. This additional information is a small thing we can do to help registry builders find out what the platform identifier ought to be for each of the platforms they aim to support, even if some of them are platforms which the Go compiler allows but which HashiCorp doesn't officially support. The new information is on a line of its own in the output as a pragmatic way to avoid breaking anyone who might be using something like $(terraform version | head -n1) to print a brief Terraform version identifier into some logs. That's not an interface we officially support for machine consumption, but it's easy to avoid breaking it here and so we won't do so.
2020-11-19 00:43:27 +01:00
Platform: getproviders.Platform{OS: "aros", Arch: "riscv64"},
add test for terraform version
2020-06-15 20:55:51 +02:00
}
command/init: Read, respect, and update provider dependency locks This changes the approach used by the provider installer to remember between runs which selections it has previously made, using the lock file format implemented in internal/depsfile. This means that version constraints in the configuration are considered only for providers we've not seen before or when -upgrade mode is active.
2020-10-03 01:41:56 +02:00
if err := c.replaceLockedDependencies(locks); err != nil {
t.Fatal(err)
}
add test for terraform version
2020-06-15 20:55:51 +02:00
if code := c.Run([]string{}); code != 0 {
t.Fatalf("bad: \n%s", ui.ErrorWriter.String())
}
actual := strings.TrimSpace(ui.OutputWriter.String())
command/version: Report the current platform Along with all of the other information we previously reported in the "terraform version" output, we'll now include the name of the current platform as our provider mechanisms represent it. This is addressing a long-standing minor annoyance where we often can't tell from an incomplete bug report which platform Terraform was running on, and incomplete bug reporters do tend to at least include the "terraform version" output even if they don't also include the requested full trace log. However, what motivated doing it _now_ is that anyone building a provider registry or mirror needs to have some awareness of these platform identifiers which have been, until v0.13, mostly an implementation detail. This additional information is a small thing we can do to help registry builders find out what the platform identifier ought to be for each of the platforms they aim to support, even if some of them are platforms which the Go compiler allows but which HashiCorp doesn't officially support. The new information is on a line of its own in the output as a pragmatic way to avoid breaking anyone who might be using something like $(terraform version | head -n1) to print a brief Terraform version identifier into some logs. That's not an interface we officially support for machine consumption, but it's easy to avoid breaking it here and so we won't do so.
2020-11-19 00:43:27 +01:00
expected := "Terraform v4.5.6-foo\non aros_riscv64\n+ provider registry.terraform.io/hashicorp/test1 v7.8.9-beta.2\n+ provider registry.terraform.io/hashicorp/test2 v1.2.3"
add test for terraform version
2020-06-15 20:55:51 +02:00
if actual != expected {
command/init: Read, respect, and update provider dependency locks This changes the approach used by the provider installer to remember between runs which selections it has previously made, using the lock file format implemented in internal/depsfile. This means that version constraints in the configuration are considered only for providers we've not seen before or when -upgrade mode is active.
2020-10-03 01:41:56 +02:00
t.Fatalf("wrong output\ngot:\n%s\nwant:\n%s", actual, expected)
add test for terraform version
2020-06-15 20:55:51 +02:00
}
}
command: Fix bug with -v/-version/--version flags We globally support a -v/-version/--version flag, which triggers the version subcommand. The recent introduction of JSON output support meant we started parsing the flags for the first time, but we didn't add flags for these global version arguments. This commit adds those flags (but doesn't check them, since they have no effect on the version command itself). Also adds usage information for terraform version.
2020-06-17 21:24:15 +02:00
func TestVersion_flags(t *testing.T) {
ui := new(cli.MockUi)
m := Meta{
Ui: ui,
}
// `terraform version`
c := &VersionCommand{
Meta: m,
Version: "4.5.6",
VersionPrerelease: "foo",
command/version: Report the current platform Along with all of the other information we previously reported in the "terraform version" output, we'll now include the name of the current platform as our provider mechanisms represent it. This is addressing a long-standing minor annoyance where we often can't tell from an incomplete bug report which platform Terraform was running on, and incomplete bug reporters do tend to at least include the "terraform version" output even if they don't also include the requested full trace log. However, what motivated doing it _now_ is that anyone building a provider registry or mirror needs to have some awareness of these platform identifiers which have been, until v0.13, mostly an implementation detail. This additional information is a small thing we can do to help registry builders find out what the platform identifier ought to be for each of the platforms they aim to support, even if some of them are platforms which the Go compiler allows but which HashiCorp doesn't officially support. The new information is on a line of its own in the output as a pragmatic way to avoid breaking anyone who might be using something like $(terraform version | head -n1) to print a brief Terraform version identifier into some logs. That's not an interface we officially support for machine consumption, but it's easy to avoid breaking it here and so we won't do so.
2020-11-19 00:43:27 +01:00
Platform: getproviders.Platform{OS: "aros", Arch: "riscv64"},
command: Fix bug with -v/-version/--version flags We globally support a -v/-version/--version flag, which triggers the version subcommand. The recent introduction of JSON output support meant we started parsing the flags for the first time, but we didn't add flags for these global version arguments. This commit adds those flags (but doesn't check them, since they have no effect on the version command itself). Also adds usage information for terraform version.
2020-06-17 21:24:15 +02:00
}
if code := c.Run([]string{"-v", "-version"}); code != 0 {
t.Fatalf("bad: \n%s", ui.ErrorWriter.String())
}
actual := strings.TrimSpace(ui.OutputWriter.String())
command/version: Report the current platform Along with all of the other information we previously reported in the "terraform version" output, we'll now include the name of the current platform as our provider mechanisms represent it. This is addressing a long-standing minor annoyance where we often can't tell from an incomplete bug report which platform Terraform was running on, and incomplete bug reporters do tend to at least include the "terraform version" output even if they don't also include the requested full trace log. However, what motivated doing it _now_ is that anyone building a provider registry or mirror needs to have some awareness of these platform identifiers which have been, until v0.13, mostly an implementation detail. This additional information is a small thing we can do to help registry builders find out what the platform identifier ought to be for each of the platforms they aim to support, even if some of them are platforms which the Go compiler allows but which HashiCorp doesn't officially support. The new information is on a line of its own in the output as a pragmatic way to avoid breaking anyone who might be using something like $(terraform version | head -n1) to print a brief Terraform version identifier into some logs. That's not an interface we officially support for machine consumption, but it's easy to avoid breaking it here and so we won't do so.
2020-11-19 00:43:27 +01:00
expected := "Terraform v4.5.6-foo\non aros_riscv64"
command: Fix bug with -v/-version/--version flags We globally support a -v/-version/--version flag, which triggers the version subcommand. The recent introduction of JSON output support meant we started parsing the flags for the first time, but we didn't add flags for these global version arguments. This commit adds those flags (but doesn't check them, since they have no effect on the version command itself). Also adds usage information for terraform version.
2020-06-17 21:24:15 +02:00
if actual != expected {
t.Fatalf("wrong output\ngot: %#v\nwant: %#v", actual, expected)
}
}
test outdated version output
2020-08-12 22:22:39 +02:00
func TestVersion_outdated(t *testing.T) {
ui := new(cli.MockUi)
m := Meta{
Ui: ui,
}
c := &VersionCommand{
Meta: m,
Version: "4.5.6",
CheckFunc: mockVersionCheckFunc(true, "4.5.7"),
command/version: Report the current platform Along with all of the other information we previously reported in the "terraform version" output, we'll now include the name of the current platform as our provider mechanisms represent it. This is addressing a long-standing minor annoyance where we often can't tell from an incomplete bug report which platform Terraform was running on, and incomplete bug reporters do tend to at least include the "terraform version" output even if they don't also include the requested full trace log. However, what motivated doing it _now_ is that anyone building a provider registry or mirror needs to have some awareness of these platform identifiers which have been, until v0.13, mostly an implementation detail. This additional information is a small thing we can do to help registry builders find out what the platform identifier ought to be for each of the platforms they aim to support, even if some of them are platforms which the Go compiler allows but which HashiCorp doesn't officially support. The new information is on a line of its own in the output as a pragmatic way to avoid breaking anyone who might be using something like $(terraform version | head -n1) to print a brief Terraform version identifier into some logs. That's not an interface we officially support for machine consumption, but it's easy to avoid breaking it here and so we won't do so.
2020-11-19 00:43:27 +01:00
Platform: getproviders.Platform{OS: "aros", Arch: "riscv64"},
test outdated version output
2020-08-12 22:22:39 +02:00
}
if code := c.Run([]string{}); code != 0 {
t.Fatalf("bad: \n%s", ui.ErrorWriter.String())
}
actual := strings.TrimSpace(ui.OutputWriter.String())
command/version: Report the current platform Along with all of the other information we previously reported in the "terraform version" output, we'll now include the name of the current platform as our provider mechanisms represent it. This is addressing a long-standing minor annoyance where we often can't tell from an incomplete bug report which platform Terraform was running on, and incomplete bug reporters do tend to at least include the "terraform version" output even if they don't also include the requested full trace log. However, what motivated doing it _now_ is that anyone building a provider registry or mirror needs to have some awareness of these platform identifiers which have been, until v0.13, mostly an implementation detail. This additional information is a small thing we can do to help registry builders find out what the platform identifier ought to be for each of the platforms they aim to support, even if some of them are platforms which the Go compiler allows but which HashiCorp doesn't officially support. The new information is on a line of its own in the output as a pragmatic way to avoid breaking anyone who might be using something like $(terraform version | head -n1) to print a brief Terraform version identifier into some logs. That's not an interface we officially support for machine consumption, but it's easy to avoid breaking it here and so we won't do so.
2020-11-19 00:43:27 +01:00
expected := "Terraform v4.5.6\non aros_riscv64\n\nYour version of Terraform is out of date! The latest version\nis 4.5.7. You can update by downloading from https://www.terraform.io/downloads.html"
test outdated version output
2020-08-12 22:22:39 +02:00
if actual != expected {
t.Fatalf("wrong output\ngot: %#v\nwant: %#v", actual, expected)
}
}
add test for terraform version -json
2020-06-15 20:45:27 +02:00
func TestVersion_json(t *testing.T) {
command/init: Read, respect, and update provider dependency locks This changes the approach used by the provider installer to remember between runs which selections it has previously made, using the lock file format implemented in internal/depsfile. This means that version constraints in the configuration are considered only for providers we've not seen before or when -upgrade mode is active.
2020-10-03 01:41:56 +02:00
td, err := ioutil.TempDir("", "terraform-test-version")
if err != nil {
t.Fatal(err)
}
add test for terraform version -json
2020-06-15 20:45:27 +02:00
defer os.RemoveAll(td)
defer testChdir(t, td)()
command/init: Read, respect, and update provider dependency locks This changes the approach used by the provider installer to remember between runs which selections it has previously made, using the lock file format implemented in internal/depsfile. This means that version constraints in the configuration are considered only for providers we've not seen before or when -upgrade mode is active.
2020-10-03 01:41:56 +02:00
ui := cli.NewMockUi()
meta := Meta{
Ui: ui,
add test for terraform version -json
2020-06-15 20:45:27 +02:00
}
// `terraform version -json` without prerelease
c := &VersionCommand{
command/version: Report the current platform Along with all of the other information we previously reported in the "terraform version" output, we'll now include the name of the current platform as our provider mechanisms represent it. This is addressing a long-standing minor annoyance where we often can't tell from an incomplete bug report which platform Terraform was running on, and incomplete bug reporters do tend to at least include the "terraform version" output even if they don't also include the requested full trace log. However, what motivated doing it _now_ is that anyone building a provider registry or mirror needs to have some awareness of these platform identifiers which have been, until v0.13, mostly an implementation detail. This additional information is a small thing we can do to help registry builders find out what the platform identifier ought to be for each of the platforms they aim to support, even if some of them are platforms which the Go compiler allows but which HashiCorp doesn't officially support. The new information is on a line of its own in the output as a pragmatic way to avoid breaking anyone who might be using something like $(terraform version | head -n1) to print a brief Terraform version identifier into some logs. That's not an interface we officially support for machine consumption, but it's easy to avoid breaking it here and so we won't do so.
2020-11-19 00:43:27 +01:00
Meta: meta,
Version: "4.5.6",
Platform: getproviders.Platform{OS: "aros", Arch: "riscv64"},
add test for terraform version -json
2020-06-15 20:45:27 +02:00
}
if code := c.Run([]string{"-json"}); code != 0 {
t.Fatalf("bad: \n%s", ui.ErrorWriter.String())
}
actual := strings.TrimSpace(ui.OutputWriter.String())
command/init: Read, respect, and update provider dependency locks This changes the approach used by the provider installer to remember between runs which selections it has previously made, using the lock file format implemented in internal/depsfile. This means that version constraints in the configuration are considered only for providers we've not seen before or when -upgrade mode is active.
2020-10-03 01:41:56 +02:00
expected := strings.TrimSpace(`
{
"terraform_version": "4.5.6",
"terraform_revision": "",
command/version: Report the current platform Along with all of the other information we previously reported in the "terraform version" output, we'll now include the name of the current platform as our provider mechanisms represent it. This is addressing a long-standing minor annoyance where we often can't tell from an incomplete bug report which platform Terraform was running on, and incomplete bug reporters do tend to at least include the "terraform version" output even if they don't also include the requested full trace log. However, what motivated doing it _now_ is that anyone building a provider registry or mirror needs to have some awareness of these platform identifiers which have been, until v0.13, mostly an implementation detail. This additional information is a small thing we can do to help registry builders find out what the platform identifier ought to be for each of the platforms they aim to support, even if some of them are platforms which the Go compiler allows but which HashiCorp doesn't officially support. The new information is on a line of its own in the output as a pragmatic way to avoid breaking anyone who might be using something like $(terraform version | head -n1) to print a brief Terraform version identifier into some logs. That's not an interface we officially support for machine consumption, but it's easy to avoid breaking it here and so we won't do so.
2020-11-19 00:43:27 +01:00
"platform": "aros_riscv64",
command/init: Read, respect, and update provider dependency locks This changes the approach used by the provider installer to remember between runs which selections it has previously made, using the lock file format implemented in internal/depsfile. This means that version constraints in the configuration are considered only for providers we've not seen before or when -upgrade mode is active.
2020-10-03 01:41:56 +02:00
"provider_selections": {},
"terraform_outdated": false
}
`)
if diff := cmp.Diff(expected, actual); diff != "" {
t.Fatalf("wrong output\n%s", diff)
add test for terraform version -json
2020-06-15 20:45:27 +02:00
}
// flush the output from the mock ui
ui.OutputWriter.Reset()
command/init: Read, respect, and update provider dependency locks This changes the approach used by the provider installer to remember between runs which selections it has previously made, using the lock file format implemented in internal/depsfile. This means that version constraints in the configuration are considered only for providers we've not seen before or when -upgrade mode is active.
2020-10-03 01:41:56 +02:00
// Now we'll create a fixed dependency lock file in our working directory
// so we can verify that the version command shows the information
// from it.
locks := depsfile.NewLocks()
locks.SetProvider(
addrs.NewDefaultProvider("test2"),
getproviders.MustParseVersion("1.2.3"),
nil,
nil,
)
locks.SetProvider(
addrs.NewDefaultProvider("test1"),
getproviders.MustParseVersion("7.8.9-beta.2"),
nil,
nil,
)
// `terraform version -json` with prerelease and provider dependencies
add test for terraform version -json
2020-06-15 20:45:27 +02:00
c = &VersionCommand{
command/init: Read, respect, and update provider dependency locks This changes the approach used by the provider installer to remember between runs which selections it has previously made, using the lock file format implemented in internal/depsfile. This means that version constraints in the configuration are considered only for providers we've not seen before or when -upgrade mode is active.
2020-10-03 01:41:56 +02:00
Meta: meta,
add test for terraform version -json
2020-06-15 20:45:27 +02:00
Version: "4.5.6",
VersionPrerelease: "foo",
command/version: Report the current platform Along with all of the other information we previously reported in the "terraform version" output, we'll now include the name of the current platform as our provider mechanisms represent it. This is addressing a long-standing minor annoyance where we often can't tell from an incomplete bug report which platform Terraform was running on, and incomplete bug reporters do tend to at least include the "terraform version" output even if they don't also include the requested full trace log. However, what motivated doing it _now_ is that anyone building a provider registry or mirror needs to have some awareness of these platform identifiers which have been, until v0.13, mostly an implementation detail. This additional information is a small thing we can do to help registry builders find out what the platform identifier ought to be for each of the platforms they aim to support, even if some of them are platforms which the Go compiler allows but which HashiCorp doesn't officially support. The new information is on a line of its own in the output as a pragmatic way to avoid breaking anyone who might be using something like $(terraform version | head -n1) to print a brief Terraform version identifier into some logs. That's not an interface we officially support for machine consumption, but it's easy to avoid breaking it here and so we won't do so.
2020-11-19 00:43:27 +01:00
Platform: getproviders.Platform{OS: "aros", Arch: "riscv64"},
add test for terraform version -json
2020-06-15 20:45:27 +02:00
}
command/init: Read, respect, and update provider dependency locks This changes the approach used by the provider installer to remember between runs which selections it has previously made, using the lock file format implemented in internal/depsfile. This means that version constraints in the configuration are considered only for providers we've not seen before or when -upgrade mode is active.
2020-10-03 01:41:56 +02:00
if err := c.replaceLockedDependencies(locks); err != nil {
t.Fatal(err)
}
add test for terraform version -json
2020-06-15 20:45:27 +02:00
if code := c.Run([]string{"-json"}); code != 0 {
t.Fatalf("bad: \n%s", ui.ErrorWriter.String())
}
actual = strings.TrimSpace(ui.OutputWriter.String())
command/init: Read, respect, and update provider dependency locks This changes the approach used by the provider installer to remember between runs which selections it has previously made, using the lock file format implemented in internal/depsfile. This means that version constraints in the configuration are considered only for providers we've not seen before or when -upgrade mode is active.
2020-10-03 01:41:56 +02:00
expected = strings.TrimSpace(`
{
"terraform_version": "4.5.6-foo",
"terraform_revision": "",
command/version: Report the current platform Along with all of the other information we previously reported in the "terraform version" output, we'll now include the name of the current platform as our provider mechanisms represent it. This is addressing a long-standing minor annoyance where we often can't tell from an incomplete bug report which platform Terraform was running on, and incomplete bug reporters do tend to at least include the "terraform version" output even if they don't also include the requested full trace log. However, what motivated doing it _now_ is that anyone building a provider registry or mirror needs to have some awareness of these platform identifiers which have been, until v0.13, mostly an implementation detail. This additional information is a small thing we can do to help registry builders find out what the platform identifier ought to be for each of the platforms they aim to support, even if some of them are platforms which the Go compiler allows but which HashiCorp doesn't officially support. The new information is on a line of its own in the output as a pragmatic way to avoid breaking anyone who might be using something like $(terraform version | head -n1) to print a brief Terraform version identifier into some logs. That's not an interface we officially support for machine consumption, but it's easy to avoid breaking it here and so we won't do so.
2020-11-19 00:43:27 +01:00
"platform": "aros_riscv64",
command/init: Read, respect, and update provider dependency locks This changes the approach used by the provider installer to remember between runs which selections it has previously made, using the lock file format implemented in internal/depsfile. This means that version constraints in the configuration are considered only for providers we've not seen before or when -upgrade mode is active.
2020-10-03 01:41:56 +02:00
"provider_selections": {
"registry.terraform.io/hashicorp/test1": "7.8.9-beta.2",
"registry.terraform.io/hashicorp/test2": "1.2.3"
},
"terraform_outdated": false
}
`)
if diff := cmp.Diff(expected, actual); diff != "" {
t.Fatalf("wrong output\n%s", diff)
add test for terraform version -json
2020-06-15 20:45:27 +02:00
}
}
test outdated version output
2020-08-12 22:22:39 +02:00
func TestVersion_jsonoutdated(t *testing.T) {
ui := new(cli.MockUi)
m := Meta{
Ui: ui,
}
c := &VersionCommand{
Meta: m,
Version: "4.5.6",
CheckFunc: mockVersionCheckFunc(true, "4.5.7"),
command/version: Report the current platform Along with all of the other information we previously reported in the "terraform version" output, we'll now include the name of the current platform as our provider mechanisms represent it. This is addressing a long-standing minor annoyance where we often can't tell from an incomplete bug report which platform Terraform was running on, and incomplete bug reporters do tend to at least include the "terraform version" output even if they don't also include the requested full trace log. However, what motivated doing it _now_ is that anyone building a provider registry or mirror needs to have some awareness of these platform identifiers which have been, until v0.13, mostly an implementation detail. This additional information is a small thing we can do to help registry builders find out what the platform identifier ought to be for each of the platforms they aim to support, even if some of them are platforms which the Go compiler allows but which HashiCorp doesn't officially support. The new information is on a line of its own in the output as a pragmatic way to avoid breaking anyone who might be using something like $(terraform version | head -n1) to print a brief Terraform version identifier into some logs. That's not an interface we officially support for machine consumption, but it's easy to avoid breaking it here and so we won't do so.
2020-11-19 00:43:27 +01:00
Platform: getproviders.Platform{OS: "aros", Arch: "riscv64"},
test outdated version output
2020-08-12 22:22:39 +02:00
}
if code := c.Run([]string{"-json"}); code != 0 {
t.Fatalf("bad: \n%s", ui.ErrorWriter.String())
}
actual := strings.TrimSpace(ui.OutputWriter.String())
command/version: Report the current platform Along with all of the other information we previously reported in the "terraform version" output, we'll now include the name of the current platform as our provider mechanisms represent it. This is addressing a long-standing minor annoyance where we often can't tell from an incomplete bug report which platform Terraform was running on, and incomplete bug reporters do tend to at least include the "terraform version" output even if they don't also include the requested full trace log. However, what motivated doing it _now_ is that anyone building a provider registry or mirror needs to have some awareness of these platform identifiers which have been, until v0.13, mostly an implementation detail. This additional information is a small thing we can do to help registry builders find out what the platform identifier ought to be for each of the platforms they aim to support, even if some of them are platforms which the Go compiler allows but which HashiCorp doesn't officially support. The new information is on a line of its own in the output as a pragmatic way to avoid breaking anyone who might be using something like $(terraform version | head -n1) to print a brief Terraform version identifier into some logs. That's not an interface we officially support for machine consumption, but it's easy to avoid breaking it here and so we won't do so.
2020-11-19 00:43:27 +01:00
expected := "{\n \"terraform_version\": \"4.5.6\",\n \"terraform_revision\": \"\",\n \"platform\": \"aros_riscv64\",\n \"provider_selections\": {},\n \"terraform_outdated\": true\n}"
test outdated version output
2020-08-12 22:22:39 +02:00
if actual != expected {
t.Fatalf("wrong output\ngot: %#v\nwant: %#v", actual, expected)
}
}
func mockVersionCheckFunc(outdated bool, latest string) VersionCheckFunc {
return func() (VersionCheckInfo, error) {
return VersionCheckInfo{
Outdated: outdated,
Latest: latest,
// Alerts is not used by version command
}, nil
}
}