DeforaNetworks/corteza
3
0
Fork 0
Code Activity

Remove internal/test pkg

Browse Source
This commit is contained in:
Denis Arh
2019-10-01 17:39:06 +02:00
parent 77ce40cf1a
commit f5f0096035
57 changed files with 933 additions and 666 deletions
Download Patch File Download Diff File Expand all files Collapse all files

42
codegen/v2/type-set-test.go
View File

@@ -32,30 +32,37 @@ import (
{{ range $i, $set := .Sets }}
func Test{{ $set }}SetWalk(t *testing.T) {
value := make({{ $set }}Set, 3)
var (
value = make({{ $set }}Set, 3)
req = require.New(t)
)
// 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)
req.NoError(err)
}
// check walk with error
test.Error(t, value.Walk(func(*{{ $set }}) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
req.Error(value.Walk(func(*{{ $set }}) error { return errors.New("walk error") }))
}
func Test{{ $set }}SetFilter(t *testing.T) {
value := make({{ $set }}Set, 3)
var (
value = make({{ $set }}Set, 3)
req = require.New(t)
)
// 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))
req.NoError(err)
req.Equal(len(set), len(value))
}
// filter one item
@@ -68,22 +75,26 @@ func Test{{ $set }}SetFilter(t *testing.T) {
}
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))
req.NoError(err)
req.Len(set, 1)
}
// filter error
{
_, err := value.Filter(func(*{{ $set }}) (bool, error) {
return false, errors.New("Filter error")
return false, errors.New("filter error")
})
test.Error(t, err, "Expected error, got %#v", err)
req.Error(err)
}
}
{{ if $.WithPrimaryKey }}
func Test{{ $set }}SetIDs(t *testing.T) {
value := make({{ $set }}Set, 3)
var (
value = make({{ $set }}Set, 3)
req = require.New(t)
)
// construct objects
value[0] = new({{ $set }})
value[1] = new({{ $set }})
@@ -96,19 +107,19 @@ func Test{{ $set }}SetIDs(t *testing.T) {
// Find existing
{
val := value.FindByID(2)
test.Assert(t, val.ID == 2, "Expected ID 2, got %d", val.ID)
req.Equal(uint64(2), val.ID)
}
// Find non-existing
{
val := value.FindByID(4)
test.Assert(t, val == nil, "Expected no value, got %#v", val)
req.Nil(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))
req.Equal(len(val), len(value))
}
}
{{ end }}
@@ -142,8 +153,7 @@ func main() {
payload.Imports = []string{
"testing",
"errors",
"",
"github.com/cortezaproject/corteza-server/internal/test",
"github.com/stretchr/testify/require",
}
flag.StringVar(&stdTypesStr, "types", "", "Comma separated list of types")

8
compose/compose_test.go
View File

@@ -4,12 +4,12 @@ import (
"context"
"testing"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/stretchr/testify/require"
)
func TestConfigure(t *testing.T) {
var config = Configure()
test.Assert(t, config != nil, "Configure valid")
test.Assert(t, func() bool { config.Init(); return true }(), "Initialization ok")
test.Assert(t, config.MakeCLI(context.Background()) != nil, "CLI created")
require.True(t, config != nil, "Configure valid")
require.True(t, func() bool { config.Init(); return true }(), "Initialization ok")
require.True(t, config.MakeCLI(context.Background()) != nil, "CLI created")
}

32
compose/decoder/decoder_test.go
View File

@@ -9,7 +9,7 @@ import (
"io"
"testing"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/stretchr/testify/require"
)
func makeReadSeeker(c string) io.ReadSeeker {
@@ -28,12 +28,12 @@ func TestEntryCount(t *testing.T) {
fr := NewFlatReader(csv.NewReader(rs), rs)
c, err := fr.EntryCount()
test.Assert(t,
require.True(t,
c == 1,
fmt.Sprintf("Invalid number of entries determines; found %d, expected %d", c, 1),
)
test.Assert(t,
require.True(t,
err == nil,
"Returned with error",
)
@@ -44,12 +44,12 @@ func TestEntryCount(t *testing.T) {
sd := NewStructuredDecoder(json.NewDecoder(rs), rs)
c, err := sd.EntryCount()
test.Assert(t,
require.True(t,
c == 1,
fmt.Sprintf("Invalid number of entries determines; found %d, expected %d", c, 1),
)
test.Assert(t,
require.True(t,
err == nil,
"Returned with error",
)
@@ -66,7 +66,7 @@ func TestGet(t *testing.T) {
err := fr.get(func(f []string) error {
return errors.New("called")
})
test.Assert(t,
require.True(t,
err != nil,
"Error should be returned to indicate that get did read",
)
@@ -74,7 +74,7 @@ func TestGet(t *testing.T) {
err = fr.get(func(f []string) error {
return errors.New("called")
})
test.Assert(t,
require.True(t,
err == nil,
"Error should NOT be returned to indicate that get didn't read",
)
@@ -87,7 +87,7 @@ func TestGet(t *testing.T) {
err := sd.get(func(f map[string]interface{}) error {
return errors.New("called")
})
test.Assert(t,
require.True(t,
err != nil,
"Error should be returned to indicate that get did read",
)
@@ -95,7 +95,7 @@ func TestGet(t *testing.T) {
err = sd.get(func(f map[string]interface{}) error {
return errors.New("called")
})
test.Assert(t,
require.True(t,
err == nil,
"Error should NOT be returned to indicate that get didn't read",
)
@@ -113,12 +113,12 @@ func TestWalk(t *testing.T) {
return nil
})
test.Assert(t,
require.True(t,
i == 2,
"Invalid number of reads",
)
test.Assert(t,
require.True(t,
err == nil,
"Returned with error",
)
@@ -134,12 +134,12 @@ func TestWalk(t *testing.T) {
return nil
})
test.Assert(t,
require.True(t,
i == 1,
"Invalid number of reads",
)
test.Assert(t,
require.True(t,
err == nil,
"Returned with error",
)
@@ -152,14 +152,14 @@ func TestHeader(t *testing.T) {
fr := NewFlatReader(csv.NewReader(rs), rs)
h := fr.Header()
test.Assert(t,
require.True(t,
len(h) == 3,
"Invalid number of header fields",
)
expect := [...]string{"f1", "f2", "ID"}
for i, h := range h {
test.Assert(t,
require.True(t,
h == expect[i],
"Invalid header value",
)
@@ -171,7 +171,7 @@ func TestHeader(t *testing.T) {
sd := NewStructuredDecoder(json.NewDecoder(rs), rs)
h := sd.Header()
test.Assert(t,
require.True(t,
len(h) == 3,
"Invalid number of header fields",
)

28
compose/decoder/record_test.go
View File

@@ -8,7 +8,7 @@ import (
"testing"
"github.com/cortezaproject/corteza-server/compose/types"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/stretchr/testify/require"
)
func TestMapify(t *testing.T) {
@@ -19,12 +19,12 @@ func TestMapify(t *testing.T) {
var v []string
v = append(v, "v1")
test.Assert(t,
require.True(t,
mapify(h, v) == nil,
"Value should be nil",
)
test.Assert(t,
require.True(t,
mapify(v, h) == nil,
"Value should be nil",
)
@@ -38,12 +38,12 @@ func TestMapify(t *testing.T) {
v = append(v, "v1", "v2")
mpd := mapify(h, v)
test.Assert(t,
require.True(t,
len(mpd) == 2,
fmt.Sprintf("Invalid length %d; should be %d", len(mpd), 2),
)
test.Assert(t,
require.True(t,
mpd["h1"] == "v1" && mpd["h2"] == "v2",
"Invalid values",
)
@@ -56,17 +56,17 @@ func TestSetSystemField(t *testing.T) {
name := "recordID"
value := "123"
is, err := setSystemField(r, name, value)
test.Assert(t,
require.True(t,
err == nil,
"Returned with error",
)
test.Assert(t,
require.True(t,
is,
"Couldn't determine it's a system field",
)
test.Assert(t,
require.True(t,
r.ID == 123,
fmt.Sprintf("Determined value (%d) not valid; should be %s", r.ID, value),
)
@@ -77,12 +77,12 @@ func TestSetSystemField(t *testing.T) {
name := "customField"
value := "123"
is, err := setSystemField(r, name, value)
test.Assert(t,
require.True(t,
err == nil,
"Returned with error",
)
test.Assert(t,
require.True(t,
!is,
"Couldn't determine it's not a system field",
)
@@ -100,12 +100,12 @@ func TestRecords(t *testing.T) {
row := 0
fr.Records(testFields, func(mod *types.Record) error {
row++
test.Assert(t,
require.True(t,
len(mod.Values) == 2,
"Not enough values",
)
test.Assert(t,
require.True(t,
mod.ID == uint64(row),
"Not enough values",
)
@@ -119,12 +119,12 @@ func TestRecords(t *testing.T) {
row := 0
sd.Records(testFields, func(mod *types.Record) error {
row++
test.Assert(t,
require.True(t,
len(mod.Values) == 2,
"Not enough values",
)
test.Assert(t,
require.True(t,
mod.ID == uint64(row),
"Not enough values",
)

6
compose/encoder/record_test.go
View File

@@ -8,7 +8,7 @@ import (
"time"
"github.com/cortezaproject/corteza-server/compose/types"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/stretchr/testify/require"
)
func Test_RecordEncoding(t *testing.T) {
@@ -75,7 +75,7 @@ func Test_RecordEncoding(t *testing.T) {
}
csvWriter.Flush()
test.Assert(t,
require.True(t,
buf.String() == tt.flatResult,
"Unexpected result: \n%s\n%s",
buf.String(),
@@ -93,7 +93,7 @@ func Test_RecordEncoding(t *testing.T) {
}
}
test.Assert(t,
require.True(t,
buf.String() == tt.structResult,
"Unexpected result: \n%s\n%s",
buf.String(),

7
compose/repository/record_report_builder_test.go
View File

@@ -3,8 +3,9 @@ package repository
import (
"testing"
"github.com/stretchr/testify/require"
"github.com/cortezaproject/corteza-server/compose/types"
"github.com/cortezaproject/corteza-server/internal/test"
)
func TestRecordReportBuilder2(t *testing.T) {
@@ -28,6 +29,6 @@ func TestRecordReportBuilder2(t *testing.T) {
"ORDER BY dimension_0"
sql, _, err := builder.Build("max(single1)", "QUARTER(ref1)", "ref1 = 2")
test.NoError(t, err, "report builder returned an error: %v")
test.Assert(t, expected == sql, "did not get expected sql for report, got: %s", sql)
require.NoError(t, err)
require.Equal(t, expected, sql)
}

10
compose/repository/record_test.go
View File

@@ -6,7 +6,7 @@ import (
"testing"
"github.com/cortezaproject/corteza-server/compose/types"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/stretchr/testify/require"
)
func TestRecordFinder(t *testing.T) {
@@ -50,22 +50,22 @@ func TestRecordFinder(t *testing.T) {
sb, err := r.buildQuery(m, tc.f)
if tc.err != nil {
test.Assert(t, tc.err.Error() == fmt.Sprintf("%v", err), "buildQuery(%+v) did not return an expected error %q but %q", tc.f, tc.err, err)
require.True(t, tc.err.Error() == fmt.Sprintf("%v", err), "buildQuery(%+v) did not return an expected error %q but %q", tc.f, tc.err, err)
} else {
test.Assert(t, err == nil, "buildQuery(%+v) returned an unexpected error: %v", tc.f, err)
require.True(t, err == nil, "buildQuery(%+v) returned an unexpected error: %v", tc.f, err)
}
sb = sb.Column("*")
sql, args, err := sb.ToSql()
for _, m := range tc.match {
test.Assert(t, strings.Contains(sql, m),
require.True(t, strings.Contains(sql, m),
"assertion failed; query %q \n "+
" did not contain %q", sql, m)
}
tc.args = append(tc.args, m.ID, m.NamespaceID)
test.Assert(t, fmt.Sprintf("%+v", args) == fmt.Sprintf("%+v", tc.args),
require.True(t, fmt.Sprintf("%+v", args) == fmt.Sprintf("%+v", tc.args),
"assertion failed; args %+v \n "+
" do not match expected %+v", args, tc.args)
}

18
compose/service/automation_runner_test.go
View File

@@ -5,9 +5,9 @@ import (
"testing"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
service_mocks "github.com/cortezaproject/corteza-server/compose/service/mocks"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/cortezaproject/corteza-server/pkg/automation"
)
@@ -48,10 +48,10 @@ func Test_automationRunner_findImplicitScripts(t *testing.T) {
ss := runner.findRecordScripts("beforeCreate", 5555)
test.Assert(t, len(ss) == 2, "Received user scripts do not match")
require.True(t, len(ss) == 2, "Received user scripts do not match")
test.Assert(t, len(runnables) == 3, "Expected runnable scriptSet to be intact")
test.Assert(t, len(runnables.FindByID(1000).Triggers()) == 3, "Expected runnable scriptSet (triggers from first script) to be intact")
require.True(t, len(runnables) == 3, "Expected runnable scriptSet to be intact")
require.True(t, len(runnables.FindByID(1000).Triggers()) == 3, "Expected runnable scriptSet (triggers from first script) to be intact")
}
func Test_automationRunner_UserScripts(t *testing.T) {
@@ -99,10 +99,10 @@ func Test_automationRunner_UserScripts(t *testing.T) {
ss := runner.UserScripts(context.Background())
test.Assert(t, len(ss) == 2, "Received user scripts do not match")
test.Assert(t, len(ss.FindByID(1000).Triggers()) == 1, "Received user script triggers do not match")
test.Assert(t, len(ss.FindByID(2000).Triggers()) == 3, "Received user script triggers do not match")
require.True(t, len(ss) == 2, "Received user scripts do not match")
require.True(t, len(ss.FindByID(1000).Triggers()) == 1, "Received user script triggers do not match")
require.True(t, len(ss.FindByID(2000).Triggers()) == 3, "Received user script triggers do not match")
test.Assert(t, len(runnables) == 3, "Expected runnable scriptSet to be intact")
test.Assert(t, len(runnables.FindByID(1000).Triggers()) == 3, "Expected runnable scriptSet (triggers from first script) to be intact")
require.True(t, len(runnables) == 3, "Expected runnable scriptSet to be intact")
require.True(t, len(runnables.FindByID(1000).Triggers()) == 3, "Expected runnable scriptSet (triggers from first script) to be intact")
}

27
compose/service/import_session_test.go
View File

@@ -4,9 +4,8 @@ import (
"context"
"testing"
"github.com/stretchr/testify/require"
"go.uber.org/zap"
"github.com/cortezaproject/corteza-server/internal/test"
)
var ctx context.Context = context.WithValue(context.Background(), "testing", true)
@@ -19,12 +18,12 @@ func TestFindRecordByID(t *testing.T) {
t.Run("Found", func(t *testing.T) {
s, err := svc.FindRecordByID(ctx, sid)
test.Assert(t,
require.True(t,
s != nil,
"Session should be found",
)
test.Assert(t,
require.True(t,
err == nil,
"Returned with error",
)
@@ -32,12 +31,12 @@ func TestFindRecordByID(t *testing.T) {
t.Run("Not found", func(t *testing.T) {
s, err := svc.FindRecordByID(ctx, sid+1)
test.Assert(t,
require.True(t,
s == nil,
"Session should not be found",
)
test.Assert(t,
require.True(t,
err != nil,
"Error should not be nil",
)
@@ -50,12 +49,12 @@ func TestSetRecordByID(t *testing.T) {
t.Run("New", func(t *testing.T) {
ss, err := svc.SetRecordByID(ctx, 1, 0, 0, nil, nil, nil)
test.Assert(t,
require.True(t,
len(svc.records) == 1 && ss != nil,
"Session should be created",
)
test.Assert(t,
require.True(t,
err == nil,
"Returned with error",
)
@@ -65,12 +64,12 @@ func TestSetRecordByID(t *testing.T) {
svc := ImportSession()
ss, err := svc.SetRecordByID(ctx, 1, 0, 0, nil, nil, nil)
ns, err := svc.SetRecordByID(ctx, ss.SessionID, 0, 0, nil, nil, nil)
test.Assert(t,
require.True(t,
len(svc.records) == 1 && ns != nil && ss.SessionID == ns.SessionID,
"Existing session should be edited",
)
test.Assert(t,
require.True(t,
err == nil,
"Returned with error",
)
@@ -84,12 +83,12 @@ func TestDeleteRecordByID(t *testing.T) {
t.Run("Delete existing", func(t *testing.T) {
err := svc.DeleteRecordByID(ctx, ss.SessionID)
test.Assert(t,
require.True(t,
len(svc.records) == 0,
"Session should be deleted",
)
test.Assert(t,
require.True(t,
err == nil,
"Returned with error",
)
@@ -98,12 +97,12 @@ func TestDeleteRecordByID(t *testing.T) {
t.Run("Session not found", func(t *testing.T) {
ss, _ := svc.SetRecordByID(ctx, 1, 0, 0, nil, nil, nil)
err := svc.DeleteRecordByID(ctx, ss.SessionID+1)
test.Assert(t,
require.True(t,
len(svc.records) == 1,
"Session should not deleted",
)
test.Assert(t,
require.True(t,
err == nil,
"Returned with error",
)

41
compose/service/record_test.go
View File

@@ -3,13 +3,16 @@ package service
import (
"testing"
"github.com/stretchr/testify/require"
"github.com/cortezaproject/corteza-server/compose/types"
"github.com/cortezaproject/corteza-server/internal/permissions"
"github.com/cortezaproject/corteza-server/internal/test"
)
func TestValueSanitizer(t *testing.T) {
var (
req = require.New(t)
svc = record{
ac: AccessControl(&permissions.ServiceAllowAll{}),
}
@@ -28,43 +31,43 @@ func TestValueSanitizer(t *testing.T) {
rvs = types.RecordValueSet{{Name: "single1", Value: "single"}}
out, err = svc.sanitizeValues(module, rvs)
test.NoError(t, err, "unexpected error for sanitizeValues() call: %v")
test.Assert(t, len(out) == 1, "expecting 1 record value after sanitization, got %d", len(rvs))
req.NoError(err)
req.Len(out, 1, "expecting 1 record value after sanitization, got %d", len(rvs))
rvs = types.RecordValueSet{{Name: "unknown", Value: "single"}}
out, err = svc.sanitizeValues(module, rvs)
test.Assert(t, err != nil, "expecting sanitizeValues() to return an error, got nil")
req.True(err != nil, "expecting sanitizeValues() to return an error, got nil")
rvs = types.RecordValueSet{{Name: "single1", Value: "single"}, {Name: "single1", Value: "single2"}}
out, err = svc.sanitizeValues(module, rvs)
test.Assert(t, err != nil, "expecting sanitizeValues() to return an error, got nil")
req.True(err != nil, "expecting sanitizeValues() to return an error, got nil")
rvs = types.RecordValueSet{{Name: "multi1", Value: "multi1"}, {Name: "multi1", Value: "multi1"}}
out, err = svc.sanitizeValues(module, rvs)
test.NoError(t, err, "unexpected error for sanitizeValues() call: %v")
test.Assert(t, len(out) == 2, "expecting 2 record values after sanitization, got %d", len(rvs))
test.Assert(t, out[0].Place == 0, "expecting first value to have place value 0, got %d", out[0].Place)
test.Assert(t, out[1].Place == 1, "expecting second value to have place value 1, got %d", out[1].Place)
req.NoError(err)
req.Len(out, 2, "expecting 2 record values after sanitization, got %d", len(rvs))
req.Equal(uint(0), out[0].Place, "expecting first value to have place value 0, got %d", out[0].Place)
req.Equal(uint(1), out[1].Place, "expecting second value to have place value 1, got %d", out[1].Place)
rvs = types.RecordValueSet{{Name: "ref1", Value: "multi1"}}
out, err = svc.sanitizeValues(module, rvs)
test.Assert(t, err != nil, "expecting sanitizeValues() to return an error, got nil")
req.True(err != nil, "expecting sanitizeValues() to return an error, got nil")
rvs = types.RecordValueSet{{Name: "ref1", Value: "12345"}}
out, err = svc.sanitizeValues(module, rvs)
test.NoError(t, err, "unexpected error for sanitizeValues() call: %v")
test.Assert(t, len(out) == 1, "expecting 1 record values after sanitization, got %d", len(rvs))
test.Assert(t, out[0].Ref == 12345, "expecting parsed ref value to match, got %d", rvs[0].Ref)
req.NoError(err)
req.Len(out, 1, "expecting 1 record values after sanitization, got %d", len(rvs))
req.Equal(uint64(12345), out[0].Ref, "expecting parsed ref value to match, got %d", rvs[0].Ref)
rvs = types.RecordValueSet{{Name: "multiRef1", Value: "12345"}, {Name: "multiRef1", Value: "67890"}}
out, err = svc.sanitizeValues(module, rvs)
test.NoError(t, err, "unexpected error for sanitizeValues() call: %v")
test.Assert(t, len(rvs) == 2, "expecting 2 record values after sanitization, got %d", len(rvs))
test.Assert(t, out[0].Ref == 12345, "expecting parsed ref value to match, got %d", out[0].Ref)
test.Assert(t, out[1].Ref == 67890, "expecting parsed ref value to match, got %d", out[1].Ref)
req.NoError(err)
req.Len(rvs, 2, "expecting 2 record values after sanitization, got %d", len(rvs))
req.Equal(uint64(12345), out[0].Ref, "expecting parsed ref value to match, got %d", out[0].Ref)
req.Equal(uint64(67890), out[1].Ref, "expecting parsed ref value to match, got %d", out[1].Ref)
rvs = types.RecordValueSet{{Name: "ref1", Value: ""}}
out, err = svc.sanitizeValues(module, rvs)
test.NoError(t, err, "unexpected error for sanitizeValues() call: %v")
test.Assert(t, len(out) == 0, "expecting 0 record values after sanitization, got %d", len(rvs))
req.NoError(err)
req.Len(out, 0, "expecting 0 record values after sanitization, got %d", len(rvs))
}

41
compose/types/attachment.gen_test.go
View File

@@ -5,36 +5,43 @@ import (
"errors"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/stretchr/testify/require"
)
// Hello! This file is auto-generated.
func TestAttachmentSetWalk(t *testing.T) {
value := make(AttachmentSet, 3)
var (
value = make(AttachmentSet, 3)
req = require.New(t)
)
// 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)
req.NoError(err)
}
// check walk with error
test.Error(t, value.Walk(func(*Attachment) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
req.Error(value.Walk(func(*Attachment) error { return errors.New("walk error") }))
}
func TestAttachmentSetFilter(t *testing.T) {
value := make(AttachmentSet, 3)
var (
value = make(AttachmentSet, 3)
req = require.New(t)
)
// 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))
req.NoError(err)
req.Equal(len(set), len(value))
}
// filter one item
@@ -47,21 +54,25 @@ func TestAttachmentSetFilter(t *testing.T) {
}
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))
req.NoError(err)
req.Len(set, 1)
}
// filter error
{
_, err := value.Filter(func(*Attachment) (bool, error) {
return false, errors.New("Filter error")
return false, errors.New("filter error")
})
test.Error(t, err, "Expected error, got %#v", err)
req.Error(err)
}
}
func TestAttachmentSetIDs(t *testing.T) {
value := make(AttachmentSet, 3)
var (
value = make(AttachmentSet, 3)
req = require.New(t)
)
// construct objects
value[0] = new(Attachment)
value[1] = new(Attachment)
@@ -74,18 +85,18 @@ func TestAttachmentSetIDs(t *testing.T) {
// Find existing
{
val := value.FindByID(2)
test.Assert(t, val.ID == 2, "Expected ID 2, got %d", val.ID)
req.Equal(uint64(2), val.ID)
}
// Find non-existing
{
val := value.FindByID(4)
test.Assert(t, val == nil, "Expected no value, got %#v", val)
req.Nil(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))
req.Equal(len(val), len(value))
}
}

41
compose/types/chart.gen_test.go
View File

@@ -5,36 +5,43 @@ import (
"errors"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/stretchr/testify/require"
)
// Hello! This file is auto-generated.
func TestChartSetWalk(t *testing.T) {
value := make(ChartSet, 3)
var (
value = make(ChartSet, 3)
req = require.New(t)
)
// 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)
req.NoError(err)
}
// check walk with error
test.Error(t, value.Walk(func(*Chart) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
req.Error(value.Walk(func(*Chart) error { return errors.New("walk error") }))
}
func TestChartSetFilter(t *testing.T) {
value := make(ChartSet, 3)
var (
value = make(ChartSet, 3)
req = require.New(t)
)
// 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))
req.NoError(err)
req.Equal(len(set), len(value))
}
// filter one item
@@ -47,21 +54,25 @@ func TestChartSetFilter(t *testing.T) {
}
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))
req.NoError(err)
req.Len(set, 1)
}
// filter error
{
_, err := value.Filter(func(*Chart) (bool, error) {
return false, errors.New("Filter error")
return false, errors.New("filter error")
})
test.Error(t, err, "Expected error, got %#v", err)
req.Error(err)
}
}
func TestChartSetIDs(t *testing.T) {
value := make(ChartSet, 3)
var (
value = make(ChartSet, 3)
req = require.New(t)
)
// construct objects
value[0] = new(Chart)
value[1] = new(Chart)
@@ -74,18 +85,18 @@ func TestChartSetIDs(t *testing.T) {
// Find existing
{
val := value.FindByID(2)
test.Assert(t, val.ID == 2, "Expected ID 2, got %d", val.ID)
req.Equal(uint64(2), val.ID)
}
// Find non-existing
{
val := value.FindByID(4)
test.Assert(t, val == nil, "Expected no value, got %#v", val)
req.Nil(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))
req.Equal(len(val), len(value))
}
}

41
compose/types/module.gen_test.go
View File

@@ -5,36 +5,43 @@ import (
"errors"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/stretchr/testify/require"
)
// Hello! This file is auto-generated.
func TestModuleSetWalk(t *testing.T) {
value := make(ModuleSet, 3)
var (
value = make(ModuleSet, 3)
req = require.New(t)
)
// 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)
req.NoError(err)
}
// check walk with error
test.Error(t, value.Walk(func(*Module) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
req.Error(value.Walk(func(*Module) error { return errors.New("walk error") }))
}
func TestModuleSetFilter(t *testing.T) {
value := make(ModuleSet, 3)
var (
value = make(ModuleSet, 3)
req = require.New(t)
)
// 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))
req.NoError(err)
req.Equal(len(set), len(value))
}
// filter one item
@@ -47,21 +54,25 @@ func TestModuleSetFilter(t *testing.T) {
}
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))
req.NoError(err)
req.Len(set, 1)
}
// filter error
{
_, err := value.Filter(func(*Module) (bool, error) {
return false, errors.New("Filter error")
return false, errors.New("filter error")
})
test.Error(t, err, "Expected error, got %#v", err)
req.Error(err)
}
}
func TestModuleSetIDs(t *testing.T) {
value := make(ModuleSet, 3)
var (
value = make(ModuleSet, 3)
req = require.New(t)
)
// construct objects
value[0] = new(Module)
value[1] = new(Module)
@@ -74,18 +85,18 @@ func TestModuleSetIDs(t *testing.T) {
// Find existing
{
val := value.FindByID(2)
test.Assert(t, val.ID == 2, "Expected ID 2, got %d", val.ID)
req.Equal(uint64(2), val.ID)
}
// Find non-existing
{
val := value.FindByID(4)
test.Assert(t, val == nil, "Expected no value, got %#v", val)
req.Nil(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))
req.Equal(len(val), len(value))
}
}

41
compose/types/module_field.gen_test.go
View File

@@ -5,36 +5,43 @@ import (
"errors"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/stretchr/testify/require"
)
// Hello! This file is auto-generated.
func TestModuleFieldSetWalk(t *testing.T) {
value := make(ModuleFieldSet, 3)
var (
value = make(ModuleFieldSet, 3)
req = require.New(t)
)
// 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)
req.NoError(err)
}
// check walk with error
test.Error(t, value.Walk(func(*ModuleField) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
req.Error(value.Walk(func(*ModuleField) error { return errors.New("walk error") }))
}
func TestModuleFieldSetFilter(t *testing.T) {
value := make(ModuleFieldSet, 3)
var (
value = make(ModuleFieldSet, 3)
req = require.New(t)
)
// 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))
req.NoError(err)
req.Equal(len(set), len(value))
}
// filter one item
@@ -47,21 +54,25 @@ func TestModuleFieldSetFilter(t *testing.T) {
}
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))
req.NoError(err)
req.Len(set, 1)
}
// filter error
{
_, err := value.Filter(func(*ModuleField) (bool, error) {
return false, errors.New("Filter error")
return false, errors.New("filter error")
})
test.Error(t, err, "Expected error, got %#v", err)
req.Error(err)
}
}
func TestModuleFieldSetIDs(t *testing.T) {
value := make(ModuleFieldSet, 3)
var (
value = make(ModuleFieldSet, 3)
req = require.New(t)
)
// construct objects
value[0] = new(ModuleField)
value[1] = new(ModuleField)
@@ -74,18 +85,18 @@ func TestModuleFieldSetIDs(t *testing.T) {
// Find existing
{
val := value.FindByID(2)
test.Assert(t, val.ID == 2, "Expected ID 2, got %d", val.ID)
req.Equal(uint64(2), val.ID)
}
// Find non-existing
{
val := value.FindByID(4)
test.Assert(t, val == nil, "Expected no value, got %#v", val)
req.Nil(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))
req.Equal(len(val), len(value))
}
}

41
compose/types/namespace.gen_test.go
View File

@@ -5,36 +5,43 @@ import (
"errors"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/stretchr/testify/require"
)
// Hello! This file is auto-generated.
func TestNamespaceSetWalk(t *testing.T) {
value := make(NamespaceSet, 3)
var (
value = make(NamespaceSet, 3)
req = require.New(t)
)
// 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)
req.NoError(err)
}
// check walk with error
test.Error(t, value.Walk(func(*Namespace) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
req.Error(value.Walk(func(*Namespace) error { return errors.New("walk error") }))
}
func TestNamespaceSetFilter(t *testing.T) {
value := make(NamespaceSet, 3)
var (
value = make(NamespaceSet, 3)
req = require.New(t)
)
// 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))
req.NoError(err)
req.Equal(len(set), len(value))
}
// filter one item
@@ -47,21 +54,25 @@ func TestNamespaceSetFilter(t *testing.T) {
}
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))
req.NoError(err)
req.Len(set, 1)
}
// filter error
{
_, err := value.Filter(func(*Namespace) (bool, error) {
return false, errors.New("Filter error")
return false, errors.New("filter error")
})
test.Error(t, err, "Expected error, got %#v", err)
req.Error(err)
}
}
func TestNamespaceSetIDs(t *testing.T) {
value := make(NamespaceSet, 3)
var (
value = make(NamespaceSet, 3)
req = require.New(t)
)
// construct objects
value[0] = new(Namespace)
value[1] = new(Namespace)
@@ -74,18 +85,18 @@ func TestNamespaceSetIDs(t *testing.T) {
// Find existing
{
val := value.FindByID(2)
test.Assert(t, val.ID == 2, "Expected ID 2, got %d", val.ID)
req.Equal(uint64(2), val.ID)
}
// Find non-existing
{
val := value.FindByID(4)
test.Assert(t, val == nil, "Expected no value, got %#v", val)
req.Nil(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))
req.Equal(len(val), len(value))
}
}

41
compose/types/page.gen_test.go
View File

@@ -5,36 +5,43 @@ import (
"errors"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/stretchr/testify/require"
)
// Hello! This file is auto-generated.
func TestPageSetWalk(t *testing.T) {
value := make(PageSet, 3)
var (
value = make(PageSet, 3)
req = require.New(t)
)
// 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)
req.NoError(err)
}
// check walk with error
test.Error(t, value.Walk(func(*Page) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
req.Error(value.Walk(func(*Page) error { return errors.New("walk error") }))
}
func TestPageSetFilter(t *testing.T) {
value := make(PageSet, 3)
var (
value = make(PageSet, 3)
req = require.New(t)
)
// 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))
req.NoError(err)
req.Equal(len(set), len(value))
}
// filter one item
@@ -47,21 +54,25 @@ func TestPageSetFilter(t *testing.T) {
}
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))
req.NoError(err)
req.Len(set, 1)
}
// filter error
{
_, err := value.Filter(func(*Page) (bool, error) {
return false, errors.New("Filter error")
return false, errors.New("filter error")
})
test.Error(t, err, "Expected error, got %#v", err)
req.Error(err)
}
}
func TestPageSetIDs(t *testing.T) {
value := make(PageSet, 3)
var (
value = make(PageSet, 3)
req = require.New(t)
)
// construct objects
value[0] = new(Page)
value[1] = new(Page)
@@ -74,18 +85,18 @@ func TestPageSetIDs(t *testing.T) {
// Find existing
{
val := value.FindByID(2)
test.Assert(t, val.ID == 2, "Expected ID 2, got %d", val.ID)
req.Equal(uint64(2), val.ID)
}
// Find non-existing
{
val := value.FindByID(4)
test.Assert(t, val == nil, "Expected no value, got %#v", val)
req.Nil(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))
req.Equal(len(val), len(value))
}
}

41
compose/types/record.gen_test.go
View File

@@ -5,36 +5,43 @@ import (
"errors"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/stretchr/testify/require"
)
// Hello! This file is auto-generated.
func TestRecordSetWalk(t *testing.T) {
value := make(RecordSet, 3)
var (
value = make(RecordSet, 3)
req = require.New(t)
)
// 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)
req.NoError(err)
}
// check walk with error
test.Error(t, value.Walk(func(*Record) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
req.Error(value.Walk(func(*Record) error { return errors.New("walk error") }))
}
func TestRecordSetFilter(t *testing.T) {
value := make(RecordSet, 3)
var (
value = make(RecordSet, 3)
req = require.New(t)
)
// 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))
req.NoError(err)
req.Equal(len(set), len(value))
}
// filter one item
@@ -47,21 +54,25 @@ func TestRecordSetFilter(t *testing.T) {
}
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))
req.NoError(err)
req.Len(set, 1)
}
// filter error
{
_, err := value.Filter(func(*Record) (bool, error) {
return false, errors.New("Filter error")
return false, errors.New("filter error")
})
test.Error(t, err, "Expected error, got %#v", err)
req.Error(err)
}
}
func TestRecordSetIDs(t *testing.T) {
value := make(RecordSet, 3)
var (
value = make(RecordSet, 3)
req = require.New(t)
)
// construct objects
value[0] = new(Record)
value[1] = new(Record)
@@ -74,18 +85,18 @@ func TestRecordSetIDs(t *testing.T) {
// Find existing
{
val := value.FindByID(2)
test.Assert(t, val.ID == 2, "Expected ID 2, got %d", val.ID)
req.Equal(uint64(2), val.ID)
}
// Find non-existing
{
val := value.FindByID(4)
test.Assert(t, val == nil, "Expected no value, got %#v", val)
req.Nil(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))
req.Equal(len(val), len(value))
}
}

29
compose/types/record_value.gen_test.go
View File

@@ -5,36 +5,43 @@ import (
"errors"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/stretchr/testify/require"
)
// Hello! This file is auto-generated.
func TestRecordValueSetWalk(t *testing.T) {
value := make(RecordValueSet, 3)
var (
value = make(RecordValueSet, 3)
req = require.New(t)
)
// 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)
req.NoError(err)
}
// check walk with error
test.Error(t, value.Walk(func(*RecordValue) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
req.Error(value.Walk(func(*RecordValue) error { return errors.New("walk error") }))
}
func TestRecordValueSetFilter(t *testing.T) {
value := make(RecordValueSet, 3)
var (
value = make(RecordValueSet, 3)
req = require.New(t)
)
// 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))
req.NoError(err)
req.Equal(len(set), len(value))
}
// filter one item
@@ -47,15 +54,15 @@ func TestRecordValueSetFilter(t *testing.T) {
}
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))
req.NoError(err)
req.Len(set, 1)
}
// filter error
{
_, err := value.Filter(func(*RecordValue) (bool, error) {
return false, errors.New("Filter error")
return false, errors.New("filter error")
})
test.Error(t, err, "Expected error, got %#v", err)
req.Error(err)
}
}

10
internal/http/client_test.go
View File

@@ -4,7 +4,7 @@ import (
"net/http/httptest"
"testing"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/stretchr/testify/require"
)
func TestHTTPClient(t *testing.T) {
@@ -15,14 +15,14 @@ func TestHTTPClient(t *testing.T) {
client, err := New(&Config{
Timeout: 10,
})
test.Assert(t, err == nil, "%+v", err)
require.True(t, err == nil, "%+v", err)
client.Debug(FULL)
req, err := client.Get(server.URL)
test.Assert(t, err == nil, "%+v", err)
require.True(t, err == nil, "%+v", err)
resp, err := client.Do(req)
test.Assert(t, err == nil, "%+v", err)
require.True(t, err == nil, "%+v", err)
err = func() error {
defer resp.Body.Close()
@@ -34,5 +34,5 @@ func TestHTTPClient(t *testing.T) {
}
}()
test.Assert(t, err == nil, "Invalid response: %+v", err)
require.True(t, err == nil, "Invalid response: %+v", err)
}

23
internal/mail/mail_test.go
View File

@@ -5,8 +5,7 @@ import (
"testing"
"github.com/golang/mock/gomock"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/stretchr/testify/require"
)
func TestDialerInvalidSetup(t *testing.T) {
@@ -14,8 +13,8 @@ func TestDialerInvalidSetup(t *testing.T) {
defaultDialerError = nil
SetupDialer("", 0, "", "", "")
test.Assert(t, defaultDialerError != nil, "'Missing SMTP configuration' error should be set, got: %v", defaultDialerError)
test.Assert(t, defaultDialer == nil, "defaultDialer should n be set, got: %v", defaultDialer)
require.True(t, defaultDialerError != nil, "'Missing SMTP configuration' error should be set, got: %v", defaultDialerError)
require.True(t, defaultDialer == nil, "defaultDialer should n be set, got: %v", defaultDialer)
}
func TestDialerValidSetup(t *testing.T) {
@@ -23,8 +22,8 @@ func TestDialerValidSetup(t *testing.T) {
defaultDialerError = nil
SetupDialer("localhost:321", 0, "", "", "some@email.tld")
test.Assert(t, defaultDialerError == nil, "defaultDialerError should be nil, got %v", defaultDialerError)
test.Assert(t, defaultDialer != nil, "defaultDialer should be set, got %v", defaultDialer)
require.True(t, defaultDialerError == nil, "defaultDialerError should be nil, got %v", defaultDialerError)
require.True(t, defaultDialer != nil, "defaultDialer should be set, got %v", defaultDialer)
}
@@ -34,14 +33,14 @@ func TestMailSendWithoutDialer(t *testing.T) {
defaultDialerError = nil
{
err := Send(msg)
test.Assert(t, err != nil, "Send() should return an error, got %v", err)
require.True(t, err != nil, "Send() should return an error, got %v", err)
}
defaultDialer = nil
defaultDialerError = errors.New("Default dialer init error")
{
err := Send(msg)
test.Assert(t, err != nil, "Send() should return an error, got %v", err)
require.True(t, err != nil, "Send() should return an error, got %v", err)
}
}
@@ -57,7 +56,7 @@ func TestMailSendWithDefaultDialer(t *testing.T) {
defaultDialerError = nil
defaultDialer = dDialer
test.NoError(t, Send(msg), "Send() returned an error: %v")
require.NoError(t, Send(msg))
defaultDialer = nil
}
@@ -75,7 +74,7 @@ func TestMailSendWithSpecificDialer(t *testing.T) {
dDialer.EXPECT().DialAndSend(msg).Times(0)
defaultDialer = dDialer
test.NoError(t, Send(msg, sDailer), "Send() returned an error: %v")
require.NoError(t, Send(msg, sDailer))
defaultDialer = nil
}
@@ -90,7 +89,7 @@ func TestMailSendErrors(t *testing.T) {
sDailer.EXPECT().DialAndSend(msg).Times(1).Return(errors.New("some-error"))
err := Send(msg, sDailer)
test.Assert(t, err != nil, "Send() should return an error, got: %v", err)
require.True(t, err != nil, "Send() should return an error, got: %v", err)
}
func TestMailValidator(t *testing.T) {
@@ -108,6 +107,6 @@ func TestMailValidator(t *testing.T) {
}
for _, tc := range ttc {
test.Assert(t, IsValidAddress(tc.addr) == tc.ok, "Validation of %s should return %v", tc.addr, tc.ok)
require.True(t, IsValidAddress(tc.addr) == tc.ok, "Validation of %s should return %v", tc.addr, tc.ok)
}
}

29
internal/permissions/resource.gen_test.go
View File

@@ -5,36 +5,43 @@ import (
"errors"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/stretchr/testify/require"
)
// Hello! This file is auto-generated.
func TestResourceSetWalk(t *testing.T) {
value := make(ResourceSet, 3)
var (
value = make(ResourceSet, 3)
req = require.New(t)
)
// 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)
req.NoError(err)
}
// check walk with error
test.Error(t, value.Walk(func(*Resource) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
req.Error(value.Walk(func(*Resource) error { return errors.New("walk error") }))
}
func TestResourceSetFilter(t *testing.T) {
value := make(ResourceSet, 3)
var (
value = make(ResourceSet, 3)
req = require.New(t)
)
// 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))
req.NoError(err)
req.Equal(len(set), len(value))
}
// filter one item
@@ -47,15 +54,15 @@ func TestResourceSetFilter(t *testing.T) {
}
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))
req.NoError(err)
req.Len(set, 1)
}
// filter error
{
_, err := value.Filter(func(*Resource) (bool, error) {
return false, errors.New("Filter error")
return false, errors.New("filter error")
})
test.Error(t, err, "Expected error, got %#v", err)
req.Error(err)
}
}

24
internal/permissions/resource_test.go
View File

@@ -3,12 +3,12 @@ package permissions
import (
"testing"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/stretchr/testify/require"
)
func TestResource(t *testing.T) {
var (
assert = test.Assert
req = require.New(t)
sCases = []struct {
r Resource
@@ -36,28 +36,28 @@ func TestResource(t *testing.T) {
)
for _, sc := range sCases {
assert(t, sc.r.String() == sc.s, "Resource check failed (%s != %s)", sc.r, sc.s)
req.Equal(sc.s, sc.r.String())
}
var r string
r = "a:"
assert(t, Resource(r).IsAppendable(), "Expecting resource %q to be appendable", r)
req.True(Resource(r).IsAppendable(), "Expecting resource %q to be appendable", r)
r = "a:1"
assert(t, Resource(r).IsAppendable(), "Expecting resource %q to be appendable", r)
req.True(Resource(r).IsAppendable(), "Expecting resource %q to be appendable", r)
r = "a:*"
assert(t, Resource(r).IsAppendable(), "Expecting resource %q to be appendable", r)
req.True(Resource(r).IsAppendable(), "Expecting resource %q to be appendable", r)
r = "a"
assert(t, Resource(r).IsValid(), "Expecting resource %q to be valid", r)
req.True(Resource(r).IsValid(), "Expecting resource %q to be valid", r)
r = "a:"
assert(t, !Resource(r).IsValid(), "Expecting resource %q not to be valid", r)
req.False(Resource(r).IsValid(), "Expecting resource %q not to be valid", r)
r = "a:1"
assert(t, Resource(r).IsValid(), "Expecting resource %q to be valid", r)
req.True(Resource(r).IsValid(), "Expecting resource %q to be valid", r)
r = "a:*"
assert(t, Resource(r).IsValid(), "Expecting resource %q to be valid", r)
req.True(Resource(r).IsValid(), "Expecting resource %q to be valid", r)
r = "a:1"
assert(t, !Resource(r).HasWildcard(), "Expecting resource %q to not have wildcard", r)
req.False(Resource(r).HasWildcard(), "Expecting resource %q to not have wildcard", r)
r = "a:*"
assert(t, Resource(r).HasWildcard(), "Expecting resource %q to have wildcard", r)
req.True(Resource(r).HasWildcard(), "Expecting resource %q to have wildcard", r)
}

29
internal/permissions/rule.gen_test.go
View File

@@ -5,36 +5,43 @@ import (
"errors"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/stretchr/testify/require"
)
// Hello! This file is auto-generated.
func TestRuleSetWalk(t *testing.T) {
value := make(RuleSet, 3)
var (
value = make(RuleSet, 3)
req = require.New(t)
)
// 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)
req.NoError(err)
}
// check walk with error
test.Error(t, value.Walk(func(*Rule) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
req.Error(value.Walk(func(*Rule) error { return errors.New("walk error") }))
}
func TestRuleSetFilter(t *testing.T) {
value := make(RuleSet, 3)
var (
value = make(RuleSet, 3)
req = require.New(t)
)
// 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))
req.NoError(err)
req.Equal(len(set), len(value))
}
// filter one item
@@ -47,15 +54,15 @@ func TestRuleSetFilter(t *testing.T) {
}
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))
req.NoError(err)
req.Len(set, 1)
}
// filter error
{
_, err := value.Filter(func(*Rule) (bool, error) {
return false, errors.New("Filter error")
return false, errors.New("filter error")
})
test.Error(t, err, "Expected error, got %#v", err)
req.Error(err)
}
}

14
internal/permissions/ruleset_checks_test.go
View File

@@ -3,7 +3,7 @@ package permissions
import (
"testing"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/stretchr/testify/require"
)
const (
@@ -24,7 +24,7 @@ const (
func TestRuleSet_check(t *testing.T) {
var (
assert = test.Assert
req = require.New(t)
rr = RuleSet{
AllowRule(role1, resThing42, opRead),
@@ -49,7 +49,7 @@ func TestRuleSet_check(t *testing.T) {
for c, sc := range sCases {
v := rr.check(sc.res, sc.op, sc.roles...)
assert(t, v == sc.expected, "Check test #%d failed, expected %s, got %s", c, sc.expected, v)
req.Equalf(sc.expected, v, "Check test #%d failed, expected %s, got %s", c, sc.expected, v)
}
}
@@ -69,7 +69,7 @@ func TestRuleSet_checkResource(t *testing.T) {
)
var (
assert = test.Assert
r = require.New(t)
sCases = []struct {
rr RuleSet
@@ -141,7 +141,7 @@ func TestRuleSet_checkResource(t *testing.T) {
for c, sc := range sCases {
v := sc.rr.checkResource(sc.res, sc.op, sc.roles...)
assert(t, v == sc.expected, "Check test #%d failed, expected %s, got %s", c, sc.expected, v)
r.Equalf(sc.expected, v, "Check test #%d failed, expected %s, got %s", c, sc.expected, v)
}
}
@@ -161,7 +161,7 @@ func TestRuleSet_Check(t *testing.T) {
AllowRule(role1, resThing42, opAccess),
}
assert = test.Assert
r = require.New(t)
sCases = []struct {
roles []uint64
@@ -182,6 +182,6 @@ func TestRuleSet_Check(t *testing.T) {
for c, sc := range sCases {
v := rr.Check(sc.res, sc.op, sc.roles...)
assert(t, v == sc.expected, "Check test #%d failed, expected %s, got %s", c, sc.expected, v)
r.Equalf(sc.expected, v, "Check test #%d failed, expected %s, got %s", c, sc.expected, v)
}
}

15
internal/permissions/ruleset_utils_test.go
View File

@@ -1,16 +1,15 @@
package permissions
import (
"reflect"
"testing"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/stretchr/testify/require"
)
// Test role inheritance
func TestRuleSet_merge(t *testing.T) {
var (
assert = test.Assert
req = require.New(t)
sCases = []struct {
old RuleSet
@@ -71,7 +70,7 @@ func TestRuleSet_merge(t *testing.T) {
}
)
for c, sc := range sCases {
for _, sc := range sCases {
// Apply changed and get update candidates
mrg := sc.old.merge(sc.new...)
del, upd := mrg.dirty()
@@ -80,9 +79,9 @@ func TestRuleSet_merge(t *testing.T) {
del.clear()
upd.clear()
assert(t, len(del) == len(sc.del), "Check test #%d failed, expected delete list length %d, got %d", c, len(sc.del), len(del))
assert(t, len(upd) == len(sc.upd), "Check test #%d failed, expected update list length %d, got %d", c, len(sc.upd), len(upd))
assert(t, reflect.DeepEqual(del, sc.del), "Check test #%d failed for delete list, reflect.DeepEqual == false", c)
assert(t, reflect.DeepEqual(upd, sc.upd), "Check test #%d failed for update list, reflect.DeepEqual == false", c)
req.Equal(len(sc.del), len(del))
req.Equal(len(sc.upd), len(upd))
req.Equal(sc.del, del)
req.Equal(sc.upd, upd)
}
}

29
internal/settings/types.gen_test.go
View File

@@ -5,36 +5,43 @@ import (
"errors"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/stretchr/testify/require"
)
// Hello! This file is auto-generated.
func TestValueSetWalk(t *testing.T) {
value := make(ValueSet, 3)
var (
value = make(ValueSet, 3)
req = require.New(t)
)
// 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)
req.NoError(err)
}
// check walk with error
test.Error(t, value.Walk(func(*Value) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
req.Error(value.Walk(func(*Value) error { return errors.New("walk error") }))
}
func TestValueSetFilter(t *testing.T) {
value := make(ValueSet, 3)
var (
value = make(ValueSet, 3)
req = require.New(t)
)
// 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))
req.NoError(err)
req.Equal(len(set), len(value))
}
// filter one item
@@ -47,15 +54,15 @@ func TestValueSetFilter(t *testing.T) {
}
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))
req.NoError(err)
req.Len(set, 1)
}
// filter error
{
_, err := value.Filter(func(*Value) (bool, error) {
return false, errors.New("Filter error")
return false, errors.New("filter error")
})
test.Error(t, err, "Expected error, got %#v", err)
req.Error(err)
}
}

44
internal/settings/types_test.go
View File

@@ -4,8 +4,7 @@ import (
"testing"
"github.com/jmoiron/sqlx/types"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/stretchr/testify/require"
)
func TestKV_Bool(t *testing.T) {
@@ -53,27 +52,36 @@ func TestKV_Bool(t *testing.T) {
}
func TestSettingValueAsString(t *testing.T) {
test.NoError(t, (&Value{}).SetRawValue(`"string"`), "unable to set value as string")
test.NoError(t, (&Value{}).SetRawValue(`false`), "unable to set value as string")
test.NoError(t, (&Value{}).SetRawValue(`null`), "unable to set value as string")
test.NoError(t, (&Value{}).SetRawValue(`42`), "unable to set value as string")
test.NoError(t, (&Value{}).SetRawValue(`3.14`), "unable to set value as string")
test.Error(t, (&Value{}).SetRawValue(`error`), "expecting error when not setting JSON")
var req = require.New(t)
req.NoError((&Value{}).SetRawValue(`"string"`), "unable to set value as string")
req.NoError((&Value{}).SetRawValue(`false`), "unable to set value as string")
req.NoError((&Value{}).SetRawValue(`null`), "unable to set value as string")
req.NoError((&Value{}).SetRawValue(`42`), "unable to set value as string")
req.NoError((&Value{}).SetRawValue(`3.14`), "unable to set value as string")
req.Error((&Value{}).SetRawValue(`error`), "expecting error when not setting JSON")
}
func TestValueSet_Upsert(t *testing.T) {
var vv = ValueSet{}
var (
req = require.New(t)
vv = ValueSet{}
)
req.Len(vv, 0)
test.Assert(t, len(vv) == 0, "expecting length to be 0")
vv.Replace(&Value{Name: "name"})
test.Assert(t, len(vv) == 1, "expecting length to be 1")
req.Len(vv, 1)
vv.Replace(&Value{Name: "name", Value: []byte("42")})
test.Assert(t, len(vv) == 1, "expecting length to be 1")
test.Assert(t, string(vv[0].Value) == "42", "expecting value to be 42")
req.Len(vv, 1)
req.Equal("42", string(vv[0].Value))
}
func TestValueSet_Changed(t *testing.T) {
var (
req = require.New(t)
// make string value
msv = func(n, v string) *Value {
o := &Value{Name: n}
@@ -89,9 +97,9 @@ func TestValueSet_Changed(t *testing.T) {
out = org.Changed(inp)
test.Assert(t, len(out) == 2, "expecting length to be 2, got %d", len(out))
test.Assert(t, out.First("a").String() == "a2", "expecting 'a' to have 'a2' value")
test.Assert(t, out.First("b").String() == "", "expecting 'b' to be missing")
test.Assert(t, out.First("c").String() == "c1", "expecting 'c' to have 'c1' value")
test.Assert(t, out.First("d").String() == "", "expecting 'd' to be missing")
req.Len(out, 2)
req.Equal("a2", out.First("a").String())
req.Equal("", out.First("b").String())
req.Equal("c1", out.First("c").String())
req.Equal("", out.First("d").String())
}

33
internal/store/store_test.go
View File

@@ -6,8 +6,7 @@ import (
"testing"
"github.com/spf13/afero"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/stretchr/testify/require"
)
func TestStore(t *testing.T) {
@@ -19,57 +18,57 @@ func TestStore(t *testing.T) {
store, err := NewWithAfero(afero.NewMemMapFs(), "test")
test.Assert(t, err == nil, "Unexpected error when creating store: %+v", err)
test.Assert(t, store != nil, "Expected non-nil return for new store")
test.Assert(t, store.Namespace() == "test", "Unexpected store namespace: test != %s", store.Namespace())
require.True(t, err == nil, "Unexpected error when creating store: %+v", err)
require.True(t, store != nil, "Expected non-nil return for new store")
require.True(t, store.Namespace() == "test", "Unexpected store namespace: test != %s", store.Namespace())
{
fn := store.Original(123, "jpg")
expected := "test/123.jpg"
test.Assert(t, fn == expected, "Unexpected filename returned: %s != %s", expected, fn)
require.True(t, fn == expected, "Unexpected filename returned: %s != %s", expected, fn)
}
{
fn := store.Preview(123, "jpg")
expected := "test/123_preview.jpg"
test.Assert(t, fn == expected, "Unexpected filename returned: %s != %s", expected, fn)
require.True(t, fn == expected, "Unexpected filename returned: %s != %s", expected, fn)
}
// write a file
{
buf := bytes.NewBuffer([]byte("This is a testing buffer"))
err := store.Save("test/123.jpg", buf)
test.Assert(t, err == nil, "Error saving file, %+v", err)
require.True(t, err == nil, "Error saving file, %+v", err)
err = store.Save("test123/123.jpg", buf)
test.Assert(t, err != nil, "Expected error when saving file outside of namespace")
require.True(t, err != nil, "Expected error when saving file outside of namespace")
}
// read a file
{
buf, err := store.Open("test/123.jpg")
test.Assert(t, err == nil, "Unexpected error when reading file: %+v", err)
require.True(t, err == nil, "Unexpected error when reading file: %+v", err)
s := readerToString(buf)
test.Assert(t, s == "This is a testing buffer", "Unexpected response when reading file: %s", s)
require.True(t, s == "This is a testing buffer", "Unexpected response when reading file: %s", s)
_, err = store.Open("test/1234.jpg")
test.Assert(t, err != nil, "Expected error when opening non-existent file")
require.True(t, err != nil, "Expected error when opening non-existent file")
_, err = store.Open("test123/123.jpg")
test.Assert(t, err != nil, "Expected error when opening file outside of namespace")
require.True(t, err != nil, "Expected error when opening file outside of namespace")
}
// delete a file
{
err := store.Remove("test/123.jpg")
test.Assert(t, err == nil, "Unexpected error when removing file: %+v", err)
require.True(t, err == nil, "Unexpected error when removing file: %+v", err)
err = store.Remove("test/123.jpg")
test.Assert(t, err != nil, "Expected error when removing missing file")
require.True(t, err != nil, "Expected error when removing missing file")
err = store.Remove("test123/123.jpg")
test.Assert(t, err != nil, "Expected error when deleting file outside of namespace")
require.True(t, err != nil, "Expected error when deleting file outside of namespace")
}
}
func TestStoreCheckFunc(t *testing.T) {
// Should not cause panic
test.Assert(t, (&store{}).check("") != nil, "Expecting an error to be returned on empty filename check")
require.True(t, (&store{}).check("") != nil, "Expecting an error to be returned on empty filename check")
}

37
internal/test/assert.go
View File

@@ -1,37 +0,0 @@
package test
import (
"fmt"
"runtime"
"testing"
)
func Assert(t *testing.T, ok bool, format string, args ...interface{}) bool {
if !ok {
_, file, line, _ := runtime.Caller(1)
caller := fmt.Sprintf("\nAsserted at:%s:%d", file, line)
t.Fatalf(format+caller, args...)
}
return ok
}
func NoError(t *testing.T, err error, format string, args ...interface{}) bool {
if err != nil {
_, file, line, _ := runtime.Caller(1)
caller := fmt.Sprintf("\nAsserted at:%s:%d", file, line)
t.Fatalf(format+caller, append([]interface{}{err}, args...)...)
return false
}
return true
}
func Error(t *testing.T, err error, format string, args ...interface{}) bool {
if err == nil {
_, file, line, _ := runtime.Caller(1)
caller := fmt.Sprintf("\nAsserted at:%s:%d", file, line)
t.Fatalf(format+caller, args...)
return false
}
return true
}

8
messaging/messaging_test.go
View File

@@ -4,12 +4,12 @@ import (
"context"
"testing"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/stretchr/testify/require"
)
func TestConfigure(t *testing.T) {
var config = Configure()
test.Assert(t, config != nil, "Configure valid")
test.Assert(t, func() bool { config.Init(); return true }(), "Initialization ok")
test.Assert(t, config.MakeCLI(context.Background()) != nil, "CLI created")
require.True(t, config != nil, "Configure valid")
require.True(t, func() bool { config.Init(); return true }(), "Initialization ok")
require.True(t, config.MakeCLI(context.Background()) != nil, "CLI created")
}

6
messaging/service/channel_test.go
View File

@@ -4,18 +4,18 @@ import (
"strings"
"testing"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/cortezaproject/corteza-server/messaging/types"
"github.com/stretchr/testify/require"
)
func TestChannelNameTooShort(t *testing.T) {
svc := channel{}
e := func(out *types.Channel, err error) error { return err }
test.Assert(t, e(svc.Create(&types.Channel{})) != nil, "Should not allow to create unnamed channels")
require.True(t, e(svc.Create(&types.Channel{})) != nil, "Should not allow to create unnamed channels")
if settingsChannelNameLength > 0 {
longName := strings.Repeat("X", settingsChannelNameLength+1)
test.Assert(t, e(svc.Create(&types.Channel{Name: longName})) != nil, "Should not allow to create channel with really long name")
require.True(t, e(svc.Create(&types.Channel{Name: longName})) != nil, "Should not allow to create channel with really long name")
}
}

10
messaging/service/message_test.go
View File

@@ -4,19 +4,19 @@ import (
"strings"
"testing"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/cortezaproject/corteza-server/messaging/types"
"github.com/stretchr/testify/require"
)
func TestMessageLength(t *testing.T) {
svc := message{}
e := func(out *types.Message, err error) error { return err }
test.Assert(t, e(svc.Create(&types.Message{})) != nil, "Should not allow to create empty message")
require.True(t, e(svc.Create(&types.Message{})) != nil, "Should not allow to create empty message")
if settingsMessageBodyLength > 0 {
longText := strings.Repeat("X", settingsMessageBodyLength+1)
test.Assert(t, e(svc.Create(&types.Message{Message: longText})) != nil, "Should not allow to create message with really long text")
require.True(t, e(svc.Create(&types.Message{Message: longText})) != nil, "Should not allow to create message with really long text")
}
}
@@ -48,10 +48,10 @@ func TestMentionsExtraction(t *testing.T) {
for _, c := range cases {
mm = svc.extractMentions(&types.Message{Message: c.text})
test.Assert(t, len(mm) == len(c.ids), "Number of extracted (%d) and expected (%d) user IDs do not match (%s)", len(mm), len(c.ids), c.text)
require.True(t, len(mm) == len(c.ids), "Number of extracted (%d) and expected (%d) user IDs do not match (%s)", len(mm), len(c.ids), c.text)
for _, id := range c.ids {
test.Assert(t, len(mm.FindByUserID(id)) == 1, "Owner ID (%d) was not extracted (%s)", id, c.text)
require.True(t, len(mm.FindByUserID(id)) == 1, "Owner ID (%d) was not extracted (%s)", id, c.text)
}
}
}

24
messaging/service/webhook_test.go
View File

@@ -10,9 +10,9 @@ import (
"github.com/cortezaproject/corteza-server/internal/auth"
"github.com/cortezaproject/corteza-server/internal/http"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/cortezaproject/corteza-server/messaging/repository"
"github.com/cortezaproject/corteza-server/messaging/types"
"github.com/stretchr/testify/require"
)
func TestOutgoingWebhook(t *testing.T) {
@@ -29,13 +29,13 @@ func TestOutgoingWebhook(t *testing.T) {
{
rpo := repository.Channel(ctx, repository.DB(ctx))
_, err := rpo.Create(channel)
test.Assert(t, err == nil, "Error when creating channel: %+v", err)
require.True(t, err == nil, "Error when creating channel: %+v", err)
}
client, err := http.New(&http.Config{
Timeout: 10,
})
test.Assert(t, err == nil, "Error creating HTTP client: %+v", err)
require.True(t, err == nil, "Error creating HTTP client: %+v", err)
svc := Webhook(ctx, client)
@@ -47,20 +47,20 @@ func TestOutgoingWebhook(t *testing.T) {
OutgoingTrigger: "fortune",
OutgoingURL: server.URL,
})
test.Assert(t, err == nil, "Error when creating webhook: %+v", err)
require.True(t, err == nil, "Error when creating webhook: %+v", err)
/* find outgoing webhook */
webhooks, err := svc.Find(&types.WebhookFilter{
OutgoingTrigger: webhook.OutgoingTrigger,
})
test.Assert(t, err == nil, "Error when finding webhook: %+v", err)
test.Assert(t, len(webhooks) == 1, "Expected to find 1 webhook, got %d", len(webhooks))
require.True(t, err == nil, "Error when finding webhook: %+v", err)
require.True(t, len(webhooks) == 1, "Expected to find 1 webhook, got %d", len(webhooks))
/* trigger outgoing webhook */
{
message, err := svc.Do(webhooks[0], "")
test.Assert(t, err == nil, "Error when triggering webhook: %+v", err)
test.Assert(t, strings.Contains(message.Message, "Louis Pasteur"), "Unexpected webhook output: %s", message.Message)
require.True(t, err == nil, "Error when triggering webhook: %+v", err)
require.True(t, strings.Contains(message.Message, "Louis Pasteur"), "Unexpected webhook output: %s", message.Message)
}
// update webhook
@@ -70,14 +70,14 @@ func TestOutgoingWebhook(t *testing.T) {
OutgoingTrigger: "fortune-json",
OutgoingURL: server.URL + "?username=test",
})
test.Assert(t, err == nil, "Error when updating webhook: %+v", err)
require.True(t, err == nil, "Error when updating webhook: %+v", err)
/* trigger outgoing webhook */
{
message, err := svc.Do(wh, "")
test.Assert(t, err == nil, "Error when triggering webhook: %+v", err)
test.Assert(t, message.Meta.Username == "test", "Expected message.meta.username = 'test', got: '%s'", message.Meta.Username)
test.Assert(t, strings.Contains(message.Message, "Louis Pasteur"), "Unexpected webhook output: %s", message.Message)
require.True(t, err == nil, "Error when triggering webhook: %+v", err)
require.True(t, message.Meta.Username == "test", "Expected message.meta.username = 'test', got: '%s'", message.Meta.Username)
require.True(t, strings.Contains(message.Message, "Louis Pasteur"), "Unexpected webhook output: %s", message.Message)
}
}
}

41
messaging/types/attachment.gen_test.go
View File

@@ -5,36 +5,43 @@ import (
"errors"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/stretchr/testify/require"
)
// Hello! This file is auto-generated.
func TestMessageAttachmentSetWalk(t *testing.T) {
value := make(MessageAttachmentSet, 3)
var (
value = make(MessageAttachmentSet, 3)
req = require.New(t)
)
// 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)
req.NoError(err)
}
// check walk with error
test.Error(t, value.Walk(func(*MessageAttachment) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
req.Error(value.Walk(func(*MessageAttachment) error { return errors.New("walk error") }))
}
func TestMessageAttachmentSetFilter(t *testing.T) {
value := make(MessageAttachmentSet, 3)
var (
value = make(MessageAttachmentSet, 3)
req = require.New(t)
)
// 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))
req.NoError(err)
req.Equal(len(set), len(value))
}
// filter one item
@@ -47,21 +54,25 @@ func TestMessageAttachmentSetFilter(t *testing.T) {
}
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))
req.NoError(err)
req.Len(set, 1)
}
// filter error
{
_, err := value.Filter(func(*MessageAttachment) (bool, error) {
return false, errors.New("Filter error")
return false, errors.New("filter error")
})
test.Error(t, err, "Expected error, got %#v", err)
req.Error(err)
}
}
func TestMessageAttachmentSetIDs(t *testing.T) {
value := make(MessageAttachmentSet, 3)
var (
value = make(MessageAttachmentSet, 3)
req = require.New(t)
)
// construct objects
value[0] = new(MessageAttachment)
value[1] = new(MessageAttachment)
@@ -74,18 +85,18 @@ func TestMessageAttachmentSetIDs(t *testing.T) {
// Find existing
{
val := value.FindByID(2)
test.Assert(t, val.ID == 2, "Expected ID 2, got %d", val.ID)
req.Equal(uint64(2), val.ID)
}
// Find non-existing
{
val := value.FindByID(4)
test.Assert(t, val == nil, "Expected no value, got %#v", val)
req.Nil(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))
req.Equal(len(val), len(value))
}
}

41
messaging/types/channel.gen_test.go
View File

@@ -5,36 +5,43 @@ import (
"errors"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/stretchr/testify/require"
)
// Hello! This file is auto-generated.
func TestChannelSetWalk(t *testing.T) {
value := make(ChannelSet, 3)
var (
value = make(ChannelSet, 3)
req = require.New(t)
)
// 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)
req.NoError(err)
}
// check walk with error
test.Error(t, value.Walk(func(*Channel) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
req.Error(value.Walk(func(*Channel) error { return errors.New("walk error") }))
}
func TestChannelSetFilter(t *testing.T) {
value := make(ChannelSet, 3)
var (
value = make(ChannelSet, 3)
req = require.New(t)
)
// 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))
req.NoError(err)
req.Equal(len(set), len(value))
}
// filter one item
@@ -47,21 +54,25 @@ func TestChannelSetFilter(t *testing.T) {
}
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))
req.NoError(err)
req.Len(set, 1)
}
// filter error
{
_, err := value.Filter(func(*Channel) (bool, error) {
return false, errors.New("Filter error")
return false, errors.New("filter error")
})
test.Error(t, err, "Expected error, got %#v", err)
req.Error(err)
}
}
func TestChannelSetIDs(t *testing.T) {
value := make(ChannelSet, 3)
var (
value = make(ChannelSet, 3)
req = require.New(t)
)
// construct objects
value[0] = new(Channel)
value[1] = new(Channel)
@@ -74,18 +85,18 @@ func TestChannelSetIDs(t *testing.T) {
// Find existing
{
val := value.FindByID(2)
test.Assert(t, val.ID == 2, "Expected ID 2, got %d", val.ID)
req.Equal(uint64(2), val.ID)
}
// Find non-existing
{
val := value.FindByID(4)
test.Assert(t, val == nil, "Expected no value, got %#v", val)
req.Nil(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))
req.Equal(len(val), len(value))
}
}

29
messaging/types/channel_member.gen_test.go
View File

@@ -5,36 +5,43 @@ import (
"errors"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/stretchr/testify/require"
)
// Hello! This file is auto-generated.
func TestChannelMemberSetWalk(t *testing.T) {
value := make(ChannelMemberSet, 3)
var (
value = make(ChannelMemberSet, 3)
req = require.New(t)
)
// 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)
req.NoError(err)
}
// check walk with error
test.Error(t, value.Walk(func(*ChannelMember) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
req.Error(value.Walk(func(*ChannelMember) error { return errors.New("walk error") }))
}
func TestChannelMemberSetFilter(t *testing.T) {
value := make(ChannelMemberSet, 3)
var (
value = make(ChannelMemberSet, 3)
req = require.New(t)
)
// 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))
req.NoError(err)
req.Equal(len(set), len(value))
}
// filter one item
@@ -47,15 +54,15 @@ func TestChannelMemberSetFilter(t *testing.T) {
}
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))
req.NoError(err)
req.Len(set, 1)
}
// filter error
{
_, err := value.Filter(func(*ChannelMember) (bool, error) {
return false, errors.New("Filter error")
return false, errors.New("filter error")
})
test.Error(t, err, "Expected error, got %#v", err)
req.Error(err)
}
}

29
messaging/types/command.gen_test.go
View File

@@ -5,36 +5,43 @@ import (
"errors"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/stretchr/testify/require"
)
// Hello! This file is auto-generated.
func TestCommandSetWalk(t *testing.T) {
value := make(CommandSet, 3)
var (
value = make(CommandSet, 3)
req = require.New(t)
)
// 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)
req.NoError(err)
}
// check walk with error
test.Error(t, value.Walk(func(*Command) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
req.Error(value.Walk(func(*Command) error { return errors.New("walk error") }))
}
func TestCommandSetFilter(t *testing.T) {
value := make(CommandSet, 3)
var (
value = make(CommandSet, 3)
req = require.New(t)
)
// 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))
req.NoError(err)
req.Equal(len(set), len(value))
}
// filter one item
@@ -47,15 +54,15 @@ func TestCommandSetFilter(t *testing.T) {
}
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))
req.NoError(err)
req.Len(set, 1)
}
// filter error
{
_, err := value.Filter(func(*Command) (bool, error) {
return false, errors.New("Filter error")
return false, errors.New("filter error")
})
test.Error(t, err, "Expected error, got %#v", err)
req.Error(err)
}
}

29
messaging/types/command_param.gen_test.go
View File

@@ -5,36 +5,43 @@ import (
"errors"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/stretchr/testify/require"
)
// Hello! This file is auto-generated.
func TestCommandParamSetWalk(t *testing.T) {
value := make(CommandParamSet, 3)
var (
value = make(CommandParamSet, 3)
req = require.New(t)
)
// 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)
req.NoError(err)
}
// check walk with error
test.Error(t, value.Walk(func(*CommandParam) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
req.Error(value.Walk(func(*CommandParam) error { return errors.New("walk error") }))
}
func TestCommandParamSetFilter(t *testing.T) {
value := make(CommandParamSet, 3)
var (
value = make(CommandParamSet, 3)
req = require.New(t)
)
// 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))
req.NoError(err)
req.Equal(len(set), len(value))
}
// filter one item
@@ -47,15 +54,15 @@ func TestCommandParamSetFilter(t *testing.T) {
}
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))
req.NoError(err)
req.Len(set, 1)
}
// filter error
{
_, err := value.Filter(func(*CommandParam) (bool, error) {
return false, errors.New("Filter error")
return false, errors.New("filter error")
})
test.Error(t, err, "Expected error, got %#v", err)
req.Error(err)
}
}

41
messaging/types/mention.gen_test.go
View File

@@ -5,36 +5,43 @@ import (
"errors"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/stretchr/testify/require"
)
// Hello! This file is auto-generated.
func TestMentionSetWalk(t *testing.T) {
value := make(MentionSet, 3)
var (
value = make(MentionSet, 3)
req = require.New(t)
)
// 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)
req.NoError(err)
}
// check walk with error
test.Error(t, value.Walk(func(*Mention) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
req.Error(value.Walk(func(*Mention) error { return errors.New("walk error") }))
}
func TestMentionSetFilter(t *testing.T) {
value := make(MentionSet, 3)
var (
value = make(MentionSet, 3)
req = require.New(t)
)
// 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))
req.NoError(err)
req.Equal(len(set), len(value))
}
// filter one item
@@ -47,21 +54,25 @@ func TestMentionSetFilter(t *testing.T) {
}
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))
req.NoError(err)
req.Len(set, 1)
}
// filter error
{
_, err := value.Filter(func(*Mention) (bool, error) {
return false, errors.New("Filter error")
return false, errors.New("filter error")
})
test.Error(t, err, "Expected error, got %#v", err)
req.Error(err)
}
}
func TestMentionSetIDs(t *testing.T) {
value := make(MentionSet, 3)
var (
value = make(MentionSet, 3)
req = require.New(t)
)
// construct objects
value[0] = new(Mention)
value[1] = new(Mention)
@@ -74,18 +85,18 @@ func TestMentionSetIDs(t *testing.T) {
// Find existing
{
val := value.FindByID(2)
test.Assert(t, val.ID == 2, "Expected ID 2, got %d", val.ID)
req.Equal(uint64(2), val.ID)
}
// Find non-existing
{
val := value.FindByID(4)
test.Assert(t, val == nil, "Expected no value, got %#v", val)
req.Nil(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))
req.Equal(len(val), len(value))
}
}

8
messaging/types/mention_test.go
View File

@@ -3,14 +3,14 @@ package types
import (
"testing"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/stretchr/testify/require"
)
func TestMentionSet_Diff(t *testing.T) {
ex := MentionSet{&Mention{ID: 1000}, &Mention{ID: 1001}}
add, upd, del := ex.Diff(MentionSet{&Mention{ID: 1001}, &Mention{UserID: 1}})
test.Assert(t, len(add) == 1 && len(add.FindByUserID(1)) == 1, "Did not find expected mention (UserID:1) for creation")
test.Assert(t, len(upd) == 1 && upd.FindByID(1001) != nil, "Did not find expected mention (id:1001) for update")
test.Assert(t, len(del) == 1 && del.FindByID(1000) != nil, "Did not find expected mention (id:1000) for removal")
require.True(t, len(add) == 1 && len(add.FindByUserID(1)) == 1, "Did not find expected mention (UserID:1) for creation")
require.True(t, len(upd) == 1 && upd.FindByID(1001) != nil, "Did not find expected mention (id:1001) for update")
require.True(t, len(del) == 1 && del.FindByID(1000) != nil, "Did not find expected mention (id:1000) for removal")
}

41
messaging/types/message.gen_test.go
View File

@@ -5,36 +5,43 @@ import (
"errors"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/stretchr/testify/require"
)
// Hello! This file is auto-generated.
func TestMessageSetWalk(t *testing.T) {
value := make(MessageSet, 3)
var (
value = make(MessageSet, 3)
req = require.New(t)
)
// 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)
req.NoError(err)
}
// check walk with error
test.Error(t, value.Walk(func(*Message) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
req.Error(value.Walk(func(*Message) error { return errors.New("walk error") }))
}
func TestMessageSetFilter(t *testing.T) {
value := make(MessageSet, 3)
var (
value = make(MessageSet, 3)
req = require.New(t)
)
// 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))
req.NoError(err)
req.Equal(len(set), len(value))
}
// filter one item
@@ -47,21 +54,25 @@ func TestMessageSetFilter(t *testing.T) {
}
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))
req.NoError(err)
req.Len(set, 1)
}
// filter error
{
_, err := value.Filter(func(*Message) (bool, error) {
return false, errors.New("Filter error")
return false, errors.New("filter error")
})
test.Error(t, err, "Expected error, got %#v", err)
req.Error(err)
}
}
func TestMessageSetIDs(t *testing.T) {
value := make(MessageSet, 3)
var (
value = make(MessageSet, 3)
req = require.New(t)
)
// construct objects
value[0] = new(Message)
value[1] = new(Message)
@@ -74,18 +85,18 @@ func TestMessageSetIDs(t *testing.T) {
// Find existing
{
val := value.FindByID(2)
test.Assert(t, val.ID == 2, "Expected ID 2, got %d", val.ID)
req.Equal(uint64(2), val.ID)
}
// Find non-existing
{
val := value.FindByID(4)
test.Assert(t, val == nil, "Expected no value, got %#v", val)
req.Nil(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))
req.Equal(len(val), len(value))
}
}

41
messaging/types/message_flag.gen_test.go
View File

@@ -5,36 +5,43 @@ import (
"errors"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/stretchr/testify/require"
)
// Hello! This file is auto-generated.
func TestMessageFlagSetWalk(t *testing.T) {
value := make(MessageFlagSet, 3)
var (
value = make(MessageFlagSet, 3)
req = require.New(t)
)
// 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)
req.NoError(err)
}
// check walk with error
test.Error(t, value.Walk(func(*MessageFlag) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
req.Error(value.Walk(func(*MessageFlag) error { return errors.New("walk error") }))
}
func TestMessageFlagSetFilter(t *testing.T) {
value := make(MessageFlagSet, 3)
var (
value = make(MessageFlagSet, 3)
req = require.New(t)
)
// 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))
req.NoError(err)
req.Equal(len(set), len(value))
}
// filter one item
@@ -47,21 +54,25 @@ func TestMessageFlagSetFilter(t *testing.T) {
}
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))
req.NoError(err)
req.Len(set, 1)
}
// filter error
{
_, err := value.Filter(func(*MessageFlag) (bool, error) {
return false, errors.New("Filter error")
return false, errors.New("filter error")
})
test.Error(t, err, "Expected error, got %#v", err)
req.Error(err)
}
}
func TestMessageFlagSetIDs(t *testing.T) {
value := make(MessageFlagSet, 3)
var (
value = make(MessageFlagSet, 3)
req = require.New(t)
)
// construct objects
value[0] = new(MessageFlag)
value[1] = new(MessageFlag)
@@ -74,18 +85,18 @@ func TestMessageFlagSetIDs(t *testing.T) {
// Find existing
{
val := value.FindByID(2)
test.Assert(t, val.ID == 2, "Expected ID 2, got %d", val.ID)
req.Equal(uint64(2), val.ID)
}
// Find non-existing
{
val := value.FindByID(4)
test.Assert(t, val == nil, "Expected no value, got %#v", val)
req.Nil(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))
req.Equal(len(val), len(value))
}
}

29
messaging/types/unread.gen_test.go
View File

@@ -5,36 +5,43 @@ import (
"errors"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/stretchr/testify/require"
)
// Hello! This file is auto-generated.
func TestUnreadSetWalk(t *testing.T) {
value := make(UnreadSet, 3)
var (
value = make(UnreadSet, 3)
req = require.New(t)
)
// 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)
req.NoError(err)
}
// check walk with error
test.Error(t, value.Walk(func(*Unread) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
req.Error(value.Walk(func(*Unread) error { return errors.New("walk error") }))
}
func TestUnreadSetFilter(t *testing.T) {
value := make(UnreadSet, 3)
var (
value = make(UnreadSet, 3)
req = require.New(t)
)
// 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))
req.NoError(err)
req.Equal(len(set), len(value))
}
// filter one item
@@ -47,15 +54,15 @@ func TestUnreadSetFilter(t *testing.T) {
}
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))
req.NoError(err)
req.Len(set, 1)
}
// filter error
{
_, err := value.Filter(func(*Unread) (bool, error) {
return false, errors.New("Filter error")
return false, errors.New("filter error")
})
test.Error(t, err, "Expected error, got %#v", err)
req.Error(err)
}
}

41
messaging/types/webhook.gen_test.go
View File

@@ -5,36 +5,43 @@ import (
"errors"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/stretchr/testify/require"
)
// Hello! This file is auto-generated.
func TestWebhookSetWalk(t *testing.T) {
value := make(WebhookSet, 3)
var (
value = make(WebhookSet, 3)
req = require.New(t)
)
// 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)
req.NoError(err)
}
// check walk with error
test.Error(t, value.Walk(func(*Webhook) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
req.Error(value.Walk(func(*Webhook) error { return errors.New("walk error") }))
}
func TestWebhookSetFilter(t *testing.T) {
value := make(WebhookSet, 3)
var (
value = make(WebhookSet, 3)
req = require.New(t)
)
// 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))
req.NoError(err)
req.Equal(len(set), len(value))
}
// filter one item
@@ -47,21 +54,25 @@ func TestWebhookSetFilter(t *testing.T) {
}
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))
req.NoError(err)
req.Len(set, 1)
}
// filter error
{
_, err := value.Filter(func(*Webhook) (bool, error) {
return false, errors.New("Filter error")
return false, errors.New("filter error")
})
test.Error(t, err, "Expected error, got %#v", err)
req.Error(err)
}
}
func TestWebhookSetIDs(t *testing.T) {
value := make(WebhookSet, 3)
var (
value = make(WebhookSet, 3)
req = require.New(t)
)
// construct objects
value[0] = new(Webhook)
value[1] = new(Webhook)
@@ -74,18 +85,18 @@ func TestWebhookSetIDs(t *testing.T) {
// Find existing
{
val := value.FindByID(2)
test.Assert(t, val.ID == 2, "Expected ID 2, got %d", val.ID)
req.Equal(uint64(2), val.ID)
}
// Find non-existing
{
val := value.FindByID(4)
test.Assert(t, val == nil, "Expected no value, got %#v", val)
req.Nil(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))
req.Equal(len(val), len(value))
}
}

8
monolith/monolith_test.go
View File

@@ -4,12 +4,12 @@ import (
"context"
"testing"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/stretchr/testify/require"
)
func TestConfigure(t *testing.T) {
var config = Configure()
test.Assert(t, config != nil, "Configure valid")
test.Assert(t, func() bool { config.Init(); return true }(), "Initialization ok")
test.Assert(t, config.MakeCLI(context.Background()) != nil, "CLI created")
require.True(t, config != nil, "Configure valid")
require.True(t, func() bool { config.Init(); return true }(), "Initialization ok")
require.True(t, config.MakeCLI(context.Background()) != nil, "CLI created")
}

41
pkg/automation/script.gen_test.go
View File

@@ -5,36 +5,43 @@ import (
"errors"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/stretchr/testify/require"
)
// Hello! This file is auto-generated.
func TestScriptSetWalk(t *testing.T) {
value := make(ScriptSet, 3)
var (
value = make(ScriptSet, 3)
req = require.New(t)
)
// check walk with no errors
{
err := value.Walk(func(*Script) error {
return nil
})
test.NoError(t, err, "Expected no returned error from Walk, got %+v", err)
req.NoError(err)
}
// check walk with error
test.Error(t, value.Walk(func(*Script) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
req.Error(value.Walk(func(*Script) error { return errors.New("walk error") }))
}
func TestScriptSetFilter(t *testing.T) {
value := make(ScriptSet, 3)
var (
value = make(ScriptSet, 3)
req = require.New(t)
)
// filter nothing
{
set, err := value.Filter(func(*Script) (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))
req.NoError(err)
req.Equal(len(set), len(value))
}
// filter one item
@@ -47,21 +54,25 @@ func TestScriptSetFilter(t *testing.T) {
}
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))
req.NoError(err)
req.Len(set, 1)
}
// filter error
{
_, err := value.Filter(func(*Script) (bool, error) {
return false, errors.New("Filter error")
return false, errors.New("filter error")
})
test.Error(t, err, "Expected error, got %#v", err)
req.Error(err)
}
}
func TestScriptSetIDs(t *testing.T) {
value := make(ScriptSet, 3)
var (
value = make(ScriptSet, 3)
req = require.New(t)
)
// construct objects
value[0] = new(Script)
value[1] = new(Script)
@@ -74,18 +85,18 @@ func TestScriptSetIDs(t *testing.T) {
// Find existing
{
val := value.FindByID(2)
test.Assert(t, val.ID == 2, "Expected ID 2, got %d", val.ID)
req.Equal(uint64(2), val.ID)
}
// Find non-existing
{
val := value.FindByID(4)
test.Assert(t, val == nil, "Expected no value, got %#v", val)
req.Nil(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))
req.Equal(len(val), len(value))
}
}

41
pkg/automation/trigger.gen_test.go
View File

@@ -5,36 +5,43 @@ import (
"errors"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/stretchr/testify/require"
)
// Hello! This file is auto-generated.
func TestTriggerSetWalk(t *testing.T) {
value := make(TriggerSet, 3)
var (
value = make(TriggerSet, 3)
req = require.New(t)
)
// 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)
req.NoError(err)
}
// check walk with error
test.Error(t, value.Walk(func(*Trigger) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
req.Error(value.Walk(func(*Trigger) error { return errors.New("walk error") }))
}
func TestTriggerSetFilter(t *testing.T) {
value := make(TriggerSet, 3)
var (
value = make(TriggerSet, 3)
req = require.New(t)
)
// 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))
req.NoError(err)
req.Equal(len(set), len(value))
}
// filter one item
@@ -47,21 +54,25 @@ func TestTriggerSetFilter(t *testing.T) {
}
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))
req.NoError(err)
req.Len(set, 1)
}
// filter error
{
_, err := value.Filter(func(*Trigger) (bool, error) {
return false, errors.New("Filter error")
return false, errors.New("filter error")
})
test.Error(t, err, "Expected error, got %#v", err)
req.Error(err)
}
}
func TestTriggerSetIDs(t *testing.T) {
value := make(TriggerSet, 3)
var (
value = make(TriggerSet, 3)
req = require.New(t)
)
// construct objects
value[0] = new(Trigger)
value[1] = new(Trigger)
@@ -74,18 +85,18 @@ func TestTriggerSetIDs(t *testing.T) {
// Find existing
{
val := value.FindByID(2)
test.Assert(t, val.ID == 2, "Expected ID 2, got %d", val.ID)
req.Equal(uint64(2), val.ID)
}
// Find non-existing
{
val := value.FindByID(4)
test.Assert(t, val == nil, "Expected no value, got %#v", val)
req.Nil(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))
req.Equal(len(val), len(value))
}
}

2
system/db/mysql/static.go
View File

File diff suppressed because one or more lines are too long

3
system/rest/request/reminder.go
View File

@@ -26,9 +26,8 @@ import (
"github.com/go-chi/chi"
"github.com/pkg/errors"
"time"
sqlxTypes "github.com/jmoiron/sqlx/types"
"time"
)
var _ = chi.URLParam

10
system/service/auth_test.go
View File

@@ -6,10 +6,10 @@ import (
"github.com/golang/mock/gomock"
"github.com/markbates/goth"
"github.com/stretchr/testify/require"
"go.uber.org/zap"
"golang.org/x/crypto/bcrypt"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/cortezaproject/corteza-server/system/repository"
repomock "github.com/cortezaproject/corteza-server/system/repository/mocks"
"github.com/cortezaproject/corteza-server/system/types"
@@ -72,8 +72,8 @@ func TestAuth_External_Existing(t *testing.T) {
{
auser, err := svc.External(p)
test.NoError(t, err, "unexpected error from auth.External: %v", err)
test.Assert(t, auser.ID == u.ID, "Did not receive expected user")
require.NoError(t, err)
require.True(t, auser.ID == u.ID, "Did not receive expected user")
}
}
@@ -117,8 +117,8 @@ func TestAuth_External_NonExisting(t *testing.T) {
{
auser, err := svc.External(p)
test.NoError(t, err, "unexpected error from auth.External: %v", err)
test.Assert(t, auser.ID == u.ID, "Did not receive expected user")
require.NoError(t, err)
require.True(t, auser.ID == u.ID, "Did not receive expected user")
}
}

8
system/system_test.go
View File

@@ -4,12 +4,12 @@ import (
"context"
"testing"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/stretchr/testify/require"
)
func TestConfigure(t *testing.T) {
var config = Configure()
test.Assert(t, config != nil, "Configure valid")
test.Assert(t, func() bool { config.Init(); return true }(), "Initialization ok")
test.Assert(t, config.MakeCLI(context.Background()) != nil, "CLI created")
require.True(t, config != nil, "Configure valid")
require.True(t, func() bool { config.Init(); return true }(), "Initialization ok")
require.True(t, config.MakeCLI(context.Background()) != nil, "CLI created")
}

41
system/types/application.gen_test.go
View File

@@ -5,36 +5,43 @@ import (
"errors"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/stretchr/testify/require"
)
// Hello! This file is auto-generated.
func TestApplicationSetWalk(t *testing.T) {
value := make(ApplicationSet, 3)
var (
value = make(ApplicationSet, 3)
req = require.New(t)
)
// 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)
req.NoError(err)
}
// check walk with error
test.Error(t, value.Walk(func(*Application) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
req.Error(value.Walk(func(*Application) error { return errors.New("walk error") }))
}
func TestApplicationSetFilter(t *testing.T) {
value := make(ApplicationSet, 3)
var (
value = make(ApplicationSet, 3)
req = require.New(t)
)
// 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))
req.NoError(err)
req.Equal(len(set), len(value))
}
// filter one item
@@ -47,21 +54,25 @@ func TestApplicationSetFilter(t *testing.T) {
}
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))
req.NoError(err)
req.Len(set, 1)
}
// filter error
{
_, err := value.Filter(func(*Application) (bool, error) {
return false, errors.New("Filter error")
return false, errors.New("filter error")
})
test.Error(t, err, "Expected error, got %#v", err)
req.Error(err)
}
}
func TestApplicationSetIDs(t *testing.T) {
value := make(ApplicationSet, 3)
var (
value = make(ApplicationSet, 3)
req = require.New(t)
)
// construct objects
value[0] = new(Application)
value[1] = new(Application)
@@ -74,18 +85,18 @@ func TestApplicationSetIDs(t *testing.T) {
// Find existing
{
val := value.FindByID(2)
test.Assert(t, val.ID == 2, "Expected ID 2, got %d", val.ID)
req.Equal(uint64(2), val.ID)
}
// Find non-existing
{
val := value.FindByID(4)
test.Assert(t, val == nil, "Expected no value, got %#v", val)
req.Nil(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))
req.Equal(len(val), len(value))
}
}

41
system/types/credentials.gen_test.go
View File

@@ -5,36 +5,43 @@ import (
"errors"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/stretchr/testify/require"
)
// Hello! This file is auto-generated.
func TestCredentialsSetWalk(t *testing.T) {
value := make(CredentialsSet, 3)
var (
value = make(CredentialsSet, 3)
req = require.New(t)
)
// 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)
req.NoError(err)
}
// check walk with error
test.Error(t, value.Walk(func(*Credentials) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
req.Error(value.Walk(func(*Credentials) error { return errors.New("walk error") }))
}
func TestCredentialsSetFilter(t *testing.T) {
value := make(CredentialsSet, 3)
var (
value = make(CredentialsSet, 3)
req = require.New(t)
)
// 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))
req.NoError(err)
req.Equal(len(set), len(value))
}
// filter one item
@@ -47,21 +54,25 @@ func TestCredentialsSetFilter(t *testing.T) {
}
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))
req.NoError(err)
req.Len(set, 1)
}
// filter error
{
_, err := value.Filter(func(*Credentials) (bool, error) {
return false, errors.New("Filter error")
return false, errors.New("filter error")
})
test.Error(t, err, "Expected error, got %#v", err)
req.Error(err)
}
}
func TestCredentialsSetIDs(t *testing.T) {
value := make(CredentialsSet, 3)
var (
value = make(CredentialsSet, 3)
req = require.New(t)
)
// construct objects
value[0] = new(Credentials)
value[1] = new(Credentials)
@@ -74,18 +85,18 @@ func TestCredentialsSetIDs(t *testing.T) {
// Find existing
{
val := value.FindByID(2)
test.Assert(t, val.ID == 2, "Expected ID 2, got %d", val.ID)
req.Equal(uint64(2), val.ID)
}
// Find non-existing
{
val := value.FindByID(4)
test.Assert(t, val == nil, "Expected no value, got %#v", val)
req.Nil(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))
req.Equal(len(val), len(value))
}
}

41
system/types/organisation.gen_test.go
View File

@@ -5,36 +5,43 @@ import (
"errors"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/stretchr/testify/require"
)
// Hello! This file is auto-generated.
func TestOrganisationSetWalk(t *testing.T) {
value := make(OrganisationSet, 3)
var (
value = make(OrganisationSet, 3)
req = require.New(t)
)
// 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)
req.NoError(err)
}
// check walk with error
test.Error(t, value.Walk(func(*Organisation) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
req.Error(value.Walk(func(*Organisation) error { return errors.New("walk error") }))
}
func TestOrganisationSetFilter(t *testing.T) {
value := make(OrganisationSet, 3)
var (
value = make(OrganisationSet, 3)
req = require.New(t)
)
// 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))
req.NoError(err)
req.Equal(len(set), len(value))
}
// filter one item
@@ -47,21 +54,25 @@ func TestOrganisationSetFilter(t *testing.T) {
}
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))
req.NoError(err)
req.Len(set, 1)
}
// filter error
{
_, err := value.Filter(func(*Organisation) (bool, error) {
return false, errors.New("Filter error")
return false, errors.New("filter error")
})
test.Error(t, err, "Expected error, got %#v", err)
req.Error(err)
}
}
func TestOrganisationSetIDs(t *testing.T) {
value := make(OrganisationSet, 3)
var (
value = make(OrganisationSet, 3)
req = require.New(t)
)
// construct objects
value[0] = new(Organisation)
value[1] = new(Organisation)
@@ -74,18 +85,18 @@ func TestOrganisationSetIDs(t *testing.T) {
// Find existing
{
val := value.FindByID(2)
test.Assert(t, val.ID == 2, "Expected ID 2, got %d", val.ID)
req.Equal(uint64(2), val.ID)
}
// Find non-existing
{
val := value.FindByID(4)
test.Assert(t, val == nil, "Expected no value, got %#v", val)
req.Nil(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))
req.Equal(len(val), len(value))
}
}

41
system/types/reminder.gen_test.go
View File

@@ -5,36 +5,43 @@ import (
"errors"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/stretchr/testify/require"
)
// Hello! This file is auto-generated.
func TestReminderSetWalk(t *testing.T) {
value := make(ReminderSet, 3)
var (
value = make(ReminderSet, 3)
req = require.New(t)
)
// check walk with no errors
{
err := value.Walk(func(*Reminder) error {
return nil
})
test.NoError(t, err, "Expected no returned error from Walk, got %+v", err)
req.NoError(err)
}
// check walk with error
test.Error(t, value.Walk(func(*Reminder) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
req.Error(value.Walk(func(*Reminder) error { return errors.New("walk error") }))
}
func TestReminderSetFilter(t *testing.T) {
value := make(ReminderSet, 3)
var (
value = make(ReminderSet, 3)
req = require.New(t)
)
// filter nothing
{
set, err := value.Filter(func(*Reminder) (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))
req.NoError(err)
req.Equal(len(set), len(value))
}
// filter one item
@@ -47,21 +54,25 @@ func TestReminderSetFilter(t *testing.T) {
}
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))
req.NoError(err)
req.Len(set, 1)
}
// filter error
{
_, err := value.Filter(func(*Reminder) (bool, error) {
return false, errors.New("Filter error")
return false, errors.New("filter error")
})
test.Error(t, err, "Expected error, got %#v", err)
req.Error(err)
}
}
func TestReminderSetIDs(t *testing.T) {
value := make(ReminderSet, 3)
var (
value = make(ReminderSet, 3)
req = require.New(t)
)
// construct objects
value[0] = new(Reminder)
value[1] = new(Reminder)
@@ -74,18 +85,18 @@ func TestReminderSetIDs(t *testing.T) {
// Find existing
{
val := value.FindByID(2)
test.Assert(t, val.ID == 2, "Expected ID 2, got %d", val.ID)
req.Equal(uint64(2), val.ID)
}
// Find non-existing
{
val := value.FindByID(4)
test.Assert(t, val == nil, "Expected no value, got %#v", val)
req.Nil(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))
req.Equal(len(val), len(value))
}
}

41
system/types/role.gen_test.go
View File

@@ -5,36 +5,43 @@ import (
"errors"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/stretchr/testify/require"
)
// Hello! This file is auto-generated.
func TestRoleSetWalk(t *testing.T) {
value := make(RoleSet, 3)
var (
value = make(RoleSet, 3)
req = require.New(t)
)
// 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)
req.NoError(err)
}
// check walk with error
test.Error(t, value.Walk(func(*Role) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
req.Error(value.Walk(func(*Role) error { return errors.New("walk error") }))
}
func TestRoleSetFilter(t *testing.T) {
value := make(RoleSet, 3)
var (
value = make(RoleSet, 3)
req = require.New(t)
)
// 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))
req.NoError(err)
req.Equal(len(set), len(value))
}
// filter one item
@@ -47,21 +54,25 @@ func TestRoleSetFilter(t *testing.T) {
}
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))
req.NoError(err)
req.Len(set, 1)
}
// filter error
{
_, err := value.Filter(func(*Role) (bool, error) {
return false, errors.New("Filter error")
return false, errors.New("filter error")
})
test.Error(t, err, "Expected error, got %#v", err)
req.Error(err)
}
}
func TestRoleSetIDs(t *testing.T) {
value := make(RoleSet, 3)
var (
value = make(RoleSet, 3)
req = require.New(t)
)
// construct objects
value[0] = new(Role)
value[1] = new(Role)
@@ -74,18 +85,18 @@ func TestRoleSetIDs(t *testing.T) {
// Find existing
{
val := value.FindByID(2)
test.Assert(t, val.ID == 2, "Expected ID 2, got %d", val.ID)
req.Equal(uint64(2), val.ID)
}
// Find non-existing
{
val := value.FindByID(4)
test.Assert(t, val == nil, "Expected no value, got %#v", val)
req.Nil(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))
req.Equal(len(val), len(value))
}
}

41
system/types/user.gen_test.go
View File

@@ -5,36 +5,43 @@ import (
"errors"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/stretchr/testify/require"
)
// Hello! This file is auto-generated.
func TestUserSetWalk(t *testing.T) {
value := make(UserSet, 3)
var (
value = make(UserSet, 3)
req = require.New(t)
)
// 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)
req.NoError(err)
}
// check walk with error
test.Error(t, value.Walk(func(*User) error { return errors.New("Walk error") }), "Expected error from walk, got nil")
req.Error(value.Walk(func(*User) error { return errors.New("walk error") }))
}
func TestUserSetFilter(t *testing.T) {
value := make(UserSet, 3)
var (
value = make(UserSet, 3)
req = require.New(t)
)
// 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))
req.NoError(err)
req.Equal(len(set), len(value))
}
// filter one item
@@ -47,21 +54,25 @@ func TestUserSetFilter(t *testing.T) {
}
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))
req.NoError(err)
req.Len(set, 1)
}
// filter error
{
_, err := value.Filter(func(*User) (bool, error) {
return false, errors.New("Filter error")
return false, errors.New("filter error")
})
test.Error(t, err, "Expected error, got %#v", err)
req.Error(err)
}
}
func TestUserSetIDs(t *testing.T) {
value := make(UserSet, 3)
var (
value = make(UserSet, 3)
req = require.New(t)
)
// construct objects
value[0] = new(User)
value[1] = new(User)
@@ -74,18 +85,18 @@ func TestUserSetIDs(t *testing.T) {
// Find existing
{
val := value.FindByID(2)
test.Assert(t, val.ID == 2, "Expected ID 2, got %d", val.ID)
req.Equal(uint64(2), val.ID)
}
// Find non-existing
{
val := value.FindByID(4)
test.Assert(t, val == nil, "Expected no value, got %#v", val)
req.Nil(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))
req.Equal(len(val), len(value))
}
}