[FIX] website: improve/fix menu, copy on unlink, clone page, unique_path, sale_report, ...

Fix bug from the initial poc of JOV

Fix menu creation
   - creating a menu would create a 'container' menu in the DB (.create is call without website_id)
   then writing on it would copy (if condition to cow) the menu with a website_id leaving the first
   one as a menu container unused.
   - website_menu should always have a website_id
     we dont want to support the multiwebsite system that allow to have generic/specific menu
     unlink/write is useless now since we always have a website_id

Make unique_path website dependent, 2 distinct website can have a page with same name

Make Sale report multiwebsite compliant

Make website_id on sale_order / account.invoice as a related stored from partner_id.

Co-authored-by: Derie Romain <rde@odoo.com>
Co-authored-by: Kersten Jérémy <jke@odoo.com>

2 files changed, 121 insertions, 106 deletions

diff --git a/addons/website/tests/test_menu.py b/addons/website/tests/test_menu.py
index e01b020bef8..8ceab5b6bf5 100644
--- a/addons/website/tests/test_menu.py
+++ b/addons/website/tests/test_menu.py
@@ -3,10 +3,19 @@ from odoo.tests import common
 
 
 class TestMenu(common.TransactionCase):
-    def setUp(self):
-        super(TestMenu, self).setUp()
+
+    def test_website_own_menu_container(self):
+        Website = self.env['website']
         Menu = self.env['website.menu']
 
+        total_menus = Menu.search_count([])
+        Website.create({'name': 'new website'})
+        self.assertEqual(total_menus + 2, Menu.search_count([]), "New website's bootstraping should have created a container menu and home menu")
+
+    def test_menu_got_duplicated(self):
+        Menu = self.env['website.menu']
+        total_menu_items = Menu.search_count([])
+
         self.menu_root = Menu.create({
             'name': 'Root',
         })
@@ -16,95 +25,27 @@ class TestMenu(common.TransactionCase):
             'parent_id': self.menu_root.id,
         })
 
-        self.menu_leaf1 = Menu.create({
-            'name': 'Leaf 1',
-            'parent_id': self.menu_child.id,
-        })
-
-        self.menu_leaf2 = Menu.create({
-            'name': 'Leaf 2',
-            'parent_id': self.menu_root.id,
-        })
-
-        # create an extra website so we have 3 in total
-        self.website_test = self.env['website'].create({'domain': 'test'})
-
-    def test_cow_leaf(self):
-        Menu = self.env['website.menu']
-
-        # backend write, no COW
-        total_menu_items = Menu.search_count([])
-        self.menu_leaf1.write({'name': 'Leaf 1 modified'})
-        self.assertEqual(total_menu_items, Menu.search_count([]))
-
-        # write through website 1
-        self.menu_leaf1.with_context(website_id=1).write({'name': 'Leaf 1 Website 1'})
-        self.assertEqual(self.menu_leaf1.name, 'Leaf 1 modified')
-        self.assertEqual(total_menu_items + 1, Menu.search_count([]))
-        new_menu = Menu.search([('name', '=', 'Leaf 1 Website 1')])
-        self.assertEqual(new_menu.website_id.id, 1)
-
-    def test_cow_root(self):
-        Menu = self.env['website.menu']
-
-        # backend write, no COW
-        total_menu_items = Menu.search_count([])
-        self.menu_root.write({'name': 'Root 1 modified'})
-        self.assertEqual(total_menu_items, Menu.search_count([]))
-
-        # write through website 1
-        self.menu_root.with_context(website_id=1).write({'name': 'Root Website 1'})
-        self.assertEqual(self.menu_root.name, 'Root 1 modified')
-        self.assertEqual(total_menu_items + 4, Menu.search_count([]))
+        self.assertEqual(total_menu_items + 4, Menu.search_count([]), "Creating a menu without a website_id should create this menu for every website_id")
 
-        # verify parent/child structure
-        website_specific_leaf2 = Menu.search([('name', '=', 'Leaf 2'), ('website_id', '=', 1)])
-        website_specific_leaf1 = Menu.search([('name', '=', 'Leaf 1'), ('website_id', '=', 1)])
-        website_specific_child = Menu.search([('name', '=', 'Child'), ('website_id', '=', 1)])
-        website_specific_root = Menu.search([('name', '=', 'Root Website 1'), ('website_id', '=', 1)])
-        self.assertEqual(website_specific_leaf2.parent_id.id, website_specific_root.id)
-        self.assertEqual(website_specific_leaf1.parent_id.id, website_specific_child.id)
-        self.assertEqual(website_specific_child.parent_id.id, website_specific_root.id)
-
-    def test_cou_leaf(self):
+    def test_menu_count(self):
         Menu = self.env['website.menu']
-
-        # backend unlink, no COU
-        self.menu_leaf1.unlink()
-        self.assertEqual(len(Menu.search([('name', '=', 'Leaf 1')])), 0)
-
         total_menu_items = Menu.search_count([])
-        self.menu_leaf2.with_context(website_id=1).unlink()
-
-        website_specific_menus = Menu.search([('name', '=', 'Leaf 2')])
-        self.assertEqual(len(website_specific_menus), 2)
-        self.assertEqual(set(website_specific_menus.mapped('website_id').ids), set([2, self.website_test.id]))
-
-        # exactly 2 website-specific menu items were created and one was deleted
-        self.assertEqual(total_menu_items + 1, Menu.search_count([]))
-
-    def test_cou_root_backend(self):
-        Menu = self.env['website.menu']
-        total_menu_items = Menu.search_count([])
-        self.menu_root.unlink()
-
-        # should have deleted root and all children
-        self.assertEqual(total_menu_items - 4, Menu.search_count([]))
-
-    def test_cou_root_frontend(self):
-        Menu = self.env['website.menu']
-        total_menu_items = Menu.search_count([])
-        self.menu_root.with_context(website_id=1).unlink()
-
-        # should have removed 4 generic menus and created root and all children for 2 remaining websites
-        self.assertEqual(Menu.search_count([('name', '=', 'Root'), ('website_id', '=', 2)]), 1)
-        self.assertEqual(Menu.search_count([('name', '=', 'Child'), ('website_id', '=', 2)]), 1)
-        self.assertEqual(Menu.search_count([('name', '=', 'Leaf 1'), ('website_id', '=', 2)]), 1)
-        self.assertEqual(Menu.search_count([('name', '=', 'Leaf 2'), ('website_id', '=', 2)]), 1)
-
-        self.assertEqual(Menu.search_count([('name', '=', 'Root'), ('website_id', '=', self.website_test.id)]), 1)
-        self.assertEqual(Menu.search_count([('name', '=', 'Child'), ('website_id', '=', self.website_test.id)]), 1)
-        self.assertEqual(Menu.search_count([('name', '=', 'Leaf 1'), ('website_id', '=', self.website_test.id)]), 1)
-        self.assertEqual(Menu.search_count([('name', '=', 'Leaf 2'), ('website_id', '=', self.website_test.id)]), 1)
 
-        self.assertEqual(total_menu_items + 4, Menu.search_count([]))
+        top_menu = self.env['website'].get_current_website().menu_id
+        data = [
+            {
+                'id': 'new-1',
+                'parent_id': top_menu.id,
+                'name': 'New Menu Specific 1',
+                'url': '/new-specific-1',
+            },
+            {
+                'id': 'new-2',
+                'parent_id': top_menu.id,
+                'name': 'New Menu Specific 2',
+                'url': '/new-specific-2',
+            }
+        ]
+        Menu.save(1, {'data': data, 'to_delete': []})
+
+        self.assertEqual(total_menu_items + 2, Menu.search_count([]), "Creating 2 new menus should create only 2 menus records")
diff --git a/addons/website/tests/test_page.py b/addons/website/tests/test_page.py
index 76bfa52e51d..3f717740e79 100644
--- a/addons/website/tests/test_page.py
+++ b/addons/website/tests/test_page.py
@@ -1,5 +1,5 @@
 # coding: utf-8
-from odoo.tests import common
+from odoo.tests import common, HttpCase
 
 
 class TestPage(common.TransactionCase):
@@ -31,8 +31,58 @@ class TestPage(common.TransactionCase):
         self.page_1_menu = Menu.create({
             'name': 'Page 1 menu',
             'page_id': self.page_1.id,
+            'website_id': 1,
         })
 
+    def test_copy_page(self):
+        View = self.env['ir.ui.view']
+        Page = self.env['website.page']
+        Menu = self.env['website.menu']
+        # Specific page
+        self.specific_view = View.create({
+            'name': 'Base',
+            'type': 'qweb',
+            'arch': '<div>Specific View</div>',
+            'key': 'test.specific_view',
+        })
+        self.page_specific = Page.create({
+            'view_id': self.specific_view.id,
+            'url': '/page_specific',
+            'website_id': 1,
+        })
+        self.page_specific_menu = Menu.create({
+            'name': 'Page Specific menu',
+            'page_id': self.page_specific.id,
+            'website_id': 1,
+        })
+        total_pages = Page.search_count([])
+        total_menus = Menu.search_count([])
+        # Copying a specific page should create a new page with an unique URL (suffixed by -X)
+        Page.clone_page(self.page_specific.id, True)
+        cloned_page = Page.search([('url', '=', '/page_specific-1')])
+        cloned_menu = Menu.search([('url', '=', '/page_specific-1')])
+        self.assertEqual(len(cloned_page), 1, "A page with an URL /page_specific-1 should've been created")
+        self.assertEqual(Page.search_count([]), total_pages + 1, "Should have cloned the page")
+        # It should also copy its menu with new url/name/page_id (if the page has a menu)
+        self.assertEqual(len(cloned_menu), 1, "A specific page (with a menu) being cloned should have it's menu also cloned")
+        self.assertEqual(cloned_menu.page_id, cloned_page, "The new cloned menu and the new cloned page should be linked (m2o)")
+        self.assertEqual(Menu.search_count([]), total_menus + 1, "Should have cloned the page menu")
+
+        total_pages = Page.search_count([])
+        total_menus = Menu.search_count([])
+
+        # Copying a generic page should create a specific page with same URL
+        Page.clone_page(self.page_1.id, True)
+        cloned_generic_page = Page.search([('url', '=', '/page_1'), ('id', '!=', self.page_1.id), ('website_id', '!=', False)])
+        self.assertEqual(len(cloned_generic_page), 1, "A generic page being cloned should create a specific one for the current website")
+        self.assertEqual(cloned_generic_page.url, self.page_1.url, "The URL of the cloned specific page should be the same as the generic page it has been cloned from")
+        self.assertEqual(Page.search_count([]), total_pages + 1, "Should have cloned the generic page as a specific page for this website")
+        self.assertEqual(Menu.search_count([]), total_menus, "It should not create a new menu as the generic page's menu belong to another website")
+        # Except if the URL already exists for this website (its the case now that we already cloned it once)
+        Page.clone_page(self.page_1.id, True)
+        cloned_generic_page_2 = Page.search([('url', '=', '/page_1-1'), ('id', '!=', self.page_1.id)])
+        self.assertEqual(len(cloned_generic_page_2), 1, "A generic page being cloned should create a specific page with a new URL if there is already a specific page with that URL")
+
     def test_cow_page(self):
         Menu = self.env['website.menu']
         Page = self.env['website.page']
@@ -50,27 +100,23 @@ class TestPage(common.TransactionCase):
         # edit through frontend
         self.page_1.with_context(website_id=1).write({'arch': '<div>website 1 content</div>'})
 
-        # should have created website-specific copies for:
-        # - page
-        # - menu
-        # - view x2 (base view + extension view)
-        # and shouldn't have touched original records
+        # 1. should have created website-specific copies for:
+        #    - page
+        #    - view x2 (base view + extension view)
+        # 2. should not have created menu copy as menus are not shared/COW
+        # 3. and shouldn't have touched original records
         self.assertEqual(total_pages + 1, Page.search_count([]))
-        self.assertEqual(total_menus + 1, Menu.search_count([]))
+        self.assertEqual(total_menus, Menu.search_count([]))
         self.assertEqual(total_views + 2, View.search_count([]))
 
         self.assertEqual(self.page_1.arch, '<div>modified base content</div>')
         self.assertEqual(bool(self.page_1.website_id), False)
-        self.assertEqual(bool(self.page_1_menu.website_id), False)
 
         new_page = Page.search([('url', '=', '/page_1'), ('id', '!=', self.page_1.id)])
         self.assertEqual(new_page.website_id.id, 1)
         self.assertEqual(new_page.view_id.inherit_children_ids[0].website_id.id, 1)
         self.assertEqual(new_page.arch, '<div>website 1 content</div>')
 
-        new_menu = new_page.menu_ids[0]
-        self.assertEqual(new_menu.website_id.id, 1)
-
     def test_cow_extension_view(self):
         ''' test cow on extension view itself (like web_editor would do in the frontend) '''
         Menu = self.env['website.menu']
@@ -98,14 +144,12 @@ class TestPage(common.TransactionCase):
 
         self.assertEqual(self.extension_view.arch, '<div>modified extension content</div>')
         self.assertEqual(bool(self.page_1.website_id), False)
-        self.assertEqual(bool(self.page_1_menu.website_id), False)
 
         new_view = View.search([('name', '=', 'Extension'), ('website_id', '=', 1)])
         self.assertEqual(new_view.arch, '<div>website 1 content</div>')
         self.assertEqual(new_view.website_id.id, 1)
 
     def test_cou_page_backend(self):
-        Menu = self.env['website.menu']
         Page = self.env['website.page']
         View = self.env['ir.ui.view']
 
@@ -113,12 +157,10 @@ class TestPage(common.TransactionCase):
         self.extension_view.unlink()
 
         self.page_1.unlink()
-        self.assertEqual(Menu.search_count([('name', '=', 'Page 1 menu')]), 0)
         self.assertEqual(Page.search_count([('url', '=', '/page_1')]), 0)
         self.assertEqual(View.search_count([('name', 'in', ('Base', 'Extension'))]), 0)
 
     def test_cou_page_frontend(self):
-        Menu = self.env['website.menu']
         Page = self.env['website.page']
         View = self.env['ir.ui.view']
 
@@ -129,8 +171,40 @@ class TestPage(common.TransactionCase):
 
         self.assertEqual(bool(self.base_view.exists()), False)
         self.assertEqual(bool(self.page_1.exists()), False)
+        # Not COU but deleting a page will delete its menu (cascade)
         self.assertEqual(bool(self.page_1_menu.exists()), False)
 
-        self.assertEqual(Menu.search([('name', '=', 'Page 1 menu')]).website_id.id, 2)
         self.assertEqual(Page.search([('url', '=', '/page_1')]).website_id.id, 2)
         self.assertEqual(View.search([('name', 'in', ('Base', 'Extension'))]).mapped('website_id').id, 2)
+
+
+class Crawler(HttpCase):
+    def test_unpublished_page(self):
+        Page = self.env['website.page']
+        View = self.env['ir.ui.view']
+        base_view = View.create({
+            'name': 'Base',
+            'type': 'qweb',
+            'arch': '''<t name="Homepage" t-name="website.base_view">
+                        <t t-call="website.layout">
+                            I am a generic page
+                        </t>
+                    </t>''',
+            'key': 'test.base_view',
+        })
+        generic_page = Page.create({
+            'view_id': base_view.id,
+            'url': '/page_1',
+            'website_published': True,
+        })
+
+        specific_page = generic_page.copy({'website_id': self.env['website'].get_current_website().id})
+        specific_page.write({'website_published': False, 'arch': generic_page.arch.replace('I am a generic page', 'I am a specific page')})
+
+        r = self.url_open(specific_page.url)
+        self.assertEqual(r.status_code, 404, "Restricted users should see a 404 and not the generic one as we unpublished the specific one")
+
+        self.authenticate('admin', 'admin')
+        r = self.url_open(specific_page.url)
+        self.assertEqual(r.status_code, 200, "Admin should see the specific unpublished page")
+        self.assertEqual('I am a specific page' in r.text, True, "Admin should see the specific unpublished page")