'SQL: hashToWhereConditions': function() {
var s = new Sequelize('sequelize_test', 'test', 'test')
var Day = s.define('Day', { name: Sequelize.TEXT })
var day = new Day({name: 'asd'})
assert.equal(h.SQL.hashToWhereConditions(5, Day.attributes), '`id`=5')
assert.equal(h.SQL.hashToWhereConditions({name: 'asd'}, Day.attributes), "`name`='asd'")
},
'SQL: valuesForUpdate': function() {
var s = new Sequelize('sequelize_test', 'test', 'test')
var Day = s.define('Day', { name: Sequelize.TEXT })
var day = new Day({name: 'asd'})
assert.equal(h.SQL.valuesForUpdate(day), "`name` = 'asd', `createdAt` = NULL, `updatedAt` = NULL")
assert.equal(h.SQL.valuesForUpdate(day, {seperator: '; '}), "`name` = 'asd'; `createdAt` = NULL; `updatedAt` = NULL")
},
it('provides persistent transactions', function () {
var sequelize = new Support.Sequelize('database', 'username', 'password', {dialect: 'sqlite'})
, User = sequelize.define('user', {
username: Support.Sequelize.STRING,
awesome: Support.Sequelize.BOOLEAN
})
, persistentTransaction;
return sequelize.transaction().then(function(t) {
return sequelize.sync({ transaction:t }).then(function( ) {
return t;
});
}).then(function(t) {
return User.create({}, {transaction:t}).then(function( ) {
return t.commit();
});
}).then(function() {
return sequelize.transaction().then(function(t) {
persistentTransaction = t;
});
}).then(function() {
return User.findAll({transaction: persistentTransaction}).then(function(users) {
expect(users.length).to.equal(1);
return persistentTransaction.commit();
});
});
});
'drop: errors': function(assert, beforeExit) {
var testIsFinished = false,
sequelizeWithInvalidCredentials = new Sequelize('foo', 'bar', 'barfoos'),
Fail = sequelizeWithInvalidCredentials.define('Fail', {})
sequelizeWithInvalidCredentials.drop(function(errors) {
assert.isDefined(errors)
assert.equal(errors.length, 1)
testIsFinished = true
})
beforeExit(function() { assert.equal(testIsFinished, true) })
}
it('runs all beforInit/afterInit hooks', function() {
Support.Sequelize.addHook('beforeInit', 'h1', this.hook1);
Support.Sequelize.addHook('beforeInit', 'h2', this.hook2);
Support.Sequelize.addHook('afterInit', 'h3', this.hook3);
Support.Sequelize.addHook('afterInit', 'h4', this.hook4);
Support.createSequelizeInstance();
expect(this.hook1).to.have.been.calledOnce;
expect(this.hook2).to.have.been.calledOnce;
expect(this.hook3).to.have.been.calledOnce;
expect(this.hook4).to.have.been.calledOnce;
// cleanup hooks on Support.Sequelize
Support.Sequelize.removeHook('beforeInit', 'h1');
Support.Sequelize.removeHook('beforeInit', 'h2');
Support.Sequelize.removeHook('afterInit', 'h3');
Support.Sequelize.removeHook('afterInit', 'h4');
Support.createSequelizeInstance();
// check if hooks were removed
expect(this.hook1).to.have.been.calledOnce;
expect(this.hook2).to.have.been.calledOnce;
expect(this.hook3).to.have.been.calledOnce;
expect(this.hook4).to.have.been.calledOnce;
});
it('do not rollback if already committed', function() {
var SumSumSum = this.sequelize.define('transaction', {
value: {
type: Support.Sequelize.DECIMAL(10, 3),
field: 'value'
}
})
, transTest = function (val) {
return self.sequelize.transaction({isolationLevel: 'SERIALIZABLE'}, function(t) {
return SumSumSum.sum('value', {transaction: t}).then(function (balance) {
return SumSumSum.create({value: -val}, {transaction: t});
});
});
}
, self = this;
// Attention: this test is a bit racy. If you find a nicer way to test this: go ahead
return SumSumSum.sync({force: true}).then(function () {
return (expect(Promise.join(transTest(80), transTest(80), transTest(80))).to.eventually.be.rejectedWith('could not serialize access due to read/write dependencies among transactions'));
}).delay(100).then(function() {
if (self.sequelize.test.$runningQueries !== 0) {
return self.sequelize.Promise.delay(200);
}
return void 0;
}).then(function() {
if (self.sequelize.test.$runningQueries !== 0) {
return self.sequelize.Promise.delay(500);
}
});
});
'sqlQueryFor: select': function(assert) {
assert.equal(Sequelize.sqlQueryFor('select', { table: 'Foo'}), "SELECT * FROM Foo")
assert.equal(Sequelize.sqlQueryFor('select', { table: 'Foo', fields: 'id'}), "SELECT id FROM Foo")
assert.equal(Sequelize.sqlQueryFor('select', { table: 'Foo', where: 'id = 1'}), "SELECT * FROM Foo WHERE id = 1")
assert.equal(Sequelize.sqlQueryFor('select', { table: 'Foo', order: 'id DESC'}), "SELECT * FROM Foo ORDER BY id DESC")
assert.equal(Sequelize.sqlQueryFor('select', { table: 'Foo', group: 'name'}), "SELECT * FROM Foo GROUP BY name")
assert.equal(Sequelize.sqlQueryFor('select', { table: 'Foo', limit: 1}), "SELECT * FROM Foo LIMIT 1")
assert.equal(Sequelize.sqlQueryFor('select', { table: 'Foo', offset: 10, limit: 1}), "SELECT * FROM Foo LIMIT 10, 1")
},
'sqlQueryFor: select': function() {
assert.equal(Sequelize.sqlQueryFor('select', { table: 'Foo'}), "SELECT * FROM `Foo`")
assert.equal(Sequelize.sqlQueryFor('select', { table: 'Foo', fields: ['id']}), "SELECT `id` FROM `Foo`")
assert.equal(Sequelize.sqlQueryFor('select', { table: 'Foo', where: {id: 1}}), "SELECT * FROM `Foo` WHERE `id`=1")
assert.equal(Sequelize.sqlQueryFor('select', { table: 'Foo', order: 'id DESC'}), "SELECT * FROM `Foo` ORDER BY id DESC")
assert.equal(Sequelize.sqlQueryFor('select', { table: 'Foo', group: 'name'}), "SELECT * FROM `Foo` GROUP BY name")
assert.equal(Sequelize.sqlQueryFor('select', { table: 'Foo', limit: 1}), "SELECT * FROM `Foo` LIMIT 1")
assert.equal(Sequelize.sqlQueryFor('select', { table: 'Foo', offset: 10, limit: 1}), "SELECT * FROM `Foo` LIMIT 10, 1")
},
Sequelize.chainQueries([{drop: sequelize}, {sync: sequelize}], function() {
var person = new Person({ name: 'Luke' }),
pet1 = new Pet({ name: 'Bob' }),
pet2 = new Pet({ name: 'Aaron' })
Sequelize.chainQueries([{save: person}, {save: pet1}, {save: pet2}], function() {
person.setPets([pet1], function(pets) {
Sequelize.Helper.log('my pet: ' + pets[0].name )
Sequelize.Helper.log("Now let's get the same data with fetchData!")
person.fetchAssociations(function(data) {
Sequelize.Helper.log("And here we are: " + data.pets[0].name)
Sequelize.Helper.log("The object should now also contain the data: " + person.fetchedAssociations.pets[0].name)
Sequelize.Helper.log('This won\'t do a database request!')
person.getPets(function(pets) {
Sequelize.Helper.log("Pets: " + pets.map(function(pet) { return pet.name }).join(", "))
Sequelize.Helper.log("Let's associate with another pet...")
person.setPets([pet1, pet2], function() {
Sequelize.Helper.log("The set call has stored the pets as associated data!")
Sequelize.Helper.log("And now let's find the pets again! This will make no new database request but serve the already stored pets Bob and Aaron!")
person.getPets(function(pets) {
Sequelize.Helper.log("Pets: " + pets.map(function(pet) { return pet.name }).join(", "))
Sequelize.Helper.log("Now let's force the reloading of pets!")
person.getPets({refetchAssociations: true}, function(pets) {
Sequelize.Helper.log("Pets: " + pets.map(function(pet) { return pet.name }).join(", "))
Person.find(person.id, { fetchAssociations: true }, function(p) {
var petNames = p.fetchedAssociations.pets.map(function(pet) { return pet.name }).join(", ")
Sequelize.Helper.log('Works with find as well: ' + petNames)
})
Person.findAll({ fetchAssociations: true }, function(people) {
var petNames = people[0].fetchedAssociations.pets.map(function(pet) { return pet.name }).join(", ")
Sequelize.Helper.log('And also with findAll: ' + petNames)
})
})
})
})
})
})
})
})
})
Sequelize.chainQueries([{drop: sequelize}, {sync: sequelize}], function() {
var person = new Person({ name: 'Luke' }),
mother = new Person({ name: 'Jane' }),
father = new Person({ name: 'John' }),
brother = new Person({ name: 'Brother' }),
sister = new Person({ name: 'Sister' }),
pet = new Pet({ name: 'Bob' })
Sequelize.chainQueries([{save: person}, {save: mother}, {save: father}, {save: brother}, {save: sister}, {save: pet}], function() {
person.setMother(mother, function(mom) { Sequelize.Helper.log('my mom: ' + mom.name) })
person.setFather(father, function(dad) { Sequelize.Helper.log('my dad: ' + dad.name) })
person.setBrothers([brother], function(bros) { Sequelize.Helper.log("ma bro: " + bros[0].name)})
person.setSisters([sister], function(sis) { Sequelize.Helper.log("ma sis: " + sis[0].name)})
person.setPets([pet], function(pets) { Sequelize.Helper.log('my pet: ' + pets[0].name )})
})
})
var sys = require("sys")
var Class = function(){ sys.log("You've just created a new instance!") }
Class.prototype.add = function(a,b,callback){
this.result = a + b
sys.log("The result: " + this.result)
callback(this.result)
}
sys.log("First of all the old and obsolete way:")
Sequelize.chainQueries([
{add: (new Class()), params: [1, 2]},
{add: (new Class()), params: [2, 3]}
], function() {
sys.log("And we did it!")
})
sys.puts("")
sys.log("The new fashioned way is about removing the array and pass an arbitrary amount of parameters!")
sys.log("Just pass as many hashes as you want, but at the end a function as callback!")
Sequelize.chainQueries(
{add: new Class(), params: [1, 2]},
{add: new Class(), params: [2, 3]},
function() { sys.log("And we did it! Great!") }
)
'sqlQueryFor: delete wihtout limit': function(assert) {
var query = Sequelize.sqlQueryFor('delete', {table: 'Foo', where: "id=2", limit: null})
assert.equal(query, "DELETE FROM Foo WHERE id=2")
},
'sqlQueryFor: insert': function() {
var query = Sequelize.sqlQueryFor('insert', { table: 'Foo', fields: ['foo'], values: "'bar'" })
assert.equal(query, "INSERT INTO `Foo` (`foo`) VALUES ('bar')")
},
'sqlQueryFor: update': function(assert) {
var query = Sequelize.sqlQueryFor('update', { table: 'Foo', values: "foo=1", id: 2 })
assert.equal(query, "UPDATE Foo SET foo=1 WHERE id = 2")
},
'sqlQueryFor: delete': function(assert) {
var query = Sequelize.sqlQueryFor('delete', {table: 'Foo', where: "id=2"})
assert.equal(query, "DELETE FROM Foo WHERE id=2 LIMIT 1")
},
}).then(function() {
return sequelize.transaction().then(function(t) {
persistentTransaction = t;
});
}).then(function() {
}).then(() => {
return sequelize.transaction().then(t => {
persistentTransaction = t;
});
}).then(() => {
'sqlQueryFor: create': function(assert) {
var query = Sequelize.sqlQueryFor('create', { table: 'Foo', fields: 'a INT' })
assert.equal(query, "CREATE TABLE IF NOT EXISTS Foo (a INT)")
},
'sqlQueryFor: drop': function(assert) {
var query = Sequelize.sqlQueryFor('drop', { table: 'Foo' })
assert.equal(query, "DROP TABLE IF EXISTS Foo")
},
'sqlQueryFor: delete with limit': function() {
var query = Sequelize.sqlQueryFor('delete', {table: 'Foo', where: {id: 2}, limit: 10})
assert.equal(query, "DELETE FROM `Foo` WHERE `id`=2 LIMIT 10")
}
'tableNames should be no empty array if tables are specified': function(assert) {
s.define('Day', { name: Sequelize.TEXT })
assert.deepEqual(s.tableNames, ['Days'])
},
'define should return a function': function(assert){
var Day = s.define('Day', { name: Sequelize.TEXT })
assert.equal(typeof Day, 'function')
},
.then(function( ) {
return sequelize.transaction();
})
/*
Title: Default values
This example demonstrates the use of default values for defined model fields. Instead of just specifying the datatype,
you have to pass a hash with a type and a default. You also might want to specify either an attribute can be null or not!
*/
var Sequelize = require(__dirname + "/../../lib/sequelize/Sequelize").Sequelize,
sequelize = new Sequelize("sequelize_test", "root", null),
User = sequelize.define('User', {
name: { type: Sequelize.STRING, allowNull: false},
isAdmin: { type: Sequelize.BOOLEAN, allowNull: false, default: false }
}),
user = new User({ name: 'Someone' })
Sequelize.chainQueries([{drop: User}, {sync: User}], function() {
user.save(function(user) {
Sequelize.Helper.log("user.isAdmin should be the default value (false): " + user.isAdmin)
user.updateAttributes({ isAdmin: true }, function(user) {
Sequelize.Helper.log("user.isAdmin was overwritten to true: " + user.isAdmin)
})
})
})
'SQL: fieldsForInsertQuery': function() {
var s = new Sequelize('sequelize_test', 'test', 'test')
var Day = s.define('Day', { name: Sequelize.TEXT })
var result = h.SQL.fieldsForInsertQuery(new Day({name: 'asd'}))
assert.eql(result, '`name`, `createdAt`, `updatedAt`')
},
'sqlQueryFor: update': function() {
var query = Sequelize.sqlQueryFor('update', { table: 'Foo', values: {foo : 1}, id: 2 })
assert.equal(query, "UPDATE `Foo` SET `foo`=1 WHERE `id`=2")
},
return sequelize.transaction().then(function(t) {
return sequelize.sync({ transaction:t }).then(function( ) {
return t;
});
}).then(function(t) {
'sqlQueryFor: insert': function(assert) {
var query = Sequelize.sqlQueryFor('insert', { table: 'Foo', fields: 'foo', values: "'bar'" })
assert.equal(query, "INSERT INTO Foo (foo) VALUES ('bar')")
},
'define should add new table to tables': function(assert) {
var Day = s.define('Day', { name: Sequelize.TEXT })
assert.includes(Sequelize.Helper.Hash.keys(Day.sequelize.tables), 'Day')
},
return sequelize.transaction().then(t => {
return sequelize.sync({ transaction: t }).then(( ) => {
return t;
});
}).then(t => {