Parse-server setup

beforeSaveService.spec

import Parse from 'parse/node'
import { afterEach, describe, it } from 'mocha'
import chai from 'chai'
import chaiAsPromised from 'chai-as-promised'

import { resetParse, getAdminUser } from '../../../test/parseHelper'
import errors from '../../utils/errors'

chai.use(chaiAsPromised)
const assert = chai.assert

const Service = Parse.Object.extend('Service')

describe('beforeSaveService', () => {
  afterEach(async () => {
    await resetParse()
  })

  it('fails: missing listText', async () => {
    const adminUser = await getAdminUser()
    const adminSessionToken = adminUser.getSessionToken()
    const service = new Service({
      formText: 'Hello form the form'
    })
    return assert.isRejected(
      service.save({}, { sessionToken: adminSessionToken }),
      new RegExp(errors.REQUIRED_LIST_TEXT)
    )
  })

  it('fails: missing formText', async () => {
    const adminUser = await getAdminUser()
    const adminSessionToken = adminUser.getSessionToken()
    const service = new Service({
      listText: 'Hello from the list'
    })
    return assert.isRejected(
      service.save({}, { sessionToken: adminSessionToken }),
      new RegExp(errors.REQUIRED_FORM_TEXT)
    )
  })

  it('fails: permission denied', async () => {
    const service = new Service({
      listText: 'Hello from the list',
      formText: 'Hello form the form'
    })
    return assert.isRejected(
      service.save(),
      /Permission denied for action create on class Service/
    )
  })

  it('succeeds', async () => {
    const adminUser = await getAdminUser()
    const adminSessionToken = adminUser.getSessionToken()
    const service = await new Service({
      listText: 'Hello from the list',
      formText: 'Hello form the form'
    }).save({}, { sessionToken: adminSessionToken })
    assert.equal(service.get('listText'), 'Hello from the list')
    assert.equal(service.get('formText'), 'Hello form the form')
  })
})

mocha-setup.js

import { initializeParse, createClasses, createAdminRole, createAdminUser, setCLPs } from './parseHelper'
import '../index.es6'

const setup = (async () => {
  initializeParse()
  await createAdminRole()
  await createAdminUser()
  await createClasses()
  await setCLPs()
  run()
})()

parseHelper.js

import Parse from 'parse/node'
import Config from 'parse-server/lib/Config'

const Role = Parse.Object.extend('_Role')
const User = Parse.Object.extend('_User')
const Service = Parse.Object.extend('Service')

export const initializeParse = () => {
  Parse.initialize('TEST_APP_ID', '', 'TEST_MASTER_KEY')
  Parse.serverURL = 'http://localhost:1337/api'
}

export const resetParse = async () => {
  const users = await new Parse.Query(User).notEqualTo('username', 'adminUser').find()
  await Parse.Object.destroyAll(users, { useMasterKey: true })
  const services = await new Parse.Query(Service).find()
  await Parse.Object.destroyAll(services, { useMasterKey: true })
}

export const signupTestUser = async () => {
  await new User({
    username: 'testUser',
    password: 'password',
    email: 'test@test.com'
  }).save(null, { useMasterKey: true })
  const user = await Parse.User.logIn('testUser', 'password')
  return user
}

export const createAdminUser = async () => {
  const adminUser = await new User({
    username: 'adminUser',
    password: 'password',
    email: 'admin@admin.com'
  }).save(null, { useMasterKey: true })
  await addUserToAdminRole(adminUser)
  console.log('createAdminUser -> done')
  return adminUser
}

export const createAdminRole = async () => {
  const acl = new Parse.ACL()
  acl.setPublicReadAccess(true)
  acl.setPublicWriteAccess(false)
  const adminRole = new Role()
  adminRole.set('name', 'admin')
  adminRole.setACL(acl)
  await adminRole.save({}, { useMasterKey: true })
  console.log('createAdminRole -> done')
}

export const getAdminUser = async () => {
  const admin = await Parse.User.logIn('adminUser', 'password')
  return admin
}

export const addUserToAdminRole = async (user) => {
  const adminRole = await new Parse.Query(Role)
    .equalTo('name', 'admin')
    .first()
  const users = adminRole.relation('users')
  users.add(user)
  await adminRole.save({}, { useMasterKey: true })
  console.log('addUserToAdminRole -> done')
}

export const createClasses = async () => {
  const config = new Config('TEST_APP_ID', '/api')
  const schema = await config.database.loadSchema()
  await schema.addClassIfNotExists('Service', {
    listText: { type: 'String' },
    formText: { type: 'String' },
    hasDateTime: { type: 'Boolean' },
    hasLocation: { type: 'Boolean' }
  })
  console.log('createClasses -> done')
}

export const setCLPs = async () => {
  const config = new Config('TEST_APP_ID', '/api')
  const schema = await config.database.loadSchema()
  await schema.setPermissions('Service', {
    get: { 'role:admin': true, '*': true },
    find: { 'role:admin': true, '*': true },
    create: { 'role:admin': true },
    update: { 'role:admin': true },
    delete: { 'role:admin': true },
    addField: {}
  })
  console.log('setCLPs -> done')
}