@typetron/framework 0.5.20 → 0.5.22

package/tests/Cache/FileStoreTest.ts

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

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

@@ -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)
+            )
+        `)
+    }
+}