Add more tests for the postgres dialect. Fix issues found while testing.

lib/dialects/postgres/connector-manager.js

@@ -59,8 +59,11 @@ module.exports = (function() {
     this.client.connect(function(err, client) {
       self.isConnecting = false
       if (!err && client) {
+        client.query("SET TIME ZONE 'UTC'")
+          .on('end', function() {
             self.isConnected = true
             this.client = client
+          });
       } else {
         this.client = null
       }

lib/dialects/postgres/query.js

@@ -24,7 +24,7 @@ module.exports = (function() {
 
     var query = this.client.query(sql)
     query.on('row', function(row) {
-      if (self.callee && self.sql.indexOf('INSERT INTO') == 0) {
+      if (self.callee && (self.sql.indexOf('INSERT INTO') == 0 || self.sql.indexOf('UPDATE') == 0)) {
         Utils._.forEach(row, function(value, key) {
           self.callee[key] = value
         })

spec-jasmine/dao.spec.js

@@ -364,9 +364,7 @@ describe('DAO', function() {
             setTimeout(function() {
               user      = User.build({ username: 'user' })
               updatedAt = user.updatedAt
-
               expect(updatedAt.getTime()).toBeGreaterThan(now)
-
               done()
             }, 10)
           })
@@ -477,7 +475,7 @@ describe('DAO', function() {
             }).success(function(user) {
               var emitter = user.updateAttributes({name: 'foobar'})
               emitter.success(function() {
-                expect(emitter.query.sql).toMatch(/WHERE `?identifier`?..identifier./)
+                expect(emitter.query.sql).toMatch(/WHERE [`"]identifier[`"]..identifier./)
                 done()
               })
             })

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

+var config    = require("../config/config")
+  , Sequelize = require("../../index")
+  , sequelize = new Sequelize(config.postgres.database, config.postgres.username, config.postgres.password, {
+      logging: false,
+      port: config.postgres.port,
+      dialect: 'postgres'
+    })
+  , Helpers   = new (require("../config/helpers"))(sequelize)
+
+describe('HasMany', function() {
+  beforeEach(function() { Helpers.sync() })
+  afterEach(function() { Helpers.drop() })
+
+  //prevent periods from occurring in the table name since they are used to delimit (table.column)
+  var User  = sequelize.define('User' + Math.ceil(Math.random()*10000000), { name: Sequelize.STRING })
+    , Task  = sequelize.define('Task' + Math.ceil(Math.random()*10000000), { name: Sequelize.STRING })
+    , users = null
+    , tasks = null
+
+  User.hasMany(Task, {as:'Tasks'})
+  Task.hasMany(User, {as:'Users'})
+
+  beforeEach(function() {
+    Helpers.async(function(_done) {
+      Helpers.Factories.DAO(User.name, {name: 'User' + Math.random()}, function(_users) {
+        users = _users; _done()
+      }, 5)
+    })
+    Helpers.async(function(_done) {
+      Helpers.Factories.DAO(Task.name, {name: 'Task' + Math.random()}, function(_tasks) {
+        tasks = _tasks; _done()
+      }, 2)
+    })
+  })
+
+  describe('addDAO / getDAO', function() {
+    var user = null
+      , task = null
+
+    beforeEach(function() {
+      Helpers.async(function(done) {
+        User.all().on('success', function(_users) {
+          Task.all().on('success', function(_tasks) {
+            user = _users[0]
+            task = _tasks[0]
+
+            done()
+          })
+        })
+      })
+    })
+
+    it('should correctly add an association to the dao', function() {
+      Helpers.async(function(done) {
+        user.getTasks().on('success', function(_tasks) {
+          expect(_tasks.length).toEqual(0)
+          user.addTask(task).on('success', function() {
+            user.getTasks().on('success', function(_tasks) {
+              expect(_tasks.length).toEqual(1)
+              done()
+            })
+          })
+        })
+      })
+    })
+  })
+
+  describe('removeDAO', function() {
+    var user  = null
+      , tasks = null
+
+    beforeEach(function() {
+      Helpers.async(function(done) {
+        User.all().on('success', function(users) {
+          Task.all().on('success', function(_tasks) {
+            user = users[0]
+            tasks = _tasks
+
+            done()
+          })
+        })
+      })
+    })
+
+    it("should correctly remove associated objects", function() {
+      Helpers.async(function(done) {
+        user.getTasks().on('success', function(__tasks) {
+          expect(__tasks.length).toEqual(0)
+          user.setTasks(tasks).on('success', function() {
+            user.getTasks().on('success', function(_tasks) {
+              expect(_tasks.length).toEqual(tasks.length)
+              user.removeTask(tasks[0]).on('success', function() {
+                user.getTasks().on('success', function(_tasks) {
+                  expect(_tasks.length).toEqual(tasks.length - 1)
+                  done()
+                })
+              })
+            })
+          })
+        })
+      })
+    })
+  })
+})

spec-jasmine/postgres/associations.spec.js

+var config    = require("../config/config")
+  , Sequelize = require("../../index")
+  , sequelize = new Sequelize(config.postgres.database, config.postgres.username, config.postgres.password, {
+      logging: false,
+      port: config.postgres.port,
+      dialect: 'postgres'
+    })
+  , Helpers   = new (require("../config/helpers"))(sequelize)
+
+describe('Associations', function() {
+  beforeEach(function() { Helpers.sync() })
+  afterEach(function() { Helpers.drop() })
+
+  /////////// many-to-many with same prefix ////////////
+
+  describe('many-to-many', function() {
+    describe('where tables have the same prefix', function() {
+      var Table2 = sequelize.define('wp_table2', {foo: Sequelize.STRING})
+        , Table1 = sequelize.define('wp_table1', {foo: Sequelize.STRING})
+
+      Table1.hasMany(Table2)
+      Table2.hasMany(Table1)
+
+      it("should create a table wp_table1wp_table2s", function() {
+        Helpers.async(function(done) {
+          expect(sequelize.daoFactoryManager.getDAO('wp_table1swp_table2s')).toBeDefined()
+          done()
+        })
+      })
+    })
+    describe('when join table name is specified', function() {
+      var Table2 = sequelize.define('ms_table1', {foo: Sequelize.STRING})
+        , Table1 = sequelize.define('ms_table2', {foo: Sequelize.STRING})
+
+      Table1.hasMany(Table2, {joinTableName: 'table1_to_table2'})
+      Table2.hasMany(Table1, {joinTableName: 'table1_to_table2'})
+
+      it("should not use a combined name", function() {
+        expect(sequelize.daoFactoryManager.getDAO('ms_table1sms_table2s')).toBeUndefined()
+      })
+      it("should use the specified name", function() {
+        expect(sequelize.daoFactoryManager.getDAO('table1_to_table2')).toBeDefined()
+      })
+    })
+  })
+
+})

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

+var config         = require("../config/config")
+  , Sequelize      = require("../../index")
+  , sequelize      = new Sequelize(config.postgres.database, config.postgres.username, config.postgres.password, {
+      logging: false,
+      dialect: 'postgres',
+      port: config.postgres.port
+    })
+  , Helpers        = new (require("../config/helpers"))(sequelize)
+  , QueryGenerator = require("../../lib/dialects/postgres/query-generator")
+  , util          = require("util")
+
+describe('QueryGenerator', function() {
+  beforeEach(function() { Helpers.sync() })
+  afterEach(function() { Helpers.drop() })
+
+  var suites = {
+    createTableQuery: [
+      {
+        arguments: ['myTable', {title: 'VARCHAR(255)', name: 'VARCHAR(255)'}],
+        expectation: "CREATE TABLE IF NOT EXISTS \"myTable\" (\"title\" VARCHAR(255), \"name\" VARCHAR(255));"
+      },
+    ],
+
+    dropTableQuery: [
+      {
+        arguments: ['myTable'],
+        expectation: "DROP TABLE IF EXISTS \"myTable\";"
+      }
+    ],
+
+    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 \"id\"=2;"
+      }, {
+        arguments: ['myTable', {where: {name: 'foo'}}],
+        expectation: "SELECT * FROM \"myTable\" WHERE \"name\"='foo';"
+      }, {
+        arguments: ['myTable', {where: {name: "foo';DROP TABLE myTable;"}}],
+        expectation: "SELECT * FROM \"myTable\" WHERE \"name\"='foo\\';DROP TABLE myTable;';"
+      }, {
+        arguments: ['myTable', {where: 2}],
+        expectation: "SELECT * FROM \"myTable\" WHERE \"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', {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;"
+      }
+    ],
+
+    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: new Date(Date.UTC(2011, 2, 27, 10, 1, 55))}],
+        expectation: "INSERT INTO \"myTable\" (\"name\",\"birthday\") VALUES ('foo','2011-03-27 10:01:55.0') RETURNING *;"
+      }, {
+        arguments: ['myTable', {name: 'foo', foo: 1}],
+        expectation: "INSERT INTO \"myTable\" (\"name\",\"foo\") VALUES ('foo',1) RETURNING *;"
+      }
+    ],
+
+    updateQuery: [
+      {
+        arguments: ['myTable', {name: 'foo', birthday: new Date(Date.UTC(2011, 2, 27, 10, 1, 55))}, {id: 2}],
+        expectation: "UPDATE \"myTable\" SET \"name\"='foo',\"birthday\"='2011-03-27 10:01:55.0' WHERE \"id\"=2"
+      }, {
+        arguments: ['myTable', {name: 'foo', birthday: new Date(Date.UTC(2011, 2, 27, 10, 1, 55))}, 2],
+        expectation: "UPDATE \"myTable\" SET \"name\"='foo',\"birthday\"='2011-03-27 10:01:55.0' WHERE \"id\"=2"
+      }, {
+        arguments: ['myTable', {bar: 2}, {name: 'foo'}],
+        expectation: "UPDATE \"myTable\" SET \"bar\"=2 WHERE \"name\"='foo'"
+      }, {
+        arguments: ['myTable', {name: "foo';DROP TABLE myTable;"}, {name: 'foo'}],
+        expectation: "UPDATE \"myTable\" SET \"name\"='foo\\';DROP TABLE myTable;' WHERE \"name\"='foo'"
+      }
+    ],
+
+    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', 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)"
+      }
+    ],
+
+    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\")"
+      }
+    ],
+
+    // 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\""
+      }
+    ],
+
+    hashToWhereConditions: [
+      {
+        arguments: [{ id: [1,2,3] }],
+        expectation: "\"id\" IN (1,2,3)"
+      }
+    ]
+  }
+
+  Sequelize.Utils._.each(suites, function(tests, suiteTitle) {
+    describe(suiteTitle, function() {
+      tests.forEach(function(test) {
+        var title = test.title || 'correctly returns ' + test.expectation + ' for ' + util.inspect(test.arguments)
+        it(title, function() {
+          var conditions = QueryGenerator[suiteTitle].apply(null, test.arguments)
+          expect(conditions).toEqual(test.expectation)
+        })
+      })
+    })
+  })
+})