@typetron/framework 0.5.3 → 0.5.4

package/tests/Router/WebSocketsHandlerTest.ts

@@ -0,0 +1,51 @@
+import { suite, test } from '@testdeck/mocha'
+import { Handler } from '../../Router/Websockets'
+import { expect } from 'chai'
+import { Container } from '@Typetron/Container'
+import { Action, Body, Controller } from '../../Router'
+import { Request } from '../../Router/Request'
+
+@suite
+class WebSocketsHandlerTest {
+
+    @test
+    'gives error when two actions have the same path'() {
+        const container = new Container()
+
+        class Controller {
+            list() {}
+        }
+
+        const router = container.get(Handler)
+        router.addAction('list', Controller, 'list')
+
+        expect(() => router.addAction('list', Controller, 'index')).to.throw(`There is already an action with the same name: 'list'`)
+    }
+
+    @test
+    async 'returns the value from the @Body'() {
+        const container = Container.getInstance()
+
+        @Controller()
+        class MyController {
+            @Action()
+            list(@Body() value: string) {
+                return value
+            }
+
+            @Action()
+            create(@Body() value: string) {
+                return value
+            }
+        }
+
+        const router = container.get(Handler)
+
+        const listContent = await router.handle(container, new Request('list', 'test'))
+        expect(listContent.body).to.be.equal('test')
+
+        const createContent = await router.handle(container, new Request('create'))
+        expect(createContent.body).to.be.equal(undefined)
+    }
+
+}

package/tests/Storage/StorageTest.ts

@@ -0,0 +1,97 @@
+import { suite, test } from '@testdeck/mocha'
+import { File, Storage } from '../../Storage'
+import { expect } from 'chai'
+import * as path from 'path'
+
+const directory = './tests/Storage/.storage'
+
+@suite
+class StorageTest {
+    storage = new Storage()
+
+    @test
+    async canReadFiles() {
+        const file = new File('testFile.txt')
+        file.directory = directory
+        // Create the file before trying to save it
+        await this.storage.put(path.join(directory, file.name), 'test content')
+
+        const content = await this.storage.read(path.join(directory, file.name))
+        expect(content).to.be.instanceOf(Buffer)
+        expect(content.toString()).to.equal('test content')
+    }
+
+    @test
+    async canCheckIfFileExists() {
+        const file = new File('testFile.txt')
+        file.directory = directory
+        // Create the file before trying to save it
+        await this.storage.put(path.join(directory, file.name), 'test content')
+
+        const exists = await this.storage.exists(path.join(directory, file.name))
+        expect(exists).to.be.true
+    }
+
+    @test
+    async canSaveFiles() {
+        const file = new File('testFile.txt')
+        file.directory = directory
+        // Create the file before trying to save it
+        await this.storage.put(path.join(directory, file.name), 'test content')
+        const savedFile = await this.storage.save(file, './tests/Storage/.storage/alternative.txt')
+        expect(savedFile).to.be.instanceOf(File)
+        expect(savedFile.name).to.equal(file.name)
+        expect(await this.storage.exists(savedFile.path)).to.be.true
+    }
+
+    @test
+    async canWriteToFile() {
+        const filePath = path.join(directory, 'testFile.txt')
+        const file = await this.storage.put(filePath, 'test content')
+        expect(file).to.be.instanceOf(File)
+        expect(file.name).to.equal('testFile.txt')
+        const content = await this.storage.read(path.join(directory, file.name))
+        expect(content).to.be.instanceOf(Buffer)
+        expect(content.toString()).to.equal('test content')
+    }
+
+    @test
+    async canCreateDirectory() {
+        await this.storage.makeDirectory(directory)
+        const exists = await this.storage.exists(directory)
+        expect(exists).to.be.true
+    }
+
+    @test
+    async canDeleteDirectory() {
+        await this.storage.makeDirectory(directory)
+        await this.storage.deleteDirectory(directory)
+        const exists = await this.storage.exists(directory)
+        expect(exists).to.be.false
+    }
+
+    @test
+    async canDeleteFile() {
+        const file = new File('testFile.txt')
+        file.directory = directory
+        // Create the file before trying to save it
+        await this.storage.put(path.join(directory, file.name), 'test content')
+
+        await this.storage.delete(path.join(directory, file.name))
+        const exists = await this.storage.exists(path.join(directory, file.name))
+        expect(exists).to.be.false
+    }
+
+    @test
+    async cannotDeleteWithoutFileName() {
+        try {
+            // Attempt to delete a directory instead of a file
+            await this.storage.delete(directory)
+            throw new Error('Expected an error to be thrown, but none was thrown.')
+        } catch (unknownError) {
+            const error = unknownError as Error
+            expect(error).to.be.instanceOf(Error)
+            expect(error.message).to.equal('Can not delete because this path leads to a directory and not a file.')
+        }
+    }
+}

package/tests/Support/ArrayTest.ts

@@ -0,0 +1,167 @@
+import { expect } from 'chai'
+import { suite, test } from '@testdeck/mocha'
+import '../../Support'
+
+interface User {
+    name: string;
+    age: number;
+    admin: boolean;
+}
+
+@suite
+class ArrayTest {
+
+    joe = {
+        name: 'Joe',
+        age: 20,
+        admin: false
+    }
+    doe = {
+        name: 'Doe',
+        age: 21,
+        admin: true
+    }
+
+    users: User[] = []
+
+    before() {
+        this.users = [this.joe, this.doe]
+    }
+
+    @test
+    empty() {
+        expect([].empty()).to.be.equal(true)
+        expect([1].empty()).to.be.equal(false)
+    }
+
+    @test
+    findWhere() {
+        expect(this.users.findWhere('name', 'Joe')).to.be.equal(this.joe)
+    }
+
+    @test
+    pluck() {
+        expect(this.users.pluck('name')).to.have.members([this.joe.name, this.doe.name])
+    }
+
+    @test
+    remove() {
+        this.users.remove(this.joe)
+        expect(this.users).to.have.members([this.doe])
+    }
+
+    @test
+    removeMany() {
+        this.users.remove(this.joe, this.doe)
+        expect(this.users).to.have.length(0)
+    }
+
+    @test
+    where() {
+        expect(this.users.where('name', this.joe.name)).to.have.members([this.joe])
+        expect([this.joe].where('admin', false)).to.have.length(1)
+    }
+
+    @test
+    whereNot() {
+        expect(this.users.whereNot('name', this.joe.name)).to.have.members([this.doe])
+        expect([this.doe].whereNot('admin', false)).to.have.length(1)
+    }
+
+    @test
+    whereWithDefaultValue() {
+        expect(this.users.where('admin')).to.have.members([this.doe])
+    }
+
+    @test
+    whereIn() {
+        expect(this.users.whereIn('name', [this.joe.name, this.doe.name])).to.have.members([this.joe, this.doe])
+    }
+
+    @test
+    whereNotIn() {
+        expect(this.users.whereNotIn('name', [this.joe.name])).to.have.members([this.doe])
+    }
+
+    @test
+    first() {
+        expect(this.users.first()).to.be.equal(this.joe)
+    }
+
+    @test
+    groupBy() {
+        expect(this.users.groupBy('age')).to.deep.equal({
+            20: [this.joe],
+            21: [this.doe],
+        })
+    }
+
+    @test
+    groupByCallback() {
+        expect(this.users.groupBy(user => user.age)).to.deep.equal({
+            20: [this.joe],
+            21: [this.doe],
+        })
+    }
+
+    @test
+    uniqueValue() {
+        const data = [1, 1, 2, 3]
+        expect(data.unique()).to.be.deep.equal([1, 2, 3])
+    }
+
+    @test
+    uniqueValueBasedOnKey() {
+        const data = [
+            {id: 1},
+            {id: 1},
+        ]
+        expect(data.unique('id')).to.be.deep.equal([{id: 1}])
+    }
+
+    @test
+    uniqueValueBasedOnCallback() {
+        const data = [
+            {age: 20},
+            {age: 20},
+            {age: 30},
+        ]
+        expect(data.unique(item => item.age)).to.be.deep.equal([{age: 20}, {age: 30}])
+    }
+
+    @test
+    sumNumbers() {
+        expect([1, 2, 3].sum()).to.be.equal(6)
+    }
+
+    @test
+    sumObjectProperties() {
+        expect(this.users.sum('age')).to.be.equal(this.joe.age + this.doe.age)
+    }
+
+    @test
+    sumCallback() {
+        expect(this.users.sum(user => user.age)).to.be.equal(this.joe.age + this.doe.age)
+    }
+
+    @test
+    whenNotEmpty() {
+        let index = false;
+        [1].whenNotEmpty(() => index = true)
+        expect(index).to.be.equal(true)
+    }
+
+    @test
+    whenNotEmptyPassesTheArrayInTheCallback() {
+        let index = false;
+        [1, 2, 3].filter(i => i >= 2).whenNotEmpty(values => index = values.length === 2)
+        expect(index).to.be.equal(true)
+    }
+
+    @test
+    whenEmpty() {
+        let index = false;
+        [].whenEmpty(() => index = true)
+        expect(index).to.be.equal(true)
+    }
+}

package/tests/Support/StringTest.ts

@@ -0,0 +1,18 @@
+import { expect } from 'chai'
+import { suite, test } from '@testdeck/mocha'
+
+@suite
+class StringTest {
+    @test
+    shouldLimitStringAddingThreeDotsAtTheEnd() {
+        expect('text'.limit(3)).to.be.equal('...')
+        expect('texts'.limit(4)).to.be.equal('t...')
+        expect('text'.limit(5)).to.be.equal('text')
+    }
+
+    @test
+    shouldLimitStringWithCustomEnding() {
+        expect('Testing this text'.limit(12, ' More...')).to.be.equal('Test More...')
+    }
+
+}

package/tests/Validation/RulesTest.ts

@@ -0,0 +1,54 @@
+import { suite, test } from '@testdeck/mocha'
+import { Email } from '../../Validation'
+import { expect } from 'chai'
+
+@suite
+class RulesTest {
+    @test
+    shouldLimitStringAddingThreeDotsAtTheEnd() {
+        const validEmails = [
+            'email@example.com',
+            'firstname.lastname@example.com',
+            'email@subdomain.example.com',
+            'firstname+lastname@example.com',
+            'email@123.123.123.123',
+            'email@[123.123.123.123]',
+            '"email"@example.com',
+            '1234567890@example.com',
+            'email@example-one.com',
+            '_______@example.com',
+            'email@example.name',
+            'email@example.museum',
+            'email@example.co.jp',
+            'firstname-lastname@example.com',
+        ]
+        const invalidEmails = [
+            'plainaddress',
+            '#@%^%#$@#$@#.com',
+            '@example.com',
+            'Joe Smith <email@example.com>',
+            'email.example.com',
+            'email@example@example.com',
+            '.email@example.com',
+            'email.@example.com',
+            'email..email@example.com',
+            'あいうえお@example.com',
+            'email@example.com (Joe Smith)',
+            'email@example',
+            'email@-example.com',
+            'email@example..com',
+            'Abc..123@example.com',
+        ]
+
+        const rule = new (Email())
+
+        validEmails.forEach(email => {
+            expect(rule.passes('', email), email).to.be.equal(true)
+        })
+
+        invalidEmails.forEach(email => {
+            expect(rule.passes('', email), email).to.be.equal(false)
+        })
+    }
+
+}

package/types.d.ts

@@ -0,0 +1,8 @@
+declare module 'fast-url-parser' {
+    export function parse(url: string): Url
+
+    type Url = URL & {
+        format(): string
+        query: string
+    }
+}