feat(reframe): Support specifying frames per char.

cartant · Apr 11, 2018 · 15ef0e9 · 15ef0e9
1 parent 21d8312
commit 15ef0e9
Show file tree

Hide file tree

Showing 2 changed files with 51 additions and 0 deletions.
diff --git a/fixtures/mocha/passing-spec.ts b/fixtures/mocha/passing-spec.ts
@@ -225,4 +225,26 @@ describe("rxjs-marbles", () => {
 
         return Promise.resolve().then(() => expect(m).to.be.an("object"));
     }));
+
+    it("should support reframing", marbles((m) => {
+
+        m.reframe(100, 10000);
+
+        const duration = m.time("--|");
+        expect(duration).to.equal(200);
+
+        const source =   m.cold("--(a|)");
+        const expected = m.cold("----(a|)");
+        m.expect(source.delay(duration, m.scheduler)).toBeObservable(expected);
+    }));
+
+    it("should restore after reframing", marbles((m) => {
+
+        const duration = m.time("--|");
+        expect(duration).to.equal(20);
+
+        const source =   m.cold("--(a|)");
+        const expected = m.cold("----(a|)");
+        m.expect(source.delay(duration, m.scheduler)).toBeObservable(expected);
+    }));
 });
diff --git a/source/context.ts b/source/context.ts
@@ -5,6 +5,7 @@
 
 import { Observable } from "rxjs/Observable";
 import { IScheduler } from "rxjs/Scheduler";
+import { VirtualTimeScheduler } from "rxjs/Scheduler/VirtualTimeScheduler";
 import { animationFrame } from "rxjs/scheduler/animationFrame";
 import { asap } from "rxjs/scheduler/asap";
 import { async } from "rxjs/scheduler/async";
@@ -27,6 +28,8 @@ export class Context {
         now?: IScheduler["now"],
         schedule?: IScheduler["schedule"]
     }[] = [];
+    private frameTimeFactor_: number | undefined = undefined;
+    private reframable_ = true;
 
     constructor(public readonly scheduler: TestScheduler) {}
 
@@ -51,6 +54,7 @@ export class Context {
     cold<T = any>(marbles: string, values?: { [key: string]: T }, error?: any): ColdObservable<T> {
 
         const { scheduler } = this;
+        this.reframable_ = false;
         const observable = scheduler.createColdObservable<T>(marbles, values, error);
         observable[argsSymbol] = { error, marbles, values };
         return observable;
@@ -98,6 +102,7 @@ export class Context {
     flush(): void {
 
         const { scheduler } = this;
+        this.reframable_ = false;
         scheduler.flush();
     }
 
@@ -112,11 +117,29 @@ export class Context {
     hot<T = any>(marbles: string, values?: { [key: string]: T }, error?: any): HotObservable<T> {
 
         const { scheduler } = this;
+        this.reframable_ = false;
         const observable = scheduler.createHotObservable<T>(marbles, values, error);
         observable[argsSymbol] = { error, marbles, values };
         return observable;
     }
 
+    reframe(framesPerCharacter: number, maxFrames?: number): void {
+
+        if (!this.reframable_) {
+            throw new Error("Cannot reframe; scheduler already used.");
+        }
+        if (maxFrames === undefined) {
+            maxFrames = framesPerCharacter * 75;
+        }
+
+        this.frameTimeFactor_ = (VirtualTimeScheduler as any).frameTimeFactor;
+        (VirtualTimeScheduler as any).frameTimeFactor = framesPerCharacter;
+        (TestScheduler as any).frameTimeFactor = framesPerCharacter;
+
+        const { scheduler } = this;
+        scheduler.maxFrames = maxFrames;
+    }
+
     teardown(): void {
 
         try {
@@ -139,13 +162,19 @@ export class Context {
                     delete instance.schedule;
                 }
             });
+
+            if (this.frameTimeFactor_) {
+                (VirtualTimeScheduler as any).frameTimeFactor = this.frameTimeFactor_;
+                (TestScheduler as any).frameTimeFactor = this.frameTimeFactor_;
+            }
         }
 
     }
 
     time(marbles: string): number {
 
         const { scheduler } = this;
+        this.reframable_ = false;
         return scheduler.createTime(marbles);
     }
 }