refactor: internal handling of imports

tests/base_conftest.py

@@ -112,16 +112,18 @@ def w3(tester):
     return w3
 
 
-def _get_contract(w3, source_code, optimize, *args, override_opt_level=None, **kwargs):
+def _get_contract(
+    w3, source_code, optimize, *args, override_opt_level=None, input_bundle=None, **kwargs
+):
     settings = Settings()
     settings.evm_version = kwargs.pop("evm_version", None)
     settings.optimize = override_opt_level or optimize
     out = compiler.compile_code(
         source_code,
         # test that metadata and natspecs get generated
-        ["abi", "bytecode", "metadata", "userdoc", "devdoc"],
+        output_formats=["abi", "bytecode", "metadata", "userdoc", "devdoc"],
         settings=settings,
-        interface_codes=kwargs.pop("interface_codes", None),
+        input_bundle=input_bundle,
         show_gas_estimates=True,  # Enable gas estimates for testing
     )
     parse_vyper_source(source_code)  # Test grammar.
@@ -145,7 +147,6 @@ def _deploy_blueprint_for(w3, source_code, optimize, initcode_prefix=b"", **kwar
     out = compiler.compile_code(
         source_code,
         ["abi", "bytecode"],
-        interface_codes=kwargs.pop("interface_codes", None),
         settings=settings,
         show_gas_estimates=True,  # Enable gas estimates for testing
     )
@@ -187,10 +188,10 @@ def deploy_blueprint_for(source_code, *args, **kwargs):
 
 @pytest.fixture(scope="module")
 def get_contract(w3, optimize):
-    def get_contract(source_code, *args, **kwargs):
+    def fn(source_code, *args, **kwargs):
         return _get_contract(w3, source_code, optimize, *args, **kwargs)
 
-    return get_contract
+    return fn
 
 
 @pytest.fixture

tests/cli/vyper_compile/test_compile_files.py

@@ -1,3 +1,5 @@
+from pathlib import Path
+
 import pytest
 
 from vyper.cli.vyper_compile import compile_files
@@ -19,10 +21,10 @@ def test_combined_json_keys(tmp_path):
         "userdoc",
         "devdoc",
     }
-    compile_data = compile_files([bar_path], ["combined_json"], root_folder=tmp_path)
+    compile_data = compile_files(["bar.vy"], ["combined_json"], root_folder=tmp_path)
 
-    assert set(compile_data.keys()) == {"bar.vy", "version"}
-    assert set(compile_data["bar.vy"].keys()) == combined_keys
+    assert set(compile_data.keys()) == {Path("bar.vy"), "version"}
+    assert set(compile_data[Path("bar.vy")].keys()) == combined_keys
 
 
 def test_invalid_root_path():

tests/cli/vyper_compile/test_import_paths.py

@@ -1,6 +1,6 @@
 import pytest
 
-from vyper.cli.vyper_compile import compile_files, get_interface_file_path
+from vyper.cli.vyper_compile import compile_files
 
 FOO_CODE = """
 {}
@@ -117,9 +117,8 @@ def test_import_parent_folder(tmp_path, assert_compile_failed):
         fp.write(BAR_CODE)
 
     assert compile_files([foo_path], ["combined_json"], root_folder=tmp_path)
-    # Cannot perform relative import outside of base folder
-    with pytest.raises(FileNotFoundError):
-        compile_files([foo_path], ["combined_json"], root_folder=tmp_path.joinpath("contracts"))
+    # perform relative import outside of base folder
+    compile_files([foo_path], ["combined_json"], root_folder=tmp_path.joinpath("contracts"))
 
 
 META_IMPORT_STMT = [
@@ -224,30 +223,6 @@ def test_local_namespace(tmp_path):
     assert compile_files(compile_paths, ["combined_json"], root_folder=tmp_path)
 
 
-def test_get_interface_file_path(tmp_path):
-    for file_name in ("foo.vy", "foo.json", "bar.vy", "baz.json", "potato"):
-        with tmp_path.joinpath(file_name).open("w") as fp:
-            fp.write("")
-
-    tmp_path.joinpath("interfaces").mkdir()
-    for file_name in ("interfaces/foo.json", "interfaces/bar"):
-        with tmp_path.joinpath(file_name).open("w") as fp:
-            fp.write("")
-
-    base_paths = [tmp_path, tmp_path.joinpath("interfaces")]
-    assert get_interface_file_path(base_paths, "foo") == tmp_path.joinpath("foo.vy")
-    assert get_interface_file_path(base_paths, "bar") == tmp_path.joinpath("bar.vy")
-    assert get_interface_file_path(base_paths, "baz") == tmp_path.joinpath("baz.json")
-
-    base_paths = [tmp_path.joinpath("interfaces"), tmp_path]
-    assert get_interface_file_path(base_paths, "foo") == tmp_path.joinpath("interfaces/foo.json")
-    assert get_interface_file_path(base_paths, "bar") == tmp_path.joinpath("bar.vy")
-    assert get_interface_file_path(base_paths, "baz") == tmp_path.joinpath("baz.json")
-
-    with pytest.raises(Exception):
-        get_interface_file_path(base_paths, "potato")
-
-
 def test_compile_outside_root_path(tmp_path):
     foo_path = tmp_path.joinpath("foo.vy")
     with foo_path.open("w") as fp:

tests/cli/vyper_json/test_compile_from_input_dict.py

@@ -1,6 +1,7 @@
 #!/usr/bin/env python3
 
 from copy import deepcopy
+from pathlib import PurePath
 
 import pytest
 
@@ -48,7 +49,6 @@ def oopsie(a: uint256) -> bool:
         "inputs": [{"type": "uint256", "name": "a"}],
         "stateMutability": "nonpayable",
         "type": "function",
-        "gas": 313,
     }
 ]
 
@@ -58,14 +58,14 @@ def oopsie(a: uint256) -> bool:
         "contracts/foo.vy": {"content": FOO_CODE},
         "contracts/bar.vy": {"content": BAR_CODE},
     },
-    "interfaces": {"contracts/bar.json": {"abi": BAR_ABI}},
+    "interfaces": {"contracts/ibar.json": {"abi": BAR_ABI}},
     "settings": {"outputSelection": {"*": ["*"]}},
 }
 
 
 def test_root_folder_not_exists():
     with pytest.raises(FileNotFoundError):
-        compile_from_input_dict({}, root_folder="/path/that/does/not/exist")
+        compile_from_input_dict(INPUT_JSON, root_folder="/path/that/does/not/exist")
 
 
 def test_wrong_language():
@@ -87,7 +87,7 @@ def test_exc_handler_to_dict_syntax():
     assert "errors" in result
     assert len(result["errors"]) == 1
     error = result["errors"][0]
-    assert error["component"] == "parser"
+    assert error["component"] == "compiler", error
     assert error["type"] == "SyntaxException"
 
 
@@ -114,14 +114,21 @@ def test_source_ids_increment():
     input_json = deepcopy(INPUT_JSON)
     input_json["settings"]["outputSelection"] = {"*": ["evm.deployedBytecode.sourceMap"]}
     result, _ = compile_from_input_dict(input_json)
-    assert result["contracts/bar.vy"]["source_map"]["pc_pos_map_compressed"].startswith("-1:-1:0")
-    assert result["contracts/foo.vy"]["source_map"]["pc_pos_map_compressed"].startswith("-1:-1:1")
+    assert result[PurePath("contracts/foo.vy")]["source_map"]["pc_pos_map_compressed"].startswith(
+        "-1:-1:0"
+    )
+    assert result[PurePath("contracts/bar.vy")]["source_map"]["pc_pos_map_compressed"].startswith(
+        "-1:-1:1"
+    )
 
 
 def test_outputs():
     result, _ = compile_from_input_dict(INPUT_JSON)
-    assert sorted(result.keys()) == ["contracts/bar.vy", "contracts/foo.vy"]
-    assert sorted(result["contracts/bar.vy"].keys()) == sorted(set(TRANSLATE_MAP.values()))
+    assert list(result.keys()) == [PurePath("contracts/foo.vy"), PurePath("contracts/bar.vy")]
+
+    output_formats = list(TRANSLATE_MAP.values())
+    output_formats.append("source_id")
+    assert sorted(result[PurePath("contracts/bar.vy")].keys()) == sorted(set(output_formats))
 
 
 def test_relative_import_paths():

tests/cli/vyper_json/test_compile_json.py

@@ -39,7 +39,7 @@ def bar(a: uint256) -> bool:
         "contracts/foo.vy": {"content": FOO_CODE},
         "contracts/bar.vy": {"content": BAR_CODE},
     },
-    "interfaces": {"contracts/bar.json": {"abi": BAR_ABI}},
+    "interfaces": {"contracts/ibar.json": {"abi": BAR_ABI}},
     "settings": {"outputSelection": {"*": ["*"]}},
 }
 

tests/cli/vyper_json/test_get_contracts.py

@@ -1,8 +1,8 @@
-#!/usr/bin/env python3
+from pathlib import PurePath
 
 import pytest
 
-from vyper.cli.vyper_json import get_input_dict_contracts
+from vyper.cli.vyper_json import get_inputs
 from vyper.exceptions import JSONError
 from vyper.utils import keccak256
 
@@ -23,49 +23,51 @@ def bar(a: uint256) -> bool:
 
 def test_no_sources():
     with pytest.raises(KeyError):
-        get_input_dict_contracts({})
+        get_inputs({})
 
 
 def test_contracts_urls():
     with pytest.raises(JSONError):
-        get_input_dict_contracts({"sources": {"foo.vy": {"urls": ["https://foo.code.com/"]}}})
+        get_inputs({"sources": {"foo.vy": {"urls": ["https://foo.code.com/"]}}})
 
 
 def test_contracts_no_content_key():
     with pytest.raises(JSONError):
-        get_input_dict_contracts({"sources": {"foo.vy": FOO_CODE}})
+        get_inputs({"sources": {"foo.vy": FOO_CODE}})
 
 
 def test_contracts_keccak():
     hash_ = keccak256(FOO_CODE.encode()).hex()
 
     input_json = {"sources": {"foo.vy": {"content": FOO_CODE, "keccak256": hash_}}}
-    get_input_dict_contracts(input_json)
+    get_inputs(input_json)
 
     input_json["sources"]["foo.vy"]["keccak256"] = "0x" + hash_
-    get_input_dict_contracts(input_json)
+    get_inputs(input_json)
 
     input_json["sources"]["foo.vy"]["keccak256"] = "0x1234567890"
     with pytest.raises(JSONError):
-        get_input_dict_contracts(input_json)
+        get_inputs(input_json)
 
 
-def test_contracts_bad_path():
+def test_contracts_outside_pwd():
     input_json = {"sources": {"../foo.vy": {"content": FOO_CODE}}}
-    with pytest.raises(JSONError):
-        get_input_dict_contracts(input_json)
+    get_inputs(input_json)
 
 
 def test_contract_collision():
     # ./foo.vy and foo.vy will resolve to the same path
     input_json = {"sources": {"./foo.vy": {"content": FOO_CODE}, "foo.vy": {"content": FOO_CODE}}}
     with pytest.raises(JSONError):
-        get_input_dict_contracts(input_json)
+        get_inputs(input_json)
 
 
 def test_contracts_return_value():
     input_json = {
         "sources": {"foo.vy": {"content": FOO_CODE}, "contracts/bar.vy": {"content": BAR_CODE}}
     }
-    result = get_input_dict_contracts(input_json)
-    assert result == {"foo.vy": FOO_CODE, "contracts/bar.vy": BAR_CODE}
+    result = get_inputs(input_json)
+    assert result == {
+        PurePath("foo.vy"): {"content": FOO_CODE},
+        PurePath("contracts/bar.vy"): {"content": BAR_CODE},
+    }