converted migrator tests

spec/migrator.spec.js → test/migrator.test.js

-if(typeof require === 'function') {
-  const buster             = require("buster")
+var chai         = require('chai')
+  , expect       = chai.expect
+  , Support      = require(__dirname + '/support')
+  , DataTypes    = require(__dirname + "/../lib/data-types")
   , QueryChainer = require("../lib/query-chainer")
-      , CustomEventEmitter = require("../lib/emitters/custom-event-emitter")
-      , Helpers            = require('./buster-helpers')
-      , dialect            = Helpers.getTestDialect()
   , Migrator     = require("../lib/migrator")
-}
+  , dialect      = Support.getTestDialect()
 
-buster.spec.expose()
-buster.testRunner.timeout = 10000
+chai.Assertion.includeStack = true
 
-describe(Helpers.getTestDialectTeaser("Migrator"), function() {
-  before(function(done) {
+describe(Support.getTestDialectTeaser("Migrator"), function() {
+  beforeEach(function() {
     this.init = function(options, callback) {
-      options = Helpers.Sequelize.Utils._.extend({
+      options = Support.Sequelize.Utils._.extend({
         path:    __dirname + '/assets/migrations',
         logging: function(){}
       }, options || {})
@@ -27,121 +25,119 @@ describe(Helpers.getTestDialectTeaser("Migrator"), function() {
         })
         .error(function(err) { console.log(err) })
     }.bind(this)
-
-    Helpers.initTests({ dialect: dialect, onComplete: done, context: this })
-  })
-
-  it("as", function() {
-    expect(1).toEqual(1)
   })
 
   describe('getUndoneMigrations', function() {
     it("returns no files if timestamps are after the files timestamp", function(done) {
       this.init({ from: 20120101010101 }, function(migrator) {
         migrator.getUndoneMigrations(function(err, migrations) {
-          expect(err).toBeNull()
-          expect(migrations.length).toEqual(0)
+          expect(err).to.be.null
+          expect(migrations.length).to.equal(0)
           done()
-        }.bind(this))
-      }.bind(this))
+        })
+      })
     })
 
     it("returns only files between from and to", function(done) {
       this.init({ from: 19700101000000, to: 20111117063700 }, function(migrator) {
         migrator.getUndoneMigrations(function(err, migrations) {
-          expect(err).toBeNull()
-          expect(migrations.length).toEqual(1)
-          expect(migrations[migrations.length - 1].filename).toEqual('20111117063700-createPerson.js')
+          expect(err).to.be.null
+          expect(migrations.length).to.equal(1)
+          expect(migrations[migrations.length - 1].filename).to.equal('20111117063700-createPerson.js')
           done()
-        }.bind(this))
-      }.bind(this))
+        })
+      })
     })
 
     it("returns exactly the migration which is defined in from and to", function(done) {
       this.init({ from: 20111117063700, to: 20111117063700 }, function(migrator) {
         migrator.getUndoneMigrations(function(err, migrations) {
-          expect(err).toBeNull()
-          expect(migrations.length).toEqual(1)
-          expect(migrations[migrations.length - 1].filename).toEqual('20111117063700-createPerson.js')
+          expect(err).to.be.null
+          expect(migrations.length).to.equal(1)
+          expect(migrations[migrations.length - 1].filename).to.equal('20111117063700-createPerson.js')
           done()
-        }.bind(this))
-      }.bind(this))
+        })
+      })
     })
 
     it("returns also the file which is exactly options.from or options.to", function(done) {
       this.init({ from: 20111117063700, to: 20111130161100 }, function(migrator) {
         migrator.getUndoneMigrations(function(err, migrations) {
-          expect(err).toBeNull()
-          expect(migrations.length).toEqual(2)
-          expect(migrations[0].filename).toEqual('20111117063700-createPerson.js')
-          expect(migrations[1].filename).toEqual('20111130161100-emptyMigration.js')
+          expect(err).to.be.null
+          expect(migrations.length).to.equal(2)
+          expect(migrations[0].filename).to.equal('20111117063700-createPerson.js')
+          expect(migrations[1].filename).to.equal('20111130161100-emptyMigration.js')
           done()
-        }.bind(this))
-      }.bind(this))
+        })
+      })
     })
 
     it("returns all files to options.to if no options.from is defined", function(done) {
       this.init({ to: 20111130161100 }, function(migrator) {
         migrator.getUndoneMigrations(function(err, migrations) {
-          expect(err).toBeNull()
-          expect(migrations.length).toEqual(2)
+          expect(err).to.be.null
+          expect(migrations.length).to.equal(2)
           done()
-        }.bind(this))
-      }.bind(this))
+        })
+      })
     })
 
     it("returns all files from last migration id stored in database", function(done) {
       this.init(undefined, function(migrator, SequelizeMeta) {
         SequelizeMeta.create({ from: null, to: 20111117063700 }).success(function() {
           migrator.getUndoneMigrations(function(err, migrations) {
-            expect(err).toBeNull()
-            expect(migrations.length).toEqual(6)
-            expect(migrations[0].filename).toEqual('20111130161100-emptyMigration.js')
+            expect(err).to.be.null
+            expect(migrations.length).to.equal(6)
+            expect(migrations[0].filename).to.equal('20111130161100-emptyMigration.js')
             done()
-          }.bind(this))
-        }.bind(this))
-      }.bind(this))
+          })
+        })
+      })
     })
   })
 
   describe('migrations', function() {
-    before(function(done) {
+    beforeEach(function(done) {
+      var self = this
+
       this.init({ from: 20111117063700, to: 20111117063700 }, function(migrator) {
-        this.migrator = migrator
-        this.migrator.migrate().success(done)
-      }.bind(this))
+        self.migrator = migrator
+        self.migrator.migrate().success(done)
+      })
     })
 
     describe('executions', function() {
       it("executes migration #20111117063700 and correctly creates the table", function(done) {
         this.sequelize.getQueryInterface().showAllTables().success(function(tableNames) {
           tableNames = tableNames.filter(function(e){ return e != 'SequelizeMeta' })
-          expect(tableNames).toEqual([ 'Person' ])
+          expect(tableNames).to.eql([ 'Person' ])
           done()
         })
       })
 
       it("executes migration #20111117063700 and correctly adds isBetaMember", function(done) {
         this.sequelize.getQueryInterface().describeTable('Person').success(function(data) {
-          var fields = Helpers.Sequelize.Utils._.keys(data).sort()
-          expect(fields).toEqual([ 'isBetaMember', 'name' ])
+          var fields = Object.keys(data).sort()
+          expect(fields).to.eql([ 'isBetaMember', 'name' ])
           done()
         })
       })
 
       it("executes migration #20111117063700 correctly up (createTable) and downwards (dropTable)", function(done) {
+        var self = this
+
         this.sequelize.getQueryInterface().showAllTables().success(function(tableNames) {
           tableNames = tableNames.filter(function(e){ return e != 'SequelizeMeta' })
-          expect(tableNames).toEqual([ 'Person' ])
+          expect(tableNames).to.eql([ 'Person' ])
 
-          this.migrator.migrate({ method: 'down' }).success(function() {
-            this.sequelize.getQueryInterface().showAllTables().success(function(tableNames) {
+          self.migrator.migrate({ method: 'down' }).success(function() {
+            self.sequelize.getQueryInterface().showAllTables().success(function(tableNames) {
               tableNames = tableNames.filter(function(e){ return e != 'SequelizeMeta' })
-              expect(tableNames).toEqual([])
+              expect(tableNames).to.eql([])
               done()
-            }.bind(this))
-          }.bind(this))
-        }.bind(this))
+            })
+          })
+        })
       })
 
       it("executes the empty migration #20111130161100", function(done) {
@@ -149,7 +145,7 @@ describe(Helpers.getTestDialectTeaser("Migrator"), function() {
           // this migration isn't actually testing anything but
           // should not timeout
 
-          expect(1).toEqual(1)
+          // expect(1).to.equal(1)
 
           migrator
             .migrate()
@@ -160,112 +156,124 @@ describe(Helpers.getTestDialectTeaser("Migrator"), function() {
     })
 
     describe('renameTable', function() {
-     before(function(done) {
+      beforeEach(function(done) {
+        var self = this
+
         this.init({ from: 20111117063700, to: 20111117063700 }, function(migrator) {
-          this.migrator = migrator
-          this.migrator.migrate().success(done)
-        }.bind(this))
+          self.migrator = migrator
+          self.migrator.migrate().success(done)
+        })
       })
 
       it("executes migration #20111205064000 and renames a table", function(done) {
+        var self = this
+
         this.sequelize.getQueryInterface().showAllTables().success(function(tableNames) {
-          tableNames = tableNames.filter(function(e){ return e != 'SequelizeMeta' })
-          expect(tableNames).toContain('Person')
+          tableNames = tableNames.filter(function(e) { return e != 'SequelizeMeta' })
+          expect(tableNames).to.include('Person')
 
-          this.init({ from: 20111205064000, to: 20111205064000 }, function(migrator) {
+          self.init({ from: 20111205064000, to: 20111205064000 }, function(migrator) {
             migrator.migrate().success(function() {
-              this.sequelize.getQueryInterface().showAllTables().success(function(tableNames) {
+              self.sequelize.getQueryInterface().showAllTables().success(function(tableNames) {
                 tableNames = tableNames.filter(function(e){ return e != 'SequelizeMeta' })
-                expect(tableNames).toEqual([ 'User' ])
+                expect(tableNames).to.eql([ 'User' ])
                 done()
               })
-            }.bind(this))
-          }.bind(this))
-        }.bind(this))
+            })
+          })
+        })
       })
     })
 
     describe('addColumn', function() {
       it('adds a column to the user table', function(done) {
+        var self = this
+
         this.init({ from: 20111117063700, to: 20111205162700 }, function(migrator) {
           migrator.migrate().complete(function(err) {
-            this.sequelize.getQueryInterface().describeTable('User').complete(function(err, data) {
+            self.sequelize.getQueryInterface().describeTable('User').complete(function(err, data) {
               var signature = data.signature
                 , isAdmin   = data.isAdmin
                 , shopId    = data.shopId
 
-              expect(signature.allowNull).toEqual(true)
-              expect(isAdmin.allowNull).toEqual(false)
-              expect(isAdmin.defaultValue).toEqual(false)
-              expect(shopId.allowNull).toEqual(true)
+              expect(signature.allowNull).to.be.true
+              expect(isAdmin.allowNull).to.be.false
+              expect(isAdmin.defaultValue).to.equal("0")
+              expect(shopId.allowNull).to.be.true
 
               done()
             })
-          }.bind(this))
-        }.bind(this))
+          })
+        })
       })
     })
 
     describe('removeColumn', function() {
       it('removes the shopId column from user', function(done) {
+        var self = this
+
         this.init({ to: 20111206061400 }, function(migrator) {
           migrator.migrate().success(function(){
-            this.sequelize.getQueryInterface().describeTable('User').success(function(data) {
+            self.sequelize.getQueryInterface().describeTable('User').success(function(data) {
               var signature = data.signature
                 , isAdmin   = data.isAdmin
                 , shopId    = data.shopId
 
-              expect(signature.allowNull).toEqual(true)
-              expect(isAdmin.allowNull).toEqual(false)
-              expect(isAdmin.defaultValue).toEqual(false)
+              expect(signature.allowNull).to.be.true
+              expect(isAdmin.allowNull).to.be.false
+              expect(isAdmin.defaultValue).to.equal('0')
 
-              expect(shopId).toBeFalsy()
+              expect(shopId).to.be.not.ok
 
               done()
             })
-          }.bind(this))
-        }.bind(this))
+          })
+        })
       })
     })
 
     describe('changeColumn', function() {
       it('changes the signature column from user to default "signature" + notNull', function(done) {
+        var self = this
+
         this.init({ to: 20111206063000 }, function(migrator) {
           migrator.migrate().success(function() {
-            this.sequelize.getQueryInterface().describeTable('User').success(function(data) {
+            self.sequelize.getQueryInterface().describeTable('User').success(function(data) {
               var signature = data.signature
 
               if (dialect === 'postgres') {
-                expect(signature.type).toEqual('CHARACTER VARYING')
+                expect(signature.type).to.equal('CHARACTER VARYING')
               } else {
-                expect(signature.type).toEqual('VARCHAR(255)')
+                expect(signature.type).to.equal('VARCHAR(255)')
               }
-              expect(signature.allowNull).toEqual(false)
-              expect(signature.defaultValue).toEqual('Signature')
+              expect(signature.allowNull).to.equal(false)
+              expect(signature.defaultValue).to.equal('Signature')
 
               done()
             })
-          }.bind(this))
-        }.bind(this))
+          })
+        })
       })
     })
   })
 
   describe('renameColumn', function() {
     it("renames the signature column from user to sig", function(done) {
+      var self = this
+
       this.init({ to: 20111206163300 }, function(migrator) {
         migrator.migrate().success(function(){
-          this.sequelize.getQueryInterface().describeTable('User').success(function(data) {
+          self.sequelize.getQueryInterface().describeTable('User').success(function(data) {
             var signature = data.signature
               , sig       = data.sig
 
-            expect(signature).toBeFalsy()
-            expect(sig).toBeTruthy()
+            expect(signature).to.not.be.ok
+            expect(sig).to.be.ok
 
             done()
           })
-        }.bind(this))
-      }.bind(this))
+        })
+      })
     })
   })
 })