refactor(connections): fix maria connections, fix more tests

lib/connection-manager.js → lib/dialects/abstract/connection-manager.js

 "use strict";
 
 var Pooling = require('generic-pool')
-  , Promise = require('./promise')
+  , Promise = require('../../promise')
   , _ = require('lodash')
   , defaultPoolingConfig = {
-    max: 10,
+    max: 5,
     min: 0,
     idle: 10000,
     handleDisconnects: false
   }
   , ConnectionManager;
 
-ConnectionManager = function(sequelize) {
+ConnectionManager = function(dialect, sequelize) {
   var config = sequelize.config
     , self = this;
 
+  this.sequelize = sequelize;
   this.config = config;
-  this.dialect = sequelize.dialect;
+  this.dialect = dialect;
 
   if (config.pool) {
     config.pool = _.extend({}, config.pool); // Make sure we don't modify the existing config object (user might re-use it)
@@ -160,6 +161,7 @@ ConnectionManager = function(sequelize) {
 ConnectionManager.prototype.getConnection = function(options) {
   var self = this;
   options = options || {};
+
   return new Promise(function (resolve, reject) {
     self.pool.acquire(function(err, connection) {
       if (err) return reject(err);
@@ -169,6 +171,7 @@ ConnectionManager.prototype.getConnection = function(options) {
 };
 ConnectionManager.prototype.releaseConnection = function(connection) {
   var self = this;
+
   return new Promise(function (resolve, reject) {
     self.pool.release(connection);
     resolve();

lib/dialects/mariadb/connection-manager.js

 "use strict";
-var ConnectionManager
+var AbstractConnectionManager = require('../abstract/connection-manager')
+  , ConnectionManager
+  , Utils = require('../../utils')
   , Promise = require('../../promise');
 
 ConnectionManager = function(dialect, sequelize) {
+  AbstractConnectionManager.call(this, dialect, sequelize);
+
   try {
     this.lib = require(sequelize.config.dialectModulePath || 'mariasql');
   } catch (err) {
@@ -10,15 +14,52 @@ ConnectionManager = function(dialect, sequelize) {
   }
 };
 
+Utils._.extend(ConnectionManager.prototype, AbstractConnectionManager.prototype);
+
 ConnectionManager.prototype.connect = function(config) {
+  var self = this;
   return new Promise(function (resolve, reject) {
+    var connectionConfig = {
+      host: config.host,
+      port: config.port,
+      user: config.username,
+      password: config.password,
+      db: config.database,
+      metadata: true
+    };
+
+    if (config.dialectOptions) {
+      Object.keys(config.dialectOptions).forEach(function(key) {
+        connectionConfig[key] = config.dialectOptions[key];
+      });
+    }
+
+    if (connectionConfig.unixSocket) {
+      delete connectionConfig.host;
+      delete connectionConfig.port;
+    }
 
+    var connection = new self.lib();
+    connection.connect(connectionConfig);
+    connection.on('error', function(err) {
+      return reject(err);
+    });
+    connection.on('connect', function() {
+      return resolve(connection);
+    });
+
+  }).tap(function (connection) {
+    connection.query("SET time_zone = '+0:00'");
   });
 };
 ConnectionManager.prototype.disconnect = function(connection) {
   return new Promise(function (resolve, reject) {
-
+    connection.end();
+    resolve();
   });
 };
+ConnectionManager.prototype.validate = function(connection) {
+  return connection && connection.state !== 'disconnected';
+};
 
 module.exports = ConnectionManager;
\ No newline at end of file

lib/dialects/mysql/connection-manager.js

 "use strict";
-var ConnectionManager
+var AbstractConnectionManager = require('../abstract/connection-manager')
+  , ConnectionManager
+  , Utils = require('../../utils')
   , Promise = require('../../promise');
 
 ConnectionManager = function(dialect, sequelize) {
+  AbstractConnectionManager.call(this, dialect, sequelize);
+
+  this.sequelize = sequelize;
+  this.sequelize.config.port = this.sequelize.config.port || 3306;
   try {
     this.lib = require(sequelize.config.dialectModulePath || 'mysql');
   } catch (err) {
@@ -10,6 +16,8 @@ ConnectionManager = function(dialect, sequelize) {
   }
 };
 
+Utils._.extend(ConnectionManager.prototype, AbstractConnectionManager.prototype);
+
 ConnectionManager.prototype.connect = function(config) {
   var self = this;
   return new Promise(function (resolve, reject) {

lib/dialects/postgres/connection-manager.js

 "use strict";
-var ConnectionManager
+var AbstractConnectionManager = require('../abstract/connection-manager')
+  , ConnectionManager
+  , Utils = require('../../utils')
   , Promise = require('../../promise');
 
 ConnectionManager = function(dialect, sequelize) {
+  AbstractConnectionManager.call(this, dialect, sequelize);
+
   this.sequelize = sequelize;
   this.sequelize.config.port = this.sequelize.config.port || 5432;
   try {
@@ -12,6 +16,8 @@ ConnectionManager = function(dialect, sequelize) {
   }
 };
 
+Utils._.extend(ConnectionManager.prototype, AbstractConnectionManager.prototype);
+
 ConnectionManager.prototype.connect = function(config) {
   var self = this;
 

lib/dialects/sqlite/connection-manager.js

 "use strict";
-var ConnectionManager
+var AbstractConnectionManager = require('../abstract/connection-manager')
+  , ConnectionManager
+  , Utils = require('../../utils')
   , Promise = require('../../promise');
 
 ConnectionManager = function(dialect, sequelize) {
   this.sequelize = sequelize;
+  this.config = sequelize.config;
+  this.dialect = dialect;
+  this.connection = null;
 
   try {
     this.lib = require(sequelize.config.dialectModulePath || 'sqlite3').verbose();
@@ -12,15 +17,20 @@ ConnectionManager = function(dialect, sequelize) {
   }
 };
 
-ConnectionManager.prototype.connect = function(config) {
+Utils._.extend(ConnectionManager.prototype, AbstractConnectionManager.prototype);
+
+ConnectionManager.prototype.getConnection = function(options) {
   var self = this;
+  
+  if (self.connection) return Promise.resolve(self.connection);
+
   return new Promise(function (resolve, reject) {
-    var connection = new self.lib.Database(self.sequelize.options.storage || ':memory:', function(err) {
+    self.connection = new self.lib.Database(self.sequelize.options.storage || ':memory:', function(err) {
       if (err) {
         if (err.code === 'SQLITE_CANTOPEN') return reject('Failed to find SQL server. Please double check your settings.');
         return reject(err);
       }
-      resolve(connection);
+      resolve(self.connection);
     });
   }).tap(function (connection) {
     if (self.sequelize.options.foreignKeys !== false) {
@@ -30,13 +40,9 @@ ConnectionManager.prototype.connect = function(config) {
     }
   });
 };
-ConnectionManager.prototype.disconnect = function(connection) {
-  return new Promise(function (resolve, reject) {
-    connection.close(function (err) {
-      if (err) return reject(err);
-      resolve();
-    });
-  });
+
+ConnectionManager.prototype.releaseConnection = function(connection) {
+  // no-op
 };
 
 module.exports = ConnectionManager;
\ No newline at end of file

lib/dialects/sqlite/index.js

@@ -16,5 +16,6 @@ SqliteDialect.prototype.supports = _.defaults({
 }, Abstract.prototype.supports);
 
 SqliteDialect.prototype.Query = Query;
+SqliteDialect.prototype.name = 'sqlite';
 
 module.exports = SqliteDialect;
\ No newline at end of file

lib/sequelize.js

@@ -7,7 +7,6 @@ var url = require('url')
   , DataTypes = require('./data-types')
   , ModelManager = require('./model-manager')
   , QueryInterface = require('./query-interface')
-  , ConnectionManager = require('./connection-manager')
   , Transaction = require('./transaction')
   , QueryTypes = require('./query-types')
   , sequelizeErrors = require('./errors')
@@ -122,7 +121,6 @@ module.exports = (function() {
       sync: {},
       logging: console.log,
       omitNull: false,
-      queue: true,
       native: false,
       replication: false,
       ssl: undefined,
@@ -170,7 +168,7 @@ module.exports = (function() {
      */
     this.models = {};
     this.modelManager = this.daoFactoryManager = new ModelManager(this);
-    this.connectionManager = new ConnectionManager(this);
+    this.connectionManager = this.dialect.connectionManager;
 
     this.importCache = {};
   };

test/sequelize.test.js

@@ -99,12 +99,10 @@ describe(Support.getTestDialectTeaser("Sequelize"), function () {
               if (dialect === 'mariadb') {
                 expect(err.message).to.match(/Access denied for user/)
               } else if (dialect === 'postgres') {
-                // When the test is run with only it produces:
-                // Error: Error: Failed to authenticate for PostgresSQL. Please double check your settings.
-                expect(err.message).to.match(/Failed to authenticate for PostgresSQL/)
-                // When its run with all the other tests it produces:
-                // Error: invalid port number: "99999"
-                //expect(err.message).to.match(/invalid port number/)
+                expect(
+                  err.message.match(/Failed to authenticate for PostgresSQL/) ||
+                  err.message.match(/invalid port number/)
+                ).to.be.ok
               } else {
                 expect(err.message).to.match(/Failed to authenticate/)
               }

test/support.js

@@ -37,7 +37,7 @@ var Support = {
 
     if (dialect === 'sqlite') {
       var options    = Sequelize.Utils._.extend({}, sequelize.options, { storage: path.join(__dirname, 'tmp', 'db.sqlite') })
-        , _sequelize = new Sequelize(sequelize.config.datase, null, null, options)
+        , _sequelize = new Sequelize(sequelize.config.database, null, null, options)
 
       _sequelize.sync({ force: true }).success(function() { callback(_sequelize) })
     } else {