How to validate an ad-hoc go value?

[kstenerud]

I'm trying to validate an ad-hoc struct but it never fails the validation:

package main

import (
	"fmt"

	"cuelang.org/go/cue/cuecontext"
	"cuelang.org/go/cue/errors"
)

type Val struct {
	I int
	S string
	b bool
}

func main() {
	c := cuecontext.New()

	s := c.CompileString(`
	#schema: {
		i: string
		s: string
	}
	`)
	if s.Err() != nil {
		fmt.Printf("Compile Error:\n%s\n", errors.Details(s.Err(), nil))
		return
	}

	v := c.Encode(Val{
		I: 1,
		S: "hello",
		b: true,
	})
	if v.Err() != nil {
		fmt.Printf("Encode Error:\n%s\n", errors.Details(v.Err(), nil))
		return
	}

	u := s.Unify(v)
	if u.Err() != nil {
		fmt.Printf("Unify Error:\n%s\n", errors.Details(u.Err(), nil))
		return
	}
	err := u.Validate()
	if err != nil {
		fmt.Printf("Validate Error:\n%s\n", errors.Details(err, nil))
		return
	}

	fmt.Printf("%#v\n", u)
}

This passes validation, despite I not being a string:

karl@dev:~/tmp/cuetest$ go build && ./cuetest
#schema: {
	i: string
	s: string
}
I: 1
S: "hello"

[myitcv]

You were very close! I've presented your code as main1.go below and the fixed versions as main2.go.

The CompileString() call you had returned a struct value that has a field named #schema. You you were unifying and validating your encoded value against that struct value, which is open. Hence it passed. Instead, you need to choose the #schema value, and unify and validate against that, which is what I do in main2.go. You will also notice that I have ensured the field names match, using the json field tag.

go mod tidy

# This should fail but doesn't...
go run main1.go

# This does fail as expected
go run main2.go
stdout 'conflicting values string and 1 \(mismatched types string and int\)'

# Show the diff between main1 and main2
! exec diff -wu main1.go main2.go

-- go.mod --
module mod.com

go 1.18

require cuelang.org/go v0.4.3

require (
	github.com/cockroachdb/apd/v2 v2.0.1 // indirect
	github.com/mpvl/unique v0.0.0-20150818121801-cbe035fff7de // indirect
	github.com/pkg/errors v0.8.1 // indirect
	golang.org/x/text v0.3.7 // indirect
)
-- main1.go --
//go:build ignore
// +build ignore

package main

import (
	"fmt"

	"cuelang.org/go/cue/cuecontext"
	"cuelang.org/go/cue/errors"
)

type Val struct {
	I int
	S string
	b bool
}

func main() {
	c := cuecontext.New()

	s := c.CompileString(`
	#schema: {
		i: string
		s: string
	}
	`)
	if s.Err() != nil {
		fmt.Printf("Compile Error:\n%s\n", errors.Details(s.Err(), nil))
		return
	}

	v := c.Encode(Val{
		I: 1,
		S: "hello",
		b: true,
	})
	if v.Err() != nil {
		fmt.Printf("Encode Error:\n%s\n", errors.Details(v.Err(), nil))
		return
	}

	u := s.Unify(v)
	if u.Err() != nil {
		fmt.Printf("Unify Error:\n%s\n", errors.Details(u.Err(), nil))
		return
	}
	err := u.Validate()
	if err != nil {
		fmt.Printf("Validate Error:\n%s\n", errors.Details(err, nil))
		return
	}

	fmt.Printf("%#v\n", u)
}
-- main2.go --
//go:build ignore
// +build ignore

package main

import (
	"fmt"

	"cuelang.org/go/cue"
	"cuelang.org/go/cue/cuecontext"
	"cuelang.org/go/cue/errors"
)

type Val struct {
	I int    `json:"i"`
	S string `json:"s"`
	b bool
}

func main() {
	c := cuecontext.New()

	s := c.CompileString(`
	#schema: {
		i: string
		s: string
	}
	`).LookupPath(cue.ParsePath("#schema"))
	if s.Err() != nil {
		fmt.Printf("Compile Error:\n%s\n", errors.Details(s.Err(), nil))
		return
	}

	v := c.Encode(Val{
		I: 1,
		S: "hello",
		b: true,
	})
	if v.Err() != nil {
		fmt.Printf("Encode Error:\n%s\n", errors.Details(v.Err(), nil))
		return
	}

	u := s.Unify(v)
	if u.Err() != nil {
		fmt.Printf("Unify Error:\n%s\n", errors.Details(u.Err(), nil))
		return
	}
	err := u.Validate()
	if err != nil {
		fmt.Printf("Validate Error:\n%s\n", errors.Details(err, nil))
		return
	}

	fmt.Printf("%#v\n", u)
}
-- deps.go --
package deps

import (
	_ "cuelang.org/go/cue"
)

This gives the output:

> go mod tidy
# This should fail but doesn't... (0.279s)
> go run main1.go
[stdout]
#schema: {
        i: string
        s: string
}
I: 1
S: "hello"

# This does fail as expected (0.276s)
> go run main2.go
[stdout]
Unify Error:
#schema.i: conflicting values string and 1 (mismatched types string and int):
    3:6


> stdout 'conflicting values string and 1 \(mismatched types string and int\)'
# Show the diff between main1 and main2 (0.001s)
> ! exec diff -wu main1.go main2.go
[stdout]
--- main1.go    2022-06-07 08:45:27.135412534 +0100
+++ main2.go    2022-06-07 08:45:27.135412534 +0100
@@ -6,13 +6,14 @@
 import (
        "fmt"

+       "cuelang.org/go/cue"
        "cuelang.org/go/cue/cuecontext"
        "cuelang.org/go/cue/errors"
 )

 type Val struct {
-       I int
-       S string
+       I int    `json:"i"`
+       S string `json:"s"`
        b bool
 }

@@ -24,7 +25,7 @@
                i: string
                s: string
        }
-       `)
+       `).LookupPath(cue.ParsePath("#schema"))
        if s.Err() != nil {
                fmt.Printf("Compile Error:\n%s\n", errors.Details(s.Err(), nil))
                return