blob: 2e38673f3e4a423f03f3fa9f21de018721c0de83 [file] [log] [blame]
package addrs
import (
"testing"
"github.com/google/go-cmp/cmp"
svchost "github.com/hashicorp/terraform-svchost"
)
func TestParseModuleSource(t *testing.T) {
tests := map[string]struct {
input string
want ModuleSource
wantErr string
}{
// Local paths
"local in subdirectory": {
input: "./child",
want: ModuleSourceLocal("./child"),
},
"local in subdirectory non-normalized": {
input: "./nope/../child",
want: ModuleSourceLocal("./child"),
},
"local in sibling directory": {
input: "../sibling",
want: ModuleSourceLocal("../sibling"),
},
"local in sibling directory non-normalized": {
input: "./nope/../../sibling",
want: ModuleSourceLocal("../sibling"),
},
"Windows-style local in subdirectory": {
input: `.\child`,
want: ModuleSourceLocal("./child"),
},
"Windows-style local in subdirectory non-normalized": {
input: `.\nope\..\child`,
want: ModuleSourceLocal("./child"),
},
"Windows-style local in sibling directory": {
input: `..\sibling`,
want: ModuleSourceLocal("../sibling"),
},
"Windows-style local in sibling directory non-normalized": {
input: `.\nope\..\..\sibling`,
want: ModuleSourceLocal("../sibling"),
},
"an abominable mix of different slashes": {
input: `./nope\nope/why\./please\don't`,
want: ModuleSourceLocal("./nope/nope/why/please/don't"),
},
// Registry addresses
// (NOTE: There is another test function TestParseModuleSourceRegistry
// which tests this situation more exhaustively, so this is just a
// token set of cases to see that we are indeed calling into the
// registry address parser when appropriate.)
"main registry implied": {
input: "hashicorp/subnets/cidr",
want: ModuleSourceRegistry{
Package: ModuleRegistryPackage{
Host: svchost.Hostname("registry.terraform.io"),
Namespace: "hashicorp",
Name: "subnets",
TargetSystem: "cidr",
},
Subdir: "",
},
},
"main registry implied, subdir": {
input: "hashicorp/subnets/cidr//examples/foo",
want: ModuleSourceRegistry{
Package: ModuleRegistryPackage{
Host: svchost.Hostname("registry.terraform.io"),
Namespace: "hashicorp",
Name: "subnets",
TargetSystem: "cidr",
},
Subdir: "examples/foo",
},
},
"main registry implied, escaping subdir": {
input: "hashicorp/subnets/cidr//../nope",
// NOTE: This error is actually being caught by the _remote package_
// address parser, because any registry parsing failure falls back
// to that but both of them have the same subdir validation. This
// case is here to make sure that stays true, so we keep reporting
// a suitable error when the user writes a registry-looking thing.
wantErr: `subdirectory path "../nope" leads outside of the module package`,
},
"custom registry": {
input: "example.com/awesomecorp/network/happycloud",
want: ModuleSourceRegistry{
Package: ModuleRegistryPackage{
Host: svchost.Hostname("example.com"),
Namespace: "awesomecorp",
Name: "network",
TargetSystem: "happycloud",
},
Subdir: "",
},
},
"custom registry, subdir": {
input: "example.com/awesomecorp/network/happycloud//examples/foo",
want: ModuleSourceRegistry{
Package: ModuleRegistryPackage{
Host: svchost.Hostname("example.com"),
Namespace: "awesomecorp",
Name: "network",
TargetSystem: "happycloud",
},
Subdir: "examples/foo",
},
},
// Remote package addresses
"github.com shorthand": {
input: "github.com/hashicorp/terraform-cidr-subnets",
want: ModuleSourceRemote{
Package: ModulePackage("git::https://github.com/hashicorp/terraform-cidr-subnets.git"),
},
},
"github.com shorthand, subdir": {
input: "github.com/hashicorp/terraform-cidr-subnets//example/foo",
want: ModuleSourceRemote{
Package: ModulePackage("git::https://github.com/hashicorp/terraform-cidr-subnets.git"),
Subdir: "example/foo",
},
},
"git protocol, URL-style": {
input: "git://example.com/code/baz.git",
want: ModuleSourceRemote{
Package: ModulePackage("git://example.com/code/baz.git"),
},
},
"git protocol, URL-style, subdir": {
input: "git://example.com/code/baz.git//bleep/bloop",
want: ModuleSourceRemote{
Package: ModulePackage("git://example.com/code/baz.git"),
Subdir: "bleep/bloop",
},
},
"git over HTTPS, URL-style": {
input: "git::https://example.com/code/baz.git",
want: ModuleSourceRemote{
Package: ModulePackage("git::https://example.com/code/baz.git"),
},
},
"git over HTTPS, URL-style, subdir": {
input: "git::https://example.com/code/baz.git//bleep/bloop",
want: ModuleSourceRemote{
Package: ModulePackage("git::https://example.com/code/baz.git"),
Subdir: "bleep/bloop",
},
},
"git over HTTPS, URL-style, subdir, query parameters": {
input: "git::https://example.com/code/baz.git//bleep/bloop?otherthing=blah",
want: ModuleSourceRemote{
Package: ModulePackage("git::https://example.com/code/baz.git?otherthing=blah"),
Subdir: "bleep/bloop",
},
},
"git over SSH, URL-style": {
input: "git::ssh://git@example.com/code/baz.git",
want: ModuleSourceRemote{
Package: ModulePackage("git::ssh://git@example.com/code/baz.git"),
},
},
"git over SSH, URL-style, subdir": {
input: "git::ssh://git@example.com/code/baz.git//bleep/bloop",
want: ModuleSourceRemote{
Package: ModulePackage("git::ssh://git@example.com/code/baz.git"),
Subdir: "bleep/bloop",
},
},
"git over SSH, scp-style": {
input: "git::git@example.com:code/baz.git",
want: ModuleSourceRemote{
// Normalized to URL-style
Package: ModulePackage("git::ssh://git@example.com/code/baz.git"),
},
},
"git over SSH, scp-style, subdir": {
input: "git::git@example.com:code/baz.git//bleep/bloop",
want: ModuleSourceRemote{
// Normalized to URL-style
Package: ModulePackage("git::ssh://git@example.com/code/baz.git"),
Subdir: "bleep/bloop",
},
},
// NOTE: We intentionally don't test the bitbucket.org shorthands
// here, because that detector makes direct HTTP tequests to the
// Bitbucket API and thus isn't appropriate for unit testing.
"Google Cloud Storage bucket implied, path prefix": {
input: "www.googleapis.com/storage/v1/BUCKET_NAME/PATH_TO_MODULE",
want: ModuleSourceRemote{
Package: ModulePackage("gcs::https://www.googleapis.com/storage/v1/BUCKET_NAME/PATH_TO_MODULE"),
},
},
"Google Cloud Storage bucket, path prefix": {
input: "gcs::https://www.googleapis.com/storage/v1/BUCKET_NAME/PATH_TO_MODULE",
want: ModuleSourceRemote{
Package: ModulePackage("gcs::https://www.googleapis.com/storage/v1/BUCKET_NAME/PATH_TO_MODULE"),
},
},
"Google Cloud Storage bucket implied, archive object": {
input: "www.googleapis.com/storage/v1/BUCKET_NAME/PATH/TO/module.zip",
want: ModuleSourceRemote{
Package: ModulePackage("gcs::https://www.googleapis.com/storage/v1/BUCKET_NAME/PATH/TO/module.zip"),
},
},
"Google Cloud Storage bucket, archive object": {
input: "gcs::https://www.googleapis.com/storage/v1/BUCKET_NAME/PATH/TO/module.zip",
want: ModuleSourceRemote{
Package: ModulePackage("gcs::https://www.googleapis.com/storage/v1/BUCKET_NAME/PATH/TO/module.zip"),
},
},
"Amazon S3 bucket implied, archive object": {
input: "s3-eu-west-1.amazonaws.com/examplecorp-terraform-modules/vpc.zip",
want: ModuleSourceRemote{
Package: ModulePackage("s3::https://s3-eu-west-1.amazonaws.com/examplecorp-terraform-modules/vpc.zip"),
},
},
"Amazon S3 bucket, archive object": {
input: "s3::https://s3-eu-west-1.amazonaws.com/examplecorp-terraform-modules/vpc.zip",
want: ModuleSourceRemote{
Package: ModulePackage("s3::https://s3-eu-west-1.amazonaws.com/examplecorp-terraform-modules/vpc.zip"),
},
},
"HTTP URL": {
input: "http://example.com/module",
want: ModuleSourceRemote{
Package: ModulePackage("http://example.com/module"),
},
},
"HTTPS URL": {
input: "https://example.com/module",
want: ModuleSourceRemote{
Package: ModulePackage("https://example.com/module"),
},
},
"HTTPS URL, archive file": {
input: "https://example.com/module.zip",
want: ModuleSourceRemote{
Package: ModulePackage("https://example.com/module.zip"),
},
},
"HTTPS URL, forced archive file": {
input: "https://example.com/module?archive=tar",
want: ModuleSourceRemote{
Package: ModulePackage("https://example.com/module?archive=tar"),
},
},
"HTTPS URL, forced archive file and checksum": {
input: "https://example.com/module?archive=tar&checksum=blah",
want: ModuleSourceRemote{
// The query string only actually gets processed when we finally
// do the get, so "checksum=blah" is accepted as valid up
// at this parsing layer.
Package: ModulePackage("https://example.com/module?archive=tar&checksum=blah"),
},
},
"absolute filesystem path": {
// Although a local directory isn't really "remote", we do
// treat it as such because we still need to do all of the same
// high-level steps to work with these, even though "downloading"
// is replaced by a deep filesystem copy instead.
input: "/tmp/foo/example",
want: ModuleSourceRemote{
Package: ModulePackage("file:///tmp/foo/example"),
},
},
"absolute filesystem path, subdir": {
// This is a funny situation where the user wants to use a
// directory elsewhere on their system as a package containing
// multiple modules, but the entry point is not at the root
// of that subtree, and so they can use the usual subdir
// syntax to move the package root higher in the real filesystem.
input: "/tmp/foo//example",
want: ModuleSourceRemote{
Package: ModulePackage("file:///tmp/foo"),
Subdir: "example",
},
},
"subdir escaping out of package": {
// This is general logic for all subdir regardless of installation
// protocol, but we're using a filesystem path here just as an
// easy placeholder/
input: "/tmp/foo//example/../../invalid",
wantErr: `subdirectory path "../invalid" leads outside of the module package`,
},
"relative path without the needed prefix": {
input: "boop/bloop",
// For this case we return a generic error message from the addrs
// layer, but using a specialized error type which our module
// installer checks for and produces an extra hint for users who
// were intending to write a local path which then got
// misinterpreted as a remote source due to the missing prefix.
// However, the main message is generic here because this is really
// just a general "this string doesn't match any of our source
// address patterns" situation, not _necessarily_ about relative
// local paths.
wantErr: `Terraform cannot detect a supported external module source type for boop/bloop`,
},
"go-getter will accept all sorts of garbage": {
input: "dfgdfgsd:dgfhdfghdfghdfg/dfghdfghdfg",
want: ModuleSourceRemote{
// Unfortunately go-getter doesn't actually reject a totally
// invalid address like this until getting time, as long as
// it looks somewhat like a URL.
Package: ModulePackage("dfgdfgsd:dgfhdfghdfghdfg/dfghdfghdfg"),
},
},
}
for name, test := range tests {
t.Run(name, func(t *testing.T) {
addr, err := ParseModuleSource(test.input)
if test.wantErr != "" {
switch {
case err == nil:
t.Errorf("unexpected success\nwant error: %s", test.wantErr)
case err.Error() != test.wantErr:
t.Errorf("wrong error messages\ngot: %s\nwant: %s", err.Error(), test.wantErr)
}
return
}
if err != nil {
t.Fatalf("unexpected error: %s", err.Error())
}
if diff := cmp.Diff(addr, test.want); diff != "" {
t.Errorf("wrong result\n%s", diff)
}
})
}
}
func TestModuleSourceRemoteFromRegistry(t *testing.T) {
t.Run("both have subdir", func(t *testing.T) {
remote := ModuleSourceRemote{
Package: ModulePackage("boop"),
Subdir: "foo",
}
registry := ModuleSourceRegistry{
Subdir: "bar",
}
gotAddr := remote.FromRegistry(registry)
if remote.Subdir != "foo" {
t.Errorf("FromRegistry modified the reciever; should be pure function")
}
if registry.Subdir != "bar" {
t.Errorf("FromRegistry modified the given address; should be pure function")
}
if got, want := gotAddr.Subdir, "foo/bar"; got != want {
t.Errorf("wrong resolved subdir\ngot: %s\nwant: %s", got, want)
}
})
t.Run("only remote has subdir", func(t *testing.T) {
remote := ModuleSourceRemote{
Package: ModulePackage("boop"),
Subdir: "foo",
}
registry := ModuleSourceRegistry{
Subdir: "",
}
gotAddr := remote.FromRegistry(registry)
if remote.Subdir != "foo" {
t.Errorf("FromRegistry modified the reciever; should be pure function")
}
if registry.Subdir != "" {
t.Errorf("FromRegistry modified the given address; should be pure function")
}
if got, want := gotAddr.Subdir, "foo"; got != want {
t.Errorf("wrong resolved subdir\ngot: %s\nwant: %s", got, want)
}
})
t.Run("only registry has subdir", func(t *testing.T) {
remote := ModuleSourceRemote{
Package: ModulePackage("boop"),
Subdir: "",
}
registry := ModuleSourceRegistry{
Subdir: "bar",
}
gotAddr := remote.FromRegistry(registry)
if remote.Subdir != "" {
t.Errorf("FromRegistry modified the reciever; should be pure function")
}
if registry.Subdir != "bar" {
t.Errorf("FromRegistry modified the given address; should be pure function")
}
if got, want := gotAddr.Subdir, "bar"; got != want {
t.Errorf("wrong resolved subdir\ngot: %s\nwant: %s", got, want)
}
})
}
func TestParseModuleSourceRemote(t *testing.T) {
tests := map[string]struct {
input string
wantString string
wantForDisplay string
wantErr string
}{
"git over HTTPS, URL-style, query parameters": {
// Query parameters should be correctly appended after the Package
input: `git::https://example.com/code/baz.git?otherthing=blah`,
wantString: `git::https://example.com/code/baz.git?otherthing=blah`,
wantForDisplay: `git::https://example.com/code/baz.git?otherthing=blah`,
},
"git over HTTPS, URL-style, subdir, query parameters": {
// Query parameters should be correctly appended after the Package and Subdir
input: `git::https://example.com/code/baz.git//bleep/bloop?otherthing=blah`,
wantString: `git::https://example.com/code/baz.git//bleep/bloop?otherthing=blah`,
wantForDisplay: `git::https://example.com/code/baz.git//bleep/bloop?otherthing=blah`,
},
}
for name, test := range tests {
t.Run(name, func(t *testing.T) {
remote, err := parseModuleSourceRemote(test.input)
if test.wantErr != "" {
switch {
case err == nil:
t.Errorf("unexpected success\nwant error: %s", test.wantErr)
case err.Error() != test.wantErr:
t.Errorf("wrong error messages\ngot: %s\nwant: %s", err.Error(), test.wantErr)
}
return
}
if err != nil {
t.Fatalf("unexpected error: %s", err.Error())
}
if got, want := remote.String(), test.wantString; got != want {
t.Errorf("wrong String() result\ngot: %s\nwant: %s", got, want)
}
if got, want := remote.ForDisplay(), test.wantForDisplay; got != want {
t.Errorf("wrong ForDisplay() result\ngot: %s\nwant: %s", got, want)
}
})
}
}
func TestParseModuleSourceRegistry(t *testing.T) {
// We test parseModuleSourceRegistry alone here, in addition to testing
// it indirectly as part of TestParseModuleSource, because general
// module parsing unfortunately eats all of the error situations from
// registry passing by falling back to trying for a direct remote package
// address.
// Historical note: These test cases were originally derived from the
// ones in the old internal/registry/regsrc package that the
// ModuleSourceRegistry type is replacing. That package had the notion
// of "normalized" addresses as separate from the original user input,
// but this new implementation doesn't try to preserve the original
// user input at all, and so the main string output is always normalized.
//
// That package also had some behaviors to turn the namespace, name, and
// remote system portions into lowercase, but apparently we didn't
// actually make use of that in the end and were preserving the case
// the user provided in the input, and so for backward compatibility
// we're continuing to do that here, at the expense of now making the
// "ForDisplay" output case-preserving where its predecessor in the
// old package wasn't. The main Terraform Registry at registry.terraform.io
// is itself case-insensitive anyway, so our case-preserving here is
// entirely for the benefit of existing third-party registry
// implementations that might be case-sensitive, which we must remain
// compatible with now.
tests := map[string]struct {
input string
wantString string
wantForDisplay string
wantForProtocol string
wantErr string
}{
"public registry": {
input: `hashicorp/consul/aws`,
wantString: `registry.terraform.io/hashicorp/consul/aws`,
wantForDisplay: `hashicorp/consul/aws`,
wantForProtocol: `hashicorp/consul/aws`,
},
"public registry with subdir": {
input: `hashicorp/consul/aws//foo`,
wantString: `registry.terraform.io/hashicorp/consul/aws//foo`,
wantForDisplay: `hashicorp/consul/aws//foo`,
wantForProtocol: `hashicorp/consul/aws`,
},
"public registry using explicit hostname": {
input: `registry.terraform.io/hashicorp/consul/aws`,
wantString: `registry.terraform.io/hashicorp/consul/aws`,
wantForDisplay: `hashicorp/consul/aws`,
wantForProtocol: `hashicorp/consul/aws`,
},
"public registry with mixed case names": {
input: `HashiCorp/Consul/aws`,
wantString: `registry.terraform.io/HashiCorp/Consul/aws`,
wantForDisplay: `HashiCorp/Consul/aws`,
wantForProtocol: `HashiCorp/Consul/aws`,
},
"private registry with non-standard port": {
input: `Example.com:1234/HashiCorp/Consul/aws`,
wantString: `example.com:1234/HashiCorp/Consul/aws`,
wantForDisplay: `example.com:1234/HashiCorp/Consul/aws`,
wantForProtocol: `HashiCorp/Consul/aws`,
},
"private registry with IDN hostname": {
input: `Испытание.com/HashiCorp/Consul/aws`,
wantString: `испытание.com/HashiCorp/Consul/aws`,
wantForDisplay: `испытание.com/HashiCorp/Consul/aws`,
wantForProtocol: `HashiCorp/Consul/aws`,
},
"private registry with IDN hostname and non-standard port": {
input: `Испытание.com:1234/HashiCorp/Consul/aws//Foo`,
wantString: `испытание.com:1234/HashiCorp/Consul/aws//Foo`,
wantForDisplay: `испытание.com:1234/HashiCorp/Consul/aws//Foo`,
wantForProtocol: `HashiCorp/Consul/aws`,
},
"invalid hostname": {
input: `---.com/HashiCorp/Consul/aws`,
wantErr: `invalid module registry hostname "---.com"; internationalized domain names must be given as direct unicode characters, not in punycode`,
},
"hostname with only one label": {
// This was historically forbidden in our initial implementation,
// so we keep it forbidden to avoid newly interpreting such
// addresses as registry addresses rather than remote source
// addresses.
input: `foo/var/baz/qux`,
wantErr: `invalid module registry hostname: must contain at least one dot`,
},
"invalid target system characters": {
input: `foo/var/no-no-no`,
wantErr: `invalid target system "no-no-no": must be between one and 64 ASCII letters or digits`,
},
"invalid target system length": {
input: `foo/var/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaah`,
wantErr: `invalid target system "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaah": must be between one and 64 ASCII letters or digits`,
},
"invalid namespace": {
input: `boop!/var/baz`,
wantErr: `invalid namespace "boop!": must be between one and 64 characters, including ASCII letters, digits, dashes, and underscores, where dashes and underscores may not be the prefix or suffix`,
},
"missing part with explicit hostname": {
input: `foo.com/var/baz`,
wantErr: `source address must have three more components after the hostname: the namespace, the name, and the target system`,
},
"errant query string": {
input: `foo/var/baz?otherthing`,
wantErr: `module registry addresses may not include a query string portion`,
},
"github.com": {
// We don't allow using github.com like a module registry because
// that conflicts with the historically-supported shorthand for
// installing directly from GitHub-hosted git repositories.
input: `github.com/HashiCorp/Consul/aws`,
wantErr: `can't use "github.com" as a module registry host, because it's reserved for installing directly from version control repositories`,
},
"bitbucket.org": {
// We don't allow using bitbucket.org like a module registry because
// that conflicts with the historically-supported shorthand for
// installing directly from BitBucket-hosted git repositories.
input: `bitbucket.org/HashiCorp/Consul/aws`,
wantErr: `can't use "bitbucket.org" as a module registry host, because it's reserved for installing directly from version control repositories`,
},
"local path from current dir": {
// Can't use a local path when we're specifically trying to parse
// a _registry_ source address.
input: `./boop`,
wantErr: `can't use local directory "./boop" as a module registry address`,
},
"local path from parent dir": {
// Can't use a local path when we're specifically trying to parse
// a _registry_ source address.
input: `../boop`,
wantErr: `can't use local directory "../boop" as a module registry address`,
},
}
for name, test := range tests {
t.Run(name, func(t *testing.T) {
addrI, err := ParseModuleSourceRegistry(test.input)
if test.wantErr != "" {
switch {
case err == nil:
t.Errorf("unexpected success\nwant error: %s", test.wantErr)
case err.Error() != test.wantErr:
t.Errorf("wrong error messages\ngot: %s\nwant: %s", err.Error(), test.wantErr)
}
return
}
if err != nil {
t.Fatalf("unexpected error: %s", err.Error())
}
addr, ok := addrI.(ModuleSourceRegistry)
if !ok {
t.Fatalf("wrong address type %T; want %T", addrI, addr)
}
if got, want := addr.String(), test.wantString; got != want {
t.Errorf("wrong String() result\ngot: %s\nwant: %s", got, want)
}
if got, want := addr.ForDisplay(), test.wantForDisplay; got != want {
t.Errorf("wrong ForDisplay() result\ngot: %s\nwant: %s", got, want)
}
if got, want := addr.Package.ForRegistryProtocol(), test.wantForProtocol; got != want {
t.Errorf("wrong ForRegistryProtocol() result\ngot: %s\nwant: %s", got, want)
}
})
}
}