674 行
23 KiB
Go
674 行
23 KiB
Go
package pub
|
|
|
|
import (
|
|
"context"
|
|
"github.com/go-fed/activity/streams/vocab"
|
|
"github.com/golang/mock/gomock"
|
|
"net/http/httptest"
|
|
"net/url"
|
|
"testing"
|
|
)
|
|
|
|
// TestPassThroughMethods tests the methods that pass-through to other
|
|
// dependency-injected types.
|
|
func TestPassThroughMethods(t *testing.T) {
|
|
ctx := context.Background()
|
|
resp := httptest.NewRecorder()
|
|
setupFn := func(ctl *gomock.Controller) (c *MockCommonBehavior, fp *MockFederatingProtocol, sp *MockSocialProtocol, db *MockDatabase, cl *MockClock, a DelegateActor) {
|
|
setupData()
|
|
c = NewMockCommonBehavior(ctl)
|
|
fp = NewMockFederatingProtocol(ctl)
|
|
sp = NewMockSocialProtocol(ctl)
|
|
db = NewMockDatabase(ctl)
|
|
cl = NewMockClock(ctl)
|
|
a = &sideEffectActor{
|
|
common: c,
|
|
s2s: fp,
|
|
c2s: sp,
|
|
db: db,
|
|
clock: cl,
|
|
}
|
|
return
|
|
}
|
|
// Run tests
|
|
t.Run("AuthenticatePostInbox", func(t *testing.T) {
|
|
// Setup
|
|
ctl := gomock.NewController(t)
|
|
defer ctl.Finish()
|
|
_, fp, _, _, _, a := setupFn(ctl)
|
|
req := toAPRequest(toPostInboxRequest(testCreate))
|
|
fp.EXPECT().AuthenticatePostInbox(ctx, resp, req).Return(true, testErr)
|
|
// Run
|
|
b, err := a.AuthenticatePostInbox(ctx, resp, req)
|
|
// Verify
|
|
assertEqual(t, b, true)
|
|
assertEqual(t, err, testErr)
|
|
})
|
|
t.Run("AuthenticateGetInbox", func(t *testing.T) {
|
|
// Setup
|
|
ctl := gomock.NewController(t)
|
|
defer ctl.Finish()
|
|
c, _, _, _, _, a := setupFn(ctl)
|
|
req := toAPRequest(toGetInboxRequest())
|
|
c.EXPECT().AuthenticateGetInbox(ctx, resp, req).Return(true, testErr)
|
|
// Run
|
|
b, err := a.AuthenticateGetInbox(ctx, resp, req)
|
|
// Verify
|
|
assertEqual(t, b, true)
|
|
assertEqual(t, err, testErr)
|
|
})
|
|
t.Run("AuthenticatePostOutbox", func(t *testing.T) {
|
|
// Setup
|
|
ctl := gomock.NewController(t)
|
|
defer ctl.Finish()
|
|
_, _, sp, _, _, a := setupFn(ctl)
|
|
req := toAPRequest(toPostOutboxRequest(testCreate))
|
|
sp.EXPECT().AuthenticatePostOutbox(ctx, resp, req).Return(true, testErr)
|
|
// Run
|
|
b, err := a.AuthenticatePostOutbox(ctx, resp, req)
|
|
// Verify
|
|
assertEqual(t, b, true)
|
|
assertEqual(t, err, testErr)
|
|
})
|
|
t.Run("AuthenticateGetOutbox", func(t *testing.T) {
|
|
// Setup
|
|
ctl := gomock.NewController(t)
|
|
defer ctl.Finish()
|
|
c, _, _, _, _, a := setupFn(ctl)
|
|
req := toAPRequest(toGetOutboxRequest())
|
|
c.EXPECT().AuthenticateGetOutbox(ctx, resp, req).Return(true, testErr)
|
|
// Run
|
|
b, err := a.AuthenticateGetOutbox(ctx, resp, req)
|
|
// Verify
|
|
assertEqual(t, b, true)
|
|
assertEqual(t, err, testErr)
|
|
})
|
|
t.Run("GetOutbox", func(t *testing.T) {
|
|
// Setup
|
|
ctl := gomock.NewController(t)
|
|
defer ctl.Finish()
|
|
_, _, sp, _, _, a := setupFn(ctl)
|
|
req := toAPRequest(toGetOutboxRequest())
|
|
sp.EXPECT().GetOutbox(ctx, req).Return(testOrderedCollectionUniqueElems, testErr)
|
|
// Run
|
|
p, err := a.GetOutbox(ctx, req)
|
|
// Verify
|
|
assertEqual(t, p, testOrderedCollectionUniqueElems)
|
|
assertEqual(t, err, testErr)
|
|
})
|
|
t.Run("GetInbox", func(t *testing.T) {
|
|
// Setup
|
|
ctl := gomock.NewController(t)
|
|
defer ctl.Finish()
|
|
_, fp, _, _, _, a := setupFn(ctl)
|
|
req := toAPRequest(toGetInboxRequest())
|
|
fp.EXPECT().GetInbox(ctx, req).Return(testOrderedCollectionUniqueElems, testErr)
|
|
// Run
|
|
p, err := a.GetInbox(ctx, req)
|
|
// Verify
|
|
assertEqual(t, p, testOrderedCollectionUniqueElems)
|
|
assertEqual(t, err, testErr)
|
|
})
|
|
}
|
|
|
|
// TestAuthorizePostInbox tests the Authorization for a federated message, which
|
|
// is only based on blocks.
|
|
func TestAuthorizePostInbox(t *testing.T) {
|
|
ctx := context.Background()
|
|
resp := httptest.NewRecorder()
|
|
setupFn := func(ctl *gomock.Controller) (c *MockCommonBehavior, fp *MockFederatingProtocol, sp *MockSocialProtocol, db *MockDatabase, cl *MockClock, a DelegateActor) {
|
|
setupData()
|
|
c = NewMockCommonBehavior(ctl)
|
|
fp = NewMockFederatingProtocol(ctl)
|
|
sp = NewMockSocialProtocol(ctl)
|
|
db = NewMockDatabase(ctl)
|
|
cl = NewMockClock(ctl)
|
|
a = &sideEffectActor{
|
|
common: c,
|
|
s2s: fp,
|
|
c2s: sp,
|
|
db: db,
|
|
clock: cl,
|
|
}
|
|
return
|
|
}
|
|
// Run tests
|
|
t.Run("ActorAuthorized", func(t *testing.T) {
|
|
// Setup
|
|
ctl := gomock.NewController(t)
|
|
defer ctl.Finish()
|
|
_, fp, _, _, _, a := setupFn(ctl)
|
|
fp.EXPECT().Blocked(ctx, []*url.URL{mustParse(testFederatedActorIRI)}).Return(false, nil)
|
|
// Run
|
|
b, err := a.AuthorizePostInbox(ctx, resp, testCreate)
|
|
// Verify
|
|
assertEqual(t, b, true)
|
|
assertEqual(t, err, nil)
|
|
})
|
|
t.Run("ActorNotAuthorized", func(t *testing.T) {
|
|
// Setup
|
|
ctl := gomock.NewController(t)
|
|
defer ctl.Finish()
|
|
_, fp, _, _, _, a := setupFn(ctl)
|
|
fp.EXPECT().Blocked(ctx, []*url.URL{mustParse(testFederatedActorIRI)}).Return(true, nil)
|
|
// Run
|
|
b, err := a.AuthorizePostInbox(ctx, resp, testCreate)
|
|
// Verify
|
|
assertEqual(t, b, false)
|
|
assertEqual(t, err, nil)
|
|
})
|
|
t.Run("AllActorsAuthorized", func(t *testing.T) {
|
|
// Setup
|
|
ctl := gomock.NewController(t)
|
|
defer ctl.Finish()
|
|
_, fp, _, _, _, a := setupFn(ctl)
|
|
fp.EXPECT().Blocked(ctx, []*url.URL{mustParse(testFederatedActorIRI), mustParse(testFederatedActorIRI2)}).Return(false, nil)
|
|
// Run
|
|
b, err := a.AuthorizePostInbox(ctx, resp, testCreate2)
|
|
// Verify
|
|
assertEqual(t, b, true)
|
|
assertEqual(t, err, nil)
|
|
})
|
|
t.Run("OneActorNotAuthorized", func(t *testing.T) {
|
|
// Setup
|
|
ctl := gomock.NewController(t)
|
|
defer ctl.Finish()
|
|
_, fp, _, _, _, a := setupFn(ctl)
|
|
fp.EXPECT().Blocked(ctx, []*url.URL{mustParse(testFederatedActorIRI), mustParse(testFederatedActorIRI2)}).Return(true, nil)
|
|
// Run
|
|
b, err := a.AuthorizePostInbox(ctx, resp, testCreate2)
|
|
// Verify
|
|
assertEqual(t, b, false)
|
|
assertEqual(t, err, nil)
|
|
})
|
|
}
|
|
|
|
// TestPostInbox ensures that the main application side effects of receiving a
|
|
// federated message occur.
|
|
func TestPostInbox(t *testing.T) {
|
|
ctx := context.Background()
|
|
setupFn := func(ctl *gomock.Controller) (c *MockCommonBehavior, fp *MockFederatingProtocol, sp *MockSocialProtocol, db *MockDatabase, cl *MockClock, a DelegateActor) {
|
|
setupData()
|
|
c = NewMockCommonBehavior(ctl)
|
|
fp = NewMockFederatingProtocol(ctl)
|
|
sp = NewMockSocialProtocol(ctl)
|
|
db = NewMockDatabase(ctl)
|
|
cl = NewMockClock(ctl)
|
|
a = &sideEffectActor{
|
|
common: c,
|
|
s2s: fp,
|
|
c2s: sp,
|
|
db: db,
|
|
clock: cl,
|
|
}
|
|
return
|
|
}
|
|
// Run tests
|
|
t.Run("AddsToEmptyInbox", func(t *testing.T) {
|
|
// Setup
|
|
ctl := gomock.NewController(t)
|
|
defer ctl.Finish()
|
|
_, fp, _, db, _, a := setupFn(ctl)
|
|
inboxIRI := mustParse(testMyInboxIRI)
|
|
gomock.InOrder(
|
|
db.EXPECT().Lock(ctx, inboxIRI),
|
|
db.EXPECT().InboxContains(ctx, inboxIRI, mustParse(testFederatedActivityIRI)).Return(false, nil),
|
|
db.EXPECT().GetInbox(ctx, inboxIRI).Return(testEmptyOrderedCollection, nil),
|
|
db.EXPECT().SetInbox(ctx, testOrderedCollectionWithFederatedId).Return(nil),
|
|
db.EXPECT().Unlock(ctx, inboxIRI),
|
|
)
|
|
fp.EXPECT().Callbacks(ctx).Return(FederatingWrappedCallbacks{}, nil)
|
|
fp.EXPECT().DefaultCallback(ctx, testListen).Return(nil)
|
|
// Run
|
|
err := a.PostInbox(ctx, inboxIRI, testListen)
|
|
// Verify
|
|
assertEqual(t, err, nil)
|
|
})
|
|
t.Run("DoesNotAddToInboxNorDoSideEffectsIfDuplicate", func(t *testing.T) {
|
|
// Setup
|
|
ctl := gomock.NewController(t)
|
|
defer ctl.Finish()
|
|
_, _, _, db, _, a := setupFn(ctl)
|
|
inboxIRI := mustParse(testMyInboxIRI)
|
|
gomock.InOrder(
|
|
db.EXPECT().Lock(ctx, inboxIRI),
|
|
db.EXPECT().InboxContains(ctx, inboxIRI, mustParse(testFederatedActivityIRI)).Return(true, nil),
|
|
db.EXPECT().Unlock(ctx, inboxIRI),
|
|
)
|
|
// Run
|
|
err := a.PostInbox(ctx, inboxIRI, testListen)
|
|
// Verify
|
|
assertEqual(t, err, nil)
|
|
})
|
|
t.Run("AddsToInbox", func(t *testing.T) {
|
|
// Setup
|
|
ctl := gomock.NewController(t)
|
|
defer ctl.Finish()
|
|
_, fp, _, db, _, a := setupFn(ctl)
|
|
inboxIRI := mustParse(testMyInboxIRI)
|
|
gomock.InOrder(
|
|
db.EXPECT().Lock(ctx, inboxIRI),
|
|
db.EXPECT().InboxContains(ctx, inboxIRI, mustParse(testFederatedActivityIRI)).Return(false, nil),
|
|
db.EXPECT().GetInbox(ctx, inboxIRI).Return(testOrderedCollectionWithFederatedId2, nil),
|
|
db.EXPECT().SetInbox(ctx, testOrderedCollectionWithBothFederatedIds).Return(nil),
|
|
db.EXPECT().Unlock(ctx, inboxIRI),
|
|
)
|
|
fp.EXPECT().Callbacks(ctx).Return(FederatingWrappedCallbacks{}, nil)
|
|
fp.EXPECT().DefaultCallback(ctx, testListen).Return(nil)
|
|
// Run
|
|
err := a.PostInbox(ctx, inboxIRI, testListen)
|
|
// Verify
|
|
assertEqual(t, err, nil)
|
|
})
|
|
t.Run("ResolvesToCustomFunction", func(t *testing.T) {
|
|
// Setup
|
|
ctl := gomock.NewController(t)
|
|
defer ctl.Finish()
|
|
_, fp, _, db, _, a := setupFn(ctl)
|
|
inboxIRI := mustParse(testMyInboxIRI)
|
|
gomock.InOrder(
|
|
db.EXPECT().Lock(ctx, inboxIRI),
|
|
db.EXPECT().InboxContains(ctx, inboxIRI, mustParse(testFederatedActivityIRI)).Return(false, nil),
|
|
db.EXPECT().GetInbox(ctx, inboxIRI).Return(testEmptyOrderedCollection, nil),
|
|
db.EXPECT().SetInbox(ctx, testOrderedCollectionWithFederatedId).Return(nil),
|
|
db.EXPECT().Unlock(ctx, inboxIRI),
|
|
)
|
|
pass := false
|
|
fp.EXPECT().Callbacks(ctx).Return(FederatingWrappedCallbacks{}, []interface{}{
|
|
func(c context.Context, a vocab.ActivityStreamsListen) error {
|
|
pass = true
|
|
return nil
|
|
},
|
|
})
|
|
// Run
|
|
err := a.PostInbox(ctx, inboxIRI, testListen)
|
|
// Verify
|
|
assertEqual(t, err, nil)
|
|
assertEqual(t, pass, true)
|
|
})
|
|
t.Run("ResolvesToOverriddenFunction", func(t *testing.T) {
|
|
// Setup
|
|
ctl := gomock.NewController(t)
|
|
defer ctl.Finish()
|
|
_, fp, _, db, _, a := setupFn(ctl)
|
|
inboxIRI := mustParse(testMyInboxIRI)
|
|
gomock.InOrder(
|
|
db.EXPECT().Lock(ctx, inboxIRI),
|
|
db.EXPECT().InboxContains(ctx, inboxIRI, mustParse(testFederatedActivityIRI)).Return(false, nil),
|
|
db.EXPECT().GetInbox(ctx, inboxIRI).Return(testEmptyOrderedCollection, nil),
|
|
db.EXPECT().SetInbox(ctx, testOrderedCollectionWithFederatedId).Return(nil),
|
|
db.EXPECT().Unlock(ctx, inboxIRI),
|
|
)
|
|
pass := false
|
|
fp.EXPECT().Callbacks(ctx).Return(FederatingWrappedCallbacks{}, []interface{}{
|
|
func(c context.Context, a vocab.ActivityStreamsCreate) error {
|
|
pass = true
|
|
return nil
|
|
},
|
|
})
|
|
// Run
|
|
err := a.PostInbox(ctx, inboxIRI, testCreate)
|
|
// Verify
|
|
assertEqual(t, err, nil)
|
|
assertEqual(t, pass, true)
|
|
})
|
|
t.Run("ResolvesToDefaultFunction", func(t *testing.T) {
|
|
// Setup
|
|
ctl := gomock.NewController(t)
|
|
defer ctl.Finish()
|
|
_, fp, _, db, _, a := setupFn(ctl)
|
|
inboxIRI := mustParse(testMyInboxIRI)
|
|
gomock.InOrder(
|
|
db.EXPECT().Lock(ctx, inboxIRI),
|
|
db.EXPECT().InboxContains(ctx, inboxIRI, mustParse(testFederatedActivityIRI)).Return(false, nil),
|
|
db.EXPECT().GetInbox(ctx, inboxIRI).Return(testEmptyOrderedCollection, nil),
|
|
db.EXPECT().SetInbox(ctx, testOrderedCollectionWithFederatedId).Return(nil),
|
|
db.EXPECT().Unlock(ctx, inboxIRI),
|
|
)
|
|
pass := false
|
|
fp.EXPECT().Callbacks(ctx).Return(FederatingWrappedCallbacks{
|
|
Create: func(c context.Context, a vocab.ActivityStreamsCreate) error {
|
|
pass = true
|
|
return nil
|
|
},
|
|
}, nil)
|
|
db.EXPECT().Lock(ctx, mustParse(testNoteId1))
|
|
db.EXPECT().Create(ctx, testFederatedNote)
|
|
db.EXPECT().Unlock(ctx, mustParse(testNoteId1))
|
|
// Run
|
|
err := a.PostInbox(ctx, inboxIRI, testCreate)
|
|
// Verify
|
|
assertEqual(t, err, nil)
|
|
assertEqual(t, pass, true)
|
|
})
|
|
}
|
|
|
|
// TestInboxForwarding ensures that the inbox forwarding logic is correct.
|
|
func TestInboxForwarding(t *testing.T) {
|
|
ctx := context.Background()
|
|
setupFn := func(ctl *gomock.Controller) (c *MockCommonBehavior, fp *MockFederatingProtocol, sp *MockSocialProtocol, db *MockDatabase, cl *MockClock, a DelegateActor) {
|
|
setupData()
|
|
c = NewMockCommonBehavior(ctl)
|
|
fp = NewMockFederatingProtocol(ctl)
|
|
sp = NewMockSocialProtocol(ctl)
|
|
db = NewMockDatabase(ctl)
|
|
cl = NewMockClock(ctl)
|
|
a = &sideEffectActor{
|
|
common: c,
|
|
s2s: fp,
|
|
c2s: sp,
|
|
db: db,
|
|
clock: cl,
|
|
}
|
|
return
|
|
}
|
|
t.Run("DoesNotForwardIfAlreadyExists", func(t *testing.T) {
|
|
// Setup
|
|
ctl := gomock.NewController(t)
|
|
defer ctl.Finish()
|
|
_, _, _, db, _, a := setupFn(ctl)
|
|
gomock.InOrder(
|
|
db.EXPECT().Lock(ctx, mustParse(testFederatedActivityIRI)),
|
|
db.EXPECT().Exists(ctx, mustParse(testFederatedActivityIRI)).Return(true, nil),
|
|
db.EXPECT().Unlock(ctx, mustParse(testFederatedActivityIRI)),
|
|
)
|
|
// Run
|
|
err := a.InboxForwarding(ctx, mustParse(testMyInboxIRI), testListen)
|
|
// Verify
|
|
assertEqual(t, err, nil)
|
|
})
|
|
t.Run("DoesNotForwardIfToCollectionNotOwned", func(t *testing.T) {
|
|
// Setup
|
|
ctl := gomock.NewController(t)
|
|
defer ctl.Finish()
|
|
_, _, _, db, _, a := setupFn(ctl)
|
|
input := addToIds(testListen)
|
|
gomock.InOrder(
|
|
db.EXPECT().Lock(ctx, mustParse(testFederatedActivityIRI)),
|
|
db.EXPECT().Exists(ctx, mustParse(testFederatedActivityIRI)).Return(false, nil),
|
|
db.EXPECT().Create(ctx, input).Return(nil),
|
|
db.EXPECT().Unlock(ctx, mustParse(testFederatedActivityIRI)),
|
|
db.EXPECT().Lock(ctx, mustParse(testToIRI)),
|
|
db.EXPECT().Owns(ctx, mustParse(testToIRI)).Return(false, nil),
|
|
db.EXPECT().Unlock(ctx, mustParse(testToIRI)),
|
|
db.EXPECT().Lock(ctx, mustParse(testToIRI2)),
|
|
db.EXPECT().Owns(ctx, mustParse(testToIRI2)).Return(false, nil),
|
|
db.EXPECT().Unlock(ctx, mustParse(testToIRI2)),
|
|
)
|
|
// Run
|
|
err := a.InboxForwarding(ctx, mustParse(testMyInboxIRI), input)
|
|
// Verify
|
|
assertEqual(t, err, nil)
|
|
})
|
|
t.Run("DoesNotForwardIfCcCollectionNotOwned", func(t *testing.T) {
|
|
// Setup
|
|
ctl := gomock.NewController(t)
|
|
defer ctl.Finish()
|
|
_, _, _, db, _, a := setupFn(ctl)
|
|
input := mustAddCcIds(testListen)
|
|
gomock.InOrder(
|
|
db.EXPECT().Lock(ctx, mustParse(testFederatedActivityIRI)),
|
|
db.EXPECT().Exists(ctx, mustParse(testFederatedActivityIRI)).Return(false, nil),
|
|
db.EXPECT().Create(ctx, input).Return(nil),
|
|
db.EXPECT().Unlock(ctx, mustParse(testFederatedActivityIRI)),
|
|
db.EXPECT().Lock(ctx, mustParse(testCcIRI)),
|
|
db.EXPECT().Owns(ctx, mustParse(testCcIRI)).Return(false, nil),
|
|
db.EXPECT().Unlock(ctx, mustParse(testCcIRI)),
|
|
db.EXPECT().Lock(ctx, mustParse(testCcIRI2)),
|
|
db.EXPECT().Owns(ctx, mustParse(testCcIRI2)).Return(false, nil),
|
|
db.EXPECT().Unlock(ctx, mustParse(testCcIRI2)),
|
|
)
|
|
// Run
|
|
err := a.InboxForwarding(ctx, mustParse(testMyInboxIRI), input)
|
|
// Verify
|
|
assertEqual(t, err, nil)
|
|
})
|
|
t.Run("DoesNotForwardIfAudienceCollectionNotOwned", func(t *testing.T) {
|
|
// Setup
|
|
ctl := gomock.NewController(t)
|
|
defer ctl.Finish()
|
|
_, _, _, db, _, a := setupFn(ctl)
|
|
input := mustAddAudienceIds(testListen)
|
|
gomock.InOrder(
|
|
db.EXPECT().Lock(ctx, mustParse(testFederatedActivityIRI)),
|
|
db.EXPECT().Exists(ctx, mustParse(testFederatedActivityIRI)).Return(false, nil),
|
|
db.EXPECT().Create(ctx, input).Return(nil),
|
|
db.EXPECT().Unlock(ctx, mustParse(testFederatedActivityIRI)),
|
|
db.EXPECT().Lock(ctx, mustParse(testAudienceIRI)),
|
|
db.EXPECT().Owns(ctx, mustParse(testAudienceIRI)).Return(false, nil),
|
|
db.EXPECT().Unlock(ctx, mustParse(testAudienceIRI)),
|
|
db.EXPECT().Lock(ctx, mustParse(testAudienceIRI2)),
|
|
db.EXPECT().Owns(ctx, mustParse(testAudienceIRI2)).Return(false, nil),
|
|
db.EXPECT().Unlock(ctx, mustParse(testAudienceIRI2)),
|
|
)
|
|
// Run
|
|
err := a.InboxForwarding(ctx, mustParse(testMyInboxIRI), input)
|
|
// Verify
|
|
assertEqual(t, err, nil)
|
|
})
|
|
t.Run("DoesNotForwardIfToOwnedButNotCollection", func(t *testing.T) {
|
|
// Setup
|
|
ctl := gomock.NewController(t)
|
|
defer ctl.Finish()
|
|
_, _, _, db, _, a := setupFn(ctl)
|
|
input := addToIds(testListen)
|
|
gomock.InOrder(
|
|
db.EXPECT().Lock(ctx, mustParse(testFederatedActivityIRI)),
|
|
db.EXPECT().Exists(ctx, mustParse(testFederatedActivityIRI)).Return(false, nil),
|
|
db.EXPECT().Create(ctx, input).Return(nil),
|
|
db.EXPECT().Unlock(ctx, mustParse(testFederatedActivityIRI)),
|
|
db.EXPECT().Lock(ctx, mustParse(testToIRI)),
|
|
db.EXPECT().Owns(ctx, mustParse(testToIRI)).Return(true, nil),
|
|
db.EXPECT().Unlock(ctx, mustParse(testToIRI)),
|
|
db.EXPECT().Lock(ctx, mustParse(testToIRI2)),
|
|
db.EXPECT().Owns(ctx, mustParse(testToIRI2)).Return(true, nil),
|
|
db.EXPECT().Unlock(ctx, mustParse(testToIRI2)),
|
|
db.EXPECT().Lock(ctx, mustParse(testToIRI)),
|
|
db.EXPECT().Get(ctx, mustParse(testToIRI)).Return(testPerson, nil),
|
|
db.EXPECT().Unlock(ctx, mustParse(testToIRI)),
|
|
db.EXPECT().Lock(ctx, mustParse(testToIRI2)),
|
|
db.EXPECT().Get(ctx, mustParse(testToIRI2)).Return(testService, nil),
|
|
db.EXPECT().Unlock(ctx, mustParse(testToIRI2)),
|
|
// Deferred
|
|
db.EXPECT().Unlock(ctx, mustParse(testToIRI2)),
|
|
db.EXPECT().Unlock(ctx, mustParse(testToIRI)),
|
|
)
|
|
// Run
|
|
err := a.InboxForwarding(ctx, mustParse(testMyInboxIRI), input)
|
|
// Verify
|
|
assertEqual(t, err, nil)
|
|
})
|
|
t.Run("DoesNotForwardIfCcOwnedButNotCollection", func(t *testing.T) {
|
|
// Setup
|
|
ctl := gomock.NewController(t)
|
|
defer ctl.Finish()
|
|
_, _, _, db, _, a := setupFn(ctl)
|
|
input := mustAddCcIds(testListen)
|
|
gomock.InOrder(
|
|
db.EXPECT().Lock(ctx, mustParse(testFederatedActivityIRI)),
|
|
db.EXPECT().Exists(ctx, mustParse(testFederatedActivityIRI)).Return(false, nil),
|
|
db.EXPECT().Create(ctx, input).Return(nil),
|
|
db.EXPECT().Unlock(ctx, mustParse(testFederatedActivityIRI)),
|
|
db.EXPECT().Lock(ctx, mustParse(testCcIRI)),
|
|
db.EXPECT().Owns(ctx, mustParse(testCcIRI)).Return(true, nil),
|
|
db.EXPECT().Unlock(ctx, mustParse(testCcIRI)),
|
|
db.EXPECT().Lock(ctx, mustParse(testCcIRI2)),
|
|
db.EXPECT().Owns(ctx, mustParse(testCcIRI2)).Return(true, nil),
|
|
db.EXPECT().Unlock(ctx, mustParse(testCcIRI2)),
|
|
db.EXPECT().Lock(ctx, mustParse(testCcIRI)),
|
|
db.EXPECT().Get(ctx, mustParse(testCcIRI)).Return(testPerson, nil),
|
|
db.EXPECT().Unlock(ctx, mustParse(testCcIRI)),
|
|
db.EXPECT().Lock(ctx, mustParse(testCcIRI2)),
|
|
db.EXPECT().Get(ctx, mustParse(testCcIRI2)).Return(testService, nil),
|
|
db.EXPECT().Unlock(ctx, mustParse(testCcIRI2)),
|
|
// Deferred
|
|
db.EXPECT().Unlock(ctx, mustParse(testCcIRI2)),
|
|
db.EXPECT().Unlock(ctx, mustParse(testCcIRI)),
|
|
)
|
|
// Run
|
|
err := a.InboxForwarding(ctx, mustParse(testMyInboxIRI), input)
|
|
// Verify
|
|
assertEqual(t, err, nil)
|
|
})
|
|
t.Run("DoesNotForwardIfAudienceOwnedButNotCollection", func(t *testing.T) {
|
|
// Setup
|
|
ctl := gomock.NewController(t)
|
|
defer ctl.Finish()
|
|
_, _, _, db, _, a := setupFn(ctl)
|
|
input := mustAddAudienceIds(testListen)
|
|
gomock.InOrder(
|
|
db.EXPECT().Lock(ctx, mustParse(testFederatedActivityIRI)),
|
|
db.EXPECT().Exists(ctx, mustParse(testFederatedActivityIRI)).Return(false, nil),
|
|
db.EXPECT().Create(ctx, input).Return(nil),
|
|
db.EXPECT().Unlock(ctx, mustParse(testFederatedActivityIRI)),
|
|
db.EXPECT().Lock(ctx, mustParse(testAudienceIRI)),
|
|
db.EXPECT().Owns(ctx, mustParse(testAudienceIRI)).Return(true, nil),
|
|
db.EXPECT().Unlock(ctx, mustParse(testAudienceIRI)),
|
|
db.EXPECT().Lock(ctx, mustParse(testAudienceIRI2)),
|
|
db.EXPECT().Owns(ctx, mustParse(testAudienceIRI2)).Return(true, nil),
|
|
db.EXPECT().Unlock(ctx, mustParse(testAudienceIRI2)),
|
|
db.EXPECT().Lock(ctx, mustParse(testAudienceIRI)),
|
|
db.EXPECT().Get(ctx, mustParse(testAudienceIRI)).Return(testPerson, nil),
|
|
db.EXPECT().Unlock(ctx, mustParse(testAudienceIRI)),
|
|
db.EXPECT().Lock(ctx, mustParse(testAudienceIRI2)),
|
|
db.EXPECT().Get(ctx, mustParse(testAudienceIRI2)).Return(testService, nil),
|
|
db.EXPECT().Unlock(ctx, mustParse(testAudienceIRI2)),
|
|
// Deferred
|
|
db.EXPECT().Unlock(ctx, mustParse(testAudienceIRI2)),
|
|
db.EXPECT().Unlock(ctx, mustParse(testAudienceIRI)),
|
|
)
|
|
// Run
|
|
err := a.InboxForwarding(ctx, mustParse(testMyInboxIRI), input)
|
|
// Verify
|
|
assertEqual(t, err, nil)
|
|
})
|
|
t.Run("DoesNotForwardIfNoChainIsOwned", func(t *testing.T) {
|
|
t.Errorf("Not yet implemented.")
|
|
})
|
|
t.Run("ForwardsToRecipients", func(t *testing.T) {
|
|
t.Errorf("Not yet implemented.")
|
|
})
|
|
t.Run("ForwardsToRecipientsIfChainIsNested", func(t *testing.T) {
|
|
t.Errorf("Not yet implemented.")
|
|
})
|
|
t.Run("DoesNotForwardIfChainIsNestedTooDeep", func(t *testing.T) {
|
|
t.Errorf("Not yet implemented.")
|
|
})
|
|
t.Run("ForwardsToRecipientsIfChainNeedsDereferencing", func(t *testing.T) {
|
|
t.Errorf("Not yet implemented.")
|
|
})
|
|
}
|
|
|
|
// TestPostOutbox ensures that the main application side effects of receiving a
|
|
// social protocol message occur.
|
|
func TestPostOutbox(t *testing.T) {
|
|
t.Run("AddsToEmptyOutbox", func(t *testing.T) {
|
|
t.Errorf("Not yet implemented.")
|
|
})
|
|
t.Run("AddsToOutbox", func(t *testing.T) {
|
|
t.Errorf("Not yet implemented.")
|
|
})
|
|
t.Run("ResolvesToCustomFunction", func(t *testing.T) {
|
|
t.Errorf("Not yet implemented.")
|
|
})
|
|
t.Run("ResolvesToOverriddenFunction", func(t *testing.T) {
|
|
t.Errorf("Not yet implemented.")
|
|
})
|
|
t.Run("ResolvesToDefaultFunction", func(t *testing.T) {
|
|
t.Errorf("Not yet implemented.")
|
|
})
|
|
}
|
|
|
|
// TestAddNewIds ensures that new 'id' properties are set on an activity and all
|
|
// of its 'object' property values if it is a Create activity.
|
|
func TestAddNewIds(t *testing.T) {
|
|
t.Run("AddsIdToActivity", func(t *testing.T) {
|
|
t.Errorf("Not yet implemented.")
|
|
})
|
|
t.Run("AddsIdsToObjectsIfCreateActivity", func(t *testing.T) {
|
|
t.Errorf("Not yet implemented.")
|
|
})
|
|
t.Run("DoesNotAddIdsToObjectsIfNotCreateActivity", func(t *testing.T) {
|
|
t.Errorf("Not yet implemented.")
|
|
})
|
|
}
|
|
|
|
// TestDeliver ensures federated delivery of an activity happens correctly to
|
|
// the ActivityPub specification.
|
|
func TestDeliver(t *testing.T) {
|
|
t.Run("SendToRecipientsInTo", func(t *testing.T) {
|
|
t.Errorf("Not yet implemented.")
|
|
})
|
|
t.Run("SendToRecipientsInBto", func(t *testing.T) {
|
|
t.Errorf("Not yet implemented.")
|
|
})
|
|
t.Run("SendToRecipientsInCc", func(t *testing.T) {
|
|
t.Errorf("Not yet implemented.")
|
|
})
|
|
t.Run("SendToRecipientsInBcc", func(t *testing.T) {
|
|
t.Errorf("Not yet implemented.")
|
|
})
|
|
t.Run("SendToRecipientsInAudience", func(t *testing.T) {
|
|
t.Errorf("Not yet implemented.")
|
|
})
|
|
t.Run("DoesNotSendToPublicIRI", func(t *testing.T) {
|
|
t.Errorf("Not yet implemented.")
|
|
})
|
|
t.Run("RecursivelyResolveCollectionActors", func(t *testing.T) {
|
|
t.Errorf("Not yet implemented.")
|
|
})
|
|
t.Run("RecursivelyResolveOrderedCollectionActors", func(t *testing.T) {
|
|
t.Errorf("Not yet implemented.")
|
|
})
|
|
t.Run("DoesNotRecursivelyResolveCollectionActorsIfExceedingMaxDepth", func(t *testing.T) {
|
|
t.Errorf("Not yet implemented.")
|
|
})
|
|
t.Run("DoesNotSendIfMoreThanOneAttributedTo", func(t *testing.T) {
|
|
t.Errorf("Not yet implemented.")
|
|
})
|
|
t.Run("DoesNotSendIfThisActorIsNotInAttributedTo", func(t *testing.T) {
|
|
t.Errorf("Not yet implemented.")
|
|
})
|
|
t.Run("DedupesRecipients", func(t *testing.T) {
|
|
t.Errorf("Not yet implemented.")
|
|
})
|
|
t.Run("StripsBto", func(t *testing.T) {
|
|
t.Errorf("Not yet implemented.")
|
|
})
|
|
t.Run("StripsBcc", func(t *testing.T) {
|
|
t.Errorf("Not yet implemented.")
|
|
})
|
|
t.Run("ReturnsErrorIfAnyTransportRequestsFail", func(t *testing.T) {
|
|
t.Errorf("Not yet implemented.")
|
|
})
|
|
}
|
|
|
|
// TestWrapInCreate ensures an object received by the Social Protocol is
|
|
// properly wrapped in a Create Activity.
|
|
func TestWrapInCreate(t *testing.T) {
|
|
t.Run("CreateHasTo", func(t *testing.T) {
|
|
t.Errorf("Not yet implemented.")
|
|
})
|
|
t.Run("CreateHasCc", func(t *testing.T) {
|
|
t.Errorf("Not yet implemented.")
|
|
})
|
|
t.Run("CreateHasBto", func(t *testing.T) {
|
|
t.Errorf("Not yet implemented.")
|
|
})
|
|
t.Run("CreateHasBcc", func(t *testing.T) {
|
|
t.Errorf("Not yet implemented.")
|
|
})
|
|
t.Run("CreateHasAudience", func(t *testing.T) {
|
|
t.Errorf("Not yet implemented.")
|
|
})
|
|
t.Run("CreateHasPublished", func(t *testing.T) {
|
|
t.Errorf("Not yet implemented.")
|
|
})
|
|
t.Run("CreateHasActor", func(t *testing.T) {
|
|
t.Errorf("Not yet implemented.")
|
|
})
|
|
t.Run("CreateHasObject", func(t *testing.T) {
|
|
t.Errorf("Not yet implemented.")
|
|
})
|
|
}
|