mirror of
https://github.com/overleaf/overleaf.git
synced 2024-11-07 20:31:06 -05:00
1007 lines
35 KiB
JavaScript
1007 lines
35 KiB
JavaScript
/* eslint-disable
|
|
camelcase,
|
|
mocha/no-identical-title,
|
|
no-return-assign,
|
|
no-unused-vars,
|
|
*/
|
|
// TODO: This file was created by bulk-decaffeinate.
|
|
// Fix any style issues and re-enable lint.
|
|
/*
|
|
* decaffeinate suggestions:
|
|
* DS102: Remove unnecessary code created because of implicit returns
|
|
* Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
|
|
*/
|
|
const sinon = require('sinon');
|
|
const chai = require('chai');
|
|
const should = chai.should();
|
|
const modulePath = "../../../../app/js/RedisManager.js";
|
|
const SandboxedModule = require('sandboxed-module');
|
|
const Errors = require("../../../../app/js/Errors");
|
|
const crypto = require("crypto");
|
|
const tk = require("timekeeper");
|
|
|
|
describe("RedisManager", function() {
|
|
beforeEach(function() {
|
|
let Timer;
|
|
this.multi = {exec: sinon.stub()};
|
|
this.rclient = {multi: () => this.multi};
|
|
tk.freeze(new Date());
|
|
this.RedisManager = SandboxedModule.require(modulePath, {
|
|
requires: {
|
|
"logger-sharelatex": (this.logger = { error: sinon.stub(), log: sinon.stub(), warn: sinon.stub() }),
|
|
"./ProjectHistoryRedisManager": (this.ProjectHistoryRedisManager = {}),
|
|
"settings-sharelatex": (this.settings = {
|
|
documentupdater: {logHashErrors: {write:true, read:true}},
|
|
apis: {
|
|
project_history: {enabled: true}
|
|
},
|
|
redis: {
|
|
documentupdater: {
|
|
key_schema: {
|
|
blockingKey({doc_id}) { return `Blocking:${doc_id}`; },
|
|
docLines({doc_id}) { return `doclines:${doc_id}`; },
|
|
docOps({doc_id}) { return `DocOps:${doc_id}`; },
|
|
docVersion({doc_id}) { return `DocVersion:${doc_id}`; },
|
|
docHash({doc_id}) { return `DocHash:${doc_id}`; },
|
|
projectKey({doc_id}) { return `ProjectId:${doc_id}`; },
|
|
pendingUpdates({doc_id}) { return `PendingUpdates:${doc_id}`; },
|
|
docsInProject({project_id}) { return `DocsIn:${project_id}`; },
|
|
ranges({doc_id}) { return `Ranges:${doc_id}`; },
|
|
pathname({doc_id}) { return `Pathname:${doc_id}`; },
|
|
projectHistoryId({doc_id}) { return `ProjectHistoryId:${doc_id}`; },
|
|
projectHistoryType({doc_id}) { return `ProjectHistoryType:${doc_id}`; },
|
|
projectState({project_id}) { return `ProjectState:${project_id}`; },
|
|
unflushedTime({doc_id}) { return `UnflushedTime:${doc_id}`; },
|
|
lastUpdatedBy({doc_id}) { return `lastUpdatedBy:${doc_id}`; },
|
|
lastUpdatedAt({doc_id}) { return `lastUpdatedAt:${doc_id}`; }
|
|
}
|
|
},
|
|
history: {
|
|
key_schema: {
|
|
uncompressedHistoryOps({doc_id}) { return `UncompressedHistoryOps:${doc_id}`; },
|
|
docsWithHistoryOps({project_id}) { return `DocsWithHistoryOps:${project_id}`; }
|
|
}
|
|
}
|
|
}
|
|
}),
|
|
"redis-sharelatex": {
|
|
createClient: () => this.rclient
|
|
},
|
|
"./Metrics": (this.metrics = {
|
|
inc: sinon.stub(),
|
|
summary: sinon.stub(),
|
|
Timer: (Timer = class Timer {
|
|
constructor() {
|
|
this.start = new Date();
|
|
}
|
|
|
|
done() {
|
|
const timeSpan = new Date - this.start;
|
|
return timeSpan;
|
|
}
|
|
})
|
|
}),
|
|
"./Errors": Errors
|
|
},
|
|
globals: {
|
|
JSON: (this.JSON = JSON)
|
|
}
|
|
}
|
|
);
|
|
|
|
this.doc_id = "doc-id-123";
|
|
this.project_id = "project-id-123";
|
|
this.projectHistoryId = 123;
|
|
return this.callback = sinon.stub();
|
|
});
|
|
|
|
afterEach(function() { return tk.reset(); });
|
|
|
|
describe("getDoc", function() {
|
|
beforeEach(function() {
|
|
this.lines = ["one", "two", "three", "これは"]; // include some utf8
|
|
this.jsonlines = JSON.stringify(this.lines);
|
|
this.version = 42;
|
|
this.hash = crypto.createHash('sha1').update(this.jsonlines,'utf8').digest('hex');
|
|
this.ranges = { comments: "mock", entries: "mock" };
|
|
this.json_ranges = JSON.stringify(this.ranges);
|
|
this.unflushed_time = 12345;
|
|
this.pathname = '/a/b/c.tex';
|
|
this.multi.get = sinon.stub();
|
|
this.multi.exec = sinon.stub().callsArgWith(0, null, [this.jsonlines, this.version, this.hash, this.project_id, this.json_ranges, this.pathname, this.projectHistoryId.toString(), this.unflushed_time]);
|
|
return this.rclient.sadd = sinon.stub().yields(null, 0);
|
|
});
|
|
|
|
describe("successfully", function() {
|
|
beforeEach(function() {
|
|
return this.RedisManager.getDoc(this.project_id, this.doc_id, this.callback);
|
|
});
|
|
|
|
it("should get the lines from redis", function() {
|
|
return this.multi.get
|
|
.calledWith(`doclines:${this.doc_id}`)
|
|
.should.equal(true);
|
|
});
|
|
|
|
it("should get the version from", function() {
|
|
return this.multi.get
|
|
.calledWith(`DocVersion:${this.doc_id}`)
|
|
.should.equal(true);
|
|
});
|
|
|
|
it('should get the hash', function() {
|
|
return this.multi.get
|
|
.calledWith(`DocHash:${this.doc_id}`)
|
|
.should.equal(true);
|
|
});
|
|
|
|
it("should get the ranges", function() {
|
|
return this.multi.get
|
|
.calledWith(`Ranges:${this.doc_id}`)
|
|
.should.equal(true);
|
|
});
|
|
|
|
it("should get the unflushed time", function() {
|
|
return this.multi.get
|
|
.calledWith(`UnflushedTime:${this.doc_id}`)
|
|
.should.equal(true);
|
|
});
|
|
|
|
it("should get the pathname", function() {
|
|
return this.multi.get
|
|
.calledWith(`Pathname:${this.doc_id}`)
|
|
.should.equal(true);
|
|
});
|
|
|
|
it("should get the projectHistoryId as an integer", function() {
|
|
return this.multi.get
|
|
.calledWith(`ProjectHistoryId:${this.doc_id}`)
|
|
.should.equal(true);
|
|
});
|
|
|
|
it("should get lastUpdatedAt", function() {
|
|
return this.multi.get
|
|
.calledWith(`lastUpdatedAt:${this.doc_id}`)
|
|
.should.equal(true);
|
|
});
|
|
|
|
it("should get lastUpdatedBy", function() {
|
|
return this.multi.get
|
|
.calledWith(`lastUpdatedBy:${this.doc_id}`)
|
|
.should.equal(true);
|
|
});
|
|
|
|
it("should check if the document is in the DocsIn set", function() {
|
|
return this.rclient.sadd
|
|
.calledWith(`DocsIn:${this.project_id}`)
|
|
.should.equal(true);
|
|
});
|
|
|
|
it('should return the document', function() {
|
|
return this.callback
|
|
.calledWithExactly(null, this.lines, this.version, this.ranges, this.pathname, this.projectHistoryId, this.unflushed_time, this.lastUpdatedAt, this.lastUpdatedBy)
|
|
.should.equal(true);
|
|
});
|
|
|
|
return it('should not log any errors', function() {
|
|
return this.logger.error.calledWith()
|
|
.should.equal(false);
|
|
});
|
|
});
|
|
|
|
describe("when the document is not present", function() {
|
|
beforeEach(function() {
|
|
this.multi.exec = sinon.stub().callsArgWith(0, null, [null, null, null, null, null, null, null, null, null, null]);
|
|
this.rclient.sadd = sinon.stub().yields();
|
|
return this.RedisManager.getDoc(this.project_id, this.doc_id, this.callback);
|
|
});
|
|
|
|
it("should not check if the document is in the DocsIn set", function() {
|
|
return this.rclient.sadd
|
|
.calledWith(`DocsIn:${this.project_id}`)
|
|
.should.equal(false);
|
|
});
|
|
|
|
it('should return an empty result', function() {
|
|
return this.callback
|
|
.calledWithExactly(null, null, 0, {}, null, null, null, null, null)
|
|
.should.equal(true);
|
|
});
|
|
|
|
return it('should not log any errors', function() {
|
|
return this.logger.error.calledWith()
|
|
.should.equal(false);
|
|
});
|
|
});
|
|
|
|
describe("when the document is missing from the DocsIn set", function() {
|
|
beforeEach(function() {
|
|
this.rclient.sadd = sinon.stub().yields(null, 1);
|
|
return this.RedisManager.getDoc(this.project_id, this.doc_id, this.callback);
|
|
});
|
|
|
|
it('should log an error', function() {
|
|
return this.logger.error.calledWith()
|
|
.should.equal(true);
|
|
});
|
|
|
|
return it('should return the document', function() {
|
|
return this.callback
|
|
.calledWithExactly(null, this.lines, this.version, this.ranges, this.pathname, this.projectHistoryId, this.unflushed_time, this.lastUpdatedAt, this.lastUpdatedBy)
|
|
.should.equal(true);
|
|
});
|
|
});
|
|
|
|
describe("with a corrupted document", function() {
|
|
beforeEach(function() {
|
|
this.badHash = "INVALID-HASH-VALUE";
|
|
this.multi.exec = sinon.stub().callsArgWith(0, null, [this.jsonlines, this.version, this.badHash, this.project_id, this.json_ranges]);
|
|
return this.RedisManager.getDoc(this.project_id, this.doc_id, this.callback);
|
|
});
|
|
|
|
it('should log a hash error', function() {
|
|
return this.logger.error.calledWith()
|
|
.should.equal(true);
|
|
});
|
|
|
|
return it('should return the document', function() {
|
|
return this.callback
|
|
.calledWith(null, this.lines, this.version, this.ranges)
|
|
.should.equal(true);
|
|
});
|
|
});
|
|
|
|
|
|
describe("with a slow request to redis", function() {
|
|
beforeEach(function() {
|
|
this.multi.exec = sinon.stub().callsArgWith(0, null, [this.jsonlines, this.version, this.badHash, this.project_id, this.json_ranges, this.pathname, this.unflushed_time]);
|
|
this.clock = sinon.useFakeTimers();
|
|
this.multi.exec = cb => {
|
|
this.clock.tick(6000);
|
|
return cb(null, [this.jsonlines, this.version, this.another_project_id, this.json_ranges, this.pathname, this.unflushed_time]);
|
|
};
|
|
|
|
return this.RedisManager.getDoc(this.project_id, this.doc_id, this.callback);
|
|
});
|
|
|
|
afterEach(function() {
|
|
return this.clock.restore();
|
|
});
|
|
|
|
return it('should return an error', function() {
|
|
return this.callback
|
|
.calledWith(new Error("redis getDoc exceeded timeout"))
|
|
.should.equal(true);
|
|
});
|
|
});
|
|
|
|
return describe("getDoc with an invalid project id", function() {
|
|
beforeEach(function() {
|
|
this.another_project_id = "project-id-456";
|
|
this.multi.exec = sinon.stub().callsArgWith(0, null, [this.jsonlines, this.version, this.hash, this.another_project_id, this.json_ranges, this.pathname, this.unflushed_time]);
|
|
return this.RedisManager.getDoc(this.project_id, this.doc_id, this.callback);
|
|
});
|
|
|
|
return it('should return an error', function() {
|
|
return this.callback
|
|
.calledWith(new Errors.NotFoundError("not found"))
|
|
.should.equal(true);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("getPreviousDocOpsTests", function() {
|
|
describe("with a start and an end value", function() {
|
|
beforeEach(function() {
|
|
this.first_version_in_redis = 30;
|
|
this.version = 70;
|
|
this.length = this.version - this.first_version_in_redis;
|
|
this.start = 50;
|
|
this.end = 60;
|
|
this.ops = [
|
|
{ "mock": "op-1" },
|
|
{ "mock": "op-2" }
|
|
];
|
|
this.jsonOps = this.ops.map(op => JSON.stringify(op));
|
|
this.rclient.llen = sinon.stub().callsArgWith(1, null, this.length);
|
|
this.rclient.get = sinon.stub().callsArgWith(1, null, this.version.toString());
|
|
this.rclient.lrange = sinon.stub().callsArgWith(3, null, this.jsonOps);
|
|
return this.RedisManager.getPreviousDocOps(this.doc_id, this.start, this.end, this.callback);
|
|
});
|
|
|
|
it("should get the length of the existing doc ops", function() {
|
|
return this.rclient.llen
|
|
.calledWith(`DocOps:${this.doc_id}`)
|
|
.should.equal(true);
|
|
});
|
|
|
|
it("should get the current version of the doc", function() {
|
|
return this.rclient.get
|
|
.calledWith(`DocVersion:${this.doc_id}`)
|
|
.should.equal(true);
|
|
});
|
|
|
|
it("should get the appropriate docs ops", function() {
|
|
return this.rclient.lrange
|
|
.calledWith(`DocOps:${this.doc_id}`, this.start - this.first_version_in_redis, this.end - this.first_version_in_redis)
|
|
.should.equal(true);
|
|
});
|
|
|
|
return it("should return the docs with the doc ops deserialized", function() {
|
|
return this.callback.calledWith(null, this.ops).should.equal(true);
|
|
});
|
|
});
|
|
|
|
describe("with an end value of -1", function() {
|
|
beforeEach(function() {
|
|
this.first_version_in_redis = 30;
|
|
this.version = 70;
|
|
this.length = this.version - this.first_version_in_redis;
|
|
this.start = 50;
|
|
this.end = -1;
|
|
this.ops = [
|
|
{ "mock": "op-1" },
|
|
{ "mock": "op-2" }
|
|
];
|
|
this.jsonOps = this.ops.map(op => JSON.stringify(op));
|
|
this.rclient.llen = sinon.stub().callsArgWith(1, null, this.length);
|
|
this.rclient.get = sinon.stub().callsArgWith(1, null, this.version.toString());
|
|
this.rclient.lrange = sinon.stub().callsArgWith(3, null, this.jsonOps);
|
|
return this.RedisManager.getPreviousDocOps(this.doc_id, this.start, this.end, this.callback);
|
|
});
|
|
|
|
it("should get the appropriate docs ops to the end of list", function() {
|
|
return this.rclient.lrange
|
|
.calledWith(`DocOps:${this.doc_id}`, this.start - this.first_version_in_redis, -1)
|
|
.should.equal(true);
|
|
});
|
|
|
|
return it("should return the docs with the doc ops deserialized", function() {
|
|
return this.callback.calledWith(null, this.ops).should.equal(true);
|
|
});
|
|
});
|
|
|
|
describe("when the requested range is not in Redis", function() {
|
|
beforeEach(function() {
|
|
this.first_version_in_redis = 30;
|
|
this.version = 70;
|
|
this.length = this.version - this.first_version_in_redis;
|
|
this.start = 20;
|
|
this.end = -1;
|
|
this.ops = [
|
|
{ "mock": "op-1" },
|
|
{ "mock": "op-2" }
|
|
];
|
|
this.jsonOps = this.ops.map(op => JSON.stringify(op));
|
|
this.rclient.llen = sinon.stub().callsArgWith(1, null, this.length);
|
|
this.rclient.get = sinon.stub().callsArgWith(1, null, this.version.toString());
|
|
this.rclient.lrange = sinon.stub().callsArgWith(3, null, this.jsonOps);
|
|
return this.RedisManager.getPreviousDocOps(this.doc_id, this.start, this.end, this.callback);
|
|
});
|
|
|
|
it("should return an error", function() {
|
|
return this.callback.calledWith(new Errors.OpRangeNotAvailableError("doc ops range is not loaded in redis")).should.equal(true);
|
|
});
|
|
|
|
return it("should log out the problem", function() {
|
|
return this.logger.warn.called.should.equal(true);
|
|
});
|
|
});
|
|
|
|
return describe("with a slow request to redis", function() {
|
|
beforeEach(function() {
|
|
this.first_version_in_redis = 30;
|
|
this.version = 70;
|
|
this.length = this.version - this.first_version_in_redis;
|
|
this.start = 50;
|
|
this.end = 60;
|
|
this.ops = [
|
|
{ "mock": "op-1" },
|
|
{ "mock": "op-2" }
|
|
];
|
|
this.jsonOps = this.ops.map(op => JSON.stringify(op));
|
|
this.rclient.llen = sinon.stub().callsArgWith(1, null, this.length);
|
|
this.rclient.get = sinon.stub().callsArgWith(1, null, this.version.toString());
|
|
this.clock = sinon.useFakeTimers();
|
|
this.rclient.lrange = (key, start, end, cb) => {
|
|
this.clock.tick(6000);
|
|
return cb(null, this.jsonOps);
|
|
};
|
|
return this.RedisManager.getPreviousDocOps(this.doc_id, this.start, this.end, this.callback);
|
|
});
|
|
|
|
afterEach(function() {
|
|
return this.clock.restore();
|
|
});
|
|
|
|
return it('should return an error', function() {
|
|
return this.callback
|
|
.calledWith(new Error("redis getPreviousDocOps exceeded timeout"))
|
|
.should.equal(true);
|
|
});
|
|
});
|
|
});
|
|
|
|
|
|
describe("updateDocument", function() {
|
|
beforeEach(function() {
|
|
this.lines = ["one", "two", "three", "これは"];
|
|
this.ops = [{ op: [{ i: "foo", p: 4 }] },{ op: [{ i: "bar", p: 8 }] }];
|
|
this.version = 42;
|
|
this.hash = crypto.createHash('sha1').update(JSON.stringify(this.lines),'utf8').digest('hex');
|
|
this.ranges = { comments: "mock", entries: "mock" };
|
|
this.updateMeta = { user_id: 'last-author-fake-id' };
|
|
this.doc_update_list_length = sinon.stub();
|
|
this.project_update_list_length = sinon.stub();
|
|
|
|
this.RedisManager.getDocVersion = sinon.stub();
|
|
this.multi.set = sinon.stub();
|
|
this.multi.rpush = sinon.stub();
|
|
this.multi.expire = sinon.stub();
|
|
this.multi.ltrim = sinon.stub();
|
|
this.multi.del = sinon.stub();
|
|
this.multi.exec = sinon.stub().callsArgWith(0, null,
|
|
[this.hash, null, null, null, null, null, null, this.doc_update_list_length, null, null]
|
|
);
|
|
return this.ProjectHistoryRedisManager.queueOps = sinon.stub().callsArgWith(
|
|
this.ops.length + 1, null, this.project_update_list_length
|
|
);
|
|
});
|
|
|
|
describe("with a consistent version", function() {
|
|
beforeEach(function() {});
|
|
|
|
|
|
describe("with project history enabled", function() {
|
|
beforeEach(function() {
|
|
this.settings.apis.project_history.enabled = true;
|
|
this.RedisManager.getDocVersion.withArgs(this.doc_id).yields(null, this.version - this.ops.length);
|
|
return this.RedisManager.updateDocument(this.project_id, this.doc_id, this.lines, this.version, this.ops, this.ranges, this.updateMeta, this.callback);
|
|
});
|
|
|
|
it("should get the current doc version to check for consistency", function() {
|
|
return this.RedisManager.getDocVersion
|
|
.calledWith(this.doc_id)
|
|
.should.equal(true);
|
|
});
|
|
|
|
it("should set the doclines", function() {
|
|
return this.multi.set
|
|
.calledWith(`doclines:${this.doc_id}`, JSON.stringify(this.lines))
|
|
.should.equal(true);
|
|
});
|
|
|
|
it("should set the version", function() {
|
|
return this.multi.set
|
|
.calledWith(`DocVersion:${this.doc_id}`, this.version)
|
|
.should.equal(true);
|
|
});
|
|
|
|
it("should set the hash", function() {
|
|
return this.multi.set
|
|
.calledWith(`DocHash:${this.doc_id}`, this.hash)
|
|
.should.equal(true);
|
|
});
|
|
|
|
it("should set the ranges", function() {
|
|
return this.multi.set
|
|
.calledWith(`Ranges:${this.doc_id}`, JSON.stringify(this.ranges))
|
|
.should.equal(true);
|
|
});
|
|
|
|
it("should set the unflushed time", function() {
|
|
return this.multi.set
|
|
.calledWith(`UnflushedTime:${this.doc_id}`, Date.now(), "NX")
|
|
.should.equal(true);
|
|
});
|
|
|
|
it("should set the last updated time", function() {
|
|
return this.multi.set
|
|
.calledWith(`lastUpdatedAt:${this.doc_id}`, Date.now())
|
|
.should.equal(true);
|
|
});
|
|
|
|
it("should set the last updater", function() {
|
|
return this.multi.set
|
|
.calledWith(`lastUpdatedBy:${this.doc_id}`, 'last-author-fake-id')
|
|
.should.equal(true);
|
|
});
|
|
|
|
it("should push the doc op into the doc ops list", function() {
|
|
return this.multi.rpush
|
|
.calledWith(`DocOps:${this.doc_id}`, JSON.stringify(this.ops[0]), JSON.stringify(this.ops[1]))
|
|
.should.equal(true);
|
|
});
|
|
|
|
it("should renew the expiry ttl on the doc ops array", function() {
|
|
return this.multi.expire
|
|
.calledWith(`DocOps:${this.doc_id}`, this.RedisManager.DOC_OPS_TTL)
|
|
.should.equal(true);
|
|
});
|
|
|
|
it("should truncate the list to 100 members", function() {
|
|
return this.multi.ltrim
|
|
.calledWith(`DocOps:${this.doc_id}`, -this.RedisManager.DOC_OPS_MAX_LENGTH, -1)
|
|
.should.equal(true);
|
|
});
|
|
|
|
it("should push the updates into the history ops list", function() {
|
|
return this.multi.rpush
|
|
.calledWith(`UncompressedHistoryOps:${this.doc_id}`, JSON.stringify(this.ops[0]), JSON.stringify(this.ops[1]))
|
|
.should.equal(true);
|
|
});
|
|
|
|
it("should push the updates into the project history ops list", function() {
|
|
return this.ProjectHistoryRedisManager.queueOps
|
|
.calledWith(this.project_id, JSON.stringify(this.ops[0]))
|
|
.should.equal(true);
|
|
});
|
|
|
|
it("should call the callback", function() {
|
|
return this.callback
|
|
.calledWith(null, this.doc_update_list_length, this.project_update_list_length)
|
|
.should.equal(true);
|
|
});
|
|
|
|
return it('should not log any errors', function() {
|
|
return this.logger.error.calledWith()
|
|
.should.equal(false);
|
|
});
|
|
});
|
|
|
|
describe("with project history disabled", function() {
|
|
beforeEach(function() {
|
|
this.settings.apis.project_history.enabled = false;
|
|
this.RedisManager.getDocVersion.withArgs(this.doc_id).yields(null, this.version - this.ops.length);
|
|
return this.RedisManager.updateDocument(this.project_id, this.doc_id, this.lines, this.version, this.ops, this.ranges, this.updateMeta, this.callback);
|
|
});
|
|
|
|
it("should not push the updates into the project history ops list", function() {
|
|
return this.ProjectHistoryRedisManager.queueOps.called.should.equal(false);
|
|
});
|
|
|
|
return it("should call the callback", function() {
|
|
return this.callback
|
|
.calledWith(null, this.doc_update_list_length)
|
|
.should.equal(true);
|
|
});
|
|
});
|
|
|
|
return describe("with a doc using project history only", function() {
|
|
beforeEach(function() {
|
|
this.RedisManager.getDocVersion.withArgs(this.doc_id).yields(null, this.version - this.ops.length, 'project-history');
|
|
return this.RedisManager.updateDocument(this.project_id, this.doc_id, this.lines, this.version, this.ops, this.ranges, this.updateMeta, this.callback);
|
|
});
|
|
|
|
it("should not push the updates to the track-changes ops list", function() {
|
|
return this.multi.rpush
|
|
.calledWith(`UncompressedHistoryOps:${this.doc_id}`)
|
|
.should.equal(false);
|
|
});
|
|
|
|
it("should push the updates into the project history ops list", function() {
|
|
return this.ProjectHistoryRedisManager.queueOps
|
|
.calledWith(this.project_id, JSON.stringify(this.ops[0]))
|
|
.should.equal(true);
|
|
});
|
|
|
|
return it("should call the callback with the project update count only", function() {
|
|
return this.callback
|
|
.calledWith(null, undefined, this.project_update_list_length)
|
|
.should.equal(true);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("with an inconsistent version", function() {
|
|
beforeEach(function() {
|
|
this.RedisManager.getDocVersion.withArgs(this.doc_id).yields(null, this.version - this.ops.length - 1);
|
|
return this.RedisManager.updateDocument(this.project_id, this.doc_id, this.lines, this.version, this.ops, this.ranges, this.updateMeta, this.callback);
|
|
});
|
|
|
|
it("should not call multi.exec", function() {
|
|
return this.multi.exec.called.should.equal(false);
|
|
});
|
|
|
|
return it("should call the callback with an error", function() {
|
|
return this.callback
|
|
.calledWith(new Error(`Version mismatch. '${this.doc_id}' is corrupted.`))
|
|
.should.equal(true);
|
|
});
|
|
});
|
|
|
|
describe("with no updates", function() {
|
|
beforeEach(function() {
|
|
this.RedisManager.getDocVersion.withArgs(this.doc_id).yields(null, this.version);
|
|
return this.RedisManager.updateDocument(this.project_id, this.doc_id, this.lines, this.version, [], this.ranges, this.updateMeta, this.callback);
|
|
});
|
|
|
|
it("should not try to enqueue doc updates", function() {
|
|
return this.multi.rpush
|
|
.called
|
|
.should.equal(false);
|
|
});
|
|
|
|
it("should not try to enqueue project updates", function() {
|
|
return this.ProjectHistoryRedisManager.queueOps
|
|
.called
|
|
.should.equal(false);
|
|
});
|
|
|
|
return it("should still set the doclines", function() {
|
|
return this.multi.set
|
|
.calledWith(`doclines:${this.doc_id}`, JSON.stringify(this.lines))
|
|
.should.equal(true);
|
|
});
|
|
});
|
|
|
|
describe("with empty ranges", function() {
|
|
beforeEach(function() {
|
|
this.RedisManager.getDocVersion.withArgs(this.doc_id).yields(null, this.version - this.ops.length);
|
|
return this.RedisManager.updateDocument(this.project_id, this.doc_id, this.lines, this.version, this.ops, {}, this.updateMeta, this.callback);
|
|
});
|
|
|
|
it("should not set the ranges", function() {
|
|
return this.multi.set
|
|
.calledWith(`Ranges:${this.doc_id}`, JSON.stringify(this.ranges))
|
|
.should.equal(false);
|
|
});
|
|
|
|
return it("should delete the ranges key", function() {
|
|
return this.multi.del
|
|
.calledWith(`Ranges:${this.doc_id}`)
|
|
.should.equal(true);
|
|
});
|
|
});
|
|
|
|
describe("with null bytes in the serialized doc lines", function() {
|
|
beforeEach(function() {
|
|
this.RedisManager.getDocVersion.withArgs(this.doc_id).yields(null, this.version - this.ops.length);
|
|
this._stringify = JSON.stringify;
|
|
this.JSON.stringify = () => '["bad bytes! \u0000 <- here"]';
|
|
return this.RedisManager.updateDocument(this.project_id, this.doc_id, this.lines, this.version, this.ops, this.ranges, this.updateMeta, this.callback);
|
|
});
|
|
|
|
afterEach(function() {
|
|
return this.JSON.stringify = this._stringify;
|
|
});
|
|
|
|
it("should log an error", function() {
|
|
return this.logger.error.called.should.equal(true);
|
|
});
|
|
|
|
return it("should call the callback with an error", function() {
|
|
return this.callback.calledWith(new Error("null bytes found in doc lines")).should.equal(true);
|
|
});
|
|
});
|
|
|
|
describe("with ranges that are too big", function() {
|
|
beforeEach(function() {
|
|
this.RedisManager.getDocVersion.withArgs(this.doc_id).yields(null, this.version - this.ops.length);
|
|
this.RedisManager._serializeRanges = sinon.stub().yields(new Error("ranges are too large"));
|
|
return this.RedisManager.updateDocument(this.project_id, this.doc_id, this.lines, this.version, this.ops, this.ranges, this.updateMeta, this.callback);
|
|
});
|
|
|
|
it('should log an error', function() {
|
|
return this.logger.error.called.should.equal(true);
|
|
});
|
|
|
|
return it("should call the callback with the error", function() {
|
|
return this.callback.calledWith(new Error("ranges are too large")).should.equal(true);
|
|
});
|
|
});
|
|
|
|
return describe("without user id from meta", function() {
|
|
beforeEach(function() {
|
|
this.RedisManager.getDocVersion.withArgs(this.doc_id).yields(null, this.version - this.ops.length);
|
|
return this.RedisManager.updateDocument(this.project_id, this.doc_id, this.lines, this.version, this.ops, this.ranges, {}, this.callback);
|
|
});
|
|
|
|
it("should set the last updater to null", function() {
|
|
return this.multi.del
|
|
.calledWith(`lastUpdatedBy:${this.doc_id}`)
|
|
.should.equal(true);
|
|
});
|
|
|
|
return it("should still set the last updated time", function() {
|
|
return this.multi.set
|
|
.calledWith(`lastUpdatedAt:${this.doc_id}`, Date.now())
|
|
.should.equal(true);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("putDocInMemory", function() {
|
|
beforeEach(function() {
|
|
this.multi.set = sinon.stub();
|
|
this.rclient.sadd = sinon.stub().yields();
|
|
this.multi.del = sinon.stub();
|
|
this.lines = ["one", "two", "three", "これは"];
|
|
this.version = 42;
|
|
this.hash = crypto.createHash('sha1').update(JSON.stringify(this.lines),'utf8').digest('hex');
|
|
this.multi.exec = sinon.stub().callsArgWith(0, null, [this.hash]);
|
|
this.ranges = { comments: "mock", entries: "mock" };
|
|
return this.pathname = '/a/b/c.tex';
|
|
});
|
|
|
|
describe("with non-empty ranges", function() {
|
|
beforeEach(function(done) {
|
|
return this.RedisManager.putDocInMemory(this.project_id, this.doc_id, this.lines, this.version, this.ranges, this.pathname, this.projectHistoryId, done);
|
|
});
|
|
|
|
it("should set the lines", function() {
|
|
return this.multi.set
|
|
.calledWith(`doclines:${this.doc_id}`, JSON.stringify(this.lines))
|
|
.should.equal(true);
|
|
});
|
|
|
|
it("should set the version", function() {
|
|
return this.multi.set
|
|
.calledWith(`DocVersion:${this.doc_id}`, this.version)
|
|
.should.equal(true);
|
|
});
|
|
|
|
it("should set the hash", function() {
|
|
return this.multi.set
|
|
.calledWith(`DocHash:${this.doc_id}`, this.hash)
|
|
.should.equal(true);
|
|
});
|
|
|
|
it("should set the ranges", function() {
|
|
return this.multi.set
|
|
.calledWith(`Ranges:${this.doc_id}`, JSON.stringify(this.ranges))
|
|
.should.equal(true);
|
|
});
|
|
|
|
it("should set the project_id for the doc", function() {
|
|
return this.multi.set
|
|
.calledWith(`ProjectId:${this.doc_id}`, this.project_id)
|
|
.should.equal(true);
|
|
});
|
|
|
|
it("should set the pathname for the doc", function() {
|
|
return this.multi.set
|
|
.calledWith(`Pathname:${this.doc_id}`, this.pathname)
|
|
.should.equal(true);
|
|
});
|
|
|
|
it("should set the projectHistoryId for the doc", function() {
|
|
return this.multi.set
|
|
.calledWith(`ProjectHistoryId:${this.doc_id}`, this.projectHistoryId)
|
|
.should.equal(true);
|
|
});
|
|
|
|
it("should add the doc_id to the project set", function() {
|
|
return this.rclient.sadd
|
|
.calledWith(`DocsIn:${this.project_id}`, this.doc_id)
|
|
.should.equal(true);
|
|
});
|
|
|
|
return it('should not log any errors', function() {
|
|
return this.logger.error.calledWith()
|
|
.should.equal(false);
|
|
});
|
|
});
|
|
|
|
describe("with empty ranges", function() {
|
|
beforeEach(function(done) {
|
|
return this.RedisManager.putDocInMemory(this.project_id, this.doc_id, this.lines, this.version, {}, this.pathname, this.projectHistoryId, done);
|
|
});
|
|
|
|
it("should delete the ranges key", function() {
|
|
return this.multi.del
|
|
.calledWith(`Ranges:${this.doc_id}`)
|
|
.should.equal(true);
|
|
});
|
|
|
|
return it("should not set the ranges", function() {
|
|
return this.multi.set
|
|
.calledWith(`Ranges:${this.doc_id}`, JSON.stringify(this.ranges))
|
|
.should.equal(false);
|
|
});
|
|
});
|
|
|
|
describe("with null bytes in the serialized doc lines", function() {
|
|
beforeEach(function() {
|
|
this._stringify = JSON.stringify;
|
|
this.JSON.stringify = () => '["bad bytes! \u0000 <- here"]';
|
|
return this.RedisManager.putDocInMemory(this.project_id, this.doc_id, this.lines, this.version, this.ranges, this.pathname, this.projectHistoryId, this.callback);
|
|
});
|
|
|
|
afterEach(function() {
|
|
return this.JSON.stringify = this._stringify;
|
|
});
|
|
|
|
it("should log an error", function() {
|
|
return this.logger.error.called.should.equal(true);
|
|
});
|
|
|
|
return it("should call the callback with an error", function() {
|
|
return this.callback.calledWith(new Error("null bytes found in doc lines")).should.equal(true);
|
|
});
|
|
});
|
|
|
|
return describe("with ranges that are too big", function() {
|
|
beforeEach(function() {
|
|
this.RedisManager._serializeRanges = sinon.stub().yields(new Error("ranges are too large"));
|
|
return this.RedisManager.putDocInMemory(this.project_id, this.doc_id, this.lines, this.version, this.ranges, this.pathname, this.projectHistoryId, this.callback);
|
|
});
|
|
|
|
it('should log an error', function() {
|
|
return this.logger.error.called.should.equal(true);
|
|
});
|
|
|
|
return it("should call the callback with the error", function() {
|
|
return this.callback.calledWith(new Error("ranges are too large")).should.equal(true);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("removeDocFromMemory", function() {
|
|
beforeEach(function(done) {
|
|
this.multi.strlen = sinon.stub();
|
|
this.multi.del = sinon.stub();
|
|
this.multi.srem = sinon.stub();
|
|
this.multi.exec.yields();
|
|
return this.RedisManager.removeDocFromMemory(this.project_id, this.doc_id, done);
|
|
});
|
|
|
|
it("should check the length of the current doclines", function() {
|
|
return this.multi.strlen
|
|
.calledWith(`doclines:${this.doc_id}`)
|
|
.should.equal(true);
|
|
});
|
|
|
|
it("should delete the lines", function() {
|
|
return this.multi.del
|
|
.calledWith(`doclines:${this.doc_id}`)
|
|
.should.equal(true);
|
|
});
|
|
|
|
it("should delete the version", function() {
|
|
return this.multi.del
|
|
.calledWith(`DocVersion:${this.doc_id}`)
|
|
.should.equal(true);
|
|
});
|
|
|
|
it("should delete the hash", function() {
|
|
return this.multi.del
|
|
.calledWith(`DocHash:${this.doc_id}`)
|
|
.should.equal(true);
|
|
});
|
|
|
|
it("should delete the unflushed time", function() {
|
|
return this.multi.del
|
|
.calledWith(`UnflushedTime:${this.doc_id}`)
|
|
.should.equal(true);
|
|
});
|
|
|
|
it("should delete the project_id for the doc", function() {
|
|
return this.multi.del
|
|
.calledWith(`ProjectId:${this.doc_id}`)
|
|
.should.equal(true);
|
|
});
|
|
|
|
it("should remove the doc_id from the project set", function() {
|
|
return this.multi.srem
|
|
.calledWith(`DocsIn:${this.project_id}`, this.doc_id)
|
|
.should.equal(true);
|
|
});
|
|
|
|
it("should delete the pathname for the doc", function() {
|
|
return this.multi.del
|
|
.calledWith(`Pathname:${this.doc_id}`)
|
|
.should.equal(true);
|
|
});
|
|
|
|
it("should delete the pathname for the doc", function() {
|
|
return this.multi.del
|
|
.calledWith(`ProjectHistoryId:${this.doc_id}`)
|
|
.should.equal(true);
|
|
});
|
|
|
|
it("should delete lastUpdatedAt", function() {
|
|
return this.multi.del
|
|
.calledWith(`lastUpdatedAt:${this.doc_id}`)
|
|
.should.equal(true);
|
|
});
|
|
|
|
return it("should delete lastUpdatedBy", function() {
|
|
return this.multi.del
|
|
.calledWith(`lastUpdatedBy:${this.doc_id}`)
|
|
.should.equal(true);
|
|
});
|
|
});
|
|
|
|
|
|
describe("clearProjectState", function() {
|
|
beforeEach(function(done) {
|
|
this.rclient.del = sinon.stub().callsArg(1);
|
|
return this.RedisManager.clearProjectState(this.project_id, done);
|
|
});
|
|
|
|
return it("should delete the project state", function() {
|
|
return this.rclient.del
|
|
.calledWith(`ProjectState:${this.project_id}`)
|
|
.should.equal(true);
|
|
});
|
|
});
|
|
|
|
return describe("renameDoc", function() {
|
|
beforeEach(function() {
|
|
this.rclient.rpush = sinon.stub().yields();
|
|
this.rclient.set = sinon.stub().yields();
|
|
return this.update = {
|
|
id: this.doc_id,
|
|
pathname: (this.pathname = 'pathname'),
|
|
newPathname: (this.newPathname = 'new-pathname')
|
|
};
|
|
});
|
|
|
|
describe("the document is cached in redis", function() {
|
|
beforeEach(function() {
|
|
this.RedisManager.getDoc = sinon.stub().callsArgWith(2, null, 'lines', 'version');
|
|
this.ProjectHistoryRedisManager.queueRenameEntity = sinon.stub().yields();
|
|
return this.RedisManager.renameDoc(this.project_id, this.doc_id, this.userId, this.update, this.projectHistoryId, this.callback);
|
|
});
|
|
|
|
it("update the cached pathname", function() {
|
|
return this.rclient.set
|
|
.calledWith(`Pathname:${this.doc_id}`, this.newPathname)
|
|
.should.equal(true);
|
|
});
|
|
|
|
return it("should queue an update", function() {
|
|
return this.ProjectHistoryRedisManager.queueRenameEntity
|
|
.calledWithExactly(this.project_id, this.projectHistoryId, 'doc', this.doc_id, this.userId, this.update, this.callback)
|
|
.should.equal(true);
|
|
});
|
|
});
|
|
|
|
describe("the document is not cached in redis", function() {
|
|
beforeEach(function() {
|
|
this.RedisManager.getDoc = sinon.stub().callsArgWith(2, null, null, null);
|
|
this.ProjectHistoryRedisManager.queueRenameEntity = sinon.stub().yields();
|
|
return this.RedisManager.renameDoc(this.project_id, this.doc_id, this.userId, this.update, this.projectHistoryId, this.callback);
|
|
});
|
|
|
|
it("does not update the cached pathname", function() {
|
|
return this.rclient.set.called.should.equal(false);
|
|
});
|
|
|
|
return it("should queue an update", function() {
|
|
return this.ProjectHistoryRedisManager.queueRenameEntity
|
|
.calledWithExactly(this.project_id, this.projectHistoryId, 'doc', this.doc_id, this.userId, this.update, this.callback)
|
|
.should.equal(true);
|
|
});
|
|
});
|
|
|
|
return describe("getDocVersion", function() {
|
|
beforeEach(function() {
|
|
return this.version = 12345;
|
|
});
|
|
|
|
describe("when the document does not have a project history type set", function() {
|
|
beforeEach(function() {
|
|
this.rclient.mget = sinon.stub().withArgs(`DocVersion:${this.doc_id}`, `ProjectHistoryType:${this.doc_id}`).callsArgWith(2, null, [`${this.version}`]);
|
|
return this.RedisManager.getDocVersion(this.doc_id, this.callback);
|
|
});
|
|
|
|
return it("should return the document version and an undefined history type", function() {
|
|
return this.callback.calledWithExactly(null, this.version, undefined).should.equal(true);
|
|
});
|
|
});
|
|
|
|
return describe("when the document has a project history type set", function() {
|
|
beforeEach(function() {
|
|
this.rclient.mget = sinon.stub().withArgs(`DocVersion:${this.doc_id}`, `ProjectHistoryType:${this.doc_id}`).callsArgWith(2, null, [`${this.version}`, 'project-history']);
|
|
return this.RedisManager.getDocVersion(this.doc_id, this.callback);
|
|
});
|
|
|
|
return it("should return the document version and history type", function() {
|
|
return this.callback.calledWithExactly(null, this.version, 'project-history').should.equal(true);
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|