def test_register_package_tuple_existing(
self, context: Context, package_tuple: Tuple[str, str,
str]) -> None:
"""Check registering an existing package tuple does not instantiate a new one."""
with pytest.raises(NotFound):
context.get_package_version(package_tuple)
extras = ["postgresql"]
package_version_registered = context.register_package_tuple(
package_tuple,
develop=True,
extras=extras,
os_name="fedora",
os_version="31",
python_version="3.7")
assert package_version_registered is not None
package_version_another = context.register_package_tuple(
package_tuple,
develop=True,
extras=extras,
os_name="fedora",
os_version="31",
python_version="3.7")
assert package_version_registered is package_version_another, "Different instances returned"
def test_register_package_tuple_new(
self, context: Context, package_tuple: Tuple[str, str,
str]) -> None:
"""Test registering a new package tuple to the context."""
with pytest.raises(NotFound):
context.get_package_version(package_tuple)
extras = ["postgresql"]
assert (context.register_package_tuple(package_tuple,
develop=True,
extras=extras,
os_name="rhel",
os_version="8.1",
python_version="3.6")
is not None)
package_version = context.get_package_version(package_tuple)
assert package_version.name == "selinon"
assert package_version.version == "==1.0.0"
assert package_version.develop is True
assert package_version.index is not None
assert package_version.index.url == "https://pypi.org/simple"
assert package_version.markers is None
assert package_version.extras == extras
def test_get_package_version(self, context: Context,
package_version: PackageVersion) -> None:
"""Test getting registering and getting a package version."""
with pytest.raises(NotFound):
context.get_package_version(package_version.to_tuple())
assert context.register_package_version(package_version) is False
assert context.get_package_version(
package_version.to_tuple()) is package_version
def test_note_dependencies(self, context: Context) -> None:
"""Test noting dependencies to the context."""
dependency_tuple = ("tensorboard", "2.1.0", "https://pypi.org/simple")
package_tuple = ("tensorflow", "2.0.0", "https://pypi.org/simple")
context.register_package_version(
PackageVersion(
name=package_tuple[0],
version="==" + package_tuple[1],
index=Source(package_tuple[2]),
develop=False,
))
context.register_package_tuple(
dependency_tuple,
develop=True,
extras=None,
dependent_tuple=package_tuple,
os_name="fedora",
os_version="31",
python_version="3.7",
)
package_version = context.get_package_version(package_tuple)
assert package_version is not None
assert package_version.name == package_tuple[0]
assert package_version.locked_version == package_tuple[1]
assert package_version.index.url == package_tuple[2]
package_version = context.get_package_version(dependency_tuple)
assert package_version is not None
assert package_version.name == dependency_tuple[0]
assert package_version.locked_version == dependency_tuple[1]
assert package_version.index.url == dependency_tuple[2]
assert package_tuple[0] in context.dependencies
assert package_tuple in context.dependencies[package_tuple[0]]
assert dependency_tuple in context.dependencies[
package_tuple[0]][package_tuple]
assert dependency_tuple[0] in context.dependents
assert dependency_tuple in context.dependents[dependency_tuple[0]]
entry = context.dependents[dependency_tuple[0]][dependency_tuple]
assert entry == {(package_tuple, "fedora", "31", "3.7")}
# By calling register_package_version we get a notion about direct dependency.
assert package_tuple[0] in context.dependents
assert package_tuple in context.dependents[package_tuple[0]]
assert context.dependents[package_tuple[0]][package_tuple] == set()
def test_get_package_version_graceful(
self, context: Context, package_version: PackageVersion) -> None:
"""Test getting registered package version, gracefully."""
assert context.get_package_version(package_version.to_tuple(),
graceful=True) is None
with pytest.raises(NotFound):
context.get_package_version(package_version.to_tuple(),
graceful=False)
assert context.register_package_version(package_version) is False
assert context.get_package_version(package_version.to_tuple(),
graceful=True) is package_version
assert context.get_package_version(package_version.to_tuple(),
graceful=False) is package_version
def test_register_package_version_existing(
self, context: Context, package_version: PackageVersion) -> None:
"""Test registering an existing package version to context."""
assert context.register_package_version(package_version) is False
assert context.get_package_version(
package_version.to_tuple()) is package_version
assert context.register_package_version(package_version) is True
def test_run_package_version_from_with_resolved(
self,
context: Context,
state: State,
package_version_from_version: str,
package_version_from_index: str,
package_version_from_develop: str,
resolved_version: str,
resolved_index: str,
resolved_develop: str,
add_resolved: bool,
pipeline_run: bool,
) -> None:
"""Test running the add package unit."""
prescription_str = f"""
name: AddPackageStep
type: step.AddPackage
should_include:
times: 1
adviser_pipeline: true
match:
package_version:
name: numpy
state:
package_version_from:
- name: scikit-learn
version: "{package_version_from_version}"
develop: {package_version_from_develop}
index_url: {package_version_from_index}
resolved_dependencies:
- name: click
version: "{resolved_version}"
develop: {resolved_develop}
index_url: {resolved_index}
run:
package_version:
name: daiquiri
locked_version: ==2.0.0
index_url: https://pypi.org/simple
develop: true
stack_info:
- type: INFO
message: "Hello, Thoth!"
link: https://thoth-station.ninja
"""
prescription = yaml.safe_load(prescription_str)
PRESCRIPTION_ADD_PACKAGE_STEP_SCHEMA(prescription)
AddPackageStepPrescription.set_prescription(prescription)
pypi = Source("https://pypi.org/simple")
package_version = PackageVersion(
name="numpy",
version="==1.19.1",
index=pypi,
develop=False,
)
package_version_from = PackageVersion(
name="scikit-learn",
version="==0.24.2",
index=pypi,
develop=False,
)
package_version_resolved = PackageVersion(
name="click",
version="==8.0.0",
index=pypi,
develop=False,
)
assert "dauiqiri" not in state.resolved_dependencies
state.add_resolved_dependency(package_version_from.to_tuple())
context.register_package_version(package_version_from)
if add_resolved:
state.add_resolved_dependency(package_version_resolved.to_tuple())
context.register_package_version(package_version_resolved)
runtime_env = context.project.runtime_environment
runtime_env.operating_system.name = "rhel"
runtime_env.operating_system.version = "8"
runtime_env.python_version = "3.8"
context.register_package_tuple(
package_version.to_tuple(),
dependent_tuple=package_version_from.to_tuple(),
develop=False,
extras=None,
os_name=runtime_env.operating_system.name,
os_version=runtime_env.operating_system.version,
python_version=runtime_env.python_version,
)
pv_tuple = ("daiquiri", "2.0.0", "https://pypi.org/simple")
if pipeline_run:
context.graph.should_receive(
"python_package_version_exists").with_args(
*pv_tuple,
solver_name="solver-rhel-8-py38").and_return(True).once()
context.graph.should_receive(
"is_python_package_index_enabled").with_args(
"https://pypi.org/simple").and_return(True).once()
unit = AddPackageStepPrescription()
unit.pre_run()
with unit.assigned_context(context):
assert unit.run(state, package_version) is None
if pipeline_run:
assert "daiquiri" in state.unresolved_dependencies
assert set(
state.unresolved_dependencies.get("daiquiri").values()) == {
pv_tuple
}
pv = context.get_package_version(pv_tuple, graceful=True)
assert pv is not None
assert pv.to_tuple() == pv_tuple
assert pv.develop is True
else:
assert "daiquiri" not in state.unresolved_dependencies
assert state.unresolved_dependencies.get("daiquiri") is None
