yonote/yjs
24
0
Fork 0
Code Pull Requests 1 Releases Activity

fixed all the tests

Browse Source
This commit is contained in:
Kevin Jahns 2015-07-19 23:31:35 +00:00
parent d4ef54358b
commit ee116b8ca4
3 changed files with 126 additions and 196 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
gulpfile.js
View File

@ -137,7 +137,7 @@ gulp.task("build_jasmine_browser", function(){
loose: "all", loose: "all",
modules: "ignore", modules: "ignore",
optional: ["es7.asyncFunctions"], optional: ["es7.asyncFunctions"],
blacklist: "regenerator", // blacklist: "regenerator",
experimental: true experimental: true
})) }))
.pipe(sourcemaps.write()) .pipe(sourcemaps.write())

270
src/Types/Map.spec.js
View File

@ -1,175 +1,164 @@
/* @flow */ /* @flow */
/*eslint-env browser,jasmine */ /*eslint-env browser,jasmine */
var numberOfYMapTests = 70; var numberOfYMapTests = 100;
describe("Map Type", function(){ describe("Map Type", function(){
jasmine.DEFAULT_TIMEOUT_INTERVAL = 3000; var y1, y2, y3, y4, flushAll;
beforeEach(function(done){
createUsers(this, 5, done); jasmine.DEFAULT_TIMEOUT_INTERVAL = 50000;
beforeEach(async function(done){
await createUsers(this, 5);
y1 = this.users[0].root;
y2 = this.users[1].root;
y3 = this.users[2].root;
y4 = this.users[3].root;
flushAll = this.users[0].connector.flushAll;
done();
}); });
afterEach(async function(done) {
await compareAllUsers(this.users);
done();
}, 5000);
describe("Basic tests", function(){ describe("Basic tests", function(){
it("Basic get&set of Map property (converge via sync)", function(){ it("Basic get&set of Map property (converge via sync)", async function(done){
var y = this.users[0].root; y1.set("stuff", "stuffy");
y.set("stuff", "stuffy"); expect(y1.get("stuff")).toEqual("stuffy");
expect(y.get("stuff")).toEqual("stuffy"); await flushAll();
this.users[0].connector.flushAll();
for (var key in this.users) { for (var key in this.users) {
var u = this.users[key].root; var u = this.users[key].root;
expect(u.get("stuff")).toEqual("stuffy"); expect(u.get("stuff")).toEqual("stuffy");
} }
compareAllUsers(this.users); await compareAllUsers(this.users);
done();
}); });
it("Map can set custom types (Map)", function(done){ it("Map can set custom types (Map)", async function(done){
var y = this.users[0].root; var map = await y1.set("Map", Y.Map);
y.set("Map", Y.Map).then(function(map) { map.set("one", 1);
map.set("one", 1); map = await y1.get("Map");
return y.get("Map"); expect(map.get("one")).toEqual(1);
}).then(function(map){ await compareAllUsers(this.users);
expect(map.get("one")).toEqual(1); done();
done();
});
}); });
it("Map can set custom types (Array)", function(done){ it("Map can set custom types (Array)", async function(done){
var y = this.users[0].root; var array = await y1.set("Array", Y.Array);
y.set("Array", Y.Array).then(function(array) { array.insert(0, [1, 2, 3]);
array.insert(0, [1, 2, 3]); array = await y1.get("Array");
return y.get("Array"); expect(array.toArray()).toEqual([1, 2, 3]);
}).then(function(array){ await compareAllUsers(this.users);
expect(array.toArray()).toEqual([1, 2, 3]); done();
done();
});
}); });
it("Basic get&set of Map property (converge via update)", function(done){ it("Basic get&set of Map property (converge via update)", async function(done){
var u = this.users[0]; await flushAll();
u.connector.flushAll(); y1.set("stuff", "stuffy");
var y = u.root; expect(y1.get("stuff")).toEqual("stuffy");
y.set("stuff", "stuffy");
expect(y.get("stuff")).toEqual("stuffy");
u.connector.flushAll(); await flushAll();
setTimeout(() => { for (var key in this.users) {
for (var key in this.users) { var r = this.users[key].root;
var r = this.users[key].root; expect(r.get("stuff")).toEqual("stuffy");
expect(r.get("stuff")).toEqual("stuffy"); }
} done();
done();
}, 50);
}); });
it("Basic get&set of Map property (handle conflict)", function(done){ it("Basic get&set of Map property (handle conflict)", async function(done){
var y = this.users[0]; await flushAll();
y.connector.flushAll(); y1.set("stuff", "c0");
y.root.set("stuff", "c0");
this.users[1].root.set("stuff", "c1"); y2.set("stuff", "c1");
y.connector.flushAll(); await flushAll();
for (var key in this.users) {
setTimeout( () => { var u = this.users[key];
for (var key in this.users) { expect(u.root.get("stuff")).toEqual("c0");
var u = this.users[key]; }
expect(u.root.get("stuff")).toEqual("c0"); await compareAllUsers(this.users);
compareAllUsers(this.users); done();
}
done();
}, 50);
}); });
it("Basic get&set&delete of Map property (handle conflict)", function(done){ it("Basic get&set&delete of Map property (handle conflict)", async function(done){
var y = this.users[0]; await flushAll();
y.connector.flushAll(); y1.set("stuff", "c0");
y.root.set("stuff", "c0"); y1.delete("stuff");
y.root.delete("stuff"); y2.set("stuff", "c1");
await flushAll();
this.users[1].root.set("stuff", "c1"); for (var key in this.users) {
var u = this.users[key];
y.connector.flushAll(); expect(u.root.get("stuff")).toBeUndefined();
}
setTimeout( () => { await compareAllUsers(this.users);
for (var key in this.users) { done();
var u = this.users[key];
expect(u.root.get("stuff")).toBeUndefined();
compareAllUsers(this.users);
}
done();
}, 50);
}); });
it("Basic get&set of Map property (handle three conflicts)", function(done){ it("Basic get&set of Map property (handle three conflicts)", async function(done){
var y = this.users[0]; await flushAll();
this.users[0].root.set("stuff", "c0"); y1.set("stuff", "c0");
this.users[1].root.set("stuff", "c1"); y2.set("stuff", "c1");
this.users[2].root.set("stuff", "c2"); y2.set("stuff", "c2");
this.users[3].root.set("stuff", "c3"); y3.set("stuff", "c3");
y.connector.flushAll(); await flushAll();
setTimeout( () => { for (var key in this.users) {
for (var key in this.users) { var u = this.users[key];
var u = this.users[key]; expect(u.root.get("stuff")).toEqual("c0");
expect(u.root.get("stuff")).toEqual("c0"); }
} await compareAllUsers(this.users);
compareAllUsers(this.users); done();
done();
}, 50);
}); });
it("Basic get&set&delete of Map property (handle three conflicts)", function(done){ it("Basic get&set&delete of Map property (handle three conflicts)", async function(done){
var y = this.users[0]; await flushAll();
this.users[0].root.set("stuff", "c0"); y1.set("stuff", "c0");
this.users[1].root.set("stuff", "c1"); y2.set("stuff", "c1");
this.users[2].root.set("stuff", "c2"); y2.set("stuff", "c2");
this.users[3].root.set("stuff", "c3"); y3.set("stuff", "c3");
y.connector.flushAll(); await flushAll();
this.users[0].root.set("stuff", "deleteme"); y1.set("stuff", "deleteme");
this.users[0].root.delete("stuff"); y1.delete("stuff");
this.users[1].root.set("stuff", "c1"); y2.set("stuff", "c1");
this.users[2].root.set("stuff", "c2"); y3.set("stuff", "c2");
this.users[3].root.set("stuff", "c3"); y4.set("stuff", "c3");
y.connector.flushAll(); await flushAll();
setTimeout( () => { for (var key in this.users) {
for (var key in this.users) { var u = this.users[key];
var u = this.users[key]; expect(u.root.get("stuff")).toBeUndefined();
expect(u.root.get("stuff")).toBeUndefined(); }
} await compareAllUsers(this.users);
compareAllUsers(this.users); done();
done();
}, 50);
}); });
it("throws add & update & delete events (with type and primitive content)", function(done){ it("throws add & update & delete events (with type and primitive content)", async function(done){
var y = this.users[0].root;
var event; var event;
y.observe(function(e){ await flushAll();
y1.observe(function(e){
event = e; // just put it on event, should be thrown synchronously anyway event = e; // just put it on event, should be thrown synchronously anyway
}); });
y.set("stuff", 4); y1.set("stuff", 4);
expect(event).toEqual([{ expect(event).toEqual([{
type: "add", type: "add",
object: y, object: y1,
name: "stuff" name: "stuff"
}]); }]);
// update, oldValue is in contents // update, oldValue is in contents
y.set("stuff", Y.Array); await y1.set("stuff", Y.Array);
expect(event).toEqual([{ expect(event).toEqual([{
type: "update", type: "update",
object: y, object: y1,
name: "stuff", name: "stuff",
oldValue: 4 oldValue: 4
}]); }]);
y.get("stuff").then(function(replacedArray){ y1.get("stuff").then(function(replacedArray){
// update, oldValue is in opContents // update, oldValue is in opContents
y.set("stuff", 5); y1.set("stuff", 5);
var getYArray = event[0].oldValue; var getYArray = event[0].oldValue;
expect(typeof getYArray.constructor === "function").toBeTruthy(); expect(typeof getYArray.constructor === "function").toBeTruthy();
getYArray().then(function(array){ getYArray().then(function(array){
expect(array).toEqual(replacedArray); expect(array).toEqual(replacedArray);
// delete // delete
y.delete("stuff"); y1.delete("stuff");
expect(event).toEqual([{ expect(event).toEqual([{
type: "delete", type: "delete",
name: "stuff", name: "stuff",
object: y, object: y1,
oldValue: 5 oldValue: 5
}]); }]);
done(); done();
@ -197,31 +186,22 @@ describe("Map Type", function(){
} }
} }
} }
beforeEach(function(done){ beforeEach(async function(done){
this.users[0].root.set("Map", Y.Map); await y1.set("Map", Y.Map);
this.users[0].connector.flushAll(); await flushAll();
var then = Promise.resolve(); var promises = [];
var maps = []; for (var u = 0; u < this.users.length; u++) {
for (var u of this.users) { promises.push(this.users[u].root.get("Map"));
then = then.then(function(){ //eslint-disable-line
return u.root.get("Map");
}).then(function(map){//eslint-disable-line
maps.push(map);
});
} }
this.maps = maps; this.maps = await Promise.all(promises);
then.then(function(){ done();
done();
});
}); });
it(`succeed after ${numberOfYMapTests} actions`, function(done){ it(`succeed after ${numberOfYMapTests} actions`, async function(done){
applyRandomTransactions(this.users, this.maps, randomMapTransactions, numberOfYMapTests); await applyRandomTransactions(this.users, this.maps, randomMapTransactions, numberOfYMapTests);
setTimeout(()=>{ await flushAll();
compareAllUsers(this.users); await compareMapValues(this.maps);
compareMapValues(this.maps); done();
done();
}, 500);
}); });
}); });
}); });

50
src/Types/TextBind.spec.js
View File

@ -1,50 +0,0 @@
/* @flow */
/*eslint-env browser,jasmine */
describe("TextBind Type", function(){
jasmine.DEFAULT_TIMEOUT_INTERVAL = 5000;
beforeEach(function(done){
createUsers(this, 5, done);
});
describe("debug tests", function(){
it("#1", function(done){
var y = this.users[0].root;
var y2 = this.users[1].root;
var y3 = this.users[2].root;
var c1 = this.users[0].connector;
var c2 = this.users[1].connector;
var c3 = this.users[2].connector;
function flushOneAndTwo(){
c1.flush();
c2.flush();
}
var u1, u2;
y.set("text", Y.TextBind);
flushOneAndTwo();
y.get("text").then(function(array) {
u1 = array;
flushOneAndTwo();
return y2.get("text");
}).then(function(array){
u2 = array;
u1.insert(0, "a");
flushOneAndTwo();
u2.insert(1, "b");
flushOneAndTwo();
u1.insert(2, "c");
flushOneAndTwo();
u2.insert(3, "d");
y3.observe(function(events){
for (var event of events) {
if (event.name === "text") {
y3.get("text");
}
}
});
c3.flush();
done();
});
});
});
});