github.com/muratcelep/terraform@v1.1.0-beta2-not-internal-4/not-internal/getproviders/memoize_source_test.go

package getproviders

import (
	"context"
	"testing"

	"github.com/google/go-cmp/cmp"
	"github.com/muratcelep/terraform/not-internal/addrs"
)

func TestMemoizeSource(t *testing.T) {
	provider := addrs.NewDefaultProvider("foo")
	version := MustParseVersion("1.0.0")
	protocols := VersionList{MustParseVersion("5.0")}
	platform := Platform{OS: "gameboy", Arch: "lr35902"}
	meta := FakePackageMeta(provider, version, protocols, platform)
	nonexistProvider := addrs.NewDefaultProvider("nonexist")
	nonexistPlatform := Platform{OS: "gamegear", Arch: "z80"}

	t.Run("AvailableVersions for existing provider", func(t *testing.T) {
		mock := NewMockSource([]PackageMeta{meta}, nil)
		source := NewMemoizeSource(mock)

		got, _, err := source.AvailableVersions(context.Background(), provider)
		want := VersionList{version}
		if err != nil {
			t.Fatalf("unexpected error: %s", err)
		}
		if diff := cmp.Diff(want, got); diff != "" {
			t.Fatalf("wrong result from first call to AvailableVersions\n%s", diff)
		}

		got, _, err = source.AvailableVersions(context.Background(), provider)
		want = VersionList{version}
		if err != nil {
			t.Fatalf("unexpected error: %s", err)
		}
		if diff := cmp.Diff(want, got); diff != "" {
			t.Fatalf("wrong result from second call to AvailableVersions\n%s", diff)
		}

		_, _, err = source.AvailableVersions(context.Background(), nonexistProvider)
		if want, ok := err.(ErrRegistryProviderNotKnown); !ok {
			t.Fatalf("wrong error type from nonexist call:\ngot:  %T\nwant: %T", err, want)
		}

		got, _, err = source.AvailableVersions(context.Background(), provider)
		want = VersionList{version}
		if err != nil {
			t.Fatalf("unexpected error: %s", err)
		}
		if diff := cmp.Diff(want, got); diff != "" {
			t.Fatalf("wrong result from third call to AvailableVersions\n%s", diff)
		}

		gotLog := mock.CallLog()
		wantLog := [][]interface{}{
			// Only one call for the main provider, because the others were returned from the cache.
			{"AvailableVersions", provider},

			// The call for nonexist also shows through, because it didn't match the cache.
			{"AvailableVersions", nonexistProvider},
		}
		if diff := cmp.Diff(wantLog, gotLog); diff != "" {
			t.Fatalf("unexpected call log\n%s", diff)
		}
	})
	t.Run("AvailableVersions with warnings", func(t *testing.T) {
		warnProvider := addrs.NewDefaultProvider("warning")
		meta := FakePackageMeta(warnProvider, version, protocols, platform)
		mock := NewMockSource([]PackageMeta{meta}, map[addrs.Provider]Warnings{warnProvider: {"WARNING!"}})
		source := NewMemoizeSource(mock)

		got, warns, err := source.AvailableVersions(context.Background(), warnProvider)
		want := VersionList{version}
		if err != nil {
			t.Fatalf("unexpected error: %s", err)
		}
		if diff := cmp.Diff(want, got); diff != "" {
			t.Fatalf("wrong result from first call to AvailableVersions\n%s", diff)
		}
		if len(warns) != 1 {
			t.Fatalf("wrong number of warnings. Got %d, expected 1", len(warns))
		}
		if warns[0] != "WARNING!" {
			t.Fatalf("wrong result! Got %s, expected \"WARNING!\"", warns[0])
		}

	})
	t.Run("PackageMeta for existing provider", func(t *testing.T) {
		mock := NewMockSource([]PackageMeta{meta}, nil)
		source := NewMemoizeSource(mock)

		got, err := source.PackageMeta(context.Background(), provider, version, platform)
		want := meta
		if err != nil {
			t.Fatalf("unexpected error: %s", err)
		}
		if diff := cmp.Diff(want, got); diff != "" {
			t.Fatalf("wrong result from first call to PackageMeta\n%s", diff)
		}

		got, err = source.PackageMeta(context.Background(), provider, version, platform)
		want = meta
		if err != nil {
			t.Fatalf("unexpected error: %s", err)
		}
		if diff := cmp.Diff(want, got); diff != "" {
			t.Fatalf("wrong result from second call to PackageMeta\n%s", diff)
		}

		_, err = source.PackageMeta(context.Background(), nonexistProvider, version, platform)
		if want, ok := err.(ErrPlatformNotSupported); !ok {
			t.Fatalf("wrong error type from nonexist provider call:\ngot:  %T\nwant: %T", err, want)
		}
		_, err = source.PackageMeta(context.Background(), provider, version, nonexistPlatform)
		if want, ok := err.(ErrPlatformNotSupported); !ok {
			t.Fatalf("wrong error type from nonexist platform call:\ngot:  %T\nwant: %T", err, want)
		}

		got, err = source.PackageMeta(context.Background(), provider, version, platform)
		want = meta
		if err != nil {
			t.Fatalf("unexpected error: %s", err)
		}
		if diff := cmp.Diff(want, got); diff != "" {
			t.Fatalf("wrong result from third call to PackageMeta\n%s", diff)
		}

		gotLog := mock.CallLog()
		wantLog := [][]interface{}{
			// Only one call for the main provider, because the others were returned from the cache.
			{"PackageMeta", provider, version, platform},

			// The other calls for non-exist things also show through, because they missed the cache.
			{"PackageMeta", nonexistProvider, version, platform},
			{"PackageMeta", provider, version, nonexistPlatform},
		}
		if diff := cmp.Diff(wantLog, gotLog); diff != "" {
			t.Fatalf("unexpected call log\n%s", diff)
		}
	})
	t.Run("AvailableVersions for non-existing provider", func(t *testing.T) {
		mock := NewMockSource([]PackageMeta{meta}, nil)
		source := NewMemoizeSource(mock)

		_, _, err := source.AvailableVersions(context.Background(), nonexistProvider)
		if want, ok := err.(ErrRegistryProviderNotKnown); !ok {
			t.Fatalf("wrong error type from first call:\ngot:  %T\nwant: %T", err, want)
		}
		_, _, err = source.AvailableVersions(context.Background(), nonexistProvider)
		if want, ok := err.(ErrRegistryProviderNotKnown); !ok {
			t.Fatalf("wrong error type from second call:\ngot:  %T\nwant: %T", err, want)
		}

		gotLog := mock.CallLog()
		wantLog := [][]interface{}{
			// Only one call, because the other was returned from the cache.
			{"AvailableVersions", nonexistProvider},
		}
		if diff := cmp.Diff(wantLog, gotLog); diff != "" {
			t.Fatalf("unexpected call log\n%s", diff)
		}
	})
	t.Run("PackageMeta for non-existing provider", func(t *testing.T) {
		mock := NewMockSource([]PackageMeta{meta}, nil)
		source := NewMemoizeSource(mock)

		_, err := source.PackageMeta(context.Background(), nonexistProvider, version, platform)
		if want, ok := err.(ErrPlatformNotSupported); !ok {
			t.Fatalf("wrong error type from first call:\ngot:  %T\nwant: %T", err, want)
		}
		_, err = source.PackageMeta(context.Background(), nonexistProvider, version, platform)
		if want, ok := err.(ErrPlatformNotSupported); !ok {
			t.Fatalf("wrong error type from second call:\ngot:  %T\nwant: %T", err, want)
		}

		gotLog := mock.CallLog()
		wantLog := [][]interface{}{
			// Only one call, because the other was returned from the cache.
			{"PackageMeta", nonexistProvider, version, platform},
		}
		if diff := cmp.Diff(wantLog, gotLog); diff != "" {
			t.Fatalf("unexpected call log\n%s", diff)
		}
	})
}