[Minor] mark field as async

documentation/getting_started/result.md

@@ -14,9 +14,10 @@
 | `validationErrors[field-name]`   | `Object[]` | All error strings for this field                    |
 | `validationWarnings`             | `Object[]` | Actual errors per each field                        |
 | `validationWarnings[field-name]` | `Object[]` | All warning strings for this field                  |
+| `async`                          | `Object{}` | Contains async tests and their current completion status |
 | `skipped`                        | `Array`    | All skipped fields (empty, unless the `specific` option is used) |
 | `getErrors`                      | `Function` | Getter function which allows accessing the errors array of one or all fields |
-| `getWarnings`                      | `Function` | Getter function which allows accessing the warnings array of one or all fields |
+| `getWarnings`                    | `Function` | Getter function which allows accessing the warnings array of one or all fields |
 
 ### `testsPerformed` field structure
 | Name        | Type     | Description                           |

src/Passable.js

@@ -83,9 +83,10 @@ class Passable {
         [...this.pending].forEach((test) => {
             if (test instanceof Promise) {
 
-                this.res.markAsync();
+                this.res.markAsync(test.fieldName);
 
                 const done: Function = () => {
+                    this.res.markAsDone(test.fieldName);
                     this.clearPendingTest(test);
                 };
 

src/result_object/index.js

@@ -12,7 +12,7 @@ class ResultObject {
      * @return {Object} Current instance
      */
     constructor(name: string) {
-        this.async = false;
+        this.async = null;
         this.name = name;
         this.hasValidationErrors = false;
         this.hasValidationWarnings = false;
@@ -139,11 +139,26 @@ class ResultObject {
     }
 
     /**
-     * Marks current suite as async to be used by `done`
+     * Marks a field as async
+     * @param {string} fieldName the name of the field marked as async
      * @return {Object} Current instance
     */
-    markAsync() {
-        this.async = true;
+    markAsync(fieldName: string) {
+        this.async = this.async || {};
+        this.async[fieldName] = { done: false };
+        return this;
+    }
+
+    /**
+     * Marks an async field as done
+     * @param {string} fieldName the name of the field marked as done
+     * @return {Object} Current instance
+    */
+    markAsDone(fieldName: string) {
+        if (this.async && this.async[fieldName]) {
+            this.async[fieldName] = { done: true };
+        }
+
         return this;
     }
 
@@ -181,7 +196,7 @@ class ResultObject {
         return [];
     }
 
-    async: boolean;
+    async: AsyncObject;
     name: string;
     hasValidationErrors: boolean;
     hasValidationWarnings: boolean;

src/result_object/spec.js

@@ -10,7 +10,7 @@ describe('class: PassableResponse', () => {
     it('Should return correct initial object from constructor', () => {
         expect(new ResultObject('FormName')).to.deep.equal({
             name: 'FormName',
-            async: false,
+            async: null,
             hasValidationErrors: false,
             hasValidationWarnings: false,
             failCount: 0,
@@ -241,7 +241,7 @@ describe('class: PassableResponse', () => {
 
             expect(fail).to.deep.equal({
                 name: 'FormName',
-                async: false,
+                async: null,
                 testCount: 0,
                 failCount: 1,
                 warnCount: 0,
@@ -261,7 +261,7 @@ describe('class: PassableResponse', () => {
             const warn = testObject.fail('f1', 'should warn', WARN);
             expect(warn).to.deep.equal({
                 name: 'FormName',
-                async: false,
+                async: null,
                 testCount: 0,
                 failCount: 0,
                 warnCount: 1,
@@ -303,7 +303,7 @@ describe('class: PassableResponse', () => {
             testObject.bumpTestWarning('f1', 'should warn');
 
             expect(testObject).to.deep.equal({
-                async: false,
+                async: null,
                 name: 'FormName',
                 testCount: 0,
                 failCount: 0,
@@ -325,7 +325,7 @@ describe('class: PassableResponse', () => {
 
             expect(testObject).to.deep.equal({
                 name: 'FormName',
-                async: false,
+                async: null,
                 testCount: 0,
                 failCount: 1,
                 warnCount: 0,

src/spec/passable.api.severity.spec.js

@@ -33,7 +33,7 @@ const warnPass = passable('WarnPass', (test) => {
 
 const warnPassExpected = {
         name: 'WarnPass',
-        async: false,
+        async: null,
         skipped: [],
         hasValidationErrors: false,
         hasValidationWarnings: true,
@@ -49,7 +49,7 @@ const warnPassExpected = {
     },
     warnFailExpected = {
         name: 'WarnFail',
-        async: false,
+        async: null,
         skipped: [],
         hasValidationErrors: true,
         hasValidationWarnings: true,
@@ -66,7 +66,7 @@ const warnPassExpected = {
     },
     failExpected = {
         name: 'Fail',
-        async: false,
+        async: null,
         skipped: [],
         hasValidationErrors: true,
         hasValidationWarnings: false,

src/spec/passable.test.spec.js

@@ -108,18 +108,31 @@ describe("Tests Passable's `test` functionality", () => {
 
         describe('async test behavior', () => {
             describe('failing', () => {
+                let name;
                 beforeEach(() => {
+                    name = lorem.word();
                     instance = new Passable('formname', (test) => {
-                        test(lorem.word(), lorem.sentence(), new Promise((resolve, reject) => setImmediate(reject)));
+                        test(name, lorem.sentence(), new Promise((resolve, reject) => setImmediate(reject)));
                     });
                 });
 
                 it('Should immediately register test', () => {
                     expect(instance.res.testCount).to.equal(1);
                 });
 
-                it('Should mark response object as `async`', () => {
-                    expect(instance.res.async).to.equal(true);
+                it('Should set field as async (done: false) upon init', () => {
+                    expect(instance.res.async).to.deep.equal({
+                        [name]: { done: false }
+                    });
+                });
+
+                it('Should set async field as done when completed', (done) => {
+                    setTimeout(() => {
+                        expect(instance.res.async).to.deep.equal({
+                            [name]: { done: true }
+                        });
+                        done();
+                    }, 100);
                 });
 
                 it('Should only marke test as failing after rejection', (done) => {
@@ -165,7 +178,7 @@ describe("Tests Passable's `test` functionality", () => {
                     test(name, lorem.sentence(), () => { throw new Error(); });
                     test(lorem.word(), lorem.sentence(), noop);
                 });
-                expect(instance.res.async).to.equal(false);
+                expect(instance.res.async).to.equal(null);
             });
 
             it('should mark a test as failed for `false`', () => {

src/spec/usecase/usecase_a.js

@@ -49,7 +49,7 @@ export default (passable) => {
     });
 
     const expect = {
-        async: false,
+        async: null,
         name: 'case_a',
         hasValidationErrors: true,
         hasValidationWarnings: true,

src/spec/usecase/usecase_b.js

@@ -47,7 +47,7 @@ export default (passable) => {
     }, ['field_1', 'field_4']);
 
     const expect = {
-        async: false,
+        async: null,
         name: 'case_b',
         hasValidationErrors: false,
         hasValidationWarnings: true,

src/spec/usecase/usecase_c.js

@@ -51,7 +51,7 @@ export default (passable) => {
     });
 
     const expect = {
-        async: false,
+        async: null,
         name: 'case_c',
         hasValidationErrors: true,
         hasValidationWarnings: false,

src/spec/usecase/usecase_d.js

@@ -25,7 +25,7 @@ export default (passable, enforce) => {
     });
 
     const expect = {
-        async: false,
+        async: null,
         name: 'case_d',
         hasValidationErrors: true,
         hasValidationWarnings: false,

src/types.js

@@ -37,6 +37,12 @@ declare type ErrorAndWarningObject = {
     [name: string]: Array<string>
 }
 
+declare type AsyncObject = {
+    [name: string]: {
+        done: boolean
+    }
+} | null;
+
 // Test
 declare type TestsWrapper = (test: TestProvider) => void;
 declare type TestProvider = (fieldName: string, statemenpt: string, test: PassableTest, severity: Severity) => void;