Translated sequelize.spec.js to Buster and modulated the helpers a tiny bit.

spec-jasmine/sequelize.spec.js

-var config         = require("./config/config")
-  , Sequelize      = require("../index")
-  , QueryInterface = require("../lib/query-interface")
-
-describe('Sequelize', function() {
-  var sequelize = null
-    , Helpers   = null
-
-
-  var setup = function(options) {
-    options   = options || {}
-
-    if (!options.hasOwnProperty('pool'))
-      options.pool = config.mysql.pool
-    if (!options.hasOwnProperty('logging'))
-      options.logging = false
-    if (!options.hasOwnProperty('host'))
-      options.host = config.mysql.host
-    if (!options.hasOwnProperty('port'))
-      options.port = config.mysql.port
-
-    sequelize = new Sequelize(config.mysql.database, config.mysql.username, config.mysql.password, options)
-    Helpers   = new (require("./config/helpers"))(sequelize)
-
-    return options
-  }
-
-  beforeEach(function() { setup() })
-  afterEach(function() { sequelize = null })
-
-  describe('constructor', function() {
-    it('should pass the global options correctly', function() {
-      setup({ logging: false, define: { underscored:true } })
-
-      var DAO = sequelize.define('dao', {name: Sequelize.STRING})
-      expect(DAO.options.underscored).toBeTruthy()
-    })
-
-    it('should correctly set the host and the port', function() {
-      var options = setup({ host: '127.0.0.1', port: 1234 })
-
-      expect(sequelize.config.host).toEqual(options.host)
-      expect(sequelize.config.port).toEqual(options.port)
-    })
-  })
-
-  describe('define', function() {
-    it("adds a new dao to the dao manager", function() {
-      expect(sequelize.daoFactoryManager.all.length).toEqual(0)
-      sequelize.define('foo', { title: Sequelize.STRING })
-      expect(sequelize.daoFactoryManager.all.length).toEqual(1)
-    })
-
-    it("overwrites global options", function() {
-      setup({ define: { collate: 'utf8_general_ci' } })
-      var DAO = sequelize.define('foo', {bar: Sequelize.STRING}, {collate: 'utf8_bin'})
-      expect(DAO.options.collate).toEqual('utf8_bin')
-    })
-
-    it("inherits global collate option", function() {
-      setup({ define: { collate: 'utf8_general_ci' } })
-      var DAO = sequelize.define('foo', {bar: Sequelize.STRING})
-      expect(DAO.options.collate).toEqual('utf8_general_ci')
-    })
-
-    it("inherits global classMethods and instanceMethods", function() {
-      setup({
-        define: {
-          classMethods : { globalClassMethod : function() {} },
-          instanceMethods : { globalInstanceMethod : function() {} }
-        }
-      })
-
-      var DAO = sequelize.define('foo', {bar: Sequelize.STRING}, {
-        classMethods : { localClassMethod : function() {} }
-      })
-
-      expect(typeof DAO.options.classMethods.globalClassMethod).toEqual('function')
-      expect(typeof DAO.options.classMethods.localClassMethod).toEqual('function')
-      expect(typeof DAO.options.instanceMethods.globalInstanceMethod).toEqual('function')
-    })
-
-    it("uses the passed tableName", function(done) {
-      var Photo = sequelize.define('Foto', { name: Sequelize.STRING }, { tableName: 'photos' })
-
-      Photo.sync({ force: true }).success(function() {
-        sequelize.getQueryInterface().showAllTables().success(function(tableNames) {
-          expect(tableNames).toContain('photos')
-          done()
-        })
-      })
-    })
-  })
-
-  describe('sync', function() {
-    it("synchronizes all daos", function() {
-      var Project = sequelize.define('project' + config.rand(), { title: Sequelize.STRING })
-      var Task = sequelize.define('task' + config.rand(), { title: Sequelize.STRING })
-
-      Helpers.async(function(done) {
-        sequelize.sync().success(function() {
-          Project.create({title: 'bla'}).success(function() {
-            Task.create({title: 'bla'}).success(done)
-          })
-        })
-      })
-    })
-  })
-
-  describe('import', function() {
-    it("imports a dao definition from a file", function() {
-      var Project = sequelize.import(__dirname + "/assets/project")
-      expect(Project).toBeDefined()
-    })
-  })
-})

spec/buster-helpers.js

@@ -30,23 +30,37 @@ var BusterHelpers = module.exports = {
 
     options.dialect = options.dialect || 'mysql'
     options.logging = (options.hasOwnProperty('logging') ? options.logging : false)
+    options.pool = options.pool || config.pool
 
     var sequelizeOptions = {
       logging: options.logging,
       dialect: options.dialect,
-      port:    process.env.SEQ_PORT || config[options.dialect].port
+      port:    options.port || process.env.SEQ_PORT || config[options.dialect].port,
+      pool:    options.pool
+    }
+
+    if (!!options.host) {
+      sequelizeOptions.host = options.host
+    }
+
+    if (!!options.define) {
+      sequelizeOptions.define = options.define
     }
 
     if (process.env.DIALECT === 'postgres-native') {
       sequelizeOptions.native = true
     }
 
-    return new Sequelize(
-      process.env.SEQ_DB    || config[options.dialect].database,
+    return this.getSequelizeInstance(
+      process.env.SEQ_DB || config[options.dialect].database,
       process.env.SEQ_USER  || process.env.SEQ_USERNAME || config[options.dialect].username,
       process.env.SEQ_PW    || process.env.SEQ_PASSWORD || config[options.dialect].password,
       sequelizeOptions
-    )
+      )
+  },
+
+  getSequelizeInstance: function(db, user, pass, options) {
+    return new Sequelize(db, user, pass, options)
   },
 
   clearDatabase: function(sequelize, callback) {

spec/sequelize.spec.js

 if(typeof require === 'function') {
   const buster  = require("buster")
       , Helpers = require('./buster-helpers')
+      , config    = require(__dirname + "/config/config")
       , dialect = Helpers.getTestDialect()
       , moment  = require('moment')
 }
@@ -16,6 +17,7 @@ var qq = function(str) {
 }
 
 buster.spec.expose()
+buster.timeout = 1000
 
 describe(Helpers.getTestDialectTeaser("Sequelize"), function() {
   before(function(done) {
@@ -26,6 +28,23 @@ describe(Helpers.getTestDialectTeaser("Sequelize"), function() {
     })
   })
 
+  describe('=> constructor', function() {
+    it('should pass the global options correctly', function(done) {
+      var sequelize = Helpers.createSequelizeInstance({ logging: false, define: { underscored:true } })
+        , DAO = sequelize.define('dao', {name: Helpers.Sequelize.STRING})
+
+      expect(DAO.options.underscored).toBeTruthy()
+      done()
+    })
+
+    it('should correctly set the host and the port', function(done) {
+      var sequelize = Helpers.createSequelizeInstance({ host: '127.0.0.1', port: 1234 })
+      expect(sequelize.config.port).toEqual(1234)
+      expect(sequelize.config.host).toEqual('127.0.0.1')
+      done()
+    })
+  })
+
   describe('isDefined', function() {
     it("returns false if the dao wasn't defined before", function() {
       expect(this.sequelize.isDefined('Project')).toBeFalse()
@@ -176,6 +195,113 @@ describe(Helpers.getTestDialectTeaser("Sequelize"), function() {
     })
   })
 
+  describe('=> define', function() {
+    it("adds a new dao to the dao manager", function(done) {
+      expect(this.sequelize.daoFactoryManager.all.length).toEqual(0)
+      this.sequelize.define('foo', { title: Helpers.Sequelize.STRING })
+      expect(this.sequelize.daoFactoryManager.all.length).toEqual(1)
+      done()
+    })
+
+    it("overwrites global options", function(done) {
+      var sequelize = Helpers.createSequelizeInstance({ define: { collate: 'utf8_general_ci' } })
+      var DAO = sequelize.define('foo', {bar: Helpers.Sequelize.STRING}, {collate: 'utf8_bin'})
+      expect(DAO.options.collate).toEqual('utf8_bin')
+      done()
+    })
+
+    it("inherits global collate option", function(done) {
+      var sequelize = Helpers.createSequelizeInstance({ define: { collate: 'utf8_general_ci' } })
+      var DAO = sequelize.define('foo', {bar: Helpers.Sequelize.STRING})
+      expect(DAO.options.collate).toEqual('utf8_general_ci')
+      done()
+    })
+
+    it("inherits global classMethods and instanceMethods", function(done) {
+      var sequelize = Helpers.createSequelizeInstance({
+        define: {
+          classMethods : { globalClassMethod : function() {} },
+          instanceMethods : { globalInstanceMethod : function() {} }
+        }
+      })
+
+      var DAO = sequelize.define('foo', {bar: Helpers.Sequelize.STRING}, {
+        classMethods : { localClassMethod : function() {} }
+      })
+
+      expect(typeof DAO.options.classMethods.globalClassMethod).toEqual('function')
+      expect(typeof DAO.options.classMethods.localClassMethod).toEqual('function')
+      expect(typeof DAO.options.instanceMethods.globalInstanceMethod).toEqual('function')
+      done()
+    })
+
+    it("uses the passed tableName", function(done) {
+      var self = this
+        , Photo = this.sequelize.define('Foto', { name: Helpers.Sequelize.STRING }, { tableName: 'photos' })
+      Photo.sync({ force: true }).success(function() {
+        self.sequelize.getQueryInterface().showAllTables().success(function(tableNames) {
+          expect(tableNames).toContain('photos')
+          done()
+        })
+      })
+    })
+  })
+
+  describe('sync', function() {
+    it("synchronizes all daos", function(done) {
+      var Project = this.sequelize.define('project' + config.rand(), { title: Helpers.Sequelize.STRING })
+      var Task = this.sequelize.define('task' + config.rand(), { title: Helpers.Sequelize.STRING })
+
+      this.sequelize.sync().success(function() {
+        Project.create({title: 'bla'}).success(function() {
+          Task.create({title: 'bla'}).success(function(task){
+            expect(task).toBeDefined()
+            expect(task.title).toEqual('bla')
+            done()
+          })
+        })
+      })
+    })
+
+    it('works with correct database credentials', function(done) {
+      var User = this.sequelize.define('User', { username: Helpers.Sequelize.STRING })
+      User.sync().success(function() {
+        expect(true).toBeTrue()
+        done()
+      })
+    })
+
+    it("fails with incorrect database credentials", function(done) {
+      var sequelize2 = Helpers.getSequelizeInstance('foo', 'bar', null, { logging: false })
+        , User2      = sequelize2.define('User', { name: Helpers.Sequelize.STRING, bio: Helpers.Sequelize.TEXT })
+
+      User2.sync().error(function(err) {
+        expect(err.message).toMatch(/.*Access\ denied.*/)
+        done()
+      })
+    })
+  })
+
+  describe('drop should work', function() {
+    it('correctly succeeds', function(done) {
+      var User = this.sequelize.define('Users', {username: Helpers.Sequelize.STRING })
+      User.sync({ force: true }).success(function() {
+        User.drop().success(function() {
+          expect(true).toBeTrue()
+          done()
+        })
+      })
+    })
+  })
+
+  describe('import', function() {
+    it("imports a dao definition from a file", function(done) {
+      var Project = this.sequelize.import(__dirname + "/assets/project")
+      expect(Project).toBeDefined()
+      done()
+    })
+  })
+
   describe('define', function() {
     [
       { type: Helpers.Sequelize.ENUM, values: ['scheduled', 'active', 'finished']},
@@ -241,6 +367,5 @@ describe(Helpers.getTestDialectTeaser("Sequelize"), function() {
 
       })
     })
-
   })
 })