@typetron/framework 0.5.2 → 0.5.3

package/tests/Database/EntityRelationshipsTest.ts

@@ -1,475 +0,0 @@
-import { suite, test } from '@testdeck/mocha'
-import { Connection, Entity, EntityConstructor, Query, SqliteDriver } from '../../Database'
-import { User } from './Entities/User'
-import { Article } from './Entities/Article'
-import { Role } from './Entities/Role'
-import { Profile } from './Entities/Profile'
-import { expect } from 'chai'
-import { BelongsTo, BelongsToMany, HasMany, HasOne } from '../../Database/Fields'
-
-@suite
-class EntityRelationshipsTest {
-    joe = {
-        name: 'Joe',
-        email: 'joe@example.com',
-    }
-
-    doe = {
-        name: 'Doe',
-        email: 'doe@example.com',
-    }
-
-    admin = {
-        name: 'Admin'
-    }
-    developer = {
-        name: 'Developer'
-    }
-
-    async before() {
-        Query.connection = new Connection(new SqliteDriver(':memory:'))
-        // Query.connection = new Connection(new MysqlDriver({
-        //     host: 'localhost', user: 'root', password: 'root', database: 'typetron_test'
-        // }))
-        await Query.connection.driver.schema.synchronize([User, Profile, Article, Role].pluck('metadata'))
-    }
-
-    async after() {
-        for await (const entity of [User, Profile, Article, Role]) {
-            await (entity as EntityConstructor<Entity>).truncate()
-        }
-
-        await Query.table('role_users').truncate()
-    }
-
-    @test
-    async hydratesEntityWithRelationships() {
-        const user = new User()
-
-        expect(user).to.haveOwnProperty('profile')
-        expect(user.profile).to.be.instanceOf(HasOne)
-        expect(user).to.haveOwnProperty('articles')
-        expect(user.articles).to.be.instanceOf(HasMany)
-        expect(user).to.haveOwnProperty('roles')
-        expect(user.roles).to.be.instanceOf(BelongsToMany)
-    }
-
-    @test
-    async hasOneSave() {
-        const user = await User.create(this.joe)
-
-        const profile = new Profile().fill({
-            address: 'address'
-        })
-        await user.profile.save(profile)
-
-        expect(user.profile.get()?.id).to.be.equal(profile.id)
-        expect(user.profile.get()?.user.get()?.id).to.be.equal(user.id)
-        expect(await Profile.first()).to.be.instanceOf(Profile)
-    }
-
-    @test
-    async hasOneLoad() {
-        const user = await User.create(this.joe)
-
-        const profile = new Profile().fill({
-            address: 'address'
-        })
-        await user.profile.save(profile)
-
-        const sameUser = await User.findOrFail(user.id)
-        expect(sameUser.profile).to.be.instanceOf(HasOne)
-        expect(sameUser.profile.get()).to.be.equal(undefined)
-        await sameUser.load('profile')
-
-        expect(sameUser.profile.get()?.id).to.be.equal(user.profile.get()?.id)
-        expect(sameUser.profile.get()?.address).to.be.equal('address')
-    }
-
-    @test
-    async hasOneEagerLoad() {
-        const user = await User.create(this.joe)
-
-        const profile = new Profile().fill({
-            address: 'address'
-        })
-        await user.profile.save(profile)
-
-        const sameUser = await User.with('profile').where('id', user.id).first() as User
-        expect(sameUser.profile.get()).to.deep.include({
-            id: profile.id,
-            address: 'address'
-        })
-    }
-
-    @test
-    async hasManySave() {
-        const user = await User.create(this.joe)
-
-        const article = new Article().fill({
-            title: 'title',
-            content: 'content',
-        })
-        await user.articles.save(article)
-
-        expect(user.articles).to.have.length(1)
-        expect(user.articles[0]).to.deep.include({
-            id: article.id,
-            title: 'title',
-            content: 'content',
-        })
-    }
-
-    @test
-    async hasManySaveUsingPlainObject() {
-        const user = await User.create(this.joe)
-
-        await user.articles.save({
-            title: 'title',
-            content: 'content',
-        } as Article)
-
-        expect(user.articles).to.have.length(1)
-        expect(user.articles[0]).to.deep.include({
-            title: 'title',
-            content: 'content',
-        })
-    }
-
-    @test
-    async hasManySaveUsingSaveOnUnsavedParent() {
-        const user = new User().fill(this.joe)
-
-        await user.articles.save(new Article().fill({
-            title: 'title',
-            content: 'content',
-        }))
-
-        expect(user.articles).to.have.length(1)
-        expect(user.articles[0]).to.deep.include({
-            title: 'title',
-            content: 'content',
-        })
-    }
-
-    @test
-    async hasManyLoad() {
-        const user = await User.create(this.joe)
-        await Article.create({
-            title: 'title',
-            content: 'content',
-            author: user
-        })
-
-        await user.load('articles')
-        expect(user.articles).to.be.instanceOf(HasMany)
-        expect(user.articles[0]).to.deep.include({
-            title: 'title',
-            content: 'content',
-        })
-    }
-
-    @test
-    async hasManyGet() {
-        const user = await User.create(this.joe)
-        const article = new Article().fill({
-            title: 'title',
-            content: 'content',
-        })
-        await user.articles.save(article)
-        await user.articles.load()
-        expect(user.articles[0]).to.deep.include({
-            title: 'title',
-            content: 'content',
-        })
-    }
-
-    @test
-    async hasManyEagerLoad() {
-        const user = new User().fill(this.joe)
-        const article = new Article().fill({
-            title: 'title',
-            content: 'content',
-        })
-        await user.articles.save(article)
-
-        const sameUser = await User.with('articles').where('id', user.id).first() as User
-        expect(sameUser.articles).to.have.length(1)
-        expect(user.articles[0]).to.deep.include({
-            id: article.id,
-            title: 'title',
-            content: 'content',
-        })
-    }
-
-    @test
-    async hasManyQuery() {
-        const user = await User.create(this.joe)
-        await user.articles.saveMany(
-            {
-                title: 'title',
-                content: 'joe\'s content',
-            },
-            {
-                title: 'other title',
-                content: 'other content',
-            },
-        )
-        const doe = await User.create(this.doe)
-        await doe.articles.save({
-            title: 'title',
-            content: 'doe\'s content',
-        })
-
-        const articles = await user.articles.where('title', 'title').get()
-        expect(articles).to.have.length(1)
-        expect(user.articles[0]).to.deep.include({
-            title: 'title',
-            content: 'joe\'s content',
-        })
-    }
-
-    @test
-    async belongsToSave() {
-        const user = await User.create(this.joe)
-        const article = new Article()
-        await user.articles.save(article)
-
-        expect(user.articles).to.have.length(1)
-        expect(user.articles[0].author).to.be.instanceof(BelongsTo)
-    }
-
-    @test
-    async belongsToEagerLoad() {
-        const user = await User.create(this.joe)
-        const article = new Article()
-        await user.articles.save(article)
-
-        const articles = await Article.with('author').get()
-
-        expect(articles).to.have.length(1)
-        expect(articles[0].author).to.be.instanceof(BelongsTo)
-    }
-
-    @test
-    async belongsToEagerLoadWithCustomQuery() {
-        const joe = await User.create(this.joe)
-        await joe.articles.save(Article.new({title: 'article1'}))
-        await joe.articles.save(Article.new({title: 'article2'}))
-
-        const user = await User.with(['articles', query => query.where('title', 'article1')]).first() as User
-
-        expect(user.articles).to.have.length(1)
-    }
-
-    // @test
-    // async deepBelongsToEagerLoadWithCustomQuery() {
-    //     const admin = await Role.create(this.admin)
-    //
-    //     const joe = await User.create(this.joe)
-    //     await joe.profile.save(new Profile({address: 'south address'}))
-    //     const doe = await User.create(this.doe)
-    //     await doe.profile.save(new Profile({address: 'east address'}))
-    //
-    //     await admin.users.add(joe, doe)
-    //
-    //     const role = await Role.with(['users.profile', query => query.whereLike('address', '%east%')]).first() as Role
-    //
-    //     expect(role.users).to.have.length(1)
-    //     expect(role.users[0].name).to.be.equal(doe.name)
-    // }
-
-    @test
-    async belongsToLoad() {
-        const user = await User.create(this.joe)
-        let article = new Article()
-        await user.articles.save(article)
-
-        article = await Article.findOrFail(article.id)
-        const a = await Article.get()
-        const u = await User.get()
-        await article.load('author')
-
-        expect(article.author).to.be.instanceOf(BelongsTo)
-        expect(article.author.get()).to.be.instanceOf(User)
-    }
-
-    @test
-    async belongsToReLoad() {
-        const user = await User.create(this.joe)
-        const article = new Article()
-        await user.articles.save(article)
-
-        await article.load('author')
-
-        expect(article.author).to.be.instanceOf(BelongsTo)
-        expect(article.author.get()).to.be.instanceOf(User)
-        expect(article.author.get()?.id).to.be.equal(user.id)
-    }
-
-    @test
-    async belongsToManySave() {
-        const user = new User().fill(this.joe)
-
-        const admin = await Role.create(this.admin)
-        const developer = await Role.create(this.developer)
-        await user.roles.add(admin.id, developer.id)
-
-        expect(user.roles).to.have.length(2)
-        expect(user.roles[0].id).to.be.equal(admin.id)
-        expect(user.roles[1].id).to.be.equal(developer.id)
-    }
-
-    @test
-    async belongsToManyEagerLoad() {
-        const user = await User.create(this.joe)
-
-        const admin = await Role.create(this.admin)
-        const developer = await Role.create(this.developer)
-        await user.roles.add(admin.id, developer.id)
-
-        const sameUser = await User.with('roles').where('id', user.id).first() as User
-
-        expect(sameUser.roles).to.have.length(2)
-        expect(sameUser.roles[0]).to.deep.include({
-            id: admin.id,
-            name: admin.name
-        })
-        expect(sameUser.roles[1]).to.deep.include({
-            id: developer.id,
-            name: developer.name
-        })
-    }
-
-    @test
-    async belongsToManyClearing() {
-        const user = new User().fill(this.joe)
-        const admin = await Role.create(this.admin)
-        const developer = await Role.create(this.developer)
-        await user.roles.add(admin.id, developer.id)
-
-        expect(user.roles).to.have.length(2)
-        await user.roles.clear()
-        expect(user.roles).to.have.length(0)
-    }
-
-    @test
-    async belongsToManyRemove() {
-        const user = new User().fill(this.joe)
-        const admin = await Role.create(this.admin)
-        const developer = await Role.create(this.developer)
-        await user.roles.add(admin.id, developer.id)
-
-        expect(user.roles).to.have.length(2)
-        await user.roles.remove(admin.id)
-        expect(user.roles).to.have.length(1)
-    }
-
-    @test
-    async belongsToManySync() {
-        const user = new User().fill(this.joe)
-        const admin = await Role.create(this.admin)
-        const developer = await Role.create(this.developer)
-        const manager = await Role.create({name: 'Manager'})
-        await user.roles.add(admin.id, manager.id)
-
-        await user.roles.sync(admin.id, developer)
-        expect(user.roles).to.have.length(2)
-        expect(user.roles[0]).to.have.property('id', admin.id)
-        expect(user.roles[1]).to.have.property('id', developer.id)
-    }
-
-    @test
-    async belongsToManySyncWithoutDetaching() {
-        const user = new User().fill(this.joe)
-        const admin = await Role.create(this.admin)
-        const developer = await Role.create(this.developer)
-        const manager = await Role.create({name: 'manager'})
-        await user.roles.add(admin.id, manager.id)
-
-        await user.roles.syncWithoutDetaching(admin.id, developer)
-        expect(user.roles).to.have.length(3)
-        expect(user.roles[0]).to.have.property('id', admin.id)
-        expect(user.roles[1]).to.have.property('id', manager.id)
-        expect(user.roles[2]).to.have.property('id', developer.id)
-    }
-
-    @test
-    async belongsToManyToggle() {
-        const user = new User().fill(this.joe)
-        const admin = await Role.create(this.admin)
-        await user.roles.add(admin.id)
-
-        expect(user.roles).to.have.length(1)
-        expect(user.roles[0]).to.have.property('id', admin.id)
-
-        const developer = await Role.create(this.developer)
-        await user.roles.toggle(admin.id, developer.id)
-
-        expect(user.roles).to.have.length(1)
-        expect(user.roles[0]).to.have.property('id', developer.id)
-    }
-
-    @test
-    async belongsToManyLoad() {
-        const user = new User().fill(this.joe)
-        const admin = await Role.create(this.admin)
-        await user.roles.add(admin.id)
-
-        const sameUser = await User.first() as User
-        await sameUser.load('roles')
-        expect(sameUser.roles[0]).to.deep.include(this.admin)
-    }
-
-    @test
-    async belongsToManyQuery() {
-        const user = new User().fill(this.joe)
-        const admin = await Role.create(this.admin)
-        const developer = await Role.create(this.developer)
-        await user.roles.add(admin.id, developer.id)
-
-        expect(user.roles).to.have.length(2)
-        const roles = await user.roles.where('name', developer.name).get()
-        expect(roles).to.have.length(1)
-        expect(roles[0]).to.deep.include(this.developer)
-    }
-
-    @test
-    async belongsToManyHas() {
-        const user = new User().fill(this.joe)
-        const admin = await Role.create(this.admin)
-        const developer = await Role.create(this.developer)
-        await user.roles.add(admin.id)
-
-        expect(await user.roles.has(admin)).to.be.equal(true)
-        expect(await user.roles.has(developer.id)).to.be.equal(false)
-    }
-
-    @test
-    async nestedEagerLoading() {
-        let user = await User.create(this.joe)
-        await user.articles.save(new Article())
-
-        user = await User.find(user.id) as User
-        await user.load('articles.author')
-
-        expect(user.articles[0].author.get()?.name).to.be.equal(user.name)
-    }
-
-    @test
-    async multipleNestedEagerLoading() {
-        let adminRole = await Role.create({name: 'Admin'})
-        const joe = await User.create(this.joe)
-        await adminRole.users.add(joe)
-        await joe.articles.save(new Article().fill({title: 'title'}))
-        await joe.profile.save(new Profile().fill({address: 'address'}))
-
-        adminRole = await Role.find(adminRole.id) as Role
-        await adminRole.load('users.articles.author', 'users.profile.user')
-
-        expect(adminRole.users[0].articles[0].title).to.be.equal('title')
-        expect(adminRole.users[0].profile.get()?.address).to.be.equal('address')
-        expect(adminRole.users[0].articles[0].author.get()?.name).to.be.equal(joe.name)
-        expect(adminRole.users[0].profile.get()?.user.get()?.name).to.be.equal(joe.name)
-    }
-}

package/tests/Database/EntityTest.ts

@@ -1,202 +0,0 @@
-import { suite, test } from '@testdeck/mocha'
-import { expect } from 'chai'
-import { Connection, Entity, EntityConstructor, Query, SqliteDriver } from '../../Database'
-import { User } from './Entities/User'
-import { EntityQuery } from '../../Database/EntityQuery'
-import { Article } from './Entities/Article'
-import { Role } from './Entities/Role'
-
-@suite
-class EntityTest {
-    joe = {
-        id: 1,
-        name: 'Joe',
-        email: 'joe@example.com',
-    }
-
-    doe = {
-        id: 2,
-        name: 'Doe',
-        email: 'doe@example.com',
-    }
-
-    admin = {
-        id: 1,
-        name: 'Admin'
-    }
-    developer = {
-        id: 1,
-        name: 'Developer'
-    }
-
-    data = {
-        users: [this.joe, this.doe],
-        roles: [this.admin, this.developer],
-    }
-
-    async before() {
-        Query.connection = new Connection(new SqliteDriver(':memory:'))
-        // Query.connection = new Connection(new MysqlDriver({
-        //     host: 'localhost', user: 'root', password: 'root', database: 'typetron_test'
-        // }))
-        await Query.connection.driver.schema.synchronize([User, Article, Role].pluck('metadata'))
-    }
-
-    async after() {
-        for await (const entity of [User, Article, Role]) {
-            await (entity as EntityConstructor<Entity>).truncate()
-        }
-    }
-
-    expectToContain(actual: User, expected: {[key: string]: string | number | Date}) {
-        const keys = Object.keys(expected)
-        keys.forEach(key => {
-            expect(actual).to.have.property(key, expected[key])
-        })
-    }
-
-    @test
-    fillEntityWhenInstantiating() {
-        expect(new User().fill({name: 'Joe'})).to.deep.include({name: 'Joe'})
-    }
-
-    @test
-    getEntityTable() {
-        expect(User.getTable()).to.equal('users')
-        expect((new User()).getTable()).to.equal('users')
-    }
-
-    @test
-    async createsNewQuery() {
-        expect(User.newQuery()).to.be.an.instanceof(EntityQuery)
-        const user = new User()
-        expect(user.newQuery()).to.be.an.instanceof(EntityQuery)
-    }
-
-    @test
-    async getEveryRecord() {
-        await Query.table(User.getTable()).insert([this.joe, this.doe])
-
-        const users = await User.get()
-
-        expect(users).to.have.length(2)
-
-        users.forEach((user, index) => this.expectToContain(user, this.data.users[index]))
-    }
-
-    // @test
-    // async where() {
-    //     const modelMock = mock(User);
-    //     const user = instance(modelMock);
-    //
-    //     const queryMock = mock(EntityQuery);
-    //     verify(queryMock.where('name', 'Joe')).once();
-    //     when(user.newQuery()).thenReturn(instance(queryMock));
-    //
-    //     const users = await User.where('name', 'Joe').get();
-    //
-    //     users.forEach((user, index) => this.expectToContain(user, this.data.users[index]));
-    // }
-    //
-    // @test
-    // async whereIn() {
-    //     when(this.connection.get(anyOfClass(Query))).thenResolve(this.data.users);
-    //
-    //     const users = await User.whereIn('name', ['Joe', 'Doe']).get();
-    //
-    //     users.forEach((user, index) => this.expectToContain(user, this.data.users[index]));
-    // }
-    //
-    @test
-    async save() {
-        const data = {email: 'tester', name: 'Tester'}
-        const user = new User().fill(data)
-
-        this.expectToContain(user, data)
-        expect(user.id).to.be.equal(undefined)
-        await user.save()
-        expect(user.id).to.be.equal(1)
-        expect(user.createdAt).to.be.an.instanceOf(Date)
-        expect(user.updatedAt).to.be.an.instanceOf(Date)
-    }
-
-    @test
-    async insertMany() {
-        await User.insert([this.joe, this.doe])
-
-        const users = await User.get()
-        expect(users).to.have.length(2)
-        this.expectToContain(users[0], this.joe)
-        this.expectToContain(users[1], this.doe)
-    }
-
-    // @test
-    // async test0() {
-    // const users = await User.get();
-    // const users = await User.get('id', 'name');
-    // const user = await User.first('id');
-    // const user = await User.firstOrNew({name: 'John'}, {email: 'john@example.com'});
-    // const user = await User.firstOrCreate({name: 'John'}, {email: 'john@example.com'});
-    // const user = await User.find(1);
-    // const users = await User.with('articles').get();
-    // }
-
-    @test
-    async getSpecificColumns() {
-        await Query.table(User.getTable()).insert([this.joe])
-
-        const users = await User.get('id', 'name')
-
-        expect(users).to.have.length(1)
-        expect(users.first()).to.have.property('name', this.joe.name)
-        expect(users.first()).and.to.have.property('id', this.joe.id)
-
-        // TODO with the new JS updates, the Entity properties are initialized to undefined,
-        //  which means we will always get them in the object and this assert below will fail
-        // But, the actual problem is picking what columns to select.
-        // User.get(col1, col2) will return an User instance with col1 and col2 values but undefined for other columns
-        // This should be invalid because there might be col3 which might be non-optional and should always have a value
-        // expect(users.first()).and.to.not.have.property('email')
-    }
-
-    @test
-    async getFirstRecord() {
-        await Query.table(User.getTable()).insert([this.joe, this.doe])
-
-        const user = await User.first() as User
-
-        this.expectToContain(user, this.joe)
-    }
-
-    @test
-    async getFirstRecordWithSpecificColumns() {
-        await Query.table(User.getTable()).insert([this.joe])
-
-        const user = await User.first('id') as User
-
-        expect(user).to.have.property('id', this.joe.id)
-
-        // TODO this has the same issue as the test `getSpecificColumns`
-        // expect(user).to.not.have.property('name')
-    }
-
-    @test
-    async getFirstRecordOrInstantiateOneIfNot() {
-        const john = await User.firstOrNew({name: 'John'}, {email: 'john@example.com'})
-
-        expect(john).to.have.property('name', 'John')
-        expect(john).to.have.property('email', 'john@example.com')
-        expect(john.id).to.be.undefined
-        expect(await User.get()).to.have.length(0)
-    }
-
-    @test
-    async getFirstRecordOrCreateOneIfNot() {
-        const john = await User.firstOrCreate({name: 'John'}, {email: 'john@example.com'})
-
-        expect(john).to.have.property('name', 'John')
-        expect(john).to.have.property('email', 'john@example.com')
-        expect(john).to.have.property('id')
-        expect(await User.get()).to.have.length(1)
-    }
-}