171 lines
3.5 KiB
Go
171 lines
3.5 KiB
Go
package addrs
|
|
|
|
import (
|
|
"fmt"
|
|
"testing"
|
|
)
|
|
|
|
func TestModuleInstanceEqual_true(t *testing.T) {
|
|
addrs := []string{
|
|
"module.foo",
|
|
"module.foo.module.bar",
|
|
"module.foo[1].module.bar",
|
|
`module.foo["a"].module.bar["b"]`,
|
|
`module.foo["a"].module.bar.module.baz[3]`,
|
|
}
|
|
for _, m := range addrs {
|
|
t.Run(m, func(t *testing.T) {
|
|
addr, diags := ParseModuleInstanceStr(m)
|
|
if len(diags) > 0 {
|
|
t.Fatalf("unexpected diags: %s", diags.Err())
|
|
}
|
|
if !addr.Equal(addr) {
|
|
t.Fatalf("expected %#v to be equal to itself", addr)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestModuleInstanceEqual_false(t *testing.T) {
|
|
testCases := []struct {
|
|
left string
|
|
right string
|
|
}{
|
|
{
|
|
"module.foo",
|
|
"module.bar",
|
|
},
|
|
{
|
|
"module.foo",
|
|
"module.foo.module.bar",
|
|
},
|
|
{
|
|
"module.foo[1]",
|
|
"module.bar[1]",
|
|
},
|
|
{
|
|
`module.foo[1]`,
|
|
`module.foo["1"]`,
|
|
},
|
|
{
|
|
"module.foo.module.bar",
|
|
"module.foo[1].module.bar",
|
|
},
|
|
{
|
|
`module.foo.module.bar`,
|
|
`module.foo["a"].module.bar`,
|
|
},
|
|
}
|
|
for _, tc := range testCases {
|
|
t.Run(fmt.Sprintf("%s = %s", tc.left, tc.right), func(t *testing.T) {
|
|
left, diags := ParseModuleInstanceStr(tc.left)
|
|
if len(diags) > 0 {
|
|
t.Fatalf("unexpected diags parsing %s: %s", tc.left, diags.Err())
|
|
}
|
|
right, diags := ParseModuleInstanceStr(tc.right)
|
|
if len(diags) > 0 {
|
|
t.Fatalf("unexpected diags parsing %s: %s", tc.right, diags.Err())
|
|
}
|
|
|
|
if left.Equal(right) {
|
|
t.Fatalf("expected %#v not to be equal to %#v", left, right)
|
|
}
|
|
|
|
if right.Equal(left) {
|
|
t.Fatalf("expected %#v not to be equal to %#v", right, left)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func BenchmarkStringShort(b *testing.B) {
|
|
addr, _ := ParseModuleInstanceStr(`module.foo`)
|
|
for n := 0; n < b.N; n++ {
|
|
addr.String()
|
|
}
|
|
}
|
|
|
|
func BenchmarkStringLong(b *testing.B) {
|
|
addr, _ := ParseModuleInstanceStr(`module.southamerica-brazil-region.module.user-regional-desktops.module.user-name`)
|
|
for n := 0; n < b.N; n++ {
|
|
addr.String()
|
|
}
|
|
}
|
|
|
|
func TestModuleInstance_IsDeclaredByCall(t *testing.T) {
|
|
tests := []struct {
|
|
instance ModuleInstance
|
|
call AbsModuleCall
|
|
want bool
|
|
}{
|
|
{
|
|
ModuleInstance{},
|
|
AbsModuleCall{},
|
|
false,
|
|
},
|
|
{
|
|
mustParseModuleInstanceStr("module.child"),
|
|
AbsModuleCall{},
|
|
false,
|
|
},
|
|
{
|
|
ModuleInstance{},
|
|
AbsModuleCall{
|
|
RootModuleInstance,
|
|
ModuleCall{Name: "child"},
|
|
},
|
|
false,
|
|
},
|
|
{
|
|
mustParseModuleInstanceStr("module.child"),
|
|
AbsModuleCall{ // module.child
|
|
RootModuleInstance,
|
|
ModuleCall{Name: "child"},
|
|
},
|
|
true,
|
|
},
|
|
{
|
|
mustParseModuleInstanceStr(`module.child`),
|
|
AbsModuleCall{ // module.kinder.module.child
|
|
mustParseModuleInstanceStr("module.kinder"),
|
|
ModuleCall{Name: "child"},
|
|
},
|
|
false,
|
|
},
|
|
{
|
|
mustParseModuleInstanceStr("module.kinder"),
|
|
// module.kinder.module.child contains module.kinder, but is not itself an instance of module.kinder
|
|
AbsModuleCall{
|
|
mustParseModuleInstanceStr("module.kinder"),
|
|
ModuleCall{Name: "child"},
|
|
},
|
|
false,
|
|
},
|
|
{
|
|
mustParseModuleInstanceStr("module.child"),
|
|
AbsModuleCall{
|
|
mustParseModuleInstanceStr(`module.kinder["a"]`),
|
|
ModuleCall{Name: "kinder"},
|
|
},
|
|
false,
|
|
},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
t.Run(fmt.Sprintf("%q.IsCallInstance(%q)", test.instance, test.call.String()), func(t *testing.T) {
|
|
got := test.instance.IsDeclaredByCall(test.call)
|
|
if got != test.want {
|
|
t.Fatal("wrong result")
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func mustParseModuleInstanceStr(str string) ModuleInstance {
|
|
mi, err := ParseModuleInstanceStr(str)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return mi
|
|
}
|