def test_dispatches__release_resource(self):
     self.mock_get_worker_for_reservation.return_value = Worker(
         name='worker1', last_heartbeat=datetime.utcnow())
     tasks._queue_reserved_task('task_name', 'my_task_id', 'my_resource_id', [1, 2], {'a': 2})
     self.mock__release_resource.apply_async.assert_called_once_with(('my_task_id',),
                                                                     routing_key='worker1',
                                                                     exchange='C.dq')

 def test_dispatches_inner_task(self):
     self.mock_get_worker_for_reservation.return_value = Worker(
         name='worker1', last_heartbeat=datetime.utcnow())
     tasks._queue_reserved_task('task_name', 'my_task_id', 'my_resource_id', [1, 2], {'a': 2})
     apply_async = self.mock_celery.tasks['task_name'].apply_async
     apply_async.assert_called_once_with(1, 2, a=2, routing_key='worker1', task_id='my_task_id',
                                         exchange='C.dq')

 def test_creates_and_saves_reserved_resource(self):
     self.mock_get_worker_for_reservation.return_value = Worker(
         name='worker1', last_heartbeat=datetime.utcnow())
     tasks._queue_reserved_task('task_name', 'my_task_id', 'my_resource_id', [1, 2], {'a': 2})
     self.mock_reserved_resource.assert_called_once_with(task_id='my_task_id',
                                                         worker_name='worker1',
                                                         resource_id='my_resource_id')
     self.mock_reserved_resource.return_value.save.assert_called_once_with()

    def test_loops_and_sleeps_waiting_for_available_worker(self):
        self.mock_get_worker_for_reservation.side_effect = NoWorkers()
        self.mock_get_unreserved_worker.side_effect = NoWorkers()

        class BreakOutException(Exception):
            pass

        def side_effect(*args):
            def second_call(*args):
                raise BreakOutException()
            self.mock_time.sleep.side_effect = second_call
            return None

        self.mock_time.sleep.side_effect = side_effect

        try:
            tasks._queue_reserved_task('task_name', 'my_task_id', 'my_resource_id', [1, 2],
                                       {'a': 2})
        except BreakOutException:
            pass
        else:
            self.fail('_queue_reserved_task should have raised a BreakOutException')

        self.mock_time.sleep.assert_has_calls([mock.call(0.25), mock.call(0.25)])

 def test_get_unreserved_worker_breaks_out_of_loop(self):
     self.mock_get_worker_for_reservation.side_effect = NoWorkers()
     self.mock_get_unreserved_worker.return_value = Worker('worker1', datetime.utcnow())
     tasks._queue_reserved_task('task_name', 'my_task_id', 'my_resource_id', [1, 2], {'a': 2})
     self.assertTrue(not self.mock_time.sleep.called)

 def test_get_worker_for_reservation_breaks_out_of_loop(self):
     self.mock_get_worker_for_reservation.return_value = Worker(
         name='worker1', last_heartbeat=datetime.utcnow())
     tasks._queue_reserved_task('task_name', 'my_task_id', 'my_resource_id', [1, 2], {'a': 2})
     self.assertTrue(not self.mock_get_unreserved_worker.called)
     self.assertTrue(not self.mock_time.sleep.called)