@typetron/framework 0.4.0-rc9 → 0.5.0-rc1

package/tests/Database/SchemaTest.ts

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,72 @@
+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 // ???
+    // }
+}