@typetron/framework 0.5.3 → 0.5.4

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 // ???
+    // }
+}

package/tests/Router/RequestTest.ts

@@ -0,0 +1,77 @@
+import { suite, test } from '@testdeck/mocha'
+import { expect } from 'chai'
+import { Http, Request } from '../../Router/Http'
+import { IncomingHttpHeaders } from 'http'
+import { File } from '../../Storage'
+
+@suite
+class RequestTest {
+
+    private request: Request
+
+    before() {
+        this.request = new Request('http://example.com/test?name=value', Http.Method.GET)
+        this.request.setHeadersLoader(() => {
+            return {'content-type': 'text/html'}
+        })
+        this.request.getHeader = <T extends string | string[] | undefined>(name: keyof IncomingHttpHeaders | string): T => {
+            return 'text/html' as T
+        }
+    }
+
+    @test
+    'uri getter should return correct uri'() {
+        expect(this.request.uri).to.equal('/test')
+    }
+
+    @test
+    'method getter should return correct method'() {
+        expect(this.request.method).to.equal(Http.Method.GET)
+    }
+
+    // Assuming that the commented url getter is uncommented in your code
+    @test
+    'url getter should return correct url'() {
+        expect(this.request.url).to.equal('http://example.com/test?name=value')
+    }
+
+    @test
+    'query getter should parse and return correct query parameters'() {
+        expect(this.request.query).to.deep.equal({name: 'value'})
+    }
+
+    @test
+    'cookies getter should parse and return correct cookies'() {
+        expect(this.request.cookies).to.deep.equal({todo: 'parse cookies'})
+    }
+
+    @test
+    'body getter and setter should return and set body correctly'() {
+        this.request.body = {test: 'data'}
+        expect(this.request.body).to.deep.equal({test: 'data'})
+    }
+
+    @test
+    'files getter and setter should return and set files correctly'() {
+        const dummyFile = { // Just a mock structure based on what you provided
+            originalName: 'test.txt',
+            directory: '/tmp',
+            saved: true,
+            path: '/tmp/test.txt'
+        } as File
+
+        this.request.files = {testFile: dummyFile}
+        expect(this.request.files).to.deep.equal({testFile: dummyFile})
+    }
+
+    @test
+    'headers getter should return correct headers'() {
+        expect(this.request.headers).to.deep.equal({'content-type': 'text/html'})
+    }
+
+    @test
+    'header value is returned'() {
+        expect(this.request.getHeader('random header')).to.deep.equal('text/html')
+    }
+}
+