DeforaNetworks/corteza
3
0
Fork 0
Code Activity

fix(crm): import fixed tests

Browse Source
This commit is contained in:
Tit Petric
2019-04-03 14:05:13 +02:00
parent 0c1bfbf2f7
commit 9b4adceaaa
13 changed files with 269 additions and 194 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
crm/internal/repository/main_test.go
View File

@@ -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
}

2
crm/internal/repository/ql/ast_parser_test.go
View File

@@ -1,3 +1,5 @@
// +build unit
package ql
import (

2
crm/internal/repository/ql/lexer_test.go
View File

@@ -1,3 +1,5 @@
// +build unit
package ql
import (

2
crm/internal/repository/record_report_builder_test.go
View File

@@ -1,3 +1,5 @@
// +build unit
package repository
import (

14
crm/internal/repository/record_test.go
View File

@@ -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)
}
}
*/

20
crm/internal/repository/repository_test.go
View File

@@ -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)
}

2
crm/internal/service/chart_test.go
View File

@@ -1,3 +1,5 @@
// +build unit
package service
import (

26
crm/internal/service/main_test.go
View File

@@ -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
}

73
crm/internal/service/module_test.go
View File

@@ -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)
}
}
}

79
crm/internal/service/page_test.go
View File

@@ -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)
}
}

31
crm/internal/service/permissions_test.go
View File

@@ -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)

141
crm/internal/service/record_test.go
View File

@@ -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))
}
}
}

59
crm/internal/service/trigger_test.go
View File

@@ -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)
}
}