DeforaNetworks/corteza
3
0
Fork 0
Code Activity

Remove old compose integ. tests

Browse Source
This commit is contained in:
Denis Arh
2019-09-11 08:26:16 +02:00
parent dbc83efcd5
commit 1ad15e77de
8 changed files with 4 additions and 776 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compose/db/migrate_test.go
-22
View File
@@ -1,22 +0,0 @@
// +build migrations
package db
import (
"os"
"testing"
"github.com/cortezaproject/corteza-server/pkg/logger"
"github.com/titpetric/factory"
dbLogger "github.com/titpetric/factory/logger"
)
func TestMigrations(t *testing.T) {
factory.Database.Add("compose", os.Getenv("COMPOSE_DB_DSN"))
db := factory.Database.MustGet("compose")
db.SetLogger(dbLogger.Default{})
if err := Migrate(db, logger.Default()); err != nil {
t.Fatalf("Unexpected error: %+v", err)
}
}
compose/service/chart_test.go
-80
View File
@@ -1,80 +0,0 @@
// +build integration
package service
import (
"context"
"testing"
"github.com/pkg/errors"
"github.com/cortezaproject/corteza-server/compose/types"
"github.com/cortezaproject/corteza-server/internal/auth"
"github.com/cortezaproject/corteza-server/internal/test"
)
func TestChart(t *testing.T) {
ctx := context.WithValue(context.Background(), "testing", true)
// Set Identity (required for permission checks).
ctx = auth.SetIdentityToContext(ctx, auth.NewIdentity(1337))
ns1, _ := createTestNamespaces(ctx, t)
svc := Chart().With(ctx)
// the chart object we're working with
chart := &types.Chart{
NamespaceID: ns1.ID,
Name: "Test",
}
{
{
m, err := svc.Update(chart)
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 chart
m, err := svc.Create(chart)
test.Assert(t, err == nil, "Error when creating chart: %+v", err)
test.Assert(t, m.ID > 0, "Expected auto generated ID")
{
_, err := svc.Create(chart)
test.Assert(t, err == nil, "Unexpected error when creating chart, %+v", err)
}
// fetch created chart
{
ms, err := svc.FindByID(m.NamespaceID, m.ID)
test.Assert(t, err == nil, "Error when retrieving chart 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 chart
{
m.UpdatedAt = nil
m.Name = "Updated test"
_, err := svc.Update(m)
test.Assert(t, err == nil, "Error when updating chart, %+v", err)
}
// re-fetch chart
{
ms, err := svc.FindByID(m.NamespaceID, m.ID)
test.Assert(t, err == nil, "Error when retrieving chart 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 chart
{
err := svc.DeleteByID(m.NamespaceID, m.ID)
test.Assert(t, err == nil, "Error when deleting chart by id: %+v", err)
}
}
}
compose/service/main_test.go
-88
View File
@@ -1,88 +0,0 @@
// +build integration
package service
import (
"context"
"fmt"
"os"
"testing"
"github.com/titpetric/factory"
"go.uber.org/zap"
composeMigrate "github.com/cortezaproject/corteza-server/compose/db"
"github.com/cortezaproject/corteza-server/compose/types"
"github.com/cortezaproject/corteza-server/internal/test"
"github.com/cortezaproject/corteza-server/pkg/cli/options"
"github.com/cortezaproject/corteza-server/pkg/logger"
dbLogger "github.com/titpetric/factory/logger"
)
type (
mockDB struct{}
)
func (mockDB) Transaction(callback func() error) error { return callback() }
func TestMain(m *testing.M) {
logger.SetDefault(logger.MakeDebugLogger())
factory.Database.Add("compose", os.Getenv("COMPOSE_DB_DSN"))
db := factory.Database.MustGet("compose")
db.SetLogger(dbLogger.Default{})
// migrate database schema
if err := composeMigrate.Migrate(db, logger.Default()); err != nil {
fmt.Printf("Error running migrations: %+v\n", err)
return
}
// clean up tables
{
// @todo remove this asap, service should not access db at all.
for _, name := range []string{
"compose_chart",
"compose_module_field",
"compose_module",
"compose_record_value",
"compose_record",
"compose_page",
"compose_attachment",
"compose_automation_trigger",
"compose_automation_script",
"compose_namespace",
} {
_, err := db.Exec("DELETE FROM " + name)
if err != nil {
panic("Error when clearing " + name + ": " + err.Error())
}
}
}
ctx := context.Background()
err := Init(ctx, zap.NewNop(), Config{
Storage: options.StorageOpt{
Path: "/tmp/corteza-compose-store",
},
})
if err != nil {
fmt.Printf("Error running migrations: %+v\n", err)
return
}
os.Exit(m.Run())
}
func createTestNamespaces(ctx context.Context, t *testing.T) (ns1 *types.Namespace, ns2 *types.Namespace) {
var err error
ns1, err = Namespace().With(ctx).Create(&types.Namespace{Enabled: true, Name: "TestNamespace"})
test.Assert(t, err == nil, "Error when creating namespace: %+v", err)
ns2, err = Namespace().With(ctx).Create(&types.Namespace{Enabled: true, Name: "TestNamespace"})
test.Assert(t, err == nil, "Error when creating namespace: %+v", err)
return ns1, ns2
}
compose/service/module_test.go
-115
View File
@@ -1,115 +0,0 @@
// +build integration
package service
import (
"context"
"testing"
"github.com/cortezaproject/corteza-server/compose/types"
"github.com/cortezaproject/corteza-server/internal/auth"
"github.com/cortezaproject/corteza-server/internal/test"
)
func TestModule(t *testing.T) {
ctx := context.WithValue(context.Background(), "testing", true)
// Set Identity (required for permission checks).
ctx = auth.SetIdentityToContext(ctx, auth.NewIdentity(1337))
ns1, _ := createTestNamespaces(ctx, t)
svc := Module().With(ctx)
// the module object we're working with
module := &types.Module{
NamespaceID: ns1.ID,
Name: "Test",
Fields: types.ModuleFieldSet{
&types.ModuleField{
Name: "name",
Kind: "input",
},
&types.ModuleField{
Name: "email",
Kind: "email",
},
&types.ModuleField{
Name: "options",
Kind: "select_multi",
},
&types.ModuleField{
Name: "description",
Kind: "text",
},
},
}
prevModuleCount := 0
{
{
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 := 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 := svc.FindByID(m.NamespaceID, 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"
m.UpdatedAt = nil
_, err := svc.Update(m)
test.Assert(t, err == nil, "Error when updating module, %+v", err)
}
// fetch module fields
{
fl := m.Fields.Names()
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 := svc.FindByID(m.NamespaceID, 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 := svc.Find(types.ModuleFilter{})
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 := svc.DeleteByID(m.NamespaceID, m.ID)
test.Assert(t, err == nil, "Error when deleting module by id: %+v", err)
}
// fetch all modules
{
ms, _, err := svc.Find(types.ModuleFilter{})
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)
}
}
}
compose/service/namespace_test.go
-86
View File
@@ -1,86 +0,0 @@
// +build integration
package service
import (
"context"
"testing"
"github.com/cortezaproject/corteza-server/compose/types"
"github.com/cortezaproject/corteza-server/internal/auth"
"github.com/cortezaproject/corteza-server/internal/test"
)
func TestNamespace(t *testing.T) {
ctx := context.WithValue(context.Background(), "testing", true)
// Set Identity (required for permission checks).
ctx = auth.SetIdentityToContext(ctx, auth.NewIdentity(1337))
svc := Namespace().With(ctx)
// the namespace object we're working with
namespace := &types.Namespace{
Name: "Test",
}
prevNamespaceCount := uint(0)
{
{
m, err := svc.Update(namespace)
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 namespace
m, err := svc.Create(namespace)
test.Assert(t, err == nil, "Error when creating namespace: %+v", err)
test.Assert(t, m.ID > 0, "Expected auto generated ID")
// fetch created namespace
{
ms, err := svc.FindByID(m.ID)
test.Assert(t, err == nil, "Error when retrieving namespace 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)
}
// update created namespace
{
m.Name = "Updated test"
m.UpdatedAt = nil
_, err := svc.Update(m)
test.Assert(t, err == nil, "Error when updating namespace, %+v", err)
}
// re-fetch namespace
{
ms, err := svc.FindByID(m.ID)
test.Assert(t, err == nil, "Error when retrieving namespace 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 namespaces
{
_, f, err := svc.Find(types.NamespaceFilter{})
test.Assert(t, err == nil, "Error when retrieving namespaces: %+v", err)
test.Assert(t, f.Count > 0, "Expected at least one namespace, got %d", f.Count)
prevNamespaceCount = f.Count
}
// re-fetch namespace
{
err := svc.DeleteByID(m.ID)
test.Assert(t, err == nil, "Error when deleting namespace by id: %+v", err)
}
// fetch all namespaces
{
_, f, err := svc.Find(types.NamespaceFilter{})
test.Assert(t, err == nil, "Error when retrieving namespaces: %+v", err)
test.Assert(t, f.Count < prevNamespaceCount, "Expected namespaces count to decrease after deletion, %d < %d", f.Count, prevNamespaceCount)
}
}
}
compose/service/page_test.go
-136
View File
@@ -1,136 +0,0 @@
// +build integration
package service
import (
"context"
"testing"
"github.com/davecgh/go-spew/spew"
"github.com/pkg/errors"
"github.com/cortezaproject/corteza-server/compose/types"
"github.com/cortezaproject/corteza-server/internal/auth"
"github.com/cortezaproject/corteza-server/internal/test"
)
func TestPage(t *testing.T) {
ctx := context.WithValue(context.Background(), "testing", true)
// Set fake Identity (required for permission checks).
ctx = auth.SetIdentityToContext(ctx, auth.NewIdentity(1337))
ns1, _ := createTestNamespaces(ctx, t)
svc := Page().With(ctx)
// the page object we're working with
var err error
page := &types.Page{
NamespaceID: ns1.ID,
Title: "Test",
ModuleID: 123,
}
(&page.Blocks).Scan([]byte("[]"))
prevPageCount := 0
{
{
m, err := svc.Update(page)
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
page, err = svc.Create(page)
test.Assert(t, err == nil, "Error when creating page: %+v", err)
test.Assert(t, page.ID > 0, "Expected auto generated ID")
var firstPageID = page.ID
page.SelfID = page.ID
{
_, err = svc.Create(page)
test.Assert(t, err != nil, "%+v", errors.Errorf("Expected error when creating duplicate moduleID page"))
}
page.ModuleID = 0
{
_, err = svc.Create(page)
test.Assert(t, err == nil, "Unexpected error when creating page, %+v", err)
}
{
_, err = svc.Create(page)
test.Assert(t, err == nil, "Unexpected error when creating page, %+v", err)
}
// fetch created page
{
p, err := svc.FindByID(page.NamespaceID, page.ID)
test.Assert(t, err == nil, "Error when retrieving page by id: %+v", err)
test.Assert(t, p.ID == page.ID, "Expected ID from database to match, %+v", errors.Errorf("%d != %d", page.ID, p.ID))
test.Assert(t, p.Title == page.Title, "Expected Title from database to match, %+v", errors.Errorf("%s != %s", page.Title, p.Title))
}
// update created page
{
page.Title = "Updated test"
page.UpdatedAt = nil
_, err := svc.Update(page)
test.Assert(t, err == nil, "Error when updating page, %+v", err)
}
// re-fetch page
{
p, err := svc.FindByID(page.NamespaceID, page.ID)
test.Assert(t, err == nil, "Error when retrieving page by id: %+v", err)
test.Assert(t, p.ID == page.ID, "re-fetch: Expected ID from database to match, %d != %d", page.ID, p.ID)
test.Assert(t, p.Title == page.Title, "Expected Title from database to match, %s != %s", page.Title, p.Title)
}
// fetch all pages
{
p, _, err := svc.FindBySelfID(page.NamespaceID, 0)
test.Assert(t, err == nil, "Error when retrieving pages: %+v", err)
test.Assert(t, len(p) >= 1, "Expected at least one page, got %d", len(p))
prevPageCount = len(p)
}
// fetch all pages
{
p, _, err := svc.FindBySelfID(page.NamespaceID, firstPageID)
test.Assert(t, err == nil, "Error when retrieving pages: %+v", err)
test.Assert(t, len(p) == 2, "Expected 2 pages with selfID=%d, got %v", page.ID, spew.Sdump(p))
prevPageCount = len(p)
ids := []uint64{p[0].ID, p[1].ID}
{
err := svc.Reorder(page.NamespaceID, firstPageID, ids)
test.Assert(t, err == nil, "Error when reordering pages: %+v", err)
p, _, err = svc.FindBySelfID(page.NamespaceID, firstPageID)
test.Assert(t, err == nil, "Error when retrieving pages: %+v", err)
test.Assert(t, len(p) == 2, "Expected 2 pages with selfID=%d, got %v", page.ID, spew.Sdump(p))
test.Assert(t, p[0].Weight < p[1].Weight, "Expected ascending order, %+v", errors.Errorf("%d < %d", p[0].Weight, p[1].Weight))
}
}
// re-fetch page
{
err := svc.DeleteByID(page.NamespaceID, page.ID)
test.Assert(t, err == nil, "Error when deleting page by id: %+v", err)
}
// fetch all pages
{
p, _, err := svc.FindBySelfID(page.NamespaceID, 0)
test.Assert(t, err == nil, "Error when retrieving pages: %+v", err)
test.Assert(t, len(p) < prevPageCount, "Expected pages count to decrease after deletion, %d < %d", len(p), prevPageCount)
}
}
}
compose/service/record.go
+4
View File
@@ -396,6 +396,10 @@ func (svc record) DeleteByID(namespaceID, recordID uint64) (err error) {
return
}
if !svc.ac.CanDeleteRecord(svc.ctx, m) {
return ErrNoDeletePermissions.withStack()
}
if err = svc.sr.BeforeRecordCreate(svc.ctx, ns, m, r); err != nil {
// Calling
return
compose/service/record_integration_test.go
-249
View File
@@ -1,249 +0,0 @@
// +build integration
package service
import (
"context"
"testing"
"github.com/cortezaproject/corteza-server/compose/types"
"github.com/cortezaproject/corteza-server/internal/auth"
"github.com/cortezaproject/corteza-server/internal/permissions"
"github.com/cortezaproject/corteza-server/internal/test"
)
func TestRecord(t *testing.T) {
ctx := context.WithValue(context.Background(), "testing", true)
ctx = auth.SetIdentityToContext(ctx, auth.NewIdentity(1337))
var err error
ns1, ns2 := createTestNamespaces(ctx, t)
moduleSvc := Module().With(ctx)
svc := Record().With(ctx)
svc.(*record).ac = AccessControl(&permissions.ServiceAllowAll{})
module1 := &types.Module{
NamespaceID: ns1.ID,
Name: "Test",
Fields: types.ModuleFieldSet{
&types.ModuleField{
Name: "name",
},
&types.ModuleField{
Name: "email",
},
&types.ModuleField{
Name: "options",
Multi: true,
},
&types.ModuleField{
Name: "description",
},
&types.ModuleField{
Name: "another_record",
Kind: "Record",
},
},
}
// set up a module1
module1, err = moduleSvc.Create(module1)
test.Assert(t, err == nil, "Error when creating module1: %+v", err)
test.Assert(t, module1.ID > 0, "Expected auto generated ID")
module2 := &types.Module{
NamespaceID: ns2.ID,
Name: "Test Dummy",
Fields: types.ModuleFieldSet{
&types.ModuleField{
Name: "name",
},
&types.ModuleField{
Name: "email",
},
&types.ModuleField{
Name: "options",
Multi: true,
},
&types.ModuleField{
Name: "description",
},
&types.ModuleField{
Name: "another_record",
Kind: "Record",
},
},
}
module2, err = moduleSvc.Create(module2)
test.Assert(t, err == nil, "Error when creating module1 in another namespace: %+v", err)
record1 := &types.Record{
NamespaceID: ns1.ID,
ModuleID: module1.ID,
}
record2 := &types.Record{
NamespaceID: ns1.ID,
ModuleID: module1.ID,
Values: types.RecordValueSet{
&types.RecordValue{
Name: "name",
Value: "John Doe",
},
&types.RecordValue{
Name: "email",
Value: "john.doe@example.com",
},
&types.RecordValue{
Name: "options",
Value: "1",
},
&types.RecordValue{
Name: "options",
Value: "2",
},
&types.RecordValue{
Name: "options",
Value: "3",
},
&types.RecordValue{
Name: "description",
Value: "just an example",
},
&types.RecordValue{
Name: "another_record",
Value: "918273645",
},
},
}
{
// Let's put something to another namespace...
_, err := svc.Create(&types.Record{
NamespaceID: ns2.ID,
ModuleID: module2.ID,
})
test.Assert(t, err == nil, "Error when creating record: %+v", err)
}
// now work with records
{
{
record1.UpdatedAt = nil
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 := 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 := 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 := svc.FindByID(m1.NamespaceID, 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
{
m1.UpdatedAt = nil
_, err := svc.Update(m1)
test.Assert(t, err == nil, "Error when updating record, %+v", err)
}
// re-fetch record
{
ms, err := svc.FindByID(m1.NamespaceID, 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, f, err := svc.Find(types.RecordFilter{ModuleID: module1.ID, Sort: "id desc"})
test.Assert(t, err == nil, "Error when retrieving records: %+v", err)
test.Assert(t, len(mr) == 2, "Expected two record, got %d", len(mr))
test.Assert(t, f.Count == 2, "Expected Meta.Count == 2, got %d", f.Count)
test.Assert(t, f.Sort == "id desc", "Expected Meta.Sort == id desc, got '%s'", f.Sort)
test.Assert(t, mr[0].ModuleID == m1.ModuleID, "Expected record module1 to match, %d != %d", m1.ModuleID, mr[0].ModuleID)
test.Assert(t, mr[0].ID > mr[1].ID, "Expected order to be descending")
}
// fetch all records
{
mr, f, err := svc.Find(types.RecordFilter{ModuleID: module1.ID, Sort: "name asc, email desc"})
test.Assert(t, err == nil, "Error when retrieving records: %+v", err)
test.Assert(t, len(mr) == 2, "Expected two record, got %d", len(mr))
test.Assert(t, f.Count == 2, "Expected Meta.Count == 2, got %d", f.Count)
test.Assert(t, f.Sort == "name asc, email desc", "Expected Meta.Sort == 'name asc, email desc' '%s'", f.Sort)
test.Assert(t, mr[0].ModuleID == m1.ModuleID, "Expected record module1 to match, %d != %d", m1.ModuleID, mr[0].ModuleID)
// @todo sort is not stable
// test.Assert(t, mr[0].ID > mr[1].ID, "Expected order to be ascending")
}
// fetch all records
{
mr, f, err := svc.Find(types.RecordFilter{ModuleID: module1.ID, Sort: "created_at desc"})
test.Assert(t, err == nil, "Error when retrieving records: %+v", err)
test.Assert(t, len(mr) == 2, "Expected two record, got %d", len(mr))
test.Assert(t, f.Count == 2, "Expected Meta.Count == 2, got %d", f.Count)
test.Assert(t, f.Sort == "created_at desc", "Expected Meta.Sort == created_at desc, got '%s'", f.Sort)
test.Assert(t, mr[0].ModuleID == m1.ModuleID, "Expected record module1 to match, %d != %d", m1.ModuleID, mr[0].ModuleID)
// @todo sort is not stable
// test.Assert(t, mr[0].ID > mr[1].ID, "Expected order to be ascending")
}
// fetch all records by query
{
filter := "name='John Doe' AND email='john.doe@example.com'"
sort := "id desc"
mr, f, err := svc.Find(types.RecordFilter{ModuleID: module1.ID, Sort: sort, Filter: filter})
test.Assert(t, err == nil, "Error when retrieving records: %+v", err)
test.Assert(t, len(mr) == 1, "Expected one record, got %d", len(mr))
test.Assert(t, f.Count == 1, "Expected Meta.Count == 1, got %d", f.Count)
test.Assert(t, f.Page == 0, "Expected Meta.Page == 0, got %d", f.Page)
test.Assert(t, f.PerPage == 50, "Expected Meta.PerPage == 50, got %d", f.PerPage)
test.Assert(t, f.Filter == filter, "Expected Meta.Filter == %q, got %q", filter, f.Filter)
test.Assert(t, f.Sort == sort, "Expected Meta.Sort == %q, got %q", sort, f.Sort)
}
// fetch all records by query
{
mr, _, err := svc.Find(types.RecordFilter{ModuleID: module1.ID, Sort: "id asc", Filter: "name='niall'"})
test.Assert(t, err == nil, "Error when retrieving records: %+v", err)
test.Assert(t, len(mr) == 0, "Expected no records, got %d", len(mr))
}
// delete record
{
err := svc.DeleteByID(m1.NamespaceID, m1.ID)
test.Assert(t, err == nil, "Error when retrieving record by id: %+v", err)
err = svc.DeleteByID(m2.NamespaceID, m2.ID)
test.Assert(t, err == nil, "Error when retrieving record by id: %+v", err)
}
// fetch all records
{
mr, _, err := svc.Find(types.RecordFilter{ModuleID: module1.ID})
test.Assert(t, err == nil, "Error when retrieving records: %+v", err)
test.Assert(t, len(mr) == 0, "Expected no record, got %d", len(mr))
}
}
}