def runTest(self):
#Create an object and set some values
test1 = TestPropertyOwner1(None)
self.dc.AddDocumentObject(test1)
test1id = test1.id
testitem1 = TestPropertyOwner2(None)
testitem1id = testitem1.id
test1.propertyowner2s.add(testitem1)
testitem1.cover = 3
test1.covers = 2
self.dc.AddDocumentObject(test1)
#Simulate sending the object to another user via conversion to JSON and emailing
jsontext = self.dc.asJSON()
#Make some local changes
test1.covers = 4
#Simulate the other user (who received the email with the edges) getting the document and loading it into memory
self.dc = DocumentCollection()
self.dc.Register(TestPropertyOwner1)
self.dc.Register(TestPropertyOwner2)
self.dc.LoadFromJSON(jsontext)
tpo1s = self.dc.GetByClass(TestPropertyOwner1)
self.assertEqual(len(tpo1s), 1)
test2 = tpo1s[0]
self.assertEqual(len(test2.propertyowner2s), 1)
#The second user makes some changes and sends them back to the first
for testitem2 in test2.propertyowner2s:
testitem2.cover = 4
test2.covers = 3
jsontext = self.dc.asJSON()
#Simulate the first user received the second users changes
self.dc = DocumentCollection()
self.dc.Register(TestPropertyOwner1)
self.dc.Register(TestPropertyOwner2)
self.dc.LoadFromJSON(jsontext)
test2s = self.dc.GetByClass(TestPropertyOwner1)
self.assertEqual(len(test2s), 1)
test2 = test2s[0]
self.assertEqual(test2.covers, 3)
for testitem2 in test2.propertyowner2s:
self.assertEqual(testitem2.cover, 4)
self.assertEqual(testitem2.cover, 4)
#The first user merges the changes back with his own
test3 = test2.Merge(test1)
self.assertEqual(len(test3.propertyowner2s), 1)
for testitem3 in test3.propertyowner2s:
self.assertEqual(testitem3.cover, 4)
self.assertEqual(test3.covers, 4)
def runTest(self):
#Create an object and set some values
test1 = CounterTestContainer(None)
test1id = test1.id
self.dc.AddDocumentObject(test1)
test1.testcounter.add(1)
self.assertEqual(test1.testcounter.get(), 1)
olddc = self.dc
sharedcurrentnode = test1.currentnode
#Simulate sending the object to another user via conversion to JSON and emailing
jsontext = self.dc.asJSON()
#Simulate making local conflicting changes
test1.testcounter.subtract(1)
self.assertEqual(test1.testcounter.get(), 0)
#Simulate the other user (who received the email with the edges) getting the document and loading it into memory
self.dc = DocumentCollection()
self.dc.Register(CounterTestContainer)
self.dc.LoadFromJSON(jsontext)
self.assertEqual(jsontext, self.dc.asJSON())
tpo1s = self.dc.GetByClass(CounterTestContainer)
self.assertEqual(len(tpo1s), 1)
test2 = tpo1s[0]
self.assertEqual(sharedcurrentnode, test2.currentnode)
#The second user makes some changes and sends them back to the first
test2.testcounter.add(1)
self.assertEqual(test2.testcounter.get(), 2)
edgenext = test2.history.edgesbyendnode[test2.currentnode]
#Simulate the first user received the second users changes out of order
#the second edge is received first. Test it is right
self.dc = olddc
self.dc.LoadFromJSON(JSONEncoder().encode({
"history": [edgenext.asTuple()],
"immutableobjects": []
}))
test2s = self.dc.GetByClass(CounterTestContainer)
self.assertEqual(len(test2s), 1)
test2 = test2s[0]
#print "test2 edges=",[str(edge) for edge in test2.history.GetAllEdges()]
self.assertEqual(test2.testcounter.get(), 1)
class FreezeThreeWayMergeTestCase(unittest.TestCase):
def setUp(self):
self.dc = DocumentCollection()
self.dc.Register(Covers)
def runTest(self):
#Test merging together by receiving an edge
test = Covers(None)
test.covers = 1
test2 = test.Clone()
test3 = test.Clone()
test.covers = 2
test2.covers = 3
test3.covers = 4
test.Freeze()
edge2 = test2.history.edgesbyendnode[test2.currentnode]
edge3 = test3.history.edgesbyendnode[test3.currentnode]
test.AddEdges([edge2, edge3])
# Normally we would receive the edge and play it. The new edge would win the conflict and update the object but that shouldn't
# happened because we are frozen
self.assertEqual(test.covers, 2)
# Once we unfreeze the updates should play
test.Unfreeze()
#print "test.id=",test.id
self.assertFalse(test.history.HasDanglingEdges())
self.assertEqual(test.covers, 4)
class MergeHistoryCommentTestCase(unittest.TestCase):
def setUp(self):
self.dc = DocumentCollection()
self.dc.Register(TestPropertyOwner1)
self.dc.Register(TestPropertyOwner2)
def runTest(self):
#Test merge together two simple covers objects
test = Comments(None)
test.comment = "AAA"
test2 = test.Clone()
test.comment = "BBB"
test2.comment = "CCC"
test3 = test.Merge(test2)
#In a merge conflict between two string the one that is sooner in alphabetical order is the winner
self.assertEqual(test3.comment, "CCC")
#Test merge together two simple covers objects
test = Comments(None)
test.comment = "AAA"
test2 = test.Clone()
test.comment = "CCC"
test2.comment = "BBB"
test3 = test.Merge(test2)
#In a merge conflict between two string the one that is sooner in alphabetical order is the winner
self.assertEqual(test3.comment, "CCC")
class SimpleCoversTestCase(unittest.TestCase):
def setUp(self):
self.dc = DocumentCollection()
self.dc.Register(TestPropertyOwner1)
self.dc.Register(TestPropertyOwner2)
def runTest(self):
#Test merging together simple covers documents
test = Covers(None)
test.covers = 1
#Test we can set a value
self.assertEqual(test.covers, 1)
test2 = Covers(test.id)
test.history.Replay(test2)
#Test we can rebuild a simple object by playing an edge
self.assertEqual(test2.covers, 1)
#Test these are just the same history object but it was actually copied
assert test.history is not test2.history
test3 = test2.Clone()
#Test the clone is the same as the original. But not just refering to the same object
self.assertEqual(test3.covers, test2.covers)
assert test2 is not test3
assert test2.history is not test3.history
test = Covers(None)
test.covers = 1
test.covers = 2
test2 = Covers(test.id)
test.history.Replay(test2)
self.assertEqual(test.covers, 2)
assert test.history is not test2.history
assert test is not test2
class FreezeUpdateTestCase(unittest.TestCase):
def setUp(self):
self.dc = DocumentCollection()
self.dc.Register(Covers)
def runTest(self):
#Test merging together by receiving an edge
test = Covers(None)
test.covers = 1
test2 = test.Clone()
handler = TestUpdateHandler()
test.AddHandler(handler.WasChanged)
test.covers = 2
test2.covers = 3
test.Freeze()
self.assertEqual(handler.covers, 2)
edge = test2.history.edgesbyendnode[test2.currentnode]
test.AddEdges([edge])
# Normally we would receive the edge and play it. The new edge would win the conflict and update the object but that shouldn't
# happened because we are frozen
self.assertEqual(test.covers, 2)
self.assertEqual(handler.covers, 2)
# Once we unfreeze the updates should play
test.Unfreeze()
self.assertFalse(test.history.HasDanglingEdges())
self.assertEqual(test.covers, 3)
self.assertEqual(handler.covers, 3)
class LargeMergeTestCase(unittest.TestCase):
def setUp(self):
self.dc = DocumentCollection()
self.dc.Register(Covers)
def runTest(self):
#Test merging together performance by receiving large numbers of edges
test = Covers(None)
test.covers = 1
test2 = test.Clone()
for i in range(2, 52):
test.covers = i
for i in range(52, 102):
test2.covers = i
# Perform this merge. This simulate databases that have been disconnected for a long time
def wrapper(func, *args, **kwargs):
def wrapped():
return func(*args, **kwargs)
return wrapped
def test_add_edges(test, test2):
test.AddEdges(
[v for (k, v) in test2.history.edgesbyendnode.iteritems()])
wrapped = wrapper(test_add_edges, test, test2)
time_taken = timeit.timeit(wrapped, number=1)
self.assertEqual(test.covers, 101)
def runTest(self):
#Test writing the immutable object to an sql lite database
t = int(round(time.time() * 1000))
m = MessageTest(messagetime=t, text="Hello")
self.dc.AddImmutableObject(m)
test1id = m.GetHash()
test1s = self.dc.GetByClass(MessageTest)
self.assertEqual(len(test1s), 1)
jsontext = self.dc.asJSON()
self.dc = DocumentCollection()
self.dc.Register(MessageTest)
self.dc.LoadFromJSON(jsontext)
test1s = self.dc.GetByClass(MessageTest)
self.assertEqual(len(test1s), 1)
test1 = test1s[0]
self.assertEqual(test1id, test1.GetHash())
def test_singleton_is_automatically_created(self):
class TestSingleton(Document):
is_singleton = True
nothing = fields.CharRegister()
dc1 = DocumentCollection(str(uuid.uuid4()))
dc1.register(TestSingleton)
docs = dc1.get_by_class(TestSingleton)
# Test the document is created
self.assertEqual(len(docs), 1)
# Test it is in it's default state
self.assertEqual(len(docs[0].history._edgesbyendnode), 0)
# New single objects always have the same id
self.assertEqual(docs[0].id, TestSingleton().id)
with self.assertRaises(AssertionError):
# Test we cannot create a singleton with a different id
TestSingleton(uuid.uuid4())
# Test we can create a signleton with the same ID
TestSingleton(docs[0].id)
def runTest(self):
dc = DocumentCollection()
dc.Register(TestListofLists1)
dc.Register(TestListofLists2)
dc.Register(TestListofLists3)
test1 = TestListofLists1(None)
dc.AddDocumentObject(test1)
l0 = TestListofLists2(None)
l1 = TestListofLists2(None)
test1.propertyowner2s.insert(0, l0)
test1.propertyowner2s.insert(1, l1)
ll0 = TestListofLists3(None)
l0.propertyowner2s.insert(0, ll0)
assert test1.propertyowner2s[0].id == l0.id
assert test1.propertyowner2s[1].id == l1.id
assert test1.propertyowner2s[0].propertyowner2s[0].id == ll0.id
assert test1.propertyowner2s[0].propertyowner2s[0].GetDocument(
).id == test1.id
assert test1.propertyowner2s[0].GetDocument().id == test1.id
ll0.comment = 'Hello'
dc2 = DocumentCollection()
dc2.Register(TestListofLists1)
dc2.Register(TestListofLists2)
dc2.Register(TestListofLists3)
test2 = TestListofLists1(test1.id)
dc2.AddDocumentObject(test2)
test1.history.Replay(test2)
assert test2.propertyowner2s[0].id == l0.id
assert test2.propertyowner2s[1].id == l1.id
assert test2.propertyowner2s[0].propertyowner2s[0].id == ll0.id
assert test2.propertyowner2s[0].propertyowner2s[0].comment == 'Hello'
assert test2.propertyowner2s[0].GetDocument().id == test1.id
assert test2.propertyowner2s[0].propertyowner2s[0].GetDocument(
).id == test1.id
def runTest(self):
test1 = TestPropertyOwner1(None)
testitem = TestPropertyOwner2(None)
test1.propertyowner2s.add(testitem)
testitem.cover = 1
#Test semantics for retriving objects
self.assertEqual(len(test1.propertyowner2s), 1)
for po2 in test1.propertyowner2s:
self.assertEqual(po2.__class__.__name__,
TestPropertyOwner2.__name__)
self.assertEqual(po2.cover, 1)
test1 = TestPropertyOwner1(None)
testitem = TestPropertyOwner2(None)
test1.propertyowner2s.add(testitem)
testitem.cover = 1
test1.propertyowner2s.remove(testitem.id)
dc2 = DocumentCollection()
dc2.Register(TestPropertyOwner1)
dc2.Register(TestPropertyOwner2)
test2 = TestPropertyOwner1(test1.id)
dc2.AddDocumentObject(test2)
test1.history.Replay(test2)
#Check that replaying correctly removes the object
self.assertEqual(len(test2.propertyowner2s), 0)
test1 = TestPropertyOwner1(None)
testitem = TestPropertyOwner2(None)
test1.propertyowner2s.add(testitem)
testitem.cover = 1
test2 = test1.Clone()
self.assertEqual(len(test2.propertyowner2s), 1)
for po2 in test2.propertyowner2s:
self.assertEqual(po2.__class__.__name__,
TestPropertyOwner2.__name__)
self.assertEqual(po2.cover, 1)
class ImmutableClassTestCase(unittest.TestCase):
def setUp(self):
self.dc = DocumentCollection()
self.dc.Register(Covers)
def runTest(self):
t = int(round(time.time() * 1000))
m = MessageTest(messagetime=t, text="Hello")
self.assertEqual(m.messagetime, t)
self.assertEqual(m.text, "Hello")
was_exception = False
with self.assertRaises(AssertionError):
m.messagetime = int(round(time.time() * 1000))
def runTest(self):
dc = DocumentCollection()
dc.Register(TestFieldListOwner1)
dc.Register(TestFieldListOwner2)
test1 = TestFieldListOwner1(None)
l0 = TestFieldListOwner2(None)
l1 = TestFieldListOwner2(None)
test1.propertyowner2s.insert(0, l0)
test1.propertyowner2s.insert(1, l1)
test2 = test1.Clone()
dc.AddDocumentObject(test2)
l2 = TestFieldListOwner2(None)
test2.propertyowner2s.insert(2, l2)
test1.propertyowner2s.remove(1)
test3 = test2.Merge(test1)
self.assertEqual(len(test3.propertyowner2s), 2)
self.assertEqual(test3.propertyowner2s[0].id, l0.id)
self.assertEqual(test3.propertyowner2s[1].id, l2.id)
def runTest(self):
dc = DocumentCollection()
dc.Register(TestColofCol1)
dc.Register(TestColofCol2)
dc.Register(TestColofCols3)
test1 = TestColofCol1(None)
dc.AddDocumentObject(test1)
l0 = TestColofCol2(None)
l1 = TestColofCol2(None)
test1.propertyowner2s.add(l0)
test1.propertyowner2s.add(l1)
ll0 = TestColofCols3(None)
l0.propertyowner2s.add(ll0)
assert {l.id for l in test1.propertyowner2s} == {l0.id, l1.id}
for l in test1.propertyowner2s:
assert l.GetDocument().id == test1.id
for l2 in l.propertyowner2s:
assert l2.GetDocument().id == test1.id
ll0.comment = 'Hello'
dc2 = DocumentCollection()
dc2.Register(TestColofCol1)
dc2.Register(TestColofCol2)
dc2.Register(TestColofCols3)
test2 = TestColofCol1(test1.id)
dc2.AddDocumentObject(test2)
test1.history.Replay(test2)
assert {l.id for l in test1.propertyowner2s} == {l0.id, l1.id}
for l in test1.propertyowner2s:
assert l.GetDocument().id == test1.id
for l2 in l.propertyowner2s:
assert l2.GetDocument().id == test1.id
assert l2.comment == 'Hello'
def runTest(self):
#Test writing the history to a sql lite database
test1 = TestPropertyOwner1(None)
self.dc.AddDocumentObject(test1)
test1id = test1.id
testitem1 = TestPropertyOwner2(None)
testitem1id = testitem1.id
test1.propertyowner2s.add(testitem1)
test2 = test1.Clone()
testitem1.cover = 3
test2.covers = 2
self.assertEqual(len(test1.propertyowner2s), 1)
test3 = test2.Merge(test1)
self.assertEqual(len(test3.propertyowner2s), 1)
for item1 in test3.propertyowner2s:
self.assertEqual(item1.cover, 3)
self.assertEqual(test3.covers, 2)
self.dc.AddDocumentObject(test3)
test1s = self.dc.GetByClass(TestPropertyOwner1)
self.assertEqual(len(test1s), 1)
jsontext = self.dc.asJSON()
self.dc = DocumentCollection()
self.dc.Register(TestPropertyOwner1)
self.dc.Register(TestPropertyOwner2)
self.dc.LoadFromJSON(jsontext)
test1s = self.dc.GetByClass(TestPropertyOwner1)
self.assertEqual(len(test1s), 1)
test1 = test1s[0]
test1id = test1.id
self.assertEqual(len(test1.propertyowner2s), 1)
for testitem1 in test3.propertyowner2s:
self.assertEqual(testitem1id, testitem1.id)
self.assertEqual(testitem1.cover, 3)
self.assertEqual(test1.covers, 2)
class SimpleCoversUpdateTestCase(unittest.TestCase):
def setUp(self):
self.dc = DocumentCollection()
self.dc.Register(TestPropertyOwner1)
self.dc.Register(TestPropertyOwner2)
def runTest(self):
#Test merging together simple covers documents
test = Covers(None)
test.covers = 1
handler = TestUpdateHandler()
test.AddHandler(handler.WasChanged)
self.assertEqual(len(test.change_handlers), 1)
test.covers = 2
self.assertEqual(handler.covers, 2)
test.RemoveHandler(handler.WasChanged)
self.assertEqual(len(test.change_handlers), 0)
test.covers = 3
self.assertEqual(handler.covers, 2)
class MergeHistorySendEdgeCoverTestCase(unittest.TestCase):
def setUp(self):
self.dc = DocumentCollection()
self.dc.Register(Covers)
def runTest(self):
#Test merging together by receiving an edge
test = Covers(None)
test.covers = 1
test2 = test.Clone()
test.covers = 2
test2.covers = 3
edge = test2.history.edgesbyendnode[test2.currentnode]
history = test.history.Clone()
history.AddEdges([edge])
test3 = Covers(test.id)
history.Replay(test3)
#In a merge conflict between two integers the greater one is the winner
self.assertEqual(test3.covers, 3)
#Test the behaviour of receiving edges out of order
test = Covers(None)
test.covers = 1
test2 = test.Clone()
test.covers = 2
test5 = test2.Clone()
test6 = test2.Clone()
test2.covers = 3
test2.covers = 4
edge4 = test2.history.edgesbyendnode[test2.currentnode]
edge3 = test2.history.edgesbyendnode[list(edge4.startnodes)[0]]
history = test.history.Clone()
history.AddEdges([edge4])
test3 = Covers(test.id)
history.Replay(test3)
#edge4 should be orphaned and not played
self.assertEqual(test3.covers, 2)
#Once edge3 is added we should replay automatically to 4
history.AddEdges([edge3])
test4 = Covers(test.id)
history.Replay(test4)
#edge4 should be orphaned and not played
self.assertEqual(test4.covers, 4)
#Test live adding of edges
test5.AddEdges([edge3])
self.assertEqual(test5.covers, 3)
#Test live adding of orphaned edges
test6.AddEdges([edge4])
self.assertEqual(test6.covers, 1)
test6.AddEdges([edge3])
self.assertEqual(test6.covers, 4)
#Test adding a Null edge where we don't have one of the start nodes.
#In the old way
dummysha = hashlib.sha256('Invalid node').hexdigest()
history = test.history.Clone()
edgenull = HistoryEdgeMerge({test6.currentnode, dummysha}, "", "", "",
"", test6.id, test6.__class__.__name__)
history.AddEdges([edgenull])
test6 = Covers(test.id)
history.Replay(test6)
self.assertEqual(test6.covers, 2)
#In the new way
test6 = test.Clone()
oldnode = test6.currentnode
edgenull = HistoryEdgeMerge({test6.currentnode, dummysha}, "", "", "",
"", test6.id, test6.__class__.__name__)
test6.AddEdges([edgenull])
self.assertEqual(test6.covers, 2)
self.assertEqual(test6.currentnode, oldnode)
def setUp(self):
self.dc = DocumentCollection()
self.dc.Register(CounterTestContainer)
def setUp(self):
self.dc = DocumentCollection()
def setUp(self):
self.dc = DocumentCollection()
self.dc.Register(Covers)
def setUp(self):
self.dc = DocumentCollection()
self.dc.Register(TestPropertyOwner1)
self.dc.Register(TestPropertyOwner2)
class AdvancedItemTestCase(unittest.TestCase):
def setUp(self):
self.dc = DocumentCollection()
self.dc.Register(TestPropertyOwner1)
self.dc.Register(TestPropertyOwner2)
def runTest(self):
#Test changing them deleting a sub element
test1 = TestPropertyOwner1(None)
self.dc.AddDocumentObject(test1)
testitem1 = TestPropertyOwner2(None)
test1.propertyowner2s.add(testitem1)
testitem1.cover = 1
test2 = test1.Clone()
testitem2 = test2.GetDocumentObject(testitem1.id)
testitem2.cover = 2
test2.propertyowner2s.remove(testitem2.id)
test3 = test1.Merge(test2)
self.assertEqual(len(test3.propertyowner2s), 0)
#Test changing them deleting a sub element. Test merging in the opposition order to previous test
test1 = TestPropertyOwner1(None)
self.dc.AddDocumentObject(test1)
testitem1 = TestPropertyOwner2(None)
test1.propertyowner2s.add(testitem1)
testitem1.cover = 1
test2 = test1.Clone()
testitem2 = test2.GetDocumentObject(testitem1.id)
testitem2.cover = 2
test2.propertyowner2s.remove(testitem2.id)
test3 = test2.Merge(test1)
self.assertEqual(len(test3.propertyowner2s), 0)
#Test merging changes to different objects in the same document works
test1 = TestPropertyOwner1(None)
self.dc.AddDocumentObject(test1)
testitem1 = TestPropertyOwner2(None)
test1.propertyowner2s.add(testitem1)
test2 = test1.Clone()
testitem1.cover = 3
test2.covers = 2
test3 = test2.Merge(test1)
self.assertEqual(len(test3.propertyowner2s), 1)
for item1 in test3.propertyowner2s:
self.assertEqual(item1.cover, 3)
self.assertEqual(test3.covers, 2)
#Test changing different objects on different branches works
test1 = TestPropertyOwner1(None)
self.dc.AddDocumentObject(test1)
testitem1 = TestPropertyOwner2(None)
id1 = testitem1.id
test1.propertyowner2s.add(testitem1)
testitem2 = TestPropertyOwner2(None)
test1.propertyowner2s.add(testitem2)
id2 = testitem2.id
test2 = test1.Clone()
testitem2 = test2.GetDocumentObject(id2)
testitem1.cover = 2
testitem1.quantity = 3
testitem2.cover = 3
testitem2.quantity = 2
test3 = test2.Merge(test1)
testitem1 = test3.GetDocumentObject(id1)
testitem2 = test3.GetDocumentObject(id2)
self.assertEqual(testitem2.cover, 3)
self.assertEqual(testitem2.quantity, 2)
self.assertEqual(testitem1.cover, 2)
self.assertEqual(testitem1.quantity, 3)
#Test changing different objects on different branches works reverse merge of above
test1 = TestPropertyOwner1(None)
self.dc.AddDocumentObject(test1)
testitem1 = TestPropertyOwner2(None)
id1 = testitem1.id
test1.propertyowner2s.add(testitem1)
testitem2 = TestPropertyOwner2(None)
test1.propertyowner2s.add(testitem2)
id2 = testitem2.id
test2 = test1.Clone()
testitem2 = test2.GetDocumentObject(id2)
testitem1.cover = 2
testitem1.quantity = 3
testitem2.cover = 3
testitem2.quantity = 2
test3 = test1.Merge(test2)
testitem1 = test3.GetDocumentObject(id1)
testitem2 = test3.GetDocumentObject(id2)
self.assertEqual(testitem2.cover, 3)
self.assertEqual(testitem2.quantity, 2)
self.assertEqual(testitem1.cover, 2)
self.assertEqual(testitem1.quantity, 3)
def setUp(self):
self.dc = DocumentCollection()
self.dc.Register(MessageTest)
def runTest(self):
#Create an object and set some values
test1 = TestPropertyOwner1(None)
test1id = test1.id
testitem1 = TestPropertyOwner2(None)
testitem1id = testitem1.id
test1.propertyowner2s.add(testitem1)
testitem1.cover = 3
test1.covers = 2
self.dc.AddDocumentObject(test1)
olddc = self.dc
#Simulate sending the object to another user via conversion to JSON and emailing
jsontext = self.dc.asJSON()
#Simulate the other user (who received the email with the edges) getting the document and loading it into memory
self.dc = DocumentCollection()
self.dc.Register(TestPropertyOwner1)
self.dc.Register(TestPropertyOwner2)
self.dc.LoadFromJSON(jsontext)
tpo1s = self.dc.GetByClass(TestPropertyOwner1)
self.assertEqual(len(tpo1s), 1)
test2 = tpo1s[0]
self.assertEqual(len(test2.propertyowner2s), 1)
#The second user makes some changes and sends them back to the first
for testitem2 in test2.propertyowner2s:
testitem2.cover = 4
edge4 = test2.history.edgesbyendnode[test2.currentnode]
test2.covers = 3
edge3 = test2.history.edgesbyendnode[test2.currentnode]
#Simulate the first user received the second users changes out of order
#the second edge is received first. Test it is right
self.dc = olddc
self.dc.LoadFromJSON(JSONEncoder().encode({
"history": [edge3.asTuple()],
"immutableobjects": []
}))
test2s = self.dc.GetByClass(TestPropertyOwner1)
self.assertEqual(len(test2s), 1)
test2 = test2s[0]
self.assertEqual(test2.covers, 2)
for testitem2 in test2.propertyowner2s:
self.assertEqual(testitem2.cover, 3)
self.assertEqual(testitem2.cover, 3)
#Simulate the first user received the second users changes out of order
#the first edge is not received make sure everything
self.dc.LoadFromJSON(JSONEncoder().encode({
"history": [edge4.asTuple()],
"immutableobjects": []
}))
test2s = self.dc.GetByClass(TestPropertyOwner1)
self.assertEqual(len(test2s), 1)
test2 = test2s[0]
self.assertEqual(test2.covers, 3)
for testitem2 in test2.propertyowner2s:
self.assertEqual(testitem2.cover, 4)
self.assertEqual(testitem2.cover, 4)
oldnode = test2.currentnode
dummysha1 = hashlib.sha256('Invalid node 1').hexdigest()
dummysha2 = hashlib.sha256('Invalid node 2').hexdigest()
edgenull1 = HistoryEdgeMerge({dummysha1, dummysha2}, "", "", "", "",
test2.id, test2.__class__.__name__)
edgenull2 = HistoryEdgeMerge(
{test2.currentnode, edgenull1.GetEndNode()}, "", "", "", "",
test2.id, test2.__class__.__name__)
self.dc.LoadFromJSON(JSONEncoder().encode({
"history": [edgenull2.asTuple()],
"immutableobjects": []
}))
test2s = self.dc.GetByClass(TestPropertyOwner1)
self.assertEqual(len(test2s), 1)
test2 = test2s[0]
self.assertEqual(oldnode, test2.currentnode)
self.assertEqual(test2.covers, 3)
for testitem2 in test2.propertyowner2s:
self.assertEqual(testitem2.cover, 4)
self.assertEqual(testitem2.cover, 4)
self.dc.LoadFromJSON(JSONEncoder().encode({
"history": [edgenull1.asTuple()],
"immutableobjects": []
}))
test2s = self.dc.GetByClass(TestPropertyOwner1)
self.assertEqual(len(test2s), 1)
test2 = test2s[0]
self.assertEqual(oldnode, test2.currentnode)
self.assertEqual(test2.covers, 3)
for testitem2 in test2.propertyowner2s:
self.assertEqual(testitem2.cover, 4)
self.assertEqual(testitem2.cover, 4)
