Add tests (#1) (#5)

* add models tests (#1)

also replace single quote to double one to confort PEP docstring
+ move _check_output to class properties to make it available for
mocking

* alpm tests implementation

* try to replace os with pathlib

* update tests for pathlib

* fix includes glob and trim version from dependencies

* build_tools package tests

* repository component tests

* add sign tests

* complete status tests

* handle exceptions in actual_version calls

* complete core tests

* move configuration to root conftest

* application tests

* complete application tests

* change copyright to more generic one

* base web tests

* complete web tests

* complete testkit

also add argument parsers test

tests/ahriman/application/conftest.py

@@ -0,0 +1,30 @@
+import argparse
+import pytest
+
+from pytest_mock import MockerFixture
+
+from ahriman.application.ahriman import _parser
+from ahriman.application.application import Application
+from ahriman.application.lock import Lock
+from ahriman.core.configuration import Configuration
+
+
+@pytest.fixture
+def application(configuration: Configuration, mocker: MockerFixture) -> Application:
+    mocker.patch("pathlib.Path.mkdir")
+    return Application("x86_64", configuration)
+
+
+@pytest.fixture
+def args() -> argparse.Namespace:
+    return argparse.Namespace(lock=None, force=False, unsafe=False, no_report=True)
+
+
+@pytest.fixture
+def lock(args: argparse.Namespace, configuration: Configuration) -> Lock:
+    return Lock(args, "x86_64", configuration)
+
+
+@pytest.fixture
+def parser() -> argparse.ArgumentParser:
+    return _parser()

tests/ahriman/application/handlers/test_handler.py

@@ -0,0 +1,27 @@
+import argparse
+
+from pytest_mock import MockerFixture
+
+from ahriman.application.handlers import Handler
+from ahriman.core.configuration import Configuration
+
+
+def test_call(args: argparse.Namespace, configuration: Configuration, mocker: MockerFixture) -> None:
+    """
+    must call inside lock
+    """
+    mocker.patch("ahriman.application.handlers.Handler.run")
+    enter_mock = mocker.patch("ahriman.application.lock.Lock.__enter__")
+    exit_mock = mocker.patch("ahriman.application.lock.Lock.__exit__")
+
+    assert Handler._call(args, "x86_64", configuration)
+    enter_mock.assert_called_once()
+    exit_mock.assert_called_once()
+
+
+def test_call_exception(args: argparse.Namespace, configuration: Configuration, mocker: MockerFixture) -> None:
+    """
+    must process exception
+    """
+    mocker.patch("ahriman.application.lock.Lock.__enter__", side_effect=Exception())
+    assert not Handler._call(args, "x86_64", configuration)

tests/ahriman/application/handlers/test_handler_add.py

@@ -0,0 +1,19 @@
+import argparse
+
+from pytest_mock import MockerFixture
+
+from ahriman.application.handlers import Add
+from ahriman.core.configuration import Configuration
+
+
+def test_run(args: argparse.Namespace, configuration: Configuration, mocker: MockerFixture) -> None:
+    """
+    must run command
+    """
+    args.package = []
+    args.without_dependencies = False
+    mocker.patch("pathlib.Path.mkdir")
+    application_mock = mocker.patch("ahriman.application.application.Application.add")
+
+    Add.run(args, "x86_64", configuration)
+    application_mock.assert_called_once()

tests/ahriman/application/handlers/test_handler_clean.py

@@ -0,0 +1,22 @@
+import argparse
+
+from pytest_mock import MockerFixture
+
+from ahriman.application.handlers import Clean
+from ahriman.core.configuration import Configuration
+
+
+def test_run(args: argparse.Namespace, configuration: Configuration, mocker: MockerFixture) -> None:
+    """
+    must run command
+    """
+    args.no_build = False
+    args.no_cache = False
+    args.no_chroot = False
+    args.no_manual = False
+    args.no_packages = False
+    mocker.patch("pathlib.Path.mkdir")
+    application_mock = mocker.patch("ahriman.application.application.Application.clean")
+
+    Clean.run(args, "x86_64", configuration)
+    application_mock.assert_called_once()

tests/ahriman/application/handlers/test_handler_dump.py

@@ -0,0 +1,17 @@
+import argparse
+
+from pytest_mock import MockerFixture
+
+from ahriman.application.handlers import Dump
+from ahriman.core.configuration import Configuration
+
+
+def test_run(args: argparse.Namespace, configuration: Configuration, mocker: MockerFixture) -> None:
+    """
+    must run command
+    """
+    mocker.patch("pathlib.Path.mkdir")
+    application_mock = mocker.patch("ahriman.core.configuration.Configuration.dump")
+
+    Dump.run(args, "x86_64", configuration)
+    application_mock.assert_called_once()

tests/ahriman/application/handlers/test_handler_rebuild.py

@@ -0,0 +1,19 @@
+import argparse
+
+from pytest_mock import MockerFixture
+
+from ahriman.application.handlers import Rebuild
+from ahriman.core.configuration import Configuration
+
+
+def test_run(args: argparse.Namespace, configuration: Configuration, mocker: MockerFixture) -> None:
+    """
+    must run command
+    """
+    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")
+
+    Rebuild.run(args, "x86_64", configuration)
+    application_packages_mock.assert_called_once()
+    application_mock.assert_called_once()

tests/ahriman/application/handlers/test_handler_remove.py

@@ -0,0 +1,18 @@
+import argparse
+
+from pytest_mock import MockerFixture
+
+from ahriman.application.handlers import Remove
+from ahriman.core.configuration import Configuration
+
+
+def test_run(args: argparse.Namespace, configuration: Configuration, mocker: MockerFixture) -> None:
+    """
+    must run command
+    """
+    args.package = []
+    mocker.patch("pathlib.Path.mkdir")
+    application_mock = mocker.patch("ahriman.application.application.Application.remove")
+
+    Remove.run(args, "x86_64", configuration)
+    application_mock.assert_called_once()

tests/ahriman/application/handlers/test_handler_report.py

@@ -0,0 +1,18 @@
+import argparse
+
+from pytest_mock import MockerFixture
+
+from ahriman.application.handlers import Report
+from ahriman.core.configuration import Configuration
+
+
+def test_run(args: argparse.Namespace, configuration: Configuration, mocker: MockerFixture) -> None:
+    """
+    must run command
+    """
+    args.target = []
+    mocker.patch("pathlib.Path.mkdir")
+    application_mock = mocker.patch("ahriman.application.application.Application.report")
+
+    Report.run(args, "x86_64", configuration)
+    application_mock.assert_called_once()

tests/ahriman/application/handlers/test_handler_status.py

@@ -0,0 +1,22 @@
+import argparse
+
+from pytest_mock import MockerFixture
+
+from ahriman.application.handlers import Status
+from ahriman.core.configuration import Configuration
+
+
+def test_run(args: argparse.Namespace, configuration: Configuration, mocker: MockerFixture) -> None:
+    """
+    must run command
+    """
+    args.ahriman = True
+    args.package = []
+    args.without_dependencies = False
+    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")
+
+    Status.run(args, "x86_64", configuration)
+    application_mock.assert_called_once()
+    packages_mock.assert_called_once()

tests/ahriman/application/handlers/test_handler_sync.py

@@ -0,0 +1,18 @@
+import argparse
+
+from pytest_mock import MockerFixture
+
+from ahriman.application.handlers import Sync
+from ahriman.core.configuration import Configuration
+
+
+def test_run(args: argparse.Namespace, configuration: Configuration, mocker: MockerFixture) -> None:
+    """
+    must run command
+    """
+    args.target = []
+    mocker.patch("pathlib.Path.mkdir")
+    application_mock = mocker.patch("ahriman.application.application.Application.sync")
+
+    Sync.run(args, "x86_64", configuration)
+    application_mock.assert_called_once()

tests/ahriman/application/handlers/test_handler_update.py

@@ -0,0 +1,40 @@
+import argparse
+
+from pytest_mock import MockerFixture
+
+from ahriman.application.handlers import Update
+from ahriman.core.configuration import Configuration
+
+
+def test_run(args: argparse.Namespace, configuration: Configuration, mocker: MockerFixture) -> None:
+    """
+    must run command
+    """
+    args.package = []
+    args.dry_run = False
+    args.no_aur = False
+    args.no_manual = False
+    args.no_vcs = False
+    mocker.patch("pathlib.Path.mkdir")
+    application_mock = mocker.patch("ahriman.application.application.Application.update")
+    updates_mock = mocker.patch("ahriman.application.application.Application.get_updates")
+
+    Update.run(args, "x86_64", configuration)
+    application_mock.assert_called_once()
+    updates_mock.assert_called_once()
+
+
+def test_run_dry_run(args: argparse.Namespace, configuration: Configuration, mocker: MockerFixture) -> None:
+    """
+    must run simplified command
+    """
+    args.package = []
+    args.dry_run = True
+    args.no_aur = False
+    args.no_manual = False
+    args.no_vcs = False
+    mocker.patch("pathlib.Path.mkdir")
+    updates_mock = mocker.patch("ahriman.application.application.Application.get_updates")
+
+    Update.run(args, "x86_64", configuration)
+    updates_mock.assert_called_once()

tests/ahriman/application/handlers/test_handler_web.py

@@ -0,0 +1,19 @@
+import argparse
+
+from pytest_mock import MockerFixture
+
+from ahriman.application.handlers import Web
+from ahriman.core.configuration import Configuration
+
+
+def test_run(args: argparse.Namespace, configuration: Configuration, mocker: MockerFixture) -> None:
+    """
+    must run command
+    """
+    mocker.patch("pathlib.Path.mkdir")
+    setup_mock = mocker.patch("ahriman.web.web.setup_service")
+    run_mock = mocker.patch("ahriman.web.web.run_server")
+
+    Web.run(args, "x86_64", configuration)
+    setup_mock.assert_called_once()
+    run_mock.assert_called_once()

tests/ahriman/application/test_ahriman.py

@@ -0,0 +1,55 @@
+import argparse
+
+
+def test_parser(parser: argparse.ArgumentParser) -> None:
+    """
+    must parse valid command line
+    """
+    parser.parse_args(["-a", "x86_64", "config"])
+
+
+def test_multiple_architectures(parser: argparse.ArgumentParser) -> None:
+    """
+    must accept multiple architectures
+    """
+    args = parser.parse_args(["-a", "x86_64", "-a", "i686", "config"])
+    assert len(args.architecture) == 2
+
+
+def test_subparsers_check(parser: argparse.ArgumentParser) -> None:
+    """
+    check command must imply no_aur, no_manual and dry_run
+    """
+    args = parser.parse_args(["-a", "x86_64", "check"])
+    assert not args.no_aur
+    assert args.no_manual
+    assert args.dry_run
+
+
+def test_subparsers_config(parser: argparse.ArgumentParser) -> None:
+    """
+    config command must imply lock, no_report and unsafe
+    """
+    args = parser.parse_args(["-a", "x86_64", "config"])
+    assert args.lock is None
+    assert args.no_report
+    assert args.unsafe
+
+
+def test_subparsers_status(parser: argparse.ArgumentParser) -> None:
+    """
+    status command must imply lock, no_report and unsafe
+    """
+    args = parser.parse_args(["-a", "x86_64", "status"])
+    assert args.lock is None
+    assert args.no_report
+    assert args.unsafe
+
+
+def test_subparsers_web(parser: argparse.ArgumentParser) -> None:
+    """
+    web command must imply lock and no_report
+    """
+    args = parser.parse_args(["-a", "x86_64", "web"])
+    assert args.lock is None
+    assert args.no_report

tests/ahriman/application/test_application.py

@@ -0,0 +1,237 @@
+from pytest_mock import MockerFixture
+from unittest import mock
+
+from ahriman.application.application import Application
+from ahriman.core.tree import Leaf, Tree
+from ahriman.models.package import Package
+
+
+def test_finalize(application: Application, mocker: MockerFixture) -> None:
+    """
+    must report and sync at the last
+    """
+    report_mock = mocker.patch("ahriman.application.application.Application.report")
+    sync_mock = mocker.patch("ahriman.application.application.Application.sync")
+
+    application._finalize()
+    report_mock.assert_called_once()
+    sync_mock.assert_called_once()
+
+
+def test_get_updates_all(application: Application, mocker: MockerFixture) -> None:
+    """
+    must get updates for all
+    """
+    updates_aur_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.updates_aur")
+    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)
+    updates_aur_mock.assert_called_with([], False)
+    updates_manual_mock.assert_called_once()
+
+
+def test_get_updates_disabled(application: Application, mocker: MockerFixture) -> None:
+    """
+    must get updates without anything
+    """
+    updates_aur_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.updates_aur")
+    updates_manual_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.updates_manual")
+
+    application.get_updates([], no_aur=True, no_manual=True, no_vcs=False, log_fn=print)
+    updates_aur_mock.assert_not_called()
+    updates_manual_mock.assert_not_called()
+
+
+def test_get_updates_no_aur(application: Application, mocker: MockerFixture) -> None:
+    """
+    must get updates without aur
+    """
+    updates_aur_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.updates_aur")
+    updates_manual_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.updates_manual")
+
+    application.get_updates([], no_aur=True, no_manual=False, no_vcs=False, log_fn=print)
+    updates_aur_mock.assert_not_called()
+    updates_manual_mock.assert_called_once()
+
+
+def test_get_updates_no_manual(application: Application, mocker: MockerFixture) -> None:
+    """
+    must get updates without manual
+    """
+    updates_aur_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.updates_aur")
+    updates_manual_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.updates_manual")
+
+    application.get_updates([], no_aur=False, no_manual=True, no_vcs=False, log_fn=print)
+    updates_aur_mock.assert_called_with([], False)
+    updates_manual_mock.assert_not_called()
+
+
+def test_get_updates_no_vcs(application: Application, mocker: MockerFixture) -> None:
+    """
+    must get updates without VCS
+    """
+    updates_aur_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.updates_aur")
+    updates_manual_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.updates_manual")
+
+    application.get_updates([], no_aur=False, no_manual=False, no_vcs=True, log_fn=print)
+    updates_aur_mock.assert_called_with([], True)
+    updates_manual_mock.assert_called_once()
+
+
+def test_get_updates_with_filter(application: Application, mocker: MockerFixture) -> None:
+    """
+    must get updates without VCS
+    """
+    updates_aur_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.updates_aur")
+    updates_manual_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.updates_manual")
+
+    application.get_updates(["filter"], no_aur=False, no_manual=False, no_vcs=False, log_fn=print)
+    updates_aur_mock.assert_called_with(["filter"], False)
+    updates_manual_mock.assert_called_once()
+
+
+def test_add_directory(application: Application, package_ahriman: Package, mocker: MockerFixture) -> None:
+    """
+    must add packages from directory
+    """
+    mocker.patch("ahriman.application.application.Application._known_packages", return_value=set())
+    mocker.patch("pathlib.Path.is_dir", return_value=True)
+    iterdir_mock = mocker.patch("pathlib.Path.iterdir",
+                                return_value=[package.filepath for package in package_ahriman.packages.values()])
+    move_mock = mocker.patch("shutil.move")
+
+    application.add([package_ahriman.base], False)
+    iterdir_mock.assert_called_once()
+    move_mock.assert_called_once()
+
+
+def test_add_manual(application: Application, package_ahriman: Package, mocker: MockerFixture) -> None:
+    """
+    must add package from AUR
+    """
+    mocker.patch("ahriman.application.application.Application._known_packages", return_value=set())
+    mocker.patch("ahriman.models.package.Package.load", return_value=package_ahriman)
+    fetch_mock = mocker.patch("ahriman.core.build_tools.task.Task.fetch")
+
+    application.add([package_ahriman.base], True)
+    fetch_mock.assert_called_once()
+
+
+def test_add_manual_with_dependencies(application: Application, package_ahriman: Package,
+                                      mocker: MockerFixture) -> None:
+    """
+    must add package from AUR with dependencies
+    """
+    mocker.patch("ahriman.application.application.Application._known_packages", return_value=set())
+    mocker.patch("ahriman.models.package.Package.load", return_value=package_ahriman)
+    mocker.patch("ahriman.core.build_tools.task.Task.fetch")
+    dependencies_mock = mocker.patch("ahriman.models.package.Package.dependencies")
+
+    application.add([package_ahriman.base], False)
+    dependencies_mock.assert_called_once()
+
+
+def test_add_package(application: Application, package_ahriman: Package, mocker: MockerFixture) -> None:
+    """
+    must add package from archive
+    """
+    mocker.patch("ahriman.application.application.Application._known_packages", return_value=set())
+    mocker.patch("pathlib.Path.is_file", return_value=True)
+    move_mock = mocker.patch("shutil.move")
+
+    application.add([package_ahriman.base], False)
+    move_mock.assert_called_once()
+
+
+def test_clean_build(application: Application, mocker: MockerFixture) -> None:
+    """
+    must clean build directory
+    """
+    clear_mock = mocker.patch("ahriman.core.repository.cleaner.Cleaner.clear_build")
+    application.clean(False, True, True, True, True)
+    clear_mock.assert_called_once()
+
+
+def test_clean_cache(application: Application, mocker: MockerFixture) -> None:
+    """
+    must clean cache directory
+    """
+    clear_mock = mocker.patch("ahriman.core.repository.cleaner.Cleaner.clear_cache")
+    application.clean(True, False, True, True, True)
+    clear_mock.assert_called_once()
+
+
+def test_clean_chroot(application: Application, mocker: MockerFixture) -> None:
+    """
+    must clean chroot directory
+    """
+    clear_mock = mocker.patch("ahriman.core.repository.cleaner.Cleaner.clear_chroot")
+    application.clean(True, True, False, True, True)
+    clear_mock.assert_called_once()
+
+
+def test_clean_manual(application: Application, mocker: MockerFixture) -> None:
+    """
+    must clean manual directory
+    """
+    clear_mock = mocker.patch("ahriman.core.repository.cleaner.Cleaner.clear_manual")
+    application.clean(True, True, True, False, True)
+    clear_mock.assert_called_once()
+
+
+def test_clean_packages(application: Application, mocker: MockerFixture) -> None:
+    """
+    must clean packages directory
+    """
+    clear_mock = mocker.patch("ahriman.core.repository.cleaner.Cleaner.clear_packages")
+    application.clean(True, True, True, True, False)
+    clear_mock.assert_called_once()
+
+
+def test_remove(application: Application, mocker: MockerFixture) -> None:
+    """
+    must remove package
+    """
+    executor_mock = mocker.patch("ahriman.core.repository.executor.Executor.process_remove")
+    finalize_mock = mocker.patch("ahriman.application.application.Application._finalize")
+
+    application.remove([])
+    executor_mock.assert_called_once()
+    finalize_mock.assert_called_once()
+
+
+def test_report(application: Application, mocker: MockerFixture) -> None:
+    """
+    must generate report
+    """
+    executor_mock = mocker.patch("ahriman.core.repository.executor.Executor.process_report")
+    application.report(None)
+    executor_mock.assert_called_once()
+
+
+def test_sync(application: Application, mocker: MockerFixture) -> None:
+    """
+    must sync to remote
+    """
+    executor_mock = mocker.patch("ahriman.core.repository.executor.Executor.process_sync")
+    application.sync(None)
+    executor_mock.assert_called_once()
+
+
+def test_update(application: Application, package_ahriman: Package, mocker: MockerFixture) -> None:
+    """
+    must process package updates
+    """
+    paths = [package.filepath for package in package_ahriman.packages.values()]
+    tree = Tree([Leaf(package_ahriman, set())])
+
+    mocker.patch("ahriman.core.tree.Tree.load", return_value=tree)
+    mocker.patch("ahriman.core.repository.repository.Repository.packages_built", return_value=[])
+    build_mock = mocker.patch("ahriman.core.repository.executor.Executor.process_build", return_value=paths)
+    update_mock = mocker.patch("ahriman.core.repository.executor.Executor.process_update")
+    finalize_mock = mocker.patch("ahriman.application.application.Application._finalize")
+
+    application.update([package_ahriman])
+    build_mock.assert_called_once()
+    update_mock.assert_has_calls([mock.call([]), mock.call(paths)])
+    finalize_mock.assert_has_calls([mock.call(), mock.call()])

tests/ahriman/application/test_lock.py

@@ -0,0 +1,151 @@
+import pytest
+import tempfile
+
+from pathlib import Path
+from pytest_mock import MockerFixture
+from unittest import mock
+
+from ahriman.application.lock import Lock
+from ahriman.core.exceptions import DuplicateRun, UnsafeRun
+from ahriman.models.build_status import BuildStatusEnum
+
+
+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")
+    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()
+    create_mock.assert_called_once()
+    update_status_mock.assert_has_calls([
+        mock.call(BuildStatusEnum.Building),
+        mock.call(BuildStatusEnum.Success)
+    ])
+
+
+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.create")
+    update_status_mock = mocker.patch("ahriman.core.status.client.Client.update_self")
+
+    with pytest.raises(Exception):
+        with lock:
+            raise Exception()
+    update_status_mock.assert_has_calls([
+        mock.call(BuildStatusEnum.Building),
+        mock.call(BuildStatusEnum.Failed)
+    ])
+
+
+def test_check_user(lock: Lock, mocker: MockerFixture) -> None:
+    """
+    must check user correctly
+    """
+    stat = Path.cwd().stat()
+    mocker.patch("pathlib.Path.stat", return_value=stat)
+    mocker.patch("os.getuid", return_value=stat.st_uid)
+
+    lock.check_user()
+
+
+def test_check_user_exception(lock: Lock, mocker: MockerFixture) -> None:
+    """
+    must raise exception if user differs
+    """
+    stat = Path.cwd().stat()
+    mocker.patch("pathlib.Path.stat")
+    mocker.patch("os.getuid", return_value=stat.st_uid + 1)
+
+    with pytest.raises(UnsafeRun):
+        lock.check_user()
+
+
+def test_check_user_unsafe(lock: Lock) -> None:
+    """
+    must skip user check if unsafe flag set
+    """
+    lock.unsafe = True
+    lock.check_user()
+
+
+def test_create(lock: Lock) -> None:
+    """
+    must create lock
+    """
+    lock.path = Path(tempfile.mktemp())
+
+    lock.create()
+    assert lock.path.is_file()
+    lock.path.unlink()
+
+
+def test_create_exception(lock: Lock) -> None:
+    """
+    must raise exception if file already exists
+    """
+    lock.path = Path(tempfile.mktemp())
+    lock.path.touch()
+
+    with pytest.raises(DuplicateRun):
+        lock.create()
+    lock.path.unlink()
+
+
+def test_create_skip(lock: Lock, mocker: MockerFixture) -> None:
+    """
+    must skip creating if no file set
+    """
+    touch_mock = mocker.patch("pathlib.Path.touch")
+    lock.create()
+    touch_mock.assert_not_called()
+
+
+def test_create_unsafe(lock: Lock) -> None:
+    """
+    must not raise exception if force flag set
+    """
+    lock.force = True
+    lock.path = Path(tempfile.mktemp())
+    lock.path.touch()
+
+    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()