diff --git a/test/.eslintrc.json b/test/.eslintrc.json index cf496752..c8e3c4a0 100644 --- a/test/.eslintrc.json +++ b/test/.eslintrc.json @@ -5,8 +5,12 @@ "rules": { "no-global-assign": 0, "no-empty": ["error", { "allowEmptyCatch": true }], + "no-shadow": "error", + "prefer-const": "error", "es5/no-block-scoping": 0, "es5/no-arrow-functions": 0, - "es5/no-template-literals": 0 + "es5/no-template-literals": 0, + "es5/no-rest-parameters": 0, + "es5/no-shorthand-properties": 0 } } diff --git a/test/atom_test.js b/test/atom_test.js index 7d336193..b8aadd30 100644 --- a/test/atom_test.js +++ b/test/atom_test.js @@ -1,154 +1,148 @@ 'use strict'; -var derivable = require('../dist/derivable'); -var assert = require('assert'); +const derivable = require('../dist/derivable'); -describe("the humble atom", function () { +describe("the humble atom", () => { - var n; + let n; - beforeEach(function() { + beforeEach(() => { n = derivable.atom(0); }); - it("can be dereferenced via .get to obtain its current state", function () { - assert.strictEqual(n.get(), 0); + it("can be dereferenced via .get to obtain its current state", () => { + expect(n.get()).toBe(0); }); - it("can be .set to change its current state", function () { + it("can be .set to change its current state", () => { n.set(1); - assert.strictEqual(n.get(), 1); + expect(n.get()).toBe(1); }); - it("can .update (a la swap in clojure)", function () { + it("can .update (a la swap in clojure)", () => { n.set(1); - var double = function double(x) { - return x * 2; - }; + const double = x => x * 2; n.update(double); - assert.strictEqual(n.get(), 2); + expect(n.get()).toBe(2); n.update(double); - assert.strictEqual(n.get(), 4); + expect(n.get()).toBe(4); }); - it('can take on temporary values inside a transaction', function () { - var a = derivable.atom("a"); - derivable.transact(function (abort) { + it('can take on temporary values inside a transaction', () => { + const a = derivable.atom("a"); + derivable.transact(abort1 => { a.set("b"); - assert.strictEqual(a.get(), "b", "blah and junk"); - derivable.transact(function (abort) { + expect(a.get()).toBe("b"); + derivable.transact(abort2 => { a.set("c"); - assert.strictEqual(a.get(), "c"); - abort(); + expect(a.get()).toBe("c"); + abort2(); }); - assert.strictEqual(a.get(), "b"); - abort(); + expect(a.get()).toBe("b"); + abort1(); }); - assert.strictEqual(a.get(), "a"); + expect(a.get()).toBe("a"); }); - it('should be able to go back to its original value with no ill effects', function () { - var a = derivable.atom("a"); - var reacted = false; - a.react(function () { + it('should be able to go back to its original value with no ill effects', () => { + const a = derivable.atom("a"); + let reacted = false; + a.react(() => { reacted = true; - }, {skipFirst: true}); + }, { skipFirst: true }); - assert.strictEqual(reacted, false, "no reaction to begin with"); + // no reaction to begin with + expect(reacted).toBe(false); - derivable.transact(function () { + derivable.transact(() => { a.set("b"); a.set("a"); }); - assert.strictEqual(reacted, false, "no reaction should take place"); + // no reaction should take place + expect(reacted).toBe(false); }); - it('can keep transaction values if they are\'t aborted', function () { - var a = derivable.atom("a"); - derivable.transact(function () { + it('can keep transaction values if they are\'t aborted', () => { + const a = derivable.atom("a"); + derivable.transact(() => { a.set("b"); - derivable.transact(function () { + derivable.transact(() => { a.set("c"); }); - assert.strictEqual(a.get(), "c"); + expect(a.get()).toBe("c"); }); - assert.strictEqual(a.get(), "c"); + expect(a.get()).toBe("c"); }); - it('can include an equality-checking function', function () { - var a = derivable.atom(0); - var b = a.withEquality(function () { - return false; - }); - assert(a !== b, 'creates a brand new atom'); + it('can include an equality-checking function', () => { + const a = derivable.atom(0); + const b = a.withEquality(() => false); + // creates a brand new atom + expect(a).not.toBe(b); - var numReactions = 0; - a.react(function () { - return numReactions++; + let numReactions = 0; + a.react(() => { + numReactions++; }, { skipFirst: true }); - b.react(function () { - return numReactions++; + b.react(() => { + numReactions++; }, { skipFirst: true }); - assert.strictEqual(numReactions, 0, "0 a"); + expect(numReactions).toBe(0); a.set(0); - assert.strictEqual(numReactions, 0, "0 b"); + expect(numReactions).toBe(0); a.set(0); - assert.strictEqual(numReactions, 0, "0 c"); + expect(numReactions).toBe(0); b.set(0); - assert.strictEqual(numReactions, 1, "0 d"); + expect(numReactions).toBe(1); b.set(0); - assert.strictEqual(numReactions, 2, "0 e"); + expect(numReactions).toBe(2); }); - it('only likes functions or falsey things for equality functions', function () { + it('only likes functions or falsey things for equality functions', () => { derivable.atom(4).withEquality(''); - assert.throws(function () { + expect(() => { derivable.atom(4).withEquality('yo'); - }); + }).toThrow(); derivable.atom(4).withEquality(0); - assert.throws(function () { + expect(() => { derivable.atom(4).withEquality(7); - }); + }).toThrow(); derivable.atom(4).withEquality(null); derivable.atom(4).withEquality(void 0); }); }); -describe('the concurrent modification of _reactors bug', function () { - it('doesnt happen any more', function () { - var $A = derivable.atom(false); - var $B = derivable.atom(false); +describe('the concurrent modification of _reactors bug', () => { + it('doesnt happen any more', () => { + const $A = derivable.atom(false); + const $B = derivable.atom(false); - var A_success = false; - var C_success = false; + let A_success = false; + let C_success = false; - $A.react(function () { + $A.react(() => { A_success = true; - }, { - from: $A - }); + }, { from: $A }); - var $C = $A.and($B); + const $C = $A.and($B); - $C.react(function () { + $C.react(() => { C_success = true; - }, { - from: $C - }); + }, { from: $C }); - assert.strictEqual(A_success, false); - assert.strictEqual(C_success, false); + expect(A_success).toBe(false); + expect(C_success).toBe(false); // used to be that this would cause the 'from' controller on C to be ignored // during the ._maybeReact iteration in .set $A.set(true); - assert.strictEqual(A_success, true); - assert.strictEqual(C_success, false); + expect(A_success).toBe(true); + expect(C_success).toBe(false); $B.set(true); - assert.strictEqual(C_success, true, "expecting c success"); + expect(C_success).toBe(true); }); }); diff --git a/test/derivation_test.js b/test/derivation_test.js index e17bcd0b..2a5267c6 100644 --- a/test/derivation_test.js +++ b/test/derivation_test.js @@ -1,771 +1,750 @@ 'use strict'; -var derivable = require('../dist/derivable'); +const immutable = require('immutable'); -var assert = require('assert'); +const derivable = require('../dist/derivable'); -var immutable = require('immutable'); +const util = require('./util'); -var util = require('./util'); - -describe("a derivation", function () { - var oneGigabyte = 1024 * 1024 * 1024; - var bytes = derivable.atom(oneGigabyte); - var kiloBytes = void 0, - megaBytes = void 0; - - var orderUp = function orderUp(n) { - var order = arguments.length <= 1 || arguments[1] === undefined ? 1 : arguments[1]; +describe("a derivation", () => { + const oneGigabyte = 1024 * 1024 * 1024; + const bytes = derivable.atom(oneGigabyte); + let kiloBytes = void 0; + let megaBytes = void 0; + const orderUp = (n, ...args) => { + const order = args.length === 0 || args[0] === undefined ? 1 : args[0]; return order > 0 ? orderUp(n / 1024, order - 1) : n; }; - it("can be created via the Atom.derive(f) method", function () { + it("can be created via the Atom.derive(f) method", () => { kiloBytes = bytes.derive(orderUp); - assert.strictEqual(kiloBytes.get(), 1024 * 1024); + expect(kiloBytes.get()).toBe(1024 * 1024); }); - it("can also be created via the derive function in the derivable package", function () { - megaBytes = derivable.derive(function () { - return orderUp(kiloBytes.get()); - }); - assert.strictEqual(megaBytes.get(), 1024); + it("can also be created via the derive function in the derivable package", () => { + megaBytes = derivable.derive(() => orderUp(kiloBytes.get())); + expect(megaBytes.get()).toBe(1024); }); - describe("can be created using the 'derive' function", function () { - function add() { - return Array.prototype.reduce.call(arguments, function (a, b) { - return a + b; - }, 0); - } + describe("can be created using the 'derive' function", () => { + const add = (...args) => args.reduce((a, b) => a + b, 0); - it('needs one argument', function () { - assert.throws(function () { derivable.derive(); }); + it('needs one argument', () => { + expect(() => { + derivable.derive(); + }).toThrow(); }); - it('using one arg', function () { - assert.strictEqual(derivable.derive(function() {return 0;}).get(), 0); + it('using one arg', () => { + expect(derivable.derive(() => 0).get()).toBe(0); }); - it('using two args', function () { - assert.strictEqual(derivable.derive(add, 1).get(), 1); - assert.strictEqual(derivable.derive(add, derivable.atom(1)).get(), 1); + it('using two args', () => { + expect(derivable.derive(add, 1).get()).toBe(1); + expect(derivable.derive(add, derivable.atom(1)).get()).toBe(1); }); - it('using three args', function () { - assert.strictEqual(derivable.derive(add, 1, 2).get(), 3); - assert.strictEqual(derivable.derive(add, derivable.atom(1), derivable.atom(2)).get(), 3); + it('using three args', () => { + expect(derivable.derive(add, 1, 2).get()).toBe(3); + expect(derivable.derive(add, derivable.atom(1), derivable.atom(2)).get()).toBe(3); }); - it('using four args', function () { - assert.strictEqual(derivable.derive(add, 1, 2, 3).get(), 6); - assert.strictEqual(derivable.derive(add, derivable.atom(1), derivable.atom(2), derivable.atom(3)).get(), 6); + it('using four args', () => { + expect(derivable.derive(add, 1, 2, 3).get()).toBe(6); + expect( + derivable.derive(add, derivable.atom(1), derivable.atom(2), derivable.atom(3)).get() + ).toBe(6); }); - it('using five args', function () { - assert.strictEqual(derivable.derive(add, 1, 2, 3, 4).get(), 10); - assert.strictEqual(derivable.derive(add, derivable.atom(1), derivable.atom(2), derivable.atom(3), 4).get(), 10); + it('using five args', () => { + expect(derivable.derive(add, 1, 2, 3, 4).get()).toBe(10); + expect( + derivable.derive(add, derivable.atom(1), derivable.atom(2), derivable.atom(3), 4).get() + ).toBe(10); }); - it('using six args', function () { - assert.strictEqual(derivable.derive(add, 1, 2, 3, 4, 5).get(), 15); - assert.strictEqual(derivable.derive(add, derivable.atom(1), derivable.atom(2), derivable.atom(3), 4, 5).get(), 15); + it('using six args', () => { + expect(derivable.derive(add, 1, 2, 3, 4, 5).get()).toBe(15); + expect( + derivable.derive(add, derivable.atom(1), derivable.atom(2), derivable.atom(3), 4, 5).get() + ).toBe(15); }); - it('using seven args', function () { - assert.strictEqual(derivable.derive(add, 1, 2, 3, 4, 5, 6).get(), 21); - assert.strictEqual(derivable.derive(add, derivable.atom(1), derivable.atom(2), - derivable.atom(3), 4, 5, derivable.atom(6)).get(), 21); + it('using seven args', () => { + expect(derivable.derive(add, 1, 2, 3, 4, 5, 6).get()).toBe(21); + expect(derivable.derive(add, derivable.atom(1), derivable.atom(2), + derivable.atom(3), 4, 5, derivable.atom(6)).get()).toBe(21); }); - it('with a template string', function () { - var a = derivable.atom('a'); - var b = 'b'; - var derivation = derivable.derive`a: ${a}, b: ${b}`; + it('with a template string', () => { + const a = derivable.atom('a'); + const b = 'b'; + const derivation = derivable.derive`a: ${a}, b: ${b}`; - assert.strictEqual(derivation.get(), 'a: a, b: b'); + expect(derivation.get()).toBe('a: a, b: b'); }); }); - it("can derive from more than one atom", function () { - var order = util.label(derivable.atom(0), "O"); - var orderName = util.label(order.derive(function (order) { - return ["bytes", "kilobytes", "megabytes", "gigabytes"][order]; - }), "ON"); - var size = util.label(bytes.derive(orderUp, order), "!size!"); - var sizeString = derivable.derive`${size} ${orderName}`; + it("can derive from more than one atom", () => { + const order = util.label(derivable.atom(0), "O"); + const orderName = util.label(order.derive(d => ["bytes", "kilobytes", "megabytes", "gigabytes"][d]), "ON"); + const size = util.label(bytes.derive(orderUp, order), "!size!"); + const sizeString = derivable.derive`${size} ${orderName}`; - assert.strictEqual(size.get(), bytes.get(), "size is in bytes when order is 0"); - assert.strictEqual(sizeString.get(), bytes.get() + " bytes"); + // size is in bytes when order is 0 + expect(size.get()).toBe(bytes.get()); + expect(sizeString.get()).toBe(bytes.get() + " bytes"); order.set(1); - assert.strictEqual(size.get(), kiloBytes.get(), "size is in kbs when order is 1"); - assert.strictEqual(sizeString.get(), kiloBytes.get() + " kilobytes"); + // size is in kbs when order is 1 + expect(size.get()).toBe(kiloBytes.get()); + expect(sizeString.get()).toBe(kiloBytes.get() + " kilobytes"); order.set(2); - assert.strictEqual(size.get(), megaBytes.get(), "size is in mbs when order is 2"); - assert.strictEqual(sizeString.get(), megaBytes.get() + " megabytes"); + // size is in mbs when order is 2 + expect(size.get()).toBe(megaBytes.get()); + expect(sizeString.get()).toBe(megaBytes.get() + " megabytes"); order.set(3); - assert.strictEqual(size.get(), 1, "size is in gbs when order is 2"); - assert.strictEqual(sizeString.get(), "1 gigabytes"); + // size is in gbs when order is 2 + expect(size.get()).toBe(1); + expect(sizeString.get()).toBe("1 gigabytes"); }); - it("implements the derivable interface", function () { - var name = derivable.atom("smithe"); - var size6 = name.derive(function (x) { - return x.length === 6; - }); - var startsWithS = name.derive(function (x) { - return x[0] === "s"; - }); - var endsWithE = name.derive(function (x) { - return x[x.length - 1] === "e"; - }); + it("implements the derivable interface", () => { + const name = derivable.atom("smithe"); + const size6 = name.derive(x => x.length === 6); + const startsWithS = name.derive(x => x[0] === "s"); + const endsWithE = name.derive(x => x[x.length - 1] === "e"); - assert.strictEqual(size6.get(), true, "has length 6"); - assert.strictEqual(startsWithS.get(), true, "starts with s"); - assert.strictEqual(endsWithE.get(), true, "ends wth e"); + expect(size6.get()).toBe(true); + expect(startsWithS.get()).toBe(true); + expect(endsWithE.get()).toBe(true); - var isSmithe = name.is(derivable.atom("smithe")); + const isSmithe = name.is(derivable.atom("smithe")); - assert.strictEqual(isSmithe.get(), true, "is smithe"); + expect(isSmithe.get()).toBe(true); - var size6orE = size6.or(endsWithE); - var size6andE = size6.and(endsWithE); - var sOrE = startsWithS.or(endsWithE); - var sAndE = startsWithS.and(endsWithE); + const size6orE = size6.or(endsWithE); + const size6andE = size6.and(endsWithE); + const sOrE = startsWithS.or(endsWithE); + const sAndE = startsWithS.and(endsWithE); - assert.strictEqual(size6orE.get(), true); - assert.strictEqual(size6andE.get(), true); - assert.strictEqual(sOrE.get(), true); - assert.strictEqual(sAndE.get(), true); + expect(size6orE.get()).toBe(true); + expect(size6andE.get()).toBe(true); + expect(sOrE.get()).toBe(true); + expect(sAndE.get()).toBe(true); name.set("smithy"); - assert.strictEqual(size6.get(), true, "has length 6"); - assert.strictEqual(startsWithS.get(), true, "starts with s"); - assert.strictEqual(endsWithE.get(), false, "ends wth y"); - - assert.strictEqual(isSmithe.get(), false, "is not smithe"); - - assert.strictEqual(size6orE.get(), true); - assert.strictEqual(size6andE.get(), false); - assert.strictEqual(sOrE.get(), true); - assert.strictEqual(sAndE.get(), false); - - assert.strictEqual(size6orE.not().get(), false); - assert.strictEqual(size6andE.not().get(), true); - assert.strictEqual(sOrE.not().get(), false); - assert.strictEqual(sAndE.not().get(), true); - - assert.strictEqual(size6orE.not().not().get(), true); - assert.strictEqual(size6andE.not().not().get(), false); - assert.strictEqual(sOrE.not().not().get(), true); - assert.strictEqual(sAndE.not().not().get(), false); - - assert.strictEqual(name.derive('length').get(), 6); - assert.strictEqual(name.derive(0).get(), "s"); - - startsWithS.then(function () { - return (0, assert)(true, "smithy starts with s"); - }, function () { - return (0, assert)(false, "smithy what?"); - }).get()(); - - endsWithE.then(function () { - return (0, assert)(false, "smithy doesn't end in e?!"); - }, function () { - return (0, assert)(true, "smithy ends in y yo"); - }).get()(); - - var firstLetter = name.derive(function (x) { - return x[0]; - }); - - firstLetter.switch("a", function () { - return (0, assert)(false, "smithy doesn't start with a"); - }, "b", function () { - return (0, assert)(false, "smithy doesn't start with b"); - }, "s", function () { - return (0, assert)(true, "smithy starts with s"); - }).get()(); - - firstLetter.switch("a", function () { - return (0, assert)(false, "allows a default value smithy doesn't start with a"); - }, "b", function () { - return (0, assert)(false, "allows a default value smithy doesn't start with b"); - }, "x", "blah", function () { - return (0, assert)(true, "allows a default value yay"); - }).get()(); - - var nonexistent = derivable.atom(null); - (0, assert)(nonexistent.mThen(false, true).get(), "null doesn't exist"); + expect(size6.get()).toBe(true); + expect(startsWithS.get()).toBe(true); + expect(endsWithE.get()).toBe(false); + + expect(isSmithe.get()).toBe(false); + + expect(size6orE.get()).toBe(true); + expect(size6andE.get()).toBe(false); + expect(sOrE.get()).toBe(true); + expect(sAndE.get()).toBe(false); + + expect(size6orE.not().get()).toBe(false); + expect(size6andE.not().get()).toBe(true); + expect(sOrE.not().get()).toBe(false); + expect(sAndE.not().get()).toBe(true); + + expect(size6orE.not().not().get()).toBe(true); + expect(size6andE.not().not().get()).toBe(false); + expect(sOrE.not().not().get()).toBe(true); + expect(sAndE.not().not().get()).toBe(false); + + expect(name.derive('length').get()).toBe(6); + expect(name.derive(0).get()).toBe("s"); + + expect(() => { + startsWithS.then( + () => "smithy starts with s", + () => { throw Error("smithy what?"); } + ).get()(); + }).not.toThrow(); + + expect(() => { + endsWithE.then( + () => { throw Error("smithy doesn't end in e?!"); }, + () => "smithy ends in y yo" + ).get()(); + }).not.toThrow(); + + const firstLetter = name.derive(x => x[0]); + + expect(() => { + firstLetter.switch( + "a", + () => { throw Error("smithy doesn't start with a"); }, + "b", + () => { throw Error("smithy doesn't start with b"); }, + "s", () => "smithy starts with s" + ).get()(); + }).not.toThrow(); + + expect(() => { + firstLetter.switch( + "a", + () => { throw Error("allows a default value smithy doesn't start with a"); }, + "b", + () => { throw Error("allows a default value smithy doesn't start with b"); }, + "x", + "blah", + () => "allows a default value yay" + ).get()(); + }).not.toThrow(); + + const nonexistent = derivable.atom(null); + // null doesn't exist + expect(nonexistent.mThen(false, true).get()).toBeTruthy(); nonexistent.set(false); - (0, assert)(nonexistent.mThen(true, false).get(), "false exists"); + // false exists + expect(nonexistent.mThen(true, false).get()).toBeTruthy(); nonexistent.set(void 0); - (0, assert)(nonexistent.mThen(false, true).get(), "undefined doesn't exist"); + // undefined doesn't exist + expect(nonexistent.mThen(false, true).get()).toBeTruthy(); nonexistent.set(""); - (0, assert)(nonexistent.mThen(true, false).get(), "the empty string exists"); + // the empty string exists + expect(nonexistent.mThen(true, false).get()).toBeTruthy(); nonexistent.set(0); - (0, assert)(nonexistent.mThen(true, false).get(), "zero exists"); + // zero exists + expect(nonexistent.mThen(true, false).get()).toBeTruthy(); - var nestedStuff = derivable.atom(immutable.fromJS({ a: { b: { c: false } } })); - var get = function get(x, y) { - return x.get(y); - }; - var innermost = nestedStuff.mDerive(get, 'a').mDerive(get, 'b').mDerive(get, 'c').mOr('not found'); + const nestedStuff = derivable.atom(immutable.fromJS({ a: { b: { c: false } } })); + const get = (x, y) => x.get(y); + const innermost = nestedStuff.mDerive(get, 'a').mDerive(get, 'b').mDerive(get, 'c').mOr('not found'); - assert.strictEqual(innermost.get(), false); + expect(innermost.get()).toBe(false); nestedStuff.set(immutable.fromJS({ a: { b: { c: 'found' } } })); - assert.strictEqual(innermost.get(), 'found'); + expect(innermost.get()).toBe('found'); nestedStuff.set(immutable.fromJS({ a: { b: { d: 'd' } } })); - assert.strictEqual(innermost.get(), 'not found'); + expect(innermost.get()).toBe('not found'); nestedStuff.set(immutable.fromJS({ a: { d: { d: 'd' } } })); - assert.strictEqual(innermost.get(), 'not found'); + expect(innermost.get()).toBe('not found'); nestedStuff.set(immutable.fromJS({ d: { d: { d: 'd' } } })); - assert.strictEqual(innermost.get(), 'not found'); + expect(innermost.get()).toBe('not found'); nestedStuff.set(null); - assert.strictEqual(innermost.get(), 'not found'); + expect(innermost.get()).toBe('not found'); - var thingOr = nestedStuff.mOr('not there'); - assert.strictEqual(thingOr.get(), 'not there'); + const thingOr = nestedStuff.mOr('not there'); + expect(thingOr.get()).toBe('not there'); nestedStuff.set(false); - assert.strictEqual(thingOr.get(), false); + expect(thingOr.get()).toBe(false); - var thingAnd = nestedStuff.mAnd('yes there'); + const thingAnd = nestedStuff.mAnd('yes there'); - assert.strictEqual(thingAnd.get(), 'yes there'); + expect(thingAnd.get()).toBe('yes there'); nestedStuff.set(null); - assert.strictEqual(thingAnd.get(), null); + expect(thingAnd.get()).toBe(null); }); - it('can be re-instantiated with custom equality-checking', function () { - var a = derivable.atom(5); - var amod2map = a.derive(function (a) { - return { a: a % 2 }; - }); + it('can be re-instantiated with custom equality-checking', () => { + const a = derivable.atom(5); + const amod2map = a.derive(d => ({ a: d % 2 })); - var numReactions = 0; - amod2map.react(function () { - return numReactions++; + let numReactions = 0; + amod2map.react(() => { + numReactions++; }, { skipFirst: true }); - assert.strictEqual(numReactions, 0); + expect(numReactions).toBe(0); a.set(7); - assert.strictEqual(numReactions, 1); + expect(numReactions).toBe(1); a.set(9); - assert.strictEqual(numReactions, 2); + expect(numReactions).toBe(2); a.set(11); - assert.strictEqual(numReactions, 3); - - var amod2map2 = a.derive(function (a) { - return { a: a % 2 }; - }).withEquality(function (_ref, _ref2) { - var a = _ref.a; - var b = _ref2.a; - return a === b; - }); + expect(numReactions).toBe(3); - var numReactions2 = 0; - amod2map2.react(function () { - return numReactions2++; + const amod2map2 = a + .derive(d => ({ a: d % 2 })) + .withEquality((_ref, _ref2) => _ref.a === _ref2.a); + + let numReactions2 = 0; + amod2map2.react(() => { + numReactions2++; }, { skipFirst: true }); - assert.strictEqual(numReactions2, 0); + expect(numReactions2).toBe(0); a.set(7); - assert.strictEqual(numReactions2, 0); + expect(numReactions2).toBe(0); a.set(9); - assert.strictEqual(numReactions2, 0); + expect(numReactions2).toBe(0); a.set(11); - assert.strictEqual(numReactions2, 0); + expect(numReactions2).toBe(0); }); }); -describe("the derive method", function () { - it("'pluck's when given a string or derivable string", function () { - var obj = derivable.atom({ nested: 'nested!', other: 'also nested!' }); +describe("the derive method", () => { + it("'pluck's when given a string or derivable string", () => { + const obj = derivable.atom({ nested: 'nested!', other: 'also nested!' }); - var nested = obj.derive('nested'); - assert.strictEqual(nested.get(), 'nested!'); + const nested = obj.derive('nested'); + expect(nested.get()).toBe('nested!'); - var prop = derivable.atom('nested'); - var item = obj.derive(prop); - assert.strictEqual(item.get(), 'nested!'); + const prop = derivable.atom('nested'); + const item = obj.derive(prop); + expect(item.get()).toBe('nested!'); prop.set('other'); - assert.strictEqual(item.get(), 'also nested!'); + expect(item.get()).toBe('also nested!'); }); - it("also 'pluck's when given a number or derivable number", function () { - var arr = derivable.atom([1, 2, 3]); - var middle = arr.derive(1); - assert.strictEqual(middle.get(), 2); + it("also 'pluck's when given a number or derivable number", () => { + const arr = derivable.atom([1, 2, 3]); + + const middle = arr.derive(1); + expect(middle.get()).toBe(2); - var cursor = derivable.atom(0); - var item = arr.derive(cursor); + const cursor = derivable.atom(0); + const item = arr.derive(cursor); - assert.strictEqual(item.get(), 1); + expect(item.get()).toBe(1); cursor.set(1); - assert.strictEqual(item.get(), 2); + expect(item.get()).toBe(2); cursor.set(2); - assert.strictEqual(item.get(), 3); + expect(item.get()).toBe(3); }); - it("uses RegExp objects to do string matching", function () { - var string = derivable.atom("this is a lovely string"); - var words = string.derive(/\w+/g); + it("uses RegExp objects to do string matching", () => { + const string = derivable.atom("this is a lovely string"); + const words = string.derive(/\w+/g); - assert.deepEqual(words.get(), ['this', 'is', 'a', 'lovely', 'string']); + expect(words.get()).toEqual(['this', 'is', 'a', 'lovely', 'string']); - var firstLetters = string.derive(/\b\w/g); - assert.deepEqual(firstLetters.get(), ['t', 'i', 'a', 'l', 's']); + const firstLetters = string.derive(/\b\w/g); + expect(firstLetters.get()).toEqual(['t', 'i', 'a', 'l', 's']); string.set("you are so kind"); - assert.deepEqual(firstLetters.get(), ['y', 'a', 's', 'k']); + expect(firstLetters.get()).toEqual(['y', 'a', 's', 'k']); }); - it("throws when given no aguments", function () { - assert.throws(function () { + it("throws when given no aguments", () => { + expect(() => { derivable.atom(null).derive(); - }); + }).toThrow(); }); - it("destructures derivables", function () { - var s = derivable.atom({ a: "aye", b: "bee", c: "cee" }); + it("destructures derivables", () => { + const s = derivable.atom({ a: "aye", b: "bee", c: "cee" }); - var _s$derive = s.derive(['a', 'b', 'c']); + const _s$derive = s.derive(['a', 'b', 'c']); - var a = _s$derive[0]; - var b = _s$derive[1]; - var c = _s$derive[2]; + let a = _s$derive[0]; + let b = _s$derive[1]; + let c = _s$derive[2]; - assert.strictEqual(a.get(), "aye"); - assert.strictEqual(b.get(), "bee"); - assert.strictEqual(c.get(), "cee"); + expect(a.get()).toBe("aye"); + expect(b.get()).toBe("bee"); + expect(c.get()).toBe("cee"); // swap a and c over - var aKey = derivable.atom('c'); - var cKey = derivable.atom('a'); + const aKey = derivable.atom('c'); + const cKey = derivable.atom('a'); - var _s$derive3 = s.derive([aKey, 'b', cKey]); + const _s$derive3 = s.derive([aKey, 'b', cKey]); a = _s$derive3[0]; b = _s$derive3[1]; c = _s$derive3[2]; - assert.strictEqual(a.get(), "cee"); - assert.strictEqual(b.get(), "bee"); - assert.strictEqual(c.get(), "aye"); + expect(a.get()).toBe("cee"); + expect(b.get()).toBe("bee"); + expect(c.get()).toBe("aye"); aKey.set('a'); cKey.set('c'); - assert.strictEqual(a.get(), "aye"); - assert.strictEqual(b.get(), "bee"); - assert.strictEqual(c.get(), "cee"); + expect(a.get()).toBe("aye"); + expect(b.get()).toBe("bee"); + expect(c.get()).toBe("cee"); - var arr = derivable.atom(['naught', 'one', 'two']); + const arr = derivable.atom(['naught', 'one', 'two']); - var _arr$derive = arr.derive([0, 1, derivable.atom(2)]); + const _arr$derive = arr.derive([0, 1, derivable.atom(2)]); - var naught = _arr$derive[0]; - var one = _arr$derive[1]; - var two = _arr$derive[2]; + const naught = _arr$derive[0]; + const one = _arr$derive[1]; + const two = _arr$derive[2]; - assert.strictEqual(naught.get(), "naught"); - assert.strictEqual(one.get(), "one"); - assert.strictEqual(two.get(), "two"); + expect(naught.get()).toBe("naught"); + expect(one.get()).toBe("one"); + expect(two.get()).toBe("two"); arr.set(['love', 'fifteen', 'thirty']); - assert.strictEqual(naught.get(), "love"); - assert.strictEqual(one.get(), "fifteen"); - assert.strictEqual(two.get(), "thirty"); + expect(naught.get()).toBe("love"); + expect(one.get()).toBe("fifteen"); + expect(two.get()).toBe("thirty"); }); - it('can also do destructuring with regexps etc', function () { - var string = derivable.atom("you are so kind"); + it('can also do destructuring with regexps etc', () => { + const string = derivable.atom("you are so kind"); - var _string$derive = string.derive([/\b\w/g, 'length', function (s) { - return s.split(' ').pop(); - }, 0]); + const _string$derive = string.derive([/\b\w/g, 'length', s => s.split(' ').pop(), 0]); - var firstLetters = _string$derive[0]; - var len = _string$derive[1]; - var lastWord = _string$derive[2]; - var firstChar = _string$derive[3]; + const firstLetters = _string$derive[0]; + const len = _string$derive[1]; + const lastWord = _string$derive[2]; + const firstChar = _string$derive[3]; - assert.deepEqual(firstLetters.get(), ['y', 'a', 's', 'k']); - assert.strictEqual(len.get(), 15); - assert.strictEqual(lastWord.get(), 'kind'); - assert.strictEqual(firstChar.get(), 'y'); + expect(firstLetters.get()).toEqual(['y', 'a', 's', 'k']); + expect(len.get()).toBe(15); + expect(lastWord.get()).toBe('kind'); + expect(firstChar.get()).toBe('y'); string.set('thank you'); - assert.deepEqual(firstLetters.get(), ['t', 'y']); - assert.strictEqual(len.get(), 9); - assert.strictEqual(lastWord.get(), 'you'); - assert.strictEqual(firstChar.get(), 't'); + expect(firstLetters.get()).toEqual(['t', 'y']); + expect(len.get()).toBe(9); + expect(lastWord.get()).toBe('you'); + expect(firstChar.get()).toBe('t'); }); - it('can derive with derivable functions', function () { - var $Deriver = derivable.atom(function (n) { - return n * 2; - }); + it('can derive with derivable functions', () => { + const $Deriver = derivable.atom(n => n * 2); - var $A = derivable.atom(4); + const $A = derivable.atom(4); - var $b = $A.derive($Deriver); + const $b = $A.derive($Deriver); - assert.strictEqual($b.get(), 8); + expect($b.get()).toBe(8); - $Deriver.set(function (n) { - return n / 2; - }); + $Deriver.set(n => n / 2); - assert.strictEqual($b.get(), 2); + expect($b.get()).toBe(2); }); - it('can derive with derivable regexps', function () { - var $Deriver = derivable.atom(/[a-z]+/); + it('can derive with derivable regexps', () => { + const $Deriver = derivable.atom(/[a-z]+/); - var $A = derivable.atom("29892funtimes232"); + const $A = derivable.atom("29892funtimes232"); - var $b = $A.derive($Deriver); + const $b = $A.derive($Deriver); - assert.strictEqual($b.get()[0], "funtimes"); + expect($b.get()[0]).toBe("funtimes"); $Deriver.set(/\d+/); - assert.strictEqual($b.get()[0], "29892"); + expect($b.get()[0]).toBe("29892"); }); - it('can\'t derive with some kinds of things', function () { - assert.throws(function () { - return derivable.atom("blah").derive(new Date()); - }); + it('can\'t derive with some kinds of things', () => { + expect(() => { + derivable.atom("blah").derive(new Date()); + }).toThrow(); }); - it('can\'t derive with some kinds of derivable things', function () { - var $Deriver = derivable.atom(new Date()); + it('can\'t derive with some kinds of derivable things', () => { + const $Deriver = derivable.atom(new Date()); - var $A = derivable.atom("29892funtimes232"); + const $A = derivable.atom("29892funtimes232"); - var $b = $A.derive($Deriver); + const $b = $A.derive($Deriver); - assert.throws(function () { - return $b.get(); - }); + expect(() => { + $b.get(); + }).toThrow(); }); - function add() { - return Array.prototype.reduce.call(arguments, function (a, b) { - return a + b; - }, 0); - } - it('can work with three args', function () { - assert.strictEqual(derivable.atom(1).derive(add, 2, 3).get(), 6); - assert.strictEqual(derivable.atom(1).derive(add, derivable.atom(2), derivable.atom(3)).get(), 6); + const add = (...args) => args.reduce((a, b) => a + b, 0); + + it('can work with three args', () => { + expect(derivable.atom(1).derive(add, 2, 3).get()).toBe(6); + expect(derivable.atom(1).derive(add, derivable.atom(2), derivable.atom(3)).get()).toBe(6); }); - it('can work with four args', function () { - assert.strictEqual(derivable.atom(1).derive(add, 2, 3, 4).get(), 10); - assert.strictEqual(derivable.atom(1).derive(add, derivable.atom(2), derivable.atom(3), 4).get(), 10); + it('can work with four args', () => { + expect(derivable.atom(1).derive(add, 2, 3, 4).get()).toBe(10); + expect( + derivable.atom(1).derive(add, derivable.atom(2), derivable.atom(3), 4).get() + ).toBe(10); }); - it('can work with five args', function () { - assert.strictEqual(derivable.atom(1).derive(add, 2, 3, 4, 5).get(), 15); - assert.strictEqual(derivable.atom(1).derive(add, derivable.atom(2), derivable.atom(3), 4, 5).get(), 15); + it('can work with five args', () => { + expect(derivable.atom(1).derive(add, 2, 3, 4, 5).get()).toBe(15); + expect( + derivable.atom(1).derive(add, derivable.atom(2), derivable.atom(3), 4, 5).get() + ).toBe(15); }); - it('can work with six args', function () { - assert.strictEqual(derivable.atom(1).derive(add, 2, 3, 4, 5, 6).get(), 21); - assert.strictEqual(derivable.atom(1).derive(add, derivable.atom(2), derivable.atom(3), 4, 5, derivable.atom(6)).get(), 21); + it('can work with six args', () => { + expect(derivable.atom(1).derive(add, 2, 3, 4, 5, 6).get()).toBe(21); + expect( + derivable.atom(1).derive(add, derivable.atom(2), derivable.atom(3), 4, 5, derivable.atom(6)).get() + ).toBe(21); }); - it('can work with seven args', function () { - assert.strictEqual(derivable.atom(1).derive(add, 2, 3, 4, 5, 6, 7).get(), 28); - assert.strictEqual(derivable.atom(1).derive(add, derivable.atom(2), derivable.atom(3), 4, 5, derivable.atom(6), derivable.atom(7)).get(), 28); + it('can work with seven args', () => { + expect(derivable.atom(1).derive(add, 2, 3, 4, 5, 6, 7).get()).toBe(28); + expect( + derivable.atom(1).derive(add, derivable.atom(2), derivable.atom(3), 4, 5, derivable.atom(6), derivable.atom(7)).get() + ).toBe(28); }); }); -describe("mDerive", function () { - it('is like derive, but propagates nulls', function () { - var thing = derivable.atom({ prop: 'val' }); - var val = thing.mDerive('prop'); +describe("mDerive", () => { + it('is like derive, but propagates nulls', () => { + const thing = derivable.atom({ prop: 'val' }); + const val = thing.mDerive('prop'); - assert.strictEqual(val.get(), 'val'); + expect(val.get()).toBe('val'); thing.set(null); - assert.equal(val.get(), null); - - var _thing$mDerive = thing.mDerive(['foo', 'bar']); + expect(val.get() == null).toBeTruthy(); - var foo = _thing$mDerive[0]; - var bar = _thing$mDerive[1]; + const _thing$mDerive = thing.mDerive(['foo', 'bar']); + const foo = _thing$mDerive[0]; + const bar = _thing$mDerive[1]; - assert.equal(foo.get(), null); - assert.equal(bar.get(), null); + expect(foo.get() == null).toBeTruthy(); + expect(bar.get() == null).toBeTruthy(); thing.set({ foo: 'FOO!', bar: 'BAR!' }); - assert.strictEqual(foo.get(), 'FOO!'); - assert.strictEqual(bar.get(), 'BAR!'); + expect(foo.get()).toBe('FOO!'); + expect(bar.get()).toBe('BAR!'); }); }); -describe("derivations inside a transaction", function () { - it("can take on temporary values", function () { - var a = derivable.atom(0); - var plusOne = a.derive(function (a) { - return a + 1; - }); +describe("derivations inside a transaction", () => { + it("can take on temporary values", () => { + const a = derivable.atom(0); + const plusOne = a.derive(d => d + 1); - assert.strictEqual(plusOne.get(), 1); + expect(plusOne.get()).toBe(1); - derivable.transact(function (abort) { + derivable.transact(abort => { a.set(1); - assert.strictEqual(plusOne.get(), 2); + expect(plusOne.get()).toBe(2); abort(); }); - assert.strictEqual(plusOne.get(), 1); + expect(plusOne.get()).toBe(1); - var thrown = null; + let thrown = null; try { - derivable.transact(function () { + derivable.transact(() => { a.set(2); - assert.strictEqual(plusOne.get(), 3); + expect(plusOne.get()).toBe(3); throw "death"; }); } catch (e) { thrown = e; } - assert.strictEqual(thrown, "death"); - assert.strictEqual(plusOne.get(), 1); + expect(thrown).toBe("death"); + expect(plusOne.get()).toBe(1); }); - it('can take on temporary values even in nested transactions', function () { - var a = derivable.atom(0); - var plusOne = a.derive(function (a) { - return a + 1; - }); + it('can take on temporary values even in nested transactions', () => { + const a = derivable.atom(0); + const plusOne = a.derive(d => d + 1); - assert.strictEqual(plusOne.get(), 1); + expect(plusOne.get()).toBe(1); - derivable.transact(function (abort) { + derivable.transact(abort1 => { a.set(1); - assert.strictEqual(plusOne.get(), 2); - derivable.transact(function (abort) { + expect(plusOne.get()).toBe(2); + derivable.transact(abort2 => { a.set(2); - assert.strictEqual(plusOne.get(), 3); - derivable.transact(function (abort) { + expect(plusOne.get()).toBe(3); + derivable.transact(abort3 => { a.set(3); - assert.strictEqual(plusOne.get(), 4); - abort(); + expect(plusOne.get()).toBe(4); + abort3(); }); - assert.strictEqual(plusOne.get(), 3); - abort(); + expect(plusOne.get()).toBe(3); + abort2(); }); - assert.strictEqual(plusOne.get(), 2); - abort(); + expect(plusOne.get()).toBe(2); + abort1(); }); - assert.strictEqual(plusOne.get(), 1); + expect(plusOne.get()).toBe(1); }); - it('can be dereferenced in nested transactions', function () { - var a = derivable.atom(0); - var plusOne = a.derive(function (a) { - return a + 1; - }); + it('can be dereferenced in nested transactions', () => { + const a = derivable.atom(0); + const plusOne = a.derive(d => d + 1); - assert.strictEqual(plusOne.get(), 1); + expect(plusOne.get()).toBe(1); - derivable.transact(function () { - assert.strictEqual(plusOne.get(), 1); - derivable.transact(function () { - assert.strictEqual(plusOne.get(), 1); - derivable.transact(function () { - assert.strictEqual(plusOne.get(), 1); + derivable.transact(() => { + expect(plusOne.get()).toBe(1); + derivable.transact(() => { + expect(plusOne.get()).toBe(1); + derivable.transact(() => { + expect(plusOne.get()).toBe(1); }); }); }); a.set(1); - derivable.transact(function () { - derivable.transact(function () { - derivable.transact(function () { - assert.strictEqual(plusOne.get(), 2); + derivable.transact(() => { + derivable.transact(() => { + derivable.transact(() => { + expect(plusOne.get()).toBe(2); }); }); }); }); - it('can be mutated indirectly in nested transactions', function () { - var a = derivable.atom(0); - var plusOne = a.derive(function (a) { - return a + 1; - }); + it('can be mutated indirectly in nested transactions', () => { + const a = derivable.atom(0); + const plusOne = a.derive(d => d + 1); - assert.strictEqual(plusOne.get(), 1); + expect(plusOne.get()).toBe(1); - derivable.transact(function () { - derivable.transact(function () { - derivable.transact(function () { + derivable.transact(() => { + derivable.transact(() => { + derivable.transact(() => { a.set(1); }); }); }); - assert.strictEqual(plusOne.get(), 2); + expect(plusOne.get()).toBe(2); - derivable.transact(function () { - derivable.transact(function () { - derivable.transact(function () { + derivable.transact(() => { + derivable.transact(() => { + derivable.transact(() => { a.set(2); }); }); - assert.strictEqual(plusOne.get(), 3); + expect(plusOne.get()).toBe(3); }); - derivable.transact(function () { - derivable.transact(function () { - derivable.transact(function () { + derivable.transact(() => { + derivable.transact(() => { + derivable.transact(() => { a.set(3); }); - assert.strictEqual(plusOne.get(), 4); + expect(plusOne.get()).toBe(4); }); }); }); }); -describe("nested derivables", function () { - it("should work in the appropriate fashion", function () { - var $$A = derivable.atom(null); - var $a = $$A.mDerive(function ($a) { - return $a.get(); - }); +describe("nested derivables", () => { + it("should work in the appropriate fashion", () => { + const $$A = derivable.atom(null); + const $a = $$A.mDerive(d => d.get()); - (0, assert)($a.get() == null); + expect($a.get() == null).toBeTruthy(); - var $B = derivable.atom(5); + const $B = derivable.atom(5); $$A.set($B); - assert.strictEqual($a.get(), 5); + expect($a.get()).toBe(5); - var reaction_b = null; - $a.react(function (b) { + let reaction_b = null; + $a.react(b => { reaction_b = b; }, { skipFirst: true }); - assert.strictEqual(reaction_b, null); + expect(reaction_b).toBe(null); $B.set(10); - assert.strictEqual(reaction_b, 10); + expect(reaction_b).toBe(10); $B.set(4); - assert.strictEqual(reaction_b, 4); + expect(reaction_b).toBe(4); - var $C = derivable.atom(9); + const $C = derivable.atom(9); $$A.set($C); - assert.strictEqual(reaction_b, 9); + expect(reaction_b).toBe(9); }); - it("should let reactors adapt to changes in atoms", function () { - var $$A = derivable.atom(null); - var $a = $$A.mDerive(function ($a) { - return $a.get(); - }); + it("should let reactors adapt to changes in atoms", () => { + const $$A = derivable.atom(null); + const $a = $$A.mDerive(d => d.get()); - var $B = derivable.atom('junk'); + const $B = derivable.atom('junk'); - var $isJunk = $B.is('junk'); + const $isJunk = $B.is('junk'); - var isJunk = null; + let isJunk = null; - $a.react(function (a) { + $a.react(a => { isJunk = a; }); - (0, assert)(isJunk == null); + expect(isJunk == null).toBeTruthy(); $$A.set($isJunk); - assert.strictEqual(isJunk, true, "bad one"); + expect(isJunk).toBe(true); $B.set('not junk'); - assert.strictEqual(isJunk, false, "bad other"); + expect(isJunk).toBe(false); }); - it("should not interfere with lifecycle control", function () { - var $$A = derivable.atom(null); - var $a = $$A.mDerive(function ($a) { - return $a.get(); - }); + it("should not interfere with lifecycle control", () => { + const $$A = derivable.atom(null); + const $a = $$A.mDerive(d => d.get()); - var $B = derivable.atom('junk'); + const $B = derivable.atom('junk'); - var $isJunk = $B.is('junk'); + const $isJunk = $B.is('junk'); - var isJunk = null; + let isJunk = null; - $a.react(function (a) { + $a.react(a => { isJunk = a; }, { when: $a }); - (0, assert)(isJunk == null); + expect(isJunk == null).toBeTruthy(); $$A.set($isJunk); - assert.strictEqual(isJunk, true); + expect(isJunk).toBe(true); $B.set('not junk'); // still junk - assert.strictEqual(isJunk, true); + expect(isJunk).toBe(true); }); - it("should not interfere with boolean casting?!", function () { - var $$Running = derivable.atom(null); - var $running = $$Running.mDerive(function ($a) { - return $a.get(); - }); + it("should not interfere with boolean casting?!", () => { + const $$Running = derivable.atom(null); + const $running = $$Running.mDerive(d => d.get()); - var running = null; - $running.derive(function (x) { - return !!x; - }).react(function (r) { + let running = null; + $running.derive(x => Boolean(x)).react(r => { running = r; }); - (0, assert)(!running); + expect(!running).toBeTruthy(); - var $Running = derivable.atom(false); + const $Running = derivable.atom(false); $$Running.set($Running); - (0, assert)(!running); + expect(!running).toBeTruthy(); $Running.set(true); - (0, assert)(running); + expect(running).toBeTruthy(); }); }); diff --git a/test/devtools_test.js b/test/devtools_test.js index 6dcd0fdb..526f30ec 100644 --- a/test/devtools_test.js +++ b/test/devtools_test.js @@ -4,7 +4,7 @@ const hook = jest.fn(); global.__DERIVABLE_DEVTOOLS_HOOK__ = hook; const atom = require('../').atom; -test('capture every atom get and pass to devtools hook', function () { +test('capture every atom get and pass to devtools hook', () => { const a = atom(1); a.react(() => {}); diff --git a/test/module_test.js b/test/module_test.js index 4365d654..1aba4522 100644 --- a/test/module_test.js +++ b/test/module_test.js @@ -1,602 +1,591 @@ 'use strict'; -var derivable = require('../dist/derivable'); +const derivable = require('../dist/derivable'); -var assert = require('assert'); +describe("the `is*` fns", () => { + it("just work, don't worry about it", () => { + const a = derivable.atom(0); + const d = a.derive(x => x * 2); + const p = a.proxy({ get: x => x * 2, set: (_, x) => x / 2 }); -describe("the `is*` fns", function () { - it("just work, don't worry about it", function () { - var a = derivable.atom(0); - var d = a.derive(function (x) { - return x * 2; - }); - var p = a.proxy({ get: function get(x) { - return x * 2; - }, set: function set(_, x) { - return x / 2; - } }); - - assert(derivable.isAtom(a), "a is an atom"); - assert(!derivable.isAtom(d), "d is not an atom"); - assert(derivable.isAtom(p), "p is an atom"); - - assert(!derivable.isDerivation(a), "a is not a derivation"); - assert(derivable.isDerivation(d), "d is a derivation"); - assert(derivable.isDerivation(p), "p is a derivation"); - - assert(!derivable.isProxy(a), "a is not a proxy"); - assert(derivable.isProxy(p), "p is a proxy"); - assert(!derivable.isProxy(d), "d is not a proxy"); - - assert(derivable.isDerivable(a), "a is derivable"); - assert(derivable.isDerivable(d), "d is derivable"); - assert(derivable.isDerivable(p), "p is derivable"); + expect(derivable.isAtom(a)).toBeTruthy(); + expect(derivable.isAtom(d)).toBeFalsy(); + expect(derivable.isAtom(p)).toBeTruthy(); + + expect(derivable.isDerivation(a)).toBeFalsy(); + expect(derivable.isDerivation(d)).toBeTruthy(); + expect(derivable.isDerivation(p)).toBeTruthy(); + + expect(derivable.isProxy(a)).toBeFalsy(); + expect(derivable.isProxy(p)).toBeTruthy(); + expect(derivable.isProxy(d)).toBeFalsy(); + + expect(derivable.isDerivable(a)).toBeTruthy(); + expect(derivable.isDerivable(d)).toBeTruthy(); + expect(derivable.isDerivable(p)).toBeTruthy(); }); }); -describe("the `struct` function", function () { - it("expects a plain object or a plain array", function () { - assert.throws(function () { +describe("the `struct` function", () => { + it("expects a plain object or a plain array", () => { + expect(() => { derivable.struct(); - }); - assert.throws(function () { + }).toThrow(); + expect(() => { derivable.struct(53); - }); - assert.throws(function () { + }).toThrow(); + expect(() => { derivable.struct(new Date()); - }); - assert.throws(function () { + }).toThrow(); + expect(() => { derivable.struct(derivable.atom(4)); - }); + }).toThrow(); derivable.struct({}); derivable.struct([]); - assert.throws(function () { + expect(() => { derivable.struct(derivable.struct({})); - }); + }).toThrow(); }); - it("turns an array of derivables into a derivable", function () { - var fib1 = derivable.atom(0), - fib2 = derivable.atom(1), - fib = derivable.derive(function () { - return fib1.get() + fib2.get(); - }); - var grouped = derivable.struct([fib1, fib2, fib]); - assert.deepEqual([0, 1, 1], grouped.get()); + it("turns an array of derivables into a derivable", () => { + const fib1 = derivable.atom(0); + const fib2 = derivable.atom(1); + const fib = derivable.derive(() => fib1.get() + fib2.get()); + + const grouped = derivable.struct([fib1, fib2, fib]); + expect([0, 1, 1]).toEqual(grouped.get()); fib1.set(1); - assert.deepEqual([1, 1, 2], grouped.get()); + expect([1, 1, 2]).toEqual(grouped.get()); }); - it("turns a map of derivables into a derivable", function () { - var name = derivable.atom("wilbur"), - telephone = derivable.atom("0987654321"); + it("turns a map of derivables into a derivable", () => { + const name = derivable.atom("wilbur"); + const telephone = derivable.atom("0987654321"); - var grouped = derivable.struct({ name: name, telephone: telephone }); + const grouped = derivable.struct({ name, telephone }); - assert.deepEqual({ name: "wilbur", telephone: "0987654321" }, grouped.get()); + expect({ name: "wilbur", telephone: "0987654321" }).toEqual(grouped.get()); name.set("Jemimah"); telephone.set("n/a"); - assert.deepEqual({ name: "Jemimah", telephone: "n/a" }, grouped.get()); + expect({ name: "Jemimah", telephone: "n/a" }).toEqual(grouped.get()); }); - it("actually turns any arbitrarily nested structure of" + " maybe-derivables into a derivable", function () { - var name = derivable.atom("wilbur"), - telephone = derivable.atom("0987654321"), - friend1Name = derivable.atom("Sylvester"), - friend1Telephone = derivable.atom("blub"); + it("actually turns any arbitrarily nested structure of" + " maybe-derivables into a derivable", () => { + const name = derivable.atom("wilbur"); + const telephone = derivable.atom("0987654321"); + const friend1Name = derivable.atom("Sylvester"); + const friend1Telephone = derivable.atom("blub"); - var grouped = derivable.struct({ - name: name, telephone: telephone, + const grouped = derivable.struct({ + name, + telephone, blood_type: "AB Negative", age: 75, friends: [{ name: friend1Name, telephone: friend1Telephone }, "others"] }); - var expected1 = { + expect({ name: "wilbur", telephone: "0987654321", blood_type: "AB Negative", age: 75, friends: [{ name: "Sylvester", telephone: "blub" }, "others"] - }; - - assert.deepEqual(expected1, grouped.get()); + }).toEqual(grouped.get()); friend1Name.set("Brittany"); - var expected2 = { + expect({ name: "wilbur", telephone: "0987654321", blood_type: "AB Negative", age: 75, friends: [{ name: "Brittany", telephone: "blub" }, "others"] - }; - - assert.deepEqual(expected2, grouped.get()); + }).toEqual(grouped.get()); }); - it("only accepts plain objects or arrays", function () { - assert.throws(function () { - return derivable.struct(3); - }); - assert.throws(function () { - return derivable.struct("blah"); - }); - assert.throws(function () { - return derivable.struct(new Error()); - }); + it("only accepts plain objects or arrays", () => { + expect(() => { + derivable.struct(3); + }).toThrow(); + expect(() => { + derivable.struct("blah"); + }).toThrow(); + expect(() => { + derivable.struct(new Error()); + }).toThrow(); function A() {} - assert.throws(function () { - return derivable.struct(new A()); - }); - assert.throws(function () { - return derivable.struct(/\d+/); - }); + expect(() => { + derivable.struct(new A()); + }).toThrow(); + expect(() => { + derivable.struct(/\d+/); + }).toThrow(); }); }); -describe("boolean logic", function () { - it("is well understood", function () { - var a = derivable.atom(true), - b = derivable.atom(true), - aANDb = derivable.and(a, b), - aORb = derivable.or(a, b), - NOTa = a.not(); - - assert.strictEqual(aANDb.get(), true, "true & true = true"); - assert.strictEqual(aORb.get(), true, "true | true = true"); - assert.strictEqual(NOTa.get(), false, "!true = false"); +describe("boolean logic", () => { + it("is well understood", () => { + const a = derivable.atom(true); + const b = derivable.atom(true); + const aANDb = derivable.and(a, b); + const aORb = derivable.or(a, b); + const NOTa = a.not(); + + // true & true = true + expect(aANDb.get()).toBe(true); + // true | true = true + expect(aORb.get()).toBe(true); + // !true = false + expect(NOTa.get()).toBe(false); b.set(false); - assert.strictEqual(aANDb.get(), false, "true & false = false"); - assert.strictEqual(aORb.get(), true, "true | false = true"); + // true & false = false + expect(aANDb.get()).toBe(false); + // true | false = true + expect(aORb.get()).toBe(true); a.set(false); - assert.strictEqual(aANDb.get(), false, "false & false = false"); - assert.strictEqual(aORb.get(), false, "false | false = false"); - assert.strictEqual(NOTa.get(), true, "!false = true"); + // false & false = false + expect(aANDb.get()).toBe(false); + // false | false = false + expect(aORb.get()).toBe(false); + // !false = true + expect(NOTa.get()).toBe(true); }); - it("is mirrored for dealing with null/undefined", function () { - var a = derivable.atom(false), - b = derivable.atom(false), - aANDb = derivable.mAnd(a, b).mThen(true, false), - aORb = derivable.mOr(a, b).mThen(true, false); + it("is mirrored for dealing with null/undefined", () => { + const a = derivable.atom(false); + const b = derivable.atom(false); + const aANDb = derivable.mAnd(a, b).mThen(true, false); + const aORb = derivable.mOr(a, b).mThen(true, false); - assert.strictEqual(aANDb.get(), true, "false m& false m= true"); - assert.strictEqual(aORb.get(), true, "false m| false m= true"); + // false m& false m= true + expect(aANDb.get()).toBe(true); + // false m| false m= true + expect(aORb.get()).toBe(true); a.set(null); - assert.strictEqual(aANDb.get(), false, "null m& false m= false"); - assert.strictEqual(aORb.get(), true, "null m| false m= true"); + // null m& false m= false + expect(aANDb.get()).toBe(false); + // null m| false m= true + expect(aORb.get()).toBe(true); b.set(null); - assert.strictEqual(aANDb.get(), false, "null m& null m= false"); - assert.strictEqual(aORb.get(), false, "null m| null m= false"); + // null m& null m= false + expect(aANDb.get()).toBe(false); + // null m| null m= false + expect(aORb.get()).toBe(false); }); }); -describe("control flow", function () { - it("allows different paths to be taken depending on conditions", function () { - var number = derivable.atom(0); - var even = number.derive(function (n) { - return n % 2 === 0; - }); +describe("control flow", () => { + it("allows different paths to be taken depending on conditions", () => { + const number = derivable.atom(0); + const even = number.derive(n => n % 2 === 0); - var message = even.then("even", "odd"); + const message = even.then("even", "odd"); - assert.strictEqual(message.get(), "even"); + expect(message.get()).toBe("even"); number.set(1); - assert.strictEqual(message.get(), "odd"); + expect(message.get()).toBe("odd"); }); - it("doesn't evaluate untaken paths", function () { - var number = derivable.atom(0); - var even = number.derive(function (n) { - return n % 2 === 0; - }); + it("doesn't evaluate untaken paths", () => { + const number = derivable.atom(0); + const even = number.derive(n => n % 2 === 0); - var dideven = false; - var didodd = false; + let dideven = false; + let didodd = false; - var chooseAPath = even.then(derivable.derive(function () { - dideven = true; - }), derivable.derive(function () { - didodd = true; - })); + const chooseAPath = even.then( + derivable.derive(() => { + dideven = true; + }), + derivable.derive(() => { + didodd = true; + }) + ); chooseAPath.get(); - assert(dideven && !didodd, "didnt eval odd path"); + expect(dideven && !didodd).toBeTruthy(); dideven = false; - assert(!dideven && !didodd, "didnt eval anything yet1"); + expect(!dideven && !didodd).toBeTruthy(); number.set(1); - assert(!dideven && !didodd, "didnt eval anything yet2"); + expect(!dideven && !didodd).toBeTruthy(); chooseAPath.get(); - assert(!dideven && didodd, "didnt eval even path"); + expect(!dideven && didodd).toBeTruthy(); }); - it("same goes for the switch statement", function () { - var thing = derivable.atom("Tigran"); + it("same goes for the switch statement", () => { + const thing = derivable.atom("Tigran"); - var result = thing.switch("Banana", "YUMMY", 532, "FiveThreeTwo", "Tigran", "Hamasayan"); + const result = thing.switch("Banana", "YUMMY", 532, "FiveThreeTwo", "Tigran", "Hamasayan"); - assert.strictEqual("Hamasayan", result.get()); + expect("Hamasayan").toBe(result.get()); thing.set("Banana"); - assert.strictEqual("YUMMY", result.get()); + expect("YUMMY").toBe(result.get()); thing.set(532); - assert.strictEqual("FiveThreeTwo", result.get()); + expect("FiveThreeTwo").toBe(result.get()); thing.set("nonsense"); - assert(result.get() === void 0); + expect(result.get()).toBe(undefined); - var switcheroo = derivable.atom("a"); + const switcheroo = derivable.atom("a"); - var dida = false, - didb = false, - didc = false, - didx = false; + let dida = false; + let didb = false; + let didc = false; + let didx = false; - var conda = derivable.atom("a"), - condb = derivable.atom("b"), - condc = derivable.atom("c"); + const conda = derivable.atom("a"); + const condb = derivable.atom("b"); + const condc = derivable.atom("c"); - var chooseAPath = switcheroo.switch(conda, derivable.derive(function () { - return dida = true; - }), condb, derivable.derive(function () { - return didb = true; - }), condc, derivable.derive(function () { - return didc = true; - }), - //else - derivable.derive(function () { - return didx = true; - })); + const chooseAPath = switcheroo.switch( + conda, + derivable.derive(() => dida = true), + condb, + derivable.derive(() => didb = true), + condc, + derivable.derive(() => didc = true), + //else + derivable.derive(() => didx = true) + ); - assert(!dida && !didb && !didc && !didx, "did nothing yet 1"); + expect(!dida && !didb && !didc && !didx).toBeTruthy(); chooseAPath.get(); - assert(dida && !didb && !didc && !didx, "did a"); + expect(dida && !didb && !didc && !didx).toBeTruthy(); dida = false; switcheroo.set("b"); - assert(!dida && !didb && !didc && !didx, "did nothing yet 2"); + expect(!dida && !didb && !didc && !didx).toBeTruthy(); chooseAPath.get(); - assert(!dida && didb && !didc && !didx, "did b"); + expect(!dida && didb && !didc && !didx).toBeTruthy(); didb = false; switcheroo.set("c"); - assert(!dida && !didb && !didc && !didx, "did nothing yet 3"); + expect(!dida && !didb && !didc && !didx).toBeTruthy(); chooseAPath.get(); - assert(!dida && !didb && didc && !didx, "did b"); + expect(!dida && !didb && didc && !didx).toBeTruthy(); didc = false; switcheroo.set("blubr"); - assert(!dida && !didb && !didc && !didx, "did nothing yet 4"); + expect(!dida && !didb && !didc && !didx).toBeTruthy(); chooseAPath.get(); - assert(!dida && !didb && !didc && didx, "did else"); + expect(!dida && !didb && !didc && didx).toBeTruthy(); }); }); -describe("lifting by using derive", function () { +describe("lifting by using derive", () => { - var lift = function(f) { - return derivable.derive.bind(null, f); - }; + const lift = f => derivable.derive.bind(null, f); - it("lifts a function which operates on values to operate on derivables", function () { - var plus = function plus(a, b) { - return a + b; - }; - var dPlus = lift(plus); + it("lifts a function which operates on values to operate on derivables", () => { + const plus = (a, b) => a + b; + const dPlus = lift(plus); - var a = derivable.atom(5); - var b = derivable.atom(10); - var c = dPlus(a, b); + const a = derivable.atom(5); + const b = derivable.atom(10); + const c = dPlus(a, b); - assert.equal(15, c.get()); + expect(15).toEqual(c.get()); }); - it("can be used in ordinary FP stuff", function () { - var cells = [0, 1, 2].map(derivable.atom); + it("can be used in ordinary FP stuff", () => { + const cells = [0, 1, 2].map(derivable.atom); - var add = lift(function (a, b) { - return a + b; - }); + const add = lift((a, b) => a + b); - var sum = cells.reduce(add); + const sum = cells.reduce(add); - var expected = 3; - var equalsExpected = false; - sum.react(function (x) { - return equalsExpected = x === expected; + let expected = 3; + let equalsExpected = false; + sum.react((x) => { + equalsExpected = x === expected; }); - assert(equalsExpected); + expect(equalsExpected).toBeTruthy(); expected = 4; equalsExpected = false; - cells[0].update(function (x) { - return x + 1; - }); - assert(equalsExpected); + cells[0].update(x => x + 1); + expect(equalsExpected).toBeTruthy(); }); }); -describe("the `transact` function", function () { - it("executes a function in the context of a transaction", function () { - var a = derivable.atom("a"), - b = derivable.atom("b"); +describe("the `transact` function", () => { + it("executes a function in the context of a transaction", () => { + const a = derivable.atom("a"); + const b = derivable.atom("b"); - var timesChanged = 0; + let timesChanged = 0; - derivable.struct({ a: a, b: b }).react(function () { - return timesChanged++; - }, {skipFirst: true}); + derivable.struct({ a, b }).react(() => { + timesChanged++; + }, { skipFirst: true }); - assert.strictEqual(timesChanged, 0); + expect(timesChanged).toBe(0); - var setAAndB = function setAAndB(a_val, b_val) { + const setAAndB = (a_val, b_val) => { a.set(a_val); b.set(b_val); }; setAAndB("aye", "bee"); - assert.strictEqual(timesChanged, 2); - assert.strictEqual(a.get(), "aye"); - assert.strictEqual(b.get(), "bee"); + expect(timesChanged).toBe(2); + expect(a.get()).toBe("aye"); + expect(b.get()).toBe("bee"); - derivable.transact(function () { - return setAAndB("a", "b"); + derivable.transact(() => { + setAAndB("a", "b"); }); - assert.strictEqual(timesChanged, 3); - assert.strictEqual(a.get(), "a"); - assert.strictEqual(b.get(), "b"); + expect(timesChanged).toBe(3); + expect(a.get()).toBe("a"); + expect(b.get()).toBe("b"); - derivable.transact(function () { - return setAAndB(5, 6); + derivable.transact(() => { + setAAndB(5, 6); }); - assert.strictEqual(timesChanged, 4); - assert.strictEqual(a.get(), 5); - assert.strictEqual(b.get(), 6); + expect(timesChanged).toBe(4); + expect(a.get()).toBe(5); + expect(b.get()).toBe(6); }); }); -describe("the `transaction` function", function () { - it("wraps a function such that its body is executed in a txn", function () { - var a = derivable.atom("a"), - b = derivable.atom("b"); +describe("the `transaction` function", () => { + it("wraps a function such that its body is executed in a txn", () => { + const a = derivable.atom("a"); + const b = derivable.atom("b"); - var timesChanged = 0; + let timesChanged = 0; - derivable.struct({ a: a, b: b }).react(function () { - return timesChanged++; - }, {skipFirst: true}); + derivable.struct({ a, b }).react(() => { + timesChanged++; + }, { skipFirst: true }); - assert.strictEqual(timesChanged, 0); + expect(timesChanged).toBe(0); - var setAAndB = function setAAndB(a_val, b_val) { + const setAAndB = (a_val, b_val) => { a.set(a_val); b.set(b_val); return a_val + b_val; }; - assert.strictEqual(setAAndB("aye", "bee"), "ayebee"); + expect(setAAndB("aye", "bee")).toBe("ayebee"); - assert.strictEqual(timesChanged, 2); - assert.strictEqual(a.get(), "aye"); - assert.strictEqual(b.get(), "bee"); + expect(timesChanged).toBe(2); + expect(a.get()).toBe("aye"); + expect(b.get()).toBe("bee"); - var tSetAAndB = derivable.transaction(setAAndB); + const tSetAAndB = derivable.transaction(setAAndB); - assert.strictEqual(tSetAAndB("a", "b"), "ab"); + expect(tSetAAndB("a", "b")).toBe("ab"); - assert.strictEqual(timesChanged, 3); - assert.strictEqual(a.get(), "a"); - assert.strictEqual(b.get(), "b"); + expect(timesChanged).toBe(3); + expect(a.get()).toBe("a"); + expect(b.get()).toBe("b"); - assert.strictEqual(tSetAAndB(2, 3), 5); + expect(tSetAAndB(2, 3)).toBe(5); - assert.strictEqual(timesChanged, 4); - assert.strictEqual(a.get(), 2); - assert.strictEqual(b.get(), 3); + expect(timesChanged).toBe(4); + expect(a.get()).toBe(2); + expect(b.get()).toBe(3); }); }); -describe("debug mode", function () { - it("causes derivations and reactors to store the stacktraces of their" + " instantiation points", function () { - var d = derivable.derive(function () { - return 0; - }); - assert(!d.stack); +describe("debug mode", () => { + it("causes derivations and reactors to store the stacktraces of their" + " instantiation points", () => { + const d = derivable.derive(() => 0); + expect(!d.stack).toBeTruthy(); derivable.setDebugMode(true); - var e = derivable.derive(function () { + const e = derivable.derive(() => { throw Error(); }); - assert(e.stack); + expect(e.stack).toBeTruthy(); derivable.setDebugMode(false); }); - it("causes stack traces to be printed when things derivations and reactors throw errors", function () { - var d = derivable.derive(function () { - return 0; - }); - assert(!d.stack); + it("causes stack traces to be printed when things derivations and reactors throw errors", () => { + const d = derivable.derive(() => 0); + expect(!d.stack).toBeTruthy(); derivable.setDebugMode(true); - var e = derivable.derive(function () { + const error = derivable.derive(() => { throw "cheese"; }); try { - var err = console.error; - var stack = void 0; - console.error = function (_stack) { + const err = console.error; + let stack = void 0; + console.error = _stack => { stack = _stack; }; - e.get(); - assert.strictEqual(stack, e.stack); + error.get(); + expect(stack).toBe(error.stack); console.error = err; } catch (e) { - assert.strictEqual(e, 'cheese'); + expect(e).toBe('cheese'); } derivable.setDebugMode(false); }); }); -describe('the atomically function', function () { - it('creates a transaction if not already in a transaction', function () { - var $A = derivable.atom('a'); - var numReactions = 0; - $A.react(function () { - return numReactions++; - }, {skipFirst: true}); - assert.strictEqual(numReactions, 0); +describe('the atomically function', () => { + it('creates a transaction if not already in a transaction', () => { + const $A = derivable.atom('a'); + let numReactions = 0; + $A.react(() => { + numReactions++; + }, { skipFirst: true }); + expect(numReactions).toBe(0); - derivable.atomically(function () { + derivable.atomically(() => { $A.set('b'); - assert.strictEqual(numReactions, 0); + expect(numReactions).toBe(0); }); - assert.strictEqual(numReactions, 1); + expect(numReactions).toBe(1); }); - it("doesn't create new transactions if already in a transaction", function () { - var $A = derivable.atom('a'); + it("doesn't create new transactions if already in a transaction", () => { + const $A = derivable.atom('a'); - derivable.transact(function () { + derivable.transact(() => { try { - derivable.atomically(function () { + derivable.atomically(() => { $A.set('b'); - assert.strictEqual($A.get(), 'b'); + expect($A.get()).toBe('b'); throw new Error(); }); } catch (ignored) {} // no transaction created so change to $A persists - assert.strictEqual($A.get(), 'b'); + expect($A.get()).toBe('b'); }); - assert.strictEqual($A.get(), 'b'); + expect($A.get()).toBe('b'); }); }); -describe('the atomic function', function () { - it('creates a transaction if not already in a transaction', function () { - var $A = derivable.atom('a'); - var numReactions = 0; - $A.react(function () { +describe('the atomic function', () => { + it('creates a transaction if not already in a transaction', () => { + const $A = derivable.atom('a'); + let numReactions = 0; + $A.react(() => { return numReactions++; - }, {skipFirst: true}); - assert.strictEqual(numReactions, 0); + }, { skipFirst: true }); + expect(numReactions).toBe(0); - var res = derivable.atomic(function () { + const res = derivable.atomic(() => { $A.set('b'); - assert.strictEqual(numReactions, 0); + expect(numReactions).toBe(0); return 3; })(); - assert.strictEqual(numReactions, 1); + expect(numReactions).toBe(1); - assert.strictEqual(res, 3); + expect(res).toBe(3); }); - it("doesn't create new transactions if already in a transaction", function () { - var $A = derivable.atom('a'); + it("doesn't create new transactions if already in a transaction", () => { + const $A = derivable.atom('a'); - derivable.transact(function () { + derivable.transact(() => { try { - derivable.atomic(function () { + derivable.atomic(() => { $A.set('b'); - assert.strictEqual($A.get(), 'b'); + expect($A.get()).toBe('b'); throw new Error(); })(); } catch (ignored) {} // no transaction created so change to $A persists - assert.strictEqual($A.get(), 'b'); + expect($A.get()).toBe('b'); }); - assert.strictEqual($A.get(), 'b'); + expect($A.get()).toBe('b'); }); }); -describe('the wrapPreviousState function', function () { - it('wraps a function of one argument, passing in previous arguments', function () { - var f = derivable.wrapPreviousState(function (a, b) { return a + b;} , 0); +describe('the wrapPreviousState function', () => { + it('wraps a function of one argument, passing in previous arguments', () => { + const f = derivable.wrapPreviousState((a, b) => a + b , 0); - assert.strictEqual(f(1), 1); - assert.strictEqual(f(2), 3); - assert.strictEqual(f(3), 5); - assert.strictEqual(f(4), 7); - assert.strictEqual(f(5), 9); - assert.strictEqual(f(6), 11); + expect(f(1)).toBe(1); + expect(f(2)).toBe(3); + expect(f(3)).toBe(5); + expect(f(4)).toBe(7); + expect(f(5)).toBe(9); + expect(f(6)).toBe(11); }); - it('the init arg is optional', function () { - var f = derivable.wrapPreviousState(function (a, b) { return a + (b || 10);}); - assert.strictEqual(f(1), 11); - assert.strictEqual(f(2), 3); + it('the init arg is optional', () => { + const f = derivable.wrapPreviousState((a, b) => a + (b || 10)); + + expect(f(1)).toBe(11); + expect(f(2)).toBe(3); }); }); -describe('the captureDereferences function', function () { - it('executes the given function, returning an array of captured dereferences', function () { - var a = derivable.atom("a"); - var b = derivable.atom("b"); - var c = a.derive('length'); +describe('the captureDereferences function', () => { + it('executes the given function, returning an array of captured dereferences', () => { + const a = derivable.atom("a"); + const b = derivable.atom("b"); + const c = a.derive('length'); - var _a = derivable.captureDereferences(function () { + const _a = derivable.captureDereferences(() => { a.get(); }); - assert.deepEqual(_a, [a]); + expect(_a).toEqual([a]); - var _ab = derivable.captureDereferences(function () { + const _ab = derivable.captureDereferences(() => { a.get(); b.get(); }); - assert.deepEqual(_ab, [a, b]); + expect(_ab).toEqual([a, b]); - var _ba = derivable.captureDereferences(function () { + const _ba = derivable.captureDereferences(() => { b.get(); a.get(); }); - assert.deepEqual(_ba, [b, a]); + expect(_ba).toEqual([b, a]); - var _c = derivable.captureDereferences(function () { + const _c = derivable.captureDereferences(() => { c.get(); }); - assert.deepEqual(_c, [c]); + expect(_c).toEqual([c]); - var _ca = derivable.captureDereferences(function () { + const _ca = derivable.captureDereferences(() => { c.get(); a.get(); }); - assert.deepEqual(_ca, [c, a]); + expect(_ca).toEqual([c, a]); - var _cab = derivable.captureDereferences(function () { + const _cab = derivable.captureDereferences(() => { c.get(); a.get(); b.get(); }); - assert.deepEqual(_cab, [c, a, b]); + expect(_cab).toEqual([c, a, b]); }); }); diff --git a/test/multiple_test.js b/test/multiple_test.js index adb1ebd3..1198de5e 100644 --- a/test/multiple_test.js +++ b/test/multiple_test.js @@ -7,7 +7,7 @@ global.__DERIVABLE_INIT_FLAG__ = true; require('../'); console.warn = originalWarn; -test('warn about multiple instances', function () { +test('warn about multiple instances', () => { expect(warn.mock.calls.length).toEqual(1); expect(warn.mock.calls[0][0].toLowerCase()).toEqual( expect.stringContaining('multiple instances') diff --git a/test/proxy_test.js b/test/proxy_test.js index 2d523740..f9dd6d62 100644 --- a/test/proxy_test.js +++ b/test/proxy_test.js @@ -1,186 +1,168 @@ 'use strict'; -var immutable = require('immutable'); +const immutable = require('immutable'); -var derivable = require('../dist/derivable'); +const derivable = require('../dist/derivable'); -var assert = require('assert'); - -describe("proxies", function () { - var cursor = function cursor(proxyable) { - for (var _len = arguments.length, path = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { - path[_key - 1] = arguments[_key]; +describe("proxies", () => { + const cursor = (proxyable, ...args) => { + const _len = args.length; + const path = Array(_len - 1); + for (let _key = 0; _key < _len; _key++) { + path[_key] = args[_key]; } return proxyable.proxy({ - get: function get(state) { - return state.getIn(path); - }, - set: function set(state, val) { - return state.setIn(path, val); - } + get: state => state.getIn(path), + set: (state, val) => state.setIn(path, val) }); }; - it("makes a functional proxy over an atom", function () { - var root = derivable.atom(immutable.fromJS({ things: ["zero", "one", "three"] })); + it("makes a functional proxy over an atom", () => { + const root = derivable.atom(immutable.fromJS({ things: ["zero", "one", "three"] })); - var two = cursor(root, "things", 2); - assert.equal("three", two.get()); + const two = cursor(root, "things", 2); + expect("three").toEqual(two.get()); two.set("two"); - assert(immutable.fromJS({ things: ["zero", "one", "two"] }).equals(root.get())); + expect(immutable.fromJS({ things: ["zero", "one", "two"] }).equals(root.get())).toBeTruthy(); - var things = cursor(root, "things"); + const things = cursor(root, "things"); - assert(immutable.fromJS(["zero", "one", "two"]).equals(things.get())); + expect(immutable.fromJS(["zero", "one", "two"]).equals(things.get())).toBeTruthy(); - var one = cursor(things, 1); + const one = cursor(things, 1); - assert.equal("one", one.get()); + expect("one").toEqual(one.get()); - var reactors = 0; + let reactors = 0; - one.react(function () { - return reactors++; + one.react(() => { + reactors++; }); - assert.equal(1, reactors); + expect(1).toEqual(reactors); one.set("five"); - assert.equal(2, reactors); + expect(2).toEqual(reactors); - assert(immutable.fromJS(["zero", "five", "two"]).equals(things.get())); + expect(immutable.fromJS(["zero", "five", "two"]).equals(things.get())).toBeTruthy(); }); - it("works on numbers too", function () { - var num = derivable.atom(3.14159); + it("works on numbers too", () => { + const num = derivable.atom(3.14159); - var afterDecimalPoint = num.proxy({ - get: function get(number) { - return parseInt(number.toString().split(".")[1]) || 0; - }, - set: function set(number, newVal) { - var beforeDecimalPoint = number.toString().split(".")[0]; + const afterDecimalPoint = num.proxy({ + get: number => parseInt(number.toString().split(".")[1]) || 0, + set: (number, newVal) => { + const beforeDecimalPoint = number.toString().split(".")[0]; return parseFloat(beforeDecimalPoint + '.' + newVal); } }); - assert.strictEqual(14159, afterDecimalPoint.get()); + expect(14159).toBe(afterDecimalPoint.get()); afterDecimalPoint.set(4567); - assert.strictEqual(3.4567, num.get()); + expect(3.4567).toBe(num.get()); - afterDecimalPoint.update(function (x) { - return x * 2; - }); + afterDecimalPoint.update(x => x * 2); - assert.strictEqual(9134, afterDecimalPoint.get()); + expect(9134).toBe(afterDecimalPoint.get()); - assert.strictEqual(3.9134, num.get()); + expect(3.9134).toBe(num.get()); }); - it('can be re-instantiated with custom equality-checking', function () { - var proxy = { - get: function get(a) { - return { a: a % 2 }; - }, - set: function set(a, v) { - return v.a; - } + it('can be re-instantiated with custom equality-checking', () => { + const proxy = { + get: a => ({ a: a % 2 }), + set: (a, v) => v.a }; - var a = derivable.atom(5); - var amod2map = a.proxy(proxy); + const a = derivable.atom(5); + const amod2map = a.proxy(proxy); - var numReactions = 0; - amod2map.react(function () { - return numReactions++; + let numReactions = 0; + amod2map.react(() => { + numReactions++; }, { skipFirst: true }); - assert.strictEqual(numReactions, 0); + expect(numReactions).toBe(0); a.set(7); - assert.strictEqual(numReactions, 1); + expect(numReactions).toBe(1); a.set(9); - assert.strictEqual(numReactions, 2); + expect(numReactions).toBe(2); a.set(11); - assert.strictEqual(numReactions, 3); + expect(numReactions).toBe(3); amod2map.set({ a: 1 }); - assert.strictEqual(numReactions, 4); + expect(numReactions).toBe(4); - var amod2map2 = a.proxy(proxy).withEquality(function (_ref, _ref2) { - var a = _ref.a; - var b = _ref2.a; - return a === b; - }); + const amod2map2 = a.proxy(proxy).withEquality((_ref, _ref2) => _ref.a === _ref2.a); - var numReactions2 = 0; - amod2map2.react(function () { - return numReactions2++; + let numReactions2 = 0; + amod2map2.react(() => { + numReactions2++; }, { skipFirst: true }); - assert.strictEqual(numReactions2, 0); + expect(numReactions2).toBe(0); a.set(7); - assert.strictEqual(numReactions2, 0); + expect(numReactions2).toBe(0); a.set(9); - assert.strictEqual(numReactions2, 0); + expect(numReactions2).toBe(0); a.set(11); - assert.strictEqual(numReactions2, 0); + expect(numReactions2).toBe(0); amod2map2.set({ a: 1 }); - assert.strictEqual(numReactions2, 0); + expect(numReactions2).toBe(0); }); }); -describe('composite proxies', function () { - it('allow multiple atoms to be proxied over', function () { - var $FirstName = derivable.atom('John'); - var $LastName = derivable.atom('Steinbeck'); - var $Name = derivable.proxy({ - get: function get() { - return $FirstName.get() + ' ' + $LastName.get(); - }, - set: function set(val) { - var _val$split = val.split(' '); +describe('composite proxies', () => { + it('allow multiple atoms to be proxied over', () => { + const $FirstName = derivable.atom('John'); + const $LastName = derivable.atom('Steinbeck'); + const $Name = derivable.proxy({ + get: () => $FirstName.get() + ' ' + $LastName.get(), + set: val => { + const _val$split = val.split(' '); - var first = _val$split[0]; - var last = _val$split[1]; + const first = _val$split[0]; + const last = _val$split[1]; $FirstName.set(first); $LastName.set(last); } }); - assert.strictEqual($Name.get(), 'John Steinbeck'); + expect($Name.get()).toBe('John Steinbeck'); $Name.set('James Joyce'); - assert.strictEqual($Name.get(), 'James Joyce'); - assert.strictEqual($FirstName.get(), 'James'); - assert.strictEqual($LastName.get(), 'Joyce'); + expect($Name.get()).toBe('James Joyce'); + expect($FirstName.get()).toBe('James'); + expect($LastName.get()).toBe('Joyce'); }); - it('runs `set` opeartions atomically', function () { - var $A = derivable.atom('a'); - var $B = derivable.atom('b'); + it('runs `set` opeartions atomically', () => { + const $A = derivable.atom('a'); + const $B = derivable.atom('b'); - var numReactions = 0; - $A.react(function () { - return numReactions++; + let numReactions = 0; + $A.react(() => { + numReactions++; }, { skipFirst: true }); - $B.react(function () { - return numReactions++; + $B.react(() => { + numReactions++; }, { skipFirst: true }); derivable.proxy({ - get: function get() {}, - set: function set() { + get: () => {}, + set: () => { $A.set('A'); - assert.strictEqual(numReactions, 0); + expect(numReactions).toBe(0); $B.set('B'); - assert.strictEqual(numReactions, 0); + expect(numReactions).toBe(0); } }).set(); - assert.strictEqual(numReactions, 2); + expect(numReactions).toBe(2); }); }); diff --git a/test/reactor_test.js b/test/reactor_test.js index 299592e1..ee60e7f8 100644 --- a/test/reactor_test.js +++ b/test/reactor_test.js @@ -1,693 +1,671 @@ 'use strict'; -var derivable = require('../dist/derivable'); - -var assert = require('assert'); - -describe("anonymous reactors", function () { - it('are created with the .react method', function () { - var a = derivable.atom('a'); - var val = null; - a.react(function (a) { - val = a; +const derivable = require('../dist/derivable'); + +describe("anonymous reactors", () => { + it('are created with the .react method', () => { + const a = derivable.atom('a'); + let val = null; + a.react(d => { + val = d; }); - assert.strictEqual(val, 'a'); + expect(val).toBe('a'); a.set('b'); - assert.strictEqual(val, 'b'); + expect(val).toBe('b'); }); - it('can start when the `from` condition becomes truthy', function () { - var cond = derivable.atom(false); - var a = derivable.atom('a'); - var val = null; - a.react(function (a) { - val = a; - }, { from: cond }); + it('can start when the `from` condition becomes truthy', () => { + const from = derivable.atom(false); + const a = derivable.atom('a'); + let val = null; + a.react(d => { + val = d; + }, { from }); - assert.strictEqual(val, null); + expect(val).toBe(null); - cond.set('truthy value'); + from.set('truthy value'); - assert.strictEqual(val, 'a'); + expect(val).toBe('a'); a.set('b'); - assert.strictEqual(val, 'b'); + expect(val).toBe('b'); }); - it('can stop (forever) when the `until` condition becomes truthy', function () { - var cond = derivable.atom(false); - var a = derivable.atom('a'); - var val = null; - a.react(function (a) { - val = a; - }, { until: cond }); + it('can stop (forever) when the `until` condition becomes truthy', () => { + const until = derivable.atom(false); + const a = derivable.atom('a'); + let val = null; + a.react(d => { + val = d; + }, { until }); - assert.strictEqual(val, 'a'); + expect(val).toBe('a'); a.set('b'); - assert.strictEqual(val, 'b'); + expect(val).toBe('b'); - cond.set('truthy value'); + until.set('truthy value'); a.set('c'); - assert.strictEqual(val, 'b'); + expect(val).toBe('b'); - cond.set(false); + until.set(false); a.set('d'); - assert.strictEqual(val, 'b'); + expect(val).toBe('b'); }); - it('can start and stop when the `when` condition becomes truthy and falsey respectively', function () { - var cond = derivable.atom(false); - var a = derivable.atom('a'); - var val = null; - a.react(function (a) { - val = a; - }, { when: cond }); + it('can start and stop when the `when` condition becomes truthy and falsey respectively', () => { + const when = derivable.atom(false); + const a = derivable.atom('a'); + let val = null; + a.react(d => { + val = d; + }, { when }); - assert.strictEqual(val, null); + expect(val).toBe(null); - cond.set('truthy value'); + when.set('truthy value'); - assert.strictEqual(val, 'a'); + expect(val).toBe('a'); a.set('b'); - assert.strictEqual(val, 'b'); + expect(val).toBe('b'); - cond.set(0); //falsey value + when.set(0); //falsey value a.set('c'); - assert.strictEqual(val, 'b'); + expect(val).toBe('b'); - cond.set(1); //truthy value + when.set(1); //truthy value - assert.strictEqual(val, 'c'); + expect(val).toBe('c'); }); - it('can have `from`, `when`, and `until` specified as functions', function () { + it('can have `from`, `when`, and `until` specified as functions', () => { { - (function () { - var cond = derivable.atom(false); - var a = derivable.atom('a'); - var val = null; - a.react(function (a) { - val = a; - }, { when: function when() { - return cond.get(); - } }); - - assert.strictEqual(val, null); - - cond.set('truthy value'); - - assert.strictEqual(val, 'a'); - })(); + const cond = derivable.atom(false); + const a = derivable.atom('a'); + let val = null; + a.react(d => { + val = d; + }, { when: () => cond.get() }); + + expect(val).toBe(null); + + cond.set('truthy value'); + + expect(val).toBe('a'); } + { - (function () { - var cond = derivable.atom(false); - var a = derivable.atom('a'); - var val = null; - a.react(function (a) { - val = a; - }, { from: function from() { - return cond.get(); - } }); - - assert.strictEqual(val, null); - - cond.set('truthy value'); - - assert.strictEqual(val, 'a'); - })(); + const cond = derivable.atom(false); + const a = derivable.atom('a'); + let val = null; + a.react(d => { + val = d; + }, { from: () => cond.get() }); + + expect(val).toBe(null); + + cond.set('truthy value'); + + expect(val).toBe('a'); } + { - (function () { - var a = derivable.atom('a'); - var val = null; - a.react(function (a) { - val = a; - }, { until: function until() { - return a.is('b').get(); - } }); + const a = derivable.atom('a'); + let val = null; + a.react(d => { + val = d; + }, { until: () => a.is('b').get() }); - assert.strictEqual(val, 'a'); + expect(val).toBe('a'); - a.set('c'); + a.set('c'); - assert.strictEqual(val, 'c'); + expect(val).toBe('c'); - a.set('b'); + a.set('b'); - assert.strictEqual(val, 'c'); + expect(val).toBe('c'); - a.set('a'); + a.set('a'); - assert.strictEqual(val, 'c'); - })(); + expect(val).toBe('c'); } }); - it('can have `from`, `when`, and `until` specified as functions that use the derivable itself', function () { + it('can have `from`, `when`, and `until` specified as functions that use the derivable itself', () => { { - (function () { - var a = derivable.atom('a'); - var val = null; - a.react(function (a) { - val = a; - }, { when: function when(derivable) { - return derivable.get() > 'c'; - } }); + const a = derivable.atom('a'); + let val = null; + a.react(d => { + val = d; + }, { when: d => d.get() > 'c' }); - assert.strictEqual(val, null); + expect(val).toBe(null); - a.set('x'); + a.set('x'); - assert.strictEqual(val, 'x'); - })(); + expect(val).toBe('x'); } + { - (function () { - var a = derivable.atom('a'); - var val = null; - a.react(function (a) { - val = a; - }, { from: function from(derivable) { - return derivable.get() > 'c'; - } }); + const a = derivable.atom('a'); + let val = null; + a.react(d => { + val = d; + }, { from: d => d.get() > 'c' }); - assert.strictEqual(val, null); + expect(val).toBe(null); - a.set('x'); + a.set('x'); - assert.strictEqual(val, 'x'); - })(); + expect(val).toBe('x'); } { - (function () { - var a = derivable.atom('a'); - var val = null; - a.react(function (a) { - val = a; - }, { until: function until(derivable) { - return derivable.is('b').get(); - } }); + const a = derivable.atom('a'); + let val = null; + a.react(d => { + val = d; + }, { until: d => d.is('b').get() }); - assert.strictEqual(val, 'a'); + expect(val).toBe('a'); - a.set('c'); + a.set('c'); - assert.strictEqual(val, 'c'); + expect(val).toBe('c'); - a.set('b'); + a.set('b'); - assert.strictEqual(val, 'c'); + expect(val).toBe('c'); - a.set('a'); + a.set('a'); - assert.strictEqual(val, 'c'); - })(); + expect(val).toBe('c'); } }); - it('doesnt like it when `from`, `when`, and `until` are other things', function () { - var a = derivable.atom('a'); - assert.throws(function () { - return a.react(function () { + it('doesnt like it when `from`, `when`, and `until` are other things', () => { + const a = derivable.atom('a'); + expect(() => { + a.react(() => { return null; }, { from: 'a string' }); - }); - assert.throws(function () { - return a.react(function () { + }).toThrow(); + expect(() => { + a.react(() => { return null; }, { when: 3 }); - }); - assert.throws(function () { - return a.react(function () { + }).toThrow(); + expect(() => { + a.react(() => { return null; }, { until: new Date() }); - }); + }).toThrow(); }); - it('can have `from`, `when`, and `until` conditions all at once', function () { + it('can have `from`, `when`, and `until` conditions all at once', () => { { // normal usage - var from = derivable.atom(false); - var when = derivable.atom(false); - var until = derivable.atom(false); - - var a = derivable.atom('a'); - var val = null; - a.react(function (a) { - val = a; + const from = derivable.atom(false); + const when = derivable.atom(false); + const until = derivable.atom(false); + + const a = derivable.atom('a'); + let val = null; + a.react(d => { + val = d; }, { from: from, when: when, until: until }); - assert.strictEqual(val, null); + expect(val).toBe(null); from.set(true); // when is still false - assert.strictEqual(val, null); + expect(val).toBe(null); when.set(true); - assert.strictEqual(val, 'a'); + expect(val).toBe('a'); a.set('b'); - assert.strictEqual(val, 'b'); + expect(val).toBe('b'); when.set(false); a.set('c'); - assert.strictEqual(val, 'b'); + expect(val).toBe('b'); when.set(true); - assert.strictEqual(val, 'c'); + expect(val).toBe('c'); until.set(true); a.set('d'); - assert.strictEqual(val, 'c'); + expect(val).toBe('c'); } + { // until already true - var _from = derivable.atom(false); - var _when = derivable.atom(false); - var _until = derivable.atom(true); - - var _a = derivable.atom('a'); - var _val = null; - _a.react(function (a) { - _val = a; - }, { from: _from, when: _when, until: _until }); - - assert.strictEqual(_val, null); - _from.set(true); + const from = derivable.atom(false); + const when = derivable.atom(false); + const until = derivable.atom(true); + + const a = derivable.atom('a'); + let val = null; + a.react(d => { + val = d; + }, { from, when, until }); + + expect(val).toBe(null); + from.set(true); // when is still false - assert.strictEqual(_val, null); - _when.set(true); - assert.strictEqual(_val, null); + expect(val).toBe(null); + when.set(true); + expect(val).toBe(null); } + { // until already true - var _from2 = derivable.atom(false); - var _when2 = derivable.atom(false); - var _until2 = derivable.atom(true); - - var _a2 = derivable.atom('a'); - var _val2 = null; - _a2.react(function (a) { - _val2 = a; - }, { from: _from2, when: _when2, until: _until2 }); - - assert.strictEqual(_val2, null); - _from2.set(true); + const from = derivable.atom(false); + const when = derivable.atom(false); + const until = derivable.atom(true); + + const a = derivable.atom('a'); + let val = null; + a.react(d => { + val = d; + }, { from, when, until }); + + expect(val).toBe(null); + from.set(true); // when is still false - assert.strictEqual(_val2, null); - _when2.set(true); - assert.strictEqual(_val2, null); + expect(val).toBe(null); + when.set(true); + expect(val).toBe(null); } + { // when already true - var _from3 = derivable.atom(false); - var _when3 = derivable.atom(true); - var _until3 = derivable.atom(false); - - var _a3 = derivable.atom('a'); - var _val3 = null; - _a3.react(function (a) { - _val3 = a; - }, { from: _from3, when: _when3, until: _until3 }); - - assert.strictEqual(_val3, null); - _from3.set(true); - assert.strictEqual(_val3, 'a'); + const from = derivable.atom(false); + const when = derivable.atom(true); + const until = derivable.atom(false); + + const a = derivable.atom('a'); + let val = null; + a.react(d => { + val = d; + }, { from, when, until }); + + expect(val).toBe(null); + from.set(true); + expect(val).toBe('a'); } + { // from and when already true - var _from4 = derivable.atom(true); - var _when4 = derivable.atom(true); - var _until4 = derivable.atom(false); + const from = derivable.atom(true); + const when = derivable.atom(true); + const until = derivable.atom(false); - var _a4 = derivable.atom('a'); - var _val4 = null; - _a4.react(function (a) { - _val4 = a; - }, { from: _from4, when: _when4, until: _until4 }); + const a = derivable.atom('a'); + let val = null; + a.react(d => { + val = d; + }, { from, when, until }); - assert.strictEqual(_val4, 'a'); + expect(val).toBe('a'); } + { // from and until already true - var _from5 = derivable.atom(true); - var _when5 = derivable.atom(false); - var _until5 = derivable.atom(true); - - var _a5 = derivable.atom('a'); - var _val5 = null; - _a5.react(function (a) { - _val5 = a; - }, { from: _from5, when: _when5, until: _until5 }); - - assert.strictEqual(_val5, null); - _when5.set(true); - assert.strictEqual(_val5, null); + const from = derivable.atom(true); + const when = derivable.atom(false); + const until = derivable.atom(true); + + const a = derivable.atom('a'); + let val = null; + a.react(d => { + val = d; + }, { from, when, until }); + + expect(val).toBe(null); + when.set(true); + expect(val).toBe(null); } + { // until and when already true - var _from6 = derivable.atom(false); - var _when6 = derivable.atom(true); - var _until6 = derivable.atom(true); - - var _a6 = derivable.atom('a'); - var _val6 = null; - _a6.react(function (a) { - _val6 = a; - }, { from: _from6, when: _when6, until: _until6 }); - - assert.strictEqual(_val6, null); - _from6.set(true); - assert.strictEqual(_val6, null); + const from = derivable.atom(false); + const when = derivable.atom(true); + const until = derivable.atom(true); + + const a = derivable.atom('a'); + let val = null; + a.react(d => { + val = d; + }, { from, when, until }); + + expect(val).toBe(null); + from.set(true); + expect(val).toBe(null); } + { - (function () { - // when and until become true atomically - var when = derivable.atom(false); - var until = derivable.atom(false); - - var a = derivable.atom('a'); - var val = null; - a.react(function (a) { - val = a; - }, { when: when, until: until }); - - assert.strictEqual(val, null); - derivable.atomically(function () { - when.set(true); - until.set(true); - }); - - assert.strictEqual(val, null); - })(); + // when and until become true atomically + const when = derivable.atom(false); + const until = derivable.atom(false); + + const a = derivable.atom('a'); + let val = null; + a.react(d => { + val = d; + }, { when, until }); + + expect(val).toBe(null); + derivable.atomically(() => { + when.set(true); + until.set(true); + }); + + expect(val).toBe(null); } }); - it('can specify that the first reaction should be skipped', function () { - var when = derivable.atom(false); - var a = derivable.atom('a'); - var val = null; - a.react(function (a) { - val = a; - }, { skipFirst: true, when: when }); + it('can specify that the first reaction should be skipped', () => { + const when = derivable.atom(false); + const a = derivable.atom('a'); + let val = null; + a.react(d => { + val = d; + }, { skipFirst: true, when }); - assert.strictEqual(val, null); + expect(val).toBe(null); when.set(true); - assert.strictEqual(val, null); + expect(val).toBe(null); a.set('b'); - assert.strictEqual(val, 'b'); + expect(val).toBe('b'); }); - it('can specify that a reaction should only happen once', function () { + it('can specify that a reaction should only happen once', () => { { // without skipFirst - var a = derivable.atom('a'); - var val = null; - a.react(function (a) { - val = a; + const a = derivable.atom('a'); + let val = null; + a.react(d => { + val = d; }, { once: true }); - assert.strictEqual(val, 'a'); + expect(val).toBe('a'); a.set('b'); - assert.strictEqual(val, 'a'); + expect(val).toBe('a'); } + { // with skipFirst - var _a7 = derivable.atom('a'); - var _val7 = null; - _a7.react(function (a) { - _val7 = a; + const a = derivable.atom('a'); + let val = null; + a.react(d => { + val = d; }, { skipFirst: true, once: true }); - assert.strictEqual(_val7, null); + expect(val).toBe(null); - _a7.set('b'); - assert.strictEqual(_val7, 'b'); - _a7.set('c'); - assert.strictEqual(_val7, 'b'); + a.set('b'); + expect(val).toBe('b'); + a.set('c'); + expect(val).toBe('b'); } + { // with when - var when = derivable.atom(false); - var _a8 = derivable.atom('a'); - var _val8 = null; - _a8.react(function (a) { - _val8 = a; - }, { when: when, once: true }); + const when = derivable.atom(false); + const a = derivable.atom('a'); + let val = null; + a.react(d => { + val = d; + }, { when, once: true }); - assert.strictEqual(_val8, null); + expect(val).toBe(null); - _a8.set('b'); + a.set('b'); - assert.strictEqual(_val8, null); + expect(val).toBe(null); when.set(true); - assert.strictEqual(_val8, 'b'); + expect(val).toBe('b'); - _a8.set('c'); - assert.strictEqual(_val8, 'b'); + a.set('c'); + expect(val).toBe('b'); } }); }); -describe("the .react method", function () { - it("must have a function as the first argument", function () { - assert.throws(function () { - return derivable.atom(5).react(); - }); - assert.throws(function () { - return derivable.atom(5).react(4); - }); - assert.throws(function () { - return derivable.atom(5).react(''); - }); - assert.throws(function () { - return derivable.atom(5).react({}); - }); +describe("the .react method", () => { + it("must have a function as the first argument", () => { + expect(() => { + derivable.atom(5).react(); + }).toThrow(); + expect(() => { + derivable.atom(5).react(4); + }).toThrow(); + expect(() => { + derivable.atom(5).react(''); + }).toThrow(); + expect(() => { + derivable.atom(5).react({}); + }).toThrow(); }); }); -describe("setting the values of atoms in a reaction phase", function () { - it("is ok as long as no cycles are created", function () { - var a = derivable.atom("a"); +describe("setting the values of atoms in a reaction phase", () => { + it("is ok as long as no cycles are created", () => { + const a = derivable.atom("a"); - var b = derivable.atom("b"); + const b = derivable.atom("b"); - a.react(function (a) { - return b.set(b.get() + a); + a.react(d => { + b.set(b.get() + d); }); - assert.strictEqual(b.get(), "ba"); + expect(b.get()).toBe("ba"); a.set("aa"); - assert.strictEqual(b.get(), "baaa"); + expect(b.get()).toBe("baaa"); // derivable disallows - assert.throws(function () { - return b.react(function (b) { - return a.set(b); + expect(() => { + b.react(d => { + a.set(d); }); - }); + }).toThrow(); }); - it("is not allowed if the atom in question is upstream of the reactor", function () { - var n = derivable.atom(3); + it("is not allowed if the atom in question is upstream of the reactor", () => { + const n = derivable.atom(3); // currently 1 - var nmod2 = n.derive(function (x) { - return x % 2; - }); + const nmod2 = n.derive(x => x % 2); - var double = function double(n) { - return n * 2; - }; + const double = d => d * 2; - nmod2.react(function () { - return n.update(double); - }, {skipFirst: true}); + nmod2.react(() => { + n.update(double); + }, { skipFirst: true }); - assert.throws(function () { - return n.set(2); - }); + expect(() => { + n.set(2); + }).toThrow(); // nmod2 becomes 0, reactor triggers n being set to 4 // reactor caught up in sweep again, identified as cycle }); }); -describe("tickers", function () { - it("allow reacting at custom intervals", function () { - var a = derivable.atom("a"); +describe("tickers", () => { + it("allow reacting at custom intervals", () => { + const a = derivable.atom("a"); - var ticker = derivable.ticker(); + const ticker = derivable.ticker(); - var b = "b"; + let b = "b"; - a.react(function (a) { - return b = a; - }, {skipFirst: true}); + a.react(d => { + b = d; + }, { skipFirst: true }); - assert.strictEqual(b, "b"); + expect(b).toBe("b"); a.set("c"); - assert.strictEqual(b, "b"); + expect(b).toBe("b"); a.set("d"); - assert.strictEqual(b, "b"); + expect(b).toBe("b"); ticker.tick(); - assert.strictEqual(b, "d"); + expect(b).toBe("d"); a.set("e"); - assert.strictEqual(b, "d"); + expect(b).toBe("d"); a.set("f"); - assert.strictEqual(b, "d"); + expect(b).toBe("d"); ticker.tick(); - assert.strictEqual(b, "f"); + expect(b).toBe("f"); ticker.release(); }); - it("can be used by more than one piece of the stack", function () { - var a = derivable.atom("a"); - var ticker1 = derivable.ticker(); - var ticker2 = derivable.ticker(); - var ticker3 = derivable.ticker(); + it("can be used by more than one piece of the stack", () => { + const a = derivable.atom("a"); + const ticker1 = derivable.ticker(); + const ticker2 = derivable.ticker(); + const ticker3 = derivable.ticker(); - assert(ticker1 !== ticker2); - assert(ticker1 !== ticker3); - assert(ticker2 !== ticker3); + expect(ticker1).not.toBe(ticker2); + expect(ticker1).not.toBe(ticker3); + expect(ticker2).not.toBe(ticker3); - var b = "b"; + let b = "b"; - a.react(function (a) { - return b = a; - }, {skipFirst: true}); - assert.strictEqual(b, "b"); + a.react(d => { + b = d; + }, { skipFirst: true }); + expect(b).toBe("b"); a.set("c"); - assert.strictEqual(b, "b"); + expect(b).toBe("b"); a.set("d"); - assert.strictEqual(b, "b"); + expect(b).toBe("b"); ticker1.tick(); - assert.strictEqual(b, "d"); + expect(b).toBe("d"); a.set("e"); - assert.strictEqual(b, "d"); + expect(b).toBe("d"); a.set("f"); - assert.strictEqual(b, "d"); + expect(b).toBe("d"); ticker2.tick(); - assert.strictEqual(b, "f"); + expect(b).toBe("f"); a.set("g"); ticker3.tick(); - assert.strictEqual(b, "g"); + expect(b).toBe("g"); ticker1.release(); ticker2.release(); ticker3.release(); }); - it("are reference counted", function () { - var a = derivable.atom(null); - var b = "b"; + it("are reference counted", () => { + const a = derivable.atom(null); + let b = "b"; - a.react(function (a) { - return b = a; - }, {skipFirst: true}); + a.react(d => { + b = d; + }, { skipFirst: true }); a.set("a"); - assert.strictEqual(b, "a"); + expect(b).toBe("a"); - var ticker1 = derivable.ticker(); - var ticker2 = derivable.ticker(); - var ticker3 = derivable.ticker(); + const ticker1 = derivable.ticker(); + const ticker2 = derivable.ticker(); + const ticker3 = derivable.ticker(); a.set("b"); - assert.strictEqual(b, "a"); + expect(b).toBe("a"); ticker1.release(); - assert.strictEqual(b, "a"); + expect(b).toBe("a"); ticker2.release(); - assert.strictEqual(b, "a"); + expect(b).toBe("a"); ticker3.release(); - assert.strictEqual(b, "b"); + expect(b).toBe("b"); a.set("c"); - assert.strictEqual(b, "c"); + expect(b).toBe("c"); }); - it('can reset the global state to the last tick', function () { - var a = derivable.atom('a'); - var b = derivable.atom('b'); + it('can reset the global state to the last tick', () => { + const a = derivable.atom('a'); + const b = derivable.atom('b'); - var t = derivable.ticker(); + const t = derivable.ticker(); a.set('b'); b.set('a'); - assert.strictEqual(a.get(), 'b'); - assert.strictEqual(b.get(), 'a'); + expect(a.get()).toBe('b'); + expect(b.get()).toBe('a'); t.reset(); - assert.strictEqual(a.get(), 'a'); - assert.strictEqual(b.get(), 'b'); + expect(a.get()).toBe('a'); + expect(b.get()).toBe('b'); t.release(); - assert.throws(function () { - return t.reset(); - }); + expect(() => { + t.reset(); + }).toThrow(); }); - it("cannot be used after being released", function () { - var t1 = derivable.ticker(); - var t2 = derivable.ticker(); + it("cannot be used after being released", () => { + const t1 = derivable.ticker(); + const t2 = derivable.ticker(); t1.release(); - assert.throws(function () { - return t1.release(); - }); + expect(() => { + t1.release(); + }).toThrow(); t2.release(); - assert.throws(function () { - return t2.tick(); - }); + expect(() => { + t2.tick(); + }).toThrow(); }); - it("should not cause parents to be investigated in the wrong order", function () { - var a = derivable.atom(null); - var b = a.derive(function (a) { - return a.toString(); - }); - var c = a.then(b, 'a is null'); + it("should not cause parents to be investigated in the wrong order", () => { + const a = derivable.atom(null); + const b = a.derive(d => d.toString()); + const c = a.then(b, 'a is null'); - var expecting = 'a is null'; + let expecting = 'a is null'; - c.react(function (c) { - return assert.strictEqual(c, expecting); + c.react(d => { + expect(d).toBe(expecting); }); expecting = 'some other string'; @@ -699,50 +677,48 @@ describe("tickers", function () { a.set(null); }); - it("can be created in reactors", function () { - var a = derivable.atom('a'); + it("can be created in reactors", () => { + const a = derivable.atom('a'); - derivable.transact(function () { + derivable.transact(() => { a.set('b'); - a.react(function (a) { - return console.log(a); + a.react(d => { + console.log(d); }); }); }); }); -describe('the `when` optons to the `react` method', function () { - it('allows one to tie the lifecycle of a reactor to some piece of state anonymously', function () { - var $Cond = derivable.atom(false); - var $N = derivable.atom(0); - var inc = function inc(x) { - return x + 1; - }; +describe('the `when` optons to the `react` method', () => { + it('allows one to tie the lifecycle of a reactor to some piece of state anonymously', () => { + const $Cond = derivable.atom(false); + const $N = derivable.atom(0); + const inc = x => x + 1; - var i = 0; - $N.react(function () { - return i++; + let i = 0; + $N.react(() => { + i++; }, { when: $Cond }); - assert.strictEqual(i, 0); + expect(i).toBe(0); $N.update(inc); - assert.strictEqual(i, 0); + expect(i).toBe(0); $Cond.set(true); - assert.strictEqual(i, 1); + expect(i).toBe(1); $N.update(inc); - assert.strictEqual(i, 2); + expect(i).toBe(2); $N.update(inc); $N.update(inc); - assert.strictEqual(i, 4); + expect(i).toBe(4); // it uses truthy/falsiness $Cond.set(0); @@ -750,129 +726,127 @@ describe('the `when` optons to the `react` method', function () { $N.update(inc); $N.update(inc); - assert.strictEqual(i, 4); + expect(i).toBe(4); }); - it('casts the condition to a boolean', function () { - var $Cond = derivable.atom("blub"); - var $N = derivable.atom(0); - var inc = function inc(x) { - return x + 1; - }; + it('casts the condition to a boolean', () => { + const $Cond = derivable.atom("blub"); + const $N = derivable.atom(0); + const inc = x => x + 1; - var i = 0; + let i = 0; - $N.react(function () { - return i++; + $N.react(() => { + i++; }, { when: $Cond }); - assert.strictEqual(i, 1); + expect(i).toBe(1); $N.update(inc); - assert.strictEqual(i, 2); + expect(i).toBe(2); $N.update(inc); $N.update(inc); $N.update(inc); - assert.strictEqual(i, 5); + expect(i).toBe(5); $Cond.set("steve"); // sould cause .force() if not casting to boolean, which would inc i - assert.strictEqual(i, 5); + expect(i).toBe(5); }); }); -describe('the .mReact method', function () { - it('only reacts when the thing in the derivable is not null or undefined', function () { - var a = derivable.atom(null); +describe('the .mReact method', () => { + it('only reacts when the thing in the derivable is not null or undefined', () => { + const a = derivable.atom(null); - var _a = "Tree"; + let _a = "Tree"; - a.mReact(function (a) { - _a = a; + a.mReact(d => { + _a = d; }); - assert.strictEqual(_a, "Tree"); + expect(_a).toBe("Tree"); a.set("House"); - assert.strictEqual(_a, "House"); + expect(_a).toBe("House"); a.set(void 0); - assert.strictEqual(_a, "House"); + expect(_a).toBe("House"); }); - it('merges any given when condition', function () { - var a = derivable.atom(null); - var alive = derivable.atom(true); + it('merges any given when condition', () => { + const a = derivable.atom(null); + const when = derivable.atom(true); - var _a = "Tree"; + let _a = "Tree"; - a.mReact(function (a) { - _a = a; - }, {when: alive}); + a.mReact(d => { + _a = d; + }, { when }); - assert.strictEqual(_a, "Tree"); + expect(_a).toBe("Tree"); a.set("House"); - assert.strictEqual(_a, "House"); + expect(_a).toBe("House"); a.set(void 0); - assert.strictEqual(_a, "House"); + expect(_a).toBe("House"); a.set("Tree"); - assert.strictEqual(_a, "Tree"); + expect(_a).toBe("Tree"); - alive.set(false); + when.set(false); a.set("House"); - assert.strictEqual(_a, "Tree"); + expect(_a).toBe("Tree"); }); - it("shouldn't touch any other conditions", function () { - var a = derivable.atom(null); - var alive = derivable.atom(true); - var from = derivable.atom(false); - var until = derivable.atom(false); + it("shouldn't touch any other conditions", () => { + const a = derivable.atom(null); + const when = derivable.atom(true); + const from = derivable.atom(false); + const until = derivable.atom(false); - var _a = "Tree"; + let _a = "Tree"; - a.mReact(function (a) { - _a = a; - }, {when: alive, from: from, until: until}); + a.mReact(d => { + _a = d; + }, { when , from, until }); - assert.strictEqual(_a, "Tree"); + expect(_a).toBe("Tree"); a.set("House"); - assert.strictEqual(_a, "Tree"); + expect(_a).toBe("Tree"); from.set(true); - assert.strictEqual(_a, "House"); + expect(_a).toBe("House"); a.set(void 0); - assert.strictEqual(_a, "House"); + expect(_a).toBe("House"); - alive.set(false); + when .set(false); a.set("Tree"); - assert.strictEqual(_a, "House"); + expect(_a).toBe("House"); - alive.set(true); + when .set(true); - assert.strictEqual(_a, "Tree"); + expect(_a).toBe("Tree"); until.set(true); a.set("House"); - assert.strictEqual(_a, "Tree"); + expect(_a).toBe("Tree"); }); }); diff --git a/test/util.js b/test/util.js index 9f64c80d..777f3ef7 100644 --- a/test/util.js +++ b/test/util.js @@ -3,8 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true }); -exports.label = label; -function label(obj, label) { +exports.label = (obj, label) => { obj["LABEL"] = label; return obj; -} +};