def added_local_files(self, container, local_container, filename, display_error_cb): task = AddedLocalFilesTask(container, (filename,), local_container, display_error_cb, create_mode=True) self.increment("added_locally_count") return add_task(task)
def test_add_task_returning_value(self): """Add a simple task who must return a value.""" with task_consumer.Context(): def task(): yield 56 promise = task_consumer.add_task(task) assert promise.result(0.01) is 56
def test_add_concurrent_tasks(self): """Add three tasks who are required to run at the same time. The task A will wait the Task B, then B will wait A. This test "force" the tasks to be executed in a non-linear order. """ p1_a, r1_a, _ = self._make_external_promise() p1_b, r1_b, _ = self._make_external_promise() p1_c, r1_c, _ = self._make_external_promise() p2_a, r2_a, _ = self._make_external_promise() p2_b, r2_b, _ = self._make_external_promise() p2_c, r2_c, _ = self._make_external_promise() def task_A(): r1_a(None) yield p1_b r2_a(None) yield p2_c yield 'A' def task_B(): r1_b(None) yield p1_c r2_b(None) yield p2_a yield 'B' def task_C(): r1_c(None) yield p1_a r2_c(None) yield p2_b yield 'C' with task_consumer.Context(): results = Promise.all([ task_consumer.add_task(task_A), task_consumer.add_task(task_B), task_consumer.add_task(task_C) ]).result(0.01) assert results == list('ABC')
def test_add_task_waiting_rejected_promise(self): """Add a task who should fail due to a rejected promise.""" class Err(Exception): pass def task(): yield Promise.resolve('OK') yield Promise.reject(Err()) with task_consumer.Context(): p = task_consumer.add_task(task) with pytest.raises(Err): p.result(0.01)
def test_add_empty_task(self): """Add a task who is an almost empty generator.""" with task_consumer.Context(): task_executed = [] def task(): task_executed.append(True) yield promise = task_consumer.add_task(task) promise.result(0.01) assert task_executed
def test_add_failing_task(self): """Add a task who will raises an Exception.""" class Err(Exception): pass def task(): yield Promise.resolve(True) raise Err() with task_consumer.Context(): p = task_consumer.add_task(task) with pytest.raises(Err): p.result(0.1)
def test_add_task_catching_rejected_promise(self): """Add a task who will catch a rejected promise.""" class Err(Exception): pass def task(): yield Promise.resolve('OK') with pytest.raises(Err): yield Promise.reject(Err()) yield 'OK' with task_consumer.Context(): p = task_consumer.add_task(task) assert p.result(0.01) == 'OK'
def test_add_task_multistep(self): """Add a task who has to wait other external tasks (promise).""" p1, resolve, _ = self._make_external_promise() p2, resolve2, _ = self._make_external_promise() def task(): value = yield p1 assert value is 44 value2 = yield p2 yield value2 * 2 with task_consumer.Context(): p_task = task_consumer.add_task(task) resolve(44) resolve2(26) assert p_task.result(0.01) is 52
def test_add_many_tasks(self): """Add 100 new tasks and wait them all.""" promises = [] def task(): yield Promise.resolve(1) yield Promise.resolve(2) yield Promise.resolve(3) yield 1 with task_consumer.Context(): for i in range(40): promises.append(task_consumer.add_task(task)) result = Promise.all(promises).result(0.1) print(result) assert sum(result) is 40
def test_ensure_task_generator_are_closed(self): """Ensure the task generators are properly closed after use. If a generator has yielded the final result, and the caller don't want to iter until the end, the caller must close the generator. Closing the generator will raise an exception GeneratorExit, and so allow the generator to clean resources. Without the close, resources locked by `with` will not be released. """ is_generator_closed = [] def task(): try: yield 'RESULT' except GeneratorExit: is_generator_closed.append(True) with task_consumer.Context(): p = task_consumer.add_task(task) assert p.result(0.01) == 'RESULT' assert is_generator_closed
def test_all_step_use_dedicated_thread(self): """Ensures the code in a task is always executed in a filesync thread. The generator code is always executed in a thread belonging to the filesync threads. """ main_thread = threading.current_thread().ident p1, resolve, _ = self._make_external_promise() p2, resolve2, _ = self._make_external_promise() def task(): assert threading.current_thread().ident is not main_thread yield p1 assert threading.current_thread().ident is not main_thread yield p2 assert threading.current_thread().ident is not main_thread yield Promise.resolve(None) assert threading.current_thread().ident is not main_thread with task_consumer.Context(): p_task = task_consumer.add_task(task) resolve(None) resolve2(None) p_task.result(0.01)
def sync_folder(self, *arg, **args): self.increment("sync_task_count") return add_task(FakeTask)
def moved_local_files(self, *arg, **args): self.increment("moved_locally_count") return add_task(FakeTask)
def changed_local_files(self, *arg, **args): self.increment("updated_locally_count") return add_task(FakeTask)
def removed_remote_files(self, *arg, **args): self.increment("removed_remotly_count") return add_task(FakeTask)