def _(): error = StopIteration("oh no") @fixture def raises_in_teardown(): yield "a" print("stdout") sys.stderr.write("stderr") raise error @testable_test def t(fix=raises_in_teardown): pass cache = FixtureCache() t = Test(t, "") t.resolver.resolve_args(cache) teardown_results: List[TeardownResult] = cache.teardown_fixtures_for_scope( scope=Scope.Test, scope_key=t.id, capture_output=True) assert len(teardown_results) == 1 assert teardown_results[0].captured_exception == error # Ensure that we still capture stdout, stderr on exception assert teardown_results[0].sout == "stdout\n" assert teardown_results[0].serr == "stderr"
def _(cache: FixtureCache = cache): cache.teardown_fixtures_for_scope(Scope.Module, testable_test.path) fixtures_at_scope = cache.get_fixtures_at_scope(Scope.Module, testable_test.path) assert fixtures_at_scope == {}
def _(cache: FixtureCache = cache, events: List = recorded_events): cache.teardown_fixtures_for_scope( Scope.Module, testable_test.path, capture_output=False # type: ignore[attr-defined] ) assert events == ["teardown m"]
def _(cache: FixtureCache = cache): cache.teardown_fixtures_for_scope( Scope.Module, testable_test.path, capture_output=True # type: ignore[attr-defined] ) fixtures_at_scope = cache.get_fixtures_at_scope( Scope.Module, testable_test.path) # type: ignore[attr-defined] assert fixtures_at_scope == {}
def _(cache: FixtureCache = cache): teardown_results = cache.teardown_global_fixtures(capture_output=True) # The cache contains a single global resolved fixture, which writes to sout/serr during teardown assert len(teardown_results) == 1 assert teardown_results[0].sout == "stdout\n" assert teardown_results[0].serr == "stderr"
def _(cache: FixtureCache = cache, global_fixture=global_fixture): fixtures_at_scope = cache.get_fixtures_at_scope(Scope.Global, Scope.Global) fixture = list(fixtures_at_scope.values())[0] assert len(fixtures_at_scope) == 1 assert fixture.fn == global_fixture
def _(cache: FixtureCache = cache, module_fixture=module_fixture): fixtures_at_scope = cache.get_fixtures_at_scope(Scope.Module, testable_test.path) fixture = list(fixtures_at_scope.values())[0] assert len(fixtures_at_scope) == 1 assert fixture.fn == module_fixture
def _resolve_single_arg(self, arg: Callable, cache: FixtureCache) -> Union[Any, Fixture]: """ Get the fixture return value If the fixture has been cached, return the value from the cache. Otherwise, call the fixture function and return the value. """ if not hasattr(arg, "ward_meta"): return arg fixture = Fixture(arg) if cache.contains(fixture, fixture.scope, self.test.scope_key_from(fixture.scope)): return cache.get(fixture.key, fixture.scope, self.test.scope_key_from(fixture.scope)) children_defaults = self.get_default_args(func=arg) children_resolved = {} for name, child_fixture in children_defaults.items(): child_resolved = self._resolve_single_arg(child_fixture, cache) children_resolved[name] = child_resolved try: args_to_inject = self._unpack_resolved(children_resolved) if fixture.is_generator_fixture: fixture.gen = arg(**args_to_inject) fixture.resolved_val = next( fixture.gen) # type: ignore[arg-type] elif fixture.is_async_generator_fixture: fixture.gen = arg(**args_to_inject) awaitable = fixture.gen.__anext__() # type: ignore[union-attr] fixture.resolved_val = asyncio.get_event_loop( ).run_until_complete(awaitable) elif fixture.is_coroutine_fixture: fixture.resolved_val = asyncio.get_event_loop( ).run_until_complete(arg(**args_to_inject)) else: fixture.resolved_val = arg(**args_to_inject) except (Exception, SystemExit) as e: raise FixtureError( f"Unable to resolve fixture '{fixture.name}'") from e scope_key = self.test.scope_key_from(fixture.scope) cache.cache_fixture(fixture, scope_key) return fixture
def _(cache: FixtureCache = cache): teardown_results = cache.teardown_fixtures_for_scope(Scope.Module, testable_test.path, capture_output=True) assert len(teardown_results) == 1 assert teardown_results[0].sout == "stdout\n" assert teardown_results[0].serr == "stderr"
def _(cache: FixtureCache = cache, t: Test = my_test, default_fixture=default_fixture): fixtures_at_scope = cache.get_fixtures_at_scope(Scope.Test, t.id) fixture = list(fixtures_at_scope.values())[0] assert len(fixtures_at_scope) == 1 assert fixture.fn == default_fixture
def _(exit_code=each(0, 1)): @fixture def exits(): sys.exit(exit_code) t = Test(fn=lambda exits=exits: None, module_name="foo") with raises(FixtureError): t.resolver.resolve_args(FixtureCache())
def _(cache: FixtureCache = cache, t: Test = my_test): teardown_results: List[TeardownResult] = cache.teardown_fixtures_for_scope( Scope.Test, t.id, capture_output=True) # There are 4 fixtures injected into the test. Only 2 are test-scoped, and teardown # code only runs in 1 of those. assert len(teardown_results) == 1 assert teardown_results[0].captured_exception is None assert teardown_results[0].sout == "stdout\n" assert teardown_results[0].serr == "stderr"
def cache(): return FixtureCache()
def _(exit_code=each(0, 1), outcome=each(TestOutcome.FAIL, TestOutcome.FAIL)): t = Test(fn=lambda: sys.exit(exit_code), module_name=mod) assert t.run(FixtureCache()).outcome is outcome
def cache(t=my_test): c = FixtureCache() t.resolver.resolve_args(c) return c
def _(f=exception_raising_fixture): cache = FixtureCache() cache.cache_fixture(f, "test_id") assert cache.get(f.key, Scope.Test, "test_id") == f
def _(cache: FixtureCache = cache, events: List = recorded_events): cache.teardown_global_fixtures() assert events == ["teardown g"]
def _(cache: FixtureCache = cache): cache.teardown_global_fixtures() fixtures_at_scope = cache.get_fixtures_at_scope(Scope.Global, Scope.Global) assert fixtures_at_scope == {}
def _(cache: FixtureCache = cache, events: List = recorded_events): cache.teardown_fixtures_for_scope(Scope.Module, testable_test.path) assert events == ["teardown m"]
def _(cache: FixtureCache = cache, t: Test = my_test, events: List = recorded_events): cache.teardown_fixtures_for_scope(Scope.Test, t.id) assert events == ["teardown t"]
def _(cache: FixtureCache = cache, t: Test = my_test): cache.teardown_fixtures_for_scope(Scope.Test, t.id) fixtures_at_scope = cache.get_fixtures_at_scope(Scope.Test, t.id) assert fixtures_at_scope == {}