mirror of
https://github.com/bringout/oca-mrp.git
synced 2026-04-20 23:32:00 +02:00
Initial commit: OCA Mrp packages (117 packages)
This commit is contained in:
Ernad Husremovic
commit
277e84fd7a
4403 changed files with 395154 additions and 0 deletions
|
|
@ -0,0 +1,4 @@
|
|||
from . import test_event_session
|
||||
from . import test_event_session_ics
|
||||
from . import test_event_session_mail
|
||||
from . import test_event_session_wizard
|
||||
|
|
@ -0,0 +1,28 @@
|
|||
# Copyright 2022 Moka Tourisme (https://www.mokatourisme.fr).
|
||||
# @author Iván Todorovich <ivan.todorovich@gmail.com>
|
||||
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
|
||||
|
||||
from odoo import fields
|
||||
from odoo.tests import TransactionCase
|
||||
|
||||
|
||||
class CommonEventSessionCase(TransactionCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
super().setUpClass()
|
||||
cls.env = cls.env(context=dict(cls.env.context, tracking_disable=True))
|
||||
cls.stage_new = cls.env.ref("event.event_stage_new")
|
||||
cls.stage_done = cls.env.ref("event.event_stage_done")
|
||||
|
||||
def assertSessionDates(self, sessions, expected):
|
||||
for session, date in zip(sessions, expected):
|
||||
local_date = fields.Datetime.context_timestamp(
|
||||
session._set_tz_context(), session.date_begin
|
||||
)
|
||||
local_date_str = fields.Datetime.to_string(local_date)
|
||||
self.assertEqual(local_date_str, date)
|
||||
|
||||
def _wizard_generate_sessions(self, vals):
|
||||
wizard = self.env["wizard.event.session"].create(vals)
|
||||
sessions_domain = wizard.action_create_sessions()["domain"]
|
||||
return self.env["event.session"].search(sessions_domain)
|
||||
|
|
@ -0,0 +1,415 @@
|
|||
# Copyright 2017-19 Tecnativa - David Vidal
|
||||
# Copyright 2017 Tecnativa - Pedro M. Baeza
|
||||
# Copyright 2021 Moka Tourisme (https://www.mokatourisme.fr).
|
||||
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl-3.0).
|
||||
|
||||
from datetime import timedelta
|
||||
|
||||
from freezegun import freeze_time
|
||||
|
||||
from odoo import fields
|
||||
from odoo.exceptions import ValidationError
|
||||
from odoo.tests.common import Form
|
||||
from odoo.tools import mute_logger
|
||||
|
||||
from .common import CommonEventSessionCase
|
||||
|
||||
|
||||
class TestEventSession(CommonEventSessionCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
super().setUpClass()
|
||||
cls.event = cls.env["event.event"].create(
|
||||
{
|
||||
"name": "Test event",
|
||||
"use_sessions": True,
|
||||
"seats_limited": True,
|
||||
"seats_max": 5,
|
||||
}
|
||||
)
|
||||
cls.session = cls.env["event.session"].create(
|
||||
{
|
||||
"date_begin": "2017-05-26 20:00:00",
|
||||
"date_end": "2017-05-26 21:00:00",
|
||||
"event_id": cls.event.id,
|
||||
}
|
||||
)
|
||||
|
||||
def test_session_name_get(self):
|
||||
# Case 1: Same tz than user
|
||||
name = self.session.name_get()[0][1]
|
||||
self.assertEqual(name, "Test event, May 26, 2017, 10:00:00 PM")
|
||||
# Case 2: Different timezone
|
||||
self.event.date_tz = "UTC"
|
||||
name = self.session.name_get()[0][1]
|
||||
self.assertEqual(name, "Test event, May 26, 2017, 8:00:00 PM (UTC)")
|
||||
|
||||
def test_check_dates(self):
|
||||
with self.assertRaisesRegex(
|
||||
ValidationError,
|
||||
"The closing date cannot be earlier than the beginning date",
|
||||
):
|
||||
self.session.date_end = "2017-05-26 19:00:00"
|
||||
|
||||
def test_open_registrations(self):
|
||||
domain = self.session.action_open_registrations()["domain"]
|
||||
attendees = self.env["event.registration"].search(domain)
|
||||
self.assertEqual(attendees, self.session.registration_ids)
|
||||
|
||||
def test_event_registration_event_begin_end_dates(self):
|
||||
"""Test that the date_begin and date_end are set to the session's"""
|
||||
# Case 1: Even with sessions
|
||||
registration = self.env["event.registration"].create(
|
||||
{
|
||||
"name": "Test attendee",
|
||||
"event_id": self.event.id,
|
||||
"session_id": self.session.id,
|
||||
}
|
||||
)
|
||||
self.assertEqual(registration.event_begin_date, self.session.date_begin)
|
||||
self.assertEqual(registration.event_end_date, self.session.date_end)
|
||||
# Case 2: Regular events
|
||||
event = self.env.ref("event.event_0")
|
||||
registration = self.env["event.registration"].create(
|
||||
{
|
||||
"name": "Test attendee",
|
||||
"event_id": event.id,
|
||||
}
|
||||
)
|
||||
self.assertEqual(registration.event_begin_date, event.date_begin)
|
||||
self.assertEqual(registration.event_end_date, event.date_end)
|
||||
|
||||
def test_event_session_dates_located(self):
|
||||
self.session.date_tz = "Europe/Paris"
|
||||
self.assertEqual(self.session.date_begin_located, "May 26, 2017, 10:00:00 PM")
|
||||
self.assertEqual(self.session.date_end_located, "May 26, 2017, 11:00:00 PM")
|
||||
self.session.date_tz = "US/Pacific"
|
||||
self.assertEqual(self.session.date_begin_located, "May 26, 2017, 1:00:00 PM")
|
||||
self.assertEqual(self.session.date_end_located, "May 26, 2017, 2:00:00 PM")
|
||||
|
||||
def test_event_event_sync_from_event_type(self):
|
||||
"""Test that the event.type fields are synced to the event.event"""
|
||||
event_type = self.env["event.type"].create(
|
||||
{
|
||||
"name": "Test event type",
|
||||
"use_sessions": True,
|
||||
}
|
||||
)
|
||||
event = self.env["event.event"].create(
|
||||
{
|
||||
"name": "Test event",
|
||||
"event_type_id": event_type.id,
|
||||
"date_begin": self.event.date_begin,
|
||||
"date_end": self.event.date_end,
|
||||
}
|
||||
)
|
||||
self.assertEqual(event.use_sessions, True)
|
||||
|
||||
def test_event_session_form(self):
|
||||
# Test workaround for this Odoo bug: https://github.com/odoo/odoo/pull/91373
|
||||
session_form = Form(
|
||||
self.env["event.session"].with_context(
|
||||
default_event_id=self.event.id,
|
||||
)
|
||||
)
|
||||
self.assertEqual(session_form.event_id, self.event)
|
||||
self.assertEqual(session_form.name, self.event.name)
|
||||
|
||||
def test_event_event_use_sessions_switch(self):
|
||||
# Case 1: We can't change an event to use_sessions after registrations
|
||||
event = self.env["event.event"].create(
|
||||
{
|
||||
"name": "Test event",
|
||||
"date_begin": self.event.date_begin,
|
||||
"date_end": self.event.date_end,
|
||||
}
|
||||
)
|
||||
self.env["event.registration"].create(
|
||||
{
|
||||
"event_id": event.id,
|
||||
"name": "Test attendee",
|
||||
}
|
||||
)
|
||||
msg = "You can't enable/disable sessions on events with registrations."
|
||||
with self.assertRaisesRegex(ValidationError, msg):
|
||||
event.use_sessions = True
|
||||
# Case 2: We can change it back, if we have no registrations
|
||||
# In fact event.sessions are removed when doing so
|
||||
self.event.use_sessions = False
|
||||
self.assertFalse(self.session.exists())
|
||||
|
||||
@mute_logger("odoo.models.unlink")
|
||||
def test_event_event_sessions_count(self):
|
||||
"""Test that the sessions count is computed correctly"""
|
||||
self.assertEqual(self.event.session_count, 1)
|
||||
self.session.unlink()
|
||||
self.assertEqual(self.event.session_count, 0)
|
||||
|
||||
def test_event_message_subscribe_organizer(self):
|
||||
"""Test that the organizer is subscribed to the sessions"""
|
||||
organizer = self.env["res.partner"].create({"name": "Test organizer"})
|
||||
# Case 1: Updating the event's organizer
|
||||
self.event.organizer_id = organizer
|
||||
self.assertIn(organizer, self.session.message_partner_ids)
|
||||
# Case 2: Creating new sessions
|
||||
session = self.env["event.session"].create(
|
||||
{
|
||||
"date_begin": "2017-05-27 20:00:00",
|
||||
"date_end": "2017-05-27 21:00:00",
|
||||
"event_id": self.event.id,
|
||||
}
|
||||
)
|
||||
self.assertIn(organizer, session.message_partner_ids)
|
||||
|
||||
def test_session_seats(self):
|
||||
"""Test event session seats constraints"""
|
||||
self.assertEqual(self.event.seats_unconfirmed, self.session.seats_unconfirmed)
|
||||
self.assertEqual(self.event.seats_used, self.session.seats_used)
|
||||
vals = {
|
||||
"name": "Test Attendee",
|
||||
"event_id": self.event.id,
|
||||
"session_id": self.session.id,
|
||||
"state": "open",
|
||||
}
|
||||
# Fill the event session with attendees
|
||||
self.env["event.registration"].create([vals] * self.session.seats_available)
|
||||
# Try to create another one
|
||||
with self.assertRaisesRegex(
|
||||
ValidationError, r"There are not enough seats available for:"
|
||||
), self.cr.savepoint():
|
||||
self.env["event.registration"].create(vals)
|
||||
# Attempt to create a draft registration on a full session
|
||||
with self.assertRaisesRegex(
|
||||
ValidationError, "No more seats available for this session."
|
||||
), self.cr.savepoint():
|
||||
self.env["event.registration"].create(dict(vals, state="draft"))
|
||||
# Temporarily allow to create a draft registration and attempt to confirm it
|
||||
self.event.seats_limited = False
|
||||
registration = self.env["event.registration"].create(dict(vals, state="draft"))
|
||||
self.event.seats_limited = True
|
||||
with self.assertRaisesRegex(
|
||||
ValidationError, r"There are not enough seats available for:"
|
||||
), self.cr.savepoint():
|
||||
registration.action_confirm()
|
||||
registration.flush_recordset()
|
||||
|
||||
def test_event_seats(self):
|
||||
"""Test that event.event seats constraints do not apply to sessions"""
|
||||
# Case: Event has a limit of 5 seats, but it should apply per-session
|
||||
self.event.seats_max = 5
|
||||
self.event.seats_limited = True
|
||||
# Fill session with attendees
|
||||
vals = {
|
||||
"name": "Test Attendee",
|
||||
"event_id": self.event.id,
|
||||
"session_id": self.session.id,
|
||||
"state": "open",
|
||||
}
|
||||
self.assertFalse(self.session.event_registrations_sold_out)
|
||||
self.env["event.registration"].create([vals] * 5)
|
||||
self.assertTrue(self.session.event_registrations_sold_out)
|
||||
# Create a second session and fill it too
|
||||
session2 = self.session.copy({})
|
||||
vals["session_id"] = session2.id
|
||||
self.env["event.registration"].create([vals] * 5)
|
||||
# Now attempt to move one registration to another session
|
||||
with self.assertRaisesRegex(
|
||||
ValidationError, r"There are not enough seats available for:"
|
||||
), self.cr.savepoint():
|
||||
self.session.registration_ids[0].session_id = session2
|
||||
# Attempt to decrease the event seats limit below the existing registrations
|
||||
with self.assertRaisesRegex(
|
||||
ValidationError, r"There are not enough seats available for:"
|
||||
), self.cr.savepoint():
|
||||
self.event.seats_max = 2
|
||||
self.event.flush_recordset()
|
||||
|
||||
def test_session_seats_count(self):
|
||||
session_1, session_2 = self.env["event.session"].create(
|
||||
[
|
||||
{
|
||||
"event_id": self.event.id,
|
||||
"date_begin": fields.Datetime.now(),
|
||||
"date_end": fields.Datetime.now() + timedelta(hours=1),
|
||||
},
|
||||
{
|
||||
"event_id": self.event.id,
|
||||
"date_begin": fields.Datetime.now() + timedelta(days=1),
|
||||
"date_end": fields.Datetime.now() + timedelta(days=1, hours=1),
|
||||
},
|
||||
]
|
||||
)
|
||||
attendee_1, attendee_2, attendee_3 = self.env["event.registration"].create(
|
||||
[
|
||||
{
|
||||
"name": "S1: First Atendee",
|
||||
"event_id": self.event.id,
|
||||
"session_id": session_1.id,
|
||||
},
|
||||
{
|
||||
"name": "S1: Second Atendee",
|
||||
"event_id": self.event.id,
|
||||
"session_id": session_1.id,
|
||||
},
|
||||
{
|
||||
"name": "S2: First Atendee",
|
||||
"event_id": self.event.id,
|
||||
"session_id": session_2.id,
|
||||
},
|
||||
]
|
||||
)
|
||||
self.assertEqual(session_1.seats_unconfirmed, 2)
|
||||
self.assertEqual(session_1.seats_reserved, 0)
|
||||
self.assertEqual(session_1.seats_expected, 2)
|
||||
self.assertEqual(session_1.seats_available_unexpected, 3)
|
||||
self.assertEqual(session_2.seats_unconfirmed, 1)
|
||||
self.assertEqual(session_2.seats_reserved, 0)
|
||||
self.assertEqual(session_2.seats_expected, 1)
|
||||
self.assertEqual(session_2.seats_available_unexpected, 4)
|
||||
self.assertEqual(self.event.seats_unconfirmed, 3)
|
||||
self.assertEqual(self.event.seats_reserved, 0)
|
||||
self.assertEqual(self.event.seats_expected, 3)
|
||||
attendee_1.action_confirm()
|
||||
self.assertEqual(session_1.seats_unconfirmed, 1)
|
||||
self.assertEqual(session_1.seats_reserved, 1)
|
||||
self.assertEqual(session_2.seats_unconfirmed, 1)
|
||||
self.assertEqual(session_2.seats_reserved, 0)
|
||||
self.assertEqual(self.event.seats_unconfirmed, 2)
|
||||
self.assertEqual(self.event.seats_reserved, 1)
|
||||
attendee_2.action_confirm()
|
||||
self.assertEqual(session_1.seats_unconfirmed, 0)
|
||||
self.assertEqual(session_1.seats_reserved, 2)
|
||||
self.assertEqual(session_2.seats_unconfirmed, 1)
|
||||
self.assertEqual(session_2.seats_reserved, 0)
|
||||
self.assertEqual(self.event.seats_unconfirmed, 1)
|
||||
self.assertEqual(self.event.seats_reserved, 2)
|
||||
attendee_3.action_confirm()
|
||||
self.assertEqual(session_1.seats_unconfirmed, 0)
|
||||
self.assertEqual(session_1.seats_reserved, 2)
|
||||
self.assertEqual(session_2.seats_unconfirmed, 0)
|
||||
self.assertEqual(session_2.seats_reserved, 1)
|
||||
self.assertEqual(self.event.seats_unconfirmed, 0)
|
||||
self.assertEqual(self.event.seats_reserved, 3)
|
||||
|
||||
def test_event_session_is_ongoing(self):
|
||||
# Case 1: Session is ongoing
|
||||
session = self.env["event.session"].create(
|
||||
{
|
||||
"event_id": self.event.id,
|
||||
"date_begin": fields.Datetime.now() - timedelta(hours=1),
|
||||
"date_end": fields.Datetime.now() + timedelta(hours=1),
|
||||
}
|
||||
)
|
||||
ongoing = self.env["event.session"].search([("is_ongoing", "=", True)])
|
||||
not_ongoing = self.env["event.session"].search([("is_ongoing", "=", False)])
|
||||
self.assertTrue(session.is_ongoing)
|
||||
self.assertIn(session, ongoing)
|
||||
self.assertNotIn(session, not_ongoing)
|
||||
# Case 2: It isn't
|
||||
session.write(
|
||||
{
|
||||
"date_begin": fields.Datetime.now() + timedelta(days=1),
|
||||
"date_end": fields.Datetime.now() + timedelta(days=1, hours=1),
|
||||
}
|
||||
)
|
||||
ongoing = self.env["event.session"].search([("is_ongoing", "=", True)])
|
||||
not_ongoing = self.env["event.session"].search([("is_ongoing", "=", False)])
|
||||
self.assertFalse(session.is_ongoing)
|
||||
self.assertIn(session, not_ongoing)
|
||||
self.assertNotIn(session, ongoing)
|
||||
|
||||
def test_event_session_is_finished(self):
|
||||
# Case 1: Session is finished
|
||||
session = self.env["event.session"].create(
|
||||
{
|
||||
"event_id": self.event.id,
|
||||
"date_begin": fields.Datetime.now() - timedelta(hours=2),
|
||||
"date_end": fields.Datetime.now() - timedelta(hours=1),
|
||||
}
|
||||
)
|
||||
finished = self.env["event.session"].search([("is_finished", "=", True)])
|
||||
not_finished = self.env["event.session"].search([("is_finished", "=", False)])
|
||||
self.assertTrue(session.is_finished)
|
||||
self.assertIn(session, finished)
|
||||
self.assertNotIn(session, not_finished)
|
||||
# Case 2: It isn't
|
||||
session.write(
|
||||
{
|
||||
"date_begin": fields.Datetime.now() + timedelta(days=1),
|
||||
"date_end": fields.Datetime.now() + timedelta(days=1, hours=1),
|
||||
}
|
||||
)
|
||||
finished = self.env["event.session"].search([("is_finished", "=", True)])
|
||||
not_finished = self.env["event.session"].search([("is_finished", "=", False)])
|
||||
self.assertFalse(session.is_finished)
|
||||
self.assertIn(session, not_finished)
|
||||
self.assertNotIn(session, finished)
|
||||
|
||||
def test_event_session_registrations_open(self):
|
||||
with freeze_time("2017-05-26 20:30:00"):
|
||||
self.session.invalidate_recordset(["event_registrations_open"])
|
||||
self.assertTrue(self.session.event_registrations_open)
|
||||
with freeze_time("2017-05-30 20:00:00"):
|
||||
self.session.invalidate_recordset(["event_registrations_open"])
|
||||
self.assertFalse(self.session.event_registrations_open)
|
||||
|
||||
def test_event_session_action_set_done(self):
|
||||
self.assertEqual(self.session.stage_id, self.stage_new)
|
||||
self.session.action_set_done()
|
||||
self.assertEqual(self.session.stage_id, self.stage_done)
|
||||
|
||||
def test_event_session_gc(self):
|
||||
self.assertEqual(self.session.stage_id, self.stage_new)
|
||||
with freeze_time("2017-05-26 20:30:00"):
|
||||
self.env["event.session"]._gc_mark_events_done()
|
||||
self.assertEqual(self.session.stage_id, self.stage_new, "Not done yet")
|
||||
with freeze_time("2017-05-27 20:00:00"):
|
||||
self.env["event.session"]._gc_mark_events_done()
|
||||
self.assertEqual(self.session.stage_id, self.stage_done, "Done")
|
||||
|
||||
def test_event_session_update_multi(self):
|
||||
"""Test the session series update"""
|
||||
sessions = self.env["event.session"].create(
|
||||
[
|
||||
{
|
||||
"event_id": self.event.id,
|
||||
"date_begin": "2017-05-20 20:00:00",
|
||||
"date_end": "2017-05-20 21:00:00",
|
||||
},
|
||||
{
|
||||
"event_id": self.event.id,
|
||||
"date_begin": "2017-05-21 20:00:00",
|
||||
"date_end": "2017-05-21 21:00:00",
|
||||
},
|
||||
{
|
||||
"event_id": self.event.id,
|
||||
"date_begin": "2017-05-22 20:00:00",
|
||||
"date_end": "2017-05-22 21:00:00",
|
||||
},
|
||||
{
|
||||
"event_id": self.event.id,
|
||||
"date_begin": "2017-05-23 20:00:00",
|
||||
"date_end": "2017-05-23 21:00:00",
|
||||
},
|
||||
]
|
||||
)
|
||||
sessions = sessions.with_context(active_test=False)
|
||||
session1, session2, session3, session4 = sessions
|
||||
# Case 1: Archive session 1
|
||||
session1.write({"active": False, "session_update": "this"})
|
||||
self.assertFalse(session1.active)
|
||||
self.assertTrue(session2.active)
|
||||
self.assertTrue(session3.active)
|
||||
self.assertTrue(session4.active)
|
||||
# Case 2: Archive all
|
||||
session2.write({"active": False, "session_update": "all"})
|
||||
self.assertFalse(session1.active)
|
||||
self.assertFalse(session2.active)
|
||||
self.assertFalse(session3.active)
|
||||
self.assertFalse(session4.active)
|
||||
# Case 3: Unarchive starting from session 3
|
||||
session3.write({"active": True, "session_update": "subsequent"})
|
||||
self.assertFalse(session1.active)
|
||||
self.assertFalse(session2.active)
|
||||
self.assertTrue(session3.active)
|
||||
self.assertTrue(session4.active)
|
||||
|
|
@ -0,0 +1,22 @@
|
|||
# Copyright 2022 Moka Tourisme (https://www.mokatourisme.fr).
|
||||
# @author Iván Todorovich <ivan.todorovich@gmail.com>
|
||||
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
|
||||
|
||||
from odoo.tests import HttpCase, tagged
|
||||
|
||||
|
||||
@tagged("-at_install", "post_install")
|
||||
class TestEventSessionICS(HttpCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
super().setUpClass()
|
||||
cls.env = cls.env(context=dict(cls.env.context, tracking_disable=True))
|
||||
cls.event_session = cls.env.ref("event_session.event_session_007_1_16_00")
|
||||
cls.event = cls.event_session.event_id
|
||||
|
||||
def test_event_session_ics_file(self):
|
||||
self.authenticate("admin", "admin")
|
||||
res = self.url_open(f"/event/session/{self.event_session.id}/ics")
|
||||
self.assertEqual(res.status_code, 200)
|
||||
self.assertEqual(res.headers["Content-Type"], "application/octet-stream")
|
||||
self.assertTrue(res.content.startswith(b"BEGIN:VCALENDAR"))
|
||||
|
|
@ -0,0 +1,147 @@
|
|||
# Copyright 2017-19 Tecnativa - David Vidal
|
||||
# Copyright 2017 Tecnativa - Pedro M. Baeza
|
||||
# Copyright 2021 Moka Tourisme (https://www.mokatourisme.fr).
|
||||
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl-3.0).
|
||||
|
||||
from datetime import timedelta
|
||||
|
||||
from freezegun import freeze_time
|
||||
|
||||
from odoo.tools import mute_logger
|
||||
|
||||
from .common import CommonEventSessionCase
|
||||
|
||||
|
||||
class TestEventSession(CommonEventSessionCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
super().setUpClass()
|
||||
cls.mail_template_reminder = cls.env.ref("event_session.event_session_reminder")
|
||||
cls.mail_template_badge = cls.env.ref(
|
||||
"event_session.event_session_registration_mail_template_badge"
|
||||
)
|
||||
cls.event = cls.env["event.event"].create(
|
||||
{
|
||||
"name": "Test event",
|
||||
"use_sessions": True,
|
||||
"event_mail_ids": [
|
||||
(0, 0, vals)
|
||||
for vals in [
|
||||
{
|
||||
"interval_nbr": 15,
|
||||
"interval_unit": "days",
|
||||
"interval_type": "before_event",
|
||||
"template_ref": f"mail.template,{cls.mail_template_reminder.id}",
|
||||
},
|
||||
{
|
||||
"interval_nbr": 0,
|
||||
"interval_unit": "hours",
|
||||
"interval_type": "after_sub",
|
||||
"template_ref": f"mail.template,{cls.mail_template_badge.id}",
|
||||
},
|
||||
]
|
||||
],
|
||||
}
|
||||
)
|
||||
cls.session = cls.env["event.session"].create(
|
||||
{
|
||||
"date_begin": "2017-05-26 20:00:00",
|
||||
"date_end": "2017-05-26 21:00:00",
|
||||
"event_id": cls.event.id,
|
||||
}
|
||||
)
|
||||
cls.registration = cls.env["event.registration"].create(
|
||||
{
|
||||
"name": "Test Attendee",
|
||||
"event_id": cls.event.id,
|
||||
"session_id": cls.session.id,
|
||||
}
|
||||
)
|
||||
cls.registration.action_confirm()
|
||||
|
||||
@mute_logger("odoo.models.unlink")
|
||||
def test_event_mail_sync_from_event(self):
|
||||
self.assertEqual(len(self.session.event_mail_ids), 2)
|
||||
# Case 1: Remove from event, removes from sessions
|
||||
self.event.event_mail_ids[0].unlink()
|
||||
self.assertEqual(len(self.session.event_mail_ids), 1)
|
||||
# Case 2: Add a new template
|
||||
event_mail = self.env["event.mail"].create(
|
||||
{
|
||||
"event_id": self.event.id,
|
||||
"interval_nbr": 5,
|
||||
"interval_unit": "days",
|
||||
"interval_type": "before_event",
|
||||
"template_ref": f"mail.template,{self.mail_template_reminder.id}",
|
||||
}
|
||||
)
|
||||
session_mail = self.session.event_mail_ids.filtered(
|
||||
lambda r: r.scheduler_id == event_mail
|
||||
)
|
||||
self.assertTrue(session_mail)
|
||||
self.assertEqual(event_mail.interval_nbr, session_mail.interval_nbr)
|
||||
self.assertEqual(event_mail.interval_unit, session_mail.interval_unit)
|
||||
self.assertEqual(event_mail.interval_type, session_mail.interval_type)
|
||||
self.assertEqual(event_mail.template_ref, session_mail.template_ref)
|
||||
|
||||
def test_event_mail_compute_scheduled_date(self):
|
||||
event_mail = self.event.event_mail_ids.filtered(
|
||||
lambda m: m.interval_type == "before_event"
|
||||
)
|
||||
session_mail = self.session.event_mail_ids.filtered(
|
||||
lambda m: m.scheduler_id == event_mail
|
||||
)
|
||||
# Case 1: 15 days before event
|
||||
event_mail.interval_nbr = 10
|
||||
expected = self.session.date_begin - timedelta(days=10)
|
||||
self.assertEqual(session_mail.scheduled_date, expected)
|
||||
self.assertFalse(event_mail.scheduled_date)
|
||||
# Case 2: 2 days after event
|
||||
event_mail.interval_nbr = 2
|
||||
event_mail.interval_type = "after_event"
|
||||
expected = self.session.date_end + timedelta(days=2)
|
||||
self.assertEqual(session_mail.scheduled_date, expected)
|
||||
self.assertFalse(event_mail.scheduled_date)
|
||||
# Case 3: after sub
|
||||
event_mail.interval_nbr = 0
|
||||
event_mail.interval_type = "after_sub"
|
||||
self.assertEqual(session_mail.scheduled_date, self.session.create_date)
|
||||
self.assertFalse(event_mail.scheduled_date)
|
||||
|
||||
def test_event_mail_registration_compute_scheduled_date(self):
|
||||
session_mail = self.session.event_mail_ids.filtered(
|
||||
lambda m: m.interval_type == "after_sub"
|
||||
)
|
||||
self.env["event.registration"].create(
|
||||
{
|
||||
"name": "Test Attendee",
|
||||
"event_id": self.event.id,
|
||||
"session_id": self.session.id,
|
||||
"state": "open",
|
||||
}
|
||||
)
|
||||
mail_registration = session_mail._create_missing_mail_registrations(
|
||||
session_mail._get_new_event_registrations()
|
||||
)
|
||||
expected = mail_registration.registration_id.create_date
|
||||
self.assertEqual(mail_registration.scheduled_date, expected)
|
||||
|
||||
@freeze_time("2017-05-16")
|
||||
def test_event_mail_session_scheduler(self):
|
||||
before_mail = self.session.event_mail_ids.filtered(
|
||||
lambda m: m.interval_type == "before_event"
|
||||
)
|
||||
self.assertFalse(before_mail.mail_done)
|
||||
self.env["event.mail"].schedule_communications()
|
||||
self.assertTrue(before_mail.mail_done)
|
||||
|
||||
@freeze_time("2017-06-01")
|
||||
def test_event_mail_session_scheduler_before_event_ignore_old(self):
|
||||
"""Test that we do not send emails if the mailing was scheduled before the event
|
||||
but the event is over"""
|
||||
before_mail = self.session.event_mail_ids.filtered(
|
||||
lambda m: m.interval_type == "before_event"
|
||||
)
|
||||
self.assertFalse(before_mail.mail_done)
|
||||
self.env["event.mail"].schedule_communications()
|
||||
self.assertFalse(before_mail.mail_done)
|
||||
|
|
@ -0,0 +1,235 @@
|
|||
# Copyright 2017-19 Tecnativa - David Vidal
|
||||
# Copyright 2017 Tecnativa - Pedro M. Baeza
|
||||
# Copyright 2021 Moka Tourisme (https://www.mokatourisme.fr).
|
||||
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl-3.0).
|
||||
|
||||
from odoo import fields
|
||||
from odoo.exceptions import ValidationError
|
||||
|
||||
from .common import CommonEventSessionCase
|
||||
|
||||
|
||||
class TestEventSessionCreateWizard(CommonEventSessionCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
super().setUpClass()
|
||||
cls.event = cls.env["event.event"].create(
|
||||
{"name": "Test Event", "use_sessions": True}
|
||||
)
|
||||
cls.timeslot_16_00 = cls.env.ref("event_session.timeslot_16_00")
|
||||
cls.timeslot_20_00 = cls.env.ref("event_session.timeslot_20_00")
|
||||
|
||||
def test_timeslot_name_create(self):
|
||||
Timeslot = self.env["event.session.timeslot"]
|
||||
# Case 1: Simple case
|
||||
timeslot_id, __ = Timeslot.name_create("23:00")
|
||||
timeslot = Timeslot.browse(timeslot_id)
|
||||
self.assertEqual(timeslot.time, 23.00)
|
||||
# Case 2: float case
|
||||
timeslot_id, __ = Timeslot.name_create("23:30")
|
||||
timeslot = Timeslot.browse(timeslot_id)
|
||||
self.assertEqual(timeslot.time, 23.50)
|
||||
# Case 3: invalid
|
||||
msg = "The timeslot has to be defined in HH:MM format"
|
||||
with self.assertRaisesRegex(ValidationError, msg):
|
||||
Timeslot.name_create("25:30")
|
||||
# Case 4: invalid
|
||||
msg = "The timeslot has to be defined in HH:MM format"
|
||||
with self.assertRaisesRegex(ValidationError, msg):
|
||||
Timeslot.name_create("22:70")
|
||||
|
||||
def test_wizard_default_values(self):
|
||||
self.env["event.session"].create(
|
||||
[
|
||||
{
|
||||
"date_begin": "2017-05-26 20:00:00",
|
||||
"date_end": "2017-05-26 21:00:00",
|
||||
"event_id": self.event.id,
|
||||
},
|
||||
{
|
||||
"date_begin": "2017-05-27 20:00:00",
|
||||
"date_end": "2017-05-27 22:00:00",
|
||||
"event_id": self.event.id,
|
||||
},
|
||||
]
|
||||
)
|
||||
wizard = self.env["wizard.event.session"].new(
|
||||
{
|
||||
"event_id": self.event.id,
|
||||
}
|
||||
)
|
||||
self.assertEqual(wizard.start, fields.Date.to_date("2017-05-28"))
|
||||
self.assertEqual(wizard.duration, 2.0)
|
||||
|
||||
def test_check_duration(self):
|
||||
with self.assertRaisesRegex(ValidationError, "Duration is required"):
|
||||
self._wizard_generate_sessions(
|
||||
{
|
||||
"event_id": self.event.id,
|
||||
"rrule_type": "weekly",
|
||||
"mon": True,
|
||||
"timeslot_ids": [(6, 0, self.timeslot_16_00.ids)],
|
||||
"duration": 0.0,
|
||||
"start": "2022-01-01",
|
||||
"until": "2022-01-31",
|
||||
}
|
||||
)
|
||||
|
||||
def test_check_interval(self):
|
||||
with self.assertRaisesRegex(ValidationError, "The interval cannot be negative"):
|
||||
self._wizard_generate_sessions(
|
||||
{
|
||||
"event_id": self.event.id,
|
||||
"rrule_type": "weekly",
|
||||
"mon": True,
|
||||
"timeslot_ids": [(6, 0, self.timeslot_16_00.ids)],
|
||||
"duration": 1.0,
|
||||
"interval": -1,
|
||||
"start": "2022-01-01",
|
||||
"until": "2022-01-31",
|
||||
}
|
||||
)
|
||||
|
||||
def test_session_create_wizard_weekly_01(self):
|
||||
"""Mondays at 16:00 and 20:00, for whole Jan 2022
|
||||
|
||||
╔════════════════════╗
|
||||
║ January ░░░░░ 2022 ║
|
||||
╟──┬──┬──┬──┬──┬──┬──╢
|
||||
║░░│░░│░░│░░│░░│░░│ ║
|
||||
╟──╔══╗──┼──┼──┼──┼──╢
|
||||
║ ║03║ │ │ │ │ ║
|
||||
╟──╠══╣──┼──┼──┼──┼──╢
|
||||
║ ║10║ │ │ │ │ ║
|
||||
╟──╠══╣──┼──┼──┼──┼──╢
|
||||
║ ║17║ │ │ │ │ ║
|
||||
╟──╠══╣──┼──┼──┼──┼──╢
|
||||
║ ║24║ │ │ │ │ ║
|
||||
╟──╠══╣──┼──┼──┼──┼──╢
|
||||
║ ║31║░░│░░│░░│░░│░░║
|
||||
╚══╚══╝══╧══╧══╧══╧══╝
|
||||
"""
|
||||
self.assertSessionDates(
|
||||
self._wizard_generate_sessions(
|
||||
{
|
||||
"event_id": self.event.id,
|
||||
"rrule_type": "weekly",
|
||||
"mon": True,
|
||||
"tue": False,
|
||||
"wed": False,
|
||||
"thu": False,
|
||||
"fri": False,
|
||||
"sun": False,
|
||||
"sat": False,
|
||||
"timeslot_ids": [
|
||||
(6, 0, (self.timeslot_16_00 | self.timeslot_20_00).ids)
|
||||
],
|
||||
"duration": 1.0,
|
||||
"start": "2022-01-01",
|
||||
"until": "2022-01-31",
|
||||
}
|
||||
),
|
||||
[
|
||||
"2022-01-03 16:00:00",
|
||||
"2022-01-03 20:00:00",
|
||||
"2022-01-10 16:00:00",
|
||||
"2022-01-10 20:00:00",
|
||||
"2022-01-17 16:00:00",
|
||||
"2022-01-17 20:00:00",
|
||||
"2022-01-24 16:00:00",
|
||||
"2022-01-24 20:00:00",
|
||||
"2022-01-31 16:00:00",
|
||||
"2022-01-31 20:00:00",
|
||||
],
|
||||
)
|
||||
|
||||
def test_session_create_wizard_weekly_02(self):
|
||||
"""Mondays, Wednesdays and Fridays at 20:00, every 2 weeks for a Feb 2022
|
||||
|
||||
╔════════════════════╗
|
||||
║ February ░░░░ 2022 ║
|
||||
╟──┬──┬──╔══╗──╔══╗──╢
|
||||
║░░│░░│ ║02║ ║04║ ║
|
||||
╟──┼──┼──╚══╝──╚══╝──╢
|
||||
║ │ │ │ │ │ │ ║
|
||||
╟──╔══╗──╔══╗──╔══╗──╢
|
||||
║ ║14║ ║16║ ║18║ ║
|
||||
╟──╚══╝──╚══╝──╚══╝──╢
|
||||
║ │ │ │ │ │ │ ║
|
||||
╟──╔══╗──┼──┼──┼──┼──╢
|
||||
║ ║28║░░│░░│░░│░░│░░║
|
||||
╚══╚══╝══╧══╧══╧══╧══╝
|
||||
"""
|
||||
self.assertSessionDates(
|
||||
self._wizard_generate_sessions(
|
||||
{
|
||||
"event_id": self.event.id,
|
||||
"rrule_type": "weekly",
|
||||
"interval": 2,
|
||||
"mon": True,
|
||||
"tue": False,
|
||||
"wed": True,
|
||||
"thu": False,
|
||||
"fri": True,
|
||||
"sun": False,
|
||||
"sat": False,
|
||||
"timeslot_ids": [(6, 0, self.timeslot_20_00.ids)],
|
||||
"duration": 2.0,
|
||||
"start": "2022-02-01",
|
||||
"until": "2022-02-28",
|
||||
}
|
||||
),
|
||||
[
|
||||
"2022-02-02 20:00:00",
|
||||
"2022-02-04 20:00:00",
|
||||
"2022-02-14 20:00:00",
|
||||
"2022-02-16 20:00:00",
|
||||
"2022-02-18 20:00:00",
|
||||
"2022-02-28 20:00:00",
|
||||
],
|
||||
)
|
||||
|
||||
def test_session_create_wizard_monthly_by_day(self):
|
||||
"""Last sunday of each month at 16:00, from March 2022 to May 2022"""
|
||||
self.assertSessionDates(
|
||||
self._wizard_generate_sessions(
|
||||
{
|
||||
"event_id": self.event.id,
|
||||
"rrule_type": "monthly",
|
||||
"month_by": "day",
|
||||
"byday": "-1",
|
||||
"weekday": "SUN",
|
||||
"timeslot_ids": [(6, 0, self.timeslot_16_00.ids)],
|
||||
"duration": 1.0,
|
||||
"start": "2022-03-01",
|
||||
"until": "2022-05-31",
|
||||
}
|
||||
),
|
||||
[
|
||||
"2022-03-27 16:00:00",
|
||||
"2022-04-24 16:00:00",
|
||||
"2022-05-29 16:00:00",
|
||||
],
|
||||
)
|
||||
|
||||
def test_session_create_wizard_monthly_by_date(self):
|
||||
"""The 15th of every month, from March 2022 to May 2022"""
|
||||
self.assertSessionDates(
|
||||
self._wizard_generate_sessions(
|
||||
{
|
||||
"event_id": self.event.id,
|
||||
"rrule_type": "monthly",
|
||||
"month_by": "date",
|
||||
"day": "15",
|
||||
"timeslot_ids": [(6, 0, self.timeslot_16_00.ids)],
|
||||
"duration": 1.0,
|
||||
"start": "2022-03-01",
|
||||
"until": "2022-05-31",
|
||||
}
|
||||
),
|
||||
[
|
||||
"2022-03-15 16:00:00",
|
||||
"2022-04-15 16:00:00",
|
||||
"2022-05-15 16:00:00",
|
||||
],
|
||||
)
|
||||
Loading…
Add table
Add a link
Reference in a new issue