overleaf/services/track-changes/test/unit/coffee/DiffGenerator/DiffGeneratorTests.coffee
James Allen 23dfe68cb8 Don't error when rewinding and insert op which is beyond the length of the document.
ShareJS will accept an op where p > content.length when applied,
and it applies as though p == content.length. However, the op is
passed to us with the original p > content.length. Detect if that
is the case with this op, and shift p back appropriately to match
ShareJS if so.
2015-09-25 13:44:44 +01:00

344 lines
11 KiB
CoffeeScript

sinon = require('sinon')
chai = require('chai')
should = chai.should()
expect = chai.expect
modulePath = "../../../../app/js/DiffGenerator.js"
SandboxedModule = require('sandboxed-module')
describe "DiffGenerator", ->
beforeEach ->
@DiffGenerator = SandboxedModule.require modulePath, requires:
"logger-sharelatex": { warn: sinon.stub() }
@ts = Date.now()
@user_id = "mock-user-id"
@user_id_2 = "mock-user-id-2"
@meta = {
start_ts: @ts, end_ts: @ts, user_id: @user_id
}
describe "rewindOp", ->
describe "rewinding an insert", ->
it "should undo the insert", ->
content = "hello world"
rewoundContent = @DiffGenerator.rewindOp content, { p: 6, i: "wo" }
rewoundContent.should.equal "hello rld"
describe "rewinding a delete", ->
it "should undo the delete", ->
content = "hello rld"
rewoundContent = @DiffGenerator.rewindOp content, { p: 6, d: "wo" }
rewoundContent.should.equal "hello world"
describe "with an inconsistent update", ->
it "should throw an error", ->
content = "hello world"
expect( () =>
@DiffGenerator.rewindOp content, { p: 6, i: "foo" }
).to.throw(@DiffGenerator.ConsistencyError)
describe "with an update which is beyond the length of the content", ->
it "should undo the insert as if it were at the end of the content", ->
content = "foobar"
rewoundContent = @DiffGenerator.rewindOp content, { p: 4, i: "bar" }
rewoundContent.should.equal "foo"
describe "rewindUpdate", ->
it "should rewind ops in reverse", ->
content = "aaabbbccc"
update =
op: [{ p: 3, i: "bbb" }, { p: 6, i: "ccc" }]
rewoundContent = @DiffGenerator.rewindUpdate content, update
rewoundContent.should.equal "aaa"
describe "rewindUpdates", ->
it "should rewind updates in reverse", ->
content = "aaabbbccc"
updates = [
{ op: [{ p: 3, i: "bbb" }] },
{ op: [{ p: 6, i: "ccc" }] }
]
rewoundContent = @DiffGenerator.rewindUpdates content, updates
rewoundContent.should.equal "aaa"
describe "buildDiff", ->
beforeEach ->
@diff = [ u: "mock-diff" ]
@content = "Hello world"
@updates = [
{ i: "mock-update-1" }
{ i: "mock-update-2" }
{ i: "mock-update-3" }
]
@DiffGenerator.applyUpdateToDiff = sinon.stub().returns(@diff)
@DiffGenerator.compressDiff = sinon.stub().returns(@diff)
@result = @DiffGenerator.buildDiff(@content, @updates)
it "should return the diff", ->
@result.should.deep.equal @diff
it "should build the content into an initial diff", ->
@DiffGenerator.applyUpdateToDiff
.calledWith([{
u: @content
}], @updates[0])
.should.equal true
it "should apply each update", ->
for update in @updates
@DiffGenerator.applyUpdateToDiff
.calledWith(sinon.match.any, update)
.should.equal true
it "should compress the diff", ->
@DiffGenerator.compressDiff
.calledWith(@diff)
.should.equal true
describe "compressDiff", ->
describe "with adjacent inserts with the same user_id", ->
it "should create one update with combined meta data and min/max timestamps", ->
diff = @DiffGenerator.compressDiff([
{ i: "foo", meta: { start_ts: 10, end_ts: 20, user: { id: @user_id } }}
{ i: "bar", meta: { start_ts: 5, end_ts: 15, user: { id: @user_id } }}
])
expect(diff).to.deep.equal([
{ i: "foobar", meta: { start_ts: 5, end_ts: 20, user: { id: @user_id } }}
])
describe "with adjacent inserts with different user_ids", ->
it "should leave the inserts unchanged", ->
input = [
{ i: "foo", meta: { start_ts: 10, end_ts: 20, user: { id: @user_id } }}
{ i: "bar", meta: { start_ts: 5, end_ts: 15, user: { id: @user_id_2 } }}
]
output = @DiffGenerator.compressDiff(input)
expect(output).to.deep.equal(input)
describe "with adjacent deletes with the same user_id", ->
it "should create one update with combined meta data and min/max timestamps", ->
diff = @DiffGenerator.compressDiff([
{ d: "foo", meta: { start_ts: 10, end_ts: 20, user: { id: @user_id } }}
{ d: "bar", meta: { start_ts: 5, end_ts: 15, user: { id: @user_id } }}
])
expect(diff).to.deep.equal([
{ d: "foobar", meta: { start_ts: 5, end_ts: 20, user: { id: @user_id } }}
])
describe "with adjacent deletes with different user_ids", ->
it "should leave the deletes unchanged", ->
input = [
{ d: "foo", meta: { start_ts: 10, end_ts: 20, user: { id: @user_id } }}
{ d: "bar", meta: { start_ts: 5, end_ts: 15, user: { id: @user_id_2 } }}
]
output = @DiffGenerator.compressDiff(input)
expect(output).to.deep.equal(input)
describe "applyUpdateToDiff", ->
describe "an insert", ->
it "should insert into the middle of (u)nchanged text", ->
diff = @DiffGenerator.applyUpdateToDiff(
[ { u: "foobar" } ],
{ op: [{ p: 3, i: "baz" }], meta: @meta }
)
expect(diff).to.deep.equal([
{ u: "foo" }
{ i: "baz", meta: @meta }
{ u: "bar" }
])
it "should insert into the start of (u)changed text", ->
diff = @DiffGenerator.applyUpdateToDiff(
[ { u: "foobar" } ],
{ op: [{ p: 0, i: "baz" }], meta: @meta }
)
expect(diff).to.deep.equal([
{ i: "baz", meta: @meta }
{ u: "foobar" }
])
it "should insert into the end of (u)changed text", ->
diff = @DiffGenerator.applyUpdateToDiff(
[ { u: "foobar" } ],
{ op: [{ p: 6, i: "baz" }], meta: @meta }
)
expect(diff).to.deep.equal([
{ u: "foobar" }
{ i: "baz", meta: @meta }
])
it "should insert into the middle of (i)inserted text", ->
diff = @DiffGenerator.applyUpdateToDiff(
[ { i: "foobar", meta: @meta } ],
{ op: [{ p: 3, i: "baz" }], meta: @meta }
)
expect(diff).to.deep.equal([
{ i: "foo", meta: @meta }
{ i: "baz", meta: @meta }
{ i: "bar", meta: @meta }
])
it "should not count deletes in the running length total", ->
diff = @DiffGenerator.applyUpdateToDiff(
[
{ d: "deleted", meta: @meta }
{ u: "foobar" }
],
{ op: [{ p: 3, i: "baz" }], meta: @meta }
)
expect(diff).to.deep.equal([
{ d: "deleted", meta: @meta }
{ u: "foo" }
{ i: "baz", meta: @meta }
{ u: "bar" }
])
describe "a delete", ->
describe "deleting unchanged text", ->
it "should delete from the middle of (u)nchanged text", ->
diff = @DiffGenerator.applyUpdateToDiff(
[ { u: "foobazbar" } ],
{ op: [{ p: 3, d: "baz" }], meta: @meta }
)
expect(diff).to.deep.equal([
{ u: "foo" }
{ d: "baz", meta: @meta }
{ u: "bar" }
])
it "should delete from the start of (u)nchanged text", ->
diff = @DiffGenerator.applyUpdateToDiff(
[ { u: "foobazbar" } ],
{ op: [{ p: 0, d: "foo" }], meta: @meta }
)
expect(diff).to.deep.equal([
{ d: "foo", meta: @meta }
{ u: "bazbar" }
])
it "should delete from the end of (u)nchanged text", ->
diff = @DiffGenerator.applyUpdateToDiff(
[ { u: "foobazbar" } ],
{ op: [{ p: 6, d: "bar" }], meta: @meta }
)
expect(diff).to.deep.equal([
{ u: "foobaz" }
{ d: "bar", meta: @meta }
])
it "should delete across multiple (u)changed text parts", ->
diff = @DiffGenerator.applyUpdateToDiff(
[ { u: "foo" }, { u: "baz" }, { u: "bar" } ],
{ op: [{ p: 2, d: "obazb" }], meta: @meta }
)
expect(diff).to.deep.equal([
{ u: "fo" }
{ d: "o", meta: @meta }
{ d: "baz", meta: @meta }
{ d: "b", meta: @meta }
{ u: "ar" }
])
describe "deleting inserts", ->
it "should delete from the middle of (i)nserted text", ->
diff = @DiffGenerator.applyUpdateToDiff(
[ { i: "foobazbar", meta: @meta } ],
{ op: [{ p: 3, d: "baz" }], meta: @meta }
)
expect(diff).to.deep.equal([
{ i: "foo", meta: @meta }
{ i: "bar", meta: @meta }
])
it "should delete from the start of (u)nchanged text", ->
diff = @DiffGenerator.applyUpdateToDiff(
[ { i: "foobazbar", meta: @meta } ],
{ op: [{ p: 0, d: "foo" }], meta: @meta }
)
expect(diff).to.deep.equal([
{ i: "bazbar", meta: @meta }
])
it "should delete from the end of (u)nchanged text", ->
diff = @DiffGenerator.applyUpdateToDiff(
[ { i: "foobazbar", meta: @meta } ],
{ op: [{ p: 6, d: "bar" }], meta: @meta }
)
expect(diff).to.deep.equal([
{ i: "foobaz", meta: @meta }
])
it "should delete across multiple (u)changed and (i)nserted text parts", ->
diff = @DiffGenerator.applyUpdateToDiff(
[ { u: "foo" }, { i: "baz", meta: @meta }, { u: "bar" } ],
{ op: [{ p: 2, d: "obazb" }], meta: @meta }
)
expect(diff).to.deep.equal([
{ u: "fo" }
{ d: "o", meta: @meta }
{ d: "b", meta: @meta }
{ u: "ar" }
])
describe "deleting over existing deletes", ->
it "should delete across multiple (u)changed and (d)deleted text parts", ->
diff = @DiffGenerator.applyUpdateToDiff(
[ { u: "foo" }, { d: "baz", meta: @meta }, { u: "bar" } ],
{ op: [{ p: 2, d: "ob" }], meta: @meta }
)
expect(diff).to.deep.equal([
{ u: "fo" }
{ d: "o", meta: @meta }
{ d: "baz", meta: @meta }
{ d: "b", meta: @meta }
{ u: "ar" }
])
describe "deleting when the text doesn't match", ->
it "should throw an error when deleting from the middle of (u)nchanged text", ->
expect(
() => @DiffGenerator.applyUpdateToDiff(
[ { u: "foobazbar" } ],
{ op: [{ p: 3, d: "xxx" }], meta: @meta }
)
).to.throw(@DiffGenerator.ConsistencyError)
it "should throw an error when deleting from the start of (u)nchanged text", ->
expect(
() => @DiffGenerator.applyUpdateToDiff(
[ { u: "foobazbar" } ],
{ op: [{ p: 0, d: "xxx" }], meta: @meta }
)
).to.throw(@DiffGenerator.ConsistencyError)
it "should throw an error when deleting from the end of (u)nchanged text", ->
expect(
() => @DiffGenerator.applyUpdateToDiff(
[ { u: "foobazbar" } ],
{ op: [{ p: 6, d: "xxx" }] , meta: @meta }
)
).to.throw(@DiffGenerator.ConsistencyError)
describe "when the last update in the existing diff is a delete", ->
it "should insert the new update before the delete", ->
diff = @DiffGenerator.applyUpdateToDiff(
[ { u: "foo" }, { d: "bar", meta: @meta } ],
{ op: [{ p: 3, i: "baz" }], meta: @meta }
)
expect(diff).to.deep.equal([
{ u: "foo" }
{ i: "baz", meta: @meta }
{ d: "bar", meta: @meta }
])
describe "when the only update in the existing diff is a delete", ->
it "should insert the new update after the delete", ->
diff = @DiffGenerator.applyUpdateToDiff(
[ { d: "bar", meta: @meta } ],
{ op: [{ p: 0, i: "baz" }], meta: @meta }
)
expect(diff).to.deep.equal([
{ d: "bar", meta: @meta }
{ i: "baz", meta: @meta }
])