apemandb/test/create_test.js

Database for apeman project.

/**
 * Test case for create.
 * Runs with mocha.
 */
'use strict'

const create = require('../lib/create.js')
const assert = require('assert')
const fs = require('fs')
const co = require('co')

describe('create', function () {
  this.timeout(9000)
  let db

  let tmpDir = `${__dirname}/../tmp`
  let dbFile = tmpDir + '/testing-db2.db'

  before(() => co(function * () {
    db = create({
      env: {
        DATABASE: 'testing-database02',
        USERNAME: 'FOO',
        PASSWORD: 'BAR',
        DIALECT: 'sqlite',
        STORAGE: dbFile,
        LOGGING: false
      },
      models: `${__dirname}/../misc/mocks/models/*.json`,
      seeds: `${__dirname}/../misc/mocks/seeds/*_seed.json`,
      hooks: `${__dirname}/../misc/mocks/hooks/*_hook.js`,
      addons: `${__dirname}/../misc/mocks/addons/*_addon.js`
    })
  }))

  after(() => co(function * () {
    yield new Promise((resolve) =>
      setTimeout(() => {
        fs.unlink(dbFile, () => {
          resolve()
        })
      }, 100) // Wait for flush.
    )
  }))

  it('Create', () => co(function * () {
    let User = db.models[ 'User' ]
    let UserSign = db.models[ 'UserSign' ]
    let UserProfile = db.models[ 'UserProfile' ]
    let Project = db.models[ 'Project' ]
    let UserProject = db.models[ 'UserProject' ]
    assert.ok(User)

    assert.ok(User.doSomethingWithThisUser, 'Addon should be added.')

    assert.equal(User.getPluralName(), 'Users')
    assert.equal(User.getSingularName(), 'User')

    let userRefFromSign = UserSign.getRef('user')

    assert.equal(userRefFromSign.$$relation, 'belongsTo')
    assert.equal(userRefFromSign.as, 'user')

    assert.deepEqual(db, User.getDB())
    let transaction = yield db.beginTransaction({})
    yield User.sync({ force: true })
    yield UserSign.sync({ force: true })
    yield db.sync({ force: true })
    yield db.seed()
    let users = yield User.findAll()
    assert.ok(users[ 0 ].uuid)
    assert.ok(users.length > 0)
    let user = yield User.create({
      key: 'hogehoge',
      email: 'hoo@example.com'
    })
    let userProfile = yield UserProfile.create(
      {
        userId: user.id,
        name: 'hoge'
      }, { transaction })
    assert.equal(userProfile.userId, user.id)
    yield transaction.commit()
    user = yield User.findById(user.id)
    assert.ok(user.uuid)
    assert.ok(user.keyAlias, 'hogehoge')
    assert.ok(user)
    user = yield User.findById(user.uuid, {
      include: [ { model: UserProfile, as: 'profile' } ]
    })
    assert.equal(user.id, user.profile.userId)
    assert.ok(user.createdAt)
    user = yield user.update({
      email: 'updated@example.com'
    })

    assert.equal(user.email, 'updated@example.com')
    assert.ok(user.createdAt)
    assert.ok(user.updatedAt)
    assert.equal(user.vr, 2)
    user = yield user.update({
      email: 'updated2@example.com'
    })
    assert.equal(user.email, 'updated2@example.com')
    assert.ok(user.createdAt)
    assert.ok(user.updatedAt)
    assert.equal(user.vr, 3)
    let sign = yield UserSign.create({
      userId: user.get('id'),
      hash: 'hoge',
      hashSalt: 'huge',
      key: 'hoge',
      kind: 'email'
    })
    assert.equal(sign.userId, user.id)
    let signs = yield UserSign.findAll({
      include: [ userRefFromSign ]
    })

    let project = yield Project.create({
      name: 'project01'
    })
    yield project.addUser(user)
    let projectUsers = yield project.getUsers()
    assert.ok(projectUsers.length)

    {
      let project = yield Project.find({
        where: { name: 'project01' },
        include: [
          {
            model: User,
            as: 'users',
            through: {
              model: UserProject,
              as: 'userProject'
            }
          }
        ]
      })
      let { users } = project.toJSON()
      assert.ok(users.length > 0)
      assert.ok(users[ 0 ].userProject)
    }

    assert.ok(signs[ 0 ].user)
    yield db.drop()
    yield db.reset()
    yield db.finishTransaction(transaction)
    let desc = yield db.describe()
    assert.ok(desc)
  }))

  it('Create transaction.', () => co(function * () {
    let transaction = yield db.beginTransaction({})
    yield transaction.commit()
    yield db.finishTransaction(transaction)
  }))
})

/* global describe, before, after, it */