mirror of https://github.com/databricks/cli.git
886 lines
22 KiB
Go
886 lines
22 KiB
Go
package convert
|
|
|
|
import (
|
|
"testing"
|
|
|
|
"github.com/databricks/cli/libs/diag"
|
|
"github.com/databricks/cli/libs/dyn"
|
|
assert "github.com/databricks/cli/libs/dyn/dynassert"
|
|
)
|
|
|
|
func TestNormalizeStruct(t *testing.T) {
|
|
type Tmp struct {
|
|
Foo string `json:"foo"`
|
|
Bar string `json:"bar"`
|
|
}
|
|
|
|
var typ Tmp
|
|
vin := dyn.V(map[string]dyn.Value{
|
|
"foo": dyn.V("bar"),
|
|
"bar": dyn.V("baz"),
|
|
})
|
|
|
|
vout, err := Normalize(typ, vin)
|
|
assert.Empty(t, err)
|
|
assert.Equal(t, vin, vout)
|
|
}
|
|
|
|
func TestNormalizeStructElementDiagnostic(t *testing.T) {
|
|
type Tmp struct {
|
|
Foo string `json:"foo"`
|
|
Bar string `json:"bar"`
|
|
}
|
|
|
|
var typ Tmp
|
|
vin := dyn.V(map[string]dyn.Value{
|
|
"foo": dyn.V("bar"),
|
|
"bar": dyn.V(map[string]dyn.Value{"an": dyn.V("error")}),
|
|
})
|
|
|
|
vout, err := Normalize(typ, vin)
|
|
assert.Len(t, err, 1)
|
|
assert.Equal(t, diag.Diagnostic{
|
|
Severity: diag.Warning,
|
|
Summary: `expected string, found map`,
|
|
Locations: []dyn.Location{{}},
|
|
Paths: []dyn.Path{dyn.NewPath(dyn.Key("bar"))},
|
|
}, err[0])
|
|
|
|
// Elements that encounter an error during normalization are dropped.
|
|
assert.Equal(t, map[string]any{
|
|
"foo": "bar",
|
|
}, vout.AsAny())
|
|
}
|
|
|
|
func TestNormalizeStructUnknownField(t *testing.T) {
|
|
type Tmp struct {
|
|
Foo string `json:"foo"`
|
|
}
|
|
|
|
var typ Tmp
|
|
|
|
m := dyn.NewMapping()
|
|
m.Set(dyn.V("foo"), dyn.V("val-foo"))
|
|
// Set the unknown field, with location information.
|
|
m.Set(dyn.NewValue("bar", []dyn.Location{
|
|
{File: "hello.yaml", Line: 1, Column: 1},
|
|
{File: "world.yaml", Line: 2, Column: 2},
|
|
}), dyn.V("var-bar"))
|
|
|
|
vin := dyn.V(m)
|
|
|
|
vout, err := Normalize(typ, vin)
|
|
assert.Len(t, err, 1)
|
|
assert.Equal(t, diag.Diagnostic{
|
|
Severity: diag.Warning,
|
|
Summary: `unknown field: bar`,
|
|
// Assert location of the unknown field is included in the diagnostic.
|
|
Locations: []dyn.Location{
|
|
{File: "hello.yaml", Line: 1, Column: 1},
|
|
{File: "world.yaml", Line: 2, Column: 2},
|
|
},
|
|
Paths: []dyn.Path{dyn.EmptyPath},
|
|
}, err[0])
|
|
|
|
// The field that can be mapped to the struct field is retained.
|
|
assert.Equal(t, map[string]any{
|
|
"foo": "val-foo",
|
|
}, vout.AsAny())
|
|
}
|
|
|
|
func TestNormalizeStructNil(t *testing.T) {
|
|
type Tmp struct {
|
|
Foo string `json:"foo"`
|
|
}
|
|
|
|
var typ Tmp
|
|
vin := dyn.NilValue
|
|
vout, err := Normalize(typ, vin)
|
|
assert.Empty(t, err)
|
|
assert.Equal(t, vin, vout)
|
|
}
|
|
|
|
func TestNormalizeStructError(t *testing.T) {
|
|
type Tmp struct {
|
|
Foo string `json:"foo"`
|
|
}
|
|
|
|
var typ Tmp
|
|
vin := dyn.V("string")
|
|
_, err := Normalize(typ, vin)
|
|
assert.Len(t, err, 1)
|
|
assert.Equal(t, diag.Diagnostic{
|
|
Severity: diag.Warning,
|
|
Summary: `expected map, found string`,
|
|
Locations: []dyn.Location{vin.Get("foo").Location()},
|
|
Paths: []dyn.Path{dyn.EmptyPath},
|
|
}, err[0])
|
|
}
|
|
|
|
func TestNormalizeStructNestedError(t *testing.T) {
|
|
type Nested struct {
|
|
F1 int `json:"f1"`
|
|
F2 int `json:"f2"`
|
|
}
|
|
type Tmp struct {
|
|
Foo Nested `json:"foo"`
|
|
Bar Nested `json:"bar"`
|
|
}
|
|
|
|
var typ Tmp
|
|
vin := dyn.V(map[string]dyn.Value{
|
|
"foo": dyn.V(map[string]dyn.Value{
|
|
"f1": dyn.V("error"),
|
|
"f2": dyn.V(1),
|
|
}),
|
|
"bar": dyn.V(map[string]dyn.Value{
|
|
"f1": dyn.V(1),
|
|
"f2": dyn.V("error"),
|
|
}),
|
|
})
|
|
vout, err := Normalize(typ, vin)
|
|
assert.Len(t, err, 2)
|
|
|
|
// Verify that valid fields are retained.
|
|
assert.Equal(t,
|
|
dyn.V(map[string]dyn.Value{
|
|
"foo": dyn.V(map[string]dyn.Value{
|
|
"f2": dyn.V(int64(1)),
|
|
}),
|
|
"bar": dyn.V(map[string]dyn.Value{
|
|
"f1": dyn.V(int64(1)),
|
|
}),
|
|
}),
|
|
vout,
|
|
)
|
|
}
|
|
|
|
func TestNormalizeStructIncludeMissingFields(t *testing.T) {
|
|
type Nested struct {
|
|
String string `json:"string"`
|
|
}
|
|
|
|
type Tmp struct {
|
|
// Verify that fields that are already set in the dynamic value are not overridden.
|
|
Existing string `json:"existing"`
|
|
|
|
// Verify that structs are recursively normalized if not set.
|
|
Nested Nested `json:"nested"`
|
|
Ptr *Nested `json:"ptr"`
|
|
|
|
// Verify that containers are also zero-initialized if not set.
|
|
Map map[string]string `json:"map"`
|
|
Slice []string `json:"slice"`
|
|
|
|
// Verify that primitive types are zero-initialized if not set.
|
|
String string `json:"string"`
|
|
Bool bool `json:"bool"`
|
|
Int int `json:"int"`
|
|
Float float64 `json:"float"`
|
|
}
|
|
|
|
var typ Tmp
|
|
vin := dyn.V(map[string]dyn.Value{
|
|
"existing": dyn.V("already set"),
|
|
})
|
|
vout, err := Normalize(typ, vin, IncludeMissingFields)
|
|
assert.Empty(t, err)
|
|
assert.Equal(t, dyn.V(map[string]dyn.Value{
|
|
"existing": dyn.V("already set"),
|
|
"nested": dyn.V(map[string]dyn.Value{
|
|
"string": dyn.V(""),
|
|
}),
|
|
"ptr": dyn.V(map[string]dyn.Value{
|
|
"string": dyn.V(""),
|
|
}),
|
|
"map": dyn.V(map[string]dyn.Value{}),
|
|
"slice": dyn.V([]dyn.Value{}),
|
|
"string": dyn.V(""),
|
|
"bool": dyn.V(false),
|
|
"int": dyn.V(int64(0)),
|
|
"float": dyn.V(float64(0)),
|
|
}), vout)
|
|
}
|
|
|
|
func TestNormalizeStructIncludeMissingFieldsOnRecursiveType(t *testing.T) {
|
|
type Tmp struct {
|
|
// Verify that structs are recursively normalized if not set.
|
|
Ptr *Tmp `json:"ptr"`
|
|
|
|
// Verify that primitive types are zero-initialized if not set.
|
|
String string `json:"string"`
|
|
}
|
|
|
|
var typ Tmp
|
|
vin := dyn.V(map[string]dyn.Value{
|
|
"ptr": dyn.V(map[string]dyn.Value{
|
|
"ptr": dyn.V(map[string]dyn.Value{
|
|
"string": dyn.V("already set"),
|
|
}),
|
|
}),
|
|
})
|
|
vout, err := Normalize(typ, vin, IncludeMissingFields)
|
|
assert.Empty(t, err)
|
|
assert.Equal(t, dyn.V(map[string]dyn.Value{
|
|
"ptr": dyn.V(map[string]dyn.Value{
|
|
"ptr": dyn.V(map[string]dyn.Value{
|
|
// Note: the ptr field is not zero-initialized because that would recurse.
|
|
"string": dyn.V("already set"),
|
|
}),
|
|
"string": dyn.V(""),
|
|
}),
|
|
"string": dyn.V(""),
|
|
}), vout)
|
|
}
|
|
|
|
func TestNormalizeStructVariableReference(t *testing.T) {
|
|
type Tmp struct {
|
|
Foo string `json:"foo"`
|
|
}
|
|
|
|
var typ Tmp
|
|
vin := dyn.NewValue("${var.foo}", []dyn.Location{{File: "file", Line: 1, Column: 1}})
|
|
vout, err := Normalize(typ, vin)
|
|
assert.Empty(t, err)
|
|
assert.Equal(t, vin, vout)
|
|
}
|
|
|
|
func TestNormalizeStructRandomStringError(t *testing.T) {
|
|
type Tmp struct {
|
|
Foo string `json:"foo"`
|
|
}
|
|
|
|
var typ Tmp
|
|
vin := dyn.NewValue("var foo", []dyn.Location{{File: "file", Line: 1, Column: 1}})
|
|
_, err := Normalize(typ, vin)
|
|
assert.Len(t, err, 1)
|
|
assert.Equal(t, diag.Diagnostic{
|
|
Severity: diag.Warning,
|
|
Summary: `expected map, found string`,
|
|
Locations: []dyn.Location{vin.Location()},
|
|
Paths: []dyn.Path{dyn.EmptyPath},
|
|
}, err[0])
|
|
}
|
|
|
|
func TestNormalizeStructIntError(t *testing.T) {
|
|
type Tmp struct {
|
|
Foo string `json:"foo"`
|
|
}
|
|
|
|
var typ Tmp
|
|
vin := dyn.NewValue(1, []dyn.Location{{File: "file", Line: 1, Column: 1}})
|
|
_, err := Normalize(typ, vin)
|
|
assert.Len(t, err, 1)
|
|
assert.Equal(t, diag.Diagnostic{
|
|
Severity: diag.Warning,
|
|
Summary: `expected map, found int`,
|
|
Locations: []dyn.Location{vin.Location()},
|
|
Paths: []dyn.Path{dyn.EmptyPath},
|
|
}, err[0])
|
|
}
|
|
|
|
func TestNormalizeMap(t *testing.T) {
|
|
var typ map[string]string
|
|
vin := dyn.V(map[string]dyn.Value{
|
|
"foo": dyn.V("bar"),
|
|
"bar": dyn.V("baz"),
|
|
})
|
|
|
|
vout, err := Normalize(typ, vin)
|
|
assert.Empty(t, err)
|
|
assert.Equal(t, vin, vout)
|
|
}
|
|
|
|
func TestNormalizeMapElementDiagnostic(t *testing.T) {
|
|
var typ map[string]string
|
|
vin := dyn.V(map[string]dyn.Value{
|
|
"foo": dyn.V("bar"),
|
|
"bar": dyn.V(map[string]dyn.Value{"an": dyn.V("error")}),
|
|
})
|
|
|
|
vout, err := Normalize(typ, vin)
|
|
assert.Len(t, err, 1)
|
|
assert.Equal(t, diag.Diagnostic{
|
|
Severity: diag.Warning,
|
|
Summary: `expected string, found map`,
|
|
Locations: []dyn.Location{{}},
|
|
Paths: []dyn.Path{dyn.NewPath(dyn.Key("bar"))},
|
|
}, err[0])
|
|
|
|
// Elements that encounter an error during normalization are dropped.
|
|
assert.Equal(t, map[string]any{
|
|
"foo": "bar",
|
|
}, vout.AsAny())
|
|
}
|
|
|
|
func TestNormalizeMapNil(t *testing.T) {
|
|
var typ map[string]string
|
|
vin := dyn.NilValue
|
|
vout, err := Normalize(typ, vin)
|
|
assert.Empty(t, err)
|
|
assert.Equal(t, vin, vout)
|
|
}
|
|
|
|
func TestNormalizeMapError(t *testing.T) {
|
|
var typ map[string]string
|
|
vin := dyn.V("string")
|
|
_, err := Normalize(typ, vin)
|
|
assert.Len(t, err, 1)
|
|
assert.Equal(t, diag.Diagnostic{
|
|
Severity: diag.Warning,
|
|
Summary: `expected map, found string`,
|
|
Locations: []dyn.Location{vin.Location()},
|
|
Paths: []dyn.Path{dyn.EmptyPath},
|
|
}, err[0])
|
|
}
|
|
|
|
func TestNormalizeMapNestedError(t *testing.T) {
|
|
type Nested struct {
|
|
F1 int `json:"f1"`
|
|
F2 int `json:"f2"`
|
|
}
|
|
|
|
var typ map[string]Nested
|
|
vin := dyn.V(map[string]dyn.Value{
|
|
"foo": dyn.V(map[string]dyn.Value{
|
|
"f1": dyn.V("error"),
|
|
"f2": dyn.V(1),
|
|
}),
|
|
"bar": dyn.V(map[string]dyn.Value{
|
|
"f1": dyn.V(1),
|
|
"f2": dyn.V("error"),
|
|
}),
|
|
})
|
|
vout, err := Normalize(typ, vin)
|
|
assert.Len(t, err, 2)
|
|
|
|
// Verify that valid fields are retained.
|
|
assert.Equal(t,
|
|
dyn.V(map[string]dyn.Value{
|
|
"foo": dyn.V(map[string]dyn.Value{
|
|
"f2": dyn.V(int64(1)),
|
|
}),
|
|
"bar": dyn.V(map[string]dyn.Value{
|
|
"f1": dyn.V(int64(1)),
|
|
}),
|
|
}),
|
|
vout,
|
|
)
|
|
}
|
|
|
|
func TestNormalizeMapVariableReference(t *testing.T) {
|
|
var typ map[string]string
|
|
vin := dyn.NewValue("${var.foo}", []dyn.Location{{File: "file", Line: 1, Column: 1}})
|
|
vout, err := Normalize(typ, vin)
|
|
assert.Empty(t, err)
|
|
assert.Equal(t, vin, vout)
|
|
}
|
|
|
|
func TestNormalizeMapRandomStringError(t *testing.T) {
|
|
var typ map[string]string
|
|
vin := dyn.NewValue("var foo", []dyn.Location{{File: "file", Line: 1, Column: 1}})
|
|
_, err := Normalize(typ, vin)
|
|
assert.Len(t, err, 1)
|
|
assert.Equal(t, diag.Diagnostic{
|
|
Severity: diag.Warning,
|
|
Summary: `expected map, found string`,
|
|
Locations: []dyn.Location{vin.Location()},
|
|
Paths: []dyn.Path{dyn.EmptyPath},
|
|
}, err[0])
|
|
}
|
|
|
|
func TestNormalizeMapIntError(t *testing.T) {
|
|
var typ map[string]string
|
|
vin := dyn.NewValue(1, []dyn.Location{{File: "file", Line: 1, Column: 1}})
|
|
_, err := Normalize(typ, vin)
|
|
assert.Len(t, err, 1)
|
|
assert.Equal(t, diag.Diagnostic{
|
|
Severity: diag.Warning,
|
|
Summary: `expected map, found int`,
|
|
Locations: []dyn.Location{vin.Location()},
|
|
Paths: []dyn.Path{dyn.EmptyPath},
|
|
}, err[0])
|
|
}
|
|
|
|
func TestNormalizeSlice(t *testing.T) {
|
|
var typ []string
|
|
vin := dyn.V([]dyn.Value{
|
|
dyn.V("foo"),
|
|
dyn.V("bar"),
|
|
})
|
|
|
|
vout, err := Normalize(typ, vin)
|
|
assert.Empty(t, err)
|
|
assert.Equal(t, vin, vout)
|
|
}
|
|
|
|
func TestNormalizeSliceElementDiagnostic(t *testing.T) {
|
|
var typ []string
|
|
vin := dyn.V([]dyn.Value{
|
|
dyn.V("foo"),
|
|
dyn.V("bar"),
|
|
dyn.V(map[string]dyn.Value{"an": dyn.V("error")}),
|
|
})
|
|
|
|
vout, err := Normalize(typ, vin)
|
|
assert.Len(t, err, 1)
|
|
assert.Equal(t, diag.Diagnostic{
|
|
Severity: diag.Warning,
|
|
Summary: `expected string, found map`,
|
|
Locations: []dyn.Location{{}},
|
|
Paths: []dyn.Path{dyn.NewPath(dyn.Index(2))},
|
|
}, err[0])
|
|
|
|
// Elements that encounter an error during normalization are dropped.
|
|
assert.Equal(t, []any{"foo", "bar"}, vout.AsAny())
|
|
}
|
|
|
|
func TestNormalizeSliceNil(t *testing.T) {
|
|
var typ []string
|
|
vin := dyn.NilValue
|
|
vout, err := Normalize(typ, vin)
|
|
assert.Empty(t, err)
|
|
assert.Equal(t, vin, vout)
|
|
}
|
|
|
|
func TestNormalizeSliceError(t *testing.T) {
|
|
var typ []string
|
|
vin := dyn.V("string")
|
|
_, err := Normalize(typ, vin)
|
|
assert.Len(t, err, 1)
|
|
assert.Equal(t, diag.Diagnostic{
|
|
Severity: diag.Warning,
|
|
Summary: `expected sequence, found string`,
|
|
Locations: []dyn.Location{vin.Location()},
|
|
Paths: []dyn.Path{dyn.EmptyPath},
|
|
}, err[0])
|
|
}
|
|
|
|
func TestNormalizeSliceNestedError(t *testing.T) {
|
|
type Nested struct {
|
|
F1 int `json:"f1"`
|
|
F2 int `json:"f2"`
|
|
}
|
|
|
|
var typ []Nested
|
|
vin := dyn.V([]dyn.Value{
|
|
dyn.V(map[string]dyn.Value{
|
|
"f1": dyn.V("error"),
|
|
"f2": dyn.V(1),
|
|
}),
|
|
dyn.V(map[string]dyn.Value{
|
|
"f1": dyn.V(1),
|
|
"f2": dyn.V("error"),
|
|
}),
|
|
})
|
|
vout, err := Normalize(typ, vin)
|
|
assert.Len(t, err, 2)
|
|
|
|
// Verify that valid fields are retained.
|
|
assert.Equal(t,
|
|
dyn.V([]dyn.Value{
|
|
dyn.V(map[string]dyn.Value{
|
|
"f2": dyn.V(int64(1)),
|
|
}),
|
|
dyn.V(map[string]dyn.Value{
|
|
"f1": dyn.V(int64(1)),
|
|
}),
|
|
}),
|
|
vout,
|
|
)
|
|
}
|
|
|
|
func TestNormalizeSliceVariableReference(t *testing.T) {
|
|
var typ []string
|
|
vin := dyn.NewValue("${var.foo}", []dyn.Location{{File: "file", Line: 1, Column: 1}})
|
|
vout, err := Normalize(typ, vin)
|
|
assert.Empty(t, err)
|
|
assert.Equal(t, vin, vout)
|
|
}
|
|
|
|
func TestNormalizeSliceRandomStringError(t *testing.T) {
|
|
var typ []string
|
|
vin := dyn.NewValue("var foo", []dyn.Location{{File: "file", Line: 1, Column: 1}})
|
|
_, err := Normalize(typ, vin)
|
|
assert.Len(t, err, 1)
|
|
assert.Equal(t, diag.Diagnostic{
|
|
Severity: diag.Warning,
|
|
Summary: `expected sequence, found string`,
|
|
Locations: []dyn.Location{vin.Location()},
|
|
Paths: []dyn.Path{dyn.EmptyPath},
|
|
}, err[0])
|
|
}
|
|
|
|
func TestNormalizeSliceIntError(t *testing.T) {
|
|
var typ []string
|
|
vin := dyn.NewValue(1, []dyn.Location{{File: "file", Line: 1, Column: 1}})
|
|
_, err := Normalize(typ, vin)
|
|
assert.Len(t, err, 1)
|
|
assert.Equal(t, diag.Diagnostic{
|
|
Severity: diag.Warning,
|
|
Summary: `expected sequence, found int`,
|
|
Locations: []dyn.Location{vin.Location()},
|
|
Paths: []dyn.Path{dyn.EmptyPath},
|
|
}, err[0])
|
|
}
|
|
|
|
func TestNormalizeString(t *testing.T) {
|
|
var typ string
|
|
vin := dyn.V("string")
|
|
vout, err := Normalize(&typ, vin)
|
|
assert.Empty(t, err)
|
|
assert.Equal(t, vin, vout)
|
|
}
|
|
|
|
func TestNormalizeStringNil(t *testing.T) {
|
|
var typ string
|
|
vin := dyn.NewValue(nil, []dyn.Location{{File: "file", Line: 1, Column: 1}})
|
|
_, err := Normalize(&typ, vin)
|
|
assert.Len(t, err, 1)
|
|
assert.Equal(t, diag.Diagnostic{
|
|
Severity: diag.Warning,
|
|
Summary: `expected a string value, found null`,
|
|
Locations: []dyn.Location{vin.Location()},
|
|
Paths: []dyn.Path{dyn.EmptyPath},
|
|
}, err[0])
|
|
}
|
|
|
|
func TestNormalizeStringFromBool(t *testing.T) {
|
|
var typ string
|
|
vin := dyn.NewValue(true, []dyn.Location{{File: "file", Line: 1, Column: 1}})
|
|
vout, err := Normalize(&typ, vin)
|
|
assert.Empty(t, err)
|
|
assert.Equal(t, dyn.NewValue("true", vin.Locations()), vout)
|
|
}
|
|
|
|
func TestNormalizeStringFromInt(t *testing.T) {
|
|
var typ string
|
|
vin := dyn.NewValue(123, []dyn.Location{{File: "file", Line: 1, Column: 1}})
|
|
vout, err := Normalize(&typ, vin)
|
|
assert.Empty(t, err)
|
|
assert.Equal(t, dyn.NewValue("123", vin.Locations()), vout)
|
|
}
|
|
|
|
func TestNormalizeStringFromFloat(t *testing.T) {
|
|
var typ string
|
|
vin := dyn.NewValue(1.20, []dyn.Location{{File: "file", Line: 1, Column: 1}})
|
|
vout, err := Normalize(&typ, vin)
|
|
assert.Empty(t, err)
|
|
assert.Equal(t, dyn.NewValue("1.2", vin.Locations()), vout)
|
|
}
|
|
|
|
func TestNormalizeStringFromTime(t *testing.T) {
|
|
var typ string
|
|
vin := dyn.NewValue(dyn.MustTime("2024-08-29"), []dyn.Location{{File: "file", Line: 1, Column: 1}})
|
|
vout, err := Normalize(&typ, vin)
|
|
assert.Empty(t, err)
|
|
assert.Equal(t, dyn.NewValue("2024-08-29", vin.Locations()), vout)
|
|
}
|
|
|
|
func TestNormalizeStringError(t *testing.T) {
|
|
var typ string
|
|
vin := dyn.V(map[string]dyn.Value{"an": dyn.V("error")})
|
|
_, err := Normalize(&typ, vin)
|
|
assert.Len(t, err, 1)
|
|
assert.Equal(t, diag.Diagnostic{
|
|
Severity: diag.Warning,
|
|
Summary: `expected string, found map`,
|
|
Locations: []dyn.Location{{}},
|
|
Paths: []dyn.Path{dyn.EmptyPath},
|
|
}, err[0])
|
|
}
|
|
|
|
func TestNormalizeBool(t *testing.T) {
|
|
var typ bool
|
|
vin := dyn.V(true)
|
|
vout, err := Normalize(&typ, vin)
|
|
assert.Empty(t, err)
|
|
assert.Equal(t, dyn.V(true), vout)
|
|
}
|
|
|
|
func TestNormalizeBoolNil(t *testing.T) {
|
|
var typ bool
|
|
vin := dyn.NewValue(nil, []dyn.Location{{File: "file", Line: 1, Column: 1}})
|
|
_, err := Normalize(&typ, vin)
|
|
assert.Len(t, err, 1)
|
|
assert.Equal(t, diag.Diagnostic{
|
|
Severity: diag.Warning,
|
|
Summary: `expected a bool value, found null`,
|
|
Locations: []dyn.Location{vin.Location()},
|
|
Paths: []dyn.Path{dyn.EmptyPath},
|
|
}, err[0])
|
|
}
|
|
|
|
func TestNormalizeBoolFromString(t *testing.T) {
|
|
var typ bool
|
|
|
|
for _, c := range []struct {
|
|
Input string
|
|
Output bool
|
|
}{
|
|
{"true", true},
|
|
{"false", false},
|
|
{"Y", true},
|
|
{"N", false},
|
|
{"on", true},
|
|
{"off", false},
|
|
} {
|
|
vin := dyn.V(c.Input)
|
|
vout, err := Normalize(&typ, vin)
|
|
assert.Empty(t, err)
|
|
assert.Equal(t, dyn.V(c.Output), vout)
|
|
}
|
|
}
|
|
|
|
func TestNormalizeBoolFromStringVariableReference(t *testing.T) {
|
|
var typ bool
|
|
vin := dyn.V("${var.foo}")
|
|
vout, err := Normalize(&typ, vin)
|
|
assert.Empty(t, err)
|
|
assert.Equal(t, vin, vout)
|
|
}
|
|
|
|
func TestNormalizeBoolFromStringError(t *testing.T) {
|
|
var typ bool
|
|
vin := dyn.V("abc")
|
|
_, err := Normalize(&typ, vin)
|
|
assert.Len(t, err, 1)
|
|
assert.Equal(t, diag.Diagnostic{
|
|
Severity: diag.Warning,
|
|
Summary: `expected bool, found string`,
|
|
Locations: []dyn.Location{vin.Location()},
|
|
Paths: []dyn.Path{dyn.EmptyPath},
|
|
}, err[0])
|
|
}
|
|
|
|
func TestNormalizeBoolError(t *testing.T) {
|
|
var typ bool
|
|
vin := dyn.V(map[string]dyn.Value{"an": dyn.V("error")})
|
|
_, err := Normalize(&typ, vin)
|
|
assert.Len(t, err, 1)
|
|
assert.Equal(t, diag.Diagnostic{
|
|
Severity: diag.Warning,
|
|
Summary: `expected bool, found map`,
|
|
Locations: []dyn.Location{{}},
|
|
Paths: []dyn.Path{dyn.EmptyPath},
|
|
}, err[0])
|
|
}
|
|
|
|
func TestNormalizeInt(t *testing.T) {
|
|
var typ int
|
|
vin := dyn.V(123)
|
|
vout, err := Normalize(&typ, vin)
|
|
assert.Empty(t, err)
|
|
assert.Equal(t, dyn.V(int64(123)), vout)
|
|
}
|
|
|
|
func TestNormalizeIntNil(t *testing.T) {
|
|
var typ int
|
|
vin := dyn.NewValue(nil, []dyn.Location{{File: "file", Line: 1, Column: 1}})
|
|
_, err := Normalize(&typ, vin)
|
|
assert.Len(t, err, 1)
|
|
assert.Equal(t, diag.Diagnostic{
|
|
Severity: diag.Warning,
|
|
Summary: `expected a int value, found null`,
|
|
Locations: []dyn.Location{vin.Location()},
|
|
Paths: []dyn.Path{dyn.EmptyPath},
|
|
}, err[0])
|
|
}
|
|
|
|
func TestNormalizeIntFromFloat(t *testing.T) {
|
|
var typ int
|
|
vin := dyn.V(float64(1.0))
|
|
vout, err := Normalize(&typ, vin)
|
|
assert.Empty(t, err)
|
|
assert.Equal(t, dyn.V(int64(1)), vout)
|
|
}
|
|
|
|
func TestNormalizeIntFromFloatError(t *testing.T) {
|
|
var typ int
|
|
vin := dyn.V(1.5)
|
|
_, err := Normalize(&typ, vin)
|
|
assert.Len(t, err, 1)
|
|
assert.Equal(t, diag.Diagnostic{
|
|
Severity: diag.Warning,
|
|
Summary: `cannot accurately represent "1.5" as integer due to precision loss`,
|
|
Locations: []dyn.Location{vin.Location()},
|
|
Paths: []dyn.Path{dyn.EmptyPath},
|
|
}, err[0])
|
|
}
|
|
|
|
func TestNormalizeIntFromString(t *testing.T) {
|
|
var typ int
|
|
vin := dyn.V("123")
|
|
vout, err := Normalize(&typ, vin)
|
|
assert.Empty(t, err)
|
|
assert.Equal(t, dyn.V(int64(123)), vout)
|
|
}
|
|
|
|
func TestNormalizeIntFromStringVariableReference(t *testing.T) {
|
|
var typ int
|
|
vin := dyn.V("${var.foo}")
|
|
vout, err := Normalize(&typ, vin)
|
|
assert.Empty(t, err)
|
|
assert.Equal(t, vin, vout)
|
|
}
|
|
|
|
func TestNormalizeIntFromStringError(t *testing.T) {
|
|
var typ int
|
|
vin := dyn.V("abc")
|
|
_, err := Normalize(&typ, vin)
|
|
assert.Len(t, err, 1)
|
|
assert.Equal(t, diag.Diagnostic{
|
|
Severity: diag.Warning,
|
|
Summary: `cannot parse "abc" as an integer`,
|
|
Locations: []dyn.Location{vin.Location()},
|
|
Paths: []dyn.Path{dyn.EmptyPath},
|
|
}, err[0])
|
|
}
|
|
|
|
func TestNormalizeIntError(t *testing.T) {
|
|
var typ int
|
|
vin := dyn.V(map[string]dyn.Value{"an": dyn.V("error")})
|
|
_, err := Normalize(&typ, vin)
|
|
assert.Len(t, err, 1)
|
|
assert.Equal(t, diag.Diagnostic{
|
|
Severity: diag.Warning,
|
|
Summary: `expected int, found map`,
|
|
Locations: []dyn.Location{{}},
|
|
Paths: []dyn.Path{dyn.EmptyPath},
|
|
}, err[0])
|
|
}
|
|
|
|
func TestNormalizeFloat(t *testing.T) {
|
|
var typ float64
|
|
vin := dyn.V(1.2)
|
|
vout, err := Normalize(&typ, vin)
|
|
assert.Empty(t, err)
|
|
assert.Equal(t, dyn.V(1.2), vout)
|
|
}
|
|
|
|
func TestNormalizeFloatNil(t *testing.T) {
|
|
var typ float64
|
|
vin := dyn.NewValue(nil, []dyn.Location{{File: "file", Line: 1, Column: 1}})
|
|
_, err := Normalize(&typ, vin)
|
|
assert.Len(t, err, 1)
|
|
assert.Equal(t, diag.Diagnostic{
|
|
Severity: diag.Warning,
|
|
Summary: `expected a float value, found null`,
|
|
Locations: []dyn.Location{vin.Location()},
|
|
Paths: []dyn.Path{dyn.EmptyPath},
|
|
}, err[0])
|
|
}
|
|
|
|
func TestNormalizeFloatFromInt(t *testing.T) {
|
|
var typ float64
|
|
|
|
// Maximum safe integer that can be accurately represented as a float.
|
|
vin := dyn.V(int64(9007199254740992))
|
|
vout, err := Normalize(&typ, vin)
|
|
assert.Empty(t, err)
|
|
assert.Equal(t, dyn.V(float64(9007199254740992)), vout)
|
|
}
|
|
|
|
func TestNormalizeFloatFromIntError(t *testing.T) {
|
|
var typ float64
|
|
|
|
// Minimum integer that cannot be accurately represented as a float.
|
|
vin := dyn.V(9007199254740992 + 1)
|
|
_, err := Normalize(&typ, vin)
|
|
assert.Len(t, err, 1)
|
|
assert.Equal(t, diag.Diagnostic{
|
|
Severity: diag.Warning,
|
|
Summary: `cannot accurately represent "9007199254740993" as floating point number due to precision loss`,
|
|
Locations: []dyn.Location{vin.Location()},
|
|
Paths: []dyn.Path{dyn.EmptyPath},
|
|
}, err[0])
|
|
}
|
|
|
|
func TestNormalizeFloatFromString(t *testing.T) {
|
|
var typ float64
|
|
vin := dyn.V("1.2")
|
|
vout, err := Normalize(&typ, vin)
|
|
assert.Empty(t, err)
|
|
assert.Equal(t, dyn.V(1.2), vout)
|
|
}
|
|
|
|
func TestNormalizeFloatFromStringVariableReference(t *testing.T) {
|
|
var typ float64
|
|
vin := dyn.V("${var.foo}")
|
|
vout, err := Normalize(&typ, vin)
|
|
assert.Empty(t, err)
|
|
assert.Equal(t, vin, vout)
|
|
}
|
|
|
|
func TestNormalizeFloatFromStringError(t *testing.T) {
|
|
var typ float64
|
|
vin := dyn.V("abc")
|
|
_, err := Normalize(&typ, vin)
|
|
assert.Len(t, err, 1)
|
|
assert.Equal(t, diag.Diagnostic{
|
|
Severity: diag.Warning,
|
|
Summary: `cannot parse "abc" as a floating point number`,
|
|
Locations: []dyn.Location{vin.Location()},
|
|
Paths: []dyn.Path{dyn.EmptyPath},
|
|
}, err[0])
|
|
}
|
|
|
|
func TestNormalizeFloatError(t *testing.T) {
|
|
var typ float64
|
|
vin := dyn.V(map[string]dyn.Value{"an": dyn.V("error")})
|
|
_, err := Normalize(&typ, vin)
|
|
assert.Len(t, err, 1)
|
|
assert.Equal(t, diag.Diagnostic{
|
|
Severity: diag.Warning,
|
|
Summary: `expected float, found map`,
|
|
Locations: []dyn.Location{{}},
|
|
Paths: []dyn.Path{dyn.EmptyPath},
|
|
}, err[0])
|
|
}
|
|
|
|
func TestNormalizeAnchors(t *testing.T) {
|
|
type Tmp struct {
|
|
Foo string `json:"foo"`
|
|
}
|
|
|
|
var typ Tmp
|
|
vin := dyn.V(map[string]dyn.Value{
|
|
"foo": dyn.V("bar"),
|
|
"anchor": dyn.V("anchor").MarkAnchor(),
|
|
})
|
|
|
|
vout, err := Normalize(typ, vin)
|
|
assert.Len(t, err, 0)
|
|
|
|
// The field that can be mapped to the struct field is retained.
|
|
assert.Equal(t, map[string]any{
|
|
"foo": "bar",
|
|
}, vout.AsAny())
|
|
}
|
|
|
|
func TestNormalizeBoolToAny(t *testing.T) {
|
|
var typ any
|
|
vin := dyn.NewValue(false, []dyn.Location{{File: "file", Line: 1, Column: 1}})
|
|
vout, err := Normalize(&typ, vin)
|
|
assert.Len(t, err, 0)
|
|
assert.Equal(t, dyn.NewValue(false, []dyn.Location{{File: "file", Line: 1, Column: 1}}), vout)
|
|
}
|
|
|
|
func TestNormalizeIntToAny(t *testing.T) {
|
|
var typ any
|
|
vin := dyn.NewValue(10, []dyn.Location{{File: "file", Line: 1, Column: 1}})
|
|
vout, err := Normalize(&typ, vin)
|
|
assert.Len(t, err, 0)
|
|
assert.Equal(t, dyn.NewValue(10, []dyn.Location{{File: "file", Line: 1, Column: 1}}), vout)
|
|
}
|
|
|
|
func TestNormalizeSliceToAny(t *testing.T) {
|
|
var typ any
|
|
v1 := dyn.NewValue(1, []dyn.Location{{File: "file", Line: 1, Column: 1}})
|
|
v2 := dyn.NewValue(2, []dyn.Location{{File: "file", Line: 1, Column: 1}})
|
|
vin := dyn.NewValue([]dyn.Value{v1, v2}, []dyn.Location{{File: "file", Line: 1, Column: 1}})
|
|
vout, err := Normalize(&typ, vin)
|
|
assert.Len(t, err, 0)
|
|
assert.Equal(t, dyn.NewValue([]dyn.Value{v1, v2}, []dyn.Location{{File: "file", Line: 1, Column: 1}}), vout)
|
|
}
|