]*)(>)[^>]*\/*>/gim,
105 | ''
106 | )
107 | .replace(/[\n]{3,}/gim, '\n\n')
108 | .replace(/(\r\n|\n\r|\r|\n)/g, '
$1')
109 |
110 | // replace all p tags with line breaks (and spaces) only by single linebreaks
111 | // limit linebreaks to max 2 (equivalent to html "br" linebreak)
112 | .replace(/(
\s*){2,}/gim, '
')
113 | // remove additional linebreaks after p tags
114 | .replace(
115 | /<\/(p|div|th|tr)>\s*(
\s*)+\s*<(p|div|th|tr)>/gim,
116 | ''
117 | )
118 | // remove additional linebreaks inside p tags
119 | .replace(
120 | /<[a-z-]+>(<[a-z-]+>)*\s*(
\s*)+\s*(<\/[a-z-]+>)*<\/[a-z-]+>/gim,
121 | ''
122 | )
123 | // remove additional linebreaks when first child inside p tags
124 | .replace(/
(\s*
\s*)+/gim, '
')
125 | // remove additional linebreaks when last child inside p tags
126 | .replace(/(\s*
\s*)+<\/p+>/gim, '
')
127 | return dirty
128 | }
129 |
130 | const fields = ['content', 'contentExcerpt']
131 |
132 | export default {
133 | Mutation: async (resolve, root, args, context, info) => {
134 | args = walkRecursive(args, fields, clean)
135 | const result = await resolve(root, args, context, info)
136 | return result
137 | },
138 | Query: async (resolve, root, args, context, info) => {
139 | const result = await resolve(root, args, context, info)
140 | return walkRecursive(result, fields, clean)
141 | }
142 | }
143 |
--------------------------------------------------------------------------------
/src/mocks/index.js:
--------------------------------------------------------------------------------
1 |
2 | import faker from 'faker'
3 |
4 | export default {
5 | User: () => ({
6 | name: () => `${faker.name.firstName()} ${faker.name.lastName()}`,
7 | email: () => `${faker.internet.email()}`
8 | }),
9 | Post: () => ({
10 | title: () => faker.lorem.lines(1),
11 | slug: () => faker.lorem.slug(3),
12 | content: () => faker.lorem.paragraphs(5),
13 | contentExcerpt: () => faker.lorem.paragraphs(1)
14 | })
15 | }
16 |
--------------------------------------------------------------------------------
/src/resolvers/follow.spec.js:
--------------------------------------------------------------------------------
1 | import Factory from '../seed/factories'
2 | import { GraphQLClient } from 'graphql-request'
3 | import { host, login } from '../jest/helpers'
4 |
5 | const factory = Factory()
6 | let clientUser1
7 | let headersUser1
8 |
9 | const mutationFollowUser = (id) => `
10 | mutation {
11 | follow(id: "${id}", type: User)
12 | }
13 | `
14 | const mutationUnfollowUser = (id) => `
15 | mutation {
16 | unfollow(id: "${id}", type: User)
17 | }
18 | `
19 |
20 | beforeEach(async () => {
21 | await factory.create('User', {
22 | id: 'u1',
23 | email: 'test@example.org',
24 | password: '1234'
25 | })
26 | await factory.create('User', {
27 | id: 'u2',
28 | email: 'test2@example.org',
29 | password: '1234'
30 | })
31 |
32 | headersUser1 = await login({ email: 'test@example.org', password: '1234' })
33 | clientUser1 = new GraphQLClient(host, { headers: headersUser1 })
34 | })
35 |
36 | afterEach(async () => {
37 | await factory.cleanDatabase()
38 | })
39 |
40 | describe('follow', () => {
41 | describe('follow user', () => {
42 | describe('unauthenticated follow', () => {
43 | it('throws authorization error', async () => {
44 | let client
45 | client = new GraphQLClient(host)
46 | await expect(
47 | client.request(mutationFollowUser('u2'))
48 | ).rejects.toThrow('Not Authorised')
49 | })
50 | })
51 |
52 | it('I can follow another user', async () => {
53 | const res = await clientUser1.request(
54 | mutationFollowUser('u2')
55 | )
56 | const expected = {
57 | follow: true
58 | }
59 | expect(res).toMatchObject(expected)
60 |
61 | const { User } = await clientUser1.request(`{
62 | User(id: "u2") {
63 | followedBy { id }
64 | followedByCurrentUser
65 | }
66 | }`)
67 | const expected2 = {
68 | followedBy: [
69 | { id: 'u1' }
70 | ],
71 | followedByCurrentUser: true
72 | }
73 | expect(User[0]).toMatchObject(expected2)
74 | })
75 |
76 | it('I can`t follow myself', async () => {
77 | const res = await clientUser1.request(
78 | mutationFollowUser('u1')
79 | )
80 | const expected = {
81 | follow: false
82 | }
83 | expect(res).toMatchObject(expected)
84 |
85 | const { User } = await clientUser1.request(`{
86 | User(id: "u1") {
87 | followedBy { id }
88 | followedByCurrentUser
89 | }
90 | }`)
91 | const expected2 = {
92 | followedBy: [],
93 | followedByCurrentUser: false
94 | }
95 | expect(User[0]).toMatchObject(expected2)
96 | })
97 | })
98 | describe('unfollow user', () => {
99 | describe('unauthenticated follow', () => {
100 | it('throws authorization error', async () => {
101 | // follow
102 | await clientUser1.request(
103 | mutationFollowUser('u2')
104 | )
105 | // unfollow
106 | let client
107 | client = new GraphQLClient(host)
108 | await expect(
109 | client.request(mutationUnfollowUser('u2'))
110 | ).rejects.toThrow('Not Authorised')
111 | })
112 | })
113 |
114 | it('I can unfollow a user', async () => {
115 | // follow
116 | await clientUser1.request(
117 | mutationFollowUser('u2')
118 | )
119 | // unfollow
120 | const expected = {
121 | unfollow: true
122 | }
123 | const res = await clientUser1.request(mutationUnfollowUser('u2'))
124 | expect(res).toMatchObject(expected)
125 |
126 | const { User } = await clientUser1.request(`{
127 | User(id: "u2") {
128 | followedBy { id }
129 | followedByCurrentUser
130 | }
131 | }`)
132 | const expected2 = {
133 | followedBy: [],
134 | followedByCurrentUser: false
135 | }
136 | expect(User[0]).toMatchObject(expected2)
137 | })
138 | })
139 | })
140 |
--------------------------------------------------------------------------------
/src/resolvers/moderation.js:
--------------------------------------------------------------------------------
1 | export default {
2 | Mutation: {
3 | disable: async (object, params, { user, driver }) => {
4 | const { id } = params
5 | const { id: userId } = user
6 | const cypher = `
7 | MATCH (u:User {id: $userId})
8 | MATCH (resource {id: $id})
9 | WHERE resource:User OR resource:Comment OR resource:Post
10 | SET resource.disabled = true
11 | MERGE (resource)<-[:DISABLED]-(u)
12 | RETURN resource {.id}
13 | `
14 | const session = driver.session()
15 | const res = await session.run(cypher, { id, userId })
16 | session.close()
17 | const [resource] = res.records.map((record) => {
18 | return record.get('resource')
19 | })
20 | if (!resource) return null
21 | return resource.id
22 | },
23 | enable: async (object, params, { user, driver }) => {
24 | const { id } = params
25 | const cypher = `
26 | MATCH (resource {id: $id})<-[d:DISABLED]-()
27 | SET resource.disabled = false
28 | DELETE d
29 | RETURN resource {.id}
30 | `
31 | const session = driver.session()
32 | const res = await session.run(cypher, { id })
33 | session.close()
34 | const [resource] = res.records.map((record) => {
35 | return record.get('resource')
36 | })
37 | if (!resource) return null
38 | return resource.id
39 | }
40 | }
41 | }
42 |
--------------------------------------------------------------------------------
/src/resolvers/posts.js:
--------------------------------------------------------------------------------
1 | import { neo4jgraphql } from 'neo4j-graphql-js'
2 |
3 | export default {
4 | Mutation: {
5 | CreatePost: async (object, params, context, resolveInfo) => {
6 | const result = await neo4jgraphql(object, params, context, resolveInfo, false)
7 |
8 | const session = context.driver.session()
9 | await session.run(
10 | 'MATCH (author:User {id: $userId}), (post:Post {id: $postId}) ' +
11 | 'MERGE (post)<-[:WROTE]-(author) ' +
12 | 'RETURN author', {
13 | userId: context.user.id,
14 | postId: result.id
15 | }
16 | )
17 | session.close()
18 |
19 | return result
20 | }
21 | }
22 | }
23 |
--------------------------------------------------------------------------------
/src/resolvers/reports.js:
--------------------------------------------------------------------------------
1 | import uuid from 'uuid/v4'
2 |
3 | export default {
4 | Mutation: {
5 | report: async (parent, { id, description }, { driver, req, user }, resolveInfo) => {
6 | const reportId = uuid()
7 | const session = driver.session()
8 | const reportData = {
9 | id: reportId,
10 | createdAt: (new Date()).toISOString(),
11 | description: description
12 | }
13 |
14 | const res = await session.run(`
15 | MATCH (submitter:User {id: $userId})
16 | MATCH (resource {id: $resourceId})
17 | WHERE resource:User OR resource:Comment OR resource:Post
18 | CREATE (report:Report $reportData)
19 | MERGE (resource)<-[:REPORTED]-(report)
20 | MERGE (report)<-[:REPORTED]-(submitter)
21 | RETURN report, submitter, resource, labels(resource)[0] as type
22 | `, {
23 | resourceId: id,
24 | userId: user.id,
25 | reportData
26 | }
27 | )
28 | session.close()
29 |
30 | const [dbResponse] = res.records.map(r => {
31 | return {
32 | report: r.get('report'),
33 | submitter: r.get('submitter'),
34 | resource: r.get('resource'),
35 | type: r.get('type')
36 | }
37 | })
38 | if (!dbResponse) return null
39 | const { report, submitter, resource, type } = dbResponse
40 |
41 | let response = {
42 | ...report.properties,
43 | post: null,
44 | comment: null,
45 | user: null,
46 | submitter: submitter.properties,
47 | type
48 | }
49 | switch (type) {
50 | case 'Post':
51 | response.post = resource.properties
52 | break
53 | case 'Comment':
54 | response.comment = resource.properties
55 | break
56 | case 'User':
57 | response.user = resource.properties
58 | break
59 | }
60 | return response
61 | }
62 | }
63 | }
64 |
--------------------------------------------------------------------------------
/src/resolvers/reports.spec.js:
--------------------------------------------------------------------------------
1 | import Factory from '../seed/factories'
2 | import { GraphQLClient } from 'graphql-request'
3 | import { host, login } from '../jest/helpers'
4 |
5 | const factory = Factory()
6 |
7 | describe('report', () => {
8 | let mutation
9 | let headers
10 | let returnedObject
11 | let variables
12 |
13 | beforeEach(async () => {
14 | returnedObject = '{ description }'
15 | variables = { id: 'whatever' }
16 | headers = {}
17 | await factory.create('User', {
18 | id: 'u1',
19 | email: 'test@example.org',
20 | password: '1234'
21 | })
22 | await factory.create('User', {
23 | id: 'u2',
24 | name: 'abusive-user',
25 | role: 'user',
26 | email: 'abusive-user@example.org'
27 | })
28 | })
29 |
30 | afterEach(async () => {
31 | await factory.cleanDatabase()
32 | })
33 |
34 | let client
35 | const action = () => {
36 | mutation = `
37 | mutation($id: ID!) {
38 | report(
39 | id: $id,
40 | description: "Violates code of conduct"
41 | ) ${returnedObject}
42 | }
43 | `
44 | client = new GraphQLClient(host, { headers })
45 | return client.request(mutation, variables)
46 | }
47 |
48 | describe('unauthenticated', () => {
49 | it('throws authorization error', async () => {
50 | await expect(action()).rejects.toThrow('Not Authorised')
51 | })
52 |
53 | describe('authenticated', () => {
54 | beforeEach(async () => {
55 | headers = await login({ email: 'test@example.org', password: '1234' })
56 | })
57 |
58 | describe('invalid resource id', () => {
59 | it('returns null', async () => {
60 | await expect(action()).resolves.toEqual({
61 | report: null
62 | })
63 | })
64 | })
65 |
66 | describe('valid resource id', () => {
67 | beforeEach(async () => {
68 | variables = { id: 'u2' }
69 | })
70 |
71 | it('creates a report', async () => {
72 | await expect(action()).resolves.toEqual({
73 | report: { description: 'Violates code of conduct' }
74 | })
75 | })
76 |
77 | it('returns the submitter', async () => {
78 | returnedObject = '{ submitter { email } }'
79 | await expect(action()).resolves.toEqual({
80 | report: { submitter: { email: 'test@example.org' } }
81 | })
82 | })
83 |
84 | describe('reported resource is a user', () => {
85 | it('returns type "User"', async () => {
86 | returnedObject = '{ type }'
87 | await expect(action()).resolves.toEqual({
88 | report: { type: 'User' }
89 | })
90 | })
91 |
92 | it('returns resource in user attribute', async () => {
93 | returnedObject = '{ user { name } }'
94 | await expect(action()).resolves.toEqual({
95 | report: { user: { name: 'abusive-user' } }
96 | })
97 | })
98 | })
99 |
100 | describe('reported resource is a post', () => {
101 | beforeEach(async () => {
102 | await factory.authenticateAs({ email: 'test@example.org', password: '1234' })
103 | await factory.create('Post', { id: 'p23', title: 'Matt and Robert having a pair-programming' })
104 | variables = { id: 'p23' }
105 | })
106 |
107 | it('returns type "Post"', async () => {
108 | returnedObject = '{ type }'
109 | await expect(action()).resolves.toEqual({
110 | report: { type: 'Post' }
111 | })
112 | })
113 |
114 | it('returns resource in post attribute', async () => {
115 | returnedObject = '{ post { title } }'
116 | await expect(action()).resolves.toEqual({
117 | report: { post: { title: 'Matt and Robert having a pair-programming' } }
118 | })
119 | })
120 |
121 | it('returns null in user attribute', async () => {
122 | returnedObject = '{ user { name } }'
123 | await expect(action()).resolves.toEqual({
124 | report: { user: null }
125 | })
126 | })
127 | })
128 |
129 | describe('reported resource is a comment', () => {
130 | beforeEach(async () => {
131 | await factory.authenticateAs({ email: 'test@example.org', password: '1234' })
132 | await factory.create('Comment', { id: 'c34', content: 'Robert getting tired.' })
133 | variables = { id: 'c34' }
134 | })
135 |
136 | it('returns type "Comment"', async () => {
137 | returnedObject = '{ type }'
138 | await expect(action()).resolves.toEqual({
139 | report: { type: 'Comment' }
140 | })
141 | })
142 |
143 | it('returns resource in comment attribute', async () => {
144 | returnedObject = '{ comment { content } }'
145 | await expect(action()).resolves.toEqual({
146 | report: { comment: { content: 'Robert getting tired.' } }
147 | })
148 | })
149 | })
150 |
151 | describe('reported resource is a tag', () => {
152 | beforeEach(async () => {
153 | await factory.create('Tag', { id: 't23' })
154 | variables = { id: 't23' }
155 | })
156 |
157 | it('returns null', async () => {
158 | await expect(action()).resolves.toEqual({ report: null })
159 | })
160 | })
161 | })
162 | })
163 | })
164 | })
165 |
--------------------------------------------------------------------------------
/src/resolvers/shout.spec.js:
--------------------------------------------------------------------------------
1 | import Factory from '../seed/factories'
2 | import { GraphQLClient } from 'graphql-request'
3 | import { host, login } from '../jest/helpers'
4 |
5 | const factory = Factory()
6 | let clientUser1, clientUser2
7 | let headersUser1, headersUser2
8 |
9 | const mutationShoutPost = (id) => `
10 | mutation {
11 | shout(id: "${id}", type: Post)
12 | }
13 | `
14 | const mutationUnshoutPost = (id) => `
15 | mutation {
16 | unshout(id: "${id}", type: Post)
17 | }
18 | `
19 |
20 | beforeEach(async () => {
21 | await factory.create('User', {
22 | id: 'u1',
23 | email: 'test@example.org',
24 | password: '1234'
25 | })
26 | await factory.create('User', {
27 | id: 'u2',
28 | email: 'test2@example.org',
29 | password: '1234'
30 | })
31 |
32 | headersUser1 = await login({ email: 'test@example.org', password: '1234' })
33 | headersUser2 = await login({ email: 'test2@example.org', password: '1234' })
34 | clientUser1 = new GraphQLClient(host, { headers: headersUser1 })
35 | clientUser2 = new GraphQLClient(host, { headers: headersUser2 })
36 |
37 | await clientUser1.request(`
38 | mutation {
39 | CreatePost(id: "p1", title: "Post Title 1", content: "Some Post Content 1") {
40 | id
41 | title
42 | }
43 | }
44 | `)
45 | await clientUser2.request(`
46 | mutation {
47 | CreatePost(id: "p2", title: "Post Title 2", content: "Some Post Content 2") {
48 | id
49 | title
50 | }
51 | }
52 | `)
53 | })
54 |
55 | afterEach(async () => {
56 | await factory.cleanDatabase()
57 | })
58 |
59 | describe('shout', () => {
60 | describe('shout foreign post', () => {
61 | describe('unauthenticated shout', () => {
62 | it('throws authorization error', async () => {
63 | let client
64 | client = new GraphQLClient(host)
65 | await expect(
66 | client.request(mutationShoutPost('p1'))
67 | ).rejects.toThrow('Not Authorised')
68 | })
69 | })
70 |
71 | it('I shout a post of another user', async () => {
72 | const res = await clientUser1.request(
73 | mutationShoutPost('p2')
74 | )
75 | const expected = {
76 | shout: true
77 | }
78 | expect(res).toMatchObject(expected)
79 |
80 | const { Post } = await clientUser1.request(`{
81 | Post(id: "p2") {
82 | shoutedByCurrentUser
83 | }
84 | }`)
85 | const expected2 = {
86 | shoutedByCurrentUser: true
87 | }
88 | expect(Post[0]).toMatchObject(expected2)
89 | })
90 |
91 | it('I can`t shout my own post', async () => {
92 | const res = await clientUser1.request(
93 | mutationShoutPost('p1')
94 | )
95 | const expected = {
96 | shout: false
97 | }
98 | expect(res).toMatchObject(expected)
99 |
100 | const { Post } = await clientUser1.request(`{
101 | Post(id: "p1") {
102 | shoutedByCurrentUser
103 | }
104 | }`)
105 | const expected2 = {
106 | shoutedByCurrentUser: false
107 | }
108 | expect(Post[0]).toMatchObject(expected2)
109 | })
110 | })
111 |
112 | describe('unshout foreign post', () => {
113 | describe('unauthenticated shout', () => {
114 | it('throws authorization error', async () => {
115 | // shout
116 | await clientUser1.request(
117 | mutationShoutPost('p2')
118 | )
119 | // unshout
120 | let client
121 | client = new GraphQLClient(host)
122 | await expect(
123 | client.request(mutationUnshoutPost('p2'))
124 | ).rejects.toThrow('Not Authorised')
125 | })
126 | })
127 |
128 | it('I unshout a post of another user', async () => {
129 | // shout
130 | await clientUser1.request(
131 | mutationShoutPost('p2')
132 | )
133 | const expected = {
134 | unshout: true
135 | }
136 | // unshout
137 | const res = await clientUser1.request(mutationUnshoutPost('p2'))
138 | expect(res).toMatchObject(expected)
139 |
140 | const { Post } = await clientUser1.request(`{
141 | Post(id: "p2") {
142 | shoutedByCurrentUser
143 | }
144 | }`)
145 | const expected2 = {
146 | shoutedByCurrentUser: false
147 | }
148 | expect(Post[0]).toMatchObject(expected2)
149 | })
150 | })
151 | })
152 |
--------------------------------------------------------------------------------
/src/resolvers/statistics.js:
--------------------------------------------------------------------------------
1 | export const query = (cypher, session) => {
2 | return new Promise((resolve, reject) => {
3 | let data = []
4 | session
5 | .run(cypher)
6 | .subscribe({
7 | onNext: function (record) {
8 | let item = {}
9 | record.keys.forEach(key => {
10 | item[key] = record.get(key)
11 | })
12 | data.push(item)
13 | },
14 | onCompleted: function () {
15 | session.close()
16 | resolve(data)
17 | },
18 | onError: function (error) {
19 | reject(error)
20 | }
21 | })
22 | })
23 | }
24 | const queryOne = (cypher, session) => {
25 | return new Promise((resolve, reject) => {
26 | query(cypher, session)
27 | .then(res => {
28 | resolve(res.length ? res.pop() : {})
29 | })
30 | .catch(err => {
31 | reject(err)
32 | })
33 | })
34 | }
35 |
36 | export default {
37 | Query: {
38 | statistics: async (parent, args, { driver, user }) => {
39 | return new Promise(async (resolve) => {
40 | const session = driver.session()
41 | const queries = {
42 | countUsers: 'MATCH (r:User) WHERE r.deleted <> true OR NOT exists(r.deleted) RETURN COUNT(r) AS countUsers',
43 | countPosts: 'MATCH (r:Post) WHERE r.deleted <> true OR NOT exists(r.deleted) RETURN COUNT(r) AS countPosts',
44 | countComments: 'MATCH (r:Comment) WHERE r.deleted <> true OR NOT exists(r.deleted) RETURN COUNT(r) AS countComments',
45 | countNotifications: 'MATCH (r:Notification) WHERE r.deleted <> true OR NOT exists(r.deleted) RETURN COUNT(r) AS countNotifications',
46 | countOrganizations: 'MATCH (r:Organization) WHERE r.deleted <> true OR NOT exists(r.deleted) RETURN COUNT(r) AS countOrganizations',
47 | countProjects: 'MATCH (r:Project) WHERE r.deleted <> true OR NOT exists(r.deleted) RETURN COUNT(r) AS countProjects',
48 | countInvites: 'MATCH (r:Invite) WHERE r.wasUsed <> true OR NOT exists(r.wasUsed) RETURN COUNT(r) AS countInvites',
49 | countFollows: 'MATCH (:User)-[r:FOLLOWS]->(:User) RETURN COUNT(r) AS countFollows',
50 | countShouts: 'MATCH (:User)-[r:SHOUTED]->(:Post) RETURN COUNT(r) AS countShouts'
51 | }
52 | let data = {
53 | countUsers: (await queryOne(queries.countUsers, session)).countUsers.low,
54 | countPosts: (await queryOne(queries.countPosts, session)).countPosts.low,
55 | countComments: (await queryOne(queries.countComments, session)).countComments.low,
56 | countNotifications: (await queryOne(queries.countNotifications, session)).countNotifications.low,
57 | countOrganizations: (await queryOne(queries.countOrganizations, session)).countOrganizations.low,
58 | countProjects: (await queryOne(queries.countProjects, session)).countProjects.low,
59 | countInvites: (await queryOne(queries.countInvites, session)).countInvites.low,
60 | countFollows: (await queryOne(queries.countFollows, session)).countFollows.low,
61 | countShouts: (await queryOne(queries.countShouts, session)).countShouts.low
62 | }
63 | resolve(data)
64 | })
65 | }
66 | }
67 | }
68 |
--------------------------------------------------------------------------------
/src/resolvers/user_management.js:
--------------------------------------------------------------------------------
1 | import encode from '../jwt/encode'
2 | import bcrypt from 'bcryptjs'
3 | import { AuthenticationError } from 'apollo-server'
4 | import { neo4jgraphql } from 'neo4j-graphql-js'
5 |
6 | export default {
7 | Query: {
8 | isLoggedIn: (parent, args, { driver, user }) => {
9 | return Boolean(user && user.id)
10 | },
11 | currentUser: async (object, params, ctx, resolveInfo) => {
12 | const { user } = ctx
13 | if (!user) return null
14 | return neo4jgraphql(object, { id: user.id }, ctx, resolveInfo, false)
15 | }
16 | },
17 | Mutation: {
18 | signup: async (parent, { email, password }, { req }) => {
19 | // if (data[email]) {
20 | // throw new Error('Another User with same email exists.')
21 | // }
22 | // data[email] = {
23 | // password: await bcrypt.hashSync(password, 10),
24 | // }
25 |
26 | return true
27 | },
28 | login: async (parent, { email, password }, { driver, req, user }) => {
29 | // if (user && user.id) {
30 | // throw new Error('Already logged in.')
31 | // }
32 | const session = driver.session()
33 | const result = await session.run(
34 | 'MATCH (user:User {email: $userEmail}) ' +
35 | 'RETURN user {.id, .slug, .name, .avatar, .email, .password, .role, .disabled} as user LIMIT 1',
36 | {
37 | userEmail: email
38 | }
39 | )
40 |
41 | session.close()
42 | const [currentUser] = await result.records.map(function (record) {
43 | return record.get('user')
44 | })
45 |
46 | if (
47 | currentUser &&
48 | (await bcrypt.compareSync(password, currentUser.password)) &&
49 | !currentUser.disabled
50 | ) {
51 | delete currentUser.password
52 | return encode(currentUser)
53 | } else if (currentUser &&
54 | currentUser.disabled
55 | ) {
56 | throw new AuthenticationError('Your account has been disabled.')
57 | } else {
58 | throw new AuthenticationError('Incorrect email address or password.')
59 | }
60 | },
61 | changePassword: async (
62 | _,
63 | { oldPassword, newPassword },
64 | { driver, user }
65 | ) => {
66 | const session = driver.session()
67 | let result = await session.run(
68 | `MATCH (user:User {email: $userEmail})
69 | RETURN user {.id, .email, .password}`,
70 | {
71 | userEmail: user.email
72 | }
73 | )
74 |
75 | const [currentUser] = result.records.map(function (record) {
76 | return record.get('user')
77 | })
78 |
79 | if (!(await bcrypt.compareSync(oldPassword, currentUser.password))) {
80 | throw new AuthenticationError('Old password is not correct')
81 | }
82 |
83 | if (await bcrypt.compareSync(newPassword, currentUser.password)) {
84 | throw new AuthenticationError(
85 | 'Old password and new password should be different'
86 | )
87 | } else {
88 | const newHashedPassword = await bcrypt.hashSync(newPassword, 10)
89 | session.run(
90 | `MATCH (user:User {email: $userEmail})
91 | SET user.password = $newHashedPassword
92 | RETURN user
93 | `,
94 | {
95 | userEmail: user.email,
96 | newHashedPassword
97 | }
98 | )
99 | session.close()
100 |
101 | return encode(currentUser)
102 | }
103 | }
104 | }
105 | }
106 |
--------------------------------------------------------------------------------
/src/seed/factories/badges.js:
--------------------------------------------------------------------------------
1 | import uuid from 'uuid/v4'
2 |
3 | export default function (params) {
4 | const {
5 | id = uuid(),
6 | key,
7 | type = 'crowdfunding',
8 | status = 'permanent',
9 | icon
10 | } = params
11 |
12 | return `
13 | mutation {
14 | CreateBadge(
15 | id: "${id}",
16 | key: "${key}",
17 | type: ${type},
18 | status: ${status},
19 | icon: "${icon}"
20 | ) { id }
21 | }
22 | `
23 | }
24 |
--------------------------------------------------------------------------------
/src/seed/factories/categories.js:
--------------------------------------------------------------------------------
1 | import uuid from 'uuid/v4'
2 |
3 | export default function (params) {
4 | const {
5 | id = uuid(),
6 | name,
7 | slug,
8 | icon
9 | } = params
10 |
11 | return `
12 | mutation {
13 | CreateCategory(
14 | id: "${id}",
15 | name: "${name}",
16 | slug: "${slug}",
17 | icon: "${icon}"
18 | ) { id, name }
19 | }
20 | `
21 | }
22 |
--------------------------------------------------------------------------------
/src/seed/factories/comments.js:
--------------------------------------------------------------------------------
1 | import faker from 'faker'
2 | import uuid from 'uuid/v4'
3 |
4 | export default function (params) {
5 | const {
6 | id = uuid(),
7 | content = [
8 | faker.lorem.sentence(),
9 | faker.lorem.sentence()
10 | ].join('. '),
11 | disabled = false,
12 | deleted = false
13 | } = params
14 |
15 | return `
16 | mutation {
17 | CreateComment(
18 | id: "${id}",
19 | content: "${content}",
20 | disabled: ${disabled},
21 | deleted: ${deleted}
22 | ) { id }
23 | }
24 | `
25 | }
26 |
--------------------------------------------------------------------------------
/src/seed/factories/index.js:
--------------------------------------------------------------------------------
1 | import { GraphQLClient, request } from 'graphql-request'
2 | import { getDriver } from '../../bootstrap/neo4j'
3 | import createBadge from './badges.js'
4 | import createUser from './users.js'
5 | import createOrganization from './organizations.js'
6 | import createPost from './posts.js'
7 | import createComment from './comments.js'
8 | import createCategory from './categories.js'
9 | import createTag from './tags.js'
10 | import createReport from './reports.js'
11 |
12 | export const seedServerHost = 'http://127.0.0.1:4001'
13 |
14 | const authenticatedHeaders = async ({ email, password }, host) => {
15 | const mutation = `
16 | mutation {
17 | login(email:"${email}", password:"${password}")
18 | }`
19 | const response = await request(host, mutation)
20 | return {
21 | authorization: `Bearer ${response.login}`
22 | }
23 | }
24 | const factories = {
25 | Badge: createBadge,
26 | User: createUser,
27 | Organization: createOrganization,
28 | Post: createPost,
29 | Comment: createComment,
30 | Category: createCategory,
31 | Tag: createTag,
32 | Report: createReport
33 | }
34 |
35 | export const cleanDatabase = async (options = {}) => {
36 | const { driver = getDriver() } = options
37 | const session = driver.session()
38 | const cypher = 'MATCH (n) DETACH DELETE n'
39 | try {
40 | return await session.run(cypher)
41 | } catch (error) {
42 | throw error
43 | } finally {
44 | session.close()
45 | }
46 | }
47 |
48 | export default function Factory (options = {}) {
49 | const {
50 | neo4jDriver = getDriver(),
51 | seedServerHost = 'http://127.0.0.1:4001'
52 | } = options
53 |
54 | const graphQLClient = new GraphQLClient(seedServerHost)
55 |
56 | const result = {
57 | neo4jDriver,
58 | seedServerHost,
59 | graphQLClient,
60 | factories,
61 | lastResponse: null,
62 | async authenticateAs ({ email, password }) {
63 | const headers = await authenticatedHeaders(
64 | { email, password },
65 | seedServerHost
66 | )
67 | this.lastResponse = headers
68 | this.graphQLClient = new GraphQLClient(seedServerHost, { headers })
69 | return this
70 | },
71 | async create (node, properties) {
72 | const mutation = this.factories[node](properties)
73 | this.lastResponse = await this.graphQLClient.request(mutation)
74 | return this
75 | },
76 | async relate (node, relationship, properties) {
77 | const { from, to } = properties
78 | const mutation = `
79 | mutation {
80 | Add${node}${relationship}(
81 | from: { id: "${from}" },
82 | to: { id: "${to}" }
83 | ) { from { id } }
84 | }
85 | `
86 | this.lastResponse = await this.graphQLClient.request(mutation)
87 | return this
88 | },
89 | async mutate (mutation, variables) {
90 | this.lastResponse = await this.graphQLClient.request(mutation, variables)
91 | return this
92 | },
93 | async shout (properties) {
94 | const { id, type } = properties
95 | const mutation = `
96 | mutation {
97 | shout(
98 | id: "${id}",
99 | type: ${type}
100 | )
101 | }
102 | `
103 | this.lastResponse = await this.graphQLClient.request(mutation)
104 | return this
105 | },
106 | async follow (properties) {
107 | const { id, type } = properties
108 | const mutation = `
109 | mutation {
110 | follow(
111 | id: "${id}",
112 | type: ${type}
113 | )
114 | }
115 | `
116 | this.lastResponse = await this.graphQLClient.request(mutation)
117 | return this
118 | },
119 | async cleanDatabase () {
120 | this.lastResponse = await cleanDatabase({ driver: this.neo4jDriver })
121 | return this
122 | }
123 | }
124 | result.authenticateAs.bind(result)
125 | result.create.bind(result)
126 | result.relate.bind(result)
127 | result.mutate.bind(result)
128 | result.cleanDatabase.bind(result)
129 | return result
130 | }
131 |
--------------------------------------------------------------------------------
/src/seed/factories/organizations.js:
--------------------------------------------------------------------------------
1 | import faker from 'faker'
2 | import uuid from 'uuid/v4'
3 |
4 | export default function create (params) {
5 | const {
6 | id = uuid(),
7 | name = faker.company.companyName(),
8 | description = faker.company.catchPhrase(),
9 | disabled = false,
10 | deleted = false
11 | } = params
12 |
13 | return `
14 | mutation {
15 | CreateOrganization(
16 | id: "${id}",
17 | name: "${name}",
18 | description: "${description}",
19 | disabled: ${disabled},
20 | deleted: ${deleted}
21 | ) { name }
22 | }
23 | `
24 | }
25 |
--------------------------------------------------------------------------------
/src/seed/factories/posts.js:
--------------------------------------------------------------------------------
1 | import faker from 'faker'
2 | import uuid from 'uuid/v4'
3 |
4 | export default function (params) {
5 | const {
6 | id = uuid(),
7 | title = faker.lorem.sentence(),
8 | content = [
9 | faker.lorem.sentence(),
10 | faker.lorem.sentence(),
11 | faker.lorem.sentence(),
12 | faker.lorem.sentence(),
13 | faker.lorem.sentence()
14 | ].join('. '),
15 | image = faker.image.image(),
16 | visibility = 'public',
17 | deleted = false
18 | } = params
19 |
20 | return `
21 | mutation {
22 | CreatePost(
23 | id: "${id}",
24 | title: "${title}",
25 | content: "${content}",
26 | image: "${image}",
27 | visibility: ${visibility},
28 | deleted: ${deleted}
29 | ) { title, content }
30 | }
31 | `
32 | }
33 |
--------------------------------------------------------------------------------
/src/seed/factories/reports.js:
--------------------------------------------------------------------------------
1 | import faker from 'faker'
2 |
3 | export default function create (params) {
4 | const {
5 | description = faker.lorem.sentence(),
6 | id
7 | } = params
8 |
9 | return `
10 | mutation {
11 | report(
12 | description: "${description}",
13 | id: "${id}",
14 | ) {
15 | id,
16 | createdAt
17 | }
18 | }
19 | `
20 | }
21 |
--------------------------------------------------------------------------------
/src/seed/factories/tags.js:
--------------------------------------------------------------------------------
1 | import uuid from 'uuid/v4'
2 |
3 | export default function (params) {
4 | const {
5 | id = uuid(),
6 | name
7 | } = params
8 |
9 | return `
10 | mutation {
11 | CreateTag(
12 | id: "${id}",
13 | name: "${name}",
14 | ) { name }
15 | }
16 | `
17 | }
18 |
--------------------------------------------------------------------------------
/src/seed/factories/users.js:
--------------------------------------------------------------------------------
1 | import faker from 'faker'
2 | import uuid from 'uuid/v4'
3 |
4 | export default function create (params) {
5 | const {
6 | id = uuid(),
7 | name = faker.name.findName(),
8 | email = faker.internet.email(),
9 | password = '1234',
10 | role = 'user',
11 | avatar = faker.internet.avatar(),
12 | about = faker.lorem.paragraph(),
13 | disabled = false,
14 | deleted = false
15 | } = params
16 |
17 | return `
18 | mutation {
19 | CreateUser(
20 | id: "${id}",
21 | name: "${name}",
22 | password: "${password}",
23 | email: "${email}",
24 | avatar: "${avatar}",
25 | about: "${about}",
26 | role: ${role},
27 | disabled: ${disabled},
28 | deleted: ${deleted}
29 | ) {
30 | id
31 | name
32 | email
33 | avatar
34 | role
35 | deleted
36 | disabled
37 | }
38 | }
39 | `
40 | }
41 |
--------------------------------------------------------------------------------
/src/seed/reset-db.js:
--------------------------------------------------------------------------------
1 | import { cleanDatabase } from './factories'
2 | import dotenv from 'dotenv'
3 |
4 | dotenv.config()
5 |
6 | if (process.env.NODE_ENV === 'production') {
7 | throw new Error(`YOU CAN'T CLEAN THE DATABASE WITH NODE_ENV=${process.env.NODE_ENV}`)
8 | }
9 |
10 | (async function () {
11 | try {
12 | await cleanDatabase()
13 | console.log('Successfully deleted all nodes and relations!')
14 | process.exit(0)
15 | } catch (err) {
16 | console.log(`Error occurred deleting the nodes and relations (reset the db)\n\n${err}`)
17 | process.exit(1)
18 | }
19 | })()
20 |
--------------------------------------------------------------------------------
/src/seed/seed-helpers.js:
--------------------------------------------------------------------------------
1 | const _ = require('lodash')
2 | const faker = require('faker')
3 | const unsplashTopics = [
4 | 'love',
5 | 'family',
6 | 'spring',
7 | 'business',
8 | 'nature',
9 | 'travel',
10 | 'happy',
11 | 'landscape',
12 | 'health',
13 | 'friends',
14 | 'computer',
15 | 'autumn',
16 | 'space',
17 | 'animal',
18 | 'smile',
19 | 'face',
20 | 'people',
21 | 'portrait',
22 | 'amazing'
23 | ]
24 | let unsplashTopicsTmp = []
25 |
26 | const ngoLogos = [
27 | 'http://www.fetchlogos.com/wp-content/uploads/2015/11/Girl-Scouts-Of-The-Usa-Logo.jpg',
28 | 'http://logos.textgiraffe.com/logos/logo-name/Ngo-designstyle-friday-m.png',
29 | 'http://seeklogo.com/images/N/ngo-logo-BD53A3E024-seeklogo.com.png',
30 | 'https://dcassetcdn.com/design_img/10133/25833/25833_303600_10133_image.jpg',
31 | 'https://cdn.tutsplus.com/vector/uploads/legacy/articles/08bad_ngologos/20.jpg',
32 | 'https://cdn.tutsplus.com/vector/uploads/legacy/articles/08bad_ngologos/33.jpg',
33 | null
34 | ]
35 |
36 | const difficulties = ['easy', 'medium', 'hard']
37 |
38 | export default {
39 | randomItem: (items, filter) => {
40 | let ids = filter
41 | ? Object.keys(items)
42 | .filter(id => {
43 | return filter(items[id])
44 | })
45 | : _.keys(items)
46 | let randomIds = _.shuffle(ids)
47 | return items[randomIds.pop()]
48 | },
49 | randomItems: (items, key = 'id', min = 1, max = 1) => {
50 | let randomIds = _.shuffle(_.keys(items))
51 | let res = []
52 |
53 | const count = _.random(min, max)
54 |
55 | for (let i = 0; i < count; i++) {
56 | let r = items[randomIds.pop()][key]
57 | if (key === 'id') {
58 | r = r.toString()
59 | }
60 | res.push(r)
61 | }
62 | return res
63 | },
64 | random: (items) => {
65 | return _.shuffle(items).pop()
66 | },
67 | randomDifficulty: () => {
68 | return _.shuffle(difficulties).pop()
69 | },
70 | randomLogo: () => {
71 | return _.shuffle(ngoLogos).pop()
72 | },
73 | randomUnsplashUrl: () => {
74 | if (Math.random() < 0.6) {
75 | // do not attach images in 60 percent of the cases (faster seeding)
76 | return
77 | }
78 | if (unsplashTopicsTmp.length < 2) {
79 | unsplashTopicsTmp = _.shuffle(unsplashTopics)
80 | }
81 | return 'https://source.unsplash.com/daily?' + unsplashTopicsTmp.pop() + ',' + unsplashTopicsTmp.pop()
82 | },
83 | randomCategories: (seederstore, allowEmpty = false) => {
84 | let count = Math.round(Math.random() * 3)
85 | if (allowEmpty === false && count === 0) {
86 | count = 1
87 | }
88 | let categorieIds = _.shuffle(_.keys(seederstore.categories))
89 | let ids = []
90 | for (let i = 0; i < count; i++) {
91 | ids.push(categorieIds.pop())
92 | }
93 | return ids
94 | },
95 | randomAddresses: () => {
96 | const count = Math.round(Math.random() * 3)
97 | let addresses = []
98 | for (let i = 0; i < count; i++) {
99 | addresses.push({
100 | city: faker.address.city(),
101 | zipCode: faker.address.zipCode(),
102 | street: faker.address.streetAddress(),
103 | country: faker.address.countryCode(),
104 | lat: 54.032726 - (Math.random() * 10),
105 | lng: 6.558838 + (Math.random() * 10)
106 | })
107 | }
108 | return addresses
109 | },
110 | /**
111 | * Get array of ids from the given seederstore items after mapping them by the key in the values
112 | *
113 | * @param items items from the seederstore
114 | * @param values values for which you need the ids
115 | * @param key the field key that is represented in the values (slug, name, etc.)
116 | */
117 | mapIdsByKey: (items, values, key) => {
118 | let res = []
119 | values.forEach(value => {
120 | res.push(_.find(items, [key, value]).id.toString())
121 | })
122 | return res
123 | },
124 | genInviteCode: () => {
125 | const chars = '23456789abcdefghkmnpqrstuvwxyzABCDEFGHJKLMNPRSTUVWXYZ'
126 | let code = ''
127 | for (let i = 0; i < 8; i++) {
128 | const n = _.random(0, chars.length - 1)
129 | code += chars.substr(n, 1)
130 | }
131 | return code
132 | }
133 | }
134 |
--------------------------------------------------------------------------------
/src/server.js:
--------------------------------------------------------------------------------
1 | import { GraphQLServer } from 'graphql-yoga'
2 | import { makeAugmentedSchema } from 'neo4j-graphql-js'
3 | import { typeDefs, resolvers } from './graphql-schema'
4 | import express from 'express'
5 | import dotenv from 'dotenv'
6 | import mocks from './mocks'
7 | import middleware from './middleware'
8 | import applyDirectives from './bootstrap/directives'
9 | import applyScalars from './bootstrap/scalars'
10 | import { getDriver } from './bootstrap/neo4j'
11 | import helmet from 'helmet'
12 | import decode from './jwt/decode'
13 |
14 | dotenv.config()
15 | // check env and warn
16 | const requiredEnvVars = ['MAPBOX_TOKEN', 'JWT_SECRET']
17 | requiredEnvVars.forEach(env => {
18 | if (!process.env[env]) {
19 | throw new Error(`ERROR: "${env}" env variable is missing.`)
20 | }
21 | })
22 |
23 | const driver = getDriver()
24 | const debug = process.env.NODE_ENV !== 'production' && process.env.DEBUG === 'true'
25 |
26 | let schema = makeAugmentedSchema({
27 | typeDefs,
28 | resolvers,
29 | config: {
30 | query: {
31 | exclude: ['Statistics', 'LoggedInUser']
32 | },
33 | mutation: {
34 | exclude: ['Statistics', 'LoggedInUser']
35 | },
36 | debug: debug
37 | }
38 | })
39 | schema = applyScalars(applyDirectives(schema))
40 |
41 | const createServer = (options) => {
42 | const defaults = {
43 | context: async ({ request }) => {
44 | const authorizationHeader = request.headers.authorization || ''
45 | const user = await decode(driver, authorizationHeader)
46 | return {
47 | driver,
48 | user,
49 | req: request,
50 | cypherParams: {
51 | currentUserId: user ? user.id : null
52 | }
53 | }
54 | },
55 | schema: schema,
56 | debug: debug,
57 | tracing: debug,
58 | middlewares: middleware(schema),
59 | mocks: (process.env.MOCK === 'true') ? mocks : false
60 | }
61 | const server = new GraphQLServer(Object.assign({}, defaults, options))
62 |
63 | server.express.use(helmet())
64 | server.express.use(express.static('public'))
65 | return server
66 | }
67 |
68 | export default createServer
69 |
--------------------------------------------------------------------------------
/test/features/activity-delete.feature:
--------------------------------------------------------------------------------
1 | Feature: Delete an object
2 | I want to delete objects
3 |
4 | Background:
5 | Given our own server runs at "http://localhost:4123"
6 | And we have the following users in our database:
7 | | Slug |
8 | | bernd-das-brot|
9 | And I send a POST request with the following activity to "/activitypub/users/bernd-das-brot/inbox":
10 | """
11 | {
12 | "@context": "https://www.w3.org/ns/activitystreams",
13 | "id": "https://aronda.org/users/bernd-das-brot/status/lka7dfzkjn2398hsfd",
14 | "type": "Create",
15 | "actor": "https://aronda.org/users/bernd-das-brot",
16 | "object": {
17 | "id": "https://aronda.org/users/bernd-das-brot/status/kljsdfg9843jknsdf234",
18 | "type": "Article",
19 | "published": "2019-02-07T19:37:55.002Z",
20 | "attributedTo": "https://aronda.org/users/bernd-das-brot",
21 | "content": "Hi Max, how are you?",
22 | "to": "https://www.w3.org/ns/activitystreams#Public"
23 | }
24 | }
25 | """
26 |
27 | Scenario: Deleting a post (Article Object)
28 | When I send a POST request with the following activity to "/activitypub/users/bernd-das-brot/inbox":
29 | """
30 | {
31 | "@context": "https://www.w3.org/ns/activitystreams",
32 | "id": "https://localhost:4123/activitypub/users/karl-heinz/status/a4DJ2afdg323v32641vna42lkj685kasd2",
33 | "type": "Delete",
34 | "object": {
35 | "id": "https://aronda.org/activitypub/users/bernd-das-brot/status/kljsdfg9843jknsdf234",
36 | "type": "Article",
37 | "published": "2019-02-07T19:37:55.002Z",
38 | "attributedTo": "https://aronda.org/activitypub/users/bernd-das-brot",
39 | "content": "Hi Max, how are you?",
40 | "to": "https://www.w3.org/ns/activitystreams#Public"
41 | }
42 | }
43 | """
44 | Then I expect the status code to be 200
45 | And the object is removed from the outbox collection of "bernd-das-brot"
46 | """
47 | {
48 | "id": "https://aronda.org/activitypub/users/bernd-das-brot/status/kljsdfg9843jknsdf234",
49 | "type": "Article",
50 | "published": "2019-02-07T19:37:55.002Z",
51 | "attributedTo": "https://aronda.org/activitypub/users/bernd-das-brot",
52 | "content": "Hi Max, how are you?",
53 | "to": "https://www.w3.org/ns/activitystreams#Public"
54 | }
55 | """
56 |
--------------------------------------------------------------------------------
/test/features/activity-follow.feature:
--------------------------------------------------------------------------------
1 | Feature: Follow a user
2 | I want to be able to follow a user on another instance.
3 | Also if I do not want to follow a previous followed user anymore,
4 | I want to undo the follow.
5 |
6 | Background:
7 | Given our own server runs at "http://localhost:4123"
8 | And we have the following users in our database:
9 | | Slug |
10 | | stuart-little |
11 | | tero-vota |
12 |
13 | Scenario: Send a follow to a user inbox and make sure it's added to the right followers collection
14 | When I send a POST request with the following activity to "/activitypub/users/tero-vota/inbox":
15 | """
16 | {
17 | "@context": "https://www.w3.org/ns/activitystreams",
18 | "id": "https://localhost:4123/activitypub/users/stuart-little/status/83J23549sda1k72fsa4567na42312455kad83",
19 | "type": "Follow",
20 | "actor": "http://localhost:4123/activitypub/users/stuart-little",
21 | "object": "http://localhost:4123/activitypub/users/tero-vota"
22 | }
23 | """
24 | Then I expect the status code to be 200
25 | And the follower is added to the followers collection of "tero-vota"
26 | """
27 | http://localhost:4123/activitypub/users/stuart-little
28 | """
29 |
30 | Scenario: Send an undo activity to revert the previous follow activity
31 | When I send a POST request with the following activity to "/activitypub/users/stuart-little/inbox":
32 | """
33 | {
34 | "@context": "https://www.w3.org/ns/activitystreams",
35 | "id": "https://localhost:4123/activitypub/users/tero-vota/status/a4DJ2afdg323v32641vna42lkj685kasd2",
36 | "type": "Undo",
37 | "actor": "http://localhost:4123/activitypub/users/tero-vota",
38 | "object": {
39 | "id": "https://localhost:4123/activitypub/users/stuart-little/status/83J23549sda1k72fsa4567na42312455kad83",
40 | "type": "Follow",
41 | "actor": "http://localhost:4123/activitypub/users/stuart-little",
42 | "object": "http://localhost:4123/activitypub/users/tero-vota"
43 | }
44 | }
45 | """
46 | Then I expect the status code to be 200
47 | And the follower is removed from the followers collection of "tero-vota"
48 | """
49 | http://localhost:4123/activitypub/users/stuart-little
50 | """
51 |
--------------------------------------------------------------------------------
/test/features/activity-like.feature:
--------------------------------------------------------------------------------
1 | Feature: Like an object like an article or note
2 | As a user I want to like others posts
3 | Also if I do not want to follow a previous followed user anymore,
4 | I want to undo the follow.
5 |
6 | Background:
7 | Given our own server runs at "http://localhost:4123"
8 | And we have the following users in our database:
9 | | Slug |
10 | | karl-heinz |
11 | | peter-lustiger |
12 | And I send a POST request with the following activity to "/activitypub/users/bernd-das-brot/inbox":
13 | """
14 | {
15 | "@context": "https://www.w3.org/ns/activitystreams",
16 | "id": "https://localhost:4123/activitypub/users/karl-heinz/status/faslkasa7dasfzkjn2398hsfd",
17 | "type": "Create",
18 | "actor": "https://localhost:4123/activitypub/users/karl-heinz",
19 | "object": {
20 | "id": "https://localhost:4123/activitypub/users/karl-heinz/status/dkasfljsdfaafg9843jknsdf",
21 | "type": "Article",
22 | "published": "2019-02-07T19:37:55.002Z",
23 | "attributedTo": "https://localhost:4123/activitypub/users/karl-heinz",
24 | "content": "Hi Max, how are you?",
25 | "to": "https://www.w3.org/ns/activitystreams#Public"
26 | }
27 | }
28 | """
29 |
30 | Scenario: Send a like of a person to an users inbox and make sure it's added to the likes collection
31 | When I send a POST request with the following activity to "/activitypub/users/karl-heinz/inbox":
32 | """
33 | {
34 | "@context": "https://www.w3.org/ns/activitystreams",
35 | "id": "https://localhost:4123/activitypub/users/peter-lustiger/status/83J23549sda1k72fsa4567na42312455kad83",
36 | "type": "Like",
37 | "actor": "http://localhost:4123/activitypub/users/peter-lustiger",
38 | "object": "http://localhost:4123/activitypub/users/karl-heinz/status/dkasfljsdfaafg9843jknsdf"
39 | }
40 | """
41 | Then I expect the status code to be 200
42 | And the post with id "dkasfljsdfaafg9843jknsdf" has been liked by "peter-lustiger"
43 |
--------------------------------------------------------------------------------
/test/features/collection.feature:
--------------------------------------------------------------------------------
1 | Feature: Receiving collections
2 | As a member of the Fediverse I want to be able of fetching collections
3 |
4 | Background:
5 | Given our own server runs at "http://localhost:4123"
6 | And we have the following users in our database:
7 | | Slug |
8 | | renate-oberdorfer |
9 |
10 | Scenario: Send a request to the outbox URI of peter-lustig and expect a ordered collection
11 | When I send a GET request to "/activitypub/users/renate-oberdorfer/outbox"
12 | Then I expect the status code to be 200
13 | And I receive the following json:
14 | """
15 | {
16 | "@context": "https://www.w3.org/ns/activitystreams",
17 | "id": "https://localhost:4123/activitypub/users/renate-oberdorfer/outbox",
18 | "summary": "renate-oberdorfers outbox collection",
19 | "type": "OrderedCollection",
20 | "first": "https://localhost:4123/activitypub/users/renate-oberdorfer/outbox?page=true",
21 | "totalItems": 0
22 | }
23 | """
24 |
25 | Scenario: Send a request to the following URI of peter-lustig and expect a ordered collection
26 | When I send a GET request to "/activitypub/users/renate-oberdorfer/following"
27 | Then I expect the status code to be 200
28 | And I receive the following json:
29 | """
30 | {
31 | "@context": "https://www.w3.org/ns/activitystreams",
32 | "id": "https://localhost:4123/activitypub/users/renate-oberdorfer/following",
33 | "summary": "renate-oberdorfers following collection",
34 | "type": "OrderedCollection",
35 | "first": "https://localhost:4123/activitypub/users/renate-oberdorfer/following?page=true",
36 | "totalItems": 0
37 | }
38 | """
39 |
40 | Scenario: Send a request to the followers URI of peter-lustig and expect a ordered collection
41 | When I send a GET request to "/activitypub/users/renate-oberdorfer/followers"
42 | Then I expect the status code to be 200
43 | And I receive the following json:
44 | """
45 | {
46 | "@context": "https://www.w3.org/ns/activitystreams",
47 | "id": "https://localhost:4123/activitypub/users/renate-oberdorfer/followers",
48 | "summary": "renate-oberdorfers followers collection",
49 | "type": "OrderedCollection",
50 | "first": "https://localhost:4123/activitypub/users/renate-oberdorfer/followers?page=true",
51 | "totalItems": 0
52 | }
53 | """
54 |
55 | Scenario: Send a request to the outbox URI of peter-lustig and expect a paginated outbox collection
56 | When I send a GET request to "/activitypub/users/renate-oberdorfer/outbox?page=true"
57 | Then I expect the status code to be 200
58 | And I receive the following json:
59 | """
60 | {
61 | "@context": "https://www.w3.org/ns/activitystreams",
62 | "id": "https://localhost:4123/activitypub/users/renate-oberdorfer/outbox?page=true",
63 | "summary": "renate-oberdorfers outbox collection",
64 | "type": "OrderedCollectionPage",
65 | "totalItems": 0,
66 | "partOf": "https://localhost:4123/activitypub/users/renate-oberdorfer/outbox",
67 | "orderedItems": []
68 | }
69 | """
70 |
71 | Scenario: Send a request to the following URI of peter-lustig and expect a paginated following collection
72 | When I send a GET request to "/activitypub/users/renate-oberdorfer/following?page=true"
73 | Then I expect the status code to be 200
74 | And I receive the following json:
75 | """
76 | {
77 | "@context": "https://www.w3.org/ns/activitystreams",
78 | "id": "https://localhost:4123/activitypub/users/renate-oberdorfer/following?page=true",
79 | "summary": "renate-oberdorfers following collection",
80 | "type": "OrderedCollectionPage",
81 | "totalItems": 0,
82 | "partOf": "https://localhost:4123/activitypub/users/renate-oberdorfer/following",
83 | "orderedItems": []
84 | }
85 | """
86 |
87 | Scenario: Send a request to the followers URI of peter-lustig and expect a paginated followers collection
88 | When I send a GET request to "/activitypub/users/renate-oberdorfer/followers?page=true"
89 | Then I expect the status code to be 200
90 | And I receive the following json:
91 | """
92 | {
93 | "@context": "https://www.w3.org/ns/activitystreams",
94 | "id": "https://localhost:4123/activitypub/users/renate-oberdorfer/followers?page=true",
95 | "summary": "renate-oberdorfers followers collection",
96 | "type": "OrderedCollectionPage",
97 | "totalItems": 0,
98 | "partOf": "https://localhost:4123/activitypub/users/renate-oberdorfer/followers",
99 | "orderedItems": []
100 | }
101 | """
102 |
--------------------------------------------------------------------------------
/test/features/object-article.feature:
--------------------------------------------------------------------------------
1 | Feature: Send and receive Articles
2 | I want to send and receive article's via ActivityPub
3 |
4 | Background:
5 | Given our own server runs at "http://localhost:4123"
6 | And we have the following users in our database:
7 | | Slug |
8 | | marvin |
9 | | max |
10 |
11 | Scenario: Send an article to a user inbox and make sure it's added to the inbox
12 | When I send a POST request with the following activity to "/activitypub/users/max/inbox":
13 | """
14 | {
15 | "@context": "https://www.w3.org/ns/activitystreams",
16 | "id": "https://aronda.org/users/marvin/status/lka7dfzkjn2398hsfd",
17 | "type": "Create",
18 | "actor": "https://aronda.org/users/marvin",
19 | "object": {
20 | "id": "https://aronda.org/users/marvin/status/kljsdfg9843jknsdf",
21 | "type": "Article",
22 | "published": "2019-02-07T19:37:55.002Z",
23 | "attributedTo": "https://aronda.org/users/marvin",
24 | "content": "Hi Max, how are you?",
25 | "to": "as:Public"
26 | }
27 | }
28 | """
29 | Then I expect the status code to be 200
30 | And the post with id "kljsdfg9843jknsdf" to be created
31 |
--------------------------------------------------------------------------------
/test/features/webfinger.feature:
--------------------------------------------------------------------------------
1 | Feature: Webfinger discovery
2 | From an external server, e.g. Mastodon
3 | I want to search for an actor alias
4 | In order to follow the actor
5 |
6 | Background:
7 | Given our own server runs at "http://localhost:4100"
8 | And we have the following users in our database:
9 | | Slug |
10 | | peter-lustiger |
11 |
12 | Scenario: Search
13 | When I send a GET request to "/.well-known/webfinger?resource=acct:peter-lustiger@localhost"
14 | Then I receive the following json:
15 | """
16 | {
17 | "subject": "acct:peter-lustiger@localhost:4123",
18 | "links": [
19 | {
20 | "rel": "self",
21 | "type": "application/activity+json",
22 | "href": "https://localhost:4123/users/peter-lustiger"
23 | }
24 | ]
25 | }
26 | """
27 | And I expect the Content-Type to be "application/jrd+json; charset=utf-8"
28 |
29 | Scenario: User does not exist
30 | When I send a GET request to "/.well-known/webfinger?resource=acct:nonexisting@localhost"
31 | Then I receive the following json:
32 | """
33 | {
34 | "error": "No record found for nonexisting@localhost."
35 | }
36 | """
37 |
38 | Scenario: Receiving an actor object
39 | When I send a GET request to "/activitypub/users/peter-lustiger"
40 | Then I receive the following json:
41 | """
42 | {
43 | "@context": [
44 | "https://www.w3.org/ns/activitystreams",
45 | "https://w3id.org/security/v1"
46 | ],
47 | "id": "https://localhost:4123/activitypub/users/peter-lustiger",
48 | "type": "Person",
49 | "preferredUsername": "peter-lustiger",
50 | "name": "peter-lustiger",
51 | "following": "https://localhost:4123/activitypub/users/peter-lustiger/following",
52 | "followers": "https://localhost:4123/activitypub/users/peter-lustiger/followers",
53 | "inbox": "https://localhost:4123/activitypub/users/peter-lustiger/inbox",
54 | "outbox": "https://localhost:4123/activitypub/users/peter-lustiger/outbox",
55 | "url": "https://localhost:4123/activitypub/@peter-lustiger",
56 | "endpoints": {
57 | "sharedInbox": "https://localhost:4123/activitypub/inbox"
58 | },
59 | "publicKey": {
60 | "id": "https://localhost:4123/activitypub/users/peter-lustiger#main-key",
61 | "owner": "https://localhost:4123/activitypub/users/peter-lustiger",
62 | "publicKeyPem": "adglkjlk89235kjn8obn2384f89z5bv9..."
63 | }
64 | }
65 | """
66 |
--------------------------------------------------------------------------------
/test/features/world.js:
--------------------------------------------------------------------------------
1 | // features/support/world.js
2 | import { setWorldConstructor } from 'cucumber'
3 | import request from 'request'
4 | const debug = require('debug')('ea:test:world')
5 |
6 | class CustomWorld {
7 | constructor () {
8 | // webFinger.feature
9 | this.lastResponses = []
10 | this.lastContentType = null
11 | this.lastInboxUrl = null
12 | this.lastActivity = null
13 | // object-article.feature
14 | this.statusCode = null
15 | }
16 | get (pathname) {
17 | return new Promise((resolve, reject) => {
18 | request(`http://localhost:4123/${this.replaceSlashes(pathname)}`, {
19 | headers: {
20 | 'Accept': 'application/activity+json'
21 | }}, function (error, response, body) {
22 | if (!error) {
23 | debug(`get content-type = ${response.headers['content-type']}`)
24 | debug(`get body = ${JSON.stringify(typeof body === 'string' ? JSON.parse(body) : body, null, 2)}`)
25 | resolve({ lastResponse: body, lastContentType: response.headers['content-type'], statusCode: response.statusCode })
26 | } else {
27 | reject(error)
28 | }
29 | })
30 | })
31 | }
32 |
33 | replaceSlashes (pathname) {
34 | return pathname.replace(/^\/+/, '')
35 | }
36 |
37 | post (pathname, activity) {
38 | return new Promise((resolve, reject) => {
39 | request({
40 | url: `http://localhost:4123/${this.replaceSlashes(pathname)}`,
41 | method: 'POST',
42 | headers: {
43 | 'Content-Type': 'application/activity+json'
44 | },
45 | body: activity
46 | }, function (error, response, body) {
47 | if (!error) {
48 | debug(`post response = ${response.headers['content-type']}`)
49 | resolve({ lastResponse: body, lastContentType: response.headers['content-type'], statusCode: response.statusCode })
50 | } else {
51 | reject(error)
52 | }
53 | })
54 | })
55 | }
56 | }
57 |
58 | setWorldConstructor(CustomWorld)
59 |
--------------------------------------------------------------------------------