| // Copyright 2019 CUE Authors |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| package gocodec |
| |
| import ( |
| "fmt" |
| "reflect" |
| "testing" |
| |
| "github.com/google/go-cmp/cmp" |
| "github.com/kr/pretty" |
| |
| "cuelang.org/go/cue" |
| ) |
| |
| type Sum struct { |
| A int `cue:"C-B" json:",omitempty"` |
| B int `cue:"C-A" json:",omitempty"` |
| C int `cue:"A+B & >=5" json:",omitempty"` |
| } |
| |
| func checkErr(t *testing.T, got error, want string) { |
| t.Helper() |
| if (got == nil) != (want == "") { |
| t.Errorf("error: got %v; want %v", got, want) |
| } |
| } |
| func TestValidate(t *testing.T) { |
| fail := "some error" |
| testCases := []struct { |
| name string |
| value interface{} |
| constraints string |
| err string |
| }{{ |
| name: "*Sum: nil disallowed by constraint", |
| value: (*Sum)(nil), |
| constraints: "!=null", |
| err: fail, |
| }, { |
| name: "Sum", |
| value: Sum{A: 1, B: 4, C: 5}, |
| }, { |
| name: "*Sum", |
| value: &Sum{A: 1, B: 4, C: 5}, |
| }, { |
| name: "*Sum: incorrect sum", |
| value: &Sum{A: 1, B: 4, C: 6}, |
| err: fail, |
| }, { |
| name: "*Sum: field C is too low", |
| value: &Sum{A: 1, B: 3, C: 4}, |
| err: fail, |
| }, { |
| name: "*Sum: nil value", |
| value: (*Sum)(nil), |
| }, { |
| // Not a typical constraint, but it is possible. |
| name: "string list", |
| value: []string{"a", "b", "c"}, |
| constraints: `[_, "b", ...]`, |
| }, { |
| // Not a typical constraint, but it is possible. |
| name: "string list incompatible lengths", |
| value: []string{"a", "b", "c"}, |
| constraints: `4*[string]`, |
| err: fail, |
| }} |
| |
| for _, tc := range testCases { |
| t.Run(tc.name, func(t *testing.T) { |
| r := &cue.Runtime{} |
| codec := New(r, nil) |
| |
| v, err := codec.ExtractType(tc.value) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| if tc.constraints != "" { |
| inst, err := r.Compile(tc.name, tc.constraints) |
| if err != nil { |
| t.Fatal(err) |
| } |
| v = v.Unify(inst.Value()) |
| } |
| |
| err = codec.Validate(v, tc.value) |
| checkErr(t, err, tc.err) |
| }) |
| } |
| } |
| |
| func TestComplete(t *testing.T) { |
| type updated struct { |
| A []*int `cue:"[...int|*1]"` // arbitrary length slice with values 1 |
| B []int `cue:"3*[int|*1]"` // slice of length 3, defaults to [1,1,1] |
| |
| // TODO: better errors if the user forgets to quote. |
| M map[string]int `cue:",opt"` |
| } |
| type sump struct { |
| A *int `cue:"C-B"` |
| B *int `cue:"C-A"` |
| C *int `cue:"A+B"` |
| } |
| one := 1 |
| two := 2 |
| fail := "some error" |
| _ = fail |
| _ = one |
| testCases := []struct { |
| name string |
| value interface{} |
| result interface{} |
| constraints string |
| err string |
| }{{ |
| name: "*Sum", |
| value: &Sum{A: 1, B: 4, C: 5}, |
| result: &Sum{A: 1, B: 4, C: 5}, |
| }, { |
| name: "*Sum", |
| value: &Sum{A: 1, B: 4}, |
| result: &Sum{A: 1, B: 4, C: 5}, |
| }, { |
| name: "*sump", |
| value: &sump{A: &one, B: &one}, |
| result: &sump{A: &one, B: &one, C: &two}, |
| }, { |
| name: "*Sum: backwards", |
| value: &Sum{B: 4, C: 8}, |
| result: &Sum{A: 4, B: 4, C: 8}, |
| }, { |
| name: "*Sum: sum too low", |
| value: &Sum{A: 1, B: 3}, |
| result: &Sum{A: 1, B: 3}, // Value should not be updated |
| err: fail, |
| }, { |
| name: "*Sum: sum underspecified", |
| value: &Sum{A: 1}, |
| result: &Sum{A: 1}, // Value should not be updated |
| err: fail, |
| }, { |
| name: "Sum: cannot modify", |
| value: Sum{A: 3, B: 4, C: 7}, |
| result: Sum{A: 3, B: 4, C: 7}, |
| err: fail, |
| }, { |
| name: "*Sum: cannot update nil value", |
| value: (*Sum)(nil), |
| result: (*Sum)(nil), |
| err: fail, |
| }, { |
| name: "cannot modify slice", |
| value: []string{"a", "b", "c"}, |
| result: []string{"a", "b", "c"}, |
| err: fail, |
| }, { |
| name: "composite values update", |
| // allocate a slice with uninitialized values and let Update fill |
| // out default values. |
| value: &updated{A: make([]*int, 3)}, |
| result: &updated{ |
| A: []*int{&one, &one, &one}, |
| B: []int{1, 1, 1}, |
| M: map[string]int(nil), |
| }, |
| }, { |
| name: "composite values update with unsatisfied map constraints", |
| value: &updated{}, |
| result: &updated{}, |
| |
| constraints: ` { M: {foo: bar, bar: foo} } `, |
| err: fail, // incomplete values |
| }, { |
| name: "composite values update with map constraints", |
| value: &updated{M: map[string]int{"foo": 1}}, |
| constraints: ` { M: {foo: bar, bar: foo} } `, |
| result: &updated{ |
| // TODO: would be better if this is nil, but will not matter for |
| // JSON output: if omitempty is false, an empty list will be |
| // printed regardless, and if it is true, it will be omitted |
| // regardless. |
| A: []*int{}, |
| B: []int{1, 1, 1}, |
| M: map[string]int{"bar": 1, "foo": 1}, |
| }, |
| }} |
| for _, tc := range testCases { |
| t.Run(tc.name, func(t *testing.T) { |
| r := &cue.Runtime{} |
| codec := New(r, nil) |
| |
| v, err := codec.ExtractType(tc.value) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| if tc.constraints != "" { |
| inst, err := r.Compile(tc.name, tc.constraints) |
| if err != nil { |
| t.Fatal(err) |
| } |
| v = v.Unify(inst.Value()) |
| } |
| |
| err = codec.Complete(v, tc.value) |
| checkErr(t, err, tc.err) |
| if !reflect.DeepEqual(tc.value, tc.result) { |
| t.Error(pretty.Diff(tc.value, tc.result)) |
| } |
| }) |
| } |
| } |
| |
| func TestEncode(t *testing.T) { |
| testCases := []struct { |
| in string |
| dst interface{} |
| want interface{} |
| }{{ |
| in: "4", |
| dst: new(int), |
| want: 4, |
| }} |
| r := &cue.Runtime{} |
| c := New(r, nil) |
| |
| for _, tc := range testCases { |
| t.Run("", func(t *testing.T) { |
| inst, err := r.Compile("test", tc.in) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| err = c.Encode(inst.Value(), tc.dst) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| got := reflect.ValueOf(tc.dst).Elem().Interface() |
| if !cmp.Equal(got, tc.want) { |
| t.Error(cmp.Diff(got, tc.want)) |
| } |
| }) |
| } |
| } |
| |
| func TestDecode(t *testing.T) { |
| testCases := []struct { |
| in interface{} |
| want string |
| }{{ |
| in: "str", |
| want: `"str"`, |
| }, { |
| in: func() interface{} { |
| type T struct { |
| B int |
| } |
| type S struct { |
| A string |
| T |
| } |
| return S{} |
| }(), |
| want: `{ |
| A: "" |
| B: 0 |
| }`, |
| }, { |
| in: func() interface{} { |
| type T struct { |
| B int |
| } |
| type S struct { |
| A string |
| T `json:"t"` |
| } |
| return S{} |
| }(), |
| want: `{ |
| A: "" |
| t: { |
| B: 0 |
| } |
| }`, |
| }} |
| c := New(&cue.Runtime{}, nil) |
| |
| for _, tc := range testCases { |
| t.Run("", func(t *testing.T) { |
| v, err := c.Decode(tc.in) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| got := fmt.Sprint(v) |
| if got != tc.want { |
| t.Errorf("got %v; want %v", got, tc.want) |
| } |
| }) |
| } |
| } |
| |
| // For debugging purposes, do not remove. |
| func TestX(t *testing.T) { |
| t.Skip() |
| |
| fail := "some error" |
| // Not a typical constraint, but it is possible. |
| var ( |
| name = "string list incompatible lengths" |
| value = []string{"a", "b", "c"} |
| constraints = `4*[string]` |
| wantErr = fail |
| ) |
| |
| r := &cue.Runtime{} |
| codec := New(r, nil) |
| |
| v, err := codec.ExtractType(value) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| if constraints != "" { |
| inst, err := r.Compile(name, constraints) |
| if err != nil { |
| t.Fatal(err) |
| } |
| w := inst.Value() |
| v = v.Unify(w) |
| } |
| |
| err = codec.Validate(v, value) |
| checkErr(t, err, wantErr) |
| } |
