Add 'postgres' dialect to support PostgreSQL.

- The basic functionality seems to be working
- The DAO and DAO factory tests all pass.

.gitignore

 test*.js
+*.swp
 .idea
 .DS_STORE
 node_modules

lib/dialects/postgres/connector-manager.js

+var Query   = require("./query")
+  , Utils   = require("../../utils")
+  , without = function(arr, elem) { return arr.filter(function(e) { return e != elem }) }
+
+module.exports = (function() {
+  var ConnectorManager = function(sequelize, config) {
+    this.sequelize = sequelize
+    this.client = null
+    this.config = config || {}
+    this.disconnectTimeoutId = null
+    this.pendingQueries = 0
+    this.maxConcurrentQueries = (this.config.maxConcurrentQueries || 50)
+  }
+  Utils._.extend(ConnectorManager.prototype, require("../connector-manager").prototype)
+
+  var isConnecting = false
+  var isConnected  = false
+
+  ConnectorManager.prototype.query = function(sql, callee, options) {
+    var self = this
+    if (this.client == null) this.connect()
+    var query = new Query(this.client, callee, options || {})
+    self.pendingQueries += 1
+    return query.run(sql)
+      .success(function() { self.endQuery.call(self) })
+      .error(function() { self.endQuery.call(self) })
+  }
+
+  ConnectorManager.prototype.endQuery = function() {
+    var self = this
+    self.pendingQueries -= 1
+    if (self.pendingQueries == 0) {
+      setTimeout(function() {
+        self.pendingQueries == 0 && self.disconnect.call(self)
+      }, 100)
+    }
+  }
+
+  ConnectorManager.prototype.connect = function() {
+    var self = this
+
+    // in case database is slow to connect, prevent orphaning the client
+    if (this.isConnecting) return
+    this.isConnecting = true
+    this.isConnected  = false
+
+    var conStr = 'tcp://<%= user %>:<%= password %>@<%= host %>:<%= port %>/<%= database %>'
+    conStr = Utils._.template(conStr)({
+      user: this.config.username,
+      password: this.config.password,
+      database: this.config.database,
+      host: this.config.host,
+      port: this.config.port
+    })
+
+    var pg = require("pg")
+    this.client = new pg.Client(conStr)
+
+    this.client.connect(function(err, client) {
+      self.isConnecting = false
+      if (!err && client) {
+        self.isConnected = true
+        this.client = client
+      } else {
+        this.client = null
+      }
+    })
+  }
+
+  ConnectorManager.prototype.disconnect = function() {
+    var self = this
+    if (this.client) this.client.end()
+    this.client = null
+    this.isConnecting = false
+    this.isConnected  = false
+  }
+
+  return ConnectorManager
+})()

lib/dialects/postgres/query-generator.js

+var Utils = require("../../utils")
+  , util  = require("util")
+
+tables = {}
+
+function pgEscape(s) {
+  s = Utils.escape(s)
+  if (typeof s == 'string') s = s.replace(/\\"/g, '"')
+  return s
+}
+
+module.exports = (function() {
+  var QueryGenerator = {
+    createTableQuery: function(tableName, attributes, options) {
+      options = Utils._.extend({
+      }, options || {})
+
+      tables[tableName] = {}
+
+      var query   = "CREATE TABLE IF NOT EXISTS <%= table %> (<%= attributes%>)"
+        , primaryKeys = []
+        , attrStr = Utils._.map(attributes, function(dataType, attr) {
+            if (Utils._.includes(dataType, 'PRIMARY KEY')) {
+              primaryKeys.push(attr)
+              dataType = dataType.replace(/PRIMARY KEY/, '')
+            }
+
+            if (Utils._.includes(dataType, 'DATETIME')) {
+              dataType = dataType.replace(/DATETIME/, 'TIMESTAMP')
+            }
+
+            if (Utils._.includes(dataType, 'TINYINT(1)')) {
+              dataType = dataType.replace(/TINYINT\(1\)/, 'BOOLEAN')
+            }
+
+            if (Utils._.includes(dataType, 'DATETIME')) {
+              dataType = dataType.replace(/DATETIME/, 'TIMESTAMP')
+            }
+
+            if (Utils._.includes(dataType, 'SERIAL')) {
+              dataType = dataType.replace(/INTEGER/, '')
+              dataType = dataType.replace(/NOT NULL/, '')
+              tables[tableName][attr] = 'serial'
+            }
+
+            return attr + " " + dataType
+          }).join(", ")
+        , values  = {
+            table: tableName,
+            attributes: attrStr,
+            engine: options.engine,
+            charset: (options.charset ? "DEFAULT CHARSET=" + options.charset : "")
+          }
+        , pkString = primaryKeys.map(function(pk) {return pk}).join(", ")
+
+      if(pkString.length > 0) values.attributes += ", PRIMARY KEY (" + pkString + ")"
+
+      return Utils._.template(query)(values).trim() + ";"
+    },
+
+    dropTableQuery: function(tableName, options) {
+      options = options || {}
+
+      var query = "DROP TABLE IF EXISTS <%= table %>;"
+
+      return Utils._.template(query)({table: tableName})
+    },
+
+    renameTableQuery: function(before, after) {
+      var query = "ALTER TABLE <%= before %> RENAME TO <%= after %>;"
+      return Utils._.template(query)({ before: before, after: after })
+    },
+
+    showTablesQuery: function() {
+      return "SELECT table_name FROM information_schema.tables WHERE table_schema = 'public';"
+    },
+
+    addColumnQuery: function(tableName, attributes) {
+      var query      = "ALTER TABLE <%= tableName %> ADD COLUMN <%= attributes %>;"
+        , attrString = Utils._.map(attributes, function(definition, attributeName) {
+            return Utils._.template('<%= attributeName %> <%= definition %>')({
+              attributeName: attributeName,
+              definition: definition
+            })
+          }).join(', ')
+
+      return Utils._.template(query)({ tableName: tableName, attributes: attrString })
+    },
+
+    removeColumnQuery: function(tableName, attributeName) {
+      var query = "ALTER TABLE <%= tableName %> DROP COLUMN <%= attributeName %>;"
+      return Utils._.template(query)({ tableName: tableName, attributeName: attributeName })
+    },
+
+    changeColumnQuery: function(tableName, attributes) {
+      var query      = "ALTER TABLE <%= tableName %> ALTER COLUMN <%= attributes %>;"
+      var attrString = Utils._.map(attributes, function(definition, attributeName) {
+        return Utils._.template('<%= attributeName %> <%= attributeName %> <%= definition %>')({
+          attributeName: attributeName,
+          definition: definition
+        })
+      }).join(', ')
+
+      return Utils._.template(query)({ tableName: tableName, attributes: attrString })
+    },
+
+    renameColumnQuery: function(tableName, attrBefore, attributes) {
+      var query      = "ALTER TABLE <%= tableName %> RENAME COLUMN <%= attributes %>;"
+      var attrString = Utils._.map(attributes, function(definition, attributeName) {
+        return Utils._.template('<%= before %> TO <%= after %>')({
+          before: attrBefore,
+          after: attributeName,
+        })
+      }).join(', ')
+
+      return Utils._.template(query)({ tableName: tableName, attributes: attrString })
+    },
+
+    selectQuery: function(tableName, options) {
+      options = options || {}
+      options.table = Array.isArray(tableName) ? tableName.map(function(tbl){return tbl}).join(", ") : tableName
+      options.attributes = options.attributes && options.attributes.map(function(attr){
+        if(Array.isArray(attr) && attr.length == 2)
+          return [attr[0], attr[1]].join(' as ')
+        else
+          return attr.indexOf(Utils.TICK_CHAR)<0 ? attr : attr
+      }).join(", ")
+
+      options.attributes = options.attributes || '*'
+
+      var query = "SELECT <%= attributes %> FROM <%= table %>"
+
+      if(options.where) {
+        options.where = QueryGenerator.getWhereConditions(options.where)
+        query += " WHERE <%= where %>"
+      }
+      if(options.order) query += " ORDER BY <%= order %>"
+      if(options.group) {
+        options.group = options.group
+        query += " GROUP BY <%= group %>"
+      }
+      if(options.limit) query += " LIMIT <%= limit %>"
+      if(options.offset) query += " OFFSET <%= offset %>"
+
+      query += ";"
+      return Utils._.template(query)(options)
+    },
+
+    insertQuery: function(tableName, attrValueHash) {
+      var query = "INSERT INTO <%= table %> (<%= attributes %>) VALUES (<%= values %>) RETURNING *;"
+
+      returning = []
+      Utils._.forEach(attrValueHash, function(value, key, hash) {
+        if (tables[tableName] && tables[tableName][key]) {
+          switch (tables[tableName][key]) {
+            case 'serial':
+              delete hash[key]
+              returning.push(key)
+              break
+          }
+        }
+      });
+
+      var replacements  = {
+        table: tableName,
+        attributes: Utils._.keys(attrValueHash).map(function(attr){return attr}).join(","),
+        values: Utils._.values(attrValueHash).map(function(value){
+          return pgEscape((value instanceof Date) ? Utils.toSqlDate(value) : value)
+        }).join(",")
+      }
+
+      return Utils._.template(query)(replacements)
+    },
+
+    updateQuery: function(tableName, values, where) {
+      var query = "UPDATE <%= table %> SET <%= values %> WHERE <%= where %>"
+      var replacements = {
+        table: tableName,
+        values: Utils._.map(values, function(value, key){
+          return key + "=" + pgEscape((value instanceof Date) ? Utils.toSqlDate(value) : value)
+        }).join(","),
+        where: QueryGenerator.getWhereConditions(where)
+      }
+
+      return Utils._.template(query)(replacements)
+    },
+
+    deleteQuery: function(tableName, where, options) {
+      options = options || {}
+      options.limit = options.limit || 1
+
+      var query = "DELETE FROM <%= table %> WHERE <%= where %>"
+      var replacements = {
+        table: tableName,
+        where: QueryGenerator.getWhereConditions(where),
+        limit: pgEscape(options.limit)
+      }
+
+      return Utils._.template(query)(replacements)
+    },
+
+    addIndexQuery: function(tableName, attributes, options) {
+      var transformedAttributes = attributes.map(function(attribute) {
+        if(typeof attribute == 'string')
+          return attribute
+        else {
+          var result = ""
+
+          if(!attribute.attribute)
+            throw new Error('The following index attribute has no attribute: ' + util.inspect(attribute))
+
+          result += attribute.attribute
+
+          if(attribute.length)
+            result += '(' + attribute.length + ')'
+
+          if(attribute.order)
+            result += ' ' + attribute.order
+
+          return result
+        }
+      })
+
+      var onlyAttributeNames = attributes.map(function(attribute) {
+        return (typeof attribute == 'string') ? attribute : attribute.attribute
+      })
+
+      options = Utils._.extend({
+        indicesType: null,
+        indexName: Utils._.underscored(tableName + '_' + onlyAttributeNames.join('_')),
+        parser: null
+      }, options || {})
+
+      return Utils._.compact([
+        "CREATE", options.indicesType, "INDEX", options.indexName,
+        (options.indexType ? ('USING ' + options.indexType) : undefined),
+        "ON", tableName, '(' + transformedAttributes.join(', ') + ')',
+        (options.parser ? "WITH PARSER " + options.parser : undefined)
+      ]).join(' ')
+    },
+
+    showIndexQuery: function(tableName, options) {
+      var sql = "SHOW INDEX FROM <%= tableName %><%= options %>"
+      return Utils._.template(sql)({
+        tableName: tableName,
+        options: (options || {}).database ? ' FROM ' + options.database : ''
+      })
+    },
+
+    removeIndexQuery: function(tableName, indexNameOrAttributes) {
+      var sql       = "DROP INDEX <%= indexName %> ON <%= tableName %>"
+        , indexName = indexNameOrAttributes
+
+      if(typeof indexName != 'string')
+        indexName = Utils._.underscored(tableName + '_' + indexNameOrAttributes.join('_'))
+
+      return Utils._.template(sql)({ tableName: tableName, indexName: indexName })
+    },
+
+    getWhereConditions: function(smth) {
+      var result = null
+
+      if(Utils.isHash(smth))
+        result = QueryGenerator.hashToWhereConditions(smth)
+      else if(typeof smth == 'number')
+        result = 'id' + "=" + pgEscape(smth)
+      else if(typeof smth == "string")
+        result = smth
+      else if(Array.isArray(smth))
+        result = Utils.format(smth)
+
+      return result
+    },
+
+    hashToWhereConditions: function(hash) {
+      return Utils._.map(hash, function(value, key) {
+         //handle qualified key names
+        var _key   = key.split('.').map(function(col){return col}).join(".")
+          , _value = null
+
+      if(Array.isArray(value)) {
+          _value = "(" + Utils._.map(value, function(subvalue) {
+            return pgEscape(subvalue);
+          }).join(',') + ")"
+
+          return [_key, _value].join(" IN ")
+      }
+      else if ((value) && (typeof value == 'object')) {
+        //using as sentinel for join column => value
+        _value = value.join.split('.').map(function(col){return col}).join(".")
+        return [_key, _value].join("=")
+      } else {
+          _value = pgEscape(value)
+          return (_value == 'NULL') ? _key + " IS NULL" : [_key, _value].join("=")
+        }
+      }).join(" AND ")
+    },
+
+    attributesToSQL: function(attributes) {
+      var result = {}
+
+      Utils._.map(attributes, function(dataType, name) {
+        //console.log(name, 'dataType:', dataType)
+        if(Utils.isHash(dataType)) {
+          var template     = "<%= type %>"
+            , replacements = { type: dataType.type }
+
+          if(dataType.type == 'TINYINT(1)') dataType.type = 'BOOLEAN'
+          if(dataType.type == 'DATETIME') dataType.type = 'TIMESTAMP'
+
+          if(dataType.hasOwnProperty('allowNull') && (!dataType.allowNull)) template += " NOT NULL"
+          if(dataType.autoIncrement) template +=" SERIAL"
+          if(dataType.defaultValue != undefined) {
+            template += " DEFAULT <%= defaultValue %>"
+            replacements.defaultValue = pgEscape(dataType.defaultValue)
+          }
+          if(dataType.unique) template += " UNIQUE"
+          if(dataType.primaryKey) template += " PRIMARY KEY"
+
+          result[name] = Utils._.template(template)(replacements)
+        } else {
+          result[name] = dataType
+        }
+      })
+
+      return result
+    },
+
+    findAutoIncrementField: function(factory) {
+      var fields = Utils._.map(factory.attributes, function(definition, name) {
+        var isAutoIncrementField = (definition && (definition.indexOf('SERIAL') > -1))
+        return isAutoIncrementField ? name : null
+      })
+
+      return Utils._.compact(fields)
+    }
+  }
+
+  return Utils._.extend(Utils._.clone(require("../query-generator")), QueryGenerator)
+})()

lib/dialects/postgres/query.js

+var Utils = require("../../utils")
+
+module.exports = (function() {
+  var Query = function(client, callee, options) {
+    var self = this
+
+    this.client = client
+    this.callee = callee
+    this.options = Utils._.extend({
+      logging: true,
+      plain: false,
+      raw: false
+    }, options || {})
+  }
+  Utils._.extend(Query.prototype, require("../query").prototype)
+
+  Query.prototype.run = function(sql) {
+    var self = this
+
+    this.sql = sql
+
+    var results = [];
+    var receivedError = false;
+
+    var query = this.client.query(sql)
+    query.on('row', function(row) {
+      if (self.callee && self.sql.indexOf('INSERT INTO') == 0) {
+        Utils._.forEach(row, function(value, key) {
+          self.callee[key] = value
+        })
+        results.push(self.callee)
+      }
+
+      if (self.sql.indexOf('SELECT table_name FROM information_schema.tables') == 0) {
+        results.push(Utils._.values(row))
+      } else if (self.sql.indexOf('SELECT') == 0) {
+        // transform results into real model instances
+        // return the first real model instance if options.plain is set (e.g. Model.find)
+        if (self.options.raw) {
+          results.push(row);
+        } else {
+          results.push(self.callee.build(row, { isNewRecord: false }))
+        }
+      } else if((self.sql.indexOf('SHOW') == 0) || (self.sql.indexOf('DESCRIBE') == 0)) {
+        results.push(row)
+      }
+    });
+
+    query.on('end', function() {
+      self.emit('sql', self.sql)
+      if (receivedError) return;
+
+      if (self.sql.indexOf('SELECT') == 0) {
+        if (self.options.plain) {
+          self.emit('success', (results.length == 0) ? null : results[0])
+        } else {
+          self.emit('success', results)
+        }
+      } else if((self.sql.indexOf('SHOW') == 0) || (self.sql.indexOf('DESCRIBE') == 0)) {
+        self.emit('success', results)
+      } else if (self.sql.indexOf('INSERT INTO') == 0) {
+        self.emit('success', results[0])
+      } else if (self.sql.indexOf('UPDATE') == 0) {
+        self.emit('success', self.callee)
+      } else {
+        self.emit('success', results)
+      }
+    });
+
+    query.on('error', function(err) {
+      receivedError = true
+      self.emit('failure', err, self.callee)
+    });
+
+    return this
+  }
+
+  return Query
+})()

package.json

@@ -20,6 +20,7 @@
   "devDependencies": {
     "jasmine-node": "1.0.22",
     "sqlite3": ">=2.0.0",
+    "pg": "0.6.x",
     "buster": "0.4.x"
   },
   "keywords": ["mysql", "orm", "nodejs", "object relational mapper"],

spec-jasmine/associations/belongs-to.spec.js

 var config    = require("../config/config")
   , Sequelize = require("../../index")
-  , sequelize = new Sequelize(config.database, config.username, config.password, { logging: false })
+  , sequelize = new Sequelize(config.mysql.database, config.mysql.username, config.mysql.password, { logging: false })
   , Helpers   = new (require("../config/helpers"))(sequelize)
 
 describe('BelongsTo', function() {

spec-jasmine/associations/has-many.spec.js

 var config    = require("../config/config")
   , Sequelize = require("../../index")
-  , sequelize = new Sequelize(config.database, config.username, config.password, { logging: false })
+  , sequelize = new Sequelize(config.mysql.database, config.mysql.username, config.mysql.password, { logging: false })
   , Helpers   = new (require("../config/helpers"))(sequelize)
 
 describe('HasMany', function() {
@@ -10,7 +10,7 @@ describe('HasMany', function() {
     , Helpers   = null
 
   var setup = function() {
-    sequelize = new Sequelize(config.database, config.username, config.password, { logging: false })
+    sequelize = new Sequelize(config.mysql.database, config.mysql.username, config.mysql.password, { logging: false })
     Helpers   = new (require("../config/helpers"))(sequelize)
 
     Helpers.dropAllTables()

spec-jasmine/associations/has-one.spec.js

 var config    = require("../config/config")
   , Sequelize = require("../../index")
-  , sequelize = new Sequelize(config.database, config.username, config.password, { logging: false })
+  , sequelize = new Sequelize(config.mysql.database, config.mysql.username, config.mysql.password, { logging: false })
   , Helpers   = new (require("../config/helpers"))(sequelize)
 
 describe('HasOne', function() {

spec-jasmine/config/config.js

 module.exports = {
+  rand: function() {
+    return parseInt(Math.random() * 999)
+  },
+
+  mysql: {
     username: "root",
     password: null,
     database: 'sequelize_test',
     host: '127.0.0.1',
-  rand: function() {
-    return parseInt(Math.random() * 999)
+    port: 3306
+  },
+
+  sqlite: {
+  },
+
+  postgres: {
+    database: 'sequelize_test',
+    port: 5432
   }
 }
 

spec-jasmine/dao-factory.spec.js

 var config    = require("./config/config")
   , Sequelize = require("../index")
-  , dialects  = ['sqlite', 'mysql']
+  , dialects  = ['sqlite', 'mysql', 'postgres']
 
 describe('DAOFactory', function() {
   dialects.forEach(function(dialect) {
     describe('with dialect "' + dialect + '"', function() {
       var User      = null
-        , sequelize = new Sequelize(config.database, config.username, config.password, {
+        , sequelize = new Sequelize(
+            config[dialect].database,
+            config[dialect].username,
+            config[dialect].password,
+            {
               logging: false,
-          dialect: dialect
-        })
+              dialect: dialect,
+              port: config[dialect].port
+            }
+          )
         , Helpers   = new (require("./config/helpers"))(sequelize)
 
       var setup = function(options) {
@@ -109,7 +115,8 @@ describe('DAOFactory', function() {
 
                 checkMatchForDialects(err.message, {
                   sqlite: /.*SQLITE_CONSTRAINT.*/,
-                  mysql: /.*Duplicate\ entry.*/
+                  mysql: /.*Duplicate\ entry.*/,
+                  postgres: /.*duplicate\ key\ value.*/
                 })
 
                 done()
@@ -130,7 +137,8 @@ describe('DAOFactory', function() {
 
               checkMatchForDialects(err.message, {
                 sqlite: /.*SQLITE_CONSTRAINT.*/,
-                mysql: "Column 'smth' cannot be null"
+                mysql: "Column 'smth' cannot be null",
+                postgres: /.*column "smth" violates not-null.*/
               })
 
               User.create({username: 'foo', smth: 'foo'}).success(function() {
@@ -139,7 +147,8 @@ describe('DAOFactory', function() {
 
                   checkMatchForDialects(err.message, {
                     sqlite: /.*SQLITE_CONSTRAINT.*/,
-                    mysql: "Duplicate entry 'foo' for key 'username'"
+                    mysql: "Duplicate entry 'foo' for key 'username'",
+                    postgres: /.*duplicate key value violates unique constraint.*/
                   })
 
                   done()

spec-jasmine/dao.spec.js

 var config    = require("./config/config")
   , Sequelize = require("../index")
-  , dialects  = ['sqlite', 'mysql']
+  , dialects  = ['sqlite', 'mysql', 'postgres']
 
 describe('DAO', function() {
   dialects.forEach(function(dialect) {
     describe('with dialect "' + dialect + '"', function() {
       var User      = null
-        , sequelize = new Sequelize(config.database, config.username, config.password, {
+        , sequelize = new Sequelize(
+            config[dialect].database,
+            config[dialect].username,
+            config[dialect].password,
+            {
               logging: false,
-          dialect: dialect
-        })
+              dialect: dialect,
+              port: config[dialect].port
+            }
+          )
         , Helpers   = new (require("./config/helpers"))(sequelize)
 
       var setup = function() {
@@ -471,7 +477,7 @@ describe('DAO', function() {
             }).success(function(user) {
               var emitter = user.updateAttributes({name: 'foobar'})
               emitter.success(function() {
-                expect(emitter.query.sql).toMatch(/WHERE `identifier`..identifier./)
+                expect(emitter.query.sql).toMatch(/WHERE `?identifier`?..identifier./)
                 done()
               })
             })

spec-jasmine/migration.spec.js

 var config    = require("./config/config")
   , Sequelize = require("../index")
-  , sequelize = new Sequelize(config.database, config.username, config.password, { logging: false })
+  , sequelize = new Sequelize(config.mysql.database, config.mysql.username, config.mysql.password, { logging: false })
   , Helpers   = new (require("./config/helpers"))(sequelize)
   , Migrator  = require("../lib/migrator")
   , Migration = require("../lib/migration")

spec-jasmine/migrator.spec.js

 var config    = require("./config/config")
   , Sequelize = require("../index")
-  , sequelize = new Sequelize(config.database, config.username, config.password, { logging: false })
+  , sequelize = new Sequelize(config.mysql.database, config.mysql.username, config.mysql.password, { logging: false })
   , Helpers   = new (require("./config/helpers"))(sequelize)
   , Migrator  = require("../lib/migrator")
   , _         = Sequelize.Utils._

spec-jasmine/mysql/associations.has-many.spec.js

 var config    = require("../config/config")
   , Sequelize = require("../../index")
-  , sequelize = new Sequelize(config.database, config.username, config.password, { logging: false })
+  , sequelize = new Sequelize(config.mysql.database, config.mysql.username, config.mysql.password, { logging: false })
   , Helpers   = new (require("../config/helpers"))(sequelize)
 
 describe('HasMany', function() {

spec-jasmine/mysql/associations.spec.js

 var config    = require("../config/config")
   , Sequelize = require("../../index")
-  , sequelize = new Sequelize(config.database, config.username, config.password, { logging: false })
+  , sequelize = new Sequelize(config.mysql.database, config.mysql.username, config.mysql.password, { logging: false })
   , Helpers   = new (require("../config/helpers"))(sequelize)
 
 describe('Associations', function() {

spec-jasmine/mysql/connector-manager.spec.js

 var config    = require("../config/config")
   , Sequelize = require("../../index")
-  , sequelize = new Sequelize(config.database, config.username, config.password, { logging: false })
+  , sequelize = new Sequelize(config.mysql.database, config.mysql.username, config.mysql.password, { logging: false })
   , Helpers   = new (require("../config/helpers"))(sequelize)
 
 describe('ConnectorManager', function() {

spec-jasmine/mysql/dao-factory.spec.js

 var config    = require("../config/config")
   , Sequelize = require("../../index")
-  , sequelize = new Sequelize(config.database, config.username, config.password, { logging: false })
+  , sequelize = new Sequelize(config.mysql.database, config.mysql.username, config.mysql.password, { logging: false })
   , Helpers   = new (require("../config/helpers"))(sequelize)
 
 describe('DAOFactory', function() {

spec-jasmine/mysql/query-generator.spec.js

 var config         = require("../config/config")
   , Sequelize      = require("../../index")
-  , sequelize      = new Sequelize(config.database, config.username, config.password, { logging: false })
+  , sequelize      = new Sequelize(config.mysql.database, config.mysql.username, config.mysql.password, { logging: false })
   , Helpers        = new (require("../config/helpers"))(sequelize)
   , QueryGenerator = require("../../lib/dialects/mysql/query-generator")
   , util          = require("util")

spec-jasmine/query-interface.spec.js

 var config         = require("./config/config")
   , Sequelize      = require("../index")
-  , sequelize      = new Sequelize(config.database, config.username, config.password, { logging: false })
+  , sequelize      = new Sequelize(config.mysql.database, config.mysql.username, config.mysql.password, { logging: false })
   , Helpers        = new (require("./config/helpers"))(sequelize)
   , QueryInterface = require("../lib/query-interface")
 

spec-jasmine/sequelize.spec.js

@@ -9,7 +9,7 @@ describe('Sequelize', function() {
 
   var setup = function(options) {
     options   = options || {logging: false}
-    sequelize = new Sequelize(config.database, config.username, config.password, options)
+    sequelize = new Sequelize(config.mysql.database, config.mysql.username, config.mysql.password, options)
     Helpers   = new (require("./config/helpers"))(sequelize)
 
     return options