feat: expose createCallRecord (#26)

* feat: expose CallRecord.create

Use this function to create an instance of CallRecord in memory.
On top of the data, a CallRecord instance has a `tersify()` method to ensure when stringifing it using `tersify()`, all data in the CallRecord will be preserved.

* fix: CallRecord.create

Change the expose to CallRecord.create.
And fix tersifing it.

* fix: reference

src/CallEntry.ts

@@ -0,0 +1,20 @@
+import { CallRecord } from './CallRecord'
+
+export interface CallEntry extends Promise<any> {
+  inputs: any[],
+  /**
+   * Synchronous result.
+   */
+  output: any,
+  /**
+   * Synchronous error got thrown.
+   */
+  error: any,
+  getCallRecord(): Promise<CallRecord>
+}
+
+// export const CallEntry = {
+//   create(callRecord: CallRecord) {
+//     return {}
+//   }
+// }

src/CallRecord.ts

@@ -0,0 +1,25 @@
+import { tersible, tersify } from 'tersify'
+
+export interface CallRecord {
+  inputs: any[],
+  output: any,
+  error: any,
+  asyncOutput: any,
+  asyncError: any,
+  tersify(): string
+}
+
+export const CallRecord = {
+  /**
+   * Creates a call record object.
+   */
+  create({ inputs, output, error, asyncOutput, asyncError }: CallRecord) {
+    return tersible({ inputs, output, error, asyncOutput, asyncError },
+      () => {
+        const obj = { inputs, output, error } as CallRecord
+        if (asyncError !== undefined) obj.asyncError = asyncError
+        if (asyncOutput !== undefined) obj.asyncOutput = asyncOutput
+        return tersify(obj, { maxLength: Infinity })
+      })
+  }
+}

src/createCallRecordCreator.ts

@@ -1,6 +1,5 @@
-import { tersify, tersible } from 'tersify'
-
-import { CallEntry } from './interfaces'
+import { CallRecord } from './CallRecord'
+import { CallEntry } from './CallEntry'
 
 export function createCallRecordCreator(args: any[]) {
   let resolve
@@ -13,31 +12,13 @@ export function createCallRecordCreator(args: any[]) {
     inputs: args,
     getCallRecord() {
       return callEntry.then(asyncOutput => {
-        const { inputs, output, error } = callEntry
-        return tersible({
-          inputs,
-          output,
-          error,
-          asyncOutput
-        }, () => tersify({
-          inputs,
-          output,
-          error,
-          asyncOutput
-        }, { maxLength: Infinity }))
+        return CallRecord.create({
+          ...callEntry, asyncOutput
+        })
       }, asyncError => {
-        const { inputs, output, error } = callEntry
-        return tersible({
-          inputs,
-          output,
-          error,
-          asyncError
-        }, () => tersify({
-          inputs,
-          output,
-          error,
-          asyncError
-        }, { maxLength: Infinity }))
+        return CallRecord.create({
+          ...callEntry, asyncError
+        })
       })
     }
   }) as CallEntry

src/createSatisfier.exec.spec.ts

@@ -1,7 +1,7 @@
 import { test } from 'ava'
 
 import { createSatisfier } from './index'
-import { assertExec, assertRegExp } from './testUtil';
+import { assertExec, assertRegExp } from './testUtil'
 
 test('primitive types without specifing generic will work without issue.', t => {
   t.is(createSatisfier(1).exec(1), undefined)

src/index.ts

@@ -1,3 +1,4 @@
+export * from './CallRecord'
 export * from './createSatisfier'
 export * from './interfaces'
 export * from './isInRange'

src/interfaces.ts

@@ -1,26 +1,6 @@
 import { Tersible } from 'tersify'
 
-export interface CallRecord {
-  inputs: any[],
-  output: any,
-  error: any,
-  asyncOutput: any,
-  asyncError: any,
-  tersify(): string
-}
-
-export interface CallEntry extends Promise<any> {
-  inputs: any[],
-  /**
-   * Synchronous result.
-   */
-  output: any,
-  /**
-   * Synchronous error got thrown.
-   */
-  error: any,
-  getCallRecord(): Promise<CallRecord>
-}
+import { CallEntry } from './CallEntry'
 
 export interface Spec<T extends Function> {
   spiedFn: T,

src/spy.spec.ts

@@ -1,7 +1,6 @@
 import { test } from 'ava'
 
 import { spy } from './index'
-import { tersify } from 'tersify';
 
 function increment(x: number) { return ++x }
 
@@ -32,7 +31,7 @@ test('tersify for sync call', async t => {
 
   t.is(fn(1), 2)
   const record = await calls[0].getCallRecord()
-  t.is(record.tersify(), `{ inputs: [1], output: 2, error: undefined, asyncOutput: undefined }`)
+  t.is(record.tersify(), `{ inputs: [1], output: 2, error: undefined }`)
 })
 
 // this is not a valid test as the package is used for boundary testing.
@@ -79,7 +78,9 @@ test('then() will receive result from promise', async t => {
   const { fn, calls } = spy(resolve)
   // tslint:disable-next-line
   fn(1)
-  t.is(await calls[0], 1)
+  return calls[0].then(actual => {
+    t.is(actual, 1)
+  })
 })
 
 test('result from promise can be retrieved from await on the call', async t => {
@@ -101,16 +102,23 @@ test('catch() will receive error thrown by promise', async t => {
   })
 })
 
-test('tersify for sync call', async t => {
-  const { fn, calls } = spy(reject)
+test('tersify for resolve call', async t => {
+  const { fn, calls } = spy(resolve)
+  // tslint:disable-next-line
+  fn(1)
+  return calls[0].getCallRecord()
+    .then(record => {
+      t.is(record.tersify(), `{ inputs: [1], output: {}, error: undefined, asyncOutput: 1 }`)
+    })
+})
 
 
-  return fn(1).catch(actualError => {
-    console.log(tersify(actualError))
+test('tersify for reject call', async t => {
+  const { fn, calls } = spy(reject)
+  return fn(1).catch(() => {
     return calls[0].getCallRecord()
       .then(record => {
         t.is(record.tersify(), `{ inputs: [1], output: {}, error: undefined, asyncError: { message: '1' } }`)
       })
   })
 })
-

src/spy.ts

@@ -1,5 +1,5 @@
+import { CallEntry } from './CallEntry'
 import { createCallRecordCreator } from './createCallRecordCreator'
-import { CallEntry } from './interfaces'
 
 export interface Spy<T> {
   calls: ReadonlyArray<CallEntry>,