speckle-server/packages/server/modules/core/tests/branches.spec.js

/* istanbul ignore file */
const chai = require( 'chai' )
const assert = require( 'assert' )

const appRoot = require( 'app-root-path' )
const { beforeEachContext } = require( `${appRoot}/test/hooks` )

const expect = chai.expect


const { createUser } = require( '../services/users' )
const { createStream } = require( '../services/streams' )
const { createObject } = require( '../services/objects' )
const {
  createBranch,
  updateBranch,
  getBranchById,
  getBranchesByStreamId,
  getBranchByNameAndStreamId,
  deleteBranchById
} = require( '../services/branches' )


describe( 'Branches @core-branches', () => {
  let user = {
    name: 'Dimitrie Stefanescu',
    email: 'didimitrie4342@gmail.com',
    password: 'sn3aky-1337-b1m'
  }

  let stream = {
    name: 'Test Stream References',
    description: 'Whatever goes in here usually...'
  }

  let testObject = {
    foo: 'bar',
    baz: 'qux'
  }

  before( async () => {
    await beforeEachContext( )

    user.id = await createUser( user )
    stream.id = await createStream( { ...stream, ownerId: user.id } )
    testObject.id = await createObject( stream.id, testObject )
  } )

  let branch = { name: 'dim/dev' }

  it( 'Should create a branch', async () => {
    branch.id = await createBranch( { ...branch, streamId: stream.id, authorId: user.id } )
    expect( branch.id ).to.be.not.null
    expect( branch.id ).to.be.a.string
  } )

  it( 'Should not allow duplicate branch names', async () => {
    try {
      await createBranch( { name: 'main', streamId: stream.id, authorId: user.id } )
      assert.fail( 'Duplicate branches should not be allowed.' )
    } catch ( err ) {
      expect( err.message ).to.contain( 'duplicate key value violates unique constraint' )
    }
  } )

  it( 'Should not allow branch names starting with # or /', async () => {
    try {
      await createBranch( { name: '/pasta', streamId: stream.id, authorId: user.id } )
      assert.fail( 'Illegal branch name passed through.' )
    } catch ( err ) {
      expect( err.message ).to.contain( 'names cannot start with # or /' )
    }

    try {
      await createBranch( { name: '#rice', streamId: stream.id, authorId: user.id } )
      assert.fail( 'Illegal branch name passed through.' )
    } catch ( err ) {
      expect( err.message ).to.contain( 'names cannot start with # or /' )
    }

    try {
      await updateBranch( { id: branch.id, name: '/super/part/two' } )
      assert.fail( 'Illegal branch name passed through in update operation.' )
    } catch ( err ) {
      expect( err.message ).to.contain( 'names cannot start with # or /' )
    }

    try {
      await updateBranch( { id: branch.id, name: '#super#part#three' } )
      assert.fail( 'Illegal branch name passed through in update operation.' )
    } catch ( err ) {
      expect( err.message ).to.contain( 'names cannot start with # or /' )
    }
  } )

  it( 'Branch names should be case insensitive (always lowercase)', async () => {
    let id = await createBranch( { name: 'CaseSensitive', streamId: stream.id, authorId: user.id } )

    let b = await getBranchByNameAndStreamId( { streamId: stream.id, name: 'casesensitive' } )
    expect( b.name ).to.equal( 'casesensitive' )

    let bb = await getBranchByNameAndStreamId( { streamId: stream.id, name: 'CaseSensitive' } )
    expect( bb.name ).to.equal( 'casesensitive' )

    let bbb = await getBranchByNameAndStreamId( { streamId: stream.id, name: 'CASESENSITIVE' } )
    expect( bbb.name ).to.equal( 'casesensitive' )

    // cleanup
    await deleteBranchById( { id, streamId: stream.id } )
  } )

  it( 'Should get a branch', async () => {
    let myBranch = await getBranchById( { id: branch.id } )
    expect( myBranch.authorId ).to.equal( user.id )
    expect( myBranch.streamId ).to.equal( stream.id )
  } )

  it( 'Should update a branch', async () => {
    await updateBranch( { id: branch.id, description: 'lorem ipsum' } )

    let b1 = await getBranchById( { id: branch.id } )
    expect( b1.description ).to.equal( 'lorem ipsum' )
  } )

  it( 'Should get all stream branches', async () => {
    await createBranch( { name: 'main-faster', streamId: stream.id, authorId: user.id } )
    await createBranch( { name: 'main-blaster', streamId: stream.id, authorId: user.id } )
    await createBranch( { name: 'blaster-farter', streamId: stream.id, authorId: user.id } )

    let { items, cursor, totalCount } = await getBranchesByStreamId( { streamId: stream.id } )
    expect( items ).to.have.lengthOf( 5 )
    expect( cursor ).to.exist
    expect( totalCount ).to.exist
  } )

  it( 'Should delete a branch', async () => {
    await deleteBranchById( { id: branch.id, streamId: stream.id } )
    let { items } = await getBranchesByStreamId( { streamId: stream.id } )
    expect( items ).to.have.lengthOf( 4 )
  } )

  it( 'Should NOT delete the main branch', async () => {
    let b = await getBranchByNameAndStreamId( { streamId: stream.id, name: 'main' } )
    try {
      await deleteBranchById( { id: b.id, streamId: stream.id } )
      assert.fail()
    } catch ( e ) {
      // pass
    }
  } )

  it( 'Should return branches in time createdAt order, MAIN first', async () => {
    let { items } = await getBranchesByStreamId( { streamId: stream.id } )
    expect( items[0].name ).to.equal( 'main' )
  
    let branch = items[3]
    await updateBranch( { id: branch.id, description: 'lorem ipsum' } )
    let cursor = new Date().toISOString()
    let got = await getBranchesByStreamId( { streamId: stream.id, cursor: cursor } ) 

    expect( got.items[3].name ).to.equal( branch.name )
    expect( got.items[0].name ).to.equal( 'main' )
  } )
} )