splitted tests into multiple files

test/Helper/etc.js

+var Sequelize = require(__dirname + "/../../lib/sequelize/Sequelize").Sequelize
+var h = Sequelize.Helper
+
+module.exports = {
+  'log should be defined': function(assert) {
+    assert.isNotNull(h.log)
+    assert.isDefined(h.log)
+  },
+
+  'evaluateTemplate': function(assert) {
+    assert.equal(h.evaluateTemplate("hallo %{foo}!", {foo: 'welt'}), "hallo welt!")
+    assert.equal(h.evaluateTemplate("hallo %{foo}!", {foo: 'welt', bar: 'asd'}), "hallo welt!")
+  },
+  
+  'Inflection: should be available': function(assert) {
+    assert.isDefined(h.Inflection)
+  },
+}
\ No newline at end of file

test/Helper/hash.js

+var Sequelize = require(__dirname + "/../../lib/sequelize/Sequelize").Sequelize
+var h = Sequelize.Helper
+
+module.exports = {
+  'Hash: forEach': function(assert) {
+    var values = []
+    var keys = []
+    h.Hash.forEach({a:1, b:2, c:3}, function(value, key) {
+      values.push(value)
+      keys.push(key)
+    })
+    assert.eql(values, [1,2,3])
+    assert.eql(keys, ['a', 'b', 'c'])
+  },
+  'Hash: map': function(assert) {
+    var hash = {a:1, b:2, c:3}
+    assert.eql(h.Hash.map(hash, function(value, key) {return value}), [1,2,3])
+    assert.eql(h.Hash.map(hash, function(value, key) {return key}), ['a','b','c'])
+  },
+  'Hash: keys': function(assert) {
+    assert.eql(h.Hash.keys({a:1,b:2}), ['a', 'b'])
+  },
+  'Hash: values': function(assert) {
+    assert.eql(h.Hash.values({a:1,b:2}), [1,2])
+  },
+  'Hash: merge': function(assert) {
+    var src = {a:1, b:2}
+    var target = {b:3, c:3}
+
+    assert.eql(h.Hash.merge(src, target), {a:1, b:3, c:3})
+    assert.eql(h.Hash.merge(src, target, true), {a:1, b:2, c:3})
+  },
+  'Hash: without': function(assert) {
+    var hash = {a: 1, b: 2}
+    assert.eql(h.Hash.without(hash, ["a"]), {b: 2})
+  }
+}
\ No newline at end of file

test/SequelizeHelperTest.js → test/Helper/sql.js

-var Sequelize = require(__dirname + "/../lib/sequelize/Sequelize").Sequelize
+var Sequelize = require(__dirname + "/../../lib/sequelize/Sequelize").Sequelize
 var h = Sequelize.Helper
 
 module.exports = {
-  'log should be defined': function(assert) {
-    assert.isNotNull(h.log)
-    assert.isDefined(h.log)
-  },
-  
-  'evaluateTemplate': function(assert) {
-    assert.equal(h.evaluateTemplate("hallo %{foo}!", {foo: 'welt'}), "hallo welt!")
-    assert.equal(h.evaluateTemplate("hallo %{foo}!", {foo: 'welt', bar: 'asd'}), "hallo welt!")
-  },
-  
   'SQL: manyToManyTableName': function(assert) {
     assert.equal(h.SQL.manyToManyTableName('foo', 'bar'), 'BarFoo')
     assert.equal(h.SQL.manyToManyTableName('bar','foo'), 'BarFoo')
@@ -50,7 +40,7 @@ module.exports = {
     assert.equal(h.SQL.transformValueByDataType(null,   {type: Sequelize.INTEGER}), "NULL")
     assert.equal(h.SQL.transformValueByDataType(null,   {type: Sequelize.STRING}), "NULL")
     assert.equal(h.SQL.transformValueByDataType(null,   {type: Sequelize.TEXT}), "NULL")
-    
+
     var d = new Date(Date.parse("Tue, 1 Jan 2000 00:00:00 GMT"))
     assert.equal(h.SQL.transformValueByDataType(d, {type: Sequelize.DATE}), "'2000-01-01 01:00:00'")
   },
@@ -71,40 +61,5 @@ module.exports = {
   'SQL: addPrefix': function(assert) {
     assert.equal(h.SQL.addPrefix('foo', 'bar', true), 'fooBar')
     assert.equal(h.SQL.addPrefix('foo', 'bar', false), 'fooBars')
-  },
-  'Hash: forEach': function(assert) {
-    var values = []
-    var keys = []
-    h.Hash.forEach({a:1, b:2, c:3}, function(value, key) {
-      values.push(value)
-      keys.push(key)
-    })
-    assert.eql(values, [1,2,3])
-    assert.eql(keys, ['a', 'b', 'c'])
-  },
-  'Hash: map': function(assert) {
-    var hash = {a:1, b:2, c:3}
-    assert.eql(h.Hash.map(hash, function(value, key) {return value}), [1,2,3])
-    assert.eql(h.Hash.map(hash, function(value, key) {return key}), ['a','b','c'])
-  },
-  'Hash: keys': function(assert) {
-    assert.eql(h.Hash.keys({a:1,b:2}), ['a', 'b'])
-  },
-  'Hash: values': function(assert) {
-    assert.eql(h.Hash.values({a:1,b:2}), [1,2])
-  },
-  'Hash: merge': function(assert) {
-    var src = {a:1, b:2}
-    var target = {b:3, c:3}
-    
-    assert.eql(h.Hash.merge(src, target), {a:1, b:3, c:3})
-    assert.eql(h.Hash.merge(src, target, true), {a:1, b:2, c:3})
-  },
-  'Inflection: should be available': function(assert) {
-    assert.isDefined(h.Inflection)
-  },
-  'Hash: without': function(assert) {
-    var hash = {a: 1, b: 2}
-    assert.eql(h.Hash.without(hash, ["a"]), {b: 2})
   }
 }
\ No newline at end of file

test/SequelizeTest.js → test/Sequelize/basics.js

-var Sequelize = require(__dirname + "/../lib/sequelize/Sequelize").Sequelize
+var Sequelize = require(__dirname + "/../../lib/sequelize/Sequelize").Sequelize
 var s = new Sequelize('sequelize_test', 'test', 'test')
 
 module.exports = {
@@ -37,39 +37,6 @@ module.exports = {
     s.define('Day', { name: Sequelize.TEXT })
     assert.deepEqual(s.tableNames, ['Days'])
   },
-  '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: 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: insert': function(assert) {
-    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")
-  },
-  '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")
-  },
   'sync: errors': function(assert, beforeExit) {
     var testIsFinished = false,
         sequelizeWithInvalidCredentials = new Sequelize('foo', 'bar', 'barfoos'),

test/Sequelize/sqlQueryFor.js

+var Sequelize = require(__dirname + "/../../lib/sequelize/Sequelize").Sequelize
+var s = new Sequelize('sequelize_test', 'test', 'test')
+
+module.exports = {
+  '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: 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: insert': function(assert) {
+    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")
+  },
+  '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")
+  }
+}
\ No newline at end of file

test/Table/associations.js

+var Sequelize = require(__dirname + "/../../lib/sequelize/Sequelize").Sequelize
+var s = new Sequelize('sequelize_test', 'root', null, {disableLogging: true})
+var Day = s.define('Day', { name: Sequelize.TEXT })
+
+module.exports = {
+  'hasMany': function(assert) {
+    var HasManyBlubb = s.define('HasManyBlubb', {})
+    Day.hasMany('HasManyBlubbs', HasManyBlubb)
+    assert.isDefined(new Day({name:''}).getHasManyBlubbs)
+  },
+  'hasMany: set association': function(assert, beforeExit) {
+    var assoc = null
+    var Character = s.define('Character', {})
+    var Word = s.define('Word', {})
+    Character.hasMany('Words', Word, 'Characters')
+
+    Sequelize.chainQueries([
+      {drop: Character}, {drop: Word}, {prepareAssociations: Word}, {prepareAssociations: Character}, {sync: Word}, {sync: Character}
+    ],
+    function() {
+      var Association = s.tables.CharactersWords.klass
+      Association.sync(function() {
+        var w = new Word()
+        var c1 = new Character()
+        var c2 = new Character()
+        Sequelize.chainQueries([{save: w}, {save: c1}, {save: c2}], function() {
+          w.setCharacters([c1, c2], function(associations) {
+            assoc = associations
+          })
+        })
+      })
+    })
+
+    beforeExit(function() {
+      assert.isNotNull(assoc)
+      assert.equal(assoc.length, 2)
+    })
+  },
+  'hasOne': function(assert) {
+    var s = new Sequelize('sequelize_test', 'root', null, {disableLogging: true})
+    var Day = s.define('Day2', { name: Sequelize.TEXT })
+    var HasOneBlubb = s.define('HasOneBlubb', {})
+    Day.hasOne('HasOneBlubb', HasOneBlubb)
+
+    assert.isDefined(Day.prototype.getHasOneBlubb)
+  },
+  'hasOne set association': function(assert, beforeExit) {
+    var s2 = new Sequelize('sequelize_test', 'root', null, {disableLogging: true})
+    var Task = s2.define('Task', {title: Sequelize.STRING})
+    var Deadline = s2.define('Deadline', {date: Sequelize.DATE})
+
+    Task.hasOneAndBelongsTo('deadline', Deadline, 'task')
+
+    var task = new Task({ title:'do smth' })
+    var deadline = new Deadline({date: new Date()})
+    var assertMe = null
+
+    Sequelize.chainQueries([{sync: s2}, {drop: s2}, {sync: s2}, {save: task}, {save: deadline}], function() {
+      task.setDeadline(deadline, function(_deadline) {
+        assertMe = _deadline
+      })
+    })
+
+    beforeExit(function() {
+      assert.isNotNull(assertMe)
+      assert.eql(assertMe, deadline)
+    })
+  },
+  'belongsTo': function(assert) {
+    var BelongsToBlubb = s.define('BelongsToBlubb', {})
+    var Day = s.define('Day2', { name: Sequelize.TEXT })
+    var assoc = Day.hasOne('asd', BelongsToBlubb)
+    Day.belongsTo('BelongsToBlubb', BelongsToBlubb, assoc)
+    assert.isDefined(new Day({name:''}).getBelongsToBlubb)
+  },
+  'belongsTo: set association': function(assert, beforeExit) {
+    var s2 = new Sequelize('sequelize_test', 'root', null, {disableLogging: true})
+    var Task = s2.define('Task', {title: Sequelize.STRING})
+    var Deadline = s2.define('Deadline', {date: Sequelize.DATE})
+    var allowExit = false
+
+    var assoc = Task.hasOne('deadline', Deadline)
+    Deadline.belongsTo('task', Task, assoc)
+
+    var task = new Task({ title:'do smth' })
+    var deadline = new Deadline({date: new Date()})
+
+    Sequelize.chainQueries([{drop: s2}, {sync: s2}], function() {
+      task.save(function() {
+        deadline.save(function() {
+          assert.isDefined(deadline.id)
+          assert.isNotNull(deadline.id)
+          deadline.setTask(task, function(_task) {
+            assert.isNotNull(_task)
+            assert.eql(_task.id, task.id)
+            allowExit = true
+          })
+        })
+      })
+    })
+
+    beforeExit(function() {
+      assert.equal(allowExit, true)
+    })
+  }
+}
\ No newline at end of file

test/Table/basics.js

+var Sequelize = require(__dirname + "/../../lib/sequelize/Sequelize").Sequelize
+var s = new Sequelize('sequelize_test', 'root', null, {disableLogging: true})
+var Day = s.define('Day', { name: Sequelize.TEXT })
+
+module.exports = {
+  'constructor': function(assert) {
+    assert.eql(Day.associations, [])
+    assert.eql(Day.attributes, {"name": {type: "TEXT"},"createdAt": {type: "DATETIME", allowNull: false},"updatedAt": {type: "DATETIME", allowNull: false}})
+    assert.eql(Day.tableName, 'Days')
+  },
+  'new': function(assert) {
+    var day = new Day({name: 'asd'})
+    assert.isNull(day.id)
+    assert.eql(day.table, Day)
+    assert.eql(day.name, 'asd')
+    assert.isUndefined(new Day({name: 'asd', bla: 'foo'}).bla)
+  },
+  'sync should return the table class': function(assert, beforeExit) {
+    var toBeTested = null
+    Day.sync(function(_Day) { toBeTested = _Day })
+    beforeExit(function() { assert.eql(toBeTested, Day) })
+  },
+  'drop should return the table class': function(assert, beforeExit) {
+    var toBeTested = null
+    Day.drop(function(_Day) { toBeTested = _Day })
+    beforeExit(function() { assert.eql(toBeTested, Day) })
+  },
+  'sqlResultToObject returns the correct object': function(assert) {
+    var SqlResultToObjectTest = s.define('SqlResultToObject', {name: Sequelize.STRING})
+    var toBeTested = SqlResultToObjectTest.sqlResultToObject({
+      id: 1,
+      name: 'foo'
+    })
+    assert.equal(toBeTested instanceof SqlResultToObjectTest, true)
+    assert.equal(toBeTested.id, 1)
+    assert.equal(toBeTested.name, 'foo')
+  },
+  'identifier': function(assert) {
+    assert.equal(s.define('Identifier', {}).identifier, 'identifierId')
+  },
+  'values': function(assert) {
+    var day = new Day({name: 's'})
+    assert.eql(day.values, { name: "s", createdAt: null, updatedAt: null})
+  },
+  'default values': function(assert) {
+    var DefaultTest = s.define("DefaultTest", {
+      aString: { type: Sequelize.STRING, allowNull: false, default: 'woot'},
+      aNumber: { type: Sequelize.INTEGER, allowNull: true},
+      aBoolean: { type: Sequelize.BOOLEAN, allowNull: false, default: false},
+      aText: { type: Sequelize.TEXT, allowNull: true }
+    }),
+    instance = new DefaultTest({})
+
+    assert.eql(instance.aString, 'woot')
+    assert.isUndefined(instance.aNumber)
+    assert.eql(instance.aBoolean, false)
+    assert.isUndefined(instance.aText)
+  }
+}
\ No newline at end of file

test/Table/databaseAccess.js

+var Sequelize = require(__dirname + "/../../lib/sequelize/Sequelize").Sequelize
+var s = new Sequelize('sequelize_test', 'root', null, {disableLogging: true})
+var Day = s.define('Day', { name: Sequelize.TEXT })
+
+module.exports = {
+ 'save should set the id of a newly created object': function(assert, beforeExit) {
+    var subject = null
+    var SaveTest = s.define('SaveTest', {name: Sequelize.STRING})
+    SaveTest.drop(function(){
+      SaveTest.sync(function() {
+         new SaveTest({name:'s'}).save(function(_saveTest){
+          subject = _saveTest
+        })
+      })
+    })
+
+    beforeExit(function() {
+      assert.isNotNull(subject.id)
+    })
+  },
+  'updateAttributes should update available attributes': function(assert, beforeExit) {
+    var subject = null
+    var UpdateMe = s.define('UpdateMe', {name: Sequelize.STRING})
+    Sequelize.chainQueries([{drop: UpdateMe}, {sync: UpdateMe}], function() {
+      new UpdateMe({name:'Monday'}).save(function(u) {
+        u.updateAttributes({name: 'Sunday', foo: 'bar'}, function(u) {
+          subject = u
+        })
+      })
+    })
+
+    beforeExit(function() {
+      assert.isNotNull(subject)
+      assert.equal(subject.name, 'Sunday')
+      assert.isUndefined(subject.foo)
+    })
+  },
+  'destroy should make the object unavailable': function(assert, beforeExit) {
+    var subject = 1
+    var UpdateAttributesTest = s.define('UpdateAttributeTest', {name: Sequelize.STRING})
+    Sequelize.chainQueries([{drop: UpdateAttributesTest}, {sync: UpdateAttributesTest}], function() {
+      new UpdateAttributesTest({name:'Monday'}).save(function(day) {
+        day.destroy(function() {
+          UpdateAttributesTest.find(day.id, function(result) {
+            subject = result
+          })
+        })
+      })
+    })
+    beforeExit(function() {
+      assert.isNull(subject)
+    })
+  },
+  'boolean ==> save': function(assert, beforeExit) {
+    var BooleanTest = s.define("BooleanTest", {flag: Sequelize.BOOLEAN})
+    var testIsFinished = false
+    BooleanTest.sync(function() {
+      new BooleanTest({flag: true}).save(function(obj) {
+        assert.equal(obj.flag, true)
+        obj.updateAttributes({flag: false}, function(obj2) {
+          assert.equal(obj2.flag, false)
+          testIsFinished = true
+        })
+      })
+    })
+    beforeExit(function() { assert.equal(true, testIsFinished) })
+  },
+  'sync ==> failure': function(assert, beforeExit) {
+    var testIsFinished = false,
+        sequelizeWithInvalidCredentials = new Sequelize('foo', 'bar', 'barfoos'),
+        Fail = sequelizeWithInvalidCredentials.define('Fail', {})
+
+    Fail.sync(function(table, err) {
+      assert.isDefined(err)
+      assert.isDefined(err.message)
+      testIsFinished = true
+    })
+    beforeExit(function() { assert.equal(testIsFinished, true) })
+  },
+  'drop ==> failure': function(assert, beforeExit) {
+    var testIsFinished = false,
+        sequelizeWithInvalidCredentials = new Sequelize('foo', 'bar', 'barfoos'),
+        Fail = sequelizeWithInvalidCredentials.define('Fail', {})
+
+    Fail.drop(function(table, err) {
+      assert.isDefined(err)
+      assert.isDefined(err.message)
+      testIsFinished = true
+    })
+    beforeExit(function() { assert.equal(testIsFinished, true) })
+  }
+}
\ No newline at end of file

test/Table/finder.js

+var Sequelize = require(__dirname + "/../../lib/sequelize/Sequelize").Sequelize
+var s = new Sequelize('sequelize_test', 'root', null, {disableLogging: true})
+var Day = s.define('Day', { name: Sequelize.TEXT })
+
+module.exports = {
+  'findAll should return all items as class objects': function(assert, beforeExit) {
+    var allFindAllTestItems = null
+    var FindAllTest = s.define('FindAllTest', {})
+
+    Sequelize.chainQueries([
+      {drop: FindAllTest}, {sync: FindAllTest}, {save: new FindAllTest({})}, {save: new FindAllTest({})}
+    ], function() {
+      FindAllTest.findAll(function(findAlls) {
+        allFindAllTestItems = findAlls
+      })
+    })
+
+    beforeExit(function(){
+      assert.equal(allFindAllTestItems.length, 2)
+      allFindAllTestItems.forEach(function(item) {
+        assert.equal(item instanceof FindAllTest, true)
+      })
+    })
+  },
+  'find returns the correct item': function(assert, beforeExit) {
+    var item = null
+    var itemToMatch = null
+    var FindTest = s.define('FindTest', { name: Sequelize.STRING })
+    FindTest.drop(function() {
+      FindTest.sync(function() {
+        itemToMatch = new FindTest({name: 'foo'})
+        itemToMatch.save(function() {
+          new FindTest({name: 'bar'}).save(function() {
+            FindTest.find({name: 'foo'}, function(result) {
+              item = result
+            })
+          })
+        })
+      })
+    })
+
+    beforeExit(function() {
+      assert.equal(itemToMatch.id, item.id)
+      assert.equal(itemToMatch.name, item.name)
+    })
+  },
+  'find returns data in correct attributes': function(assert, beforeExit) {
+    var assertMe = null
+    var FindMeNow = s.define('FindMeNow', { title: Sequelize.STRING, content: Sequelize.TEXT })
+    FindMeNow.drop(function() {
+      FindMeNow.sync(function() {
+        new FindMeNow({title: 'a title', content: 'a content'}).save(function(blubb) {
+          assertMe = blubb
+        })
+      })
+    })
+    beforeExit(function() {
+      assert.isNotNull(assertMe)
+      assert.equal(assertMe.title, 'a title')
+      assert.equal(assertMe.content, 'a content')
+    })
+  }
+}
\ No newline at end of file

test/Table/prepareAssociations.js

+var Sequelize = require(__dirname + "/../../lib/sequelize/Sequelize").Sequelize
+var s = new Sequelize('sequelize_test', 'root', null, {disableLogging: true})
+var Day = s.define('Day', { name: Sequelize.TEXT })
+
+module.exports = {
+ 'prepareAssociations belongsTo': function(assert) {
+    var s = new Sequelize('sequelize_test', 'root', null, {disableLogging: true})
+    var Me = s.define('Me', {})
+    var You = s.define('You', {})
+    var assoc = Me.hasOne('you', You)
+    You.belongsTo('me', Me, assoc)
+
+    Me.prepareAssociations()
+    You.prepareAssociations()
+
+    assert.includes(Sequelize.Helper.Hash.keys(You.attributes), 'meId')
+    assert.isDefined(You.attributes.meId)
+    assert.isNotNull(You.attributes.meId)
+  },
+  'prepareAssociations hasMany': function(assert) {
+    var House = s.define('House', {})
+    var Person = s.define('Person', {})
+
+    House.hasMany('members', Person, 'households')
+    House.prepareAssociations()
+    Person.prepareAssociations()
+
+    assert.isUndefined(House.attributes.personId)
+    assert.isUndefined(House.attributes.membersId)
+    assert.isUndefined(Person.attributes.houseId)
+
+    assert.isDefined(s.tables.HouseholdsMembers)
+  } 
+}
\ No newline at end of file