def build_logs(self):
"""
This builds the default log scenario for most test cases
"""
# Create the foo object
Foo = FederatedVersion.new('Foo')
# Add our version tree with a fork, even version on one side, odd
# version numbers on the other side. Alpha writes the first and even
# version numbers while Bravo writes the odd versions greater than 3.
self.versions.append(Foo(self.alpha)) # Foo.1.0
self.versions.append(self.versions[0].nextv(self.alpha)) # Foo.2.0
self.versions.append(self.versions[0].nextv(self.bravo)) # Foo.3.0 (fork)
self.versions.append(self.versions[1].nextv(self.alpha)) # Foo.4.0
self.versions.append(self.versions[2].nextv(self.bravo)) # Foo.5.0 (fork)
self.versions.append(self.versions[3].nextv(self.alpha)) # Foo.6.0
self.versions.append(self.versions[4].nextv(self.bravo)) # Foo.7.0 (fork)
self.versions.append(self.versions[5].nextv(self.alpha)) # Foo.8.0
self.versions.append(self.versions[6].nextv(self.bravo)) # Foo.9.0 (fork)
# Add the first and even versions to alpha
for vers in self.versions:
if vers.version == 1 or vers.version % 2 == 0:
self.alpha.log.append(vers, 0)
# Add the first and odd versions to bravo
for vers in self.versions:
if vers.version == 1 or vers.version % 2 == 1:
self.bravo.log.append(vers, 0)
# Add all versions to delta except Foo.6.0 and Foo.8.0
for vers in self.versions:
if vers.version < 6 or vers.version % 2 == 1:
self.delta.log.append(vers, 0)
def test_backpressure_only_on_log(self):
"""
Ensure that backpressure only affects versions in the log
"""
Bar = FederatedVersion.new('Bar')
v1 = Bar(self.alpha)
v2 = v1.nextv(self.alpha)
self.alpha.log.append(v1, 0)
self.alpha.log.append(v2, 0)
others = []
v = v2
for _ in xrange(5):
v = v.nextv(self.alpha)
others.append(v)
v3 = v.nextv(self.alpha)
self.alpha.log.append(v3, 0)
v4 = v3.nextv(self.alpha)
self.alpha.log.append(v4, 0)
self.assertEqual(v4.version, 9)
v1.forte = 1
self.assertEqual(self.alpha.log.get_latest_version('Bar'), v4)
current = self.alpha.update_forte_children(v4, v1)
self.assertEqual(current, v4)
for v in (v1, v2, v3, v4):
self.assertEqual(v.forte, 1)
for v in others:
self.assertEqual(v.forte, 0)
def test_backpressure_log_rearrange(self):
"""
Test how backpressure rearranges the log
"""
def assertLogOrder(log, order):
self.assertEqual(len(log)-1, len(order))
for idx, vers in enumerate(order):
self.assertEqual(log[idx+1].version, vers)
Baz = FederatedVersion.new('Baz')
v1 = Baz(self.alpha)
v2 = v1.nextv(self.alpha)
v3 = v1.nextv(self.bravo) # Fork!
v4 = v2.nextv(self.alpha)
v5 = v3.nextv(self.bravo)
v6 = v4.nextv(self.alpha)
v7 = v5.nextv(self.bravo)
# Baz.1.0 -> Baz.2.0 -> Baz.4.0 -> Baz.6.0
# Baz.1.0 -> Baz.3.0 -> Baz.5.0 -> Baz.7.0
for v in (v1,v2,v3,v4,v5,v7):
self.delta.log.append(v, 0)
# Move v4, the end of the v2 fork in this log to the end.
v2.forte = 1
self.delta.update_forte_children(self.delta.log.get_latest_version('Baz'), v2)
assertLogOrder(self.delta.log, (v1,v2,v3,v5,v7,v4))
self.delta.log.truncate()
for v in (v1,v2,v3,v4,v5,v6,v7): v.forte = 0
for v in (v1,v3,v7,v2,v4,v6):
self.delta.log.append(v, 0)
# Move v7, the out of order fork in this log to the end.
v3.forte = 1
self.delta.update_forte_children(self.delta.log.get_latest_version('Baz'), v3)
assertLogOrder(self.delta.log, (v1,v3,v2,v4,v6,v7))
