Corrected all of the tests, MySQL doesn't return false for defaultValue of boole…

…an, not sure if this is intentional or not.

test/config/config.js

@@ -26,6 +26,6 @@ module.exports = {
     database: 'sequelize_test',
     database: 'sequelize_test',
     username: "postgres",
     username: "postgres",
     port: 5432,
     port: 5432,
-    pool: { maxConnections: 5, maxIdleTime: 30}
+    pool: { maxConnections: 5, maxIdleTime: 3000}
   }
   }
 }
 }

test/configuration.test.js

 var chai      = require('chai')
 var chai      = require('chai')
   , expect    = chai.expect
   , expect    = chai.expect
-  , semver    = require("semver")
   , config    = require(__dirname + "/config/config")
   , config    = require(__dirname + "/config/config")
   , Support   = require(__dirname + '/support')
   , Support   = require(__dirname + '/support')
   , dialect   = Support.getTestDialect()
   , dialect   = Support.getTestDialect()
   , Sequelize = require(__dirname + '/../index')
   , Sequelize = require(__dirname + '/../index')
-  , noDomains = semver.lt(process.version, '0.8.0')
 
 
 chai.Assertion.includeStack = true
 chai.Assertion.includeStack = true
 
 
 describe(Support.getTestDialectTeaser("Configuration"), function() {
 describe(Support.getTestDialectTeaser("Configuration"), function() {
-  describe.skip('Connections problems should fail with a nice message', function() {
+  describe('Connections problems should fail with a nice message', function() {
     it("when we don't have the correct server details", function(done) {
     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('').to.equal('') // Silence Buster!
-        done()
-      } else {
-        var seq    = 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')
-          , domain = Domain.create()
+      // mysql is not properly supported due to the custom pooling system
+      if (dialect !== "postgres" && dialect !== "postgres-native") {
+        console.log('This dialect doesn\'t support me :(')
+        expect(true).to.be.true // Silence Buster
+        return done()
+      }
 
 
-        domain.on('error', function(err){
-          expect(err.toString()).to.match(/Failed to find (.*?) Please double check your settings\./)
-          domain.remove(seq.query)
+      var seq = 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})
+      seq.query('select 1 as hello').error(function(err) {
+        expect(err.message).to.match(/Failed to find (.*?) Please double check your settings\./)
         done()
         done()
       })
       })
-
-        domain.run(function(){
-          domain.add(seq.query)
-          seq.query('select 1 as hello')
-          .success(function(){})
-        })
-      }
     })
     })
 
 
     it('when we don\'t have the correct login information', function(done) {
     it('when we don\'t have the correct login information', function(done) {
-      if (dialect !== "postgres" && dialect !== "postgres-native" && dialect !== "mysql") {
+      if (dialect !== "postgres" && dialect !== "postgres-native") {
         console.log('This dialect doesn\'t support me :(')
         console.log('This dialect doesn\'t support me :(')
-        expect('').to.equal('') // Silence Buster
-        return done()
-      } else if (noDomains === true) {
-        console.log('WARNING: Configuration specs requires NodeJS version >= 0.8 for full compatibility')
-        expect('').to.equal('') // Silence Buster!
+        expect(true).to.be.true // Silence Buster
         return done()
         return done()
-      } else {
-        var seq    = new Sequelize(config[dialect].database, config[dialect].username, 'fakepass123', {logging: false, host: config[dialect].host, port: 1, dialect: dialect})
-          , Domain = require('domain')
-          , domain = Domain.create()
+      }
 
 
-        domain.on('error', function(err){
-          expect(err.toString()).to.match(/^Failed to authenticate/)
-          domain.remove(seq.query)
+      var seq = new Sequelize(config[dialect].database, config[dialect].username, 'fakepass123', {logging: false, host: config[dialect].host, port: 1, dialect: dialect})
+      seq.query('select 1 as hello').error(function(err) {
+        expect(err.message).to.match(/^Failed to authenticate/)
         done()
         done()
       })
       })
-
-        domain.run(function(){
-          domain.add(seq.query)
-          seq.query('select 1 as hello').success(function(){})
-        })
-      }
     })
     })
 
 
     it('when we don\'t have a valid dialect.', function(done) {
     it('when we don\'t have a valid dialect.', function(done) {
       expect(function() {
       expect(function() {
         new Sequelize(config[dialect].database, config[dialect].username, config[dialect].password, {host: '0.0.0.1', port: config[dialect].port, dialect: undefined})
         new Sequelize(config[dialect].database, config[dialect].username, config[dialect].password, {host: '0.0.0.1', port: config[dialect].port, dialect: undefined})
-      }).to.throw('The dialect undefined is not supported.')
+      }).to.throw(Error, 'The dialect undefined is not supported.')
       done()
       done()
     })
     })
   })
   })

test/dao-factory.test.js

@@ -559,7 +559,7 @@ describe(Support.getTestDialectTeaser("DAOFactory"), function () {
 
 
     it('stores the current date in createdAt', function(done) {
     it('stores the current date in createdAt', function(done) {
       this.User.create({ username: 'foo' }).success(function(user) {
       this.User.create({ username: 'foo' }).success(function(user) {
-        expect(parseInt(+user.createdAt/5000, 10)).to.equal(parseInt(+new Date()/5000, 10))
+        expect(parseInt(+user.createdAt/5000, 10)).to.be.closeTo(parseInt(+new Date()/5000, 10), 1.5)
         done()
         done()
       })
       })
     })
     })
@@ -2310,8 +2310,8 @@ describe(Support.getTestDialectTeaser("DAOFactory"), function () {
       self.sequelize.dropAllSchemas().success(function(){
       self.sequelize.dropAllSchemas().success(function(){
         self.sequelize.createSchema('schema_test').success(function(){
         self.sequelize.createSchema('schema_test').success(function(){
           self.sequelize.createSchema('special').success(function(){
           self.sequelize.createSchema('special').success(function(){
-            self.UserSpecial.schema('special').sync({force: true}).success(function(UserSpecialSync){
-              self.UserSpecialSync = UserSpecialSync;
+            self.UserSpecial.schema('special').sync({force: true}).success(function(UserSpecialSync) {
+              self.UserSpecialSync = UserSpecialSync
               done()
               done()
             })
             })
           })
           })
@@ -2320,10 +2320,12 @@ describe(Support.getTestDialectTeaser("DAOFactory"), function () {
     })
     })
 
 
     it("should be able to list schemas", function(done){
     it("should be able to list schemas", function(done){
-      this.sequelize.showAllSchemas().success(function(schemas){
+      this.sequelize.showAllSchemas().success(function(schemas) {
         expect(schemas).to.exist
         expect(schemas).to.exist
         expect(schemas[0]).to.be.instanceof(Array)
         expect(schemas[0]).to.be.instanceof(Array)
-        expect(schemas[0].length).to.equal(2)
+        // sqlite & MySQL doesn't actually create schemas unless Model.sync() is called
+        // Postgres supports schemas natively
+        expect(schemas[0]).to.have.length((dialect === "postgres" || dialect === "postgres-native" ? 2 : 1))
         done()
         done()
       })
       })
     })
     })
@@ -2495,7 +2497,7 @@ describe(Support.getTestDialectTeaser("DAOFactory"), function () {
         }
         }
       }).error(function(err) {
       }).error(function(err) {
         if (dialect === 'mysql') {
         if (dialect === 'mysql') {
-          expect(err.message).to.match(/ER_CANT_CREATE_TABLE/)
+          expect(err.message).to.match(/ER_CANNOT_ADD_FOREIGN/)
         }
         }
         else if (dialect === 'sqlite') {
         else if (dialect === 'sqlite') {
           // the parser should not end up here ... see above
           // the parser should not end up here ... see above

test/dao.test.js

@@ -994,7 +994,7 @@ describe(Support.getTestDialectTeaser("DAO"), function () {
             createdAt: new Date(2000, 1, 1),
             createdAt: new Date(2000, 1, 1),
             identifier: 'another identifier'
             identifier: 'another identifier'
           }).success(function(user) {
           }).success(function(user) {
-            expect(user.createdAt).to.equal(oldCreatedAt)
+            expect((new Date(user.createdAt)).getTime()).to.equal((new Date(oldCreatedAt)).getTime())
             expect(user.identifier).to.equal(oldIdentifier)
             expect(user.identifier).to.equal(oldIdentifier)
             done()
             done()
           })
           })

test/migrator.test.js

@@ -64,7 +64,7 @@ describe(Support.getTestDialectTeaser("Migrator"), function() {
       this.init({ from: 20111117063700, to: 20111130161100 }, function(migrator) {
       this.init({ from: 20111117063700, to: 20111130161100 }, function(migrator) {
         migrator.getUndoneMigrations(function(err, migrations) {
         migrator.getUndoneMigrations(function(err, migrations) {
           expect(err).to.be.null
           expect(err).to.be.null
-          expect(migrations.length).to.equal(2)
+          expect(migrations).to.have.length(2)
           expect(migrations[0].filename).to.equal('20111117063700-createPerson.js')
           expect(migrations[0].filename).to.equal('20111117063700-createPerson.js')
           expect(migrations[1].filename).to.equal('20111130161100-emptyMigration.js')
           expect(migrations[1].filename).to.equal('20111130161100-emptyMigration.js')
           done()
           done()
@@ -76,7 +76,7 @@ describe(Support.getTestDialectTeaser("Migrator"), function() {
       this.init({ to: 20111130161100 }, function(migrator) {
       this.init({ to: 20111130161100 }, function(migrator) {
         migrator.getUndoneMigrations(function(err, migrations) {
         migrator.getUndoneMigrations(function(err, migrations) {
           expect(err).to.be.null
           expect(err).to.be.null
-          expect(migrations.length).to.equal(2)
+          expect(migrations).to.have.length(2)
           done()
           done()
         })
         })
       })
       })
@@ -87,7 +87,7 @@ describe(Support.getTestDialectTeaser("Migrator"), function() {
         SequelizeMeta.create({ from: null, to: 20111117063700 }).success(function() {
         SequelizeMeta.create({ from: null, to: 20111117063700 }).success(function() {
           migrator.getUndoneMigrations(function(err, migrations) {
           migrator.getUndoneMigrations(function(err, migrations) {
             expect(err).to.be.null
             expect(err).to.be.null
-            expect(migrations.length).to.equal(6)
+            expect(migrations).to.have.length(6)
             expect(migrations[0].filename).to.equal('20111130161100-emptyMigration.js')
             expect(migrations[0].filename).to.equal('20111130161100-emptyMigration.js')
             done()
             done()
           })
           })
@@ -198,7 +198,11 @@ describe(Support.getTestDialectTeaser("Migrator"), function() {
 
 
               expect(signature.allowNull).to.be.true
               expect(signature.allowNull).to.be.true
               expect(isAdmin.allowNull).to.be.false
               expect(isAdmin.allowNull).to.be.false
+              if (dialect === "postgres" || dialect === "postgres-native" || dialect === "sqlite") {
+                expect(isAdmin.defaultValue).to.be.false
+              } else {
                 expect(isAdmin.defaultValue).to.equal("0")
                 expect(isAdmin.defaultValue).to.equal("0")
+              }
               expect(shopId.allowNull).to.be.true
               expect(shopId.allowNull).to.be.true
 
 
               done()
               done()
@@ -221,8 +225,11 @@ describe(Support.getTestDialectTeaser("Migrator"), function() {
 
 
               expect(signature.allowNull).to.be.true
               expect(signature.allowNull).to.be.true
               expect(isAdmin.allowNull).to.be.false
               expect(isAdmin.allowNull).to.be.false
-              expect(isAdmin.defaultValue).to.equal('0')
-
+              if (dialect === "postgres" || dialect === "postgres-native" || dialect === "sqlite") {
+                expect(isAdmin.defaultValue).to.be.false
+              } else {
+                expect(isAdmin.defaultValue).to.equal("0")
+              }
               expect(shopId).to.be.not.ok
               expect(shopId).to.be.not.ok
 
 
               done()
               done()

test/postgres/associations.test.js

+var chai      = require('chai')
+  , expect    = chai.expect
+  , Support   = require(__dirname + '/../support')
+  , dialect   = Support.getTestDialect()
+  , config    = require(__dirname + '/../config/config')
+  , DataTypes = require(__dirname + "/../../lib/data-types")
+
+chai.Assertion.includeStack = true
+
+if (dialect.match(/^postgres/)) {
+  describe('[POSTGRES 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})
+
+          Table1.hasMany(Table2)
+          Table2.hasMany(Table1)
+
+          expect(this.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'})
+          done()
+        })
+
+        it("should not use a combined name", function(done) {
+          expect(this.sequelize.daoFactoryManager.getDAO('ms_table1sms_table2s')).not.to.exist
+          done()
+        })
+
+        it("should use the specified name", function(done) {
+          expect(this.sequelize.daoFactoryManager.getDAO('table1_to_table2')).to.exist
+          done()
+        })
+      })
+    })
+
+    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' + config.rand(), { name: DataTypes.STRING })
+        this.Task  = this.sequelize.define('Task' + config.rand(), { 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()}
+        }
+
+        self.sequelize.getQueryInterface().dropAllTables().success(function() {
+          self.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).to.have.length(0)
+            self.user.addTask(self.task).on('success', function() {
+              self.user.getTasks().on('success', function(_tasks) {
+                expect(_tasks).to.have.length(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).to.have.length(0)
+            self.user.setTasks(self.tasks).on('success', function() {
+              self.user.getTasks().on('success', function(_tasks) {
+                expect(_tasks).to.have.length(self.tasks.length)
+                self.user.removeTask(self.tasks[0]).on('success', function() {
+                  self.user.getTasks().on('success', function(_tasks) {
+                    expect(_tasks).to.have.length(self.tasks.length - 1)
+                    done()
+                  })
+                })
+              })
+            })
+          })
+        })
+      })
+    })
+  })
+}

test/postgres/dao.test.js

+var chai      = require('chai')
+  , expect    = chai.expect
+  , Support   = require(__dirname + '/../support')
+  , dialect   = Support.getTestDialect()
+  , config    = require(__dirname + '/../config/config')
+  , DataTypes = require(__dirname + "/../../lib/data-types")
+
+chai.Assertion.includeStack = true
+
+if (dialect.match(/^postgres/)) {
+  describe('[POSTGRES Specific] DAO', function() {
+    beforeEach(function(done) {
+      this.sequelize.options.quoteIdentifiers = true
+      this.User = this.sequelize.define('User', {
+        username: DataTypes.STRING,
+        email: {type: DataTypes.ARRAY(DataTypes.TEXT)},
+        document: {type: DataTypes.HSTORE, defaultValue: '"default"=>"value"'}
+      })
+      this.User.sync({ force: true }).success(function() {
+        done()
+      })
+    })
+
+    afterEach(function(done) {
+      this.sequelize.options.quoteIdentifiers = true
+      done()
+    })
+
+    describe('model', function() {
+      it("create handles array correctly", function(done) {
+        this.User
+          .create({ username: 'user', email: ['foo@bar.com', 'bar@baz.com'] })
+          .success(function(oldUser) {
+            expect(oldUser.email).to.contain.members(['foo@bar.com', 'bar@baz.com'])
+            done()
+          })
+          .error(function(err) {
+            console.log(err)
+          })
+      })
+
+      it("should handle hstore correctly", function(done) {
+        var self = this
+
+        this.User
+          .create({ username: 'user', email: ['foo@bar.com'], document: { created: { test: '"value"' }}})
+          .success(function(newUser) {
+            expect(newUser.document).to.deep.equal({ created: { test: '"value"' }})
+
+            // Check to see if updating an hstore field works
+            newUser.updateAttributes({document: {should: 'update', to: 'this', first: 'place'}}).success(function(oldUser){
+              // Postgres always returns keys in alphabetical order (ascending)
+              expect(oldUser.document).to.deep.equal({first: 'place', should: 'update', to: 'this'})
+              // Check to see if the default value for an hstore field works
+              self.User.create({ username: 'user2', email: ['bar@baz.com']}).success(function(defaultUser){
+                expect(defaultUser.document).to.deep.equal({default: 'value'})
+                done()
+              })
+            })
+          })
+          .error(console.log)
+      })
+    })
+
+    describe('[POSTGRES] Unquoted identifiers', function() {
+      it("can insert and select", function(done) {
+        var self = this
+        this.sequelize.options.quoteIdentifiers = false
+        this.sequelize.getQueryInterface().QueryGenerator.options.quoteIdentifiers = false
+
+        this.User = this.sequelize.define('Userxs', {
+          username: DataTypes.STRING,
+          fullName: DataTypes.STRING // Note mixed case
+        }, {
+          quoteIdentifiers: false
+        })
+
+        this.User.sync({ force: true }).success(function() {
+          self.User
+            .create({ username: 'user', fullName: "John Smith" })
+            .success(function(user) {
+              // We can insert into a table with non-quoted identifiers
+              expect(user.id).to.exist
+              expect(user.id).not.to.be.null
+              expect(user.username).to.equal('user')
+              expect(user.fullName).to.equal('John Smith')
+
+              // We can query by non-quoted identifiers
+              self.User.find({
+                where: {fullName: "John Smith"}
+              })
+              .success(function(user2) {
+                self.sequelize.options.quoteIndentifiers = true
+                self.sequelize.getQueryInterface().QueryGenerator.options.quoteIdentifiers = true
+                self.sequelize.options.logging = false
+                // We can map values back to non-quoted identifiers
+                expect(user2.id).to.equal(user.id)
+                expect(user2.username).to.equal('user')
+                expect(user2.fullName).to.equal('John Smith')
+                done()
+              })
+            })
+        })
+      })
+    })
+  })
+}

test/postgres/hstore.test.js

+/* jshint camelcase: false */
+var chai      = require('chai')
+  , expect    = chai.expect
+  , Support   = require(__dirname + '/../support')
+  , dialect   = Support.getTestDialect()
+  , hstore    = require(__dirname + '/../../lib/dialects/postgres/hstore')
+
+chai.Assertion.includeStack = true
+
+if (dialect.match(/^postgres/)) {
+  describe('[POSTGRES Specific] hstore', function() {
+    describe('stringifyPart', function() {
+      it("handles undefined values correctly", function(done) {
+        expect(hstore.stringifyPart(undefined)).to.equal('NULL')
+        done()
+      })
+
+      it("handles null values correctly", function(done) {
+        expect(hstore.stringifyPart(null)).to.equal('NULL')
+        done()
+      })
+
+      it("handles boolean values correctly", function(done) {
+        expect(hstore.stringifyPart(false)).to.equal('false')
+        expect(hstore.stringifyPart(true)).to.equal('true')
+        done()
+      })
+
+      it("handles strings correctly", function(done) {
+        expect(hstore.stringifyPart('foo')).to.equal('"foo"')
+        done()
+      })
+
+      it("handles strings with backslashes correctly", function(done) {
+        expect(hstore.stringifyPart("\\'literally\\'")).to.equal('"\\\\\'literally\\\\\'"')
+        done()
+      })
+
+      it("handles arrays correctly", function(done) {
+        expect(hstore.stringifyPart([1,['2'],'"3"'])).to.equal('"[1,[\\"2\\"],\\"\\\\\\"3\\\\\\"\\"]"')
+        done()
+      })
+
+      it("handles simple objects correctly", function(done) {
+        expect(hstore.stringifyPart({ test: 'value' })).to.equal('"{\\"test\\":\\"value\\"}"')
+        done()
+      })
+
+      it("handles nested objects correctly", function(done) {
+        expect(hstore.stringifyPart({ test: { nested: 'value' } })).to.equal('"{\\"test\\":{\\"nested\\":\\"value\\"}}"')
+        done()
+      })
+
+      it("handles objects correctly", function(done) {
+        expect(hstore.stringifyPart({test: {nested: {value: {including: '"string"'}}}})).to.equal('"{\\"test\\":{\\"nested\\":{\\"value\\":{\\"including\\":\\"\\\\\\"string\\\\\\"\\"}}}}"')
+        done()
+      })
+    })
+
+    describe('stringify', function() {
+      it('should handle empty objects correctly', function(done) {
+        expect(hstore.stringify({ })).to.equal('')
+        done()
+      })
+
+      it('should handle null values correctly', function(done) {
+        expect(hstore.stringify({ null: null })).to.equal('"null"=>NULL')
+        done()
+      })
+
+      it('should handle simple objects correctly', function(done) {
+        expect(hstore.stringify({ test: 'value' })).to.equal('"test"=>"value"')
+        done()
+      })
+
+      it('should handle nested objects correctly', function(done) {
+        expect(hstore.stringify({ test: { nested: 'value' } })).to.equal('"test"=>"{\\"nested\\":\\"value\\"}"')
+        done()
+      })
+
+      it('should handle nested arrays correctly', function(done) {
+        expect(hstore.stringify({ test: [ 1, '2', [ '"3"' ] ] })).to.equal('"test"=>"[1,\\"2\\",[\\"\\\\\\"3\\\\\\"\\"]]"')
+        done()
+      })
+
+      it('should handle multiple keys with different types of values', function(done) {
+        expect(hstore.stringify({ true: true, false: false, null: null, undefined: undefined, integer: 1, array: [1,'2'], object: { object: 'value' }})).to.equal('"true"=>true,"false"=>false,"null"=>NULL,"undefined"=>NULL,"integer"=>1,"array"=>"[1,\\"2\\"]","object"=>"{\\"object\\":\\"value\\"}"')
+        done()
+      })
+    })
+
+    describe('parse', function() {
+      it('should handle empty objects correctly', function(done) {
+        expect(hstore.parse('')).to.deep.equal({ })
+        done()
+      })
+
+      it('should handle simple objects correctly', function(done) {
+        expect(hstore.parse('"test"=>"value"')).to.deep.equal({ test: 'value' })
+        done()
+      })
+
+      it('should handle nested objects correctly', function(done) {
+        expect(hstore.parse('"test"=>"{\\"nested\\":\\"value\\"}"')).to.deep.equal({ test: { nested: 'value' } })
+        done()
+      })
+
+      it('should handle nested arrays correctly', function(done) {
+        expect(hstore.parse('"test"=>"[1,\\"2\\",[\\"\\\\\\"3\\\\\\"\\"]]"')).to.deep.equal({ test: [ 1, '2', [ '"3"' ] ] })
+        done()
+      })
+
+      it('should handle multiple keys with different types of values', function(done) {
+        expect(hstore.parse('"true"=>true,"false"=>false,"null"=>NULL,"undefined"=>NULL,"integer"=>1,"array"=>"[1,\\"2\\"]","object"=>"{\\"object\\":\\"value\\"}"')).to.deep.equal({ true: true, false: false, null: null, undefined: null, integer: "1", array: [1,'2'], object: { object: 'value' }})
+        done()
+      })
+    })
+  })
+}

test/postgres/query-generator.test.js

+/* jshint camelcase: false */
+var chai            = require('chai')
+  , expect          = chai.expect
+  , QueryGenerator  = require("../../lib/dialects/postgres/query-generator")
+  , Support         = require(__dirname + '/../support')
+  , dialect         = Support.getTestDialect()
+  , DataTypes       = require(__dirname + "/../../lib/data-types")
+  , moment          = require('moment')
+  , util            = require("util")
+  , _               = require('lodash')
+
+chai.Assertion.includeStack = true
+
+if (dialect.match(/^postgres/)) {
+  describe('[POSTGRES Specific] QueryGenerator', function() {
+    beforeEach(function(done) {
+      this.User = this.sequelize.define('User', {
+        username: DataTypes.STRING,
+        email: {type: DataTypes.ARRAY(DataTypes.TEXT)},
+        document: {type: DataTypes.HSTORE, defaultValue: '"default"=>"value"'}
+      })
+      this.User.sync({ force: true }).success(function() {
+        done()
+      })
+    })
+
+    var suites = {
+      attributesToSQL: [
+        {
+          arguments: [{id: 'INTEGER'}],
+          expectation: {id: 'INTEGER'}
+        },
+        {
+          arguments: [{id: 'INTEGER', foo: 'VARCHAR(255)'}],
+          expectation: {id: 'INTEGER', foo: 'VARCHAR(255)'}
+        },
+        {
+          arguments: [{id: {type: 'INTEGER'}}],
+          expectation: {id: 'INTEGER'}
+        },
+        {
+          arguments: [{id: {type: 'INTEGER', allowNull: false}}],
+          expectation: {id: 'INTEGER NOT NULL'}
+        },
+        {
+          arguments: [{id: {type: 'INTEGER', allowNull: true}}],
+          expectation: {id: 'INTEGER'}
+        },
+        {
+          arguments: [{id: {type: 'INTEGER', primaryKey: true, autoIncrement: true}}],
+          expectation: {id: 'INTEGER SERIAL PRIMARY KEY'}
+        },
+        {
+          arguments: [{id: {type: 'INTEGER', defaultValue: 0}}],
+          expectation: {id: 'INTEGER DEFAULT 0'}
+        },
+        {
+          arguments: [{id: {type: 'INTEGER', unique: true}}],
+          expectation: {id: 'INTEGER UNIQUE'}
+        },
+        {
+          arguments: [{id: {type: 'INTEGER', comment: "I'm a comment!" }}],
+          expectation: {id: "INTEGER COMMENT ON COLUMN <%= table %>.\"id\" IS 'I''m a comment!'" }
+        },
+        {
+          arguments: [{id: {type: 'INTEGER', references: 'Bar'}}],
+          expectation: {id: 'INTEGER REFERENCES "Bar" ("id")'}
+        },
+        {
+          arguments: [{id: {type: 'INTEGER', references: 'Bar', referencesKey: 'pk'}}],
+          expectation: {id: 'INTEGER REFERENCES "Bar" ("pk")'}
+        },
+        {
+          arguments: [{id: {type: 'INTEGER', references: 'Bar', onDelete: 'CASCADE'}}],
+          expectation: {id: 'INTEGER REFERENCES "Bar" ("id") ON DELETE CASCADE'}
+        },
+        {
+          arguments: [{id: {type: 'INTEGER', references: 'Bar', onUpdate: 'RESTRICT'}}],
+          expectation: {id: 'INTEGER REFERENCES "Bar" ("id") ON UPDATE RESTRICT'}
+        },
+        {
+          arguments: [{id: {type: 'INTEGER', allowNull: false, defaultValue: 1, references: 'Bar', onDelete: 'CASCADE', onUpdate: 'RESTRICT'}}],
+          expectation: {id: 'INTEGER NOT NULL DEFAULT 1 REFERENCES "Bar" ("id") ON DELETE CASCADE ON UPDATE RESTRICT'}
+        },
+
+        // Variants when quoteIdentifiers is false
+        {
+          arguments: [{id: {type: 'INTEGER', references: 'Bar'}}],
+          expectation: {id: 'INTEGER REFERENCES Bar (id)'},
+          context: {options: {quoteIdentifiers: false}}
+        },
+        {
+          arguments: [{id: {type: 'INTEGER', references: 'Bar', referencesKey: 'pk'}}],
+          expectation: {id: 'INTEGER REFERENCES Bar (pk)'},
+          context: {options: {quoteIdentifiers: false}}
+        },
+        {
+          arguments: [{id: {type: 'INTEGER', references: 'Bar', onDelete: 'CASCADE'}}],
+          expectation: {id: 'INTEGER REFERENCES Bar (id) ON DELETE CASCADE'},
+          context: {options: {quoteIdentifiers: false}}
+        },
+        {
+          arguments: [{id: {type: 'INTEGER', references: 'Bar', onUpdate: 'RESTRICT'}}],
+          expectation: {id: 'INTEGER REFERENCES Bar (id) ON UPDATE RESTRICT'},
+          context: {options: {quoteIdentifiers: false}}
+        },
+        {
+          arguments: [{id: {type: 'INTEGER', allowNull: false, defaultValue: 1, references: 'Bar', onDelete: 'CASCADE', onUpdate: 'RESTRICT'}}],
+          expectation: {id: 'INTEGER NOT NULL DEFAULT 1 REFERENCES Bar (id) ON DELETE CASCADE ON UPDATE RESTRICT'},
+          context: {options: {quoteIdentifiers: false}}
+        },
+
+      ],
+
+      createTableQuery: [
+        {
+          arguments: ['myTable', {title: 'VARCHAR(255)', name: 'VARCHAR(255)'}],
+          expectation: "CREATE TABLE IF NOT EXISTS \"myTable\" (\"title\" VARCHAR(255), \"name\" VARCHAR(255));",
+        },
+        {
+          arguments: ['myTable', {title: "INTEGER COMMENT ON COLUMN <%= table %>.\"title\" IS 'I''m a comment!'"}],
+          expectation: "CREATE TABLE IF NOT EXISTS \"myTable\" (\"title\" INTEGER ); COMMENT ON COLUMN \"myTable\".\"title\" IS 'I''m a comment!';",
+        },
+        {
+          arguments: ['myTable', {title: "INTEGER"}, {comment: "I'm a comment!"}],
+          expectation: "CREATE TABLE IF NOT EXISTS \"myTable\" (\"title\" INTEGER); COMMENT ON TABLE \"myTable\" IS 'I''m a comment!';",
+        },
+        {
+          arguments: ['mySchema.myTable', {title: 'VARCHAR(255)', name: 'VARCHAR(255)'}],
+          expectation: "CREATE TABLE IF NOT EXISTS \"mySchema\".\"myTable\" (\"title\" VARCHAR(255), \"name\" VARCHAR(255));"
+        },
+        {
+          arguments: ['myTable', {title: 'ENUM("A", "B", "C")', name: 'VARCHAR(255)'}],
+          expectation: "DROP TYPE IF EXISTS \"enum_myTable_title\"; CREATE TYPE \"enum_myTable_title\" AS ENUM(\"A\", \"B\", \"C\"); CREATE TABLE IF NOT EXISTS \"myTable\" (\"title\" \"enum_myTable_title\", \"name\" VARCHAR(255));"
+        },
+        {
+          arguments: ['myTable', {title: 'VARCHAR(255)', name: 'VARCHAR(255)', id: 'INTEGER PRIMARY KEY'}],
+          expectation: "CREATE TABLE IF NOT EXISTS \"myTable\" (\"title\" VARCHAR(255), \"name\" VARCHAR(255), \"id\" INTEGER , PRIMARY KEY (\"id\"));"
+        },
+        {
+          arguments: ['myTable', {title: 'VARCHAR(255)', name: 'VARCHAR(255)', otherId: 'INTEGER REFERENCES "otherTable" ("id") ON DELETE CASCADE ON UPDATE NO ACTION'}],
+          expectation: "CREATE TABLE IF NOT EXISTS \"myTable\" (\"title\" VARCHAR(255), \"name\" VARCHAR(255), \"otherId\" INTEGER REFERENCES \"otherTable\" (\"id\") ON DELETE CASCADE ON UPDATE NO ACTION);"
+        },
+
+        // Variants when quoteIdentifiers is false
+        {
+          arguments: ['myTable', {title: 'VARCHAR(255)', name: 'VARCHAR(255)'}],
+          expectation: "CREATE TABLE IF NOT EXISTS myTable (title VARCHAR(255), name VARCHAR(255));",
+          context: {options: {quoteIdentifiers: false}}
+        },
+        {
+          arguments: ['mySchema.myTable', {title: 'VARCHAR(255)', name: 'VARCHAR(255)'}],
+          expectation: "CREATE TABLE IF NOT EXISTS mySchema.myTable (title VARCHAR(255), name VARCHAR(255));",
+          context: {options: {quoteIdentifiers: false}}
+        },
+        {
+          arguments: ['myTable', {title: 'ENUM("A", "B", "C")', name: 'VARCHAR(255)'}],
+          expectation: "DROP TYPE IF EXISTS enum_myTable_title; CREATE TYPE enum_myTable_title AS ENUM(\"A\", \"B\", \"C\"); CREATE TABLE IF NOT EXISTS myTable (title enum_myTable_title, name VARCHAR(255));",
+          context: {options: {quoteIdentifiers: false}}
+        },
+        {
+          arguments: ['myTable', {title: 'VARCHAR(255)', name: 'VARCHAR(255)', id: 'INTEGER PRIMARY KEY'}],
+          expectation: "CREATE TABLE IF NOT EXISTS myTable (title VARCHAR(255), name VARCHAR(255), id INTEGER , PRIMARY KEY (id));",
+          context: {options: {quoteIdentifiers: false}}
+        },
+        {
+          arguments: ['myTable', {title: 'VARCHAR(255)', name: 'VARCHAR(255)', otherId: 'INTEGER REFERENCES otherTable (id) ON DELETE CASCADE ON UPDATE NO ACTION'}],
+          expectation: "CREATE TABLE IF NOT EXISTS myTable (title VARCHAR(255), name VARCHAR(255), otherId INTEGER REFERENCES otherTable (id) ON DELETE CASCADE ON UPDATE NO ACTION);",
+          context: {options: {quoteIdentifiers: false}}
+        }
+      ],
+
+      dropTableQuery: [
+        {
+          arguments: ['myTable'],
+          expectation: "DROP TABLE IF EXISTS \"myTable\";"
+        },
+        {
+          arguments: ['mySchema.myTable'],
+          expectation: "DROP TABLE IF EXISTS \"mySchema\".\"myTable\";"
+        },
+        {
+          arguments: ['myTable', {cascade: true}],
+          expectation: "DROP TABLE IF EXISTS \"myTable\" CASCADE;"
+        },
+        {
+          arguments: ['mySchema.myTable', {cascade: true}],
+          expectation: "DROP TABLE IF EXISTS \"mySchema\".\"myTable\" CASCADE;"
+        },
+
+        // Variants when quoteIdentifiers is false
+        {
+          arguments: ['myTable'],
+          expectation: "DROP TABLE IF EXISTS myTable;",
+          context: {options: {quoteIdentifiers: false}}
+        },
+        {
+          arguments: ['mySchema.myTable'],
+          expectation: "DROP TABLE IF EXISTS mySchema.myTable;",
+          context: {options: {quoteIdentifiers: false}}
+        },
+        {
+          arguments: ['myTable', {cascade: true}],
+          expectation: "DROP TABLE IF EXISTS myTable CASCADE;",
+          context: {options: {quoteIdentifiers: false}}
+        },
+        {
+          arguments: ['mySchema.myTable', {cascade: true}],
+          expectation: "DROP TABLE IF EXISTS mySchema.myTable CASCADE;",
+          context: {options: {quoteIdentifiers: false}}
+        }
+      ],
+
+      selectQuery: [
+        {
+          arguments: ['myTable'],
+          expectation: "SELECT * FROM \"myTable\";"
+        }, {
+          arguments: ['myTable', {attributes: ['id', 'name']}],
+          expectation: "SELECT \"id\", \"name\" FROM \"myTable\";"
+        }, {
+          arguments: ['myTable', {where: {id: 2}}],
+          expectation: "SELECT * FROM \"myTable\" WHERE \"myTable\".\"id\"=2;"
+        }, {
+          arguments: ['myTable', {where: {name: 'foo'}}],
+          expectation: "SELECT * FROM \"myTable\" WHERE \"myTable\".\"name\"='foo';"
+        }, {
+          arguments: ['myTable', {where: {name: "foo';DROP TABLE myTable;"}}],
+          expectation: "SELECT * FROM \"myTable\" WHERE \"myTable\".\"name\"='foo'';DROP TABLE myTable;';"
+        }, {
+          arguments: ['myTable', {where: 2}],
+          expectation: "SELECT * FROM \"myTable\" WHERE \"myTable\".\"id\"=2;"
+        }, {
+          arguments: ['foo', { attributes: [['count(*)', 'count']] }],
+          expectation: 'SELECT count(*) as \"count\" FROM \"foo\";'
+        }, {
+          arguments: ['myTable', {where: "foo='bar'"}],
+          expectation: "SELECT * FROM \"myTable\" WHERE foo='bar';"
+        }, {
+          arguments: ['myTable', {order: "id DESC"}],
+          expectation: "SELECT * FROM \"myTable\" ORDER BY \"id\" DESC;"
+        }, {
+          arguments: ['myTable', {group: "name"}],
+          expectation: "SELECT * FROM \"myTable\" GROUP BY \"name\";"
+        }, {
+          arguments: ['myTable', {group: ["name"]}],
+          expectation: "SELECT * FROM \"myTable\" GROUP BY \"name\";"
+        }, {
+          arguments: ['myTable', {group: ["name","title"]}],
+          expectation: "SELECT * FROM \"myTable\" GROUP BY \"name\", \"title\";"
+        }, {
+          arguments: ['myTable', {limit: 10}],
+          expectation: "SELECT * FROM \"myTable\" LIMIT 10;"
+        }, {
+          arguments: ['myTable', {limit: 10, offset: 2}],
+          expectation: "SELECT * FROM \"myTable\" LIMIT 10 OFFSET 2;"
+        }, {
+          title: 'uses offset even if no limit was passed',
+          arguments: ['myTable', {offset: 2}],
+          expectation: "SELECT * FROM \"myTable\" OFFSET 2;"
+        }, {
+          arguments: ['mySchema.myTable'],
+          expectation: "SELECT * FROM \"mySchema\".\"myTable\";"
+        }, {
+          arguments: ['mySchema.myTable', {where: {name: "foo';DROP TABLE mySchema.myTable;"}}],
+          expectation: "SELECT * FROM \"mySchema\".\"myTable\" WHERE \"mySchema\".\"myTable\".\"name\"='foo'';DROP TABLE mySchema.myTable;';"
+        },
+
+        // Variants when quoteIdentifiers is false
+        {
+          arguments: ['myTable'],
+          expectation: "SELECT * FROM myTable;",
+          context: {options: {quoteIdentifiers: false}}
+        }, {
+          arguments: ['myTable', {attributes: ['id', 'name']}],
+          expectation: "SELECT id, name FROM myTable;",
+          context: {options: {quoteIdentifiers: false}}
+        }, {
+          arguments: ['myTable', {where: {id: 2}}],
+          expectation: "SELECT * FROM myTable WHERE myTable.id=2;",
+          context: {options: {quoteIdentifiers: false}}
+        }, {
+          arguments: ['myTable', {where: {name: 'foo'}}],
+          expectation: "SELECT * FROM myTable WHERE myTable.name='foo';",
+          context: {options: {quoteIdentifiers: false}}
+        }, {
+          arguments: ['myTable', {where: {name: "foo';DROP TABLE myTable;"}}],
+          expectation: "SELECT * FROM myTable WHERE myTable.name='foo'';DROP TABLE myTable;';",
+          context: {options: {quoteIdentifiers: false}}
+        }, {
+          arguments: ['myTable', {where: 2}],
+          expectation: "SELECT * FROM myTable WHERE myTable.id=2;",
+          context: {options: {quoteIdentifiers: false}}
+        }, {
+          arguments: ['foo', { attributes: [['count(*)', 'count']] }],
+          expectation: 'SELECT count(*) as count FROM foo;',
+          context: {options: {quoteIdentifiers: false}}
+        }, {
+          arguments: ['myTable', {where: "foo='bar'"}],
+          expectation: "SELECT * FROM myTable WHERE foo='bar';",
+          context: {options: {quoteIdentifiers: false}}
+        }, {
+          arguments: ['myTable', {order: "id DESC"}],
+          expectation: "SELECT * FROM myTable ORDER BY id DESC;",
+          context: {options: {quoteIdentifiers: false}}
+        }, {
+          arguments: ['myTable', {group: "name"}],
+          expectation: "SELECT * FROM myTable GROUP BY name;",
+          context: {options: {quoteIdentifiers: false}}
+        }, {
+          arguments: ['myTable', {group: ["name"]}],
+          expectation: "SELECT * FROM myTable GROUP BY name;",
+          context: {options: {quoteIdentifiers: false}}
+        }, {
+          arguments: ['myTable', {group: ["name","title"]}],
+          expectation: "SELECT * FROM myTable GROUP BY name, title;",
+          context: {options: {quoteIdentifiers: false}}
+        }, {
+          arguments: ['myTable', {limit: 10}],
+          expectation: "SELECT * FROM myTable LIMIT 10;",
+          context: {options: {quoteIdentifiers: false}}
+        }, {
+          arguments: ['myTable', {limit: 10, offset: 2}],
+          expectation: "SELECT * FROM myTable LIMIT 10 OFFSET 2;",
+          context: {options: {quoteIdentifiers: false}}
+        }, {
+          title: 'uses offset even if no limit was passed',
+          arguments: ['myTable', {offset: 2}],
+          expectation: "SELECT * FROM myTable OFFSET 2;",
+          context: {options: {quoteIdentifiers: false}}
+        }, {
+          arguments: ['mySchema.myTable'],
+          expectation: "SELECT * FROM mySchema.myTable;",
+          context: {options: {quoteIdentifiers: false}}
+        }, {
+          arguments: ['mySchema.myTable', {where: {name: "foo';DROP TABLE mySchema.myTable;"}}],
+          expectation: "SELECT * FROM mySchema.myTable WHERE mySchema.myTable.name='foo'';DROP TABLE mySchema.myTable;';",
+          context: {options: {quoteIdentifiers: false}}
+        }
+      ],
+
+      insertQuery: [
+        {
+          arguments: ['myTable', {name: 'foo'}],
+          expectation: "INSERT INTO \"myTable\" (\"name\") VALUES ('foo') RETURNING *;"
+        }, {
+          arguments: ['myTable', {name: "foo';DROP TABLE myTable;"}],
+          expectation: "INSERT INTO \"myTable\" (\"name\") VALUES ('foo'';DROP TABLE myTable;') RETURNING *;"
+        }, {
+          arguments: ['myTable', {name: 'foo', birthday: moment("2011-03-27 10:01:55 +0000", "YYYY-MM-DD HH:mm:ss Z").toDate()}],
+          expectation: "INSERT INTO \"myTable\" (\"name\",\"birthday\") VALUES ('foo','2011-03-27 10:01:55.000 +00:00') RETURNING *;"
+        }, {
+          arguments: ['myTable', {name: 'foo', foo: 1}],
+          expectation: "INSERT INTO \"myTable\" (\"name\",\"foo\") VALUES ('foo',1) RETURNING *;"
+        }, {
+          arguments: ['myTable', {name: 'foo', nullValue: null}],
+          expectation: "INSERT INTO \"myTable\" (\"name\",\"nullValue\") VALUES ('foo',NULL) RETURNING *;"
+        }, {
+          arguments: ['myTable', {name: 'foo', nullValue: null}],
+          expectation: "INSERT INTO \"myTable\" (\"name\",\"nullValue\") VALUES ('foo',NULL) RETURNING *;",
+          context: {options: {omitNull: false}}
+        }, {
+          arguments: ['myTable', {name: 'foo', nullValue: null}],
+          expectation: "INSERT INTO \"myTable\" (\"name\") VALUES ('foo') RETURNING *;",
+          context: {options: {omitNull: true}}
+        }, {
+          arguments: ['myTable', {name: 'foo', nullValue: undefined}],
+          expectation: "INSERT INTO \"myTable\" (\"name\") VALUES ('foo') RETURNING *;",
+          context: {options: {omitNull: true}}
+        }, {
+          arguments: ['mySchema.myTable', {name: 'foo'}],
+          expectation: "INSERT INTO \"mySchema\".\"myTable\" (\"name\") VALUES ('foo') RETURNING *;"
+        }, {
+          arguments: ['mySchema.myTable', {name: JSON.stringify({info: 'Look ma a " quote'})}],
+          expectation: "INSERT INTO \"mySchema\".\"myTable\" (\"name\") VALUES ('{\"info\":\"Look ma a \\\" quote\"}') RETURNING *;"
+        }, {
+          arguments: ['mySchema.myTable', {name: "foo';DROP TABLE mySchema.myTable;"}],
+          expectation: "INSERT INTO \"mySchema\".\"myTable\" (\"name\") VALUES ('foo'';DROP TABLE mySchema.myTable;') RETURNING *;"
+        },
+
+        // Variants when quoteIdentifiers is false
+        {
+          arguments: ['myTable', {name: 'foo'}],
+          expectation: "INSERT INTO myTable (name) VALUES ('foo') RETURNING *;",
+          context: {options: {quoteIdentifiers: false}}
+        }, {
+          arguments: ['myTable', {name: "foo';DROP TABLE myTable;"}],
+          expectation: "INSERT INTO myTable (name) VALUES ('foo'';DROP TABLE myTable;') RETURNING *;",
+          context: {options: {quoteIdentifiers: false}}
+        }, {
+          arguments: ['myTable', {name: 'foo', birthday: moment("2011-03-27 10:01:55 +0000", "YYYY-MM-DD HH:mm:ss Z").toDate()}],
+          expectation: "INSERT INTO myTable (name,birthday) VALUES ('foo','2011-03-27 10:01:55.000 +00:00') RETURNING *;",
+          context: {options: {quoteIdentifiers: false}}
+        }, {
+          arguments: ['myTable', {name: 'foo', foo: 1}],
+          expectation: "INSERT INTO myTable (name,foo) VALUES ('foo',1) RETURNING *;",
+          context: {options: {quoteIdentifiers: false}}
+        }, {
+          arguments: ['myTable', {name: 'foo', nullValue: null}],
+          expectation: "INSERT INTO myTable (name,nullValue) VALUES ('foo',NULL) RETURNING *;",
+          context: {options: {quoteIdentifiers: false}}
+        }, {
+          arguments: ['myTable', {name: 'foo', nullValue: null}],
+          expectation: "INSERT INTO myTable (name,nullValue) VALUES ('foo',NULL) RETURNING *;",
+          context: {options: {omitNull: false, quoteIdentifiers: false}}
+        }, {
+          arguments: ['myTable', {name: 'foo', nullValue: null}],
+          expectation: "INSERT INTO myTable (name) VALUES ('foo') RETURNING *;",
+          context: {options: {omitNull: true, quoteIdentifiers: false}}
+        }, {
+          arguments: ['myTable', {name: 'foo', nullValue: undefined}],
+          expectation: "INSERT INTO myTable (name) VALUES ('foo') RETURNING *;",
+          context: {options: {omitNull: true, quoteIdentifiers: false}}
+        }, {
+          arguments: ['mySchema.myTable', {name: 'foo'}],
+          expectation: "INSERT INTO mySchema.myTable (name) VALUES ('foo') RETURNING *;",
+          context: {options: {quoteIdentifiers: false}}
+        }, {
+          arguments: ['mySchema.myTable', {name: JSON.stringify({info: 'Look ma a " quote'})}],
+          expectation: "INSERT INTO mySchema.myTable (name) VALUES ('{\"info\":\"Look ma a \\\" quote\"}') RETURNING *;",
+          context: {options: {quoteIdentifiers: false}}
+        }, {
+          arguments: ['mySchema.myTable', {name: "foo';DROP TABLE mySchema.myTable;"}],
+          expectation: "INSERT INTO mySchema.myTable (name) VALUES ('foo'';DROP TABLE mySchema.myTable;') RETURNING *;",
+          context: {options: {quoteIdentifiers: false}}
+        }
+
+      ],
+
+      bulkInsertQuery: [
+        {
+          arguments: ['myTable', [{name: 'foo'}, {name: 'bar'}]],
+          expectation: "INSERT INTO \"myTable\" (\"name\") VALUES ('foo'),('bar') RETURNING *;"
+        }, {
+          arguments: ['myTable', [{name: "foo';DROP TABLE myTable;"}, {name: 'bar'}]],
+          expectation: "INSERT INTO \"myTable\" (\"name\") VALUES ('foo'';DROP TABLE myTable;'),('bar') RETURNING *;"
+        }, {
+          arguments: ['myTable', [{name: 'foo', birthday: moment("2011-03-27 10:01:55 +0000", "YYYY-MM-DD HH:mm:ss Z").toDate()}, {name: 'bar', birthday: moment("2012-03-27 10:01:55 +0000", "YYYY-MM-DD HH:mm:ss Z").toDate()}]],
+          expectation: "INSERT INTO \"myTable\" (\"name\",\"birthday\") VALUES ('foo','2011-03-27 10:01:55.000 +00:00'),('bar','2012-03-27 10:01:55.000 +00:00') RETURNING *;"
+        }, {
+          arguments: ['myTable', [{name: 'foo', foo: 1}, {name: 'bar', foo: 2}]],
+          expectation: "INSERT INTO \"myTable\" (\"name\",\"foo\") VALUES ('foo',1),('bar',2) RETURNING *;"
+        }, {
+          arguments: ['myTable', [{name: 'foo', nullValue: null}, {name: 'bar', nullValue: null}]],
+          expectation: "INSERT INTO \"myTable\" (\"name\",\"nullValue\") VALUES ('foo',NULL),('bar',NULL) RETURNING *;"
+        }, {
+          arguments: ['myTable', [{name: 'foo', nullValue: null}, {name: 'bar', nullValue: null}]],
+          expectation: "INSERT INTO \"myTable\" (\"name\",\"nullValue\") VALUES ('foo',NULL),('bar',NULL) RETURNING *;",
+          context: {options: {omitNull: false}}
+        }, {
+          arguments: ['myTable', [{name: 'foo', nullValue: null}, {name: 'bar', nullValue: null}]],
+          expectation: "INSERT INTO \"myTable\" (\"name\",\"nullValue\") VALUES ('foo',NULL),('bar',NULL) RETURNING *;",
+          context: {options: {omitNull: true}} // Note: We don't honour this because it makes little sense when some rows may have nulls and others not
+        }, {
+          arguments: ['myTable', [{name: 'foo', nullValue: undefined}, {name: 'bar', nullValue: undefined}]],
+          expectation: "INSERT INTO \"myTable\" (\"name\",\"nullValue\") VALUES ('foo',NULL),('bar',NULL) RETURNING *;",
+          context: {options: {omitNull: true}} // Note: As above
+        }, {
+          arguments: ['mySchema.myTable', [{name: 'foo'}, {name: 'bar'}]],
+          expectation: "INSERT INTO \"mySchema\".\"myTable\" (\"name\") VALUES ('foo'),('bar') RETURNING *;"
+        }, {
+          arguments: ['mySchema.myTable', [{name: JSON.stringify({info: 'Look ma a " quote'})}, {name: JSON.stringify({info: 'Look ma another " quote'})}]],
+          expectation: "INSERT INTO \"mySchema\".\"myTable\" (\"name\") VALUES ('{\"info\":\"Look ma a \\\" quote\"}'),('{\"info\":\"Look ma another \\\" quote\"}') RETURNING *;"
+        }, {
+          arguments: ['mySchema.myTable', [{name: "foo';DROP TABLE mySchema.myTable;"}, {name: 'bar'}]],
+          expectation: "INSERT INTO \"mySchema\".\"myTable\" (\"name\") VALUES ('foo'';DROP TABLE mySchema.myTable;'),('bar') RETURNING *;"
+        },
+
+        // Variants when quoteIdentifiers is false
+        {
+          arguments: ['myTable', [{name: 'foo'}, {name: 'bar'}]],
+          expectation: "INSERT INTO myTable (name) VALUES ('foo'),('bar') RETURNING *;",
+          context: {options: {quoteIdentifiers: false}}
+        }, {
+          arguments: ['myTable', [{name: "foo';DROP TABLE myTable;"}, {name: 'bar'}]],
+          expectation: "INSERT INTO myTable (name) VALUES ('foo'';DROP TABLE myTable;'),('bar') RETURNING *;",
+          context: {options: {quoteIdentifiers: false}}
+        }, {
+          arguments: ['myTable', [{name: 'foo', birthday: moment("2011-03-27 10:01:55 +0000", "YYYY-MM-DD HH:mm:ss Z").toDate()}, {name: 'bar', birthday: moment("2012-03-27 10:01:55 +0000", "YYYY-MM-DD HH:mm:ss Z").toDate()}]],
+          expectation: "INSERT INTO myTable (name,birthday) VALUES ('foo','2011-03-27 10:01:55.000 +00:00'),('bar','2012-03-27 10:01:55.000 +00:00') RETURNING *;",
+          context: {options: {quoteIdentifiers: false}}
+        }, {
+          arguments: ['myTable', [{name: 'foo', foo: 1}, {name: 'bar', foo: 2}]],
+          expectation: "INSERT INTO myTable (name,foo) VALUES ('foo',1),('bar',2) RETURNING *;",
+          context: {options: {quoteIdentifiers: false}}
+        }, {
+          arguments: ['myTable', [{name: 'foo', nullValue: null}, {name: 'bar', nullValue: null}]],
+          expectation: "INSERT INTO myTable (name,nullValue) VALUES ('foo',NULL),('bar',NULL) RETURNING *;",
+          context: {options: {quoteIdentifiers: false}}
+        }, {
+          arguments: ['myTable', [{name: 'foo', nullValue: null}, {name: 'bar', nullValue: null}]],
+          expectation: "INSERT INTO myTable (name,nullValue) VALUES ('foo',NULL),('bar',NULL) RETURNING *;",
+          context: {options: {quoteIdentifiers: false, omitNull: false}},
+        }, {
+          arguments: ['myTable', [{name: 'foo', nullValue: null}, {name: 'bar', nullValue: null}]],
+          expectation: "INSERT INTO myTable (name,nullValue) VALUES ('foo',NULL),('bar',NULL) RETURNING *;",
+          context: {options: {omitNull: true, quoteIdentifiers: false}} // Note: We don't honour this because it makes little sense when some rows may have nulls and others not
+        }, {
+          arguments: ['myTable', [{name: 'foo', nullValue: undefined}, {name: 'bar', nullValue: undefined}]],
+          expectation: "INSERT INTO myTable (name,nullValue) VALUES ('foo',NULL),('bar',NULL) RETURNING *;",
+          context: {options: {omitNull: true, quoteIdentifiers: false}} // Note: As above
+        }, {
+          arguments: ['mySchema.myTable', [{name: 'foo'}, {name: 'bar'}]],
+          expectation: "INSERT INTO mySchema.myTable (name) VALUES ('foo'),('bar') RETURNING *;",
+          context: {options: {quoteIdentifiers: false}}
+        }, {
+          arguments: ['mySchema.myTable', [{name: JSON.stringify({info: 'Look ma a " quote'})}, {name: JSON.stringify({info: 'Look ma another " quote'})}]],
+          expectation: "INSERT INTO mySchema.myTable (name) VALUES ('{\"info\":\"Look ma a \\\" quote\"}'),('{\"info\":\"Look ma another \\\" quote\"}') RETURNING *;",
+          context: {options: {quoteIdentifiers: false}}
+        }, {
+          arguments: ['mySchema.myTable', [{name: "foo';DROP TABLE mySchema.myTable;"}, {name: 'bar'}]],
+          expectation: "INSERT INTO mySchema.myTable (name) VALUES ('foo'';DROP TABLE mySchema.myTable;'),('bar') RETURNING *;",
+          context: {options: {quoteIdentifiers: false}}
+        }
+      ],
+
+      updateQuery: [
+        {
+          arguments: ['myTable', {name: 'foo', birthday: moment("2011-03-27 10:01:55 +0000", "YYYY-MM-DD HH:mm:ss Z").toDate()}, {id: 2}],
+          expectation: "UPDATE \"myTable\" SET \"name\"='foo',\"birthday\"='2011-03-27 10:01:55.000 +00:00' WHERE \"id\"=2 RETURNING *"
+        }, {
+          arguments: ['myTable', {name: 'foo', birthday: moment("2011-03-27 10:01:55 +0000", "YYYY-MM-DD HH:mm:ss Z").toDate()}, 2],
+          expectation: "UPDATE \"myTable\" SET \"name\"='foo',\"birthday\"='2011-03-27 10:01:55.000 +00:00' WHERE \"id\"=2 RETURNING *"
+        }, {
+          arguments: ['myTable', {bar: 2}, {name: 'foo'}],
+          expectation: "UPDATE \"myTable\" SET \"bar\"=2 WHERE \"name\"='foo' RETURNING *"
+        }, {
+          arguments: ['myTable', {name: "foo';DROP TABLE myTable;"}, {name: 'foo'}],
+          expectation: "UPDATE \"myTable\" SET \"name\"='foo'';DROP TABLE myTable;' WHERE \"name\"='foo' RETURNING *"
+        }, {
+          arguments: ['myTable', {bar: 2, nullValue: null}, {name: 'foo'}],
+          expectation: "UPDATE \"myTable\" SET \"bar\"=2,\"nullValue\"=NULL WHERE \"name\"='foo' RETURNING *"
+        }, {
+          arguments: ['myTable', {bar: 2, nullValue: null}, {name: 'foo'}],
+          expectation: "UPDATE \"myTable\" SET \"bar\"=2,\"nullValue\"=NULL WHERE \"name\"='foo' RETURNING *",
+          context: {options: {omitNull: false}}
+        }, {
+          arguments: ['myTable', {bar: 2, nullValue: null}, {name: 'foo'}],
+          expectation: "UPDATE \"myTable\" SET \"bar\"=2 WHERE \"name\"='foo' RETURNING *",
+          context: {options: {omitNull: true}}
+        }, {
+          arguments: ['myTable', {bar: 2, nullValue: undefined}, {name: 'foo'}],
+          expectation: "UPDATE \"myTable\" SET \"bar\"=2 WHERE \"name\"='foo' RETURNING *",
+          context: {options: {omitNull: true}}
+        }, {
+          arguments: ['mySchema.myTable', {name: 'foo', birthday: moment("2011-03-27 10:01:55 +0000", "YYYY-MM-DD HH:mm:ss Z").toDate()}, {id: 2}],
+          expectation: "UPDATE \"mySchema\".\"myTable\" SET \"name\"='foo',\"birthday\"='2011-03-27 10:01:55.000 +00:00' WHERE \"id\"=2 RETURNING *"
+        }, {
+          arguments: ['mySchema.myTable', {name: "foo';DROP TABLE mySchema.myTable;"}, {name: 'foo'}],
+          expectation: "UPDATE \"mySchema\".\"myTable\" SET \"name\"='foo'';DROP TABLE mySchema.myTable;' WHERE \"name\"='foo' RETURNING *"
+        },
+
+        // Variants when quoteIdentifiers is false
+        {
+          arguments: ['myTable', {name: 'foo', birthday: moment("2011-03-27 10:01:55 +0000", "YYYY-MM-DD HH:mm:ss Z").toDate()}, {id: 2}],
+          expectation: "UPDATE myTable SET name='foo',birthday='2011-03-27 10:01:55.000 +00:00' WHERE id=2 RETURNING *",
+          context: {options: {quoteIdentifiers: false}}
+        }, {
+          arguments: ['myTable', {name: 'foo', birthday: moment("2011-03-27 10:01:55 +0000", "YYYY-MM-DD HH:mm:ss Z").toDate()}, 2],
+          expectation: "UPDATE myTable SET name='foo',birthday='2011-03-27 10:01:55.000 +00:00' WHERE id=2 RETURNING *",
+          context: {options: {quoteIdentifiers: false}}
+        }, {
+          arguments: ['myTable', {bar: 2}, {name: 'foo'}],
+          expectation: "UPDATE myTable SET bar=2 WHERE name='foo' RETURNING *",
+          context: {options: {quoteIdentifiers: false}}
+        }, {
+          arguments: ['myTable', {name: "foo';DROP TABLE myTable;"}, {name: 'foo'}],
+          expectation: "UPDATE myTable SET name='foo'';DROP TABLE myTable;' WHERE name='foo' RETURNING *",
+          context: {options: {quoteIdentifiers: false}}
+        }, {
+          arguments: ['myTable', {bar: 2, nullValue: null}, {name: 'foo'}],
+          expectation: "UPDATE myTable SET bar=2,nullValue=NULL WHERE name='foo' RETURNING *",
+          context: {options: {quoteIdentifiers: false}}
+        }, {
+          arguments: ['myTable', {bar: 2, nullValue: null}, {name: 'foo'}],
+          expectation: "UPDATE myTable SET bar=2,nullValue=NULL WHERE name='foo' RETURNING *",
+          context: {options: {omitNull: false, quoteIdentifiers: false}},
+        }, {
+          arguments: ['myTable', {bar: 2, nullValue: null}, {name: 'foo'}],
+          expectation: "UPDATE myTable SET bar=2 WHERE name='foo' RETURNING *",
+          context: {options: {omitNull: true, quoteIdentifiers: false}},
+        }, {
+          arguments: ['myTable', {bar: 2, nullValue: undefined}, {name: 'foo'}],
+          expectation: "UPDATE myTable SET bar=2 WHERE name='foo' RETURNING *",
+          context: {options: {omitNull: true, quoteIdentifiers: false}},
+        }, {
+          arguments: ['mySchema.myTable', {name: 'foo', birthday: moment("2011-03-27 10:01:55 +0000", "YYYY-MM-DD HH:mm:ss Z").toDate()}, {id: 2}],
+          expectation: "UPDATE mySchema.myTable SET name='foo',birthday='2011-03-27 10:01:55.000 +00:00' WHERE id=2 RETURNING *",
+          context: {options: {quoteIdentifiers: false}}
+        }, {
+          arguments: ['mySchema.myTable', {name: "foo';DROP TABLE mySchema.myTable;"}, {name: 'foo'}],
+          expectation: "UPDATE mySchema.myTable SET name='foo'';DROP TABLE mySchema.myTable;' WHERE name='foo' RETURNING *",
+          context: {options: {quoteIdentifiers: false}}
+        }
+      ],
+
+      deleteQuery: [
+        {
+          arguments: ['myTable', {name: 'foo'}],
+          expectation: "DELETE FROM \"myTable\" WHERE \"id\" IN (SELECT \"id\" FROM \"myTable\" WHERE \"name\"='foo' LIMIT 1)"
+        }, {
+          arguments: ['myTable', 1],
+          expectation: "DELETE FROM \"myTable\" WHERE \"id\" IN (SELECT \"id\" FROM \"myTable\" WHERE \"id\"=1 LIMIT 1)"
+        }, {
+          arguments: ['myTable', undefined, {truncate: true}],
+          expectation: "TRUNCATE \"myTable\""
+        }, {
+          arguments: ['myTable', 1, {limit: 10, truncate: true}],
+          expectation: "TRUNCATE \"myTable\""
+        }, {
+          arguments: ['myTable', 1, {limit: 10}],
+          expectation: "DELETE FROM \"myTable\" WHERE \"id\" IN (SELECT \"id\" FROM \"myTable\" WHERE \"id\"=1 LIMIT 10)"
+        }, {
+          arguments: ['myTable', {name: "foo';DROP TABLE myTable;"}, {limit: 10}],
+          expectation: "DELETE FROM \"myTable\" WHERE \"id\" IN (SELECT \"id\" FROM \"myTable\" WHERE \"name\"='foo'';DROP TABLE myTable;' LIMIT 10)"
+        }, {
+          arguments: ['mySchema.myTable', {name: 'foo'}],
+          expectation: "DELETE FROM \"mySchema\".\"myTable\" WHERE \"id\" IN (SELECT \"id\" FROM \"mySchema\".\"myTable\" WHERE \"name\"='foo' LIMIT 1)"
+        }, {
+          arguments: ['mySchema.myTable', {name: "foo';DROP TABLE mySchema.myTable;"}, {limit: 10}],
+          expectation: "DELETE FROM \"mySchema\".\"myTable\" WHERE \"id\" IN (SELECT \"id\" FROM \"mySchema\".\"myTable\" WHERE \"name\"='foo'';DROP TABLE mySchema.myTable;' LIMIT 10)"
+        }, {
+          arguments: ['myTable', {name: 'foo'}, {limit: null}],
+          expectation: "DELETE FROM \"myTable\" WHERE \"id\" IN (SELECT \"id\" FROM \"myTable\" WHERE \"name\"='foo')"
+        },
+
+        // Variants when quoteIdentifiers is false
+        {
+          arguments: ['myTable', {name: 'foo'}],
+          expectation: "DELETE FROM myTable WHERE id IN (SELECT id FROM myTable WHERE name='foo' LIMIT 1)",
+          context: {options: {quoteIdentifiers: false}}
+        }, {
+          arguments: ['myTable', 1],
+          expectation: "DELETE FROM myTable WHERE id IN (SELECT id FROM myTable WHERE id=1 LIMIT 1)",
+          context: {options: {quoteIdentifiers: false}}
+        }, {
+          arguments: ['myTable', 1, {limit: 10}],
+          expectation: "DELETE FROM myTable WHERE id IN (SELECT id FROM myTable WHERE id=1 LIMIT 10)",
+          context: {options: {quoteIdentifiers: false}}
+        }, {
+          arguments: ['myTable', {name: "foo';DROP TABLE myTable;"}, {limit: 10}],
+          expectation: "DELETE FROM myTable WHERE id IN (SELECT id FROM myTable WHERE name='foo'';DROP TABLE myTable;' LIMIT 10)",
+          context: {options: {quoteIdentifiers: false}}
+        }, {
+          arguments: ['mySchema.myTable', {name: 'foo'}],
+          expectation: "DELETE FROM mySchema.myTable WHERE id IN (SELECT id FROM mySchema.myTable WHERE name='foo' LIMIT 1)",
+          context: {options: {quoteIdentifiers: false}}
+        }, {
+          arguments: ['mySchema.myTable', {name: "foo';DROP TABLE mySchema.myTable;"}, {limit: 10}],
+          expectation: "DELETE FROM mySchema.myTable WHERE id IN (SELECT id FROM mySchema.myTable WHERE name='foo'';DROP TABLE mySchema.myTable;' LIMIT 10)",
+          context: {options: {quoteIdentifiers: false}}
+        }, {
+          arguments: ['myTable', {name: 'foo'}, {limit: null}],
+          expectation: "DELETE FROM myTable WHERE id IN (SELECT id FROM myTable WHERE name='foo')",
+          context: {options: {quoteIdentifiers: false}}
+        }
+      ],
+
+      addIndexQuery: [
+        {
+          arguments: ['User', ['username', 'isAdmin']],
+          expectation: 'CREATE INDEX \"user_username_is_admin\" ON \"User\" (\"username\", \"isAdmin\")'
+        }, {
+          arguments: [
+            'User', [
+              { attribute: 'username', length: 10, order: 'ASC'},
+              'isAdmin'
+            ]
+          ],
+          expectation: "CREATE INDEX \"user_username_is_admin\" ON \"User\" (\"username\"(10) ASC, \"isAdmin\")"
+        }, {
+          arguments: [
+            'User', ['username', 'isAdmin'], { indicesType: 'FULLTEXT', indexName: 'bar'}
+          ],
+          expectation: "CREATE FULLTEXT INDEX \"bar\" ON \"User\" (\"username\", \"isAdmin\")"
+        }, {
+          arguments: ['mySchema.User', ['username', 'isAdmin']],
+          expectation: 'CREATE INDEX \"user_username_is_admin\" ON \"mySchema\".\"User\" (\"username\", \"isAdmin\")'
+        },
+
+        // Variants when quoteIdentifiers is false
+        {
+          arguments: ['User', ['username', 'isAdmin']],
+          expectation: 'CREATE INDEX user_username_is_admin ON User (username, isAdmin)',
+          context: {options: {quoteIdentifiers: false}}
+        }, {
+          arguments: [
+            'User', [
+              { attribute: 'username', length: 10, order: 'ASC'},
+              'isAdmin'
+            ]
+          ],
+          expectation: "CREATE INDEX user_username_is_admin ON User (username(10) ASC, isAdmin)",
+          context: {options: {quoteIdentifiers: false}}
+        }, {
+          arguments: [
+            'User', ['username', 'isAdmin'], { indicesType: 'FULLTEXT', indexName: 'bar'}
+          ],
+          expectation: "CREATE FULLTEXT INDEX bar ON User (username, isAdmin)",
+          context: {options: {quoteIdentifiers: false}}
+        }, {
+          arguments: ['mySchema.User', ['username', 'isAdmin']],
+          expectation: 'CREATE INDEX user_username_is_admin ON mySchema.User (username, isAdmin)',
+          context: {options: {quoteIdentifiers: false}}
+        }
+      ],
+
+      // FIXME: not implemented
+      //showIndexQuery: [
+      //  {
+      //    arguments: ['User'],
+      //    expectation: 'SHOW INDEX FROM \"User\"'
+      //  }, {
+      //    arguments: ['User', { database: 'sequelize' }],
+      //    expectation: "SHOW INDEX FROM \"User\" FROM \"sequelize\""
+      //  }
+      //],
+
+      removeIndexQuery: [
+        {
+          arguments: ['User', 'user_foo_bar'],
+          expectation: "DROP INDEX IF EXISTS \"user_foo_bar\""
+        }, {
+          arguments: ['User', ['foo', 'bar']],
+          expectation: "DROP INDEX IF EXISTS \"user_foo_bar\""
+        }, {
+          arguments: ['User', 'mySchema.user_foo_bar'],
+          expectation: "DROP INDEX IF EXISTS \"mySchema\".\"user_foo_bar\""
+        },
+
+        // Variants when quoteIdentifiers is false
+        {
+          arguments: ['User', 'user_foo_bar'],
+          expectation: "DROP INDEX IF EXISTS user_foo_bar",
+          context: {options: {quoteIdentifiers: false}}
+        }, {
+          arguments: ['User', ['foo', 'bar']],
+          expectation: "DROP INDEX IF EXISTS user_foo_bar",
+          context: {options: {quoteIdentifiers: false}}
+        }, {
+          arguments: ['User', 'mySchema.user_foo_bar'],
+          expectation: "DROP INDEX IF EXISTS mySchema.user_foo_bar",
+          context: {options: {quoteIdentifiers: false}}
+        }
+      ],
+
+      hashToWhereConditions: [
+        {
+          arguments: [{ id: [1,2,3] }],
+          expectation: "\"id\" IN (1,2,3)"
+        },
+        {
+          arguments: [{ id: [] }],
+          expectation: "\"id\" IN (NULL)"
+        },
+
+        // Variants when quoteIdentifiers is false
+        {
+          arguments: [{ id: [1,2,3] }],
+          expectation: "id IN (1,2,3)",
+          context: {options: {quoteIdentifiers: false}}
+        },
+        {
+          arguments: [{ id: [] }],
+          expectation: "id IN (NULL)",
+          context: {options: {quoteIdentifiers: false}}
+        },
+      ]
+    }
+
+    _.each(suites, function(tests, suiteTitle) {
+      describe(suiteTitle, function() {
+        afterEach(function(done) {
+          this.sequelize.options.quoteIdentifiers = true
+          QueryGenerator.options.quoteIdentifiers = true
+          done()
+        })
+
+        tests.forEach(function(test) {
+          var title = test.title || 'Postgres correctly returns ' + test.expectation + ' for ' + util.inspect(test.arguments)
+          it(title, function(done) {
+            // Options would normally be set by the query interface that instantiates the query-generator, but here we specify it explicitly
+            var context = test.context || {options: {}};
+            QueryGenerator.options = context.options
+            var conditions = QueryGenerator[suiteTitle].apply(QueryGenerator, test.arguments)
+            expect(conditions).to.deep.equal(test.expectation)
+            done()
+          })
+        })
+      })
+    })
+  })
+}
\ No newline at end of file

test/query-generator.test.js

@@ -9,11 +9,6 @@ var chai      = require('chai')
 chai.Assertion.includeStack = true
 chai.Assertion.includeStack = true
 
 
 describe(Support.getTestDialectTeaser("QueryGenerators"), function () {
 describe(Support.getTestDialectTeaser("QueryGenerators"), function () {
-  before(function(done) {
-    this.interface = this.sequelize.getQueryInterface()
-    done()
-  })
-
   describe("comments", function() {
   describe("comments", function() {
     it("should create a comment for a column", function(done) {
     it("should create a comment for a column", function(done) {
       var self = this
       var self = this
@@ -21,7 +16,7 @@ describe(Support.getTestDialectTeaser("QueryGenerators"), function () {
           username: {type: DataTypes.STRING, comment: 'Some lovely info for my DBA'}
           username: {type: DataTypes.STRING, comment: 'Some lovely info for my DBA'}
         })
         })
 
 
-      User.sync({ force: true }).success(function(){
+      User.sync({ force: true }).success(function() {
         var sql = ''
         var sql = ''
         if (dialect === "mysql") {
         if (dialect === "mysql") {
           sql = 'SELECT COLUMN_COMMENT as cmt FROM information_schema.COLUMNS WHERE TABLE_SCHEMA = \'' + self.sequelize.config.database + '\' AND TABLE_NAME = \'Users\' AND COLUMN_NAME = \'username\'';
           sql = 'SELECT COLUMN_COMMENT as cmt FROM information_schema.COLUMNS WHERE TABLE_SCHEMA = \'' + self.sequelize.config.database + '\' AND TABLE_NAME = \'Users\' AND COLUMN_NAME = \'username\'';

test/query-interface.test.js

@@ -8,34 +8,35 @@ var chai      = require('chai')
 chai.Assertion.includeStack = true
 chai.Assertion.includeStack = true
 
 
 describe(Support.getTestDialectTeaser("QueryInterface"), function () {
 describe(Support.getTestDialectTeaser("QueryInterface"), function () {
-  before(function(done) {
-    this.interface = this.sequelize.getQueryInterface()
+  beforeEach(function(done) {
+    this.sequelize.options.quoteIdenifiers = true
+    this.queryInterface = this.sequelize.getQueryInterface()
     done()
     done()
   })
   })
 
 
   describe('dropAllTables', function() {
   describe('dropAllTables', function() {
     it("should drop all tables", function(done) {
     it("should drop all tables", function(done) {
       var self = this
       var self = this
-      this.interface.dropAllTables().complete(function(err) {
+      this.queryInterface.dropAllTables().complete(function(err) {
         expect(err).to.be.null
         expect(err).to.be.null
 
 
-        self.interface.showAllTables().complete(function(err, tableNames) {
+        self.queryInterface.showAllTables().complete(function(err, tableNames) {
           expect(err).to.be.null
           expect(err).to.be.null
-          expect(tableNames.length).to.equal(0)
+          expect(tableNames).to.be.empty
 
 
-          self.interface.createTable('table', { name: DataTypes.STRING }).complete(function(err) {
+          self.queryInterface.createTable('table', { name: DataTypes.STRING }).complete(function(err) {
             expect(err).to.be.null
             expect(err).to.be.null
 
 
-            self.interface.showAllTables().complete(function(err, tableNames) {
+            self.queryInterface.showAllTables().complete(function(err, tableNames) {
               expect(err).to.be.null
               expect(err).to.be.null
-              expect(tableNames.length).to.equal(1)
+              expect(tableNames).to.have.length(1)
 
 
-              self.interface.dropAllTables().complete(function(err) {
+              self.queryInterface.dropAllTables().complete(function(err) {
                 expect(err).to.be.null
                 expect(err).to.be.null
 
 
-                self.interface.showAllTables().complete(function(err, tableNames) {
+                self.queryInterface.showAllTables().complete(function(err, tableNames) {
                   expect(err).to.be.null
                   expect(err).to.be.null
-                  expect(tableNames.length).to.equal(0)
+                  expect(tableNames).to.be.empty
                   done()
                   done()
                 })
                 })
               })
               })
@@ -47,28 +48,34 @@ describe(Support.getTestDialectTeaser("QueryInterface"), function () {
   })
   })
 
 
   describe('indexes', function() {
   describe('indexes', function() {
-    beforeEach(function(done) {
-      this.interface.createTable('User', {
+    before(function(done) {
+      var self = this
+      this.queryInterface.dropTable('Users').success(function() {
+        self.queryInterface.createTable('Users', {
           username: DataTypes.STRING,
           username: DataTypes.STRING,
           isAdmin: DataTypes.BOOLEAN
           isAdmin: DataTypes.BOOLEAN
-      }).success(done)
+        }).success(function() {
+          done()
+        })
+      })
     })
     })
 
 
     it('adds, reads and removes an index to the table', function(done) {
     it('adds, reads and removes an index to the table', function(done) {
       var self = this
       var self = this
-      this.interface.addIndex('User', ['username', 'isAdmin']).complete(function(err) {
+
+      this.queryInterface.addIndex('Users', ['username', 'isAdmin']).complete(function(err) {
         expect(err).to.be.null
         expect(err).to.be.null
 
 
-        self.interface.showIndex('User').complete(function(err, indexes) {
+        self.queryInterface.showIndex('Users').complete(function(err, indexes) {
           expect(err).to.be.null
           expect(err).to.be.null
 
 
           var indexColumns = _.uniq(indexes.map(function(index) { return index.name }))
           var indexColumns = _.uniq(indexes.map(function(index) { return index.name }))
-          expect(indexColumns).to.include('user_username_is_admin')
+          expect(indexColumns).to.include('users_username_is_admin')
 
 
-          self.interface.removeIndex('User', ['username', 'isAdmin']).complete(function(err) {
+          self.queryInterface.removeIndex('Users', ['username', 'isAdmin']).complete(function(err) {
             expect(err).to.be.null
             expect(err).to.be.null
 
 
-            self.interface.showIndex('User').complete(function(err, indexes) {
+            self.queryInterface.showIndex('Users').complete(function(err, indexes) {
               expect(err).to.be.null
               expect(err).to.be.null
 
 
               indexColumns = _.uniq(indexes.map(function(index) { return index.name }))
               indexColumns = _.uniq(indexes.map(function(index) { return index.name }))
@@ -85,14 +92,14 @@ describe(Support.getTestDialectTeaser("QueryInterface"), function () {
   describe('describeTable', function() {
   describe('describeTable', function() {
     it('reads the metadata of the table', function(done) {
     it('reads the metadata of the table', function(done) {
       var self = this
       var self = this
-      var Users = self.sequelize.define('User', {
+      var Users = self.sequelize.define('_Users', {
         username: DataTypes.STRING,
         username: DataTypes.STRING,
         isAdmin: DataTypes.BOOLEAN,
         isAdmin: DataTypes.BOOLEAN,
         enumVals: DataTypes.ENUM('hello', 'world')
         enumVals: DataTypes.ENUM('hello', 'world')
       }, { freezeTableName: true })
       }, { freezeTableName: true })
 
 
       Users.sync({ force: true }).success(function() {
       Users.sync({ force: true }).success(function() {
-        self.interface.describeTable('User').complete(function(err, metadata) {
+        self.queryInterface.describeTable('_Users').complete(function(err, metadata) {
           expect(err).to.be.null
           expect(err).to.be.null
 
 
           var username = metadata.username
           var username = metadata.username
@@ -109,7 +116,7 @@ describe(Support.getTestDialectTeaser("QueryInterface"), function () {
 
 
           if (dialect === "postgres" || dialect === "postgres-native") {
           if (dialect === "postgres" || dialect === "postgres-native") {
             expect(enumVals.special).to.be.instanceof(Array)
             expect(enumVals.special).to.be.instanceof(Array)
-            expect(enumVals.special.length).to.equal(2);
+            expect(enumVals.special).to.have.length(2);
           }
           }
 
 
           done()
           done()

test/sequelize.test.js

@@ -52,6 +52,11 @@ describe(Support.getTestDialectTeaser("Sequelize"), function () {
   })
   })
 
 
   describe('query', function() {
   describe('query', function() {
+    afterEach(function(done) {
+      this.sequelize.options.quoteIdentifiers = true
+      done()
+    })
+
     beforeEach(function(done) {
     beforeEach(function(done) {
       this.User = this.sequelize.define('User', {
       this.User = this.sequelize.define('User', {
         username: DataTypes.STRING
         username: DataTypes.STRING
@@ -259,11 +264,21 @@ describe(Support.getTestDialectTeaser("Sequelize"), function () {
     })
     })
 
 
     it("fails with incorrect database credentials", function(done) {
     it("fails with incorrect database credentials", function(done) {
+      // sqlite doesn't have a concept of database credentials
+      if (dialect === "sqlite") {
+        expect(true).to.be.true
+        return done()
+      }
+
       var sequelize2 = Support.getSequelizeInstance('foo', 'bar', null, { logging: false })
       var sequelize2 = Support.getSequelizeInstance('foo', 'bar', null, { logging: false })
         , User2      = sequelize2.define('User', { name: DataTypes.STRING, bio: DataTypes.TEXT })
         , User2      = sequelize2.define('User', { name: DataTypes.STRING, bio: DataTypes.TEXT })
 
 
       User2.sync().error(function(err) {
       User2.sync().error(function(err) {
-        expect(err.message).to.match(/.*Access\ denied.*/)
+        if (dialect === "postgres" || dialect === "postgres-native") {
+          expect(err.message).to.equal('role "bar" does not exist')
+        } else {
+          expect(err.message.toString()).to.match(/.*Access\ denied.*/)
+        }
         done()
         done()
       })
       })
     })
     })

test/support.js

@@ -59,6 +59,8 @@ var Support = {
   },
   },
 
 
   getSequelizeInstance: function(db, user, pass, options) {
   getSequelizeInstance: function(db, user, pass, options) {
+    options = options || {};
+    options.dialect = options.dialect || this.getTestDialect()
     return new Sequelize(db, user, pass, options)
     return new Sequelize(db, user, pass, options)
   },
   },