github.com/iaas-resource-provision/iaas-rpc@v1.0.7-0.20211021023331-ed21f798c408/internal/configs/config_test.go (about)

     1  package configs
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/go-test/deep"
     7  	"github.com/google/go-cmp/cmp"
     8  	"github.com/google/go-cmp/cmp/cmpopts"
     9  	"github.com/zclconf/go-cty/cty"
    10  
    11  	version "github.com/hashicorp/go-version"
    12  	"github.com/hashicorp/hcl/v2/hclsyntax"
    13  	svchost "github.com/iaas-resource-provision/iaas-rpc-svchost"
    14  	"github.com/iaas-resource-provision/iaas-rpc/internal/addrs"
    15  	"github.com/iaas-resource-provision/iaas-rpc/internal/getproviders"
    16  )
    17  
    18  func TestConfigProviderTypes(t *testing.T) {
    19  	// nil cfg should return an empty map
    20  	got := NewEmptyConfig().ProviderTypes()
    21  	if len(got) != 0 {
    22  		t.Fatal("expected empty result from empty config")
    23  	}
    24  
    25  	cfg, diags := testModuleConfigFromFile("testdata/valid-files/providers-explicit-implied.tf")
    26  	if diags.HasErrors() {
    27  		t.Fatal(diags.Error())
    28  	}
    29  
    30  	got = cfg.ProviderTypes()
    31  	want := []addrs.Provider{
    32  		addrs.NewDefaultProvider("aws"),
    33  		addrs.NewDefaultProvider("null"),
    34  		addrs.NewDefaultProvider("template"),
    35  		addrs.NewDefaultProvider("test"),
    36  	}
    37  	for _, problem := range deep.Equal(got, want) {
    38  		t.Error(problem)
    39  	}
    40  }
    41  
    42  func TestConfigProviderTypes_nested(t *testing.T) {
    43  	// basic test with a nil config
    44  	c := NewEmptyConfig()
    45  	got := c.ProviderTypes()
    46  	if len(got) != 0 {
    47  		t.Fatalf("wrong result!\ngot: %#v\nwant: nil\n", got)
    48  	}
    49  
    50  	// config with two provider sources, and one implicit (default) provider
    51  	cfg, diags := testNestedModuleConfigFromDir(t, "testdata/valid-modules/nested-providers-fqns")
    52  	if diags.HasErrors() {
    53  		t.Fatal(diags.Error())
    54  	}
    55  
    56  	got = cfg.ProviderTypes()
    57  	want := []addrs.Provider{
    58  		addrs.NewProvider(addrs.DefaultRegistryHost, "bar", "test"),
    59  		addrs.NewProvider(addrs.DefaultRegistryHost, "foo", "test"),
    60  		addrs.NewDefaultProvider("test"),
    61  	}
    62  
    63  	for _, problem := range deep.Equal(got, want) {
    64  		t.Error(problem)
    65  	}
    66  }
    67  
    68  func TestConfigResolveAbsProviderAddr(t *testing.T) {
    69  	cfg, diags := testModuleConfigFromDir("testdata/providers-explicit-fqn")
    70  	if diags.HasErrors() {
    71  		t.Fatal(diags.Error())
    72  	}
    73  
    74  	t.Run("already absolute", func(t *testing.T) {
    75  		addr := addrs.AbsProviderConfig{
    76  			Module:   addrs.RootModule,
    77  			Provider: addrs.NewDefaultProvider("test"),
    78  			Alias:    "boop",
    79  		}
    80  		got := cfg.ResolveAbsProviderAddr(addr, addrs.RootModule)
    81  		if got, want := got.String(), addr.String(); got != want {
    82  			t.Errorf("wrong result\ngot:  %s\nwant: %s", got, want)
    83  		}
    84  	})
    85  	t.Run("local, implied mapping", func(t *testing.T) {
    86  		addr := addrs.LocalProviderConfig{
    87  			LocalName: "implied",
    88  			Alias:     "boop",
    89  		}
    90  		got := cfg.ResolveAbsProviderAddr(addr, addrs.RootModule)
    91  		want := addrs.AbsProviderConfig{
    92  			Module:   addrs.RootModule,
    93  			Provider: addrs.NewDefaultProvider("implied"),
    94  			Alias:    "boop",
    95  		}
    96  		if got, want := got.String(), want.String(); got != want {
    97  			t.Errorf("wrong result\ngot:  %s\nwant: %s", got, want)
    98  		}
    99  	})
   100  	t.Run("local, explicit mapping", func(t *testing.T) {
   101  		addr := addrs.LocalProviderConfig{
   102  			LocalName: "foo-test", // this is explicitly set in the config
   103  			Alias:     "boop",
   104  		}
   105  		got := cfg.ResolveAbsProviderAddr(addr, addrs.RootModule)
   106  		want := addrs.AbsProviderConfig{
   107  			Module:   addrs.RootModule,
   108  			Provider: addrs.NewProvider(addrs.DefaultRegistryHost, "foo", "test"),
   109  			Alias:    "boop",
   110  		}
   111  		if got, want := got.String(), want.String(); got != want {
   112  			t.Errorf("wrong result\ngot:  %s\nwant: %s", got, want)
   113  		}
   114  	})
   115  }
   116  
   117  func TestConfigProviderRequirements(t *testing.T) {
   118  	cfg, diags := testNestedModuleConfigFromDir(t, "testdata/provider-reqs")
   119  	// TODO: Version Constraint Deprecation.
   120  	// Once we've removed the version argument from provider configuration
   121  	// blocks, this can go back to expected 0 diagnostics.
   122  	// assertNoDiagnostics(t, diags)
   123  	assertDiagnosticCount(t, diags, 1)
   124  	assertDiagnosticSummary(t, diags, "Version constraints inside provider configuration blocks are deprecated")
   125  
   126  	tlsProvider := addrs.NewProvider(
   127  		addrs.DefaultRegistryHost,
   128  		"hashicorp", "tls",
   129  	)
   130  	happycloudProvider := addrs.NewProvider(
   131  		svchost.Hostname("tf.example.com"),
   132  		"awesomecorp", "happycloud",
   133  	)
   134  	nullProvider := addrs.NewDefaultProvider("null")
   135  	randomProvider := addrs.NewDefaultProvider("random")
   136  	impliedProvider := addrs.NewDefaultProvider("implied")
   137  	terraformProvider := addrs.NewBuiltInProvider("terraform")
   138  	configuredProvider := addrs.NewDefaultProvider("configured")
   139  	grandchildProvider := addrs.NewDefaultProvider("grandchild")
   140  
   141  	got, diags := cfg.ProviderRequirements()
   142  	assertNoDiagnostics(t, diags)
   143  	want := getproviders.Requirements{
   144  		// the nullProvider constraints from the two modules are merged
   145  		nullProvider:       getproviders.MustParseVersionConstraints("~> 2.0.0, 2.0.1"),
   146  		randomProvider:     getproviders.MustParseVersionConstraints("~> 1.2.0"),
   147  		tlsProvider:        getproviders.MustParseVersionConstraints("~> 3.0"),
   148  		configuredProvider: getproviders.MustParseVersionConstraints("~> 1.4"),
   149  		impliedProvider:    nil,
   150  		happycloudProvider: nil,
   151  		terraformProvider:  nil,
   152  		grandchildProvider: nil,
   153  	}
   154  
   155  	if diff := cmp.Diff(want, got); diff != "" {
   156  		t.Errorf("wrong result\n%s", diff)
   157  	}
   158  }
   159  
   160  func TestConfigProviderRequirementsShallow(t *testing.T) {
   161  	cfg, diags := testNestedModuleConfigFromDir(t, "testdata/provider-reqs")
   162  	// TODO: Version Constraint Deprecation.
   163  	// Once we've removed the version argument from provider configuration
   164  	// blocks, this can go back to expected 0 diagnostics.
   165  	// assertNoDiagnostics(t, diags)
   166  	assertDiagnosticCount(t, diags, 1)
   167  	assertDiagnosticSummary(t, diags, "Version constraints inside provider configuration blocks are deprecated")
   168  
   169  	tlsProvider := addrs.NewProvider(
   170  		addrs.DefaultRegistryHost,
   171  		"hashicorp", "tls",
   172  	)
   173  	nullProvider := addrs.NewDefaultProvider("null")
   174  	randomProvider := addrs.NewDefaultProvider("random")
   175  	impliedProvider := addrs.NewDefaultProvider("implied")
   176  	terraformProvider := addrs.NewBuiltInProvider("terraform")
   177  	configuredProvider := addrs.NewDefaultProvider("configured")
   178  
   179  	got, diags := cfg.ProviderRequirementsShallow()
   180  	assertNoDiagnostics(t, diags)
   181  	want := getproviders.Requirements{
   182  		// the nullProvider constraint is only from the root module
   183  		nullProvider:       getproviders.MustParseVersionConstraints("~> 2.0.0"),
   184  		randomProvider:     getproviders.MustParseVersionConstraints("~> 1.2.0"),
   185  		tlsProvider:        getproviders.MustParseVersionConstraints("~> 3.0"),
   186  		configuredProvider: getproviders.MustParseVersionConstraints("~> 1.4"),
   187  		impliedProvider:    nil,
   188  		terraformProvider:  nil,
   189  	}
   190  
   191  	if diff := cmp.Diff(want, got); diff != "" {
   192  		t.Errorf("wrong result\n%s", diff)
   193  	}
   194  }
   195  
   196  func TestConfigProviderRequirementsByModule(t *testing.T) {
   197  	cfg, diags := testNestedModuleConfigFromDir(t, "testdata/provider-reqs")
   198  	// TODO: Version Constraint Deprecation.
   199  	// Once we've removed the version argument from provider configuration
   200  	// blocks, this can go back to expected 0 diagnostics.
   201  	// assertNoDiagnostics(t, diags)
   202  	assertDiagnosticCount(t, diags, 1)
   203  	assertDiagnosticSummary(t, diags, "Version constraints inside provider configuration blocks are deprecated")
   204  
   205  	tlsProvider := addrs.NewProvider(
   206  		addrs.DefaultRegistryHost,
   207  		"hashicorp", "tls",
   208  	)
   209  	happycloudProvider := addrs.NewProvider(
   210  		svchost.Hostname("tf.example.com"),
   211  		"awesomecorp", "happycloud",
   212  	)
   213  	nullProvider := addrs.NewDefaultProvider("null")
   214  	randomProvider := addrs.NewDefaultProvider("random")
   215  	impliedProvider := addrs.NewDefaultProvider("implied")
   216  	terraformProvider := addrs.NewBuiltInProvider("terraform")
   217  	configuredProvider := addrs.NewDefaultProvider("configured")
   218  	grandchildProvider := addrs.NewDefaultProvider("grandchild")
   219  
   220  	got, diags := cfg.ProviderRequirementsByModule()
   221  	assertNoDiagnostics(t, diags)
   222  	want := &ModuleRequirements{
   223  		Name:       "",
   224  		SourceAddr: "",
   225  		SourceDir:  "testdata/provider-reqs",
   226  		Requirements: getproviders.Requirements{
   227  			// Only the root module's version is present here
   228  			nullProvider:       getproviders.MustParseVersionConstraints("~> 2.0.0"),
   229  			randomProvider:     getproviders.MustParseVersionConstraints("~> 1.2.0"),
   230  			tlsProvider:        getproviders.MustParseVersionConstraints("~> 3.0"),
   231  			configuredProvider: getproviders.MustParseVersionConstraints("~> 1.4"),
   232  			impliedProvider:    nil,
   233  			terraformProvider:  nil,
   234  		},
   235  		Children: map[string]*ModuleRequirements{
   236  			"kinder": {
   237  				Name:       "kinder",
   238  				SourceAddr: "./child",
   239  				SourceDir:  "testdata/provider-reqs/child",
   240  				Requirements: getproviders.Requirements{
   241  					nullProvider:       getproviders.MustParseVersionConstraints("= 2.0.1"),
   242  					happycloudProvider: nil,
   243  				},
   244  				Children: map[string]*ModuleRequirements{
   245  					"nested": {
   246  						Name:       "nested",
   247  						SourceAddr: "./grandchild",
   248  						SourceDir:  "testdata/provider-reqs/child/grandchild",
   249  						Requirements: getproviders.Requirements{
   250  							grandchildProvider: nil,
   251  						},
   252  						Children: map[string]*ModuleRequirements{},
   253  					},
   254  				},
   255  			},
   256  		},
   257  	}
   258  
   259  	ignore := cmpopts.IgnoreUnexported(version.Constraint{}, cty.Value{}, hclsyntax.Body{})
   260  	if diff := cmp.Diff(want, got, ignore); diff != "" {
   261  		t.Errorf("wrong result\n%s", diff)
   262  	}
   263  }
   264  
   265  func TestConfigProviderForConfigAddr(t *testing.T) {
   266  	cfg, diags := testModuleConfigFromDir("testdata/valid-modules/providers-fqns")
   267  	assertNoDiagnostics(t, diags)
   268  
   269  	got := cfg.ProviderForConfigAddr(addrs.NewDefaultLocalProviderConfig("foo-test"))
   270  	want := addrs.NewProvider(addrs.DefaultRegistryHost, "foo", "test")
   271  	if !got.Equals(want) {
   272  		t.Errorf("wrong result\ngot:  %s\nwant: %s", got, want)
   273  	}
   274  
   275  	// now check a provider that isn't in the configuration. It should return a DefaultProvider.
   276  	got = cfg.ProviderForConfigAddr(addrs.NewDefaultLocalProviderConfig("bar-test"))
   277  	want = addrs.NewDefaultProvider("bar-test")
   278  	if !got.Equals(want) {
   279  		t.Errorf("wrong result\ngot:  %s\nwant: %s", got, want)
   280  	}
   281  }
   282  
   283  func TestConfigAddProviderRequirements(t *testing.T) {
   284  	cfg, diags := testModuleConfigFromFile("testdata/valid-files/providers-explicit-implied.tf")
   285  	assertNoDiagnostics(t, diags)
   286  
   287  	reqs := getproviders.Requirements{
   288  		addrs.NewDefaultProvider("null"): nil,
   289  	}
   290  	diags = cfg.addProviderRequirements(reqs, true)
   291  	assertNoDiagnostics(t, diags)
   292  }