def _get_version(
self, etc_os_release: typing.Mapping[str, str],
fs: boot_inspect.system.filesystems.Filesystem) -> model.Version:
systemd_version, legacy_version = model.Version(''), model.Version('')
if 'VERSION_ID' in etc_os_release:
systemd_version = model.Version.split(etc_os_release['VERSION_ID'])
if self._legacy_version_reader:
legacy_version = self._legacy_version_reader.get_version(fs)
if legacy_version:
legacy_version = model.Version.split(legacy_version)
# The assumption here is that the longer string is better.
# For an example, look at test-data/docker-image-debian:8.8.yaml.
# In /etc/os-release, the version is '8', while in /etc/debian_version
# the version is 8.8.
if str(systemd_version) > str(legacy_version):
return systemd_version
return legacy_version
def test_yaml_encoded_cases(fpath):
with open(fpath) as stream:
loaded_yaml = yaml.safe_load(stream)
assert 'files' in loaded_yaml
assert 'expected' in loaded_yaml
fs = filesystems.DictBackedFilesystem(loaded_yaml['files'])
expected = model.OperatingSystem(
model.distro_for(loaded_yaml['expected']['distro']),
model.Version(loaded_yaml['expected']['major'],
loaded_yaml['expected']['minor']))
inspector = inspection._linux_inspector(fs)
actual = inspector.inspect()
assert expected == actual
def _from_nt_version(variant: str, major_nt: int, minor_nt: int,
product_name: str) -> model.OperatingSystem:
major, minor = None, None
nt_version = major_nt, minor_nt
if _client_pattern.search(variant):
major, minor = _client_versions.get(nt_version, (None, None))
elif _server_pattern.search(variant):
if nt_version in _server_versions:
major, minor = _server_versions.get(nt_version, (None, None))
elif nt_version == (10, 0):
if '2016' in product_name:
major, minor = '2016', ''
elif '2019' in product_name:
major, minor = '2019', ''
if major is not None and minor is not None:
return model.OperatingSystem(model.Distro.WINDOWS,
model.Version(major, minor))
def test_allow_empty_minor_version(self):
inspection_results = model.InspectionResults(
device="/dev/sdb",
os=model.OperatingSystem(
distro=model.Distro.UBUNTU,
version=model.Version(major="14", ),
),
architecture=model.Architecture.x64,
)
expected = {
"device": "/dev/sdb",
"os": {
"distro": "ubuntu",
"version": {
"major": "14",
"minor": "",
}
},
"architecture": "x64",
}
actual = json.dumps(inspection_results, cls=model.ModelJSONEncoder)
assert expected == json.loads(actual)
def test_happy_case(self):
inspection_results = model.InspectionResults(
device="/dev/sdb",
os=model.OperatingSystem(
distro=model.Distro.WINDOWS,
version=model.Version(major="8", minor="1"),
),
architecture=model.Architecture.x86,
)
expected = {
"device": "/dev/sdb",
"os": {
"distro": "windows",
"version": {
"major": "8",
"minor": "1",
}
},
"architecture": "x86",
}
actual = json.dumps(inspection_results, cls=model.ModelJSONEncoder)
assert expected == json.loads(actual)
def _get_version(self) -> model.Version: major = self._g.inspect_get_major_version(self._root) minor = self._g.inspect_get_minor_version(self._root) return model.Version(major, minor)
def test_to_string__empty_when_version_empty(self):
assert "" == str(model.Version(""))
def test_to_string__omits_period_when_only_major(self):
assert "15" == str(model.Version("15"))
def test_to_string__happy_case(self):
assert "15.04", str(model.Version("15", "04"))
assert "2008.3", str(model.Version("2008", "3"))
def test_split_allows_non_period(self):
assert model.Version("fuzzy/fossa", "") == \
model.Version.split("fuzzy/fossa")
assert "fuzzy/fossa" == str(model.Version.split("fuzzy/fossa"))
def test_split_empty_input(self):
assert model.Version("", "") == model.Version.split("")
def test_split_happy_case(self):
assert model.Version("14", "04") == model.Version.split("14.04")
assert model.Version("2008", "3") == model.Version.split("2008.3")
assert model.Version("15", "") == model.Version.split("15")
def windows(major, minor=''):
return model.OperatingSystem(distro=model.Distro.WINDOWS,
version=model.Version(major, minor))
