def mock_pj_api(type_api: str, filename: str): api_result = json.load( open(os.path.join(os.path.dirname(__file__), filename))) updated_settings = {} source_type = ApiPjSource with override_settings(updated_settings), init_pj_source(source_type): if type_api == "api": api_mock = mock.patch.object( places_utils.pj_source, "get_from_params", new=lambda *x, **y: api_result, ) with api_mock: yield else: api_mock = mock.patch.object( places_utils.pj_source, "get_from_params", new=lambda *x, **y: {"search_results": { "listings": [api_result] }}, ) with api_mock: yield
def mock_bragi_carrefour_in_bbox(request, httpx_mock): bragi_response = read_fixture( "fixtures/autocomplete/carrefour_in_bbox.json") limit = getattr(request, "param", {}).get("limit") if limit is not None: bragi_response["features"] = bragi_response["features"][:limit] with override_settings({"BRAGI_BASE_URL": BASE_URL}): httpx_mock.post(re.compile(f"^{BASE_URL}/autocomplete")).respond( json=bragi_response) yield
def test_dotted_path_annotation_local_type_def( python_version, import_collision_policy, expected_import, comment, remove_type ): content = ''' class serializers: # why would you do this pass def no_op(arg1): """ Args: arg1 (serializers.Serializer): blah """ pass ''' if comment: comment = f"{comment}\n " docstring_type = "" if remove_type else " (serializers.Serializer)" expected = f'''{expected_import} class serializers: # why would you do this pass def no_op(arg1): {comment}""" Args: arg1{docstring_type}: blah """ pass ''' with tempfile.NamedTemporaryFile(suffix=".py") as f: with open(f.name, "w") as fw: fw.write(content) test_settings = override_settings( PYTHON_VERSION=python_version, ALLOW_UNTYPED_ARGS=False, REQUIRE_RETURN_TYPE=False, IMPORT_COLLISION_POLICY=import_collision_policy, UNPATHED_TYPE_POLICY=UnpathedTypePolicy.FAIL, ) inject.clear_and_configure(configuration_factory(test_settings)) annotate( f.name, in_process=True, interactive=False, write=True, silent=True, ) with open(f.name, "r") as fr: annotated = fr.read() assert annotated == expected
def test_decorated_function(): content = ''' @whatever(param=val) def decorated(arg1): """ Args: arg1 (Tuple[str, ...]): blah Returns: Tuple[int, ...]: blah """ return tuple( int(arg) for arg in arg1 ) ''' expected = '''from typing import Tuple @whatever(param=val) def decorated(arg1): # type: (Tuple[str, ...]) -> Tuple[int, ...] """ Args: arg1: blah Returns: blah """ return tuple( int(arg) for arg in arg1 ) ''' with tempfile.NamedTemporaryFile(suffix=".py") as f: with open(f.name, "w") as fw: fw.write(content) test_settings = override_settings( ALLOW_UNTYPED_ARGS=False, REQUIRE_RETURN_TYPE=False, IMPORT_COLLISION_POLICY=ImportCollisionPolicy.IMPORT, UNPATHED_TYPE_POLICY=UnpathedTypePolicy.FAIL, ) inject.clear_and_configure(configuration_factory(test_settings)) annotate( f.name, in_process=True, interactive=False, write=True, silent=True, ) with open(f.name, "r") as fr: annotated = fr.read() assert annotated == expected
def enable_bancheck(httpx_mock): with override_settings( { "BANCHECK_ENABLED": True, "QWANT_API_BASE_URL": "http://qwant-api.test", } ), patch("idunn.utils.ban_check.ban_check_http", new_callable=get_ban_check_http): httpx_mock.get(url__regex=r"http://qwant-api.test/v3/captcha/isban.*").respond( json={"status": "success", "data": True} ) yield
def test_require_return_type(require_return_type): """ NOTE: here is an example of a function where omitting the "Returns" block from the docstring and setting `REQUIRE_RETURN_TYPE=False` will give the wrong result (...an argument for `REQUIRE_RETURN_TYPE=True`) TODO: I don't know if there is any check for return statements we can do via Bowler? """ content = ''' def identity(arg1): """ Args: arg1 (Tuple[str, ...]): blah """ return arg1 ''' if not require_return_type: expected = '''from typing import Tuple def identity(arg1): # type: (Tuple[str, ...]) -> None """ Args: arg1: blah """ return arg1 ''' else: expected = content with tempfile.NamedTemporaryFile(suffix=".py") as f: with open(f.name, "w") as fw: fw.write(content) test_settings = override_settings( ALLOW_UNTYPED_ARGS=False, REQUIRE_RETURN_TYPE=require_return_type, IMPORT_COLLISION_POLICY=ImportCollisionPolicy.IMPORT, UNPATHED_TYPE_POLICY=UnpathedTypePolicy.FAIL, ) inject.clear_and_configure(configuration_factory(test_settings)) annotate( f.name, in_process=True, interactive=False, write=True, silent=True, ) with open(f.name, "r") as fr: annotated = fr.read() assert annotated == expected
def test_staticmethod(): """ First arg *is* annotatable """ content = ''' class SomeClass: @staticmethod def method(obj, whatever): """ Args: obj (object) whatever (Any) """ pass ''' expected = '''from typing import Any class SomeClass: @staticmethod def method(obj, whatever): # type: (object, Any) -> None """ Args: obj whatever """ pass ''' with tempfile.NamedTemporaryFile(suffix=".py") as f: with open(f.name, "w") as fw: fw.write(content) test_settings = override_settings( ALLOW_UNTYPED_ARGS=False, REQUIRE_RETURN_TYPE=False, IMPORT_COLLISION_POLICY=ImportCollisionPolicy.IMPORT, UNPATHED_TYPE_POLICY=UnpathedTypePolicy.FAIL, ) inject.clear_and_configure(configuration_factory(test_settings)) annotate( f.name, in_process=True, interactive=False, write=True, silent=True, ) with open(f.name, "r") as fr: annotated = fr.read() assert annotated == expected
def test_allow_untyped_args(allow_untyped_args): content = ''' def identity(arg1): """ Args: arg1: blah Returns: Tuple[str, ...]: blah """ return arg1 ''' if allow_untyped_args: expected = '''from typing import Tuple def identity(arg1): # type: (...) -> Tuple[str, ...] """ Args: arg1: blah Returns: blah """ return arg1 ''' else: expected = content with tempfile.NamedTemporaryFile(suffix=".py") as f: with open(f.name, "w") as fw: fw.write(content) test_settings = override_settings( ALLOW_UNTYPED_ARGS=allow_untyped_args, REQUIRE_RETURN_TYPE=False, IMPORT_COLLISION_POLICY=ImportCollisionPolicy.IMPORT, UNPATHED_TYPE_POLICY=UnpathedTypePolicy.FAIL, ) inject.clear_and_configure(configuration_factory(test_settings)) annotate( f.name, in_process=True, interactive=False, write=True, silent=True, ) with open(f.name, "r") as fr: annotated = fr.read() assert annotated == expected
def test_yields_generator(): content = ''' def generator(arg1): """ Args: arg1 (Iterable[int]): blah Yields: int: blah """ for val in arg1: yield val ''' expected = '''from typing import Generator, Iterable def generator(arg1): # type: (Iterable[int]) -> Generator[int, None, None] """ Args: arg1: blah Yields: blah """ for val in arg1: yield val ''' with tempfile.NamedTemporaryFile(suffix=".py") as f: with open(f.name, "w") as fw: fw.write(content) test_settings = override_settings( ALLOW_UNTYPED_ARGS=False, REQUIRE_RETURN_TYPE=False, IMPORT_COLLISION_POLICY=ImportCollisionPolicy.IMPORT, UNPATHED_TYPE_POLICY=UnpathedTypePolicy.FAIL, ) inject.clear_and_configure(configuration_factory(test_settings)) annotate( f.name, in_process=True, interactive=False, write=True, silent=True, ) with open(f.name, "r") as fr: annotated = fr.read() assert annotated == expected
def test_dotted_path_decorator(): # NOTE: this example is an instance method, so first arg is not annotatable content = ''' class SomeClass: @some_package.decorator def method(cls, obj): """ Args: obj (object) Returns: int """ return 1 ''' expected = ''' class SomeClass: @some_package.decorator def method(cls, obj): # type: (object) -> int """ Args: obj """ return 1 ''' with tempfile.NamedTemporaryFile(suffix=".py") as f: with open(f.name, "w") as fw: fw.write(content) test_settings = override_settings( ALLOW_UNTYPED_ARGS=False, REQUIRE_RETURN_TYPE=False, IMPORT_COLLISION_POLICY=ImportCollisionPolicy.IMPORT, UNPATHED_TYPE_POLICY=UnpathedTypePolicy.FAIL, ) inject.clear_and_configure(configuration_factory(test_settings)) annotate( f.name, in_process=True, interactive=False, write=True, silent=True, ) with open(f.name, "r") as fr: annotated = fr.read() assert annotated == expected
def test_find_local_types(python_version): expected = LocalTypes.factory( type_defs={ "T", "TopLevel", "InnerClass", "SomeTuple", "SomeTypedTuple", "SomeTypedDict", "NewClass", }, star_imports={"serious"}, names_to_packages={ "Irrelevant": "..sub", "Nonsense": "..sub", "ReallyUnused": "..sub", "Product": "other.module", "Imported": "some.module", "ConditionallyImported": "some.module", "InnerImported": "some.module", "namedtuple": "collections", "NamedTuple": "typing", "TypedDict": "typing", "TypeVar": "typing", "Union": "typing", }, package_imports={"logging", "nott.so.serious"}, signatures={ 34: ("static", ("cls", "self")), 39: ("clsmethod", ("self", )), 49: ("method", ("cls", )), 53: ("conditionally_defined_method", ("cls", )), 57: ("first", ("products", "getter")), 77: ("second", ("products", "getter")), 97: ("second_inner", ("product", "key", "default")), 118: ("third", ("product_ids", "user_id")), 133: ("fourth", ("product_id", "user_id")), 141: ("fifth", ("product_ids", "user_id")), 158: ("sixth", ("product_ids", )), }, ) test_settings = override_settings(PYTHON_VERSION=python_version) inject.clear_and_configure(configuration_factory(test_settings)) result = find_local_types("tests/fixtures/napoleon.py") assert result == expected
def test_returns_none(python_version): content = ''' def no_op(arg1): """ Args: arg1 (Tuple[str, ...]): blah Returns: None """ pass ''' # "Returns" block omitted since there was no description expected = '''from typing import Tuple def no_op(arg1): # type: (Tuple[str, ...]) -> None """ Args: arg1: blah """ pass ''' with tempfile.NamedTemporaryFile(suffix=".py") as f: with open(f.name, "w") as fw: fw.write(content) test_settings = override_settings( PYTHON_VERSION=python_version, ALLOW_UNTYPED_ARGS=False, REQUIRE_RETURN_TYPE=True, IMPORT_COLLISION_POLICY=ImportCollisionPolicy.IMPORT, UNPATHED_TYPE_POLICY=UnpathedTypePolicy.FAIL, ) inject.clear_and_configure(configuration_factory(test_settings)) annotate( f.name, in_process=True, interactive=False, write=True, silent=True, ) with open(f.name, "r") as fr: annotated = fr.read() assert annotated == expected
def test_handle_splat_args(): content = ''' def no_op(arg1, *args, **kwargs): """ Args: arg1 (str): blah *args (int) **kwargs (Tuple[bool, ...]) """ return ''' expected = '''from typing import Tuple def no_op(arg1, *args, **kwargs): # type: (str, *int, **Tuple[bool, ...]) -> None """ Args: arg1: blah *args **kwargs """ return ''' with tempfile.NamedTemporaryFile(suffix=".py") as f: with open(f.name, "w") as fw: fw.write(content) test_settings = override_settings( ALLOW_UNTYPED_ARGS=False, REQUIRE_RETURN_TYPE=False, IMPORT_COLLISION_POLICY=ImportCollisionPolicy.IMPORT, UNPATHED_TYPE_POLICY=UnpathedTypePolicy.FAIL, ) inject.clear_and_configure(configuration_factory(test_settings)) annotate( f.name, in_process=True, interactive=False, write=True, silent=True, ) with open(f.name, "r") as fr: annotated = fr.read() assert annotated == expected
def test_allow_missing_args_section_no_args_func(allow_untyped_args): """ If func has no args but 'Returns' is given then we should be able to annotate it. """ content = ''' def identity(): """ Returns: Tuple[str, ...]: blah """ return arg1 ''' expected = '''from typing import Tuple def identity(): # type: () -> Tuple[str, ...] """ Returns: blah """ return arg1 ''' with tempfile.NamedTemporaryFile(suffix=".py") as f: with open(f.name, "w") as fw: fw.write(content) test_settings = override_settings( ALLOW_UNTYPED_ARGS=allow_untyped_args, REQUIRE_RETURN_TYPE=False, IMPORT_COLLISION_POLICY=ImportCollisionPolicy.IMPORT, UNPATHED_TYPE_POLICY=UnpathedTypePolicy.FAIL, ) inject.clear_and_configure(configuration_factory(test_settings)) annotate( f.name, in_process=True, interactive=False, write=True, silent=True, ) with open(f.name, "r") as fr: annotated = fr.read() assert annotated == expected
def test_property(): """ First arg is not annotatable """ content = ''' class SomeClass: @property def method(obj): """ Returns: int """ return 1 ''' expected = ''' class SomeClass: @property def method(obj): # type: () -> int """ """ return 1 ''' with tempfile.NamedTemporaryFile(suffix=".py") as f: with open(f.name, "w") as fw: fw.write(content) test_settings = override_settings( ALLOW_UNTYPED_ARGS=False, REQUIRE_RETURN_TYPE=False, IMPORT_COLLISION_POLICY=ImportCollisionPolicy.IMPORT, UNPATHED_TYPE_POLICY=UnpathedTypePolicy.FAIL, ) inject.clear_and_configure(configuration_factory(test_settings)) annotate( f.name, in_process=True, interactive=False, write=True, silent=True, ) with open(f.name, "r") as fr: annotated = fr.read() assert annotated == expected
def mock_NLU_for(httpx_mock, dataset): with override_settings({ "NLU_TAGGER_URL": NLU_URL, "NLU_CLASSIFIER_URL": CLASSIF_URL, "PJ_ES": ES_URL }): nlu_json = read_fixture(f"fixtures/autocomplete/nlu/{dataset}.json") httpx_mock.post(NLU_URL).respond(json=nlu_json) for q, data in FIXTURE_CLASSIF.items(): httpx_mock.post(CLASSIF_URL, json={ "text": q, "domain": "poi", "language": "fr", "count": 10 }).respond(json=data) yield nlu_json
def test_package_imports(python_version, import_line, arg_type): content = f'''{import_line} def no_op(arg1): """ Args: arg1 ({arg_type}): blah """ pass ''' expected = f'''{import_line} def no_op(arg1): # type: ({arg_type}) -> None """ Args: arg1: blah """ pass ''' with tempfile.NamedTemporaryFile(suffix=".py") as f: with open(f.name, "w") as fw: fw.write(content) test_settings = override_settings( PYTHON_VERSION=python_version, ALLOW_UNTYPED_ARGS=False, REQUIRE_RETURN_TYPE=False, IMPORT_COLLISION_POLICY=ImportCollisionPolicy.IMPORT, UNPATHED_TYPE_POLICY=UnpathedTypePolicy.FAIL, ) inject.clear_and_configure(configuration_factory(test_settings)) annotate( f.name, in_process=True, interactive=False, write=True, silent=True, ) with open(f.name, "r") as fr: annotated = fr.read() assert annotated == expected
def test_arg_annotation_signature_mismatch(signature, arg_annotations): annotations = "\n".join( f" {name} ({type_}): {description}" for name, (type_, description) in arg_annotations.items() ) content = f''' def no_op({signature}): """ Args: {annotations} """ pass ''' # in all cases we should not have annotated expected = content with tempfile.NamedTemporaryFile(suffix=".py") as f: with open(f.name, "w") as fw: fw.write(content) test_settings = override_settings( ALLOW_UNTYPED_ARGS=True, REQUIRE_RETURN_TYPE=False, IMPORT_COLLISION_POLICY=ImportCollisionPolicy.IMPORT, UNPATHED_TYPE_POLICY=UnpathedTypePolicy.FAIL, ) inject.clear_and_configure(configuration_factory(test_settings)) annotate( f.name, in_process=True, interactive=False, write=True, silent=True, ) with open(f.name, "r") as fr: annotated = fr.read() assert annotated == expected
def mock_autocomplete_get(httpx_mock): with override_settings({"BRAGI_BASE_URL": BASE_URL}): httpx_mock.get( re.compile(f"^{BASE_URL}/autocomplete.*q=bloublou")).respond( json=read_fixture("fixtures/autocomplete/empty.json")) httpx_mock.get( re.compile(f"^{BASE_URL}/autocomplete.*q=(paris|parigi).*") ).respond(json=read_fixture("fixtures/autocomplete/paris.json")) httpx_mock.get( re.compile(f"^{BASE_URL}/autocomplete.*q=auchan.*")).respond( json=read_fixture("fixtures/autocomplete/auchan.json")) httpx_mock.get( re.compile( rf"^{BASE_URL}/autocomplete.*q=43\+rue\+de\+paris\+rennes.*") ).respond(json=read_fixture( "fixtures/autocomplete/43_rue_de_paris_rennes.json")) httpx_mock.get(re.compile(f"^{BASE_URL}/autocomplete")).respond( json=FIXTURE_AUTOCOMPLETE) yield
async def test_server(): with override_settings( ASYNC_TASKS=False, INTERNAL_DATABASE_FILE=settings.INTERNAL_DATABASE_FILE + '.test'): from cloudcopy.server.app import api as app, tasks try: async with AsyncExitStack() as stack: client = await stack.enter_async_context( AsyncClient(app=app, base_url='http://test')) test0 = await stack.enter_async_context( setup_test_database('test0', url='file:test0')) test1 = await stack.enter_async_context( setup_test_database('test1', url='file:test1')) test2 = await stack.enter_async_context( setup_test_database('test2', url='file:test2')) await setup_db(test0, tables=('test1', 'test2', 'test3')) await setup_db(test1, tables=('test2', 'test3'), rows=5) await setup_db(test2, tables=('test3', )) databases = [{ 'name': 'test0', 'url': 'file:test0', 'scope': { 'schemas': { 'main': True } } }, { 'name': 'test2', 'url': 'file:test2' }, { 'name': 'test3', 'url': 'file:test3', 'scope': { 'schemas': { 'main': True } } }] # POST for value in databases: response = await client.post('/v0/databases/', data=json.dumps( {'data': value})) assert response.status_code == 201 response = response.json()['data'] for k, v in value.items(): assert response[k] == v value['id'] = response['id'] # GET (collection) response = await client.get('/v0/databases/') assert response.status_code == 200 response = response.json()['data'] for i, value in enumerate(databases): for k, v in value.items(): assert response[i][k] == v # GET (record) modify_index = 2 id = databases[modify_index]['id'] response = await client.get(f'/v0/databases/{id}/') assert response.status_code == 200 response = response.json()['data'] for k, v in databases[modify_index].items(): assert response[k] == v assert response['created'] created = response['created'] assert response['updated'] updated = response['updated'] # PUT # all writable fields not in response # should be reset to defaults response = await client.put(f'/v0/databases/{id}/', data=json.dumps({ 'data': { 'name': 'foo', 'url': 'file:test1' } })) assert response.status_code == 200 response = response.json()['data'] assert response['name'] == 'foo' assert response['url'] == 'file:test1' # unset "scope" was set to null assert response['scope'] == None # unchanged assert response['created'] == created assert response['updated'] >= updated updated = response['updated'] # PATCH (by name) response = await client.patch(f'/v0/databases/foo/', data=json.dumps( {'data': { 'name': 'test1' }})) assert response.status_code == 200 response = response.json()['data'] assert response['name'] == 'test1' # unchanged assert response['url'] == 'file:test1' assert response['updated'] >= updated # Workflows response = await client.get(f'/v0/workflows') assert response.status_code == 200 response = response.json()['data'] assert response == [] workflows = [ { "name": "diff-0-1", "schedule": { "immediate": True }, "steps": [{ "type": "compare", "hashes": True, "source": databases[0]['id'], # by id (test0) "target": "test1" # by name reference (test1) }] }, { "name": "info-2", "steps": [{ "type": "info", "source": "file:test2" }], "schedule": { "delay": "1 minute" } } ] # add workflow for workflow in workflows: response = await client.post('/v0/workflows/', data=json.dumps( {'data': workflow})) assert response.status_code == 201 response = response.json()['data'] for k, v in workflow.items(): assert response[k] == v workflow['id'] = response['id'] # DELETE (by newly changed name) response = await client.delete(f'/v0/databases/test1/') assert response.status_code == 204 response = await client.get('/v0/databases/') assert len(response.json()['data']) == len(databases) - 1 immediate_workflow = workflows[0] delayed_workflow = workflows[1] scheduled = tasks.scheduled() assert len(scheduled) == 1 assert scheduled[0].name == 'workflow-execute' args, kwargs = scheduled[0].data assert args[0] == delayed_workflow['id'] immediate_id = immediate_workflow['id'] response = await client.get( f'/v0/jobs/?f__workflow_id={immediate_id}') assert response.status_code == 200 data = response.json()['data'] assert len(data) == 1 data = data[0] assert data['status'] == 'Succeeded' result = data['result'] assert result == diff_0_1_result finally: # clean up test sqlite DB if os.path.exists(settings.INTERNAL_DATABASE_FILE): os.remove(settings.INTERNAL_DATABASE_FILE)
def mock_autocomplete_unavailable(httpx_mock): with override_settings({"BRAGI_BASE_URL": BASE_URL}): httpx_mock.get(re.compile(f"^{BASE_URL}/autocomplete")).respond(502) yield
def mock_autocomplete_post(httpx_mock): with override_settings({"BRAGI_BASE_URL": BASE_URL}): httpx_mock.post(re.compile(f"^{BASE_URL}/autocomplete")).respond( json=FIXTURE_AUTOCOMPLETE) yield
def test_py3_syntax(): content = ''' class OtherClass(object): raise ValueError("WTF python 2") def one(arg2): """ Args: arg2 (str): blah Returns: my.module.SomeClass[str]: blah """ try: SomeClass([]) except TypeError as e: pass return SomeClass(arg2) def two(arg1): """ Args: arg1 (Tuple[str, ...]): blah Returns: Tuple[my.module.SomeClass[str], ...]: blah """ print("print function with kwarg", end='end') return tuple( one(arg) for arg in arg1 ) ''' expected = '''from my.module import SomeClass from typing import Tuple class OtherClass(object): raise ValueError("WTF python 2") def one(arg2): # type: (str) -> SomeClass[str] """ Args: arg2: blah Returns: blah """ try: SomeClass([]) except TypeError as e: pass return SomeClass(arg2) def two(arg1): # type: (Tuple[str, ...]) -> Tuple[SomeClass[str], ...] """ Args: arg1: blah Returns: blah """ print("print function with kwarg", end='end') return tuple( one(arg) for arg in arg1 ) ''' with tempfile.NamedTemporaryFile(suffix=".py") as f: with open(f.name, "w") as fw: fw.write(content) test_settings = override_settings( PYTHON_VERSION="3.6", ALLOW_UNTYPED_ARGS=False, REQUIRE_RETURN_TYPE=False, IMPORT_COLLISION_POLICY=ImportCollisionPolicy.IMPORT, UNPATHED_TYPE_POLICY=UnpathedTypePolicy.FAIL, ) inject.clear_and_configure(configuration_factory(test_settings)) annotate( f.name, in_process=True, interactive=False, write=True, silent=True, ) with open(f.name, "r") as fr: annotated = fr.read() assert annotated == expected
def test_arg_annotation_signature_validate(signature, arg_annotations): annotations = "\n".join( f" {name} ({type_}): {description}" for name, (type_, description) in arg_annotations.items() ) content = f''' def no_op({signature}): """ Args: {annotations} """ pass ''' def splatify(name, type_): if name.startswith("**"): return f"**{type_}" elif name.startswith("*"): return f"*{type_}" else: return type_ # I guess this is an 'oracle' i.e. an alternate implementation (meh) stripped_annotations = "\n".join( f" {name}: {description}" for name, (_, description) in arg_annotations.items() ) str_types = ", ".join( splatify(name, type_) for name, (type_, _) in arg_annotations.items() ) type_comment = f"# type: ({str_types}) -> None" # only builtin types in examples, no imports needed expected = f''' def no_op({signature}): {type_comment} """ Args: {stripped_annotations} """ pass ''' with tempfile.NamedTemporaryFile(suffix=".py") as f: with open(f.name, "w") as fw: fw.write(content) test_settings = override_settings( PYTHON_VERSION="3.8", # keyword-only args ALLOW_UNTYPED_ARGS=True, REQUIRE_RETURN_TYPE=False, IMPORT_COLLISION_POLICY=ImportCollisionPolicy.IMPORT, UNPATHED_TYPE_POLICY=UnpathedTypePolicy.FAIL, ) inject.clear_and_configure(configuration_factory(test_settings)) annotate( f.name, in_process=True, interactive=False, write=True, silent=True, ) with open(f.name, "r") as fr: annotated = fr.read() assert annotated == expected