diff --git a/store/tests/applications_test.go b/store/tests/applications_test.go index ab0bb003e..1b2c83bd2 100644 --- a/store/tests/applications_test.go +++ b/store/tests/applications_test.go @@ -4,6 +4,7 @@ import ( "context" "github.com/cortezaproject/corteza-server/pkg/filter" "github.com/cortezaproject/corteza-server/pkg/id" + "github.com/cortezaproject/corteza-server/pkg/rand" "github.com/cortezaproject/corteza-server/store" "github.com/cortezaproject/corteza-server/system/types" "github.com/stretchr/testify/require" @@ -25,6 +26,14 @@ func testApplications(t *testing.T, s store.Applications) { Unify: &types.ApplicationUnify{}, } } + + truncAndCreate = func(t *testing.T) (*require.Assertions, *types.Application) { + req := require.New(t) + req.NoError(s.TruncateApplications(ctx)) + res := makeNew(string(rand.Bytes(10))) + req.NoError(s.CreateApplication(ctx, res)) + return req, res + } ) t.Run("create", func(t *testing.T) { @@ -44,18 +53,6 @@ func testApplications(t *testing.T, s store.Applications) { req.Nil(fetched.DeletedAt) }) - t.Run("Delete", func(t *testing.T) { - application := makeNew("Delete") - req.NoError(s.CreateApplication(ctx, application)) - req.NoError(s.DeleteApplication(ctx)) - }) - - t.Run("Delete by ID", func(t *testing.T) { - application := makeNew("Delete by id") - req.NoError(s.CreateApplication(ctx, application)) - req.NoError(s.DeleteApplication(ctx)) - }) - t.Run("update", func(t *testing.T) { application := makeNew("update me") req.NoError(s.CreateApplication(ctx, application)) @@ -73,6 +70,22 @@ func testApplications(t *testing.T, s store.Applications) { req.Equal(application.Name, updated.Name) }) + t.Run("delete", func(t *testing.T) { + t.Run("by Application", func(t *testing.T) { + req, application := truncAndCreate(t) + req.NoError(s.DeleteApplication(ctx, application)) + _, err := s.LookupApplicationByID(ctx, application.ID) + req.EqualError(err, store.ErrNotFound.Error()) + }) + + t.Run("by ID", func(t *testing.T) { + req, application := truncAndCreate(t) + req.NoError(s.DeleteApplicationByID(ctx, application.ID)) + _, err := s.LookupApplicationByID(ctx, application.ID) + req.EqualError(err, store.ErrNotFound.Error()) + }) + }) + t.Run("search", func(t *testing.T) { prefill := []*types.Application{ makeNew("/one-one"), diff --git a/store/tests/attachments_test.go b/store/tests/attachments_test.go index b38ba6914..326c6265a 100644 --- a/store/tests/attachments_test.go +++ b/store/tests/attachments_test.go @@ -16,6 +16,7 @@ import ( func testAttachment(t *testing.T, s store.Attachments) { var ( ctx = context.Background() + req = require.New(t) makeNew = func(nn ...string) *types.Attachment { name := strings.Join(nn, "") @@ -74,7 +75,22 @@ func testAttachment(t *testing.T, s store.Attachments) { req.NoError(err) req.Equal(att.ID, fetched.ID) req.Equal("url", fetched.Url) + }) + t.Run("delete", func(t *testing.T) { + t.Run("by Attachment", func(t *testing.T) { + req, att := truncAndCreate(t) + req.NoError(s.DeleteAttachment(ctx, att)) + _, err := s.LookupAttachmentByID(ctx, att.ID) + req.EqualError(err, store.ErrNotFound.Error()) + }) + + t.Run("by ID", func(t *testing.T) { + req, att := truncAndCreate(t) + req.NoError(s.DeleteAttachmentByID(ctx, att.ID)) + _, err := s.LookupAttachmentByID(ctx, att.ID) + req.EqualError(err, store.ErrNotFound.Error()) + }) }) t.Run("search", func(t *testing.T) { diff --git a/store/tests/compose_attachments_test.go b/store/tests/compose_attachments_test.go index ccd90b3e1..3a3d27de1 100644 --- a/store/tests/compose_attachments_test.go +++ b/store/tests/compose_attachments_test.go @@ -62,7 +62,22 @@ func testComposeAttachments(t *testing.T, s store.ComposeAttachments) { req.NoError(err) req.Equal(att.ID, fetched.ID) req.Equal("url", fetched.Url) + }) + t.Run("delete", func(t *testing.T) { + t.Run("by Attachment", func(t *testing.T) { + req, att := truncAndCreate(t) + req.NoError(s.DeleteComposeAttachment(ctx, att)) + _, err := s.LookupComposeAttachmentByID(ctx, att.ID) + req.EqualError(err, store.ErrNotFound.Error()) + }) + + t.Run("by ID", func(t *testing.T) { + req, att := truncAndCreate(t) + req.NoError(s.DeleteComposeAttachmentByID(ctx, att.ID)) + _, err := s.LookupComposeAttachmentByID(ctx, att.ID) + req.EqualError(err, store.ErrNotFound.Error()) + }) }) t.Run("search", func(t *testing.T) { diff --git a/store/tests/compose_charts_test.go b/store/tests/compose_charts_test.go index 8b780c868..1f088f4e2 100644 --- a/store/tests/compose_charts_test.go +++ b/store/tests/compose_charts_test.go @@ -5,6 +5,7 @@ import ( "github.com/cortezaproject/corteza-server/compose/types" "github.com/cortezaproject/corteza-server/pkg/filter" "github.com/cortezaproject/corteza-server/pkg/id" + "github.com/cortezaproject/corteza-server/pkg/rand" "github.com/cortezaproject/corteza-server/store" "github.com/stretchr/testify/require" "testing" @@ -28,6 +29,14 @@ func testComposeCharts(t *testing.T, s store.Storer) { Handle: handle, } } + + truncAndCreate = func(t *testing.T) (*require.Assertions, *types.Chart) { + req := require.New(t) + req.NoError(s.TruncateComposeCharts(ctx)) + res := makeNew(string(rand.Bytes(10)), string(rand.Bytes(10))) + req.NoError(s.CreateComposeChart(ctx, res)) + return req, res + } ) t.Run("create", func(t *testing.T) { @@ -39,33 +48,34 @@ func testComposeCharts(t *testing.T, s store.Storer) { t.Skip("not implemented") }) - t.Run("lookup by ID", func(t *testing.T) { - composeChart := makeNew("look up by id", "look-up-by-id") - req.NoError(s.CreateComposeChart(ctx, composeChart)) - fetched, err := s.LookupComposeChartByID(ctx, composeChart.ID) - req.NoError(err) - req.Equal(composeChart.Name, fetched.Name) - req.Equal(composeChart.ID, fetched.ID) - req.NotNil(fetched.CreatedAt) - req.Nil(fetched.UpdatedAt) - req.Nil(fetched.DeletedAt) - }) + t.Run("lookup", func(t *testing.T) { + t.Run("by ID", func(t *testing.T) { + composeChart := makeNew("look up by id", "look-up-by-id") + req.NoError(s.CreateComposeChart(ctx, composeChart)) + fetched, err := s.LookupComposeChartByID(ctx, composeChart.ID) + req.NoError(err) + req.Equal(composeChart.Name, fetched.Name) + req.Equal(composeChart.ID, fetched.ID) + req.NotNil(fetched.CreatedAt) + req.Nil(fetched.UpdatedAt) + req.Nil(fetched.DeletedAt) + }) - t.Run("Delete", func(t *testing.T) { - composeChart := makeNew("Delete", "Delete") - req.NoError(s.CreateComposeChart(ctx, composeChart)) - req.NoError(s.DeleteComposeChart(ctx)) - }) - - t.Run("Delete by ID", func(t *testing.T) { - composeChart := makeNew("Delete by id", "Delete-by-id") - req.NoError(s.CreateComposeChart(ctx, composeChart)) - req.NoError(s.DeleteComposeChart(ctx)) + t.Run("by Namespace ID, Handle", func(t *testing.T) { + composeChart := makeNew("look up by handle", "look-up-by-handle") + req.NoError(s.CreateComposeChart(ctx, composeChart)) + fetched, err := s.LookupComposeChartByNamespaceIDHandle(ctx, composeChart.NamespaceID, composeChart.Handle) + req.NoError(err) + req.Equal(composeChart.Name, fetched.Name) + req.Equal(composeChart.ID, fetched.ID) + req.NotNil(fetched.CreatedAt) + req.Nil(fetched.UpdatedAt) + req.Nil(fetched.DeletedAt) + }) }) t.Run("update", func(t *testing.T) { - composeChart := makeNew("update me", "update-me") - req.NoError(s.CreateComposeChart(ctx, composeChart)) + req, composeChart := truncAndCreate(t) composeChart = &types.Chart{ ID: composeChart.ID, @@ -83,6 +93,23 @@ func testComposeCharts(t *testing.T, s store.Storer) { t.Skip("not implemented") }) + + t.Run("delete", func(t *testing.T) { + t.Run("by Chart", func(t *testing.T) { + req, composeChart := truncAndCreate(t) + req.NoError(s.DeleteComposeChart(ctx, composeChart)) + _, err := s.LookupComposeChartByID(ctx, composeChart.ID) + req.EqualError(err, store.ErrNotFound.Error()) + }) + + t.Run("by ID", func(t *testing.T) { + req, composeChart := truncAndCreate(t) + req.NoError(s.DeleteComposeChartByID(ctx, composeChart.ID)) + _, err := s.LookupComposeChartByID(ctx, composeChart.ID) + req.EqualError(err, store.ErrNotFound.Error()) + }) + }) + t.Run("search", func(t *testing.T) { prefill := []*types.Chart{ makeNew("/one-one", "chart-1-1"), diff --git a/store/tests/compose_module_fields_test.go b/store/tests/compose_module_fields_test.go index 6d8f48569..eecb8de4b 100644 --- a/store/tests/compose_module_fields_test.go +++ b/store/tests/compose_module_fields_test.go @@ -50,14 +50,6 @@ func testComposeModuleFields(t *testing.T, s store.ComposeModuleFields) { t.Skip("not implemented") }) - t.Run("Delete", func(t *testing.T) { - req, fld := truncAndCreate(t) - req.NoError(s.DeleteComposeModuleField(ctx, fld)) - fetched, _, err := s.SearchComposeModuleFields(ctx, types.ModuleFieldFilter{ModuleID: []uint64{fld.ModuleID}}) - req.NoError(err) - req.Empty(fetched) - }) - t.Run("update", func(t *testing.T) { req := require.New(t) composeModuleField := makeNew("update me", "update-me") @@ -74,4 +66,23 @@ func testComposeModuleFields(t *testing.T, s store.ComposeModuleFields) { t.Run("update with duplicate handle", func(t *testing.T) { t.Skip("not implemented") }) + + + t.Run("delete", func(t *testing.T) { + t.Run("by Field", func(t *testing.T) { + req, fld := truncAndCreate(t) + req.NoError(s.DeleteComposeModuleField(ctx, fld)) + fetched, _, err := s.SearchComposeModuleFields(ctx, types.ModuleFieldFilter{ModuleID: []uint64{fld.ModuleID}}) + req.NoError(err) + req.Empty(fetched) + }) + + t.Run("by ID", func(t *testing.T) { + req, fld := truncAndCreate(t) + req.NoError(s.DeleteComposeModuleFieldByID(ctx, fld.ID)) + fetched, _, err := s.SearchComposeModuleFields(ctx, types.ModuleFieldFilter{ModuleID: []uint64{fld.ModuleID}}) + req.NoError(err) + req.Empty(fetched) + }) + }) } diff --git a/store/tests/compose_modules_test.go b/store/tests/compose_modules_test.go index 7d6ad3e55..5df76df46 100644 --- a/store/tests/compose_modules_test.go +++ b/store/tests/compose_modules_test.go @@ -5,6 +5,7 @@ import ( "github.com/cortezaproject/corteza-server/compose/types" "github.com/cortezaproject/corteza-server/pkg/filter" "github.com/cortezaproject/corteza-server/pkg/id" + "github.com/cortezaproject/corteza-server/pkg/rand" "github.com/cortezaproject/corteza-server/store" "github.com/stretchr/testify/require" "testing" @@ -28,6 +29,14 @@ func testComposeModules(t *testing.T, s store.ComposeModules) { Handle: handle, } } + + truncAndCreate = func(t *testing.T) (*require.Assertions, *types.Module) { + req := require.New(t) + req.NoError(s.TruncateComposeModules(ctx)) + res := makeNew(string(rand.Bytes(10)), string(rand.Bytes(10))) + req.NoError(s.CreateComposeModule(ctx, res)) + return req, res + } ) t.Run("create", func(t *testing.T) { @@ -51,18 +60,6 @@ func testComposeModules(t *testing.T, s store.ComposeModules) { req.Nil(fetched.DeletedAt) }) - t.Run("Delete", func(t *testing.T) { - composeModule := makeNew("Delete", "Delete") - req.NoError(s.CreateComposeModule(ctx, composeModule)) - req.NoError(s.DeleteComposeModule(ctx)) - }) - - t.Run("Delete by ID", func(t *testing.T) { - composeModule := makeNew("Delete by id", "Delete-by-id") - req.NoError(s.CreateComposeModule(ctx, composeModule)) - req.NoError(s.DeleteComposeModule(ctx)) - }) - t.Run("update", func(t *testing.T) { composeModule := makeNew("update me", "update-me") req.NoError(s.CreateComposeModule(ctx, composeModule)) @@ -83,6 +80,22 @@ func testComposeModules(t *testing.T, s store.ComposeModules) { t.Skip("not implemented") }) + t.Run("delete", func(t *testing.T) { + t.Run("by Module", func(t *testing.T) { + req, composeModule := truncAndCreate(t) + req.NoError(s.DeleteComposeModule(ctx, composeModule)) + _, err := s.LookupComposeModuleByID(ctx, composeModule.ID) + req.EqualError(err, store.ErrNotFound.Error()) + }) + + t.Run("by ID", func(t *testing.T) { + req, composeModule := truncAndCreate(t) + req.NoError(s.DeleteComposeModuleByID(ctx, composeModule.ID)) + _, err := s.LookupComposeModuleByID(ctx, composeModule.ID) + req.EqualError(err, store.ErrNotFound.Error()) + }) + }) + t.Run("search", func(t *testing.T) { prefill := []*types.Module{ makeNew("/one-one", "module-1-1"), diff --git a/store/tests/compose_namespaces_test.go b/store/tests/compose_namespaces_test.go index 508a91ddd..ef913c778 100644 --- a/store/tests/compose_namespaces_test.go +++ b/store/tests/compose_namespaces_test.go @@ -5,6 +5,7 @@ import ( "github.com/cortezaproject/corteza-server/compose/types" "github.com/cortezaproject/corteza-server/pkg/filter" "github.com/cortezaproject/corteza-server/pkg/id" + "github.com/cortezaproject/corteza-server/pkg/rand" "github.com/cortezaproject/corteza-server/store" "github.com/stretchr/testify/require" "testing" @@ -25,6 +26,14 @@ func testComposeNamespaces(t *testing.T, s store.ComposeNamespaces) { Slug: slug, } } + + truncAndCreate = func(t *testing.T) (*require.Assertions, *types.Namespace) { + req := require.New(t) + req.NoError(s.TruncateComposeNamespaces(ctx)) + res := makeNew(string(rand.Bytes(10)), string(rand.Bytes(10))) + req.NoError(s.CreateComposeNamespace(ctx, res)) + return req, res + } ) t.Run("create", func(t *testing.T) { @@ -48,18 +57,6 @@ func testComposeNamespaces(t *testing.T, s store.ComposeNamespaces) { req.Nil(fetched.DeletedAt) }) - t.Run("Delete", func(t *testing.T) { - composeNamespace := makeNew("Delete", "Delete") - req.NoError(s.CreateComposeNamespace(ctx, composeNamespace)) - req.NoError(s.DeleteComposeNamespace(ctx)) - }) - - t.Run("Delete by ID", func(t *testing.T) { - composeNamespace := makeNew("Delete by id", "Delete-by-id") - req.NoError(s.CreateComposeNamespace(ctx, composeNamespace)) - req.NoError(s.DeleteComposeNamespace(ctx)) - }) - t.Run("update", func(t *testing.T) { composeNamespace := makeNew("update me", "update-me") req.NoError(s.CreateComposeNamespace(ctx, composeNamespace)) @@ -80,6 +77,22 @@ func testComposeNamespaces(t *testing.T, s store.ComposeNamespaces) { t.Skip("not implemented") }) + t.Run("delete", func(t *testing.T) { + t.Run("by Namespace", func(t *testing.T) { + req, composeNamespace := truncAndCreate(t) + req.NoError(s.DeleteComposeNamespace(ctx, composeNamespace)) + _, err := s.LookupComposeNamespaceByID(ctx, composeNamespace.ID) + req.EqualError(err, store.ErrNotFound.Error()) + }) + + t.Run("by ID", func(t *testing.T) { + req, composeNamespace := truncAndCreate(t) + req.NoError(s.DeleteComposeNamespaceByID(ctx, composeNamespace.ID)) + _, err := s.LookupComposeNamespaceByID(ctx, composeNamespace.ID) + req.EqualError(err, store.ErrNotFound.Error()) + }) + }) + t.Run("search", func(t *testing.T) { prefill := []*types.Namespace{ makeNew("/one-one", "namespace-1-1"), diff --git a/store/tests/compose_pages_test.go b/store/tests/compose_pages_test.go index 866cfb13a..686097fb5 100644 --- a/store/tests/compose_pages_test.go +++ b/store/tests/compose_pages_test.go @@ -5,6 +5,7 @@ import ( "github.com/cortezaproject/corteza-server/compose/types" "github.com/cortezaproject/corteza-server/pkg/filter" "github.com/cortezaproject/corteza-server/pkg/id" + "github.com/cortezaproject/corteza-server/pkg/rand" "github.com/cortezaproject/corteza-server/store" "github.com/stretchr/testify/require" "testing" @@ -28,6 +29,14 @@ func testComposePages(t *testing.T, s store.ComposePages) { Handle: handle, } } + + truncAndCreate = func(t *testing.T) (*require.Assertions, *types.Page) { + req := require.New(t) + req.NoError(s.TruncateComposePages(ctx)) + res := makeNew(string(rand.Bytes(10)), string(rand.Bytes(10))) + req.NoError(s.CreateComposePage(ctx, res)) + return req, res + } ) t.Run("create", func(t *testing.T) { @@ -51,18 +60,6 @@ func testComposePages(t *testing.T, s store.ComposePages) { req.Nil(fetched.DeletedAt) }) - t.Run("Delete", func(t *testing.T) { - composePage := makeNew("Delete", "Delete") - req.NoError(s.CreateComposePage(ctx, composePage)) - req.NoError(s.DeleteComposePage(ctx)) - }) - - t.Run("Delete by ID", func(t *testing.T) { - composePage := makeNew("Delete by id", "Delete-by-id") - req.NoError(s.CreateComposePage(ctx, composePage)) - req.NoError(s.DeleteComposePage(ctx)) - }) - t.Run("update", func(t *testing.T) { composePage := makeNew("update me", "update-me") req.NoError(s.CreateComposePage(ctx, composePage)) @@ -83,6 +80,22 @@ func testComposePages(t *testing.T, s store.ComposePages) { t.Skip("not implemented") }) + t.Run("delete", func(t *testing.T) { + t.Run("by Page", func(t *testing.T) { + req, composePage := truncAndCreate(t) + req.NoError(s.DeleteComposePage(ctx, composePage)) + _, err := s.LookupComposePageByID(ctx, composePage.ID) + req.EqualError(err, store.ErrNotFound.Error()) + }) + + t.Run("by ID", func(t *testing.T) { + req, composePage := truncAndCreate(t) + req.NoError(s.DeleteComposePageByID(ctx, composePage.ID)) + _, err := s.LookupComposePageByID(ctx, composePage.ID) + req.EqualError(err, store.ErrNotFound.Error()) + }) + }) + t.Run("search", func(t *testing.T) { prefill := []*types.Page{ makeNew("/one-one", "page-1-1"), diff --git a/store/tests/compose_records_test.go b/store/tests/compose_records_test.go index b223ddf11..4f74d757d 100644 --- a/store/tests/compose_records_test.go +++ b/store/tests/compose_records_test.go @@ -117,24 +117,6 @@ func testComposeRecords(t *testing.T, s store.ComposeRecords) { req.Equal(uint64(2), fetched.Values[1].Ref) }) - t.Run("Delete", func(t *testing.T) { - req, rr := truncAndCreate(t) - rec := rr[0] - - req.NoError(s.DeleteComposeRecord(ctx, mod, rec)) - _, err := s.LookupComposeRecordByID(ctx, mod, rec.ID) - req.EqualError(err, store.ErrNotFound.Error()) - }) - - t.Run("Delete by ID", func(t *testing.T) { - req, rr := truncAndCreate(t) - rec := rr[0] - - req.NoError(s.DeleteComposeRecordByID(ctx, mod, rec.ID)) - _, err := s.LookupComposeRecordByID(ctx, mod, rec.ID) - req.EqualError(err, store.ErrNotFound.Error()) - }) - t.Run("update", func(t *testing.T) { req, rr := truncAndCreate(t) rec := rr[0] @@ -205,6 +187,26 @@ func testComposeRecords(t *testing.T, s store.ComposeRecords) { req.NotNil(updated.Values[1].DeletedAt) }) + t.Run("delete", func(t *testing.T) { + t.Run("by Record", func(t *testing.T) { + req, rr := truncAndCreate(t) + rec := rr[0] + + req.NoError(s.DeleteComposeRecord(ctx, mod, rec)) + _, err := s.LookupComposeRecordByID(ctx, mod, rec.ID) + req.EqualError(err, store.ErrNotFound.Error()) + }) + + t.Run("by ID", func(t *testing.T) { + req, rr := truncAndCreate(t) + rec := rr[0] + + req.NoError(s.DeleteComposeRecordByID(ctx, mod, rec.ID)) + _, err := s.LookupComposeRecordByID(ctx, mod, rec.ID) + req.EqualError(err, store.ErrNotFound.Error()) + }) + }) + t.Run("search", func(t *testing.T) { t.Run("by record attributes", func(t *testing.T) { prefill := []*types.Record{ diff --git a/store/tests/messaging_attachments_test.go b/store/tests/messaging_attachments_test.go index ea5f5c7b7..7f8ba5cdb 100644 --- a/store/tests/messaging_attachments_test.go +++ b/store/tests/messaging_attachments_test.go @@ -65,6 +65,22 @@ func testMessagingAttachments(t *testing.T, s store.MessagingAttachments) { }) + t.Run("delete", func(t *testing.T) { + t.Run("by Attachment", func(t *testing.T) { + req, att := truncAndCreate(t) + req.NoError(s.DeleteMessagingAttachment(ctx, att)) + _, err := s.LookupMessagingAttachmentByID(ctx, att.ID) + req.EqualError(err, store.ErrNotFound.Error()) + }) + + t.Run("by ID", func(t *testing.T) { + req, att := truncAndCreate(t) + req.NoError(s.DeleteMessagingAttachmentByID(ctx, att.ID)) + _, err := s.LookupMessagingAttachmentByID(ctx, att.ID) + req.EqualError(err, store.ErrNotFound.Error()) + }) + }) + t.Run("search", func(t *testing.T) { t.Skip("not implemented") }) diff --git a/store/tests/messaging_channel_members_test.go b/store/tests/messaging_channel_members_test.go index 901cd56d0..03bb51e53 100644 --- a/store/tests/messaging_channel_members_test.go +++ b/store/tests/messaging_channel_members_test.go @@ -20,19 +20,23 @@ func testMessagingChannelMembers(t *testing.T, s store.MessagingChannelMembers) makeNew = func(channelID, userID uint64) *types.ChannelMember { // minimum data set for new messagingChannelMember return &types.ChannelMember{ - UserID: userID, ChannelID: channelID, + UserID: userID, + + Type: types.ChannelMembershipType("owner"), + Flag: types.ChannelMembershipFlag(""), + CreatedAt: time.Now(), } } - //truncAndCreate = func(t *testing.T) (*require.Assertions, *types.ChannelMember) { - // req := require.New(t) - // req.NoError(s.TruncateMessagingChannelMembers(ctx)) - // res := makeNew(channelID, userID) - // req.NoError(s.CreateMessagingChannelMember(ctx, res)) - // return req, res - //} + truncAndCreate = func(t *testing.T) (*require.Assertions, *types.ChannelMember) { + req := require.New(t) + req.NoError(s.TruncateMessagingChannelMembers(ctx)) + res := makeNew(channelID, userID) + req.NoError(s.CreateMessagingChannelMember(ctx, res)) + return req, res + } ) t.Run("create", func(t *testing.T) { @@ -41,4 +45,22 @@ func testMessagingChannelMembers(t *testing.T, s store.MessagingChannelMembers) messagingChannelMember := makeNew(channelID, userID) req.NoError(s.CreateMessagingChannelMember(ctx, messagingChannelMember)) }) + + t.Run("delete", func(t *testing.T) { + t.Run("by ChannelMember", func(t *testing.T) { + req, messagingChannelMember := truncAndCreate(t) + req.NoError(s.DeleteMessagingChannelMember(ctx, messagingChannelMember)) + set, _, err := s.SearchMessagingChannelMembers(ctx, types.ChannelMemberFilter{ChannelID: []uint64{messagingChannelMember.ChannelID}, MemberID: []uint64{messagingChannelMember.UserID}}) + req.NoError(err) + req.Len(set, 0) + }) + + t.Run("by ID", func(t *testing.T) { + req, messagingChannelMember := truncAndCreate(t) + req.NoError(s.DeleteMessagingChannelMemberByChannelIDUserID(ctx, messagingChannelMember.ChannelID, messagingChannelMember.UserID)) + set, _, err := s.SearchMessagingChannelMembers(ctx, types.ChannelMemberFilter{ChannelID: []uint64{messagingChannelMember.ChannelID}, MemberID: []uint64{messagingChannelMember.UserID}}) + req.NoError(err) + req.Len(set, 0) + }) + }) } diff --git a/store/tests/messaging_channels_test.go b/store/tests/messaging_channels_test.go index c401fc333..9c5da0dcf 100644 --- a/store/tests/messaging_channels_test.go +++ b/store/tests/messaging_channels_test.go @@ -4,6 +4,7 @@ import ( "context" "github.com/cortezaproject/corteza-server/messaging/types" "github.com/cortezaproject/corteza-server/pkg/id" + "github.com/cortezaproject/corteza-server/pkg/rand" "github.com/cortezaproject/corteza-server/store" "github.com/stretchr/testify/require" "testing" @@ -23,6 +24,14 @@ func testMessagingChannels(t *testing.T, s store.MessagingChannels) { Name: name, } } + + truncAndCreate = func(t *testing.T) (*require.Assertions, *types.Channel) { + req := require.New(t) + req.NoError(s.TruncateMessagingChannels(ctx)) + res := makeNew(string(rand.Bytes(10))) + req.NoError(s.CreateMessagingChannel(ctx, res)) + return req, res + } ) t.Run("create", func(t *testing.T) { @@ -46,18 +55,6 @@ func testMessagingChannels(t *testing.T, s store.MessagingChannels) { req.Nil(fetched.DeletedAt) }) - t.Run("Delete", func(t *testing.T) { - messagingChannel := makeNew("Delete") - req.NoError(s.CreateMessagingChannel(ctx, messagingChannel)) - req.NoError(s.DeleteMessagingChannel(ctx)) - }) - - t.Run("Delete by ID", func(t *testing.T) { - messagingChannel := makeNew("Delete by id") - req.NoError(s.CreateMessagingChannel(ctx, messagingChannel)) - req.NoError(s.DeleteMessagingChannel(ctx)) - }) - t.Run("update", func(t *testing.T) { messagingChannel := makeNew("update me") req.NoError(s.CreateMessagingChannel(ctx, messagingChannel)) @@ -78,6 +75,22 @@ func testMessagingChannels(t *testing.T, s store.MessagingChannels) { t.Skip("not implemented") }) + t.Run("delete", func(t *testing.T) { + t.Run("by Channel", func(t *testing.T) { + req, messagingChannel := truncAndCreate(t) + req.NoError(s.DeleteMessagingChannel(ctx, messagingChannel)) + _, err := s.LookupMessagingChannelByID(ctx, messagingChannel.ID) + req.EqualError(err, store.ErrNotFound.Error()) + }) + + t.Run("by ID", func(t *testing.T) { + req, messagingChannel := truncAndCreate(t) + req.NoError(s.DeleteMessagingChannelByID(ctx, messagingChannel.ID)) + _, err := s.LookupMessagingChannelByID(ctx, messagingChannel.ID) + req.EqualError(err, store.ErrNotFound.Error()) + }) + }) + t.Run("search", func(t *testing.T) { prefill := []*types.Channel{ makeNew("one-one"), diff --git a/store/tests/messaging_flags_test.go b/store/tests/messaging_flags_test.go index 1c12eea28..a8a6b1094 100644 --- a/store/tests/messaging_flags_test.go +++ b/store/tests/messaging_flags_test.go @@ -4,6 +4,7 @@ import ( "context" "github.com/cortezaproject/corteza-server/messaging/types" "github.com/cortezaproject/corteza-server/pkg/id" + "github.com/cortezaproject/corteza-server/pkg/rand" "github.com/cortezaproject/corteza-server/store" "github.com/stretchr/testify/require" "testing" @@ -29,6 +30,14 @@ func testMessagingFlags(t *testing.T, s store.MessagingFlags) { CreatedAt: *now(), } } + + truncAndCreate = func(t *testing.T) (*require.Assertions, *types.MessageFlag) { + req := require.New(t) + req.NoError(s.TruncateMessagingFlags(ctx)) + res := makeNew(string(rand.Bytes(10))) + req.NoError(s.CreateMessagingFlag(ctx, res)) + return req, res + } ) t.Run("create", func(t *testing.T) { @@ -51,18 +60,6 @@ func testMessagingFlags(t *testing.T, s store.MessagingFlags) { req.Nil(fetched.DeletedAt) }) - t.Run("Delete", func(t *testing.T) { - messagingFlag := makeNew("f") - req.NoError(s.CreateMessagingFlag(ctx, messagingFlag)) - req.NoError(s.DeleteMessagingFlag(ctx)) - }) - - t.Run("Delete by ID", func(t *testing.T) { - messagingFlag := makeNew("Delete-by-id") - req.NoError(s.CreateMessagingFlag(ctx, messagingFlag)) - req.NoError(s.DeleteMessagingFlag(ctx)) - }) - t.Run("update", func(t *testing.T) { messagingFlag := makeNew("update-me") req.NoError(s.CreateMessagingFlag(ctx, messagingFlag)) @@ -83,6 +80,22 @@ func testMessagingFlags(t *testing.T, s store.MessagingFlags) { t.Skip("not implemented") }) + t.Run("delete", func(t *testing.T) { + t.Run("by Message Flag", func(t *testing.T) { + req, messagingFlag := truncAndCreate(t) + req.NoError(s.DeleteMessagingFlag(ctx, messagingFlag)) + _, err := s.LookupMessagingFlagByID(ctx, messagingFlag.ID) + req.EqualError(err, store.ErrNotFound.Error()) + }) + + t.Run("by ID", func(t *testing.T) { + req, messagingFlag := truncAndCreate(t) + req.NoError(s.DeleteMessagingFlagByID(ctx, messagingFlag.ID)) + _, err := s.LookupMessagingFlagByID(ctx, messagingFlag.ID) + req.EqualError(err, store.ErrNotFound.Error()) + }) + }) + t.Run("search", func(t *testing.T) { prefill := []*types.MessageFlag{ makeNew("flag-1-1"), diff --git a/store/tests/messaging_mentions_test.go b/store/tests/messaging_mentions_test.go index 95a3f7122..089c83d3d 100644 --- a/store/tests/messaging_mentions_test.go +++ b/store/tests/messaging_mentions_test.go @@ -4,6 +4,7 @@ import ( "context" "github.com/cortezaproject/corteza-server/messaging/types" "github.com/cortezaproject/corteza-server/pkg/id" + "github.com/cortezaproject/corteza-server/pkg/rand" "github.com/cortezaproject/corteza-server/store" "github.com/stretchr/testify/require" "testing" @@ -28,6 +29,14 @@ func testMessagingMentions(t *testing.T, s store.MessagingMentions) { CreatedAt: *now(), } } + + truncAndCreate = func(t *testing.T) (*require.Assertions, *types.Mention) { + req := require.New(t) + req.NoError(s.TruncateMessagingMentions(ctx)) + res := makeNew(string(rand.Bytes(10))) + req.NoError(s.CreateMessagingMention(ctx, res)) + return req, res + } ) t.Run("create", func(t *testing.T) { @@ -48,15 +57,19 @@ func testMessagingMentions(t *testing.T, s store.MessagingMentions) { req.NotNil(fetched.CreatedAt) }) - t.Run("Delete", func(t *testing.T) { - messagingMention := makeNew("f") - req.NoError(s.CreateMessagingMention(ctx, messagingMention)) - req.NoError(s.DeleteMessagingMention(ctx)) - }) + t.Run("delete", func(t *testing.T) { + t.Run("by Mention", func(t *testing.T) { + req, messagingMention := truncAndCreate(t) + req.NoError(s.DeleteMessagingMention(ctx, messagingMention)) + _, err := s.LookupMessagingMentionByID(ctx, messagingMention.ID) + req.EqualError(err, store.ErrNotFound.Error()) + }) - t.Run("Delete by ID", func(t *testing.T) { - messagingMention := makeNew("Delete-by-id") - req.NoError(s.CreateMessagingMention(ctx, messagingMention)) - req.NoError(s.DeleteMessagingMention(ctx)) + t.Run("by ID", func(t *testing.T) { + req, messagingMention := truncAndCreate(t) + req.NoError(s.DeleteMessagingMentionByID(ctx, messagingMention.ID)) + _, err := s.LookupMessagingMentionByID(ctx, messagingMention.ID) + req.EqualError(err, store.ErrNotFound.Error()) + }) }) } diff --git a/store/tests/messaging_message_attachments_test.go b/store/tests/messaging_message_attachments_test.go index 1534ca1f6..f7218b5c4 100644 --- a/store/tests/messaging_message_attachments_test.go +++ b/store/tests/messaging_message_attachments_test.go @@ -13,6 +13,22 @@ import ( func testMessagingMessageAttachments(t *testing.T, s store.MessagingMessageAttachments) { var ( ctx = context.Background() + + makeNew = func() *types.MessageAttachment { + // minimum data set for new messageAttachment + return &types.MessageAttachment{ + MessageID: id.Next(), + AttachmentID: id.Next(), + } + } + + truncAndCreate = func(t *testing.T) (*require.Assertions, *types.MessageAttachment) { + req := require.New(t) + req.NoError(s.TruncateMessagingMessageAttachments(ctx)) + res := makeNew() + req.NoError(s.CreateMessagingMessageAttachment(ctx, res)) + return req, res + } ) t.Run("create", func(t *testing.T) { @@ -25,12 +41,18 @@ func testMessagingMessageAttachments(t *testing.T, s store.MessagingMessageAttac }) t.Run("delete", func(t *testing.T) { - req := require.New(t) - mma := &types.MessageAttachment{ - MessageID: id.Next(), - AttachmentID: id.Next(), - } - req.NoError(s.DeleteMessagingMessageAttachment(ctx, mma)) - }) + t.Run("by MessageAttachment", func(t *testing.T) { + req, mma := truncAndCreate(t) + req.NoError(s.DeleteMessagingMessageAttachment(ctx, mma)) + _, err := s.LookupMessagingMessageAttachmentByMessageID(ctx, mma.MessageID) + req.EqualError(err, store.ErrNotFound.Error()) + }) + t.Run("by MessageID", func(t *testing.T) { + req, mma := truncAndCreate(t) + req.NoError(s.DeleteMessagingMessageAttachmentByMessageID(ctx, mma.MessageID)) + _, err := s.LookupMessagingMessageAttachmentByMessageID(ctx, mma.MessageID) + req.EqualError(err, store.ErrNotFound.Error()) + }) + }) } diff --git a/store/tests/messaging_messages_test.go b/store/tests/messaging_messages_test.go index 25f91f6a1..5442cc2b2 100644 --- a/store/tests/messaging_messages_test.go +++ b/store/tests/messaging_messages_test.go @@ -4,6 +4,7 @@ import ( "context" "github.com/cortezaproject/corteza-server/messaging/types" "github.com/cortezaproject/corteza-server/pkg/id" + "github.com/cortezaproject/corteza-server/pkg/rand" "github.com/cortezaproject/corteza-server/store" "github.com/stretchr/testify/require" "testing" @@ -26,6 +27,14 @@ func testMessagingMessages(t *testing.T, s store.MessagingMessages) { Type: types.MessageTypeSimpleMessage, } } + + truncAndCreate = func(t *testing.T) (*require.Assertions, *types.Message) { + req := require.New(t) + req.NoError(s.TruncateMessagingMessages(ctx)) + res := makeNew(string(rand.Bytes(10))) + req.NoError(s.CreateMessagingMessage(ctx, res)) + return req, res + } ) t.Run("create", func(t *testing.T) { @@ -49,18 +58,6 @@ func testMessagingMessages(t *testing.T, s store.MessagingMessages) { req.Nil(fetched.DeletedAt) }) - t.Run("Delete", func(t *testing.T) { - messagingMessage := makeNew("deleted") - req.NoError(s.CreateMessagingMessage(ctx, messagingMessage)) - req.NoError(s.DeleteMessagingMessage(ctx)) - }) - - t.Run("Delete by ID", func(t *testing.T) { - messagingMessage := makeNew("Delete by id") - req.NoError(s.CreateMessagingMessage(ctx, messagingMessage)) - req.NoError(s.DeleteMessagingMessage(ctx)) - }) - t.Run("update", func(t *testing.T) { messagingMessage := makeNew("update me") req.NoError(s.CreateMessagingMessage(ctx, messagingMessage)) @@ -82,6 +79,22 @@ func testMessagingMessages(t *testing.T, s store.MessagingMessages) { t.Skip("not implemented") }) + t.Run("delete", func(t *testing.T) { + t.Run("by Message", func(t *testing.T) { + req, messagingMessage := truncAndCreate(t) + req.NoError(s.DeleteMessagingMessage(ctx, messagingMessage)) + _, err := s.LookupMessagingMessageByID(ctx, messagingMessage.ID) + req.EqualError(err, store.ErrNotFound.Error()) + }) + + t.Run("by ID", func(t *testing.T) { + req, messagingMessage := truncAndCreate(t) + req.NoError(s.DeleteMessagingMessageByID(ctx, messagingMessage.ID)) + _, err := s.LookupMessagingMessageByID(ctx, messagingMessage.ID) + req.EqualError(err, store.ErrNotFound.Error()) + }) + }) + t.Run("search", func(t *testing.T) { prefill := []*types.Message{ makeNew("/one-one"), diff --git a/store/tests/role_members_test.go b/store/tests/role_members_test.go index 66e688435..9e5900103 100644 --- a/store/tests/role_members_test.go +++ b/store/tests/role_members_test.go @@ -54,22 +54,6 @@ func testRoleMembers(t *testing.T, s store.RoleMembers) { truncAndFill(t, 5) }) - t.Run("delete", func(t *testing.T) { - t.Run("by role member", func(t *testing.T) { - req, roleMember := truncAndCreate(t) - req.NoError(s.DeleteRoleMember(ctx, roleMember)) - roleMembers, _, _ := s.SearchRoleMembers(ctx, types.RoleMemberFilter{UserID: roleMember.UserID, RoleID: roleMember.RoleID}) - req.Len(roleMembers, 0) - }) - - t.Run("by RoleID and OwnerID", func(t *testing.T) { - req, roleMember := truncAndCreate(t) - req.NoError(s.DeleteRoleMemberByUserIDRoleID(ctx, roleMember.UserID, roleMember.RoleID)) - roleMembers, _, _ := s.SearchRoleMembers(ctx, types.RoleMemberFilter{UserID: roleMember.UserID, RoleID: roleMember.RoleID}) - req.Len(roleMembers, 0) - }) - }) - // t.Run("update", func(t *testing.T) { // req, roleMember := truncAndCreate(t) @@ -95,4 +79,20 @@ func testRoleMembers(t *testing.T, s store.RoleMembers) { // req.Len(set, 1) // }) // }) + + t.Run("delete", func(t *testing.T) { + t.Run("by role member", func(t *testing.T) { + req, roleMember := truncAndCreate(t) + req.NoError(s.DeleteRoleMember(ctx, roleMember)) + roleMembers, _, _ := s.SearchRoleMembers(ctx, types.RoleMemberFilter{UserID: roleMember.UserID, RoleID: roleMember.RoleID}) + req.Len(roleMembers, 0) + }) + + t.Run("by RoleID and UserID", func(t *testing.T) { + req, roleMember := truncAndCreate(t) + req.NoError(s.DeleteRoleMemberByUserIDRoleID(ctx, roleMember.UserID, roleMember.RoleID)) + roleMembers, _, _ := s.SearchRoleMembers(ctx, types.RoleMemberFilter{UserID: roleMember.UserID, RoleID: roleMember.RoleID}) + req.Len(roleMembers, 0) + }) + }) } diff --git a/store/tests/settings_test.go b/store/tests/settings_test.go index 876d334fe..b508e0545 100644 --- a/store/tests/settings_test.go +++ b/store/tests/settings_test.go @@ -74,7 +74,7 @@ func testSettings(t *testing.T, s store.Settings) { }) t.Run("delete", func(t *testing.T) { - t.Run("by settings", func(t *testing.T) { + t.Run("by Settings", func(t *testing.T) { req, setting := truncAndCreate(t) req.NoError(s.DeleteSetting(ctx, setting)) set, _, err := s.SearchSettings(ctx, types.SettingsFilter{OwnedBy: setting.OwnedBy})