initial commit 2

7 files changed, 1046 insertions, 0 deletions

diff --git a/addons/website_slides/tests/__init__.py b/addons/website_slides/tests/__init__.py
new file mode 100644
index 00000000..ec3a0a5f
--- /dev/null
+++ b/addons/website_slides/tests/__init__.py
@@ -0,0 +1,9 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from . import common
+from . import test_karma
+from . import test_security
+from . import test_slide_utils
+from . import test_statistics
+from . import test_ui_wslides
diff --git a/addons/website_slides/tests/common.py b/addons/website_slides/tests/common.py
new file mode 100644
index 00000000..fa336fa0
--- /dev/null
+++ b/addons/website_slides/tests/common.py
@@ -0,0 +1,100 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from odoo.tests import common
+from odoo.addons.mail.tests.common import mail_new_test_user
+
+
+class SlidesCase(common.SavepointCase):
+
+    @classmethod
+    def setUpClass(cls):
+        super(SlidesCase, cls).setUpClass()
+
+        cls.user_officer = mail_new_test_user(
+            cls.env, name='Ophélie Officer', login='user_officer', email='officer@example.com',
+            groups='base.group_user,website_slides.group_website_slides_officer'
+        )
+
+        cls.user_manager = mail_new_test_user(
+            cls.env, name='Manuel Manager', login='user_manager', email='manager@example.com',
+            groups='base.group_user,website_slides.group_website_slides_manager'
+        )
+
+        cls.user_emp = mail_new_test_user(
+            cls.env, name='Eglantine Employee', login='user_emp', email='employee@example.com',
+            groups='base.group_user'
+        )
+
+        cls.user_portal = mail_new_test_user(
+            cls.env, name='Patrick Portal', login='user_portal', email='portal@example.com',
+            groups='base.group_portal'
+        )
+
+        cls.user_public = mail_new_test_user(
+            cls.env, name='Pauline Public', login='user_public', email='public@example.com',
+            groups='base.group_public'
+        )
+
+        cls.customer = cls.env['res.partner'].create({
+            'name': 'Caroline Customer',
+            'email': 'customer@example.com',
+        })
+
+        cls.channel = cls.env['slide.channel'].with_user(cls.user_officer).create({
+            'name': 'Test Channel',
+            'channel_type': 'documentation',
+            'promote_strategy': 'most_voted',
+            'enroll': 'public',
+            'visibility': 'public',
+            'is_published': True,
+            'karma_gen_channel_finish': 100,
+            'karma_gen_slide_vote': 5,
+            'karma_gen_channel_rank': 10,
+        })
+        cls.slide = cls.env['slide.slide'].with_user(cls.user_officer).create({
+            'name': 'How To Cook Humans',
+            'channel_id': cls.channel.id,
+            'slide_type': 'presentation',
+            'is_published': True,
+            'completion_time': 2.0,
+            'sequence': 1,
+        })
+        cls.category = cls.env['slide.slide'].with_user(cls.user_officer).create({
+            'name': 'Cooking Tips for Humans',
+            'channel_id': cls.channel.id,
+            'is_category': True,
+            'is_published': True,
+            'sequence': 2,
+        })
+        cls.slide_2 = cls.env['slide.slide'].with_user(cls.user_officer).create({
+            'name': 'How To Cook For Humans',
+            'channel_id': cls.channel.id,
+            'slide_type': 'presentation',
+            'is_published': True,
+            'completion_time': 3.0,
+            'sequence': 3,
+        })
+        cls.slide_3 = cls.env['slide.slide'].with_user(cls.user_officer).create({
+            'name': 'How To Cook Humans For Humans',
+            'channel_id': cls.channel.id,
+            'slide_type': 'document',
+            'is_published': True,
+            'completion_time': 1.5,
+            'sequence': 4,
+            'quiz_first_attempt_reward': 42,
+        })
+        cls.question_1 = cls.env['slide.question'].with_user(cls.user_officer).create({
+            'question': 'How long should be cooked a human?',
+            'slide_id': cls.slide_3.id,
+        })
+        cls.answer_1 = cls.env['slide.answer'].with_user(cls.user_officer).create({
+            'question_id': cls.question_1.id,
+            'text_value': "25' at 180°C",
+            'is_correct': True,
+        })
+        cls.answer_2 = cls.env['slide.answer'].with_user(cls.user_officer).create({
+            'question_id': cls.question_1.id,
+            'text_value': "Raw",
+            'is_correct': False,
+        })
diff --git a/addons/website_slides/tests/test_karma.py b/addons/website_slides/tests/test_karma.py
new file mode 100644
index 00000000..83e8374b
--- /dev/null
+++ b/addons/website_slides/tests/test_karma.py
@@ -0,0 +1,113 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from odoo.addons.website_slides.tests import common
+from odoo.tests import tagged
+from odoo.tests.common import users
+from odoo.tools import mute_logger
+
+
+@tagged('functional')
+class TestKarmaGain(common.SlidesCase):
+
+    def setUp(self):
+        super(TestKarmaGain, self).setUp()
+
+        self.channel_2 = self.env['slide.channel'].with_user(self.user_officer).create({
+            'name': 'Test Channel 2',
+            'channel_type': 'training',
+            'promote_strategy': 'most_voted',
+            'enroll': 'public',
+            'visibility': 'public',
+            'is_published': True,
+            'karma_gen_channel_finish': 100,
+            'karma_gen_slide_vote': 5,
+            'karma_gen_channel_rank': 10,
+        })
+
+        self.slide_2_0 = self.env['slide.slide'].with_user(self.user_officer).create({
+            'name': 'How to travel through space and time',
+            'channel_id': self.channel_2.id,
+            'slide_type': 'presentation',
+            'is_published': True,
+            'completion_time': 2.0,
+        })
+        self.slide_2_1 = self.env['slide.slide'].with_user(self.user_officer).create({
+            'name': 'How to duplicate yourself',
+            'channel_id': self.channel_2.id,
+            'slide_type': 'presentation',
+            'is_published': True,
+            'completion_time': 2.0,
+        })
+
+    @mute_logger('odoo.models')
+    @users('user_emp', 'user_portal', 'user_officer')
+    def test_karma_gain(self):
+        user = self.env.user
+        user.write({'karma': 0})
+        computed_karma = 0
+
+        # Add the user to the course
+        (self.channel | self.channel_2)._action_add_members(user.partner_id)
+        self.assertEqual(user.karma, 0)
+
+        # Finish the Course
+        self.slide.with_user(user).action_set_completed()
+        self.assertFalse(self.channel.with_user(user).completed)
+        self.slide_2.with_user(user).action_set_completed()
+
+        # answer a quizz question
+        self.slide_3.with_user(user).action_set_viewed(quiz_attempts_inc=True)
+        self.slide_3.with_user(user)._action_set_quiz_done()
+        self.slide_3.with_user(user).action_set_completed()
+        computed_karma += self.slide_3.quiz_first_attempt_reward
+        computed_karma += self.channel.karma_gen_channel_finish
+
+        self.assertTrue(self.channel.with_user(user).completed)
+        self.assertEqual(user.karma, computed_karma)
+
+        # Begin then finish the second Course
+        self.slide_2_0.with_user(user).action_set_completed()
+        self.assertFalse(self.channel_2.with_user(user).completed)
+        self.assertEqual(user.karma, computed_karma)
+
+        self.slide_2_1.with_user(user).action_set_completed()
+        self.assertTrue(self.channel_2.with_user(user).completed)
+        computed_karma += self.channel_2.karma_gen_channel_finish
+        self.assertEqual(user.karma, computed_karma)
+
+        # Vote for a slide
+        slide_user = self.slide.with_user(user)
+        slide_user.action_like()
+        computed_karma += self.channel.karma_gen_slide_vote
+        self.assertEqual(user.karma, computed_karma)
+        slide_user.action_like()  # re-like something already liked should not add karma again
+        self.assertEqual(user.karma, computed_karma)
+        slide_user.action_dislike()
+        computed_karma -= self.channel.karma_gen_slide_vote
+        self.assertEqual(user.karma, computed_karma)
+        slide_user.action_dislike()
+        computed_karma -= self.channel.karma_gen_slide_vote
+        self.assertEqual(user.karma, computed_karma)
+        slide_user.action_dislike()  # dislike again something already disliked should not remove karma again
+        self.assertEqual(user.karma, computed_karma)
+
+        # Leave the finished course
+        self.channel._remove_membership(user.partner_id.ids)
+        computed_karma -= self.channel.karma_gen_channel_finish
+        computed_karma -= self.slide_3.quiz_first_attempt_reward
+        self.assertEqual(user.karma, computed_karma)
+
+    @mute_logger('odoo.models')
+    @users('user_emp', 'user_portal', 'user_officer')
+    def test_karma_gain_multiple_course(self):
+        user = self.env.user
+        user.write({'karma': 0})
+        computed_karma = 0
+
+        # Finish two course at the same time (should not ever happen but hey, we never know)
+        (self.channel | self.channel_2)._action_add_members(user.partner_id)
+
+        computed_karma += self.channel.karma_gen_channel_finish + self.channel_2.karma_gen_channel_finish
+        (self.slide | self.slide_2 | self.slide_3 | self.slide_2_0 | self.slide_2_1).with_user(user).action_set_completed()
+        self.assertEqual(user.karma, computed_karma)
diff --git a/addons/website_slides/tests/test_security.py b/addons/website_slides/tests/test_security.py
new file mode 100644
index 00000000..1f5eecc3
--- /dev/null
+++ b/addons/website_slides/tests/test_security.py
@@ -0,0 +1,300 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from odoo.addons.website_slides.tests import common
+from odoo.exceptions import AccessError, UserError
+from odoo.tests import tagged
+from odoo.tests.common import users
+from odoo.tools import mute_logger
+
+
+@tagged('security')
+class TestAccess(common.SlidesCase):
+
+    @mute_logger('odoo.models', 'odoo.addons.base.models.ir_rule')
+    def test_access_channel_invite(self):
+        """ Invite channels don't give enroll if not member """
+        self.channel.write({'enroll': 'invite'})
+
+        self.channel.with_user(self.user_officer).read(['name'])
+        self.channel.with_user(self.user_manager).read(['name'])
+        self.channel.with_user(self.user_emp).read(['name'])
+        self.channel.with_user(self.user_portal).read(['name'])
+        self.channel.with_user(self.user_public).read(['name'])
+
+        self.slide.with_user(self.user_officer).read(['name'])
+        self.slide.with_user(self.user_manager).read(['name'])
+
+        with self.assertRaises(AccessError):
+            self.slide.with_user(self.user_emp).read(['name'])
+        with self.assertRaises(AccessError):
+            self.slide.with_user(self.user_portal).read(['name'])
+        with self.assertRaises(AccessError):
+            self.slide.with_user(self.user_portal).read(['name'])
+
+        # if member -> can read
+        membership = self.env['slide.channel.partner'].create({
+            'channel_id': self.channel.id,
+            'partner_id': self.user_emp.partner_id.id,
+        })
+        self.channel.with_user(self.user_emp).read(['name'])
+        self.slide.with_user(self.user_emp).read(['name'])
+
+        # not member anymore -> cannot read
+        membership.unlink()
+        self.channel.with_user(self.user_emp).read(['name'])
+        with self.assertRaises(AccessError):
+            self.slide.with_user(self.user_emp).read(['name'])
+
+    @mute_logger('odoo.models', 'odoo.addons.base.models.ir_rule')
+    def test_access_channel_public(self):
+        """ Public channels don't give enroll if not member """
+        self.channel.write({'enroll': 'public'})
+
+        self.channel.with_user(self.user_officer).read(['name'])
+        self.channel.with_user(self.user_manager).read(['name'])
+        self.channel.with_user(self.user_emp).read(['name'])
+        self.channel.with_user(self.user_portal).read(['name'])
+        self.channel.with_user(self.user_public).read(['name'])
+
+        self.slide.with_user(self.user_officer).read(['name'])
+        self.slide.with_user(self.user_manager).read(['name'])
+
+        with self.assertRaises(AccessError):
+            self.slide.with_user(self.user_emp).read(['name'])
+        with self.assertRaises(AccessError):
+            self.slide.with_user(self.user_portal).read(['name'])
+        with self.assertRaises(AccessError):
+            self.slide.with_user(self.user_public).read(['name'])
+
+    @mute_logger('odoo.models', 'odoo.addons.base.models.ir_rule')
+    def test_access_channel_publish(self):
+        """ Unpublished channels and their content are visible only to eLearning people """
+        self.channel.write({'is_published': False, 'enroll': 'public'})
+        self.channel.flush(['is_published', 'website_published', 'enroll'])
+
+        # channel available only to eLearning
+        self.channel.invalidate_cache(['name'])
+        self.channel.with_user(self.user_officer).read(['name'])
+        self.channel.invalidate_cache(['name'])
+        self.channel.with_user(self.user_manager).read(['name'])
+        with self.assertRaises(AccessError):
+            self.channel.invalidate_cache(['name'])
+            self.channel.with_user(self.user_emp).read(['name'])
+        with self.assertRaises(AccessError):
+            self.channel.invalidate_cache(['name'])
+            self.channel.with_user(self.user_portal).read(['name'])
+        with self.assertRaises(AccessError):
+            self.channel.invalidate_cache(['name'])
+            self.channel.with_user(self.user_public).read(['name'])
+
+        # slide available only to eLearning
+        self.channel.invalidate_cache(['name'])
+        self.slide.with_user(self.user_officer).read(['name'])
+        self.channel.invalidate_cache(['name'])
+        self.slide.with_user(self.user_manager).read(['name'])
+        with self.assertRaises(AccessError):
+            self.slide.invalidate_cache(['name'])
+            self.slide.with_user(self.user_emp).read(['name'])
+        with self.assertRaises(AccessError):
+            self.slide.invalidate_cache(['name'])
+            self.slide.with_user(self.user_portal).read(['name'])
+        with self.assertRaises(AccessError):
+            self.slide.invalidate_cache(['name'])
+            self.slide.with_user(self.user_public).read(['name'])
+
+        # even members cannot see unpublished content
+        self.env['slide.channel.partner'].create({
+            'channel_id': self.channel.id,
+            'partner_id': self.user_emp.partner_id.id,
+        })
+        with self.assertRaises(AccessError):
+            self.channel.invalidate_cache(['name'])
+            self.channel.with_user(self.user_emp).read(['name'])
+        with self.assertRaises(AccessError):
+            self.slide.invalidate_cache(['name'])
+            self.slide.with_user(self.user_emp).read(['name'])
+
+        # publish channel but content unpublished (even if can be previewed) still unavailable
+        self.channel.write({'is_published': True})
+        self.slide.write({
+            'is_preview': True,
+            'is_published': False,
+        })
+        self.channel.flush(['website_published'])
+        self.slide.flush(['is_preview', 'website_published'])
+
+        self.slide.invalidate_cache(['name'])
+        self.slide.with_user(self.user_officer).read(['name'])
+        self.slide.invalidate_cache(['name'])
+        self.slide.with_user(self.user_manager).read(['name'])
+        with self.assertRaises(AccessError):
+            self.slide.invalidate_cache(['name'])
+            self.slide.with_user(self.user_emp).read(['name'])
+        with self.assertRaises(AccessError):
+            self.slide.invalidate_cache(['name'])
+            self.slide.with_user(self.user_portal).read(['name'])
+        with self.assertRaises(AccessError):
+            self.slide.invalidate_cache(['name'])
+            self.slide.with_user(self.user_public).read(['name'])
+
+    @mute_logger('odoo.models', 'odoo.addons.base.models.ir_rule')
+    def test_access_slide_preview(self):
+        """ Slides with preview flag are always visible even to non members if published """
+        self.channel.write({'enroll': 'invite'})
+        self.slide.write({'is_preview': True})
+        self.slide.flush(['is_preview'])
+
+        self.slide.with_user(self.user_officer).read(['name'])
+        self.slide.with_user(self.user_manager).read(['name'])
+        self.slide.with_user(self.user_emp).read(['name'])
+        self.slide.with_user(self.user_portal).read(['name'])
+        self.slide.with_user(self.user_public).read(['name'])
+
+
+@tagged('functional', 'security')
+class TestRemoveMembership(common.SlidesCase):
+
+    def setUp(self):
+        super(TestRemoveMembership, self).setUp()
+        self.channel_partner = self.env['slide.channel.partner'].create({
+            'channel_id': self.channel.id,
+            'partner_id': self.customer.id,
+        })
+
+        self.slide_partner = self.env['slide.slide.partner'].create({
+            'slide_id': self.slide.id,
+            'channel_id': self.channel.id,
+            'partner_id': self.customer.id
+        })
+
+    def test_security_unlink(self):
+        # Only the publisher can unlink channel_partner (and slide_partner by extension)
+        with self.assertRaises(AccessError):
+            self.channel_partner.with_user(self.user_public).unlink()
+        with self.assertRaises(AccessError):
+            self.channel_partner.with_user(self.user_portal).unlink()
+        with self.assertRaises(AccessError):
+            self.channel_partner.with_user(self.user_emp).unlink()
+
+    def test_slide_partner_remove(self):
+        id_slide_partner = self.slide_partner.id
+        id_channel_partner = self.channel_partner.id
+        self.channel_partner.with_user(self.user_officer).unlink()
+        self.assertFalse(self.env['slide.channel.partner'].search([('id', '=', '%d' % id_channel_partner)]))
+        # Slide(s) related to the channel and the partner is unlink too.
+        self.assertFalse(self.env['slide.slide.partner'].search([('id', '=', '%d' % id_slide_partner)]))
+
+
+@tagged('functional')
+class TestAccessFeatures(common.SlidesCase):
+
+    @mute_logger('odoo.models', 'odoo.addons.base.models.ir_rule')
+    def test_channel_auto_subscription(self):
+        user_employees = self.env['res.users'].search([('groups_id', 'in', self.ref('base.group_user'))])
+
+        channel = self.env['slide.channel'].with_user(self.user_officer).create({
+            'name': 'Test',
+            'enroll': 'invite',
+            'is_published': True,
+            'enroll_group_ids': [(4, self.ref('base.group_user'))]
+        })
+        channel.invalidate_cache(['partner_ids'])
+        self.assertEqual(channel.partner_ids, user_employees.mapped('partner_id'))
+
+        new_user = self.env['res.users'].create({
+            'name': 'NewUser',
+            'login': 'NewUser',
+            'groups_id': [(6, 0, [self.ref('base.group_user')])]
+        })
+        channel.invalidate_cache()
+        self.assertEqual(channel.partner_ids, user_employees.mapped('partner_id') | new_user.partner_id)
+
+        new_user_2 = self.env['res.users'].create({
+            'name': 'NewUser2',
+            'login': 'NewUser2',
+            'groups_id': [(5, 0)]
+        })
+        channel.invalidate_cache()
+        self.assertEqual(channel.partner_ids, user_employees.mapped('partner_id') | new_user.partner_id)
+        new_user_2.write({'groups_id': [(4, self.ref('base.group_user'))]})
+        channel.invalidate_cache()
+        self.assertEqual(channel.partner_ids, user_employees.mapped('partner_id') | new_user.partner_id | new_user_2.partner_id)
+
+        new_user_3 = self.env['res.users'].create({
+            'name': 'NewUser3',
+            'login': 'NewUser3',
+            'groups_id': [(5, 0)]
+        })
+        channel.invalidate_cache()
+        self.assertEqual(channel.partner_ids, user_employees.mapped('partner_id') | new_user.partner_id | new_user_2.partner_id)
+        self.env.ref('base.group_user').write({'users': [(4, new_user_3.id)]})
+        channel.invalidate_cache()
+        self.assertEqual(channel.partner_ids, user_employees.mapped('partner_id') | new_user.partner_id | new_user_2.partner_id | new_user_3.partner_id)
+
+    @mute_logger('odoo.models', 'odoo.addons.base.models.ir_rule')
+    def test_channel_access_fields_employee(self):
+        channel_manager = self.channel.with_user(self.user_manager)
+        channel_emp = self.channel.with_user(self.user_emp)
+        channel_portal = self.channel.with_user(self.user_portal)
+        self.assertFalse(channel_emp.can_upload)
+        self.assertFalse(channel_emp.can_publish)
+        self.assertFalse(channel_portal.can_upload)
+        self.assertFalse(channel_portal.can_publish)
+
+        # allow employees to upload
+        channel_manager.write({'upload_group_ids': [(4, self.ref('base.group_user'))]})
+        self.assertTrue(channel_emp.can_upload)
+        self.assertFalse(channel_emp.can_publish)
+        self.assertFalse(channel_portal.can_upload)
+        self.assertFalse(channel_portal.can_publish)
+
+    @mute_logger('odoo.models', 'odoo.addons.base.models.ir_rule')
+    def test_channel_access_fields_officer(self):
+        self.assertEqual(self.channel.user_id, self.user_officer)
+
+        channel_officer = self.channel.with_user(self.user_officer)
+        self.assertTrue(channel_officer.can_upload)
+        self.assertTrue(channel_officer.can_publish)
+
+        channel_officer.write({'upload_group_ids': [(4, self.ref('base.group_system'))]})
+        self.assertTrue(channel_officer.can_upload)
+        self.assertTrue(channel_officer.can_publish)
+
+        channel_manager = self.channel.with_user(self.user_manager)
+        channel_manager.write({
+            'upload_group_ids': [(5, 0)],
+            'user_id': self.user_manager.id
+        })
+        self.assertFalse(channel_officer.can_upload)
+        self.assertFalse(channel_officer.can_publish)
+        self.assertTrue(channel_manager.can_upload)
+        self.assertTrue(channel_manager.can_publish)
+
+    @mute_logger('odoo.models', 'odoo.addons.base.models.ir_rule')
+    def test_channel_access_fields_manager(self):
+        channel_manager = self.channel.with_user(self.user_manager)
+        self.assertTrue(channel_manager.can_upload)
+        self.assertTrue(channel_manager.can_publish)
+
+        # test upload group limitation: member of group_system OR responsible OR manager
+        channel_manager.write({'upload_group_ids': [(4, self.ref('base.group_system'))]})
+        self.assertFalse(channel_manager.can_upload)
+        self.assertFalse(channel_manager.can_publish)
+        channel_manager.write({'user_id': self.user_manager.id})
+        self.assertTrue(channel_manager.can_upload)
+        self.assertTrue(channel_manager.can_publish)
+
+        # Needs the manager to write on channel as user_officer is not the responsible anymore
+        channel_manager.write({'upload_group_ids': [(5, 0)]})
+        self.assertTrue(channel_manager.can_upload)
+        self.assertTrue(channel_manager.can_publish)
+        channel_manager.write({'user_id': self.user_officer.id})
+        self.assertTrue(channel_manager.can_upload)
+        self.assertTrue(channel_manager.can_publish)
+
+        # superuser should always be able to publish even if he's not the responsible
+        channel_superuser = self.channel.sudo()
+        channel_superuser.invalidate_cache(['can_upload', 'can_publish'])
+        self.assertTrue(channel_superuser.can_upload)
+        self.assertTrue(channel_superuser.can_publish)
diff --git a/addons/website_slides/tests/test_slide_utils.py b/addons/website_slides/tests/test_slide_utils.py
new file mode 100644
index 00000000..58a8b72c
--- /dev/null
+++ b/addons/website_slides/tests/test_slide_utils.py
@@ -0,0 +1,160 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from odoo.addons.website_slides.tests import common as slides_common
+from odoo.tests.common import users
+
+
+class TestSlidesManagement(slides_common.SlidesCase):
+
+    @users('user_officer')
+    def test_get_categorized_slides(self):
+        new_category = self.env['slide.slide'].create({
+            'name': 'Cooking Tips for Cooking Humans',
+            'channel_id': self.channel.id,
+            'is_category': True,
+            'sequence': 5,
+        })
+        order = self.env['slide.slide']._order_by_strategy['sequence']
+        categorized_slides = self.channel._get_categorized_slides([], order)
+        self.assertEqual(categorized_slides[0]['category'], False)
+        self.assertEqual(categorized_slides[1]['category'], self.category)
+        self.assertEqual(categorized_slides[1]['total_slides'], 2)
+        self.assertEqual(categorized_slides[2]['total_slides'], 0)
+        self.assertEqual(categorized_slides[2]['category'], new_category)
+
+    @users('user_manager')
+    def test_archive(self):
+        self.env['slide.slide.partner'].create({
+            'slide_id': self.slide.id,
+            'channel_id': self.channel.id,
+            'partner_id': self.user_manager.partner_id.id,
+            'completed': True
+        })
+        channel_partner = self.channel._action_add_members(self.user_manager.partner_id)
+
+        self.assertTrue(self.channel.active)
+        self.assertTrue(self.channel.is_published)
+        self.assertFalse(channel_partner.completed)
+        for slide in self.channel.slide_ids:
+            self.assertTrue(slide.active, "All slide should be archived when a channel is archived")
+            self.assertTrue(slide.is_published, "All slide should be unpublished when a channel is archived")
+
+        self.channel.toggle_active()
+        self.assertFalse(self.channel.active)
+        self.assertFalse(self.channel.is_published)
+        # channel_partner should still NOT be marked as completed
+        self.assertFalse(channel_partner.completed)
+
+        for slide in self.channel.slide_ids:
+            self.assertFalse(slide.active, "All slides should be archived when a channel is archived")
+            if not slide.is_category:
+                self.assertFalse(slide.is_published, "All slides should be unpublished when a channel is archived, except categories")
+            else:
+                self.assertTrue(slide.is_published, "All slides should be unpublished when a channel is archived, except categories")
+
+class TestSequencing(slides_common.SlidesCase):
+
+    @users('user_officer')
+    def test_category_update(self):
+        self.assertEqual(self.channel.slide_category_ids, self.category)
+        self.assertEqual(self.channel.slide_content_ids, self.slide | self.slide_2 | self.slide_3)
+        self.assertEqual(self.slide.category_id, self.env['slide.slide'])
+        self.assertEqual(self.slide_2.category_id, self.category)
+        self.assertEqual(self.slide_3.category_id, self.category)
+        self.assertEqual([s.id for s in self.channel.slide_ids], [self.slide.id, self.category.id, self.slide_2.id, self.slide_3.id])
+
+        self.slide.write({'sequence': 0})
+        self.assertEqual([s.id for s in self.channel.slide_ids], [self.slide.id, self.category.id, self.slide_2.id, self.slide_3.id])
+        self.assertEqual(self.slide_2.category_id, self.category)
+        self.slide_2.write({'sequence': 1})
+        self.channel.invalidate_cache()
+        self.assertEqual([s.id for s in self.channel.slide_ids], [self.slide.id, self.slide_2.id, self.category.id, self.slide_3.id])
+        self.assertEqual(self.slide_2.category_id, self.env['slide.slide'])
+
+        channel_2 = self.env['slide.channel'].create({
+            'name': 'Test2'
+        })
+        new_category = self.env['slide.slide'].create({
+            'name': 'NewCategorySlide',
+            'channel_id': channel_2.id,
+            'is_category': True,
+            'sequence': 1,
+        })
+        new_category_2 = self.env['slide.slide'].create({
+            'name': 'NewCategorySlide2',
+            'channel_id': channel_2.id,
+            'is_category': True,
+            'sequence': 2,
+        })
+        new_slide = self.env['slide.slide'].create({
+            'name': 'NewTestSlide',
+            'channel_id': channel_2.id,
+            'sequence': 2,
+        })
+        self.assertEqual(new_slide.category_id, new_category_2)
+        (new_slide | self.slide_3).write({'sequence': 1})
+        self.assertEqual(new_slide.category_id, new_category)
+        self.assertEqual(self.slide_3.category_id, self.env['slide.slide'])
+
+        (new_slide | self.slide_3).write({'sequence': 0})
+        self.assertEqual(new_slide.category_id, self.env['slide.slide'])
+        self.assertEqual(self.slide_3.category_id, self.env['slide.slide'])
+
+    @users('user_officer')
+    def test_resequence(self):
+        self.assertEqual(self.slide.sequence, 1)
+        self.category.write({'sequence': 4})
+        self.slide_2.write({'sequence': 8})
+        self.slide_3.write({'sequence': 3})
+
+        self.channel.invalidate_cache()
+        self.assertEqual([s.id for s in self.channel.slide_ids], [self.slide.id, self.slide_3.id, self.category.id, self.slide_2.id])
+        self.assertEqual(self.slide.sequence, 1)
+
+        # insert a new category and check resequence_slides does as expected
+        new_category = self.env['slide.slide'].create({
+            'name': 'Sub-cooking Tips Category',
+            'channel_id': self.channel.id,
+            'is_category': True,
+            'is_published': True,
+            'sequence': 2,
+        })
+        new_category.flush()
+        self.channel.invalidate_cache()
+        self.channel._resequence_slides(self.slide_3, force_category=new_category)
+        self.assertEqual(self.slide.sequence, 1)
+        self.assertEqual(new_category.sequence, 2)
+        self.assertEqual(self.slide_3.sequence, 3)
+        self.assertEqual(self.category.sequence, 4)
+        self.assertEqual(self.slide_2.sequence, 5)
+        self.assertEqual([s.id for s in self.channel.slide_ids], [self.slide.id, new_category.id, self.slide_3.id, self.category.id, self.slide_2.id])
+
+
+class TestFromURL(slides_common.SlidesCase):
+    def test_youtube_urls(self):
+        urls = {
+            'W0JQcpGLSFw': [
+                'https://youtu.be/W0JQcpGLSFw',
+                'https://www.youtube.com/watch?v=W0JQcpGLSFw',
+                'https://www.youtube.com/watch?v=W0JQcpGLSFw&list=PL1-aSABtP6ACZuppkBqXFgzpNb2nVctZx',
+            ],
+            'vmhB-pt7EfA': [  # id starts with v, it is important
+                'https://youtu.be/vmhB-pt7EfA',
+                'https://www.youtube.com/watch?feature=youtu.be&v=vmhB-pt7EfA',
+                'https://www.youtube.com/watch?v=vmhB-pt7EfA&list=PL1-aSABtP6ACZuppkBqXFgzpNb2nVctZx&index=7',
+            ],
+            'hlhLv0GN1hA': [
+                'https://www.youtube.com/v/hlhLv0GN1hA',
+                'https://www.youtube.com/embed/hlhLv0GN1hA',
+                'https://www.youtube-nocookie.com/embed/hlhLv0GN1hA',
+                'https://m.youtube.com/watch?v=hlhLv0GN1hA',
+            ],
+        }
+
+        for id, urls in urls.items():
+            for url in urls:
+                with self.subTest(url=url, id=id):
+                    document = self.env['slide.slide']._find_document_data_from_url(url)
+                    self.assertEqual(document[0], 'youtube')
+                    self.assertEqual(document[1], id)
diff --git a/addons/website_slides/tests/test_statistics.py b/addons/website_slides/tests/test_statistics.py
new file mode 100644
index 00000000..79f0745a
--- /dev/null
+++ b/addons/website_slides/tests/test_statistics.py
@@ -0,0 +1,183 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+import math
+
+from dateutil.relativedelta import relativedelta
+
+from odoo import fields
+from odoo.addons.website_slides.tests import common
+from odoo.exceptions import UserError
+from odoo.tests import tagged
+from odoo.tests.common import users
+from odoo.tools import mute_logger, float_compare
+
+
+@tagged('functional')
+class TestChannelStatistics(common.SlidesCase):
+
+    @mute_logger('odoo.models')
+    def test_channel_new_content(self):
+        (self.slide | self.slide_2).write({'date_published': fields.Datetime.now() + relativedelta(days=-6)})
+        self.slide_3.write({'date_published': fields.Datetime.now() + relativedelta(days=-8)})
+        self.assertTrue(all(slide.is_new_slide for slide in (self.slide | self.slide_2)))
+        self.assertFalse(self.slide_3.is_new_slide)
+
+        channel_aspublisher = self.channel.with_user(self.user_officer)
+        self.assertTrue(channel_aspublisher.partner_has_new_content)
+        (self.slide | self.slide_2).with_user(self.user_officer).action_set_completed()
+        self.assertFalse(channel_aspublisher.partner_has_new_content)
+
+        channel_aspublisher._action_add_members(self.user_portal.partner_id)
+        channel_asportal = self.channel.with_user(self.user_portal)
+        self.assertTrue(channel_asportal.partner_has_new_content)
+
+        (self.slide | self.slide_2).write({'date_published': fields.Datetime.now() + relativedelta(days=-8)})
+        channel_asportal.invalidate_cache(['partner_has_new_content'])
+        self.assertFalse(channel_asportal.partner_has_new_content)
+
+    @mute_logger('odoo.models')
+    def test_channel_statistics(self):
+        channel_publisher = self.channel.with_user(self.user_officer)
+        # slide type computation
+        self.assertEqual(channel_publisher.total_slides, len(channel_publisher.slide_content_ids))
+        self.assertEqual(channel_publisher.nbr_infographic, len(channel_publisher.slide_content_ids.filtered(lambda s: s.slide_type == 'infographic')))
+        self.assertEqual(channel_publisher.nbr_presentation, len(channel_publisher.slide_content_ids.filtered(lambda s: s.slide_type == 'presentation')))
+        self.assertEqual(channel_publisher.nbr_document, len(channel_publisher.slide_content_ids.filtered(lambda s: s.slide_type == 'document')))
+        self.assertEqual(channel_publisher.nbr_video, len(channel_publisher.slide_content_ids.filtered(lambda s: s.slide_type == 'video')))
+        # slide statistics computation
+        self.assertEqual(float_compare(channel_publisher.total_time, sum(s.completion_time for s in channel_publisher.slide_content_ids), 3), 0)
+        # members computation
+        self.assertEqual(channel_publisher.members_count, 1)
+        channel_publisher.action_add_member()
+        self.assertEqual(channel_publisher.members_count, 1)
+        channel_publisher._action_add_members(self.user_emp.partner_id)
+        channel_publisher.invalidate_cache(['partner_ids'])
+        self.assertEqual(channel_publisher.members_count, 2)
+        self.assertEqual(channel_publisher.partner_ids, self.user_officer.partner_id | self.user_emp.partner_id)
+
+    @mute_logger('odoo.models')
+    def test_channel_user_statistics(self):
+        channel_publisher = self.channel.with_user(self.user_officer)
+        channel_publisher.write({
+            'enroll': 'invite',
+        })
+        channel_publisher._action_add_members(self.user_emp.partner_id)
+        channel_emp = self.channel.with_user(self.user_emp)
+
+        slides_emp = (self.slide | self.slide_2).with_user(self.user_emp)
+        slides_emp.action_set_viewed()
+        self.assertEqual(channel_emp.completion, 0)
+
+        slides_emp.action_set_completed()
+        channel_emp.invalidate_cache()
+        self.assertEqual(
+            channel_emp.completion,
+            math.ceil(100.0 * len(slides_emp) / len(channel_publisher.slide_content_ids)))
+        self.assertFalse(channel_emp.completed)
+
+        self.slide_3.with_user(self.user_emp).action_set_completed()
+        self.assertEqual(channel_emp.completion, 100)
+        self.assertTrue(channel_emp.completed)
+
+        self.slide_3.is_published = False
+        self.assertEqual(channel_emp.completion, 100)
+        self.assertTrue(channel_emp.completed)
+
+        self.slide_3.is_published = True
+        self.slide_3.active = False
+        self.assertEqual(channel_emp.completion, 100)
+        self.assertTrue(channel_emp.completed)
+
+    @mute_logger('odoo.models')
+    def test_channel_user_statistics_complete_check_member(self):
+        slides = (self.slide | self.slide_2)
+        slides.write({'is_preview': True})
+        slides.flush(['is_preview'])
+        slides_emp = slides.with_user(self.user_emp)
+        slides_emp.read(['name'])
+        with self.assertRaises(UserError):
+            slides_emp.action_set_completed()
+
+    @mute_logger('odoo.models')
+    def test_channel_user_statistics_view_check_member(self):
+        slides = (self.slide | self.slide_2)
+        slides.write({'is_preview': True})
+        slides.flush(['is_preview'])
+        slides_emp = slides.with_user(self.user_emp)
+        slides_emp.read(['name'])
+        with self.assertRaises(UserError):
+            slides_emp.action_set_viewed()
+
+
+@tagged('functional')
+class TestSlideStatistics(common.SlidesCase):
+
+    def test_slide_user_statistics(self):
+        channel_publisher = self.channel.with_user(self.user_officer)
+        channel_publisher._action_add_members(self.user_emp.partner_id)
+        channel_publisher.invalidate_cache(['partner_ids'])
+
+        slide_emp = self.slide.with_user(self.user_emp)
+        self.assertEqual(slide_emp.likes, 0)
+        self.assertEqual(slide_emp.dislikes, 0)
+        self.assertEqual(slide_emp.user_vote, 0)
+        slide_emp.action_like()
+        self.assertEqual(slide_emp.likes, 1)
+        self.assertEqual(slide_emp.dislikes, 0)
+        self.assertEqual(slide_emp.user_vote, 1)
+        slide_emp.action_dislike()
+        self.assertEqual(slide_emp.likes, 0)
+        self.assertEqual(slide_emp.dislikes, 0)
+        self.assertEqual(slide_emp.user_vote, 0)
+        slide_emp.action_dislike()
+        self.assertEqual(slide_emp.likes, 0)
+        self.assertEqual(slide_emp.dislikes, 1)
+        self.assertEqual(slide_emp.user_vote, -1)
+
+    def test_slide_statistics_views(self):
+        channel_publisher = self.channel.with_user(self.user_officer)
+        channel_publisher._action_add_members(self.user_emp.partner_id)
+
+        self.assertEqual(self.slide.slide_views, 0)
+        self.assertEqual(self.slide.public_views, 0)
+
+        self.slide.write({'public_views': 4})
+
+        self.assertEqual(self.slide.slide_views, 0)
+        self.assertEqual(self.slide.public_views, 4)
+        self.assertEqual(self.slide.total_views, 4)
+
+        slide_emp = self.slide.with_user(self.user_emp)
+        slide_emp.action_set_viewed()
+
+        self.assertEqual(slide_emp.slide_views, 1)
+        self.assertEqual(slide_emp.public_views, 4)
+        self.assertEqual(slide_emp.total_views, 5)
+
+    @users('user_officer')
+    def test_slide_statistics_types(self):
+        category = self.category.with_user(self.env.user)
+        self.assertEqual(
+            category.nbr_presentation,
+            len(category.channel_id.slide_ids.filtered(lambda s: s.category_id == category and s.slide_type == 'presentation')))
+        self.assertEqual(
+            category.nbr_document,
+            len(category.channel_id.slide_ids.filtered(lambda s: s.category_id == category and s.slide_type == 'document')))
+
+        self.assertEqual(self.channel.total_slides, 3, 'The channel should contain 3 slides')
+        self.assertEqual(category.total_slides, 2, 'The first category should contain 2 slides')
+        other_category = self.env['slide.slide'].with_user(self.user_officer).create({
+            'name': 'Other Category',
+            'channel_id': self.channel.id,
+            'is_category': True,
+            'is_published': True,
+            'sequence': 5,
+        })
+        self.assertEqual(other_category.total_slides, 0, 'The other category should not contain any slide yet')
+
+        # move one of the slide to the other category
+        self.slide_3.write({'sequence': 6})
+        self.assertEqual(category.total_slides, 1, 'The first category should contain 1 slide')
+        self.assertEqual(other_category.total_slides, 1, 'The other category should contain 1 slide')
+        self.assertEqual(self.channel.total_slides, 3, 'The channel should still contain 3 slides')
diff --git a/addons/website_slides/tests/test_ui_wslides.py b/addons/website_slides/tests/test_ui_wslides.py
new file mode 100644
index 00000000..7338295a
--- /dev/null
+++ b/addons/website_slides/tests/test_ui_wslides.py
@@ -0,0 +1,181 @@
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+import base64
+
+from dateutil.relativedelta import relativedelta
+from odoo import tests
+from odoo.fields import Datetime
+from odoo.modules.module import get_module_resource
+from odoo.addons.base.tests.common import HttpCaseWithUserDemo, HttpCaseWithUserPortal
+
+
+class TestUICommon(HttpCaseWithUserDemo, HttpCaseWithUserPortal):
+    
+    def setUp(self):
+        super(TestUICommon, self).setUp()
+        # Load pdf and img contents
+        pdf_path = get_module_resource('website_slides', 'static', 'src', 'img', 'presentation.pdf')
+        pdf_content = base64.b64encode(open(pdf_path, "rb").read())
+        img_path = get_module_resource('website_slides', 'static', 'src', 'img', 'slide_demo_gardening_1.jpg')
+        img_content = base64.b64encode(open(img_path, "rb").read())
+
+        self.env['slide.channel'].create({
+            'name': 'Basics of Gardening - Test',
+            'user_id': self.env.ref('base.user_admin').id,
+            'enroll': 'public',
+            'channel_type': 'training',
+            'allow_comment': True,
+            'promote_strategy': 'most_voted',
+            'is_published': True,
+            'description': 'Learn the basics of gardening !',
+            'create_date': Datetime.now() - relativedelta(days=8),
+            'slide_ids': [
+                (0, 0, {
+                    'name': 'Gardening: The Know-How',
+                    'sequence': 1,
+                    'datas': pdf_content,
+                    'slide_type': 'presentation',
+                    'is_published': True,
+                    'is_preview': True,
+                }), (0, 0, {
+                    'name': 'Home Gardening',
+                    'sequence': 2,
+                    'image_1920': img_content,
+                    'slide_type': 'infographic',
+                    'is_published': True,
+                }), (0, 0, {
+                    'name': 'Mighty Carrots',
+                    'sequence': 3,
+                    'image_1920': img_content,
+                    'slide_type': 'infographic',
+                    'is_published': True,
+                }), (0, 0, {
+                    'name': 'How to Grow and Harvest The Best Strawberries | Basics',
+                    'sequence': 4,
+                    'datas': pdf_content,
+                    'slide_type': 'document',
+                    'is_published': True,
+                }), (0, 0, {
+                    'name': 'Test your knowledge',
+                    'sequence': 5,
+                    'slide_type': 'quiz',
+                    'is_published': True,
+                    'question_ids': [
+                        (0, 0, {
+                            'question': 'What is a strawberry ?',
+                            'answer_ids': [
+                                (0, 0, {
+                                    'text_value': 'A fruit',
+                                    'is_correct': True,
+                                    'sequence': 1,
+                                }), (0, 0, {
+                                    'text_value': 'A vegetable',
+                                    'sequence': 2,
+                                }), (0, 0, {
+                                    'text_value': 'A table',
+                                    'sequence': 3,
+                                })
+                            ]
+                        }), (0, 0, {
+                            'question': 'What is the best tool to dig a hole for your plants ?',
+                            'answer_ids': [
+                                (0, 0, {
+                                    'text_value': 'A shovel',
+                                    'is_correct': True,
+                                    'sequence': 1,
+                                }), (0, 0, {
+                                    'text_value': 'A spoon',
+                                    'sequence': 2,
+                                })
+                            ]
+                        })
+                    ]
+                })
+            ]
+        })
+
+
+@tests.common.tagged('post_install', '-at_install')
+class TestUi(TestUICommon):
+
+    def test_course_member_employee(self):
+        user_demo = self.user_demo
+        user_demo.flush()
+        user_demo.write({
+            'groups_id': [(5, 0), (4, self.env.ref('base.group_user').id)]
+        })
+
+        self.browser_js(
+            '/slides',
+            'odoo.__DEBUG__.services["web_tour.tour"].run("course_member")',
+            'odoo.__DEBUG__.services["web_tour.tour"].tours.course_member.ready',
+            login=user_demo.login)
+
+    def test_course_member_elearning_officer(self):
+        user_demo = self.user_demo
+        user_demo.flush()
+        user_demo.write({
+            'groups_id': [(5, 0), (4, self.env.ref('base.group_user').id), (4, self.env.ref('website_slides.group_website_slides_officer').id)]
+        })
+
+        self.browser_js(
+            '/slides',
+            'odoo.__DEBUG__.services["web_tour.tour"].run("course_member")',
+            'odoo.__DEBUG__.services["web_tour.tour"].tours.course_member.ready',
+            login=user_demo.login)
+
+    def test_course_member_portal(self):
+        user_portal = self.user_portal
+        user_portal.flush()
+
+        self.browser_js(
+            '/slides',
+            'odoo.__DEBUG__.services["web_tour.tour"].run("course_member")',
+            'odoo.__DEBUG__.services["web_tour.tour"].tours.course_member.ready',
+            login=user_portal.login)
+
+    def test_full_screen_edition_website_publisher(self):
+        # group_website_designer
+        user_demo = self.env.ref('base.user_demo')
+        user_demo.flush()
+        user_demo.write({
+            'groups_id': [(5, 0), (4, self.env.ref('base.group_user').id), (4, self.env.ref('website.group_website_publisher').id)]
+        })
+
+        self.browser_js(
+            '/slides',
+            'odoo.__DEBUG__.services["web_tour.tour"].run("full_screen_web_editor")',
+            'odoo.__DEBUG__.services["web_tour.tour"].tours.full_screen_web_editor.ready',
+            login=user_demo.login)
+
+
+@tests.common.tagged('external', 'post_install', '-standard', '-at_install')
+class TestUiYoutube(HttpCaseWithUserDemo):
+
+    def test_course_member_yt_employee(self):
+        # remove membership because we need to be able to join the course during the tour
+        user_demo = self.user_demo
+        user_demo.flush()
+        user_demo.write({
+            'groups_id': [(5, 0), (4, self.env.ref('base.group_user').id)]
+        })
+        self.env.ref('website_slides.slide_channel_demo_3_furn0')._remove_membership(self.env.ref('base.partner_demo').ids)
+
+        self.browser_js(
+            '/slides',
+            'odoo.__DEBUG__.services["web_tour.tour"].run("course_member_youtube")',
+            'odoo.__DEBUG__.services["web_tour.tour"].tours.course_member_youtube.ready',
+            login=user_demo.login)
+
+    def test_course_publisher_elearning_manager(self):
+        user_demo = self.user_demo
+        user_demo.flush()
+        user_demo.write({
+            'groups_id': [(5, 0), (4, self.env.ref('base.group_user').id), (4, self.env.ref('website_slides.group_website_slides_manager').id)]
+        })
+
+        self.browser_js(
+            '/slides',
+            'odoo.__DEBUG__.services["web_tour.tour"].run("course_publisher")',
+            'odoo.__DEBUG__.services["web_tour.tour"].tours.course_publisher.ready',
+            login=user_demo.login)