@typetron/framework 0.5.22 → 0.5.24

package/tests/Cache/FileStoreTest.ts

@@ -1,93 +0,0 @@
-import { suite, test } from '@testdeck/mocha'
-import { FileStore } from '@Typetron/Cache'
-import { Storage } from '@Typetron/Storage'
-import { expect } from 'chai'
-
-const directory = './tests/Cache/.cache'
-
-@suite
-class FileStoreTest {
-    storage = new Storage()
-    fileStore = new FileStore(this.storage, directory)
-
-    static async after() {
-        const storage = new Storage()
-        if (await storage.exists(directory)) {
-            await storage.deleteDirectory(directory)
-        }
-    }
-
-    @test
-    async returnsUndefinedIfKeyDoesNotExist() {
-        const value = await this.fileStore.get('nonexistentKey')
-        expect(value).to.be.undefined
-    }
-
-    @test
-    async canStoreAndRetrieveData() {
-        await this.fileStore.set('testKey', 'testValue')
-        const value = await this.fileStore.get('testKey')
-        expect(value).to.equal('testValue')
-    }
-
-    @test
-    async canDeleteData() {
-        await this.fileStore.set('testKey', 'testValue')
-        await this.fileStore.delete('testKey')
-        const value = await this.fileStore.get('testKey')
-        expect(value).to.be.undefined
-    }
-
-    @test
-    async canFlushAllData() {
-        await this.fileStore.set('key1', 'value1')
-        await this.fileStore.set('key2', 'value2')
-        await this.fileStore.flush()
-        const value1 = await this.fileStore.get('key1')
-        const value2 = await this.fileStore.get('key2')
-        expect(value1).to.be.undefined
-        expect(value2).to.be.undefined
-    }
-
-    @test
-    async respectsExpiration() {
-        await this.fileStore.set('expiringKey', 'expiringValue', 0.01)
-        await new Promise(resolve => setTimeout(resolve, 11))
-        const value = await this.fileStore.get('expiringKey')
-        expect(value).to.be.undefined
-    }
-
-    @test
-    async canCheckIfKeyExists() {
-        await this.fileStore.set('testKey', 'testValue')
-        const exists = await this.fileStore.has('testKey')
-        expect(exists).to.be.true
-        const nonExistent = await this.fileStore.has('nonexistentKey')
-        expect(nonExistent).to.be.false
-    }
-
-    @test
-    async canRememberValue() {
-        const value = await this.fileStore.remember('rememberKey', 'rememberValue', 0.01)
-        expect(value).to.equal('rememberValue')
-        await new Promise(resolve => setTimeout(resolve, 11))
-        const expiredValue = await this.fileStore.get('rememberKey')
-        expect(expiredValue).to.be.undefined
-    }
-
-    @test
-    async getMethodCanAcceptNonFunctionAndFunctionAsDefaultValue() {
-        const value1 = await this.fileStore.get('nonexistentKey', 'defaultValue')
-        expect(value1).to.equal('defaultValue')
-        const value2 = await this.fileStore.get('nonexistentKey', () => 'defaultValue')
-        expect(value2).to.equal('defaultValue')
-    }
-
-    @test
-    async rememberMethodCanAcceptNonFunctionAndFunctionAsDefaultValue() {
-        const value1 = await this.fileStore.remember('nonexistentKey', 'defaultValue', 0.01)
-        expect(value1).to.equal('defaultValue')
-        const value2 = await this.fileStore.remember('nonexistentKey2', () => 'defaultValue', 0.01)
-        expect(value2).to.equal('defaultValue')
-    }
-}

package/tests/Cache/MemoryStoreTest.ts

@@ -1,92 +0,0 @@
-import { suite, test } from '@testdeck/mocha'
-import { MemoryStore } from '@Typetron/Cache'
-import { expect } from 'chai'
-
-@suite
-class MemoryStoreTest {
-    memoryStore = new MemoryStore()
-
-    @test
-    async returnsUndefinedIfKeyDoesNotExist() {
-        const value = await this.memoryStore.get('nonexistentKey')
-        expect(value).to.be.undefined
-    }
-
-    @test
-    async canStoreAndRetrieveData() {
-        await this.memoryStore.set('testKey', 'testValue')
-        expect(this.memoryStore.cache.has('testKey')).to.be.true
-        const value = await this.memoryStore.get('testKey')
-        expect(value).to.equal('testValue')
-    }
-
-    @test
-    async canDeleteData() {
-        await this.memoryStore.set('testKey', 'testValue')
-        await this.memoryStore.delete('testKey')
-        const value = await this.memoryStore.get('testKey')
-        expect(value).to.be.undefined
-    }
-
-    @test
-    async canFlushAllData() {
-        await this.memoryStore.set('key1', 'value1')
-        await this.memoryStore.set('key2', 'value2')
-        await this.memoryStore.flush()
-        const value1 = await this.memoryStore.get('key1')
-        const value2 = await this.memoryStore.get('key2')
-        expect(value1).to.be.undefined
-        expect(value2).to.be.undefined
-    }
-
-    @test
-    async respectsExpiration() {
-        await this.memoryStore.set('expiringKey', 'expiringValue', 0.01)
-        await new Promise(resolve => setTimeout(resolve, 11))
-        const value = await this.memoryStore.get('expiringKey')
-        expect(value).to.be.undefined
-    }
-
-    @test
-    async canCheckIfKeyExists() {
-        await this.memoryStore.set('testKey', 'testValue')
-        const exists = await this.memoryStore.has('testKey')
-        expect(exists).to.be.true
-        const nonExistent = await this.memoryStore.has('nonexistentKey')
-        expect(nonExistent).to.be.false
-    }
-
-    @test
-    async canRememberValue() {
-        const value = await this.memoryStore.remember('rememberKey', 'rememberValue', 0.01)
-        expect(value).to.equal('rememberValue')
-        expect(this.memoryStore.cache.has('rememberKey')).to.be.true
-        await new Promise(resolve => setTimeout(resolve, 11))
-        const expiredValue = await this.memoryStore.get('rememberKey')
-        expect(expiredValue).to.be.undefined
-    }
-
-    @test
-    async getMethodCanAcceptNonFunctionAndFunctionAsDefaultValue() {
-        // Non-function default value
-        const value1 = await this.memoryStore.get('nonexistentKey', 'defaultValue')
-        expect(value1).to.equal('defaultValue')
-
-        // Function default value
-        const value2 = await this.memoryStore.get('nonexistentKey', () => 'defaultValue')
-        expect(value2).to.equal('defaultValue')
-    }
-
-    @test
-    async rememberMethodCanAcceptNonFunctionAndFunctionAsDefaultValue() {
-        // Non-function default value
-        const value1 = await this.memoryStore.remember('nonexistentKey', 'defaultValue', 0.01)
-        expect(value1).to.equal('defaultValue')
-        expect(this.memoryStore.cache.has('nonexistentKey')).to.be.true
-
-        // Function default value
-        const value2 = await this.memoryStore.remember('nonexistentKey2', () => 'defaultValue', 0.01)
-        expect(value2).to.equal('defaultValue')
-        expect(this.memoryStore.cache.has('nonexistentKey2')).to.be.true
-    }
-}

package/tests/Container/ContainerTest.ts

@@ -1,336 +0,0 @@
-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

@@ -1,100 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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)
-            )
-        `)
-    }
-}