def test_wait_does_not_propogate_exceptions_from_result(self):
transfer_coordinator = TransferCoordinator()
transfer_coordinator.set_exception(FutureResultException())
transfer_coordinator.announce_done()
try:
self.coordinator_controller.wait()
except FutureResultException as e:
self.fail('%s should not have been raised.' % e)
def test_cancel(self):
transfer_coordinator = TransferCoordinator()
# Add the transfer coordinator
self.coordinator_controller.add_transfer_coordinator(
transfer_coordinator)
# Cancel with the canceler
self.coordinator_controller.cancel()
# Check that coordinator got canceled
self.assert_coordinator_is_cancelled(transfer_coordinator)
def test_add_transfer_coordinator(self):
transfer_coordinator = TransferCoordinator()
# Add the transfer coordinator
self.coordinator_controller.add_transfer_coordinator(
transfer_coordinator)
# Ensure that is tracked.
self.assertEqual(
self.coordinator_controller.tracked_transfer_coordinators,
set([transfer_coordinator]))
def setUp(self):
self.leaky_bucket = mock.Mock(LeakyBucket)
self.time_utils = mock.Mock(TimeUtils)
self.tempdir = tempfile.mkdtemp()
self.content = b'a' * 1024 * 1024
self.filename = os.path.join(self.tempdir, 'myfile')
with open(self.filename, 'wb') as f:
f.write(self.content)
self.coordinator = TransferCoordinator()
def test_cancel_with_provided_exception(self):
message = 'my cancel message'
transfer_coordinator = TransferCoordinator()
self.coordinator_controller.add_transfer_coordinator(
transfer_coordinator)
self.coordinator_controller.cancel(message, exc_type=FatalError)
transfer_coordinator.announce_done()
with self.assertRaisesRegexp(FatalError, message):
transfer_coordinator.result()
def test_cancel_with_message(self):
message = 'my cancel message'
transfer_coordinator = TransferCoordinator()
self.coordinator_controller.add_transfer_coordinator(
transfer_coordinator)
self.coordinator_controller.cancel(message)
transfer_coordinator.announce_done()
with self.assertRaisesRegexp(CancelledError, message):
transfer_coordinator.result()
def test_remove_transfer_coordinator(self):
transfer_coordinator = TransferCoordinator()
# Add the coordinator
self.coordinator_controller.add_transfer_coordinator(
transfer_coordinator)
# Now remove the coordinator
self.coordinator_controller.remove_transfer_coordinator(
transfer_coordinator)
# Make sure that it is no longer getting tracked.
self.assertEqual(
self.coordinator_controller.tracked_transfer_coordinators, set())
def _get_future_with_components(self, call_args):
transfer_id = self._id_counter
# Creates a new transfer future along with its components
transfer_coordinator = TransferCoordinator(transfer_id=transfer_id)
# Track the transfer coordinator for transfers to manage.
self._coordinator_controller.add_transfer_coordinator(
transfer_coordinator)
# Also make sure that the transfer coordinator is removed once
# the transfer completes so it does not stick around in memory.
transfer_coordinator.add_done_callback(
self._coordinator_controller.remove_transfer_coordinator,
transfer_coordinator)
components = {
'meta': TransferMeta(call_args, transfer_id=transfer_id),
'coordinator': transfer_coordinator
}
transfer_future = TransferFuture(**components)
return transfer_future, components
def test_wait_for_done_transfer_coordinators(self):
# Create a coordinator and add it to the canceler
transfer_coordinator = TransferCoordinator()
self.coordinator_controller.add_transfer_coordinator(
transfer_coordinator)
sleep_time = 0.02
with ThreadPoolExecutor(max_workers=1) as executor:
# In a seperate thread sleep and then set the transfer coordinator
# to done after sleeping.
start_time = time.time()
executor.submit(self.sleep_then_announce_done,
transfer_coordinator, sleep_time)
# Now call wait to wait for the transfer coordinator to be done.
self.coordinator_controller.wait()
end_time = time.time()
wait_time = end_time - start_time
# The time waited should not be less than the time it took to sleep in
# the seperate thread because the wait ending should be dependent on
# the sleeping thread announcing that the transfer coordinator is done.
self.assertTrue(sleep_time <= wait_time)
def setUp(self):
self.meta = TransferMeta()
self.coordinator = TransferCoordinator()
self.future = self._get_transfer_future()
def setUp(self):
self.coordinator = TransferCoordinator()
self.tag_semaphores = {}
self.executor = self.get_executor()
def test_transfer_id(self):
transfer_coordinator = TransferCoordinator(transfer_id=1)
self.assertEqual(transfer_coordinator.transfer_id, 1)
def setUp(self):
self.transfer_coordinator = TransferCoordinator()
def setUp(self):
self.transfer_id = 1
self.transfer_coordinator = TransferCoordinator(
transfer_id=self.transfer_id)
def test_repr(self):
transfer_coordinator = TransferCoordinator(transfer_id=1)
self.assertEqual(repr(transfer_coordinator),
'TransferCoordinator(transfer_id=1)')
def setUp(self):
super(BaseTaskTest, self).setUp()
self.transfer_coordinator = TransferCoordinator()