Added MySQL specific tests.

test/mysql/associations.test.js

+var chai      = require('chai')
+  , expect    = chai.expect
+  , Support   = require(__dirname + '/../support')
+  , dialect   = Support.getTestDialect()
+  , sinon     = require('sinon')
+  , DataTypes = require(__dirname + "/../../lib/data-types")
+
+chai.Assertion.includeStack = true
+
+if (dialect.match(/^mysql/)) {
+  describe('[MYSQL Specific] Associations', function() {
+    describe('many-to-many', function() {
+      describe('where tables have the same prefix', function() {
+        it("should create a table wp_table1wp_table2s", function(done) {
+          var Table2 = this.sequelize.define('wp_table2', {foo: DataTypes.STRING})
+            , Table1 = this.sequelize.define('wp_table1', {foo: DataTypes.STRING})
+            , self = this
+
+          Table1.hasMany(Table2)
+          Table2.hasMany(Table1)
+          Table1.sync({ force: true }).success(function() {
+            Table2.sync({ force: true }).success(function() {
+              expect(self.sequelize.daoFactoryManager.getDAO('wp_table1swp_table2s')).to.exist
+              done()
+            })
+          })
+        })
+      })
+
+      describe('when join table name is specified', function() {
+        beforeEach(function(done){
+          var Table2 = this.sequelize.define('ms_table1', {foo: DataTypes.STRING})
+            , Table1 = this.sequelize.define('ms_table2', {foo: DataTypes.STRING})
+
+          Table1.hasMany(Table2, {joinTableName: 'table1_to_table2'})
+          Table2.hasMany(Table1, {joinTableName: 'table1_to_table2'})
+          Table1.sync({ force: true }).success(function() {
+            Table2.sync({ force: true }).success(function() {
+              done()
+            })
+          })
+        })
+
+        it("should not use only a specified name", function() {
+          expect(this.sequelize.daoFactoryManager.getDAO('ms_table1sms_table2s')).not.to.exist
+          expect(this.sequelize.daoFactoryManager.getDAO('table1_to_table2')).to.exist
+        })
+      })
+    })
+
+
+    describe('HasMany', function() {
+      beforeEach(function(done) {
+        //prevent periods from occurring in the table name since they are used to delimit (table.column)
+        this.User  = this.sequelize.define('User' + Math.ceil(Math.random()*10000000), { name: DataTypes.STRING })
+        this.Task  = this.sequelize.define('Task' + Math.ceil(Math.random()*10000000), { name: DataTypes.STRING })
+        this.users = null
+        this.tasks = null
+
+        this.User.hasMany(this.Task, {as:'Tasks'})
+        this.Task.hasMany(this.User, {as:'Users'})
+
+        var self = this
+          , users = []
+          , tasks = []
+
+        for (var i = 0; i < 5; ++i) {
+          users[users.length] = {name: 'User' + Math.random()}
+        }
+
+        for (var x = 0; x < 5; ++x) {
+          tasks[tasks.length] = {name: 'Task' + Math.random()}
+        }
+
+        this.User.sync({ force: true }).success(function() {
+          self.Task.sync({ force: true }).success(function() {
+            self.User.bulkCreate(users).success(function() {
+              self.Task.bulkCreate(tasks).success(function() {
+                done()
+              })
+            })
+          })
+        })
+      })
+
+      describe('addDAO / getDAO', function() {
+        beforeEach(function(done) {
+          var self = this
+
+          self.user = null
+          self.task = null
+
+          self.User.all().success(function(_users) {
+            self.Task.all().success(function(_tasks) {
+              self.user = _users[0]
+              self.task = _tasks[0]
+              done()
+            })
+          })
+        })
+
+        it('should correctly add an association to the dao', function(done) {
+          var self = this
+
+          self.user.getTasks().on('success', function(_tasks) {
+            expect(_tasks.length).to.equal(0)
+            self.user.addTask(self.task).on('success', function() {
+              self.user.getTasks().on('success', function(_tasks) {
+                expect(_tasks.length).to.equal(1)
+                done()
+              })
+            })
+          })
+        })
+      })
+
+      describe('removeDAO', function() {
+        beforeEach(function(done) {
+          var self = this
+
+          self.user = null
+          self.tasks = null
+
+          self.User.all().success(function(_users) {
+            self.Task.all().success(function(_tasks) {
+              self.user = _users[0]
+              self.tasks = _tasks
+              done()
+            })
+          })
+        })
+
+        it("should correctly remove associated objects", function(done) {
+          var self = this
+
+          self.user.getTasks().on('success', function(__tasks) {
+            expect(__tasks.length).to.equal(0)
+            self.user.setTasks(self.tasks).on('success', function() {
+              self.user.getTasks().on('success', function(_tasks) {
+                expect(_tasks.length).to.equal(self.tasks.length)
+                self.user.removeTask(self.tasks[0]).on('success', function() {
+                  self.user.getTasks().on('success', function(_tasks) {
+                    expect(_tasks.length).to.equal(self.tasks.length - 1)
+                    done()
+                  })
+                })
+              })
+            })
+          })
+        })
+      })
+    })
+  })
+}

test/mysql/connector-manager.test.js

+var chai      = require('chai')
+  , expect    = chai.expect
+  , Support   = require(__dirname + '/../support')
+  , dialect   = Support.getTestDialect()
+  , sinon     = require('sinon')
+  , DataTypes = require(__dirname + "/../../lib/data-types")
+
+chai.Assertion.includeStack = true
+
+if (dialect.match(/^mysql/)) {
+  describe('[MYSQL Specific] Connector Manager', function() {
+    this.timeout(10000)
+
+    it('works correctly after being idle', function(done) {
+      var User = this.sequelize.define('User', { username: DataTypes.STRING })
+      , spy = sinon.spy()
+
+      User.sync({force: true}).on('success', function() {
+        User.create({username: 'user1'}).on('success', function() {
+          User.count().on('success', function(count) {
+            expect(count).to.equal(1)
+            spy()
+
+            setTimeout(function() {
+              User.count().on('success', function(count) {
+                expect(count).to.equal(1)
+                spy()
+                if (spy.calledTwice) {
+                  done()
+                }
+              })
+            }, 1000)
+          })
+        })
+      })
+    })
+  })
+}

test/mysql/dao-factory.test.js

+/* jshint camelcase: false */
+var chai      = require('chai')
+  , expect    = chai.expect
+  , Support   = require(__dirname + '/../support')
+  , DataTypes = require(__dirname + "/../../lib/data-types")
+  , dialect   = Support.getTestDialect()
+  , config    = require(__dirname + "/../config/config")
+
+chai.Assertion.includeStack = true
+
+if (dialect.match(/^mysql/)) {
+  describe("[MYSQL Specific] DAOFactory", function () {
+    describe('constructor', function() {
+      it("handles extended attributes (unique)", function(done) {
+        var User = this.sequelize.define('User' + config.rand(), {
+          username: { type: DataTypes.STRING, unique: true }
+        }, { timestamps: false })
+        expect(User.attributes).to.deep.equal({username:"VARCHAR(255) UNIQUE",id:"INTEGER NOT NULL auto_increment PRIMARY KEY"})
+        done()
+      })
+
+      it("handles extended attributes (default)", function(done) {
+        var User = this.sequelize.define('User' + config.rand(), {
+          username: {type: DataTypes.STRING, defaultValue: 'foo'}
+        }, { timestamps: false })
+        expect(User.attributes).to.deep.equal({username:"VARCHAR(255) DEFAULT 'foo'",id:"INTEGER NOT NULL auto_increment PRIMARY KEY"})
+        done()
+      })
+
+      it("handles extended attributes (null)", function(done) {
+        var User = this.sequelize.define('User' + config.rand(), {
+          username: {type: DataTypes.STRING, allowNull: false}
+        }, { timestamps: false })
+        expect(User.attributes).to.deep.equal({username:"VARCHAR(255) NOT NULL",id:"INTEGER NOT NULL auto_increment PRIMARY KEY"})
+        done()
+      })
+
+      it("handles extended attributes (comment)", function(done) {
+        var User = this.sequelize.define('User' + config.rand(), {
+          username: {type: DataTypes.STRING, comment: 'This be\'s a comment'}
+        }, { timestamps: false })
+        expect(User.attributes).to.deep.equal({username:"VARCHAR(255) COMMENT 'This be\\'s a comment'",id:"INTEGER NOT NULL auto_increment PRIMARY KEY"})
+        done()
+      })
+
+      it("handles extended attributes (primaryKey)", function(done) {
+        var User = this.sequelize.define('User' + config.rand(), {
+          username: {type: DataTypes.STRING, primaryKey: true}
+        }, { timestamps: false })
+        expect(User.attributes).to.deep.equal({username:"VARCHAR(255) PRIMARY KEY"})
+        done()
+      })
+
+      it("adds timestamps", function(done) {
+        var User1 = this.sequelize.define('User' + config.rand(), {})
+        var User2 = this.sequelize.define('User' + config.rand(), {}, { timestamps: true })
+
+        expect(User1.attributes).to.deep.equal({id:"INTEGER NOT NULL auto_increment PRIMARY KEY", updatedAt:"DATETIME NOT NULL", createdAt:"DATETIME NOT NULL"})
+        expect(User2.attributes).to.deep.equal({id:"INTEGER NOT NULL auto_increment PRIMARY KEY", updatedAt:"DATETIME NOT NULL", createdAt:"DATETIME NOT NULL"})
+        done()
+      })
+
+      it("adds deletedAt if paranoid", function(done) {
+        var User = this.sequelize.define('User' + config.rand(), {}, { paranoid: true })
+        expect(User.attributes).to.deep.equal({id:"INTEGER NOT NULL auto_increment PRIMARY KEY", deletedAt:"DATETIME", updatedAt:"DATETIME NOT NULL", createdAt:"DATETIME NOT NULL"})
+        done()
+      })
+
+      it("underscores timestamps if underscored", function(done) {
+        var User = this.sequelize.define('User' + config.rand(), {}, { paranoid: true, underscored: true })
+        expect(User.attributes).to.deep.equal({id:"INTEGER NOT NULL auto_increment PRIMARY KEY", deleted_at:"DATETIME", updated_at:"DATETIME NOT NULL", created_at:"DATETIME NOT NULL"})
+        done()
+      })
+    })
+
+    describe('primaryKeys', function() {
+      it("determines the correct primaryKeys", function(done) {
+        var User = this.sequelize.define('User' + config.rand(), {
+          foo: {type: DataTypes.STRING, primaryKey: true},
+          bar: DataTypes.STRING
+        })
+        expect(User.primaryKeys).to.deep.equal({"foo":"VARCHAR(255) PRIMARY KEY"})
+        done()
+      })
+    })
+  })
+}