diff --git a/codegen.sh b/codegen.sh index ceae5a6a2..8a957f7df 100755 --- a/codegen.sh +++ b/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" } diff --git a/codegen/v2/type-set-test.go b/codegen/v2/type-set-test.go new file mode 100644 index 000000000..e93e1d36e --- /dev/null +++ b/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) +} diff --git a/compose/types/attachment.gen_test.go b/compose/types/attachment.gen_test.go new file mode 100644 index 000000000..5da0d52e4 --- /dev/null +++ b/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)) + } +} diff --git a/compose/types/chart.gen_test.go b/compose/types/chart.gen_test.go new file mode 100644 index 000000000..60b662e88 --- /dev/null +++ b/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)) + } +} diff --git a/compose/types/module.gen_test.go b/compose/types/module.gen_test.go new file mode 100644 index 000000000..9d17e9b10 --- /dev/null +++ b/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)) + } +} diff --git a/compose/types/module_field.gen_test.go b/compose/types/module_field.gen_test.go new file mode 100644 index 000000000..ea94af458 --- /dev/null +++ b/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)) + } +} diff --git a/compose/types/namespace.gen_test.go b/compose/types/namespace.gen_test.go new file mode 100644 index 000000000..3043d9d90 --- /dev/null +++ b/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)) + } +} diff --git a/compose/types/page.gen_test.go b/compose/types/page.gen_test.go new file mode 100644 index 000000000..72cc8bc08 --- /dev/null +++ b/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)) + } +} diff --git a/compose/types/record.gen_test.go b/compose/types/record.gen_test.go new file mode 100644 index 000000000..3a7c4ef91 --- /dev/null +++ b/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)) + } +} diff --git a/compose/types/record_value.gen_test.go b/compose/types/record_value.gen_test.go new file mode 100644 index 000000000..5a8d7c723 --- /dev/null +++ b/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) + } +} diff --git a/compose/types/trigger.gen_test.go b/compose/types/trigger.gen_test.go new file mode 100644 index 000000000..5b7403bb2 --- /dev/null +++ b/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)) + } +} diff --git a/internal/permissions/resource.gen_test.go b/internal/permissions/resource.gen_test.go new file mode 100644 index 000000000..49b4d2d1d --- /dev/null +++ b/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) + } +} diff --git a/internal/permissions/rule.gen_test.go b/internal/permissions/rule.gen_test.go new file mode 100644 index 000000000..d51639c3e --- /dev/null +++ b/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) + } +} diff --git a/internal/settings/types.gen_test.go b/internal/settings/types.gen_test.go new file mode 100644 index 000000000..71b2d41f1 --- /dev/null +++ b/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) + } +} diff --git a/messaging/types/attachment.gen_test.go b/messaging/types/attachment.gen_test.go new file mode 100644 index 000000000..a43790e6a --- /dev/null +++ b/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)) + } +} diff --git a/messaging/types/channel.gen_test.go b/messaging/types/channel.gen_test.go new file mode 100644 index 000000000..d8429b5c4 --- /dev/null +++ b/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)) + } +} diff --git a/messaging/types/channel_member.gen_test.go b/messaging/types/channel_member.gen_test.go new file mode 100644 index 000000000..85cd19a54 --- /dev/null +++ b/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) + } +} diff --git a/messaging/types/command.gen_test.go b/messaging/types/command.gen_test.go new file mode 100644 index 000000000..fb4c777a9 --- /dev/null +++ b/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) + } +} diff --git a/messaging/types/command_param.gen_test.go b/messaging/types/command_param.gen_test.go new file mode 100644 index 000000000..f37d91426 --- /dev/null +++ b/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) + } +} diff --git a/messaging/types/mention.gen_test.go b/messaging/types/mention.gen_test.go new file mode 100644 index 000000000..34c7c6614 --- /dev/null +++ b/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)) + } +} diff --git a/messaging/types/message.gen_test.go b/messaging/types/message.gen_test.go new file mode 100644 index 000000000..1967a3eed --- /dev/null +++ b/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)) + } +} diff --git a/messaging/types/message_flag.gen_test.go b/messaging/types/message_flag.gen_test.go new file mode 100644 index 000000000..9141f425f --- /dev/null +++ b/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)) + } +} diff --git a/messaging/types/unread.gen_test.go b/messaging/types/unread.gen_test.go new file mode 100644 index 000000000..6bcffd03f --- /dev/null +++ b/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) + } +} diff --git a/messaging/types/webhook.gen_test.go b/messaging/types/webhook.gen_test.go new file mode 100644 index 000000000..61694d7db --- /dev/null +++ b/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)) + } +} diff --git a/system/types/application.gen_test.go b/system/types/application.gen_test.go new file mode 100644 index 000000000..8f2142c31 --- /dev/null +++ b/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)) + } +} diff --git a/system/types/credentials.gen_test.go b/system/types/credentials.gen_test.go new file mode 100644 index 000000000..51a0f5e8c --- /dev/null +++ b/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)) + } +} diff --git a/system/types/organisation.gen_test.go b/system/types/organisation.gen_test.go new file mode 100644 index 000000000..1ebeabca1 --- /dev/null +++ b/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)) + } +} diff --git a/system/types/role.gen_test.go b/system/types/role.gen_test.go new file mode 100644 index 000000000..6854d1535 --- /dev/null +++ b/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)) + } +} diff --git a/system/types/user.gen_test.go b/system/types/user.gen_test.go new file mode 100644 index 000000000..63da6c67a --- /dev/null +++ b/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)) + } +}