@typetron/framework 0.5.2 → 0.5.3

package/tests/Database/SchemaTest.ts

@@ -1,32 +0,0 @@
-import { suite, test } from '@testdeck/mocha'
-import { expect } from 'chai'
-import { Connection, Query } from '../../Database'
-import { User } from './Entities/User'
-import { Role } from './Entities/Role'
-import { SqliteDriver } from '@Typetron/Database/Drivers'
-
-@suite
-class SchemaTest {
-
-    async before() {
-        Query.connection = new Connection(new SqliteDriver(':memory:'))
-        // Query.connection = new Connection(new MysqlDriver({
-        //     host: 'localhost', user: 'root', password: 'root', database: 'typetron_test'
-        // }))
-    }
-
-    @test
-    async createsPivotTable() {
-        await Query.connection.driver.schema.synchronize([User, Role].pluck('metadata'))
-
-        const tableName = [User.getTable(), Role.getTable()].sort().join('_')
-        const table = await Query.connection.tableExists(tableName)
-        expect(Boolean(table)).to.be.equal(true, 'Pivot table was not created')
-        const tableColumns = await Query.connection.tableColumns(tableName) as {name: string, type: string}[]
-        expect(tableColumns).to.have.length(2)
-        // expect(tableColumns[0]).to.deep.include({name: 'id', type: 'integer'});
-        expect(tableColumns[0]).to.deep.include({name: 'roleId'})
-        expect(tableColumns[1]).to.deep.include({name: 'userId'})
-    }
-
-}

package/tests/Database/Seeders/RunnerTest.ts

@@ -1,30 +0,0 @@
-import { suite, test } from '@testdeck/mocha'
-import { SeederManager } from '@Typetron/Database/Seeders'
-import { expect } from 'chai'
-import { Connection, Query, SqliteDriver } from '../../../Database'
-import { Storage } from '../../../Storage'
-
-@suite
-class RunnerTest {
-    private runner: SeederManager
-    private seedsPath = './tests/Database/Seeders/seeders'
-
-    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.runRaw('CREATE TABLE random_table (col1 varchar)')
-
-        this.runner = new SeederManager(new Storage(), this.seedsPath)
-    }
-
-    @test
-    async shouldSeed() {
-        await this.runner.seed()
-
-        const result = await Query.table<{ col1: string }>('random_table').first()
-        
-        expect(result?.col1).to.be.equal('val1')
-    }
-}

package/tests/Database/Seeders/seeders/RandomSeeder.ts

@@ -1,10 +0,0 @@
-import { Query } from "@Typetron/Database";
-import { Seeder } from "@Typetron/Database/Seeders";
-
-export class RandomSeeder extends Seeder{
-    public run(): void {
-        Query.table('random_table').insertOne({
-            col1: 'val1'
-        })
-    }
-}

package/tests/Database/utils.ts

@@ -1,16 +0,0 @@
-import { Expression } from '@Typetron/Database'
-import { expect } from 'chai'
-
-export function expectQuery(expression: Expression | string) {
-    const sql = expression instanceof Expression ? expression.toSQL() : expression
-
-    return {
-        toEqual: (expected: string) => {
-            expect(trimSQL(sql)).to.be.equal(trimSQL(expected))
-        }
-    }
-}
-
-export function trimSQL(sql: string) {
-    return sql.replace(/(\r\n|\n|\r)/gm, ' ').replace(/`/gm, '').replace(/  +/g, ' ').trim()
-}

package/tests/Forms/FormsTest.ts

@@ -1,59 +0,0 @@
-import { suite, test } from '@testdeck/mocha'
-import { MinLength, Required } from '../../Validation'
-import { Field, Form, Rules } from '@Typetron/Forms'
-import { expect } from 'chai'
-import { Optional } from '@Typetron/Validation/Rules/Optional'
-
-@suite
-class FormsTest {
-
-    @test
-    validatesFormBasedOnValidators() {
-
-        class UserForm extends Form {
-            @Field()
-            @Rules(Required)
-            name: string
-        }
-
-        const formData = {
-            name: 'John'
-        }
-        const form = new UserForm()
-        form.fill(formData)
-
-        expect(form.valid()).to.be.equal(true)
-    }
-
-    @test
-    showsErrorWhenFormIsInvalid() {
-        class UserForm extends Form {
-            @Field()
-            @Rules(Required)
-            name: string
-        }
-
-        const form = new UserForm()
-
-        expect(form.valid()).to.be.equal(false)
-    }
-
-    @test
-    doesNotGiveErrorForOptionalFieldsThatHaveValidatorsAlready() {
-        class UserForm extends Form {
-            @Field()
-            @Rules(Optional, MinLength(10))
-            name?: string
-        }
-
-        const validForm = new UserForm()
-
-        expect(validForm.valid()).to.be.equal(true)
-
-        const invalidForm = new UserForm()
-        invalidForm.fill({name: ''} as object)
-
-        expect(invalidForm.valid()).to.be.equal(false)
-    }
-
-}

package/tests/Framework/Middleware/StaticAssetsMiddlewareTest.ts

@@ -1,129 +0,0 @@
-import { suite, test } from '@testdeck/mocha'
-import { Container } from '@Typetron/Container'
-import { Handler, Http, Request } from '@Typetron/Router/Http'
-import { expect } from 'chai'
-import { Router } from '@Typetron/Router'
-import { StaticAssetsMiddleware } from '@Typetron/Framework/Middleware/StaticAssetsMiddleware'
-import { AppConfig } from '@Typetron/Framework'
-import * as path from 'path'
-
-@suite
-class StaticAssetsMiddlewareTest {
-
-    @test
-    async 'resolves url to a local directory'() {
-        const container = new Container()
-
-        container.set<Partial<AppConfig>>(AppConfig, {
-            staticAssets: [
-                {
-                    url: 'assets/.*',
-                    path: path.join(__dirname, '')
-                }
-            ]
-        })
-        const router = container.get(Router)
-        router.middleware.http.push(StaticAssetsMiddleware)
-
-        const handler = container.get(Handler)
-        const request = new Request('assets/styles.css', Http.Method.GET)
-        const response = await handler.handle(container, request)
-
-        expect(response.headers['Content-type']).to.be.equal('text/css')
-        expect(String(response.body)).to.contain('color : purple')
-    }
-
-    @test
-    async 'resolves url to a static asset with the exact same name'() {
-        const container = new Container()
-
-        container.set<Partial<AppConfig>>(AppConfig, {
-            staticAssets: [
-                {
-                    url: '.*',
-                    path: path.join(__dirname, 'articles')
-                }
-            ]
-        })
-        const router = container.get(Router)
-        router.middleware.http.push(StaticAssetsMiddleware)
-
-        const handler = container.get(Handler)
-        const request = new Request('my-article.html', Http.Method.GET)
-        const response = await handler.handle(container, request)
-
-        expect(response.headers['Content-type']).to.be.equal('text/html')
-        expect(String(response.body)).to.contain('article')
-    }
-
-    @test
-    async 'resolves url to a static asset returning index file'() {
-        const container = new Container()
-
-        container.set<Partial<AppConfig>>(AppConfig, {
-            staticAssets: [
-                {
-                    url: '.*',
-                    path: path.join(__dirname, 'articles')
-                }
-            ]
-        })
-        const router = container.get(Router)
-        router.middleware.http.push(StaticAssetsMiddleware)
-
-        const handler = container.get(Handler)
-        const request = new Request('some-directory', Http.Method.GET)
-        const response = await handler.handle(container, request)
-
-        expect(response.headers['Content-type']).to.be.equal('text/html')
-        expect(String(response.body)).to.contain('index file')
-    }
-
-    @test
-    async 'resolves url to base path'() {
-        const container = new Container()
-
-        container.set<Partial<AppConfig>>(AppConfig, {
-            staticAssets: [
-                {
-                    url: '.*',
-                    path: path.join(__dirname, 'articles/some-directory'),
-                    basePath: true
-                }
-            ]
-        })
-        const router = container.get(Router)
-        router.middleware.http.push(StaticAssetsMiddleware)
-
-        const handler = container.get(Handler)
-        const request = new Request('test', Http.Method.GET)
-        const response = await handler.handle(container, request)
-
-        expect(response.headers['Content-type']).to.be.equal('text/html')
-        expect(String(response.body)).to.contain('index file')
-    }
-
-    @test
-    async 'resolves to static resource of when having base path'() {
-        const container = new Container()
-
-        container.set<Partial<AppConfig>>(AppConfig, {
-            staticAssets: [
-                {
-                    url: '.*',
-                    path: path.join(__dirname, 'assets'),
-                    basePath: true
-                }
-            ]
-        })
-        const router = container.get(Router)
-        router.middleware.http.push(StaticAssetsMiddleware)
-
-        const handler = container.get(Handler)
-        const request = new Request('styles.css', Http.Method.GET)
-        const response = await handler.handle(container, request)
-
-        expect(response.headers['Content-type']).to.be.equal('text/css')
-        expect(String(response.body)).to.contain('color : purple')
-    }
-}

package/tests/Framework/Resolvers/EntityResolverTest.ts

@@ -1,48 +0,0 @@
-import { suite, test } from '@testdeck/mocha'
-import { Container } from '@Typetron/Container'
-import { Column, Connection, Entity, ID, Query, SqliteDriver } from '@Typetron/Database'
-import { Handler } from '@Typetron/Router/Websockets'
-import { AnyFunction, Type } from '@Typetron/Support'
-import { Http, Request, Response } from '@Typetron/Router/Http'
-import { anyOfClass, instance, mock, when } from 'ts-mockito'
-import { EntityResolver } from '@Typetron/Framework/Resolvers/EntityResolver'
-import { expect } from 'chai'
-
-@suite
-class EntityResolverTest {
-
-    @test
-    async 'resolves entity parameters'() {
-        const connection = mock(Connection)
-        Query.connection = instance(connection)
-        Query.connection.driver = new SqliteDriver(':memory:')
-        when(connection.first(anyOfClass(Query))).thenResolve({id: 2}, {id: 3})
-
-        const container = new Container()
-        container.resolvers.unshift(new EntityResolver(container))
-
-        class User extends Entity {
-            @Column()
-            id: ID
-        }
-
-        class Controller {
-            read(thisUser: User, thatUser: User) {
-                return [thisUser.id, thatUser.id]
-            }
-        }
-
-        const handler = container.get(Handler)
-        handler.addAction('read', Controller, 'read', [User as unknown as Type<AnyFunction>, User as unknown as Type<AnyFunction>])
-
-        const request = new Request('read', Http.Method.GET)
-        request.parameters = {
-            0: 2,
-            1: 3
-        }
-        const response: Response<[ID, ID]> = await handler.handle(container, request)
-
-        expect(response.body[0]).to.be.equal(2)
-        expect(response.body[1]).to.be.equal(3)
-    }
-}

package/tests/Framework/Router/RouterTest.ts

@@ -1,33 +0,0 @@
-import { suite, test } from '@testdeck/mocha'
-import { expect } from 'chai'
-import { Action, Body, Controller, Get, Router } from '../../../Router'
-import { App, Application } from '@Typetron/Framework'
-import { AuthUser } from '../../../Framework/Auth'
-
-@suite
-class RouterTest {
-
-    @test
-    'registers http routes and websocket actions'() {
-        App.instance = new Application('./tests')
-
-        @Controller()
-        class MyController {
-
-            @Action()
-            create(@AuthUser() user: string) {}
-
-            @Get()
-            list(@Body() content: number) {}
-
-        }
-
-        const router = App.instance.get(Router)
-
-        expect(router.routes).to.have.length(1)
-        expect(router.actions).to.have.length(1)
-        expect(router.routes[0]).to.deep.include({name: 'list'})
-        expect(router.actions.get('create')).to.deep.include({name: 'create'})
-    }
-
-}

package/tests/Mail/MailerTest.ts

@@ -1,76 +0,0 @@
-import { suite, test } from '@testdeck/mocha'
-import { Mailable, Mailer, MemoryTransport } from '@Typetron/Mail'
-import { expect } from 'chai'
-
-class Order {
-    constructor(public id: number) {
-    }
-}
-
-class OrderShipped extends Mailable {
-    constructor(public order: Order) {
-        super()
-    }
-
-    content() {
-        return {
-            html: `<h2>Order #${this.order.id} shipped</h2>`,
-            text: `Order #${this.order.id} shipped`
-        }
-    }
-}
-
-@suite
-class MailerTest {
-    mail = new Mailer({email: 'tester@test.com'}, new MemoryTransport())
-
-    @test
-    async canSendSimpleMessage() {
-        const sentMessage = await this.mail.to('john@example.com')
-            .from('from@example.com')
-            .replyTo('replyTo@example.com')
-            .subject('test')
-            .cc('moreUsers@example.com')
-            .bcc('evenMoreUsers@example.com')
-            .send('Order #123 shipped')
-
-        expect(sentMessage.replyTo).to.deep.equal('replyTo@example.com')
-        expect(sentMessage.subject).to.deep.equal('test')
-        expect(sentMessage.from).to.deep.equal('from@example.com')
-        expect(sentMessage.to).to.deep.equal('john@example.com')
-        expect(sentMessage.cc).to.equal('moreUsers@example.com')
-        expect(sentMessage.bcc).to.equal('evenMoreUsers@example.com')
-        expect(sentMessage.body).to.equal('Order #123 shipped')
-    }
-
-    @test
-    async canSendHtmlMessage() {
-        const sentMessage = await this.mail.to('john@example.com')
-            .cc('moreUsers@example.com')
-            .bcc('evenMoreUsers@example.com')
-            .send({html: '<h2>Order #1234 shipped</h2>', text: 'Order #1234 shipped'})
-
-        expect(sentMessage.to).to.equal('john@example.com')
-        expect(sentMessage.cc).to.equal('moreUsers@example.com')
-        expect(sentMessage.bcc).to.equal('evenMoreUsers@example.com')
-        expect(sentMessage.body).to.deep.equal({html: '<h2>Order #1234 shipped</h2>', text: 'Order #1234 shipped'})
-    }
-
-    @test
-    async canSendMailable() {
-        const order = new Order(1234)
-
-        const sentMessage = await this.mail.to('john@example.com')
-            .cc('moreUsers@example.com')
-            .bcc('evenMoreUsers@example.com')
-            .send(new OrderShipped(order))
-
-        expect(sentMessage.to).to.equal('john@example.com')
-        expect(sentMessage.cc).to.equal('moreUsers@example.com')
-        expect(sentMessage.bcc).to.equal('evenMoreUsers@example.com')
-        expect(sentMessage.body).to.deep.equal({
-            html: `<h2>Order #${order.id} shipped</h2>`,
-            text: `Order #${order.id} shipped`
-        })
-    }
-}

package/tests/Model/ModelTest.ts

@@ -1,183 +0,0 @@
-import { expect } from 'chai'
-import { suite, test } from '@testdeck/mocha'
-import { Field, FieldMany, Model } from '../../Models'
-
-@suite
-class ModelTest {
-    @test
-    mapsSingleObject() {
-        class UserModel extends Model {
-            @Field()
-            id: number
-
-            @Field()
-            name: string
-        }
-
-        const user = {
-            id: 1,
-            name: 'John',
-            age: 20
-        }
-        const expectedUser = {
-            id: 1,
-            name: 'John'
-        }
-        expect(UserModel.from(user)).to.deep.equal(expectedUser)
-    }
-
-    // @test
-    // mapsSingleObjectHavingUndefinedProperties() {
-    //     class UserModel extends Model {
-    //         @Field()
-    //         id: number;
-    //
-    //         @Field()
-    //         name: string;
-    //     }
-    //
-    //     const user = {
-    //         id: 1
-    //     };
-    //     const expectedUser = {
-    //         id: 1,
-    //         name: 'John'
-    //     };
-    //     expect(UserModel.from(user)).to.deep.equal(expectedUser);
-    // }
-
-    @test
-    mapsListOfObject() {
-        class UserModel extends Model {
-            @Field()
-            id: number
-
-            @Field()
-            name: string
-        }
-
-        const user = {
-            id: 1,
-            name: 'John',
-            age: 20
-        }
-        const expectedUser = {
-            id: 1,
-            name: 'John'
-        }
-        expect(UserModel.from([user, user])).to.deep.equal([expectedUser, expectedUser])
-    }
-
-    @test
-    mapsDeepModelObject() {
-        class ProfileModel extends Model {
-            @Field()
-            address: string
-        }
-
-        class UserModel extends Model {
-            @Field()
-            id: number
-
-            @Field()
-            name: string
-
-            @Field()
-            profile: ProfileModel
-        }
-
-        const user = {
-            id: 1,
-            name: 'John',
-            age: 20,
-            profile: {
-                address: 'somewhere',
-                picture: 'avatar'
-            }
-        }
-        const expectedUser = {
-            id: 1,
-            name: 'John',
-            profile: {
-                address: 'somewhere'
-            }
-        }
-        expect(UserModel.from(user)).to.deep.equal(expectedUser)
-    }
-
-    @test
-    mapsDeepListOfObject() {
-        class PostModel extends Model {
-            @Field()
-            title: string
-        }
-
-        class UserModel extends Model {
-            @Field()
-            id: number
-
-            @Field()
-            name: string
-
-            @Field()
-            @FieldMany(PostModel)
-            posts: PostModel[]
-        }
-
-        const user = {
-            id: 1,
-            name: 'John',
-            age: 20,
-            posts: [
-                {
-                    title: 'first post',
-                    content: 'some content'
-                }
-            ]
-        }
-        const expectedUser = {
-            id: 1,
-            name: 'John',
-            posts: [
-                {
-                    title: 'first post',
-                }
-            ]
-        }
-        expect(UserModel.from(user)).to.deep.equal(expectedUser)
-    }
-
-    @test
-    async 'Handles a promise with an object'() {
-        class UserModel extends Model {
-            @Field()
-            name: string
-        }
-
-        const user = {
-            name: 'John',
-            age: 20
-        }
-        const expectedUser = {
-            name: 'John'
-        }
-        expect(await UserModel.from(Promise.resolve(user))).to.deep.equal(expectedUser)
-    }
-
-    @test
-    async 'Handles a promise with a list of objects'() {
-        class UserModel extends Model {
-            @Field()
-            name: string
-        }
-
-        const user = {
-            name: 'John',
-            age: 20
-        }
-        const expectedUser = {
-            name: 'John'
-        }
-        expect(await UserModel.from(Promise.resolve([user, user]))).to.deep.equal([expectedUser, expectedUser])
-    }
-}

package/tests/Router/HttpHandlerTest.ts

@@ -1,72 +0,0 @@
-import { suite, test } from '@testdeck/mocha'
-import { Handler, Http, Request } from '../../Router/Http'
-import { expect } from 'chai'
-import { Container } from '@Typetron/Container'
-import { Body, Controller, Get } from '../../Router'
-
-@suite
-class HttpHandlerTest {
-    private container: Container
-
-    async before() {
-        this.container = new Container()
-        Container.setInstance(this.container)
-    }
-
-    @test
-    'gives error when two routes have the same path'() {
-
-        class MyController {
-            index() {}
-        }
-
-        const handler = this.container.get(Handler)
-        handler.addRoute('', Http.Method.GET, MyController, 'index', 'index')
-
-        expect(() => handler.addRoute('', Http.Method.POST, MyController, 'index', 'index'))
-            .to.not.throw(`There is already a route with the same url: [GET] ''`)
-        expect(() => handler.addRoute('', Http.Method.GET, MyController, 'index', 'index'))
-            .to.throw(`There is already a route with the same url: [GET] ''`)
-    }
-
-    @test
-    async 'returns the value from the @Body'() {
-        @Controller()
-        class MyController {
-            @Get('list')
-            list(@Body() value: string) {
-                return value
-            }
-
-            @Get('create')
-            create(@Body() value: string) {
-                return value
-            }
-        }
-
-        const router = this.container.get(Handler)
-
-        const listContent = await router.handle(this.container, new Request('list', Http.Method.GET, undefined, {}, 'test'))
-        expect(listContent.body).to.be.equal('test')
-
-        const createContent = await router.handle(this.container, new Request('create', Http.Method.GET))
-        expect(createContent.body).to.be.equal(undefined)
-    }
-
-    // @test
-    // async 'caches route urls'(done: Function) {
-    //     class Controller {
-    //         index() {}
-    //     }
-    //
-    //     const router = new Router()
-    //     router.add('', Http.Method.GET, Controller, 'index', 'index')
-    //
-    //     expect(router.cachedRoutes).to.be.have.length(0)
-    //
-    //     const app = new Container()
-    //     const request = new Request('', Http.Method.GET)
-    //     await router.handle(app as Application, request)
-    //     expect(router.findRouteIndex).to.be.called.once // ???
-    // }
-}