class ProgressManagerLoadingTest(FileReadingTestCase):
def setUp(self):
self.working_directory = self.get_abs_path(WD_HAS_PROGRESS)
directory_manager = LocalDirectoryWorkingContext(self.working_directory)
self.progress_manager = LocalProgressManager(directory_manager)
def tearDown(self):
self.progress_manager.clean(suffixes=[LOCK_SUFFIX])
def test_load_progress(self):
assert_that(self.progress_manager.get_done(tasks.CANDS_TASK),
contains_inanyorder("xxx1.cands.astrom", "xxx3.cands.astrom"))
assert_that(self.progress_manager.get_done(tasks.REALS_TASK),
contains_inanyorder("xxx3.reals.astrom"))
class ProgressManagerLoadingTest(FileReadingTestCase):
def setUp(self):
self.working_directory = self.get_abs_path(WD_HAS_PROGRESS)
directory_manager = LocalDirectoryWorkingContext(
self.working_directory)
self.progress_manager = LocalProgressManager(directory_manager)
def tearDown(self):
self.progress_manager.clean(suffixes=[LOCK_SUFFIX])
def test_load_progress(self):
assert_that(
self.progress_manager.get_done(tasks.CANDS_TASK),
contains_inanyorder("xxx1.cands.astrom", "xxx3.cands.astrom"))
assert_that(self.progress_manager.get_done(tasks.REALS_TASK),
contains_inanyorder("xxx3.reals.astrom"))
class ProgressManagerFreshDirectoryTest(FileReadingTestCase):
def setUp(self):
self.main_user_id = "main_user"
self.working_directory = self.get_abs_path(WD_NO_LOG)
directory_manager = LocalDirectoryWorkingContext(self.working_directory)
self.progress_manager = LocalProgressManager(directory_manager,
userid=self.main_user_id)
def create_concurrent_progress_manager(self, userid="test_user"):
directory_manager = LocalDirectoryWorkingContext(self.working_directory)
return LocalProgressManager(directory_manager, userid=userid)
def tearDown(self):
# Get rid of generated files so we don't interfere with other tests
self.progress_manager.clean()
def test_load_progress_no_logs(self):
assert_that(self.progress_manager.get_done(tasks.CANDS_TASK),
has_length(0))
assert_that(self.progress_manager.get_done(tasks.REALS_TASK),
has_length(0))
def test_record_done_requires_lock(self):
self.assertRaises(
RequiresLockException,
self.progress_manager.record_done, "xxx2.reals.astrom")
def test_write_progress(self):
assert_that(self.progress_manager.get_done(tasks.CANDS_TASK),
has_length(0))
assert_that(self.progress_manager.get_done(tasks.REALS_TASK),
has_length(0))
processed1 = "xxx2.reals.astrom"
self.progress_manager.lock(processed1)
self.progress_manager.record_done(processed1)
assert_that(self.progress_manager.get_done(tasks.CANDS_TASK),
has_length(0))
assert_that(self.progress_manager.get_done(tasks.REALS_TASK),
contains(processed1))
assert_that(self.progress_manager.is_done(processed1), equal_to(True))
# Create a second persistence manager and make sure it sees the changes
manager2 = self.create_concurrent_progress_manager()
assert_that(manager2.get_done(tasks.CANDS_TASK), has_length(0))
assert_that(manager2.get_done(tasks.REALS_TASK), contains(processed1))
assert_that(manager2.is_done(processed1), equal_to(True))
def test_write_progress_two_simultaneous_managers(self):
assert_that(self.progress_manager.get_done(tasks.CANDS_TASK),
has_length(0))
assert_that(self.progress_manager.get_done(tasks.REALS_TASK),
has_length(0))
processed1 = "xxx2.reals.astrom"
self.progress_manager.lock(processed1)
self.progress_manager.record_done(processed1)
assert_that(self.progress_manager.get_done(tasks.CANDS_TASK),
has_length(0))
assert_that(self.progress_manager.get_done(tasks.REALS_TASK),
contains(processed1))
# Create a second simultaneous manager
manager2 = self.create_concurrent_progress_manager()
processed2 = "xxx3.reals.astrom"
manager2.lock(processed2)
manager2.record_done(processed2)
# Make sure second manager sees both entries
assert_that(manager2.get_done(tasks.CANDS_TASK),
has_length(0))
assert_that(manager2.get_done(tasks.REALS_TASK),
contains_inanyorder(processed1, processed2))
# Make sure original manager sees both entries
assert_that(self.progress_manager.get_done(tasks.CANDS_TASK),
has_length(0))
assert_that(self.progress_manager.get_done(tasks.REALS_TASK),
contains_inanyorder(processed1, processed2))
def test_lock_file(self):
file1 = "xxx1.cands.astrom"
self.progress_manager.lock(file1)
# No-one else should be able to acquire the lock...
lock_requesting_user = "******"
manager2 = self.create_concurrent_progress_manager(lock_requesting_user)
self.assertRaises(FileLockedException, manager2.lock, file1)
# ... until we unlock it
self.progress_manager.unlock(file1)
manager2.lock(file1)
def test_lock_has_locker_id(self):
lock_holding_user = self.main_user_id
lock_requesting_user = "******"
file1 = "xxx1.cands.astrom"
self.progress_manager.lock(file1)
manager2 = self.create_concurrent_progress_manager(lock_requesting_user)
try:
manager2.lock(file1)
self.fail("Should have thrown FileLockedExcecption")
except FileLockedException as ex:
assert_that(ex.filename, equal_to(file1))
assert_that(ex.locker, equal_to(lock_holding_user))
def test_record_index_requires_lock(self):
self.assertRaises(RequiresLockException,
self.progress_manager.record_index,
"xxx1.cands.astrom", 0)
def test_record_index(self):
file1 = "xxx1.cands.astrom"
self.progress_manager.lock(file1)
self.progress_manager.record_index(file1, 1)
self.progress_manager.record_index(file1, 3)
self.progress_manager.record_index(file1, 0)
assert_that(self.progress_manager.get_processed_indices(file1),
contains_inanyorder(1, 3, 0))
# Check they are still recorded after we release lock
self.progress_manager.unlock(file1)
assert_that(self.progress_manager.get_processed_indices(file1),
contains_inanyorder(1, 3, 0))
# Check other clients can read them
manager2 = self.create_concurrent_progress_manager()
assert_that(manager2.get_processed_indices(file1),
contains_inanyorder(1, 3, 0))
def test_unlock_after_record_done_no_error(self):
file1 = "xxx1.cands.astrom"
self.progress_manager.lock(file1)
self.progress_manager.record_done(file1)
self.progress_manager.unlock(file1)
def test_record_done_does_not_unlock_all(self):
file1 = "xxx1.cands.astrom"
file2 = "xxx2.cands.astrom"
manager2 = self.create_concurrent_progress_manager()
self.progress_manager.lock(file1)
manager2.lock(file2)
self.progress_manager.record_done(file1)
assert_that(manager2.owns_lock(file2), equal_to(True))
manager2.unlock(file2)
assert_that(manager2.owns_lock(file2), equal_to(False))
def test_get_processed_indices_empty_should_not_cause_error(self):
assert_that(self.progress_manager.get_processed_indices("xxx1.cands.astrom"),
has_length(0))
def test_get_processed_indices_after_done(self):
filename = "xxx1.cands.astrom"
self.progress_manager.lock(filename)
self.progress_manager.record_index(filename, 0)
self.progress_manager.record_index(filename, 1)
self.progress_manager.record_index(filename, 2)
self.progress_manager.unlock(filename)
assert_that(self.progress_manager.get_processed_indices(filename),
contains_inanyorder(0, 1, 2))
self.progress_manager.lock(filename)
self.progress_manager.record_done(filename)
self.progress_manager.unlock(filename)
assert_that(self.progress_manager.get_processed_indices(filename),
contains_inanyorder(0, 1, 2))
# Double check with a second manager
assert_that(self.create_concurrent_progress_manager().get_processed_indices(filename),
contains_inanyorder(0, 1, 2))
class ProgressManagerFreshDirectoryTest(FileReadingTestCase):
def setUp(self):
self.main_user_id = "main_user"
self.working_directory = self.get_abs_path(WD_NO_LOG)
directory_manager = LocalDirectoryWorkingContext(
self.working_directory)
self.progress_manager = LocalProgressManager(directory_manager,
userid=self.main_user_id)
def create_concurrent_progress_manager(self, userid="test_user"):
directory_manager = LocalDirectoryWorkingContext(
self.working_directory)
return LocalProgressManager(directory_manager, userid=userid)
def tearDown(self):
# Get rid of generated files so we don't interfere with other tests
self.progress_manager.clean()
def test_load_progress_no_logs(self):
assert_that(self.progress_manager.get_done(tasks.CANDS_TASK),
has_length(0))
assert_that(self.progress_manager.get_done(tasks.REALS_TASK),
has_length(0))
def test_record_done_requires_lock(self):
self.assertRaises(RequiresLockException,
self.progress_manager.record_done,
"xxx2.reals.astrom")
def test_write_progress(self):
assert_that(self.progress_manager.get_done(tasks.CANDS_TASK),
has_length(0))
assert_that(self.progress_manager.get_done(tasks.REALS_TASK),
has_length(0))
processed1 = "xxx2.reals.astrom"
self.progress_manager.lock(processed1)
self.progress_manager.record_done(processed1)
assert_that(self.progress_manager.get_done(tasks.CANDS_TASK),
has_length(0))
assert_that(self.progress_manager.get_done(tasks.REALS_TASK),
contains(processed1))
assert_that(self.progress_manager.is_done(processed1), equal_to(True))
# Create a second persistence manager and make sure it sees the changes
manager2 = self.create_concurrent_progress_manager()
assert_that(manager2.get_done(tasks.CANDS_TASK), has_length(0))
assert_that(manager2.get_done(tasks.REALS_TASK), contains(processed1))
assert_that(manager2.is_done(processed1), equal_to(True))
def test_write_progress_two_simultaneous_managers(self):
assert_that(self.progress_manager.get_done(tasks.CANDS_TASK),
has_length(0))
assert_that(self.progress_manager.get_done(tasks.REALS_TASK),
has_length(0))
processed1 = "xxx2.reals.astrom"
self.progress_manager.lock(processed1)
self.progress_manager.record_done(processed1)
assert_that(self.progress_manager.get_done(tasks.CANDS_TASK),
has_length(0))
assert_that(self.progress_manager.get_done(tasks.REALS_TASK),
contains(processed1))
# Create a second simultaneous manager
manager2 = self.create_concurrent_progress_manager()
processed2 = "xxx3.reals.astrom"
manager2.lock(processed2)
manager2.record_done(processed2)
# Make sure second manager sees both entries
assert_that(manager2.get_done(tasks.CANDS_TASK), has_length(0))
assert_that(manager2.get_done(tasks.REALS_TASK),
contains_inanyorder(processed1, processed2))
# Make sure original manager sees both entries
assert_that(self.progress_manager.get_done(tasks.CANDS_TASK),
has_length(0))
assert_that(self.progress_manager.get_done(tasks.REALS_TASK),
contains_inanyorder(processed1, processed2))
def test_lock_file(self):
file1 = "xxx1.cands.astrom"
self.progress_manager.lock(file1)
# No-one else should be able to acquire the lock...
lock_requesting_user = "******"
manager2 = self.create_concurrent_progress_manager(
lock_requesting_user)
self.assertRaises(FileLockedException, manager2.lock, file1)
# ... until we unlock it
self.progress_manager.unlock(file1)
manager2.lock(file1)
def test_lock_has_locker_id(self):
lock_holding_user = self.main_user_id
lock_requesting_user = "******"
file1 = "xxx1.cands.astrom"
self.progress_manager.lock(file1)
manager2 = self.create_concurrent_progress_manager(
lock_requesting_user)
try:
manager2.lock(file1)
self.fail("Should have thrown FileLockedExcecption")
except FileLockedException as ex:
assert_that(ex.filename, equal_to(file1))
assert_that(ex.locker, equal_to(lock_holding_user))
def test_record_index_requires_lock(self):
self.assertRaises(RequiresLockException,
self.progress_manager.record_index,
"xxx1.cands.astrom", 0)
def test_record_index(self):
file1 = "xxx1.cands.astrom"
self.progress_manager.lock(file1)
self.progress_manager.record_index(file1, 1)
self.progress_manager.record_index(file1, 3)
self.progress_manager.record_index(file1, 0)
assert_that(self.progress_manager.get_processed_indices(file1),
contains_inanyorder(1, 3, 0))
# Check they are still recorded after we release lock
self.progress_manager.unlock(file1)
assert_that(self.progress_manager.get_processed_indices(file1),
contains_inanyorder(1, 3, 0))
# Check other clients can read them
manager2 = self.create_concurrent_progress_manager()
assert_that(manager2.get_processed_indices(file1),
contains_inanyorder(1, 3, 0))
def test_unlock_after_record_done_no_error(self):
file1 = "xxx1.cands.astrom"
self.progress_manager.lock(file1)
self.progress_manager.record_done(file1)
self.progress_manager.unlock(file1)
def test_record_done_does_not_unlock_all(self):
file1 = "xxx1.cands.astrom"
file2 = "xxx2.cands.astrom"
manager2 = self.create_concurrent_progress_manager()
self.progress_manager.lock(file1)
manager2.lock(file2)
self.progress_manager.record_done(file1)
assert_that(manager2.owns_lock(file2), equal_to(True))
manager2.unlock(file2)
assert_that(manager2.owns_lock(file2), equal_to(False))
def test_get_processed_indices_empty_should_not_cause_error(self):
assert_that(
self.progress_manager.get_processed_indices("xxx1.cands.astrom"),
has_length(0))
def test_get_processed_indices_after_done(self):
filename = "xxx1.cands.astrom"
self.progress_manager.lock(filename)
self.progress_manager.record_index(filename, 0)
self.progress_manager.record_index(filename, 1)
self.progress_manager.record_index(filename, 2)
self.progress_manager.unlock(filename)
assert_that(self.progress_manager.get_processed_indices(filename),
contains_inanyorder(0, 1, 2))
self.progress_manager.lock(filename)
self.progress_manager.record_done(filename)
self.progress_manager.unlock(filename)
assert_that(self.progress_manager.get_processed_indices(filename),
contains_inanyorder(0, 1, 2))
# Double check with a second manager
assert_that(
self.create_concurrent_progress_manager().get_processed_indices(
filename), contains_inanyorder(0, 1, 2))