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