def test_commit(self):
"""
Test the commit of multiple versions over time.
"""
A = Version.new('A')
a = A(self.replica)
B = Version.new('B')
b = B(self.replica)
for idx, replica in enumerate(self.sim.replicas):
if replica == self.replica: continue
self.sim.env.now += (2 * (idx + 1))
a.update(replica)
b.update(replica)
a.update(self.replica, commit=True)
self.assertTrue(a.committed)
self.assertTrue(a.is_committed())
self.assertFalse(b.committed)
self.assertFalse(b.is_committed())
self.sim.results.update.assert_called_with(
'commit latency', (self.replica.id, str(a), a.created, a.updated))
b.update(self.replica, commit=True)
self.assertTrue(a.committed)
self.assertTrue(a.is_committed())
self.assertTrue(b.committed)
self.assertTrue(b.is_committed())
self.sim.results.update.assert_called_with(
'commit latency', (self.replica.id, str(b), b.created, b.updated))
def test_visibility_metric(self):
"""
Test that the visibility metric is tracked
"""
v1 = Version(self.replica)
calls = []
replicas = [r for r in self.sim.replicas if r != self.replica]
for idx, replica in enumerate(replicas):
self.sim.env.now += (2 * (idx + 1))
v1.update(replica)
self.assertGreater(v1.updated, v1.created)
self.assertEqual(v1.updated, self.sim.env.now)
pcent = float(idx + 2) / float(len(self.sim.replicas))
calls.append(
mock.call('visibility', (self.replica.id, str(v1), pcent,
v1.created, self.sim.env.now)))
# Check that this is the last call
self.sim.results.update.assert_has_calls(calls + [
mock.call('visibility latency',
(self.replica.id, str(v1), v1.created, v1.updated))
],
any_order=True)
self.assertTrue(v1.is_visible())
def test_visibility_metric(self):
"""
Test that the visibility metric is tracked
"""
v1 = Version(self.replica)
calls = []
replicas = [
r for r in self.sim.replicas if r!= self.replica
]
for idx, replica in enumerate(replicas):
self.sim.env.now += (2*(idx+1))
v1.update(replica)
self.assertGreater(v1.updated, v1.created)
self.assertEqual(v1.updated, self.sim.env.now)
pcent = float(idx+2) / float(len(self.sim.replicas))
calls.append(
mock.call('visibility', (self.replica.id, str(v1), pcent, v1.created, self.sim.env.now))
)
# Check that this is the last call
self.sim.results.update.assert_has_calls(calls + [
mock.call('visibility latency', (self.replica.id, str(v1), v1.created, v1.updated))
], any_order=True)
self.assertTrue(v1.is_visible())
def test_commit(self):
"""
Test the commit of multiple versions over time.
"""
A = Version.new('A')
a = A(self.replica)
B = Version.new('B')
b = B(self.replica)
for idx, replica in enumerate(self.sim.replicas):
if replica == self.replica: continue
self.sim.env.now += (2*(idx+1))
a.update(replica)
b.update(replica)
a.update(self.replica, commit=True)
self.assertTrue(a.committed)
self.assertTrue(a.is_committed())
self.assertFalse(b.committed)
self.assertFalse(b.is_committed())
self.sim.results.update.assert_called_with(
'commit latency', (self.replica.id, str(a), a.created, a.updated)
)
b.update(self.replica, commit=True)
self.assertTrue(a.committed)
self.assertTrue(a.is_committed())
self.assertTrue(b.committed)
self.assertTrue(b.is_committed())
self.sim.results.update.assert_called_with(
'commit latency', (self.replica.id, str(b), b.created, b.updated)
)
def test_is_stale(self):
"""
Test the staleness of a version.
"""
v1 = Version(self.replica)
self.assertFalse(v1.is_stale())
self.sim.env.now = 42
v2 = v1.nextv(random.choice([r for r in self.sim.replicas if r != self.replica]))
self.assertTrue(v1.is_stale())
self.assertFalse(v2.is_stale())
def test_is_stale(self):
"""
Test the staleness of a version.
"""
v1 = Version(self.replica)
self.assertFalse(v1.is_stale())
self.sim.env.now = 42
v2 = v1.nextv(
random.choice([r for r in self.sim.replicas if r != self.replica]))
self.assertTrue(v1.is_stale())
self.assertFalse(v2.is_stale())
def test_version_string(self):
"""
Test that the version string is compressed.
"""
version = Version(self.replica)
self.assertEqual(str(version), "root->1")
for idx in xrange(100):
version = version.nextv(self.replica)
self.assertEqual(str(version), "100->101")
def test_version_string(self):
"""
Test that the version string is compressed.
"""
version = Version(self.replica)
self.assertEqual(str(version), "root->1")
for idx in xrange(100):
version = version.nextv(self.replica)
self.assertEqual(str(version), "100->101")
def test_version_comparison(self):
"""
Test version comparison based on fork
"""
v1 = Version(self.replica)
v2 = v1.nextv(self.replica)
self.assertLess(v1, v2)
self.assertLessEqual(v1, v2)
self.assertLessEqual(v2, v2)
self.assertEqual(v1, v1)
self.assertNotEqual(v1, v2)
self.assertGreater(v2, v1)
self.assertGreaterEqual(v2, v1)
self.assertGreaterEqual(v2, v2)
def test_version_comparison(self):
"""
Test version comparison based on fork
"""
v1 = Version(self.replica)
v2 = v1.nextv(self.replica)
self.assertLess(v1, v2)
self.assertLessEqual(v1, v2)
self.assertLessEqual(v2, v2)
self.assertEqual(v1, v1)
self.assertNotEqual(v1, v2)
self.assertGreater(v2, v1)
self.assertGreaterEqual(v2, v1)
self.assertGreaterEqual(v2, v2)
def test_version_string(self):
"""
Test that multiple versions string is accurate.
"""
A = Version.new('A')
a = A(self.replica)
B = Version.new('B')
b = B(self.replica)
self.assertEqual(str(a), "root->A.1")
self.assertEqual(str(b), "root->B.1")
for idx in xrange(100):
a = a.nextv(self.replica)
b = b.nextv(self.replica)
self.assertEqual(str(a), "A.100->A.101")
self.assertEqual(str(b), "B.100->B.101")
def test_nextv(self):
"""
Test getting the next version of an object.
"""
v1 = Version(self.replica)
self.sim.env.now = 42
v2 = v1.nextv(random.choice([r for r in self.sim.replicas if r != self.replica]))
self.assertIsInstance(v2, Version)
self.assertEqual(v2.parent, v1)
self.assertEqual(v1.level, v2.level)
self.assertFalse(v2.committed)
self.assertGreater(v2.version, v1.version)
self.assertGreater(v2.created, v1.created)
self.assertGreater(v2.updated, v1.created)
self.assertNotEqual(v2.writer, v1.writer)
self.assertEqual(v1.counter, v2.counter)
def test_version_string(self):
"""
Test that multiple versions string is accurate.
"""
A = Version.new('A')
a = A(self.replica)
B = Version.new('B')
b = B(self.replica)
self.assertEqual(str(a), "root->A.1")
self.assertEqual(str(b), "root->B.1")
for idx in xrange(100):
a = a.nextv(self.replica)
b = b.nextv(self.replica)
self.assertEqual(str(a), "A.100->A.101")
self.assertEqual(str(b), "B.100->B.101")
def test_version_comparison(self):
"""
Test multiple versions comparison based on fork
"""
A = Version.new('A')
a1 = A(self.replica)
a2 = a1.nextv(self.replica)
B = Version.new('B')
b1 = B(self.replica)
b2 = b1.nextv(self.replica)
self.assertLess(a1, a2)
self.assertLess(b1, b2)
self.assertLess(b1, a2)
self.assertLess(a1, b2)
self.assertLessEqual(a1, a2)
self.assertLessEqual(b1, b2)
self.assertLessEqual(b1, a2)
self.assertLessEqual(a1, b2)
self.assertLessEqual(a1, b1)
self.assertLessEqual(a2, b2)
self.assertEqual(a1, b1)
self.assertEqual(a2, b2)
self.assertIsNot(a1, b1)
self.assertIsNot(a2, b2)
self.assertNotEqual(a1, b2)
self.assertNotEqual(b1, a2)
self.assertNotEqual(a1, a2)
self.assertNotEqual(b1, b2)
self.assertGreater(a2, a1)
self.assertGreater(b2, b1)
self.assertGreater(a2, b1)
self.assertGreater(b2, a1)
self.assertGreaterEqual(a2, a1)
self.assertGreaterEqual(b2, b1)
self.assertGreaterEqual(a2, b1)
self.assertGreaterEqual(b2, a1)
self.assertGreaterEqual(b2, a2)
self.assertGreaterEqual(b1, a1)
def test_version_comparison(self):
"""
Test multiple versions comparison based on fork
"""
A = Version.new('A')
a1 = A(self.replica)
a2 = a1.nextv(self.replica)
B = Version.new('B')
b1 = B(self.replica)
b2 = b1.nextv(self.replica)
self.assertLess(a1, a2)
self.assertLess(b1, b2)
self.assertLess(b1, a2)
self.assertLess(a1, b2)
self.assertLessEqual(a1, a2)
self.assertLessEqual(b1, b2)
self.assertLessEqual(b1, a2)
self.assertLessEqual(a1, b2)
self.assertLessEqual(a1, b1)
self.assertLessEqual(a2, b2)
self.assertEqual(a1, b1)
self.assertEqual(a2, b2)
self.assertIsNot(a1, b1)
self.assertIsNot(a2, b2)
self.assertNotEqual(a1, b2)
self.assertNotEqual(b1, a2)
self.assertNotEqual(a1, a2)
self.assertNotEqual(b1, b2)
self.assertGreater(a2, a1)
self.assertGreater(b2, b1)
self.assertGreater(a2, b1)
self.assertGreater(b2, a1)
self.assertGreaterEqual(a2, a1)
self.assertGreaterEqual(b2, b1)
self.assertGreaterEqual(a2, b1)
self.assertGreaterEqual(b2, a1)
self.assertGreaterEqual(b2, a2)
self.assertGreaterEqual(b1, a1)
def test_nextv(self):
"""
Test getting the next version of an object.
"""
v1 = Version(self.replica)
self.sim.env.now = 42
v2 = v1.nextv(
random.choice([r for r in self.sim.replicas if r != self.replica]))
self.assertIsInstance(v2, Version)
self.assertEqual(v2.parent, v1)
self.assertEqual(v1.level, v2.level)
self.assertFalse(v2.committed)
self.assertGreater(v2.version, v1.version)
self.assertGreater(v2.created, v1.created)
self.assertGreater(v2.updated, v1.created)
self.assertNotEqual(v2.writer, v1.writer)
self.assertEqual(v1.counter, v2.counter)
def test_update(self):
"""
Test the update of a version over time.
"""
v1 = Version(self.replica)
for idx, replica in enumerate(self.sim.replicas):
if replica == self.replica: continue
self.sim.env.now += (2 * (idx + 1))
v1.update(replica)
self.assertGreater(v1.updated, v1.created)
self.assertEqual(v1.updated, self.sim.env.now)
# Check that this is the last call
self.sim.results.update.assert_called_with(
'visibility latency',
(self.replica.id, str(v1), v1.created, v1.updated))
self.assertTrue(v1.is_visible())
def test_update(self):
"""
Test the update of a version over time.
"""
v1 = Version(self.replica)
for idx, replica in enumerate(self.sim.replicas):
if replica == self.replica: continue
self.sim.env.now += (2*(idx+1))
v1.update(replica)
self.assertGreater(v1.updated, v1.created)
self.assertEqual(v1.updated, self.sim.env.now)
# Check that this is the last call
self.sim.results.update.assert_called_with(
'visibility latency', (self.replica.id, str(v1), v1.created, v1.updated)
)
self.assertTrue(v1.is_visible())
def test_replica_continuation(self):
"""
Test the writing of multiple versions on different replicas
"""
other = random.choice(
[r for r in self.sim.replicas if r != self.replica])
A = Version.new('A')
a1 = A(self.replica)
self.sim.env.now += 10
a2 = a1.nextv(other)
self.sim.env.now += 10
B = Version.new('B')
b1 = B(other)
self.sim.env.now += 10
b2 = b1.nextv(self.replica)
self.assertIsInstance(a2, A)
self.assertIsInstance(b2, B)
self.assertEqual(b2.parent, b1)
self.assertEqual(a2.parent, a1)
# This is kind of strange, but we're saying that the b2 and a2
# parents are equivalent versions (e.g. root->1), then we test that
# they're different objects with the ID method.
self.assertEqual(b2.parent, a1)
self.assertEqual(a2.parent, b1)
self.assertIsNot(b2.parent, a1)
self.assertIsNot(a2.parent, b1)
self.assertGreater(a2.version, a1.version)
self.assertGreater(b2.version, b1.version)
self.assertEqual(a1.version, b1.version)
self.assertEqual(a2.version, b2.version)
self.assertGreater(a2.created, a1.created)
self.assertGreater(b1.created, a2.created)
self.assertGreater(b2.created, b1.created)
def test_update(self):
"""
Test the update of multiple versions over time.
"""
A = Version.new('A')
a = A(self.replica)
B = Version.new('B')
b = B(self.replica)
calls = []
replicas = [r for r in self.sim.replicas if r != self.replica]
for idx, replica in enumerate(replicas):
self.sim.env.now += (2 * (idx + 1))
a.update(replica)
b.update(replica)
pcent = float(idx + 2) / float(len(self.sim.replicas))
calls.append(
mock.call('visibility', (self.replica.id, str(a), pcent,
a.created, self.sim.env.now)))
calls.append(
mock.call('visibility', (self.replica.id, str(b), pcent,
a.created, self.sim.env.now)))
self.assertGreater(a.updated, a.created)
self.assertEqual(a.updated, self.sim.env.now)
self.assertGreater(b.updated, b.created)
self.assertEqual(b.updated, self.sim.env.now)
self.sim.results.update.assert_has_calls(calls + [
mock.call('visibility latency',
(self.replica.id, str(a), a.created, a.updated)),
mock.call('visibility latency',
(self.replica.id, str(b), b.created, b.updated)),
],
any_order=True)
self.assertTrue(a.is_visible())
self.assertTrue(b.is_visible())
def test_forked_version_string(self):
"""
Test the compressability of a forked version string.
"""
version = Version(self.replica)
for idx in xrange(5):
version = version.nextv(self.replica)
# Now we split
version_a = version.nextv(self.replica)
version_b = version.nextv(self.replica)
for idx in xrange(3):
version_a = version_a.nextv(self.replica)
for idx in xrange(9):
version_b = version_b.nextv(self.replica)
self.assertEqual(str(version_a), '')
self.assertEqual(str(version_b), '')
def test_new(self):
"""
Test the version class creation mechanism
"""
A = Version.new('A')
B = Version.new('B')
a = A(self.replica)
b = B(self.replica)
self.assertIsInstance(a, Version)
self.assertIsInstance(b, Version)
self.assertNotEqual(type(a), type(b))
self.assertNotEqual(a.counter, b.counter)
C = A.new('C')
c = C(self.replica)
self.assertIsInstance(c, Version)
self.assertNotEqual(type(a), type(c))
self.assertNotEqual(a.counter, c.counter)
def test_forked_version_string(self):
"""
Test the compressability of a forked version string.
"""
version = Version(self.replica)
for idx in xrange(5):
version = version.nextv(self.replica)
# Now we split
version_a = version.nextv(self.replica)
version_b = version.nextv(self.replica)
for idx in xrange(3):
version_a = version_a.nextv(self.replica)
for idx in xrange(9):
version_b = version_b.nextv(self.replica)
self.assertEqual(str(version_a), '')
self.assertEqual(str(version_b), '')
def test_new(self):
"""
Test the version class creation mechanism
"""
A = Version.new('A')
B = Version.new('B')
a = A(self.replica)
b = B(self.replica)
self.assertIsInstance(a, Version)
self.assertIsInstance(b, Version)
self.assertNotEqual(type(a), type(b))
self.assertNotEqual(a.counter, b.counter)
C = A.new('C')
c = C(self.replica)
self.assertIsInstance(c, Version)
self.assertNotEqual(type(a), type(c))
self.assertNotEqual(a.counter, c.counter)
def test_replica_continuation(self):
"""
Test the writing of multiple versions on different replicas
"""
other = random.choice([r for r in self.sim.replicas if r != self.replica])
A = Version.new('A')
a1 = A(self.replica)
self.sim.env.now += 10
a2 = a1.nextv(other)
self.sim.env.now += 10
B = Version.new('B')
b1 = B(other)
self.sim.env.now += 10
b2 = b1.nextv(self.replica)
self.assertIsInstance(a2, A)
self.assertIsInstance(b2, B)
self.assertEqual(b2.parent, b1)
self.assertEqual(a2.parent, a1)
# This is kind of strange, but we're saying that the b2 and a2
# parents are equivalent versions (e.g. root->1), then we test that
# they're different objects with the ID method.
self.assertEqual(b2.parent, a1)
self.assertEqual(a2.parent, b1)
self.assertIsNot(b2.parent, a1)
self.assertIsNot(a2.parent, b1)
self.assertGreater(a2.version, a1.version)
self.assertGreater(b2.version, b1.version)
self.assertEqual(a1.version, b1.version)
self.assertEqual(a2.version, b2.version)
self.assertGreater(a2.created, a1.created)
self.assertGreater(b1.created, a2.created)
self.assertGreater(b2.created, b1.created)
def test_update(self):
"""
Test the update of multiple versions over time.
"""
A = Version.new('A')
a = A(self.replica)
B = Version.new('B')
b = B(self.replica)
calls = []
replicas = [
r for r in self.sim.replicas if r != self.replica
]
for idx, replica in enumerate(replicas):
self.sim.env.now += (2*(idx+1))
a.update(replica)
b.update(replica)
pcent = float(idx+2) / float(len(self.sim.replicas))
calls.append(mock.call('visibility', (self.replica.id, str(a), pcent, a.created, self.sim.env.now)))
calls.append(mock.call('visibility', (self.replica.id, str(b), pcent, a.created, self.sim.env.now)))
self.assertGreater(a.updated, a.created)
self.assertEqual(a.updated, self.sim.env.now)
self.assertGreater(b.updated, b.created)
self.assertEqual(b.updated, self.sim.env.now)
self.sim.results.update.assert_has_calls(calls + [
mock.call('visibility latency', (self.replica.id, str(a), a.created, a.updated)),
mock.call('visibility latency', (self.replica.id, str(b), b.created, b.updated)),
], any_order=True)
self.assertTrue(a.is_visible())
self.assertTrue(b.is_visible())
def test_is_stale(self):
"""
Test the staleness of multiple versions.
"""
A = Version.new('A')
a = A(self.replica)
B = Version.new('B')
b = B(self.replica)
self.assertFalse(a.is_stale())
self.assertFalse(b.is_stale())
self.sim.env.now += 42
b2 = b.nextv(self.replica)
self.assertTrue(b.is_stale())
self.assertFalse(a.is_stale())
self.assertFalse(b2.is_stale())
self.sim.env.now += 42
a2 = a.nextv(self.replica)
self.assertTrue(a.is_stale())
self.assertTrue(b.is_stale())
self.assertFalse(a2.is_stale())
self.assertFalse(b2.is_stale())
def test_is_stale(self):
"""
Test the staleness of multiple versions.
"""
A = Version.new('A')
a = A(self.replica)
B = Version.new('B')
b = B(self.replica)
self.assertFalse(a.is_stale())
self.assertFalse(b.is_stale())
self.sim.env.now += 42
b2 = b.nextv(self.replica)
self.assertTrue(b.is_stale())
self.assertFalse(a.is_stale())
self.assertFalse(b2.is_stale())
self.sim.env.now += 42
a2 = a.nextv(self.replica)
self.assertTrue(a.is_stale())
self.assertTrue(b.is_stale())
self.assertFalse(a2.is_stale())
self.assertFalse(b2.is_stale())
def test_is_forked(self):
"""
Test the fork detection mechanism of multiple versions.
"""
# Create new version history for an object named A
A = Version.new('A')
# Create the first version
a1 = A(self.replica)
self.assertFalse(a1.is_forked())
# Create another version
a2 = a1.nextv(self.replica)
self.assertFalse(a1.is_forked())
self.assertFalse(a2.is_forked())
# Create a fork!
a3 = a1.nextv(self.replica)
self.assertTrue(a1.is_forked())
self.assertFalse(a2.is_forked())
self.assertFalse(a3.is_forked())
# Create another version from a2
a4 = a2.nextv(self.replica)
self.assertTrue(a1.is_forked())
self.assertFalse(a2.is_forked())
self.assertFalse(a3.is_forked())
self.assertFalse(a4.is_forked())
# Create a fork from a2!
a5 = a2.nextv(self.replica)
self.assertTrue(a1.is_forked())
self.assertTrue(a2.is_forked())
self.assertFalse(a3.is_forked())
self.assertFalse(a4.is_forked())
self.assertFalse(a5.is_forked())
# Create another fork from a1!
a6 = a1.nextv(self.replica)
self.assertTrue(a1.is_forked())
self.assertTrue(a2.is_forked())
self.assertFalse(a3.is_forked())
self.assertFalse(a4.is_forked())
self.assertFalse(a5.is_forked())
self.assertFalse(a6.is_forked())
def test_is_forked(self):
"""
Test the fork detection mechanism of multiple versions.
"""
# Create new version history for an object named A
A = Version.new('A')
# Create the first version
a1 = A(self.replica)
self.assertFalse(a1.is_forked())
# Create another version
a2 = a1.nextv(self.replica)
self.assertFalse(a1.is_forked())
self.assertFalse(a2.is_forked())
# Create a fork!
a3 = a1.nextv(self.replica)
self.assertTrue(a1.is_forked())
self.assertFalse(a2.is_forked())
self.assertFalse(a3.is_forked())
# Create another version from a2
a4 = a2.nextv(self.replica)
self.assertTrue(a1.is_forked())
self.assertFalse(a2.is_forked())
self.assertFalse(a3.is_forked())
self.assertFalse(a4.is_forked())
# Create a fork from a2!
a5 = a2.nextv(self.replica)
self.assertTrue(a1.is_forked())
self.assertTrue(a2.is_forked())
self.assertFalse(a3.is_forked())
self.assertFalse(a4.is_forked())
self.assertFalse(a5.is_forked())
# Create another fork from a1!
a6 = a1.nextv(self.replica)
self.assertTrue(a1.is_forked())
self.assertTrue(a2.is_forked())
self.assertFalse(a3.is_forked())
self.assertFalse(a4.is_forked())
self.assertFalse(a5.is_forked())
self.assertFalse(a6.is_forked())
def test_unforking(self):
"""
Test "unforking" a version by dropping the child access.
"""
# Create new version history for an object named A
A = Version.new('A')
# Create the first version
a1 = A(self.replica)
self.assertFalse(a1.is_forked())
# Create another version
a2 = a1.nextv(self.replica)
self.assertFalse(a1.is_forked())
self.assertFalse(a2.is_forked())
# Create a fork!
a3 = a1.nextv(self.replica)
self.assertTrue(a1.is_forked())
self.assertFalse(a2.is_forked())
self.assertFalse(a3.is_forked())
# Now drop a3 and "unfork" it.
a3.access.drop()
self.assertFalse(a1.is_forked())
self.assertFalse(a2.is_forked())
self.assertFalse(a3.is_forked())
# Create two more forks!
a4 = a1.nextv(self.replica)
a5 = a1.nextv(self.replica)
self.assertTrue(a1.is_forked())
self.assertFalse(a2.is_forked())
self.assertFalse(a3.is_forked())
self.assertFalse(a4.is_forked())
self.assertFalse(a5.is_forked())
# Drop a4 but a1 remains forked
a4.access.drop()
self.assertTrue(a1.is_forked())
# Drop a5 which unforks a1
a5.access.drop()
self.assertFalse(a1.is_forked())
def test_unforking(self):
"""
Test "unforking" a version by dropping the child access.
"""
# Create new version history for an object named A
A = Version.new('A')
# Create the first version
a1 = A(self.replica)
self.assertFalse(a1.is_forked())
# Create another version
a2 = a1.nextv(self.replica)
self.assertFalse(a1.is_forked())
self.assertFalse(a2.is_forked())
# Create a fork!
a3 = a1.nextv(self.replica)
self.assertTrue(a1.is_forked())
self.assertFalse(a2.is_forked())
self.assertFalse(a3.is_forked())
# Now drop a3 and "unfork" it.
a3.access.drop()
self.assertFalse(a1.is_forked())
self.assertFalse(a2.is_forked())
self.assertFalse(a3.is_forked())
# Create two more forks!
a4 = a1.nextv(self.replica)
a5 = a1.nextv(self.replica)
self.assertTrue(a1.is_forked())
self.assertFalse(a2.is_forked())
self.assertFalse(a3.is_forked())
self.assertFalse(a4.is_forked())
self.assertFalse(a5.is_forked())
# Drop a4 but a1 remains forked
a4.access.drop()
self.assertTrue(a1.is_forked())
# Drop a5 which unforks a1
a5.access.drop()
self.assertFalse(a1.is_forked())
def test_construct_from_version(self):
"""
Test Tree instantiation from a version.
"""
# Set up a mock simulation
sim = mock.MagicMock()
sim.env.now = 42
r0, r1 = Replica(sim), Replica(sim)
sim.replicas = [r0, r1]
# Create a new version
Foo = Version.new("Foo")
# Add some version history
f1 = Foo(r0)
f2 = f1.nextv(r0)
f3 = f1.nextv(r1)
f4 = f2.nextv(r0)
f5 = f3.nextv(r1)
f6 = f5.nextv(r1)
f7 = f6.nextv(r1)
f8 = f7.nextv(r0)
tree = Tree.from_version(f1)
self.assertTrue(tree.is_root())
self.assertEqual(tree.label, '1')
self.assertEqual(tree.data['name'], 'Foo')
self.assertEqual(tree.height(), 6)
self.assertEqual(tree.size(), 8)
def evaluate(parent):
for child in parent:
self.assertEqual(child.parent, parent)
self.assertIsInstance(child.label, str)
self.assertEqual(child.data['name'], parent.data['name'])
self.assertGreater(int(child.label), int(parent.label))
evaluate(child)
evaluate(tree)
def test_construct_from_version(self):
"""
Test Tree instantiation from a version.
"""
# Set up a mock simulation
sim = mock.MagicMock()
sim.env.now = 42
r0, r1 = Replica(sim), Replica(sim)
sim.replicas = [r0, r1]
# Create a new version
Foo = Version.new("Foo")
# Add some version history
f1 = Foo(r0)
f2 = f1.nextv(r0)
f3 = f1.nextv(r1)
f4 = f2.nextv(r0)
f5 = f3.nextv(r1)
f6 = f5.nextv(r1)
f7 = f6.nextv(r1)
f8 = f7.nextv(r0)
tree = Tree.from_version(f1)
self.assertTrue(tree.is_root())
self.assertEqual(tree.label, "1")
self.assertEqual(tree.data["name"], "Foo")
self.assertEqual(tree.height(), 6)
self.assertEqual(tree.size(), 8)
def evaluate(parent):
for child in parent:
self.assertEqual(child.parent, parent)
self.assertIsInstance(child.label, str)
self.assertEqual(child.data["name"], parent.data["name"])
self.assertGreater(int(child.label), int(parent.label))
evaluate(child)
evaluate(tree)
def test_commit(self):
"""
Test the commit of a version over time.
"""
v1 = Version(self.replica)
for idx, replica in enumerate(self.sim.replicas):
if replica == self.replica: continue
self.sim.env.now += (2 * (idx + 1))
v1.update(replica)
self.sim.results.update.assert_called_with(
'visibility latency',
(self.replica.id, str(v1), v1.created, v1.updated))
self.assertTrue(v1.is_visible())
v1.update(self.replica, commit=True)
self.assertTrue(v1.committed)
self.assertTrue(v1.is_committed())
self.sim.results.update.assert_called_with(
'commit latency',
(self.replica.id, str(v1), v1.created, v1.updated))
def test_commit(self):
"""
Test the commit of a version over time.
"""
v1 = Version(self.replica)
for idx, replica in enumerate(self.sim.replicas):
if replica == self.replica: continue
self.sim.env.now += (2*(idx+1))
v1.update(replica)
self.sim.results.update.assert_called_with(
'visibility latency', (self.replica.id, str(v1), v1.created, v1.updated)
)
self.assertTrue(v1.is_visible())
v1.update(self.replica, commit=True)
self.assertTrue(v1.committed)
self.assertTrue(v1.is_committed())
self.sim.results.update.assert_called_with(
'commit latency', (self.replica.id, str(v1), v1.created, v1.updated)
)
