@neurodevs/node-tdd 0.2.5 → 1.0.0

package/src/__tests__/behavioral/utilities/InstanceParentTestCanAccessParentMethods.test.ts

@@ -0,0 +1,14 @@
+import assert from '../../../utilities/assert.js'
+import test, { suite } from '../../../utilities/decorators.js'
+import AbstractStaticTest from '../../support/AbstractStaticTest.js'
+
+@suite()
+export default class InstanceParentTestCanAccessParentMethodsTest extends AbstractStaticTest {
+    @test()
+    protected async canCreateInstanceParentTestCanAccessParentMethods() {
+        assert.isTrue(
+            InstanceParentTestCanAccessParentMethodsTest.didCallAnotherStaticMethodInBeforeEach,
+            'beforeAll in parent class not referrenced'
+        )
+    }
+}

package/src/__tests__/behavioral/utilities/MockFetch.test.ts

@@ -0,0 +1,240 @@
+import generateId from '@neurodevs/generate-id'
+
+import assert from '../../../utilities/assert.js'
+import test, { suite } from '../../../utilities/decorators.js'
+import AbstractModuleTest from '../../../impl/AbstractModuleTest.js'
+import MockFetch, { ExpectedRequest } from '../../MockFetch.js'
+
+@suite()
+export default class MockFetchTest extends AbstractModuleTest {
+    private mock = new MockFetch()
+    private fetch = this.mock.buildFetch()
+    private url = generateId()
+
+    @test()
+    protected async throwsIfNotCalled() {
+        assert.doesThrow(() => this.assertFetchWasCalled(), 'expected')
+    }
+
+    @test()
+    protected async passesIfCalled() {
+        await this.callFetch()
+        this.assertFetchWasCalled()
+    }
+
+    @test()
+    protected async throwsIfUrlDoesNotMatch() {
+        await this.callFetch()
+        assert.doesThrow(
+            () => this.assertFetchWasCalled(generateId()),
+            'Expected fetch() to have been called with URL'
+        )
+    }
+
+    @test()
+    protected async canAssertMultipleCalls() {
+        await this.callFetch()
+        const url1 = this.url
+
+        this.randomizeUrl()
+        await this.callFetch()
+
+        const expected = [url1, this.url]
+        this.assertMadeRequests(expected)
+    }
+
+    @test()
+    protected async assertMultipleFailsIfSecondUrlDoesNotMatch() {
+        await this.callFetch()
+        const url1 = this.url
+
+        this.randomizeUrl()
+        await this.callFetch()
+
+        const expected = [url1, generateId()]
+        assert.doesThrow(
+            () => this.assertMadeRequests(expected),
+            'Expected fetch() to have been called with URL'
+        )
+    }
+
+    @test()
+    protected async assertCalledThrowsIfDoesNotMatchSecondUrl() {
+        await this.callFetch()
+        const url = this.url
+        this.randomizeUrl()
+        await this.callFetch()
+
+        assert.doesThrow(
+            () => this.assertFetchWasCalled(url),
+            'Expected fetch() to have been called with URL'
+        )
+    }
+
+    @test()
+    protected async throwsIfInitDoesNotMatch() {
+        await this.callFetch({
+            method: 'POST',
+        })
+
+        assert.doesThrow(
+            () =>
+                this.assertFetchWasCalled(this.url, {
+                    method: 'GET',
+                }),
+            'Expected fetch() to have been called with init'
+        )
+    }
+
+    @test()
+    protected async passesIfMethodMatches() {
+        await this.callFetch({
+            method: 'POST',
+        })
+
+        this.assertFetchWasCalled(this.url, {
+            method: 'POST',
+        })
+    }
+
+    @test()
+    protected async passesIfHeadersMatch() {
+        await this.callFetch({
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        })
+
+        this.assertFetchWasCalled(this.url, {
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        })
+    }
+
+    @test()
+    protected async throwsIfHeadersDoNotMatch() {
+        await this.callFetch({
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        })
+
+        assert.doesThrow(() =>
+            this.assertFetchWasCalled(this.url, {
+                headers: {
+                    'Content-Type': 'text/plain',
+                },
+            })
+        )
+    }
+
+    @test()
+    protected async doesNotThrowIfMultipleRequestsMatch() {
+        await this.callFetch({
+            method: 'POST',
+        })
+
+        await this.callFetch({
+            method: 'GET',
+        })
+
+        this.assertMadeRequests([
+            { url: this.url, init: { method: 'POST' } },
+            { url: this.url, init: { method: 'GET' } },
+        ])
+    }
+
+    @test()
+    protected async getBackGeneric200Response() {
+        const expected = new Response(
+            JSON.stringify({
+                success: true,
+            }),
+            { status: 200 }
+        )
+        await this.assertFetchResponseEquals(expected)
+    }
+
+    @test()
+    protected async canSetResponseForAllRequests() {
+        const expected = new Response('Hello, World!', {
+            status: 404,
+        })
+
+        this.setResponse(expected)
+        await this.assertFetchResponseEquals(expected)
+    }
+
+    @test()
+    protected async defaultResponseDoesNotThrowWhenGettingJson() {
+        const response = await this.callFetch()
+        await response.json()
+    }
+
+    @test()
+    protected async canSetResponseByUrl() {
+        const expected1 = new Response('Response for URL 1', {})
+        const expected2 = new Response('Response for URL 2', {})
+
+        const url1 = generateId()
+        const url2 = generateId()
+
+        this.setResponse(expected1, url1)
+        this.setResponse(expected2, url2)
+
+        this.url = url1
+        await this.assertFetchResponseEquals(expected1)
+
+        this.url = url2
+        await this.assertFetchResponseEquals(expected2)
+    }
+
+    @test()
+    protected async canSetResponseByInit() {
+        const expected1 = new Response('Special POST Response 1', {})
+        const expected2 = new Response('Special POST Response 2', {})
+
+        this.setResponse(expected1, this.url, { method: 'POST' })
+        this.setResponse(expected2, this.url, { method: 'GET' })
+
+        await this.assertFetchResponseEquals(expected1, { method: 'POST' })
+        await this.assertFetchResponseEquals(expected2, { method: 'GET' })
+    }
+
+    private setResponse(
+        expected: Response,
+        url?: string | URL,
+        init?: RequestInit
+    ) {
+        this.mock.setResponse(expected, url, init)
+    }
+
+    private async assertFetchResponseEquals(
+        expected: Response,
+        init?: RequestInit
+    ) {
+        const response = await this.callFetch(init)
+        assert.isEqualDeep(
+            (await response.text()) + ': ' + response.status,
+            (await expected.text()) + ': ' + expected.status,
+            'fetch() did not return the expected response.'
+        )
+    }
+
+    private assertMadeRequests(expected: ExpectedRequest[]) {
+        this.mock.assertMadeRequests(expected)
+    }
+
+    private randomizeUrl() {
+        this.url = generateId()
+    }
+
+    private async callFetch(init?: RequestInit) {
+        return await this.fetch(this.url, init)
+    }
+
+    private assertFetchWasCalled(url?: string | URL, init?: RequestInit) {
+        this.mock.assertWasCalled(url, init)
+    }
+}

package/src/__tests__/behavioral/utilities/StackCleaner.test.ts

@@ -0,0 +1,46 @@
+import AbstractModuleTest from '../../../impl/AbstractModuleTest.js'
+import assert from '../../../utilities/assert.js'
+import test from '../../../utilities/decorators.js'
+import StackCleaner from '../../../utilities/StackCleaner.js'
+
+export default class ErrorStackTest extends AbstractModuleTest {
+    @test(
+        'removes test files',
+        `Error: You called will-fail!
+	at Object.willFail (~/node-tdd/src/assert.ts:53:17)
+	at Function.canRemoveTestFiles (~/node-tdd/src/__tests__/ErrorStack.test.ts:8:10)
+	at Object.<anonymous> (~/node-tdd/src/decorators.ts:36:11)
+	at Object.asyncJestTest (~/node-tdd/node_modules/jest-jasmine2/build/jasmineAsyncInstall.js:100:37)
+	at ~/node-tdd/node_modules/jest-jasmine2/build/queueRunner.js:45:12
+	at new Promise (<anonymous>)
+	at mapper (~/node-tdd/node_modules/jest-jasmine2/build/queueRunner.js:28:19)
+	at ~/node-tdd/node_modules/jest-jasmine2/build/queueRunner.js:75:41
+	at processTicksAndRejections (internal/process/task_queues.js:97:5)`,
+        `Error: You called will-fail!
+	at Function.canRemoveTestFiles (~/node-tdd/src/__tests__/ErrorStack.test.ts:8:10)
+	at new Promise (<anonymous>)`
+    )
+    @test(
+        'drops babel crap',
+        `TypeError: Cannot read property 'map' of undefined
+    at Object (~/example/src/databases/mongo.utilities.ts:21:17)
+    at Array.forEach (<anonymous>)
+    at mapNestedIdValues (~/example/src/databases/mongo.utilities.ts:20:2)
+    at Object.mongoUtil [as mapQuery] (~/example/src/databases/mongo.utilities.ts:11:27)
+    at MongoDatabase.toMongo…
+    at Generator.next (~/example/node_modules/regenerator-runtime/runtime.js:118:21)
+    at asyncGeneratorStep (~/example/node_modules/@babel/runtime/helpers/asyncToGenerator.js:3:24)
+    at _next (~/example/node_modules/@babel/runtime/helpers/asyncToGenerator.js:25:9)
+    at processTicksAndRejections (internal/process/task_queues.js:97:5)`,
+        `TypeError: Cannot read property 'map' of undefined
+    at Object (~/example/src/databases/mongo.utilities.ts:21:17)
+    at Array.forEach (<anonymous>)
+    at mapNestedIdValues (~/example/src/databases/mongo.utilities.ts:20:2)
+    at Object.mongoUtil [as mapQuery] (~/example/src/databases/mongo.utilities.ts:11:27)
+    at MongoDatabase.toMongo…`
+    )
+    protected static async removesExpected(stack: string, expected: string) {
+        const cleaned = StackCleaner.clean(stack)
+        assert.isEqual(cleaned, expected)
+    }
+}

package/src/__tests__/behavioral/utilities/StaticParentTestCanAccessParentMethods.test.ts

@@ -0,0 +1,34 @@
+import assert from '../../../utilities/assert.js'
+import test from '../../../utilities/decorators.js'
+import AbstractStaticTest from '../../support/AbstractStaticTest.js'
+
+export default class StaticParentTestCanAccessParentMethodsTest extends AbstractStaticTest {
+    protected static didCallFirstTest = false
+
+    protected static async afterAll(): Promise<void> {
+        await super.afterAll()
+
+        assert.isEqual(this, StaticParentTestCanAccessParentMethodsTest)
+
+        assert.isTrue(
+            this.didCallAnotherStaticMethodInBeforeEach,
+            'beforeAll in parent class not referrenced'
+        )
+
+        assert.isTrue(this.didCallFirstTest, 'First test was not called')
+    }
+
+    @test()
+    protected static async didCallBeforeAllScopedCorrectly() {
+        this.didCallFirstTest = true
+        assert.isTrue(
+            this.didCallAnotherStaticMethodInBeforeEach,
+            'beforeAll in parent class not referrenced'
+        )
+    }
+
+    @test()
+    protected static async shouldCallFirstTest() {
+        assert.isTrue(this.didCallFirstTest, 'First test was not called')
+    }
+}

package/src/__tests__/behavioral/utilities/StaticTestInheritsAbstractSpruceTestProperly.test.ts

@@ -0,0 +1,11 @@
+import AbstractModuleTest from '../../../impl/AbstractModuleTest.js'
+import assert from '../../../utilities/assert.js'
+import test from '../../../utilities/decorators.js'
+
+export default class StaticTestInheritsAbstractModuleTestProperlyTest extends AbstractModuleTest {
+    @test('checking if cwd is set')
+    protected static canCreateStaticTestInheritsAbstractModuleTestProperly() {
+        assert.isEqual(this.cwd, process.cwd())
+        this.resolvePath('hello')
+    }
+}

package/src/__tests__/behavioral/utilities/Stringify.test.ts

@@ -0,0 +1,169 @@
+import chalk from 'chalk'
+
+import assert from '../../../utilities/assert.js'
+import test from '../../../utilities/decorators.js'
+import assertUtil, {
+    CIRCULAR_PLACEHOLDER,
+    FUNCTION_PLACEHOLDER,
+    NULL_PLACEHOLDER,
+    UNDEFINED_PLACEHOLDER,
+} from '../../../utilities/assert.utility.js'
+
+const teammate = {
+    firstName: 'tay',
+}
+
+const team: Record<string, any> = {
+    teammate: { ...teammate },
+}
+
+team.teammate.team = team
+
+const team2 = {
+    teammate,
+    teammate2: teammate,
+}
+
+const team3 = {
+    teammate: {
+        ...teammate,
+        age: 100,
+    },
+    coach: {
+        name: {
+            firstName: 'tay',
+            age: 100,
+        },
+    },
+}
+
+export default class StringifyTest {
+    @test('placeholdering simple object', { test: true }, { test: true })
+    @test(
+        'placeholdering object with null',
+        { test: null },
+        { test: NULL_PLACEHOLDER }
+    )
+    @test(
+        'placeholdering object with function',
+        { test: () => {} },
+        { test: FUNCTION_PLACEHOLDER }
+    )
+    @test('placeholdering circular object', team, {
+        teammate: {
+            firstName: 'tay',
+            team: CIRCULAR_PLACEHOLDER,
+        },
+    })
+    @test('placeholdering same object on same level', team2, {
+        teammate: {
+            firstName: 'tay',
+        },
+        teammate2: {
+            firstName: 'tay',
+        },
+    })
+    @test(
+        'placeholdering objects with same values at different levels',
+        team3,
+        {
+            teammate: {
+                firstName: 'tay',
+                age: 100,
+            },
+            coach: {
+                name: {
+                    firstName: 'tay',
+                    age: 100,
+                },
+            },
+        }
+    )
+    protected static dropInPlaceholders(obj: any, expected: any) {
+        const placholder = assertUtil.dropInPlaceholders(obj)
+        assert.isEqualDeep(placholder, expected)
+    }
+
+    @test(
+        'one level deep (undefined)',
+        {
+            hello: 'world',
+            undefined,
+        },
+        `{
+  "hello": "world",
+  "undefined": "${UNDEFINED_PLACEHOLDER}"
+}`
+    )
+    @test(
+        'one level deep (null)',
+        {
+            hello: 'world',
+            null: null,
+        },
+        `{
+  "hello": "world",
+  "null": "${NULL_PLACEHOLDER}"
+}`
+    )
+    @test(
+        'two levels deep',
+        {
+            hello: 'world',
+            undefinedDeep: {
+                undefined,
+            },
+        },
+        `{
+  "hello": "world",
+  "undefinedDeep": {
+    "undefined": "${UNDEFINED_PLACEHOLDER}"
+  }
+}`
+    )
+    @test(
+        'three levels deep',
+        {
+            hello: 'world',
+            undefinedDeep: {
+                undefinedDeepAgain: {
+                    undefined,
+                },
+            },
+        },
+        `{
+  "hello": "world",
+  "undefinedDeep": {
+    "undefinedDeepAgain": {
+      "undefined": "${UNDEFINED_PLACEHOLDER}"
+    }
+  }
+}`
+    )
+    @test(
+        'prints a function nicely',
+        { hello: () => {} },
+        `{
+  "hello": "${FUNCTION_PLACEHOLDER}"
+}`
+    )
+    protected static printsPlaceholderFields(
+        obj: Record<string, any>,
+        expected: string
+    ) {
+        const stringified = assertUtil.stringify(obj)
+
+        assert.isEqual(
+            stringified,
+            chalk.bold(assertUtil.replacePlaceholders(expected))
+        )
+    }
+
+    @test.skip('array looks good', ['hello', 'world'])
+    @test.skip('objects looks good', { hello: 'world' })
+    protected static canRenderWithoutStrippingCharactorsInTestReporter(
+        obj: any
+    ) {
+        process.stderr.write(assertUtil.stringify(obj))
+    }
+}

package/src/__tests__/behavioral/utilities/TestDecoratorResolver.test.ts

@@ -0,0 +1,51 @@
+import assert from '../../../utilities/assert.js'
+import test, { suite } from '../../../utilities/decorators.js'
+import AbstractModuleTest from '../../../impl/AbstractModuleTest.js'
+
+import TestDecoratorResolver from '../../../utilities/TestDecoratorResolver.js'
+
+@suite()
+export default class TestDecoratorResolverTest extends AbstractModuleTest {
+    protected static counter = 4
+
+    protected static async beforeAll(): Promise<void> {
+        await super.beforeAll()
+
+        assert.isEqual(
+            this.counter,
+            4,
+            'beforeAll did not access correct static property'
+        )
+    }
+
+    protected static async afterAll(): Promise<void> {
+        await super.afterAll()
+
+        assert.isEqual(
+            this.counter,
+            10,
+            'afterAll did not access correct static property'
+        )
+    }
+
+    @test()
+    protected async canCreateTestDecoratorResolver() {
+        TestDecoratorResolverTest.counter = 10
+
+        const activeTest = TestDecoratorResolver.getActiveTest()
+
+        assert.isInstanceOf(
+            activeTest,
+            TestDecoratorResolverTest,
+            'getActive test is not this on instance test'
+        )
+
+        const activeTest2 = TestDecoratorResolver.getActiveTest()
+
+        assert.isEqual(
+            activeTest,
+            activeTest2,
+            'getActiveTest called a second time did not return same instance'
+        )
+    }
+}

package/src/__tests__/behavioral/utilities/TestOnBasic.test.ts

@@ -0,0 +1,62 @@
+import AbstractModuleTest from '../../../impl/AbstractModuleTest.js'
+import test from '../../../utilities/decorators.js'
+import assert from '../../../utilities/assert.js'
+
+let beforeAllCount = 0
+let beforeEachCount = 0
+let afterEachCount = 0
+
+export default class TestOnBasic extends AbstractModuleTest {
+    protected static async beforeAll() {
+        await super.beforeAll()
+        beforeAllCount += 1
+    }
+
+    protected static async beforeEach() {
+        await super.beforeEach()
+        beforeEachCount += 1
+    }
+
+    protected static async afterEach() {
+        await super.afterEach()
+        afterEachCount += 1
+    }
+
+    @test()
+    protected static async calledBeforeAll() {
+        assert.isEqual(beforeAllCount, 1)
+    }
+
+    @test()
+    protected static async calledBeforeAndAfterEach() {
+        assert.isEqual(beforeEachCount, 2)
+        assert.isEqual(afterEachCount, 1)
+    }
+
+    @test()
+    protected static async basicPassingTest() {
+        assert.isTrue(true)
+        assert.isFalse(false)
+        assert.isEqual(5, 5, `Thing's don't equal`)
+    }
+
+    @test('can pass variables to test handler from decorator', 'hello', 'world')
+    protected static async canAccessVarsFromDecorator(
+        hello: string,
+        world: string
+    ) {
+        assert.isEqual(hello, 'hello')
+        assert.isEqual(world, 'world')
+    }
+
+    @test()
+    protected static async asyncWaits() {
+        const results = await this.wait(10)
+        assert.isTruthy(results)
+    }
+
+    @test.todo('can create a TODO test')
+    protected static async todo() {
+        assert.fail('This test should not run')
+    }
+}