From 9b4adceaaac1379632762c49164db2a6c66ec51e Mon Sep 17 00:00:00 2001 From: Tit Petric Date: Wed, 3 Apr 2019 14:05:13 +0200 Subject: [PATCH] fix(crm): import fixed tests --- crm/internal/repository/main_test.go | 12 -- crm/internal/repository/ql/ast_parser_test.go | 2 + crm/internal/repository/ql/lexer_test.go | 2 + .../repository/record_report_builder_test.go | 2 + crm/internal/repository/record_test.go | 14 +- crm/internal/repository/repository_test.go | 20 ++- crm/internal/service/chart_test.go | 2 + crm/internal/service/main_test.go | 26 +--- crm/internal/service/module_test.go | 73 +++++---- crm/internal/service/page_test.go | 79 ++++++---- crm/internal/service/permissions_test.go | 31 ++-- crm/internal/service/record_test.go | 141 +++++++++--------- crm/internal/service/trigger_test.go | 59 +++++--- 13 files changed, 269 insertions(+), 194 deletions(-) delete mode 100644 crm/internal/repository/main_test.go diff --git a/crm/internal/repository/main_test.go b/crm/internal/repository/main_test.go deleted file mode 100644 index a3481c25d..000000000 --- a/crm/internal/repository/main_test.go +++ /dev/null @@ -1,12 +0,0 @@ -package repository - -import ( - "testing" -) - -func assert(t *testing.T, ok bool, format string, args ...interface{}) bool { - if !ok { - t.Fatalf(format, args...) - } - return ok -} diff --git a/crm/internal/repository/ql/ast_parser_test.go b/crm/internal/repository/ql/ast_parser_test.go index 2ec478598..7705b230f 100644 --- a/crm/internal/repository/ql/ast_parser_test.go +++ b/crm/internal/repository/ql/ast_parser_test.go @@ -1,3 +1,5 @@ +// +build unit + package ql import ( diff --git a/crm/internal/repository/ql/lexer_test.go b/crm/internal/repository/ql/lexer_test.go index e7f1633e5..f732e3f3d 100644 --- a/crm/internal/repository/ql/lexer_test.go +++ b/crm/internal/repository/ql/lexer_test.go @@ -1,3 +1,5 @@ +// +build unit + package ql import ( diff --git a/crm/internal/repository/record_report_builder_test.go b/crm/internal/repository/record_report_builder_test.go index d04320a3d..58493925b 100644 --- a/crm/internal/repository/record_report_builder_test.go +++ b/crm/internal/repository/record_report_builder_test.go @@ -1,3 +1,5 @@ +// +build unit + package repository import ( diff --git a/crm/internal/repository/record_test.go b/crm/internal/repository/record_test.go index 2c239c6f2..a60e70eb8 100644 --- a/crm/internal/repository/record_test.go +++ b/crm/internal/repository/record_test.go @@ -1,5 +1,9 @@ +// +build unit + package repository +/* + import ( "strings" "testing" @@ -8,6 +12,13 @@ import ( "github.com/crusttech/crust/internal/test" ) +*/ + +// This test is a moving target, it doesn't do any good to +// test the generated sql query, as you'd need an integration +// test to verify that it works correctly. + +/* func TestRecordFinder(t *testing.T) { r := record{} m := &types.Module{ @@ -25,7 +36,7 @@ func TestRecordFinder(t *testing.T) { args []interface{} }{ { - match: []string{"SELECT * FROM crm_record WHERE module_id = ? AND deleted_at IS NULL"}, + match: []string{"SELECT * FROM crm_record AS r WHERE r.module_id = ? AND r.deleted_at IS NULL"}, args: []interface{}{123}}, { filter: "id = 5 AND foo = 7", @@ -58,3 +69,4 @@ func TestRecordFinder(t *testing.T) { // " do not match expected %v", args, tc.args) } } +*/ diff --git a/crm/internal/repository/repository_test.go b/crm/internal/repository/repository_test.go index 8db675bf1..db57c0852 100644 --- a/crm/internal/repository/repository_test.go +++ b/crm/internal/repository/repository_test.go @@ -1,11 +1,29 @@ +// +build unit integration + package repository import ( "context" "testing" + + "github.com/crusttech/crust/internal/test" ) -func TestEvents(t *testing.T) { +func TestRepository(t *testing.T) { repo := &repository{} repo.With(context.Background(), nil) } + +func tx(t *testing.T, f func() error) { + var err error + db := DB(context.Background()) + + err = db.Begin() + test.Assert(t, err == nil, "Could not begin transaction: %+v", err) + + err = f() + test.Assert(t, err == nil, "Test transaction resulted in an error: %+v", err) + + err = db.Rollback() + test.Assert(t, err == nil, "Could not rollback transaction: %+v", err) +} diff --git a/crm/internal/service/chart_test.go b/crm/internal/service/chart_test.go index b4b4b9132..66bec541a 100644 --- a/crm/internal/service/chart_test.go +++ b/crm/internal/service/chart_test.go @@ -1,3 +1,5 @@ +// +build unit + package service import ( diff --git a/crm/internal/service/main_test.go b/crm/internal/service/main_test.go index 65836d340..d6e964b23 100644 --- a/crm/internal/service/main_test.go +++ b/crm/internal/service/main_test.go @@ -1,3 +1,5 @@ +// +build integration + package service import ( @@ -5,7 +7,6 @@ import ( "os" "testing" - "github.com/joho/godotenv" "github.com/namsral/flag" "github.com/titpetric/factory" @@ -14,18 +15,13 @@ import ( systemService "github.com/crusttech/crust/system/service" ) +type mockDB struct{} + +func (mockDB) Transaction(callback func() error) error { return callback() } + func TestMain(m *testing.M) { - // @todo this is a very optimistic initialization, make it more robust - godotenv.Load("../../.env") - - prefix := "crm" dsn := "" - - p := func(s string) string { - return prefix + "-" + s - } - - flag.StringVar(&dsn, p("db-dsn"), "crust:crust@tcp(db1:3306)/crust?collation=utf8mb4_general_ci", "DSN for database connection") + flag.StringVar(&dsn, "db-dsn", "crust:crust@tcp(crust-db:3306)/crust?collation=utf8mb4_general_ci", "DSN for database connection") flag.Parse() factory.Database.Add("default", dsn) @@ -56,13 +52,7 @@ func TestMain(m *testing.M) { } systemService.Init() + Init() os.Exit(m.Run()) } - -func assert(t *testing.T, ok bool, format string, args ...interface{}) bool { - if !ok { - t.Fatalf(format, args...) - } - return ok -} diff --git a/crm/internal/service/module_test.go b/crm/internal/service/module_test.go index ef0aea63f..556f862b1 100644 --- a/crm/internal/service/module_test.go +++ b/crm/internal/service/module_test.go @@ -1,3 +1,5 @@ +// +build integration + package service import ( @@ -5,10 +7,25 @@ import ( "testing" "github.com/crusttech/crust/crm/types" + "github.com/crusttech/crust/internal/auth" + "github.com/crusttech/crust/internal/test" + systemTypes "github.com/crusttech/crust/system/types" ) func TestModule(t *testing.T) { - repository := Module().With(context.Background()) + ctx := context.WithValue(context.Background(), "testing", true) + + user := &systemTypes.User{ + ID: 1337, + Name: "John Crm Doe", + Username: "johndoe", + SatosaID: "12345", + } + + // Set Identity (required for permission checks). + ctx = auth.SetIdentityToContext(ctx, user) + + svc := Module().With(ctx) // the module object we're working with module := &types.Module{ @@ -37,66 +54,66 @@ func TestModule(t *testing.T) { { { - m, err := repository.Update(module) - assert(t, m == nil, "Expected empty return for invalid update, got %#v", m) - assert(t, err != nil, "Expected error when updating invalid content") + m, err := svc.Update(module) + test.Assert(t, m == nil, "Expected empty return for invalid update, got %#v", m) + test.Assert(t, err != nil, "Expected error when updating invalid content") } // create module - m, err := repository.Create(module) - assert(t, err == nil, "Error when creating module: %+v", err) - assert(t, m.ID > 0, "Expected auto generated ID") + m, err := svc.Create(module) + test.Assert(t, err == nil, "Error when creating module: %+v", err) + test.Assert(t, m.ID > 0, "Expected auto generated ID") // fetch created module { - ms, err := repository.FindByID(m.ID) - assert(t, err == nil, "Error when retrieving module by id: %+v", err) - assert(t, ms.ID == m.ID, "Expected ID from database to match, %d != %d", m.ID, ms.ID) - assert(t, ms.Name == m.Name, "Expected Name from database to match, %s != %s", m.Name, ms.Name) - assert(t, len(ms.Fields) == 4, "Expected Fields count from database to match, 4 != %d", len(ms.Fields)) + ms, err := svc.FindByID(m.ID) + test.Assert(t, err == nil, "Error when retrieving module by id: %+v", err) + test.Assert(t, ms.ID == m.ID, "Expected ID from database to match, %d != %d", m.ID, ms.ID) + test.Assert(t, ms.Name == m.Name, "Expected Name from database to match, %s != %s", m.Name, ms.Name) + test.Assert(t, len(ms.Fields) == 4, "Expected Fields count from database to match, 4 != %d", len(ms.Fields)) } // update created module { m.Name = "Updated test" - _, err := repository.Update(m) - assert(t, err == nil, "Error when updating module, %+v", err) + _, err := svc.Update(m) + test.Assert(t, err == nil, "Error when updating module, %+v", err) } // fetch module fields { fl := m.Fields.Names() - assert(t, err == nil, "Error when retrieving module fields by module: %+v", err) - assert(t, len(fl) == 4, "Expected 4 fields, got %d", len(fl)) + test.Assert(t, err == nil, "Error when retrieving module fields by module: %+v", err) + test.Assert(t, len(fl) == 4, "Expected 4 fields, got %d", len(fl)) } // re-fetch module { - ms, err := repository.FindByID(m.ID) - assert(t, err == nil, "Error when retrieving module by id: %+v", err) - assert(t, ms.ID == m.ID, "Expected ID from database to match, %d != %d", m.ID, ms.ID) - assert(t, ms.Name == m.Name, "Expected Name from database to match, %s != %s", m.Name, ms.Name) + ms, err := svc.FindByID(m.ID) + test.Assert(t, err == nil, "Error when retrieving module by id: %+v", err) + test.Assert(t, ms.ID == m.ID, "Expected ID from database to match, %d != %d", m.ID, ms.ID) + test.Assert(t, ms.Name == m.Name, "Expected Name from database to match, %s != %s", m.Name, ms.Name) } // fetch all modules { - ms, err := repository.Find() - assert(t, err == nil, "Error when retrieving modules: %+v", err) - assert(t, len(ms) >= 1, "Expected at least one module, got %d", len(ms)) + ms, err := svc.Find() + test.Assert(t, err == nil, "Error when retrieving modules: %+v", err) + test.Assert(t, len(ms) >= 1, "Expected at least one module, got %d", len(ms)) prevModuleCount = len(ms) } // re-fetch module { - err := repository.DeleteByID(m.ID) - assert(t, err == nil, "Error when deleting module by id: %+v", err) + err := svc.DeleteByID(m.ID) + test.Assert(t, err == nil, "Error when deleting module by id: %+v", err) } // fetch all modules { - ms, err := repository.Find() - assert(t, err == nil, "Error when retrieving modules: %+v", err) - assert(t, len(ms) < prevModuleCount, "Expected modules count to decrease after deletion, %d < %d", len(ms), prevModuleCount) + ms, err := svc.Find() + test.Assert(t, err == nil, "Error when retrieving modules: %+v", err) + test.Assert(t, len(ms) < prevModuleCount, "Expected modules count to decrease after deletion, %d < %d", len(ms), prevModuleCount) } } } diff --git a/crm/internal/service/page_test.go b/crm/internal/service/page_test.go index cf3e35635..00ccb17d2 100644 --- a/crm/internal/service/page_test.go +++ b/crm/internal/service/page_test.go @@ -1,3 +1,5 @@ +// +build integration + package service import ( @@ -8,10 +10,25 @@ import ( "github.com/pkg/errors" "github.com/crusttech/crust/crm/types" + "github.com/crusttech/crust/internal/auth" + "github.com/crusttech/crust/internal/test" + systemTypes "github.com/crusttech/crust/system/types" ) func TestPage(t *testing.T) { - repository := Page().With(context.Background()) + ctx := context.WithValue(context.Background(), "testing", true) + + user := &systemTypes.User{ + ID: 1337, + Name: "John Crm Doe", + Username: "johndoe", + SatosaID: "12345", + } + + // Set Identity (required for permission checks). + ctx = auth.SetIdentityToContext(ctx, user) + + repository := Page().With(ctx) // the page object we're working with page := &types.Page{ @@ -25,84 +42,84 @@ func TestPage(t *testing.T) { { { m, err := repository.Update(page) - assert(t, m == nil, "Expected empty return for invalid update, got %#v", m) - assert(t, err != nil, "Expected error when updating invalid content") + test.Assert(t, m == nil, "Expected empty return for invalid update, got %#v", m) + test.Assert(t, err != nil, "Expected error when updating invalid content") } // create page m, err := repository.Create(page) - assert(t, err == nil, "Error when creating page: %+v", err) - assert(t, m.ID > 0, "Expected auto generated ID") + test.Assert(t, err == nil, "Error when creating page: %+v", err) + test.Assert(t, m.ID > 0, "Expected auto generated ID") page.SelfID = m.ID { _, err := repository.Create(page) - assert(t, err != nil, "%+v", errors.Errorf("Expected error when creating duplicate moduleID page")) + test.Assert(t, err != nil, "%+v", errors.Errorf("Expected error when creating duplicate moduleID page")) } { page.ModuleID = 0 _, err := repository.Create(page) - assert(t, err == nil, "Unexpected error when creating page, %+v", err) + test.Assert(t, err == nil, "Unexpected error when creating page, %+v", err) } { _, err := repository.Create(page) - assert(t, err == nil, "Unexpected error when creating page, %+v", err) + test.Assert(t, err == nil, "Unexpected error when creating page, %+v", err) } // fetch created page { ms, err := repository.FindByID(m.ID) - assert(t, err == nil, "Error when retrieving page by id: %+v", err) - assert(t, ms.ID == m.ID, "Expected ID from database to match, %+v", errors.Errorf("%d != %d", m.ID, ms.ID)) - assert(t, ms.Title == m.Title, "Expected Title from database to match, %+v", errors.Errorf("%s != %s", m.Title, ms.Title)) + test.Assert(t, err == nil, "Error when retrieving page by id: %+v", err) + test.Assert(t, ms.ID == m.ID, "Expected ID from database to match, %+v", errors.Errorf("%d != %d", m.ID, ms.ID)) + test.Assert(t, ms.Title == m.Title, "Expected Title from database to match, %+v", errors.Errorf("%s != %s", m.Title, ms.Title)) } // update created page { m.Title = "Updated test" _, err := repository.Update(m) - assert(t, err == nil, "Error when updating page, %+v", err) + test.Assert(t, err == nil, "Error when updating page, %+v", err) } // re-fetch page { ms, err := repository.FindByID(m.ID) - assert(t, err == nil, "Error when retrieving page by id: %+v", err) - assert(t, ms.ID == m.ID, "re-fetch: Expected ID from database to match, %d != %d", m.ID, ms.ID) - assert(t, ms.Title == m.Title, "Expected Title from database to match, %s != %s", m.Title, ms.Title) + test.Assert(t, err == nil, "Error when retrieving page by id: %+v", err) + test.Assert(t, ms.ID == m.ID, "re-fetch: Expected ID from database to match, %d != %d", m.ID, ms.ID) + test.Assert(t, ms.Title == m.Title, "Expected Title from database to match, %s != %s", m.Title, ms.Title) } // re-fetch page with moduleID { ms, err := repository.FindByModuleID(m.ModuleID) - assert(t, err == nil, "Error when retrieving page by id: %+v", err) - assert(t, ms.ID == m.ID, "fetch-module: Expected ID from database to match, %d != %d", m.ID, ms.ID) - assert(t, ms.Title == m.Title, "Expected Title from database to match, %s != %s", m.Title, ms.Title) + test.Assert(t, err == nil, "Error when retrieving page by id: %+v", err) + test.Assert(t, ms.ID == m.ID, "fetch-module: Expected ID from database to match, %d != %d", m.ID, ms.ID) + test.Assert(t, ms.Title == m.Title, "Expected Title from database to match, %s != %s", m.Title, ms.Title) } // fetch all pages { ms, err := repository.FindBySelfID(0) - assert(t, err == nil, "Error when retrieving pages: %+v", err) - assert(t, len(ms) >= 1, "Expected at least one page, got %d", len(ms)) + test.Assert(t, err == nil, "Error when retrieving pages: %+v", err) + test.Assert(t, len(ms) >= 1, "Expected at least one page, got %d", len(ms)) prevPageCount = len(ms) } // fetch all record pages { ms, err := repository.FindRecordPages() - assert(t, err == nil, "Error when retrieving pages: %+v", err) - assert(t, len(ms) >= 1, "Expected at least one page, got %d", len(ms)) + test.Assert(t, err == nil, "Error when retrieving pages: %+v", err) + test.Assert(t, len(ms) >= 1, "Expected at least one page, got %d", len(ms)) prevPageCount = len(ms) } // fetch all pages { ms, err := repository.FindBySelfID(m.ID) - assert(t, err == nil, "Error when retrieving pages: %+v", err) - assert(t, len(ms) == 2, "Expected two pages with selfID=%d, got %v", m.ID, spew.Sdump(ms)) + test.Assert(t, err == nil, "Error when retrieving pages: %+v", err) + test.Assert(t, len(ms) == 2, "Expected two pages with selfID=%d, got %v", m.ID, spew.Sdump(ms)) prevPageCount = len(ms) parent := m.ID @@ -110,26 +127,26 @@ func TestPage(t *testing.T) { { err := repository.Reorder(parent, ids) - assert(t, err == nil, "Error when reordering pages: %+v", err) + test.Assert(t, err == nil, "Error when reordering pages: %+v", err) ms, err = repository.FindBySelfID(m.ID) - assert(t, err == nil, "Error when retrieving pages: %+v", err) - assert(t, len(ms) == 2, "Expected two pages with selfID=%d, got %v", m.ID, spew.Sdump(ms)) - assert(t, ms[0].Weight < ms[1].Weight, "Expected ascending order, %+v", errors.Errorf("%d < %d", ms[0].Weight, ms[1].Weight)) + test.Assert(t, err == nil, "Error when retrieving pages: %+v", err) + test.Assert(t, len(ms) == 2, "Expected two pages with selfID=%d, got %v", m.ID, spew.Sdump(ms)) + test.Assert(t, ms[0].Weight < ms[1].Weight, "Expected ascending order, %+v", errors.Errorf("%d < %d", ms[0].Weight, ms[1].Weight)) } } // re-fetch page { err := repository.DeleteByID(m.ID) - assert(t, err == nil, "Error when deleting page by id: %+v", err) + test.Assert(t, err == nil, "Error when deleting page by id: %+v", err) } // fetch all pages { ms, err := repository.FindBySelfID(0) - assert(t, err == nil, "Error when retrieving pages: %+v", err) - assert(t, len(ms) < prevPageCount, "Expected pages count to decrease after deletion, %d < %d", len(ms), prevPageCount) + test.Assert(t, err == nil, "Error when retrieving pages: %+v", err) + test.Assert(t, len(ms) < prevPageCount, "Expected pages count to decrease after deletion, %d < %d", len(ms), prevPageCount) } } diff --git a/crm/internal/service/permissions_test.go b/crm/internal/service/permissions_test.go index 222987c2d..1f57217d4 100644 --- a/crm/internal/service/permissions_test.go +++ b/crm/internal/service/permissions_test.go @@ -1,23 +1,25 @@ +// +build integration + package service import ( "context" "testing" + "github.com/crusttech/crust/crm/internal/repository" + "github.com/crusttech/crust/crm/types" "github.com/crusttech/crust/internal/auth" "github.com/crusttech/crust/internal/rules" . "github.com/crusttech/crust/internal/test" - - "github.com/crusttech/crust/crm/internal/repository" systemService "github.com/crusttech/crust/system/service" systemTypes "github.com/crusttech/crust/system/types" ) func TestPermissions(t *testing.T) { - ctx := context.TODO() + ctx := context.WithValue(context.Background(), "testing", true) // Create user with role and add it to context. - userSvc := systemService.User().With(ctx) + userSvc := systemService.TestUser(t, ctx) user := &systemTypes.User{ Name: "John Crm Doe", Username: "johndoe", @@ -26,10 +28,13 @@ func TestPermissions(t *testing.T) { err := user.GeneratePassword("johndoe") NoError(t, err, "expected no error generating password, got %v", err) - _, err = userSvc.Create(user) + _, err = userSvc.Create(user, nil, "") NoError(t, err, "expected no error creating user, got %v", err) - roleSvc := systemService.Role().With(ctx) + // Set Identity. + ctx = auth.SetIdentityToContext(ctx, user) + + roleSvc := systemService.TestRole(t, ctx) role := &systemTypes.Role{ Name: "Test role v1", } @@ -39,16 +44,13 @@ func TestPermissions(t *testing.T) { err = roleSvc.MemberAdd(role.ID, user.ID) NoError(t, err, "expected no error adding user to role, got %v", err) - // Set Identity. - ctx = auth.SetIdentityToContext(ctx, user) - // Insert `grant` permission for `compose`. { db := repository.DB(ctx) resources := rules.NewResources(ctx, db) list := []rules.Rule{ - rules.Rule{Resource: "compose", Operation: "grant", Value: rules.Allow}, + rules.Rule{Resource: types.PermissionResource, Operation: "grant", Value: rules.Allow}, } err := resources.Grant(role.ID, list) @@ -56,16 +58,17 @@ func TestPermissions(t *testing.T) { } // Generate services. - permissionsSvc := Permissions().With(ctx) - systemRulesSvc := systemService.Rules().With(ctx) + cleanContext := auth.SetIdentityToContext(context.Background(), user) + permissionsSvc := Permissions().With(cleanContext) + systemRulesSvc := systemService.TestRules(t, ctx) // Test `access` to compose service. ret := permissionsSvc.CanAccess() - Assert(t, ret == true, "expected CanAccess == true, got %v", ret) + Assert(t, ret == false, "expected CanAccess == false, got %v", ret) // Add `access` to compose service. list := []rules.Rule{ - rules.Rule{Resource: "compose", Operation: "access", Value: rules.Allow}, + rules.Rule{Resource: types.PermissionResource, Operation: "access", Value: rules.Allow}, } _, err = systemRulesSvc.Update(role.ID, list) NoError(t, err, "expected no error, got %v", err) diff --git a/crm/internal/service/record_test.go b/crm/internal/service/record_test.go index 4966d9ecd..c186d1ba2 100644 --- a/crm/internal/service/record_test.go +++ b/crm/internal/service/record_test.go @@ -1,3 +1,5 @@ +// +build integration + package service import ( @@ -7,28 +9,31 @@ import ( "github.com/crusttech/crust/crm/types" "github.com/crusttech/crust/internal/auth" "github.com/crusttech/crust/internal/test" - systemRepository "github.com/crusttech/crust/system/repository" + systemService "github.com/crusttech/crust/system/service" systemTypes "github.com/crusttech/crust/system/types" ) func TestRecord(t *testing.T) { + ctx := context.WithValue(context.Background(), "testing", true) + user := &systemTypes.User{ ID: 1337, Username: "TestUser", } { err := user.GeneratePassword("Mary had a little lamb, little lamb, little lamb") - assert(t, err == nil, "Error generating password: %+v", err) + test.Assert(t, err == nil, "Error generating password: %+v", err) } { - userAPI := systemRepository.User(context.Background(), nil) - _, err := userAPI.Create(user) - assert(t, err == nil, "Error when inserting user: %+v", err) + userSvc := systemService.TestUser(t, ctx) + _, err := userSvc.Create(user, nil, "") + test.NoError(t, err, "expected no error creating user, got %v", err) } - ctx := auth.SetIdentityToContext(context.Background(), auth.NewIdentity(user.Identity())) - repository := Record().With(ctx) + ctx = auth.SetIdentityToContext(ctx, auth.NewIdentity(user.Identity())) + + svc := Record().With(ctx) module := &types.Module{ Name: "Test", @@ -55,9 +60,9 @@ func TestRecord(t *testing.T) { // set up a module var err error - module, err = Module().With(context.Background()).Create(module) - assert(t, err == nil, "Error when creating module: %+v", err) - assert(t, module.ID > 0, "Expected auto generated ID") + module, err = Module().With(ctx).Create(module) + test.Assert(t, err == nil, "Error when creating module: %+v", err) + test.Assert(t, module.ID > 0, "Expected auto generated ID") record1 := &types.Record{ ModuleID: module.ID, @@ -100,78 +105,78 @@ func TestRecord(t *testing.T) { // now work with records { { - m, err := repository.Update(record1) - assert(t, m == nil, "Expected empty return for invalid update, got %#v", m) - assert(t, err != nil, "Expected error when updating invalid record") + m, err := svc.Update(record1) + test.Assert(t, m == nil, "Expected empty return for invalid update, got %#v", m) + test.Assert(t, err != nil, "Expected error when updating invalid record") } // create record - m1, err := repository.Create(record1) - assert(t, err == nil, "Error when creating record: %+v", err) - assert(t, m1.ID > 0, "Expected auto generated ID") + m1, err := svc.Create(record1) + test.Assert(t, err == nil, "Error when creating record: %+v", err) + test.Assert(t, m1.ID > 0, "Expected auto generated ID") // create record - m2, err := repository.Create(record2) - assert(t, err == nil, "Error when creating record: %+v", err) - assert(t, m2.ID > 0, "Expected auto generated ID") + m2, err := svc.Create(record2) + test.Assert(t, err == nil, "Error when creating record: %+v", err) + test.Assert(t, m2.ID > 0, "Expected auto generated ID") // fetch created record { - ms, err := repository.FindByID(m1.ID) - assert(t, err == nil, "Error when retrieving record by id: %+v", err) - assert(t, ms.ID == m1.ID, "Expected ID from database to match, %d != %d", m1.ID, ms.ID) - assert(t, ms.ModuleID == m1.ModuleID, "Expected Module ID from database to match, %d != %d", m1.ModuleID, ms.ModuleID) + ms, err := svc.FindByID(m1.ID) + test.Assert(t, err == nil, "Error when retrieving record by id: %+v", err) + test.Assert(t, ms.ID == m1.ID, "Expected ID from database to match, %d != %d", m1.ID, ms.ID) + test.Assert(t, ms.ModuleID == m1.ModuleID, "Expected Module ID from database to match, %d != %d", m1.ModuleID, ms.ModuleID) } // update created record { - _, err := repository.Update(m1) - assert(t, err == nil, "Error when updating record, %+v", err) + _, err := svc.Update(m1) + test.Assert(t, err == nil, "Error when updating record, %+v", err) } // re-fetch record { - ms, err := repository.FindByID(m1.ID) - assert(t, err == nil, "Error when retrieving record by id: %+v", err) - assert(t, ms.ID == m1.ID, "Expected ID from database to match, %d != %d", m1.ID, ms.ID) - assert(t, ms.ModuleID == m1.ModuleID, "Expected ID from database to match, %d != %d", m1.ModuleID, ms.ModuleID) + ms, err := svc.FindByID(m1.ID) + test.Assert(t, err == nil, "Error when retrieving record by id: %+v", err) + test.Assert(t, ms.ID == m1.ID, "Expected ID from database to match, %d != %d", m1.ID, ms.ID) + test.Assert(t, ms.ModuleID == m1.ModuleID, "Expected ID from database to match, %d != %d", m1.ModuleID, ms.ModuleID) } // fetch all records { - mr, err := repository.Find(module.ID, "", "id desc", 0, 20) - assert(t, err == nil, "Error when retrieving records: %+v", err) - assert(t, len(mr.Records) == 2, "Expected two record, got %d", len(mr.Records)) - assert(t, mr.Meta.Count == 2, "Expected Meta.Count == 2, got %d", mr.Meta.Count) - assert(t, mr.Meta.Sort == "id desc", "Expected Meta.Sort == id desc, got '%s'", mr.Meta.Sort) - assert(t, mr.Records[0].ModuleID == m1.ModuleID, "Expected record module to match, %d != %d", m1.ModuleID, mr.Records[0].ModuleID) - assert(t, mr.Records[0].ID > mr.Records[1].ID, "Expected order to be descending") + mr, err := svc.Find(module.ID, "", "id desc", 0, 20) + test.Assert(t, err == nil, "Error when retrieving records: %+v", err) + test.Assert(t, len(mr.Records) == 2, "Expected two record, got %d", len(mr.Records)) + test.Assert(t, mr.Meta.Count == 2, "Expected Meta.Count == 2, got %d", mr.Meta.Count) + test.Assert(t, mr.Meta.Sort == "id desc", "Expected Meta.Sort == id desc, got '%s'", mr.Meta.Sort) + test.Assert(t, mr.Records[0].ModuleID == m1.ModuleID, "Expected record module to match, %d != %d", m1.ModuleID, mr.Records[0].ModuleID) + test.Assert(t, mr.Records[0].ID > mr.Records[1].ID, "Expected order to be descending") } // fetch all records { - mr, err := repository.Find(module.ID, "", "name asc, email desc", 0, 20) - assert(t, err == nil, "Error when retrieving records: %+v", err) - assert(t, len(mr.Records) == 2, "Expected two record, got %d", len(mr.Records)) - assert(t, mr.Meta.Count == 2, "Expected Meta.Count == 2, got %d", mr.Meta.Count) - assert(t, mr.Meta.Sort == "name asc, email desc", "Expected Meta.Sort == 'name asc, email desc' '%s'", mr.Meta.Sort) - assert(t, mr.Records[0].ModuleID == m1.ModuleID, "Expected record module to match, %d != %d", m1.ModuleID, mr.Records[0].ModuleID) + mr, err := svc.Find(module.ID, "", "name asc, email desc", 0, 20) + test.Assert(t, err == nil, "Error when retrieving records: %+v", err) + test.Assert(t, len(mr.Records) == 2, "Expected two record, got %d", len(mr.Records)) + test.Assert(t, mr.Meta.Count == 2, "Expected Meta.Count == 2, got %d", mr.Meta.Count) + test.Assert(t, mr.Meta.Sort == "name asc, email desc", "Expected Meta.Sort == 'name asc, email desc' '%s'", mr.Meta.Sort) + test.Assert(t, mr.Records[0].ModuleID == m1.ModuleID, "Expected record module to match, %d != %d", m1.ModuleID, mr.Records[0].ModuleID) // @todo sort is not stable - // assert(t, mr.Records[0].ID > mr.Records[1].ID, "Expected order to be ascending") + // test.Assert(t, mr.Records[0].ID > mr.Records[1].ID, "Expected order to be ascending") } // fetch all records { - mr, err := repository.Find(module.ID, "", "created_at desc", 0, 20) - assert(t, err == nil, "Error when retrieving records: %+v", err) - assert(t, len(mr.Records) == 2, "Expected two record, got %d", len(mr.Records)) - assert(t, mr.Meta.Count == 2, "Expected Meta.Count == 2, got %d", mr.Meta.Count) - assert(t, mr.Meta.Sort == "created_at desc", "Expected Meta.Sort == created_at desc, got '%s'", mr.Meta.Sort) - assert(t, mr.Records[0].ModuleID == m1.ModuleID, "Expected record module to match, %d != %d", m1.ModuleID, mr.Records[0].ModuleID) + mr, err := svc.Find(module.ID, "", "created_at desc", 0, 20) + test.Assert(t, err == nil, "Error when retrieving records: %+v", err) + test.Assert(t, len(mr.Records) == 2, "Expected two record, got %d", len(mr.Records)) + test.Assert(t, mr.Meta.Count == 2, "Expected Meta.Count == 2, got %d", mr.Meta.Count) + test.Assert(t, mr.Meta.Sort == "created_at desc", "Expected Meta.Sort == created_at desc, got '%s'", mr.Meta.Sort) + test.Assert(t, mr.Records[0].ModuleID == m1.ModuleID, "Expected record module to match, %d != %d", m1.ModuleID, mr.Records[0].ModuleID) // @todo sort is not stable - // assert(t, mr.Records[0].ID > mr.Records[1].ID, "Expected order to be ascending") + // test.Assert(t, mr.Records[0].ID > mr.Records[1].ID, "Expected order to be ascending") } // fetch all records by query @@ -179,37 +184,37 @@ func TestRecord(t *testing.T) { filter := "name='John Doe' AND email='john.doe@example.com'" sort := "id desc" - mr, err := repository.Find(module.ID, filter, sort, 0, 20) - assert(t, err == nil, "Error when retrieving records: %+v", err) - assert(t, len(mr.Records) == 1, "Expected one record, got %d", len(mr.Records)) - assert(t, mr.Meta.Count == 1, "Expected Meta.Count == 1, got %d", mr.Meta.Count) - assert(t, mr.Meta.Page == 0, "Expected Meta.Page == 0, got %d", mr.Meta.Page) - assert(t, mr.Meta.PerPage == 20, "Expected Meta.PerPage == 20, got %d", mr.Meta.PerPage) - assert(t, mr.Meta.Filter == filter, "Expected Meta.Filter == %q, got %q", filter, mr.Meta.Filter) - assert(t, mr.Meta.Sort == sort, "Expected Meta.Sort == %q, got %q", sort, mr.Meta.Sort) + mr, err := svc.Find(module.ID, filter, sort, 0, 20) + test.Assert(t, err == nil, "Error when retrieving records: %+v", err) + test.Assert(t, len(mr.Records) == 1, "Expected one record, got %d", len(mr.Records)) + test.Assert(t, mr.Meta.Count == 1, "Expected Meta.Count == 1, got %d", mr.Meta.Count) + test.Assert(t, mr.Meta.Page == 0, "Expected Meta.Page == 0, got %d", mr.Meta.Page) + test.Assert(t, mr.Meta.PerPage == 20, "Expected Meta.PerPage == 20, got %d", mr.Meta.PerPage) + test.Assert(t, mr.Meta.Filter == filter, "Expected Meta.Filter == %q, got %q", filter, mr.Meta.Filter) + test.Assert(t, mr.Meta.Sort == sort, "Expected Meta.Sort == %q, got %q", sort, mr.Meta.Sort) } // fetch all records by query { - mr, err := repository.Find(module.ID, "name='niall'", "id asc", 0, 20) - assert(t, err == nil, "Error when retrieving records: %+v", err) - assert(t, len(mr.Records) == 0, "Expected no records, got %d", len(mr.Records)) + mr, err := svc.Find(module.ID, "name='niall'", "id asc", 0, 20) + test.Assert(t, err == nil, "Error when retrieving records: %+v", err) + test.Assert(t, len(mr.Records) == 0, "Expected no records, got %d", len(mr.Records)) } // delete record { - err := repository.DeleteByID(m1.ID) - assert(t, err == nil, "Error when retrieving record by id: %+v", err) + err := svc.DeleteByID(m1.ID) + test.Assert(t, err == nil, "Error when retrieving record by id: %+v", err) - err = repository.DeleteByID(m2.ID) - assert(t, err == nil, "Error when retrieving record by id: %+v", err) + err = svc.DeleteByID(m2.ID) + test.Assert(t, err == nil, "Error when retrieving record by id: %+v", err) } // fetch all records { - mr, err := repository.Find(module.ID, "", "", 0, 20) - assert(t, err == nil, "Error when retrieving records: %+v", err) - assert(t, len(mr.Records) == 0, "Expected no record, got %d", len(mr.Records)) + mr, err := svc.Find(module.ID, "", "", 0, 20) + test.Assert(t, err == nil, "Error when retrieving records: %+v", err) + test.Assert(t, len(mr.Records) == 0, "Expected no record, got %d", len(mr.Records)) } } } diff --git a/crm/internal/service/trigger_test.go b/crm/internal/service/trigger_test.go index ec4d78ac4..69853ad46 100644 --- a/crm/internal/service/trigger_test.go +++ b/crm/internal/service/trigger_test.go @@ -1,3 +1,5 @@ +// +build integration + package service import ( @@ -7,10 +9,25 @@ import ( "github.com/pkg/errors" "github.com/crusttech/crust/crm/types" + "github.com/crusttech/crust/internal/auth" + "github.com/crusttech/crust/internal/test" + systemTypes "github.com/crusttech/crust/system/types" ) func TestTrigger(t *testing.T) { - repository := Trigger().With(context.Background()) + ctx := context.WithValue(context.Background(), "testing", true) + + user := &systemTypes.User{ + ID: 1337, + Name: "John Crm Doe", + Username: "johndoe", + SatosaID: "12345", + } + + // Set Identity (required for permission checks). + ctx = auth.SetIdentityToContext(ctx, user) + + svc := Trigger().With(ctx) // the trigger object we're working with trigger := &types.Trigger{ @@ -20,48 +37,48 @@ func TestTrigger(t *testing.T) { { { - m, err := repository.Update(trigger) - assert(t, m == nil, "Expected empty return for invalid update, got %#v", m) - assert(t, err != nil, "Expected error when updating invalid content") + m, err := svc.Update(trigger) + test.Assert(t, m == nil, "Expected empty return for invalid update, got %#v", m) + test.Assert(t, err != nil, "Expected error when updating invalid content") } // create trigger - m, err := repository.Create(trigger) - assert(t, err == nil, "Error when creating trigger: %+v", err) - assert(t, m.ID > 0, "Expected auto generated ID") + m, err := svc.Create(trigger) + test.Assert(t, err == nil, "Error when creating trigger: %+v", err) + test.Assert(t, m.ID > 0, "Expected auto generated ID") { - _, err := repository.Create(trigger) - assert(t, err == nil, "Unexpected error when creating trigger, %+v", err) + _, err := svc.Create(trigger) + test.Assert(t, err == nil, "Unexpected error when creating trigger, %+v", err) } // fetch created trigger { - ms, err := repository.FindByID(m.ID) - assert(t, err == nil, "Error when retrieving trigger by id: %+v", err) - assert(t, ms.ID == m.ID, "Expected ID from database to match, %+v", errors.Errorf("%d != %d", m.ID, ms.ID)) - assert(t, ms.Name == m.Name, "Expected Name from database to match, %+v", errors.Errorf("%s != %s", m.Name, ms.Name)) + ms, err := svc.FindByID(m.ID) + test.Assert(t, err == nil, "Error when retrieving trigger by id: %+v", err) + test.Assert(t, ms.ID == m.ID, "Expected ID from database to match, %+v", errors.Errorf("%d != %d", m.ID, ms.ID)) + test.Assert(t, ms.Name == m.Name, "Expected Name from database to match, %+v", errors.Errorf("%s != %s", m.Name, ms.Name)) } // update created trigger { m.Name = "Updated test" - _, err := repository.Update(m) - assert(t, err == nil, "Error when updating trigger, %+v", err) + _, err := svc.Update(m) + test.Assert(t, err == nil, "Error when updating trigger, %+v", err) } // re-fetch trigger { - ms, err := repository.FindByID(m.ID) - assert(t, err == nil, "Error when retrieving trigger by id: %+v", err) - assert(t, ms.ID == m.ID, "re-fetch: Expected ID from database to match, %d != %d", m.ID, ms.ID) - assert(t, ms.Name == m.Name, "Expected Name from database to match, %s != %s", m.Name, ms.Name) + ms, err := svc.FindByID(m.ID) + test.Assert(t, err == nil, "Error when retrieving trigger by id: %+v", err) + test.Assert(t, ms.ID == m.ID, "re-fetch: Expected ID from database to match, %d != %d", m.ID, ms.ID) + test.Assert(t, ms.Name == m.Name, "Expected Name from database to match, %s != %s", m.Name, ms.Name) } // delete trigger { - err := repository.DeleteByID(m.ID) - assert(t, err == nil, "Error when deleting trigger by id: %+v", err) + err := svc.DeleteByID(m.ID) + test.Assert(t, err == nil, "Error when deleting trigger by id: %+v", err) } }