def test_should_include(self,
builder_context: PipelineBuilderContext) -> None:
"""Test registering this unit if supplied software environment is fully specified."""
builder_context.project.runtime_environment.should_receive(
"is_fully_specified").with_args().and_return(True).twice()
assert list(
SolvedSoftwareEnvironmentBoot.should_include(builder_context)) == [
{}
]
builder_context.add_unit(SolvedSoftwareEnvironmentBoot())
assert list(
SolvedSoftwareEnvironmentBoot.should_include(
builder_context)) == []
def test_no_include(
self,
builder_context: PipelineBuilderContext,
recommendation_type: RecommendationType,
decision_type: DecisionType,
cuda_version: str,
) -> None:
"""Test not including this pipeline unit."""
builder_context.decision_type = decision_type
builder_context.recommendation_type = recommendation_type
builder_context.project.runtime_environment.cuda_version = cuda_version
assert builder_context.is_adviser_pipeline() or builder_context.is_dependency_monkey_pipeline()
assert self.UNIT_TESTED.should_include(builder_context) is None
def test_include(
self,
builder_context: PipelineBuilderContext,
recommendation_type: RecommendationType,
) -> None:
"""Test including this pipeline unit."""
builder_context.recommendation_type = recommendation_type
builder_context.project = Project.from_strings(
self._CASE_DISALLOWED_PIPFILE)
assert builder_context.is_adviser_pipeline()
assert list(
CutPreReleasesSieve.should_include(builder_context)) == [{}]
def test_is_included(self,
builder_context: PipelineBuilderContext) -> None:
"""Test check if the given pipeline unit is included."""
assert builder_context.is_included(units.boots.Boot1)
assert not builder_context.is_included(units.boots.Boot2)
assert builder_context.is_included(units.sieves.Sieve1)
assert not builder_context.is_included(units.sieves.Sieve2)
assert builder_context.is_included(units.steps.Step1)
assert not builder_context.is_included(units.steps.Step2)
assert builder_context.is_included(units.strides.Stride1)
assert not builder_context.is_included(units.strides.Stride2)
assert builder_context.is_included(units.wraps.Wrap1)
assert not builder_context.is_included(units.wraps.Wrap2)
def test_include(
self,
builder_context: PipelineBuilderContext,
recommendation_type: RecommendationType,
decision_type: DecisionType,
) -> None:
"""Test including this pipeline unit."""
builder_context.decision_type = decision_type
builder_context.recommendation_type = recommendation_type
builder_context.project.runtime_environment.python_version = "3.6"
assert builder_context.is_adviser_pipeline() or builder_context.is_dependency_monkey_pipeline()
assert Py36SetuptoolsSieve.should_include(builder_context) == {}
def test_no_include(
self,
builder_context: PipelineBuilderContext,
recommendation_type,
decision_type: DecisionType,
cpu_family: Optional[int],
cpu_model: Optional[int],
) -> None:
"""Test not including this pipeline unit step."""
builder_context.decision_type = decision_type
builder_context.recommendation_type = recommendation_type
builder_context.project.runtime_environment.hardware.cpu_family = cpu_family
builder_context.project.runtime_environment.hardware.cpu_model = cpu_model
assert list(self.UNIT_TESTED.should_include(builder_context)) == []
def test_no_include(
self,
builder_context: PipelineBuilderContext,
recommendation_type: RecommendationType,
decision_type: DecisionType,
library_usage: str,
) -> None:
"""Test not including this pipeline unit."""
builder_context.decision_type = decision_type
builder_context.recommendation_type = recommendation_type
builder_context.library_usage = library_usage
assert builder_context.is_adviser_pipeline(
) or builder_context.is_dependency_monkey_pipeline()
assert self.UNIT_TESTED.should_include(builder_context) is None
def test_no_include(
self,
builder_context: PipelineBuilderContext,
recommendation_type,
decision_type: DecisionType,
cpu_family: Optional[int],
cpu_model: Optional[int],
) -> None:
"""Test not including this pipeline unit step."""
builder_context.decision_type = decision_type
builder_context.recommendation_type = recommendation_type
# A Haswell CPU with AVX2 support.
builder_context.project.runtime_environment.hardware.cpu_family = cpu_family
builder_context.project.runtime_environment.hardware.cpu_model = cpu_model
assert TensorFlowAVX2Step.should_include(builder_context) is None
def test_should_include_recommendation_type(
self, builder_context: PipelineBuilderContext,
recommendation_type: RecommendationType):
"""Check inclusion for various recommendation types."""
builder_context.recommendation_type = recommendation_type
builder_context.decision_type = None
if recommendation_type in (RecommendationType.LATEST,
RecommendationType.TESTING):
assert list(self.UNIT_TESTED.should_include(builder_context)) == [{
"cve_penalization":
0.0
}]
else:
assert list(
self.UNIT_TESTED.should_include(builder_context)) == [{}]
def test_no_include(
self,
builder_context: PipelineBuilderContext,
python_version: Optional[str],
recommendation_type: RecommendationType,
decision_type: DecisionType,
develop: bool,
) -> None:
"""Test not including this unit."""
builder_context.project.runtime_environment.python_version = python_version
builder_context.recommendation_type = recommendation_type
builder_context.decision_type = decision_type
assert builder_context.is_dependency_monkey_pipeline() or builder_context.is_adviser_pipeline()
assert ImportlibResourcesBackportSieve.should_include(builder_context) is None
def test_verify_multiple_should_include(self) -> None:
"""Verify multiple should_include calls do not loop endlessly."""
builder_context = PipelineBuilderContext(recommendation_type=RecommendationType.LATEST)
for package_name in ("tensorflow", "tensorflow-cpu", "tensorflow-gpu", "intel-tensorflow"):
pipeline_config = self.UNIT_TESTED.should_include(builder_context)
assert pipeline_config is not None
assert pipeline_config == {"package_name": package_name}
unit = self.UNIT_TESTED()
unit.update_configuration(pipeline_config)
builder_context.add_unit(unit)
assert self.UNIT_TESTED.should_include(builder_context) is None, "The unit must not be included"
def test_include(
self,
builder_context: PipelineBuilderContext,
recommendation_type: RecommendationType,
) -> None:
"""Test including this pipeline unit."""
builder_context.recommendation_type = recommendation_type
builder_context.project = Project.from_strings(self._CASE_ENABLED)
assert builder_context.is_adviser_pipeline()
assert list(self.UNIT_TESTED.should_include(builder_context)) == [{
"package_name":
"tensorflow",
"index_url":
"https://thoth-station.ninja/simple",
}]
def verify_multiple_should_include(
cls, builder_context: PipelineBuilderContext) -> bool:
"""Check multiple should_include calls do not end in an infinite loop."""
assert cls.UNIT_TESTED is not None, "No unit assigned for testing"
pipeline_config = cls.UNIT_TESTED.should_include(builder_context)
assert pipeline_config is not None, "First call to should_include should be always non-None"
unit = cls.UNIT_TESTED()
if pipeline_config:
unit.update_configuration(pipeline_config)
builder_context.add_unit(unit)
assert (
cls.UNIT_TESTED.should_include(builder_context) is None
), "Make sure the pipeline unit does not loop endlessly on multiple should_include calls"
return True
def test_should_include(
self,
builder_context: PipelineBuilderContext,
python_version: str,
recommendation_type: RecommendationType,
decision_type: DecisionType,
develop: bool,
) -> None:
"""Test registering this unit."""
builder_context.project.runtime_environment.python_version = python_version
builder_context.recommendation_type = recommendation_type
builder_context.decision_type = decision_type
assert builder_context.is_dependency_monkey_pipeline(
) or builder_context.is_adviser_pipeline()
assert Functools32BackportSieve.should_include(builder_context) == {}
def test_verify_multiple_should_include(self, builder_context: PipelineBuilderContext) -> None:
"""Verify multiple should_include calls do not loop endlessly."""
builder_context.recommendation_type = RecommendationType.STABLE
builder_context.project.runtime_environment.cuda_version = None
for package_name in ("tensorflow", "tensorflow-cpu"):
pipeline_config = self.UNIT_TESTED.should_include(builder_context)
assert pipeline_config is not None
assert pipeline_config == {"package_name": package_name}
unit = self.UNIT_TESTED()
unit.update_configuration(pipeline_config)
builder_context.add_unit(unit)
assert self.UNIT_TESTED.should_include(builder_context) is None, "The unit must not be included"
def test_include(
self,
builder_context: PipelineBuilderContext,
cpu_model: int,
cpu_family: str,
recommendation_type: RecommendationType,
) -> None:
"""Test including this pipeline unit."""
builder_context.decision_type = None
builder_context.recommendation_type = recommendation_type
builder_context.project.runtime_environment.hardware.cpu_family = cpu_family
builder_context.project.runtime_environment.hardware.cpu_model = cpu_model
builder_context.project.runtime_environment.platform = "linux-x86_64"
assert builder_context.is_adviser_pipeline()
assert not builder_context.is_dependency_monkey_pipeline()
assert IntelTensorFlowWrap.should_include(builder_context) == {}
def test_verify_multiple_should_include(self, builder_context: PipelineBuilderContext) -> None:
"""Verify multiple should_include calls do not loop endlessly."""
builder_context.recommendation_type = RecommendationType.STABLE
builder_context.project.runtime_environment.cuda_version = "10.1"
pipeline_config = list(self.UNIT_TESTED.should_include(builder_context))
assert {"package_name": "tensorflow"} in pipeline_config
assert {"package_name": "tensorflow-gpu"} in pipeline_config
assert len(pipeline_config) == 2
for item in pipeline_config:
unit = self.UNIT_TESTED()
unit.update_configuration(item)
builder_context.add_unit(unit)
assert list(self.UNIT_TESTED.should_include(builder_context)) == [], "The unit must not be included"
def test_verify_multiple_should_include(self, builder_context: PipelineBuilderContext) -> None:
"""Verify multiple should_include calls do not loop endlessly."""
builder_context.recommendation_type = RecommendationType.STABLE
builder_context.project.runtime_environment.hardware.cpu_model = 13
builder_context.project.runtime_environment.hardware.cpu_family = 6
builder_context.project.runtime_environment.platform = "linux-x86_64"
self.verify_multiple_should_include(builder_context)
def test_include(
self,
builder_context: PipelineBuilderContext,
recommendation_type: RecommendationType,
) -> None:
"""Test including this pipeline unit."""
builder_context.recommendation_type = recommendation_type
builder_context.project = Project.from_strings(
self._CASE_GLOBAL_ALLOW_PIPFILE)
assert builder_context.is_adviser_pipeline()
assert list(self.UNIT_TESTED.should_include(builder_context)) == [{
"package_name":
None,
"allowed_indexes": {"https://pypi.org/simple"},
}]
def test_verify_multiple_should_include(
self, builder_context: PipelineBuilderContext) -> None:
"""Verify multiple should_include calls do not loop endlessly."""
builder_context.recommendation_type = RecommendationType.STABLE
for package_name in ("tensorflow", "tensorflow-cpu", "tensorflow-gpu"):
pipeline_config = self.UNIT_TESTED.should_include(builder_context)
assert pipeline_config is not None
assert pipeline_config == {"package_name": package_name}
unit = self.UNIT_TESTED()
unit.update_configuration(pipeline_config)
builder_context.add_unit(unit)
self.verify_multiple_should_include(builder_context)
def test_verify_multiple_should_include(
self, builder_context: PipelineBuilderContext) -> None:
"""Verify multiple should_include calls do not loop endlessly."""
builder_context.recommendation_type = RecommendationType.LATEST
builder_context.project.runtime_environment.should_receive(
"is_fully_specified").with_args().and_return(True)
self.verify_multiple_should_include(builder_context)
def test_get_included_pseudonyms(self) -> None:
"""Test get included pseudonyms of the provided pseudonym class."""
builder_context = PipelineBuilderContext(decision_type=DecisionType.RANDOM)
assert list(builder_context.get_included_pseudonyms(units.pseudonyms.Pseudonym1)) == []
assert list(builder_context.get_included_pseudonym_names()) == []
unit = units.pseudonyms.Pseudonym1()
builder_context.add_unit(unit)
assert list(builder_context.get_included_pseudonyms(units.pseudonyms.Pseudonym1)) == [unit]
assert list(builder_context.get_included_pseudonym_names()) == ["Pseudonym1"]
def test_get_included_strides(self) -> None:
"""Get included strides of the provided stride class."""
builder_context = PipelineBuilderContext(decision_type=DecisionType.RANDOM)
assert list(builder_context.get_included_strides(units.strides.Stride1)) == []
assert list(builder_context.get_included_stride_names()) == []
unit = units.strides.Stride1()
builder_context.add_unit(unit)
assert list(builder_context.get_included_strides(units.strides.Stride1)) == [unit]
assert list(builder_context.get_included_stride_names()) == ["Stride1"]
def test_get_included_wraps(self) -> None:
"""Get included wraps of the provided wrap class."""
builder_context = PipelineBuilderContext(decision_type=DecisionType.RANDOM)
assert list(builder_context.get_included_wraps(units.wraps.Wrap1)) == []
assert list(builder_context.get_included_wrap_names()) == []
unit = units.wraps.Wrap1()
builder_context.add_unit(unit)
assert list(builder_context.get_included_wraps(units.wraps.Wrap1)) == [unit]
assert list(builder_context.get_included_wrap_names()) == ["Wrap1"]
def test_get_included_boots(self) -> None:
"""Test get included boots of the provided boot class."""
builder_context = PipelineBuilderContext(decision_type=DecisionType.RANDOM)
assert list(builder_context.get_included_boots(units.boots.Boot1)) == []
assert list(builder_context.get_included_boot_names()) == []
unit = units.boots.Boot1()
builder_context.add_unit(unit)
assert list(builder_context.get_included_boots(units.boots.Boot1)) == [unit]
assert list(builder_context.get_included_boot_names()) == ["Boot1"]
def verify_multiple_should_include(cls, builder_context: PipelineBuilderContext) -> bool:
"""Check multiple should_include calls do not end in an infinite loop."""
assert cls.UNIT_TESTED is not None, "No unit assigned for testing"
pipeline_config = list(cls.UNIT_TESTED.should_include(builder_context))
assert pipeline_config != [], "First call to should_include should be always non-empty generator"
assert (
len(pipeline_config) == 1
), "First call to should_include should return one config, adjust the test if it requires additional logic"
unit = cls.UNIT_TESTED()
unit.update_configuration(pipeline_config[0])
builder_context.add_unit(unit)
assert (
list(cls.UNIT_TESTED.should_include(builder_context)) == []
), "Make sure the pipeline unit does not loop endlessly on multiple should_include calls"
return True
def test_verify_multiple_should_include(
self, builder_context: PipelineBuilderContext) -> None:
"""Verify multiple should_include calls do not loop endlessly."""
builder_context.recommendation_type = RecommendationType.STABLE
builder_context.project.runtime_environment.operating_system.name = "rhel"
builder_context.project.runtime_environment.operating_system.version = "8.2"
builder_context.project.runtime_environment.python_version = "3.6"
self.verify_multiple_should_include(builder_context)
def test_should_include_rpm_packages(
self,
builder_context: PipelineBuilderContext,
rpms_present: List[Dict[str, str]],
rpms_configured: List[Dict[str, str]],
include: bool,
) -> None:
"""Test including pipeline units based on RPM packages present in the base image."""
base_image_present_name, base_image_present_version = "s2i-thoth", "1.0.0"
builder_context.project.runtime_environment.base_image = (
f"{base_image_present_name}:v{base_image_present_version}"
)
should_include = {
"adviser_pipeline": True,
"runtime_environments": {"base_images": [builder_context.project.runtime_environment.base_image]},
}
if rpms_configured:
should_include["runtime_environments"]["rpm_packages"] = rpms_configured
PRESCRIPTION_UNIT_SHOULD_INCLUDE_SCHEMA(should_include)
if rpms_configured:
builder_context.graph.should_receive("get_last_analysis_document_id").with_args(
base_image_present_name,
base_image_present_version,
is_external=False,
).and_return("package-extract-foo-bar").once()
builder_context.graph.should_receive("get_rpm_package_version_all").with_args(
"package-extract-foo-bar"
).and_return(rpms_present).once()
else:
builder_context.graph.should_receive("get_last_analysis_document_id").times(0)
builder_context.graph.should_receive("get_rpm_package_version_all").times(0)
UnitPrescription._PRESCRIPTION = {
"name": "RPMPackagesUnit",
"should_include": should_include,
}
builder_context.recommendation_type = RecommendationType.LATEST
builder_context.decision_type = None
assert builder_context.is_adviser_pipeline()
builder_context.should_receive("is_included").with_args(UnitPrescription).and_return(False).once()
assert UnitPrescription._should_include_base(builder_context) == include
def test_verify_multiple_should_include(
self, builder_context: PipelineBuilderContext) -> None:
"""Verify multiple should_include calls do not loop endlessly."""
builder_context.recommendation_type = RecommendationType.STABLE
# Not None and not in AVX2 CPUs listing.
builder_context.project.runtime_environment.hardware.cpu_family = 0x0
builder_context.project.runtime_environment.hardware.cpu_model = 0x0
self.verify_multiple_should_include(builder_context)
def test_no_include(
self,
builder_context: PipelineBuilderContext,
decision_type: DecisionType,
recommendation_type: RecommendationType,
cpu_model: int,
cpu_family: int,
platform: Optional[str],
) -> None:
"""Test not including this pipeline unit."""
builder_context.decision_type = decision_type
builder_context.recommendation_type = recommendation_type
builder_context.project.runtime_environment.hardware.cpu_model = cpu_model
builder_context.project.runtime_environment.hardware.cpu_family = cpu_family
builder_context.project.runtime_environment.platform = platform
assert builder_context.is_adviser_pipeline() or builder_context.is_dependency_monkey_pipeline()
assert IntelTensorFlowWrap.should_include(builder_context) is None
