mirror of
https://github.com/opentofu/opentofu.git
synced 2024-12-28 01:41:48 -06:00
ec99b6910b
Don't suggest constraints when the available plugin isn't versioned. Add zero version const for comparisons.
418 lines
7.8 KiB
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")
|
|
}
|
|
}
|