From d00364181063c1d411f8059ef4957a2eded241fd Mon Sep 17 00:00:00 2001 From: Cory Slep Date: Sat, 4 Jul 2020 17:47:17 +0200 Subject: [PATCH] Add unit tests for federated announce --- pub/federating_wrapped_callbacks.go | 8 +- pub/federating_wrapped_callbacks_test.go | 158 ++++++++++++++++++++++- 2 files changed, 158 insertions(+), 8 deletions(-) diff --git a/pub/federating_wrapped_callbacks.go b/pub/federating_wrapped_callbacks.go index 8822fcc..a406acb 100644 --- a/pub/federating_wrapped_callbacks.go +++ b/pub/federating_wrapped_callbacks.go @@ -865,9 +865,11 @@ func (w FederatingWrappedCallbacks) announce(c context.Context, a vocab.Activity } return nil } - for iter := op.Begin(); iter != op.End(); iter = iter.Next() { - if err := loopFn(iter); err != nil { - return err + if op != nil { + for iter := op.Begin(); iter != op.End(); iter = iter.Next() { + if err := loopFn(iter); err != nil { + return err + } } } if w.Announce != nil { diff --git a/pub/federating_wrapped_callbacks_test.go b/pub/federating_wrapped_callbacks_test.go index 73710ae..728cbee 100644 --- a/pub/federating_wrapped_callbacks_test.go +++ b/pub/federating_wrapped_callbacks_test.go @@ -1495,20 +1495,168 @@ func TestFederatedLike(t *testing.T) { } func TestFederatedAnnounce(t *testing.T) { + newAnnounceFn := func() vocab.ActivityStreamsAnnounce { + a := streams.NewActivityStreamsAnnounce() + id := streams.NewJSONLDIdProperty() + id.Set(mustParse(testFederatedActivityIRI)) + a.SetJSONLDId(id) + actor := streams.NewActivityStreamsActorProperty() + actor.AppendIRI(mustParse(testFederatedActorIRI)) + a.SetActivityStreamsActor(actor) + op := streams.NewActivityStreamsObjectProperty() + op.AppendActivityStreamsNote(testFederatedNote) + a.SetActivityStreamsObject(op) + return a + } + ctx := context.Background() + setupFn := func(ctl *gomock.Controller) (w FederatingWrappedCallbacks, mockDB *MockDatabase) { + mockDB = NewMockDatabase(ctl) + w.db = mockDB + return + } + t.Run("DoesNothingWhenNoObjects", func(t *testing.T) { + a := newAnnounceFn() + a.SetActivityStreamsObject(nil) + var w FederatingWrappedCallbacks + err := w.announce(ctx, a) + if err != nil { + t.Fatalf("got error %s", err) + } + }) t.Run("SkipsUnownedObjects", func(t *testing.T) { - t.Errorf("Not yet implemented.") + ctl := gomock.NewController(t) + defer ctl.Finish() + w, mockDB := setupFn(ctl) + mockDB.EXPECT().Lock(ctx, mustParse(testNoteId1)) + mockDB.EXPECT().Owns(ctx, mustParse(testNoteId1)).Return( + false, nil) + mockDB.EXPECT().Unlock(ctx, mustParse(testNoteId1)) + a := newAnnounceFn() + err := w.announce(ctx, a) + if err != nil { + t.Fatalf("got error %s", err) + } }) t.Run("AddsToNewSharesCollection", func(t *testing.T) { - t.Errorf("Not yet implemented.") + ctl := gomock.NewController(t) + defer ctl.Finish() + w, mockDB := setupFn(ctl) + note := streams.NewActivityStreamsNote() + expectNote := streams.NewActivityStreamsNote() + expectShares := streams.NewActivityStreamsSharesProperty() + expectCol := streams.NewActivityStreamsCollection() + expectItems := streams.NewActivityStreamsItemsProperty() + expectItems.AppendIRI(mustParse(testFederatedActivityIRI)) + expectCol.SetActivityStreamsItems(expectItems) + expectShares.SetActivityStreamsCollection(expectCol) + expectNote.SetActivityStreamsShares(expectShares) + mockDB.EXPECT().Lock(ctx, mustParse(testNoteId1)) + mockDB.EXPECT().Owns(ctx, mustParse(testNoteId1)).Return( + true, nil) + mockDB.EXPECT().Get(ctx, mustParse(testNoteId1)).Return( + note, nil) + mockDB.EXPECT().Update(ctx, expectNote).Return(nil) + mockDB.EXPECT().Unlock(ctx, mustParse(testNoteId1)) + a := newAnnounceFn() + err := w.announce(ctx, a) + if err != nil { + t.Fatalf("got error %s", err) + } }) t.Run("AddsToExistingSharesCollection", func(t *testing.T) { - t.Errorf("Not yet implemented.") + ctl := gomock.NewController(t) + defer ctl.Finish() + w, mockDB := setupFn(ctl) + note := streams.NewActivityStreamsNote() + shares := streams.NewActivityStreamsSharesProperty() + col := streams.NewActivityStreamsCollection() + items := streams.NewActivityStreamsItemsProperty() + items.AppendIRI(mustParse(testFederatedActivityIRI2)) + col.SetActivityStreamsItems(items) + shares.SetActivityStreamsCollection(col) + note.SetActivityStreamsShares(shares) + expectNote := streams.NewActivityStreamsNote() + expectShares := streams.NewActivityStreamsSharesProperty() + expectCol := streams.NewActivityStreamsCollection() + expectItems := streams.NewActivityStreamsItemsProperty() + expectItems.AppendIRI(mustParse(testFederatedActivityIRI)) + expectItems.AppendIRI(mustParse(testFederatedActivityIRI2)) + expectCol.SetActivityStreamsItems(expectItems) + expectShares.SetActivityStreamsCollection(expectCol) + expectNote.SetActivityStreamsShares(expectShares) + mockDB.EXPECT().Lock(ctx, mustParse(testNoteId1)) + mockDB.EXPECT().Owns(ctx, mustParse(testNoteId1)).Return( + true, nil) + mockDB.EXPECT().Get(ctx, mustParse(testNoteId1)).Return( + note, nil) + mockDB.EXPECT().Update(ctx, expectNote).Return(nil) + mockDB.EXPECT().Unlock(ctx, mustParse(testNoteId1)) + a := newAnnounceFn() + err := w.announce(ctx, a) + if err != nil { + t.Fatalf("got error %s", err) + } }) t.Run("AddsToExistingSharesOrderedCollection", func(t *testing.T) { - t.Errorf("Not yet implemented.") + ctl := gomock.NewController(t) + defer ctl.Finish() + w, mockDB := setupFn(ctl) + note := streams.NewActivityStreamsNote() + shares := streams.NewActivityStreamsSharesProperty() + col := streams.NewActivityStreamsOrderedCollection() + items := streams.NewActivityStreamsOrderedItemsProperty() + items.AppendIRI(mustParse(testFederatedActivityIRI2)) + col.SetActivityStreamsOrderedItems(items) + shares.SetActivityStreamsOrderedCollection(col) + note.SetActivityStreamsShares(shares) + expectNote := streams.NewActivityStreamsNote() + expectShares := streams.NewActivityStreamsSharesProperty() + expectCol := streams.NewActivityStreamsOrderedCollection() + expectItems := streams.NewActivityStreamsOrderedItemsProperty() + expectItems.AppendIRI(mustParse(testFederatedActivityIRI)) + expectItems.AppendIRI(mustParse(testFederatedActivityIRI2)) + expectCol.SetActivityStreamsOrderedItems(expectItems) + expectShares.SetActivityStreamsOrderedCollection(expectCol) + expectNote.SetActivityStreamsShares(expectShares) + mockDB.EXPECT().Lock(ctx, mustParse(testNoteId1)) + mockDB.EXPECT().Owns(ctx, mustParse(testNoteId1)).Return( + true, nil) + mockDB.EXPECT().Get(ctx, mustParse(testNoteId1)).Return( + note, nil) + mockDB.EXPECT().Update(ctx, expectNote).Return(nil) + mockDB.EXPECT().Unlock(ctx, mustParse(testNoteId1)) + a := newAnnounceFn() + err := w.announce(ctx, a) + if err != nil { + t.Fatalf("got error %s", err) + } }) t.Run("CallsCustomCallback", func(t *testing.T) { - t.Errorf("Not yet implemented.") + ctl := gomock.NewController(t) + defer ctl.Finish() + w, mockDB := setupFn(ctl) + note := streams.NewActivityStreamsNote() + mockDB.EXPECT().Lock(ctx, mustParse(testNoteId1)) + mockDB.EXPECT().Owns(ctx, mustParse(testNoteId1)).Return( + true, nil) + mockDB.EXPECT().Get(ctx, mustParse(testNoteId1)).Return( + note, nil) + mockDB.EXPECT().Update(ctx, gomock.Any()).Return(nil) + mockDB.EXPECT().Unlock(ctx, mustParse(testNoteId1)) + var gotc context.Context + var got vocab.ActivityStreamsAnnounce + w.Announce = func(ctx context.Context, v vocab.ActivityStreamsAnnounce) error { + gotc = ctx + got = v + return nil + } + a := newAnnounceFn() + err := w.announce(ctx, a) + if err != nil { + t.Fatalf("got error %s", err) + } + assertEqual(t, ctx, gotc) + assertEqual(t, a, got) }) }