Refactored existing test to use framework

Author: jalextowle

test/app_test.ts

@@ -1,51 +1,54 @@
-import { web3Factory } from '@0x/dev-utils';
-import { Web3ProviderEngine } from '@0x/subproviders';
+import { APIOrder, PaginatedCollection } from '@0x/connect';
 import * as HttpStatus from 'http-status-codes';
-import 'mocha';
 import * as request from 'supertest';
 
-import { getAppAsync, getDefaultAppDependenciesAsync } from '../src/app';
-import * as config from '../src/config';
 import { DEFAULT_PAGE, DEFAULT_PER_PAGE, SRA_PATH } from '../src/constants';
 
-import { setupDependenciesAsync, teardownDependenciesAsync } from './utils/deployment';
 import { expect } from './utils/expect';
+import { TestCase, TestManager } from './utils/test_manager';
 
-let app: Express.Application;
+const API_HTTP_ADDRESS = 'http://localhost:3000';
 
-let provider: Web3ProviderEngine;
+async function apiGetRequestAsync(url: string): Promise<request.Response> {
+    return request(API_HTTP_ADDRESS).get(url);
+}
 
-describe('app test', () => {
-    before(async () => {
-        const ganacheConfigs = {
-            shouldUseInProcessGanache: false,
-            shouldAllowUnlimitedContractSize: true,
-            rpcUrl: config.ETHEREUM_RPC_URL,
-        };
-        provider = web3Factory.getRpcProvider(ganacheConfigs);
-        await setupDependenciesAsync();
-        const dependencies = await getDefaultAppDependenciesAsync(provider, config);
-        // start the 0x-api app
-        app = await getAppAsync({ ...dependencies }, config);
-    });
-    after(async () => {
-        await teardownDependenciesAsync();
-        // NOTE(jalextowle): The app should be torn down. I'm not going to worry
-        // about it because this test will be refactored so this will be a non-issue.
-    });
-    it('should not be undefined', () => {
-        expect(app).to.not.be.undefined();
-    });
-    it('should respond to GET /sra/orders', async () => {
-        await request(app)
-            .get(`${SRA_PATH}/orders`)
-            .expect('Content-Type', /json/)
-            .expect(HttpStatus.OK)
-            .then(response => {
-                expect(response.body.perPage).to.equal(DEFAULT_PER_PAGE);
-                expect(response.body.page).to.equal(DEFAULT_PAGE);
-                expect(response.body.total).to.equal(0);
-                expect(response.body.records).to.deep.equal([]);
-            });
-    });
-});
+async function assertCorrectGetBodyAsync(
+    expectedBody: PaginatedCollection<APIOrder>,
+    actualResponse: request.Response,
+): Promise<boolean> {
+    expect(actualResponse.type).to.match(/json/);
+    expect(actualResponse.status).to.be.eq(HttpStatus.OK);
+    expect(actualResponse.body).to.be.deep.eq(expectedBody);
+    return true;
+}
+
+const manager = new TestManager(
+    {
+        apiGetRequestAsync,
+    },
+    {
+        assertCorrectGetBodyAsync,
+    },
+);
+
+const suite: TestCase[] = [
+    {
+        description: 'should respond to GET /sra/orders',
+        action: {
+            actionType: 'apiGetRequestAsync',
+            input: `${SRA_PATH}/orders`,
+        },
+        assertion: {
+            assertionType: 'assertCorrectGetBodyAsync',
+            // This is the body of the expected HTTP request.
+            input: {
+                perPage: DEFAULT_PER_PAGE,
+                page: DEFAULT_PAGE,
+                total: 0,
+                records: [],
+            },
+        },
+    },
+];
+manager.executeTestSuite('app test', suite);

test/new_app_test.ts

@@ -22,18 +22,18 @@ export interface LoggingConfig {
 
 /**
  * Sets up a 0x-api instance.
- * @param logConfig Whether or not the logs from the setup functions should
+ * @param loggingConfig Whether or not the logs from the setup functions should
  *        be printed.
  */
-export async function setupApiAsync(logConfig: LoggingConfig = {}): Promise<void> {
+export async function setupApiAsync(loggingConfig: LoggingConfig = {}): Promise<void> {
     if (yarnStartProcess) {
         throw new Error('Old 0x-api instance has not been torn down');
     }
-    await setupDependenciesAsync(logConfig.shouldPrintDependencyLogs || false);
+    await setupDependenciesAsync(loggingConfig.shouldPrintDependencyLogs || false);
     yarnStartProcess = spawn('yarn', ['start'], {
         cwd: apiRootDir,
     });
-    if (logConfig.shouldPrintApiLogs) {
+    if (loggingConfig.shouldPrintApiLogs) {
         yarnStartProcess.stdout.on('data', chunk => {
             neatlyPrintChunk('[0x-api]', chunk);
         });
@@ -44,20 +44,20 @@ export async function setupApiAsync(logConfig: LoggingConfig = {}): Promise<void
     // Wait for the API to boot up
     // HACK(jalextowle): This should really be replaced by log-scraping, but it
     // does appear to work for now.
-    await sleepAsync(2500); // tslint:disable-line:custom-no-magic-numbers
+    await sleepAsync(5000); // tslint:disable-line:custom-no-magic-numbers
 }
 
 /**
  * Tears down the old 0x-api instance.
- * @param logConfig Whether or not the logs from the teardown functions should
+ * @param loggingConfig Whether or not the logs from the teardown functions should
  *        be printed.
  */
-export async function teardownApiAsync(logConfig: LoggingConfig = {}): Promise<void> {
+export async function teardownApiAsync(loggingConfig: LoggingConfig = {}): Promise<void> {
     if (!yarnStartProcess) {
         throw new Error('There is no 0x-api instance to tear down');
     }
     yarnStartProcess.kill();
-    await teardownDependenciesAsync(logConfig.shouldPrintDependencyLogs || false);
+    await teardownDependenciesAsync(loggingConfig.shouldPrintDependencyLogs || false);
 }
 
 /**

test/utils/deployment.ts

@@ -1,16 +1,18 @@
 import 'mocha';
 
-import { setupApiAsync, teardownApiAsync } from './deployment';
+import { LoggingConfig, setupApiAsync, teardownApiAsync } from './deployment';
 import { expect } from './expect';
 
 // FIXME(jalextowle): Lock this down to only the actions that have been created.
 export type ActionType = string;
 
 // FIXME(jalextowle): Lock this down to only the assetions that have been created.
+//                    The TestManager should remain flexible, but not when it is
+//                    being used normally.
 export type AssertionType = string;
 
 // tslint:disable-next-line:interface-over-type-literal
-export type ActionResult = {} | undefined;
+export type ActionResult = any;
 
 export interface ActionInfo {
     actionType: ActionType;
@@ -20,7 +22,7 @@ export interface ActionInfo {
 
 export interface AssertionInfo {
     assertionType: AssertionType;
-    expectedResult: ActionResult;
+    input: any;
 }
 
 export interface TestCase {
@@ -30,12 +32,13 @@ export interface TestCase {
 }
 
 type Action = (input: any) => Promise<any>;
-type Assertion = (expectedResult: ActionResult, actualResult: ActionResult) => boolean;
+type Assertion = (expectedResult: ActionResult, actualResult: ActionResult) => Promise<boolean>;
 
 export class TestManager {
     constructor(
         protected _actionsAsync: Record<string, Action>,
         protected _assertionsAsync: Record<string, Assertion>,
+        protected readonly _loggingConfig?: LoggingConfig,
     ) {}
 
     /**
@@ -56,12 +59,12 @@ export class TestManager {
         describe(description, () => {
             beforeEach(async () => {
                 // Setup the 0x-api instance.
-                await setupApiAsync();
+                await setupApiAsync(this._loggingConfig);
             });
 
             afterEach(async () => {
                 // Teardown the 0x-api instance.
-                await teardownApiAsync();
+                await teardownApiAsync(this._loggingConfig);
             });
 
             for (const testCase of testSuite) {
@@ -91,6 +94,6 @@ export class TestManager {
         if (!assertionAsync) {
             throw new Error('[test-manager] assertion is not registered');
         }
-        return assertionAsync(assertion.expectedResult, actualResult);
+        return assertionAsync(assertion.input, actualResult);
     }
 }