public void Ensure_When_We_Construct_A_Revision_It_Contains_A_Reference_To_The_Previous_Revision()
{
var previousRevision = new TestRevision("Test");
var patches = new diff_match_patch().patch_make("Test", "Test2");
var revison = new BasicRevision(previousRevision, patches);
Assert.That(revison.PreviousRevisionAppliedTo != null);
}
public void Ensure_When_We_Construct_A_Revision_We_Can_Retrieve_The_Current_Document_Content_From_The_Revision_Object()
{
var previousRevision = new TestRevision("Test");
var patches = new diff_match_patch().patch_make("Test", "Test2");
var revison = new BasicRevision(previousRevision, patches);
Assert.That(revison.GenerateEditedContent() != null);
}
public void Ensure_We_Can_Construct_A_Basic_Revision()
{
var previousRevision = new TestRevision("Test");
var patches = new diff_match_patch().patch_make("Test", "Test2");
var revison = new BasicRevision(previousRevision, patches);
Assert.That(revison != null);
}
public void Ensure_When_We_Construct_A_Revision_And_Retreive_The_Current_Document_That_It_Contains_Changes_From_The_Latest_Revision()
{
var previousRevision = new TestRevision("Test");
var patches = new diff_match_patch().patch_make("Test", "Test2");
var revison = new BasicRevision(previousRevision,patches);
var content = revison.GenerateEditedContent();
Assert.That(content, Is.EqualTo("Test2"));
}
public void Given_A_Merging_Revision_With_Two_Mergeable_Revisions_Ensure_That_When_We_Retrieve_The_Current_Document_It_Contains_The_Merge()
{
var originalRevision = new TestRevision("Test\nTest");
var revisionOne = new BasicRevision(originalRevision, Patches.Make(originalRevision.GenerateEditedContent(), "Test\nTest3"));
var revisionTwo = new BasicRevision(originalRevision, Patches.Make(originalRevision.GenerateEditedContent(), "Test2\nTest"));
var revision = new MergingRevision(originalRevision, new List<IRevision> {revisionOne, revisionTwo});
Assert.That(revision.GenerateEditedContent(), Is.EqualTo("Test2\nTest3"));
}
public void Execute()
{
var document = Session.Load<Document>(_documentEditRequest.DocumentId);
var parentRevision = document.LoadRevision(_documentEditRequest.ParentRevisionId);
if(parentRevision == null)
throw new InvalidDataException("Cannot load the revision specified by this DocumentEditRequest");
var revision = new BasicRevision(parentRevision, _documentEditRequest.Patches.ToList(), _documentEditRequest.RevisionId);
document.Edit(revision);
}
public void Ensure_We_Can_Construct_A_Merging_Revision()
{
var originalRevision = new TestRevision("Test\nTest");
var revisionOne = new BasicRevision(originalRevision,
Patches.Make(originalRevision.GenerateEditedContent(), "Test\nTest3"));
var revisionTwo = new BasicRevision(originalRevision,
Patches.Make(originalRevision.GenerateEditedContent(), "Test2\nTest"));
var revision = new MergingRevision(originalRevision, new List<IRevision> { revisionOne, revisionTwo });
Assert.That(revision != null);
}
public void Given_Two_Un_Mergeable_Revisions_Ensure_that_When_We_Construct_The_MergingRevision_Ensure_It_Is_Marked_As_In_Conflict()
{
var originalRevision = new TestRevision("Test\nTest");
var revisionOne = new BasicRevision(originalRevision,
Patches.Make(originalRevision.GenerateEditedContent(),
"The quick brown fox jumped over the lazy dog\nTest"));
var revisionTwo = new BasicRevision(originalRevision,
Patches.Make(originalRevision.GenerateEditedContent(),
"Waiter, there's a fly in my soup\nTest"));
var revision = new MergingRevision(originalRevision, new List<IRevision> { revisionOne, revisionTwo });
Assert.That(revision.RevisionsConflict);
}
public void Given_A_Merging_Revision_With_Two_Un_Mergeable_Revisions_Ensure_that_When_We_Retrieve_The_Current_Document_We_Recieve_An_Exception()
{
var originalRevision = new TestRevision("Test\nTest");
var revisionOne = new BasicRevision(originalRevision,
Patches.Make(originalRevision.GenerateEditedContent(),
"The quick brown fox jumped over the lazy dog\nTest"));
var revisionTwo = new BasicRevision(originalRevision,
Patches.Make(originalRevision.GenerateEditedContent(),
"Waiter, there's a fly in my soup\nTest"));
var revision = new MergingRevision(originalRevision, new List<IRevision> {revisionOne, revisionTwo});
Assert.Throws<ConflictException>(() => revision.GenerateEditedContent());
}
public void Given_A_Merging_Revision_With_Two_Un_Mergeable_Revisions_Ensure_that_If_We_Set_A_Revision_For_Resolution_And_Then_Call_GenerateEditedContent_It_Returns_The_Resolution_Revision()
{
var originalRevision = new TestRevision("Test\nTest");
var revisionOne = new BasicRevision(originalRevision,
Patches.Make(originalRevision.GenerateEditedContent(),
"The quick brown fox jumped over the lazy dog\nTest"));
var revisionTwo = new BasicRevision(originalRevision,
Patches.Make(originalRevision.GenerateEditedContent(),
"Waiter, there's a fly in my soup\nTest"));
var revision = new MergingRevision(originalRevision, new List<IRevision> { revisionOne, revisionTwo });
revision.ResolveConflict(new TestRevision("The quick brown fox jumped over the lazy dog\nWaiter, there's a fly in my soup\nTest"));
Assert.That(revision.GenerateEditedContent(),
Is.EqualTo(
"The quick brown fox jumped over the lazy dog\nWaiter, there's a fly in my soup\nTest"));
}
public void Ensure_That_When_We_Save_And_Then_Reload_a_Document_That_The_NextRevision_Applied_Property_On_Its_Revisios_Is_Populated()
{
Document document;
using (var session = DocumentStore.OpenSession())
{
document = new Document("Test");
var revision = new BasicRevision(document.CurrentRevision, Patches.Make(document.Contents, "Test2"));
document.Edit(revision);
session.Store(document);
session.SaveChanges();
}
using (var session = DocumentStore.OpenSession())
{
var loadedDoc = session.Load<Document>(document.Id);
Assert.That(loadedDoc.CurrentRevision.PreviousRevisionAppliedTo.NextRevisionApplied, Is.EqualTo(loadedDoc.CurrentRevision));
}
}
public void Ensure_That_If_We_Add_Two_Revisions_With_The_Same_Previous_Revision_The_Document_Handles_The_Merge()
{
var document = new Document("I went to the store to get mom some milk");
var revisionOne = new BasicRevision(document.CurrentRevision,
Patches.Make("I went to the store to get mom some milk",
"I went to the store to get mom some milk and crackers"));
var revisionTwo = new BasicRevision(document.CurrentRevision,
Patches.Make("I went to the store to get mom some milk",
"I ran to the store to get mom some milk"));
document.Edit(revisionTwo);
document.Edit(revisionOne);
Assert.That(document.CurrentRevision.GenerateEditedContent(),
Is.EqualTo("I ran to the store to get mom some milk and crackers"));
}
public void Given_We_Have_A_Document_With_A_Merging_Revision_As_The_Parent_Of_The_Current_Revision_Ensure_That_When_The_Document_Is_Edited_With_A_Revision_Targeting_One_Of_The_Merged_Revisions_The_New_Revision_Is_Merged_In()
{
var document = new Document("I went to the store to get some milk");
var revisionsToMerge = new[]
{
"I ran to the store to get some milk",
"I went to the store to get some milk and crackers"
}.Select(s => new BasicRevision(document.CurrentRevision, Patches.Make(document.Contents, s))).ToList();
foreach (var basicRevision in revisionsToMerge)
document.Edit(basicRevision);
var postMergeRevision = new BasicRevision(document.CurrentRevision,
Patches.Make(document.Contents,
"I ran to the store to get mom some milk and crackers"));
document.Edit(postMergeRevision);
var lateRevisionsParent = revisionsToMerge.First();
var lateRevision = new BasicRevision(lateRevisionsParent,
Patches.Make(lateRevisionsParent.GenerateEditedContent(),
"I ran to the corner store to get some milk"));
document.Edit(lateRevision);
Assert.That(document.Contents, Is.EqualTo("I ran to the corner store to get mom some milk and crackers"));
}
public void Given_We_Have_Added_A_Subscriber_To_A_Document_Ensure_That_When_The_Document_Merges_Two_Revisions_The_Subscriber_Is_Notified_With_The_Merging_Revision()
{
var document = new Document("I went to the store");
var subscriber = new Subscriber(Guid.NewGuid().ToString());
document.AddSubscriber(subscriber);
var revision1 = new BasicRevision(document.CurrentRevision, Patches.Make(document.Contents, "I went to the store to get some milk"));
var revision2 = new BasicRevision(document.CurrentRevision, Patches.Make(document.Contents, "I went to the corner store"));
IList<Patch> notifiedPatch = null;
subscriber.SubscriberNotifiedOfUpdate +=
(o, e) => notifiedPatch = e.patches;
document.Edit(revision1);
document.Edit(revision2);
var patch = document.CurrentRevision.BuildPatch();
Assert.That(notifiedPatch.Select(p=> p.ToString()), Is.EquivalentTo(patch.Select(p=> p.ToString())));
}
public void Given_We_Have_Added_A_Subscriber_To_A_Document_Ensure_That_When_A_Document_Is_Edited_The_Subscriber_Is_Notified()
{
var document = new Document("Test");
var subscriber = new Subscriber(Guid.NewGuid().ToString());
document.AddSubscriber(subscriber);
var revision = new BasicRevision(document.CurrentRevision, Patches.Make(document.Contents, "Test 2"));
var eventFired = false;
subscriber.SubscriberNotifiedOfUpdate += (o, e) => eventFired = true;
document.Edit(revision);
Assert.That(eventFired);
}
public void Ensure_We_Can_Add_A_Revision_To_A_Document_And_Then_Retrive_The_New_Document_Contents()
{
var document = new Document();
var patch = Patches.Make("", "This is a test");
var revision = new BasicRevision(document.CurrentRevision, patch);
document.Edit(revision);
Assert.That(document.CurrentRevision.GenerateEditedContent(), Is.EqualTo("This is a test"));
}
