Gergő Jedlicska
217 lines
9.3 KiB
JavaScript
217 lines
9.3 KiB
JavaScript
/* istanbul ignore file */
|
|
const chai = require( 'chai' )
|
|
const chaiHttp = require( 'chai-http' )
|
|
|
|
const appRoot = require( 'app-root-path' )
|
|
const { createUser } = require( '../../core/services/users' )
|
|
const { createPersonalAccessToken } = require( '../../core/services/tokens' )
|
|
const { createObject } = require( '../../core/services/objects' )
|
|
const { getUserActivity } = require( '../services' )
|
|
const { init, startHttp } = require( `${appRoot}/app` )
|
|
const knex = require( `${appRoot}/db/knex` )
|
|
|
|
const expect = chai.expect
|
|
chai.use( chaiHttp )
|
|
|
|
let serverAddress
|
|
|
|
|
|
describe( 'Activity @activity', () => {
|
|
let testServer
|
|
|
|
let userIz = {
|
|
name: 'Izzy Lyseggen',
|
|
email: 'izzybizzi@speckle.systems',
|
|
password: 'sp0ckle sucks 9001'
|
|
}
|
|
|
|
let userCr = {
|
|
name: 'Cristi Balas',
|
|
email: 'cristib@speckle.systems',
|
|
password: 'hack3r man 666'
|
|
}
|
|
|
|
let userX = {
|
|
name: 'Mystery User',
|
|
email: 'mysteriousDude@speckle.systems',
|
|
password: 'super $ecret pw0rd'
|
|
}
|
|
|
|
let streamPublic = {
|
|
name: 'a fun stream for sharing',
|
|
description: 'for all to see!',
|
|
isPublic: true
|
|
}
|
|
|
|
let branchPublic = { name: '🍁maple branch' }
|
|
|
|
let streamSecret = {
|
|
name: 'a secret stream for me',
|
|
description: 'for no one to see!',
|
|
isPublic: false
|
|
}
|
|
|
|
let testObj = {
|
|
hello: 'hallo',
|
|
cool: 'kult',
|
|
bunny: 'kanin'
|
|
}
|
|
let testObj2 = {
|
|
goodbye: 'ha det bra',
|
|
warm: 'varmt',
|
|
bunny: 'kanin'
|
|
}
|
|
|
|
before( async () => {
|
|
await knex.migrate.rollback( )
|
|
await knex.migrate.latest()
|
|
|
|
let { app } = await init( )
|
|
let { server } = await startHttp( app, 0 )
|
|
|
|
testServer = server
|
|
|
|
app.on( 'appStarted', () => {
|
|
serverAddress = `http://localhost:${server.address().port}`
|
|
} )
|
|
|
|
|
|
// create users and tokens
|
|
userIz.id = await createUser( userIz )
|
|
let token = await createPersonalAccessToken( userIz.id, 'izz test token', [ 'streams:read', 'streams:write', 'users:read', 'users:email', 'tokens:write', 'tokens:read', 'profile:read', 'profile:email' ] )
|
|
userIz.token = `Bearer ${token}`
|
|
|
|
userCr.id = await createUser( userCr )
|
|
userCr.token = `Bearer ${( await createPersonalAccessToken( userCr.id, 'cristi test token', [ 'streams:read', 'streams:write', 'users:read', 'users:email', 'tokens:write', 'tokens:read', 'profile:read', 'profile:email' ] ) )}`
|
|
|
|
userX.id = await createUser( userX )
|
|
userX.token = `Bearer ${( await createPersonalAccessToken( userX.id, 'no users:read test token', [ 'streams:read', 'streams:write' ] ) )}`
|
|
} )
|
|
|
|
after( async ( ) => {
|
|
await knex.migrate.rollback()
|
|
testServer.close( )
|
|
} )
|
|
|
|
it( 'Should create activity', async () => {
|
|
// create stream (cr1)
|
|
const resStream1 = await sendRequest( userCr.token, { query: 'mutation createStream($myStream:StreamCreateInput!) { streamCreate(stream: $myStream) }', variables: { myStream: streamSecret } } )
|
|
expect( noErrors( resStream1 ) )
|
|
streamSecret.id = resStream1.body.data.streamCreate
|
|
|
|
// create commit (cr2)
|
|
testObj2.id = await createObject( streamSecret.id, testObj2 )
|
|
const resCommit1 = await sendRequest( userCr.token, { query: `mutation { commitCreate(commit: {streamId: "${streamSecret.id}", branchName: "main", objectId: "${testObj2.id}", message: "first commit"})}` } )
|
|
expect( noErrors( resCommit1 ) )
|
|
|
|
// create stream #2 (iz1)
|
|
const resStream2 = await sendRequest( userIz.token, { query: 'mutation createStream($myStream:StreamCreateInput!) { streamCreate(stream: $myStream) }', variables: { myStream: streamPublic } } )
|
|
expect( noErrors( resStream2 ) )
|
|
streamPublic.id = resStream2.body.data.streamCreate
|
|
|
|
// create branch (iz2)
|
|
const resBranch = await sendRequest( userIz.token, { query: `mutation { branchCreate(branch: { streamId: "${streamPublic.id}", name: "${branchPublic.name}" }) }` } )
|
|
expect( noErrors( resBranch ) )
|
|
branchPublic.id = resBranch.body.data.branchCreate
|
|
|
|
// create commit #2 (iz3)
|
|
testObj.id = await createObject( streamPublic.id, testObj )
|
|
const resCommit2 = await sendRequest( userIz.token, { query: `mutation { commitCreate(commit: { streamId: "${streamPublic.id}", branchName: "${branchPublic.name}", objectId: "${testObj.id}", message: "first commit" })}` } )
|
|
expect( noErrors( resCommit2 ) )
|
|
|
|
// add collaborator (iz4)
|
|
const resCollab = await sendRequest( userIz.token, { query: `mutation { streamGrantPermission( permissionParams: { streamId: "${streamPublic.id}", userId: "${userCr.id}", role: "stream:contributor" } ) }` } )
|
|
expect( noErrors( resCollab ) )
|
|
|
|
let { items: activityC } = await getUserActivity( { userId: userCr.id } )
|
|
expect( activityC.length ).to.equal( 3 )
|
|
expect( activityC[ 0 ].actionType ).to.equal( 'commit_create' )
|
|
|
|
let { items: activityI } = await getUserActivity( { userId: userIz.id } )
|
|
expect( activityI.length ).to.equal( 5 )
|
|
expect( activityI[ 0 ].actionType ).to.equal( 'stream_permissions_add' )
|
|
} )
|
|
|
|
it( 'Should get a user\'s own activity', async () => {
|
|
const res = await sendRequest( userIz.token, { query: `query {user(id:"${userIz.id}") { name activity { totalCount items {streamId resourceType resourceId actionType userId message time}}} }` } )
|
|
expect( noErrors( res ) )
|
|
let activity = res.body.data.user.activity
|
|
|
|
expect( activity.items.length ).to.equal( 5 )
|
|
expect( activity.totalCount ).to.equal( 5 )
|
|
expect( activity.items[ 0 ].actionType ).to.equal( 'stream_permissions_add' )
|
|
expect( activity.items[ activity.totalCount - 1 ].actionType ).to.equal( 'user_create' )
|
|
} )
|
|
|
|
it( 'Should get another user\'s activity', async () => {
|
|
const res = await sendRequest( userIz.token, { query: `query {user(id:"${userCr.id}") { name activity { totalCount items {streamId resourceType resourceId actionType userId message time}}} }` } )
|
|
expect( noErrors( res ) )
|
|
expect( res.body.data.user.activity.items.length ).to.equal( 3 )
|
|
expect( res.body.data.user.activity.totalCount ).to.equal( 3 )
|
|
} )
|
|
|
|
it( 'Should get a user\'s timeline', async () => {
|
|
const res = await sendRequest( userIz.token, { query: `query {user(id:"${userCr.id}") { name timeline { totalCount items {streamId resourceType resourceId actionType userId message time}}} }` } )
|
|
expect( noErrors( res ) )
|
|
expect( res.body.data.user.timeline.items.length ).to.equal( 6 ) // sum of all actions in 'should create activity'
|
|
expect( res.body.data.user.timeline.totalCount ).to.equal( 6 )
|
|
} )
|
|
|
|
it( 'Should get a stream\'s activity', async () => {
|
|
const res = await sendRequest( userCr.token, { query: `query { stream(id: "${streamPublic.id}") { activity { totalCount items {streamId resourceId actionType message} } } }` } )
|
|
expect( noErrors( res ) )
|
|
let activity = res.body.data.stream.activity
|
|
expect( activity.items.length ).to.equal( 4 )
|
|
expect( activity.totalCount ).to.equal( 4 )
|
|
expect( activity.items[ activity.totalCount - 1 ].actionType ).to.equal( 'stream_create' )
|
|
} )
|
|
|
|
it( 'Should get a branch\'s activity', async () => {
|
|
const res = await sendRequest( userCr.token, { query: `query { stream(id: "${streamPublic.id}") { branch(name: "${branchPublic.name}") { activity { totalCount items {streamId resourceId actionType message} } } } }` } )
|
|
expect( noErrors( res ) )
|
|
let activity = res.body.data.stream.branch.activity
|
|
expect( activity.items.length ).to.equal( 1 )
|
|
expect( activity.totalCount ).to.equal( 1 )
|
|
expect( activity.items[ 0 ].actionType ).to.equal( 'branch_create' )
|
|
} )
|
|
|
|
it( 'Should *not* get a stream\'s activity if you don\'t have access to it', async () => {
|
|
const res = await sendRequest( userIz.token, { query: `query {stream(id:"${streamSecret.id}") {name activity {items {streamId resourceType resourceId actionType userId message time}}} }` } )
|
|
expect( res.body.errors.length ).to.equal( 1 )
|
|
} )
|
|
|
|
it( 'Should *not* get a stream\'s activity if you are not a server user', async () => {
|
|
const res = await sendRequest( null, { query: `query {stream(id:"${streamPublic.id}") {name activity {items {streamId resourceType resourceId actionType userId message time}}} }` } )
|
|
expect( res.body.errors.length ).to.equal( 1 )
|
|
} )
|
|
|
|
it( 'Should *not* get a user\'s activity without the `users:read` scope', async () => {
|
|
const res = await sendRequest( userX.token, { query: `query {user(id:"${userCr.id}") { name activity {items {streamId resourceType resourceId actionType userId message time}}} }` } )
|
|
expect( res.body.errors.length ).to.equal( 1 )
|
|
} )
|
|
|
|
it( 'Should *not* get a user\'s timeline without the `users:read` scope', async () => {
|
|
const res = await sendRequest( userX.token, { query: `query {user(id:"${userCr.id}") { name timeline {items {streamId resourceType resourceId actionType userId message time}}} }` } )
|
|
expect( res.body.errors.length ).to.equal( 1 )
|
|
} )
|
|
} )
|
|
|
|
/**
|
|
* Sends a graphql request. Convenience wrapper.
|
|
* @param {string} auth the user's token
|
|
* @param {string} obj the query/mutation to send
|
|
* @return {Promise} the awaitable request
|
|
*/
|
|
function sendRequest( auth, obj, address = serverAddress ) {
|
|
return chai.request( address ).post( '/graphql' ).set( 'Authorization', auth ).send( obj )
|
|
}
|
|
|
|
/**
|
|
* Checks the response body for errors. To be used in expect assertions.
|
|
* Will throw an error if 'errors' exist.
|
|
* @param {*} res
|
|
*/
|
|
function noErrors( res ) {
|
|
if ( 'errors' in res.body ) throw new Error( `Failed GraphQL request: ${res.body.errors[ 0 ].message}` )
|
|
}
|