From c230da732a49d587eeadbb76e309987bc7aae7bc Mon Sep 17 00:00:00 2001 From: Simon Friis Vindum Date: Thu, 19 Sep 2019 13:59:05 +0200 Subject: [PATCH] Move tests for time related functions into separate module --- test/behavior.ts | 118 ----------------------------- test/stream.ts | 66 +---------------- test/time.ts | 188 +++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 189 insertions(+), 183 deletions(-) create mode 100644 test/time.ts diff --git a/test/behavior.ts b/test/behavior.ts index 6e0d4ad..4e32d2e 100644 --- a/test/behavior.ts +++ b/test/behavior.ts @@ -9,7 +9,6 @@ import { producerBehavior, push, sinkBehavior, - integrateFrom, moment, format, switchTo, @@ -460,73 +459,6 @@ describe("behavior", () => { H.flat(b).map((s) => s + "bar"); }); }); - describe("integrateFrom", () => { - let clock: SinonFakeTimers; - beforeEach(() => { - clock = useFakeTimers(); - }); - afterEach(() => { - clock.restore(); - }); - it("can integrate", () => { - const acceleration = sinkBehavior(1); - const bIntergrate = integrateFrom(acceleration); - const integration = at(bIntergrate); - assert.strictEqual(at(integration), 0); - clock.tick(2000); - assert.strictEqual(at(integration), 2000); - clock.tick(1000); - assert.strictEqual(at(integration), 3000); - clock.tick(500); - acceleration.push(2); - assert.strictEqual(at(integration), 4000); - }); - it("stays in pull state if parent changes to push", () => { - const fut = H.sinkFuture>(); - const b1 = H.switchTo(fromFunction(() => 4), fut); - const integration = H.runNow(H.integrate(b1)); - observe( - () => {}, - () => { - return () => { - throw new Error("Should not be called."); - }; - }, - integration - ); - fut.resolve(H.sinkBehavior(5)); - }); - it("supports circular dependencies", () => { - const { speed } = H.runNow( - H.loopNow((input: { speed: Behavior }) => - H.sample( - H.moment((at) => { - const velocity = input.speed.map((s) => (s < 4000 ? 1 : 0)); - const speed = at(H.integrateFrom(velocity)); - return { speed }; - }) - ) - ) - ); - speed.observe(() => {}, () => () => {}); - assert.strictEqual(at(speed), 0); - clock.tick(3000); - assert.strictEqual(at(speed), 3000); - clock.tick(1000); - assert.strictEqual(at(speed), 4000); - clock.tick(1000); - assert.strictEqual(at(speed), 4000); - clock.tick(1000); - assert.strictEqual(at(speed), 4000); - }); - it("does not sample parent for no delta", () => { - const b = H.fromFunction(() => { - throw new Error("Must not be called"); - }); - const result = H.runNow(H.integrate(b).chain((bi) => H.sample(bi))); - assert.strictEqual(result, 0); - }); - }); describe("format", () => { it("interpolates string", () => { const bs1 = sinkBehavior("foo"); @@ -972,56 +904,6 @@ describe("Behavior and Stream", () => { // H.subscribe((s) => console.log(s), s3); // }); }); - describe("continuous time", () => { - describe("measureTime", () => { - it("gives time from sample point", () => { - const [setTime, restore] = mockNow(); - setTime(3); - const time = runNow(H.measureTime); - let pull; - const results = []; - observe( - (n: number) => { - results.push(n); - }, - (p) => { - pull = p; - return () => {}; - }, - time - ); - pull(); - setTime(4); - pull(); - setTime(7); - pull(); - assert.deepEqual(results, [0, 1, 4]); - restore(); - }); - }); - describe("time", () => { - it("gives time since UNIX epoch", () => { - let beginPull = false; - let endPull = false; - let pushed: number[] = []; - observe( - (n: number) => pushed.push(n), - (pull) => { - beginPull = true; - return () => { - endPull = true; - }; - }, - H.time - ); - assert.strictEqual(beginPull, true); - const t = at(H.time); - const now = Date.now(); - assert(now - 2 <= t && t <= now); - assert.strictEqual(endPull, false); - }); - }); - }); describe("toggle", () => { it("has correct initial value", () => { const s1 = H.sinkStream(); diff --git a/test/stream.ts b/test/stream.ts index 281e4cd..d627688 100644 --- a/test/stream.ts +++ b/test/stream.ts @@ -1,5 +1,5 @@ import { assert } from "chai"; -import { spy, useFakeTimers } from "sinon"; +import { spy } from "sinon"; import { map, push, @@ -311,70 +311,6 @@ describe("stream", () => { assert.deepEqual(callback.args, [[0], [1], [4], [6]]); }); }); - describe("timing operators", () => { - let clock: any; - beforeEach(() => { - clock = useFakeTimers(); - }); - afterEach(() => { - clock.restore(); - }); - describe("delay", () => { - it("should delay every push", () => { - let n = 0; - const s = H.sinkStream(); - const delayedS = H.runNow(H.delay(50, s)); - delayedS.subscribe(() => (n = 2)); - s.subscribe(() => (n = 1)); - s.push(0); - assert.strictEqual(n, 1); - clock.tick(49); - assert.strictEqual(n, 1); - clock.tick(1); - assert.strictEqual(n, 2); - }); - }); - describe("throttle", () => { - it("after an occurrence it should ignore", () => { - let n = 0; - const s = H.sinkStream(); - const throttleS = H.runNow(H.throttle(100, s)); - throttleS.subscribe((v) => (n = v)); - assert.strictEqual(n, 0); - s.push(1); - assert.strictEqual(n, 1); - clock.tick(80); - s.push(2); - assert.strictEqual(n, 1); - clock.tick(19); - s.push(3); - assert.strictEqual(n, 1); - clock.tick(1); - s.push(4); - assert.strictEqual(n, 4); - }); - }); - describe("debounce", () => { - it("holding the latest occurrence until an amount of time has passed", () => { - let n = 0; - const s = H.sinkStream(); - const debouncedS = H.runNow(H.debounce(100, s)); - debouncedS.subscribe((v) => (n = v)); - assert.strictEqual(n, 0); - s.push(1); - clock.tick(80); - assert.strictEqual(n, 0); - clock.tick(30); - assert.strictEqual(n, 1); - s.push(2); - assert.strictEqual(n, 1); - clock.tick(99); - assert.strictEqual(n, 1); - clock.tick(2); - assert.strictEqual(n, 2); - }); - }); - }); describe("snapshot", () => { it("snapshots pull based Behavior", () => { let n = 0; diff --git a/test/time.ts b/test/time.ts new file mode 100644 index 0000000..d7e740a --- /dev/null +++ b/test/time.ts @@ -0,0 +1,188 @@ +import { assert } from "chai"; +import { useFakeTimers, SinonFakeTimers } from "sinon"; +import * as H from "../src"; +import { mockNow } from "./helpers"; + +describe("behavior", () => { + describe("integrateFrom", () => { + let clock: SinonFakeTimers; + beforeEach(() => { + clock = useFakeTimers(); + }); + afterEach(() => { + clock.restore(); + }); + it("can integrate", () => { + const acceleration = H.sinkBehavior(1); + const bIntergrate = H.integrateFrom(acceleration); + const integration = H.at(bIntergrate); + assert.strictEqual(H.at(integration), 0); + clock.tick(2000); + assert.strictEqual(H.at(integration), 2000); + clock.tick(1000); + assert.strictEqual(H.at(integration), 3000); + clock.tick(500); + acceleration.push(2); + assert.strictEqual(H.at(integration), 4000); + }); + it("stays in pull state if parent changes to push", () => { + const fut = H.sinkFuture>(); + const b1 = H.switchTo(H.fromFunction(() => 4), fut); + const integration = H.runNow(H.integrate(b1)); + H.observe( + () => {}, + () => { + return () => { + throw new Error("Should not be called."); + }; + }, + integration + ); + fut.resolve(H.sinkBehavior(5)); + }); + it("supports circular dependencies", () => { + const { speed } = H.runNow( + H.loopNow((input: { speed: H.Behavior }) => + H.sample( + H.moment((at) => { + const velocity = input.speed.map((s) => (s < 4000 ? 1 : 0)); + const speed = at(H.integrateFrom(velocity)); + return { speed }; + }) + ) + ) + ); + speed.observe(() => {}, () => () => {}); + assert.strictEqual(H.at(speed), 0); + clock.tick(3000); + assert.strictEqual(H.at(speed), 3000); + clock.tick(1000); + assert.strictEqual(H.at(speed), 4000); + clock.tick(1000); + assert.strictEqual(H.at(speed), 4000); + clock.tick(1000); + assert.strictEqual(H.at(speed), 4000); + }); + it("does not sample parent for no delta", () => { + const b = H.fromFunction(() => { + throw new Error("Must not be called"); + }); + const result = H.runNow(H.integrate(b).chain((bi) => H.sample(bi))); + assert.strictEqual(result, 0); + }); + }); + describe("continuous time", () => { + describe("measureTime", () => { + it("gives time from sample point", () => { + const [setTime, restore] = mockNow(); + setTime(3); + const time = H.runNow(H.measureTime); + let pull: (t?: number) => void; + const results = []; + H.observe( + (n: number) => { + results.push(n); + }, + (p) => { + pull = p; + return () => {}; + }, + time + ); + pull(); + setTime(4); + pull(); + setTime(7); + pull(); + assert.deepEqual(results, [0, 1, 4]); + restore(); + }); + }); + describe("time", () => { + it("gives time since UNIX epoch", () => { + let beginPull = false; + let endPull = false; + let pushed: number[] = []; + H.observe( + (n: number) => pushed.push(n), + (_pull) => { + beginPull = true; + return () => { + endPull = true; + }; + }, + H.time + ); + assert.strictEqual(beginPull, true); + const t = H.at(H.time); + const now = Date.now(); + assert(now - 2 <= t && t <= now); + assert.strictEqual(endPull, false); + }); + }); + }); + describe("timing operators", () => { + let clock: any; + beforeEach(() => { + clock = useFakeTimers(); + }); + afterEach(() => { + clock.restore(); + }); + describe("delay", () => { + it("should delay every push", () => { + let n = 0; + const s = H.sinkStream(); + const delayedS = H.runNow(H.delay(50, s)); + delayedS.subscribe(() => (n = 2)); + s.subscribe(() => (n = 1)); + s.push(0); + assert.strictEqual(n, 1); + clock.tick(49); + assert.strictEqual(n, 1); + clock.tick(1); + assert.strictEqual(n, 2); + }); + }); + describe("throttle", () => { + it("after an occurrence it should ignore", () => { + let n = 0; + const s = H.sinkStream(); + const throttleS = H.runNow(H.throttle(100, s)); + throttleS.subscribe((v) => (n = v)); + assert.strictEqual(n, 0); + s.push(1); + assert.strictEqual(n, 1); + clock.tick(80); + s.push(2); + assert.strictEqual(n, 1); + clock.tick(19); + s.push(3); + assert.strictEqual(n, 1); + clock.tick(1); + s.push(4); + assert.strictEqual(n, 4); + }); + }); + describe("debounce", () => { + it("holding the latest occurrence until an amount of time has passed", () => { + let n = 0; + const s = H.sinkStream(); + const debouncedS = H.runNow(H.debounce(100, s)); + debouncedS.subscribe((v) => (n = v)); + assert.strictEqual(n, 0); + s.push(1); + clock.tick(80); + assert.strictEqual(n, 0); + clock.tick(30); + assert.strictEqual(n, 1); + s.push(2); + assert.strictEqual(n, 1); + clock.tick(99); + assert.strictEqual(n, 1); + clock.tick(2); + assert.strictEqual(n, 2); + }); + }); + }); +});