Skip to content

public / sequelize

Go to a project

不要怂，就是干，撸起袖子干！

Commit 66ccf6b9 by Daniel Durante
Options

Cleaned up BusterJS even more, hopefully this will fix most of the problems.

1 parent ea264aba
Inline Side-by-side
Showing with 177 additions and 1613 deletions
lib/dialects/mysql/query-generator.js
......@@ -377,7 +377,7 @@ module.exports = (function() {
}, options || {})
return Utils._.compact([
"CREATE", options.indicesType, "INDEX IF NOT EXISTS", options.indexName,
"CREATE", options.indicesType, "INDEX", options.indexName,
(options.indexType ? ('USING ' + options.indexType) : undefined),
"ON", tableName, '(' + transformedAttributes.join(', ') + ')',
(options.parser ? "WITH PARSER " + options.parser : undefined)
......
spec/associations/belongs-to.spec.js
......@@ -8,9 +8,9 @@ var buster = require("buster")
buster.spec.expose()
buster.testRunner.timeout = 1000
var sequelize = Helpers.createSequelizeInstance({dialect: dialect})
describe(Helpers.getTestDialectTeaser("BelongsTo"), function() {
var sequelize = Helpers.createSequelizeInstance({dialect: dialect})
before(function(done) {
this.sequelize = sequelize
Helpers.clearDatabase(this.sequelize, done)
......
spec/associations/has-many.js deleted 100644 → 0
/* jshint camelcase: false */
var buster = require("buster")
, Helpers = require('../buster-helpers')
, Sequelize = require('../../index')
, dialect = Helpers.getTestDialect()
, _ = require('lodash')
, moment = require('moment')
, DataTypes = require(__dirname + "/../../lib/data-types")
buster.spec.expose()
buster.testRunner.timeout = 1000
var sequelize = Helpers.createSequelizeInstance({dialect: dialect})
describe(Helpers.getTestDialectTeaser("HasMany"), function() {
before(function(done) {
this.sequelize = sequelize
Helpers.clearDatabase(this.sequelize, done)
})
describe('general usage', function() {
before(function(done) {
this.User = this.sequelize.define('User', { username: DataTypes.STRING })
this.Task = this.sequelize.define('Task', { title: DataTypes.STRING })
var self = this
this.User.sync({ force: true }).success(function() {
self.Task.sync({ force: true }).success(done)
})
})
describe('mono-directional', function() {
it("adds the foreign key", function(done) {
this.User.hasMany(this.Task)
expect(this.Task.attributes.UserId).toEqual("INTEGER")
done()
})
it('adds the foreign key with underscore', function(done) {
var User = this.sequelize.define('User', { username: DataTypes.STRING })
, Task = this.sequelize.define('Task', { title: DataTypes.STRING }, { underscored: true })
Task.hasMany(User)
expect(User.attributes.task_id).toBeDefined()
done()
})
it('uses the passed foreign key', function(done) {
this.User.hasMany(this.Task, { foreignKey: 'person_id' })
expect(this.Task.attributes.person_id).toEqual("INTEGER")
done()
})
it('defines getters and setters', function(done) {
this.User.hasMany(this.Task)
var u = this.User.build({username: 'asd'})
expect(u.setTasks).toBeDefined()
expect(u.getTasks).toBeDefined()
done()
})
it("defines getters and setters according to the 'as' option", function(done) {
this.User.hasMany(this.Task, {as: 'Tasks'})
var u = this.User.build({username: 'asd'})
expect(u.setTasks).toBeDefined()
expect(u.getTasks).toBeDefined()
done()
})
it("sets and gets associated objects", function(done) {
var self = this
this.User.hasMany(this.Task, { as: 'Tasks' })
this.User.sync({ force: true }).success(function() {
self.Task.sync({ force: true }).success(function() {
self.User.create({username: 'name'}).success(function(user) {
self.Task.create({title: 'task1'}).success(function(task1) {
self.Task.create({title: 'task2'}).success(function(task2) {
user.setTasks([task1, task2]).success(function() {
user.getTasks().success(function(tasks) {
expect(tasks.length).toEqual(2)
user.getTasks({attributes: ['title']}).success(function(tasks) {
expect(tasks[0].selectedValues.title).toEqual('task1')
expect(tasks[0].selectedValues.id).not.toBeDefined()
done()
})
})
})
})
})
})
})
})
})
})
it("should allow selfAssociation to be single linked (only one DAO is created)", function(done) {
var oldLength = this.sequelize.daoFactoryManager.daos.length
, Comment = this.sequelize.define('Comment', { content: DataTypes.STRING })
Comment.belongsTo(Comment, {as: "Parent"});
Comment.hasMany(Comment, {as: 'Children', foreignKey: "ParentId", useJunctionTable: false})
expect(this.sequelize.daoFactoryManager.daos.length).toEqual(oldLength + 1)
Comment.sync({force: true}).success(function() {
Comment.create({ content: 'parentComment' }).success(function(parent) {
Comment.create({ content: 'child1' }).success(function(child1) {
child1.setParent(parent).success(function() {
Comment.create({ content: 'child2' }).success(function(child2) {
child2.setParent(parent).success(function() {
Comment.find({where: { content: 'parentComment' }}).success(function(parent) {
parent.getChildren().success(function(children) {
expect(children.length).toEqual(2)
done()
})
})
})
})
})
})
})
})
})
it("should still use many to many for selfAssociation by default (two DAOs are created)", function(done) {
var oldLength = this.sequelize.daoFactoryManager.daos.length
, Comment = this.sequelize.define('Comment', { content: Sequelize.STRING })
Comment.belongsTo(Comment, {as: "Parent"})
Comment.hasMany(Comment, {as: 'Children'})
expect(this.sequelize.daoFactoryManager.daos.length).toEqual(oldLength + 2)
done();
})
describe('bi-directional', function() {
it('adds the foreign key', function(done) {
var self = this
this.Task.hasMany(this.User)
this.User.hasMany(this.Task)
expect(this.Task.attributes.UserId).not.toBeDefined()
expect(this.User.attributes.UserId).not.toBeDefined()
var daos = this.sequelize.daoFactoryManager.daos.filter(function(dao) {
return (dao.tableName == (self.Task.tableName + self.User.tableName))
})
daos.forEach(function(dao) {
expect(dao.attributes.UserId).toBeDefined()
expect(dao.attributes.TaskId).toBeDefined()
})
done()
})
it("adds the foreign key with underscores", function(done) {
var User = this.sequelize.define('User', { username: Helpers.Sequelize.STRING }, { underscored: true })
, Task = this.sequelize.define('Task', { title: Helpers.Sequelize.STRING })
Task.hasMany(User)
User.hasMany(Task)
expect(Task.attributes.user_id).not.toBeDefined()
expect(User.attributes.user_id).not.toBeDefined()
var daos = this.sequelize.daoFactoryManager.daos.filter(function(dao) {
return (dao.tableName == (Task.tableName + User.tableName))
})
daos.forEach(function(dao) {
expect(dao.attributes.user_id).toBeDefined()
expect(dao.attributes.TaskId).toBeDefined()
})
done()
})
it("uses the passed foreign keys", function(done) {
var self = this
this.User.hasMany(this.Task, { foreignKey: 'person_id' })
this.Task.hasMany(this.User, { foreignKey: 'work_item_id' })
var daos = this.sequelize.daoFactoryManager.daos.filter(function(dao) {
return (dao.tableName == (self.Task.tableName + self.User.tableName))
})
daos.forEach(function(dao) {
expect(dao.attributes.person_id).toBeDefined()
expect(dao.attributes.work_item_id).toBeDefined()
})
done()
})
it("defines getters and setters", function(done) {
this.User.hasMany(this.Task)
this.Task.hasMany(this.User)
var u = this.User.build({ username: 'asd' })
expect(u.setTasks).toBeDefined()
expect(u.getTasks).toBeDefined()
var t = this.Task.build({ title: 'foobar' })
expect(t.setUsers).toBeDefined()
expect(t.getUsers).toBeDefined()
done()
})
it("defines getters and setters according to the 'as' option", function(done) {
this.User.hasMany(this.Task, { as: 'Tasks' })
this.Task.hasMany(this.User, { as: 'Users' })
var u = this.User.build({ username: 'asd' })
expect(u.setTasks).toBeDefined()
expect(u.getTasks).toBeDefined()
var t = this.Task.build({ title: 'asd' })
expect(t.setUsers).toBeDefined()
expect(t.getUsers).toBeDefined()
done()
})
it("sets and gets the corrected associated objects", function(done) {
var self = this
var users = []
, tasks = []
this.User.hasMany(this.Task, {as: 'Tasks'})
this.Task.hasMany(this.User, {as: 'Users'})
this.User.sync({ force: true }).success(function() {
self.Task.sync({ force: true }).success(function() {
self.User.create({username: 'name'}).success(function(user1) {
self.User.create({username: 'name2'}).success(function(user2) {
self.Task.create({title: 'task1'}).success(function(task1) {
self.Task.create({title: 'task2'}).success(function(task2) {
users.push(user1)
users.push(user2)
tasks.push(task1)
tasks.push(task2)
users[0].setTasks(tasks).success(function() {
users[0].getTasks().success(function(_tasks) {
expect(_tasks.length).toEqual(2)
tasks[1].setUsers(users).success(function() {
tasks[1].getUsers().success(function() {
expect(users.length).toEqual(2)
done()
})
})
})
})
})
})
})
})
})
})
})
})
it("build the connector daos name", function(done) {
var self = this
, Person = this.sequelize.define('Person', { name: Helpers.Sequelize.STRING })
Person.hasMany(Person, {as: 'Children'})
Person.hasMany(Person, {as: 'Friends'})
Person.hasMany(Person, {as: 'CoWorkers'})
Person.sync({force: true}).success(function() {
var daoNames = self.sequelize.daoFactoryManager.daos.map(function(dao) { return dao.tableName })
, expectation = ["Persons", "ChildrenPersons", "CoWorkersPersons", "FriendsPersons"]
expectation.forEach(function(ex) {
expect(daoNames.indexOf(ex) > -1).toBeTruthy()
})
done()
})
})
it("allows join table to be specified", function(done) {
var Child = this.sequelize.define('Child', { name: Helpers.Sequelize.STRING }, {underscore: true, freezeTableName: true})
, Parent = this.sequelize.define('Parent', { name: Helpers.Sequelize.STRING }, {underscore: true, freezeTableName: true})
, ParentJoin = this.sequelize.define('ParentRelationship', { parent_id: Helpers.Sequelize.INTEGER, child_id: Helpers.Sequelize.INTEGER }, {underscore: true, freezeTableName: true})
, parents = []
Parent.hasMany(Child, {as: 'Children', foreignKey: 'child_id', joinTableName: 'ParentRelationship'})
Child.hasMany(Parent, {as: 'Parents', foreignKey: 'parent_id', joinTableName: 'ParentRelationship'})
Parent.sync({ force: true }).success(function() {
Child.sync({ force: true }).success(function() {
Parent.create({name: 'mom'}).success(function(mom) {
parents.push(mom)
Parent.create({name: 'dad'}).success(function(dad) {
parents.push(dad)
Child.create({name: 'baby'}).success(function(baby) {
baby.setParents(parents).success(function(){
parents[0].getChildren().success(function(children){
expect(children).not.toBe(null)
expect(children.length).toBeDefined()
expect(children.length).toEqual(1)
expect(children[0]).toBeDefined()
expect(children[0].name).toEqual('baby')
done()
})
})
})
})
})
})
})
})
it("allows join table to be mapped and specified", function(done) {
var User = this.sequelize.define('User', { name: Helpers.Sequelize.STRING }, {underscore: true, freezeTableName: true})
, Company = this.sequelize.define('Company', { name: Helpers.Sequelize.STRING }, {underscore: true, freezeTableName: true})
, CompanyAccess = this.sequelize.define('CompanyAccess', { company_id: Helpers.Sequelize.INTEGER, user_id: Helpers.Sequelize.INTEGER, permission: Helpers.Sequelize.STRING }, {underscore: true, freezeTableName: true})
, companies = []
CompanyAccess.belongsTo(User, {as: 'User', foreignKey: 'user_id'})
CompanyAccess.belongsTo(Company, {as: 'Company', foreignKey: 'company_id'})
User.hasMany(Company, {as: 'Companies', foreignKey: 'user_id', joinTableName: 'CompanyAccess'})
Company.hasMany(User, {as: 'Users', foreignKey: 'company_id', joinTableName: 'CompanyAccess'})
User.sync({ force: true }).success(function() {
Company.sync({ force: true }).success(function() {
CompanyAccess.sync({ force: true }).success(function() {
Company.create({name: 'IBM'}).success(function(ibm) {
companies.push(ibm)
Company.create({name: 'EA'}).success(function(ea) {
companies.push(ea)
User.create({name: 'joe@ibm.com'}).success(function(joe) {
joe.setCompanies(companies).success(function(){
User.find({where: {name: 'joe@ibm.com'}}).success(function(joe) {
expect(joe).not.toEqual(null)
joe.getCompanies().success(function(comps) {
expect(comps).not.toEqual(null)
expect(comps.length).toEqual(2)
done()
})
})
})
})
})
})
})
})
})
})
it("gets and sets the connector daos", function(done) {
var Person = this.sequelize.define('Person', { name: Helpers.Sequelize.STRING })
Person.hasMany(Person, {as: 'Children'})
Person.hasMany(Person, {as: 'Friends'})
Person.hasMany(Person, {as: 'CoWorkers'})
Person.sync({ force: true }).success(function() {
Person.create({name: 'foobar'}).success(function(person) {
Person.create({name: 'friend'}).success(function(friend) {
person.setFriends([friend]).success(function() {
person.getFriends().success(function(friends) {
expect(friends.length).toEqual(1)
expect(friends[0].name).toEqual('friend')
done()
})
})
})
})
})
})
})
describe('(1:N)', function() {
describe('hasSingle', function() {
before(function(done) {
this.Article = this.sequelize.define('Article', {
'title': DataTypes.STRING
})
this.Label = this.sequelize.define('Label', {
'text': DataTypes.STRING
})
this.Article.hasMany(this.Label)
var self = this
this.Article.sync({ force: true }).success(function() {
self.Label.sync({ force: true }).success(done)
})
})
it('does not have any labels assigned to it initially', function(done) {
var chainer = new Sequelize.Utils.QueryChainer([
this.Article.create({ title: 'Article' }),
this.Label.create({ text: 'Awesomeness' }),
this.Label.create({ text: 'Epicness' })
])
chainer.run().success(function(results, article, label1, label2) {
var chainer = new Sequelize.Utils.QueryChainer([
article.hasLabel(label1),
article.hasLabel(label2)
])
chainer.run().success(function(_, hasLabel1, hasLabel2) {
expect(hasLabel1).toBeFalse()
expect(hasLabel2).toBeFalse()
done()
})
})
})
it('answers true if the label has been assigned', function(done) {
var chainer = new Sequelize.Utils.QueryChainer([
this.Article.create({ title: 'Article' }),
this.Label.create({ text: 'Awesomeness' }),
this.Label.create({ text: 'Epicness' })
])
chainer.run().success(function(results, article, label1, label2) {
var chainer = new Sequelize.Utils.QueryChainer([
[ article, 'addLabel', [ label1 ]],
[ article, 'hasLabel', [ label1 ]],
[ article, 'hasLabel', [ label2 ]]
])
chainer.runSerially()
.success(function(_, label1, hasLabel1, hasLabel2) {
expect(hasLabel1).toBeTrue()
expect(hasLabel2).toBeFalse()
done()
})
})
})
})
describe('hasAll', function() {
before(function(done) {
this.Article = this.sequelize.define('Article', {
'title': DataTypes.STRING
})
this.Label = this.sequelize.define('Label', {
'text': DataTypes.STRING
})
this.Article.hasMany(this.Label)
var self = this
this.Article.sync({ force: true }).success(function() {
self.Label.sync({ force: true }).success(done)
})
})
it('answers false if only some labels have been assigned', function(done) {
var chainer = new Sequelize.Utils.QueryChainer([
this.Article.create({ title: 'Article' }),
this.Label.create({ text: 'Awesomeness' }),
this.Label.create({ text: 'Epicness' })
])
chainer.run().success(function(results, article, label1, label2) {
article.addLabel(label1).success(function() {
article.hasLabels([label1, label2]).success(function(result) {
expect(result).toBeFalse()
done()
})
})
})
})
it('answers true if all label have been assigned', function(done) {
var chainer = new Sequelize.Utils.QueryChainer([
this.Article.create({ title: 'Article' }),
this.Label.create({ text: 'Awesomeness' }),
this.Label.create({ text: 'Epicness' })
])
chainer.run().success(function(results, article, label1, label2) {
article.setLabels([label1, label2]).success(function() {
article.hasLabels([label1, label2]).success(function(result) {
expect(result).toBeTrue()
done()
})
})
})
})
})
describe('setAssociations', function() {
it("clears associations when passing null to the set-method", function(done) {
var User = this.sequelize.define('User', { username: DataTypes.STRING })
, Task = this.sequelize.define('Task', { title: DataTypes.STRING })
Task.hasMany(User)
User.sync({ force: true }).success(function() {
Task.sync({ force: true }).success(function() {
User.create({ username: 'foo' }).success(function(user) {
Task.create({ title: 'task' }).success(function(task) {
task.setUsers([ user ]).success(function() {
task.getUsers().success(function(_users) {
expect(_users.length).toEqual(1)
task.setUsers(null).success(function() {
task.getUsers().success(function(_users) {
expect(_users.length).toEqual(0)
done()
})
})
})
})
})
})
})
})
})
})
it("clears associations when passing null to the set-method with omitNull set to true", function(done) {
this.sequelize.options.omitNull = true
var User = this.sequelize.define('User', { username: Sequelize.STRING })
, Task = this.sequelize.define('Task', { title: Sequelize.STRING })
Task.hasMany(User)
User.sync({ force: true }).success(function() {
Task.sync({ force: true }).success(function() {
User.create({ username: 'foo' }).success(function(user) {
Task.create({ title: 'task' }).success(function(task) {
task.setUsers([ user ]).success(function() {
task.getUsers().success(function(_users) {
expect(_users.length).toEqual(1)
task.setUsers(null).success(function() {
task.getUsers().success(function(_users) {
expect(_users.length).toEqual(0)
done()
})
})
})
})
})
})
})
})
})
describe("getting assocations with options", function() {
it('should treat the where object of associations as a first class citizen', function(done) {
var self = this
this.Article = this.sequelize.define('Article', {
'title': DataTypes.STRING
})
this.Label = this.sequelize.define('Label', {
'text': DataTypes.STRING,
'until': DataTypes.DATE
})
this.Article.hasMany(this.Label)
self.Article.sync({ force: true }).success(function() {
self.Label.sync({ force: true }).success(function() {
var chainer = new Sequelize.Utils.QueryChainer([
self.Article.create({ title: 'Article' }),
self.Label.create({ text: 'Awesomeness', until: '2014-01-01 01:00:00' }),
self.Label.create({ text: 'Epicness', until: '2014-01-03 01:00:00' })
])
chainer.run().success(function(results, article, label1, label2) {
article.setLabels([label1, label2]).success(function() {
article.getLabels({where: ['until > ?', moment('2014-01-02').toDate()]}).success(function(labels) {
expect(labels).toBeArray()
expect(labels.length).toEqual(1)
expect(labels[0].text).toEqual('Epicness')
done()
})
})
})
})
})
})
describe("generic options", function() {
before(function(done) {
var self = this
this.User = this.sequelize.define('User', { username: DataTypes.STRING })
this.Task = this.sequelize.define('Task', { title: DataTypes.STRING, active: DataTypes.BOOLEAN })
this.User.hasMany(self.Task)
this.User.sync({ force: true }).success(function() {
self.Task.sync({ force: true }).success(function() {
var chainer = new Sequelize.Utils.QueryChainer([
self.User.create({ username: 'John'}),
self.Task.create({ title: 'Get rich', active: true}),
self.Task.create({ title: 'Die trying', active: false})
])
chainer.run().success(function (results, john, task1, task2) {
john.setTasks([task1, task2]).success(done)
})
})
})
})
it("gets all associated objects when no options are passed", function(done) {
this.User.find({where: {username: 'John'}}).success(function(john) {
john.getTasks().success(function (tasks) {
expect(tasks.length).toEqual(2)
done()
})
})
})
it("only get objects that fulfill the options", function(done) {
this.User.find({ where: { username: 'John' } }).success(function(john) {
john.getTasks({ where: { active: true }, limit: 10, order: 'id DESC' }).success(function(tasks) {
expect(tasks.length).toEqual(1)
done()
})
})
})
})
})
describe('optimizations using bulk create, destroy and update', function () {
before(function(done) {
var self = this
this.User = this.sequelize.define('User', { username: DataTypes.STRING }, {timestamps: false})
this.Task = this.sequelize.define('Task', { title: DataTypes.STRING }, {timestamps: false})
this.User.hasMany(this.Task)
self.User.sync({ force: true }).success(function() {
self.Task.sync({ force: true }).success(done)
})
})
it('uses one UPDATE statement', function(done) {
var spy = this.spy()
, self = this
this.User.create({ username: 'foo' }).success(function(user) {
self.Task.create({ title: 'task1' }).success(function(task1) {
self.Task.create({ title: 'task2' }).success(function(task2) {
user.setTasks([task1, task2]).on('sql', spy).on('sql', _.after(2, function(sql) { // We don't care about SELECt, only UPDAET
expect(sql).toMatch("UPDATE")
expect(sql).toMatch("IN (1,2)")
})).success(function () {
expect(spy).toHaveBeenCalledTwice() // Once for SELECT, once for UPDATE
done()
})
})
})
})
})
it('uses one UPDATE statement', function(done) {
var spy = this.spy()
, self = this
this.User.create({ username: 'foo' }).success(function(user) {
self.Task.create({ title: 'task1' }).success(function(task1) {
self.Task.create({ title: 'task2' }).success(function(task2) {
user.setTasks([task1, task2]).success(function () {
user.setTasks(null).on('sql', spy).on('sql', _.after(2, function(sql) { // We don't care about SELECT, only UPDATE
expect(sql).toMatch("UPDATE")
expect(sql).toMatch("IN (1,2)")
})).success(function () {
expect(spy).toHaveBeenCalledTwice() // Once for SELECT, once for UPDATE
done()
})
})
})
})
})
})
})
})
describe('(N:M)', function() {
describe("getting assocations with options", function() {
before(function(done) {
var self = this
this.User = this.sequelize.define('User', { username: DataTypes.STRING })
this.Task = this.sequelize.define('Task', { title: DataTypes.STRING, active: DataTypes.BOOLEAN })
self.User.hasMany(self.Task)
self.Task.hasMany(self.User)
self.User.sync({ force: true }).success(function() {
self.Task.sync({ force: true }).success(function() {
var chainer = new Sequelize.Utils.QueryChainer([
self.User.create({ username: 'John'}),
self.Task.create({ title: 'Get rich', active: true}),
self.Task.create({ title: 'Die trying', active: false})
])
chainer.run().success(function(results, john, task1, task2) {
john.setTasks([task1, task2]).success(done)
})
})
})
})
it("gets all associated objects when no options are passed", function(done) {
this.User.find({where: {username: 'John'}}).success(function(john) {
john.getTasks().success(function (tasks) {
expect(tasks.length).toEqual(2)
done()
})
})
})
it("only get objects that fulfill the options", function(done) {
this.User.find({where: {username: 'John'}}).success(function(john) {
john.getTasks({where: {active: true}}).success(function(tasks) {
expect(tasks.length).toEqual(1)
done()
})
})
})
it("only gets objects that fulfill options with a formatted value", function(done) {
this.User.find({where: {username: 'John'}}).success(function(john) {
john.getTasks({where: ['active = ?', true]}).success(function(tasks) {
expect(tasks.length).toEqual(1)
done()
})
})
})
})
it("removes the reference id, which was added in the first place", function(done) {
var User = this.sequelize.define('User', { username: DataTypes.STRING })
, Task = this.sequelize.define('Task', { title: DataTypes.STRING })
User.hasMany(Task)
expect(Task.attributes.UserId).toBeDefined()
Task.hasMany(User)
expect(Task.attributes.UserId).not.toBeDefined()
done()
})
it("adds three items to the query chainer when calling sync", function(done) {
var User = this.sequelize.define('User', { username: DataTypes.STRING })
, Task = this.sequelize.define('Task', { title: DataTypes.STRING })
User.hasMany(Task)
Task.hasMany(User)
var add = this.spy()
this.stub(Sequelize.Utils, 'QueryChainer').returns({ add: add, runSerially: function(){} })
this.sequelize.sync({ force: true })
expect(add).toHaveBeenCalledThrice()
done()
})
describe('setAssociations', function() {
it("clears associations when passing null to the set-method", function(done) {
var User = this.sequelize.define('User', { username: Sequelize.STRING })
, Task = this.sequelize.define('Task', { title: Sequelize.STRING })
User.hasMany(Task)
Task.hasMany(User)
User.sync({ force: true }).success(function() {
Task.sync({ force: true }).success(function() {
User.create({ username: 'foo' }).success(function(user) {
Task.create({ title: 'task' }).success(function(task) {
task.setUsers([ user ]).success(function() {
task.getUsers().success(function(_users) {
expect(_users.length).toEqual(1)
task.setUsers(null).success(function() {
task.getUsers().success(function(_users) {
expect(_users.length).toEqual(0)
done()
})
})
})
})
})
})
})
})
})
})
describe('optimizations using bulk create, destroy and update', function () {
before(function (done) {
this.User = this.sequelize.define('User', { username: DataTypes.STRING }, {timestamps: false})
this.Task = this.sequelize.define('Task', { title: DataTypes.STRING }, {timestamps: false})
this.User.hasMany(this.Task)
this.Task.hasMany(this.User)
var self = this
self.User.sync({ force: true }).success(function() {
self.Task.sync({ force: true }).success(done)
})
})
it('uses one insert into statement', function(done) {
var spy = this.spy()
, self = this
this.User.create({ username: 'foo' }).success(function(user) {
self.Task.create({ title: 'task1' }).success(function(task1) {
self.Task.create({ title: 'task2' }).success(function(task2) {
user.setTasks([task1, task2]).on('sql', spy).on('sql', _.after(2, function(sql) {
expect(sql).toMatch("INSERT INTO")
expect(sql).toMatch("VALUES (1,1),(2,1)")
})).success(function () {
expect(spy).toHaveBeenCalledTwice() // Once for SELECT, once for INSERT into
done()
})
})
})
})
})
it('uses one delete from statement', function(done) {
var spy = this.spy()
, self = this
this.User.create({ username: 'foo' }).success(function(user) {
self.Task.create({ title: 'task1' }).success(function(task1) {
self.Task.create({ title: 'task2' }).success(function(task2) {
user.setTasks([task1, task2]).success(function () {
user.setTasks(null).on('sql', spy).on('sql', _.after(2, function(sql) {
expect(sql).toMatch("DELETE FROM")
expect(sql).toMatch("IN (1,2)")
})).success(function () {
expect(spy).toHaveBeenCalledTwice() // Once for SELECT, once for DELETE
done()
})
})
})
})
})
})
}) // end optimization using bulk create, destroy and update
describe('join table creation', function () {
before(function (done) {
this.User = this.sequelize.define('User',
{ username: DataTypes.STRING },
{ tableName: 'users'}
)
this.Task = this.sequelize.define('Task',
{ title: DataTypes.STRING },
{ tableName: 'tasks' }
)
this.User.hasMany(this.Task,
{ joinTableName: 'user_has_tasks' }
)
this.Task.hasMany(this.User)
var self = this
self.User.sync({ force: true }).success(function() {
self.Task.sync({ force: true }).success(done)
})
})
it('uses the specified joinTableName or a reasonable default', function(done) {
for (var associationName in this.User.associations) {
expect(associationName).not.toEqual(this.User.tableName)
expect(associationName).not.toEqual(this.Task.tableName)
var joinTableName = this.User.associations[associationName].options.joinTableName
if (typeof joinTableName !== 'undefined') {
expect(joinTableName).toEqual(associationName)
}
var tableName = this.User.associations[associationName].options.tableName
if (typeof tableName !== 'undefined') {
expect(tableName).toEqual(associationName)
}
}
done()
})
})
})
describe("Foreign key constraints", function() {
before(function(done) {
this.sequelize.options = console.log
done()
})
it("are not enabled by default", function(done) {
var Task = this.sequelize.define('Task', { title: DataTypes.STRING })
, User = this.sequelize.define('User', { username: DataTypes.STRING })
User.hasMany(Task)
User.sync({ force: true }).success(function() {
Task.sync({ force: true }).success(function() {
User.create({ username: 'foo' }).success(function(user) {
Task.create({ title: 'task' }).success(function(task) {
user.setTasks([task]).success(function() {
user.destroy().success(function() {
Task.findAll().success(function(tasks) {
expect(tasks.length).toEqual(1)
done()
})
})
})
})
})
})
})
})
it("can cascade deletes", function(done) {
var self = this
self.User.hasMany(self.Task, {onDelete: 'cascade'})
self.User.sync({ force: true }).success(function() {
self.Task.sync({ force: true }).success(function() {
self.User.create({ username: 'foo' }).success(function(user) {
self.Task.create({ title: 'task' }).success(function(task) {
user.setTasks([task]).success(function() {
user.destroy().success(function() {
self.Task.findAll().success(function(tasks) {
expect(tasks.length).toEqual(0)
done()
})
})
})
})
})
})
})
})
it("can restrict deletes", function(done) {
var self = this
self.User.hasMany(self.Task, {onDelete: 'restrict'})
self.User.sync({ force: true }).success(function() {
self.Task.sync({ force: true }).success(function() {
self.User.create({ username: 'foo' }).success(function(user) {
self.Task.create({ title: 'task' }).success(function(task) {
user.setTasks([task]).success(function() {
user.destroy().error(function() {
// Should fail due to FK restriction
self.Task.findAll().success(function(tasks) {
expect(tasks.length).toEqual(1)
done()
})
})
})
})
})
})
})
})
it("can cascade updates", function(done) {
var self = this
self.User.hasMany(self.Task, {onUpdate: 'cascade'})
self.User.sync({ force: true }).success(function() {
self.Task.sync({ force: true }).success(function() {
self.User.create({ username: 'foo' }).success(function(user) {
self.Task.create({ title: 'task' }).success(function(task) {
user.setTasks([task]).success(function() {
// Changing the id of a DAO requires a little dance since
// the `UPDATE` query generated by `save()` uses `id` in the
// `WHERE` clause
var tableName = user.QueryInterface.QueryGenerator.addSchema(user.__factory)
user.QueryInterface.update(user, tableName, {id: 999}, user.id)
.success(function() {
self.Task.findAll().success(function(tasks) {
expect(tasks.length).toEqual(1)
expect(tasks[0].UserId).toEqual(999)
done()
})
})
})
})
})
})
})
})
it("can restrict updates", function(done) {
var self = this
self.User.hasMany(self.Task, {onUpdate: 'restrict'})
self.User.sync({ force: true }).success(function() {
self.Task.sync({ force: true }).success(function() {
self.User.create({ username: 'foo' }).success(function(user) {
self.Task.create({ title: 'task' }).success(function(task) {
user.setTasks([task]).success(function() {
// Changing the id of a DAO requires a little dance since
// the `UPDATE` query generated by `save()` uses `id` in the
// `WHERE` clause
var tableName = user.QueryInterface.QueryGenerator.addSchema(user.__factory)
user.QueryInterface.update(user, tableName, {id: 999}, user.id)
.error(function() {
// Should fail due to FK restriction
self.Task.findAll().success(function(tasks) {
expect(tasks.length).toEqual(1)
done()
})
})
})
})
})
})
})
})
})
describe("Association options", function() {
it('can specify data type for autogenerated relational keys', function(done) {
var User = this.sequelize.define('UserXYZ', { username: DataTypes.STRING })
, dataTypes = [DataTypes.INTEGER, Sequelize.BIGINT, DataTypes.STRING]
, self = this
dataTypes.forEach(function(dataType) {
var tableName = 'TaskXYZ_' + dataType.toString()
, Task = self.sequelize.define(tableName, { title: DataTypes.STRING })
User.hasMany(Task, { foreignKey: 'userId', keyType: dataType })
User.sync({ force: true }).success(function() {
expect(Task.rawAttributes.userId.type.toString())
.toEqual(dataType.toString())
dataTypes.splice(dataTypes.indexOf(dataType), 1)
if (!dataTypes.length) {
done()
}
})
})
})
})
})
spec/associations/has-many.spec.js
......@@ -9,9 +9,9 @@ var buster = require("buster")
buster.spec.expose()
buster.testRunner.timeout = 1000
var sequelize = Helpers.createSequelizeInstance({dialect: dialect})
describe(Helpers.getTestDialectTeaser("HasMany"), function() {
var sequelize = Helpers.createSequelizeInstance({dialect: dialect})
before(function(done) {
var self = this
self.sequelize = sequelize
......@@ -20,57 +20,61 @@ describe(Helpers.getTestDialectTeaser("HasMany"), function() {
describe('general usage', function() {
before(function(done) {
this.User = this.sequelize.define('User', { username: Helpers.Sequelize.STRING })
this.Task = this.sequelize.define('Task', { title: Helpers.Sequelize.STRING })
this.sequelize.sync({ force: true }).success(done)
var self = this
self.User = self.sequelize.define('User', { username: Helpers.Sequelize.STRING })
self.Task = self.sequelize.define('Task', { title: Helpers.Sequelize.STRING })
self.User.sync({ force: true }).success(function() {
self.Task.sync({ force: true }).success(done)
})
})
describe('mono-directional', function() {
it("adds the foreign key", function(done) {
this.User.hasMany(this.Task)
expect(this.Task.attributes.UserId).toEqual("INTEGER")
done()
it("adds the foreign key", function() {
var self = this
self.User.hasMany(self.Task)
expect(self.Task.attributes.UserId).toEqual("INTEGER")
})
it('adds the foreign key with underscore', function(done) {
var User = this.sequelize.define('User', { username: Helpers.Sequelize.STRING })
, Task = this.sequelize.define('Task', { title: Helpers.Sequelize.STRING }, { underscored: true })
it('adds the foreign key with underscore', function() {
var self = this
, User = self.sequelize.define('User', { username: Helpers.Sequelize.STRING })
, Task = self.sequelize.define('Task', { title: Helpers.Sequelize.STRING }, { underscored: true })
Task.hasMany(User)
expect(User.attributes.task_id).toBeDefined()
done()
})
it('uses the passed foreign key', function(done) {
this.User.hasMany(this.Task, { foreignKey: 'person_id' })
expect(this.Task.attributes.person_id).toEqual("INTEGER")
done()
it('uses the passed foreign key', function() {
var self = this
self.User.hasMany(self.Task, { foreignKey: 'person_id' })
expect(self.Task.attributes.person_id).toEqual("INTEGER")
})
it('defines getters and setters', function(done) {
this.User.hasMany(this.Task)
it('defines getters and setters', function() {
var self = this
self.User.hasMany(self.Task)
var u = this.User.build({username: 'asd'})
var u = self.User.build({username: 'asd'})
expect(u.setTasks).toBeDefined()
expect(u.getTasks).toBeDefined()
done()
})
it("defines getters and setters according to the 'as' option", function(done) {
this.User.hasMany(this.Task, {as: 'Tasks'})
var u = this.User.build({username: 'asd'})
it("defines getters and setters according to the 'as' option", function() {
var self = this
self.User.hasMany(self.Task, {as: 'Tasks'})
var u = self.User.build({username: 'asd'})
expect(u.setTasks).toBeDefined()
expect(u.getTasks).toBeDefined()
done()
})
it("sets and gets associated objects", function(done) {
var self = this
this.User.hasMany(this.Task, { as: 'Tasks' })
this.sequelize.sync({ force: true }).success(function() {
self.User.hasMany(self.Task, { as: 'Tasks' })
self.User.sync({ force: true }).success(function() {
self.Task.sync({ force: true }).success(function() {
self.User.create({username: 'name'}).success(function(user) {
self.Task.create({title: 'task1'}).success(function(task1) {
self.Task.create({title: 'task2'}).success(function(task2) {
......@@ -90,17 +94,19 @@ describe(Helpers.getTestDialectTeaser("HasMany"), function() {
})
})
})
})
it("should allow selfAssociation to be single linked (only one DAO is created)", function(done) {
var oldLength = this.sequelize.daoFactoryManager.daos.length
, Comment = this.sequelize.define('Comment', { content: Helpers.Sequelize.STRING })
var self = this
, oldLength = self.sequelize.daoFactoryManager.daos.length
, Comment = self.sequelize.define('Comment', { content: Helpers.Sequelize.STRING })
Comment.belongsTo(Comment, {as: "Parent"});
Comment.hasMany(Comment, {as: 'Children', foreignKey: "ParentId", useJunctionTable: false})
expect(this.sequelize.daoFactoryManager.daos.length).toEqual(oldLength + 1)
expect(self.sequelize.daoFactoryManager.daos.length).toEqual(oldLength + 1)
Comment.sync({force: true}).success(function() {
self.sequelize.sync({ force: true }).success(function() {
Comment.create({ content: 'parentComment' }).success(function(parent) {
Comment.create({ content: 'child1' }).success(function(child1) {
child1.setParent(parent).success(function() {
......@@ -120,19 +126,19 @@ describe(Helpers.getTestDialectTeaser("HasMany"), function() {
})
})
it("should still use many to many for selfAssociation by default (two DAOs are created)", function(done) {
var oldLength = this.sequelize.daoFactoryManager.daos.length
, Comment = this.sequelize.define('Comment', { content: Sequelize.STRING })
it("should still use many to many for selfAssociation by default (two DAOs are created)", function() {
var self = this
, oldLength = self.sequelize.daoFactoryManager.daos.length
, Comment = self.sequelize.define('Comment', { content: Sequelize.STRING })
Comment.belongsTo(Comment, {as: "Parent"})
Comment.hasMany(Comment, {as: 'Children'})
expect(this.sequelize.daoFactoryManager.daos.length).toEqual(oldLength + 2)
done();
expect(self.sequelize.daoFactoryManager.daos.length).toEqual(oldLength + 2)
})
describe('bi-directional', function() {
it('adds the foreign key', function(done) {
it('adds the foreign key', function() {
var self = this
this.Task.hasMany(this.User)
......@@ -149,7 +155,6 @@ describe(Helpers.getTestDialectTeaser("HasMany"), function() {
expect(dao.attributes.UserId).toBeDefined()
expect(dao.attributes.TaskId).toBeDefined()
})
done()
})
it("adds the foreign key with underscores", function(done) {
......@@ -340,7 +345,8 @@ describe(Helpers.getTestDialectTeaser("HasMany"), function() {
})
it("gets and sets the connector daos", function(done) {
var Person = this.sequelize.define('Person', { name: Helpers.Sequelize.STRING })
var self = this
, Person = self.sequelize.define('Person', { name: Helpers.Sequelize.STRING })
Person.hasMany(Person, {as: 'Children'})
Person.hasMany(Person, {as: 'Friends'})
......@@ -531,12 +537,13 @@ describe(Helpers.getTestDialectTeaser("HasMany"), function() {
before(function(done) {
var self = this
this.User = this.sequelize.define('User', { username: Sequelize.STRING })
this.Task = this.sequelize.define('Task', { title: Sequelize.STRING, active: Sequelize.BOOLEAN })
self.User = self.sequelize.define('User', { username: Sequelize.STRING })
self.Task = self.sequelize.define('Task', { title: Sequelize.STRING, active: Sequelize.BOOLEAN })
this.User.hasMany(self.Task)
self.User.hasMany(self.Task)
this.sequelize.sync({ force: true }).done(function() {
self.User.sync({ force: true }).done(function() {
self.Task.sync({ force: true }).success(function() {
var chainer = new Sequelize.Utils.QueryChainer([
self.User.create({ username: 'John'}),
self.Task.create({ title: 'Get rich', active: true}),
......@@ -548,6 +555,7 @@ describe(Helpers.getTestDialectTeaser("HasMany"), function() {
})
})
})
})
it('should treat the where object of associations as a first class citizen', function(done) {
var self = this
......
spec/associations/mixin.spec.js
......@@ -6,9 +6,9 @@ var buster = require("buster")
buster.spec.expose()
buster.testRunner.timeout = 1000
var sequelize = Helpers.createSequelizeInstance({dialect: dialect})
describe(Helpers.getTestDialectTeaser("Mixin"), function() {
var sequelize = Helpers.createSequelizeInstance({dialect: dialect})
before(function(done) {
this.sequelize = sequelize
Helpers.clearDatabase(this.sequelize, done)
......
spec/configuration.spec.js
......@@ -3,13 +3,12 @@ var buster = require("buster")
, Helpers = require('./buster-helpers')
, config = require(__dirname + "/config/config")
, dialect = Helpers.getTestDialect()
, Sequelize = require(__dirname + '/../index')
, noDomains = semver.lt(process.version, '0.8.0')
buster.spec.expose()
buster.testRunner.timeout = 1000
var Sequelize = require(__dirname + '/../index')
, noDomains = semver.lt(process.version, '0.8.0')
describe(Helpers.getTestDialectTeaser("Configuration"), function() {
describe('Connections problems should fail with a nice message', function() {
it('when we don\'t have the correct server details', function(done) {
......@@ -19,21 +18,23 @@ describe(Helpers.getTestDialectTeaser("Configuration"), function() {
return done()
}
var sequelize = 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})
(function() {
var sequelizeSpecific2 = 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')
, d = domain.create()
d.on('error', function(err){
expect(err).toMatch(/Failed to find (.*?) Please double check your settings\./)
d.remove(sequelize.query)
d.remove(sequelizeSpecific2.query)
done()
})
d.run(function(){
d.add(sequelize.query)
sequelize.query('select 1 as hello')
d.add(sequelizeSpecific2.query)
sequelizeSpecific2.query('select 1 as hello')
.success(function(){})
})
})()
})
it('when we don\'t have the correct login information', function(done) {
......@@ -49,19 +50,19 @@ describe(Helpers.getTestDialectTeaser("Configuration"), function() {
return done()
}
var sequelize = new Sequelize(config[dialect].database, config[dialect].username, 'fakepass123', {logging: false, host: config[dialect].host, port: 1, dialect: dialect})
var sequelizeSpecific1 = new Sequelize(config[dialect].database, config[dialect].username, 'fakepass123', {logging: false, host: config[dialect].host, port: 1, dialect: dialect})
, domain = require('domain')
, d = domain.create()
d.on('error', function(err){
expect(err).toMatch(/^Failed to authenticate/)
d.remove(sequelize)
d.remove(sequelizeSpecific1.query)
done()
})
d.run(function(){
d.add(sequelize)
sequelize.query('select 1 as hello')
d.add(sequelizeSpecific1.query)
sequelizeSpecific1.query('select 1 as hello')
.success(function(){})
})
})
......@@ -75,7 +76,7 @@ describe(Helpers.getTestDialectTeaser("Configuration"), function() {
})
describe('Instantiation with a URL string', function() {
it('should accept username, password, host, port, and database', function(done) {
it('should accept username, password, host, port, and database', function() {
var sequelize = new Sequelize('mysql://user:pass@example.com:9821/dbname')
var config = sequelize.config
var options = sequelize.options
......@@ -87,49 +88,44 @@ describe(Helpers.getTestDialectTeaser("Configuration"), function() {
expect(config.username).toEqual('user')
expect(config.password).toEqual('pass')
expect(config.port).toEqual(9821)
done()
})
it('should work with no authentication options', function(done) {
it('should work with no authentication options', function() {
var sequelize = new Sequelize('mysql://example.com:9821/dbname')
var config = sequelize.config
expect(config.username).toEqual(undefined)
expect(config.password).toEqual(null)
done()
})
it('should use the default port when no other is specified', function(done) {
it('should use the default port when no other is specified', function() {
var sequelize = new Sequelize('mysql://example.com/dbname')
var config = sequelize.config
// The default port should be set
expect(config.port).toEqual(3306)
done()
})
})
describe('Intantiation with arguments', function() {
it('should accept two parameters (database, username)', function(done) {
it('should accept two parameters (database, username)', function() {
var sequelize = new Sequelize('dbname', 'root')
var config = sequelize.config
expect(config.database).toEqual('dbname')
expect(config.username).toEqual('root')
done()
})
it('should accept three parameters (database, username, password)', function(done) {
it('should accept three parameters (database, username, password)', function() {
var sequelize = new Sequelize('dbname', 'root', 'pass')
var config = sequelize.config
expect(config.database).toEqual('dbname')
expect(config.username).toEqual('root')
expect(config.password).toEqual('pass')
done()
})
it('should accept four parameters (database, username, password, options)', function(done) {
it('should accept four parameters (database, username, password, options)', function() {
var sequelize = new Sequelize('dbname', 'root', 'pass', { port: 999 })
var config = sequelize.config
......@@ -137,7 +133,6 @@ describe(Helpers.getTestDialectTeaser("Configuration"), function() {
expect(config.username).toEqual('root')
expect(config.password).toEqual('pass')
expect(config.port).toEqual(999)
done()
})
})
})
spec/dao-factory.spec.js
......@@ -341,7 +341,9 @@ describe(Helpers.getTestDialectTeaser("DAOFactory"), function() {
Helpers.checkMatchForDialects(dialect, err.message, {
sqlite: /.*SQLITE_CONSTRAINT.*/,
mysql: "Column 'smth' cannot be null",
// We need to allow two different errors for MySQL, see:
// http://dev.mysql.com/doc/refman/5.0/en/server-sql-mode.html#sqlmode_strict_trans_tables
mysql: /(Column 'smth' cannot be null|Field 'smth' doesn't have a default value)/,
postgres: /.*column "smth" violates not-null.*/
})
......@@ -1313,19 +1315,12 @@ describe(Helpers.getTestDialectTeaser("DAOFactory"), function() {
describe('eager loading', function() {
before(function(done) {
var self = this
this.Task = this.sequelize.define('Task', { title: Sequelize.STRING })
this.Worker = this.sequelize.define('Worker', { name: Sequelize.STRING })
this.Domain = this.sequelize.define('Domain', { ip: Sequelize.STRING })
this.Environment = this.sequelize.define('Environment', { name: Sequelize.STRING })
this.Environment
.belongsTo(this.Domain, { as: 'PrivateDomain', foreignKey: 'privateDomainId' })
.belongsTo(this.Domain, { as: 'PublicDomain', foreignKey: 'publicDomainId' })
self.Task = self.sequelize.define('Task', { title: Sequelize.STRING })
self.Worker = self.sequelize.define('Worker', { name: Sequelize.STRING })
this.init = function(callback) {
self.Task.sync({ force: true }).success(function() {
self.Worker.sync({ force: true }).success(function() {
self.Domain.sync({ force: true }).success(function() {
self.Environment.sync({ force: true }).success(function() {
self.Worker.create({ name: 'worker' }).success(function(worker) {
self.Task.create({ title: 'homework' }).success(function(task) {
self.worker = worker
......@@ -1335,13 +1330,12 @@ describe(Helpers.getTestDialectTeaser("DAOFactory"), function() {
})
})
})
})
})
}
done()
})
describe('belongsTo', function() {
describe('generic', function() {
before(function(done) {
var self = this
this.Task.belongsTo(this.Worker)
......@@ -1386,10 +1380,19 @@ describe(Helpers.getTestDialectTeaser("DAOFactory"), function() {
done()
})
})
})
it('returns the private and public ip', function(done) {
var self = this
this.Domain.create({ ip: '192.168.0.1' }).success(function(privateIp) {
self.Domain = self.sequelize.define('Domain', { ip: Sequelize.STRING })
self.Environment = self.sequelize.define('Environment', { name: Sequelize.STRING })
self.Environment
.belongsTo(self.Domain, { as: 'PrivateDomain', foreignKey: 'privateDomainId' })
.belongsTo(self.Domain, { as: 'PublicDomain', foreignKey: 'publicDomainId' })
self.Domain.sync({ force: true }).success(function() {
self.Environment.sync({ force: true }).success(function() {
self.Domain.create({ ip: '192.168.0.1' }).success(function(privateIp) {
self.Domain.create({ ip: '91.65.189.19' }).success(function(publicIp) {
self.Environment.create({ name: 'environment' }).success(function(env) {
env.setPrivateDomain(privateIp).success(function() {
......@@ -1416,6 +1419,8 @@ describe(Helpers.getTestDialectTeaser("DAOFactory"), function() {
})
})
})
})
})
describe('hasOne', function() {
before(function(done) {
......@@ -2456,7 +2461,7 @@ describe(Helpers.getTestDialectTeaser("DAOFactory"), function() {
})
it("emits the error event as the referenced table name is invalid", function(done) {
this.timeout = 1500
this.timeout = 2500
var self = this
this.Author.sync({ force: true }).success(function() {
self.Post.sync({ force: true }).success(function() {
......
spec/dao.spec.js
......@@ -965,7 +965,7 @@ describe(Helpers.getTestDialectTeaser("DAO"), function() {
identifier: {type: Helpers.Sequelize.STRING, primaryKey: true}
})
User.sync().success(function(){
User.sync({ force: true }).success(function(){
User.create({
name: 'snafu',
identifier: 'identifier'
......@@ -993,7 +993,7 @@ describe(Helpers.getTestDialectTeaser("DAO"), function() {
identifier: {type: Helpers.Sequelize.STRING, primaryKey: true}
})
User.sync().success(function(){
User.sync({ force: true }).success(function(){
User.create({
name: 'snafu',
identifier: 'identifier'
......
spec/migrator.spec.js
var buster = require("buster")
if(typeof require === 'function') {
const buster = require("buster")
, QueryChainer = require("../lib/query-chainer")
, CustomEventEmitter = require("../lib/emitters/custom-event-emitter")
, Helpers = require('./buster-helpers')
, dialect = Helpers.getTestDialect()
, Migrator = require("../lib/migrator")
}
buster.spec.expose()
buster.testRunner.timeout = 10000
describe(Helpers.getTestDialectTeaser("Migrator"), function() {
var sequelize = Helpers.createSequelizeInstance({dialect: dialect})
before(function(done) {
this.sequelize = sequelize
this.init = function(options, callback) {
options = Helpers.Sequelize.Utils._.extend({
path: __dirname + '/assets/migrations',
logging: function(){},
context: sequelize
logging: function(){}
}, options || {})
var migrator = new Migrator(sequelize, options)
var migrator = new Migrator(this.sequelize, options)
migrator
.findOrCreateSequelizeMetaDAO({ force: true })
......@@ -26,9 +26,13 @@ describe(Helpers.getTestDialectTeaser("Migrator"), function() {
callback && callback(migrator, SequelizeMeta)
})
.error(function(err) { console.log(err) })
}
}.bind(this)
Helpers.clearDatabase(this.sequelize, done)
Helpers.initTests({ dialect: dialect, onComplete: done, context: this })
})
it("as", function() {
expect(1).toEqual(1)
})
describe('getUndoneMigrations', function() {
......@@ -38,8 +42,8 @@ describe(Helpers.getTestDialectTeaser("Migrator"), function() {
expect(err).toBeNull()
expect(migrations.length).toEqual(0)
done()
})
})
}.bind(this))
}.bind(this))
})
it("returns only files between from and to", function(done) {
......@@ -49,8 +53,8 @@ describe(Helpers.getTestDialectTeaser("Migrator"), function() {
expect(migrations.length).toEqual(1)
expect(migrations[migrations.length - 1].filename).toEqual('20111117063700-createPerson.js')
done()
})
})
}.bind(this))
}.bind(this))
})
it("returns exactly the migration which is defined in from and to", function(done) {
......@@ -60,8 +64,8 @@ describe(Helpers.getTestDialectTeaser("Migrator"), function() {
expect(migrations.length).toEqual(1)
expect(migrations[migrations.length - 1].filename).toEqual('20111117063700-createPerson.js')
done()
})
})
}.bind(this))
}.bind(this))
})
it("returns also the file which is exactly options.from or options.to", function(done) {
......@@ -72,8 +76,8 @@ describe(Helpers.getTestDialectTeaser("Migrator"), function() {
expect(migrations[0].filename).toEqual('20111117063700-createPerson.js')
expect(migrations[1].filename).toEqual('20111130161100-emptyMigration.js')
done()
})
})
}.bind(this))
}.bind(this))
})
it("returns all files to options.to if no options.from is defined", function(done) {
......@@ -82,8 +86,8 @@ describe(Helpers.getTestDialectTeaser("Migrator"), function() {
expect(err).toBeNull()
expect(migrations.length).toEqual(2)
done()
})
})
}.bind(this))
}.bind(this))
})
it("returns all files from last migration id stored in database", function(done) {
......@@ -94,24 +98,23 @@ describe(Helpers.getTestDialectTeaser("Migrator"), function() {
expect(migrations.length).toEqual(6)
expect(migrations[0].filename).toEqual('20111130161100-emptyMigration.js')
done()
})
})
})
}.bind(this))
}.bind(this))
}.bind(this))
})
})
describe('migrations', function() {
before(function(done) {
var self = this
this.init({ from: 20111117063700, to: 20111117063700 }, function(migrator) {
self.migrator = migrator
self.migrator.migrate().success(done)
})
this.migrator = migrator
this.migrator.migrate().success(done)
}.bind(this))
})
describe('executions', function() {
it("executes migration #20111117063700 and correctly creates the table", function(done) {
sequelize.getQueryInterface().showAllTables().success(function(tableNames) {
this.sequelize.getQueryInterface().showAllTables().success(function(tableNames) {
tableNames = tableNames.filter(function(e){ return e != 'SequelizeMeta' })
expect(tableNames).toEqual([ 'Person' ])
done()
......@@ -119,7 +122,7 @@ describe(Helpers.getTestDialectTeaser("Migrator"), function() {
})
it("executes migration #20111117063700 and correctly adds isBetaMember", function(done) {
sequelize.getQueryInterface().describeTable('Person').success(function(data) {
this.sequelize.getQueryInterface().describeTable('Person').success(function(data) {
var fields = Helpers.Sequelize.Utils._.keys(data).sort()
expect(fields).toEqual([ 'isBetaMember', 'name' ])
done()
......@@ -127,19 +130,18 @@ describe(Helpers.getTestDialectTeaser("Migrator"), function() {
})
it("executes migration #20111117063700 correctly up (createTable) and downwards (dropTable)", function(done) {
var self = this
sequelize.getQueryInterface().showAllTables().success(function(tableNames) {
this.sequelize.getQueryInterface().showAllTables().success(function(tableNames) {
tableNames = tableNames.filter(function(e){ return e != 'SequelizeMeta' })
expect(tableNames).toEqual([ 'Person' ])
self.migrator.migrate({ method: 'down' }).success(function() {
self.sequelize.getQueryInterface().showAllTables().success(function(tableNames) {
this.migrator.migrate({ method: 'down' }).success(function() {
this.sequelize.getQueryInterface().showAllTables().success(function(tableNames) {
tableNames = tableNames.filter(function(e){ return e != 'SequelizeMeta' })
expect(tableNames).toEqual([])
done()
})
})
})
}.bind(this))
}.bind(this))
}.bind(this))
})
it("executes the empty migration #20111130161100", function(done) {
......@@ -159,38 +161,35 @@ describe(Helpers.getTestDialectTeaser("Migrator"), function() {
describe('renameTable', function() {
before(function(done) {
var self = this
this.init({ from: 20111117063700, to: 20111117063700 }, function(migrator) {
self.migrator = migrator
self.migrator.migrate().success(done)
})
this.migrator = migrator
this.migrator.migrate().success(done)
}.bind(this))
})
it("executes migration #20111205064000 and renames a table", function(done) {
var self = this
self.sequelize.getQueryInterface().showAllTables().success(function(tableNames) {
this.sequelize.getQueryInterface().showAllTables().success(function(tableNames) {
tableNames = tableNames.filter(function(e){ return e != 'SequelizeMeta' })
expect(tableNames).toContain('Person')
self.init({ from: 20111205064000, to: 20111205064000 }, function(migrator) {
this.init({ from: 20111205064000, to: 20111205064000 }, function(migrator) {
migrator.migrate().success(function() {
self.sequelize.getQueryInterface().showAllTables().success(function(tableNames) {
this.sequelize.getQueryInterface().showAllTables().success(function(tableNames) {
tableNames = tableNames.filter(function(e){ return e != 'SequelizeMeta' })
expect(tableNames).toEqual([ 'User' ])
done()
})
})
})
})
}.bind(this))
}.bind(this))
}.bind(this))
})
})
describe('addColumn', function() {
it('adds a column to the user table', function(done) {
var self = this
self.init({ from: 20111117063700, to: 20111205162700 }, function(migrator) {
this.init({ from: 20111117063700, to: 20111205162700 }, function(migrator) {
migrator.migrate().complete(function(err) {
self.sequelize.getQueryInterface().describeTable('User').complete(function(err, data) {
this.sequelize.getQueryInterface().describeTable('User').complete(function(err, data) {
var signature = data.signature
, isAdmin = data.isAdmin
, shopId = data.shopId
......@@ -202,17 +201,16 @@ describe(Helpers.getTestDialectTeaser("Migrator"), function() {
done()
})
})
})
}.bind(this))
}.bind(this))
})
})
describe('removeColumn', function() {
it('removes the shopId column from user', function(done) {
var self = this
self.init({ to: 20111206061400 }, function(migrator) {
this.init({ to: 20111206061400 }, function(migrator) {
migrator.migrate().success(function(){
self.sequelize.getQueryInterface().describeTable('User').success(function(data) {
this.sequelize.getQueryInterface().describeTable('User').success(function(data) {
var signature = data.signature
, isAdmin = data.isAdmin
, shopId = data.shopId
......@@ -225,17 +223,16 @@ describe(Helpers.getTestDialectTeaser("Migrator"), function() {
done()
})
})
})
}.bind(this))
}.bind(this))
})
})
describe('changeColumn', function() {
it('changes the signature column from user to default "signature" + notNull', function(done) {
var self = this
self.init({ to: 20111206063000 }, function(migrator) {
this.init({ to: 20111206063000 }, function(migrator) {
migrator.migrate().success(function() {
self.sequelize.getQueryInterface().describeTable('User').success(function(data) {
this.sequelize.getQueryInterface().describeTable('User').success(function(data) {
var signature = data.signature
if (dialect === 'postgres') {
......@@ -248,18 +245,17 @@ describe(Helpers.getTestDialectTeaser("Migrator"), function() {
done()
})
})
})
}.bind(this))
}.bind(this))
})
})
})
describe('renameColumn', function() {
it("renames the signature column from user to sig", function(done) {
var self = this
self.init({ to: 20111206163300 }, function(migrator) {
this.init({ to: 20111206163300 }, function(migrator) {
migrator.migrate().success(function(){
self.sequelize.getQueryInterface().describeTable('User').success(function(data) {
this.sequelize.getQueryInterface().describeTable('User').success(function(data) {
var signature = data.signature
, sig = data.sig
......@@ -268,8 +264,9 @@ describe(Helpers.getTestDialectTeaser("Migrator"), function() {
done()
})
})
})
}.bind(this))
}.bind(this))
})
})
})
spec/mysql/associations.spec.js
/* jshint camelcase: false */
var buster = require("buster")
, config = require('../config/config')
, Helpers = require('../buster-helpers')
, dialect = Helpers.getTestDialect()
......@@ -10,9 +9,8 @@ buster.testRunner.timeout = 1000
var sequelize = Helpers.createSequelizeInstance({dialect: dialect})
if (dialect.match(/^mysql/)) {
describe('[MYSQL] Associations', function() {
describe('[MYSQL Specific] Associations', function() {
before(function(done) {
var self = this
this.sequelize = sequelize
Helpers.clearDatabase(this.sequelize, done)
})
......@@ -26,12 +24,14 @@ if (dialect.match(/^mysql/)) {
Table1.hasMany(Table2)
Table2.hasMany(Table1)
this.sequelize.sync({ force: true }).success(function() {
Table1.sync({ force: true }).success(function() {
Table2.sync({ force: true }).success(function() {
expect(self.sequelize.daoFactoryManager.getDAO('wp_table1swp_table2s')).toBeDefined()
done()
})
})
})
})
describe('when join table name is specified', function() {
before(function(done){
......@@ -40,17 +40,14 @@ if (dialect.match(/^mysql/)) {
Table1.hasMany(Table2, {joinTableName: 'table1_to_table2'})
Table2.hasMany(Table1, {joinTableName: 'table1_to_table2'})
this.sequelize.sync({ force: true }).success(done)
Table1.sync({ force: true }).success(function() {
Table2.sync({ force: true }).success(done)
})
it("should not use a combined name", function(done) {
expect(this.sequelize.daoFactoryManager.getDAO('ms_table1sms_table2s')).not.toBeDefined()
done()
})
it("should use the specified name", function(done) {
it("should not use only a specified name", function() {
expect(this.sequelize.daoFactoryManager.getDAO('ms_table1sms_table2s')).not.toBeDefined()
expect(this.sequelize.daoFactoryManager.getDAO('table1_to_table2')).toBeDefined()
done()
})
})
})
......@@ -79,12 +76,14 @@ if (dialect.match(/^mysql/)) {
tasks[tasks.length] = {name: 'Task' + Math.random()}
}
this.sequelize.sync({ force: true }).success(function() {
this.User.sync({ force: true }).success(function() {
self.Task.sync({ force: true }).success(function() {
self.User.bulkCreate(users).success(function() {
self.Task.bulkCreate(tasks).success(done)
})
})
})
})
describe('addDAO / getDAO', function() {
before(function(done) {
......
spec/mysql/connector-manager.spec.js
......@@ -8,7 +8,7 @@ buster.testRunner.timeout = 1000
var sequelize = Helpers.createSequelizeInstance({dialect: dialect})
if (dialect.match(/^mysql/)) {
describe('[MYSQL] Connector Manager', function() {
describe('[MYSQL Specific] Connector Manager', function() {
before(function(done) {
this.sequelize = sequelize
Helpers.clearDatabase(this.sequelize, done)
......
spec/mysql/dao-factory.spec.js
......@@ -10,7 +10,7 @@ buster.testRunner.timeout = 1000
var sequelize = Helpers.createSequelizeInstance({dialect: dialect})
if (dialect.match(/^mysql/)) {
describe('[MYSQL] DAOFactory', function() {
describe('[MYSQL Specific] DAOFactory', function() {
before(function(done) {
this.sequelize = sequelize
Helpers.clearDatabase(this.sequelize, done)
......
spec/mysql/query-generator.spec.js
......@@ -11,7 +11,7 @@ buster.testRunner.timeout = 1000
var sequelize = Helpers.createSequelizeInstance({dialect: dialect})
if (dialect.match(/^mysql/)) {
describe('[MYSQL] QueryGenerator', function() {
describe('[MYSQL Specific] QueryGenerator', function() {
before(function(done) {
this.sequelize = sequelize
Helpers.clearDatabase(this.sequelize, done)
......
spec/promise.spec.js
......@@ -73,7 +73,7 @@ describe(Helpers.getTestDialectTeaser("Promise"), function () {
return self.User.find(1)
}).then(function(user5) {
expect(user5.aNumber).toBe(3)
done();
done()
}, done)
})
})
......
spec/query-chainer.spec.js
if(typeof require === 'function') {
const buster = require("buster")
var buster = require("buster")
, QueryChainer = require("../lib/query-chainer")
, CustomEventEmitter = require("../lib/emitters/custom-event-emitter")
, Helpers = require('./buster-helpers')
, dialect = Helpers.getTestDialect()
}
buster.spec.expose()
buster.testRunner.timeout = 1000
......
spec/sequelize.js deleted 100644 → 0
var buster = require("buster")
, Helpers = require('./buster-helpers')
, config = require(__dirname + "/config/config")
, dialect = Helpers.getTestDialect()
, moment = require('moment')
var qq = function(str) {
if (dialect == 'postgres' || dialect == 'sqlite') {
return '"' + str + '"'
} else if (dialect == 'mysql') {
return '`' + str + '`'
} else {
return str
}
}
buster.spec.expose()
buster.testRunner.timeout = 1000
describe(Helpers.getTestDialectTeaser("Sequelize"), function() {
var sequelize = Helpers.createSequelizeInstance({dialect: dialect})
before(function(done) {
console.log('BEFORE #1', sequelize.options.quoteIdentifiers)
var self = this
self.sequelize = sequelize
Helpers.clearDatabase(self.sequelize, done)
})
describe('constructor', function() {
it('should pass the global options correctly', function(done) {
var self = Object.create(this)
self.sequelize.options.define = self.sequelize.options.define || {}
self.sequelize.options.define.underscored = true
var DAO = self.sequelize.define('dao', {name: Helpers.Sequelize.STRING})
expect(DAO.options.underscored).toBeTruthy()
done()
})
it('should correctly set the host and the port', function(done) {
var sequelize = Helpers.createSequelizeInstance({ host: '127.0.0.1', port: 1234 })
expect(sequelize.config.port).toEqual(1234)
expect(sequelize.config.host).toEqual('127.0.0.1')
done()
})
})
describe('isDefined', function() {
it("returns false if the dao wasn't defined before", function(done) {
var self = this
expect(self.sequelize.isDefined('Project')).toBeFalse()
done()
})
it("returns true if the dao was defined before", function(done) {
var self = this
self.sequelize.define('Project', {
name: Helpers.Sequelize.STRING
})
expect(self.sequelize.isDefined('Project')).toBeTrue()
done()
})
})
describe('query', function() {
before(function(done) {
var self = this
self.sequelize.options.logging = console.log
self.User = self.sequelize.define('User', {
username: Helpers.Sequelize.STRING
})
self.insertQuery = "INSERT INTO " + qq(self.User.tableName) + " (username, " + qq("createdAt") + ", " + qq("updatedAt") + ") VALUES ('john', '2012-01-01 10:10:10', '2012-01-01 10:10:10')"
console.log('BEFORE #2');
Helpers.clearDatabase(self.sequelize, function() {
self.User.sync({ force: true }).success(done)
})
})
it('executes a query the internal way', function(done) {
var self = this
self.sequelize.query(self.insertQuery, null, { raw: true })
.complete(function(err, result) {
expect(err).toBeNull()
expect(result).toBeNull()
done()
})
})
it('executes a query if only the sql is passed', function(done) {
var self = this
self.sequelize.query(self.insertQuery)
.complete(function(err, result) {
expect(err).toBeNull()
expect(result).not.toBeDefined()
done()
})
})
it('executes select queries correctly', function(done) {
var self = this
sequelize.query(this.insertQuery).success(function() {
sequelize
.query("select * from " + qq(self.User.tableName) + "")
.complete(function(err, users) {
console.log('USERS', users)
expect(err).toBeNull()
expect(users.map(function(u){ return u.username })).toEqual(['john'])
done()
})
})
})
it('executes select queries correctly when quoteIdentifiers is false', function(done) {
var temp = this
var self = cloneObject(this.sequelize)
self.options.quoteIdentifiers = false
self.query(self.insertQuery).success(function() {
self.query("select * from " + qq(temp.User.tableName) + "")
.complete(function(err, users) {
console.log('USERS', users)
expect(err).toBeNull()
expect(users.map(function(u){ return u.username })).toEqual(['john'])
done()
})
})
})
it('executes select query and parses dot notation results', function(done) {
var self = this
self.sequelize.query(self.insertQuery).success(function() {
self.sequelize
.query("select username as " + qq("user.username") + " from " + qq(self.User.tableName) + "")
.complete(function(err, users) {
expect(err).toBeNull()
expect(users.map(function(u){ return u.user })).toEqual([{'username':'john'}])
done()
})
})
})
if (dialect == 'mysql') {
it('executes stored procedures', function(done) {
var self = this
sequelize.query(self.insertQuery).success(function() {
sequelize.query('DROP PROCEDURE IF EXISTS foo').success(function() {
sequelize.query(
"CREATE PROCEDURE foo()\nSELECT * FROM " + self.User.tableName + ";"
).success(function() {
sequelize.query('CALL foo()').success(function(users) {
expect(users.map(function(u){ return u.username })).toEqual(['john'])
done()
})
})
})
})
})
} else {
console.log('FIXME: I want to be supported in this dialect as well :-(')
}
it('uses the passed DAOFactory', function(done) {
var self = this
self.sequelize.query(self.insertQuery).success(function() {
self.sequelize.query("SELECT * FROM " + qq(self.User.tableName) + ";", self.User).success(function(users) {
expect(users[0].__factory).toEqual(self.User)
done()
})
})
})
it('destructs dot separated attributes when doing a raw query', function(done) {
var tickChar = (dialect === 'postgres') ? '"' : '`'
, sql = "select 1 as " + Helpers.Sequelize.Utils.addTicks('foo.bar.baz', tickChar)
, self = this
self.sequelize.query(sql, null, { raw: true }).success(function(result) {
expect(result).toEqual([ { foo: { bar: { baz: 1 } } } ])
done()
})
})
it('replaces token with the passed array', function(done) {
var self = this
self.sequelize.query('select ? as foo, ? as bar', null, { raw: true }, [ 1, 2 ]).success(function(result) {
expect(result).toEqual([{ foo: 1, bar: 2 }])
done()
})
})
it('handles AS in conjunction with functions just fine', function(done) {
var self = this
self.sequelize.query('SELECT ' + (dialect === "sqlite" ? 'date(\'now\')' : 'NOW()') + ' AS t').success(function(result) {
expect(moment(result[0].t).isValid()).toBeTrue()
done()
})
})
})
describe('define', function() {
it("adds a new dao to the dao manager", function(done) {
var self = this
expect(self.sequelize.daoFactoryManager.all.length).toEqual(0)
self.sequelize.define('foo', { title: Helpers.Sequelize.STRING })
expect(self.sequelize.daoFactoryManager.all.length).toEqual(1)
done()
})
it("overwrites global options", function(done) {
var sequelize = Helpers.createSequelizeInstance({ define: { collate: 'utf8_general_ci' } })
var DAO = sequelize.define('foo', {bar: Helpers.Sequelize.STRING}, {collate: 'utf8_bin'})
expect(DAO.options.collate).toEqual('utf8_bin')
done()
})
it("inherits global collate option", function(done) {
var sequelize = Helpers.createSequelizeInstance({ define: { collate: 'utf8_general_ci' } })
var DAO = sequelize.define('foo', {bar: Helpers.Sequelize.STRING})
expect(DAO.options.collate).toEqual('utf8_general_ci')
done()
})
it("inherits global classMethods and instanceMethods", function(done) {
var sequelize = Helpers.createSequelizeInstance({
define: {
classMethods : { globalClassMethod : function() {} },
instanceMethods : { globalInstanceMethod : function() {} }
}
})
var DAO = sequelize.define('foo', {bar: Helpers.Sequelize.STRING}, {
classMethods : { localClassMethod : function() {} }
})
expect(typeof DAO.options.classMethods.globalClassMethod).toEqual('function')
expect(typeof DAO.options.classMethods.localClassMethod).toEqual('function')
expect(typeof DAO.options.instanceMethods.globalInstanceMethod).toEqual('function')
done()
})
it("uses the passed tableName", function(done) {
var self = this
, Photo = this.sequelize.define('Foto', { name: Helpers.Sequelize.STRING }, { tableName: 'photos' })
Photo.sync({ force: true }).success(function() {
self.sequelize.getQueryInterface().showAllTables().success(function(tableNames) {
expect(tableNames).toContain('photos')
done()
})
})
})
})
describe('sync', function() {
it("synchronizes all daos", function(done) {
var self = this
var Project = self.sequelize.define('project' + config.rand(), { title: Helpers.Sequelize.STRING })
var Task = self.sequelize.define('task' + config.rand(), { title: Helpers.Sequelize.STRING })
self.sequelize.sync().success(function() {
Project.create({title: 'bla'}).success(function() {
Task.create({title: 'bla'}).success(function(task){
expect(task).toBeDefined()
expect(task.title).toEqual('bla')
done()
})
})
})
})
it('works with correct database credentials', function(done) {
var self = this
var User = self.sequelize.define('User', { username: Helpers.Sequelize.STRING })
User.sync().success(function() {
expect(true).toBeTrue()
done()
})
})
it("fails with incorrect database credentials", function(done) {
var sequelize2 = Helpers.getSequelizeInstance('foo', 'bar', null, { logging: false })
, User2 = sequelize2.define('User', { name: Helpers.Sequelize.STRING, bio: Helpers.Sequelize.TEXT })
User2.sync().error(function(err) {
expect(err.message).toMatch(/.*Access\ denied.*/)
done()
})
})
})
describe('drop should work', function() {
it('correctly succeeds', function(done) {
var self = this
, User = self.sequelize.define('Users', {username: Helpers.Sequelize.STRING })
User.sync({ force: true }).success(function() {
User.drop().success(function() {
expect(true).toBeTrue()
done()
})
})
})
})
describe('import', function() {
it("imports a dao definition from a file", function(done) {
var self = this
, Project = self.sequelize.import(__dirname + "/assets/project")
expect(Project).toBeDefined()
done()
})
})
describe('define', function() {
[
{ type: Helpers.Sequelize.ENUM, values: ['scheduled', 'active', 'finished']},
Helpers.Sequelize.ENUM('scheduled', 'active', 'finished')
].forEach(function(status) {
describe('enum', function() {
before(function(done) {
var self = this
self.Review = self.sequelize.define('review', { status: status })
self.Review.sync({ force: true }).success(done)
})
it('raises an error if no values are defined', function(done) {
var self = this
expect(function() {
self.sequelize.define('omnomnom', {
bla: { type: Helpers.Sequelize.ENUM }
})
}).toThrow('Error', 'Values for ENUM haven\'t been defined.')
done()
})
it('correctly stores values', function(done) {
this.Review.create({ status: 'active' }).success(function(review) {
expect(review.status).toEqual('active')
done()
})
})
it('correctly loads values', function(done) {
var self = this
self.Review.create({ status: 'active' }).success(function() {
self.Review.findAll().success(function(reviews) {
expect(reviews[0].status).toEqual('active')
done()
})
})
})
it("doesn't save an instance if value is not in the range of enums", function(done) {
var self = this
expect(function() {
self.Review.create({ status: 'fnord' })
}).toThrow('Error', 'Value "fnord" for ENUM status is out of allowed scope. Allowed values: scheduled, active, finished')
done()
})
})
})
describe('table', function() {
[
{ id: { type: Helpers.Sequelize.BIGINT } },
{ id: { type: Helpers.Sequelize.STRING, allowNull: true } },
{ id: { type: Helpers.Sequelize.BIGINT, allowNull: false, primaryKey: true, autoIncrement: true } }
].forEach(function(customAttributes) {
it('should be able to override options on the default attributes', function(done) {
var self = this
var Picture = self.sequelize.define('picture', Helpers.Sequelize.Utils._.cloneDeep(customAttributes))
Picture.sync({ force: true }).success(function() {
Object.keys(customAttributes).forEach(function(attribute) {
Object.keys(customAttributes[attribute]).forEach(function(option) {
var optionValue = customAttributes[attribute][option];
expect(Picture.rawAttributes[attribute][option]).toBe(optionValue)
});
})
done()
})
})
})
})
})
})
spec/sequelize.spec.js
......@@ -241,7 +241,8 @@ describe(Helpers.getTestDialectTeaser("Sequelize"), function() {
var Project = this.sequelize.define('project' + config.rand(), { title: Helpers.Sequelize.STRING })
var Task = this.sequelize.define('task' + config.rand(), { title: Helpers.Sequelize.STRING })
sequelize.sync().success(function() {
Project.sync({ force: true }).success(function() {
Task.sync({ force: true }).success(function() {
Project.create({title: 'bla'}).success(function() {
Task.create({title: 'bla'}).success(function(task){
expect(task).toBeDefined()
......@@ -251,6 +252,7 @@ describe(Helpers.getTestDialectTeaser("Sequelize"), function() {
})
})
})
})
it('works with correct database credentials', function(done) {
var User = sequelize.define('User', { username: Helpers.Sequelize.STRING })
......
Markdown is supported
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!