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

879 lines
20 KiB
Go
Raw Normal View History

core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
package terraform
import (
"fmt"
"strings"
"testing"
)
config: count can't be a SimpleVariable
2016-08-16 22:48:12 +02:00
func TestContext2Validate_badCount(t *testing.T) {
p := testProvider("aws")
m := testModule(t, "validate-bad-count")
c := testContext2(t, &ContextOpts{
Module: m,
Update tests for the new ProviderResolver interface Rather than providing an already-resolved map of plugins to core, we now provide a "provider resolver" which knows how to resolve a set of provider dependencies, to be determined later, and produce that map. This requires the context to be instantiated in a different way, so this very noisy diff is a mostly-mechanical update of all of the existing places where contexts get created for testing, using some adapted versions of the pre-existing utilities for passing in mock providers.
2017-04-22 02:40:46 +02:00
ProviderResolver: ResourceProviderResolverFixed(
map[string]ResourceProviderFactory{
"aws": testProviderFuncFixed(p),
},
),
config: count can't be a SimpleVariable
2016-08-16 22:48:12 +02:00
})
return tfdiags.Diagnostics from validation methods Validation is the best time to return detailed diagnostics to the user since we're much more likely to have source location information, etc than we are in later operations. This change doesn't actually add any detail to the messages yet, but it changes the interface so that we can gradually introduce more detailed diagnostics over time. While here there are some minor adjustments to some of the messages to improve their consistency with terminology we use elsewhere.
2017-11-22 00:08:00 +01:00
diags := c.Validate()
if !diags.HasErrors() {
t.Fatalf("bad: %#v", diags)
config: count can't be a SimpleVariable
2016-08-16 22:48:12 +02:00
}
}
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
func TestContext2Validate_badVar(t *testing.T) {
p := testProvider("aws")
m := testModule(t, "validate-bad-var")
c := testContext2(t, &ContextOpts{
Module: m,
Update tests for the new ProviderResolver interface Rather than providing an already-resolved map of plugins to core, we now provide a "provider resolver" which knows how to resolve a set of provider dependencies, to be determined later, and produce that map. This requires the context to be instantiated in a different way, so this very noisy diff is a mostly-mechanical update of all of the existing places where contexts get created for testing, using some adapted versions of the pre-existing utilities for passing in mock providers.
2017-04-22 02:40:46 +02:00
ProviderResolver: ResourceProviderResolverFixed(
map[string]ResourceProviderFactory{
"aws": testProviderFuncFixed(p),
},
),
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
})
return tfdiags.Diagnostics from validation methods Validation is the best time to return detailed diagnostics to the user since we're much more likely to have source location information, etc than we are in later operations. This change doesn't actually add any detail to the messages yet, but it changes the interface so that we can gradually introduce more detailed diagnostics over time. While here there are some minor adjustments to some of the messages to improve their consistency with terminology we use elsewhere.
2017-11-22 00:08:00 +01:00
diags := c.Validate()
if !diags.HasErrors() {
t.Fatalf("bad: %#v", diags)
core: Support explicit variable type declaration This commit adds support for declaring variable types in Terraform configuration. Historically, the type has been inferred from the default value, defaulting to string if no default was supplied. This has caused users to devise workarounds if they wanted to declare a map but provide values from a .tfvars file (for example). The new syntax adds the "type" key to variable blocks: ``` variable "i_am_a_string" { type = "string" } variable "i_am_a_map" { type = "map" } ``` This commit does _not_ extend the type system to include bools, integers or floats - the only two types available are maps and strings. Validation is performed if a default value is provided in order to ensure that the default value type matches the declared type. In the case that a type is not declared, the old logic is used for determining the type. This allows backwards compatiblity with previous Terraform configuration.
2016-01-21 20:33:16 +01:00
}
}
terraform: user friendly error when using old map overrides Related to #8036 We have had this behavior for a _long_ time now (since 0.7.0) but it seems people are still periodically getting bit by it. This adds an explicit error message that explains that this kind of override isn't allowed anymore.
2016-12-09 21:58:24 +01:00
func TestContext2Validate_varMapOverrideOld(t *testing.T) {
m := testModule(t, "validate-module-pc-vars")
p := testProvider("aws")
c := testContext2(t, &ContextOpts{
Module: m,
Update tests for the new ProviderResolver interface Rather than providing an already-resolved map of plugins to core, we now provide a "provider resolver" which knows how to resolve a set of provider dependencies, to be determined later, and produce that map. This requires the context to be instantiated in a different way, so this very noisy diff is a mostly-mechanical update of all of the existing places where contexts get created for testing, using some adapted versions of the pre-existing utilities for passing in mock providers.
2017-04-22 02:40:46 +02:00
ProviderResolver: ResourceProviderResolverFixed(
map[string]ResourceProviderFactory{
"aws": testProviderFuncFixed(p),
},
),
terraform: user friendly error when using old map overrides Related to #8036 We have had this behavior for a _long_ time now (since 0.7.0) but it seems people are still periodically getting bit by it. This adds an explicit error message that explains that this kind of override isn't allowed anymore.
2016-12-09 21:58:24 +01:00
Variables: map[string]interface{}{
"foo.foo": "bar",
},
})
return tfdiags.Diagnostics from validation methods Validation is the best time to return detailed diagnostics to the user since we're much more likely to have source location information, etc than we are in later operations. This change doesn't actually add any detail to the messages yet, but it changes the interface so that we can gradually introduce more detailed diagnostics over time. While here there are some minor adjustments to some of the messages to improve their consistency with terminology we use elsewhere.
2017-11-22 00:08:00 +01:00
diags := c.Validate()
if !diags.HasErrors() {
t.Fatalf("bad: %#v", diags)
terraform: user friendly error when using old map overrides Related to #8036 We have had this behavior for a _long_ time now (since 0.7.0) but it seems people are still periodically getting bit by it. This adds an explicit error message that explains that this kind of override isn't allowed anymore.
2016-12-09 21:58:24 +01:00
}
}
core: Support explicit variable type declaration This commit adds support for declaring variable types in Terraform configuration. Historically, the type has been inferred from the default value, defaulting to string if no default was supplied. This has caused users to devise workarounds if they wanted to declare a map but provide values from a .tfvars file (for example). The new syntax adds the "type" key to variable blocks: ``` variable "i_am_a_string" { type = "string" } variable "i_am_a_map" { type = "map" } ``` This commit does _not_ extend the type system to include bools, integers or floats - the only two types available are maps and strings. Validation is performed if a default value is provided in order to ensure that the default value type matches the declared type. In the case that a type is not declared, the old logic is used for determining the type. This allows backwards compatiblity with previous Terraform configuration.
2016-01-21 20:33:16 +01:00
func TestContext2Validate_varNoDefaultExplicitType(t *testing.T) {
m := testModule(t, "validate-var-no-default-explicit-type")
c := testContext2(t, &ContextOpts{
Module: m,
})
return tfdiags.Diagnostics from validation methods Validation is the best time to return detailed diagnostics to the user since we're much more likely to have source location information, etc than we are in later operations. This change doesn't actually add any detail to the messages yet, but it changes the interface so that we can gradually introduce more detailed diagnostics over time. While here there are some minor adjustments to some of the messages to improve their consistency with terminology we use elsewhere.
2017-11-22 00:08:00 +01:00
diags := c.Validate()
if !diags.HasErrors() {
t.Fatalf("bad: %#v", diags)
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
}
}
func TestContext2Validate_computedVar(t *testing.T) {
p := testProvider("aws")
m := testModule(t, "validate-computed-var")
c := testContext2(t, &ContextOpts{
Module: m,
Update tests for the new ProviderResolver interface Rather than providing an already-resolved map of plugins to core, we now provide a "provider resolver" which knows how to resolve a set of provider dependencies, to be determined later, and produce that map. This requires the context to be instantiated in a different way, so this very noisy diff is a mostly-mechanical update of all of the existing places where contexts get created for testing, using some adapted versions of the pre-existing utilities for passing in mock providers.
2017-04-22 02:40:46 +02:00
ProviderResolver: ResourceProviderResolverFixed(
map[string]ResourceProviderFactory{
"aws": testProviderFuncFixed(p),
"test": testProviderFuncFixed(testProvider("test")),
},
),
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
})
p.ValidateFn = func(c *ResourceConfig) ([]string, []error) {
if !c.IsComputed("value") {
return nil, []error{fmt.Errorf("value isn't computed")}
}
return nil, c.CheckSet([]string{"value"})
}
p.ConfigureFn = func(c *ResourceConfig) error {
return fmt.Errorf("Configure should not be called for provider")
}
return tfdiags.Diagnostics from validation methods Validation is the best time to return detailed diagnostics to the user since we're much more likely to have source location information, etc than we are in later operations. This change doesn't actually add any detail to the messages yet, but it changes the interface so that we can gradually introduce more detailed diagnostics over time. While here there are some minor adjustments to some of the messages to improve their consistency with terminology we use elsewhere.
2017-11-22 00:08:00 +01:00
diags := c.Validate()
if diags.HasErrors() {
t.Fatalf("bad: %#v", diags)
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
}
}
terraform: don't validate computed values in validate This disables the computed value check for `count` during the validation pass. This enables partial support for #3888 or #1497: as long as the value is non-computed during the plan, complex values will work in counts. **Notably, this allows data source values to be present in counts!** The "count" value can be disabled during validation safely because we can treat it as if any field that uses `count.index` is computed for validation. We then validate a single instance (as if `count = 1`) just to make sure all required fields are set.
2017-01-28 06:15:43 +01:00
// Test that validate allows through computed counts. We do this and allow
// them to fail during "plan" since we can't know if the computed values
// can be realized during a plan.
func TestContext2Validate_countComputed(t *testing.T) {
p := testProvider("aws")
m := testModule(t, "validate-count-computed")
c := testContext2(t, &ContextOpts{
Module: m,
Update tests for the new ProviderResolver interface Rather than providing an already-resolved map of plugins to core, we now provide a "provider resolver" which knows how to resolve a set of provider dependencies, to be determined later, and produce that map. This requires the context to be instantiated in a different way, so this very noisy diff is a mostly-mechanical update of all of the existing places where contexts get created for testing, using some adapted versions of the pre-existing utilities for passing in mock providers.
2017-04-22 02:40:46 +02:00
ProviderResolver: ResourceProviderResolverFixed(
map[string]ResourceProviderFactory{
"aws": testProviderFuncFixed(p),
},
),
terraform: don't validate computed values in validate This disables the computed value check for `count` during the validation pass. This enables partial support for #3888 or #1497: as long as the value is non-computed during the plan, complex values will work in counts. **Notably, this allows data source values to be present in counts!** The "count" value can be disabled during validation safely because we can treat it as if any field that uses `count.index` is computed for validation. We then validate a single instance (as if `count = 1`) just to make sure all required fields are set.
2017-01-28 06:15:43 +01:00
})
return tfdiags.Diagnostics from validation methods Validation is the best time to return detailed diagnostics to the user since we're much more likely to have source location information, etc than we are in later operations. This change doesn't actually add any detail to the messages yet, but it changes the interface so that we can gradually introduce more detailed diagnostics over time. While here there are some minor adjustments to some of the messages to improve their consistency with terminology we use elsewhere.
2017-11-22 00:08:00 +01:00
diags := c.Validate()
if diags.HasErrors() {
t.Fatalf("bad: %#v", diags)
terraform: don't validate computed values in validate This disables the computed value check for `count` during the validation pass. This enables partial support for #3888 or #1497: as long as the value is non-computed during the plan, complex values will work in counts. **Notably, this allows data source values to be present in counts!** The "count" value can be disabled during validation safely because we can treat it as if any field that uses `count.index` is computed for validation. We then validate a single instance (as if `count = 1`) just to make sure all required fields are set.
2017-01-28 06:15:43 +01:00
}
}
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
func TestContext2Validate_countNegative(t *testing.T) {
p := testProvider("aws")
m := testModule(t, "validate-count-negative")
c := testContext2(t, &ContextOpts{
Module: m,
Update tests for the new ProviderResolver interface Rather than providing an already-resolved map of plugins to core, we now provide a "provider resolver" which knows how to resolve a set of provider dependencies, to be determined later, and produce that map. This requires the context to be instantiated in a different way, so this very noisy diff is a mostly-mechanical update of all of the existing places where contexts get created for testing, using some adapted versions of the pre-existing utilities for passing in mock providers.
2017-04-22 02:40:46 +02:00
ProviderResolver: ResourceProviderResolverFixed(
map[string]ResourceProviderFactory{
"aws": testProviderFuncFixed(p),
},
),
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
})
return tfdiags.Diagnostics from validation methods Validation is the best time to return detailed diagnostics to the user since we're much more likely to have source location information, etc than we are in later operations. This change doesn't actually add any detail to the messages yet, but it changes the interface so that we can gradually introduce more detailed diagnostics over time. While here there are some minor adjustments to some of the messages to improve their consistency with terminology we use elsewhere.
2017-11-22 00:08:00 +01:00
diags := c.Validate()
if !diags.HasErrors() {
t.Fatalf("bad: %#v", diags)
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
}
}
func TestContext2Validate_countVariable(t *testing.T) {
p := testProvider("aws")
m := testModule(t, "apply-count-variable")
c := testContext2(t, &ContextOpts{
Module: m,
Update tests for the new ProviderResolver interface Rather than providing an already-resolved map of plugins to core, we now provide a "provider resolver" which knows how to resolve a set of provider dependencies, to be determined later, and produce that map. This requires the context to be instantiated in a different way, so this very noisy diff is a mostly-mechanical update of all of the existing places where contexts get created for testing, using some adapted versions of the pre-existing utilities for passing in mock providers.
2017-04-22 02:40:46 +02:00
ProviderResolver: ResourceProviderResolverFixed(
map[string]ResourceProviderFactory{
"aws": testProviderFuncFixed(p),
},
),
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
})
return tfdiags.Diagnostics from validation methods Validation is the best time to return detailed diagnostics to the user since we're much more likely to have source location information, etc than we are in later operations. This change doesn't actually add any detail to the messages yet, but it changes the interface so that we can gradually introduce more detailed diagnostics over time. While here there are some minor adjustments to some of the messages to improve their consistency with terminology we use elsewhere.
2017-11-22 00:08:00 +01:00
diags := c.Validate()
if diags.HasErrors() {
t.Fatalf("bad: %#v", diags)
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
}
}
func TestContext2Validate_countVariableNoDefault(t *testing.T) {
p := testProvider("aws")
m := testModule(t, "validate-count-variable")
c := testContext2(t, &ContextOpts{
Module: m,
Update tests for the new ProviderResolver interface Rather than providing an already-resolved map of plugins to core, we now provide a "provider resolver" which knows how to resolve a set of provider dependencies, to be determined later, and produce that map. This requires the context to be instantiated in a different way, so this very noisy diff is a mostly-mechanical update of all of the existing places where contexts get created for testing, using some adapted versions of the pre-existing utilities for passing in mock providers.
2017-04-22 02:40:46 +02:00
ProviderResolver: ResourceProviderResolverFixed(
map[string]ResourceProviderFactory{
"aws": testProviderFuncFixed(p),
},
),
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
})
return tfdiags.Diagnostics from validation methods Validation is the best time to return detailed diagnostics to the user since we're much more likely to have source location information, etc than we are in later operations. This change doesn't actually add any detail to the messages yet, but it changes the interface so that we can gradually introduce more detailed diagnostics over time. While here there are some minor adjustments to some of the messages to improve their consistency with terminology we use elsewhere.
2017-11-22 00:08:00 +01:00
diags := c.Validate()
if !diags.HasErrors() {
t.Fatalf("bad: %#v", diags)
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
}
}
/*
TODO: What should we do here?
func TestContext2Validate_cycle(t *testing.T) {
p := testProvider("aws")
m := testModule(t, "validate-cycle")
c := testContext2(t, &ContextOpts{
Module: m,
Update tests for the new ProviderResolver interface Rather than providing an already-resolved map of plugins to core, we now provide a "provider resolver" which knows how to resolve a set of provider dependencies, to be determined later, and produce that map. This requires the context to be instantiated in a different way, so this very noisy diff is a mostly-mechanical update of all of the existing places where contexts get created for testing, using some adapted versions of the pre-existing utilities for passing in mock providers.
2017-04-22 02:40:46 +02:00
ProviderResolver: ResourceProviderResolverFixed(
map[string]ResourceProviderFactory{
"aws": testProviderFuncFixed(p),
},
),
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
})
return tfdiags.Diagnostics from validation methods Validation is the best time to return detailed diagnostics to the user since we're much more likely to have source location information, etc than we are in later operations. This change doesn't actually add any detail to the messages yet, but it changes the interface so that we can gradually introduce more detailed diagnostics over time. While here there are some minor adjustments to some of the messages to improve their consistency with terminology we use elsewhere.
2017-11-22 00:08:00 +01:00
diags := c.Validate()
if !diags.HasErrors() {
t.Fatalf("bad: %#v", diags)
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
}
}
*/
func TestContext2Validate_moduleBadOutput(t *testing.T) {
p := testProvider("aws")
m := testModule(t, "validate-bad-module-output")
c := testContext2(t, &ContextOpts{
Module: m,
Update tests for the new ProviderResolver interface Rather than providing an already-resolved map of plugins to core, we now provide a "provider resolver" which knows how to resolve a set of provider dependencies, to be determined later, and produce that map. This requires the context to be instantiated in a different way, so this very noisy diff is a mostly-mechanical update of all of the existing places where contexts get created for testing, using some adapted versions of the pre-existing utilities for passing in mock providers.
2017-04-22 02:40:46 +02:00
ProviderResolver: ResourceProviderResolverFixed(
map[string]ResourceProviderFactory{
"aws": testProviderFuncFixed(p),
},
),
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
})
return tfdiags.Diagnostics from validation methods Validation is the best time to return detailed diagnostics to the user since we're much more likely to have source location information, etc than we are in later operations. This change doesn't actually add any detail to the messages yet, but it changes the interface so that we can gradually introduce more detailed diagnostics over time. While here there are some minor adjustments to some of the messages to improve their consistency with terminology we use elsewhere.
2017-11-22 00:08:00 +01:00
diags := c.Validate()
if !diags.HasErrors() {
t.Fatalf("bad: %#v", diags)
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
}
}
func TestContext2Validate_moduleGood(t *testing.T) {
p := testProvider("aws")
m := testModule(t, "validate-good-module")
c := testContext2(t, &ContextOpts{
Module: m,
Update tests for the new ProviderResolver interface Rather than providing an already-resolved map of plugins to core, we now provide a "provider resolver" which knows how to resolve a set of provider dependencies, to be determined later, and produce that map. This requires the context to be instantiated in a different way, so this very noisy diff is a mostly-mechanical update of all of the existing places where contexts get created for testing, using some adapted versions of the pre-existing utilities for passing in mock providers.
2017-04-22 02:40:46 +02:00
ProviderResolver: ResourceProviderResolverFixed(
map[string]ResourceProviderFactory{
"aws": testProviderFuncFixed(p),
},
),
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
})
return tfdiags.Diagnostics from validation methods Validation is the best time to return detailed diagnostics to the user since we're much more likely to have source location information, etc than we are in later operations. This change doesn't actually add any detail to the messages yet, but it changes the interface so that we can gradually introduce more detailed diagnostics over time. While here there are some minor adjustments to some of the messages to improve their consistency with terminology we use elsewhere.
2017-11-22 00:08:00 +01:00
diags := c.Validate()
if diags.HasErrors() {
t.Fatalf("bad: %#v", diags)
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
}
}
func TestContext2Validate_moduleBadResource(t *testing.T) {
m := testModule(t, "validate-module-bad-rc")
p := testProvider("aws")
c := testContext2(t, &ContextOpts{
Module: m,
Update tests for the new ProviderResolver interface Rather than providing an already-resolved map of plugins to core, we now provide a "provider resolver" which knows how to resolve a set of provider dependencies, to be determined later, and produce that map. This requires the context to be instantiated in a different way, so this very noisy diff is a mostly-mechanical update of all of the existing places where contexts get created for testing, using some adapted versions of the pre-existing utilities for passing in mock providers.
2017-04-22 02:40:46 +02:00
ProviderResolver: ResourceProviderResolverFixed(
map[string]ResourceProviderFactory{
"aws": testProviderFuncFixed(p),
},
),
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
})
p.ValidateResourceReturnErrors = []error{fmt.Errorf("bad")}
return tfdiags.Diagnostics from validation methods Validation is the best time to return detailed diagnostics to the user since we're much more likely to have source location information, etc than we are in later operations. This change doesn't actually add any detail to the messages yet, but it changes the interface so that we can gradually introduce more detailed diagnostics over time. While here there are some minor adjustments to some of the messages to improve their consistency with terminology we use elsewhere.
2017-11-22 00:08:00 +01:00
diags := c.Validate()
if !diags.HasErrors() {
t.Fatalf("bad: %#v", diags)
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
}
}
func TestContext2Validate_moduleDepsShouldNotCycle(t *testing.T) {
m := testModule(t, "validate-module-deps-cycle")
p := testProvider("aws")
ctx := testContext2(t, &ContextOpts{
Module: m,
Update tests for the new ProviderResolver interface Rather than providing an already-resolved map of plugins to core, we now provide a "provider resolver" which knows how to resolve a set of provider dependencies, to be determined later, and produce that map. This requires the context to be instantiated in a different way, so this very noisy diff is a mostly-mechanical update of all of the existing places where contexts get created for testing, using some adapted versions of the pre-existing utilities for passing in mock providers.
2017-04-22 02:40:46 +02:00
ProviderResolver: ResourceProviderResolverFixed(
map[string]ResourceProviderFactory{
"aws": testProviderFuncFixed(p),
},
),
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
})
return tfdiags.Diagnostics from validation methods Validation is the best time to return detailed diagnostics to the user since we're much more likely to have source location information, etc than we are in later operations. This change doesn't actually add any detail to the messages yet, but it changes the interface so that we can gradually introduce more detailed diagnostics over time. While here there are some minor adjustments to some of the messages to improve their consistency with terminology we use elsewhere.
2017-11-22 00:08:00 +01:00
diags := ctx.Validate()
if diags.HasErrors() {
t.Fatalf("bad: %#v", diags)
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
}
}
resintate disabled tests Reinstate the disabled tests that required some sort of inheritance during graph evaluation.
2017-11-02 20:25:59 +01:00
func TestContext2Validate_moduleProviderInheritOrphan(t *testing.T) {
m := testModule(t, "validate-module-pc-inherit-orphan")
p := testProvider("aws")
c := testContext2(t, &ContextOpts{
Module: m,
ProviderResolver: ResourceProviderResolverFixed(
map[string]ResourceProviderFactory{
"aws": testProviderFuncFixed(p),
},
),
State: &State{
Modules: []*ModuleState{
&ModuleState{
Path: []string{"root", "child"},
Resources: map[string]*ResourceState{
"aws_instance.bar": &ResourceState{
Type: "aws_instance",
Primary: &InstanceState{
ID: "bar",
},
},
},
},
},
},
})
p.ValidateFn = func(c *ResourceConfig) ([]string, []error) {
v, ok := c.Get("set")
if !ok {
return nil, []error{fmt.Errorf("not set")}
}
if v != "bar" {
return nil, []error{fmt.Errorf("bad: %#v", v)}
}
return nil, nil
}
return tfdiags.Diagnostics from validation methods Validation is the best time to return detailed diagnostics to the user since we're much more likely to have source location information, etc than we are in later operations. This change doesn't actually add any detail to the messages yet, but it changes the interface so that we can gradually introduce more detailed diagnostics over time. While here there are some minor adjustments to some of the messages to improve their consistency with terminology we use elsewhere.
2017-11-22 00:08:00 +01:00
diags := c.Validate()
if diags.HasErrors() {
t.Fatalf("bad: %#v", diags)
resintate disabled tests Reinstate the disabled tests that required some sort of inheritance during graph evaluation.
2017-11-02 20:25:59 +01:00
}
}
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
func TestContext2Validate_moduleProviderVar(t *testing.T) {
m := testModule(t, "validate-module-pc-vars")
p := testProvider("aws")
c := testContext2(t, &ContextOpts{
Module: m,
Update tests for the new ProviderResolver interface Rather than providing an already-resolved map of plugins to core, we now provide a "provider resolver" which knows how to resolve a set of provider dependencies, to be determined later, and produce that map. This requires the context to be instantiated in a different way, so this very noisy diff is a mostly-mechanical update of all of the existing places where contexts get created for testing, using some adapted versions of the pre-existing utilities for passing in mock providers.
2017-04-22 02:40:46 +02:00
ProviderResolver: ResourceProviderResolverFixed(
map[string]ResourceProviderFactory{
"aws": testProviderFuncFixed(p),
},
),
core: Convert context vars to map[string]interface{} This is the first step in allowing overrides of map and list variables. We convert Context.variables to map[string]interface{} from map[string]string and fix up all the call sites.
2016-07-18 19:52:10 +02:00
Variables: map[string]interface{}{
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
"provider_var": "bar",
},
})
p.ValidateFn = func(c *ResourceConfig) ([]string, []error) {
return nil, c.CheckSet([]string{"foo"})
}
return tfdiags.Diagnostics from validation methods Validation is the best time to return detailed diagnostics to the user since we're much more likely to have source location information, etc than we are in later operations. This change doesn't actually add any detail to the messages yet, but it changes the interface so that we can gradually introduce more detailed diagnostics over time. While here there are some minor adjustments to some of the messages to improve their consistency with terminology we use elsewhere.
2017-11-22 00:08:00 +01:00
diags := c.Validate()
if diags.HasErrors() {
t.Fatalf("bad: %#v", diags)
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
}
}
func TestContext2Validate_moduleProviderInheritUnused(t *testing.T) {
m := testModule(t, "validate-module-pc-inherit-unused")
p := testProvider("aws")
c := testContext2(t, &ContextOpts{
Module: m,
Update tests for the new ProviderResolver interface Rather than providing an already-resolved map of plugins to core, we now provide a "provider resolver" which knows how to resolve a set of provider dependencies, to be determined later, and produce that map. This requires the context to be instantiated in a different way, so this very noisy diff is a mostly-mechanical update of all of the existing places where contexts get created for testing, using some adapted versions of the pre-existing utilities for passing in mock providers.
2017-04-22 02:40:46 +02:00
ProviderResolver: ResourceProviderResolverFixed(
map[string]ResourceProviderFactory{
"aws": testProviderFuncFixed(p),
},
),
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
})
p.ValidateFn = func(c *ResourceConfig) ([]string, []error) {
return nil, c.CheckSet([]string{"foo"})
}
return tfdiags.Diagnostics from validation methods Validation is the best time to return detailed diagnostics to the user since we're much more likely to have source location information, etc than we are in later operations. This change doesn't actually add any detail to the messages yet, but it changes the interface so that we can gradually introduce more detailed diagnostics over time. While here there are some minor adjustments to some of the messages to improve their consistency with terminology we use elsewhere.
2017-11-22 00:08:00 +01:00
diags := c.Validate()
if diags.HasErrors() {
t.Fatalf("bad: %#v", diags)
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
}
}
func TestContext2Validate_orphans(t *testing.T) {
p := testProvider("aws")
m := testModule(t, "validate-good")
state := &State{
Modules: []*ModuleState{
&ModuleState{
Path: rootModulePath,
Resources: map[string]*ResourceState{
"aws_instance.web": &ResourceState{
Type: "aws_instance",
Primary: &InstanceState{
ID: "bar",
},
},
},
},
},
}
c := testContext2(t, &ContextOpts{
Module: m,
Update tests for the new ProviderResolver interface Rather than providing an already-resolved map of plugins to core, we now provide a "provider resolver" which knows how to resolve a set of provider dependencies, to be determined later, and produce that map. This requires the context to be instantiated in a different way, so this very noisy diff is a mostly-mechanical update of all of the existing places where contexts get created for testing, using some adapted versions of the pre-existing utilities for passing in mock providers.
2017-04-22 02:40:46 +02:00
ProviderResolver: ResourceProviderResolverFixed(
map[string]ResourceProviderFactory{
"aws": testProviderFuncFixed(p),
},
),
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
State: state,
})
p.ValidateResourceFn = func(
t string, c *ResourceConfig) ([]string, []error) {
return nil, c.CheckSet([]string{"foo"})
}
return tfdiags.Diagnostics from validation methods Validation is the best time to return detailed diagnostics to the user since we're much more likely to have source location information, etc than we are in later operations. This change doesn't actually add any detail to the messages yet, but it changes the interface so that we can gradually introduce more detailed diagnostics over time. While here there are some minor adjustments to some of the messages to improve their consistency with terminology we use elsewhere.
2017-11-22 00:08:00 +01:00
diags := c.Validate()
if diags.HasErrors() {
t.Fatalf("bad: %#v", diags)
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
}
}
func TestContext2Validate_providerConfig_bad(t *testing.T) {
m := testModule(t, "validate-bad-pc")
p := testProvider("aws")
c := testContext2(t, &ContextOpts{
Module: m,
Update tests for the new ProviderResolver interface Rather than providing an already-resolved map of plugins to core, we now provide a "provider resolver" which knows how to resolve a set of provider dependencies, to be determined later, and produce that map. This requires the context to be instantiated in a different way, so this very noisy diff is a mostly-mechanical update of all of the existing places where contexts get created for testing, using some adapted versions of the pre-existing utilities for passing in mock providers.
2017-04-22 02:40:46 +02:00
ProviderResolver: ResourceProviderResolverFixed(
map[string]ResourceProviderFactory{
"aws": testProviderFuncFixed(p),
},
),
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
})
p.ValidateReturnErrors = []error{fmt.Errorf("bad")}
return tfdiags.Diagnostics from validation methods Validation is the best time to return detailed diagnostics to the user since we're much more likely to have source location information, etc than we are in later operations. This change doesn't actually add any detail to the messages yet, but it changes the interface so that we can gradually introduce more detailed diagnostics over time. While here there are some minor adjustments to some of the messages to improve their consistency with terminology we use elsewhere.
2017-11-22 00:08:00 +01:00
diags := c.Validate()
if len(diags) != 1 {
t.Fatalf("wrong number of diagnostics %d; want %d", len(diags), 1)
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
}
return tfdiags.Diagnostics from validation methods Validation is the best time to return detailed diagnostics to the user since we're much more likely to have source location information, etc than we are in later operations. This change doesn't actually add any detail to the messages yet, but it changes the interface so that we can gradually introduce more detailed diagnostics over time. While here there are some minor adjustments to some of the messages to improve their consistency with terminology we use elsewhere.
2017-11-22 00:08:00 +01:00
if !strings.Contains(diags.Err().Error(), "bad") {
t.Fatalf("bad: %s", diags.Err().Error())
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
}
}
func TestContext2Validate_providerConfig_badEmpty(t *testing.T) {
m := testModule(t, "validate-bad-pc-empty")
p := testProvider("aws")
c := testContext2(t, &ContextOpts{
Module: m,
Update tests for the new ProviderResolver interface Rather than providing an already-resolved map of plugins to core, we now provide a "provider resolver" which knows how to resolve a set of provider dependencies, to be determined later, and produce that map. This requires the context to be instantiated in a different way, so this very noisy diff is a mostly-mechanical update of all of the existing places where contexts get created for testing, using some adapted versions of the pre-existing utilities for passing in mock providers.
2017-04-22 02:40:46 +02:00
ProviderResolver: ResourceProviderResolverFixed(
map[string]ResourceProviderFactory{
"aws": testProviderFuncFixed(p),
},
),
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
})
p.ValidateReturnErrors = []error{fmt.Errorf("bad")}
return tfdiags.Diagnostics from validation methods Validation is the best time to return detailed diagnostics to the user since we're much more likely to have source location information, etc than we are in later operations. This change doesn't actually add any detail to the messages yet, but it changes the interface so that we can gradually introduce more detailed diagnostics over time. While here there are some minor adjustments to some of the messages to improve their consistency with terminology we use elsewhere.
2017-11-22 00:08:00 +01:00
diags := c.Validate()
if !diags.HasErrors() {
t.Fatalf("bad: %#v", diags)
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
}
}
func TestContext2Validate_providerConfig_good(t *testing.T) {
m := testModule(t, "validate-bad-pc")
p := testProvider("aws")
c := testContext2(t, &ContextOpts{
Module: m,
Update tests for the new ProviderResolver interface Rather than providing an already-resolved map of plugins to core, we now provide a "provider resolver" which knows how to resolve a set of provider dependencies, to be determined later, and produce that map. This requires the context to be instantiated in a different way, so this very noisy diff is a mostly-mechanical update of all of the existing places where contexts get created for testing, using some adapted versions of the pre-existing utilities for passing in mock providers.
2017-04-22 02:40:46 +02:00
ProviderResolver: ResourceProviderResolverFixed(
map[string]ResourceProviderFactory{
"aws": testProviderFuncFixed(p),
},
),
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
})
return tfdiags.Diagnostics from validation methods Validation is the best time to return detailed diagnostics to the user since we're much more likely to have source location information, etc than we are in later operations. This change doesn't actually add any detail to the messages yet, but it changes the interface so that we can gradually introduce more detailed diagnostics over time. While here there are some minor adjustments to some of the messages to improve their consistency with terminology we use elsewhere.
2017-11-22 00:08:00 +01:00
diags := c.Validate()
if diags.HasErrors() {
t.Fatalf("bad: %#v", diags)
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
}
}
func TestContext2Validate_provisionerConfig_bad(t *testing.T) {
m := testModule(t, "validate-bad-prov-conf")
p := testProvider("aws")
pr := testProvisioner()
c := testContext2(t, &ContextOpts{
Module: m,
Update tests for the new ProviderResolver interface Rather than providing an already-resolved map of plugins to core, we now provide a "provider resolver" which knows how to resolve a set of provider dependencies, to be determined later, and produce that map. This requires the context to be instantiated in a different way, so this very noisy diff is a mostly-mechanical update of all of the existing places where contexts get created for testing, using some adapted versions of the pre-existing utilities for passing in mock providers.
2017-04-22 02:40:46 +02:00
ProviderResolver: ResourceProviderResolverFixed(
map[string]ResourceProviderFactory{
"aws": testProviderFuncFixed(p),
},
),
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
Provisioners: map[string]ResourceProvisionerFactory{
"shell": testProvisionerFuncFixed(pr),
},
})
pr.ValidateReturnErrors = []error{fmt.Errorf("bad")}
return tfdiags.Diagnostics from validation methods Validation is the best time to return detailed diagnostics to the user since we're much more likely to have source location information, etc than we are in later operations. This change doesn't actually add any detail to the messages yet, but it changes the interface so that we can gradually introduce more detailed diagnostics over time. While here there are some minor adjustments to some of the messages to improve their consistency with terminology we use elsewhere.
2017-11-22 00:08:00 +01:00
diags := c.Validate()
if !diags.HasErrors() {
t.Fatalf("bad: %#v", diags)
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
}
}
func TestContext2Validate_provisionerConfig_good(t *testing.T) {
m := testModule(t, "validate-bad-prov-conf")
p := testProvider("aws")
pr := testProvisioner()
pr.ValidateFn = func(c *ResourceConfig) ([]string, []error) {
if c == nil {
t.Fatalf("missing resource config for provisioner")
}
return nil, c.CheckSet([]string{"command"})
}
c := testContext2(t, &ContextOpts{
Module: m,
Update tests for the new ProviderResolver interface Rather than providing an already-resolved map of plugins to core, we now provide a "provider resolver" which knows how to resolve a set of provider dependencies, to be determined later, and produce that map. This requires the context to be instantiated in a different way, so this very noisy diff is a mostly-mechanical update of all of the existing places where contexts get created for testing, using some adapted versions of the pre-existing utilities for passing in mock providers.
2017-04-22 02:40:46 +02:00
ProviderResolver: ResourceProviderResolverFixed(
map[string]ResourceProviderFactory{
"aws": testProviderFuncFixed(p),
},
),
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
Provisioners: map[string]ResourceProvisionerFactory{
"shell": testProvisionerFuncFixed(pr),
},
})
return tfdiags.Diagnostics from validation methods Validation is the best time to return detailed diagnostics to the user since we're much more likely to have source location information, etc than we are in later operations. This change doesn't actually add any detail to the messages yet, but it changes the interface so that we can gradually introduce more detailed diagnostics over time. While here there are some minor adjustments to some of the messages to improve their consistency with terminology we use elsewhere.
2017-11-22 00:08:00 +01:00
diags := c.Validate()
if diags.HasErrors() {
t.Fatalf("bad: %#v", diags)
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
}
}
func TestContext2Validate_requiredVar(t *testing.T) {
m := testModule(t, "validate-required-var")
p := testProvider("aws")
c := testContext2(t, &ContextOpts{
Module: m,
Update tests for the new ProviderResolver interface Rather than providing an already-resolved map of plugins to core, we now provide a "provider resolver" which knows how to resolve a set of provider dependencies, to be determined later, and produce that map. This requires the context to be instantiated in a different way, so this very noisy diff is a mostly-mechanical update of all of the existing places where contexts get created for testing, using some adapted versions of the pre-existing utilities for passing in mock providers.
2017-04-22 02:40:46 +02:00
ProviderResolver: ResourceProviderResolverFixed(
map[string]ResourceProviderFactory{
"aws": testProviderFuncFixed(p),
},
),
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
})
return tfdiags.Diagnostics from validation methods Validation is the best time to return detailed diagnostics to the user since we're much more likely to have source location information, etc than we are in later operations. This change doesn't actually add any detail to the messages yet, but it changes the interface so that we can gradually introduce more detailed diagnostics over time. While here there are some minor adjustments to some of the messages to improve their consistency with terminology we use elsewhere.
2017-11-22 00:08:00 +01:00
diags := c.Validate()
if !diags.HasErrors() {
t.Fatalf("bad: %#v", diags)
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
}
}
func TestContext2Validate_resourceConfig_bad(t *testing.T) {
m := testModule(t, "validate-bad-rc")
p := testProvider("aws")
c := testContext2(t, &ContextOpts{
Module: m,
Update tests for the new ProviderResolver interface Rather than providing an already-resolved map of plugins to core, we now provide a "provider resolver" which knows how to resolve a set of provider dependencies, to be determined later, and produce that map. This requires the context to be instantiated in a different way, so this very noisy diff is a mostly-mechanical update of all of the existing places where contexts get created for testing, using some adapted versions of the pre-existing utilities for passing in mock providers.
2017-04-22 02:40:46 +02:00
ProviderResolver: ResourceProviderResolverFixed(
map[string]ResourceProviderFactory{
"aws": testProviderFuncFixed(p),
},
),
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
})
p.ValidateResourceReturnErrors = []error{fmt.Errorf("bad")}
return tfdiags.Diagnostics from validation methods Validation is the best time to return detailed diagnostics to the user since we're much more likely to have source location information, etc than we are in later operations. This change doesn't actually add any detail to the messages yet, but it changes the interface so that we can gradually introduce more detailed diagnostics over time. While here there are some minor adjustments to some of the messages to improve their consistency with terminology we use elsewhere.
2017-11-22 00:08:00 +01:00
diags := c.Validate()
if !diags.HasErrors() {
t.Fatalf("bad: %#v", diags)
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
}
}
func TestContext2Validate_resourceConfig_good(t *testing.T) {
m := testModule(t, "validate-bad-rc")
p := testProvider("aws")
c := testContext2(t, &ContextOpts{
Module: m,
Update tests for the new ProviderResolver interface Rather than providing an already-resolved map of plugins to core, we now provide a "provider resolver" which knows how to resolve a set of provider dependencies, to be determined later, and produce that map. This requires the context to be instantiated in a different way, so this very noisy diff is a mostly-mechanical update of all of the existing places where contexts get created for testing, using some adapted versions of the pre-existing utilities for passing in mock providers.
2017-04-22 02:40:46 +02:00
ProviderResolver: ResourceProviderResolverFixed(
map[string]ResourceProviderFactory{
"aws": testProviderFuncFixed(p),
},
),
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
})
return tfdiags.Diagnostics from validation methods Validation is the best time to return detailed diagnostics to the user since we're much more likely to have source location information, etc than we are in later operations. This change doesn't actually add any detail to the messages yet, but it changes the interface so that we can gradually introduce more detailed diagnostics over time. While here there are some minor adjustments to some of the messages to improve their consistency with terminology we use elsewhere.
2017-11-22 00:08:00 +01:00
diags := c.Validate()
if diags.HasErrors() {
t.Fatalf("bad: %#v", diags)
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
}
}
func TestContext2Validate_resourceNameSymbol(t *testing.T) {
p := testProvider("aws")
m := testModule(t, "validate-resource-name-symbol")
c := testContext2(t, &ContextOpts{
Module: m,
Update tests for the new ProviderResolver interface Rather than providing an already-resolved map of plugins to core, we now provide a "provider resolver" which knows how to resolve a set of provider dependencies, to be determined later, and produce that map. This requires the context to be instantiated in a different way, so this very noisy diff is a mostly-mechanical update of all of the existing places where contexts get created for testing, using some adapted versions of the pre-existing utilities for passing in mock providers.
2017-04-22 02:40:46 +02:00
ProviderResolver: ResourceProviderResolverFixed(
map[string]ResourceProviderFactory{
"aws": testProviderFuncFixed(p),
},
),
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
})
return tfdiags.Diagnostics from validation methods Validation is the best time to return detailed diagnostics to the user since we're much more likely to have source location information, etc than we are in later operations. This change doesn't actually add any detail to the messages yet, but it changes the interface so that we can gradually introduce more detailed diagnostics over time. While here there are some minor adjustments to some of the messages to improve their consistency with terminology we use elsewhere.
2017-11-22 00:08:00 +01:00
diags := c.Validate()
if !diags.HasErrors() {
t.Fatalf("bad: %#v", diags)
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
}
}
func TestContext2Validate_selfRef(t *testing.T) {
p := testProvider("aws")
m := testModule(t, "validate-self-ref")
c := testContext2(t, &ContextOpts{
Module: m,
Update tests for the new ProviderResolver interface Rather than providing an already-resolved map of plugins to core, we now provide a "provider resolver" which knows how to resolve a set of provider dependencies, to be determined later, and produce that map. This requires the context to be instantiated in a different way, so this very noisy diff is a mostly-mechanical update of all of the existing places where contexts get created for testing, using some adapted versions of the pre-existing utilities for passing in mock providers.
2017-04-22 02:40:46 +02:00
ProviderResolver: ResourceProviderResolverFixed(
map[string]ResourceProviderFactory{
"aws": testProviderFuncFixed(p),
},
),
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
})
return tfdiags.Diagnostics from validation methods Validation is the best time to return detailed diagnostics to the user since we're much more likely to have source location information, etc than we are in later operations. This change doesn't actually add any detail to the messages yet, but it changes the interface so that we can gradually introduce more detailed diagnostics over time. While here there are some minor adjustments to some of the messages to improve their consistency with terminology we use elsewhere.
2017-11-22 00:08:00 +01:00
diags := c.Validate()
if !diags.HasErrors() {
t.Fatalf("bad: %#v", diags)
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
}
}
func TestContext2Validate_selfRefMulti(t *testing.T) {
p := testProvider("aws")
m := testModule(t, "validate-self-ref-multi")
c := testContext2(t, &ContextOpts{
Module: m,
Update tests for the new ProviderResolver interface Rather than providing an already-resolved map of plugins to core, we now provide a "provider resolver" which knows how to resolve a set of provider dependencies, to be determined later, and produce that map. This requires the context to be instantiated in a different way, so this very noisy diff is a mostly-mechanical update of all of the existing places where contexts get created for testing, using some adapted versions of the pre-existing utilities for passing in mock providers.
2017-04-22 02:40:46 +02:00
ProviderResolver: ResourceProviderResolverFixed(
map[string]ResourceProviderFactory{
"aws": testProviderFuncFixed(p),
},
),
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
})
return tfdiags.Diagnostics from validation methods Validation is the best time to return detailed diagnostics to the user since we're much more likely to have source location information, etc than we are in later operations. This change doesn't actually add any detail to the messages yet, but it changes the interface so that we can gradually introduce more detailed diagnostics over time. While here there are some minor adjustments to some of the messages to improve their consistency with terminology we use elsewhere.
2017-11-22 00:08:00 +01:00
diags := c.Validate()
if !diags.HasErrors() {
t.Fatalf("bad: %#v", diags)
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
}
}
func TestContext2Validate_selfRefMultiAll(t *testing.T) {
p := testProvider("aws")
m := testModule(t, "validate-self-ref-multi-all")
c := testContext2(t, &ContextOpts{
Module: m,
Update tests for the new ProviderResolver interface Rather than providing an already-resolved map of plugins to core, we now provide a "provider resolver" which knows how to resolve a set of provider dependencies, to be determined later, and produce that map. This requires the context to be instantiated in a different way, so this very noisy diff is a mostly-mechanical update of all of the existing places where contexts get created for testing, using some adapted versions of the pre-existing utilities for passing in mock providers.
2017-04-22 02:40:46 +02:00
ProviderResolver: ResourceProviderResolverFixed(
map[string]ResourceProviderFactory{
"aws": testProviderFuncFixed(p),
},
),
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
})
return tfdiags.Diagnostics from validation methods Validation is the best time to return detailed diagnostics to the user since we're much more likely to have source location information, etc than we are in later operations. This change doesn't actually add any detail to the messages yet, but it changes the interface so that we can gradually introduce more detailed diagnostics over time. While here there are some minor adjustments to some of the messages to improve their consistency with terminology we use elsewhere.
2017-11-22 00:08:00 +01:00
diags := c.Validate()
if !diags.HasErrors() {
t.Fatalf("bad: %#v", diags)
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
}
}
func TestContext2Validate_tainted(t *testing.T) {
p := testProvider("aws")
m := testModule(t, "validate-good")
state := &State{
Modules: []*ModuleState{
&ModuleState{
Path: rootModulePath,
Resources: map[string]*ResourceState{
"aws_instance.foo": &ResourceState{
Type: "aws_instance",
Add tests and fix last issues
2016-04-21 21:59:10 +02:00
Primary: &InstanceState{
ID: "bar",
Tainted: true,
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
},
},
},
},
},
}
c := testContext2(t, &ContextOpts{
Module: m,
Update tests for the new ProviderResolver interface Rather than providing an already-resolved map of plugins to core, we now provide a "provider resolver" which knows how to resolve a set of provider dependencies, to be determined later, and produce that map. This requires the context to be instantiated in a different way, so this very noisy diff is a mostly-mechanical update of all of the existing places where contexts get created for testing, using some adapted versions of the pre-existing utilities for passing in mock providers.
2017-04-22 02:40:46 +02:00
ProviderResolver: ResourceProviderResolverFixed(
map[string]ResourceProviderFactory{
"aws": testProviderFuncFixed(p),
},
),
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
State: state,
})
p.ValidateResourceFn = func(
t string, c *ResourceConfig) ([]string, []error) {
return nil, c.CheckSet([]string{"foo"})
}
return tfdiags.Diagnostics from validation methods Validation is the best time to return detailed diagnostics to the user since we're much more likely to have source location information, etc than we are in later operations. This change doesn't actually add any detail to the messages yet, but it changes the interface so that we can gradually introduce more detailed diagnostics over time. While here there are some minor adjustments to some of the messages to improve their consistency with terminology we use elsewhere.
2017-11-22 00:08:00 +01:00
diags := c.Validate()
if diags.HasErrors() {
t.Fatalf("bad: %#v", diags)
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
}
}
func TestContext2Validate_targetedDestroy(t *testing.T) {
m := testModule(t, "validate-targeted")
p := testProvider("aws")
pr := testProvisioner()
p.ApplyFn = testApplyFn
p.DiffFn = testDiffFn
ctx := testContext2(t, &ContextOpts{
Module: m,
Update tests for the new ProviderResolver interface Rather than providing an already-resolved map of plugins to core, we now provide a "provider resolver" which knows how to resolve a set of provider dependencies, to be determined later, and produce that map. This requires the context to be instantiated in a different way, so this very noisy diff is a mostly-mechanical update of all of the existing places where contexts get created for testing, using some adapted versions of the pre-existing utilities for passing in mock providers.
2017-04-22 02:40:46 +02:00
ProviderResolver: ResourceProviderResolverFixed(
map[string]ResourceProviderFactory{
"aws": testProviderFuncFixed(p),
},
),
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
Provisioners: map[string]ResourceProvisionerFactory{
"shell": testProvisionerFuncFixed(pr),
},
State: &State{
Modules: []*ModuleState{
&ModuleState{
Path: rootModulePath,
Resources: map[string]*ResourceState{
"aws_instance.foo": resourceState("aws_instance", "i-bcd345"),
"aws_instance.bar": resourceState("aws_instance", "i-abc123"),
},
},
},
},
Targets: []string{"aws_instance.foo"},
Destroy: true,
})
return tfdiags.Diagnostics from validation methods Validation is the best time to return detailed diagnostics to the user since we're much more likely to have source location information, etc than we are in later operations. This change doesn't actually add any detail to the messages yet, but it changes the interface so that we can gradually introduce more detailed diagnostics over time. While here there are some minor adjustments to some of the messages to improve their consistency with terminology we use elsewhere.
2017-11-22 00:08:00 +01:00
diags := ctx.Validate()
if diags.HasErrors() {
t.Fatalf("bad: %#v", diags)
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
}
}
func TestContext2Validate_varRefFilled(t *testing.T) {
m := testModule(t, "validate-variable-ref")
p := testProvider("aws")
c := testContext2(t, &ContextOpts{
Module: m,
Update tests for the new ProviderResolver interface Rather than providing an already-resolved map of plugins to core, we now provide a "provider resolver" which knows how to resolve a set of provider dependencies, to be determined later, and produce that map. This requires the context to be instantiated in a different way, so this very noisy diff is a mostly-mechanical update of all of the existing places where contexts get created for testing, using some adapted versions of the pre-existing utilities for passing in mock providers.
2017-04-22 02:40:46 +02:00
ProviderResolver: ResourceProviderResolverFixed(
map[string]ResourceProviderFactory{
"aws": testProviderFuncFixed(p),
},
),
core: Convert context vars to map[string]interface{} This is the first step in allowing overrides of map and list variables. We convert Context.variables to map[string]interface{} from map[string]string and fix up all the call sites.
2016-07-18 19:52:10 +02:00
Variables: map[string]interface{}{
core: split context tests The context_test file has gotten pretty unruly. Let's split it up into a few files so we can be nicer to our editors and our own sanity. Definitely lots more we can do to clean up, but with changes like this I'd rather do small, focused, clear steps instead of one big "cleaned up lots of stuff" PR.
2015-07-10 22:08:49 +02:00
"foo": "bar",
},
})
var value interface{}
p.ValidateResourceFn = func(t string, c *ResourceConfig) ([]string, []error) {
value, _ = c.Get("foo")
return nil, nil
}
c.Validate()
if value != "bar" {
t.Fatalf("bad: %#v", value)
}
}
Interpolation also skipped during Validate phase Adding walkValidate to the EvalTree operations, and removing the walkValidate guard from the Interpolater.valueModuleVar allows the values to be interpolated for Validate.
2016-05-23 18:46:06 +02:00
// Module variables weren't being interpolated during Validate phase.
// related to https://github.com/hashicorp/terraform/issues/5322
func TestContext2Validate_interpolateVar(t *testing.T) {
input := new(MockUIInput)
m := testModule(t, "input-interpolate-var")
p := testProvider("null")
p.ApplyFn = testApplyFn
p.DiffFn = testDiffFn
ctx := testContext2(t, &ContextOpts{
Module: m,
Update tests for the new ProviderResolver interface Rather than providing an already-resolved map of plugins to core, we now provide a "provider resolver" which knows how to resolve a set of provider dependencies, to be determined later, and produce that map. This requires the context to be instantiated in a different way, so this very noisy diff is a mostly-mechanical update of all of the existing places where contexts get created for testing, using some adapted versions of the pre-existing utilities for passing in mock providers.
2017-04-22 02:40:46 +02:00
ProviderResolver: ResourceProviderResolverFixed(
map[string]ResourceProviderFactory{
"template": testProviderFuncFixed(p),
},
),
Interpolation also skipped during Validate phase Adding walkValidate to the EvalTree operations, and removing the walkValidate guard from the Interpolater.valueModuleVar allows the values to be interpolated for Validate.
2016-05-23 18:46:06 +02:00
UIInput: input,
})
return tfdiags.Diagnostics from validation methods Validation is the best time to return detailed diagnostics to the user since we're much more likely to have source location information, etc than we are in later operations. This change doesn't actually add any detail to the messages yet, but it changes the interface so that we can gradually introduce more detailed diagnostics over time. While here there are some minor adjustments to some of the messages to improve their consistency with terminology we use elsewhere.
2017-11-22 00:08:00 +01:00
diags := ctx.Validate()
if diags.HasErrors() {
t.Fatalf("bad: %#v", diags)
Interpolation also skipped during Validate phase Adding walkValidate to the EvalTree operations, and removing the walkValidate guard from the Interpolater.valueModuleVar allows the values to be interpolated for Validate.
2016-05-23 18:46:06 +02:00
}
}
core: Another validate test for computed module var refs I wanted to make sure this case was handled, and it is! So here's an extra test for us.
2016-05-23 22:54:14 +02:00
// When module vars reference something that is actually computed, this
// shouldn't cause validation to fail.
func TestContext2Validate_interpolateComputedModuleVarDef(t *testing.T) {
input := new(MockUIInput)
m := testModule(t, "validate-computed-module-var-ref")
p := testProvider("aws")
p.ApplyFn = testApplyFn
p.DiffFn = testDiffFn
ctx := testContext2(t, &ContextOpts{
Module: m,
Update tests for the new ProviderResolver interface Rather than providing an already-resolved map of plugins to core, we now provide a "provider resolver" which knows how to resolve a set of provider dependencies, to be determined later, and produce that map. This requires the context to be instantiated in a different way, so this very noisy diff is a mostly-mechanical update of all of the existing places where contexts get created for testing, using some adapted versions of the pre-existing utilities for passing in mock providers.
2017-04-22 02:40:46 +02:00
ProviderResolver: ResourceProviderResolverFixed(
map[string]ResourceProviderFactory{
"aws": testProviderFuncFixed(p),
},
),
core: Another validate test for computed module var refs I wanted to make sure this case was handled, and it is! So here's an extra test for us.
2016-05-23 22:54:14 +02:00
UIInput: input,
})
return tfdiags.Diagnostics from validation methods Validation is the best time to return detailed diagnostics to the user since we're much more likely to have source location information, etc than we are in later operations. This change doesn't actually add any detail to the messages yet, but it changes the interface so that we can gradually introduce more detailed diagnostics over time. While here there are some minor adjustments to some of the messages to improve their consistency with terminology we use elsewhere.
2017-11-22 00:08:00 +01:00
diags := ctx.Validate()
if diags.HasErrors() {
t.Fatalf("bad: %#v", diags)
core: Another validate test for computed module var refs I wanted to make sure this case was handled, and it is! So here's an extra test for us.
2016-05-23 22:54:14 +02:00
}
}
Add failing test for missing computed map entries The map output from the module "mod" loses the computed value from the template when we validate. If the "extra" field is removed from the map, the validation fails earlier with map "does not have any elements so cannot determine type". Apply will work, because the computed value will exist in the map.
2016-10-26 22:05:50 +02:00
// Computed values are lost when a map is output from a module
func TestContext2Validate_interpolateMap(t *testing.T) {
input := new(MockUIInput)
m := testModule(t, "issue-9549")
p := testProvider("null")
p.ApplyFn = testApplyFn
p.DiffFn = testDiffFn
ctx := testContext2(t, &ContextOpts{
Module: m,
Update tests for the new ProviderResolver interface Rather than providing an already-resolved map of plugins to core, we now provide a "provider resolver" which knows how to resolve a set of provider dependencies, to be determined later, and produce that map. This requires the context to be instantiated in a different way, so this very noisy diff is a mostly-mechanical update of all of the existing places where contexts get created for testing, using some adapted versions of the pre-existing utilities for passing in mock providers.
2017-04-22 02:40:46 +02:00
ProviderResolver: ResourceProviderResolverFixed(
map[string]ResourceProviderFactory{
"template": testProviderFuncFixed(p),
},
),
Add failing test for missing computed map entries The map output from the module "mod" loses the computed value from the template when we validate. If the "extra" field is removed from the map, the validation fails earlier with map "does not have any elements so cannot determine type". Apply will work, because the computed value will exist in the map.
2016-10-26 22:05:50 +02:00
UIInput: input,
})
return tfdiags.Diagnostics from validation methods Validation is the best time to return detailed diagnostics to the user since we're much more likely to have source location information, etc than we are in later operations. This change doesn't actually add any detail to the messages yet, but it changes the interface so that we can gradually introduce more detailed diagnostics over time. While here there are some minor adjustments to some of the messages to improve their consistency with terminology we use elsewhere.
2017-11-22 00:08:00 +01:00
diags := ctx.Validate()
if diags.HasErrors() {
t.Fatalf("bad: %#v", diags)
Add failing test for missing computed map entries The map output from the module "mod" loses the computed value from the template when we validate. If the "extra" field is removed from the map, the validation fails earlier with map "does not have any elements so cannot determine type". Apply will work, because the computed value will exist in the map.
2016-10-26 22:05:50 +02:00
}
}
Make sure that a Context.diff is never nil The context and diff passed along during a walk, and the diff is assumed to be valid.
2016-12-02 16:53:29 +01:00
// Manually validate using the new PlanGraphBuilder
func TestContext2Validate_PlanGraphBuilder(t *testing.T) {
m := testModule(t, "apply-vars")
p := testProvider("aws")
p.ApplyFn = testApplyFn
p.DiffFn = testDiffFn
c := testContext2(t, &ContextOpts{
Module: m,
Update tests for the new ProviderResolver interface Rather than providing an already-resolved map of plugins to core, we now provide a "provider resolver" which knows how to resolve a set of provider dependencies, to be determined later, and produce that map. This requires the context to be instantiated in a different way, so this very noisy diff is a mostly-mechanical update of all of the existing places where contexts get created for testing, using some adapted versions of the pre-existing utilities for passing in mock providers.
2017-04-22 02:40:46 +02:00
ProviderResolver: ResourceProviderResolverFixed(
map[string]ResourceProviderFactory{
"aws": testProviderFuncFixed(p),
},
),
Make sure that a Context.diff is never nil The context and diff passed along during a walk, and the diff is assumed to be valid.
2016-12-02 16:53:29 +01:00
Variables: map[string]interface{}{
"foo": "us-west-2",
"test_list": []interface{}{"Hello", "World"},
"test_map": map[string]interface{}{
"Hello": "World",
"Foo": "Bar",
"Baz": "Foo",
},
"amis": []map[string]interface{}{
map[string]interface{}{
"us-east-1": "override",
},
},
},
})
graph, err := (&PlanGraphBuilder{
Module: c.module,
State: NewState(),
Providers: c.components.ResourceProviders(),
Targets: c.targets,
}).Build(RootModulePath)
Fix swallowed tests in terraform package tests
2017-07-20 11:23:43 +02:00
if err != nil {
t.Fatalf("error attmepting to Build PlanGraphBuilder: %s", err)
}
terraform: acquireRun during test to avoid special case logic
2017-01-30 17:41:38 +01:00
defer c.acquireRun("validate-test")()
core: remove shadow graph infrastructure The shadow graph was incredibly useful during the 0.7 cycle but these days it is idle, since we're not planning any significant graph-related changes for the forseeable future. The shadow graph infrastructure is somewhat burdensome since any change to the ResourceProvider interface must have shims written. Since we _are_ expecting changes to the ResourceProvider interface in the next few releases, I'm calling "YAGNI" on the shadow graph support to reduce our maintenence burden. If we do end up wanting to use shadow graph again in future, we'll always be able to pull it out of version control and then make whatever changes we skipped making in the mean time, but we can avoid that cost in the mean time while we don't have any evidence that we'll need to pay it.
2017-08-15 01:33:15 +02:00
walker, err := c.walk(graph, walkValidate)
Make sure that a Context.diff is never nil The context and diff passed along during a walk, and the diff is assumed to be valid.
2016-12-02 16:53:29 +01:00
if err != nil {
t.Fatal(err)
}
if len(walker.ValidationErrors) > 0 {
t.Fatal(walker.ValidationErrors)
}
}