fix ValidateProviderAddress + Introduce Provider.Validate + Provider (un)marshaler interfaces (#104)

Author: radeksimko

provider.go

@@ -128,6 +128,59 @@ func (pt Provider) IsZero() bool {
 	return pt == Provider{}
 }
 
+// Validate returns error if the Provider representing "modern"
+// (Terraform 0.14+) address is not valid. Valid address implies
+// both valid namespace and a non-empty hostname.
+//
+// Validation makes assumptions equivalent to [ValidateProviderAddress].
+//
+// If you can guarantee [ValidateProviderAddress] was called
+// on the input and the [Provider] data was not mutated
+// you should not need to call this method.
+func (pt Provider) Validate() error {
+	if pt.IsZero() {
+		return &ParserError{
+			Summary: "Empty provider address",
+			Detail:  "Expected address composed of hostname, provider namespace and name",
+		}
+	}
+
+	if pt.Hostname == "" {
+		return &ParserError{
+			Summary: "Unknown hostname",
+			Detail:  "Expected hostname in the provider address to be set",
+		}
+	}
+	if pt.Namespace == "" {
+		return &ParserError{
+			Summary: "Unknown provider namespace",
+			Detail:  "Expected provider namespace to be set",
+		}
+	}
+	if pt.Type == "" {
+		return &ParserError{
+			Summary: "Unknown provider type",
+			Detail:  "Expected provider type to be set",
+		}
+	}
+
+	if !pt.HasKnownNamespace() {
+		return &ParserError{
+			Summary: "Unknown provider namespace",
+			Detail:  `Expected FQN in the format "hostname/namespace/name"`,
+		}
+	}
+
+	if pt.IsLegacy() {
+		return &ParserError{
+			Summary: "Invalid legacy provider namespace",
+			Detail:  `Expected FQN in the format "hostname/namespace/name"`,
+		}
+	}
+
+	return nil
+}
+
 // HasKnownNamespace returns true if the provider namespace is known
 // (also if it is legacy namespace)
 func (pt Provider) HasKnownNamespace() bool {
@@ -162,6 +215,31 @@ func (pt Provider) LessThan(other Provider) bool {
 	}
 }
 
+// MarshalText implements encoding.TextMarshaler interface.
+//
+// It encodes the [Provider] into an FQN, equivalent to [String]
+// or returns an error for an invalid [Provider].
+func (pt Provider) MarshalText() ([]byte, error) {
+	err := pt.Validate()
+	if err != nil {
+		return nil, err
+	}
+
+	return []byte(pt.String()), nil
+}
+
+// UnmarshalText implements encoding.TextUnmarshaler interface.
+//
+// It decodes a valid provider address or returns an error
+// using [ParseProviderSource].
+//
+// [Validate] should be called on the decoded [Provider]
+// if modern-style Terraform 0.14+ addresses are expected.
+func (pt *Provider) UnmarshalText(text []byte) (err error) {
+	*pt, err = ParseProviderSource(string(text))
+	return
+}
+
 // IsLegacy returns true if the provider is a legacy-style provider
 func (pt Provider) IsLegacy() bool {
 	if pt.IsZero() {
@@ -182,9 +260,10 @@ func (pt Provider) Equals(other Provider) bool {
 // terraform-config-inspect.
 //
 // The following are valid source string formats:
-// 		name
-// 		namespace/name
-// 		hostname/namespace/name
+//
+//	name
+//	namespace/name
+//	hostname/namespace/name
 //
 // "name"-only format is parsed as -/name (i.e. legacy namespace)
 // requiring further identification of the namespace via Registry API
@@ -296,7 +375,7 @@ func ParseProviderSource(str string) (Provider, error) {
 
 // MustParseProviderSource is a wrapper around ParseProviderSource that panics if
 // it returns an error.
-func MustParseProviderSource(raw string) (Provider) {
+func MustParseProviderSource(raw string) Provider {
 	p, err := ParseProviderSource(raw)
 	if err != nil {
 		panic(err)
@@ -332,7 +411,7 @@ func ValidateProviderAddress(raw string) error {
 		}
 	}
 
-	if !p.IsLegacy() {
+	if p.IsLegacy() {
 		return &ParserError{
 			Summary: "Invalid legacy provider namespace",
 			Detail:  `Expected FQN in the format "hostname/namespace/name"`,

provider_test.go

@@ -4,6 +4,7 @@
 package tfaddr
 
 import (
+	"encoding/json"
 	"fmt"
 	"log"
 	"testing"
@@ -247,6 +248,148 @@ func TestProviderIsLegacy(t *testing.T) {
 	}
 }
 
+func TestValidate(t *testing.T) {
+	tests := []struct {
+		Input       Provider
+		ExpectedErr bool
+	}{
+		{
+			MustParseProviderSource("host.com/hashicorp/coffee"),
+			false,
+		},
+		{
+			Provider{},
+			true,
+		},
+		{
+			Provider{
+				Type: "latte",
+			},
+			true,
+		},
+		{
+			Provider{
+				Type:      "latte",
+				Namespace: "coffeeshop",
+			},
+			true,
+		},
+		{
+			Provider{
+				Hostname: svchost.Hostname("registry.terraform.io"),
+			},
+			true,
+		},
+		{
+			MustParseProviderSource("unknown-namespace"),
+			true,
+		},
+		{
+			MustParseProviderSource("-/legacy"),
+			true,
+		},
+	}
+
+	for i, tc := range tests {
+		t.Run(fmt.Sprintf("%02d", i), func(t *testing.T) {
+			err := tc.Input.Validate()
+			if err != nil {
+				if tc.ExpectedErr {
+					return
+				}
+				t.Fatalf("unexpected validation error: %s", err)
+			}
+			if tc.ExpectedErr {
+				t.Fatal("expected validation error, none received")
+			}
+		})
+	}
+}
+
+func TestValidateProviderAddress(t *testing.T) {
+	tests := []struct {
+		RawInput    string
+		ExpectedErr bool
+	}{
+		{
+			"host.com/hashicorp/coffee",
+			false,
+		},
+		{
+			"",
+			true,
+		},
+		{
+			"latte",
+			true,
+		},
+		{
+			"coffeeshop/latte",
+			true,
+		},
+		{
+			"registry.terraform.io//",
+			true,
+		},
+		{
+			"unknown-namespace",
+			true,
+		},
+		{
+			"-/legacy",
+			true,
+		},
+	}
+
+	for i, tc := range tests {
+		t.Run(fmt.Sprintf("%02d", i), func(t *testing.T) {
+			err := ValidateProviderAddress(tc.RawInput)
+			if err != nil {
+				if tc.ExpectedErr {
+					return
+				}
+				t.Fatalf("unexpected validation error for %q: %s", tc.RawInput, err)
+			}
+			if tc.ExpectedErr {
+				t.Fatal("expected validation error, none received")
+			}
+		})
+	}
+}
+
+func TestProviderMarshalText(t *testing.T) {
+	p := Provider{
+		Hostname:  svchost.Hostname("registry.terraform.io"),
+		Namespace: "hashicorp",
+		Type:      "aws",
+	}
+	b, err := json.Marshal(p)
+	if err != nil {
+		t.Fatal(err)
+	}
+	expected := `"registry.terraform.io/hashicorp/aws"`
+	if diff := cmp.Diff(expected, string(b)); diff != "" {
+		t.Fatalf("marshaled text mismatch: %s", diff)
+	}
+}
+
+func TestProviderUnmarshalText(t *testing.T) {
+	address := `"registry.terraform.io/hashicorp/aws"`
+	var p Provider
+	err := json.Unmarshal([]byte(address), &p)
+	if err != nil {
+		t.Fatal(err)
+	}
+	expectedProvider := Provider{
+		Hostname:  svchost.Hostname("registry.terraform.io"),
+		Namespace: "hashicorp",
+		Type:      "aws",
+	}
+	if diff := cmp.Diff(expectedProvider, p); diff != "" {
+		t.Fatalf("unmarshaled provider mismatch: %s", diff)
+	}
+}
+
 func ExampleParseProviderSource() {
 	pAddr, err := ParseProviderSource("hashicorp/aws")
 	if err != nil {
@@ -561,7 +704,3 @@ func TestProviderEquals(t *testing.T) {
 		})
 	}
 }
-
-func TestValidateProviderAddress(t *testing.T) {
-	t.Skip("TODO")
-}