def test_build_status_ne_by_status(build_status_failed: BuildStatus) -> None:
"""
must be not equal by status
"""
other = BuildStatus.from_json(build_status_failed.view())
other.status = BuildStatusEnum.Success
assert build_status_failed != other
def test_build_status_ne_by_timestamp(
build_status_failed: BuildStatus) -> None:
"""
must be not equal by timestamp
"""
other = BuildStatus.from_json(build_status_failed.view())
other.timestamp = datetime.datetime.utcnow().timestamp()
assert build_status_failed != other
def test_build_status_init_1() -> None:
"""
must construct status object from None
"""
status = BuildStatus()
assert status.status == BuildStatusEnum.Unknown
assert status.timestamp > 0
def test_get(watcher: Watcher, package_ahriman: Package) -> None:
"""
must return package status
"""
watcher.known = {package_ahriman.base: (package_ahriman, BuildStatus())}
package, status = watcher.get(package_ahriman.base)
assert package == package_ahriman
assert status.status == BuildStatusEnum.Unknown
def get_self(self) -> BuildStatus:
"""
get ahriman status itself
:return: current ahriman status
"""
try:
response = requests.get(self._ahriman_url())
response.raise_for_status()
status_json = response.json()
return BuildStatus.from_json(status_json)
except requests.exceptions.HTTPError as e:
self.logger.exception(
f"could not get service status: {exception_response_text(e)}")
except Exception:
self.logger.exception("could not get service status")
return BuildStatus()
async def test_get(client: TestClient) -> None:
"""
must return valid service status
"""
response = await client.get("/api/v1/ahriman")
status = BuildStatus.from_json(await response.json())
assert response.status == 200
assert status.status == BuildStatusEnum.Unknown
def test_counters_from_packages(package_ahriman: Package,
package_python_schedule: Package) -> None:
"""
must construct object from list of packages with their statuses
"""
payload = [
(package_ahriman, BuildStatus(status=BuildStatusEnum.Success)),
(package_python_schedule, BuildStatus(status=BuildStatusEnum.Failed)),
]
counters = Counters.from_packages(payload)
assert counters.total == 2
assert counters.success == 1
assert counters.failed == 1
json = asdict(counters)
total = json.pop("total")
assert total == sum(i for i in json.values())
def test_cache_save(watcher: Watcher, package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must save state to cache
"""
mocker.patch("pathlib.Path.open")
json_mock = mocker.patch("json.dump")
watcher.known = {package_ahriman.base: (package_ahriman, BuildStatus())}
watcher._cache_save()
json_mock.assert_called_once()
def test_remove(watcher: Watcher, package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must remove package base
"""
cache_mock = mocker.patch(
"ahriman.core.status.watcher.Watcher._cache_save")
watcher.known = {package_ahriman.base: (package_ahriman, BuildStatus())}
watcher.remove(package_ahriman.base)
assert not watcher.known
cache_mock.assert_called_once()
def load(self) -> None:
"""
load packages from local repository. In case if last status is known, it will use it
"""
for package in self.repository.packages():
# get status of build or assign unknown
current = self.known.get(package.base)
if current is None:
status = BuildStatus()
else:
_, status = current
self.known[package.base] = (package, status)
self._cache_load()
def test_run_with_package_filter(args: argparse.Namespace, configuration: Configuration, package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must run command
"""
args = _default_args(args)
args.package = [package_ahriman.base]
mocker.patch("pathlib.Path.mkdir")
packages_mock = mocker.patch("ahriman.core.status.client.Client.get",
return_value=[(package_ahriman, BuildStatus())])
Status.run(args, "x86_64", configuration)
packages_mock.assert_called_once()
def test_get_self(web_client: WebClient, mocker: MockerFixture) -> None:
"""
must return service status
"""
response_obj = Response()
response_obj._content = json.dumps(BuildStatus().view()).encode("utf8")
response_obj.status_code = 200
requests_mock = mocker.patch("requests.get", return_value=response_obj)
result = web_client.get_self()
requests_mock.assert_called_once()
assert result.status == BuildStatusEnum.Unknown
async def test_post(client: TestClient) -> None:
"""
must update service status correctly
"""
payload = {"status": BuildStatusEnum.Success.value}
post_response = await client.post("/api/v1/ahriman", json=payload)
assert post_response.status == 204
response = await client.get("/api/v1/ahriman")
status = BuildStatus.from_json(await response.json())
assert response.status == 200
assert status.status == BuildStatusEnum.Success
def __init__(self, architecture: str,
configuration: Configuration) -> None:
"""
default constructor
:param architecture: repository architecture
:param configuration: configuration instance
"""
self.logger = logging.getLogger("http")
self.architecture = architecture
self.repository = Repository(architecture, configuration)
self.known: Dict[str, Tuple[Package, BuildStatus]] = {}
self.status = BuildStatus()
def test_update_ping(watcher: Watcher, package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must update package status only for known package
"""
cache_mock = mocker.patch(
"ahriman.core.status.watcher.Watcher._cache_save")
watcher.known = {package_ahriman.base: (package_ahriman, BuildStatus())}
watcher.update(package_ahriman.base, BuildStatusEnum.Success, None)
cache_mock.assert_called_once()
package, status = watcher.known[package_ahriman.base]
assert package == package_ahriman
assert status.status == BuildStatusEnum.Success
def update(self, base: str, status: BuildStatusEnum,
package: Optional[Package]) -> None:
"""
update package status and description
:param base: package base to update
:param status: new build status
:param package: optional new package description. In case if not set current properties will be used
"""
if package is None:
try:
package, _ = self.known[base]
except KeyError:
raise UnknownPackage(base)
full_status = BuildStatus(status)
self.known[base] = (package, full_status)
self._cache_save()
def test_load_known(watcher: Watcher, package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must correctly load packages with known statuses
"""
mocker.patch("ahriman.core.repository.repository.Repository.packages",
return_value=[package_ahriman])
mocker.patch("ahriman.core.status.watcher.Watcher._cache_load")
watcher.known = {
package_ahriman.base:
(package_ahriman, BuildStatus(BuildStatusEnum.Success))
}
watcher.load()
_, status = watcher.known[package_ahriman.base]
assert status.status == BuildStatusEnum.Success
def test_cache_save_load(watcher: Watcher, package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must save state to cache which can be loaded later
"""
dump_file = Path(tempfile.mktemp())
mocker.patch("ahriman.core.status.watcher.Watcher.cache_path",
new_callable=PropertyMock,
return_value=dump_file)
known_current = {package_ahriman.base: (package_ahriman, BuildStatus())}
watcher.known = known_current
watcher._cache_save()
watcher.known = {package_ahriman.base: (None, None)}
watcher._cache_load()
assert watcher.known == known_current
dump_file.unlink()
def get(self, base: Optional[str]) -> List[Tuple[Package, BuildStatus]]:
"""
get package status
:param base: package base to get
:return: list of current package description and status if it has been found
"""
try:
response = requests.get(self._package_url(base or ""))
response.raise_for_status()
status_json = response.json()
return [(Package.from_json(package["package"]),
BuildStatus.from_json(package["status"]))
for package in status_json]
except requests.exceptions.HTTPError as e:
self.logger.exception(
f"could not get {base}: {exception_response_text(e)}")
except Exception:
self.logger.exception(f"could not get {base}")
return []
def test_build_status_repr(build_status_failed: BuildStatus) -> None:
"""
must return string in __repr__ function
"""
assert build_status_failed.__repr__()
assert isinstance(build_status_failed.__repr__(), str)
def parse_single(properties: Dict[str, Any]) -> None:
package = Package.from_json(properties["package"])
status = BuildStatus.from_json(properties["status"])
if package.base in self.known:
self.known[package.base] = (package, status)
def test_build_status_eq(build_status_failed: BuildStatus) -> None:
"""
must be equal
"""
other = BuildStatus.from_json(build_status_failed.view())
assert other == build_status_failed
def build_status_failed() -> BuildStatus:
return BuildStatus(BuildStatusEnum.Failed, 42)
def test_build_status_init_2(build_status_failed: BuildStatus) -> None:
"""
must construct status object from objects
"""
status = BuildStatus(BuildStatusEnum.Failed, 42)
assert status == build_status_failed
def update_self(self, status: BuildStatusEnum) -> None:
"""
update service status
:param status: new service status
"""
self.status = BuildStatus(status)
def get_package_status_extended(package: Package) -> Dict[str, Any]:
return {"status": BuildStatus().view(), "package": package.view()}
def test_build_status_from_json_view(build_status_failed: BuildStatus) -> None:
"""
must construct same object from json
"""
assert BuildStatus.from_json(
build_status_failed.view()) == build_status_failed
def get_self(self) -> BuildStatus:
"""
get ahriman status itself
:return: current ahriman status
"""
return BuildStatus()
def test_build_status_pretty_print(build_status_failed: BuildStatus) -> None:
"""
must return string in pretty print function
"""
assert build_status_failed.pretty_print()
assert isinstance(build_status_failed.pretty_print(), str)
