Merge branch 'master' of github.com:sequelize/sequelize

lib/dao.js

@@ -125,10 +125,24 @@ module.exports = (function() {
     for (var attrName in this.daoFactory.rawAttributes) {
     for (var attrName in this.daoFactory.rawAttributes) {
       if (this.daoFactory.rawAttributes.hasOwnProperty(attrName)) {
       if (this.daoFactory.rawAttributes.hasOwnProperty(attrName)) {
         var definition      = this.daoFactory.rawAttributes[attrName]
         var definition      = this.daoFactory.rawAttributes[attrName]
-          , isEnum          = (definition.type && (definition.type.toString() === DataTypes.ENUM.toString()))
-          , isHstore        = (!!definition.type && !!definition.type.type && definition.type.type === DataTypes.HSTORE.type)
-          , hasValue        = (typeof values[attrName] !== 'undefined')
-          , valueOutOfScope = ((definition.values || []).indexOf(values[attrName]) === -1)
+          , isEnum          = definition.type && (definition.type.toString() === DataTypes.ENUM.toString())
+          , isHstore        = !!definition.type && !!definition.type.type && definition.type.type === DataTypes.HSTORE.type
+          , hasValue        = values[attrName] !== undefined
+          , isMySQL         = this.daoFactory.daoFactoryManager.sequelize.options.dialect === "mysql"
+          , ciCollation     = !!this.daoFactory.options.collate && this.daoFactory.options.collate.match(/_ci$/i)
+          , valueOutOfScope
+
+        if (isEnum && isMySQL && ciCollation && hasValue) {
+          var scopeIndex = (definition.values || []).map(function(d) { return d.toLowerCase() }).indexOf(values[attrName].toLowerCase())
+          valueOutOfScope = scopeIndex === -1
+
+          // We'll return what the actual case will be, since a simple SELECT query would do the same...
+          if (!valueOutOfScope) {
+            values[attrName] = definition.values[scopeIndex]
+          }
+        } else {
+          valueOutOfScope = ((definition.values || []).indexOf(values[attrName]) === -1)
+        }
 
 
         if (isEnum && hasValue && valueOutOfScope) {
         if (isEnum && hasValue && valueOutOfScope) {
           throw new Error('Value "' + values[attrName] + '" for ENUM ' + attrName + ' is out of allowed scope. Allowed values: ' + definition.values.join(', '))
           throw new Error('Value "' + values[attrName] + '" for ENUM ' + attrName + ' is out of allowed scope. Allowed values: ' + definition.values.join(', '))

test/dao-factory.test.js

@@ -861,8 +861,8 @@ describe(Support.getTestDialectTeaser("DAOFactory"), function () {
             expect(users[1].username).to.equal("Bill")
             expect(users[1].username).to.equal("Bill")
             expect(users[2].username).to.equal("Bob")
             expect(users[2].username).to.equal("Bob")
 
 
-            expect(parseInt(+users[0].updatedAt/5000, 10)).to.equal(parseInt(+new Date()/5000, 10))
-            expect(parseInt(+users[1].updatedAt/5000, 10)).to.equal(parseInt(+new Date()/5000, 10))
+            expect(parseInt(+users[0].updatedAt/5000, 10)).to.be.closeTo(parseInt(+new Date()/5000, 10), 1)
+            expect(parseInt(+users[1].updatedAt/5000, 10)).to.be.closeTo(parseInt(+new Date()/5000, 10), 1)
 
 
             done()
             done()
           })
           })

test/mysql/dao-factory.test.js

@@ -85,6 +85,57 @@ if (dialect.match(/^mysql/)) {
       })
       })
     })
     })
 
 
+    describe('validations', function() {
+      describe('enums', function() {
+        it('enum data type should be case insensitive if my collation allows it', function(done) {
+          var User = this.sequelize.define('User' + config.rand(), {
+            mood: {
+              type: DataTypes.ENUM,
+              values: ['HAPPY', 'sad', 'WhatEver']
+            }
+          }, {
+            collate: 'utf8_general_ci'
+          })
+
+          User.sync({ force: true }).success(function() {
+            User.create({mood: 'happy'}).success(function(user) {
+              expect(user).to.exist
+              expect(user.mood).to.equal('HAPPY')
+              var u = User.build({mood: 'SAD'})
+              u.save().success(function(_user) {
+                expect(_user).to.exist
+                expect(_user.mood).to.equal('sad')
+                done()
+              })
+            })
+          })
+        })
+
+        it('enum data type should be case sensitive if my collation enforces it', function(done) {
+          var User = this.sequelize.define('User' + config.rand(), {
+            mood: {
+              type: DataTypes.ENUM,
+              values: ['HAPPY', 'sad', 'WhatEver']
+            }
+          }, {
+            collate: 'latin1_bin'
+          })
+
+          User.sync({ force: true }).success(function() {
+            expect(function() {
+              User.create({mood: 'happy'})
+            }).to.throw(Error, 'Value "happy" for ENUM mood is out of allowed scope. Allowed values: HAPPY, sad, WhatEver')
+
+            expect(function() {
+              var u = User.build({mood: 'SAD'})
+              u.save()
+            }).to.throw(Error, 'Value "SAD" for ENUM mood is out of allowed scope. Allowed values: HAPPY, sad, WhatEver')
+            done()
+          })
+        })
+      })
+    })
+
     describe('primaryKeys', function() {
     describe('primaryKeys', function() {
       it("determines the correct primaryKeys", function(done) {
       it("determines the correct primaryKeys", function(done) {
         var User = this.sequelize.define('User' + config.rand(), {
         var User = this.sequelize.define('User' + config.rand(), {