154 lines
6.3 KiB
Python
154 lines
6.3 KiB
Python
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
|
|
|
from odoo import Command
|
|
from odoo.exceptions import UserError
|
|
from odoo.tests.common import TransactionCase
|
|
from odoo.addons.mail.tests.common import mail_new_test_user
|
|
|
|
|
|
class TestDocumentsDocumentFolder(TransactionCase):
|
|
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
super().setUpClass()
|
|
cls.parent_folder = cls.env['documents.document'].create({
|
|
'name': 'Parent',
|
|
'type': 'folder',
|
|
})
|
|
cls.folder = cls.env['documents.document'].create({
|
|
'name': 'Folder',
|
|
'type': 'folder',
|
|
'folder_id': cls.parent_folder.id,
|
|
})
|
|
cls.child_folder = cls.env['documents.document'].create({
|
|
'name': 'Child',
|
|
'type': 'folder',
|
|
'folder_id': cls.folder.id,
|
|
})
|
|
cls.document = cls.env['documents.document'].create({
|
|
'raw': b'TEST',
|
|
'name': 'file.txt',
|
|
'mimetype': 'text/plain',
|
|
'folder_id': cls.child_folder.id
|
|
})
|
|
cls.folders = cls.parent_folder | cls.folder | cls.child_folder
|
|
|
|
cls.user_portal = mail_new_test_user(
|
|
cls.env,
|
|
login='portal_test',
|
|
groups='base.group_portal',
|
|
company_id=cls.env.ref('base.main_company').id,
|
|
name='portal',
|
|
notification_type='email'
|
|
)
|
|
|
|
def test_folder_archive_unarchive(self):
|
|
""" General archive/restore test """
|
|
self.folder.action_archive()
|
|
self.assertEqual(
|
|
(self.folders | self.document).mapped('active'),
|
|
[True, False, False, False],
|
|
)
|
|
self.assertEqual(self.folders.exists(), self.folders,
|
|
"No folder/document should have been deleted")
|
|
|
|
with self.assertRaises(UserError) as capture:
|
|
self.child_folder.action_unarchive()
|
|
self.assertEqual(
|
|
capture.exception.args[0],
|
|
"Item(s) you wish to restore are included in archived folders. "
|
|
"To restore these items, you must restore the following including folders instead:"
|
|
"\n"
|
|
"- Folder"
|
|
)
|
|
|
|
self.folder.action_unarchive()
|
|
self.assertEqual(
|
|
(self.folders | self.document).mapped('active'),
|
|
[True, True, True, True],
|
|
)
|
|
self.assertEqual(self.folder.folder_id, self.parent_folder,
|
|
"The restored folder must be anchored to the parent it had")
|
|
|
|
def test_folder_unlink(self):
|
|
""" To unlink a folder should unlink all its descendant. """
|
|
self.folder.unlink()
|
|
self.assertEqual(self.folders.exists(), self.parent_folder,
|
|
"Folder and Child Folder must have been deleted")
|
|
self.assertFalse(self.document.exists())
|
|
|
|
def test_folder_archive_unlink(self):
|
|
"""
|
|
To unlink the last document of an archived folder should unlink
|
|
that folder too.
|
|
"""
|
|
self.folder.action_archive()
|
|
self.document.unlink()
|
|
self.assertEqual(
|
|
self.folders.exists(), self.parent_folder, "Folder and Child Folder should have been deleted"
|
|
)
|
|
|
|
def test_folder_create_subfolder(self):
|
|
self.folder.action_update_access_rights('view', 'edit', False, {
|
|
self.user_portal.partner_id: ('view', None),
|
|
})
|
|
new_folder = self.env['documents.document'].create({
|
|
'name': 'New Child Folder',
|
|
'folder_id': self.folder.id,
|
|
})
|
|
self.assertEqual(new_folder.access_internal, 'view')
|
|
self.assertEqual(new_folder.access_via_link, 'edit')
|
|
self.assertFalse(new_folder.is_access_via_link_hidden)
|
|
acl = new_folder.access_ids.ensure_one()
|
|
self.assertEqual(acl.partner_id, self.user_portal.partner_id)
|
|
self.assertEqual(acl.role, 'view')
|
|
|
|
def test_folder_copy(self):
|
|
folder_copy = self.folder.copy()
|
|
self.assertNotEqual(folder_copy.id, self.folder.id)
|
|
self.assertEqual(folder_copy.name, self.folder.name)
|
|
self.assertEqual(folder_copy.type, 'folder')
|
|
self.assertEqual(folder_copy.folder_id, self.parent_folder)
|
|
|
|
child_copy = folder_copy.children_ids.ensure_one()
|
|
self.assertNotEqual(child_copy.id, self.child_folder.id)
|
|
self.assertEqual(child_copy.name, self.child_folder.name)
|
|
self.assertEqual(child_copy.type, 'folder')
|
|
self.assertEqual(child_copy.folder_id, folder_copy)
|
|
|
|
document_copy = child_copy.children_ids.ensure_one()
|
|
self.assertNotEqual(document_copy.id, self.document.id)
|
|
self.assertEqual(document_copy.name, f'{self.document.name} (copy)')
|
|
self.assertEqual(document_copy.type, 'binary')
|
|
self.assertEqual(document_copy.folder_id, child_copy)
|
|
|
|
attachment = document_copy.attachment_id.ensure_one()
|
|
self.assertNotEqual(attachment.id, self.document.attachment_id.id)
|
|
self.assertEqual(document_copy.raw, self.document.raw)
|
|
|
|
def test_folder_copy_embedded_actions(self):
|
|
"""Test that copying a folder embeds the same server actions"""
|
|
original_folder = self.env['documents.document'].create({
|
|
'type': 'folder',
|
|
'name': 'A Folder',
|
|
'children_ids': [Command.create({'name': "A Request"})]
|
|
})
|
|
original_child = original_folder.children_ids[0]
|
|
self.assertFalse(original_folder.available_embedded_actions_ids)
|
|
server_action = self.env.ref('documents.ir_actions_server_tag_add_validated')
|
|
self.env['documents.document'].action_folder_embed_action(
|
|
original_folder.id, server_action.id)
|
|
original_child._compute_available_embedded_actions_ids()
|
|
action_original_child = original_child.available_embedded_actions_ids
|
|
|
|
self.assertEqual(len(action_original_child), 1)
|
|
self.assertEqual(action_original_child.action_id.id, server_action.id)
|
|
|
|
copied_folder = original_folder.copy()
|
|
copied_child = copied_folder.children_ids[0]
|
|
copied_child._compute_available_embedded_actions_ids()
|
|
action_copied_child = copied_child.available_embedded_actions_ids
|
|
self.assertEqual(len(action_copied_child), 1)
|
|
self.assertEqual(action_original_child.action_id, action_copied_child.action_id)
|
|
self.assertNotEqual(action_original_child, action_copied_child)
|