add(all): test files for type-set

Signed-off-by: Tit Petric <black@scene-si.org>

codegen.sh

@@ -1,6 +1,8 @@
 #!/bin/bash
 set -e
 
+find ./build -name gen-* -delete
+
 _PWD=$PWD
 
 function yellow {
@@ -21,6 +23,9 @@ function types {
 	if [ ! -f "build/gen-type-set" ]; then
 		CGO_ENABLED=0 go build -o ./build/gen-type-set codegen/v2/type-set.go 
 	fi
+	if [ ! -f "build/gen-type-set-test" ]; then
+		CGO_ENABLED=0 go build -o ./build/gen-type-set-test codegen/v2/type-set-test.go 
+	fi
 
 	./build/gen-type-set --types Namespace   --output compose/types/namespace.gen.go
 	./build/gen-type-set --types Attachment  --output compose/types/attachment.gen.go
@@ -31,7 +36,17 @@ function types {
 	./build/gen-type-set --types Record      --output compose/types/record.gen.go
 	./build/gen-type-set --types ModuleField --output compose/types/module_field.gen.go
 
+	./build/gen-type-set-test --types Namespace   --output compose/types/namespace.gen_test.go
+	./build/gen-type-set-test --types Attachment  --output compose/types/attachment.gen_test.go
+	./build/gen-type-set-test --types Module      --output compose/types/module.gen_test.go
+	./build/gen-type-set-test --types Page        --output compose/types/page.gen_test.go
+	./build/gen-type-set-test --types Chart       --output compose/types/chart.gen_test.go
+	./build/gen-type-set-test --types Trigger     --output compose/types/trigger.gen_test.go
+	./build/gen-type-set-test --types Record      --output compose/types/record.gen_test.go
+	./build/gen-type-set-test --types ModuleField --output compose/types/module_field.gen_test.go
+
 	./build/gen-type-set --with-primary-key=false --types RecordValue --output compose/types/record_value.gen.go
+	./build/gen-type-set-test --with-primary-key=false --types RecordValue --output compose/types/record_value.gen_test.go
 
 	./build/gen-type-set --types MessageAttachment --output messaging/types/attachment.gen.go
 	./build/gen-type-set --types Mention           --output messaging/types/mention.gen.go
@@ -40,22 +55,44 @@ function types {
 	./build/gen-type-set --types Channel           --output messaging/types/channel.gen.go
 	./build/gen-type-set --types Webhook           --output messaging/types/webhook.gen.go
 
+	./build/gen-type-set-test --types MessageAttachment --output messaging/types/attachment.gen_test.go
+	./build/gen-type-set-test --types Mention           --output messaging/types/mention.gen_test.go
+	./build/gen-type-set-test --types MessageFlag       --output messaging/types/message_flag.gen_test.go
+	./build/gen-type-set-test --types Message           --output messaging/types/message.gen_test.go
+	./build/gen-type-set-test --types Channel           --output messaging/types/channel.gen_test.go
+	./build/gen-type-set-test --types Webhook           --output messaging/types/webhook.gen_test.go
+
 	./build/gen-type-set --with-primary-key=false --types ChannelMember --output messaging/types/channel_member.gen.go
 	./build/gen-type-set --with-primary-key=false --types Command       --output messaging/types/command.gen.go
 	./build/gen-type-set --with-primary-key=false --types CommandParam  --output messaging/types/command_param.gen.go
 	./build/gen-type-set --with-primary-key=false --types Unread        --output messaging/types/unread.gen.go
 
+	./build/gen-type-set-test --with-primary-key=false --types ChannelMember --output messaging/types/channel_member.gen_test.go
+	./build/gen-type-set-test --with-primary-key=false --types Command       --output messaging/types/command.gen_test.go
+	./build/gen-type-set-test --with-primary-key=false --types CommandParam  --output messaging/types/command_param.gen_test.go
+	./build/gen-type-set-test --with-primary-key=false --types Unread        --output messaging/types/unread.gen_test.go
+
 	./build/gen-type-set --types User         --output system/types/user.gen.go
 	./build/gen-type-set --types Application  --output system/types/application.gen.go
 	./build/gen-type-set --types Role         --output system/types/role.gen.go
 	./build/gen-type-set --types Organisation --output system/types/organisation.gen.go
 	./build/gen-type-set --types Credentials  --output system/types/credentials.gen.go
 
+	./build/gen-type-set-test --types User         --output system/types/user.gen_test.go
+	./build/gen-type-set-test --types Application  --output system/types/application.gen_test.go
+	./build/gen-type-set-test --types Role         --output system/types/role.gen_test.go
+	./build/gen-type-set-test --types Organisation --output system/types/organisation.gen_test.go
+	./build/gen-type-set-test --types Credentials  --output system/types/credentials.gen_test.go
+
 	./build/gen-type-set --types Value --output internal/settings/types.gen.go --with-primary-key=false --package settings
+	./build/gen-type-set-test --types Value --output internal/settings/types.gen_test.go --with-primary-key=false --package settings
 
 	./build/gen-type-set --types Rule      --output internal/permissions/rule.gen.go     --with-primary-key=false --package permissions
 	./build/gen-type-set --types Resource  --output internal/permissions/resource.gen.go --with-primary-key=false --package permissions
 
+	./build/gen-type-set-test --types Rule      --output internal/permissions/rule.gen_test.go     --with-primary-key=false --package permissions
+	./build/gen-type-set-test --types Resource  --output internal/permissions/resource.gen_test.go --with-primary-key=false --package permissions
+
 	green "OK"
 }
 

codegen/v2/type-set-test.go

@@ -0,0 +1,207 @@
+package main
+
+// *Set type generator for functions like Walk(), Filter(), FindByID() & IDs()
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+	"go/format"
+	"io"
+	"os"
+	"strings"
+	"text/template"
+)
+
+const tmplTypeSet = `package {{ .Package }}
+
+{{ if .Imports }}
+import (
+	{{ range $i, $import := .Imports }}
+	{{ if $import }}
+	"{{ $import }}"
+	{{ else }}
+
+	{{ end }}
+	{{ end }}
+)
+{{ end }}
+
+// 	Hello! This file is auto-generated.
+
+{{ range $i, $set := .Sets }}
+
+func Test{{ $set }}SetWalk(t *testing.T) {
+	value := make({{ $set }}Set, 3)
+
+	// check walk with no errors
+	{
+		err := value.Walk(func(*{{ $set }}) error {
+			return nil
+		})
+		test.NoError(t, err, "Expected no returned error from Walk, got %+v", err)
+	}
+
+	// check walk with error
+	test.Error(t, value.Walk(func(*{{ $set }}) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
+}
+
+func Test{{ $set }}SetFilter(t *testing.T) {
+	value := make({{ $set }}Set, 3)
+
+	// filter nothing
+	{
+		set, err := value.Filter(func(*{{ $set }}) (bool, error) {
+			return true, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == len(value), "Expected equal length filter: %d != %d", len(value), len(set))
+	}
+
+	// filter one item
+	{
+		found := false
+		set, err := value.Filter(func(*{{ $set }}) (bool, error) {
+			if !found {
+				found = true
+				return found, nil
+			}
+			return false, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == 1, "Expected single item, got %d", len(value))
+	}
+
+	// filter error
+	{
+		_, err := value.Filter(func(*{{ $set }}) (bool, error) {
+			return false, errors.New("Filter error")
+		})
+		test.Error(t, err, "Expected error, got %#v", err)
+	}
+}
+
+{{ if $.WithPrimaryKey }}
+func Test{{ $set }}SetIDs(t *testing.T) {
+	value := make({{ $set }}Set, 3)
+	// construct objects
+	value[0] = new({{ $set }})
+	value[1] = new({{ $set }})
+	value[2] = new({{ $set }})
+	// set ids
+	value[0].ID = 1
+	value[1].ID = 2
+	value[2].ID = 3
+
+	// Find existing
+	{
+		val := value.FindByID(2)
+		test.Assert(t, val.ID == 2, "Expected ID 2, got %d", val.ID)
+	}
+
+	// Find non-existing
+	{
+		val := value.FindByID(4)
+		test.Assert(t, val == nil, "Expected no value, got %#v", val)
+	}
+
+	// List IDs from set
+	{
+		val := value.IDs()
+		test.Assert(t, len(val) == len(value), "Expected ID count mismatch, %d != %d", len(val), len(value))
+	}
+}
+{{ end }}
+
+{{ end }}
+`
+
+func main() {
+	t := template.New("")
+
+	tpl := template.Must(template.Must(t.Clone()).Parse(tmplTypeSet))
+
+	var (
+		importsStr,
+		stdTypesStr,
+		outputFile string
+		output io.Writer
+	)
+
+	payload := struct {
+		Package string
+		Sets    []string
+		Imports []string
+
+		ResourceType string
+
+		WithPrimaryKey bool
+		WithResources  bool
+	}{}
+
+	payload.Imports = []string{
+		"testing",
+		"errors",
+		"",
+		"github.com/crusttech/crust/internal/test",
+	}
+
+	flag.StringVar(&stdTypesStr, "types", "", "Comma separated list of types")
+	flag.StringVar(&importsStr, "imports", "", "Comma separated list of imports")
+	flag.StringVar(&payload.Package, "package", "types", "Package name")
+
+	flag.BoolVar(&payload.WithPrimaryKey, "with-primary-key", true, "Generate types with ID field")
+
+	flag.BoolVar(&payload.WithResources, "with-resources", false, "Generate Resources() functions")
+	flag.StringVar(&payload.ResourceType, "resource-type", "Resource", "Resource type name to use (with imports)")
+
+	flag.StringVar(&outputFile, "output", "", "JWT Expiration in minutes")
+
+	flag.Parse()
+	for _, name := range strings.Split(importsStr, ",") {
+		if name = strings.TrimSpace(name); len(name) > 0 {
+			payload.Imports = append(payload.Imports, name)
+		}
+	}
+
+	for _, name := range strings.Split(stdTypesStr, ",") {
+		if name = strings.TrimSpace(name); len(name) > 0 {
+			payload.Sets = append(payload.Sets, name)
+		}
+	}
+
+	buf := bytes.Buffer{}
+
+	if err := tpl.Execute(&buf, payload); err != nil {
+		exit(err)
+	} else {
+		fmtsrc, err := format.Source(buf.Bytes())
+		if err != nil {
+			stderr("fmt warn: %v", err)
+			fmtsrc = buf.Bytes()
+		}
+
+		if outputFile == "" || outputFile == "-" {
+			output = os.Stdout
+		} else {
+			if output, err = os.Create(outputFile); err != nil {
+				exit(err)
+			}
+			fmt.Println(outputFile)
+			defer output.(io.Closer).Close()
+		}
+
+		if _, err := output.Write(fmtsrc); err != nil {
+			exit(err)
+		}
+	}
+}
+
+func stderr(format string, a ...interface{}) {
+	_, _ = os.Stderr.WriteString(fmt.Sprintf(format+"\n", a...))
+}
+
+func exit(err error) {
+	stderr("error: %v", err)
+	os.Exit(1)
+}

compose/types/attachment.gen_test.go

@@ -0,0 +1,91 @@
+package types
+
+import (
+	"testing"
+
+	"errors"
+
+	"github.com/crusttech/crust/internal/test"
+)
+
+// 	Hello! This file is auto-generated.
+
+func TestAttachmentSetWalk(t *testing.T) {
+	value := make(AttachmentSet, 3)
+
+	// check walk with no errors
+	{
+		err := value.Walk(func(*Attachment) error {
+			return nil
+		})
+		test.NoError(t, err, "Expected no returned error from Walk, got %+v", err)
+	}
+
+	// check walk with error
+	test.Error(t, value.Walk(func(*Attachment) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
+}
+
+func TestAttachmentSetFilter(t *testing.T) {
+	value := make(AttachmentSet, 3)
+
+	// filter nothing
+	{
+		set, err := value.Filter(func(*Attachment) (bool, error) {
+			return true, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == len(value), "Expected equal length filter: %d != %d", len(value), len(set))
+	}
+
+	// filter one item
+	{
+		found := false
+		set, err := value.Filter(func(*Attachment) (bool, error) {
+			if !found {
+				found = true
+				return found, nil
+			}
+			return false, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == 1, "Expected single item, got %d", len(value))
+	}
+
+	// filter error
+	{
+		_, err := value.Filter(func(*Attachment) (bool, error) {
+			return false, errors.New("Filter error")
+		})
+		test.Error(t, err, "Expected error, got %#v", err)
+	}
+}
+
+func TestAttachmentSetIDs(t *testing.T) {
+	value := make(AttachmentSet, 3)
+	// construct objects
+	value[0] = new(Attachment)
+	value[1] = new(Attachment)
+	value[2] = new(Attachment)
+	// set ids
+	value[0].ID = 1
+	value[1].ID = 2
+	value[2].ID = 3
+
+	// Find existing
+	{
+		val := value.FindByID(2)
+		test.Assert(t, val.ID == 2, "Expected ID 2, got %d", val.ID)
+	}
+
+	// Find non-existing
+	{
+		val := value.FindByID(4)
+		test.Assert(t, val == nil, "Expected no value, got %#v", val)
+	}
+
+	// List IDs from set
+	{
+		val := value.IDs()
+		test.Assert(t, len(val) == len(value), "Expected ID count mismatch, %d != %d", len(val), len(value))
+	}
+}

compose/types/chart.gen_test.go

@@ -0,0 +1,91 @@
+package types
+
+import (
+	"testing"
+
+	"errors"
+
+	"github.com/crusttech/crust/internal/test"
+)
+
+// 	Hello! This file is auto-generated.
+
+func TestChartSetWalk(t *testing.T) {
+	value := make(ChartSet, 3)
+
+	// check walk with no errors
+	{
+		err := value.Walk(func(*Chart) error {
+			return nil
+		})
+		test.NoError(t, err, "Expected no returned error from Walk, got %+v", err)
+	}
+
+	// check walk with error
+	test.Error(t, value.Walk(func(*Chart) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
+}
+
+func TestChartSetFilter(t *testing.T) {
+	value := make(ChartSet, 3)
+
+	// filter nothing
+	{
+		set, err := value.Filter(func(*Chart) (bool, error) {
+			return true, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == len(value), "Expected equal length filter: %d != %d", len(value), len(set))
+	}
+
+	// filter one item
+	{
+		found := false
+		set, err := value.Filter(func(*Chart) (bool, error) {
+			if !found {
+				found = true
+				return found, nil
+			}
+			return false, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == 1, "Expected single item, got %d", len(value))
+	}
+
+	// filter error
+	{
+		_, err := value.Filter(func(*Chart) (bool, error) {
+			return false, errors.New("Filter error")
+		})
+		test.Error(t, err, "Expected error, got %#v", err)
+	}
+}
+
+func TestChartSetIDs(t *testing.T) {
+	value := make(ChartSet, 3)
+	// construct objects
+	value[0] = new(Chart)
+	value[1] = new(Chart)
+	value[2] = new(Chart)
+	// set ids
+	value[0].ID = 1
+	value[1].ID = 2
+	value[2].ID = 3
+
+	// Find existing
+	{
+		val := value.FindByID(2)
+		test.Assert(t, val.ID == 2, "Expected ID 2, got %d", val.ID)
+	}
+
+	// Find non-existing
+	{
+		val := value.FindByID(4)
+		test.Assert(t, val == nil, "Expected no value, got %#v", val)
+	}
+
+	// List IDs from set
+	{
+		val := value.IDs()
+		test.Assert(t, len(val) == len(value), "Expected ID count mismatch, %d != %d", len(val), len(value))
+	}
+}

compose/types/module.gen_test.go

@@ -0,0 +1,91 @@
+package types
+
+import (
+	"testing"
+
+	"errors"
+
+	"github.com/crusttech/crust/internal/test"
+)
+
+// 	Hello! This file is auto-generated.
+
+func TestModuleSetWalk(t *testing.T) {
+	value := make(ModuleSet, 3)
+
+	// check walk with no errors
+	{
+		err := value.Walk(func(*Module) error {
+			return nil
+		})
+		test.NoError(t, err, "Expected no returned error from Walk, got %+v", err)
+	}
+
+	// check walk with error
+	test.Error(t, value.Walk(func(*Module) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
+}
+
+func TestModuleSetFilter(t *testing.T) {
+	value := make(ModuleSet, 3)
+
+	// filter nothing
+	{
+		set, err := value.Filter(func(*Module) (bool, error) {
+			return true, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == len(value), "Expected equal length filter: %d != %d", len(value), len(set))
+	}
+
+	// filter one item
+	{
+		found := false
+		set, err := value.Filter(func(*Module) (bool, error) {
+			if !found {
+				found = true
+				return found, nil
+			}
+			return false, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == 1, "Expected single item, got %d", len(value))
+	}
+
+	// filter error
+	{
+		_, err := value.Filter(func(*Module) (bool, error) {
+			return false, errors.New("Filter error")
+		})
+		test.Error(t, err, "Expected error, got %#v", err)
+	}
+}
+
+func TestModuleSetIDs(t *testing.T) {
+	value := make(ModuleSet, 3)
+	// construct objects
+	value[0] = new(Module)
+	value[1] = new(Module)
+	value[2] = new(Module)
+	// set ids
+	value[0].ID = 1
+	value[1].ID = 2
+	value[2].ID = 3
+
+	// Find existing
+	{
+		val := value.FindByID(2)
+		test.Assert(t, val.ID == 2, "Expected ID 2, got %d", val.ID)
+	}
+
+	// Find non-existing
+	{
+		val := value.FindByID(4)
+		test.Assert(t, val == nil, "Expected no value, got %#v", val)
+	}
+
+	// List IDs from set
+	{
+		val := value.IDs()
+		test.Assert(t, len(val) == len(value), "Expected ID count mismatch, %d != %d", len(val), len(value))
+	}
+}

compose/types/module_field.gen_test.go

@@ -0,0 +1,91 @@
+package types
+
+import (
+	"testing"
+
+	"errors"
+
+	"github.com/crusttech/crust/internal/test"
+)
+
+// 	Hello! This file is auto-generated.
+
+func TestModuleFieldSetWalk(t *testing.T) {
+	value := make(ModuleFieldSet, 3)
+
+	// check walk with no errors
+	{
+		err := value.Walk(func(*ModuleField) error {
+			return nil
+		})
+		test.NoError(t, err, "Expected no returned error from Walk, got %+v", err)
+	}
+
+	// check walk with error
+	test.Error(t, value.Walk(func(*ModuleField) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
+}
+
+func TestModuleFieldSetFilter(t *testing.T) {
+	value := make(ModuleFieldSet, 3)
+
+	// filter nothing
+	{
+		set, err := value.Filter(func(*ModuleField) (bool, error) {
+			return true, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == len(value), "Expected equal length filter: %d != %d", len(value), len(set))
+	}
+
+	// filter one item
+	{
+		found := false
+		set, err := value.Filter(func(*ModuleField) (bool, error) {
+			if !found {
+				found = true
+				return found, nil
+			}
+			return false, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == 1, "Expected single item, got %d", len(value))
+	}
+
+	// filter error
+	{
+		_, err := value.Filter(func(*ModuleField) (bool, error) {
+			return false, errors.New("Filter error")
+		})
+		test.Error(t, err, "Expected error, got %#v", err)
+	}
+}
+
+func TestModuleFieldSetIDs(t *testing.T) {
+	value := make(ModuleFieldSet, 3)
+	// construct objects
+	value[0] = new(ModuleField)
+	value[1] = new(ModuleField)
+	value[2] = new(ModuleField)
+	// set ids
+	value[0].ID = 1
+	value[1].ID = 2
+	value[2].ID = 3
+
+	// Find existing
+	{
+		val := value.FindByID(2)
+		test.Assert(t, val.ID == 2, "Expected ID 2, got %d", val.ID)
+	}
+
+	// Find non-existing
+	{
+		val := value.FindByID(4)
+		test.Assert(t, val == nil, "Expected no value, got %#v", val)
+	}
+
+	// List IDs from set
+	{
+		val := value.IDs()
+		test.Assert(t, len(val) == len(value), "Expected ID count mismatch, %d != %d", len(val), len(value))
+	}
+}

compose/types/namespace.gen_test.go

@@ -0,0 +1,91 @@
+package types
+
+import (
+	"testing"
+
+	"errors"
+
+	"github.com/crusttech/crust/internal/test"
+)
+
+// 	Hello! This file is auto-generated.
+
+func TestNamespaceSetWalk(t *testing.T) {
+	value := make(NamespaceSet, 3)
+
+	// check walk with no errors
+	{
+		err := value.Walk(func(*Namespace) error {
+			return nil
+		})
+		test.NoError(t, err, "Expected no returned error from Walk, got %+v", err)
+	}
+
+	// check walk with error
+	test.Error(t, value.Walk(func(*Namespace) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
+}
+
+func TestNamespaceSetFilter(t *testing.T) {
+	value := make(NamespaceSet, 3)
+
+	// filter nothing
+	{
+		set, err := value.Filter(func(*Namespace) (bool, error) {
+			return true, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == len(value), "Expected equal length filter: %d != %d", len(value), len(set))
+	}
+
+	// filter one item
+	{
+		found := false
+		set, err := value.Filter(func(*Namespace) (bool, error) {
+			if !found {
+				found = true
+				return found, nil
+			}
+			return false, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == 1, "Expected single item, got %d", len(value))
+	}
+
+	// filter error
+	{
+		_, err := value.Filter(func(*Namespace) (bool, error) {
+			return false, errors.New("Filter error")
+		})
+		test.Error(t, err, "Expected error, got %#v", err)
+	}
+}
+
+func TestNamespaceSetIDs(t *testing.T) {
+	value := make(NamespaceSet, 3)
+	// construct objects
+	value[0] = new(Namespace)
+	value[1] = new(Namespace)
+	value[2] = new(Namespace)
+	// set ids
+	value[0].ID = 1
+	value[1].ID = 2
+	value[2].ID = 3
+
+	// Find existing
+	{
+		val := value.FindByID(2)
+		test.Assert(t, val.ID == 2, "Expected ID 2, got %d", val.ID)
+	}
+
+	// Find non-existing
+	{
+		val := value.FindByID(4)
+		test.Assert(t, val == nil, "Expected no value, got %#v", val)
+	}
+
+	// List IDs from set
+	{
+		val := value.IDs()
+		test.Assert(t, len(val) == len(value), "Expected ID count mismatch, %d != %d", len(val), len(value))
+	}
+}

compose/types/page.gen_test.go

@@ -0,0 +1,91 @@
+package types
+
+import (
+	"testing"
+
+	"errors"
+
+	"github.com/crusttech/crust/internal/test"
+)
+
+// 	Hello! This file is auto-generated.
+
+func TestPageSetWalk(t *testing.T) {
+	value := make(PageSet, 3)
+
+	// check walk with no errors
+	{
+		err := value.Walk(func(*Page) error {
+			return nil
+		})
+		test.NoError(t, err, "Expected no returned error from Walk, got %+v", err)
+	}
+
+	// check walk with error
+	test.Error(t, value.Walk(func(*Page) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
+}
+
+func TestPageSetFilter(t *testing.T) {
+	value := make(PageSet, 3)
+
+	// filter nothing
+	{
+		set, err := value.Filter(func(*Page) (bool, error) {
+			return true, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == len(value), "Expected equal length filter: %d != %d", len(value), len(set))
+	}
+
+	// filter one item
+	{
+		found := false
+		set, err := value.Filter(func(*Page) (bool, error) {
+			if !found {
+				found = true
+				return found, nil
+			}
+			return false, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == 1, "Expected single item, got %d", len(value))
+	}
+
+	// filter error
+	{
+		_, err := value.Filter(func(*Page) (bool, error) {
+			return false, errors.New("Filter error")
+		})
+		test.Error(t, err, "Expected error, got %#v", err)
+	}
+}
+
+func TestPageSetIDs(t *testing.T) {
+	value := make(PageSet, 3)
+	// construct objects
+	value[0] = new(Page)
+	value[1] = new(Page)
+	value[2] = new(Page)
+	// set ids
+	value[0].ID = 1
+	value[1].ID = 2
+	value[2].ID = 3
+
+	// Find existing
+	{
+		val := value.FindByID(2)
+		test.Assert(t, val.ID == 2, "Expected ID 2, got %d", val.ID)
+	}
+
+	// Find non-existing
+	{
+		val := value.FindByID(4)
+		test.Assert(t, val == nil, "Expected no value, got %#v", val)
+	}
+
+	// List IDs from set
+	{
+		val := value.IDs()
+		test.Assert(t, len(val) == len(value), "Expected ID count mismatch, %d != %d", len(val), len(value))
+	}
+}

compose/types/record.gen_test.go

@@ -0,0 +1,91 @@
+package types
+
+import (
+	"testing"
+
+	"errors"
+
+	"github.com/crusttech/crust/internal/test"
+)
+
+// 	Hello! This file is auto-generated.
+
+func TestRecordSetWalk(t *testing.T) {
+	value := make(RecordSet, 3)
+
+	// check walk with no errors
+	{
+		err := value.Walk(func(*Record) error {
+			return nil
+		})
+		test.NoError(t, err, "Expected no returned error from Walk, got %+v", err)
+	}
+
+	// check walk with error
+	test.Error(t, value.Walk(func(*Record) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
+}
+
+func TestRecordSetFilter(t *testing.T) {
+	value := make(RecordSet, 3)
+
+	// filter nothing
+	{
+		set, err := value.Filter(func(*Record) (bool, error) {
+			return true, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == len(value), "Expected equal length filter: %d != %d", len(value), len(set))
+	}
+
+	// filter one item
+	{
+		found := false
+		set, err := value.Filter(func(*Record) (bool, error) {
+			if !found {
+				found = true
+				return found, nil
+			}
+			return false, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == 1, "Expected single item, got %d", len(value))
+	}
+
+	// filter error
+	{
+		_, err := value.Filter(func(*Record) (bool, error) {
+			return false, errors.New("Filter error")
+		})
+		test.Error(t, err, "Expected error, got %#v", err)
+	}
+}
+
+func TestRecordSetIDs(t *testing.T) {
+	value := make(RecordSet, 3)
+	// construct objects
+	value[0] = new(Record)
+	value[1] = new(Record)
+	value[2] = new(Record)
+	// set ids
+	value[0].ID = 1
+	value[1].ID = 2
+	value[2].ID = 3
+
+	// Find existing
+	{
+		val := value.FindByID(2)
+		test.Assert(t, val.ID == 2, "Expected ID 2, got %d", val.ID)
+	}
+
+	// Find non-existing
+	{
+		val := value.FindByID(4)
+		test.Assert(t, val == nil, "Expected no value, got %#v", val)
+	}
+
+	// List IDs from set
+	{
+		val := value.IDs()
+		test.Assert(t, len(val) == len(value), "Expected ID count mismatch, %d != %d", len(val), len(value))
+	}
+}

compose/types/record_value.gen_test.go

@@ -0,0 +1,61 @@
+package types
+
+import (
+	"testing"
+
+	"errors"
+
+	"github.com/crusttech/crust/internal/test"
+)
+
+// 	Hello! This file is auto-generated.
+
+func TestRecordValueSetWalk(t *testing.T) {
+	value := make(RecordValueSet, 3)
+
+	// check walk with no errors
+	{
+		err := value.Walk(func(*RecordValue) error {
+			return nil
+		})
+		test.NoError(t, err, "Expected no returned error from Walk, got %+v", err)
+	}
+
+	// check walk with error
+	test.Error(t, value.Walk(func(*RecordValue) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
+}
+
+func TestRecordValueSetFilter(t *testing.T) {
+	value := make(RecordValueSet, 3)
+
+	// filter nothing
+	{
+		set, err := value.Filter(func(*RecordValue) (bool, error) {
+			return true, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == len(value), "Expected equal length filter: %d != %d", len(value), len(set))
+	}
+
+	// filter one item
+	{
+		found := false
+		set, err := value.Filter(func(*RecordValue) (bool, error) {
+			if !found {
+				found = true
+				return found, nil
+			}
+			return false, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == 1, "Expected single item, got %d", len(value))
+	}
+
+	// filter error
+	{
+		_, err := value.Filter(func(*RecordValue) (bool, error) {
+			return false, errors.New("Filter error")
+		})
+		test.Error(t, err, "Expected error, got %#v", err)
+	}
+}

compose/types/trigger.gen_test.go

@@ -0,0 +1,91 @@
+package types
+
+import (
+	"testing"
+
+	"errors"
+
+	"github.com/crusttech/crust/internal/test"
+)
+
+// 	Hello! This file is auto-generated.
+
+func TestTriggerSetWalk(t *testing.T) {
+	value := make(TriggerSet, 3)
+
+	// check walk with no errors
+	{
+		err := value.Walk(func(*Trigger) error {
+			return nil
+		})
+		test.NoError(t, err, "Expected no returned error from Walk, got %+v", err)
+	}
+
+	// check walk with error
+	test.Error(t, value.Walk(func(*Trigger) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
+}
+
+func TestTriggerSetFilter(t *testing.T) {
+	value := make(TriggerSet, 3)
+
+	// filter nothing
+	{
+		set, err := value.Filter(func(*Trigger) (bool, error) {
+			return true, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == len(value), "Expected equal length filter: %d != %d", len(value), len(set))
+	}
+
+	// filter one item
+	{
+		found := false
+		set, err := value.Filter(func(*Trigger) (bool, error) {
+			if !found {
+				found = true
+				return found, nil
+			}
+			return false, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == 1, "Expected single item, got %d", len(value))
+	}
+
+	// filter error
+	{
+		_, err := value.Filter(func(*Trigger) (bool, error) {
+			return false, errors.New("Filter error")
+		})
+		test.Error(t, err, "Expected error, got %#v", err)
+	}
+}
+
+func TestTriggerSetIDs(t *testing.T) {
+	value := make(TriggerSet, 3)
+	// construct objects
+	value[0] = new(Trigger)
+	value[1] = new(Trigger)
+	value[2] = new(Trigger)
+	// set ids
+	value[0].ID = 1
+	value[1].ID = 2
+	value[2].ID = 3
+
+	// Find existing
+	{
+		val := value.FindByID(2)
+		test.Assert(t, val.ID == 2, "Expected ID 2, got %d", val.ID)
+	}
+
+	// Find non-existing
+	{
+		val := value.FindByID(4)
+		test.Assert(t, val == nil, "Expected no value, got %#v", val)
+	}
+
+	// List IDs from set
+	{
+		val := value.IDs()
+		test.Assert(t, len(val) == len(value), "Expected ID count mismatch, %d != %d", len(val), len(value))
+	}
+}

internal/permissions/resource.gen_test.go

@@ -0,0 +1,61 @@
+package permissions
+
+import (
+	"testing"
+
+	"errors"
+
+	"github.com/crusttech/crust/internal/test"
+)
+
+// 	Hello! This file is auto-generated.
+
+func TestResourceSetWalk(t *testing.T) {
+	value := make(ResourceSet, 3)
+
+	// check walk with no errors
+	{
+		err := value.Walk(func(*Resource) error {
+			return nil
+		})
+		test.NoError(t, err, "Expected no returned error from Walk, got %+v", err)
+	}
+
+	// check walk with error
+	test.Error(t, value.Walk(func(*Resource) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
+}
+
+func TestResourceSetFilter(t *testing.T) {
+	value := make(ResourceSet, 3)
+
+	// filter nothing
+	{
+		set, err := value.Filter(func(*Resource) (bool, error) {
+			return true, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == len(value), "Expected equal length filter: %d != %d", len(value), len(set))
+	}
+
+	// filter one item
+	{
+		found := false
+		set, err := value.Filter(func(*Resource) (bool, error) {
+			if !found {
+				found = true
+				return found, nil
+			}
+			return false, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == 1, "Expected single item, got %d", len(value))
+	}
+
+	// filter error
+	{
+		_, err := value.Filter(func(*Resource) (bool, error) {
+			return false, errors.New("Filter error")
+		})
+		test.Error(t, err, "Expected error, got %#v", err)
+	}
+}

internal/permissions/rule.gen_test.go

@@ -0,0 +1,61 @@
+package permissions
+
+import (
+	"testing"
+
+	"errors"
+
+	"github.com/crusttech/crust/internal/test"
+)
+
+// 	Hello! This file is auto-generated.
+
+func TestRuleSetWalk(t *testing.T) {
+	value := make(RuleSet, 3)
+
+	// check walk with no errors
+	{
+		err := value.Walk(func(*Rule) error {
+			return nil
+		})
+		test.NoError(t, err, "Expected no returned error from Walk, got %+v", err)
+	}
+
+	// check walk with error
+	test.Error(t, value.Walk(func(*Rule) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
+}
+
+func TestRuleSetFilter(t *testing.T) {
+	value := make(RuleSet, 3)
+
+	// filter nothing
+	{
+		set, err := value.Filter(func(*Rule) (bool, error) {
+			return true, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == len(value), "Expected equal length filter: %d != %d", len(value), len(set))
+	}
+
+	// filter one item
+	{
+		found := false
+		set, err := value.Filter(func(*Rule) (bool, error) {
+			if !found {
+				found = true
+				return found, nil
+			}
+			return false, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == 1, "Expected single item, got %d", len(value))
+	}
+
+	// filter error
+	{
+		_, err := value.Filter(func(*Rule) (bool, error) {
+			return false, errors.New("Filter error")
+		})
+		test.Error(t, err, "Expected error, got %#v", err)
+	}
+}

internal/settings/types.gen_test.go

@@ -0,0 +1,61 @@
+package settings
+
+import (
+	"testing"
+
+	"errors"
+
+	"github.com/crusttech/crust/internal/test"
+)
+
+// 	Hello! This file is auto-generated.
+
+func TestValueSetWalk(t *testing.T) {
+	value := make(ValueSet, 3)
+
+	// check walk with no errors
+	{
+		err := value.Walk(func(*Value) error {
+			return nil
+		})
+		test.NoError(t, err, "Expected no returned error from Walk, got %+v", err)
+	}
+
+	// check walk with error
+	test.Error(t, value.Walk(func(*Value) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
+}
+
+func TestValueSetFilter(t *testing.T) {
+	value := make(ValueSet, 3)
+
+	// filter nothing
+	{
+		set, err := value.Filter(func(*Value) (bool, error) {
+			return true, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == len(value), "Expected equal length filter: %d != %d", len(value), len(set))
+	}
+
+	// filter one item
+	{
+		found := false
+		set, err := value.Filter(func(*Value) (bool, error) {
+			if !found {
+				found = true
+				return found, nil
+			}
+			return false, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == 1, "Expected single item, got %d", len(value))
+	}
+
+	// filter error
+	{
+		_, err := value.Filter(func(*Value) (bool, error) {
+			return false, errors.New("Filter error")
+		})
+		test.Error(t, err, "Expected error, got %#v", err)
+	}
+}

messaging/types/attachment.gen_test.go

@@ -0,0 +1,91 @@
+package types
+
+import (
+	"testing"
+
+	"errors"
+
+	"github.com/crusttech/crust/internal/test"
+)
+
+// 	Hello! This file is auto-generated.
+
+func TestMessageAttachmentSetWalk(t *testing.T) {
+	value := make(MessageAttachmentSet, 3)
+
+	// check walk with no errors
+	{
+		err := value.Walk(func(*MessageAttachment) error {
+			return nil
+		})
+		test.NoError(t, err, "Expected no returned error from Walk, got %+v", err)
+	}
+
+	// check walk with error
+	test.Error(t, value.Walk(func(*MessageAttachment) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
+}
+
+func TestMessageAttachmentSetFilter(t *testing.T) {
+	value := make(MessageAttachmentSet, 3)
+
+	// filter nothing
+	{
+		set, err := value.Filter(func(*MessageAttachment) (bool, error) {
+			return true, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == len(value), "Expected equal length filter: %d != %d", len(value), len(set))
+	}
+
+	// filter one item
+	{
+		found := false
+		set, err := value.Filter(func(*MessageAttachment) (bool, error) {
+			if !found {
+				found = true
+				return found, nil
+			}
+			return false, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == 1, "Expected single item, got %d", len(value))
+	}
+
+	// filter error
+	{
+		_, err := value.Filter(func(*MessageAttachment) (bool, error) {
+			return false, errors.New("Filter error")
+		})
+		test.Error(t, err, "Expected error, got %#v", err)
+	}
+}
+
+func TestMessageAttachmentSetIDs(t *testing.T) {
+	value := make(MessageAttachmentSet, 3)
+	// construct objects
+	value[0] = new(MessageAttachment)
+	value[1] = new(MessageAttachment)
+	value[2] = new(MessageAttachment)
+	// set ids
+	value[0].ID = 1
+	value[1].ID = 2
+	value[2].ID = 3
+
+	// Find existing
+	{
+		val := value.FindByID(2)
+		test.Assert(t, val.ID == 2, "Expected ID 2, got %d", val.ID)
+	}
+
+	// Find non-existing
+	{
+		val := value.FindByID(4)
+		test.Assert(t, val == nil, "Expected no value, got %#v", val)
+	}
+
+	// List IDs from set
+	{
+		val := value.IDs()
+		test.Assert(t, len(val) == len(value), "Expected ID count mismatch, %d != %d", len(val), len(value))
+	}
+}

messaging/types/channel.gen_test.go

@@ -0,0 +1,91 @@
+package types
+
+import (
+	"testing"
+
+	"errors"
+
+	"github.com/crusttech/crust/internal/test"
+)
+
+// 	Hello! This file is auto-generated.
+
+func TestChannelSetWalk(t *testing.T) {
+	value := make(ChannelSet, 3)
+
+	// check walk with no errors
+	{
+		err := value.Walk(func(*Channel) error {
+			return nil
+		})
+		test.NoError(t, err, "Expected no returned error from Walk, got %+v", err)
+	}
+
+	// check walk with error
+	test.Error(t, value.Walk(func(*Channel) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
+}
+
+func TestChannelSetFilter(t *testing.T) {
+	value := make(ChannelSet, 3)
+
+	// filter nothing
+	{
+		set, err := value.Filter(func(*Channel) (bool, error) {
+			return true, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == len(value), "Expected equal length filter: %d != %d", len(value), len(set))
+	}
+
+	// filter one item
+	{
+		found := false
+		set, err := value.Filter(func(*Channel) (bool, error) {
+			if !found {
+				found = true
+				return found, nil
+			}
+			return false, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == 1, "Expected single item, got %d", len(value))
+	}
+
+	// filter error
+	{
+		_, err := value.Filter(func(*Channel) (bool, error) {
+			return false, errors.New("Filter error")
+		})
+		test.Error(t, err, "Expected error, got %#v", err)
+	}
+}
+
+func TestChannelSetIDs(t *testing.T) {
+	value := make(ChannelSet, 3)
+	// construct objects
+	value[0] = new(Channel)
+	value[1] = new(Channel)
+	value[2] = new(Channel)
+	// set ids
+	value[0].ID = 1
+	value[1].ID = 2
+	value[2].ID = 3
+
+	// Find existing
+	{
+		val := value.FindByID(2)
+		test.Assert(t, val.ID == 2, "Expected ID 2, got %d", val.ID)
+	}
+
+	// Find non-existing
+	{
+		val := value.FindByID(4)
+		test.Assert(t, val == nil, "Expected no value, got %#v", val)
+	}
+
+	// List IDs from set
+	{
+		val := value.IDs()
+		test.Assert(t, len(val) == len(value), "Expected ID count mismatch, %d != %d", len(val), len(value))
+	}
+}

messaging/types/channel_member.gen_test.go

@@ -0,0 +1,61 @@
+package types
+
+import (
+	"testing"
+
+	"errors"
+
+	"github.com/crusttech/crust/internal/test"
+)
+
+// 	Hello! This file is auto-generated.
+
+func TestChannelMemberSetWalk(t *testing.T) {
+	value := make(ChannelMemberSet, 3)
+
+	// check walk with no errors
+	{
+		err := value.Walk(func(*ChannelMember) error {
+			return nil
+		})
+		test.NoError(t, err, "Expected no returned error from Walk, got %+v", err)
+	}
+
+	// check walk with error
+	test.Error(t, value.Walk(func(*ChannelMember) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
+}
+
+func TestChannelMemberSetFilter(t *testing.T) {
+	value := make(ChannelMemberSet, 3)
+
+	// filter nothing
+	{
+		set, err := value.Filter(func(*ChannelMember) (bool, error) {
+			return true, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == len(value), "Expected equal length filter: %d != %d", len(value), len(set))
+	}
+
+	// filter one item
+	{
+		found := false
+		set, err := value.Filter(func(*ChannelMember) (bool, error) {
+			if !found {
+				found = true
+				return found, nil
+			}
+			return false, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == 1, "Expected single item, got %d", len(value))
+	}
+
+	// filter error
+	{
+		_, err := value.Filter(func(*ChannelMember) (bool, error) {
+			return false, errors.New("Filter error")
+		})
+		test.Error(t, err, "Expected error, got %#v", err)
+	}
+}

messaging/types/command.gen_test.go

@@ -0,0 +1,61 @@
+package types
+
+import (
+	"testing"
+
+	"errors"
+
+	"github.com/crusttech/crust/internal/test"
+)
+
+// 	Hello! This file is auto-generated.
+
+func TestCommandSetWalk(t *testing.T) {
+	value := make(CommandSet, 3)
+
+	// check walk with no errors
+	{
+		err := value.Walk(func(*Command) error {
+			return nil
+		})
+		test.NoError(t, err, "Expected no returned error from Walk, got %+v", err)
+	}
+
+	// check walk with error
+	test.Error(t, value.Walk(func(*Command) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
+}
+
+func TestCommandSetFilter(t *testing.T) {
+	value := make(CommandSet, 3)
+
+	// filter nothing
+	{
+		set, err := value.Filter(func(*Command) (bool, error) {
+			return true, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == len(value), "Expected equal length filter: %d != %d", len(value), len(set))
+	}
+
+	// filter one item
+	{
+		found := false
+		set, err := value.Filter(func(*Command) (bool, error) {
+			if !found {
+				found = true
+				return found, nil
+			}
+			return false, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == 1, "Expected single item, got %d", len(value))
+	}
+
+	// filter error
+	{
+		_, err := value.Filter(func(*Command) (bool, error) {
+			return false, errors.New("Filter error")
+		})
+		test.Error(t, err, "Expected error, got %#v", err)
+	}
+}

messaging/types/command_param.gen_test.go

@@ -0,0 +1,61 @@
+package types
+
+import (
+	"testing"
+
+	"errors"
+
+	"github.com/crusttech/crust/internal/test"
+)
+
+// 	Hello! This file is auto-generated.
+
+func TestCommandParamSetWalk(t *testing.T) {
+	value := make(CommandParamSet, 3)
+
+	// check walk with no errors
+	{
+		err := value.Walk(func(*CommandParam) error {
+			return nil
+		})
+		test.NoError(t, err, "Expected no returned error from Walk, got %+v", err)
+	}
+
+	// check walk with error
+	test.Error(t, value.Walk(func(*CommandParam) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
+}
+
+func TestCommandParamSetFilter(t *testing.T) {
+	value := make(CommandParamSet, 3)
+
+	// filter nothing
+	{
+		set, err := value.Filter(func(*CommandParam) (bool, error) {
+			return true, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == len(value), "Expected equal length filter: %d != %d", len(value), len(set))
+	}
+
+	// filter one item
+	{
+		found := false
+		set, err := value.Filter(func(*CommandParam) (bool, error) {
+			if !found {
+				found = true
+				return found, nil
+			}
+			return false, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == 1, "Expected single item, got %d", len(value))
+	}
+
+	// filter error
+	{
+		_, err := value.Filter(func(*CommandParam) (bool, error) {
+			return false, errors.New("Filter error")
+		})
+		test.Error(t, err, "Expected error, got %#v", err)
+	}
+}

messaging/types/mention.gen_test.go

@@ -0,0 +1,91 @@
+package types
+
+import (
+	"testing"
+
+	"errors"
+
+	"github.com/crusttech/crust/internal/test"
+)
+
+// 	Hello! This file is auto-generated.
+
+func TestMentionSetWalk(t *testing.T) {
+	value := make(MentionSet, 3)
+
+	// check walk with no errors
+	{
+		err := value.Walk(func(*Mention) error {
+			return nil
+		})
+		test.NoError(t, err, "Expected no returned error from Walk, got %+v", err)
+	}
+
+	// check walk with error
+	test.Error(t, value.Walk(func(*Mention) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
+}
+
+func TestMentionSetFilter(t *testing.T) {
+	value := make(MentionSet, 3)
+
+	// filter nothing
+	{
+		set, err := value.Filter(func(*Mention) (bool, error) {
+			return true, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == len(value), "Expected equal length filter: %d != %d", len(value), len(set))
+	}
+
+	// filter one item
+	{
+		found := false
+		set, err := value.Filter(func(*Mention) (bool, error) {
+			if !found {
+				found = true
+				return found, nil
+			}
+			return false, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == 1, "Expected single item, got %d", len(value))
+	}
+
+	// filter error
+	{
+		_, err := value.Filter(func(*Mention) (bool, error) {
+			return false, errors.New("Filter error")
+		})
+		test.Error(t, err, "Expected error, got %#v", err)
+	}
+}
+
+func TestMentionSetIDs(t *testing.T) {
+	value := make(MentionSet, 3)
+	// construct objects
+	value[0] = new(Mention)
+	value[1] = new(Mention)
+	value[2] = new(Mention)
+	// set ids
+	value[0].ID = 1
+	value[1].ID = 2
+	value[2].ID = 3
+
+	// Find existing
+	{
+		val := value.FindByID(2)
+		test.Assert(t, val.ID == 2, "Expected ID 2, got %d", val.ID)
+	}
+
+	// Find non-existing
+	{
+		val := value.FindByID(4)
+		test.Assert(t, val == nil, "Expected no value, got %#v", val)
+	}
+
+	// List IDs from set
+	{
+		val := value.IDs()
+		test.Assert(t, len(val) == len(value), "Expected ID count mismatch, %d != %d", len(val), len(value))
+	}
+}

messaging/types/message.gen_test.go

@@ -0,0 +1,91 @@
+package types
+
+import (
+	"testing"
+
+	"errors"
+
+	"github.com/crusttech/crust/internal/test"
+)
+
+// 	Hello! This file is auto-generated.
+
+func TestMessageSetWalk(t *testing.T) {
+	value := make(MessageSet, 3)
+
+	// check walk with no errors
+	{
+		err := value.Walk(func(*Message) error {
+			return nil
+		})
+		test.NoError(t, err, "Expected no returned error from Walk, got %+v", err)
+	}
+
+	// check walk with error
+	test.Error(t, value.Walk(func(*Message) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
+}
+
+func TestMessageSetFilter(t *testing.T) {
+	value := make(MessageSet, 3)
+
+	// filter nothing
+	{
+		set, err := value.Filter(func(*Message) (bool, error) {
+			return true, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == len(value), "Expected equal length filter: %d != %d", len(value), len(set))
+	}
+
+	// filter one item
+	{
+		found := false
+		set, err := value.Filter(func(*Message) (bool, error) {
+			if !found {
+				found = true
+				return found, nil
+			}
+			return false, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == 1, "Expected single item, got %d", len(value))
+	}
+
+	// filter error
+	{
+		_, err := value.Filter(func(*Message) (bool, error) {
+			return false, errors.New("Filter error")
+		})
+		test.Error(t, err, "Expected error, got %#v", err)
+	}
+}
+
+func TestMessageSetIDs(t *testing.T) {
+	value := make(MessageSet, 3)
+	// construct objects
+	value[0] = new(Message)
+	value[1] = new(Message)
+	value[2] = new(Message)
+	// set ids
+	value[0].ID = 1
+	value[1].ID = 2
+	value[2].ID = 3
+
+	// Find existing
+	{
+		val := value.FindByID(2)
+		test.Assert(t, val.ID == 2, "Expected ID 2, got %d", val.ID)
+	}
+
+	// Find non-existing
+	{
+		val := value.FindByID(4)
+		test.Assert(t, val == nil, "Expected no value, got %#v", val)
+	}
+
+	// List IDs from set
+	{
+		val := value.IDs()
+		test.Assert(t, len(val) == len(value), "Expected ID count mismatch, %d != %d", len(val), len(value))
+	}
+}

messaging/types/message_flag.gen_test.go

@@ -0,0 +1,91 @@
+package types
+
+import (
+	"testing"
+
+	"errors"
+
+	"github.com/crusttech/crust/internal/test"
+)
+
+// 	Hello! This file is auto-generated.
+
+func TestMessageFlagSetWalk(t *testing.T) {
+	value := make(MessageFlagSet, 3)
+
+	// check walk with no errors
+	{
+		err := value.Walk(func(*MessageFlag) error {
+			return nil
+		})
+		test.NoError(t, err, "Expected no returned error from Walk, got %+v", err)
+	}
+
+	// check walk with error
+	test.Error(t, value.Walk(func(*MessageFlag) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
+}
+
+func TestMessageFlagSetFilter(t *testing.T) {
+	value := make(MessageFlagSet, 3)
+
+	// filter nothing
+	{
+		set, err := value.Filter(func(*MessageFlag) (bool, error) {
+			return true, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == len(value), "Expected equal length filter: %d != %d", len(value), len(set))
+	}
+
+	// filter one item
+	{
+		found := false
+		set, err := value.Filter(func(*MessageFlag) (bool, error) {
+			if !found {
+				found = true
+				return found, nil
+			}
+			return false, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == 1, "Expected single item, got %d", len(value))
+	}
+
+	// filter error
+	{
+		_, err := value.Filter(func(*MessageFlag) (bool, error) {
+			return false, errors.New("Filter error")
+		})
+		test.Error(t, err, "Expected error, got %#v", err)
+	}
+}
+
+func TestMessageFlagSetIDs(t *testing.T) {
+	value := make(MessageFlagSet, 3)
+	// construct objects
+	value[0] = new(MessageFlag)
+	value[1] = new(MessageFlag)
+	value[2] = new(MessageFlag)
+	// set ids
+	value[0].ID = 1
+	value[1].ID = 2
+	value[2].ID = 3
+
+	// Find existing
+	{
+		val := value.FindByID(2)
+		test.Assert(t, val.ID == 2, "Expected ID 2, got %d", val.ID)
+	}
+
+	// Find non-existing
+	{
+		val := value.FindByID(4)
+		test.Assert(t, val == nil, "Expected no value, got %#v", val)
+	}
+
+	// List IDs from set
+	{
+		val := value.IDs()
+		test.Assert(t, len(val) == len(value), "Expected ID count mismatch, %d != %d", len(val), len(value))
+	}
+}

messaging/types/unread.gen_test.go

@@ -0,0 +1,61 @@
+package types
+
+import (
+	"testing"
+
+	"errors"
+
+	"github.com/crusttech/crust/internal/test"
+)
+
+// 	Hello! This file is auto-generated.
+
+func TestUnreadSetWalk(t *testing.T) {
+	value := make(UnreadSet, 3)
+
+	// check walk with no errors
+	{
+		err := value.Walk(func(*Unread) error {
+			return nil
+		})
+		test.NoError(t, err, "Expected no returned error from Walk, got %+v", err)
+	}
+
+	// check walk with error
+	test.Error(t, value.Walk(func(*Unread) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
+}
+
+func TestUnreadSetFilter(t *testing.T) {
+	value := make(UnreadSet, 3)
+
+	// filter nothing
+	{
+		set, err := value.Filter(func(*Unread) (bool, error) {
+			return true, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == len(value), "Expected equal length filter: %d != %d", len(value), len(set))
+	}
+
+	// filter one item
+	{
+		found := false
+		set, err := value.Filter(func(*Unread) (bool, error) {
+			if !found {
+				found = true
+				return found, nil
+			}
+			return false, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == 1, "Expected single item, got %d", len(value))
+	}
+
+	// filter error
+	{
+		_, err := value.Filter(func(*Unread) (bool, error) {
+			return false, errors.New("Filter error")
+		})
+		test.Error(t, err, "Expected error, got %#v", err)
+	}
+}

messaging/types/webhook.gen_test.go

@@ -0,0 +1,91 @@
+package types
+
+import (
+	"testing"
+
+	"errors"
+
+	"github.com/crusttech/crust/internal/test"
+)
+
+// 	Hello! This file is auto-generated.
+
+func TestWebhookSetWalk(t *testing.T) {
+	value := make(WebhookSet, 3)
+
+	// check walk with no errors
+	{
+		err := value.Walk(func(*Webhook) error {
+			return nil
+		})
+		test.NoError(t, err, "Expected no returned error from Walk, got %+v", err)
+	}
+
+	// check walk with error
+	test.Error(t, value.Walk(func(*Webhook) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
+}
+
+func TestWebhookSetFilter(t *testing.T) {
+	value := make(WebhookSet, 3)
+
+	// filter nothing
+	{
+		set, err := value.Filter(func(*Webhook) (bool, error) {
+			return true, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == len(value), "Expected equal length filter: %d != %d", len(value), len(set))
+	}
+
+	// filter one item
+	{
+		found := false
+		set, err := value.Filter(func(*Webhook) (bool, error) {
+			if !found {
+				found = true
+				return found, nil
+			}
+			return false, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == 1, "Expected single item, got %d", len(value))
+	}
+
+	// filter error
+	{
+		_, err := value.Filter(func(*Webhook) (bool, error) {
+			return false, errors.New("Filter error")
+		})
+		test.Error(t, err, "Expected error, got %#v", err)
+	}
+}
+
+func TestWebhookSetIDs(t *testing.T) {
+	value := make(WebhookSet, 3)
+	// construct objects
+	value[0] = new(Webhook)
+	value[1] = new(Webhook)
+	value[2] = new(Webhook)
+	// set ids
+	value[0].ID = 1
+	value[1].ID = 2
+	value[2].ID = 3
+
+	// Find existing
+	{
+		val := value.FindByID(2)
+		test.Assert(t, val.ID == 2, "Expected ID 2, got %d", val.ID)
+	}
+
+	// Find non-existing
+	{
+		val := value.FindByID(4)
+		test.Assert(t, val == nil, "Expected no value, got %#v", val)
+	}
+
+	// List IDs from set
+	{
+		val := value.IDs()
+		test.Assert(t, len(val) == len(value), "Expected ID count mismatch, %d != %d", len(val), len(value))
+	}
+}

system/types/application.gen_test.go

@@ -0,0 +1,91 @@
+package types
+
+import (
+	"testing"
+
+	"errors"
+
+	"github.com/crusttech/crust/internal/test"
+)
+
+// 	Hello! This file is auto-generated.
+
+func TestApplicationSetWalk(t *testing.T) {
+	value := make(ApplicationSet, 3)
+
+	// check walk with no errors
+	{
+		err := value.Walk(func(*Application) error {
+			return nil
+		})
+		test.NoError(t, err, "Expected no returned error from Walk, got %+v", err)
+	}
+
+	// check walk with error
+	test.Error(t, value.Walk(func(*Application) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
+}
+
+func TestApplicationSetFilter(t *testing.T) {
+	value := make(ApplicationSet, 3)
+
+	// filter nothing
+	{
+		set, err := value.Filter(func(*Application) (bool, error) {
+			return true, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == len(value), "Expected equal length filter: %d != %d", len(value), len(set))
+	}
+
+	// filter one item
+	{
+		found := false
+		set, err := value.Filter(func(*Application) (bool, error) {
+			if !found {
+				found = true
+				return found, nil
+			}
+			return false, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == 1, "Expected single item, got %d", len(value))
+	}
+
+	// filter error
+	{
+		_, err := value.Filter(func(*Application) (bool, error) {
+			return false, errors.New("Filter error")
+		})
+		test.Error(t, err, "Expected error, got %#v", err)
+	}
+}
+
+func TestApplicationSetIDs(t *testing.T) {
+	value := make(ApplicationSet, 3)
+	// construct objects
+	value[0] = new(Application)
+	value[1] = new(Application)
+	value[2] = new(Application)
+	// set ids
+	value[0].ID = 1
+	value[1].ID = 2
+	value[2].ID = 3
+
+	// Find existing
+	{
+		val := value.FindByID(2)
+		test.Assert(t, val.ID == 2, "Expected ID 2, got %d", val.ID)
+	}
+
+	// Find non-existing
+	{
+		val := value.FindByID(4)
+		test.Assert(t, val == nil, "Expected no value, got %#v", val)
+	}
+
+	// List IDs from set
+	{
+		val := value.IDs()
+		test.Assert(t, len(val) == len(value), "Expected ID count mismatch, %d != %d", len(val), len(value))
+	}
+}

system/types/credentials.gen_test.go

@@ -0,0 +1,91 @@
+package types
+
+import (
+	"testing"
+
+	"errors"
+
+	"github.com/crusttech/crust/internal/test"
+)
+
+// 	Hello! This file is auto-generated.
+
+func TestCredentialsSetWalk(t *testing.T) {
+	value := make(CredentialsSet, 3)
+
+	// check walk with no errors
+	{
+		err := value.Walk(func(*Credentials) error {
+			return nil
+		})
+		test.NoError(t, err, "Expected no returned error from Walk, got %+v", err)
+	}
+
+	// check walk with error
+	test.Error(t, value.Walk(func(*Credentials) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
+}
+
+func TestCredentialsSetFilter(t *testing.T) {
+	value := make(CredentialsSet, 3)
+
+	// filter nothing
+	{
+		set, err := value.Filter(func(*Credentials) (bool, error) {
+			return true, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == len(value), "Expected equal length filter: %d != %d", len(value), len(set))
+	}
+
+	// filter one item
+	{
+		found := false
+		set, err := value.Filter(func(*Credentials) (bool, error) {
+			if !found {
+				found = true
+				return found, nil
+			}
+			return false, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == 1, "Expected single item, got %d", len(value))
+	}
+
+	// filter error
+	{
+		_, err := value.Filter(func(*Credentials) (bool, error) {
+			return false, errors.New("Filter error")
+		})
+		test.Error(t, err, "Expected error, got %#v", err)
+	}
+}
+
+func TestCredentialsSetIDs(t *testing.T) {
+	value := make(CredentialsSet, 3)
+	// construct objects
+	value[0] = new(Credentials)
+	value[1] = new(Credentials)
+	value[2] = new(Credentials)
+	// set ids
+	value[0].ID = 1
+	value[1].ID = 2
+	value[2].ID = 3
+
+	// Find existing
+	{
+		val := value.FindByID(2)
+		test.Assert(t, val.ID == 2, "Expected ID 2, got %d", val.ID)
+	}
+
+	// Find non-existing
+	{
+		val := value.FindByID(4)
+		test.Assert(t, val == nil, "Expected no value, got %#v", val)
+	}
+
+	// List IDs from set
+	{
+		val := value.IDs()
+		test.Assert(t, len(val) == len(value), "Expected ID count mismatch, %d != %d", len(val), len(value))
+	}
+}

system/types/organisation.gen_test.go

@@ -0,0 +1,91 @@
+package types
+
+import (
+	"testing"
+
+	"errors"
+
+	"github.com/crusttech/crust/internal/test"
+)
+
+// 	Hello! This file is auto-generated.
+
+func TestOrganisationSetWalk(t *testing.T) {
+	value := make(OrganisationSet, 3)
+
+	// check walk with no errors
+	{
+		err := value.Walk(func(*Organisation) error {
+			return nil
+		})
+		test.NoError(t, err, "Expected no returned error from Walk, got %+v", err)
+	}
+
+	// check walk with error
+	test.Error(t, value.Walk(func(*Organisation) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
+}
+
+func TestOrganisationSetFilter(t *testing.T) {
+	value := make(OrganisationSet, 3)
+
+	// filter nothing
+	{
+		set, err := value.Filter(func(*Organisation) (bool, error) {
+			return true, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == len(value), "Expected equal length filter: %d != %d", len(value), len(set))
+	}
+
+	// filter one item
+	{
+		found := false
+		set, err := value.Filter(func(*Organisation) (bool, error) {
+			if !found {
+				found = true
+				return found, nil
+			}
+			return false, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == 1, "Expected single item, got %d", len(value))
+	}
+
+	// filter error
+	{
+		_, err := value.Filter(func(*Organisation) (bool, error) {
+			return false, errors.New("Filter error")
+		})
+		test.Error(t, err, "Expected error, got %#v", err)
+	}
+}
+
+func TestOrganisationSetIDs(t *testing.T) {
+	value := make(OrganisationSet, 3)
+	// construct objects
+	value[0] = new(Organisation)
+	value[1] = new(Organisation)
+	value[2] = new(Organisation)
+	// set ids
+	value[0].ID = 1
+	value[1].ID = 2
+	value[2].ID = 3
+
+	// Find existing
+	{
+		val := value.FindByID(2)
+		test.Assert(t, val.ID == 2, "Expected ID 2, got %d", val.ID)
+	}
+
+	// Find non-existing
+	{
+		val := value.FindByID(4)
+		test.Assert(t, val == nil, "Expected no value, got %#v", val)
+	}
+
+	// List IDs from set
+	{
+		val := value.IDs()
+		test.Assert(t, len(val) == len(value), "Expected ID count mismatch, %d != %d", len(val), len(value))
+	}
+}

system/types/role.gen_test.go

@@ -0,0 +1,91 @@
+package types
+
+import (
+	"testing"
+
+	"errors"
+
+	"github.com/crusttech/crust/internal/test"
+)
+
+// 	Hello! This file is auto-generated.
+
+func TestRoleSetWalk(t *testing.T) {
+	value := make(RoleSet, 3)
+
+	// check walk with no errors
+	{
+		err := value.Walk(func(*Role) error {
+			return nil
+		})
+		test.NoError(t, err, "Expected no returned error from Walk, got %+v", err)
+	}
+
+	// check walk with error
+	test.Error(t, value.Walk(func(*Role) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
+}
+
+func TestRoleSetFilter(t *testing.T) {
+	value := make(RoleSet, 3)
+
+	// filter nothing
+	{
+		set, err := value.Filter(func(*Role) (bool, error) {
+			return true, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == len(value), "Expected equal length filter: %d != %d", len(value), len(set))
+	}
+
+	// filter one item
+	{
+		found := false
+		set, err := value.Filter(func(*Role) (bool, error) {
+			if !found {
+				found = true
+				return found, nil
+			}
+			return false, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == 1, "Expected single item, got %d", len(value))
+	}
+
+	// filter error
+	{
+		_, err := value.Filter(func(*Role) (bool, error) {
+			return false, errors.New("Filter error")
+		})
+		test.Error(t, err, "Expected error, got %#v", err)
+	}
+}
+
+func TestRoleSetIDs(t *testing.T) {
+	value := make(RoleSet, 3)
+	// construct objects
+	value[0] = new(Role)
+	value[1] = new(Role)
+	value[2] = new(Role)
+	// set ids
+	value[0].ID = 1
+	value[1].ID = 2
+	value[2].ID = 3
+
+	// Find existing
+	{
+		val := value.FindByID(2)
+		test.Assert(t, val.ID == 2, "Expected ID 2, got %d", val.ID)
+	}
+
+	// Find non-existing
+	{
+		val := value.FindByID(4)
+		test.Assert(t, val == nil, "Expected no value, got %#v", val)
+	}
+
+	// List IDs from set
+	{
+		val := value.IDs()
+		test.Assert(t, len(val) == len(value), "Expected ID count mismatch, %d != %d", len(val), len(value))
+	}
+}

system/types/user.gen_test.go

@@ -0,0 +1,91 @@
+package types
+
+import (
+	"testing"
+
+	"errors"
+
+	"github.com/crusttech/crust/internal/test"
+)
+
+// 	Hello! This file is auto-generated.
+
+func TestUserSetWalk(t *testing.T) {
+	value := make(UserSet, 3)
+
+	// check walk with no errors
+	{
+		err := value.Walk(func(*User) error {
+			return nil
+		})
+		test.NoError(t, err, "Expected no returned error from Walk, got %+v", err)
+	}
+
+	// check walk with error
+	test.Error(t, value.Walk(func(*User) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
+}
+
+func TestUserSetFilter(t *testing.T) {
+	value := make(UserSet, 3)
+
+	// filter nothing
+	{
+		set, err := value.Filter(func(*User) (bool, error) {
+			return true, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == len(value), "Expected equal length filter: %d != %d", len(value), len(set))
+	}
+
+	// filter one item
+	{
+		found := false
+		set, err := value.Filter(func(*User) (bool, error) {
+			if !found {
+				found = true
+				return found, nil
+			}
+			return false, nil
+		})
+		test.NoError(t, err, "Didn't expect error when filtering set: %+v", err)
+		test.Assert(t, len(set) == 1, "Expected single item, got %d", len(value))
+	}
+
+	// filter error
+	{
+		_, err := value.Filter(func(*User) (bool, error) {
+			return false, errors.New("Filter error")
+		})
+		test.Error(t, err, "Expected error, got %#v", err)
+	}
+}
+
+func TestUserSetIDs(t *testing.T) {
+	value := make(UserSet, 3)
+	// construct objects
+	value[0] = new(User)
+	value[1] = new(User)
+	value[2] = new(User)
+	// set ids
+	value[0].ID = 1
+	value[1].ID = 2
+	value[2].ID = 3
+
+	// Find existing
+	{
+		val := value.FindByID(2)
+		test.Assert(t, val.ID == 2, "Expected ID 2, got %d", val.ID)
+	}
+
+	// Find non-existing
+	{
+		val := value.FindByID(4)
+		test.Assert(t, val == nil, "Expected no value, got %#v", val)
+	}
+
+	// List IDs from set
+	{
+		val := value.IDs()
+		test.Assert(t, len(val) == len(value), "Expected ID count mismatch, %d != %d", len(val), len(value))
+	}
+}