dao validations spec

spec/configuration.spec.js

-var buster        = require("buster")
-  , semver        = require("semver")
-  , Helpers       = require('./buster-helpers')
-  , config        = require(__dirname + "/config/config")
-  , dialect       = Helpers.getTestDialect()
-  , Sequelize     = require(__dirname + '/../index')
-  , noDomains     = semver.lt(process.version, '0.8.0')
-
-buster.spec.expose()
-buster.testRunner.timeout = 1000
-
-describe(Helpers.getTestDialectTeaser("Configuration"), function() {
-  describe('Connections problems should fail with a nice message', function() {
-    it('when we don\'t have the correct server details', function(done) {
-      if (noDomains === true) {
-        console.log('WARNING: Configuration specs requires NodeJS version >= 0.8 for full compatibility')
-        expect('').toEqual('') // Silence Buster!
-        return done()
-      }
-
-      (function() {
-        var sequelizeSpecific2 = new Sequelize(config[dialect].database, config[dialect].username, config[dialect].password, {storage: '/path/to/no/where/land', logging: false, host: '0.0.0.1', port: config[dialect].port, dialect: dialect})
-          , domain = require('domain')
-          , d = domain.create()
-
-        d.on('error', function(err){
-          expect(err).toMatch(/Failed to find (.*?) Please double check your settings\./)
-          d.remove(sequelizeSpecific2.query)
-          done()
-        })
-
-        d.run(function(){
-          d.add(sequelizeSpecific2.query)
-          sequelizeSpecific2.query('select 1 as hello')
-          .success(function(){})
-        })
-      })()
-    })
-
-    it('when we don\'t have the correct login information', function(done) {
-      if (dialect !== "postgres" && dialect !== "postgres-native" && dialect !== "mysql") {
-        console.log('This dialect doesn\'t support me :(')
-        expect('').toEqual('') // Silence Buster
-        return done()
-      }
-
-      if (noDomains === true) {
-        console.log('WARNING: Configuration specs requires NodeJS version >= 0.8 for full compatibility')
-        expect('').toEqual('') // Silence Buster!
-        return done()
-      }
-
-      (function() {
-        var sequelizeSpecific1 = new Sequelize(config[dialect].database, config[dialect].username, 'fakepass123', {logging: false, host: config[dialect].host, port: 1, dialect: dialect})
-        , domain = require('domain')
-        , d = domain.create()
-
-        d.on('error', function(err){
-          expect(err).toMatch(/^Failed to authenticate/)
-          d.remove(sequelizeSpecific1.query)
-          done()
-        })
-
-        d.run(function(){
-          d.add(sequelizeSpecific1.query)
-          sequelizeSpecific1.query('select 1 as hello')
-          .success(function(){})
-        })
-      })()
-    })
-
-    it('when we don\'t have a valid dialect.', function(done) {
-      expect(function() {
-        new Sequelize(config[dialect].database, config[dialect].username, config[dialect].password, {host: '0.0.0.1', port: config[dialect].port, dialect: undefined})
-      }).toThrow('Error', 'The dialect undefined is not supported.')
-      done()
-    })
-  })
-
-  describe('Instantiation with a URL string', function() {
-    it('should accept username, password, host, port, and database', function() {
-      var sequelize = new Sequelize('mysql://user:pass@example.com:9821/dbname')
-      var config = sequelize.config
-      var options = sequelize.options
-
-      expect(options.dialect).toEqual('mysql')
-
-      expect(config.database).toEqual('dbname')
-      expect(config.host).toEqual('example.com')
-      expect(config.username).toEqual('user')
-      expect(config.password).toEqual('pass')
-      expect(config.port).toEqual(9821)
-    })
-
-    it('should work with no authentication options', function() {
-      var sequelize = new Sequelize('mysql://example.com:9821/dbname')
-      var config = sequelize.config
-
-      expect(config.username).toEqual(undefined)
-      expect(config.password).toEqual(null)
-    })
-
-    it('should use the default port when no other is specified', function() {
-      var sequelize = new Sequelize('mysql://example.com/dbname')
-      var config = sequelize.config
-
-      // The default port should be set
-      expect(config.port).toEqual(3306)
-    })
-  })
-
-  describe('Intantiation with arguments', function() {
-    it('should accept two parameters (database, username)', function() {
-      var sequelize = new Sequelize('dbname', 'root')
-      var config = sequelize.config
-
-      expect(config.database).toEqual('dbname')
-      expect(config.username).toEqual('root')
-    })
-
-    it('should accept three parameters (database, username, password)', function() {
-      var sequelize = new Sequelize('dbname', 'root', 'pass')
-      var config = sequelize.config
-
-      expect(config.database).toEqual('dbname')
-      expect(config.username).toEqual('root')
-      expect(config.password).toEqual('pass')
-    })
-
-    it('should accept four parameters (database, username, password, options)', function() {
-      var sequelize = new Sequelize('dbname', 'root', 'pass', { port: 999 })
-      var config = sequelize.config
-
-      expect(config.database).toEqual('dbname')
-      expect(config.username).toEqual('root')
-      expect(config.password).toEqual('pass')
-      expect(config.port).toEqual(999)
-    })
-  })
-})

spec/dao.validations.spec.js → test/dao.validations.test.js

-var buster    = require("buster")
-  , Sequelize = require("../index")
-  , Helpers   = require('./buster-helpers')
-  , dialect   = Helpers.getTestDialect()
+var chai      = require('chai')
+  , expect    = chai.expect
+  , Sequelize = require(__dirname + '/../index')
+  , Utils     = require(__dirname + '/../lib/utils')
+  , Support   = require(__dirname + '/support')
+  , dialect   = Support.getTestDialect()
 
 
-buster.spec.expose()
-buster.testRunner.timeout = 1000
-
-describe(Helpers.getTestDialectTeaser("DaoValidator"), function() {
-  var sequelize = Helpers.createSequelizeInstance({dialect: dialect})
+describe(Support.getTestDialectTeaser("DaoValidator"), function() {
+  var sequelize = Support.createSequelizeInstance({ dialect: dialect })
 
 
   describe('validations', function() {
   describe('validations', function() {
-    beforeAll(function(done) {
-      var self = this
-      self.sequelize = Object.create(sequelize)
-      Helpers.clearDatabase(self.sequelize, done)
+    before(function(done) {
+      this.sequelize = Object.create(sequelize)
+      Support.clearDatabase(this.sequelize, done)
     })
     })
 
 
     var checks = {
     var checks = {
@@ -222,8 +220,8 @@ describe(Helpers.getTestDialectTeaser("DaoValidator"), function() {
             var failingUser = UserFail.build({ name : failingValue })
             var failingUser = UserFail.build({ name : failingValue })
               , errors      = failingUser.validate()
               , errors      = failingUser.validate()
 
 
-            expect(errors).not.toBeNull()
-            expect(errors).toEqual({ name : [message] })
+            expect(errors).not.to.be.null
+            expect(errors).to.eql({ name : [message] })
             done()
             done()
           })
           })
         }
         }
@@ -253,7 +251,7 @@ describe(Helpers.getTestDialectTeaser("DaoValidator"), function() {
             })
             })
 
 
             var successfulUser = UserSuccess.build({ name: succeedingValue })
             var successfulUser = UserSuccess.build({ name: succeedingValue })
-            expect(successfulUser.validate()).toBeNull()
+            expect(successfulUser.validate()).to.be.null
             done()
             done()
           })
           })
         }
         }
@@ -277,11 +275,12 @@ describe(Helpers.getTestDialectTeaser("DaoValidator"), function() {
       var failingUser = User.build({ name : "3" })
       var failingUser = User.build({ name : "3" })
         , errors      = failingUser.validate()
         , errors      = failingUser.validate()
 
 
-      expect(errors).not.toBeNull(null)
-      expect(errors).toEqual({ name: ["name should equal '2'"] })
+      expect(errors).not.to.be.null
+      expect(errors).to.eql({ name: ["name should equal '2'"] })
 
 
       var successfulUser = User.build({ name : "2" })
       var successfulUser = User.build({ name : "2" })
-      expect(successfulUser.validate()).toBeNull()
+      expect(successfulUser.validate()).to.be.null
+
       done()
       done()
     })
     })
 
 
@@ -299,14 +298,15 @@ describe(Helpers.getTestDialectTeaser("DaoValidator"), function() {
       var failingUser = User.build({ age: -1 })
       var failingUser = User.build({ age: -1 })
         , errors      = failingUser.validate()
         , errors      = failingUser.validate()
 
 
-      expect(errors).not.toBeNull(null)
-      expect(errors).toEqual({ age: ['must be positive'] })
+      expect(errors).not.to.be.null
+      expect(errors).to.eql({ age: ['must be positive'] })
 
 
       var successfulUser1 = User.build({ age: null })
       var successfulUser1 = User.build({ age: null })
-      expect(successfulUser1.validate()).toBeNull()
+      expect(successfulUser1.validate()).to.be.null
 
 
       var successfulUser2 = User.build({ age: 1 })
       var successfulUser2 = User.build({ age: 1 })
-      expect(successfulUser2.validate()).toBeNull()
+      expect(successfulUser2.validate()).to.be.null
+
       done()
       done()
     })
     })
 
 
@@ -333,11 +333,11 @@ describe(Helpers.getTestDialectTeaser("DaoValidator"), function() {
       var failingFoo = Foo.build({ field1: null, field2: null })
       var failingFoo = Foo.build({ field1: null, field2: null })
         , errors     = failingFoo.validate()
         , errors     = failingFoo.validate()
 
 
-      expect(errors).not.toBeNull()
-      expect(errors).toEqual({ 'xnor': ['xnor failed'] })
+      expect(errors).not.to.be.null
+      expect(errors).to.eql({ 'xnor': ['xnor failed'] })
 
 
       var successfulFoo = Foo.build({ field1: 33, field2: null })
       var successfulFoo = Foo.build({ field1: 33, field2: null })
-      expect(successfulFoo.validate()).toBeNull()
+      expect(successfulFoo.validate()).to.be.null
       done()
       done()
     })
     })
   })
   })

test/support.js

 var fs        = require('fs')
 var fs        = require('fs')
+  , Sequelize = require(__dirname + "/../index")
+  , DataTypes = require(__dirname + "/../lib/data-types")
+  , config    = require(__dirname + "/config/config")
 
 
 module.exports = {
 module.exports = {
+  Sequelize: Sequelize,
+
+  initTests: function(options) {
+    var sequelize = this.createSequelizeInstance(options)
+
+    this.clearDatabase(sequelize, function() {
+      if (options.context) {
+        options.context.sequelize = sequelize
+      }
+
+      if (options.beforeComplete) {
+        options.beforeComplete(sequelize, DataTypes)
+      }
+
+      if (options.onComplete) {
+        options.onComplete(sequelize, DataTypes)
+      }
+    })
+  },
+
+  createSequelizeInstance: function(options) {
+    options = options || {}
+
+    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:    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 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) {
+    sequelize
+      .getQueryInterface()
+      .dropAllTables()
+      .success(function() {
+        sequelize.daoFactoryManager.daos = []
+        callback && callback()
+      })
+      .error(function(err) { console.log(err) })
+  },
+
   getSupportedDialects: function() {
   getSupportedDialects: function() {
     return fs.readdirSync(__dirname + '/../lib/dialects').filter(function(file) {
     return fs.readdirSync(__dirname + '/../lib/dialects').filter(function(file) {
       return ((file.indexOf('.js') === -1) && (file.indexOf('abstract') === -1))
       return ((file.indexOf('.js') === -1) && (file.indexOf('abstract') === -1))