532 lines
9.2 KiB
Go
532 lines
9.2 KiB
Go
package activitypub
|
|
|
|
import (
|
|
"reflect"
|
|
"testing"
|
|
)
|
|
|
|
func TestPathTyper_Type(t *testing.T) {
|
|
t.Skipf("TODO")
|
|
}
|
|
|
|
func TestValidActivityCollection(t *testing.T) {
|
|
t.Skipf("TODO")
|
|
}
|
|
|
|
func TestValidCollection(t *testing.T) {
|
|
t.Skipf("TODO")
|
|
}
|
|
|
|
func TestValidObjectCollection(t *testing.T) {
|
|
t.Skipf("TODO")
|
|
}
|
|
|
|
func TestValidCollectionIRI(t *testing.T) {
|
|
t.Skipf("TODO")
|
|
}
|
|
|
|
func TestSplit(t *testing.T) {
|
|
t.Skipf("TODO")
|
|
}
|
|
|
|
func TestCollectionTypes_Of(t *testing.T) {
|
|
type args struct {
|
|
o Item
|
|
t CollectionPath
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
args args
|
|
want Item
|
|
}{
|
|
{
|
|
name: "nil from nil object",
|
|
args: args{
|
|
o: nil,
|
|
t: "likes",
|
|
},
|
|
want: nil,
|
|
},
|
|
{
|
|
name: "nil from invalid CollectionPath type",
|
|
args: args{
|
|
o: Object{
|
|
Likes: IRI("test"),
|
|
},
|
|
t: "like",
|
|
},
|
|
want: nil,
|
|
},
|
|
{
|
|
name: "nil from nil CollectionPath type",
|
|
args: args{
|
|
o: Object{
|
|
Likes: nil,
|
|
},
|
|
t: "likes",
|
|
},
|
|
want: nil,
|
|
},
|
|
{
|
|
name: "get likes iri",
|
|
args: args{
|
|
o: Object{
|
|
Likes: IRI("test"),
|
|
},
|
|
t: "likes",
|
|
},
|
|
want: IRI("test"),
|
|
},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
if ob := test.args.t.Of(test.args.o); ob != test.want {
|
|
t.Errorf("Object received %#v is different, expected #%v", ob, test.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCollectionType_IRI(t *testing.T) {
|
|
type args struct {
|
|
o Item
|
|
t CollectionPath
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
args args
|
|
want IRI
|
|
}{
|
|
{
|
|
name: "just path from nil object",
|
|
args: args{
|
|
o: nil,
|
|
t: "likes",
|
|
},
|
|
want: IRI("/likes"),
|
|
},
|
|
{
|
|
name: "emptyIRI from invalid CollectionPath type",
|
|
args: args{
|
|
o: Object{
|
|
Likes: IRI("test"),
|
|
},
|
|
t: "like",
|
|
},
|
|
want: "/like",
|
|
},
|
|
{
|
|
name: "just path from object without ID",
|
|
args: args{
|
|
o: Object{},
|
|
t: "likes",
|
|
},
|
|
want: IRI("/likes"),
|
|
},
|
|
{
|
|
name: "likes iri on object",
|
|
args: args{
|
|
o: Object{
|
|
ID: "http://example.com",
|
|
Likes: IRI("test"),
|
|
},
|
|
t: "likes",
|
|
},
|
|
want: IRI("test"),
|
|
},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
if ob := test.args.t.IRI(test.args.o); ob != test.want {
|
|
t.Errorf("IRI received %q is different, expected %q", ob, test.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCollectionType_OfActor(t *testing.T) {
|
|
t.Skipf("TODO")
|
|
}
|
|
|
|
func TestCollectionTypes_Contains(t *testing.T) {
|
|
t.Skipf("TODO")
|
|
}
|
|
|
|
func TestIRIf(t *testing.T) {
|
|
type args struct {
|
|
i IRI
|
|
t CollectionPath
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
args args
|
|
want IRI
|
|
}{
|
|
{
|
|
name: "nil iri",
|
|
args: args{
|
|
i: Object{}.ID,
|
|
t: "inbox",
|
|
},
|
|
want: "/inbox",
|
|
},
|
|
{
|
|
name: "empty iri",
|
|
args: args{
|
|
i: "",
|
|
t: "inbox",
|
|
},
|
|
want: "/inbox",
|
|
},
|
|
{
|
|
name: "plain concat",
|
|
args: args{
|
|
i: "https://example.com",
|
|
t: "inbox",
|
|
},
|
|
want: "https://example.com/inbox",
|
|
},
|
|
{
|
|
name: "strip root from iri",
|
|
args: args{
|
|
i: "https://example.com/",
|
|
t: "inbox",
|
|
},
|
|
want: "https://example.com/inbox",
|
|
},
|
|
{
|
|
name: "invalid iri",
|
|
args: args{
|
|
i: "example.com",
|
|
t: "test",
|
|
},
|
|
want: "example.com/test",
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
if got := IRIf(tt.args.i, tt.args.t); got != tt.want {
|
|
t.Errorf("IRIf() = %v, want %v", got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCollectionType_AddTo(t *testing.T) {
|
|
type args struct {
|
|
i Item
|
|
}
|
|
var i Item
|
|
var o *Object
|
|
tests := []struct {
|
|
name string
|
|
t CollectionPath
|
|
args args
|
|
want IRI
|
|
want1 bool
|
|
}{
|
|
{
|
|
name: "simple",
|
|
t: "test",
|
|
args: args{
|
|
i: &Object{ID: "http://example.com/addTo"},
|
|
},
|
|
want: "http://example.com/addTo/test",
|
|
want1: false, // this seems to always be false
|
|
},
|
|
{
|
|
name: "on-nil-item",
|
|
t: "test",
|
|
args: args{
|
|
i: i,
|
|
},
|
|
want: NilIRI,
|
|
want1: false,
|
|
},
|
|
{
|
|
name: "on-nil",
|
|
t: "test",
|
|
args: args{
|
|
i: nil,
|
|
},
|
|
want: NilIRI,
|
|
want1: false,
|
|
},
|
|
{
|
|
name: "on-nil-object",
|
|
t: "test",
|
|
args: args{
|
|
i: o,
|
|
},
|
|
want: NilIRI,
|
|
want1: false,
|
|
},
|
|
{
|
|
name: "on-nil-item",
|
|
t: "test",
|
|
args: args{
|
|
i: i,
|
|
},
|
|
want: NilIRI,
|
|
want1: false,
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
got, got1 := tt.t.AddTo(tt.args.i)
|
|
if got != tt.want {
|
|
t.Errorf("AddTo() got = %v, want %v", got, tt.want)
|
|
}
|
|
if got1 != tt.want1 {
|
|
t.Errorf("AddTo() got1 = %v, want %v", got1, tt.want1)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCollectionPaths_Split(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
t CollectionPaths
|
|
given IRI
|
|
maybeActor IRI
|
|
maybeCol CollectionPath
|
|
}{
|
|
{
|
|
name: "empty",
|
|
t: nil,
|
|
given: "",
|
|
maybeActor: "",
|
|
maybeCol: "",
|
|
},
|
|
{
|
|
name: "nil with example.com",
|
|
t: nil,
|
|
given: "example.com",
|
|
maybeActor: "example.com",
|
|
maybeCol: "",
|
|
},
|
|
{
|
|
name: "nil with https://example.com",
|
|
t: nil,
|
|
given: "https://example.com/",
|
|
maybeActor: "https://example.com",
|
|
maybeCol: Unknown,
|
|
},
|
|
{
|
|
name: "outbox with https://example.com/outbox",
|
|
t: CollectionPaths{Outbox},
|
|
given: "https://example.com/outbox",
|
|
maybeActor: "https://example.com",
|
|
maybeCol: Outbox,
|
|
},
|
|
{
|
|
name: "{outbox,inbox} with https://example.com/inbox",
|
|
t: CollectionPaths{Outbox, Inbox},
|
|
given: "https://example.com/inbox",
|
|
maybeActor: "https://example.com",
|
|
maybeCol: Inbox,
|
|
},
|
|
{
|
|
// TODO(marius): This feels wrong.
|
|
name: "outbox with https://example.com/inbox",
|
|
t: CollectionPaths{Outbox},
|
|
given: "https://example.com/inbox",
|
|
maybeActor: "https://example.com",
|
|
maybeCol: Unknown,
|
|
},
|
|
{
|
|
name: "invalid url",
|
|
t: CollectionPaths{Inbox},
|
|
given: "127.0.0.1:666/inbox",
|
|
maybeActor: "127.0.0.1:666",
|
|
maybeCol: Inbox,
|
|
},
|
|
{
|
|
name: "invalid url - collection doesn't match",
|
|
t: CollectionPaths{Outbox},
|
|
given: "127.0.0.1:666/inbox",
|
|
maybeActor: "127.0.0.1:666/inbox",
|
|
maybeCol: Unknown,
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
ma, mc := tt.t.Split(tt.given)
|
|
if ma != tt.maybeActor {
|
|
t.Errorf("Split() got Actor = %q, want %q", ma, tt.maybeActor)
|
|
}
|
|
if mc != tt.maybeCol {
|
|
t.Errorf("Split() got Colletion Path = %q, want %q", mc, tt.maybeCol)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCollectionPath_Of(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
t CollectionPath
|
|
arg Item
|
|
want Item
|
|
}{
|
|
{
|
|
name: "all-nil",
|
|
t: "",
|
|
},
|
|
{
|
|
name: "inbox-nil",
|
|
t: Inbox,
|
|
},
|
|
{
|
|
name: "outbox-nil",
|
|
t: Outbox,
|
|
},
|
|
{
|
|
name: "followers-nil",
|
|
t: Followers,
|
|
},
|
|
{
|
|
name: "following-nil",
|
|
t: Following,
|
|
},
|
|
{
|
|
name: "liked-nil",
|
|
t: Liked,
|
|
},
|
|
{
|
|
name: "likes-nil",
|
|
t: Likes,
|
|
},
|
|
{
|
|
name: "shares-nil",
|
|
t: Shares,
|
|
},
|
|
{
|
|
name: "replies-nil",
|
|
t: Replies,
|
|
},
|
|
{
|
|
name: "inbox-empty",
|
|
t: Inbox,
|
|
arg: &Actor{},
|
|
},
|
|
{
|
|
name: "outbox-empty",
|
|
t: Outbox,
|
|
arg: &Actor{},
|
|
},
|
|
{
|
|
name: "followers-empty",
|
|
t: Followers,
|
|
arg: &Actor{},
|
|
},
|
|
{
|
|
name: "following-empty",
|
|
t: Following,
|
|
arg: &Actor{},
|
|
},
|
|
{
|
|
name: "liked-empty",
|
|
t: Liked,
|
|
arg: &Actor{},
|
|
},
|
|
{
|
|
name: "likes-empty",
|
|
t: Likes,
|
|
arg: &Object{},
|
|
},
|
|
{
|
|
name: "shares-empty",
|
|
t: Shares,
|
|
arg: &Object{},
|
|
},
|
|
{
|
|
name: "replies-empty",
|
|
t: Replies,
|
|
arg: &Object{},
|
|
},
|
|
//
|
|
{
|
|
name: "inbox",
|
|
t: Inbox,
|
|
arg: &Actor{
|
|
Type: PersonType,
|
|
Inbox: IRI("https://example.com/inbox"),
|
|
},
|
|
want: IRI("https://example.com/inbox"),
|
|
},
|
|
{
|
|
name: "outbox",
|
|
t: Outbox,
|
|
arg: &Actor{
|
|
Type: PersonType,
|
|
Outbox: IRI("https://example.com/outbox"),
|
|
},
|
|
want: IRI("https://example.com/outbox"),
|
|
},
|
|
{
|
|
name: "followers",
|
|
t: Followers,
|
|
arg: &Actor{
|
|
Type: GroupType,
|
|
Followers: IRI("https://example.com/c132-333"),
|
|
},
|
|
want: IRI("https://example.com/c132-333"),
|
|
},
|
|
{
|
|
name: "following",
|
|
t: Following,
|
|
arg: &Actor{
|
|
Type: GroupType,
|
|
Following: IRI("https://example.com/c666-333"),
|
|
},
|
|
want: IRI("https://example.com/c666-333"),
|
|
},
|
|
{
|
|
name: "liked",
|
|
t: Liked,
|
|
arg: &Actor{
|
|
Type: ApplicationType,
|
|
Liked: IRI("https://example.com/l666"),
|
|
},
|
|
want: IRI("https://example.com/l666"),
|
|
},
|
|
{
|
|
name: "likes",
|
|
t: Likes,
|
|
arg: &Object{
|
|
Type: NoteType,
|
|
Likes: IRI("https://example.com/l166"),
|
|
},
|
|
want: IRI("https://example.com/l166"),
|
|
},
|
|
{
|
|
name: "shares",
|
|
t: Shares,
|
|
arg: &Object{
|
|
Type: PageType,
|
|
Shares: IRI("https://example.com/s266"),
|
|
},
|
|
want: IRI("https://example.com/s266"),
|
|
},
|
|
{
|
|
name: "replies",
|
|
t: Replies,
|
|
arg: &Object{
|
|
Type: ArticleType,
|
|
Replies: IRI("https://example.com/r466"),
|
|
},
|
|
want: IRI("https://example.com/r466"),
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
if got := tt.t.Of(tt.arg); !reflect.DeepEqual(got, tt.want) {
|
|
t.Errorf("Of() = %v, want %v", got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|