Release 0.21.2

add changelog generator to both gh-actions and repository
Release 0.21.1
2025-06-27 14:22:10 +00:00 · 2021-04-05 02:01:28 +03:00 · 2021-04-05 02:00:05 +03:00 · 2021-04-05 00:45:12 +03:00 · 2021-04-05 00:44:39 +03:00 · 2021-04-05 00:38:23 +03:00
69 changed files with 1154 additions and 304 deletions
--- a/.github/ISSUE_TEMPLATE/bug-report.md
+++ b/.github/ISSUE_TEMPLATE/bug-report.md
--- a/.github/ISSUE_TEMPLATE/feature-request.md
+++ b/.github/ISSUE_TEMPLATE/feature-request.md
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@ -0,0 +1,37 @@
+name: create release
+
+on:
+  push:
+    tags:
+      - '*.*.*'
+
+jobs:
+  make-release:
+
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: extract version
+        id: version
+        run: echo ::set-output name=VERSION::${GITHUB_REF#refs/tags/}
+      - name: create changelog
+        id: changelog
+        uses: jaywcjlove/changelog-generator@main
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          filter: '[R|r]elease[d]\s+[v|V]\d(\.\d+){0,2}'
+      - name: create archive
+        run: make archive
+        env:
+          VERSION: ${{ steps.version.outputs.VERSION }}
+      - name: Release
+        uses: softprops/action-gh-release@v1
+        with:
+          body: |
+            ${{ steps.changelog.outputs.compareurl }}
+            ${{ steps.changelog.outputs.changelog }}
+          files: ahriman-*-src.tar.xz
+          fail_on_unmatched_files: true
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
--- a/.github/workflows/python-app.yml
+++ b/.github/workflows/python-app.yml
@ -1,6 +1,5 @@
 # based on https://github.com/actions/starter-workflows/blob/main/ci/python-app.yml
-
-name: ahriman
+name: check commit

 on:
  push:
@ -9,7 +8,7 @@ on:
    branches: [ master ]

 jobs:
-  build:
+  run-tests:

    runs-on: ubuntu-latest

--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -0,0 +1,126 @@
+# Changelog
+
+## [0.21.1](https://github.com/arcan1s/ahriman/tree/0.21.1) (2021-04-04)
+
+[Full Changelog](https://github.com/arcan1s/ahriman/compare/0.21.0...0.21.1)
+
+## [0.21.0](https://github.com/arcan1s/ahriman/tree/0.21.0) (2021-04-04)
+
+[Full Changelog](https://github.com/arcan1s/ahriman/compare/0.20.0...0.21.0)
+
+## [0.20.0](https://github.com/arcan1s/ahriman/tree/0.20.0) (2021-03-31)
+
+[Full Changelog](https://github.com/arcan1s/ahriman/compare/0.19.0...0.20.0)
+
+## [0.19.0](https://github.com/arcan1s/ahriman/tree/0.19.0) (2021-03-30)
+
+[Full Changelog](https://github.com/arcan1s/ahriman/compare/0.18.0...0.19.0)
+
+## [0.18.0](https://github.com/arcan1s/ahriman/tree/0.18.0) (2021-03-29)
+
+[Full Changelog](https://github.com/arcan1s/ahriman/compare/0.17.0...0.18.0)
+
+## [0.17.0](https://github.com/arcan1s/ahriman/tree/0.17.0) (2021-03-29)
+
+[Full Changelog](https://github.com/arcan1s/ahriman/compare/0.16.0...0.17.0)
+
+**Implemented enhancements:**
+
+- Sign command [\#7](https://github.com/arcan1s/ahriman/issues/7)
+- Provide extended setup help command [\#6](https://github.com/arcan1s/ahriman/issues/6)
+
+**Merged pull requests:**
+
+- Setup command [\#9](https://github.com/arcan1s/ahriman/pull/9) ([arcan1s](https://github.com/arcan1s))
+- add sign command [\#8](https://github.com/arcan1s/ahriman/pull/8) ([arcan1s](https://github.com/arcan1s))
+
+## [0.16.0](https://github.com/arcan1s/ahriman/tree/0.16.0) (2021-03-28)
+
+[Full Changelog](https://github.com/arcan1s/ahriman/compare/0.15.0...0.16.0)
+
+**Implemented enhancements:**
+
+- Review unsafe option [\#4](https://github.com/arcan1s/ahriman/issues/4)
+- Split functions class to module package [\#3](https://github.com/arcan1s/ahriman/issues/3)
+- Import from another repository [\#2](https://github.com/arcan1s/ahriman/issues/2)
+- Tests [\#1](https://github.com/arcan1s/ahriman/issues/1)
+
+**Merged pull requests:**
+
+- Add tests \(\#1\) [\#5](https://github.com/arcan1s/ahriman/pull/5) ([arcan1s](https://github.com/arcan1s))
+
+## [0.15.0](https://github.com/arcan1s/ahriman/tree/0.15.0) (2021-03-20)
+
+[Full Changelog](https://github.com/arcan1s/ahriman/compare/0.14.1...0.15.0)
+
+## [0.14.1](https://github.com/arcan1s/ahriman/tree/0.14.1) (2021-03-17)
+
+[Full Changelog](https://github.com/arcan1s/ahriman/compare/0.14.0...0.14.1)
+
+## [0.14.0](https://github.com/arcan1s/ahriman/tree/0.14.0) (2021-03-16)
+
+[Full Changelog](https://github.com/arcan1s/ahriman/compare/0.13.0...0.14.0)
+
+## [0.13.0](https://github.com/arcan1s/ahriman/tree/0.13.0) (2021-03-15)
+
+[Full Changelog](https://github.com/arcan1s/ahriman/compare/0.12.2...0.13.0)
+
+## [0.12.2](https://github.com/arcan1s/ahriman/tree/0.12.2) (2021-03-15)
+
+[Full Changelog](https://github.com/arcan1s/ahriman/compare/0.12.1...0.12.2)
+
+## [0.12.1](https://github.com/arcan1s/ahriman/tree/0.12.1) (2021-03-15)
+
+[Full Changelog](https://github.com/arcan1s/ahriman/compare/0.12.0...0.12.1)
+
+## [0.12.0](https://github.com/arcan1s/ahriman/tree/0.12.0) (2021-03-15)
+
+[Full Changelog](https://github.com/arcan1s/ahriman/compare/0.11.7...0.12.0)
+
+## [0.11.7](https://github.com/arcan1s/ahriman/tree/0.11.7) (2021-03-14)
+
+[Full Changelog](https://github.com/arcan1s/ahriman/compare/0.11.6...0.11.7)
+
+## [0.11.6](https://github.com/arcan1s/ahriman/tree/0.11.6) (2021-03-13)
+
+[Full Changelog](https://github.com/arcan1s/ahriman/compare/0.11.5...0.11.6)
+
+## [0.11.5](https://github.com/arcan1s/ahriman/tree/0.11.5) (2021-03-13)
+
+[Full Changelog](https://github.com/arcan1s/ahriman/compare/0.11.4...0.11.5)
+
+## [0.11.4](https://github.com/arcan1s/ahriman/tree/0.11.4) (2021-03-13)
+
+[Full Changelog](https://github.com/arcan1s/ahriman/compare/0.11.3...0.11.4)
+
+## [0.11.3](https://github.com/arcan1s/ahriman/tree/0.11.3) (2021-03-12)
+
+[Full Changelog](https://github.com/arcan1s/ahriman/compare/0.11.2...0.11.3)
+
+## [0.11.2](https://github.com/arcan1s/ahriman/tree/0.11.2) (2021-03-12)
+
+[Full Changelog](https://github.com/arcan1s/ahriman/compare/0.11.1...0.11.2)
+
+## [0.11.1](https://github.com/arcan1s/ahriman/tree/0.11.1) (2021-03-11)
+
+[Full Changelog](https://github.com/arcan1s/ahriman/compare/0.11.0...0.11.1)
+
+## [0.11.0](https://github.com/arcan1s/ahriman/tree/0.11.0) (2021-03-11)
+
+[Full Changelog](https://github.com/arcan1s/ahriman/compare/0.10.0...0.11.0)
+
+## [0.10.0](https://github.com/arcan1s/ahriman/tree/0.10.0) (2021-03-10)
+
+[Full Changelog](https://github.com/arcan1s/ahriman/compare/0.9.1...0.10.0)
+
+## [0.9.1](https://github.com/arcan1s/ahriman/tree/0.9.1) (2021-03-09)
+
+[Full Changelog](https://github.com/arcan1s/ahriman/compare/0.9.0...0.9.1)
+
+## [0.9.0](https://github.com/arcan1s/ahriman/tree/0.9.0) (2021-03-08)
+
+[Full Changelog](https://github.com/arcan1s/ahriman/compare/53d21d6496ab902b664a678a2f2d3a7f4e96d8d1...0.9.0)
+
+
+
+\* *This Changelog was automatically generated by [github_changelog_generator](https://github.com/github-changelog-generator/github-changelog-generator)*
--- a/CONFIGURING.md
+++ b/CONFIGURING.md
@ -1,6 +1,6 @@
 # ahriman configuration

-Some groups can be specified for each architecture separately. E.g. if there are `build` and `build_x86_64` groups it will use the option from `build_x86_64` for the `x86_64` architecture and `build` for any other (architecture specific group has higher priority). In case if both groups are presented, architecture specific options will be merged into global ones overriding them. 
+Some groups can be specified for each architecture separately. E.g. if there are `build` and `build:x86_64` groups it will use the option from `build:x86_64` for the `x86_64` architecture and `build` for any other (architecture specific group has higher priority). In case if both groups are presented, architecture specific options will be merged into global ones overriding them. 

 ## `settings` group

@ -18,9 +18,9 @@ libalpm and AUR related configuration.
 * `repositories` - list of pacman repositories, space separated list of strings, required.
 * `root` - root for alpm library, string, required.

-## `build_*` groups
+## `build:*` groups

-Build related configuration. Group name must refer to architecture, e.g. it should be `build_x86_64` for x86_64 architecture.
+Build related configuration. Group name must refer to architecture, e.g. it should be `build:x86_64` for x86_64 architecture.

 * `archbuild_flags` - additional flags passed to `archbuild` command, space separated list of strings, optional.
 * `build_command` - default build command, string, required.
@ -35,9 +35,9 @@ Base repository settings.
 * `name` - repository name, string, required.
 * `root` - root path for application, string, required.

-## `sign_*` groups
+## `sign:*` groups

-Settings for signing packages or repository. Group name must refer to architecture, e.g. it should be `sign_x86_64` for x86_64 architecture.
+Settings for signing packages or repository. Group name must refer to architecture, e.g. it should be `sign:x86_64` for x86_64 architecture.

 * `target` - configuration flag to enable signing, space separated list of strings, required. Allowed values are `package` (sign each package separately), `repository` (sign repository database file).
 * `key` - default PGP key, string, required. This key will also be used for database signing if enabled.
@ -49,9 +49,9 @@ Report generation settings.

 * `target` - list of reports to be generated, space separated list of strings, optional. Allowed values are `html`.

-### `html_*` groups
+### `html:*` groups

-Group name must refer to architecture, e.g. it should be `html_x86_64` for x86_64 architecture.
+Group name must refer to architecture, e.g. it should be `html:x86_64` for x86_64 architecture.

 * `path` - path to html report file, string, required.
 * `homepage` - link to homepage, string, optional.
@ -64,23 +64,23 @@ Remote synchronization settings.

 * `target` - list of synchronizations to be used, space separated list of strings, optional. Allowed values are `rsync`, `s3`.

-### `rsync_*` groups
+### `rsync:*` groups

-Group name must refer to architecture, e.g. it should be `rsync_x86_64` for x86_64 architecture. Requires `rsync` package to be installed. Do not forget to configure ssh for user `ahriman`.
+Group name must refer to architecture, e.g. it should be `rsync:x86_64` for x86_64 architecture. Requires `rsync` package to be installed. Do not forget to configure ssh for user `ahriman`.

 * `command` - rsync command to run, space separated list of string, required.
 * `remote` - remote server to rsync (e.g. `1.2.3.4:5678:path/to/sync`), string, required.

-### `s3_*` groups
+### `s3:*` groups

-Group name must refer to architecture, e.g. it should be `s3_x86_64` for x86_64 architecture. Requires `aws-cli` package to be installed. Do not forget to configure it for user `ahriman`.
+Group name must refer to architecture, e.g. it should be `s3:x86_64` for x86_64 architecture. Requires `aws-cli` package to be installed. Do not forget to configure it for user `ahriman`.

 * `command` - s3 command to run, space separated list of string, required.
 * `bucket` - bucket name (e.g. `s3://bucket/path`), string, required.

-## `web_*` groups
+## `web:*` groups

-Web server settings. If any of `host`/`port` is not set, web integration will be disabled. Group name must refer to architecture, e.g. it should be `web_x86_64` for x86_64 architecture.
+Web server settings. If any of `host`/`port` is not set, web integration will be disabled. Group name must refer to architecture, e.g. it should be `web:x86_64` for x86_64 architecture.

 * `host` - host to bind, string, optional.
 * `port` - port to bind, int, optional.
--- a/14
+++ b/14
@ -1,9 +1,9 @@
-.PHONY: archive archive_directory archlinux check clean directory push tests version
+.PHONY: archive archive_directory archlinux changelog check clean directory push tests version
 .DEFAULT_GOAL := archlinux

 PROJECT := ahriman

-FILES := AUTHORS COPYING CONFIGURING.md README.md package src setup.py
+FILES := AUTHORS CHANGELOG.md COPYING CONFIGURING.md README.md package src setup.py
 TARGET_FILES := $(addprefix $(PROJECT)/, $(FILES))
 IGNORE_FILES := package/archlinux src/.mypy_cache

@ -24,6 +24,12 @@ archlinux: archive
 	sed -i "/sha512sums=('[0-9A-Fa-f]*/s/[^'][^)]*/sha512sums=('$$(sha512sum $(PROJECT)-$(VERSION)-src.tar.xz | awk '{print $$1}')'/" package/archlinux/PKGBUILD
 	sed -i "s/pkgver=[0-9.]*/pkgver=$(VERSION)/" package/archlinux/PKGBUILD

+changelog:
+ifndef GITHUB_TOKEN
+	$(error GITHUB_TOKEN is required, but not set)
+endif
+	docker run -it --rm -v "$(pwd)":/usr/local/src/your-app ferrarimarco/github-changelog-generator -u arcan1s -p ahriman -t $(GITHUB_TOKEN)
+
 check: clean
 	cd src && mypy --implicit-reexport --strict -p "$(PROJECT)"
 	find "src/$(PROJECT)" tests -name "*.py" -execdir autopep8 --exit-code --max-line-length 120 -aa -i {} +
@ -36,8 +42,8 @@ clean:
 directory: clean
 	mkdir "$(PROJECT)"

-push: archlinux
-	git add package/archlinux/PKGBUILD src/ahriman/version.py
+push: archlinux changelog
+	git add package/archlinux/PKGBUILD src/ahriman/version.py CHANGELOG.md
 	git commit -m "Release $(VERSION)"
 	git push
 	git tag "$(VERSION)"
--- a/package/archlinux/PKGBUILD
+++ b/package/archlinux/PKGBUILD
@ -1,7 +1,7 @@
 # Maintainer: Evgeniy Alekseev

 pkgname='ahriman'
-pkgver=0.19.0
+pkgver=0.21.2
 pkgrel=1
 pkgdesc="ArcHlinux ReposItory MANager"
 arch=('any')
@ -23,7 +23,7 @@ optdepends=('aws-cli: sync to s3'
 source=("https://github.com/arcan1s/ahriman/releases/download/$pkgver/$pkgname-$pkgver-src.tar.xz"
        'ahriman.sysusers'
        'ahriman.tmpfiles')
-sha512sums=('af644c52c990268f1190632ccd514f351283d5578b161aebd2819d02e9d6a041571d50fe54ca03568bdabecca2e0492222b1a88bffef6bc0eab4e7460193df61'
+sha512sums=('6ab741bfb42f92ab00d1b6ecfc44426c00e5c433486e014efbdb585715d9a12dbbafc280e5a9f85b941c8681b13a9dad41327a3e3c44a9683ae30c1d6f017f50'
            '13718afec2c6786a18f0b223ef8e58dccf0688bca4cdbe203f14071f5031ed20120eb0ce38b52c76cfd6e8b6581a9c9eaa2743eb11abbaca637451a84c33f075'
            '55b20f6da3d66e7bbf2add5d95a3b60632df121717d25a993e56e737d14f51fe063eb6f1b38bd81cc32e05db01c0c1d80aaa720c45cde87f238d8b46cdb8cbc4')
 backup=('etc/ahriman.ini'
--- a/package/etc/ahriman.ini
+++ b/package/etc/ahriman.ini
@ -41,4 +41,5 @@ command = rsync --archive --verbose --compress --partial --delete
 command = aws s3 sync --quiet --delete

 [web]
+host = 0.0.0.0
 templates = /usr/share/ahriman
--- a/setup.cfg
+++ b/setup.cfg
@ -2,4 +2,4 @@
 test = pytest

 [tool:pytest]
-addopts = --cov=ahriman --pspec
+addopts = --cov=ahriman --cov-report term-missing:skip-covered --pspec
--- a/src/ahriman/application/ahriman.py
+++ b/src/ahriman/application/ahriman.py
@ -20,10 +20,13 @@
 import argparse
 import sys

+from pathlib import Path
+
 import ahriman.application.handlers as handlers
 import ahriman.version as version

 from ahriman.models.build_status import BuildStatusEnum
+from ahriman.models.sign_settings import SignSettings


 # pylint thinks it is bad idea, but get the fuck off
@ -40,9 +43,9 @@ def _parser() -> argparse.ArgumentParser:
                                     formatter_class=argparse.ArgumentDefaultsHelpFormatter)
    parser.add_argument("-a", "--architecture", help="target architectures (can be used multiple times)",
                        action="append", required=True)
-    parser.add_argument("-c", "--configuration", help="configuration path", default="/etc/ahriman.ini")
+    parser.add_argument("-c", "--configuration", help="configuration path", type=Path, default=Path("/etc/ahriman.ini"))
    parser.add_argument("--force", help="force run, remove file lock", action="store_true")
-    parser.add_argument("--lock", help="lock file", default="/tmp/ahriman.lock")
+    parser.add_argument("-l", "--lock", help="lock file", type=Path, default=Path("/tmp/ahriman.lock"))
    parser.add_argument("--no-log", help="redirect all log messages to stderr", action="store_true")
    parser.add_argument("--no-report", help="force disable reporting to web service", action="store_true")
    parser.add_argument("--unsafe", help="allow to run ahriman as non-ahriman user", action="store_true")
@ -136,6 +139,7 @@ def _set_rebuild_parser(root: SubParserAction) -> argparse.ArgumentParser:
    """
    parser = root.add_parser("rebuild", help="rebuild repository", description="rebuild whole repository",
                             formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    parser.add_argument("--depends-on", help="only rebuild packages that depend on specified package")
    parser.set_defaults(handler=handlers.Rebuild)
    return parser

@ -177,10 +181,14 @@ def _set_setup_parser(root: SubParserAction) -> argparse.ArgumentParser:
                             formatter_class=argparse.ArgumentDefaultsHelpFormatter)
    parser.add_argument("--build-command", help="build command prefix", default="ahriman")
    parser.add_argument("--from-configuration", help="path to default devtools pacman configuration",
-                        default="/usr/share/devtools/pacman-extra.conf")
+                        type=Path, default=Path("/usr/share/devtools/pacman-extra.conf"))
    parser.add_argument("--no-multilib", help="do not add multilib repository", action="store_true")
    parser.add_argument("--packager", help="packager name and email", required=True)
-    parser.add_argument("--repository", help="repository name", default="aur-clone")
+    parser.add_argument("--repository", help="repository name", required=True)
+    parser.add_argument("--sign-key", help="sign key id")
+    parser.add_argument("--sign-target", help="sign options", type=SignSettings.from_option,
+                        choices=SignSettings, nargs="*")
+    parser.add_argument("--web-port", help="port of the web service", type=int)
    parser.set_defaults(handler=handlers.Setup, lock=None, no_report=True, unsafe=True)
    return parser

@ -224,8 +232,9 @@ def _set_status_update_parser(root: SubParserAction) -> argparse.ArgumentParser:
        "package",
        help="set status for specified packages. If no packages supplied, service status will be updated",
        nargs="*")
-    parser.add_argument("--status", help="new status", choices=[value.value for value in BuildStatusEnum],
-                        default="success")
+    parser.add_argument("--status", help="new status", choices=BuildStatusEnum,
+                        type=BuildStatusEnum, default=BuildStatusEnum.Success)
+    parser.add_argument("--remove", help="remove package status page", action="store_true")
    parser.set_defaults(handler=handlers.StatusUpdate, lock=None, no_report=True, unsafe=True)
    return parser

@ -272,11 +281,18 @@ def _set_web_parser(root: SubParserAction) -> argparse.ArgumentParser:
    return parser


-if __name__ == "__main__":
-    args_parser = _parser()
-    args = args_parser.parse_args()
+def run() -> None:
+    """
+    run application instance
+    """
+    if __name__ == "__main__":
+        args_parser = _parser()
+        args = args_parser.parse_args()

-    handler: handlers.Handler = args.handler
-    status = handler.execute(args)
+        handler: handlers.Handler = args.handler
+        status = handler.execute(args)

-    sys.exit(status)
+        sys.exit(status)
+
+
+run()
--- a/src/ahriman/application/application.py
+++ b/src/ahriman/application/application.py
@ -51,6 +51,13 @@ class Application:
        self.architecture = architecture
        self.repository = Repository(architecture, configuration)

+    def _finalize(self) -> None:
+        """
+        generate report and sync to remote server
+        """
+        self.report([])
+        self.sync([])
+
    def _known_packages(self) -> Set[str]:
        """
        load packages from repository and pacman repositories
@ -63,13 +70,6 @@ class Application:
        known_packages.update(self.repository.pacman.all_packages())
        return known_packages

-    def _finalize(self) -> None:
-        """
-        generate report and sync to remote server
-        """
-        self.report([])
-        self.sync([])
-
    def get_updates(self, filter_packages: List[str], no_aur: bool, no_manual: bool, no_vcs: bool,
                    log_fn: Callable[[str], None]) -> List[Package]:
        """
@ -182,6 +182,7 @@ class Application:
                continue
            for archive in package.packages.values():
                if archive.filepath is None:
+                    self.logger.warning(f"filepath is empty for {package.base}")
                    continue  # avoid mypy warning
                src = self.repository.paths.repository / archive.filepath
                dst = self.repository.paths.packages / archive.filepath
--- a/src/ahriman/application/handlers/rebuild.py
+++ b/src/ahriman/application/handlers/rebuild.py
@ -40,5 +40,9 @@ class Rebuild(Handler):
        :param configuration: configuration instance
        """
        application = Application(architecture, configuration)
-        packages = application.repository.packages()
+        packages = [
+            package
+            for package in application.repository.packages()
+            if args.depends_on is None or args.depends_on in package.depends
+        ]  # we have to use explicit list here for testing purpose
        application.update(packages)
--- a/src/ahriman/application/handlers/setup.py
+++ b/src/ahriman/application/handlers/setup.py
@ -54,9 +54,9 @@ class Setup(Handler):
        application = Application(architecture, configuration)
        Setup.create_makepkg_configuration(args.packager, application.repository.paths)
        Setup.create_executable(args.build_command, architecture)
-        Setup.create_devtools_configuration(args.build_command, architecture, Path(args.from_configuration),
+        Setup.create_devtools_configuration(args.build_command, architecture, args.from_configuration,
                                            args.no_multilib, args.repository, application.repository.paths)
-        Setup.create_ahriman_configuration(args.build_command, architecture, args.repository, configuration.include)
+        Setup.create_ahriman_configuration(args, architecture, args.repository, configuration.include)
        Setup.create_sudo_configuration(args.build_command, architecture)

    @staticmethod
@ -70,23 +70,36 @@ class Setup(Handler):
        return Setup.BIN_DIR_PATH / f"{prefix}-{architecture}-build"

    @staticmethod
-    def create_ahriman_configuration(prefix: str, architecture: str, repository: str, include_path: Path) -> None:
+    def create_ahriman_configuration(args: argparse.Namespace, architecture: str, repository: str,
+                                     include_path: Path) -> None:
        """
        create service specific configuration
-        :param prefix: command prefix in {prefix}-{architecture}-build
+        :param args: command line args
        :param architecture: repository architecture
        :param repository: repository name
        :param include_path: path to directory with configuration includes
        """
        configuration = configparser.ConfigParser()

-        configuration.add_section("build")
-        configuration.set("build", "build_command", str(Setup.build_command(prefix, architecture)))
+        section = Configuration.section_name("build", architecture)
+        configuration.add_section(section)
+        configuration.set(section, "build_command", str(Setup.build_command(args.build_command, architecture)))

        configuration.add_section("repository")
        configuration.set("repository", "name", repository)

-        target = include_path / "build-overrides.ini"
+        if args.sign_key is not None:
+            section = Configuration.section_name("sign", architecture)
+            configuration.add_section(section)
+            configuration.set(section, "target", " ".join([target.name.lower() for target in args.sign_target]))
+            configuration.set(section, "key", args.sign_key)
+
+        if args.web_port is not None:
+            section = Configuration.section_name("web", architecture)
+            configuration.add_section(section)
+            configuration.set(section, "port", str(args.web_port))
+
+        target = include_path / "setup-overrides.ini"
        with target.open("w") as ahriman_configuration:
            configuration.write(ahriman_configuration)

--- a/src/ahriman/application/handlers/status_update.py
+++ b/src/ahriman/application/handlers/status_update.py
@ -19,12 +19,11 @@
 #
 import argparse

-from typing import Type
+from typing import Callable, Type

 from ahriman.application.application import Application
 from ahriman.application.handlers.handler import Handler
 from ahriman.core.configuration import Configuration
-from ahriman.models.build_status import BuildStatusEnum


 class StatusUpdate(Handler):
@ -41,11 +40,11 @@ class StatusUpdate(Handler):
        :param configuration: configuration instance
        """
        client = Application(architecture, configuration).repository.reporter
-        status = BuildStatusEnum(args.status)
+        callback: Callable[[str], None] = lambda p: client.remove(p) if args.remove else client.update(p, args.status)
        if args.package:
            # update packages statuses
            for package in args.package:
-                client.update(package, status)
+                callback(package)
        else:
            # update service status
-            client.update_self(status)
+            client.update_self(args.status)
--- a/src/ahriman/application/handlers/update.py
+++ b/src/ahriman/application/handlers/update.py
@ -19,7 +19,7 @@
 #
 import argparse

-from typing import Type
+from typing import Callable, Type

 from ahriman.application.application import Application
 from ahriman.application.handlers.handler import Handler
@ -39,13 +39,22 @@ class Update(Handler):
        :param architecture: repository architecture
        :param configuration: configuration instance
        """
-        # typing workaround
-        def log_fn(line: str) -> None:
-            return print(line) if args.dry_run else application.logger.info(line)
-
        application = Application(architecture, configuration)
-        packages = application.get_updates(args.package, args.no_aur, args.no_manual, args.no_vcs, log_fn)
+        packages = application.get_updates(args.package, args.no_aur, args.no_manual, args.no_vcs,
+                                           Update.log_fn(application, args.dry_run))
        if args.dry_run:
            return

        application.update(packages)
+
+    @staticmethod
+    def log_fn(application: Application, dry_run: bool) -> Callable[[str], None]:
+        """
+        package updates log function
+        :param application: application instance
+        :param dry_run: do not perform update itself
+        :return: in case if dry_run is set it will return print, logger otherwise
+        """
+        def inner(line: str) -> None:
+            return print(line) if dry_run else application.logger.info(line)
+        return inner
--- a/src/ahriman/application/lock.py
+++ b/src/ahriman/application/lock.py
@ -80,7 +80,7 @@ class Lock:
        :param exc_tb: exception traceback if any
        :return: always False (do not suppress any exception)
        """
-        self.remove()
+        self.clear()
        status = BuildStatusEnum.Success if exc_val is None else BuildStatusEnum.Failed
        self.reporter.update_self(status)
        return False
@ -96,6 +96,14 @@ class Lock:
        if current_uid != root_uid:
            raise UnsafeRun(current_uid, root_uid)

+    def clear(self) -> None:
+        """
+        remove lock file
+        """
+        if self.path is None:
+            return
+        self.path.unlink(missing_ok=True)
+
    def create(self) -> None:
        """
        create lock file
@ -106,11 +114,3 @@ class Lock:
            self.path.touch(exist_ok=self.force)
        except FileExistsError:
            raise DuplicateRun()
-
-    def remove(self) -> None:
-        """
-        remove lock file
-        """
-        if self.path is None:
-            return
-        self.path.unlink(missing_ok=True)
--- a/src/ahriman/core/build_tools/task.py
+++ b/src/ahriman/core/build_tools/task.py
@ -123,4 +123,4 @@ class Task:
        if self.cache_path.is_dir():
            # no need to clone whole repository, just copy from cache first
            shutil.copytree(self.cache_path, git_path)
-        return Task.fetch(git_path, self.package.git_url)
+        return self.fetch(git_path, self.package.git_url)
--- a/src/ahriman/core/configuration.py
+++ b/src/ahriman/core/configuration.py
@ -84,7 +84,7 @@ class Configuration(configparser.RawConfigParser):
        :param architecture: repository architecture
        :return: correct section name for repository specific section
        """
-        return f"{section}_{architecture}"
+        return f"{section}:{architecture}"

    def dump(self) -> Dict[str, Dict[str, str]]:
        """
@ -183,6 +183,6 @@ class Configuration(configparser.RawConfigParser):
            # remove any arch specific section
            for foreign in self.sections():
                # we would like to use lambda filter here, but pylint is too dumb
-                if not foreign.startswith(f"{section}_"):
+                if not foreign.startswith(f"{section}:"):
                    continue
                self.remove_section(foreign)
--- a/src/ahriman/core/report/html.py
+++ b/src/ahriman/core/report/html.py
@ -43,6 +43,7 @@ class HTML(Report):
                   * architecture, string
                   * archive_size, pretty printed size, string
                   * build_date, pretty printed datetime, string
+                   * depends, sorted list of strings
                   * description, string
                   * filename, string,
                   * groups, sorted list of strings
@ -95,6 +96,7 @@ class HTML(Report):
                "architecture": properties.architecture or "",
                "archive_size": pretty_size(properties.archive_size),
                "build_date": pretty_datetime(properties.build_date),
+                "depends": properties.depends,
                "description": properties.description or "",
                "filename": properties.filename,
                "groups": properties.groups,
@ -110,8 +112,8 @@ class HTML(Report):
        html = template.render(
            homepage=self.homepage,
            link_path=self.link_path,
-            has_package_signed=SignSettings.SignPackages in self.sign_targets,
-            has_repo_signed=SignSettings.SignRepository in self.sign_targets,
+            has_package_signed=SignSettings.Packages in self.sign_targets,
+            has_repo_signed=SignSettings.Repository in self.sign_targets,
            packages=sorted(content, key=comparator),
            pgp_key=self.default_pgp_key,
            repository=self.name)
--- a/src/ahriman/core/report/report.py
+++ b/src/ahriman/core/report/report.py
@ -17,9 +17,11 @@
 # You should have received a copy of the GNU General Public License
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 #
+from __future__ import annotations
+
 import logging

-from typing import Iterable
+from typing import Iterable, Type

 from ahriman.core.configuration import Configuration
 from ahriman.core.exceptions import ReportFailed
@ -45,30 +47,34 @@ class Report:
        self.architecture = architecture
        self.configuration = configuration

-    @staticmethod
-    def run(architecture: str, configuration: Configuration, target: str, packages: Iterable[Package]) -> None:
+    @classmethod
+    def load(cls: Type[Report], architecture: str, configuration: Configuration, target: str) -> Report:
        """
-        run report generation
+        load client from settings
        :param architecture: repository architecture
        :param configuration: configuration instance
        :param target: target to generate report (e.g. html)
-        :param packages: list of packages to generate report
+        :return: client according to current settings
        """
        provider = ReportSettings.from_option(target)
        if provider == ReportSettings.HTML:
            from ahriman.core.report.html import HTML
-            report: Report = HTML(architecture, configuration)
-        else:
-            report = Report(architecture, configuration)
-
-        try:
-            report.generate(packages)
-        except Exception:
-            report.logger.exception(f"report generation failed for target {provider.name}")
-            raise ReportFailed()
+            return HTML(architecture, configuration)
+        return cls(architecture, configuration)  # should never happen

    def generate(self, packages: Iterable[Package]) -> None:
        """
        generate report for the specified packages
        :param packages: list of packages to generate report
        """
+
+    def run(self, packages: Iterable[Package]) -> None:
+        """
+        run report generation
+        :param packages: list of packages to generate report
+        """
+        try:
+            self.generate(packages)
+        except Exception:
+            self.logger.exception("report generation failed")
+            raise ReportFailed()
--- a/src/ahriman/core/repository/executor.py
+++ b/src/ahriman/core/repository/executor.py
@ -108,7 +108,8 @@ class Executor(Cleaner):
        if targets is None:
            targets = self.configuration.getlist("report", "target")
        for target in targets:
-            Report.run(self.architecture, self.configuration, target, self.packages())
+            runner = Report.load(self.architecture, self.configuration, target)
+            runner.run(self.packages())

    def process_sync(self, targets: Optional[Iterable[str]]) -> None:
        """
@ -118,7 +119,8 @@ class Executor(Cleaner):
        if targets is None:
            targets = self.configuration.getlist("upload", "target")
        for target in targets:
-            Upload.run(self.architecture, self.configuration, target, self.paths.repository)
+            runner = Upload.load(self.architecture, self.configuration, target)
+            runner.run(self.paths.repository)

    def process_update(self, packages: Iterable[Path]) -> Path:
        """
--- a/src/ahriman/core/repository/properties.py
+++ b/src/ahriman/core/repository/properties.py
@ -33,6 +33,7 @@ class Properties:
    :ivar architecture: repository architecture
    :ivar aur_url: base AUR url
    :ivar configuration: configuration instance
+    :ivar ignore_list: package bases which will be ignored during auto updates
    :ivar logger: class logger
    :ivar name: repository name
    :ivar pacman: alpm wrapper instance
@ -53,6 +54,7 @@ class Properties:
        self.paths = RepositoryPaths(configuration.getpath("repository", "root"), architecture)
        self.paths.create_tree()

+        self.ignore_list = configuration.getlist("build", "ignore_packages")
        self.pacman = Pacman(configuration)
        self.sign = GPG(architecture, configuration)
        self.repo = Repo(self.name, self.paths, self.sign.repository_sign_args)
--- a/src/ahriman/core/repository/repository.py
+++ b/src/ahriman/core/repository/repository.py
@ -53,4 +53,4 @@ class Repository(Executor, UpdateHandler):
        get list of files in built packages directory
        :return: list of filenames from the directory
        """
-        return list(self.paths.packages.iterdir())
+        return list(filter(package_like, self.paths.packages.iterdir()))
--- a/src/ahriman/core/repository/update_handler.py
+++ b/src/ahriman/core/repository/update_handler.py
@ -44,10 +44,8 @@ class UpdateHandler(Cleaner):
        """
        result: List[Package] = []

-        ignore_list = self.configuration.getlist("build", "ignore_packages")
-
        for local in self.packages():
-            if local.base in ignore_list:
+            if local.base in self.ignore_list:
                continue
            if local.is_vcs and no_vcs:
                continue
--- a/src/ahriman/core/sign/gpg.py
+++ b/src/ahriman/core/sign/gpg.py
@ -56,7 +56,7 @@ class GPG:
        """
        :return: command line arguments for repo-add command to sign database
        """
-        if SignSettings.SignRepository not in self.targets:
+        if SignSettings.Repository not in self.targets:
            return []
        if self.default_key is None:
            self.logger.error("no default key set, skip repository sign")
@ -107,7 +107,7 @@ class GPG:
        :param base: package base required to check for key overrides
        :return: list of generated files including original file
        """
-        if SignSettings.SignPackages not in self.targets:
+        if SignSettings.Packages not in self.targets:
            return [path]
        key = self.configuration.get("sign", f"key_{base}", fallback=self.default_key)
        if key is None:
@ -122,7 +122,7 @@ class GPG:
        :param path: path to repository database
        :return: list of generated files including original file
        """
-        if SignSettings.SignRepository not in self.targets:
+        if SignSettings.Repository not in self.targets:
            return [path]
        if self.default_key is None:
            self.logger.error("no default key set, skip repository sign")
--- a/src/ahriman/core/status/client.py
+++ b/src/ahriman/core/status/client.py
@ -19,7 +19,7 @@
 #
 from __future__ import annotations

-from typing import List, Optional, Tuple
+from typing import List, Optional, Tuple, Type

 from ahriman.core.configuration import Configuration
 from ahriman.models.build_status import BuildStatus, BuildStatusEnum
@ -31,6 +31,20 @@ class Client:
    base build status reporter client
    """

+    @classmethod
+    def load(cls: Type[Client], configuration: Configuration) -> Client:
+        """
+        load client from settings
+        :param configuration: configuration instance
+        :return: client according to current settings
+        """
+        host = configuration.get("web", "host", fallback=None)
+        port = configuration.getint("web", "port", fallback=None)
+        if host is not None and port is not None:
+            from ahriman.core.status.web_client import WebClient
+            return WebClient(host, port)
+        return cls()
+
    def add(self, package: Package, status: BuildStatusEnum) -> None:
        """
        add new package with status
@ -109,18 +123,3 @@ class Client:
        :param package: current package properties
        """
        return self.add(package, BuildStatusEnum.Unknown)
-
-    @staticmethod
-    def load(configuration: Configuration) -> Client:
-        """
-        load client from settings
-        :param configuration: configuration instance
-        :return: client according to current settings
-        """
-        host = configuration.get("web", "host", fallback=None)
-        port = configuration.getint("web", "port", fallback=None)
-        if host is None or port is None:
-            return Client()
-
-        from ahriman.core.status.web_client import WebClient
-        return WebClient(host, port)
--- a/src/ahriman/core/status/web_client.py
+++ b/src/ahriman/core/status/web_client.py
@ -45,6 +45,16 @@ class WebClient(Client):
        self.host = host
        self.port = port

+    @staticmethod
+    def _exception_response_text(exception: requests.exceptions.HTTPError) -> str:
+        """
+        safe response exception text generation
+        :param exception: exception raised
+        :return: text of the response if it is not None and empty string otherwise
+        """
+        result: str = exception.response.text if exception.response is not None else ""
+        return result
+
    def _ahriman_url(self) -> str:
        """
        url generator
@ -75,7 +85,7 @@ class WebClient(Client):
            response = requests.post(self._package_url(package.base), json=payload)
            response.raise_for_status()
        except requests.exceptions.HTTPError as e:
-            self.logger.exception(f"could not add {package.base}: {e.response.text}")
+            self.logger.exception(f"could not add {package.base}: {WebClient._exception_response_text(e)}")
        except Exception:
            self.logger.exception(f"could not add {package.base}")

@ -95,7 +105,7 @@ class WebClient(Client):
                for package in status_json
            ]
        except requests.exceptions.HTTPError as e:
-            self.logger.exception(f"could not get {base}: {e.response.text}")
+            self.logger.exception(f"could not get {base}: {WebClient._exception_response_text(e)}")
        except Exception:
            self.logger.exception(f"could not get {base}")
        return []
@ -112,7 +122,7 @@ class WebClient(Client):
            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: {e.response.text}")
+            self.logger.exception(f"could not get service status: {WebClient._exception_response_text(e)}")
        except Exception:
            self.logger.exception("could not get service status")
        return BuildStatus()
@ -126,7 +136,7 @@ class WebClient(Client):
            response = requests.delete(self._package_url(base))
            response.raise_for_status()
        except requests.exceptions.HTTPError as e:
-            self.logger.exception(f"could not delete {base}: {e.response.text}")
+            self.logger.exception(f"could not delete {base}: {WebClient._exception_response_text(e)}")
        except Exception:
            self.logger.exception(f"could not delete {base}")

@ -142,7 +152,7 @@ class WebClient(Client):
            response = requests.post(self._package_url(base), json=payload)
            response.raise_for_status()
        except requests.exceptions.HTTPError as e:
-            self.logger.exception(f"could not update {base}: {e.response.text}")
+            self.logger.exception(f"could not update {base}: {WebClient._exception_response_text(e)}")
        except Exception:
            self.logger.exception(f"could not update {base}")

@ -157,6 +167,6 @@ class WebClient(Client):
            response = requests.post(self._ahriman_url(), json=payload)
            response.raise_for_status()
        except requests.exceptions.HTTPError as e:
-            self.logger.exception(f"could not update service status: {e.response.text}")
+            self.logger.exception(f"could not update service status: {WebClient._exception_response_text(e)}")
        except Exception:
            self.logger.exception("could not update service status")
--- a/src/ahriman/core/upload/upload.py
+++ b/src/ahriman/core/upload/upload.py
@ -17,9 +17,12 @@
 # You should have received a copy of the GNU General Public License
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 #
+from __future__ import annotations
+
 import logging

 from pathlib import Path
+from typing import Type

 from ahriman.core.configuration import Configuration
 from ahriman.core.exceptions import SyncFailed
@ -44,29 +47,33 @@ class Upload:
        self.architecture = architecture
        self.config = configuration

-    @staticmethod
-    def run(architecture: str, configuration: Configuration, target: str, path: Path) -> None:
+    @classmethod
+    def load(cls: Type[Upload], architecture: str, configuration: Configuration, target: str) -> Upload:
        """
-        run remote sync
+        load client from settings
        :param architecture: repository architecture
        :param configuration: configuration instance
        :param target: target to run sync (e.g. s3)
-        :param path: local path to sync
+        :return: client according to current settings
        """
        provider = UploadSettings.from_option(target)
        if provider == UploadSettings.Rsync:
            from ahriman.core.upload.rsync import Rsync
-            upload: Upload = Rsync(architecture, configuration)
-        elif provider == UploadSettings.S3:
+            return Rsync(architecture, configuration)
+        if provider == UploadSettings.S3:
            from ahriman.core.upload.s3 import S3
-            upload = S3(architecture, configuration)
-        else:
-            upload = Upload(architecture, configuration)
+            return S3(architecture, configuration)
+        return cls(architecture, configuration)  # should never happen

+    def run(self, path: Path) -> None:
+        """
+        run remote sync
+        :param path: local path to sync
+        """
        try:
-            upload.sync(path)
+            self.sync(path)
        except Exception:
-            upload.logger.exception(f"remote sync failed for {provider.name}")
+            self.logger.exception("remote sync failed")
            raise SyncFailed()

    def sync(self, path: Path) -> None:
--- a/src/ahriman/core/util.py
+++ b/src/ahriman/core/util.py
@ -89,6 +89,6 @@ def pretty_size(size: Optional[float], level: int = 0) -> str:

    if size is None:
        return ""
-    if size < 1024 or level == 3:
+    if size < 1024 or level >= 3:
        return f"{size:.1f} {str_level()}"
    return pretty_size(size / 1024, level + 1)
--- a/src/ahriman/models/build_status.py
+++ b/src/ahriman/models/build_status.py
@ -63,7 +63,7 @@ class BuildStatus:
    """
    build status holder
    :ivar status: build status
-    :ivar _timestamp: build status update time
+    :ivar timestamp: build status update time
    """

    def __init__(self, status: Union[BuildStatusEnum, str, None] = None,
--- a/src/ahriman/models/package.py
+++ b/src/ahriman/models/package.py
@ -52,6 +52,13 @@ class Package:

    _check_output = check_output

+    @property
+    def depends(self) -> List[str]:
+        """
+        :return: sum of dependencies per arch package
+        """
+        return sorted(set(sum([package.depends for package in self.packages.values()], start=[])))
+
    @property
    def git_url(self) -> str:
        """
@ -147,7 +154,7 @@ class Package:
        :return: package properties
        """
        packages = {
-            key: PackageDescription(**value)
+            key: PackageDescription.from_json(value)
            for key, value in dump.get("packages", {}).items()
        }
        return Package(
@ -156,6 +163,27 @@ class Package:
            aur_url=dump["aur_url"],
            packages=packages)

+    @classmethod
+    def load(cls: Type[Package], path: Union[Path, str], pacman: Pacman, aur_url: str) -> Package:
+        """
+        package constructor from available sources
+        :param path: one of path to sources directory, path to archive or package name/base
+        :param pacman: alpm wrapper instance (required to load from archive)
+        :param aur_url: AUR root url
+        :return: package properties
+        """
+        try:
+            maybe_path = Path(path)
+            if maybe_path.is_dir():
+                return cls.from_build(maybe_path, aur_url)
+            if maybe_path.is_file():
+                return cls.from_archive(maybe_path, pacman, aur_url)
+            return cls.from_aur(str(path), aur_url)
+        except InvalidPackageInfo:
+            raise
+        except Exception as e:
+            raise InvalidPackageInfo(str(e))
+
    @staticmethod
    def dependencies(path: Path) -> Set[str]:
        """
@ -194,29 +222,6 @@ class Package:
        prefix = f"{epoch}:" if epoch else ""
        return f"{prefix}{pkgver}-{pkgrel}"

-    @staticmethod
-    def load(path: Union[Path, str], pacman: Pacman, aur_url: str) -> Package:
-        """
-        package constructor from available sources
-        :param path: one of path to sources directory, path to archive or package name/base
-        :param pacman: alpm wrapper instance (required to load from archive)
-        :param aur_url: AUR root url
-        :return: package properties
-        """
-        try:
-            maybe_path = Path(path)
-            if maybe_path.is_dir():
-                package: Package = Package.from_build(maybe_path, aur_url)
-            elif maybe_path.is_file():
-                package = Package.from_archive(maybe_path, pacman, aur_url)
-            else:
-                package = Package.from_aur(str(path), aur_url)
-            return package
-        except InvalidPackageInfo:
-            raise
-        except Exception as e:
-            raise InvalidPackageInfo(str(e))
-
    def actual_version(self, paths: RepositoryPaths) -> str:
        """
        additional method to handle VCS package versions
--- a/src/ahriman/models/package_description.py
+++ b/src/ahriman/models/package_description.py
@ -19,10 +19,10 @@
 #
 from __future__ import annotations

-from dataclasses import dataclass, field
+from dataclasses import dataclass, field, fields
 from pathlib import Path
 from pyalpm import Package  # type: ignore
-from typing import List, Optional, Type
+from typing import Any, Dict, List, Optional, Type


@dataclass
@ -32,6 +32,7 @@ class PackageDescription:
    :ivar architecture: package architecture
    :ivar archive_size: package archive size
    :ivar build_date: package build date
+    :ivar depends: package dependencies list
    :ivar description: package description
    :ivar filename: package archive name
    :ivar groups: package groups
@ -43,6 +44,7 @@ class PackageDescription:
    architecture: Optional[str] = None
    archive_size: Optional[int] = None
    build_date: Optional[int] = None
+    depends: List[str] = field(default_factory=list)
    description: Optional[str] = None
    filename: Optional[str] = None
    groups: List[str] = field(default_factory=list)
@ -57,6 +59,18 @@ class PackageDescription:
        """
        return Path(self.filename) if self.filename is not None else None

+    @classmethod
+    def from_json(cls: Type[PackageDescription], dump: Dict[str, Any]) -> PackageDescription:
+        """
+        construct package properties from json dump
+        :param dump: json dump body
+        :return: package properties
+        """
+        # filter to only known fields
+        known_fields = [pair.name for pair in fields(cls)]
+        dump = {key: value for key, value in dump.items() if key in known_fields}
+        return cls(**dump)
+
    @classmethod
    def from_package(cls: Type[PackageDescription], package: Package, path: Path) -> PackageDescription:
        """
@ -65,10 +79,11 @@ class PackageDescription:
        :param path: path to package archive
        :return: package properties based on tarball
        """
-        return PackageDescription(
+        return cls(
            architecture=package.arch,
            archive_size=package.size,
            build_date=package.builddate,
+            depends=package.depends,
            description=package.desc,
            filename=path.name,
            groups=package.groups,
--- a/src/ahriman/models/report_settings.py
+++ b/src/ahriman/models/report_settings.py
@ -20,6 +20,7 @@
 from __future__ import annotations

 from enum import Enum, auto
+from typing import Type

 from ahriman.core.exceptions import InvalidOption

@ -30,15 +31,16 @@ class ReportSettings(Enum):
    :cvar HTML: html report generation
    """

+    Disabled = auto()  # for testing purpose
    HTML = auto()

-    @staticmethod
-    def from_option(value: str) -> ReportSettings:
+    @classmethod
+    def from_option(cls: Type[ReportSettings], value: str) -> ReportSettings:
        """
        construct value from configuration
        :param value: configuration value
        :return: parsed value
        """
        if value.lower() in ("html",):
-            return ReportSettings.HTML
+            return cls.HTML
        raise InvalidOption(value)
--- a/src/ahriman/models/sign_settings.py
+++ b/src/ahriman/models/sign_settings.py
@ -20,6 +20,7 @@
 from __future__ import annotations

 from enum import Enum, auto
+from typing import Type

 from ahriman.core.exceptions import InvalidOption

@ -27,22 +28,22 @@ from ahriman.core.exceptions import InvalidOption
 class SignSettings(Enum):
    """
    sign targets enumeration
-    :cvar SignPackages: sign each package
-    :cvar SignRepository: sign repository database file
+    :cvar Packages: sign each package
+    :cvar Repository: sign repository database file
    """

-    SignPackages = auto()
-    SignRepository = auto()
+    Packages = auto()
+    Repository = auto()

-    @staticmethod
-    def from_option(value: str) -> SignSettings:
+    @classmethod
+    def from_option(cls: Type[SignSettings], value: str) -> SignSettings:
        """
        construct value from configuration
        :param value: configuration value
        :return: parsed value
        """
        if value.lower() in ("package", "packages", "sign-package"):
-            return SignSettings.SignPackages
+            return cls.Packages
        if value.lower() in ("repository", "sign-repository"):
-            return SignSettings.SignRepository
+            return cls.Repository
        raise InvalidOption(value)
--- a/src/ahriman/models/upload_settings.py
+++ b/src/ahriman/models/upload_settings.py
@ -20,6 +20,7 @@
 from __future__ import annotations

 from enum import Enum, auto
+from typing import Type

 from ahriman.core.exceptions import InvalidOption

@ -31,18 +32,19 @@ class UploadSettings(Enum):
    :cvar S3: sync to Amazon S3
    """

+    Disabled = auto()  # for testing purpose
    Rsync = auto()
    S3 = auto()

-    @staticmethod
-    def from_option(value: str) -> UploadSettings:
+    @classmethod
+    def from_option(cls: Type[UploadSettings], value: str) -> UploadSettings:
        """
        construct value from configuration
        :param value: configuration value
        :return: parsed value
        """
        if value.lower() in ("rsync",):
-            return UploadSettings.Rsync
+            return cls.Rsync
        if value.lower() in ("s3",):
-            return UploadSettings.S3
+            return cls.S3
        raise InvalidOption(value)
--- a/src/ahriman/version.py
+++ b/src/ahriman/version.py
@ -17,4 +17,4 @@
 # You should have received a copy of the GNU General Public License
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 #
-__version__ = "0.19.0"
+__version__ = "0.21.2"
--- a/src/ahriman/web/views/index.py
+++ b/src/ahriman/web/views/index.py
@ -36,6 +36,7 @@ class IndexView(BaseView):
        architecture - repository architecture, string, required
        packages - sorted list of packages properties, required
                   * base, string
+                   * depends, sorted list of strings
                   * groups, sorted list of strings
                   * licenses, sorted list of strings
                   * packages, sorted list of strings
@ -61,6 +62,7 @@ class IndexView(BaseView):
        packages = [
            {
                "base": package.base,
+                "depends": package.depends,
                "groups": package.groups,
                "licenses": package.licenses,
                "packages": list(sorted(package.packages)),
--- a/tests/ahriman/application/handlers/test_handler.py
+++ b/tests/ahriman/application/handlers/test_handler.py
@ -1,15 +1,18 @@
 import argparse
+import pytest

+from pathlib import Path
 from pytest_mock import MockerFixture

 from ahriman.application.handlers import Handler
+from ahriman.core.configuration import Configuration


 def test_call(args: argparse.Namespace, mocker: MockerFixture) -> None:
    """
    must call inside lock
    """
-    args.configuration = ""
+    args.configuration = Path("")
    args.no_log = False
    mocker.patch("ahriman.application.handlers.Handler.run")
    mocker.patch("ahriman.core.configuration.Configuration.from_path")
@ -27,3 +30,22 @@ def test_call_exception(args: argparse.Namespace, mocker: MockerFixture) -> None
    """
    mocker.patch("ahriman.application.lock.Lock.__enter__", side_effect=Exception())
    assert not Handler._call(args, "x86_64")
+
+
+def test_execute(args: argparse.Namespace, mocker: MockerFixture) -> None:
+    """
+    must run execution in multiple processes
+    """
+    args.architecture = ["i686", "x86_64"]
+    starmap_mock = mocker.patch("multiprocessing.pool.Pool.starmap")
+
+    Handler.execute(args)
+    starmap_mock.assert_called_once()
+
+
+def test_packages(args: argparse.Namespace, configuration: Configuration) -> None:
+    """
+    must raise NotImplemented for missing method
+    """
+    with pytest.raises(NotImplementedError):
+        Handler.run(args, "x86_64", configuration)
--- a/tests/ahriman/application/handlers/test_handler_rebuild.py
+++ b/tests/ahriman/application/handlers/test_handler_rebuild.py
@ -4,12 +4,19 @@ from pytest_mock import MockerFixture

 from ahriman.application.handlers import Rebuild
 from ahriman.core.configuration import Configuration
+from ahriman.models.package import Package
+
+
+def _default_args(args: argparse.Namespace) -> argparse.Namespace:
+    args.depends_on = None
+    return args


 def test_run(args: argparse.Namespace, configuration: Configuration, mocker: MockerFixture) -> None:
    """
    must run command
    """
+    args = _default_args(args)
    mocker.patch("pathlib.Path.mkdir")
    application_packages_mock = mocker.patch("ahriman.core.repository.repository.Repository.packages")
    application_mock = mocker.patch("ahriman.application.application.Application.update")
@ -17,3 +24,36 @@ def test_run(args: argparse.Namespace, configuration: Configuration, mocker: Moc
    Rebuild.run(args, "x86_64", configuration)
    application_packages_mock.assert_called_once()
    application_mock.assert_called_once()
+
+
+def test_run_filter(args: argparse.Namespace, configuration: Configuration,
+                    package_ahriman: Package, package_python_schedule: Package,
+                    mocker: MockerFixture) -> None:
+    """
+    must run command with depends filter
+    """
+    args = _default_args(args)
+    args.depends_on = "python-aur"
+    mocker.patch("pathlib.Path.mkdir")
+    mocker.patch("ahriman.core.repository.repository.Repository.packages",
+                 return_value=[package_ahriman, package_python_schedule])
+    application_mock = mocker.patch("ahriman.application.application.Application.update")
+
+    Rebuild.run(args, "x86_64", configuration)
+    application_mock.assert_called_with([package_ahriman])
+
+
+def test_run_without_filter(args: argparse.Namespace, configuration: Configuration,
+                            package_ahriman: Package, package_python_schedule: Package,
+                            mocker: MockerFixture) -> None:
+    """
+    must run command for all packages if no filter supplied
+    """
+    args = _default_args(args)
+    mocker.patch("pathlib.Path.mkdir")
+    mocker.patch("ahriman.core.repository.repository.Repository.packages",
+                 return_value=[package_ahriman, package_python_schedule])
+    application_mock = mocker.patch("ahriman.application.application.Application.update")
+
+    Rebuild.run(args, "x86_64", configuration)
+    application_mock.assert_called_with([package_ahriman, package_python_schedule])
--- a/tests/ahriman/application/handlers/test_handler_setup.py
+++ b/tests/ahriman/application/handlers/test_handler_setup.py
@ -7,14 +7,18 @@ from unittest import mock
 from ahriman.application.handlers import Setup
 from ahriman.core.configuration import Configuration
 from ahriman.models.repository_paths import RepositoryPaths
+from ahriman.models.sign_settings import SignSettings


 def _default_args(args: argparse.Namespace) -> argparse.Namespace:
    args.build_command = "ahriman"
-    args.from_configuration = "/usr/share/devtools/pacman-extra.conf"
+    args.from_configuration = Path("/usr/share/devtools/pacman-extra.conf")
    args.no_multilib = False
    args.packager = "John Doe <john@doe.com>"
    args.repository = "aur-clone"
+    args.sign_key = "key"
+    args.sign_target = [SignSettings.Packages]
+    args.web_port = 8080
    return args


@ -58,14 +62,20 @@ def test_create_ahriman_configuration(args: argparse.Namespace, configuration: C
    write_mock = mocker.patch("configparser.RawConfigParser.write")

    command = Setup.build_command(args.build_command, "x86_64")
-    Setup.create_ahriman_configuration(args.build_command, "x86_64", args.repository, configuration.include)
+    Setup.create_ahriman_configuration(args, "x86_64", args.repository, configuration.include)
    add_section_mock.assert_has_calls([
-        mock.call("build"),
+        mock.call(Configuration.section_name("build", "x86_64")),
        mock.call("repository"),
+        mock.call(Configuration.section_name("sign", "x86_64")),
+        mock.call(Configuration.section_name("web", "x86_64")),
    ])
    set_mock.assert_has_calls([
-        mock.call("build", "build_command", str(command)),
+        mock.call(Configuration.section_name("build", "x86_64"), "build_command", str(command)),
        mock.call("repository", "name", args.repository),
+        mock.call(Configuration.section_name("sign", "x86_64"), "target",
+                  " ".join([target.name.lower() for target in args.sign_target])),
+        mock.call(Configuration.section_name("sign", "x86_64"), "key", args.sign_key),
+        mock.call(Configuration.section_name("web", "x86_64"), "port", str(args.web_port)),
    ])
    write_mock.assert_called_once()

@ -81,7 +91,7 @@ def test_create_devtools_configuration(args: argparse.Namespace, repository_path
    add_section_mock = mocker.patch("configparser.RawConfigParser.add_section")
    write_mock = mocker.patch("configparser.RawConfigParser.write")

-    Setup.create_devtools_configuration(args.build_command, "x86_64", Path(args.from_configuration),
+    Setup.create_devtools_configuration(args.build_command, "x86_64", args.from_configuration,
                                        args.no_multilib, args.repository, repository_paths)
    add_section_mock.assert_has_calls([
        mock.call("multilib"),
@ -101,7 +111,7 @@ def test_create_devtools_configuration_no_multilib(args: argparse.Namespace, rep
    add_section_mock = mocker.patch("configparser.RawConfigParser.add_section")
    write_mock = mocker.patch("configparser.RawConfigParser.write")

-    Setup.create_devtools_configuration(args.build_command, "x86_64", Path(args.from_configuration),
+    Setup.create_devtools_configuration(args.build_command, "x86_64", args.from_configuration,
                                        True, args.repository, repository_paths)
    add_section_mock.assert_called_once()
    write_mock.assert_called_once()
--- a/tests/ahriman/application/handlers/test_handler_status.py
+++ b/tests/ahriman/application/handlers/test_handler_status.py
@ -4,6 +4,8 @@ from pytest_mock import MockerFixture

 from ahriman.application.handlers import Status
 from ahriman.core.configuration import Configuration
+from ahriman.models.build_status import BuildStatus
+from ahriman.models.package import Package


 def _default_args(args: argparse.Namespace) -> argparse.Namespace:
@ -12,15 +14,32 @@ def _default_args(args: argparse.Namespace) -> argparse.Namespace:
    return args


-def test_run(args: argparse.Namespace, configuration: Configuration, mocker: MockerFixture) -> None:
+def test_run(args: argparse.Namespace, configuration: Configuration, package_ahriman: Package,
+             mocker: MockerFixture) -> None:
    """
    must run command
    """
    args = _default_args(args)
    mocker.patch("pathlib.Path.mkdir")
    application_mock = mocker.patch("ahriman.core.status.client.Client.get_self")
-    packages_mock = mocker.patch("ahriman.core.status.client.Client.get")
+    packages_mock = mocker.patch("ahriman.core.status.client.Client.get",
+                                 return_value=[(package_ahriman, BuildStatus())])

    Status.run(args, "x86_64", configuration)
    application_mock.assert_called_once()
    packages_mock.assert_called_once()
+
+
+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()
--- a/tests/ahriman/application/handlers/test_handler_status_update.py
+++ b/tests/ahriman/application/handlers/test_handler_status_update.py
@ -9,8 +9,9 @@ from ahriman.models.package import Package


 def _default_args(args: argparse.Namespace) -> argparse.Namespace:
-    args.status = BuildStatusEnum.Success.value
+    args.status = BuildStatusEnum.Success
    args.package = None
+    args.remove = False
    return args


@ -38,3 +39,18 @@ def test_run_packages(args: argparse.Namespace, configuration: Configuration, pa

    StatusUpdate.run(args, "x86_64", configuration)
    update_mock.assert_called_once()
+
+
+def test_run_remove(args: argparse.Namespace, configuration: Configuration, package_ahriman: Package,
+                    mocker: MockerFixture) -> None:
+    """
+    must remove package from status page
+    """
+    args = _default_args(args)
+    args.package = [package_ahriman.base]
+    args.remove = True
+    mocker.patch("pathlib.Path.mkdir")
+    update_mock = mocker.patch("ahriman.core.status.client.Client.remove")
+
+    StatusUpdate.run(args, "x86_64", configuration)
+    update_mock.assert_called_once()
--- a/tests/ahriman/application/handlers/test_handler_update.py
+++ b/tests/ahriman/application/handlers/test_handler_update.py
@ -2,6 +2,7 @@ import argparse

 from pytest_mock import MockerFixture

+from ahriman.application.application import Application
 from ahriman.application.handlers import Update
 from ahriman.core.configuration import Configuration

@ -40,3 +41,12 @@ def test_run_dry_run(args: argparse.Namespace, configuration: Configuration, moc

    Update.run(args, "x86_64", configuration)
    updates_mock.assert_called_once()
+
+
+def test_log_fn(application: Application, mocker: MockerFixture) -> None:
+    """
+    must print package updates
+    """
+    logger_mock = mocker.patch("logging.Logger.info")
+    Update.log_fn(application, False)("hello")
+    logger_mock.assert_called_once()
--- a/tests/ahriman/application/test_ahriman.py
+++ b/tests/ahriman/application/test_ahriman.py
@ -1,5 +1,12 @@
 import argparse

+from pathlib import Path
+from pytest_mock import MockerFixture
+
+from ahriman.application.handlers import Handler
+from ahriman.models.build_status import BuildStatusEnum
+from ahriman.models.sign_settings import SignSettings
+

 def test_parser(parser: argparse.ArgumentParser) -> None:
    """
@ -8,6 +15,26 @@ def test_parser(parser: argparse.ArgumentParser) -> None:
    parser.parse_args(["-a", "x86_64", "config"])


+def test_parser_option_configuration(parser: argparse.ArgumentParser) -> None:
+    """
+    must convert configuration option to Path instance
+    """
+    args = parser.parse_args(["-a", "x86_64", "config"])
+    assert isinstance(args.configuration, Path)
+    args = parser.parse_args(["-a", "x86_64", "-c", "ahriman.ini", "config"])
+    assert isinstance(args.configuration, Path)
+
+
+def test_parser_option_lock(parser: argparse.ArgumentParser) -> None:
+    """
+    must convert lock option to Path instance
+    """
+    args = parser.parse_args(["-a", "x86_64", "update"])
+    assert isinstance(args.lock, Path)
+    args = parser.parse_args(["-a", "x86_64", "-l", "ahriman.lock", "update"])
+    assert isinstance(args.lock, Path)
+
+
 def test_multiple_architectures(parser: argparse.ArgumentParser) -> None:
    """
    must accept multiple architectures
@ -48,12 +75,35 @@ def test_subparsers_setup(parser: argparse.ArgumentParser) -> None:
    """
    setup command must imply lock, no_report and unsafe
    """
-    args = parser.parse_args(["-a", "x86_64", "setup", "--packager", "John Doe <john@doe.com>"])
+    args = parser.parse_args(["-a", "x86_64", "setup", "--packager", "John Doe <john@doe.com>",
+                              "--repository", "aur-clone"])
    assert args.lock is None
    assert args.no_report
    assert args.unsafe


+def test_subparsers_setup_option_from_configuration(parser: argparse.ArgumentParser) -> None:
+    """
+    setup command must convert from-configuration option to path instance
+    """
+    args = parser.parse_args(["-a", "x86_64", "setup", "--packager", "John Doe <john@doe.com>",
+                              "--repository", "aur-clone"])
+    assert isinstance(args.from_configuration, Path)
+    args = parser.parse_args(["-a", "x86_64", "setup", "--packager", "John Doe <john@doe.com>",
+                              "--repository", "aur-clone", "--from-configuration", "path"])
+    assert isinstance(args.from_configuration, Path)
+
+
+def test_subparsers_setup_option_sign_target(parser: argparse.ArgumentParser) -> None:
+    """
+    setup command must convert sign-target option to signsettings instance
+    """
+    args = parser.parse_args(["-a", "x86_64", "setup", "--packager", "John Doe <john@doe.com>",
+                              "--repository", "aur-clone", "--sign-target", "packages"])
+    assert args.sign_target
+    assert all(isinstance(target, SignSettings) for target in args.sign_target)
+
+
 def test_subparsers_status(parser: argparse.ArgumentParser) -> None:
    """
    status command must imply lock, no_report and unsafe
@ -74,6 +124,16 @@ def test_subparsers_status_update(parser: argparse.ArgumentParser) -> None:
    assert args.unsafe


+def test_subparsers_status_update_option_status(parser: argparse.ArgumentParser) -> None:
+    """
+    status-update command must convert status option to buildstatusenum instance
+    """
+    args = parser.parse_args(["-a", "x86_64", "status-update"])
+    assert isinstance(args.status, BuildStatusEnum)
+    args = parser.parse_args(["-a", "x86_64", "status-update", "--status", "failed"])
+    assert isinstance(args.status, BuildStatusEnum)
+
+
 def test_subparsers_web(parser: argparse.ArgumentParser) -> None:
    """
    web command must imply lock and no_report
@ -81,3 +141,19 @@ def test_subparsers_web(parser: argparse.ArgumentParser) -> None:
    args = parser.parse_args(["-a", "x86_64", "web"])
    assert args.lock is None
    assert args.no_report
+
+
+def test_run(args: argparse.Namespace, mocker: MockerFixture) -> None:
+    """
+    application must be run
+    """
+    args.architecture = "x86_64"
+    args.handler = Handler
+
+    from ahriman.application import ahriman
+    mocker.patch.object(ahriman, "__name__", "__main__")
+    mocker.patch("argparse.ArgumentParser.parse_args", return_value=args)
+    exit_mock = mocker.patch("sys.exit")
+
+    ahriman.run()
+    exit_mock.assert_called_once()
--- a/tests/ahriman/application/test_application.py
+++ b/tests/ahriman/application/test_application.py
@ -20,11 +20,22 @@ def test_finalize(application: Application, mocker: MockerFixture) -> None:
    sync_mock.assert_called_once()


-def test_get_updates_all(application: Application, mocker: MockerFixture) -> None:
+def test_known_packages(application: Application, package_ahriman: Package, mocker: MockerFixture) -> None:
+    """
+    must return not empty list of known packages
+    """
+    mocker.patch("ahriman.core.repository.repository.Repository.packages", return_value=[package_ahriman])
+    packages = application._known_packages()
+    assert len(packages) > 1
+    assert package_ahriman.base in packages
+
+
+def test_get_updates_all(application: Application, package_ahriman: Package, mocker: MockerFixture) -> None:
    """
    must get updates for all
    """
-    updates_aur_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.updates_aur")
+    updates_aur_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.updates_aur",
+                                    return_value=[package_ahriman])
    updates_manual_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.updates_manual")

    application.get_updates([], no_aur=False, no_manual=False, no_vcs=False, log_fn=print)
@ -233,6 +244,17 @@ def test_sign(application: Application, package_ahriman: Package, package_python
    finalize_mock.assert_called_once()


+def test_sign_skip(application: Application, package_ahriman: Package, mocker: MockerFixture) -> None:
+    """
+    must skip sign packages with empty filename
+    """
+    package_ahriman.packages[package_ahriman.base].filename = None
+    mocker.patch("ahriman.core.repository.repository.Repository.packages", return_value=[package_ahriman])
+    mocker.patch("ahriman.application.application.Application.update")
+
+    application.sign([])
+
+
 def test_sign_specific(application: Application, package_ahriman: Package, package_python_schedule: Package,
                       mocker: MockerFixture) -> None:
    """
--- a/tests/ahriman/application/test_lock.py
+++ b/tests/ahriman/application/test_lock.py
@ -15,14 +15,14 @@ def test_enter(lock: Lock, mocker: MockerFixture) -> None:
    must process with context manager
    """
    check_user_mock = mocker.patch("ahriman.application.lock.Lock.check_user")
-    remove_mock = mocker.patch("ahriman.application.lock.Lock.remove")
+    clear_mock = mocker.patch("ahriman.application.lock.Lock.clear")
    create_mock = mocker.patch("ahriman.application.lock.Lock.create")
    update_status_mock = mocker.patch("ahriman.core.status.client.Client.update_self")

    with lock:
        pass
    check_user_mock.assert_called_once()
-    remove_mock.assert_called_once()
+    clear_mock.assert_called_once()
    create_mock.assert_called_once()
    update_status_mock.assert_has_calls([
        mock.call(BuildStatusEnum.Building),
@ -35,7 +35,7 @@ def test_exit_with_exception(lock: Lock, mocker: MockerFixture) -> None:
    must process with context manager in case if exception raised
    """
    mocker.patch("ahriman.application.lock.Lock.check_user")
-    mocker.patch("ahriman.application.lock.Lock.remove")
+    mocker.patch("ahriman.application.lock.Lock.clear")
    mocker.patch("ahriman.application.lock.Lock.create")
    update_status_mock = mocker.patch("ahriman.core.status.client.Client.update_self")

@ -79,6 +79,34 @@ def test_check_user_unsafe(lock: Lock) -> None:
    lock.check_user()


+def test_clear(lock: Lock) -> None:
+    """
+    must remove lock file
+    """
+    lock.path = Path(tempfile.mktemp())
+    lock.path.touch()
+
+    lock.clear()
+    assert not lock.path.is_file()
+
+
+def test_clear_missing(lock: Lock) -> None:
+    """
+    must not fail on lock removal if file is missing
+    """
+    lock.path = Path(tempfile.mktemp())
+    lock.clear()
+
+
+def test_clear_skip(lock: Lock, mocker: MockerFixture) -> None:
+    """
+    must skip removal if no file set
+    """
+    unlink_mock = mocker.patch("pathlib.Path.unlink")
+    lock.clear()
+    unlink_mock.assert_not_called()
+
+
 def test_create(lock: Lock) -> None:
    """
    must create lock
@ -121,31 +149,3 @@ def test_create_unsafe(lock: Lock) -> None:

    lock.create()
    lock.path.unlink()
-
-
-def test_remove(lock: Lock) -> None:
-    """
-    must remove lock file
-    """
-    lock.path = Path(tempfile.mktemp())
-    lock.path.touch()
-
-    lock.remove()
-    assert not lock.path.is_file()
-
-
-def test_remove_missing(lock: Lock) -> None:
-    """
-    must not fail on lock removal if file is missing
-    """
-    lock.path = Path(tempfile.mktemp())
-    lock.remove()
-
-
-def test_remove_skip(lock: Lock, mocker: MockerFixture) -> None:
-    """
-    must skip removal if no file set
-    """
-    unlink_mock = mocker.patch("pathlib.Path.unlink")
-    lock.remove()
-    unlink_mock.assert_not_called()
--- a/tests/ahriman/conftest.py
+++ b/tests/ahriman/conftest.py
@ -61,6 +61,7 @@ def package_description_ahriman() -> PackageDescription:
        architecture="x86_64",
        archive_size=4200,
        build_date=42,
+        depends=["devtools", "git", "pyalpm", "python-aur", "python-srcinfo"],
        description="ArcHlinux ReposItory MANager",
        filename="ahriman-0.12.1-1-any.pkg.tar.zst",
        groups=[],
@ -75,6 +76,7 @@ def package_description_python_schedule() -> PackageDescription:
        architecture="x86_64",
        archive_size=4201,
        build_date=421,
+        depends=["python"],
        description="Python job scheduling for humans.",
        filename="python-schedule-1.0.0-2-any.pkg.tar.zst",
        groups=[],
@ -89,6 +91,7 @@ def package_description_python2_schedule() -> PackageDescription:
        architecture="x86_64",
        archive_size=4202,
        build_date=422,
+        depends=["python2"],
        description="Python job scheduling for humans.",
        filename="python2-schedule-1.0.0-2-any.pkg.tar.zst",
        groups=[],
--- a/tests/ahriman/core/build_tools/test_task.py
+++ b/tests/ahriman/core/build_tools/test_task.py
@ -51,6 +51,15 @@ def test_fetch_new(mocker: MockerFixture) -> None:
    ])


+def test_build(task_ahriman: Task, mocker: MockerFixture) -> None:
+    """
+    must build package
+    """
+    check_output_mock = mocker.patch("ahriman.core.build_tools.task.Task._check_output")
+    task_ahriman.build()
+    check_output_mock.assert_called()
+
+
 def test_init_with_cache(task_ahriman: Task, mocker: MockerFixture) -> None:
    """
    must copy tree instead of fetch
--- a/tests/ahriman/core/report/test_report.py
+++ b/tests/ahriman/core/report/test_report.py
@ -15,7 +15,17 @@ def test_report_failure(configuration: Configuration, mocker: MockerFixture) ->
    """
    mocker.patch("ahriman.core.report.html.HTML.generate", side_effect=Exception())
    with pytest.raises(ReportFailed):
-        Report.run("x86_64", configuration, ReportSettings.HTML.name, Path("path"))
+        Report.load("x86_64", configuration, ReportSettings.HTML.name).run(Path("path"))
+
+
+def test_report_dummy(configuration: Configuration, mocker: MockerFixture) -> None:
+    """
+    must construct dummy report class
+    """
+    mocker.patch("ahriman.models.report_settings.ReportSettings.from_option", return_value=ReportSettings.Disabled)
+    report_mock = mocker.patch("ahriman.core.report.report.Report.generate")
+    Report.load("x86_64", configuration, ReportSettings.Disabled.name).run(Path("path"))
+    report_mock.assert_called_once()


 def test_report_html(configuration: Configuration, mocker: MockerFixture) -> None:
@ -23,5 +33,5 @@ def test_report_html(configuration: Configuration, mocker: MockerFixture) -> Non
    must generate html report
    """
    report_mock = mocker.patch("ahriman.core.report.html.HTML.generate")
-    Report.run("x86_64", configuration, ReportSettings.HTML.name, Path("path"))
+    Report.load("x86_64", configuration, ReportSettings.HTML.name).run(Path("path"))
    report_mock.assert_called_once()
--- a/tests/ahriman/core/repository/test_cleaner.py
+++ b/tests/ahriman/core/repository/test_cleaner.py
@ -1,3 +1,4 @@
+import pytest
 import shutil

 from pathlib import Path
@ -20,6 +21,14 @@ def _mock_clear_check() -> None:
    ])


+def test_packages_built(cleaner: Cleaner) -> None:
+    """
+    must raise NotImplemented for missing method
+    """
+    with pytest.raises(NotImplementedError):
+        cleaner.packages_built()
+
+
 def test_clear_build(cleaner: Cleaner, mocker: MockerFixture) -> None:
    """
    must remove directories with sources
--- a/tests/ahriman/core/repository/test_executor.py
+++ b/tests/ahriman/core/repository/test_executor.py
@ -1,23 +1,34 @@
+import pytest
+
 from pathlib import Path
 from pytest_mock import MockerFixture
 from unittest import mock

+from ahriman.core.report.report import Report
 from ahriman.core.repository.executor import Executor
+from ahriman.core.upload.upload import Upload
 from ahriman.models.package import Package


+def test_packages(executor: Executor) -> None:
+    """
+    must raise NotImplemented for missing method
+    """
+    with pytest.raises(NotImplementedError):
+        executor.packages()
+
+
 def test_process_build(executor: Executor, package_ahriman: Package, mocker: MockerFixture) -> None:
    """
    must run build process
    """
-    mocker.patch("ahriman.core.repository.executor.Executor.packages_built", return_value=[package_ahriman])
    mocker.patch("ahriman.core.build_tools.task.Task.build", return_value=[Path(package_ahriman.base)])
    mocker.patch("ahriman.core.build_tools.task.Task.init")
    move_mock = mocker.patch("shutil.move")
    status_client_mock = mocker.patch("ahriman.core.status.client.Client.set_building")
+    built_packages_mock = mocker.patch("ahriman.core.repository.executor.Executor.packages_built")

-    # must return list of built packages
-    assert executor.process_build([package_ahriman]) == [package_ahriman]
+    executor.process_build([package_ahriman])
    # must move files (once)
    move_mock.assert_called_once()
    # must update status
@ -25,6 +36,8 @@ def test_process_build(executor: Executor, package_ahriman: Package, mocker: Moc
    # must clear directory
    from ahriman.core.repository.cleaner import Cleaner
    Cleaner.clear_build.assert_called_once()
+    # must return build packages after all
+    built_packages_mock.assert_called_once()


 def test_process_build_failure(executor: Executor, package_ahriman: Package, mocker: MockerFixture) -> None:
@ -68,7 +81,7 @@ def test_process_remove_base_multiple(executor: Executor, package_python_schedul
    executor.process_remove([package_python_schedule.base])
    # must remove via alpm wrapper
    repo_remove_mock.assert_has_calls([
-        mock.call(package, Path(props.filename))
+        mock.call(package, props.filepath)
        for package, props in package_python_schedule.packages.items()
    ], any_order=True)
    # must update status
@ -91,6 +104,15 @@ def test_process_remove_base_single(executor: Executor, package_python_schedule:
    status_client_mock.assert_not_called()


+def test_process_remove_failed(executor: Executor, package_ahriman: Package, mocker: MockerFixture) -> None:
+    """
+    must suppress remove errors
+    """
+    mocker.patch("ahriman.core.repository.executor.Executor.packages", return_value=[package_ahriman])
+    mocker.patch("ahriman.core.alpm.repo.Repo.remove", side_effect=Exception())
+    executor.process_remove([package_ahriman.base])
+
+
 def test_process_remove_nothing(executor: Executor, package_ahriman: Package, package_python_schedule: Package,
                                mocker: MockerFixture) -> None:
    """
@ -103,6 +125,18 @@ def test_process_remove_nothing(executor: Executor, package_ahriman: Package, pa
    repo_remove_mock.assert_not_called()


+def test_process_report(executor: Executor, package_ahriman: Package, mocker: MockerFixture) -> None:
+    """
+    must process report
+    """
+    mocker.patch("ahriman.core.repository.executor.Executor.packages", return_value=[package_ahriman])
+    mocker.patch("ahriman.core.report.report.Report.load", return_value=Report("x86_64", executor.configuration))
+    report_mock = mocker.patch("ahriman.core.report.report.Report.run")
+
+    executor.process_report(["dummy"])
+    report_mock.assert_called_once()
+
+
 def test_process_report_auto(executor: Executor, mocker: MockerFixture) -> None:
    """
    must process report in auto mode if no targets supplied
@ -113,7 +147,18 @@ def test_process_report_auto(executor: Executor, mocker: MockerFixture) -> None:
    configuration_getlist_mock.assert_called_once()


-def test_process_sync_auto(executor: Executor, mocker: MockerFixture) -> None:
+def test_process_upload(executor: Executor, mocker: MockerFixture) -> None:
+    """
+    must process sync in auto mode if no targets supplied
+    """
+    mocker.patch("ahriman.core.upload.upload.Upload.load", return_value=Upload("x86_64", executor.configuration))
+    upload_mock = mocker.patch("ahriman.core.upload.upload.Upload.run")
+
+    executor.process_sync(["dummy"])
+    upload_mock.assert_called_once()
+
+
+def test_process_upload_auto(executor: Executor, mocker: MockerFixture) -> None:
    """
    must process sync in auto mode if no targets supplied
    """
@ -134,7 +179,7 @@ def test_process_update(executor: Executor, package_ahriman: Package, mocker: Mo
    status_client_mock = mocker.patch("ahriman.core.status.client.Client.set_success")

    # must return complete
-    assert executor.process_update([Path(package.filename) for package in package_ahriman.packages.values()])
+    assert executor.process_update([package.filepath for package in package_ahriman.packages.values()])
    # must move files (once)
    move_mock.assert_called_once()
    # must sign package
@ -158,14 +203,23 @@ def test_process_update_group(executor: Executor, package_python_schedule: Packa
    repo_add_mock = mocker.patch("ahriman.core.alpm.repo.Repo.add")
    status_client_mock = mocker.patch("ahriman.core.status.client.Client.set_success")

-    executor.process_update([Path(package.filename) for package in package_python_schedule.packages.values()])
+    executor.process_update([package.filepath for package in package_python_schedule.packages.values()])
    repo_add_mock.assert_has_calls([
-        mock.call(executor.paths.repository / package.filename)
+        mock.call(executor.paths.repository / package.filepath)
        for package in package_python_schedule.packages.values()
    ], any_order=True)
    status_client_mock.assert_called_with(package_python_schedule)


+def test_process_empty_filename(executor: Executor, package_ahriman: Package, mocker: MockerFixture) -> None:
+    """
+    must skip update for package which does not have path
+    """
+    package_ahriman.packages[package_ahriman.base].filename = None
+    mocker.patch("ahriman.models.package.Package.load", return_value=package_ahriman)
+    executor.process_update([package.filepath for package in package_ahriman.packages.values()])
+
+
 def test_process_update_failed(executor: Executor, package_ahriman: Package, mocker: MockerFixture) -> None:
    """
    must process update for failed package
@ -174,7 +228,7 @@ def test_process_update_failed(executor: Executor, package_ahriman: Package, moc
    mocker.patch("ahriman.models.package.Package.load", return_value=package_ahriman)
    status_client_mock = mocker.patch("ahriman.core.status.client.Client.set_failed")

-    executor.process_update([Path(package.filename) for package in package_ahriman.packages.values()])
+    executor.process_update([package.filepath for package in package_ahriman.packages.values()])
    status_client_mock.assert_called_once()


@ -185,4 +239,4 @@ def test_process_update_failed_on_load(executor: Executor, package_ahriman: Pack
    mocker.patch("shutil.move")
    mocker.patch("ahriman.models.package.Package.load", side_effect=Exception())

-    assert executor.process_update([Path(package.filename) for package in package_ahriman.packages.values()])
+    assert executor.process_update([package.filepath for package in package_ahriman.packages.values()])
--- a/tests/ahriman/core/repository/test_repository.py
+++ b/tests/ahriman/core/repository/test_repository.py
@ -31,3 +31,28 @@ def test_packages(package_ahriman: Package, package_python_schedule: Package,
    expected = set(package_ahriman.packages.keys())
    expected.update(package_python_schedule.packages.keys())
    assert set(archives) == expected
+
+
+def test_packages_failed(repository: Repository, mocker: MockerFixture) -> None:
+    """
+    must skip packages which cannot be loaded
+    """
+    mocker.patch("pathlib.Path.iterdir", return_value=[Path("a.pkg.tar.xz")])
+    mocker.patch("ahriman.models.package.Package.load", side_effect=Exception())
+    assert not repository.packages()
+
+
+def test_packages_not_package(repository: Repository, mocker: MockerFixture) -> None:
+    """
+    must skip not packages from iteration
+    """
+    mocker.patch("pathlib.Path.iterdir", return_value=[Path("a.tar.xz")])
+    assert not repository.packages()
+
+
+def test_packages_built(repository: Repository, mocker: MockerFixture) -> None:
+    """
+    must return build packages
+    """
+    mocker.patch("pathlib.Path.iterdir", return_value=[Path("a.tar.xz"), Path("b.pkg.tar.xz")])
+    assert repository.packages_built() == [Path("b.pkg.tar.xz")]
--- a/tests/ahriman/core/repository/test_update_handler.py
+++ b/tests/ahriman/core/repository/test_update_handler.py
@ -1,9 +1,19 @@
+import pytest
+
 from pytest_mock import MockerFixture

 from ahriman.core.repository.update_handler import UpdateHandler
 from ahriman.models.package import Package


+def test_packages(update_handler: UpdateHandler) -> None:
+    """
+    must raise NotImplemented for missing method
+    """
+    with pytest.raises(NotImplementedError):
+        update_handler.packages()
+
+
 def test_updates_aur(update_handler: UpdateHandler, package_ahriman: Package,
                     mocker: MockerFixture) -> None:
    """
@ -50,7 +60,7 @@ def test_updates_aur_ignore(update_handler: UpdateHandler, package_ahriman: Pack
    """
    must skip ignore packages
    """
-    mocker.patch("ahriman.core.configuration.Configuration.getlist", return_value=[package_ahriman.base])
+    update_handler.ignore_list = [package_ahriman.base]
    mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.packages", return_value=[package_ahriman])
    package_load_mock = mocker.patch("ahriman.models.package.Package.load")

--- a/tests/ahriman/core/sign/test_gpg.py
+++ b/tests/ahriman/core/sign/test_gpg.py
@ -9,7 +9,7 @@ def test_repository_sign_args_1(gpg_with_key: GPG) -> None:
    """
    must generate correct sign args
    """
-    gpg_with_key.targets = {SignSettings.SignRepository}
+    gpg_with_key.targets = {SignSettings.Repository}
    assert gpg_with_key.repository_sign_args


@ -17,7 +17,7 @@ def test_repository_sign_args_2(gpg_with_key: GPG) -> None:
    """
    must generate correct sign args
    """
-    gpg_with_key.targets = {SignSettings.SignPackages, SignSettings.SignRepository}
+    gpg_with_key.targets = {SignSettings.Packages, SignSettings.Repository}
    assert gpg_with_key.repository_sign_args


@ -33,7 +33,7 @@ def test_repository_sign_args_skip_2(gpg_with_key: GPG) -> None:
    """
    must return empty args if it is not set
    """
-    gpg_with_key.targets = {SignSettings.SignPackages}
+    gpg_with_key.targets = {SignSettings.Packages}
    assert not gpg_with_key.repository_sign_args


@ -41,7 +41,7 @@ def test_repository_sign_args_skip_3(gpg: GPG) -> None:
    """
    must return empty args if it is not set
    """
-    gpg.targets = {SignSettings.SignRepository}
+    gpg.targets = {SignSettings.Repository}
    assert not gpg.repository_sign_args


@ -49,10 +49,28 @@ def test_repository_sign_args_skip_4(gpg: GPG) -> None:
    """
    must return empty args if it is not set
    """
-    gpg.targets = {SignSettings.SignPackages, SignSettings.SignRepository}
+    gpg.targets = {SignSettings.Packages, SignSettings.Repository}
    assert not gpg.repository_sign_args


+def test_sign_command(gpg_with_key: GPG) -> None:
+    """
+    must generate sign command
+    """
+    assert gpg_with_key.sign_command(Path("a"), gpg_with_key.default_key)
+
+
+def test_process(gpg_with_key: GPG, mocker: MockerFixture) -> None:
+    """
+    must call process method correctly
+    """
+    result = [Path("a"), Path("a.sig")]
+    check_output_mock = mocker.patch("ahriman.core.sign.gpg.GPG._check_output")
+
+    assert gpg_with_key.process(Path("a"), gpg_with_key.default_key) == result
+    check_output_mock.assert_called()
+
+
 def test_sign_package_1(gpg_with_key: GPG, mocker: MockerFixture) -> None:
    """
    must sign package
@ -60,7 +78,7 @@ def test_sign_package_1(gpg_with_key: GPG, mocker: MockerFixture) -> None:
    result = [Path("a"), Path("a.sig")]
    process_mock = mocker.patch("ahriman.core.sign.gpg.GPG.process", return_value=result)

-    gpg_with_key.targets = {SignSettings.SignPackages}
+    gpg_with_key.targets = {SignSettings.Packages}
    assert gpg_with_key.sign_package(Path("a"), "a") == result
    process_mock.assert_called_once()

@ -72,7 +90,7 @@ def test_sign_package_2(gpg_with_key: GPG, mocker: MockerFixture) -> None:
    result = [Path("a"), Path("a.sig")]
    process_mock = mocker.patch("ahriman.core.sign.gpg.GPG.process", return_value=result)

-    gpg_with_key.targets = {SignSettings.SignPackages, SignSettings.SignRepository}
+    gpg_with_key.targets = {SignSettings.Packages, SignSettings.Repository}
    assert gpg_with_key.sign_package(Path("a"), "a") == result
    process_mock.assert_called_once()

@ -92,7 +110,7 @@ def test_sign_package_skip_2(gpg_with_key: GPG, mocker: MockerFixture) -> None:
    must not sign package if it is not set
    """
    process_mock = mocker.patch("ahriman.core.sign.gpg.GPG.process")
-    gpg_with_key.targets = {SignSettings.SignRepository}
+    gpg_with_key.targets = {SignSettings.Repository}
    gpg_with_key.sign_package(Path("a"), "a")
    process_mock.assert_not_called()

@ -102,7 +120,7 @@ def test_sign_package_skip_3(gpg: GPG, mocker: MockerFixture) -> None:
    must not sign package if it is not set
    """
    process_mock = mocker.patch("ahriman.core.sign.gpg.GPG.process")
-    gpg.targets = {SignSettings.SignPackages}
+    gpg.targets = {SignSettings.Packages}
    gpg.sign_package(Path("a"), "a")
    process_mock.assert_not_called()

@ -112,7 +130,7 @@ def test_sign_package_skip_4(gpg: GPG, mocker: MockerFixture) -> None:
    must not sign package if it is not set
    """
    process_mock = mocker.patch("ahriman.core.sign.gpg.GPG.process")
-    gpg.targets = {SignSettings.SignPackages, SignSettings.SignRepository}
+    gpg.targets = {SignSettings.Packages, SignSettings.Repository}
    gpg.sign_package(Path("a"), "a")
    process_mock.assert_not_called()

@ -124,7 +142,7 @@ def test_sign_repository_1(gpg_with_key: GPG, mocker: MockerFixture) -> None:
    result = [Path("a"), Path("a.sig")]
    process_mock = mocker.patch("ahriman.core.sign.gpg.GPG.process", return_value=result)

-    gpg_with_key.targets = {SignSettings.SignRepository}
+    gpg_with_key.targets = {SignSettings.Repository}
    assert gpg_with_key.sign_repository(Path("a")) == result
    process_mock.assert_called_once()

@ -136,7 +154,7 @@ def test_sign_repository_2(gpg_with_key: GPG, mocker: MockerFixture) -> None:
    result = [Path("a"), Path("a.sig")]
    process_mock = mocker.patch("ahriman.core.sign.gpg.GPG.process", return_value=result)

-    gpg_with_key.targets = {SignSettings.SignPackages, SignSettings.SignRepository}
+    gpg_with_key.targets = {SignSettings.Packages, SignSettings.Repository}
    assert gpg_with_key.sign_repository(Path("a")) == result
    process_mock.assert_called_once()

@ -156,7 +174,7 @@ def test_sign_repository_skip_2(gpg_with_key: GPG, mocker: MockerFixture) -> Non
    must not sign repository if it is not set
    """
    process_mock = mocker.patch("ahriman.core.sign.gpg.GPG.process")
-    gpg_with_key.targets = {SignSettings.SignPackages}
+    gpg_with_key.targets = {SignSettings.Packages}
    gpg_with_key.sign_repository(Path("a"))
    process_mock.assert_not_called()

@ -166,7 +184,7 @@ def test_sign_repository_skip_3(gpg: GPG, mocker: MockerFixture) -> None:
    must not sign repository if it is not set
    """
    process_mock = mocker.patch("ahriman.core.sign.gpg.GPG.process")
-    gpg.targets = {SignSettings.SignRepository}
+    gpg.targets = {SignSettings.Repository}
    gpg.sign_repository(Path("a"))
    process_mock.assert_not_called()

@ -176,6 +194,6 @@ def test_sign_repository_skip_4(gpg: GPG, mocker: MockerFixture) -> None:
    must not sign repository if it is not set
    """
    process_mock = mocker.patch("ahriman.core.sign.gpg.GPG.process")
-    gpg.targets = {SignSettings.SignPackages, SignSettings.SignRepository}
+    gpg.targets = {SignSettings.Packages, SignSettings.Repository}
    gpg.sign_repository(Path("a"))
    process_mock.assert_not_called()
--- a/tests/ahriman/core/status/test_client.py
+++ b/tests/ahriman/core/status/test_client.py
@ -7,6 +7,22 @@ from ahriman.models.build_status import BuildStatusEnum
 from ahriman.models.package import Package


+def test_load_dummy_client(configuration: Configuration) -> None:
+    """
+    must load dummy client if no settings set
+    """
+    assert isinstance(Client.load(configuration), Client)
+
+
+def test_load_full_client(configuration: Configuration) -> None:
+    """
+    must load full client if no settings set
+    """
+    configuration.set("web", "host", "localhost")
+    configuration.set("web", "port", "8080")
+    assert isinstance(Client.load(configuration), WebClient)
+
+
 def test_add(client: Client, package_ahriman: Package) -> None:
    """
    must process package addition without errors
@ -98,19 +114,3 @@ def test_set_unknown(client: Client, package_ahriman: Package, mocker: MockerFix
    client.set_unknown(package_ahriman)

    add_mock.assert_called_with(package_ahriman, BuildStatusEnum.Unknown)
-
-
-def test_load_dummy_client(configuration: Configuration) -> None:
-    """
-    must load dummy client if no settings set
-    """
-    assert isinstance(Client.load(configuration), Client)
-
-
-def test_load_full_client(configuration: Configuration) -> None:
-    """
-    must load full client if no settings set
-    """
-    configuration.set("web", "host", "localhost")
-    configuration.set("web", "port", "8080")
-    assert isinstance(Client.load(configuration), WebClient)
--- a/tests/ahriman/core/status/test_watcher.py
+++ b/tests/ahriman/core/status/test_watcher.py
@ -51,6 +51,21 @@ def test_cache_load_no_file(watcher: Watcher, mocker: MockerFixture) -> None:
    assert not watcher.known


+def test_cache_load_package_load_error(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> None:
+    """
+    must not fail on json errors
+    """
+    response = {"packages": [pytest.helpers.get_package_status_extended(package_ahriman)]}
+
+    mocker.patch("pathlib.Path.is_file", return_value=True)
+    mocker.patch("pathlib.Path.open")
+    mocker.patch("ahriman.models.package.Package.from_json", side_effect=Exception())
+    mocker.patch("json.load", return_value=response)
+
+    watcher._cache_load()
+    assert not watcher.known
+
+
 def test_cache_load_unknown(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> None:
    """
    must not load unknown package
--- a/tests/ahriman/core/status/test_web_client.py
+++ b/tests/ahriman/core/status/test_web_client.py
@ -1,5 +1,6 @@
 import json
 import pytest
+import requests

 from pytest_mock import MockerFixture
 from requests import Response
@ -44,6 +45,14 @@ def test_add_failed(web_client: WebClient, package_ahriman: Package, mocker: Moc
    web_client.add(package_ahriman, BuildStatusEnum.Unknown)


+def test_add_failed_http_error(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
+    """
+    must suppress any exception happened during addition
+    """
+    mocker.patch("requests.post", side_effect=requests.exceptions.HTTPError())
+    web_client.add(package_ahriman, BuildStatusEnum.Unknown)
+
+
 def test_get_all(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
    """
    must return all packages status
@ -69,6 +78,14 @@ def test_get_failed(web_client: WebClient, mocker: MockerFixture) -> None:
    assert web_client.get(None) == []


+def test_get_failed_http_error(web_client: WebClient, mocker: MockerFixture) -> None:
+    """
+    must suppress any exception happened during status getting
+    """
+    mocker.patch("requests.get", side_effect=requests.exceptions.HTTPError())
+    assert web_client.get(None) == []
+
+
 def test_get_single(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
    """
    must return single package status
@ -109,6 +126,14 @@ def test_get_self_failed(web_client: WebClient, mocker: MockerFixture) -> None:
    assert web_client.get_self().status == BuildStatusEnum.Unknown


+def test_get_self_failed_http_error(web_client: WebClient, mocker: MockerFixture) -> None:
+    """
+    must suppress any exception happened during service status getting
+    """
+    mocker.patch("requests.get", side_effect=requests.exceptions.HTTPError())
+    assert web_client.get_self().status == BuildStatusEnum.Unknown
+
+
 def test_remove(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
    """
    must process package removal
@ -127,6 +152,14 @@ def test_remove_failed(web_client: WebClient, package_ahriman: Package, mocker:
    web_client.remove(package_ahriman.base)


+def test_remove_failed_http_error(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
+    """
+    must suppress any exception happened during removal
+    """
+    mocker.patch("requests.delete", side_effect=requests.exceptions.HTTPError())
+    web_client.remove(package_ahriman.base)
+
+
 def test_update(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
    """
    must process package update
@ -145,6 +178,14 @@ def test_update_failed(web_client: WebClient, package_ahriman: Package, mocker:
    web_client.update(package_ahriman.base, BuildStatusEnum.Unknown)


+def test_update_failed_http_error(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
+    """
+    must suppress any exception happened during update
+    """
+    mocker.patch("requests.post", side_effect=requests.exceptions.HTTPError())
+    web_client.update(package_ahriman.base, BuildStatusEnum.Unknown)
+
+
 def test_update_self(web_client: WebClient, mocker: MockerFixture) -> None:
    """
    must process service update
@ -161,3 +202,11 @@ def test_update_self_failed(web_client: WebClient, mocker: MockerFixture) -> Non
    """
    mocker.patch("requests.post", side_effect=Exception())
    web_client.update_self(BuildStatusEnum.Unknown)
+
+
+def test_update_self_failed_http_error(web_client: WebClient, mocker: MockerFixture) -> None:
+    """
+    must suppress any exception happened during service update
+    """
+    mocker.patch("requests.post", side_effect=requests.exceptions.HTTPError())
+    web_client.update_self(BuildStatusEnum.Unknown)
--- a/tests/ahriman/core/test_configuration.py
+++ b/tests/ahriman/core/test_configuration.py
@ -14,8 +14,8 @@ def test_from_path(mocker: MockerFixture) -> None:
    load_logging_mock = mocker.patch("ahriman.core.configuration.Configuration.load_logging")
    path = Path("path")

-    config = Configuration.from_path(path, "x86_64", True)
-    assert config.path == path
+    configuration = Configuration.from_path(path, "x86_64", True)
+    assert configuration.path == path
    read_mock.assert_called_with(path)
    load_includes_mock.assert_called_once()
    load_logging_mock.assert_called_once()
@ -25,7 +25,7 @@ def test_section_name(configuration: Configuration) -> None:
    """
    must return architecture specific group
    """
-    assert configuration.section_name("build", "x86_64") == "build_x86_64"
+    assert configuration.section_name("build", "x86_64") == "build:x86_64"


 def test_absolute_path_for_absolute(configuration: Configuration) -> None:
@ -60,14 +60,15 @@ def test_dump_architecture_specific(configuration: Configuration) -> None:
    """
    dump must contain architecture specific settings
    """
-    configuration.add_section("build_x86_64")
-    configuration.set("build_x86_64", "archbuild_flags", "hello flag")
+    section = configuration.section_name("build", "x86_64")
+    configuration.add_section(section)
+    configuration.set(section, "archbuild_flags", "hello flag")
    configuration.merge_sections("x86_64")

    dump = configuration.dump()
    assert dump
    assert "build" in dump
-    assert "build_x86_64" not in dump
+    assert section not in dump
    assert dump["build"]["archbuild_flags"] == "hello flag"


@ -104,6 +105,14 @@ def test_load_includes_missing(configuration: Configuration) -> None:
    configuration.load_includes()


+def test_load_includes_no_option(configuration: Configuration) -> None:
+    """
+    must not fail if no option set
+    """
+    configuration.remove_option("settings", "include")
+    configuration.load_includes()
+
+
 def test_load_logging_fallback(configuration: Configuration, mocker: MockerFixture) -> None:
    """
    must fallback to stderr without errors
@ -125,9 +134,10 @@ def test_merge_sections_missing(configuration: Configuration) -> None:
    """
    must merge create section if not exists
    """
+    section = configuration.section_name("build", "x86_64")
    configuration.remove_section("build")
-    configuration.add_section("build_x86_64")
-    configuration.set("build_x86_64", "key", "value")
+    configuration.add_section(section)
+    configuration.set(section, "key", "value")

    configuration.merge_sections("x86_64")
    assert configuration.get("build", "key") == "value"
--- a/tests/ahriman/core/test_util.py
+++ b/tests/ahriman/core/test_util.py
@ -4,6 +4,7 @@ import subprocess

 from pytest_mock import MockerFixture

+from ahriman.core.exceptions import InvalidOption
 from ahriman.core.util import check_output, package_like, pretty_datetime, pretty_size
 from ahriman.models.package import Package

@ -124,6 +125,14 @@ def test_pretty_size_pbytes() -> None:
    assert abbrev == "GiB"


+def test_pretty_size_pbytes_failure() -> None:
+    """
+    must raise exception if level >= 4 supplied
+    """
+    with pytest.raises(InvalidOption):
+        pretty_size(42 * 1024 * 1024 * 1024 * 1024, 4).split()
+
+
 def test_pretty_size_empty() -> None:
    """
    must generate empty string for None value
--- a/tests/ahriman/core/upload/test_uploader.py
+++ b/tests/ahriman/core/upload/test_uploader.py
@ -15,7 +15,17 @@ def test_upload_failure(configuration: Configuration, mocker: MockerFixture) ->
    """
    mocker.patch("ahriman.core.upload.rsync.Rsync.sync", side_effect=Exception())
    with pytest.raises(SyncFailed):
-        Upload.run("x86_64", configuration, UploadSettings.Rsync.name, Path("path"))
+        Upload.load("x86_64", configuration, UploadSettings.Rsync.name).run(Path("path"))
+
+
+def test_report_dummy(configuration: Configuration, mocker: MockerFixture) -> None:
+    """
+    must construct dummy upload class
+    """
+    mocker.patch("ahriman.models.upload_settings.UploadSettings.from_option", return_value=UploadSettings.Disabled)
+    upload_mock = mocker.patch("ahriman.core.upload.upload.Upload.sync")
+    Upload.load("x86_64", configuration, UploadSettings.Disabled.name).run(Path("path"))
+    upload_mock.assert_called_once()


 def test_upload_rsync(configuration: Configuration, mocker: MockerFixture) -> None:
@ -23,7 +33,7 @@ def test_upload_rsync(configuration: Configuration, mocker: MockerFixture) -> No
    must upload via rsync
    """
    upload_mock = mocker.patch("ahriman.core.upload.rsync.Rsync.sync")
-    Upload.run("x86_64", configuration, UploadSettings.Rsync.name, Path("path"))
+    Upload.load("x86_64", configuration, UploadSettings.Rsync.name).run(Path("path"))
    upload_mock.assert_called_once()


@ -32,5 +42,5 @@ def test_upload_s3(configuration: Configuration, mocker: MockerFixture) -> None:
    must upload via s3
    """
    upload_mock = mocker.patch("ahriman.core.upload.s3.S3.sync")
-    Upload.run("x86_64", configuration, UploadSettings.S3.name, Path("path"))
+    Upload.load("x86_64", configuration, UploadSettings.S3.name).run(Path("path"))
    upload_mock.assert_called_once()
--- a/tests/ahriman/models/conftest.py
+++ b/tests/ahriman/models/conftest.py
@ -42,6 +42,7 @@ def pyalpm_package_description_ahriman(package_description_ahriman: PackageDescr
    mock = MagicMock()
    type(mock).arch = PropertyMock(return_value=package_description_ahriman.architecture)
    type(mock).builddate = PropertyMock(return_value=package_description_ahriman.build_date)
+    type(mock).depends = PropertyMock(return_value=package_description_ahriman.depends)
    type(mock).desc = PropertyMock(return_value=package_description_ahriman.description)
    type(mock).groups = PropertyMock(return_value=package_description_ahriman.groups)
    type(mock).isize = PropertyMock(return_value=package_description_ahriman.installed_size)
--- a/tests/ahriman/models/test_build_status.py
+++ b/tests/ahriman/models/test_build_status.py
@ -1,3 +1,5 @@
+import datetime
+
 from ahriman.models.build_status import BuildStatus, BuildStatusEnum


@ -36,3 +38,59 @@ 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 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)
+
+
+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 test_build_status_eq_self(build_status_failed: BuildStatus) -> None:
+    """
+    must be equal itself
+    """
+    assert build_status_failed == build_status_failed
+
+
+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_ne_other(build_status_failed: BuildStatus) -> None:
+    """
+    must be not equal to random object
+    """
+    assert build_status_failed != object()
+
+
+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)
--- a/tests/ahriman/models/test_package.py
+++ b/tests/ahriman/models/test_package.py
@ -9,6 +9,16 @@ from ahriman.models.package import Package
 from ahriman.models.repository_paths import RepositoryPaths


+def test_depends(package_python_schedule: Package) -> None:
+    """
+    must return combined list of dependencies
+    """
+    assert all(
+        set(package_python_schedule.depends).intersection(package.depends)
+        for package in package_python_schedule.packages.values()
+    )
+
+
 def test_git_url(package_ahriman: Package) -> None:
    """
    must generate valid git url
@ -114,6 +124,17 @@ def test_from_build(package_ahriman: Package, mocker: MockerFixture, resource_pa
    assert package_ahriman == package


+def test_from_build_failed(package_ahriman: Package, mocker: MockerFixture) -> None:
+    """
+    must raise exception if there are errors during srcinfo load
+    """
+    mocker.patch("pathlib.Path.read_text", return_value="")
+    mocker.patch("ahriman.models.package.parse_srcinfo", return_value=({"packages": {}}, ["an error"]))
+
+    with pytest.raises(InvalidPackageInfo):
+        Package.from_build(Path("path"), package_ahriman.aur_url)
+
+
 def test_from_json_view_1(package_ahriman: Package) -> None:
    """
    must construct same object from json
@ -135,24 +156,6 @@ def test_from_json_view_3(package_tpacpi_bat_git: Package) -> None:
    assert Package.from_json(package_tpacpi_bat_git.view()) == package_tpacpi_bat_git


-def test_dependencies_with_version(mocker: MockerFixture, resource_path_root: Path) -> None:
-    """
-    must load correct list of dependencies with version
-    """
-    srcinfo = (resource_path_root / "models" / "package_yay_srcinfo").read_text()
-    mocker.patch("pathlib.Path.read_text", return_value=srcinfo)
-
-    assert Package.dependencies(Path("path")) == {"git", "go", "pacman"}
-
-
-def test_full_version() -> None:
-    """
-    must construct full version
-    """
-    assert Package.full_version("1", "r2388.d30e3201", "1") == "1:r2388.d30e3201-1"
-    assert Package.full_version(None, "0.12.1", "1") == "0.12.1-1"
-
-
 def test_load_from_archive(package_ahriman: Package, pyalpm_handle: MagicMock, mocker: MockerFixture) -> None:
    """
    must load package from package archive
@ -198,6 +201,35 @@ def test_load_failure(package_ahriman: Package, pyalpm_handle: MagicMock, mocker
        Package.load(Path("path"), pyalpm_handle, package_ahriman.aur_url)


+def test_dependencies_failed(mocker: MockerFixture) -> None:
+    """
+    must raise exception if there are errors during srcinfo load
+    """
+    mocker.patch("pathlib.Path.read_text", return_value="")
+    mocker.patch("ahriman.models.package.parse_srcinfo", return_value=({"packages": {}}, ["an error"]))
+
+    with pytest.raises(InvalidPackageInfo):
+        Package.dependencies(Path("path"))
+
+
+def test_dependencies_with_version(mocker: MockerFixture, resource_path_root: Path) -> None:
+    """
+    must load correct list of dependencies with version
+    """
+    srcinfo = (resource_path_root / "models" / "package_yay_srcinfo").read_text()
+    mocker.patch("pathlib.Path.read_text", return_value=srcinfo)
+
+    assert Package.dependencies(Path("path")) == {"git", "go", "pacman"}
+
+
+def test_full_version() -> None:
+    """
+    must construct full version
+    """
+    assert Package.full_version("1", "r2388.d30e3201", "1") == "1:r2388.d30e3201-1"
+    assert Package.full_version(None, "0.12.1", "1") == "0.12.1-1"
+
+
 def test_actual_version(package_ahriman: Package, repository_paths: RepositoryPaths) -> None:
    """
    must return same actual_version as version is
@ -217,12 +249,25 @@ def test_actual_version_vcs(package_tpacpi_bat_git: Package, repository_paths: R
    assert package_tpacpi_bat_git.actual_version(repository_paths) == "3.1.r13.g4959b52-1"


+def test_actual_version_srcinfo_failed(package_tpacpi_bat_git: Package, repository_paths: RepositoryPaths,
+                                       mocker: MockerFixture) -> None:
+    """
+    must return same version in case if exception occurred
+    """
+    mocker.patch("ahriman.models.package.Package._check_output", side_effect=Exception())
+    mocker.patch("ahriman.core.build_tools.task.Task.fetch")
+
+    assert package_tpacpi_bat_git.actual_version(repository_paths) == package_tpacpi_bat_git.version
+
+
 def test_actual_version_vcs_failed(package_tpacpi_bat_git: Package, repository_paths: RepositoryPaths,
                                   mocker: MockerFixture) -> None:
    """
    must return same version in case if exception occurred
    """
-    mocker.patch("ahriman.models.package.Package._check_output", side_effect=Exception())
+    mocker.patch("pathlib.Path.read_text", return_value="")
+    mocker.patch("ahriman.models.package.parse_srcinfo", return_value=({"packages": {}}, ["an error"]))
+    mocker.patch("ahriman.models.package.Package._check_output")
    mocker.patch("ahriman.core.build_tools.task.Task.fetch")

    assert package_tpacpi_bat_git.actual_version(repository_paths) == package_tpacpi_bat_git.version
@ -243,3 +288,11 @@ def test_is_outdated_true(package_ahriman: Package, repository_paths: Repository
    other.version = other.version.replace("-1", "-2")

    assert package_ahriman.is_outdated(other, repository_paths)
+
+
+def test_build_status_pretty_print(package_ahriman: Package) -> None:
+    """
+    must return string in pretty print function
+    """
+    assert package_ahriman.pretty_print()
+    assert isinstance(package_ahriman.pretty_print(), str)
--- a/tests/ahriman/models/test_package_desciption.py
+++ b/tests/ahriman/models/test_package_desciption.py
@ -1,3 +1,4 @@
+from dataclasses import asdict
 from unittest.mock import MagicMock

 from ahriman.models.package_description import PackageDescription
@ -19,6 +20,22 @@ def test_filepath_empty(package_description_ahriman: PackageDescription) -> None
    assert package_description_ahriman.filepath is None


+def test_from_json(package_description_ahriman: PackageDescription) -> None:
+    """
+    must construct description from json object
+    """
+    assert PackageDescription.from_json(asdict(package_description_ahriman)) == package_description_ahriman
+
+
+def test_from_json_with_unknown_fields(package_description_ahriman: PackageDescription) -> None:
+    """
+    must construct description from json object containing unknown fields
+    """
+    dump = asdict(package_description_ahriman)
+    dump.update(unknown_field="value")
+    assert PackageDescription.from_json(dump) == package_description_ahriman
+
+
 def test_from_package(package_description_ahriman: PackageDescription,
                      pyalpm_package_description_ahriman: MagicMock) -> None:
    """
--- a/tests/ahriman/models/test_sign_settings.py
+++ b/tests/ahriman/models/test_sign_settings.py
@ -16,11 +16,11 @@ def test_from_option_valid() -> None:
    """
    must return value from valid options
    """
-    assert SignSettings.from_option("package") == SignSettings.SignPackages
-    assert SignSettings.from_option("PACKAGE") == SignSettings.SignPackages
-    assert SignSettings.from_option("packages") == SignSettings.SignPackages
-    assert SignSettings.from_option("sign-package") == SignSettings.SignPackages
+    assert SignSettings.from_option("package") == SignSettings.Packages
+    assert SignSettings.from_option("PACKAGE") == SignSettings.Packages
+    assert SignSettings.from_option("packages") == SignSettings.Packages
+    assert SignSettings.from_option("sign-package") == SignSettings.Packages

-    assert SignSettings.from_option("repository") == SignSettings.SignRepository
-    assert SignSettings.from_option("REPOSITORY") == SignSettings.SignRepository
-    assert SignSettings.from_option("sign-repository") == SignSettings.SignRepository
+    assert SignSettings.from_option("repository") == SignSettings.Repository
+    assert SignSettings.from_option("REPOSITORY") == SignSettings.Repository
+    assert SignSettings.from_option("sign-repository") == SignSettings.Repository
--- a/tests/ahriman/web/test_web.py
+++ b/tests/ahriman/web/test_web.py
@ -34,12 +34,10 @@ def test_run(application: web.Application, mocker: MockerFixture) -> None:
    """
    must run application
    """
-    host = "localhost"
    port = 8080
-    application["configuration"].set("web", "host", host)
    application["configuration"].set("web", "port", str(port))
    run_application_mock = mocker.patch("aiohttp.web.run_app")

    run_server(application)
-    run_application_mock.assert_called_with(application, host=host, port=port,
+    run_application_mock.assert_called_with(application, host="0.0.0.0", port=port,
                                            handle_signals=False, access_log=pytest.helpers.anyvar(int))
--- a/tests/ahriman/web/views/test_view_ahriman.py
+++ b/tests/ahriman/web/views/test_view_ahriman.py
@ -1,4 +1,5 @@
 from aiohttp.test_utils import TestClient
+from pytest_mock import MockerFixture

 from ahriman.models.build_status import BuildStatus, BuildStatusEnum

@ -35,3 +36,14 @@ async def test_post_exception(client: TestClient) -> None:
    """
    post_response = await client.post("/api/v1/ahriman", json={})
    assert post_response.status == 400
+
+
+async def test_post_exception_inside(client: TestClient, mocker: MockerFixture) -> None:
+    """
+    exception handler must handle 500 errors
+    """
+    payload = {"status": BuildStatusEnum.Success.value}
+    mocker.patch("ahriman.core.status.watcher.Watcher.update_self", side_effect=Exception())
+
+    post_response = await client.post("/api/v1/ahriman", json=payload)
+    assert post_response.status == 500
--- a/tests/testresources/core/ahriman.ini
+++ b/tests/testresources/core/ahriman.ini
@ -43,4 +43,5 @@ bucket =
 command = aws s3 sync --quiet --delete

 [web]
+host = 0.0.0.0
 templates = ../web/templates
Author	SHA1	Message	Date
Evgeniy Alekseev	a0e20ffb77	Release 0.21.2	2021-04-05 02:01:28 +03:00
Evgeniy Alekseev	96e4abc3c0	add changelog generator to both gh-actions and repository	2021-04-05 02:00:05 +03:00
Evgeniy Alekseev	6df60498aa	Release 0.21.1	2021-04-05 00:45:12 +03:00
Evgeniy Alekseev	eb0a4b6b4a	use globing instead	2021-04-05 00:44:39 +03:00
Evgeniy Alekseev	8f469e7eac	Release 0.21.0	2021-04-05 00:38:23 +03:00
Evgeniy Alekseev	535e955814	try to make auto archive upload	2021-04-05 00:37:03 +03:00
Evgeniy Alekseev	0bd3ba626a	implicit type conversion from command line	2021-04-04 23:53:30 +03:00
Evgeniy Alekseev	ffe6aec190	more options in setup command	2021-04-04 15:42:06 +03:00
Evgeniy Alekseev	56c600e5ac	fix check errors	2021-04-04 14:00:42 +03:00
Evgeniy Alekseev	461883217d	100% coverage	2021-04-03 21:30:57 +03:00
Evgeniy Alekseev	62d55eff19	add ability to fitler by dependency list	2021-04-02 04:20:39 +03:00
Evgeniy Alekseev	534b5600b4	add ability to remove package from status page	2021-04-02 01:26:46 +03:00
Evgeniy Alekseev	32cbafd12b	Release 0.20.0	2021-04-01 02:38:59 +03:00
Evgeniy Alekseev	880c70bd58	constistent classmethod and staticmethod usage General idea is to use classmethod for every constructor and statismethod otherwise. Also use self and cls whenever it's possible to call static and class methods	2021-03-31 04:29:08 +03:00
Evgeniy Alekseev	d449eb3c2e	change arch specific section naming from section_arch to section:arch Some archs can have _ in their name. Also in future we can use sections with similar names	2021-03-31 02:31:14 +03:00