@typetron/framework 0.4.0-rc9 → 0.5.0

package/tests/Cache/DatabaseStoreTest.ts

@@ -0,0 +1,110 @@
+import { suite, test } from '@testdeck/mocha'
+import { CacheItem, DatabaseStore } from '@Typetron/Cache'
+import { expect } from 'chai'
+import { createHash } from 'crypto'
+import { Connection, Query, SqliteDriver } from '@Typetron/Database'
+import { Storage } from '@Typetron/Storage'
+
+const tableName = 'cache'
+const databaseFilePath = './tests/Cache/database.sqlite'
+
+@suite
+class DatabaseStoreTest {
+
+    databaseStore = new DatabaseStore(tableName)
+
+    static async before() {
+        Query.connection = new Connection(new SqliteDriver(databaseFilePath))
+    }
+
+    static async after() {
+        await new Storage().deleteDirectory(databaseFilePath)
+    }
+
+    private getCacheRecord(name: string) {
+        const cacheKeyHash = createHash('sha1').update(name).digest('hex')
+        return Query.table<CacheItem<unknown>>(tableName).where('name', cacheKeyHash).first()
+    }
+
+    @test
+    async returnsUndefinedIfRecordDoesntExist() {
+        const value = await this.databaseStore.get('tests')
+        expect(value).to.be.undefined
+    }
+
+    @test
+    async testPutCreatesRecord() {
+        const contents = 'test'
+
+        await this.databaseStore.set('foo', contents)
+
+        const cacheRecord = await this.getCacheRecord('foo')
+        expect(cacheRecord).to.exist
+        expect((cacheRecord as CacheItem<any>).value).to.be.equal(JSON.stringify(contents))
+    }
+
+    @test
+    async testExpirationValueIsWrittenInCacheRecord() {
+        const durationInSeconds = 60
+        const expirationTime = Date.now() + durationInSeconds * 1000
+
+        await this.databaseStore.set('expireTest', 'value', durationInSeconds)
+        const cacheRecord = await this.getCacheRecord('expireTest')
+
+        expect(cacheRecord).to.exist
+        expect(new Date((cacheRecord as CacheItem<unknown>).date ?? Infinity).getTime()).to.be.closeTo(expirationTime, 1000) // Allowing a 1-second difference
+    }
+
+    @test
+    async testCacheValueIsUndefinedIfExpired() {
+        const durationInSeconds = -60 // Setting a past expiration
+
+        await this.databaseStore.set('anotherExpiredTest', 'value', durationInSeconds)
+
+        const value = await this.databaseStore.get('anotherExpiredTest')
+        expect(value).to.be.undefined
+
+        const cacheRecord = await this.getCacheRecord('anotherExpiredTest')
+        expect(cacheRecord).to.be.undefined
+    }
+
+    @test
+    async testDeleteMethodDeletesRecordFromDatabase() {
+        await this.databaseStore.set('deleteTest', 'value')
+
+        await this.databaseStore.delete('deleteTest')
+
+        const cacheRecord = await this.getCacheRecord('deleteTest')
+        expect(cacheRecord).to.be.undefined
+    }
+
+    @test
+    async testFlushMethodDeletesAllRecords() {
+        await this.databaseStore.set('flushTest', 'value')
+
+        await this.databaseStore.flush()
+
+        const allRecords = await Query.table(tableName).get()
+        expect(allRecords.length).to.be.equal(0)
+    }
+
+    @test
+    async testRememberMethodCreatesRecordIfNotExists() {
+        const value = await this.databaseStore.remember('rememberTest', 'defaultValue', 60)
+
+        expect(value).to.equal('defaultValue')
+
+        const cacheRecord = await this.getCacheRecord('rememberTest')
+        expect(cacheRecord).to.exist
+        expect((cacheRecord as CacheItem<any>).value).to.be.equal(JSON.stringify('defaultValue'))
+    }
+
+    @test
+    async testRememberMethodReturnsExistingValue() {
+        await this.databaseStore.set('rememberTest2', 'existingValue')
+
+        const value = await this.databaseStore.remember('rememberTest2', 'defaultValue', 60)
+
+        expect(value).to.equal('existingValue')
+    }
+}

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);
+    // }
+}