def setUp(self):
"""Set up."""
yield super(PathFixingTests, self).setUp()
self.plt = PathLockingTree()
self.handler = MementoHandler()
self.plt.logger.setLevel(logging.DEBUG)
self.plt.logger.propagate = False
self.plt.logger.addHandler(self.handler)
self.addCleanup(self.plt.logger.removeHandler, self.handler)
class LoggingTests(TwistedTestCase):
"""Test the logging."""
@defer.inlineCallbacks
def setUp(self):
"""Set up."""
yield super(LoggingTests, self).setUp()
self.plt = PathLockingTree()
self.handler = MementoHandler()
self.plt.logger.setLevel(logging.DEBUG)
self.plt.logger.propagate = False
self.plt.logger.addHandler(self.handler)
self.addCleanup(self.plt.logger.removeHandler, self.handler)
@defer.inlineCallbacks
def test_logger_can_be_given(self):
"""Accept an external logger."""
logger = logging.getLogger("ubuntuone.SyncDaemon.Test")
handler = MementoHandler()
logger.addHandler(handler)
logger.setLevel(logging.DEBUG)
logger.propagate = False
# acquire and test
release = yield self.plt.acquire('path', logger=logger)
self.assertTrue(handler.check_debug("acquiring on"))
# release and test
release()
self.assertTrue(handler.check_debug("releasing"))
def test_acquire_single_default(self):
"""Single path, full check."""
self.plt.acquire('path')
self.assertTrue(self.handler.check_debug(
"acquiring on", "path",
"(on_parent=False, on_children=False)", "wait for: 0"))
def test_acquire_single_on_parent(self):
"""Single path, on parent."""
self.plt.acquire('path', on_parent=True)
self.assertTrue(self.handler.check_debug("on_parent=True"))
def test_acquire_single_on_children(self):
"""Single path, on children."""
self.plt.acquire('path', on_children=True)
self.assertTrue(self.handler.check_debug("on_children=True"))
def test_acquire_single_on_both(self):
"""Single path, on both."""
self.plt.acquire('path', on_parent=True, on_children=True)
self.assertTrue(self.handler.check_debug(
"(on_parent=True, on_children=True)"))
def test_acquire_multiple(self):
"""Single path, on both."""
self.plt.acquire('1', '2', *"abc")
self.assertTrue(self.handler.check_debug("'1', '2', 'a', 'b', 'c'"))
def test_acquire_waiting(self):
"""Single path, on both."""
self.plt.acquire('path')
self.assertTrue(self.handler.check_debug("wait for: 0"))
self.plt.acquire('path')
self.assertTrue(self.handler.check_debug("wait for: 1"))
self.plt.acquire('path')
self.assertTrue(self.handler.check_debug("wait for: 2"))
@defer.inlineCallbacks
def test_release_simple(self):
"""Single release."""
release = yield self.plt.acquire("path")
release()
self.assertTrue(self.handler.check_debug("releasing",
"path", "remaining: 0"))
@defer.inlineCallbacks
def test_release_double(self):
"""Double release."""
release1 = yield self.plt.acquire("path1")
release2 = yield self.plt.acquire("path2")
release1()
self.assertTrue(self.handler.check_debug("releasing",
"path1", "remaining: 1"))
release2()
self.assertTrue(self.handler.check_debug("releasing",
"path2", "remaining: 0"))
@defer.inlineCallbacks
def test_release_longer_branches(self):
"""Longer branches."""
release = yield self.plt.acquire(*"abcde")
self.plt.acquire(*"abc")
self.plt.acquire(*"abcdefg")
self.plt.acquire(*"abklop")
self.plt.acquire(*"foobar")
release()
self.assertTrue(self.handler.check_debug("releasing",
"'a', 'b', 'c', 'd', 'e'",
"remaining: 4"))
class PathFixingTests(TwistedTestCase):
"""Test the path fixing."""
@defer.inlineCallbacks
def setUp(self):
"""Set up."""
yield super(PathFixingTests, self).setUp()
self.plt = PathLockingTree()
self.handler = MementoHandler()
self.plt.logger.setLevel(logging.DEBUG)
self.plt.logger.propagate = False
self.plt.logger.addHandler(self.handler)
self.addCleanup(self.plt.logger.removeHandler, self.handler)
def test_clean_pathlocktree(self):
"""A fix over nothing stored."""
self.plt.fix_path(tuple('abc'), tuple('abX'))
self.assertEqual(len(self.plt.root['children_nodes']), 0)
@defer.inlineCallbacks
def test_simple_leaf(self):
"""Simple change for a leaf."""
from_path = tuple('abc')
to_path = tuple('abX')
release = yield self.plt.acquire(*from_path)
# get leaf deferred
node_a = self.plt.root['children_nodes']['a']
node_b = node_a['children_nodes']['b']
node_c = node_b['children_nodes']['c']
original_deferreds = node_c['node_deferreds']
# fix path
self.plt.fix_path(from_path, to_path)
# get deferred from new path, assert is the same
node_a = self.plt.root['children_nodes']['a']
node_b = node_a['children_nodes']['b']
node_X = node_b['children_nodes']['X']
self.assertEqual(node_X['node_deferreds'], original_deferreds)
# release, it should be clean now
release()
self.assertEqual(len(self.plt.root['children_nodes']), 0)
@defer.inlineCallbacks
def test_complex_leaf(self):
"""Change for a leaf with two items."""
from_path = tuple('abc')
to_path = tuple('abX')
releases = []
d = self.plt.acquire(*from_path)
d.addCallback(releases.append)
d = self.plt.acquire(*from_path)
d.addCallback(releases.append)
# get leaf deferred
node_a = self.plt.root['children_nodes']['a']
node_b = node_a['children_nodes']['b']
node_c = node_b['children_nodes']['c']
original_deferreds = node_c['node_deferreds']
# rename
self.plt.fix_path(from_path, to_path)
# get deferred from new path, assert is the same
node_a = self.plt.root['children_nodes']['a']
node_b = node_a['children_nodes']['b']
node_X = node_b['children_nodes']['X']
self.assertEqual(node_X['node_deferreds'], original_deferreds)
# acquire with other one, assert that it's not released
d = self.plt.acquire(*to_path)
d.addCallback(lambda f: self.assertFalse(releases) or f)
# release
releases.pop(0)()
releases.pop(0)()
release = yield d
release()
self.assertEqual(len(self.plt.root['children_nodes']), 0)
@defer.inlineCallbacks
def test_simple_not_leaf(self):
"""Simple change for not a leaf."""
from_path = tuple('abc')
to_path = tuple('aXc')
releases = []
d = self.plt.acquire(*from_path)
d.addCallback(releases.append)
# get leaf deferred
node_a = self.plt.root['children_nodes']['a']
node_b = node_a['children_nodes']['b']
node_c = node_b['children_nodes']['c']
original_deferreds = node_c['node_deferreds']
# rename
self.plt.fix_path(from_path, to_path)
# get deferred from new path, assert is the same
node_a = self.plt.root['children_nodes']['a']
node_X = node_a['children_nodes']['X']
node_c = node_X['children_nodes']['c']
self.assertEqual(node_c['node_deferreds'], original_deferreds)
# acquire with other one, assert that it's not released
d = self.plt.acquire(*to_path)
d.addCallback(lambda f: self.assertFalse(releases) or f)
# release
releases.pop(0)()
release = yield d
release()
self.assertEqual(len(self.plt.root['children_nodes']), 0)
@defer.inlineCallbacks
def test_same_tree(self):
"""Move a leaf one level up."""
from_path = tuple('abcd')
to_path = tuple('abd')
releases = []
d = self.plt.acquire(*from_path)
d.addCallback(releases.append)
# get leaf deferred
node_a = self.plt.root['children_nodes']['a']
node_b = node_a['children_nodes']['b']
node_c = node_b['children_nodes']['c']
node_d = node_c['children_nodes']['d']
original_deferreds = node_d['node_deferreds']
# rename
self.plt.fix_path(from_path, to_path)
# get deferred from new path, assert is the same
node_a = self.plt.root['children_nodes']['a']
node_b = node_a['children_nodes']['b']
node_d = node_b['children_nodes']['d']
self.assertEqual(node_d['node_deferreds'], original_deferreds)
# check also that the 'c' node is gone
self.assertNotIn('c', node_b['children_nodes'])
# acquire with other one, assert that it's not released
d = self.plt.acquire(*to_path)
d.addCallback(lambda f: self.assertFalse(releases) or f)
# release
releases.pop(0)()
release = yield d
release()
self.assertEqual(len(self.plt.root['children_nodes']), 0)
@defer.inlineCallbacks
def test_parents_move_child(self):
"""Complex change involving parents, renaming child."""
releases = []
d = self.plt.acquire('a', 'b')
d.addCallback(releases.append)
d = self.plt.acquire('a', 'b', 'c', on_parent=True)
d.addCallback(releases.append)
# rename
self.plt.fix_path(('a', 'b', 'c'), ('a', 'b', 'X'))
# acquire with other one, assert that it's not released
d = self.plt.acquire('a', 'b', 'X')
d.addCallback(lambda f: self.assertFalse(releases) or f)
# release
releases.pop(0)()
releases.pop(0)()
release = yield d
release()
self.assertEqual(len(self.plt.root['children_nodes']), 0)
@defer.inlineCallbacks
def test_parents_move_parent(self):
"""Complex change involving parents, renaming parent."""
releases = []
d = self.plt.acquire('a', 'b')
d.addCallback(releases.append)
d = self.plt.acquire('a', 'b', 'c', on_parent=True)
d.addCallback(releases.append)
# rename
self.plt.fix_path(('a', 'b'), ('a', 'X'))
# acquire with other one, assert that there's only one
# left to release ('aXC', as releasing 'aX' will trigger
# this one)
d = self.plt.acquire('a', 'X', 'd', on_parent=True)
d.addCallback(lambda f: self.assertEqual(len(releases), 1) and f)
# release first the parent, then the child
releases.pop(0)()
releases.pop(0)()
release = yield d
release()
self.assertEqual(len(self.plt.root['children_nodes']), 0)
@defer.inlineCallbacks
def test_very_different_children(self):
"""Aquire changing the children a lot."""
releases = []
d = self.plt.acquire('a', 'b', 'c', 'd')
d.addCallback(releases.append)
d = self.plt.acquire('a', 'b', 'c', on_children=True)
d.addCallback(releases.append)
# rename
self.plt.fix_path(('a', 'b', 'c', 'd'), ('a', 'b', 'X', 'Y'))
# acquire with other one, assert that there's only one
# left to release ('aXC', as releasing 'aX' will trigger
# this one)
d = self.plt.acquire('a', 'b', 'X', on_children=True)
d.addCallback(lambda f: self.assertEqual(len(releases), 1) and f)
# release first the parent, then the child
releases.pop(0)()
releases.pop(0)()
release = yield d
release()
self.assertEqual(len(self.plt.root['children_nodes']), 0)
def test_double_simple(self):
"""Simple but duplicate acquiring."""
releases = []
d = self.plt.acquire('GetDelta', '')
d.addCallback(releases.append)
d = self.plt.acquire('GetDelta', '')
d.addCallback(releases.append)
releases.pop(0)()
releases.pop(0)()
self.assertEqual(len(self.plt.root['children_nodes']), 0)
def test_moving_over(self):
"""Move over something that still exists."""
releases = []
d = self.plt.acquire('a', 'b', 'c')
d.addCallback(releases.append)
d = self.plt.acquire('a', 'b', 'd')
d.addCallback(releases.append)
# rename
self.plt.fix_path(('a', 'b', 'd'), ('a', 'b', 'c'))
# release both
releases.pop(0)()
releases.pop(0)()
self.assertEqual(len(self.plt.root['children_nodes']), 0)
def test_irl_complicated_example(self):
"""Just a complicated move I found IRL."""
releases = []
d = self.plt.acquire('temp', 'drizzle', '.bzr', 'checkout', 'limbo',
'new-19', 'handshake.cc')
d.addCallback(releases.append)
# rename
fix_from = ('temp', 'drizzle', '.bzr', 'checkout', 'limbo', 'new-19')
fix_to = ('temp', 'drizzle', 'libdrizzle')
self.plt.fix_path(fix_from, fix_to)
# release it
releases.pop(0)()
self.assertEqual(len(self.plt.root['children_nodes']), 0)
def setUp(self):
"""Set up."""
yield super(CleaningTests, self).setUp()
self.plt = PathLockingTree()
def setUp(self):
"""Set up."""
yield super(InternalDeferredTests, self).setUp()
self.plt = PathLockingTree()
class CleaningTests(TwistedTestCase):
"""Test that the releases clean the tree."""
@defer.inlineCallbacks
def setUp(self):
"""Set up."""
yield super(CleaningTests, self).setUp()
self.plt = PathLockingTree()
@defer.inlineCallbacks
def test_simple(self):
"""Simple clean, add one, release it."""
release = yield self.plt.acquire("path")
release()
self.assertEqual(len(self.plt.root['children_nodes']), 0)
@defer.inlineCallbacks
def test_add_two_release_one(self):
"""Add two different paths, release them by one."""
release1 = yield self.plt.acquire("path1")
release2 = yield self.plt.acquire("path2")
self.assertEqual(len(self.plt.root['children_nodes']), 2)
release1()
self.assertEqual(len(self.plt.root['children_nodes']), 1)
release2()
self.assertEqual(len(self.plt.root['children_nodes']), 0)
@defer.inlineCallbacks
def test_longer_branch(self):
"""Simple clean, but using a longer branch."""
release = yield self.plt.acquire(*"abc")
release()
self.assertEqual(len(self.plt.root['children_nodes']), 0)
@defer.inlineCallbacks
def test_overlapped_release_shorter(self):
"""Overlap two paths, release shorter."""
release1 = yield self.plt.acquire(*"abc")
release2 = yield self.plt.acquire(*"ab")
# release shorter, check structure
release2()
self.assertEqual(len(self.plt.root['children_nodes']), 1)
node_a = self.plt.root['children_nodes']['a']
self.assertEqual(len(node_a['children_nodes']), 1)
self.assertEqual(len(node_a['children_deferreds']), 1)
self.assertEqual(len(node_a['node_deferreds']), 0)
node_b = node_a['children_nodes']['b']
self.assertEqual(len(node_b['children_nodes']), 1)
self.assertEqual(len(node_b['children_deferreds']), 1)
self.assertEqual(len(node_b['node_deferreds']), 0)
node_c = node_b['children_nodes']['c']
self.assertEqual(len(node_c['children_nodes']), 0)
self.assertEqual(len(node_c['children_deferreds']), 0)
self.assertEqual(len(node_c['node_deferreds']), 1)
# release longer, empty now!
release1()
self.assertEqual(len(self.plt.root['children_nodes']), 0)
@defer.inlineCallbacks
def test_overlapped_release_longer(self):
"""Overlap two paths, release longer."""
release1 = yield self.plt.acquire(*"abc")
release2 = yield self.plt.acquire(*"ab")
# release longer, check structure
release1()
self.assertEqual(len(self.plt.root['children_nodes']), 1)
node_a = self.plt.root['children_nodes']['a']
self.assertEqual(len(node_a['children_nodes']), 1)
self.assertEqual(len(node_a['children_deferreds']), 1)
self.assertEqual(len(node_a['node_deferreds']), 0)
node_b = node_a['children_nodes']['b']
self.assertEqual(len(node_b['children_nodes']), 0)
self.assertEqual(len(node_b['children_deferreds']), 0)
self.assertEqual(len(node_b['node_deferreds']), 1)
# release shorter, empty now!
release2()
self.assertEqual(len(self.plt.root['children_nodes']), 0)
@defer.inlineCallbacks
def test_same_long_path_double(self):
"""Two long branchs."""
release1 = yield self.plt.acquire(*"ab")
releases = []
d = self.plt.acquire(*"ab")
d.addCallback(releases.append)
# release first, check structure
release1()
self.assertEqual(len(self.plt.root['children_nodes']), 1)
node_a = self.plt.root['children_nodes']['a']
self.assertEqual(len(node_a['children_nodes']), 1)
self.assertEqual(len(node_a['children_deferreds']), 1)
self.assertEqual(len(node_a['node_deferreds']), 0)
node_b = node_a['children_nodes']['b']
self.assertEqual(len(node_b['children_nodes']), 0)
self.assertEqual(len(node_b['children_deferreds']), 0)
self.assertEqual(len(node_b['node_deferreds']), 1)
# release second, empty now!
releases.pop(0)()
self.assertEqual(len(self.plt.root['children_nodes']), 0)
@defer.inlineCallbacks
def test_diverging_branch(self):
"""Diverging branches."""
release1 = yield self.plt.acquire(*"abc")
release2 = yield self.plt.acquire(*"aj")
# release longer, check structure
release1()
self.assertEqual(len(self.plt.root['children_nodes']), 1)
node_a = self.plt.root['children_nodes']['a']
self.assertEqual(len(node_a['children_nodes']), 1)
self.assertEqual(len(node_a['children_deferreds']), 1)
self.assertEqual(len(node_a['node_deferreds']), 0)
node_j = node_a['children_nodes']['j']
self.assertEqual(len(node_j['children_nodes']), 0)
self.assertEqual(len(node_j['children_deferreds']), 0)
self.assertEqual(len(node_j['node_deferreds']), 1)
# release second, empty now!
release2()
self.assertEqual(len(self.plt.root['children_nodes']), 0)
class InternalDeferredTests(TwistedTestCase):
"""Test the internal deferreds handling functionality."""
@defer.inlineCallbacks
def setUp(self):
"""Set up."""
yield super(InternalDeferredTests, self).setUp()
self.plt = PathLockingTree()
def test_single_element_old(self):
"""Add to a single element that was there."""
self.plt.acquire('path')
self.plt.acquire('path')
# root has only one child
self.assertEqual(len(self.plt.root['children_nodes']), 1)
child = self.plt.root['children_nodes']['path']
# child has right values
self.assertEqual(len(child['children_nodes']), 0)
self.assertEqual(len(child['children_deferreds']), 0)
self.assertEqual(len(child['node_deferreds']), 2)
def test_single_element_new(self):
"""Add a single element that is new."""
self.plt.acquire('path')
# root has only one child
self.assertEqual(len(self.plt.root['children_nodes']), 1)
child = self.plt.root['children_nodes']['path']
# child has right values
self.assertEqual(len(child['children_nodes']), 0)
self.assertEqual(len(child['children_deferreds']), 0)
self.assertEqual(len(child['node_deferreds']), 1)
def test_two_element_both_old(self):
"""Add to two already there elements."""
self.plt.acquire('path1', 'path2')
self.plt.acquire('path1', 'path2')
# root has only one child
self.assertEqual(len(self.plt.root['children_nodes']), 1)
child = self.plt.root['children_nodes']['path1']
# root's child has right values
self.assertEqual(len(child['children_nodes']), 1)
self.assertEqual(len(child['children_deferreds']), 2)
self.assertEqual(len(child['node_deferreds']), 0)
# root's grandchild has right values
child = child['children_nodes']['path2']
self.assertEqual(len(child['children_nodes']), 0)
self.assertEqual(len(child['children_deferreds']), 0)
self.assertEqual(len(child['node_deferreds']), 2)
def test_two_element_both_new(self):
"""Add to two new elements."""
self.plt.acquire('path1', 'path2')
# root has only one child
self.assertEqual(len(self.plt.root['children_nodes']), 1)
child = self.plt.root['children_nodes']['path1']
# root's child has right values
self.assertEqual(len(child['children_nodes']), 1)
self.assertEqual(len(child['children_deferreds']), 1)
self.assertEqual(len(child['node_deferreds']), 0)
# root's grandchild has right values
child = child['children_nodes']['path2']
self.assertEqual(len(child['children_nodes']), 0)
self.assertEqual(len(child['children_deferreds']), 0)
self.assertEqual(len(child['node_deferreds']), 1)
def test_two_element_mixed(self):
"""Add to one new and one old elements."""
# first one
self.plt.acquire('path1')
# root has only one child
self.assertEqual(len(self.plt.root['children_nodes']), 1)
child = self.plt.root['children_nodes']['path1']
# root's child has right values
self.assertEqual(len(child['children_nodes']), 0)
self.assertEqual(len(child['children_deferreds']), 0)
self.assertEqual(len(child['node_deferreds']), 1)
# second one
self.plt.acquire('path1', 'path2')
# root's child has right values
self.assertEqual(len(child['children_nodes']), 1)
self.assertEqual(len(child['children_deferreds']), 1)
self.assertEqual(len(child['node_deferreds']), 1)
# root's grandchild has right values
child = child['children_nodes']['path2']
self.assertEqual(len(child['children_nodes']), 0)
self.assertEqual(len(child['children_deferreds']), 0)
self.assertEqual(len(child['node_deferreds']), 1)
def test_element_to_longer_branch(self):
"""Add element in the middle of longer branch."""
# first a long one, then a shorter one
self.plt.acquire(*"abc")
self.plt.acquire("a")
# root has only one child
self.assertEqual(len(self.plt.root['children_nodes']), 1)
child = self.plt.root['children_nodes']['a']
# root's child has right values
self.assertEqual(len(child['children_nodes']), 1)
self.assertEqual(len(child['children_deferreds']), 1)
self.assertEqual(len(child['node_deferreds']), 1)
# root's grandchild has right values
child = child['children_nodes']['b']
self.assertEqual(len(child['children_nodes']), 1)
self.assertEqual(len(child['children_deferreds']), 1)
self.assertEqual(len(child['node_deferreds']), 0)
# root's grandgrandchild has right values
child = child['children_nodes']['c']
self.assertEqual(len(child['children_nodes']), 0)
self.assertEqual(len(child['children_deferreds']), 0)
self.assertEqual(len(child['node_deferreds']), 1)
def test_second_to_root(self):
"""Add other root child."""
self.plt.acquire("path1")
self.plt.acquire("path2")
# root has two children
self.assertEqual(len(self.plt.root['children_nodes']), 2)
# root's child 1 has right values
child = self.plt.root['children_nodes']['path1']
self.assertEqual(len(child['children_nodes']), 0)
self.assertEqual(len(child['children_deferreds']), 0)
self.assertEqual(len(child['node_deferreds']), 1)
# root's child 2 has right values
child = self.plt.root['children_nodes']['path2']
self.assertEqual(len(child['children_nodes']), 0)
self.assertEqual(len(child['children_deferreds']), 0)
self.assertEqual(len(child['node_deferreds']), 1)
def test_diverging_branch(self):
"""Add a branch that separates from other."""
# first a long one, then a shorter one
self.plt.acquire(*"abcd")
self.plt.acquire(*"abj")
# root has only one child
self.assertEqual(len(self.plt.root['children_nodes']), 1)
# node a values
node_a = self.plt.root['children_nodes']['a']
self.assertEqual(len(node_a['children_nodes']), 1)
self.assertEqual(len(node_a['children_deferreds']), 2)
self.assertEqual(len(node_a['node_deferreds']), 0)
# node a values
node_b = node_a['children_nodes']['b']
self.assertEqual(len(node_b['children_nodes']), 2)
self.assertEqual(len(node_b['children_deferreds']), 2)
self.assertEqual(len(node_b['node_deferreds']), 0)
# node c values
node_c = node_b['children_nodes']['c']
self.assertEqual(len(node_c['children_nodes']), 1)
self.assertEqual(len(node_c['children_deferreds']), 1)
self.assertEqual(len(node_c['node_deferreds']), 0)
# node a values
node_d = node_c['children_nodes']['d']
self.assertEqual(len(node_d['children_nodes']), 0)
self.assertEqual(len(node_d['children_deferreds']), 0)
self.assertEqual(len(node_d['node_deferreds']), 1)
# node a values
node_j = node_b['children_nodes']['j']
self.assertEqual(len(node_j['children_nodes']), 0)
self.assertEqual(len(node_j['children_deferreds']), 0)
self.assertEqual(len(node_j['node_deferreds']), 1)
class LockingTests(TwistedTestCase):
"""Test the locking between elements."""
@defer.inlineCallbacks
def setUp(self):
"""Set up."""
yield super(LockingTests, self).setUp()
self.plt = PathLockingTree()
@defer.inlineCallbacks
def test_none_before(self):
"""Not lock because nothing there before."""
yield self.plt.acquire("path")
@defer.inlineCallbacks
def test_same_path_one_previous(self):
"""Lock on same path, one previous command."""
release = yield self.plt.acquire("path")
d = self.plt.acquire("path")
# add func first and change value later, to check when released
d.addCallback(lambda _: self.assertTrue(was_later))
was_later = True
release()
yield d
@defer.inlineCallbacks
def test_same_path_two_previous(self):
"""Lock on same path, two previous commands."""
releases = []
d1 = self.plt.acquire("path")
d1.addCallback(releases.append)
d2 = self.plt.acquire("path")
d2.addCallback(releases.append)
# add func first, test all releases were made before the check
d3 = self.plt.acquire("path")
d3.addCallback(lambda _: self.assertFalse(releases))
releases.pop(0)()
releases.pop(0)()
yield d3
def test_deferred_can_be_cancelled(self):
"""The path locking can be cancelled without harm."""
releases = []
d1 = self.plt.acquire("path")
d1.addCallback(lambda _: releases.append(1))
d2 = self.plt.acquire("path")
d2.addCallback(lambda _: releases.append(2))
# the first one should not be locked
self.assertEqual(releases, [1])
# cancel the second deferred, but it still needs to pass ok
d2.cancel()
self.assertEqual(releases, [1, 2])
@defer.inlineCallbacks
def test_same_path_having_parent(self):
"""Lock with parent having just the parent."""
yield self.plt.acquire("path1")
yield self.plt.acquire("path1", "path2")
@defer.inlineCallbacks
def test_same_path_having_children(self):
"""Lock with parent having just the parent."""
yield self.plt.acquire("path1", "path2", "path3")
yield self.plt.acquire("path1", "path2")
@defer.inlineCallbacks
def test_with_parent_none(self):
"""Lock with parent but empty."""
yield self.plt.acquire("path", on_parent=True)
@defer.inlineCallbacks
def test_with_parent_just_parent(self):
"""Lock with parent having just the parent."""
release = yield self.plt.acquire("path1")
d = self.plt.acquire("path1", "path2", on_parent=True)
# add func first and change value later, to check when released
d.addCallback(lambda _: self.assertTrue(was_later))
was_later = True
release()
yield d
@defer.inlineCallbacks
def test_with_parent_having_same(self):
"""Lock with parent having also the same path."""
releases = []
d = self.plt.acquire(*"abc")
d.addCallback(releases.append)
d = self.plt.acquire(*"abcd")
d.addCallback(releases.append)
# add func first, test all releases were made before the check
d = self.plt.acquire(*"abcd", on_parent=True)
d.addCallback(lambda _: self.assertFalse(releases))
releases.pop(0)()
releases.pop(0)()
yield d
@defer.inlineCallbacks
def test_with_parent_multiple(self):
"""Lock with some commands in parent and same."""
releases = []
d = self.plt.acquire(*"abcd")
d.addCallback(releases.append)
d = self.plt.acquire(*"abcd")
d.addCallback(releases.append)
d = self.plt.acquire(*"abc")
d.addCallback(releases.append)
d = self.plt.acquire(*"abc")
d.addCallback(releases.append)
# add func first, test all releases were made before the check
d = self.plt.acquire(*"abcd", on_parent=True)
d.addCallback(lambda _: self.assertFalse(releases))
releases.pop(0)()
releases.pop(0)()
releases.pop(0)()
releases.pop(0)()
yield d
@defer.inlineCallbacks
def test_with_parent_having_just_children(self):
"""Lock with parent but only has children."""
yield self.plt.acquire("path1", "path2", "path3")
yield self.plt.acquire("path1", "path2", on_parent=True)
@defer.inlineCallbacks
def test_with_children_none(self):
"""Lock with children but empty."""
yield self.plt.acquire("path", on_children=True)
@defer.inlineCallbacks
def test_with_children_just_children(self):
"""Lock with children having just a child."""
release = yield self.plt.acquire("path1", "path2")
d = self.plt.acquire("path1", on_children=True)
# add func first and change value later, to check when released
d.addCallback(lambda _: self.assertTrue(was_later))
was_later = True
release()
yield d
@defer.inlineCallbacks
def test_with_children_having_same(self):
"""Lock with children having also the same path."""
releases = []
d = self.plt.acquire(*"ab")
d.addCallback(releases.append)
d = self.plt.acquire(*"abc")
d.addCallback(releases.append)
# add func first, test all releases were made before the check
d = self.plt.acquire(*"ab", on_children=True)
d.addCallback(lambda _: self.assertFalse(releases))
releases.pop(0)()
releases.pop(0)()
yield d
@defer.inlineCallbacks
def test_with_children_multiple(self):
"""Lock with some commands in children and same."""
releases = []
d = self.plt.acquire(*"ab")
d.addCallback(releases.append)
d = self.plt.acquire(*"ab")
d.addCallback(releases.append)
d = self.plt.acquire(*"abc")
d.addCallback(releases.append)
d = self.plt.acquire(*"abc")
d.addCallback(releases.append)
# add func first, test all releases were made before the check
d = self.plt.acquire(*"ab", on_children=True)
d.addCallback(lambda _: self.assertFalse(releases))
releases.pop(0)()
releases.pop(0)()
releases.pop(0)()
releases.pop(0)()
yield d
@defer.inlineCallbacks
def test_with_children_and_parent_all_mixed(self):
"""Lock with some commands everywhere, :p."""
releases = []
d = self.plt.acquire(*"ab")
d.addCallback(releases.append)
d = self.plt.acquire(*"abc")
d.addCallback(releases.append)
d = self.plt.acquire(*"abc")
d.addCallback(releases.append)
d = self.plt.acquire(*"a")
d.addCallback(releases.append)
# add func first, test all releases were made before the check
d = self.plt.acquire(*"ab", on_children=True, on_parent=True)
d.addCallback(lambda _: self.assertFalse(releases))
releases.pop(0)()
releases.pop(0)()
releases.pop(0)()
releases.pop(0)()
yield d
