def test_that_we_cannot_add_path_requirements_with_different_names(
current_platform):
req1 = requirement_parser.parse("path/to/req#egg=req1")
req2 = requirement_parser.parse("path/to/req#egg=req2")
with pytest.raises(IncompatibleRequirements):
req1.add(req2, current_platform)
def test_that_adding_requirements_with_the_same_url_works(current_platform):
req1 = requirement_parser.parse("https://url.test#egg=req")
req2 = requirement_parser.parse("https://url.test#egg=req")
sum_requirement = req1.add(req2, current_platform)
assert isinstance(sum_requirement, UrlRequirement)
assert sum_requirement.url() == "https://url.test"
def test_that_we_can_add_url_requirements_where_one_does_not_apply(
current_platform):
req1 = requirement_parser.parse("https://test.test#egg=test-req")
req2 = requirement_parser.parse(
'https://other.test#egg=test-req; "python_version" == "1.0"')
assert req1.add(req2, current_platform) == req1
assert req2.add(req1, current_platform) == req1
def test_versions_add_if_same_requirement_is_added_twice(current_platform):
requirement_set = RequirementSet(current_platform)
requirement_set.add(requirement_parser.parse("pypi2nix <= 2.0"))
requirement_set.add(requirement_parser.parse("pypi2nix >= 1.9"))
requirement = requirement_set.requirements["pypi2nix"]
assert isinstance(requirement, VersionRequirement)
assert len(requirement.version()) == 2
def test_that_adding_requirements_where_one_does_not_apply_to_system_yields_the_other(
current_platform):
req1 = requirement_parser.parse("req1")
req2 = requirement_parser.parse(
'req1 >= 1.0; python_version == "1.0"') # definitly not true
sum_requirement = req1.add(req2, current_platform)
assert isinstance(sum_requirement, VersionRequirement)
assert not sum_requirement.version()
def test_elements_from_both_sets_can_be_found_in_sum_of_sets(current_platform):
left = RequirementSet(current_platform)
left.add(requirement_parser.parse("test1"))
right = RequirementSet(current_platform)
right.add(requirement_parser.parse("test2"))
sum = left + right
assert "test1" in sum
assert "test2" in sum
def test_adding_path_requirements_where_one_requirement_does_not_apply(
current_platform):
req1 = requirement_parser.parse("path/to/req#egg=test-req")
req2 = requirement_parser.parse(
'different/path#egg=test-req; "python_version" == "1.0"')
assert req1.add(req2, current_platform) == req1
assert req2.add(req1, current_platform) == req1
def test_can_add_version_requirement_with_url_requirement(
version_requirement_line, url_requirement_line, current_platform):
req1 = requirement_parser.parse(version_requirement_line)
req2 = requirement_parser.parse(url_requirement_line)
sum_requirement = req1.add(req2, current_platform)
assert isinstance(sum_requirement, UrlRequirement)
sum_requirement = req2.add(req1, current_platform)
assert isinstance(sum_requirement, UrlRequirement)
def test_that_we_can_add_version_with_path_requirement_result_is_path_requirement(
version_requirement_line, path_requirement_line, current_platform):
req1 = requirement_parser.parse(version_requirement_line)
req2 = requirement_parser.parse(path_requirement_line)
sum_requirement = req1.add(req2, current_platform)
assert isinstance(sum_requirement, PathRequirement)
sum_requirement = req2.add(req1, current_platform)
assert isinstance(sum_requirement, PathRequirement)
def test_that_requirements_can_be_added_together_adding_version_constraints(
current_platform):
req1 = requirement_parser.parse("req >= 1.0")
assert isinstance(req1, VersionRequirement)
req2 = requirement_parser.parse("req >= 2.0")
assert isinstance(req2, VersionRequirement)
sum_requirement = req1.add(req2, current_platform)
assert isinstance(sum_requirement, VersionRequirement)
assert len(
sum_requirement.version()) == len(req1.version()) + len(req2.version())
def test_cannot_add_path_and_url_requirement(path_requirement_line,
url_requirement_line,
current_platform):
req1 = requirement_parser.parse(path_requirement_line)
req2 = requirement_parser.parse(url_requirement_line)
with pytest.raises(IncompatibleRequirements):
req1.add(req2, current_platform)
with pytest.raises(IncompatibleRequirements):
req2.add(req1, current_platform)
def test_that_adding_requirements_with_a_version_and_a_url_results_in_url_requirement(
current_platform):
for direction in ["forward", "reverse"]:
req1 = requirement_parser.parse("req1 >= 1.0")
req2 = requirement_parser.parse("git+https://test.test/path#egg=req1")
if direction == "forward":
sum_requirement = req1.add(req2, current_platform)
else:
sum_requirement = req2.add(req1, current_platform)
assert isinstance(sum_requirement, UrlRequirement)
assert sum_requirement.url() == "git+https://test.test/path"
def test_that_git_source_extracted_is_valid():
requirement = requirement_parser.parse(
"git+https://github.com/nix-community/pypi2nix.git@5c65345a2ce7f2f1c376f983d20e935c09c15995#egg=pypi2nix"
)
source = requirement.source()
assert isinstance(source, GitSource)
source.nix_expression()
def test_pip_downloads_sources_to_target_directory(pip, project_dir,
current_platform):
download_path = os.path.join(project_dir, "download")
requirements = RequirementSet(current_platform)
requirements.add(requirement_parser.parse("six"))
pip.download_sources(requirements=requirements,
target_directory=download_path)
assert list_files(download_path)
def test_install_six_yields_non_empty_freeze_output(pip, project_dir,
download_dir,
current_platform):
requirements = RequirementSet(current_platform)
requirements.add(requirement_parser.parse("six"))
pip.download_sources(requirements, download_dir)
pip.install(requirements, source_directories=[download_dir])
assert pip.freeze()
def build_dependencies_from_setup_cfg(
self, target_platform: TargetPlatform) -> RequirementSet:
setup_requires = self.setup_cfg.get("options",
{}).get("setup_requires")
requirements = RequirementSet(target_platform)
if isinstance(setup_requires, str):
requirements.add(requirement_parser.parse(setup_requires))
elif isinstance(setup_requires, list):
for requirement_string in setup_requires:
try:
requirement = requirement_parser.parse(requirement_string)
except ParsingFailed as e:
self.logger.warning(
"Failed to parse build dependency of `{name}`".format(
name=self.name))
self.logger.warning(
"Possible reason: `{reason}`".format(reason=e.reason))
else:
if requirement.applies_to_target(target_platform):
requirements.add(requirement)
return requirements
def test_freeze_respects_additional_python_path(pip, project_dir, current_platform):
prefix = os.path.join(project_dir, "custom-prefix")
download_dir = os.path.join(project_dir, "download")
requirements = RequirementSet(current_platform)
requirements.add(requirement_parser.parse("six"))
pip.download_sources(requirements, download_dir)
pip.install(
requirements, target_directory=prefix, source_directories=[download_dir]
)
freeze_without_six = pip.freeze()
freeze_with_six = pip.freeze(python_path=[prefix])
assert len(freeze_without_six) < len(freeze_with_six)
def test_pip_can_install_wheels_previously_downloaded(pip, project_dir,
current_platform):
download_directory = os.path.join(project_dir, "download")
target_directory = os.path.join(project_dir, "wheels")
requirements = RequirementSet(current_platform)
requirements.add(requirement_parser.parse("six"))
pip.download_sources(requirements, download_directory)
pip.build_wheels(
requirements=requirements,
source_directories=[download_directory],
target_directory=target_directory,
)
assert list_files(target_directory)
assert any(map(lambda x: x.endswith(".whl"), list_files(target_directory)))
def from_file(
constructor,
requirements_file: RequirementsFile,
target_platform: TargetPlatform,
) -> "RequirementSet":
file_lines = requirements_file.read().splitlines()
requirements_set = constructor(target_platform)
for line in file_lines:
try:
requirement = requirement_parser.parse(line)
except ParsingFailed:
detected_requirements = constructor._handle_non_requirement_line(
line, target_platform)
requirements_set += detected_requirements
else:
requirements_set.add(requirement)
return requirements_set
def test_install_to_target_directory_does_not_install_to_default_directory(
pip, project_dir, download_dir, current_platform):
requirements = RequirementSet(current_platform)
requirements.add(requirement_parser.parse("six"))
target_directory = os.path.join(project_dir, "target-directory")
os.makedirs(target_directory)
pip.download_sources(requirements, download_dir)
assert not os.listdir(target_directory)
pip.install(
requirements,
source_directories=[download_dir],
target_directory=target_directory,
)
assert os.listdir(target_directory)
def build_dependencies_from_pyproject_toml(
self, target_platform: TargetPlatform) -> RequirementSet:
requirement_set = RequirementSet(target_platform)
if self.pyproject_toml is None:
pass
else:
for build_input in self.pyproject_toml.get("build-system",
{}).get("requires", []):
try:
requirement = requirement_parser.parse(build_input)
except ParsingFailed as e:
self.logger.warning(
"Failed to parse build dependency of `{name}`".format(
name=self.name))
self.logger.warning(
"Possible reason: `{reason}`".format(reason=e.reason))
else:
if requirement.applies_to_target(target_platform):
requirement_set.add(requirement)
return requirement_set
def requirements_for_jsonschema(current_platform):
requirements = RequirementSet(current_platform)
requirements.add(requirement_parser.parse("jsonschema == 3.0.1"))
return requirements
def six_requirements(project_dir, current_platform):
requirements = RequirementSet(current_platform)
requirements.add(requirement_parser.parse("six == 1.12.0"))
return requirements
def requirement(request):
return requirement_parser.parse(request.param)
def test_can_find_requirement_in_requirement_set(current_platform):
requirements = RequirementSet(current_platform)
requirements.add(requirement_parser.parse("pypi2nix"))
assert "pypi2nix" in requirements
def add_line(self, line: str) -> None:
requirement = requirement_parser.parse(line)
if isinstance(requirement, PathRequirement):
requirement = requirement.change_path(os.path.abspath)
self.requirement_set.add(requirement)
def test_sources_contains_a_source_per_git_requirement(current_platform):
requirement_set = RequirementSet(current_platform)
requirement_set.add(requirement_parser.parse("no-git-source"))
requirement_set.add(
requirement_parser.parse("git+https://url.test/path#egg=test-egg"))
assert len(requirement_set.sources()) == 1
def test_length_is_one_after_adding_same_requirement_twice(current_platform):
requirement_set = RequirementSet(current_platform)
requirement_set.add(requirement_parser.parse("pypi2nix"))
requirement_set.add(requirement_parser.parse("pypi2nix"))
assert len(requirement_set) == 1
def test_that_queries_into_set_are_canonicalized(requirement_set):
requirement = requirement_parser.parse("pytest")
requirement_set.add(requirement)
assert requirement_set["PyTest"] == requirement
def test_that_we_can_query_for_added_requirements(requirement_set):
requirement = requirement_parser.parse("pytest")
requirement_set.add(requirement)
assert requirement_set[requirement.name()] == requirement
