odoo-addon-odoo-repository 16.0.1.3.0.13__py3-none-any.whl

odoo/addons/odoo_repository/tests/test_base_scanner.py

@@ -0,0 +1,214 @@
+# Copyright 2024 Camptocamp SA
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl)
+
+import tempfile
+
+from odoo.addons.odoo_repository.lib.scanner import BaseScanner
+
+from .common import Common
+
+
+class TestBaseScanner(Common):
+    def _init_scanner(self, **params):
+        kwargs = {
+            "org": self.fork_org,
+            "name": self.repo_name,
+            "clone_url": self.repo_upstream_path,
+            "branches": [
+                self.branch1_name,
+                self.branch2_name,
+                self.branch3_name,
+            ],
+            "repositories_path": self.repositories_path,
+        }
+        if params:
+            kwargs.update(params)
+        return BaseScanner(**kwargs)
+
+    def test_init(self):
+        scanner = self._init_scanner()
+        self.assertTrue(scanner.repositories_path.exists())
+        self.assertEqual(scanner.path.parts[-1], self.repo_name)
+        self.assertEqual(scanner.path.parts[-2], self.fork_org)
+        self.assertEqual(scanner.full_name, f"{self.fork_org}/{self.repo_name}")
+
+    def test_clone_url_github_token(self):
+        # Without token
+        base_clone_url = "https://github.com/OCA/test"
+        scanner = self._init_scanner(repo_type="github", clone_url=base_clone_url)
+        self.assertEqual(scanner.clone_url, base_clone_url)
+        # With a token
+        token = "test"
+        scanner = self._init_scanner(
+            repo_type="github", clone_url=base_clone_url, token=token
+        )
+        token_clone_url = f"https://oauth2:{token}@github.com/OCA/test"
+        self.assertEqual(scanner.clone_url, token_clone_url)
+
+    def test_sync(self):
+        scanner = self._init_scanner(repositories_path=tempfile.mkdtemp())
+        # Clone
+        self.assertFalse(scanner.path.exists())
+        self.assertFalse(scanner.is_cloned)
+        scanner.sync()
+        self.assertTrue(scanner.is_cloned)
+        # Fetch once cloned
+        scanner.sync()
+
+    def test_branch_exists(self):
+        scanner = self._init_scanner()
+        scanner.sync()
+        with scanner.repo() as repo:
+            self.assertTrue(scanner._branch_exists(repo, self.branch1_name))
+            self.assertTrue(scanner._branch_exists(repo, self.branch2_name))
+            self.assertTrue(scanner._branch_exists(repo, self.branch3_name))
+
+    def test_checkout_branch(self):
+        scanner = self._init_scanner()
+        scanner.sync()
+        with scanner.repo() as repo:
+            branch = self.branch2_name
+            branch_sha = repo.refs[f"origin/{branch}"].object.hexsha
+            self.assertNotEqual(repo.head.object.hexsha, branch_sha)
+            scanner._checkout_branch(repo, branch)
+            self.assertEqual(repo.head.object.hexsha, branch_sha)
+
+    def test_get_last_fetched_commit(self):
+        scanner = self._init_scanner()
+        scanner.sync()
+        with scanner.repo() as repo:
+            branch1 = self.branch1_name
+            branch2 = self.branch2_name
+            branch3 = self.branch3_name
+            branch1_sha = repo.refs[f"origin/{branch1}"].object.hexsha
+            branch2_sha = repo.refs[f"origin/{branch2}"].object.hexsha
+            branch3_sha = repo.refs[f"origin/{branch3}"].object.hexsha
+            self.assertEqual(
+                scanner._get_last_fetched_commit(repo, branch1), branch1_sha
+            )
+            self.assertEqual(
+                scanner._get_last_fetched_commit(repo, branch2), branch2_sha
+            )
+            self.assertEqual(
+                scanner._get_last_fetched_commit(repo, branch3), branch3_sha
+            )
+
+    def test_get_module_paths(self):
+        scanner = self._init_scanner()
+        scanner.sync()
+        with scanner.repo() as repo:
+            branch = self.branch1_name
+            module_paths = scanner._get_module_paths(repo, ".", branch)
+            self.assertEqual(len(module_paths), 1)
+            self.assertEqual(module_paths[0], self.addon)
+
+    def test_get_module_paths_updated(self):
+        scanner = self._init_scanner()
+        scanner.sync()
+        branch = self.branch1_name
+        with scanner.repo() as repo:
+            initial_commit = scanner._get_last_fetched_commit(repo, branch)
+            # Case where from_commit and to_commit are the same: no change detected
+            module_paths = scanner._get_module_paths_updated(
+                repo,
+                relative_path=".",
+                from_commit=initial_commit,
+                to_commit=initial_commit,
+                branch=branch,
+            )
+            self.assertFalse(module_paths)
+        # Update the upstream repository with a new commit
+        self._update_module_version_on_branch(branch, "1.0.1")
+        # Module is now detected has updated
+        scanner.sync()  # Fetch new commit from upstream repo
+        with scanner.repo() as repo:
+            last_commit = scanner._get_last_fetched_commit(repo, branch)
+            module_paths = scanner._get_module_paths_updated(
+                repo,
+                relative_path=".",
+                from_commit=initial_commit,
+                to_commit=last_commit,
+                branch=branch,
+            )
+            self.assertEqual(len(module_paths), 1)
+            self.assertEqual(module_paths.pop(), self.addon)
+
+    def test_filter_file_path(self):
+        scanner = self._init_scanner()
+        self.assertFalse(scanner._filter_file_path("fr.po"))
+        self.assertTrue(scanner._filter_file_path("test.py"))
+
+    def test_get_last_commit_of_git_tree(self):
+        scanner = self._init_scanner()
+        scanner.sync()
+        with scanner.repo() as repo:
+            branch = self.branch1_name
+            remote_branch = f"origin/{branch}"
+            module = self.addon
+            module_tree = repo.tree(remote_branch) / module
+            all_commits = [c.hexsha for c in repo.iter_commits(remote_branch)]
+            commit = scanner._get_last_commit_of_git_tree(remote_branch, module_tree)
+            self.assertIn(commit, all_commits)
+
+    def test_get_commits_of_git_tree(self):
+        scanner = self._init_scanner()
+        scanner.sync()
+        with scanner.repo() as repo:
+            branch = self.branch1_name
+            remote_branch = f"origin/{branch}"
+            module = self.addon
+            module_tree = repo.tree(remote_branch) / module
+            all_commits = [c.hexsha for c in repo.iter_commits(remote_branch)]
+            commits = scanner._get_commits_of_git_tree(
+                from_=None, to_=remote_branch, tree=module_tree
+            )
+            for commit in commits:
+                self.assertIn(commit, all_commits)
+
+    def test_odoo_module(self):
+        scanner = self._init_scanner()
+        scanner.sync()
+        with scanner.repo() as repo:
+            branch = self.branch1_name
+            remote_branch = f"origin/{branch}"
+            module = self.addon
+            module_tree = repo.tree(remote_branch) / module
+            self.assertTrue(scanner._odoo_module(module_tree))
+
+    def test_manifest_exists(self):
+        scanner = self._init_scanner()
+        scanner.sync()
+        with scanner.repo() as repo:
+            branch = self.branch1_name
+            remote_branch = f"origin/{branch}"
+            # Check module tree: OK
+            module = self.addon
+            module_tree = repo.tree(remote_branch) / module
+            self.assertTrue(scanner._manifest_exists(module_tree))
+            # Check repository root tree: KO
+            self.assertFalse(scanner._manifest_exists(repo.tree(remote_branch)))
+
+    def test_get_subtree(self):
+        scanner = self._init_scanner()
+        scanner.sync()
+        with scanner.repo() as repo:
+            branch = self.branch1_name
+            remote_branch = f"origin/{branch}"
+            module = self.addon
+            # Module/folder exists: OK
+            self.assertTrue(scanner._get_subtree(repo.tree(remote_branch), module))
+            # Module/folder doesn't exist: KO
+            self.assertFalse(scanner._get_subtree(repo.tree(remote_branch), "none"))
+
+    def test_workaround_fs_errors(self):
+        scanner = self._init_scanner(
+            repositories_path=tempfile.mkdtemp(),
+            workaround_fs_errors=True,
+        )
+        # Clone
+        self.assertFalse(scanner.path.exists())
+        self.assertFalse(scanner.is_cloned)
+        scanner.sync()
+        self.assertTrue(scanner.is_cloned)
+        # Fetch once cloned
+        scanner.sync()

odoo/addons/odoo_repository/tests/test_odoo_module_branch.py

@@ -0,0 +1,97 @@
+# Copyright 2024 Camptocamp SA
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl)
+
+from odoo.exceptions import ValidationError
+
+from .common import Common
+
+
+class TestOdooModuleBranch(Common):
+    def test_constraint_generic_depends_on_specific(self):
+        generic_mod = self._create_odoo_module("generic_mod")
+        generic_mod_branch = self._create_odoo_module_branch(
+            generic_mod, self.branch, specific=False
+        )
+        specific_mod = self._create_odoo_module("specific_mod")
+        specific_mod_branch = self._create_odoo_module_branch(
+            specific_mod, self.branch, specific=True
+        )
+        with self.assertRaises(ValidationError):
+            generic_mod_branch.dependency_ids = specific_mod_branch
+
+    def test_dependency_level(self):
+        # base module in the dependencies tree
+        mod_base = self._create_odoo_module("base")
+        mod_base_branch = self._create_odoo_module_branch(
+            mod_base, self.branch, is_standard=True
+        )
+        self.assertEqual(mod_base_branch.global_dependency_level, 1)
+        self.assertEqual(mod_base_branch.non_std_dependency_level, 0)
+        # add a standard module depending on the base one
+        mod_std = self._create_odoo_module("std")
+        mod_std_branch = self._create_odoo_module_branch(
+            mod_std,
+            self.branch,
+            is_standard=True,
+            dependency_ids=[(4, mod_base_branch.id)],
+        )
+        self.assertEqual(mod_std_branch.global_dependency_level, 2)
+        self.assertEqual(mod_std_branch.non_std_dependency_level, 0)
+        # add a non-standard module depending on the std one
+        mod_non_std = self._create_odoo_module("non_std")
+        mod_non_std_branch = self._create_odoo_module_branch(
+            mod_non_std,
+            self.branch,
+            is_standard=False,
+            dependency_ids=[(4, mod_std_branch.id)],
+        )
+        self.assertEqual(mod_non_std_branch.global_dependency_level, 3)
+        self.assertEqual(mod_non_std_branch.non_std_dependency_level, 1)
+        # add another one depending on base module
+        mod_non_std2 = self._create_odoo_module("non_std2")
+        mod_non_std2_branch = self._create_odoo_module_branch(
+            mod_non_std2,
+            self.branch,
+            is_standard=False,
+            dependency_ids=[(4, mod_base_branch.id)],
+        )
+        self.assertEqual(mod_non_std2_branch.global_dependency_level, 2)
+        self.assertEqual(mod_non_std2_branch.non_std_dependency_level, 1)
+        # add another one depending on non-std module
+        mod_non_std3 = self._create_odoo_module("non_std3")
+        mod_non_std3_branch = self._create_odoo_module_branch(
+            mod_non_std3,
+            self.branch,
+            is_standard=False,
+            dependency_ids=[(4, mod_non_std_branch.id)],
+        )
+        self.assertEqual(mod_non_std3_branch.global_dependency_level, 4)
+        self.assertEqual(mod_non_std3_branch.non_std_dependency_level, 2)
+
+    def test_find(self):
+        mb_model = self.env["odoo.module.branch"]
+        mod = self._create_odoo_module("my_module")
+        repo = self.odoo_repository
+        repo2 = self.odoo_repository.copy({"name": "Repo2"})
+        # Find orphaned module
+        mod_orphaned = mb_model._create_orphaned_module_branch(self.branch, mod)
+        self.assertEqual(mb_model._find(self.branch, mod, repo), mod_orphaned)
+        # Find generic module
+        repo_branch = self._create_odoo_repository_branch(repo, self.branch)
+        mod_generic = self._create_odoo_module_branch(
+            mod,
+            self.branch,
+            specific=False,
+            repository_branch_id=repo_branch.id,
+        )
+        self.assertEqual(mb_model._find(self.branch, mod, repo), mod_generic)
+        # Find module in current repository
+        repo2_branch = self._create_odoo_repository_branch(repo2, self.branch)
+        mod_in_repo2 = self._create_odoo_module_branch(
+            mod,
+            self.branch,
+            repository_branch_id=repo2_branch.id,
+        )
+        self.assertEqual(mb_model._find(self.branch, mod, repo2), mod_in_repo2)
+        # While we have 3 modules (hosted in different repos or orphaned)
+        self.assertEqual(len(mod.module_branch_ids), 3)

odoo/addons/odoo_repository/tests/test_odoo_repository_scan.py

@@ -0,0 +1,242 @@
+# Copyright 2024 Camptocamp SA
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl)
+
+from odoo import fields
+
+from .common import Common
+
+
+class TestOdooRepositoryScan(Common):
+    def test_check_config(self):
+        self.odoo_repository._check_config()
+
+    def test_action_scan_basic(self):
+        """Test the creation of a module when scanning a (generic) repository."""
+        self.assertFalse(self.odoo_repository.specific)
+        module = self.env["odoo.module"].search([("name", "=", self.module_name)])
+        self.assertFalse(module)
+        self._run_odoo_repository_action_scan(self.branch.id)
+        # Check module technical name
+        module = self.env["odoo.module"].search([("name", "=", self.module_name)])
+        self.assertTrue(module)
+        # Check module branch
+        module_branch = self.env["odoo.module.branch"].search(
+            [("module_id", "=", module.id), ("branch_id", "=", self.branch.id)]
+        )
+        self.assertEqual(module_branch.module_name, self.module_name)
+        self.assertTrue(module_branch.last_scanned_commit)
+        self.assertEqual(module_branch.repository_id, self.odoo_repository)
+        self.assertEqual(module_branch.org_id, self.org)
+        self.assertEqual(module_branch.title, "Test")
+        self.assertEqual(module_branch.category_id.name, "Test Module")
+        self.assertItemsEqual(
+            module_branch.author_ids.mapped("name"),
+            ["Odoo Community Association (OCA)", "Camptocamp"],
+        )
+        self.assertFalse(module_branch.specific)
+        self.assertEqual(module_branch.dependency_ids.module_name, "base")
+        self.assertFalse(module_branch.dependency_ids.specific)
+        self.assertEqual(module_branch.license_id.name, "AGPL-3")
+        self.assertEqual(module_branch.version, "1.0.0")
+        self.assertEqual(module_branch.version_ids.manifest_value, "1.0.0")
+        self.assertEqual(module_branch.version_ids.name, f"{self.branch.name}.1.0.0")
+        self.assertEqual(
+            module_branch.version_ids.commit, module_branch.last_scanned_commit
+        )
+        self.assertFalse(module_branch.version_ids.has_migration_script)
+        self.assertTrue(module_branch.sloc_python)
+        self.assertEqual(module_branch.addons_path, ".")
+        # Check repository branch
+        repo_branch = module_branch.repository_branch_id
+        self.assertEqual(repo_branch.branch_id, self.branch)
+        self.assertEqual(
+            repo_branch.last_scanned_commit, module_branch.last_scanned_commit
+        )
+
+    def test_action_scan_repo_specific(self):
+        """Test the creation of a module when scanning a specific repository."""
+        self.odoo_repository.specific = True
+        self.odoo_repository.write(
+            {
+                "specific": True,
+                "branch_ids": [
+                    fields.Command.create({"branch_id": self.branch.id}),
+                ],
+            }
+        )
+        self.assertTrue(self.odoo_repository.specific)
+        self._run_odoo_repository_action_scan(self.branch.id)
+        # Check module data
+        module = self.env["odoo.module"].search([("name", "=", self.module_name)])
+        module_branch = self.env["odoo.module.branch"].search(
+            [("module_id", "=", module.id), ("branch_id", "=", self.branch.id)]
+        )
+        self.assertTrue(module_branch.specific)
+        self.assertFalse(module_branch.dependency_ids.specific)
+
+    def test_action_scan_repo_module_exists(self):
+        """Test the update of existing module when scanning a repository.
+
+        If a module has already been scanned in the current repository, a second
+        scan will trigger an update of its data.
+        """
+        # First scan, like in `test_action_scan_first_time`
+        self._run_odoo_repository_action_scan(self.branch.id)
+        module = self.env["odoo.module"].search([("name", "=", self.module_name)])
+        module_branch = self.env["odoo.module.branch"].search(
+            [("module_id", "=", module.id), ("branch_id", "=", self.branch.id)]
+        )
+        # Change some data in the module before triggering the second scan
+        module_branch.write({"title": False})
+        # Launch a second scan (force it to make it happen)
+        self._run_odoo_repository_action_scan(self.branch.id, force=True)
+        self.assertEqual(module_branch.title, "Test")
+
+    def test_action_scan_orphaned_module_exists(self):
+        """Test the link of an orphaned module when scanning a repository.
+
+        An orphaned module is a record without repository assigned while we know
+        its name and branch. Such record is automatically created when generating
+        dependencies of a given module that have not been scanned yet, or by
+        importing installed modules in a project (see `odoo_project` Odoo module).
+
+        If such a module matches a module scanned in a repository, it is updated
+        accordingly to belong to this repository.
+        """
+        # Create an orphaned module.
+        # To ease its creation, we run a scan to get the record created, and
+        # we update it to make it orphaned.
+        self._run_odoo_repository_action_scan(self.branch.id)
+        module = self.env["odoo.module"].search([("name", "=", self.module_name)])
+        module_branch = self.env["odoo.module.branch"].search(
+            [("module_id", "=", module.id), ("branch_id", "=", self.branch.id)]
+        )
+        module_branch.write(
+            {
+                "repository_branch_id": False,
+                "last_scanned_commit": False,
+                "dependency_ids": False,
+            }
+        )
+        # Launch a scan
+        self._run_odoo_repository_action_scan(self.branch.id, force=True)
+        self.assertEqual(module_branch.repository_id, self.odoo_repository)
+
+    def _create_wrong_repo_branch(self, repo_sequence=100):
+        wrong_repo = self.env["odoo.repository"].create(
+            {
+                "org_id": self.odoo_repository.org_id.id,
+                "name": "wrong_repo",
+                "repo_url": "https://example.net/OCA-test/wrong_repo",
+                "clone_url": "https://example.net/OCA-test/wrong_repo",
+                "repo_type": "github",
+                "sequence": repo_sequence,
+            }
+        )
+        wrong_repo_branch = self.env["odoo.repository.branch"].create(
+            {
+                "repository_id": wrong_repo.id,
+                "branch_id": self.branch.id,
+            }
+        )
+        return wrong_repo_branch
+
+    def _create_unmerged_module_branch(self):
+        # To ease the creation of such module, we run a scan to get the record
+        # created, and we update it to make it unmerged/pending.
+        self._run_odoo_repository_action_scan(self.branch.id)
+        module = self.env["odoo.module"].search([("name", "=", self.module_name)])
+        module_branch = self.env["odoo.module.branch"].search(
+            [("module_id", "=", module.id), ("branch_id", "=", self.branch.id)]
+        )
+        wrong_repo_branch = self._create_wrong_repo_branch(
+            # Lower priority than self.odoo_repository
+            repo_sequence=200
+        )
+        wrong_repo = wrong_repo_branch.repository_id
+        module_branch.write(
+            {
+                "repository_branch_id": wrong_repo_branch,
+                "last_scanned_commit": False,
+                "dependency_ids": False,
+                "pr_url": f"{wrong_repo.repo_url}/pull/1",
+                "specific": False,
+            }
+        )
+        return module_branch
+
+    def test_action_scan_repo_generic_unmerged_module_exists(self):
+        """Test link of an unmerged module when scanning a generic repository.
+
+        An unmerged module is like an orphaned module but with a PR attached.
+        However such PR indicates from which repository a module is coming from,
+        but this information could also be wrong (wrong PR detected on the wrong
+        repository).
+
+        Note: unmerged modules can only be generic, as PR detection is restricted
+        only to generic modules.
+
+        When scanning a generic repository, if an unmerged module is
+        detected it should be linked to this scanned repository.
+        """
+        self.odoo_repository.specific = False
+        # Create an unmerged module
+        module_branch = self._create_unmerged_module_branch()
+        self.assertFalse(module_branch.specific)
+        self.assertNotEqual(module_branch.repository_id, self.odoo_repository)
+        # Launch a scan
+        self._run_odoo_repository_action_scan(self.branch.id, force=True)
+        self.assertFalse(module_branch.specific)
+        self.assertEqual(module_branch.repository_id, self.odoo_repository)
+
+    def test_action_scan_repo_specific_unmerged_module_exists(self):
+        """Test non-link of an unmerged module when scanning a specific repository.
+
+        When scanning a specific repository, detection of unmerged modules is
+        not done as such modules are linked to generic repositories only.
+        """
+        self.odoo_repository.specific = True
+        # Create an unmerged module
+        module_branch = self._create_unmerged_module_branch()
+        self.assertFalse(module_branch.specific)
+        self.assertNotEqual(module_branch.repository_id, self.odoo_repository)
+        # Launch a scan
+        self._run_odoo_repository_action_scan(self.branch.id, force=True)
+        # Unmerged module hasn't been attached to the scanned repository
+        self.assertNotEqual(module_branch.repository_id, self.odoo_repository)
+
+    def test_action_scan_uninstallable_module(self):
+        """Test scan of an 'installable: False' module.
+
+        Such module should not be created with its dependencies (Odoo, Python...)
+        or versions history to not pollute the DB. Such data could be
+        outdated as the module is flagged as not installable. They will be updated
+        once the module is migrated/installable.
+        """
+        self._update_module_installable_on_branch(self.branch.name, installable=False)
+        module = self.env["odoo.module"].search([("name", "=", self.module_name)])
+        self.assertFalse(module)
+        self._run_odoo_repository_action_scan(self.branch.id)
+        module = self.env["odoo.module"].search([("name", "=", self.module_name)])
+        self.assertTrue(module)
+        # Check module branch
+        module_branch = self.env["odoo.module.branch"].search(
+            [("module_id", "=", module.id), ("branch_id", "=", self.branch.id)]
+        )
+        self.assertEqual(module_branch.module_name, self.module_name)
+        self.assertTrue(module_branch.last_scanned_commit)
+        self.assertEqual(module_branch.repository_id, self.odoo_repository)
+        self.assertEqual(module_branch.org_id, self.org)
+        self.assertEqual(module_branch.title, "Test")
+        self.assertEqual(module_branch.category_id.name, "Test Module")
+        self.assertItemsEqual(
+            module_branch.author_ids.mapped("name"),
+            ["Odoo Community Association (OCA)", "Camptocamp"],
+        )
+        self.assertFalse(module_branch.specific)
+        # No dependencies
+        self.assertFalse(module_branch.dependency_ids)
+        self.assertFalse(module_branch.external_dependencies)
+        self.assertFalse(module_branch.python_dependency_ids)
+        # No version scanned
+        self.assertFalse(module_branch.version_ids)