Complete official repository support (#59)

tests/ahriman/core/alpm/remote/conftest.py

@@ -2,6 +2,7 @@ import pytest
 
 from ahriman.core.alpm.remote.aur import AUR
 from ahriman.core.alpm.remote.official import Official
+from ahriman.core.alpm.remote.official_syncdb import OfficialSyncdb
 from ahriman.core.alpm.remote.remote import Remote
 
 
@@ -27,6 +28,17 @@ def official() -> Official:
     return Official()
 
 
+@pytest.fixture
+def official_syncdb() -> OfficialSyncdb:
+    """
+    official repository fixture with database processing
+
+    Returns:
+        OfficialSyncdb: official repository with database processing helper instance
+    """
+    return OfficialSyncdb()
+
+
 @pytest.fixture
 def remote() -> Remote:
     """

tests/ahriman/core/alpm/remote/test_aur.py

@@ -6,6 +6,7 @@ from pathlib import Path
 from pytest_mock import MockerFixture
 from unittest.mock import MagicMock
 
+from ahriman.core.alpm.pacman import Pacman
 from ahriman.core.alpm.remote.aur import AUR
 from ahriman.core.exceptions import InvalidPackageInfo
 from ahriman.models.aur_package import AURPackage
@@ -49,6 +50,23 @@ def test_parse_response_unknown_error() -> None:
         AUR.parse_response({"type": "error"})
 
 
+def test_remote_git_url(aur_package_ahriman: AURPackage) -> None:
+    """
+    must generate package git url
+    """
+    git_url = AUR.remote_git_url(aur_package_ahriman.package_base, aur_package_ahriman.repository)
+    assert git_url.endswith(".git")
+    assert git_url.startswith(AUR.DEFAULT_AUR_URL)
+
+
+def test_remote_web_url(aur_package_ahriman: AURPackage) -> None:
+    """
+    must generate package git url
+    """
+    web_url = AUR.remote_web_url(aur_package_ahriman.package_base)
+    assert web_url.startswith(AUR.DEFAULT_AUR_URL)
+
+
 def test_make_request(aur: AUR, aur_package_ahriman: AURPackage,
                       mocker: MockerFixture, resource_path_root: Path) -> None:
     """
@@ -109,19 +127,19 @@ def test_make_request_failed_http_error(aur: AUR, mocker: MockerFixture) -> None
         aur.make_request("info", "ahriman")
 
 
-def test_package_info(aur: AUR, aur_package_ahriman: AURPackage, mocker: MockerFixture) -> None:
+def test_package_info(aur: AUR, aur_package_ahriman: AURPackage, pacman: Pacman, mocker: MockerFixture) -> None:
     """
     must make request for info
     """
     request_mock = mocker.patch("ahriman.core.alpm.remote.aur.AUR.make_request", return_value=[aur_package_ahriman])
-    assert aur.package_info(aur_package_ahriman.name) == aur_package_ahriman
+    assert aur.package_info(aur_package_ahriman.name, pacman=pacman) == aur_package_ahriman
     request_mock.assert_called_once_with("info", aur_package_ahriman.name)
 
 
-def test_package_search(aur: AUR, aur_package_ahriman: AURPackage, mocker: MockerFixture) -> None:
+def test_package_search(aur: AUR, aur_package_ahriman: AURPackage, pacman: Pacman, mocker: MockerFixture) -> None:
     """
     must make request for search
     """
     request_mock = mocker.patch("ahriman.core.alpm.remote.aur.AUR.make_request", return_value=[aur_package_ahriman])
-    assert aur.package_search(aur_package_ahriman.name) == [aur_package_ahriman]
+    assert aur.package_search(aur_package_ahriman.name, pacman=pacman) == [aur_package_ahriman]
     request_mock.assert_called_once_with("search", aur_package_ahriman.name, by="name-desc")

tests/ahriman/core/alpm/remote/test_official.py

@@ -6,6 +6,7 @@ from pathlib import Path
 from pytest_mock import MockerFixture
 from unittest.mock import MagicMock
 
+from ahriman.core.alpm.pacman import Pacman
 from ahriman.core.alpm.remote.official import Official
 from ahriman.core.exceptions import InvalidPackageInfo
 from ahriman.models.aur_package import AURPackage
@@ -41,6 +42,38 @@ def test_parse_response_unknown_error(resource_path_root: Path) -> None:
         Official.parse_response(json.loads(response))
 
 
+def test_remote_git_url(aur_package_akonadi: AURPackage) -> None:
+    """
+    must generate package git url for core packages
+    """
+    git_urls = [
+        Official.remote_git_url(aur_package_akonadi.package_base, repository)
+        for repository in ("core", "extra", "Core", "Extra")
+    ]
+    assert all(git_url.endswith("svntogit-packages.git") for git_url in git_urls)
+    assert len(set(git_urls)) == 1
+
+
+def test_remote_git_url_community(aur_package_akonadi: AURPackage) -> None:
+    """
+    must generate package git url for core packages
+    """
+    git_urls = [
+        Official.remote_git_url(aur_package_akonadi.package_base, repository)
+        for repository in ("community", "multilib", "Community", "Multilib")
+    ]
+    assert all(git_url.endswith("svntogit-community.git") for git_url in git_urls)
+    assert len(set(git_urls)) == 1
+
+
+def test_remote_web_url(aur_package_akonadi: AURPackage) -> None:
+    """
+    must generate package git url
+    """
+    web_url = Official.remote_web_url(aur_package_akonadi.package_base)
+    assert web_url.startswith(Official.DEFAULT_ARCHLINUX_URL)
+
+
 def test_make_request(official: Official, aur_package_akonadi: AURPackage,
                       mocker: MockerFixture, resource_path_root: Path) -> None:
     """
@@ -51,7 +84,8 @@ def test_make_request(official: Official, aur_package_akonadi: AURPackage,
     request_mock = mocker.patch("requests.get", return_value=response_mock)
 
     assert official.make_request("akonadi", by="q") == [aur_package_akonadi]
-    request_mock.assert_called_once_with("https://archlinux.org/packages/search/json", params={"q": ("akonadi",)})
+    request_mock.assert_called_once_with("https://archlinux.org/packages/search/json",
+                                         params={"q": ("akonadi",), "repo": Official.DEFAULT_SEARCH_REPOSITORIES})
 
 
 def test_make_request_failed(official: Official, mocker: MockerFixture) -> None:
@@ -72,21 +106,23 @@ def test_make_request_failed_http_error(official: Official, mocker: MockerFixtur
         official.make_request("akonadi", by="q")
 
 
-def test_package_info(official: Official, aur_package_akonadi: AURPackage, mocker: MockerFixture) -> None:
+def test_package_info(official: Official, aur_package_akonadi: AURPackage, pacman: Pacman,
+                      mocker: MockerFixture) -> None:
     """
     must make request for info
     """
     request_mock = mocker.patch("ahriman.core.alpm.remote.official.Official.make_request",
                                 return_value=[aur_package_akonadi])
-    assert official.package_info(aur_package_akonadi.name) == aur_package_akonadi
+    assert official.package_info(aur_package_akonadi.name, pacman=pacman) == aur_package_akonadi
     request_mock.assert_called_once_with(aur_package_akonadi.name, by="name")
 
 
-def test_package_search(official: Official, aur_package_akonadi: AURPackage, mocker: MockerFixture) -> None:
+def test_package_search(official: Official, aur_package_akonadi: AURPackage, pacman: Pacman,
+                        mocker: MockerFixture) -> None:
     """
     must make request for search
     """
     request_mock = mocker.patch("ahriman.core.alpm.remote.official.Official.make_request",
                                 return_value=[aur_package_akonadi])
-    assert official.package_search(aur_package_akonadi.name) == [aur_package_akonadi]
+    assert official.package_search(aur_package_akonadi.name, pacman=pacman) == [aur_package_akonadi]
     request_mock.assert_called_once_with(aur_package_akonadi.name, by="q")

tests/ahriman/core/alpm/remote/test_official_syncdb.py

@@ -0,0 +1,18 @@
+from pytest_mock import MockerFixture
+
+from ahriman.core.alpm.pacman import Pacman
+from ahriman.core.alpm.remote.official_syncdb import OfficialSyncdb
+from ahriman.models.aur_package import AURPackage
+
+
+def test_package_info(official_syncdb: OfficialSyncdb, aur_package_akonadi: AURPackage,
+                      pacman: Pacman, mocker: MockerFixture) -> None:
+    """
+    must return package info from the database
+    """
+    mocker.patch("ahriman.models.aur_package.AURPackage.from_pacman", return_value=aur_package_akonadi)
+    get_mock = mocker.patch("ahriman.core.alpm.pacman.Pacman.get", return_value=[aur_package_akonadi])
+
+    package = official_syncdb.package_info(aur_package_akonadi.name, pacman=pacman)
+    get_mock.assert_called_once_with(aur_package_akonadi.name)
+    assert package == aur_package_akonadi

tests/ahriman/core/alpm/remote/test_remote.py

@@ -3,70 +3,87 @@ import pytest
 from pytest_mock import MockerFixture
 from unittest import mock
 
+from ahriman.core.alpm.pacman import Pacman
 from ahriman.core.alpm.remote.remote import Remote
 from ahriman.models.aur_package import AURPackage
 
 
-def test_info(mocker: MockerFixture) -> None:
+def test_info(pacman: Pacman, mocker: MockerFixture) -> None:
     """
     must call info method
     """
     info_mock = mocker.patch("ahriman.core.alpm.remote.remote.Remote.package_info")
-    Remote.info("ahriman")
-    info_mock.assert_called_once_with("ahriman")
+    Remote.info("ahriman", pacman=pacman)
+    info_mock.assert_called_once_with("ahriman", pacman=pacman)
 
 
-def test_multisearch(aur_package_ahriman: AURPackage, mocker: MockerFixture) -> None:
+def test_multisearch(aur_package_ahriman: AURPackage, pacman: Pacman, mocker: MockerFixture) -> None:
     """
     must search in AUR with multiple words
     """
     terms = ["ahriman", "is", "cool"]
     search_mock = mocker.patch("ahriman.core.alpm.remote.remote.Remote.search", return_value=[aur_package_ahriman])
 
-    assert Remote.multisearch(*terms) == [aur_package_ahriman]
-    search_mock.assert_has_calls([mock.call("ahriman"), mock.call("cool")])
+    assert Remote.multisearch(*terms, pacman=pacman) == [aur_package_ahriman]
+    search_mock.assert_has_calls([mock.call("ahriman", pacman=pacman), mock.call("cool", pacman=pacman)])
 
 
-def test_multisearch_empty(mocker: MockerFixture) -> None:
+def test_multisearch_empty(pacman: Pacman, mocker: MockerFixture) -> None:
     """
     must return empty list if no long terms supplied
     """
     terms = ["it", "is"]
     search_mock = mocker.patch("ahriman.core.alpm.remote.remote.Remote.search")
 
-    assert Remote.multisearch(*terms) == []
+    assert Remote.multisearch(*terms, pacman=pacman) == []
     search_mock.assert_not_called()
 
 
-def test_multisearch_single(aur_package_ahriman: AURPackage, mocker: MockerFixture) -> None:
+def test_multisearch_single(aur_package_ahriman: AURPackage, pacman: Pacman, mocker: MockerFixture) -> None:
     """
     must search in AUR with one word
     """
     search_mock = mocker.patch("ahriman.core.alpm.remote.remote.Remote.search", return_value=[aur_package_ahriman])
-    assert Remote.multisearch("ahriman") == [aur_package_ahriman]
-    search_mock.assert_called_once_with("ahriman")
+    assert Remote.multisearch("ahriman", pacman=pacman) == [aur_package_ahriman]
+    search_mock.assert_called_once_with("ahriman", pacman=pacman)
 
 
-def test_search(mocker: MockerFixture) -> None:
+def test_remote_git_url(remote: Remote, pacman: Pacman) -> None:
+    """
+    must raise NotImplemented for missing remote git url
+    """
+    with pytest.raises(NotImplementedError):
+        remote.remote_git_url("package", "repositorys")
+
+
+def test_remote_web_url(remote: Remote, pacman: Pacman) -> None:
+    """
+    must raise NotImplemented for missing remote web url
+    """
+    with pytest.raises(NotImplementedError):
+        remote.remote_web_url("package")
+
+
+def test_search(pacman: Pacman, mocker: MockerFixture) -> None:
     """
     must call search method
     """
     search_mock = mocker.patch("ahriman.core.alpm.remote.remote.Remote.package_search")
-    Remote.search("ahriman")
-    search_mock.assert_called_once_with("ahriman")
+    Remote.search("ahriman", pacman=pacman)
+    search_mock.assert_called_once_with("ahriman", pacman=pacman)
 
 
-def test_package_info(remote: Remote) -> None:
+def test_package_info(remote: Remote, pacman: Pacman) -> None:
     """
     must raise NotImplemented for missing package info method
     """
     with pytest.raises(NotImplementedError):
-        remote.package_info("package")
+        remote.package_info("package", pacman=pacman)
 
 
-def test_package_search(remote: Remote) -> None:
+def test_package_search(remote: Remote, pacman: Pacman) -> None:
     """
     must raise NotImplemented for missing package search method
     """
     with pytest.raises(NotImplementedError):
-        remote.package_search("package")
+        remote.package_search("package", pacman=pacman)

tests/ahriman/core/alpm/test_pacman.py

@@ -15,3 +15,17 @@ def test_all_packages_with_provides(pacman: Pacman) -> None:
     package list must contain provides packages
     """
     assert "sh" in pacman.all_packages()
+
+
+def test_get(pacman: Pacman) -> None:
+    """
+    must retrieve package
+    """
+    assert list(pacman.get("pacman"))
+
+
+def test_get_empty(pacman: Pacman) -> None:
+    """
+    must return empty packages list without exception
+    """
+    assert not list(pacman.get("some-random-name"))

tests/ahriman/core/build_tools/test_sources.py

@@ -5,6 +5,7 @@ from pytest_mock import MockerFixture
 from unittest import mock
 
 from ahriman.core.build_tools.sources import Sources
+from ahriman.models.remote_source import RemoteSource
 
 
 def test_add(mocker: MockerFixture) -> None:
@@ -45,7 +46,7 @@ def test_diff(mocker: MockerFixture) -> None:
                                               exception=None, cwd=local, logger=pytest.helpers.anyvar(int))
 
 
-def test_fetch_empty(mocker: MockerFixture) -> None:
+def test_fetch_empty(remote_source: RemoteSource, mocker: MockerFixture) -> None:
     """
     must do nothing in case if no branches available
     """
@@ -53,46 +54,51 @@ def test_fetch_empty(mocker: MockerFixture) -> None:
     mocker.patch("ahriman.core.build_tools.sources.Sources.has_remotes", return_value=False)
     check_output_mock = mocker.patch("ahriman.core.build_tools.sources.Sources._check_output")
 
-    Sources.fetch(Path("local"), "remote")
+    Sources.fetch(Path("local"), remote_source)
     check_output_mock.assert_not_called()
 
 
-def test_fetch_existing(mocker: MockerFixture) -> None:
+def test_fetch_existing(remote_source: RemoteSource, mocker: MockerFixture) -> None:
     """
     must fetch new package via fetch command
     """
     mocker.patch("pathlib.Path.is_dir", return_value=True)
     mocker.patch("ahriman.core.build_tools.sources.Sources.has_remotes", return_value=True)
     check_output_mock = mocker.patch("ahriman.core.build_tools.sources.Sources._check_output")
+    move_mock = mocker.patch("ahriman.core.build_tools.sources.Sources.move")
 
     local = Path("local")
-    Sources.fetch(local, "remote")
+    Sources.fetch(local, remote_source)
     check_output_mock.assert_has_calls([
-        mock.call("git", "fetch", "origin", Sources._branch,
+        mock.call("git", "fetch", "origin", remote_source.branch,
                   exception=None, cwd=local, logger=pytest.helpers.anyvar(int)),
-        mock.call("git", "checkout", "--force", Sources._branch,
+        mock.call("git", "checkout", "--force", remote_source.branch,
                   exception=None, cwd=local, logger=pytest.helpers.anyvar(int)),
-        mock.call("git", "reset", "--hard", f"origin/{Sources._branch}",
+        mock.call("git", "reset", "--hard", f"origin/{remote_source.branch}",
                   exception=None, cwd=local, logger=pytest.helpers.anyvar(int))
     ])
+    move_mock.assert_called_once_with(local.resolve(), local)
 
 
-def test_fetch_new(mocker: MockerFixture) -> None:
+def test_fetch_new(remote_source: RemoteSource, mocker: MockerFixture) -> None:
     """
     must fetch new package via clone command
     """
     mocker.patch("pathlib.Path.is_dir", return_value=False)
     check_output_mock = mocker.patch("ahriman.core.build_tools.sources.Sources._check_output")
+    move_mock = mocker.patch("ahriman.core.build_tools.sources.Sources.move")
 
     local = Path("local")
-    Sources.fetch(local, "remote")
+    Sources.fetch(local, remote_source)
     check_output_mock.assert_has_calls([
-        mock.call("git", "clone", "remote", str(local), exception=None, cwd=local, logger=pytest.helpers.anyvar(int)),
-        mock.call("git", "checkout", "--force", Sources._branch,
+        mock.call("git", "clone", "--branch", remote_source.branch, "--single-branch",
+                  remote_source.git_url, str(local), exception=None, cwd=local, logger=pytest.helpers.anyvar(int)),
+        mock.call("git", "checkout", "--force", remote_source.branch,
                   exception=None, cwd=local, logger=pytest.helpers.anyvar(int)),
-        mock.call("git", "reset", "--hard", f"origin/{Sources._branch}",
+        mock.call("git", "reset", "--hard", f"origin/{remote_source.branch}",
                   exception=None, cwd=local, logger=pytest.helpers.anyvar(int))
     ])
+    move_mock.assert_called_once_with(local.resolve(), local)
 
 
 def test_fetch_new_without_remote(mocker: MockerFixture) -> None:
@@ -101,15 +107,28 @@ def test_fetch_new_without_remote(mocker: MockerFixture) -> None:
     """
     mocker.patch("pathlib.Path.is_dir", return_value=False)
     check_output_mock = mocker.patch("ahriman.core.build_tools.sources.Sources._check_output")
+    move_mock = mocker.patch("ahriman.core.build_tools.sources.Sources.move")
 
     local = Path("local")
     Sources.fetch(local, None)
     check_output_mock.assert_has_calls([
-        mock.call("git", "checkout", "--force", Sources._branch,
+        mock.call("git", "checkout", "--force", Sources.DEFAULT_BRANCH,
                   exception=None, cwd=local, logger=pytest.helpers.anyvar(int)),
-        mock.call("git", "reset", "--hard", f"origin/{Sources._branch}",
+        mock.call("git", "reset", "--hard", f"origin/{Sources.DEFAULT_BRANCH}",
                   exception=None, cwd=local, logger=pytest.helpers.anyvar(int))
     ])
+    move_mock.assert_called_once_with(local.resolve(), local)
+
+
+def test_fetch_relative(remote_source: RemoteSource, mocker: MockerFixture) -> None:
+    """
+    must process move correctly on relative directory
+    """
+    mocker.patch("ahriman.core.build_tools.sources.Sources._check_output")
+    move_mock = mocker.patch("ahriman.core.build_tools.sources.Sources.move")
+
+    Sources.fetch(Path("path"), remote_source)
+    move_mock.assert_called_once_with(Path("path").resolve(), Path("path"))
 
 
 def test_has_remotes(mocker: MockerFixture) -> None:
@@ -140,33 +159,53 @@ def test_init(mocker: MockerFixture) -> None:
 
     local = Path("local")
     Sources.init(local)
-    check_output_mock.assert_called_once_with("git", "init", "--initial-branch", Sources._branch,
+    check_output_mock.assert_called_once_with("git", "init", "--initial-branch", Sources.DEFAULT_BRANCH,
                                               exception=None, cwd=local, logger=pytest.helpers.anyvar(int))
 
 
-def test_load(mocker: MockerFixture) -> None:
+def test_load(remote_source: RemoteSource, mocker: MockerFixture) -> None:
     """
     must load packages sources correctly
     """
     fetch_mock = mocker.patch("ahriman.core.build_tools.sources.Sources.fetch")
     patch_mock = mocker.patch("ahriman.core.build_tools.sources.Sources.patch_apply")
 
-    Sources.load(Path("local"), "remote", "patch")
-    fetch_mock.assert_called_once_with(Path("local"), "remote")
+    Sources.load(Path("local"), remote_source, "patch")
+    fetch_mock.assert_called_once_with(Path("local"), remote_source)
     patch_mock.assert_called_once_with(Path("local"), "patch")
 
 
-def test_load_no_patch(mocker: MockerFixture) -> None:
+def test_load_no_patch(remote_source: RemoteSource, mocker: MockerFixture) -> None:
     """
     must load packages sources correctly without patches
     """
     mocker.patch("ahriman.core.build_tools.sources.Sources.fetch")
     patch_mock = mocker.patch("ahriman.core.build_tools.sources.Sources.patch_apply")
 
-    Sources.load(Path("local"), "remote", None)
+    Sources.load(Path("local"), remote_source, None)
     patch_mock.assert_not_called()
 
 
+def test_move(mocker: MockerFixture) -> None:
+    """
+    must move content between directories
+    """
+    mocker.patch("ahriman.core.build_tools.sources.walk", return_value=[Path("/source/path")])
+    move_mock = mocker.patch("shutil.move")
+
+    Sources.move(Path("/source"), Path("/destination"))
+    move_mock.assert_called_once_with(Path("/source/path"), Path("/destination/path"))
+
+
+def test_move_same(mocker: MockerFixture) -> None:
+    """
+    must not do anything in case if directories are the same
+    """
+    walk_mock = mocker.patch("ahriman.core.build_tools.sources.walk")
+    Sources.move(Path("/same"), Path("/same"))
+    walk_mock.assert_not_called()
+
+
 def test_patch_apply(mocker: MockerFixture) -> None:
     """
     must apply patches if any

tests/ahriman/core/conftest.py

@@ -1,6 +1,5 @@
 import pytest
 
-from ahriman.core.alpm.pacman import Pacman
 from ahriman.core.alpm.repo import Repo
 from ahriman.core.build_tools.task import Task
 from ahriman.core.configuration import Configuration
@@ -37,20 +36,6 @@ def leaf_python_schedule(package_python_schedule: Package) -> Leaf:
     return Leaf(package_python_schedule, set())
 
 
-@pytest.fixture
-def pacman(configuration: Configuration) -> Pacman:
-    """
-    fixture for pacman wrapper
-
-    Args:
-        configuration(Configuration): configuration fixture
-
-    Returns:
-        Pacman: pacman wrapper test instance
-    """
-    return Pacman(configuration)
-
-
 @pytest.fixture
 def repo(configuration: Configuration, repository_paths: RepositoryPaths) -> Repo:
     """

tests/ahriman/core/database/data/test_data_init.py

@@ -15,11 +15,24 @@ def test_migrate_data_initial(connection: Connection, configuration: Configurati
     packages = mocker.patch("ahriman.core.database.data.migrate_package_statuses")
     patches = mocker.patch("ahriman.core.database.data.migrate_patches")
     users = mocker.patch("ahriman.core.database.data.migrate_users_data")
+    remotes = mocker.patch("ahriman.core.database.data.migrate_package_remotes")
 
     migrate_data(MigrationResult(old_version=0, new_version=900), connection, configuration)
     packages.assert_called_once_with(connection, repository_paths)
     patches.assert_called_once_with(connection, repository_paths)
     users.assert_called_once_with(connection, configuration)
+    remotes.assert_called_once_with(connection, repository_paths)
+
+
+def test_migrate_data_remotes(connection: Connection, configuration: Configuration,
+                              repository_paths: RepositoryPaths, mocker: MockerFixture) -> None:
+    """
+    must perform initial migration
+    """
+    remotes = mocker.patch("ahriman.core.database.data.migrate_package_remotes")
+
+    migrate_data(MigrationResult(old_version=1, new_version=900), connection, configuration)
+    remotes.assert_called_once_with(connection, repository_paths)
 
 
 def test_migrate_data_skip(connection: Connection, configuration: Configuration, mocker: MockerFixture) -> None:

tests/ahriman/core/database/data/test_package_remotes.py

@@ -0,0 +1,66 @@
+import pytest
+
+from pytest_mock import MockerFixture
+from sqlite3 import Connection
+
+from ahriman.core.database.data import migrate_package_remotes
+from ahriman.models.package import Package
+from ahriman.models.repository_paths import RepositoryPaths
+
+
+def test_migrate_package_remotes(package_ahriman: Package, connection: Connection, repository_paths: RepositoryPaths,
+                                 mocker: MockerFixture) -> None:
+    """
+    must put package remotes to database
+    """
+    mocker.patch(
+        "ahriman.core.database.operations.package_operations.PackageOperations._packages_get_select_package_bases",
+        return_value={package_ahriman.base: package_ahriman})
+    mocker.patch("pathlib.Path.exists", return_value=False)
+
+    migrate_package_remotes(connection, repository_paths)
+    connection.execute.assert_called_once_with(pytest.helpers.anyvar(str, strict=True), pytest.helpers.anyvar(int))
+
+
+def test_migrate_package_remotes_has_local(package_ahriman: Package, connection: Connection,
+                                           repository_paths: RepositoryPaths, mocker: MockerFixture) -> None:
+    """
+    must skip processing for packages which have local cache
+    """
+    mocker.patch(
+        "ahriman.core.database.operations.package_operations.PackageOperations._packages_get_select_package_bases",
+        return_value={package_ahriman.base: package_ahriman})
+    mocker.patch("pathlib.Path.exists", return_value=True)
+
+    migrate_package_remotes(connection, repository_paths)
+    connection.execute.assert_not_called()
+
+
+def test_migrate_package_remotes_vcs(package_ahriman: Package, connection: Connection,
+                                     repository_paths: RepositoryPaths, mocker: MockerFixture) -> None:
+    """
+    must process VCS packages with local cache
+    """
+    mocker.patch(
+        "ahriman.core.database.operations.package_operations.PackageOperations._packages_get_select_package_bases",
+        return_value={package_ahriman.base: package_ahriman})
+    mocker.patch("pathlib.Path.exists", return_value=True)
+    mocker.patch.object(Package, "is_vcs", True)
+
+    migrate_package_remotes(connection, repository_paths)
+    connection.execute.assert_called_once_with(pytest.helpers.anyvar(str, strict=True), pytest.helpers.anyvar(int))
+
+
+def test_migrate_package_remotes_no_remotes(package_ahriman: Package, connection: Connection,
+                                            repository_paths: RepositoryPaths, mocker: MockerFixture) -> None:
+    """
+    must skip processing in case if no remotes generated (should never happen)
+    """
+    mocker.patch(
+        "ahriman.core.database.operations.package_operations.PackageOperations._packages_get_select_package_bases",
+        return_value={package_ahriman.base: package_ahriman})
+    mocker.patch("pathlib.Path.exists", return_value=False)
+    mocker.patch("ahriman.models.remote_source.RemoteSource.from_remote", return_value=None)
+
+    migrate_package_remotes(connection, repository_paths)
+    connection.execute.assert_not_called()

tests/ahriman/core/database/data/test_users.py

@@ -9,7 +9,7 @@ from ahriman.core.database.data import migrate_users_data
 
 def test_migrate_users_data(connection: Connection, configuration: Configuration) -> None:
     """
-    must users to database
+    must put users to database
     """
     configuration.set_option("auth:read", "user1", "password1")
     configuration.set_option("auth:write", "user2", "password2")

tests/ahriman/core/database/migrations/test_m001_package_source.py

@@ -0,0 +1,8 @@
+from ahriman.core.database.migrations.m001_package_source import steps
+
+
+def test_migration_package_source() -> None:
+    """
+    migration must not be empty
+    """
+    assert steps

tests/ahriman/core/database/operations/test_package_operations.py

@@ -7,6 +7,8 @@ from unittest import mock
 from ahriman.core.database.sqlite import SQLite
 from ahriman.models.build_status import BuildStatus, BuildStatusEnum
 from ahriman.models.package import Package
+from ahriman.models.package_source import PackageSource
+from ahriman.models.remote_source import RemoteSource
 
 
 def test_package_remove_package_base(database: SQLite, connection: Connection) -> None:
@@ -166,3 +168,23 @@ def test_package_update_update(database: SQLite, package_ahriman: Package) -> No
     assert next(db_status.status
                 for db_package, db_status in database.packages_get()
                 if db_package.base == package_ahriman.base) == BuildStatusEnum.Failed
+
+
+def test_remote_update_get(database: SQLite, package_ahriman: Package) -> None:
+    """
+    must insert and retrieve package remote
+    """
+    database.remote_update(package_ahriman)
+    assert database.remotes_get()[package_ahriman.base] == package_ahriman.remote
+
+
+def test_remote_update_update(database: SQLite, package_ahriman: Package) -> None:
+    """
+    must perform package remote update for existing package
+    """
+    database.remote_update(package_ahriman)
+    remote_source = RemoteSource.from_remote(PackageSource.Repository, package_ahriman.base, "community")
+    package_ahriman.remote = remote_source
+
+    database.remote_update(package_ahriman)
+    assert database.remotes_get()[package_ahriman.base] == remote_source

tests/ahriman/core/repository/test_repository.py

@@ -15,11 +15,11 @@ def test_load_archives(package_ahriman: Package, package_python_schedule: Packag
     single_packages = [
         Package(base=package_python_schedule.base,
                 version=package_python_schedule.version,
-                aur_url=package_python_schedule.aur_url,
+                remote=package_python_schedule.remote,
                 packages={package: props})
         for package, props in package_python_schedule.packages.items()
     ] + [package_ahriman]
-    mocker.patch("ahriman.models.package.Package.load", side_effect=single_packages)
+    mocker.patch("ahriman.models.package.Package.from_archive", side_effect=single_packages)
 
     packages = repository.load_archives([Path("a.pkg.tar.xz"), Path("b.pkg.tar.xz"), Path("c.pkg.tar.xz")])
     assert len(packages) == 2
@@ -36,7 +36,7 @@ def test_load_archives_failed(repository: Repository, mocker: MockerFixture) ->
     """
     must skip packages which cannot be loaded
     """
-    mocker.patch("ahriman.models.package.Package.load", side_effect=Exception())
+    mocker.patch("ahriman.models.package.Package.from_archive", side_effect=Exception())
     assert not repository.load_archives([Path("a.pkg.tar.xz")])
 
 
@@ -55,12 +55,12 @@ def test_load_archives_different_version(repository: Repository, package_python_
     single_packages = [
         Package(base=package_python_schedule.base,
                 version=package_python_schedule.version,
-                aur_url=package_python_schedule.aur_url,
+                remote=package_python_schedule.remote,
                 packages={package: props})
         for package, props in package_python_schedule.packages.items()
     ]
     single_packages[0].version = "0.0.1-1"
-    mocker.patch("ahriman.models.package.Package.load", side_effect=single_packages)
+    mocker.patch("ahriman.models.package.Package.from_archive", side_effect=single_packages)
 
     packages = repository.load_archives([Path("a.pkg.tar.xz"), Path("b.pkg.tar.xz")])
     assert len(packages) == 1

tests/ahriman/core/repository/test_update_handler.py

@@ -5,6 +5,7 @@ from pytest_mock import MockerFixture
 from ahriman.core.repository.update_handler import UpdateHandler
 from ahriman.models.package import Package
 from ahriman.models.package_source import PackageSource
+from ahriman.models.remote_source import RemoteSource
 
 
 def test_packages(update_handler: UpdateHandler) -> None:
@@ -22,7 +23,22 @@ def test_updates_aur(update_handler: UpdateHandler, package_ahriman: Package,
     """
     mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.packages", return_value=[package_ahriman])
     mocker.patch("ahriman.models.package.Package.is_outdated", return_value=True)
-    mocker.patch("ahriman.models.package.Package.load", return_value=package_ahriman)
+    mocker.patch("ahriman.models.package.Package.from_aur", return_value=package_ahriman)
+    status_client_mock = mocker.patch("ahriman.core.status.client.Client.set_pending")
+
+    assert update_handler.updates_aur([], False) == [package_ahriman]
+    status_client_mock.assert_called_once_with(package_ahriman.base)
+
+
+def test_updates_aur_official(update_handler: UpdateHandler, package_ahriman: Package,
+                              mocker: MockerFixture) -> None:
+    """
+    must provide updates based on repository data
+    """
+    package_ahriman.remote = RemoteSource.from_remote(PackageSource.Repository, package_ahriman.base, "community")
+    mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.packages", return_value=[package_ahriman])
+    mocker.patch("ahriman.models.package.Package.is_outdated", return_value=True)
+    mocker.patch("ahriman.models.package.Package.from_official", return_value=package_ahriman)
     status_client_mock = mocker.patch("ahriman.core.status.client.Client.set_pending")
 
     assert update_handler.updates_aur([], False) == [package_ahriman]
@@ -36,7 +52,7 @@ def test_updates_aur_success(update_handler: UpdateHandler, package_ahriman: Pac
     """
     mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.packages", return_value=[package_ahriman])
     mocker.patch("ahriman.models.package.Package.is_outdated", return_value=False)
-    mocker.patch("ahriman.models.package.Package.load", return_value=package_ahriman)
+    mocker.patch("ahriman.models.package.Package.from_aur", return_value=package_ahriman)
     status_client_mock = mocker.patch("ahriman.core.status.client.Client.set_success")
 
     assert not update_handler.updates_aur([], False)
@@ -49,7 +65,7 @@ def test_updates_aur_failed(update_handler: UpdateHandler, package_ahriman: Pack
     must update status via client for failed load
     """
     mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.packages", return_value=[package_ahriman])
-    mocker.patch("ahriman.models.package.Package.load", side_effect=Exception())
+    mocker.patch("ahriman.models.package.Package.from_aur", side_effect=Exception())
     status_client_mock = mocker.patch("ahriman.core.status.client.Client.set_failed")
 
     update_handler.updates_aur([], False)
@@ -64,11 +80,10 @@ def test_updates_aur_filter(update_handler: UpdateHandler, package_ahriman: Pack
     mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.packages",
                  return_value=[package_ahriman, package_python_schedule])
     mocker.patch("ahriman.models.package.Package.is_outdated", return_value=True)
-    package_load_mock = mocker.patch("ahriman.models.package.Package.load", return_value=package_ahriman)
+    package_load_mock = mocker.patch("ahriman.models.package.Package.from_aur", return_value=package_ahriman)
 
     assert update_handler.updates_aur([package_ahriman.base], False) == [package_ahriman]
-    package_load_mock.assert_called_once_with(package_ahriman.base, PackageSource.AUR,
-                                              update_handler.pacman, update_handler.aur_url)
+    package_load_mock.assert_called_once_with(package_ahriman.base, update_handler.pacman)
 
 
 def test_updates_aur_ignore(update_handler: UpdateHandler, package_ahriman: Package,
@@ -78,7 +93,7 @@ def test_updates_aur_ignore(update_handler: UpdateHandler, package_ahriman: Pack
     """
     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")
+    package_load_mock = mocker.patch("ahriman.models.package.Package.from_aur")
 
     update_handler.updates_aur([], False)
     package_load_mock.assert_not_called()
@@ -105,13 +120,12 @@ def test_updates_local(update_handler: UpdateHandler, package_ahriman: Package,
     mocker.patch("pathlib.Path.iterdir", return_value=[package_ahriman.base])
     mocker.patch("ahriman.models.package.Package.is_outdated", return_value=True)
     fetch_mock = mocker.patch("ahriman.core.build_tools.sources.Sources.fetch")
-    package_load_mock = mocker.patch("ahriman.models.package.Package.load", return_value=package_ahriman)
+    package_load_mock = mocker.patch("ahriman.models.package.Package.from_build", return_value=package_ahriman)
     status_client_mock = mocker.patch("ahriman.core.status.client.Client.set_pending")
 
     assert update_handler.updates_local() == [package_ahriman]
     fetch_mock.assert_called_once_with(package_ahriman.base, remote=None)
-    package_load_mock.assert_called_once_with(
-        package_ahriman.base, PackageSource.Local, update_handler.pacman, update_handler.aur_url)
+    package_load_mock.assert_called_once_with(package_ahriman.base)
     status_client_mock.assert_called_once_with(package_ahriman.base)
 
 
@@ -123,7 +137,7 @@ def test_updates_local_unknown(update_handler: UpdateHandler, package_ahriman: P
     mocker.patch("pathlib.Path.iterdir", return_value=[package_ahriman.base])
     mocker.patch("ahriman.models.package.Package.is_outdated", return_value=True)
     mocker.patch("ahriman.core.build_tools.sources.Sources.fetch")
-    mocker.patch("ahriman.models.package.Package.load", return_value=package_ahriman)
+    mocker.patch("ahriman.models.package.Package.from_build", return_value=package_ahriman)
     status_client_mock = mocker.patch("ahriman.core.status.client.Client.set_unknown")
 
     assert update_handler.updates_local() == [package_ahriman]
@@ -151,7 +165,7 @@ def test_updates_local_success(update_handler: UpdateHandler, package_ahriman: P
     mocker.patch("pathlib.Path.iterdir", return_value=[package_ahriman.base])
     mocker.patch("ahriman.models.package.Package.is_outdated", return_value=False)
     mocker.patch("ahriman.core.build_tools.sources.Sources.fetch")
-    mocker.patch("ahriman.models.package.Package.load", return_value=package_ahriman)
+    mocker.patch("ahriman.models.package.Package.from_build", return_value=package_ahriman)
     status_client_mock = mocker.patch("ahriman.core.status.client.Client.set_success")
 
     assert not update_handler.updates_local()

tests/ahriman/core/test_tree.py

@@ -51,7 +51,7 @@ def test_leaf_load(package_ahriman: Package, database: SQLite, mocker: MockerFix
     assert leaf.dependencies == {"ahriman-dependency"}
     tempdir_mock.assert_called_once_with()
     load_mock.assert_called_once_with(
-        pytest.helpers.anyvar(int), package_ahriman.git_url, database.patches_get(package_ahriman.base))
+        pytest.helpers.anyvar(int), package_ahriman.remote, database.patches_get(package_ahriman.base))
     dependencies_mock.assert_called_once_with(pytest.helpers.anyvar(int))
     rmtree_mock.assert_called_once_with(pytest.helpers.anyvar(int), ignore_errors=True)