Merge pull request #8 from salsify/allow-no-callback

Allow milestones with no callback

addon/index.ts

@@ -64,14 +64,17 @@ export function advanceTo(name: string): MilestoneTarget {
  * When not activated, code wrapped in a milestone is immediately invoked as though
  * the wrapper weren't there at all.
  */
-export function milestone<T extends PromiseLike<any>>(name: string, callback: () => T): T {
+export function milestone<T extends PromiseLike<any>>(name: string, callback: () => T): T;
+export function milestone(name: string): PromiseLike<void>;
+export function milestone(name: string, callback?: () => any): PromiseLike<any> {
   let coordinator = CoordinatorImpl.forMilestone(name);
+  let action = callback || (() => Promise.resolve());
   if (coordinator) {
     debugActive('reached active milestone %s', name);
-    return coordinator._milestoneReached(name, callback);
+    return coordinator._milestoneReached(name, action);
   } else {
     debugInactive('skipping inactive milestone %s', name);
-    return callback();
+    return action();
   }
 }
 

tests/integration/milestones-test.ts

@@ -20,12 +20,25 @@ module('Integration | milestones', function(hooks) {
   });
 
   module('with no milestones active', function() {
-    test('milestones are inert', async function(assert) {
+    test('milestones with callbacks are inert', async function(assert) {
       let { first, second } = await program();
       assert.equal(location, 'two-completed');
       assert.equal(first, 1);
       assert.equal(second, 2);
     });
+
+    test('milestones without callbacks are inert', async function(assert) {
+      let program = async () => {
+        let first = await milestone('one');
+        let second = await milestone('two');
+        return { first, second };
+      };
+
+      assert.deepEqual(await program(), {
+        first: undefined,
+        second: undefined,
+      });
+    });
   });
 
   module('with milestones active', function(hooks) {
@@ -127,6 +140,19 @@ module('Integration | milestones', function(hooks) {
       assert.equal(await program(), boom);
     });
 
+    test('with no callback', async function(assert) {
+      let program = async () => {
+        let first = await milestone('one');
+        let second = await milestone('two');
+        return { first, second };
+      };
+
+      let programPromise = program();
+      await advanceTo('one').andContinue();
+      await advanceTo('two').andContinue();
+      assert.deepEqual(await programPromise, { first: undefined, second: undefined });
+    });
+
     test('stepping through each location', async function(assert) {
       let programPromise = program();