terraform/plugin/discovery/meta_set_test.go

418 lines
7.8 KiB
Go

package discovery
import (
"fmt"
"strings"
"testing"
)
func TestPluginMetaSetManipulation(t *testing.T) {
metas := []PluginMeta{
{
Name: "foo",
Version: "1.0.0",
Path: "test-foo",
},
{
Name: "bar",
Version: "2.0.0",
Path: "test-bar",
},
{
Name: "baz",
Version: "2.0.0",
Path: "test-bar",
},
}
s := make(PluginMetaSet)
if count := s.Count(); count != 0 {
t.Fatalf("set has Count %d before any items added", count)
}
// Can we add metas?
for _, p := range metas {
s.Add(p)
if !s.Has(p) {
t.Fatalf("%q not in set after adding it", p.Name)
}
}
if got, want := s.Count(), len(metas); got != want {
t.Fatalf("set has Count %d after all items added; want %d", got, want)
}
// Can we still retrieve earlier ones after we added later ones?
for _, p := range metas {
if !s.Has(p) {
t.Fatalf("%q not in set after all adds", p.Name)
}
}
// Can we remove metas?
for _, p := range metas {
s.Remove(p)
if s.Has(p) {
t.Fatalf("%q still in set after removing it", p.Name)
}
}
if count := s.Count(); count != 0 {
t.Fatalf("set has Count %d after all items removed", count)
}
}
func TestPluginMetaSetValidateVersions(t *testing.T) {
metas := []PluginMeta{
{
Name: "foo",
Version: "1.0.0",
Path: "test-foo",
},
{
Name: "bar",
Version: "0.0.1",
Path: "test-bar",
},
{
Name: "baz",
Version: "bananas",
Path: "test-bar",
},
}
s := make(PluginMetaSet)
for _, p := range metas {
s.Add(p)
}
valid, invalid := s.ValidateVersions()
if count := valid.Count(); count != 2 {
t.Errorf("valid set has %d metas; want 2", count)
}
if count := invalid.Count(); count != 1 {
t.Errorf("valid set has %d metas; want 1", count)
}
if !valid.Has(metas[0]) {
t.Errorf("'foo' not in valid set")
}
if !valid.Has(metas[1]) {
t.Errorf("'bar' not in valid set")
}
if !invalid.Has(metas[2]) {
t.Errorf("'baz' not in invalid set")
}
if invalid.Has(metas[0]) {
t.Errorf("'foo' in invalid set")
}
if invalid.Has(metas[1]) {
t.Errorf("'bar' in invalid set")
}
if valid.Has(metas[2]) {
t.Errorf("'baz' in valid set")
}
}
func TestPluginMetaSetWithName(t *testing.T) {
tests := []struct {
metas []PluginMeta
name string
wantCount int
}{
{
[]PluginMeta{},
"foo",
0,
},
{
[]PluginMeta{
{
Name: "foo",
Version: "0.0.1",
Path: "foo",
},
},
"foo",
1,
},
{
[]PluginMeta{
{
Name: "foo",
Version: "0.0.1",
Path: "foo",
},
},
"bar",
0,
},
}
for i, test := range tests {
t.Run(fmt.Sprintf("Test%02d", i), func(t *testing.T) {
s := make(PluginMetaSet)
for _, p := range test.metas {
s.Add(p)
}
filtered := s.WithName(test.name)
if gotCount := filtered.Count(); gotCount != test.wantCount {
t.Errorf("got count %d in %#v; want %d", gotCount, filtered, test.wantCount)
}
})
}
}
func TestPluginMetaSetByName(t *testing.T) {
metas := []PluginMeta{
{
Name: "foo",
Version: "1.0.0",
Path: "test-foo",
},
{
Name: "foo",
Version: "2.0.0",
Path: "test-foo-2",
},
{
Name: "bar",
Version: "0.0.1",
Path: "test-bar",
},
{
Name: "baz",
Version: "1.2.0",
Path: "test-bar",
},
}
s := make(PluginMetaSet)
for _, p := range metas {
s.Add(p)
}
byName := s.ByName()
if got, want := len(byName), 3; got != want {
t.Errorf("%d keys in ByName map; want %d", got, want)
}
if got, want := len(byName["foo"]), 2; got != want {
t.Errorf("%d metas for 'foo'; want %d", got, want)
}
if got, want := len(byName["bar"]), 1; got != want {
t.Errorf("%d metas for 'bar'; want %d", got, want)
}
if got, want := len(byName["baz"]), 1; got != want {
t.Errorf("%d metas for 'baz'; want %d", got, want)
}
if !byName["foo"].Has(metas[0]) {
t.Errorf("%#v missing from 'foo' set", metas[0])
}
if !byName["foo"].Has(metas[1]) {
t.Errorf("%#v missing from 'foo' set", metas[1])
}
if !byName["bar"].Has(metas[2]) {
t.Errorf("%#v missing from 'bar' set", metas[2])
}
if !byName["baz"].Has(metas[3]) {
t.Errorf("%#v missing from 'baz' set", metas[3])
}
}
func TestPluginMetaSetNewest(t *testing.T) {
tests := []struct {
versions []string
want string
}{
{
[]string{
"0.0.1",
},
"0.0.1",
},
{
[]string{
"0.0.1",
"0.0.2",
},
"0.0.2",
},
{
[]string{
"1.0.0",
"1.0.0-beta1",
},
"1.0.0",
},
{
[]string{
"0.0.1",
"1.0.0",
},
"1.0.0",
},
}
for _, test := range tests {
t.Run(strings.Join(test.versions, "|"), func(t *testing.T) {
s := make(PluginMetaSet)
for _, version := range test.versions {
s.Add(PluginMeta{
Name: "foo",
Version: VersionStr(version),
Path: "foo-V" + version,
})
}
newest := s.Newest()
if newest.Version != VersionStr(test.want) {
t.Errorf("version is %q; want %q", newest.Version, test.want)
}
})
}
}
func TestPluginMetaSetConstrainVersions(t *testing.T) {
metas := []PluginMeta{
{
Name: "foo",
Version: "1.0.0",
Path: "test-foo",
},
{
Name: "foo",
Version: "2.0.0",
Path: "test-foo-2",
},
{
Name: "foo",
Version: "3.0.0",
Path: "test-foo-2",
},
{
Name: "bar",
Version: "0.0.5",
Path: "test-bar",
},
{
Name: "baz",
Version: "0.0.1",
Path: "test-bar",
},
}
s := make(PluginMetaSet)
for _, p := range metas {
s.Add(p)
}
byName := s.ConstrainVersions(PluginRequirements{
"foo": &PluginConstraints{Versions: ConstraintStr(">=2.0.0").MustParse()},
"bar": &PluginConstraints{Versions: ConstraintStr(">=0.0.0").MustParse()},
"baz": &PluginConstraints{Versions: ConstraintStr(">=1.0.0").MustParse()},
"fun": &PluginConstraints{Versions: ConstraintStr(">5.0.0").MustParse()},
})
if got, want := len(byName), 3; got != want {
t.Errorf("%d keys in map; want %d", got, want)
}
if got, want := len(byName["foo"]), 2; got != want {
t.Errorf("%d metas for 'foo'; want %d", got, want)
}
if got, want := len(byName["bar"]), 1; got != want {
t.Errorf("%d metas for 'bar'; want %d", got, want)
}
if got, want := len(byName["baz"]), 0; got != want {
t.Errorf("%d metas for 'baz'; want %d", got, want)
}
// "fun" is not in the map at all, because we have no metas for that name
if !byName["foo"].Has(metas[1]) {
t.Errorf("%#v missing from 'foo' set", metas[1])
}
if !byName["foo"].Has(metas[2]) {
t.Errorf("%#v missing from 'foo' set", metas[2])
}
if !byName["bar"].Has(metas[3]) {
t.Errorf("%#v missing from 'bar' set", metas[3])
}
}
func TestPluginMetaSetOverridePaths(t *testing.T) {
metas := []PluginMeta{
{
Name: "foo",
Version: "1.0.0",
Path: "test-foo-1",
},
{
Name: "foo",
Version: "2.0.0",
Path: "test-foo-2",
},
{
Name: "foo",
Version: "3.0.0",
Path: "test-foo-3",
},
{
Name: "bar",
Version: "0.0.5",
Path: "test-bar-5",
},
{
Name: "bar",
Version: "0.0.6",
Path: "test-bar-6",
},
{
Name: "baz",
Version: "0.0.1",
Path: "test-bar",
},
}
s := make(PluginMetaSet)
for _, p := range metas {
s.Add(p)
}
ns := s.OverridePaths(map[string]string{
"foo": "override-foo",
"fun": "override-fun",
})
if got, want := ns.Count(), 5; got != want {
t.Errorf("got %d metas; want %d", got, want)
}
if !ns.Has(metas[3]) {
t.Errorf("new set is missing %#v", metas[3])
}
if !ns.Has(metas[4]) {
t.Errorf("new set is missing %#v", metas[4])
}
if !ns.Has(metas[5]) {
t.Errorf("new set is missing %#v", metas[5])
}
if !ns.Has(PluginMeta{
Name: "foo",
Version: VersionZero,
Path: "override-foo",
}) {
t.Errorf("new set is missing 'foo' override")
}
if !ns.Has(PluginMeta{
Name: "fun",
Version: VersionZero,
Path: "override-fun",
}) {
t.Errorf("new set is missing 'fun' override")
}
}