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

odoo/addons/odoo_repository/tests/test_repository_scanner.py

@@ -0,0 +1,215 @@
+# Copyright 2024 Camptocamp SA
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl)
+
+from odoo.addons.odoo_repository.utils.scanner import RepositoryScannerOdooEnv
+
+from .common import Common
+
+
+class TestRepositoryScanner(Common):
+    def _init_scanner(self, **params):
+        kwargs = {
+            "org": self.org.name,
+            "name": self.repo_name,
+            "clone_url": self.repo_upstream_path,
+            "version": self.branch.name,
+            "branch": self.branch.name,
+            "addons_paths_data": [
+                {
+                    "relative_path": ".",
+                    "is_standard": False,
+                    "is_enterprise": False,
+                    "is_community": True,
+                },
+            ],
+            "repositories_path": self.repositories_path,
+            "env": self.env,
+        }
+        if params:
+            kwargs.update(params)
+        return RepositoryScannerOdooEnv(**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_sync(self):
+        scanner = self._init_scanner()
+        scanner.sync()
+
+    def test_get_odoo_repository_id(self):
+        scanner = self._init_scanner()
+        repo_id = scanner._get_odoo_repository_id()
+        self.assertEqual(repo_id, self.odoo_repository.id)
+
+    def test_get_odoo_branch_id(self):
+        scanner = self._init_scanner()
+        branch_id = scanner._get_odoo_branch_id(self.branch.name)
+        self.assertEqual(branch_id, self.branch.id)
+
+    def test_create_odoo_repository_branch(self):
+        scanner = self._init_scanner()
+        repo_id = scanner._get_odoo_repository_id()
+        branch_id = scanner._get_odoo_branch_id(self.branch.name)
+        # The repository branch doesn't exist yet
+        expected_repo_branch_id = scanner._get_odoo_repository_branch_id(
+            repo_id, branch_id
+        )
+        self.assertFalse(expected_repo_branch_id)
+        # Create it
+        repo_branch_id = scanner._create_odoo_repository_branch(repo_id, branch_id)
+        self.assertTrue(repo_branch_id)
+        self.assertEqual(
+            repo_branch_id, scanner._get_odoo_repository_branch_id(repo_id, branch_id)
+        )
+
+    def test_get_repo_last_scanned_commit(self):
+        scanner = self._init_scanner()
+        repo_id = scanner._get_odoo_repository_id()
+        branch_id = scanner._get_odoo_branch_id(self.branch.name)
+        repo_branch_id = scanner._create_odoo_repository_branch(repo_id, branch_id)
+        repo_branch = self.env["odoo.repository.branch"].browse(repo_branch_id)
+        # Nothing has been scanned until now
+        self.assertFalse(scanner._get_repo_last_scanned_commit(repo_branch_id))
+        # Clone/fetch the repo
+        scanner.sync()
+        with scanner.repo() as repo:
+            last_fetched_commit = scanner._get_last_fetched_commit(
+                repo, self.branch.name
+            )
+            # Simulate the end of scan
+            repo_branch.last_scanned_commit = last_fetched_commit
+            # Check again
+            last_scanned_commit = scanner._get_repo_last_scanned_commit(repo_branch_id)
+            self.assertEqual(last_fetched_commit, last_scanned_commit)
+
+    def test_detect_modules_to_scan(self):
+        scanner = self._init_scanner()
+        scanner._clone()
+        repo_id = scanner._get_odoo_repository_id()
+        with scanner.repo() as repo:
+            res = scanner._detect_modules_to_scan(repo, repo_id)
+            self.assertTrue(res)
+            self.assertIn("my_module", res["addons_paths"]["."]["modules_to_scan"])
+
+    def test_detect_modules_to_scan_in_addons_path(self):
+        scanner = self._init_scanner()
+        scanner._clone()
+        with scanner.repo() as repo:
+            scanner._checkout_branch(repo, self.branch.name)
+            repo_id = scanner._get_odoo_repository_id()
+            branch_id = scanner._get_odoo_branch_id(self.branch.name)
+            repo_branch_id = scanner._create_odoo_repository_branch(repo_id, branch_id)
+            last_fetched_commit = scanner._get_last_fetched_commit(
+                repo, self.branch.name
+            )
+            last_scanned_commit = scanner._get_repo_last_scanned_commit(repo_branch_id)
+            # Scan the addons_path (root of the repository here)
+            modules_to_scan = scanner._detect_modules_to_scan_in_addons_path(
+                repo,
+                scanner.addons_paths_data[0]["relative_path"],
+                repo_branch_id,
+                last_fetched_commit,
+                last_scanned_commit,
+            )
+        module = self.addon
+        self.assertIn(module, modules_to_scan)
+
+    def test_scan_module(self):
+        scanner = self._init_scanner()
+        scanner._clone()
+        with scanner.repo() as repo:
+            scanner._checkout_branch(repo, self.branch.name)
+            repo_id = scanner._get_odoo_repository_id()
+            branch_id = scanner._get_odoo_branch_id(self.branch.name)
+            repo_branch_id = scanner._create_odoo_repository_branch(repo_id, branch_id)
+            module_path = self.addon
+            remote_branch = f"origin/{self.branch.name}"
+            module_tree = repo.tree(remote_branch) / module_path
+            last_module_commit = scanner._get_last_commit_of_git_tree(
+                remote_branch, module_tree
+            )
+            # Scan module
+            specs = scanner.addons_paths_data[0]
+            data = scanner._scan_module(
+                repo,
+                repo_branch_id,
+                module_path,
+                last_module_commit,
+                specs,
+            )
+        self.assertTrue(data)
+        self.assertTrue(data["code"])
+        self.assertTrue(data["manifest"])
+        self.assertEqual(data["is_standard"], specs["is_standard"])
+        self.assertEqual(data["is_enterprise"], specs["is_enterprise"])
+        self.assertEqual(data["is_community"], specs["is_community"])
+        self.assertEqual(data["last_scanned_commit"], last_module_commit)
+        self.assertIn("1.0.0", data["versions"])
+        self.assertEqual(data["versions"]["1.0.0"]["commit"], last_module_commit)
+        self.assertFalse(data["versions"]["1.0.0"]["migration_script"])
+
+    def test_push_scanned_data(self):
+        scanner = self._init_scanner()
+        scanner._clone()
+        with scanner.repo() as repo:
+            scanner._checkout_branch(repo, self.branch.name)
+            repo_id = scanner._get_odoo_repository_id()
+            branch_id = scanner._get_odoo_branch_id(self.branch.name)
+            repo_branch_id = scanner._create_odoo_repository_branch(repo_id, branch_id)
+            module = self.addon
+            remote_branch = f"origin/{self.branch.name}"
+            module_tree = repo.tree(remote_branch) / module
+            last_module_commit = scanner._get_last_commit_of_git_tree(
+                remote_branch, module_tree
+            )
+            specs = scanner.addons_paths_data[0]
+            data = scanner._scan_module(
+                repo,
+                repo_branch_id,
+                module,
+                last_module_commit,
+                specs,
+            )
+        # Push scanned data
+        module_branch = scanner._push_scanned_data(repo_branch_id, module, data)
+        self.assertEqual(module_branch.module_id.name, module)
+        self.assertEqual(module_branch.repository_branch_id.id, repo_branch_id)
+        self.assertRecordValues(
+            module_branch,
+            [
+                {
+                    "repository_branch_id": repo_branch_id,
+                    "is_standard": specs["is_standard"],
+                    "is_enterprise": specs["is_enterprise"],
+                    "is_community": specs["is_community"],
+                    "application": data["manifest"].get("application", False),
+                    "installable": data["manifest"]["installable"],
+                    "sloc_python": data["code"]["Python"],
+                    "sloc_xml": data["code"]["XML"],
+                    "sloc_js": data["code"]["JavaScript"],
+                    "sloc_css": data["code"]["CSS"],
+                    "last_scanned_commit": last_module_commit,
+                }
+            ],
+        )
+
+    def test_update_last_scanned_commit(self):
+        scanner = self._init_scanner()
+        scanner._clone()
+        repo_id = scanner._get_odoo_repository_id()
+        branch_id = scanner._get_odoo_branch_id(self.branch.name)
+        repo_branch_id = scanner._create_odoo_repository_branch(repo_id, branch_id)
+        repo_branch = self.env["odoo.repository.branch"].browse(repo_branch_id)
+        with scanner.repo() as repo:
+            last_repo_commit = scanner._get_last_fetched_commit(repo, self.branch.name)
+            self.assertFalse(repo_branch.last_scanned_commit)
+            scanner._update_last_scanned_commit(repo_branch_id, last_repo_commit)
+            self.assertEqual(repo_branch.last_scanned_commit, last_repo_commit)
+
+    def test_workaround_fs_errors(self):
+        scanner = self._init_scanner(workaround_fs_errors=True)
+        scanner.sync()

odoo/addons/odoo_repository/tests/test_sync_node.py

@@ -0,0 +1,55 @@
+# Copyright 2024 Camptocamp SA
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl)
+
+from .common import Common
+
+
+class TestSyncNode(Common):
+    def test_sync_node(self):
+        # Scan a repository
+        self.odoo_repository.with_context(queue_job__no_delay=True).action_scan(
+            self.branch.ids
+        )
+        # Check data to sync
+        data = self.env["odoo.module.branch"]._get_modules_data()
+        self.assertEqual(len(data), 1)  # 1 module scanned
+        module = data[0]
+        self.assertEqual(module["module"], self.module_name)
+        self.assertEqual(module["branch"], self.branch.name)
+        self.assertEqual(module["version"], "1.0.0")
+        self.assertTrue(module["versions"])
+        self.assertEqual(module["addons_path"], ".")
+        self.assertEqual(module["repository"]["name"], self.odoo_repository.name)
+        self.assertEqual(module["repository"]["org"], self.odoo_repository.org_id.name)
+        self.assertEqual(
+            module["repository"]["repo_type"], self.odoo_repository.repo_type
+        )
+        self.assertEqual(
+            module["repository"]["repo_url"], self.odoo_repository.repo_url
+        )
+        # Sync these data with a node
+        # NOTE as we are using the same node to sync with in tests, we change
+        # the content of the data to sync to create a new module
+        data[0].update(
+            module="synced",
+            version="2.0.0",
+            branch=self.branch2_name,
+        )
+        new_module = self.env["odoo.module"].search([("name", "=", "synced")])
+        self.assertFalse(new_module)
+        self.env["odoo.repository"]._import_data(data)
+        nb_modules = self.env["odoo.module"].search_count([])
+        self.assertTrue(nb_modules >= 2)
+        new_module = self.env["odoo.module.branch"].search(
+            [("module_name", "=", "synced")]
+        )
+        self.assertTrue(new_module)
+        self.assertEqual(new_module.version, "2.0.0")
+        self.assertEqual(new_module.branch_id.name, self.branch2_name)
+        # Existing module didn't changed
+        existing_module = self.env["odoo.module.branch"].search(
+            [("module_name", "=", self.module_name)]
+        )
+        self.assertTrue(existing_module)
+        self.assertEqual(existing_module.version, "1.0.0")
+        self.assertEqual(existing_module.branch_id, self.branch)

odoo/addons/odoo_repository/tests/test_utils.py

@@ -0,0 +1,25 @@
+# Copyright 2024 Camptocamp SA
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl)
+
+from odoo.tests.common import TransactionCase
+
+from odoo.addons.odoo_repository.utils.module import adapt_version
+
+
+class TestUtils(TransactionCase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.env = cls.env(context=dict(cls.env.context, tracking_disable=True))
+
+    def test_adapt_version(self):
+        # Module version equals major version: add prefix
+        self.assertEqual(adapt_version("14.0", "14.0"), "14.0.14.0")
+        # Basic module version: add prefix
+        self.assertEqual(adapt_version("14.0", "1.0.0"), "14.0.1.0.0")
+        # Module version already prefixed with major version
+        self.assertEqual(adapt_version("14.0", "14.0.1.0.0"), "14.0.1.0.0")
+        # Dot chars added as prefix or suffix in the provided version
+        self.assertEqual(adapt_version("14.0", ".1.0.0"), "14.0.1.0.0")
+        self.assertEqual(adapt_version("14.0", "1.0.0."), "14.0.1.0.0")
+        self.assertEqual(adapt_version("14.0", "...1.0.0..."), "14.0.1.0.0")

odoo/addons/odoo_repository/utils/github.py

@@ -0,0 +1,30 @@
+# Copyright 2023 Camptocamp SA
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl)
+
+import os
+
+import requests
+
+GITHUB_URL = "https://github.com"
+GITHUB_API_URL = "https://api.github.com"
+
+
+def request(env, url, method="get", params=None, json=None):
+    """Request GitHub API."""
+    headers = {"Accept": "application/vnd.github.groot-preview+json"}
+    key = "odoo_repository_github_token"
+    token = env["ir.config_parameter"].sudo().get_param(key, "") or os.environ.get(
+        "GITHUB_TOKEN"
+    )
+    if token:
+        headers.update({"Authorization": f"token {token}"})
+    full_url = "/".join([GITHUB_API_URL, url])
+    kwargs = {"headers": headers}
+    if json:
+        kwargs.update(json=json)
+    if params:
+        kwargs.update(params=params)
+    response = getattr(requests, method)(full_url, **kwargs)
+    if not response.ok:
+        raise RuntimeError(response.text)
+    return response.json()

odoo/addons/odoo_repository/utils/module.py

@@ -0,0 +1,25 @@
+# Copyright 2023 Camptocamp SA
+# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl)
+
+
+def adapt_version(major_version: str, module_version: str):
+    """Return the module version prefixed with major version.
+
+    This function has been copied and adapted from upstream Odoo source code:
+        https://github.com/odoo/odoo/blob/16.0/odoo/modules/module.py#L527-L533
+    """
+    # Remove extra special characters (e.g. '14.0.' => '14.0')
+    # NOTE: we need to sanitize such versions in order to compute a
+    # sequence number helping the sort of module versions.
+    chars = ["."]
+    for char in chars:
+        while module_version.startswith(char):
+            module_version = module_version[1:]
+        while module_version.endswith(char):
+            module_version = module_version[:-1]
+    # Append major Odoo version as prefix if needed
+    if module_version == major_version or not module_version.startswith(
+        major_version + "."
+    ):
+        module_version = "%s.%s" % (major_version, module_version)
+    return module_version

odoo/addons/odoo_repository/utils/scanner.py

@@ -0,0 +1,90 @@
+# Copyright 2023 Camptocamp SA
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl)
+
+from odoo.tools import config
+
+from ..lib.scanner import RepositoryScanner
+
+
+class RepositoryScannerOdooEnv(RepositoryScanner):
+    """RepositoryScanner running on the same server than Odoo.
+
+    This class takes an additional `env` parameter (`odoo.api.Environment`)
+    used to request Odoo, and implement required methods to use it.
+    """
+
+    def __init__(self, *args, **kwargs):
+        if kwargs.get("env"):
+            self.env = kwargs.pop("env")
+        super().__init__(*args, **kwargs)
+
+    def _get_odoo_repository_id(self):
+        return (
+            self.env["odoo.repository"]
+            .search([("name", "=", self.name), ("org_id", "=", self.org)])
+            .id
+        )
+
+    def _get_odoo_branch_id(self, version):
+        return self.env["odoo.branch"].search([("name", "=", version)]).id
+
+    def _get_odoo_repository_branch_id(self, repo_id, branch_id):
+        args = [
+            ("repository_id", "=", repo_id),
+            ("branch_id", "=", branch_id),
+        ]
+        repo_branch = self.env["odoo.repository.branch"].search(args, limit=1)
+        if repo_branch:
+            return repo_branch.id
+
+    def _create_odoo_repository_branch(self, repo_id, branch_id, cloned_branch=None):
+        repo_branch_id = self._get_odoo_repository_branch_id(repo_id, branch_id)
+        if not repo_branch_id:
+            values = {
+                "repository_id": repo_id,
+                "branch_id": branch_id,
+            }
+            if cloned_branch:
+                values["cloned_branch"] = cloned_branch
+            repo_branch_model = self.env["odoo.repository.branch"]
+            repo_branch_id = repo_branch_model.create(values).id
+        return repo_branch_id
+
+    def _get_repo_last_scanned_commit(self, repo_branch_id):
+        repo_branch_model = self.env["odoo.repository.branch"]
+        repo_branch = repo_branch_model.browse(repo_branch_id)
+        return repo_branch.last_scanned_commit
+
+    def _is_module_blacklisted(self, module):
+        return bool(
+            self.env["odoo.module"].search_count(
+                [("name", "=", module), ("blacklisted", "=", True)]
+            )
+        )
+
+    def _get_module_last_scanned_commit(self, repo_branch_id, module_name):
+        module_branch_model = self.env["odoo.module.branch"]
+        args = [
+            ("repository_branch_id", "=", repo_branch_id),
+            ("module_name", "=", module_name),
+        ]
+        module = module_branch_model.search(args)
+        return module.last_scanned_commit
+
+    def _push_scanned_data(self, repo_branch_id, module, data):
+        res = self.env["odoo.module.branch"].push_scanned_data(
+            repo_branch_id, module, data
+        )
+        # Commit after each module
+        if not config["test_enable"]:
+            self.env.cr.commit()  # pylint: disable=invalid-commit
+        return res
+
+    def _update_last_scanned_commit(self, repo_branch_id, last_fetched_commit):
+        repo_branch_model = self.env["odoo.repository.branch"]
+        repo_branch = repo_branch_model.browse(repo_branch_id)
+        repo_branch.last_scanned_commit = last_fetched_commit
+        # Commit after each repository/branch
+        if not config["test_enable"]:
+            self.env.cr.commit()  # pylint: disable=invalid-commit
+        return True

odoo/addons/odoo_repository/views/authentication_token.xml

@@ -0,0 +1,63 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<!-- Copyright 2024 Camptocamp SA
+     License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl). -->
+<odoo>
+
+  <record id="authentication_token_view_form" model="ir.ui.view">
+    <field name="name">authentication.token.form</field>
+    <field name="model">authentication.token</field>
+    <field
+            name="groups_id"
+            eval="[(4,ref('odoo_repository.group_odoo_repository_manager'))]"
+        />
+    <field name="arch" type="xml">
+      <form>
+        <sheet>
+          <group>
+            <field name="name" />
+            <field name="token" password="True" />
+          </group>
+        </sheet>
+      </form>
+    </field>
+  </record>
+
+  <record id="authentication_token_view_tree" model="ir.ui.view">
+    <field name="name">authentication.token.tree</field>
+    <field name="model">authentication.token</field>
+    <field name="arch" type="xml">
+      <tree>
+        <field name="name" />
+      </tree>
+    </field>
+  </record>
+
+  <record id="authentication_token_view_search" model="ir.ui.view">
+    <field name="name">authentication.token.search</field>
+    <field name="model">authentication.token</field>
+    <field name="type">search</field>
+    <field name="arch" type="xml">
+      <search>
+        <field name="name" />
+      </search>
+    </field>
+  </record>
+
+  <record id="authentication_token_action" model="ir.actions.act_window">
+    <field name="name">Authentication Tokens</field>
+    <field name="type">ir.actions.act_window</field>
+    <field name="res_model">authentication.token</field>
+    <field name="view_id" ref="authentication_token_view_tree" />
+    <field
+            name="groups_id"
+            eval="[(4,ref('odoo_repository.group_odoo_repository_manager'))]"
+        />
+  </record>
+
+  <menuitem
+        id="authentication_token_menu"
+        parent="config_odoo_repository_menu"
+        action="authentication_token_action"
+    />
+
+</odoo>

odoo/addons/odoo_repository/views/menu.xml

@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<!-- Copyright 2023 Camptocamp SA
+     License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl). -->
+<odoo>
+
+  <menuitem
+        id="main_odoo_repository_menu"
+        groups="odoo_repository.group_odoo_repository_user"
+        web_icon="odoo_repository,static/description/icon.png"
+        name="Odoo Repositories"
+    />
+  <menuitem
+        id="data_odoo_repository_menu"
+        parent="main_odoo_repository_menu"
+        name="Data"
+        sequence="20"
+    />
+  <menuitem
+        id="report_odoo_repository_menu"
+        parent="main_odoo_repository_menu"
+        name="Report"
+        sequence="30"
+    />
+  <menuitem
+        id="misc_odoo_repository_menu"
+        parent="main_odoo_repository_menu"
+        name="Misc."
+        sequence="40"
+    />
+  <menuitem
+        id="config_odoo_repository_menu"
+        parent="main_odoo_repository_menu"
+        groups="odoo_repository.group_odoo_repository_manager"
+        name="Configuration"
+        sequence="50"
+    />
+
+</odoo>

odoo/addons/odoo_repository/views/odoo_author.xml

@@ -0,0 +1,54 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<!-- Copyright 2023 Camptocamp SA
+     License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl). -->
+<odoo>
+
+  <record id="odoo_author_view_form" model="ir.ui.view">
+    <field name="name">odoo.author.form</field>
+    <field name="model">odoo.author</field>
+    <field name="arch" type="xml">
+      <form>
+        <sheet>
+          <group>
+            <field name="name" />
+          </group>
+        </sheet>
+      </form>
+    </field>
+  </record>
+
+  <record id="odoo_author_view_tree" model="ir.ui.view">
+    <field name="name">odoo.author.tree</field>
+    <field name="model">odoo.author</field>
+    <field name="arch" type="xml">
+      <tree>
+        <field name="name" />
+      </tree>
+    </field>
+  </record>
+
+  <record id="odoo_author_view_search" model="ir.ui.view">
+    <field name="name">odoo.author.search</field>
+    <field name="model">odoo.author</field>
+    <field name="type">search</field>
+    <field name="arch" type="xml">
+      <search>
+        <field name="name" />
+      </search>
+    </field>
+  </record>
+
+  <record id="odoo_author_action" model="ir.actions.act_window">
+    <field name="name">Authors</field>
+    <field name="type">ir.actions.act_window</field>
+    <field name="res_model">odoo.author</field>
+    <field name="view_id" ref="odoo_author_view_tree" />
+  </record>
+
+  <menuitem
+        id="odoo_author_menu"
+        parent="misc_odoo_repository_menu"
+        action="odoo_author_action"
+    />
+
+</odoo>