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

410 lines
8.7 KiB
Go
Raw Normal View History

comand/output
2014-07-13 19:25:42 +02:00
package command
import (
"os"
"path/filepath"
"strings"
"testing"
"github.com/mitchellh/cli"
terraform: Ugly huge change to weave in new State and Plan types Due to how often the state and plan types are referenced throughout Terraform, there isn't a great way to switch them out gradually. As a consequence, this huge commit gets us from the old world to a _compilable_ new world, but still has a large number of known test failures due to key functionality being stubbed out. The stubs here are for anything that interacts with providers, since we now need to do the follow-up work to similarly replace the old terraform.ResourceProvider interface with its replacement in the new "providers" package. That work, along with work to fix the remaining failing tests, will follow in subsequent commits. The aim here was to replace all references to terraform.State and its downstream types with states.State, terraform.Plan with plans.Plan, state.State with statemgr.State, and switch to the new implementations of the state and plan file formats. However, due to the number of times those types are used, this also ended up affecting numerous other parts of core such as terraform.Hook, the backend.Backend interface, and most of the CLI commands. Just as with 5861dbf3fc49b19587a31816eb06f511ab861bb4 before, I apologize in advance to the person who inevitably just found this huge commit while spelunking through the commit history.
2018-08-14 23:24:45 +02:00
"github.com/zclconf/go-cty/cty"
"github.com/hashicorp/terraform/addrs"
"github.com/hashicorp/terraform/states"
comand/output
2014-07-13 19:25:42 +02:00
)
func TestOutput(t *testing.T) {
terraform: Ugly huge change to weave in new State and Plan types Due to how often the state and plan types are referenced throughout Terraform, there isn't a great way to switch them out gradually. As a consequence, this huge commit gets us from the old world to a _compilable_ new world, but still has a large number of known test failures due to key functionality being stubbed out. The stubs here are for anything that interacts with providers, since we now need to do the follow-up work to similarly replace the old terraform.ResourceProvider interface with its replacement in the new "providers" package. That work, along with work to fix the remaining failing tests, will follow in subsequent commits. The aim here was to replace all references to terraform.State and its downstream types with states.State, terraform.Plan with plans.Plan, state.State with statemgr.State, and switch to the new implementations of the state and plan file formats. However, due to the number of times those types are used, this also ended up affecting numerous other parts of core such as terraform.Hook, the backend.Backend interface, and most of the CLI commands. Just as with 5861dbf3fc49b19587a31816eb06f511ab861bb4 before, I apologize in advance to the person who inevitably just found this huge commit while spelunking through the commit history.
2018-08-14 23:24:45 +02:00
originalState := states.BuildState(func(s *states.SyncState) {
s.SetOutputValue(
addrs.OutputValue{Name: "foo"}.Absolute(addrs.RootModuleInstance),
cty.StringVal("bar"),
false,
)
})
comand/output
2014-07-13 19:25:42 +02:00
statePath := testStateFile(t, originalState)
ui := new(cli.MockUi)
c := &OutputCommand{
Meta: Meta{
Push plugin discovery down into command package Previously we did plugin discovery in the main package, but as we move towards versioned plugins we need more information available in order to resolve plugins, so we move this responsibility into the command package itself. For the moment this is just preserving the existing behavior as long as there are only internal and unversioned plugins present. This is the final state for provisioners in 0.10, since we don't want to support versioned provisioners yet. For providers this is just a checkpoint along the way, since further work is required to apply version constraints from configuration and support additional plugin search directories. The automatic plugin discovery behavior is not desirable for tests because we want to mock the plugins there, so we add a new backdoor for the tests to use to skip the plugin discovery and just provide their own mock implementations. Most of this diff is thus noisy rework of the tests to use this new mechanism.
2017-04-14 03:05:58 +02:00
testingOverrides: metaOverridesForProvider(testProvider()),
Ui: ui,
comand/output
2014-07-13 19:25:42 +02:00
},
}
args := []string{
"-state", statePath,
"foo",
}
if code := c.Run(args); code != 0 {
t.Fatalf("bad: \n%s", ui.ErrorWriter.String())
}
actual := strings.TrimSpace(ui.OutputWriter.String())
repl: Improved value renderer for console outputs Use a slightly modified value renderer from terraform-provider-testing to display values in the console REPL, as well as outputs from the apply and outputs subcommands. Derived from code in this repository, MIT licensed: https://github.com/apparentlymart/terraform-provider-testing Note that this is technically a breaking change for the console subcommand, which would previously error if the user attempted to render an unknown value (such as an unset variable). This was marked as an unintentional side effect, with the goal being the new behaviour of rendering "(unknown)", which is why I changed the behaviour in this commit.
2020-09-09 20:13:53 +02:00
if actual != `"bar"` {
comand/output
2014-07-13 19:25:42 +02:00
t.Fatalf("bad: %#v", actual)
}
}
core: Add -json flag to `terraform output` This commit removes the ability to index into complex output types using `terraform output a_list 1` (for example), and adds a `-json` flag to the `terraform output` command, such that the output can be piped through a post-processor such as jq or json. This removes the need to allow arbitrary traversal of nested structures. It also adds tests of human readable ("normal") output with nested lists and maps, and of the new JSON output.
2016-07-13 18:38:19 +02:00
func TestOutput_nestedListAndMap(t *testing.T) {
terraform: Ugly huge change to weave in new State and Plan types Due to how often the state and plan types are referenced throughout Terraform, there isn't a great way to switch them out gradually. As a consequence, this huge commit gets us from the old world to a _compilable_ new world, but still has a large number of known test failures due to key functionality being stubbed out. The stubs here are for anything that interacts with providers, since we now need to do the follow-up work to similarly replace the old terraform.ResourceProvider interface with its replacement in the new "providers" package. That work, along with work to fix the remaining failing tests, will follow in subsequent commits. The aim here was to replace all references to terraform.State and its downstream types with states.State, terraform.Plan with plans.Plan, state.State with statemgr.State, and switch to the new implementations of the state and plan file formats. However, due to the number of times those types are used, this also ended up affecting numerous other parts of core such as terraform.Hook, the backend.Backend interface, and most of the CLI commands. Just as with 5861dbf3fc49b19587a31816eb06f511ab861bb4 before, I apologize in advance to the person who inevitably just found this huge commit while spelunking through the commit history.
2018-08-14 23:24:45 +02:00
originalState := states.BuildState(func(s *states.SyncState) {
s.SetOutputValue(
addrs.OutputValue{Name: "foo"}.Absolute(addrs.RootModuleInstance),
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"),
}),
}),
false,
)
})
core: Add -json flag to `terraform output` This commit removes the ability to index into complex output types using `terraform output a_list 1` (for example), and adds a `-json` flag to the `terraform output` command, such that the output can be piped through a post-processor such as jq or json. This removes the need to allow arbitrary traversal of nested structures. It also adds tests of human readable ("normal") output with nested lists and maps, and of the new JSON output.
2016-07-13 18:38:19 +02:00
statePath := testStateFile(t, originalState)
ui := new(cli.MockUi)
c := &OutputCommand{
Meta: Meta{
Push plugin discovery down into command package Previously we did plugin discovery in the main package, but as we move towards versioned plugins we need more information available in order to resolve plugins, so we move this responsibility into the command package itself. For the moment this is just preserving the existing behavior as long as there are only internal and unversioned plugins present. This is the final state for provisioners in 0.10, since we don't want to support versioned provisioners yet. For providers this is just a checkpoint along the way, since further work is required to apply version constraints from configuration and support additional plugin search directories. The automatic plugin discovery behavior is not desirable for tests because we want to mock the plugins there, so we add a new backdoor for the tests to use to skip the plugin discovery and just provide their own mock implementations. Most of this diff is thus noisy rework of the tests to use this new mechanism.
2017-04-14 03:05:58 +02:00
testingOverrides: metaOverridesForProvider(testProvider()),
Ui: ui,
core: Add -json flag to `terraform output` This commit removes the ability to index into complex output types using `terraform output a_list 1` (for example), and adds a `-json` flag to the `terraform output` command, such that the output can be piped through a post-processor such as jq or json. This removes the need to allow arbitrary traversal of nested structures. It also adds tests of human readable ("normal") output with nested lists and maps, and of the new JSON output.
2016-07-13 18:38:19 +02:00
},
}
args := []string{
"-state", statePath,
}
if code := c.Run(args); code != 0 {
t.Fatalf("bad: \n%s", ui.ErrorWriter.String())
}
actual := strings.TrimSpace(ui.OutputWriter.String())
repl: Improved value renderer for console outputs Use a slightly modified value renderer from terraform-provider-testing to display values in the console REPL, as well as outputs from the apply and outputs subcommands. Derived from code in this repository, MIT licensed: https://github.com/apparentlymart/terraform-provider-testing Note that this is technically a breaking change for the console subcommand, which would previously error if the user attempted to render an unknown value (such as an unset variable). This was marked as an unintentional side effect, with the goal being the new behaviour of rendering "(unknown)", which is why I changed the behaviour in this commit.
2020-09-09 20:13:53 +02:00
expected := strings.TrimSpace(`
foo = tolist([
tomap({
"key" = "value"
"key2" = "value2"
}),
tomap({
"key" = "value"
}),
])
`)
core: Add -json flag to `terraform output` This commit removes the ability to index into complex output types using `terraform output a_list 1` (for example), and adds a `-json` flag to the `terraform output` command, such that the output can be piped through a post-processor such as jq or json. This removes the need to allow arbitrary traversal of nested structures. It also adds tests of human readable ("normal") output with nested lists and maps, and of the new JSON output.
2016-07-13 18:38:19 +02:00
if actual != expected {
repl: Improved value renderer for console outputs Use a slightly modified value renderer from terraform-provider-testing to display values in the console REPL, as well as outputs from the apply and outputs subcommands. Derived from code in this repository, MIT licensed: https://github.com/apparentlymart/terraform-provider-testing Note that this is technically a breaking change for the console subcommand, which would previously error if the user attempted to render an unknown value (such as an unset variable). This was marked as an unintentional side effect, with the goal being the new behaviour of rendering "(unknown)", which is why I changed the behaviour in this commit.
2020-09-09 20:13:53 +02:00
t.Fatalf("wrong output\ngot: %s\nwant: %s", actual, expected)
core: Add -json flag to `terraform output` This commit removes the ability to index into complex output types using `terraform output a_list 1` (for example), and adds a `-json` flag to the `terraform output` command, such that the output can be piped through a post-processor such as jq or json. This removes the need to allow arbitrary traversal of nested structures. It also adds tests of human readable ("normal") output with nested lists and maps, and of the new JSON output.
2016-07-13 18:38:19 +02:00
}
}
func TestOutput_json(t *testing.T) {
terraform: Ugly huge change to weave in new State and Plan types Due to how often the state and plan types are referenced throughout Terraform, there isn't a great way to switch them out gradually. As a consequence, this huge commit gets us from the old world to a _compilable_ new world, but still has a large number of known test failures due to key functionality being stubbed out. The stubs here are for anything that interacts with providers, since we now need to do the follow-up work to similarly replace the old terraform.ResourceProvider interface with its replacement in the new "providers" package. That work, along with work to fix the remaining failing tests, will follow in subsequent commits. The aim here was to replace all references to terraform.State and its downstream types with states.State, terraform.Plan with plans.Plan, state.State with statemgr.State, and switch to the new implementations of the state and plan file formats. However, due to the number of times those types are used, this also ended up affecting numerous other parts of core such as terraform.Hook, the backend.Backend interface, and most of the CLI commands. Just as with 5861dbf3fc49b19587a31816eb06f511ab861bb4 before, I apologize in advance to the person who inevitably just found this huge commit while spelunking through the commit history.
2018-08-14 23:24:45 +02:00
originalState := states.BuildState(func(s *states.SyncState) {
s.SetOutputValue(
addrs.OutputValue{Name: "foo"}.Absolute(addrs.RootModuleInstance),
cty.StringVal("bar"),
false,
)
})
core: Add -json flag to `terraform output` This commit removes the ability to index into complex output types using `terraform output a_list 1` (for example), and adds a `-json` flag to the `terraform output` command, such that the output can be piped through a post-processor such as jq or json. This removes the need to allow arbitrary traversal of nested structures. It also adds tests of human readable ("normal") output with nested lists and maps, and of the new JSON output.
2016-07-13 18:38:19 +02:00
statePath := testStateFile(t, originalState)
ui := new(cli.MockUi)
c := &OutputCommand{
Meta: Meta{
Push plugin discovery down into command package Previously we did plugin discovery in the main package, but as we move towards versioned plugins we need more information available in order to resolve plugins, so we move this responsibility into the command package itself. For the moment this is just preserving the existing behavior as long as there are only internal and unversioned plugins present. This is the final state for provisioners in 0.10, since we don't want to support versioned provisioners yet. For providers this is just a checkpoint along the way, since further work is required to apply version constraints from configuration and support additional plugin search directories. The automatic plugin discovery behavior is not desirable for tests because we want to mock the plugins there, so we add a new backdoor for the tests to use to skip the plugin discovery and just provide their own mock implementations. Most of this diff is thus noisy rework of the tests to use this new mechanism.
2017-04-14 03:05:58 +02:00
testingOverrides: metaOverridesForProvider(testProvider()),
Ui: ui,
core: Add -json flag to `terraform output` This commit removes the ability to index into complex output types using `terraform output a_list 1` (for example), and adds a `-json` flag to the `terraform output` command, such that the output can be piped through a post-processor such as jq or json. This removes the need to allow arbitrary traversal of nested structures. It also adds tests of human readable ("normal") output with nested lists and maps, and of the new JSON output.
2016-07-13 18:38:19 +02:00
},
}
args := []string{
"-state", statePath,
"-json",
}
if code := c.Run(args); code != 0 {
t.Fatalf("bad: \n%s", ui.ErrorWriter.String())
}
actual := strings.TrimSpace(ui.OutputWriter.String())
command: Restore the "terraform output" functionality We previously stubbed most of this out because it hadn't yet been updated to support the new state types, etc. This restores all of the previous behavior as covered by the tests. We intentionally remove one behavior that was not covered by the tests: we used to allow retrieval of outputs from non-root modules using the -module option, but since we no longer persist non-root outputs in the state we can no longer support this without a full expression evaluation walk, and that'd be overkill for this otherwise-simple command. Descendant module outputs are not part of the public interface of a configuration anyway, so accessing them from outside in this way is an anti-pattern. (For debugging scenarios it is still possible to access these from "terraform console", which _does_ do a full evaluation graph walk to prepare its evaluation scope.)
2018-10-13 18:24:03 +02:00
expected := "{\n \"foo\": {\n \"sensitive\": false,\n \"type\": \"string\",\n \"value\": \"bar\"\n }\n}"
core: Add -json flag to `terraform output` This commit removes the ability to index into complex output types using `terraform output a_list 1` (for example), and adds a `-json` flag to the `terraform output` command, such that the output can be piped through a post-processor such as jq or json. This removes the need to allow arbitrary traversal of nested structures. It also adds tests of human readable ("normal") output with nested lists and maps, and of the new JSON output.
2016-07-13 18:38:19 +02:00
if actual != expected {
command: Restore the "terraform output" functionality We previously stubbed most of this out because it hadn't yet been updated to support the new state types, etc. This restores all of the previous behavior as covered by the tests. We intentionally remove one behavior that was not covered by the tests: we used to allow retrieval of outputs from non-root modules using the -module option, but since we no longer persist non-root outputs in the state we can no longer support this without a full expression evaluation walk, and that'd be overkill for this otherwise-simple command. Descendant module outputs are not part of the public interface of a configuration anyway, so accessing them from outside in this way is an anti-pattern. (For debugging scenarios it is still possible to access these from "terraform console", which _does_ do a full evaluation graph walk to prepare its evaluation scope.)
2018-10-13 18:24:03 +02:00
t.Fatalf("wrong output\ngot: %#v\nwant: %#v", actual, expected)
cli: Remove error on empty outputs when `-json` is set (#11721) - Fixes #11696 - This changes makes `terraform output -json` return '{}' instead of throwing an error about "no outputs defined" - If `-json` is not set, the user will receive an error as before - This UX helps new users to understand how outputs are used - Allows for easier automation of TF CLI as an empty set of outputs is usually acceptable, but any other error from `output` would be re-raised to the user.
2018-06-20 17:58:07 +02:00
}
}
command: Warn instead of error for empty output When the output subcommand is called with no arguments, and there are no outputs to show, we previously rendered an error message but returned a non-error status code. This is confusing. This commit changes the text UI to use a warning diagnostic, which makes it clearer that this is a non-error situation. We do not change the exit code or the text of the warning, so hopefully this is not considered a breaking change.
2020-08-28 17:05:46 +02:00
func TestOutput_emptyOutputs(t *testing.T) {
terraform: Ugly huge change to weave in new State and Plan types Due to how often the state and plan types are referenced throughout Terraform, there isn't a great way to switch them out gradually. As a consequence, this huge commit gets us from the old world to a _compilable_ new world, but still has a large number of known test failures due to key functionality being stubbed out. The stubs here are for anything that interacts with providers, since we now need to do the follow-up work to similarly replace the old terraform.ResourceProvider interface with its replacement in the new "providers" package. That work, along with work to fix the remaining failing tests, will follow in subsequent commits. The aim here was to replace all references to terraform.State and its downstream types with states.State, terraform.Plan with plans.Plan, state.State with statemgr.State, and switch to the new implementations of the state and plan file formats. However, due to the number of times those types are used, this also ended up affecting numerous other parts of core such as terraform.Hook, the backend.Backend interface, and most of the CLI commands. Just as with 5861dbf3fc49b19587a31816eb06f511ab861bb4 before, I apologize in advance to the person who inevitably just found this huge commit while spelunking through the commit history.
2018-08-14 23:24:45 +02:00
originalState := states.NewState()
cli: Remove error on empty outputs when `-json` is set (#11721) - Fixes #11696 - This changes makes `terraform output -json` return '{}' instead of throwing an error about "no outputs defined" - If `-json` is not set, the user will receive an error as before - This UX helps new users to understand how outputs are used - Allows for easier automation of TF CLI as an empty set of outputs is usually acceptable, but any other error from `output` would be re-raised to the user.
2018-06-20 17:58:07 +02:00
statePath := testStateFile(t, originalState)
cli: update tests
2018-06-26 20:57:52 +02:00
p := testProvider()
cli: Remove error on empty outputs when `-json` is set (#11721) - Fixes #11696 - This changes makes `terraform output -json` return '{}' instead of throwing an error about "no outputs defined" - If `-json` is not set, the user will receive an error as before - This UX helps new users to understand how outputs are used - Allows for easier automation of TF CLI as an empty set of outputs is usually acceptable, but any other error from `output` would be re-raised to the user.
2018-06-20 17:58:07 +02:00
ui := new(cli.MockUi)
c := &OutputCommand{
Meta: Meta{
cli: update tests
2018-06-26 20:57:52 +02:00
testingOverrides: metaOverridesForProvider(p),
Ui: ui,
cli: Remove error on empty outputs when `-json` is set (#11721) - Fixes #11696 - This changes makes `terraform output -json` return '{}' instead of throwing an error about "no outputs defined" - If `-json` is not set, the user will receive an error as before - This UX helps new users to understand how outputs are used - Allows for easier automation of TF CLI as an empty set of outputs is usually acceptable, but any other error from `output` would be re-raised to the user.
2018-06-20 17:58:07 +02:00
},
}
args := []string{
"-state", statePath,
}
command/output: Absence of outputs is not an error
2019-11-07 01:26:32 +01:00
if code := c.Run(args); code != 0 {
cli: Remove error on empty outputs when `-json` is set (#11721) - Fixes #11696 - This changes makes `terraform output -json` return '{}' instead of throwing an error about "no outputs defined" - If `-json` is not set, the user will receive an error as before - This UX helps new users to understand how outputs are used - Allows for easier automation of TF CLI as an empty set of outputs is usually acceptable, but any other error from `output` would be re-raised to the user.
2018-06-20 17:58:07 +02:00
t.Fatalf("bad: \n%s", ui.ErrorWriter.String())
}
command: Warn instead of error for empty output When the output subcommand is called with no arguments, and there are no outputs to show, we previously rendered an error message but returned a non-error status code. This is confusing. This commit changes the text UI to use a warning diagnostic, which makes it clearer that this is a non-error situation. We do not change the exit code or the text of the warning, so hopefully this is not considered a breaking change.
2020-08-28 17:05:46 +02:00
if got, want := ui.ErrorWriter.String(), "Warning: No outputs found"; !strings.Contains(got, want) {
t.Fatalf("bad output: expected to contain %q, got:\n%s", want, got)
}
cli: Remove error on empty outputs when `-json` is set (#11721) - Fixes #11696 - This changes makes `terraform output -json` return '{}' instead of throwing an error about "no outputs defined" - If `-json` is not set, the user will receive an error as before - This UX helps new users to understand how outputs are used - Allows for easier automation of TF CLI as an empty set of outputs is usually acceptable, but any other error from `output` would be re-raised to the user.
2018-06-20 17:58:07 +02:00
}
func TestOutput_jsonEmptyOutputs(t *testing.T) {
terraform: Ugly huge change to weave in new State and Plan types Due to how often the state and plan types are referenced throughout Terraform, there isn't a great way to switch them out gradually. As a consequence, this huge commit gets us from the old world to a _compilable_ new world, but still has a large number of known test failures due to key functionality being stubbed out. The stubs here are for anything that interacts with providers, since we now need to do the follow-up work to similarly replace the old terraform.ResourceProvider interface with its replacement in the new "providers" package. That work, along with work to fix the remaining failing tests, will follow in subsequent commits. The aim here was to replace all references to terraform.State and its downstream types with states.State, terraform.Plan with plans.Plan, state.State with statemgr.State, and switch to the new implementations of the state and plan file formats. However, due to the number of times those types are used, this also ended up affecting numerous other parts of core such as terraform.Hook, the backend.Backend interface, and most of the CLI commands. Just as with 5861dbf3fc49b19587a31816eb06f511ab861bb4 before, I apologize in advance to the person who inevitably just found this huge commit while spelunking through the commit history.
2018-08-14 23:24:45 +02:00
originalState := states.NewState()
cli: Remove error on empty outputs when `-json` is set (#11721) - Fixes #11696 - This changes makes `terraform output -json` return '{}' instead of throwing an error about "no outputs defined" - If `-json` is not set, the user will receive an error as before - This UX helps new users to understand how outputs are used - Allows for easier automation of TF CLI as an empty set of outputs is usually acceptable, but any other error from `output` would be re-raised to the user.
2018-06-20 17:58:07 +02:00
statePath := testStateFile(t, originalState)
cli: update tests
2018-06-26 20:57:52 +02:00
p := testProvider()
cli: Remove error on empty outputs when `-json` is set (#11721) - Fixes #11696 - This changes makes `terraform output -json` return '{}' instead of throwing an error about "no outputs defined" - If `-json` is not set, the user will receive an error as before - This UX helps new users to understand how outputs are used - Allows for easier automation of TF CLI as an empty set of outputs is usually acceptable, but any other error from `output` would be re-raised to the user.
2018-06-20 17:58:07 +02:00
ui := new(cli.MockUi)
c := &OutputCommand{
Meta: Meta{
cli: update tests
2018-06-26 20:57:52 +02:00
testingOverrides: metaOverridesForProvider(p),
Ui: ui,
cli: Remove error on empty outputs when `-json` is set (#11721) - Fixes #11696 - This changes makes `terraform output -json` return '{}' instead of throwing an error about "no outputs defined" - If `-json` is not set, the user will receive an error as before - This UX helps new users to understand how outputs are used - Allows for easier automation of TF CLI as an empty set of outputs is usually acceptable, but any other error from `output` would be re-raised to the user.
2018-06-20 17:58:07 +02:00
},
}
args := []string{
"-state", statePath,
"-json",
}
if code := c.Run(args); code != 0 {
t.Fatalf("bad: \n%s", ui.ErrorWriter.String())
}
actual := strings.TrimSpace(ui.OutputWriter.String())
expected := "{}"
if actual != expected {
core: Add -json flag to `terraform output` This commit removes the ability to index into complex output types using `terraform output a_list 1` (for example), and adds a `-json` flag to the `terraform output` command, such that the output can be piped through a post-processor such as jq or json. This removes the need to allow arbitrary traversal of nested structures. It also adds tests of human readable ("normal") output with nested lists and maps, and of the new JSON output.
2016-07-13 18:38:19 +02:00
t.Fatalf("bad:\n%#v\n%#v", expected, actual)
}
}
Add module outputs
2015-05-27 16:46:12 +02:00
func TestMissingModuleOutput(t *testing.T) {
terraform: Ugly huge change to weave in new State and Plan types Due to how often the state and plan types are referenced throughout Terraform, there isn't a great way to switch them out gradually. As a consequence, this huge commit gets us from the old world to a _compilable_ new world, but still has a large number of known test failures due to key functionality being stubbed out. The stubs here are for anything that interacts with providers, since we now need to do the follow-up work to similarly replace the old terraform.ResourceProvider interface with its replacement in the new "providers" package. That work, along with work to fix the remaining failing tests, will follow in subsequent commits. The aim here was to replace all references to terraform.State and its downstream types with states.State, terraform.Plan with plans.Plan, state.State with statemgr.State, and switch to the new implementations of the state and plan file formats. However, due to the number of times those types are used, this also ended up affecting numerous other parts of core such as terraform.Hook, the backend.Backend interface, and most of the CLI commands. Just as with 5861dbf3fc49b19587a31816eb06f511ab861bb4 before, I apologize in advance to the person who inevitably just found this huge commit while spelunking through the commit history.
2018-08-14 23:24:45 +02:00
originalState := states.BuildState(func(s *states.SyncState) {
s.SetOutputValue(
addrs.OutputValue{Name: "foo"}.Absolute(addrs.RootModuleInstance),
cty.StringVal("bar"),
false,
)
})
Add module outputs
2015-05-27 16:46:12 +02:00
statePath := testStateFile(t, originalState)
ui := new(cli.MockUi)
c := &OutputCommand{
Meta: Meta{
Push plugin discovery down into command package Previously we did plugin discovery in the main package, but as we move towards versioned plugins we need more information available in order to resolve plugins, so we move this responsibility into the command package itself. For the moment this is just preserving the existing behavior as long as there are only internal and unversioned plugins present. This is the final state for provisioners in 0.10, since we don't want to support versioned provisioners yet. For providers this is just a checkpoint along the way, since further work is required to apply version constraints from configuration and support additional plugin search directories. The automatic plugin discovery behavior is not desirable for tests because we want to mock the plugins there, so we add a new backdoor for the tests to use to skip the plugin discovery and just provide their own mock implementations. Most of this diff is thus noisy rework of the tests to use this new mechanism.
2017-04-14 03:05:58 +02:00
testingOverrides: metaOverridesForProvider(testProvider()),
Ui: ui,
Add module outputs
2015-05-27 16:46:12 +02:00
},
}
args := []string{
"-state", statePath,
"-module", "not_existing_module",
"blah",
}
if code := c.Run(args); code != 1 {
t.Fatalf("bad: \n%s", ui.ErrorWriter.String())
}
}
comand/output
2014-07-13 19:25:42 +02:00
func TestOutput_badVar(t *testing.T) {
terraform: Ugly huge change to weave in new State and Plan types Due to how often the state and plan types are referenced throughout Terraform, there isn't a great way to switch them out gradually. As a consequence, this huge commit gets us from the old world to a _compilable_ new world, but still has a large number of known test failures due to key functionality being stubbed out. The stubs here are for anything that interacts with providers, since we now need to do the follow-up work to similarly replace the old terraform.ResourceProvider interface with its replacement in the new "providers" package. That work, along with work to fix the remaining failing tests, will follow in subsequent commits. The aim here was to replace all references to terraform.State and its downstream types with states.State, terraform.Plan with plans.Plan, state.State with statemgr.State, and switch to the new implementations of the state and plan file formats. However, due to the number of times those types are used, this also ended up affecting numerous other parts of core such as terraform.Hook, the backend.Backend interface, and most of the CLI commands. Just as with 5861dbf3fc49b19587a31816eb06f511ab861bb4 before, I apologize in advance to the person who inevitably just found this huge commit while spelunking through the commit history.
2018-08-14 23:24:45 +02:00
originalState := states.BuildState(func(s *states.SyncState) {
s.SetOutputValue(
addrs.OutputValue{Name: "foo"}.Absolute(addrs.RootModuleInstance),
cty.StringVal("bar"),
false,
)
})
comand/output
2014-07-13 19:25:42 +02:00
statePath := testStateFile(t, originalState)
ui := new(cli.MockUi)
c := &OutputCommand{
Meta: Meta{
Push plugin discovery down into command package Previously we did plugin discovery in the main package, but as we move towards versioned plugins we need more information available in order to resolve plugins, so we move this responsibility into the command package itself. For the moment this is just preserving the existing behavior as long as there are only internal and unversioned plugins present. This is the final state for provisioners in 0.10, since we don't want to support versioned provisioners yet. For providers this is just a checkpoint along the way, since further work is required to apply version constraints from configuration and support additional plugin search directories. The automatic plugin discovery behavior is not desirable for tests because we want to mock the plugins there, so we add a new backdoor for the tests to use to skip the plugin discovery and just provide their own mock implementations. Most of this diff is thus noisy rework of the tests to use this new mechanism.
2017-04-14 03:05:58 +02:00
testingOverrides: metaOverridesForProvider(testProvider()),
Ui: ui,
comand/output
2014-07-13 19:25:42 +02:00
},
}
args := []string{
"-state", statePath,
"bar",
}
if code := c.Run(args); code != 1 {
t.Fatalf("bad: \n%s", ui.ErrorWriter.String())
}
}
command/output: protect againts blank params
2014-07-13 19:29:31 +02:00
func TestOutput_blank(t *testing.T) {
terraform: Ugly huge change to weave in new State and Plan types Due to how often the state and plan types are referenced throughout Terraform, there isn't a great way to switch them out gradually. As a consequence, this huge commit gets us from the old world to a _compilable_ new world, but still has a large number of known test failures due to key functionality being stubbed out. The stubs here are for anything that interacts with providers, since we now need to do the follow-up work to similarly replace the old terraform.ResourceProvider interface with its replacement in the new "providers" package. That work, along with work to fix the remaining failing tests, will follow in subsequent commits. The aim here was to replace all references to terraform.State and its downstream types with states.State, terraform.Plan with plans.Plan, state.State with statemgr.State, and switch to the new implementations of the state and plan file formats. However, due to the number of times those types are used, this also ended up affecting numerous other parts of core such as terraform.Hook, the backend.Backend interface, and most of the CLI commands. Just as with 5861dbf3fc49b19587a31816eb06f511ab861bb4 before, I apologize in advance to the person who inevitably just found this huge commit while spelunking through the commit history.
2018-08-14 23:24:45 +02:00
originalState := states.BuildState(func(s *states.SyncState) {
s.SetOutputValue(
addrs.OutputValue{Name: "foo"}.Absolute(addrs.RootModuleInstance),
cty.StringVal("bar"),
false,
)
s.SetOutputValue(
addrs.OutputValue{Name: "name"}.Absolute(addrs.RootModuleInstance),
cty.StringVal("john-doe"),
false,
)
})
command/output: protect againts blank params
2014-07-13 19:29:31 +02:00
statePath := testStateFile(t, originalState)
ui := new(cli.MockUi)
c := &OutputCommand{
Meta: Meta{
Push plugin discovery down into command package Previously we did plugin discovery in the main package, but as we move towards versioned plugins we need more information available in order to resolve plugins, so we move this responsibility into the command package itself. For the moment this is just preserving the existing behavior as long as there are only internal and unversioned plugins present. This is the final state for provisioners in 0.10, since we don't want to support versioned provisioners yet. For providers this is just a checkpoint along the way, since further work is required to apply version constraints from configuration and support additional plugin search directories. The automatic plugin discovery behavior is not desirable for tests because we want to mock the plugins there, so we add a new backdoor for the tests to use to skip the plugin discovery and just provide their own mock implementations. Most of this diff is thus noisy rework of the tests to use this new mechanism.
2017-04-14 03:05:58 +02:00
testingOverrides: metaOverridesForProvider(testProvider()),
Ui: ui,
command/output: protect againts blank params
2014-07-13 19:29:31 +02:00
},
}
args := []string{
"-state", statePath,
"",
}
command/output: Update test since we now allow printing everything
2015-08-03 13:44:41 +02:00
if code := c.Run(args); code != 0 {
command/output: protect againts blank params
2014-07-13 19:29:31 +02:00
t.Fatalf("bad: \n%s", ui.ErrorWriter.String())
}
command/output: Update test since we now allow printing everything
2015-08-03 13:44:41 +02:00
repl: Improved value renderer for console outputs Use a slightly modified value renderer from terraform-provider-testing to display values in the console REPL, as well as outputs from the apply and outputs subcommands. Derived from code in this repository, MIT licensed: https://github.com/apparentlymart/terraform-provider-testing Note that this is technically a breaking change for the console subcommand, which would previously error if the user attempted to render an unknown value (such as an unset variable). This was marked as an unintentional side effect, with the goal being the new behaviour of rendering "(unknown)", which is why I changed the behaviour in this commit.
2020-09-09 20:13:53 +02:00
expectedOutput := "foo = \"bar\"\nname = \"john-doe\"\n"
command/output: Update test since we now allow printing everything
2015-08-03 13:44:41 +02:00
output := ui.OutputWriter.String()
if output != expectedOutput {
command: Restore the "terraform output" functionality We previously stubbed most of this out because it hadn't yet been updated to support the new state types, etc. This restores all of the previous behavior as covered by the tests. We intentionally remove one behavior that was not covered by the tests: we used to allow retrieval of outputs from non-root modules using the -module option, but since we no longer persist non-root outputs in the state we can no longer support this without a full expression evaluation walk, and that'd be overkill for this otherwise-simple command. Descendant module outputs are not part of the public interface of a configuration anyway, so accessing them from outside in this way is an anti-pattern. (For debugging scenarios it is still possible to access these from "terraform console", which _does_ do a full evaluation graph walk to prepare its evaluation scope.)
2018-10-13 18:24:03 +02:00
t.Fatalf("wrong output\ngot: %#v\nwant: %#v", output, expectedOutput)
command/output: Update test since we now allow printing everything
2015-08-03 13:44:41 +02:00
}
command/output: protect againts blank params
2014-07-13 19:29:31 +02:00
}
comand/output
2014-07-13 19:25:42 +02:00
func TestOutput_manyArgs(t *testing.T) {
ui := new(cli.MockUi)
c := &OutputCommand{
Meta: Meta{
Push plugin discovery down into command package Previously we did plugin discovery in the main package, but as we move towards versioned plugins we need more information available in order to resolve plugins, so we move this responsibility into the command package itself. For the moment this is just preserving the existing behavior as long as there are only internal and unversioned plugins present. This is the final state for provisioners in 0.10, since we don't want to support versioned provisioners yet. For providers this is just a checkpoint along the way, since further work is required to apply version constraints from configuration and support additional plugin search directories. The automatic plugin discovery behavior is not desirable for tests because we want to mock the plugins there, so we add a new backdoor for the tests to use to skip the plugin discovery and just provide their own mock implementations. Most of this diff is thus noisy rework of the tests to use this new mechanism.
2017-04-14 03:05:58 +02:00
testingOverrides: metaOverridesForProvider(testProvider()),
Ui: ui,
comand/output
2014-07-13 19:25:42 +02:00
},
}
args := []string{
"bad",
"bad",
}
if code := c.Run(args); code != 1 {
t.Fatalf("bad: \n%s", ui.OutputWriter.String())
}
}
func TestOutput_noArgs(t *testing.T) {
ui := new(cli.MockUi)
c := &OutputCommand{
Meta: Meta{
Push plugin discovery down into command package Previously we did plugin discovery in the main package, but as we move towards versioned plugins we need more information available in order to resolve plugins, so we move this responsibility into the command package itself. For the moment this is just preserving the existing behavior as long as there are only internal and unversioned plugins present. This is the final state for provisioners in 0.10, since we don't want to support versioned provisioners yet. For providers this is just a checkpoint along the way, since further work is required to apply version constraints from configuration and support additional plugin search directories. The automatic plugin discovery behavior is not desirable for tests because we want to mock the plugins there, so we add a new backdoor for the tests to use to skip the plugin discovery and just provide their own mock implementations. Most of this diff is thus noisy rework of the tests to use this new mechanism.
2017-04-14 03:05:58 +02:00
testingOverrides: metaOverridesForProvider(testProvider()),
Ui: ui,
comand/output
2014-07-13 19:25:42 +02:00
},
}
args := []string{}
command/output: Absence of outputs is not an error
2019-11-07 01:26:32 +01:00
if code := c.Run(args); code != 0 {
comand/output
2014-07-13 19:25:42 +02:00
t.Fatalf("bad: \n%s", ui.OutputWriter.String())
}
}
command/output: don't panic if no root module in state [GH-1263]
2015-03-26 00:35:27 +01:00
func TestOutput_noState(t *testing.T) {
terraform: Ugly huge change to weave in new State and Plan types Due to how often the state and plan types are referenced throughout Terraform, there isn't a great way to switch them out gradually. As a consequence, this huge commit gets us from the old world to a _compilable_ new world, but still has a large number of known test failures due to key functionality being stubbed out. The stubs here are for anything that interacts with providers, since we now need to do the follow-up work to similarly replace the old terraform.ResourceProvider interface with its replacement in the new "providers" package. That work, along with work to fix the remaining failing tests, will follow in subsequent commits. The aim here was to replace all references to terraform.State and its downstream types with states.State, terraform.Plan with plans.Plan, state.State with statemgr.State, and switch to the new implementations of the state and plan file formats. However, due to the number of times those types are used, this also ended up affecting numerous other parts of core such as terraform.Hook, the backend.Backend interface, and most of the CLI commands. Just as with 5861dbf3fc49b19587a31816eb06f511ab861bb4 before, I apologize in advance to the person who inevitably just found this huge commit while spelunking through the commit history.
2018-08-14 23:24:45 +02:00
originalState := states.NewState()
command/output: don't panic if no root module in state [GH-1263]
2015-03-26 00:35:27 +01:00
statePath := testStateFile(t, originalState)
ui := new(cli.MockUi)
c := &OutputCommand{
Meta: Meta{
Push plugin discovery down into command package Previously we did plugin discovery in the main package, but as we move towards versioned plugins we need more information available in order to resolve plugins, so we move this responsibility into the command package itself. For the moment this is just preserving the existing behavior as long as there are only internal and unversioned plugins present. This is the final state for provisioners in 0.10, since we don't want to support versioned provisioners yet. For providers this is just a checkpoint along the way, since further work is required to apply version constraints from configuration and support additional plugin search directories. The automatic plugin discovery behavior is not desirable for tests because we want to mock the plugins there, so we add a new backdoor for the tests to use to skip the plugin discovery and just provide their own mock implementations. Most of this diff is thus noisy rework of the tests to use this new mechanism.
2017-04-14 03:05:58 +02:00
testingOverrides: metaOverridesForProvider(testProvider()),
Ui: ui,
command/output: don't panic if no root module in state [GH-1263]
2015-03-26 00:35:27 +01:00
},
}
args := []string{
"-state", statePath,
"foo",
}
command/output: Absence of outputs is not an error
2019-11-07 01:26:32 +01:00
if code := c.Run(args); code != 0 {
command/output: don't panic if no root module in state [GH-1263]
2015-03-26 00:35:27 +01:00
t.Fatalf("bad: \n%s", ui.ErrorWriter.String())
}
}
comand/output
2014-07-13 19:25:42 +02:00
func TestOutput_noVars(t *testing.T) {
terraform: Ugly huge change to weave in new State and Plan types Due to how often the state and plan types are referenced throughout Terraform, there isn't a great way to switch them out gradually. As a consequence, this huge commit gets us from the old world to a _compilable_ new world, but still has a large number of known test failures due to key functionality being stubbed out. The stubs here are for anything that interacts with providers, since we now need to do the follow-up work to similarly replace the old terraform.ResourceProvider interface with its replacement in the new "providers" package. That work, along with work to fix the remaining failing tests, will follow in subsequent commits. The aim here was to replace all references to terraform.State and its downstream types with states.State, terraform.Plan with plans.Plan, state.State with statemgr.State, and switch to the new implementations of the state and plan file formats. However, due to the number of times those types are used, this also ended up affecting numerous other parts of core such as terraform.Hook, the backend.Backend interface, and most of the CLI commands. Just as with 5861dbf3fc49b19587a31816eb06f511ab861bb4 before, I apologize in advance to the person who inevitably just found this huge commit while spelunking through the commit history.
2018-08-14 23:24:45 +02:00
originalState := states.NewState()
comand/output
2014-07-13 19:25:42 +02:00
statePath := testStateFile(t, originalState)
ui := new(cli.MockUi)
c := &OutputCommand{
Meta: Meta{
Push plugin discovery down into command package Previously we did plugin discovery in the main package, but as we move towards versioned plugins we need more information available in order to resolve plugins, so we move this responsibility into the command package itself. For the moment this is just preserving the existing behavior as long as there are only internal and unversioned plugins present. This is the final state for provisioners in 0.10, since we don't want to support versioned provisioners yet. For providers this is just a checkpoint along the way, since further work is required to apply version constraints from configuration and support additional plugin search directories. The automatic plugin discovery behavior is not desirable for tests because we want to mock the plugins there, so we add a new backdoor for the tests to use to skip the plugin discovery and just provide their own mock implementations. Most of this diff is thus noisy rework of the tests to use this new mechanism.
2017-04-14 03:05:58 +02:00
testingOverrides: metaOverridesForProvider(testProvider()),
Ui: ui,
comand/output
2014-07-13 19:25:42 +02:00
},
}
args := []string{
"-state", statePath,
"bar",
}
command/output: Absence of outputs is not an error
2019-11-07 01:26:32 +01:00
if code := c.Run(args); code != 0 {
comand/output
2014-07-13 19:25:42 +02:00
t.Fatalf("bad: \n%s", ui.ErrorWriter.String())
}
}
func TestOutput_stateDefault(t *testing.T) {
terraform: Ugly huge change to weave in new State and Plan types Due to how often the state and plan types are referenced throughout Terraform, there isn't a great way to switch them out gradually. As a consequence, this huge commit gets us from the old world to a _compilable_ new world, but still has a large number of known test failures due to key functionality being stubbed out. The stubs here are for anything that interacts with providers, since we now need to do the follow-up work to similarly replace the old terraform.ResourceProvider interface with its replacement in the new "providers" package. That work, along with work to fix the remaining failing tests, will follow in subsequent commits. The aim here was to replace all references to terraform.State and its downstream types with states.State, terraform.Plan with plans.Plan, state.State with statemgr.State, and switch to the new implementations of the state and plan file formats. However, due to the number of times those types are used, this also ended up affecting numerous other parts of core such as terraform.Hook, the backend.Backend interface, and most of the CLI commands. Just as with 5861dbf3fc49b19587a31816eb06f511ab861bb4 before, I apologize in advance to the person who inevitably just found this huge commit while spelunking through the commit history.
2018-08-14 23:24:45 +02:00
originalState := states.BuildState(func(s *states.SyncState) {
s.SetOutputValue(
addrs.OutputValue{Name: "foo"}.Absolute(addrs.RootModuleInstance),
cty.StringVal("bar"),
false,
)
})
comand/output
2014-07-13 19:25:42 +02:00
// Write the state file in a temporary directory with the
// default filename.
cleanup temp files from command tests Rather than try to modify all the hundreds of calls to the temp helper functions, and cleanup the temp files at every call site, have all tests work within a single temp directory that is removed at the end of TestMain.
2018-03-28 19:08:38 +02:00
td := testTempDir(t)
comand/output
2014-07-13 19:25:42 +02:00
statePath := filepath.Join(td, DefaultStateFilename)
f, err := os.Create(statePath)
if err != nil {
t.Fatalf("err: %s", err)
}
terraform: Ugly huge change to weave in new State and Plan types Due to how often the state and plan types are referenced throughout Terraform, there isn't a great way to switch them out gradually. As a consequence, this huge commit gets us from the old world to a _compilable_ new world, but still has a large number of known test failures due to key functionality being stubbed out. The stubs here are for anything that interacts with providers, since we now need to do the follow-up work to similarly replace the old terraform.ResourceProvider interface with its replacement in the new "providers" package. That work, along with work to fix the remaining failing tests, will follow in subsequent commits. The aim here was to replace all references to terraform.State and its downstream types with states.State, terraform.Plan with plans.Plan, state.State with statemgr.State, and switch to the new implementations of the state and plan file formats. However, due to the number of times those types are used, this also ended up affecting numerous other parts of core such as terraform.Hook, the backend.Backend interface, and most of the CLI commands. Just as with 5861dbf3fc49b19587a31816eb06f511ab861bb4 before, I apologize in advance to the person who inevitably just found this huge commit while spelunking through the commit history.
2018-08-14 23:24:45 +02:00
err = writeStateForTesting(originalState, f)
comand/output
2014-07-13 19:25:42 +02:00
f.Close()
if err != nil {
t.Fatalf("err: %s", err)
}
// Change to that directory
cwd, err := os.Getwd()
if err != nil {
t.Fatalf("err: %s", err)
}
if err := os.Chdir(filepath.Dir(statePath)); err != nil {
t.Fatalf("err: %s", err)
}
defer os.Chdir(cwd)
ui := new(cli.MockUi)
c := &OutputCommand{
Meta: Meta{
Push plugin discovery down into command package Previously we did plugin discovery in the main package, but as we move towards versioned plugins we need more information available in order to resolve plugins, so we move this responsibility into the command package itself. For the moment this is just preserving the existing behavior as long as there are only internal and unversioned plugins present. This is the final state for provisioners in 0.10, since we don't want to support versioned provisioners yet. For providers this is just a checkpoint along the way, since further work is required to apply version constraints from configuration and support additional plugin search directories. The automatic plugin discovery behavior is not desirable for tests because we want to mock the plugins there, so we add a new backdoor for the tests to use to skip the plugin discovery and just provide their own mock implementations. Most of this diff is thus noisy rework of the tests to use this new mechanism.
2017-04-14 03:05:58 +02:00
testingOverrides: metaOverridesForProvider(testProvider()),
Ui: ui,
comand/output
2014-07-13 19:25:42 +02:00
},
}
args := []string{
"foo",
}
if code := c.Run(args); code != 0 {
t.Fatalf("bad: \n%s", ui.ErrorWriter.String())
}
actual := strings.TrimSpace(ui.OutputWriter.String())
repl: Improved value renderer for console outputs Use a slightly modified value renderer from terraform-provider-testing to display values in the console REPL, as well as outputs from the apply and outputs subcommands. Derived from code in this repository, MIT licensed: https://github.com/apparentlymart/terraform-provider-testing Note that this is technically a breaking change for the console subcommand, which would previously error if the user attempted to render an unknown value (such as an unset variable). This was marked as an unintentional side effect, with the goal being the new behaviour of rendering "(unknown)", which is why I changed the behaviour in this commit.
2020-09-09 20:13:53 +02:00
if actual != `"bar"` {
comand/output
2014-07-13 19:25:42 +02:00
t.Fatalf("bad: %#v", actual)
}
}