deleted old test files

test_old/Helper/etc.js

-var Sequelize = require(__dirname + "/../../lib/sequelize/Sequelize").Sequelize
-var h = Sequelize.Helper
-var assert = require("assert")
-
-module.exports = {
-  'log should be defined': function() {
-    assert.isNotNull(h.log)
-    assert.isDefined(h.log)
-  },
-
-  'evaluateTemplate': function() {
-    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.isDefined(h.Inflection)
-  },
-}
\ No newline at end of file

test_old/Helper/hash.js

-var Sequelize = require(__dirname + "/../../lib/sequelize/Sequelize").Sequelize
-var h = Sequelize.Helper
-var assert = require("assert")
-
-module.exports = {
-  'Hash: forEach': function() {
-    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() {
-    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.eql(h.Hash.keys({a:1,b:2}), ['a', 'b'])
-  },
-  'Hash: values': function() {
-    assert.eql(h.Hash.values({a:1,b:2}), [1,2])
-  },
-  'Hash: merge': function() {
-    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() {
-    var hash = {a: 1, b: 2}
-    assert.eql(h.Hash.without(hash, ["a"]), {b: 2})
-  },
-  'Hash: isHash': function() {
-    assert.eql(h.Hash.isHash([1,2]), false)
-    assert.eql(h.Hash.isHash(1), false)
-    assert.eql(h.Hash.isHash("asd"), false)
-    assert.eql(h.Hash.isHash({a:1}), true)
-  }
-}
\ No newline at end of file

test_old/Helper/sql.js

-var Sequelize = require(__dirname + "/../../lib/sequelize/Sequelize").Sequelize
-var h = Sequelize.Helper
-var assert = require("assert")
-
-module.exports = {
-  'SQL: manyToManyTableName': function() {
-    assert.equal(h.SQL.manyToManyTableName('foo', 'bar'), 'BarFoo')
-    assert.equal(h.SQL.manyToManyTableName('bar','foo'), 'BarFoo')
-  },
-  'SQL: asTableIdentifier': function() {
-    assert.equal(h.SQL.asTableIdentifier('Users'), 'userId')
-    assert.equal(h.SQL.asTableIdentifier('Children'), 'childId')
-    assert.equal(h.SQL.asTableIdentifier('Children'), 'childId')
-    assert.equal(h.SQL.asTableIdentifier('Mice'), 'mouseId')
-  },
-  'SQL: asTableName': function() {
-    assert.equal(h.SQL.asTableName('User'), 'Users')
-    assert.equal(h.SQL.asTableName('Child'), 'Children')
-    assert.equal(h.SQL.asTableName('Mouse'), 'Mice')
-  },
-  'SQL: asTableName with options': function() {
-    h.configure({ disableTableNameModification: true })
-    assert.equal(h.SQL.asTableName('User'), 'User')
-    assert.equal(h.SQL.asTableName('Child'), 'Child')
-    assert.equal(h.SQL.asTableName('Mouse'), 'Mouse')
-    h.configure({ disableTableNameModification: false })
-  },
-  'SQL: asSqlDate': function() {
-    var d = new Date(Date.parse("Tue, 1 Jan 2000 00:00:00 GMT"))
-    assert.equal(h.SQL.asSqlDate(d), '2000-01-01 01:00:00')
-  },
-  'SQL: valuesForInsertQuery': function() {
-    var s = new Sequelize('sequelize_test', 'test', 'test')
-    var Day = s.define('Day', { name: Sequelize.TEXT })
-    var result = h.SQL.valuesForInsertQuery(new Day({name: 'asd'}))
-    assert.eql(result, ["'asd'", 'NULL', 'NULL'])
-  },
-  '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`')
-  },
-  'SQL: transformValueByDataType': function() {
-    assert.equal(h.SQL.transformValueByDataType('asd',  {type: Sequelize.STRING}), "'asd'")
-    assert.equal(h.SQL.transformValueByDataType('asd',  {type: Sequelize.TEXT}), "'asd'")
-    assert.equal(h.SQL.transformValueByDataType(6,      {type: Sequelize.INTEGER}), "6")
-    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'")
-  },
-  '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")
-  },
-  '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: addPrefix': function() {
-    assert.equal(h.SQL.addPrefix('foo', 'bar', true), 'fooBar')
-    assert.equal(h.SQL.addPrefix('foo', 'bar', false), 'fooBars')
-  },
-  'getDataTypeForValue': function() {
-    var fct = h.SQL.getDataTypeForValue
-    assert.equal(fct(1), Sequelize.INTEGER)
-    assert.equal(fct(1.2), Sequelize.FLOAT)
-    assert.equal(fct("1"), Sequelize.TEXT)
-    assert.equal(fct(new Date()), Sequelize.DATE)
-    assert.equal(fct(true), Sequelize.BOOLEAN)
-  }
-}
\ No newline at end of file

test_old/Sequelize/basics.js

-var Sequelize = require(__dirname + "/../../lib/sequelize/Sequelize").Sequelize
-var s = new Sequelize('sequelize_test', 'test', 'test')
-var assert = require("assert")
-
-module.exports = {
-  'test constants': function() {
-    assert.isDefined(Sequelize.STRING)
-    assert.isNotNull(Sequelize.STRING)
-    assert.isDefined(Sequelize.TEXT)
-    assert.isNotNull(Sequelize.TEXT)
-    assert.isDefined(Sequelize.INTEGER)
-    assert.isNotNull(Sequelize.INTEGER)
-  },
-  'the constructor sets config correctly': function(){
-    assert.equal(s.config.database, 'sequelize_test')
-    assert.equal(s.config.username, 'test')
-    assert.equal(s.config.password, 'test')
-  },
-  'the constructor initializes empty tables hash': function() {
-    var s = new Sequelize('sequelize_test', 'test', 'test')
-    assert.isDefined(s.tables)
-    assert.isNotNull(s.tables)
-    assert.eql(s.tables, {})
-  },
-  'define should return a function': function(){
-    var Day = s.define('Day', { name: Sequelize.TEXT })
-    assert.equal(typeof Day, 'function')
-  },
-  'define should add new table to tables': function() {
-    var Day = s.define('Day', { name: Sequelize.TEXT })
-    assert.includes(Sequelize.Helper.Hash.keys(Day.sequelize.tables), 'Day')
-  },
-  'tableNames should be an empty array if no tables are specified': function(){
-    var s2 = new Sequelize('sequelize_test', 'test', 'test')
-    assert.deepEqual(s2.tableNames, [])
-  },
-  'tableNames should be no empty array if tables are specified': function() {
-    s.define('Day', { name: Sequelize.TEXT })
-    assert.deepEqual(s.tableNames, ['Days'])
-  },
-  'sync: errors': function(beforeExit) {
-    var testIsFinished = false,
-        sequelizeWithInvalidCredentials = new Sequelize('foo', 'bar', 'barfoos'),
-        Fail = sequelizeWithInvalidCredentials.define('Fail', {})
-
-    sequelizeWithInvalidCredentials.sync(function(errors) {
-      assert.isDefined(errors)
-      assert.equal(errors.length, 1)
-      testIsFinished = true
-    })
-    beforeExit(function() { assert.equal(testIsFinished, true) })
-  },
-  'drop: errors': function(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) })
-  }
-}
\ No newline at end of file

test_old/Sequelize/sqlQueryFor.js

-var Sequelize = require(__dirname + "/../../lib/sequelize/Sequelize").Sequelize
-var s = new Sequelize('sequelize_test', 'test', 'test')
-var assert = require("assert")
-
-module.exports = {
-  'sqlQueryFor: create': function() {
-    var query = Sequelize.sqlQueryFor('create', { table: 'Foo', fields: 'a INT' })
-    assert.equal(query, "CREATE TABLE IF NOT EXISTS `Foo` (a INT)")
-  },
-  'sqlQueryFor: drop': function() {
-    var query = Sequelize.sqlQueryFor('drop', { table: 'Foo' })
-    assert.equal(query, "DROP TABLE IF EXISTS `Foo`")
-  },
-  '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")
-  },
-  '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() {
-    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() {
-    var query = Sequelize.sqlQueryFor('delete', {table: 'Foo', where: {id: 2}})
-    assert.equal(query, "DELETE FROM `Foo` WHERE `id`=2 LIMIT 1")
-  },
-  'sqlQueryFor: delete without limit': function() {
-    var query = Sequelize.sqlQueryFor('delete', {table: 'Foo', where: {id: 2}, limit: null})
-    assert.equal(query, "DELETE FROM `Foo` WHERE `id`=2")
-  },
-  '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")
-  }
-}
\ No newline at end of file

test_old/Table/associations.js

-var Sequelize = require(__dirname + "/../../lib/sequelize/Sequelize").Sequelize
-  , config    = require(__dirname + '/../config')
-  , s         = new Sequelize(config.database, config.username, config.password, {disableLogging: true})
-  , Day       = s.define('Day', { name: Sequelize.TEXT })
-  , assert    = require("assert")
-
-module.exports = {
-  'hasMany': function() {
-    var HasManyBlubb = s.define('HasManyBlubb', {})
-    Day.hasMany('HasManyBlubbs', HasManyBlubb)
-    assert.isDefined(new Day({name:''}).getHasManyBlubbs)
-  },
-  'hasMany: set association': function(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.match(1,2)
-      assert.isNotNull(assoc)
-      assert.equal(assoc.length, 2)
-    })
-  },
-  'hasOne': function() {
-    var s = new Sequelize(config.database, config.username, config.password, {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(beforeExit) {
-    var s2 = new Sequelize(config.database, config.username, config.password, {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(Me)
-      assert.eql(Me, deadline)
-    })
-  },
-  'belongsTo': function() {
-    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(beforeExit) {
-    var s2 = new Sequelize(config.database, config.username, config.password, {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_old/Table/basics.js

-var Sequelize = require(__dirname + "/../../lib/sequelize/Sequelize").Sequelize
-  , config    = require(__dirname + '/../config')
-  , s         = new Sequelize(config.database, config.username, config.password, {disableLogging: true})
-  , Day       = s.define('Day', { name: Sequelize.TEXT })
-  , assert    = require("assert")
-
-module.exports = {
-  'constructor': function() {
-    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() {
-    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(beforeExit) {
-    var toBeTested = null
-    Day.sync(function(_Day) { toBeTested = _Day })
-    beforeExit(function() { assert.eql(toBeTested, Day) })
-  },
-  'drop should return the table class': function(beforeExit) {
-    var toBeTested = null
-    Day.drop(function(_Day) { toBeTested = _Day })
-    beforeExit(function() { assert.eql(toBeTested, Day) })
-  },
-  'sqlResultToObject returns the correct object': function() {
-    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.equal(s.define('Identifier', {}).identifier, 'identifierId')
-  },
-  'values': function() {
-    var day = new Day({name: 's'})
-    assert.eql(day.values, { name: "s", createdAt: null, updatedAt: null})
-  },
-  'default values': function() {
-    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_old/Table/databaseAccess.js

-var Sequelize = require(__dirname + "/../../lib/sequelize/Sequelize").Sequelize
-  , config    = require(__dirname + '/../config')
-  , s         = new Sequelize(config.database, config.username, config.password, {disableLogging: true})
-  , Day       = s.define('Day', { name: Sequelize.TEXT })
-  , assert    = require("assert")
-
-module.exports = {
- 'save should set the id of a newly created object': function(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(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(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(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(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(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_old/Table/fetchAssociations.js

-var Sequelize = require(__dirname + "/../../lib/sequelize/Sequelize").Sequelize
-  , config = require(__dirname + '/../config')
-  , s      = new Sequelize(config.database, config.username, config.password, {disableLogging: true})
-  , Foo    = s.define('Foo', { name: Sequelize.TEXT })
-  , Bar    = s.define('Bar', { nr: Sequelize.INTEGER })
-  , assert = require("assert")
-
-module.exports = {
-  'should have no fetchedAssociations first': function(beforeExit) {
-    var allowExit = false
-    
-    Foo.hasMany('bars', Bar, 'foos')
-    Sequelize.chainQueries({drop: s}, {sync: s}, function() {
-      new Foo({name:'asd'}).save(function(foo) {
-        assert.eql(foo.fetchedAssociations, {})
-        allowExit = true
-      })
-    })
-
-    beforeExit(function() { assert.eql(allowExit, true) })
-  },
-
-  'should have an empty array for each table association': function(beforeExit) {
-    var allowExit = false
-
-    Foo.hasMany('bars', Bar, 'foos')
-    Sequelize.chainQueries({drop: s}, {sync: s}, function() {
-      new Foo({name:'asd'}).save(function(foo) {
-        foo.fetchAssociations(function() {
-          assert.eql(foo.fetchedAssociations, {bars: []})
-          allowExit = true
-        })
-      })
-    })
-
-    beforeExit(function() { assert.eql(allowExit, true) })
-  }
-}
\ No newline at end of file

test_old/Table/finder.js

-var Sequelize = require(__dirname + "/../../lib/sequelize/Sequelize").Sequelize
-  , config    = require(__dirname + '/../config')
-  , s         = new Sequelize(config.database, config.username, config.password, {disableLogging: true})
-  , Day       = s.define('Day', { name: Sequelize.TEXT })
-  , assert    = require("assert")
-  
-module.exports = {
-  'findAll should return all items as class objects': function(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(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(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(Me)
-      assert.equal(Me.title, 'a title')
-      assert.equal(Me.content, 'a content')
-    })
-  }
-}
\ No newline at end of file

test_old/Table/prepareAssociations.js

-var Sequelize = require(__dirname + "/../../lib/sequelize/Sequelize").Sequelize
-  , config    = require(__dirname + '/../config')
-  , s         = new Sequelize(config.database, config.username, config.password, {disableLogging: true})
-  , Day       = s.define('Day', { name: Sequelize.TEXT })
-  , assert    = require("assert")
-  
-module.exports = {
- 'prepareAssociations belongsTo': function() {
-    var s = new Sequelize(config.database, config.username, config.password, {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() {
-    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

test_old/config.js

-module.exports = {
-  username: 'root',
-  password: 'root',
-  database: 'sequelize_test'
-}
\ No newline at end of file