relu-core
Version:
292 lines (287 loc) • 8.23 kB
JavaScript
var should = require("should");
var rp = require("../");
var checkRefs = require("./checkRefs");
describe("delegated", function() {
it("should be able to get and modify the value", checkRefs(function() {
var x = rp.variable("test");
var y = rp.variable(x);
var z = rp.delegated(y);
var counter = 0;
var zz = z.computed(function(z) {
return z + "" + (++counter);
}).scope();
z.isWritable().should.be.eql(true);
zz().should.be.eql("test1");
x.set("TEST");
zz().should.be.eql("TEST2");
var a = rp.variable(123);
y.set(a);
zz().should.be.eql("1233");
y.set(x);
zz().should.be.eql("TEST4");
z.isWritable().should.be.eql(true);
y.set(rp.const(true));
z.isWritable().should.be.eql(false);
y.set(x);
z.isWritable().should.be.eql(true);
}));
it("should not capture rp.const", checkRefs(function() {
var x = rp.const("test");
var caputured = rp.capture(function() {
x();
});
caputured.should.be.eql({dependencies:[], scope:[], value: undefined});
}));
it("should support a delegated array", checkRefs(function() {
var x = rp.variable("x");
var y = rp.variable("y");
var c = rp.computed(function() {
return [x, y];
});
var d = rp.delegated(c);
d().should.be.eql(["x", "y"]);
d(0).should.be.equal(x);
d(1).should.be.equal(y);
}));
it("should fire correct events", checkRefs(function() {
var x = rp.variable("test");
var x2 = rp.variable("test2");
var y = rp.variable(x);
var z = rp.delegated(y);
var a = rp.computed(function() {
return [y(), x, x2];
}).delegated();
var events = [];
var events2 = [];
z.onChanged(function() {
events.push("changed");
});
z.onUpdated(function(n, o) {
events.push(["updated", n, o]);
});
z.onAdded(function(idx, i) {
events.push(["added", idx, i]);
});
z.onRemoved(function(idx, i) {
events.push(["removed", idx, i]);
});
a.onChanged(function() {
events2.push("changed");
});
a.onUpdated(function(n, o) {
events2.push(["updated", n, o]);
});
a.onAdded(function(idx, i) {
events2.push(["added", idx, i]);
});
a.onRemoved(function(idx, i) {
events2.push(["removed", idx, i]);
});
x.set(2);
events.shift().should.be.eql(["updated", 2, "test"]);
events.shift().should.be.eql("changed");
events2.shift().should.be.eql("changed");
events.length.should.be.eql(0);
events2.length.should.be.eql(0);
rp.atomic(function() {
y.set(rp.const("error"));
y.set(x2);
});
events.shift().should.be.eql(["updated", "test2", 2]);
events.shift().should.be.eql("changed");
events2.shift().should.be.eql(["updated", ["test2", 2, "test2"], [2, 2, "test2"]]);
events2.shift().should.be.eql("changed");
x2.set([1, 2, 3]);
x.set("error");
events.shift().should.be.eql(["updated", [1,2,3], "test2"]);
events.shift().should.be.eql("changed");
events2.shift().should.be.eql("changed");
events2.shift().should.be.eql("changed");
rp.atomic(function() {
x2.push(4);
x2.shift();
});
events.shift().should.be.eql(["removed", 0, 1]);
events.shift().should.be.eql(["added", 2, 4]);
events.shift().should.be.eql("changed");
events2.shift().should.be.eql("changed");
events.length.should.be.eql(0);
events2.length.should.be.eql(0);
}));
it("should delegate properties of objects", checkRefs(function() {
var x = rp.variable({a: "x"});
var y = rp.variable({a: "y"});
var d = rp.variable(x);
var z = rp.delegated(d);
var a = z("a");
a().should.be.eql("x");
d.set(y);
a().should.be.eql("y");
}));
it("should not delegate elements of arrays", checkRefs(function() {
var x = rp.variable(["x"]);
var y = rp.variable(["y"]);
var d = rp.variable(x);
var z = rp.delegated(d);
var a = z(0);
a().should.be.eql("x");
d.set(y);
should.not.exist(a());
}));
it("should delegate nested event in an object", checkRefs(function() {
var x = rp.variable({x:1, z:10, a:{b:[1]}});
var d = rp.variable(x);
var z = rp.delegated(d);
var ze = [];
z.onNested(function() {
ze.push([].slice.call(arguments));
});
z.onChanged(function() {
ze.push("changed");
});
var xe = [];
x.onNested(function() {
xe.push([].slice.call(arguments));
});
x.onChanged(function() {
xe.push("changed");
});
z("z").set(20);
x("x").set(2);
z("a", "b").push(2);
x("a", "b").splice(0, 1, "one");
xe.should.be.eql([
["updated", ["z"], 20, 10],
["changed", ["z"], undefined, undefined],
"changed",
["updated", ["x"], 2, 1],
["changed", ["x"], undefined, undefined],
"changed",
["added", ["a", "b"], 1, 2],
["changed", ["a", "b"], undefined, undefined],
["changed", ["a"], undefined, undefined],
"changed",
["removed", ["a", "b"], 0, 1],
["added", ["a", "b"], 0, "one"],
["changed", ["a", "b"], undefined, undefined],
["changed", ["a"], undefined, undefined],
"changed",
]);
ze.should.be.eql(xe);
}));
it("should delegate nested event in an array", checkRefs(function() {
var x = rp.variable([1, 10, {a:[1]}]);
var d = rp.variable(x);
var z = rp.delegated(d);
var ze = [];
z.onNested(function() {
ze.push([].slice.call(arguments));
});
z.onChanged(function() {
ze.push("changed");
});
var xe = [];
x.onNested(function() {
xe.push([].slice.call(arguments));
});
x.onChanged(function() {
xe.push("changed");
});
x(0).set(2);
z(1).set(20);
z(2, "a").push(2);
x(2, "a").splice(0, 1, "one");
xe.should.be.eql([
["updated", [0], 2, 1],
["changed", [0], undefined, undefined],
"changed",
["updated", [1], 20, 10],
["changed", [1], undefined, undefined],
"changed",
["added", [2, "a"], 1, 2],
["changed", [2, "a"], undefined, undefined],
["changed", [2], undefined, undefined],
"changed",
["removed", [2, "a"], 0, 1],
["added", [2, "a"], 0, "one"],
["changed", [2, "a"], undefined, undefined],
["changed", [2], undefined, undefined],
"changed",
]);
ze.should.be.eql(xe);
}));
it("should handle events in a complex case", checkRefs(function() {
var x = rp.variable({a: {b: 1}});
var d = rp.variable(x);
var z = rp.delegated(d);
var xb = x("a", "b");
var zb = z("a")("b");
var xe = [];
xb.onUpdated(function() {
xe.push([].slice.call(arguments));
});
xb.onChanged(function() {
xe.push("changed");
});
var ze = [];
zb.onUpdated(function() {
ze.push([].slice.call(arguments));
});
zb.onChanged(function() {
ze.push("changed");
});
xb.set(2);
zb.set(3);
xe.should.be.eql([
[2, 1],
"changed",
[3, 2],
"changed"
]);
ze.should.be.eql(xe);
}));
it("should delegate attributes", checkRefs(function() {
var x = rp.const();
x.attr("a").set("ax");
x.attr("b").set("bx");
var y = rp.variable(5);
y.attr("a").set("ay");
y.attr("c").set("cy");
var s = rp.variable(x);
var d = rp.delegated(s);
var a = d.attr("a");
var b = d.attr("b");
var c = d.attr("c");
var events = [];
a.onUpdated(function() {
events.push(["a"].concat([].slice.call(arguments)));
});
b.onUpdated(function() {
events.push(["b"].concat([].slice.call(arguments)));
});
c.onUpdated(function() {
events.push(["c"].concat([].slice.call(arguments)));
});
a().should.be.eql("ax");
b().should.be.eql("bx");
should.strictEqual(c(), undefined);
s.set(y);
a().should.be.eql("ay");
should.strictEqual(b(), undefined);
c().should.be.eql("cy");
events.shift().should.be.eql(["a", "ay", "ax"]);
events.shift().should.be.eql(["b", undefined, "bx"]);
events.shift().should.be.eql(["c", "cy", undefined]);
events.should.be.eql([]);
x.attr("a").set("new ax");
events.should.be.eql([]);
y.attr("a").set("new ay");
events.shift().should.be.eql(["a", "new ay", "ay"]);
a().should.be.eql("new ay");
a.set("test");
y.attr("a")().should.be.eql("test");
x.attr("a")().should.be.eql("new ax");
events.shift().should.be.eql(["a", "test", "new ay"]);
events.should.be.eql([]);
}));
});