@typetron/framework 0.5.3 → 0.5.4

package/tests/Container/ContainerTest.ts

@@ -0,0 +1,336 @@
+import { expect } from 'chai'
+import { suite, test } from '@testdeck/mocha'
+import { BaseResolver, Container, Inject, Injectable, Scope } from '../../Container'
+import { ServiceIdentifier } from '../../Container/Contracts'
+
+@suite
+class ContainerTest {
+    @test
+    givesSingletonContainer() {
+        const container = Container.getInstance()
+        expect(container).instanceOf(Container)
+        expect(Container.getInstance()).to.be.equal(container)
+        expect(Container.getInstance()).instanceOf(Container)
+    }
+
+    @test
+    overwritesSingletonContainer() {
+        const container = Container.setInstance(new Container)
+        expect(container).equal(Container.getInstance())
+        const container2 = new Container
+        Container.setInstance(container2)
+        expect(container).not.equal(Container.getInstance())
+        expect(container2).equal(Container.getInstance())
+    }
+
+    @test
+    createsInstance() {
+        const container = new Container()
+
+        @Injectable()
+        class Request {}
+
+        expect(container.get(Request)).instanceOf(Request)
+    }
+
+    // @test
+    // bindsCallbacks() {
+    //     class Dependency {}
+    //
+    //     const container = new Container;
+    //
+    //     @Injectable() // not possible right now
+    //     function myFunction(dependency: Dependency) {
+    //         return dependency;
+    //     };
+    //     expect(container.call(myFunction())).to.be.instanceOf(Dependency);
+    // }
+
+    @test
+    singletonScope() {
+        class Request {}
+
+        const container = new Container()
+        const request = container.get(Request)
+        expect(request).to.be.equal(container.get(Request))
+    }
+
+    @test
+    transientScope() {
+        @Injectable(Scope.TRANSIENT)
+        class Request {}
+
+        const container = new Container()
+        const request1 = container.get(Request)
+        const request2 = container.get(Request)
+        expect(request1).not.to.be.equal(request2)
+    }
+
+    @test
+    requestScope() {
+        @Injectable(Scope.REQUEST)
+        class Request {}
+
+        const container = new Container()
+        const childContainer = container.createChildContainer()
+        const request = childContainer.get(Request)
+        expect(container.getInstances().size).to.be.equal(0)
+        expect(childContainer.getInstances().size).to.be.equal(2)
+        expect(request).to.be.instanceof(Request)
+    }
+
+    // @test
+    // requestScopeWithSingletonDependencyFromParenContainer() {
+    //     @Injectable(Scope.REQUEST)
+    //     class Request {}
+    //
+    //     class Controller {
+    //         @Inject()
+    //         request: Request;
+    //     }
+    //
+    //     const container = new Container();
+    //     const childContainer = container.createChildContainer();
+    //     const controller = childContainer.get(Controller);
+    //     expect(Object.values(container.getInstances())).to.have.length(0);
+    //     expect(Object.values(childContainer.getInstances())).to.have.length(1);
+    //     expect(Object.values(childContainer.getInstances())[0]).to.be.instanceof(Request);
+    // }
+
+    @test
+    bindsStringToImplementation() {
+        @Injectable(Scope.TRANSIENT)
+        class Request {}
+
+        const container = new Container()
+        const request = container.get(Request)
+        container.set('request', request)
+
+        expect(request).to.be.equal(container.get('request'))
+    }
+
+    @test
+    bindsImplementationsWithTheSameName() {
+        const namespaceA = {
+            Request: class Request {}
+        }
+        const namespaceB = {
+            Request: class Request {}
+        }
+        const namespaceC = {
+            Request: class Request {}
+        }
+
+        const container = new Container()
+        const requestA = container.get(namespaceA.Request)
+        const requestB = container.get(namespaceB.Request)
+        const requestC = container.get(namespaceC.Request)
+        expect(requestA).to.be.instanceOf(namespaceA.Request)
+        expect(requestB).to.be.instanceOf(namespaceB.Request)
+        expect(requestC).to.be.instanceOf(namespaceC.Request)
+    }
+
+    @test
+    bindsClassToInterface() {
+        abstract class StorageInterface {}
+
+        class DiskStorage implements StorageInterface {}
+
+        class CloudStorage implements StorageInterface {}
+
+        const container = new Container()
+        container.set(StorageInterface, new DiskStorage)
+        expect(container.get(StorageInterface)).to.be.instanceOf(DiskStorage)
+        container.set(StorageInterface, new CloudStorage())
+        expect(container.get(StorageInterface)).to.be.instanceOf(CloudStorage)
+    }
+
+    @test
+    throwsExceptionIfCannotResolve() {
+        const container = new Container
+        expect(() => container.get('DoesNotExist')).to.throw(`No instance found for 'DoesNotExist'`)
+    }
+
+    @test
+    throwsExceptionIfCannotFindAnAbstractName() {
+        const container = new Container
+        const x = {} as typeof Container
+        expect(() => container.get(x)).to.throw(`Cannot get abstract name for ${x}`)
+    }
+
+    @test
+    resolvesDependenciesFromClassProperties() {
+        const container = new Container()
+
+        @Injectable()
+        class UserRepository {
+        }
+
+        @Injectable()
+        class AuthService {
+            @Inject()
+            userRepository: UserRepository
+        }
+
+        @Injectable()
+        class UserController {
+            @Inject()
+            authService: AuthService
+        }
+
+        const userController = container.get(UserController)
+        expect(userController).instanceOf(UserController)
+        expect(userController.authService).instanceOf(AuthService)
+        expect(userController.authService.userRepository).instanceOf(UserRepository)
+    }
+
+    @test
+    resolvesDependenciesFromConstructorParameters() {
+        const container = new Container
+
+        @Injectable()
+        class UserRepository {
+        }
+
+        @Injectable()
+        class AuthService {
+            constructor(public userRepository: UserRepository) {
+            }
+        }
+
+        @Injectable()
+        class UserController {
+            constructor(public authService: AuthService) {
+            }
+        }
+
+        const userController = container.get(UserController)
+        expect(userController).instanceOf(UserController)
+        expect(userController.authService).instanceOf(AuthService)
+        expect(userController.authService.userRepository).instanceOf(UserRepository)
+    }
+
+    // @test
+    // async throwsExceptionIfDependencyCannotBeResolved() {
+    //     const container = new Container;
+    //
+    //     @Injectable()
+    //     class UserController {
+    //         constructor(public userRepository: object) {
+    //         }
+    //     }
+    //
+    //     await expect(() => container.get(UserController)).to.throw(`No binding found for parameter 0 in 'UserController'`);
+    // }
+
+    @test
+    createsChildContainer() {
+        const container = new Container()
+        const childContainer = container.createChildContainer()
+        expect(childContainer).to.be.instanceOf(Container)
+        expect(childContainer).not.to.equal(container)
+    }
+
+    @test
+    childContainerGetsObjectFromParentContainer() {
+        class Storage {}
+
+        const container = new Container()
+        const childContainer = container.createChildContainer()
+
+        const storage = container.get(Storage)
+        expect(childContainer.get(Storage)).to.equal(storage)
+    }
+
+    @test
+    dependenciesHaveTheScopeSingleton() {
+        class Request {}
+
+        const container = new Container()
+        const childContainer = container.createChildContainer()
+
+        const request = childContainer.get(Request)
+        expect(childContainer.get(Request)).to.equal(request)
+    }
+
+    @test
+    async resolvesAsyncDependencies() {
+        class User {}
+
+        class Request {
+            @Inject()
+            user: User
+        }
+
+        class UserResolver extends BaseResolver {
+            canResolve<T>(abstract: ServiceIdentifier<T>): boolean {
+                return abstract === User
+            }
+
+            async resolve<T>(abstract: ServiceIdentifier<T>, parameters: object[]): Promise<T> {
+                await new Promise(resolve => setTimeout(resolve, 1))
+                return new User as T
+            }
+        }
+
+        const container = new Container()
+        container.resolvers.unshift(new UserResolver(container))
+
+        const request = container.get(Request)
+        expect(request).to.be.instanceof(Promise)
+        const resolvedRequest = await container.get(Request)
+        expect(resolvedRequest).to.be.instanceof(Request)
+    }
+
+    @test
+    async injectsDependencyUsingStringAlias() {
+        class SomeClass {
+            @Inject('theCode')
+            code: number
+        }
+
+        const container = new Container()
+        container.set('theCode', 123)
+
+        const instance = container.get(SomeClass)
+
+        expect(instance.code).to.be.equal(123)
+
+    }
+
+    // @test
+    // async customDecorators() {
+    //     class Database {
+    //         debug = false;
+    //
+    //         async init() {
+    //             this.debug = true;
+    //         }
+    //     }
+    //
+    //     function CustomDecorator() {
+    //         return function (target: Object, targetKey: string) {
+    //             // @ts-ignore
+    //             console.log('thi ->', this);
+    //             const metadata = InjectableMetadata.get(target.constructor);
+    //             metadata.dependencies[targetKey] = AuthUserIdentifier;
+    //             metadata.scope = Scope.REQUEST;
+    //             InjectableMetadata.set(metadata, target.constructor);
+    //         };
+    //         // return Container.createPropertyDecorator(container => {
+    //         //
+    //         // });
+    //     }
+    //
+    //     class Controller {
+    //         @CustomDecorator()
+    //         database: Database;
+    //     }
+    //
+    //     const container = new Container();
+    //     const controller = await container.get(Controller);
+    //
+    //     expect(controller.database).to.be.instanceof(Database);
+    //     expect(controller.database.debug).to.equal(true);
+    // }
+}

package/tests/Database/Drivers/MySQL/AlterTest.ts

@@ -0,0 +1,100 @@
+import { suite, test } from '@testdeck/mocha'
+import { expectQuery } from '@Typetron/tests/Database/utils'
+import { AddColumn, AddConstraint, Alter, Constraints, DropColumn, ModifyColumn } from '@Typetron/Database/Drivers/MySQL/Alter'
+
+@suite
+class AlterTest {
+
+    @test
+    async addColumn() {
+        const addAge = new AddColumn({
+            name: 'age',
+            type: 'integer',
+        })
+        const statement = new Alter('test', [addAge])
+        expectQuery(statement).toEqual('ALTER TABLE test ADD age integer')
+    }
+
+    @test
+    async addPrimaryKeyColumn() {
+        const addAge = new AddColumn({
+            name: 'age',
+            type: 'integer',
+        })
+        const statement = new Alter('test', [addAge])
+        expectQuery(statement).toEqual('ALTER TABLE test ADD age integer')
+    }
+
+    @test
+    async dropColumn() {
+        const age = new DropColumn('age')
+        const statement = new Alter('test', [age])
+        expectQuery(statement).toEqual('ALTER TABLE test DROP COLUMN age')
+    }
+
+    @test
+    async ModifyColumn() {
+        const age = new ModifyColumn({
+            name: 'age',
+            type: 'integer',
+        })
+        const statement = new Alter('test', [age])
+        expectQuery(statement).toEqual('ALTER TABLE test MODIFY age integer')
+    }
+
+    @test
+    async ModifyColumnWithAutoIncrement() {
+        const age = new ModifyColumn({
+            name: 'age',
+            type: 'integer',
+            autoIncrement: 1
+        })
+        const statement = new Alter('test', [age])
+        expectQuery(statement).toEqual('ALTER TABLE test MODIFY age integer AUTO_INCREMENT')
+    }
+
+    @test
+    async addPrimaryKeyConstraint() {
+        const age = new AddConstraint({
+            name: 'age',
+            type: 'integer',
+        }, Constraints.PrimaryKey)
+        const statement = new Alter('test', [age])
+        expectQuery(statement).toEqual('ALTER TABLE test ADD CONSTRAINT PRIMARY KEY (age)')
+    }
+
+    @test
+    async addForeignKeyConstraint() {
+        const age = new AddConstraint({
+            name: 'age',
+            type: 'integer',
+        }, Constraints.ForeignKey)
+        const statement = new Alter('test', [age])
+        expectQuery(statement).toEqual('ALTER TABLE test ADD CONSTRAINT FOREIGN KEY (age)')
+    }
+
+    @test
+    async altersMultipleColumns() {
+        const addAge = new AddColumn({
+            name: 'age',
+            type: 'integer',
+        })
+        const dropName = new DropColumn('age')
+        const dropTitle = new DropColumn('title')
+
+        const addAddress = new AddColumn({
+            name: 'address',
+            type: 'varchar(255)',
+        })
+        const statement = new Alter('test', [addAge, dropName, dropTitle, addAddress])
+        expectQuery(statement).toEqual(`
+            ALTER TABLE test
+                ADD age integer,
+            DROP
+            COLUMN age,
+                DROP
+            COLUMN title,
+                ADD address varchar(255)
+        `)
+    }
+}

package/tests/Database/Drivers/MySQL/CreateTest.ts

@@ -0,0 +1,39 @@
+import { suite, test } from '@testdeck/mocha'
+import { Create } from '@Typetron/Database/Drivers/MySQL/Create'
+import { expectQuery } from '@Typetron/tests/Database/utils'
+
+@suite
+class CreateTest {
+
+    @test
+    async createsEmptyTable() {
+        const statement = new Create('test')
+        expectQuery(statement).toEqual('CREATE TABLE test ( )')
+    }
+
+    @test
+    async createsTableWithIntegerColumn() {
+        const statement = new Create('test', [{
+            name: 'age',
+            type: 'integer',
+        }])
+        expectQuery(statement).toEqual('CREATE TABLE test ( age integer )')
+    }
+
+    @test
+    async createsTableWithPrimaryAutoIncrementColumn() {
+        const statement = new Create('test', [{
+            name: 'id',
+            type: 'integer',
+            primaryKey: true,
+            autoIncrement: 1
+        }])
+        expectQuery(statement).toEqual(`
+            CREATE TABLE test
+            (
+                id integer AUTO_INCREMENT,
+                PRIMARY KEY (id)
+            )
+        `)
+    }
+}

package/tests/Database/Drivers/MysqlDriverTest.ts

@@ -0,0 +1,140 @@
+import { suite, test } from '@testdeck/mocha'
+import { BelongsTo, Column, Entity, HasOne, ID, MysqlDriver, Options, PrimaryColumn, Relation } from '@Typetron/Database'
+import { anyString, instance, mock, when } from 'ts-mockito'
+import { Schema } from '@Typetron/Database/Drivers/MySQL/Schema'
+import { expectQuery } from '../utils'
+import { DatabaseDriver } from '@Typetron/Database/Drivers/DatabaseDriver'
+
+@suite
+class MysqlDriverTest {
+
+    driver: DatabaseDriver
+    schema: Schema
+    query: string
+
+    async before() {
+        this.driver = mock(MysqlDriver)
+        this.schema = new Schema(instance(this.driver))
+        when(this.driver.run(anyString())).thenCall((query: string) => this.query = query)
+    }
+
+    @test
+    async createsEmptyTable() {
+        @Options()
+        class Test extends Entity {}
+
+        await this.schema.synchronize([Test].pluck('metadata'))
+        expectQuery(this.query).toEqual('CREATE TABLE test ( )')
+    }
+
+    @test
+    async createsTableWithIntegerColumn() {
+        class Test extends Entity {
+            @Column()
+            age: number
+        }
+
+        await this.schema.synchronize([Test].pluck('metadata'))
+        expectQuery(this.query).toEqual('CREATE TABLE test ( age integer )')
+    }
+
+    @test
+    async createsTableWithPrimaryAutoIncrementColumn() {
+        class Test extends Entity {
+            @PrimaryColumn()
+            id: ID
+        }
+
+        await this.schema.synchronize([Test].pluck('metadata'))
+        expectQuery(this.query).toEqual(`
+            CREATE TABLE test
+            (
+                id integer AUTO_INCREMENT,
+                PRIMARY KEY (id)
+            )
+        `)
+    }
+
+    @test
+    async createsTableWithForeignColumn() {
+        class User extends Entity {
+            @Column()
+            @Relation(() => Image, 'user')
+            image: HasOne<Image>
+        }
+
+        class Image extends Entity {
+            @Column()
+            @Relation(() => User, 'image')
+            user: BelongsTo<User>
+        }
+
+        await this.schema.synchronize([Image].pluck('metadata'))
+        expectQuery(this.query).toEqual(`
+            CREATE TABLE image
+            (
+                userId integer
+            )
+        `)
+    }
+
+    @test
+    async altersTable() {
+        when(this.driver.tableExists(anyString())).thenReturn(Promise.resolve(true))
+        when(this.driver.tableColumns(anyString())).thenReturn(Promise.resolve([
+            {
+                name: 'column2',
+                type: 'integer'
+            },
+            {
+                name: 'column3',
+                type: 'integer'
+            },
+        ]))
+
+        class User extends Entity {
+            @Column()
+            column1: number
+
+            @Column()
+            column2: string
+        }
+
+        await this.schema.synchronize([User].pluck('metadata'))
+
+        expectQuery(this.query).toEqual(`
+            ALTER TABLE user
+                ADD column1 integer,
+            MODIFY column2 varchar(255),
+            DROP
+            COLUMN column3
+        `)
+    }
+
+    @test
+    async altersTableAddPrimaryKey() {
+        when(this.driver.tableExists(anyString())).thenReturn(Promise.resolve(true))
+        when(this.driver.tableColumns(anyString())).thenReturn(Promise.resolve([]))
+
+        class User extends Entity {
+            @PrimaryColumn()
+            id: ID
+        }
+
+        const queries: string[] = []
+        when(this.driver.run(anyString())).thenCall((query: string) => queries.push(query))
+
+        await this.schema.synchronize([User].pluck('metadata'))
+
+        expectQuery(queries[0]).toEqual(`
+            ALTER TABLE user
+                ADD id integer
+        `)
+
+        expectQuery(queries[1]).toEqual(`
+            ALTER TABLE user
+                ADD CONSTRAINT PRIMARY KEY (id),
+                MODIFY id integer AUTO_INCREMENT
+        `)
+    }
+}