Mildwonkey/terraform tests (targeting integration branch)

configs/config.go

@@ -310,10 +310,7 @@ func (c *Config) ResolveAbsProviderAddr(addr addrs.ProviderConfig, inModule addr
 		if providerReq, exists := c.Module.ProviderRequirements[addr.LocalName]; exists {
 			provider = providerReq.Type
 		} else {
-			// FIXME: For now we're returning a _legacy_ address as fallback here,
-			// but once we remove legacy addresses this should actually be a
-			// _default_ provider address.
-			provider = addrs.NewLegacyProvider(addr.LocalName)
+			provider = addrs.NewDefaultProvider(addr.LocalName)
 		}
 
 		return addrs.AbsProviderConfig{
@@ -330,7 +327,7 @@ func (c *Config) ResolveAbsProviderAddr(addr addrs.ProviderConfig, inModule addr
 
 // ProviderForConfigAddr returns the FQN for a given addrs.ProviderConfig, first
 // by checking for the provider in module.ProviderRequirements and falling
-// back to addrs.NewLegacyProvider if it is not found.
+// back to addrs.NewDefaultProvider if it is not found.
 func (c *Config) ProviderForConfigAddr(addr addrs.LocalProviderConfig) addrs.Provider {
 	if provider, exists := c.Module.ProviderRequirements[addr.LocalName]; exists {
 		return provider.Type

configs/config_test.go

@@ -25,9 +25,9 @@ func TestConfigProviderTypes(t *testing.T) {
 
 	got = cfg.ProviderTypes()
 	want := []addrs.Provider{
-		addrs.NewLegacyProvider("aws"),
-		addrs.NewLegacyProvider("null"),
-		addrs.NewLegacyProvider("template"),
+		addrs.NewDefaultProvider("aws"),
+		addrs.NewDefaultProvider("null"),
+		addrs.NewDefaultProvider("template"),
 	}
 	for _, problem := range deep.Equal(got, want) {
 		t.Error(problem)
@@ -50,10 +50,9 @@ func TestConfigProviderTypes_nested(t *testing.T) {
 
 	got = cfg.ProviderTypes()
 	want := []addrs.Provider{
-		// FIXME: this will be updated to NewDefaultProvider as we remove `Legacy*`
-		addrs.NewLegacyProvider("test"),
 		addrs.NewProvider(addrs.DefaultRegistryHost, "bar", "test"),
 		addrs.NewProvider(addrs.DefaultRegistryHost, "foo", "test"),
+		addrs.NewDefaultProvider("test"),
 	}
 
 	for _, problem := range deep.Equal(got, want) {
@@ -85,14 +84,8 @@ func TestConfigResolveAbsProviderAddr(t *testing.T) {
 		}
 		got := cfg.ResolveAbsProviderAddr(addr, addrs.RootModule)
 		want := addrs.AbsProviderConfig{
-			Module: addrs.RootModule,
-			// FIXME: At the time of writing we still have LocalProviderConfig
-			// nested inside AbsProviderConfig, but a future change will
-			// stop tis embedding and just have an addrs.Provider and an alias
-			// string here, at which point the correct result will be:
-			//    Provider as the addrs repr of "registry.terraform.io/hashicorp/implied"
-			//    Alias as "boop".
-			Provider: addrs.NewLegacyProvider("implied"),
+			Module:   addrs.RootModule,
+			Provider: addrs.NewDefaultProvider("implied"),
 			Alias:    "boop",
 		}
 		if got, want := got.String(), want.String(); got != want {
@@ -128,13 +121,9 @@ func TestConfigProviderRequirements(t *testing.T) {
 		svchost.Hostname("tf.example.com"),
 		"awesomecorp", "happycloud",
 	)
-	// FIXME: these two are legacy ones for now because the config loader
-	// isn't using default configurations fully yet.
-	// Once that changes, these should be default-shaped ones like tlsProvider
-	// above.
-	nullProvider := addrs.NewLegacyProvider("null")
-	randomProvider := addrs.NewLegacyProvider("random")
-	impliedProvider := addrs.NewLegacyProvider("implied")
+	nullProvider := addrs.NewDefaultProvider("null")
+	randomProvider := addrs.NewDefaultProvider("random")
+	impliedProvider := addrs.NewDefaultProvider("implied")
 
 	got, diags := cfg.ProviderRequirements()
 	assertNoDiagnostics(t, diags)
@@ -152,7 +141,7 @@ func TestConfigProviderRequirements(t *testing.T) {
 	}
 }
 
-func TestProviderForConfigAddr(t *testing.T) {
+func TestConfigProviderForConfigAddr(t *testing.T) {
 	cfg, diags := testModuleConfigFromDir("testdata/valid-modules/providers-fqns")
 	assertNoDiagnostics(t, diags)
 
@@ -162,9 +151,9 @@ func TestProviderForConfigAddr(t *testing.T) {
 		t.Errorf("wrong result\ngot:  %s\nwant: %s", got, want)
 	}
 
-	// now check a provider that isn't in the configuration. It should return a NewLegacyProvider.
+	// now check a provider that isn't in the configuration. It should return a DefaultProvider.
 	got = cfg.ProviderForConfigAddr(addrs.NewDefaultLocalProviderConfig("bar-test"))
-	want = addrs.NewLegacyProvider("bar-test")
+	want = addrs.NewDefaultProvider("bar-test")
 	if !got.Equals(want) {
 		t.Errorf("wrong result\ngot:  %s\nwant: %s", got, want)
 	}

configs/module.go

@@ -195,7 +195,7 @@ func (m *Module) appendFile(file *File) hcl.Diagnostics {
 			}
 			diags = append(diags, hclDiags...)
 		} else {
-			fqn = addrs.NewLegacyProvider(reqd.Name)
+			fqn = addrs.NewDefaultProvider(reqd.Name)
 		}
 		if existing, exists := m.ProviderRequirements[reqd.Name]; exists {
 			if existing.Type != fqn {
@@ -208,16 +208,16 @@ func (m *Module) appendFile(file *File) hcl.Diagnostics {
 	}
 
 	for _, pm := range file.ProviderMetas {
-		// TODO(paddy): pm.Provider is a string, but we need to build an addrs.Provider out of it somehow
-		if existing, exists := m.ProviderMetas[addrs.NewLegacyProvider(pm.Provider)]; exists {
+		provider := m.ProviderForLocalConfig(addrs.LocalProviderConfig{LocalName: pm.Provider})
+		if existing, exists := m.ProviderMetas[provider]; exists {
 			diags = append(diags, &hcl.Diagnostic{
 				Severity: hcl.DiagError,
 				Summary:  "Duplicate provider_meta block",
 				Detail:   fmt.Sprintf("A provider_meta block for provider %q was already declared at %s. Providers may only have one provider_meta block per module.", existing.Provider, existing.DeclRange),
 				Subject:  &pm.DeclRange,
 			})
 		}
-		m.ProviderMetas[addrs.NewLegacyProvider(pm.Provider)] = pm
+		m.ProviderMetas[provider] = pm
 	}
 
 	for _, v := range file.Variables {
@@ -282,20 +282,15 @@ func (m *Module) appendFile(file *File) hcl.Diagnostics {
 		m.ManagedResources[key] = r
 
 		// set the provider FQN for the resource
-		var provider addrs.Provider
 		if r.ProviderConfigRef != nil {
 			if existing, exists := m.ProviderRequirements[r.ProviderConfigAddr().LocalName]; exists {
-				provider = existing.Type
+				r.Provider = existing.Type
 			} else {
-				// FIXME: This will be a NewDefaultProvider
-				provider = addrs.NewLegacyProvider(r.ProviderConfigAddr().LocalName)
+				r.Provider = addrs.NewDefaultProvider(r.ProviderConfigAddr().LocalName)
 			}
-			r.Provider = provider
 			continue
 		}
-		// FIXME: this will replaced with NewDefaultProvider when provider
-		// source is fully implemented.
-		r.Provider = addrs.NewLegacyProvider(r.Addr().ImpliedProvider())
+		r.Provider = addrs.NewDefaultProvider(r.Addr().ImpliedProvider())
 	}
 
 	for _, r := range file.DataResources {
@@ -312,20 +307,16 @@ func (m *Module) appendFile(file *File) hcl.Diagnostics {
 		m.DataResources[key] = r
 
 		// set the provider FQN for the resource
-		var provider addrs.Provider
 		if r.ProviderConfigRef != nil {
 			if existing, exists := m.ProviderRequirements[r.ProviderConfigAddr().LocalName]; exists {
-				provider = existing.Type
+				r.Provider = existing.Type
+
 			} else {
-				// FIXME: This will be a NewDefaultProvider
-				provider = addrs.NewLegacyProvider(r.ProviderConfigAddr().LocalName)
+				r.Provider = addrs.NewDefaultProvider(r.ProviderConfigAddr().LocalName)
 			}
-			r.Provider = provider
 			continue
 		}
-		// FIXME: this will replaced with NewDefaultProvider when provider
-		// source is fully implemented.
-		r.Provider = addrs.NewLegacyProvider(r.Addr().ImpliedProvider())
+		r.Provider = addrs.NewDefaultProvider(r.Addr().ImpliedProvider())
 	}
 
 	return diags
@@ -520,5 +511,5 @@ func (m *Module) ProviderForLocalConfig(pc addrs.LocalProviderConfig) addrs.Prov
 	if provider, exists := m.ProviderRequirements[pc.LocalName]; exists {
 		return provider.Type
 	}
-	return addrs.NewLegacyProvider(pc.LocalName)
+	return addrs.NewDefaultProvider(pc.LocalName)
 }

configs/module_merge.go

@@ -48,7 +48,7 @@ func mergeProviderVersionConstraints(recv map[string]ProviderRequirements, ovrd
 			// any errors parsing the source string will have already been captured.
 			fqn, _ = addrs.ParseProviderSourceString(reqd.Source.SourceStr)
 		} else {
-			fqn = addrs.NewLegacyProvider(reqd.Name)
+			fqn = addrs.NewDefaultProvider(reqd.Name)
 		}
 		recv[reqd.Name] = ProviderRequirements{Type: fqn, VersionConstraints: []VersionConstraint{reqd.Requirement}}
 	}
@@ -218,7 +218,7 @@ func (r *Resource) merge(or *Resource, prs map[string]ProviderRequirements) hcl.
 		if existing, exists := prs[or.ProviderConfigRef.Name]; exists {
 			r.Provider = existing.Type
 		} else {
-			r.Provider = addrs.NewLegacyProvider(r.ProviderConfigRef.Name)
+			r.Provider = addrs.NewDefaultProvider(r.ProviderConfigRef.Name)
 		}
 	}
 

configs/module_merge_test.go

@@ -224,7 +224,7 @@ func TestModuleOverrideResourceFQNs(t *testing.T) {
 
 	// now verify that a resource with no provider config falls back to default
 	got = mod.ManagedResources["test_instance.default"]
-	wantProvider = addrs.NewLegacyProvider("test")
+	wantProvider = addrs.NewDefaultProvider("test")
 	if !got.Provider.Equals(wantProvider) {
 		t.Fatalf("wrong provider %s, want %s", got.Provider, wantProvider)
 	}
@@ -267,7 +267,7 @@ func TestMergeProviderVersionConstraints(t *testing.T) {
 					VersionConstraints: []VersionConstraint{},
 				},
 				"null": ProviderRequirements{
-					Type: addrs.NewLegacyProvider("null"),
+					Type: addrs.NewDefaultProvider("null"),
 					VersionConstraints: []VersionConstraint{
 						VersionConstraint{
 							Required:  version.Constraints(nil),
@@ -292,7 +292,7 @@ func TestMergeProviderVersionConstraints(t *testing.T) {
 			},
 			map[string]ProviderRequirements{
 				"random": ProviderRequirements{
-					Type:               addrs.NewLegacyProvider("random"),
+					Type:               addrs.NewDefaultProvider("random"),
 					VersionConstraints: []VersionConstraint{vc2},
 				},
 			},

configs/module_test.go

@@ -45,7 +45,7 @@ func TestNewModule_resource_providers(t *testing.T) {
 	// both the root and child module have two resources, one which should use
 	// the default implied provider and one explicitly using a provider set in
 	// required_providers
-	wantImplicit := addrs.NewLegacyProvider("test")
+	wantImplicit := addrs.NewDefaultProvider("test")
 	wantFoo := addrs.NewProvider(addrs.DefaultRegistryHost, "foo", "test")
 	wantBar := addrs.NewProvider(addrs.DefaultRegistryHost, "bar", "test")