From 0f83df510516b19f116320cd97aec71eb0ece0b8 Mon Sep 17 00:00:00 2001 From: Sara Lago Date: Fri, 8 Apr 2022 18:22:15 +0200 Subject: [PATCH] [IMP] pms: add tests for multi channel in services --- pms/tests/__init__.py | 2 +- pms/tests/test_pms_service.py | 1438 +++++++++++++++++++++++++++++++++ 2 files changed, 1439 insertions(+), 1 deletion(-) create mode 100644 pms/tests/test_pms_service.py diff --git a/pms/tests/__init__.py b/pms/tests/__init__.py index b7730751d..a0857b137 100644 --- a/pms/tests/__init__.py +++ b/pms/tests/__init__.py @@ -38,5 +38,5 @@ from . import test_pms_wizard_split_join_swap_reservation from . import test_product_template from . import test_pms_multiproperty from . import test_shared_room - # from . import test_automated_mails +from . import test_pms_service diff --git a/pms/tests/test_pms_service.py b/pms/tests/test_pms_service.py new file mode 100644 index 000000000..37cb5489d --- /dev/null +++ b/pms/tests/test_pms_service.py @@ -0,0 +1,1438 @@ +import datetime + +from freezegun import freeze_time + +from odoo import fields +from .common import TestPms + +class TestPmsService(TestPms): + + def setUp(self): + super().setUp() + # create room type + self.room_type_double = self.env["pms.room.type"].create( + { + "pms_property_ids": [self.pms_property1.id], + "name": "Double Test", + "default_code": "DBL_Test", + "class_id": self.room_type_class1.id, + } + ) + # create rooms + self.room1 = self.env["pms.room"].create( + { + "pms_property_id": self.pms_property1.id, + "name": "Double 101", + "room_type_id": self.room_type_double.id, + "capacity": 2, + "extra_beds_allowed": 1, + } + ) + + self.room2 = self.env["pms.room"].create( + { + "pms_property_id": self.pms_property1.id, + "name": "Double 102", + "room_type_id": self.room_type_double.id, + "capacity": 2, + "extra_beds_allowed": 1, + } + ) + self.partner1 = self.env["res.partner"].create( + { + "firstname": "María", + "lastname": "", + "email": "jaime@example.com", + "birthdate_date": "1983-03-01", + "gender": "male", + } + ) + self.sale_channel_door = self.env["pms.sale.channel"].create( + {"name": "Door", "channel_type": "direct"} + ) + self.sale_channel_phone = self.env["pms.sale.channel"].create( + {"name": "Phone", "channel_type": "direct"} + ) + self.sale_channel_mail = self.env["pms.sale.channel"].create( + {"name": "Mail", "channel_type": "direct"} + ) + + @freeze_time("2002-01-01") + def test_reservation_sale_origin_in_board_service(self): + """ + When a reservation is created with board_service, the sale_channel_origin_id + is indicated in reservation. Therefore, the board_service takes + the sale_channel_origin of its reservation + + Reservation --> sale_channel_origin_id = Door + | + --> service.sale_channel_origin_id? It must be Door + """ + # ARRANGE + self.product1 = self.env["product.product"].create( + { + "name": "Test Product 1", + } + ) + + self.board_service1 = self.env["pms.board.service"].create( + { + "name": "Test Board Service 1", + "default_code": "CB1", + } + ) + self.board_service_line1 = self.env["pms.board.service.line"].create( + { + "product_id": self.product1.id, + "pms_board_service_id": self.board_service1.id, + "amount": 10, + } + ) + + self.board_service_room_type1 = self.env["pms.board.service.room.type"].create( + { + "pms_room_type_id": self.room_type_double.id, + "pms_board_service_id": self.board_service1.id, + } + ) + # ACT + self.reservation = self.env["pms.reservation"].create( + { + "checkin": fields.date.today(), + "checkout": fields.date.today() + datetime.timedelta(days=2), + "room_type_id": self.room_type_double.id, + "partner_id": self.partner1.id, + "pms_property_id": self.pms_property1.id, + "pricelist_id": self.pricelist1.id, + "board_service_room_id": self.board_service_room_type1.id, + "sale_channel_origin_id": self.sale_channel_door.id, + } + ) + # ASSERT + self.assertEqual( + self.reservation.sale_channel_origin_id, + self.reservation.service_ids.sale_channel_origin_id, + "sale_channel_origin of board_Service must be the same as its reservation" + ) + + @freeze_time("2002-01-03") + def test_board_service_origin_as_sale_channel_in_lines(self): + """ + The lines of board_service when created have as sale_channel_id + the sale_channel_origin_id of its board_service + + Board_service ---> sale_channel_origin = Door + | + ---> service_line.sale_channel? It must be DOOR + """ + # ARRANGE + self.product1 = self.env["product.product"].create( + { + "name": "Test Product 1", + } + ) + + self.board_service1 = self.env["pms.board.service"].create( + { + "name": "Test Board Service 1", + "default_code": "CB1", + } + ) + self.board_service_line1 = self.env["pms.board.service.line"].create( + { + "product_id": self.product1.id, + "pms_board_service_id": self.board_service1.id, + "amount": 10, + } + ) + + self.board_service_room_type1 = self.env["pms.board.service.room.type"].create( + { + "pms_room_type_id": self.room_type_double.id, + "pms_board_service_id": self.board_service1.id, + } + ) + # ACT + self.reservation = self.env["pms.reservation"].create( + { + "checkin": fields.date.today(), + "checkout": fields.date.today() + datetime.timedelta(days=3), + "room_type_id": self.room_type_double.id, + "partner_id": self.partner1.id, + "pms_property_id": self.pms_property1.id, + "pricelist_id": self.pricelist1.id, + "board_service_room_id": self.board_service_room_type1.id, + "sale_channel_origin_id": self.sale_channel_door.id, + } + ) + # ASSERT + self.assertEqual( + self.reservation.service_ids.sale_channel_origin_id, + self.reservation.service_ids.service_line_ids.mapped("sale_channel_id"), + "sale_channel_origin of board_Service must be the same as its service_lines" + ) + + @freeze_time("2002-01-05") + def test_sale_channel_in_new_line_of_board_service(self): + """ + When adding a line to a board_service already created, by default, + the sale_channel of the line will be the same as the sale_channel_origin_id + of its board_service + Reservation --> sale_channel_ids = { Door, Phone } + | + --> board_service.sale_channel_origin = Door + | + --> board_service.service_line[0].sale_channel = Door + --> NEW board_service.service_line[1].sale_channel? + It must be Door --CHECKING THIS-- + """ + # ARRANGE + self.product1 = self.env["product.product"].create( + { + "name": "Test Product 1", + } + ) + + self.board_service1 = self.env["pms.board.service"].create( + { + "name": "Test Board Service 1", + "default_code": "CB1", + } + ) + self.board_service_line1 = self.env["pms.board.service.line"].create( + { + "product_id": self.product1.id, + "pms_board_service_id": self.board_service1.id, + "amount": 10, + } + ) + + self.board_service_room_type1 = self.env["pms.board.service.room.type"].create( + { + "pms_room_type_id": self.room_type_double.id, + "pms_board_service_id": self.board_service1.id, + } + ) + + self.reservation = self.env["pms.reservation"].create( + { + "checkin": fields.date.today(), + "checkout": fields.date.today() + datetime.timedelta(days=3), + "room_type_id": self.room_type_double.id, + "partner_id": self.partner1.id, + "pms_property_id": self.pms_property1.id, + "pricelist_id": self.pricelist1.id, + "board_service_room_id": self.board_service_room_type1.id, + "sale_channel_origin_id": self.sale_channel_door.id, + } + ) + # ACT + self.env["pms.service.line"].create( + { + "service_id": self.reservation.service_ids.id, + } + ) + # ASSERT + self.assertEqual( + self.reservation.service_ids.sale_channel_origin_id, + self.reservation.service_ids.service_line_ids.mapped("sale_channel_id"), + "sale_channel_origin of board_Service must corresponds to the" + "sale_channel_id of its new service_line" + ) + + @freeze_time("2002-01-07") + def test_sale_channel_different_in_lines_check_sale_channel_ids(self): + """ + Check that sale_channel_ids is calculated well (in board_service, folio and + reservation) when a board service has lines from different sale_channels + + Reservation --> sale_channel_ids = { Door, Phone } --CHECKING THIS-- + | + --> board_service.sale_channel_origin = Door + | + --> board_service.service_line[0].sale_channel = Door + --> board_service.service_line[1].sale_channel = Phone + + reservation.folio_id.sale_channel_ids = { Door, Phone } --CHECKING THIS-- + """ + # ARRANGE + self.product1 = self.env["product.product"].create( + { + "name": "Test Product 1", + } + ) + + self.board_service1 = self.env["pms.board.service"].create( + { + "name": "Test Board Service 1", + "default_code": "CB1", + } + ) + self.board_service_line1 = self.env["pms.board.service.line"].create( + { + "product_id": self.product1.id, + "pms_board_service_id": self.board_service1.id, + "amount": 10, + } + ) + + self.board_service_room_type1 = self.env["pms.board.service.room.type"].create( + { + "pms_room_type_id": self.room_type_double.id, + "pms_board_service_id": self.board_service1.id, + } + ) + self.reservation = self.env["pms.reservation"].create( + { + "checkin": fields.date.today(), + "checkout": fields.date.today() + datetime.timedelta(days=3), + "room_type_id": self.room_type_double.id, + "partner_id": self.partner1.id, + "pms_property_id": self.pms_property1.id, + "pricelist_id": self.pricelist1.id, + "board_service_room_id": self.board_service_room_type1.id, + "sale_channel_origin_id": self.sale_channel_door.id, + } + ) + # ACT + self.env["pms.service.line"].create( + { + "service_id": self.reservation.service_ids.id, + "sale_channel_id": self.sale_channel_phone.id + } + ) + sale_channel_ids = [ + self.reservation.folio_id.sale_channel_ids.ids, + self.reservation.sale_channel_ids.ids, + self.reservation.service_ids.sale_channel_ids.ids + ] + + expected_sale_channel_ids = [self.sale_channel_door.id, self.sale_channel_phone.id] + # ASSERT + for sale_channel in sale_channel_ids: + with self.subTest(k=sale_channel): + self.assertItemsEqual( + sale_channel, + expected_sale_channel_ids, + "sale_channel_ids must contain sale_channel_id of all board_service_lines" + ) + + @freeze_time("2002-01-09") + def test_sale_channel_equal_in_lines_check_sale_channel_ids(self): + """ + Check that sale_channel_ids of service is calculated correctly when its lines + have the sale sale_channel_id + """ + # ARRANGE + self.product1 = self.env["product.product"].create( + { + "name": "Test Product 1", + } + ) + + self.board_service1 = self.env["pms.board.service"].create( + { + "name": "Test Board Service 1", + "default_code": "CB1", + } + ) + self.board_service_line1 = self.env["pms.board.service.line"].create( + { + "product_id": self.product1.id, + "pms_board_service_id": self.board_service1.id, + "amount": 10, + } + ) + + self.board_service_room_type1 = self.env["pms.board.service.room.type"].create( + { + "pms_room_type_id": self.room_type_double.id, + "pms_board_service_id": self.board_service1.id, + } + ) + # ACT + self.reservation = self.env["pms.reservation"].create( + { + "checkin": fields.date.today(), + "checkout": fields.date.today() + datetime.timedelta(days=3), + "room_type_id": self.room_type_double.id, + "partner_id": self.partner1.id, + "pms_property_id": self.pms_property1.id, + "pricelist_id": self.pricelist1.id, + "board_service_room_id": self.board_service_room_type1.id, + "sale_channel_origin_id": self.sale_channel_door.id, + } + ) + self.env["pms.service.line"].create( + { + "service_id": self.reservation.service_ids.id, + } + ) + # ASSERT + self.assertEqual( + self.reservation.service_ids.sale_channel_ids, + self.reservation.service_ids.service_line_ids.mapped("sale_channel_id"), + "sale_channel_ids of board_Service must correspond to the sale_channel_id set of its service_lines" + ) + + @freeze_time("2002-01-11") + def test_change_origin_board_service_not_change_reservation_origin(self): + """ + When you change the sale_channel_origin_id of a board_service in a reservation + that matched the origin of its reservation, if that reservation has reservation_lines + with that sale_channel_id, it doesn't change the origin of reservation + + Reservation --> sale_channel_origin = Door sale_channel_ids = Door + | + --> board_services.sale_channel_origin = Door + + Change board_service origin to Mail + Reservation --> sale_channel_origin = Door sale_channel_ids = {Door, Mail} + | + --> board_services.sale_channel_origin = Mail + + """ + # ARRANGE + self.product1 = self.env["product.product"].create( + { + "name": "Test Product 1", + } + ) + + self.board_service1 = self.env["pms.board.service"].create( + { + "name": "Test Board Service 1", + "default_code": "CB1", + } + ) + self.board_service_line1 = self.env["pms.board.service.line"].create( + { + "product_id": self.product1.id, + "pms_board_service_id": self.board_service1.id, + "amount": 10, + } + ) + + self.board_service_room_type1 = self.env["pms.board.service.room.type"].create( + { + "pms_room_type_id": self.room_type_double.id, + "pms_board_service_id": self.board_service1.id, + } + ) + + self.reservation = self.env["pms.reservation"].create( + { + "checkin": fields.date.today(), + "checkout": fields.date.today() + datetime.timedelta(days=3), + "room_type_id": self.room_type_double.id, + "partner_id": self.partner1.id, + "pms_property_id": self.pms_property1.id, + "pricelist_id": self.pricelist1.id, + "board_service_room_id": self.board_service_room_type1.id, + "sale_channel_origin_id": self.sale_channel_door.id, + } + ) + # ACT + self.reservation.service_ids.sale_channel_origin_id = self.sale_channel_mail.id + # ASSERT + self.assertNotEqual( + self.reservation.sale_channel_origin_id, + self.reservation.service_ids.sale_channel_origin_id, + "sale_channel_origin_id mustn't match with sale_channel_origin_id of its reservation" + ) + + @freeze_time("2002-01-13") + def test_change_origin_board_service_change_in_lines(self): + """ + Check that when changing sale_channel_origin_id of board_service they + change their lines matching the changed channel + + Service --> sale_channel_origin_id = Door sale_channel_ids = {Door, Phone} + | + --> service_line[0].sale_channel_id = Door + | + --> service_line[1].sale_channel_id = Phone + + Change service origin to mail, expected results: + Service --> sale_channel_origin_id = Mail sale_channel_ids = {Mail, Phone} + | + --> service_line[0].sale_channel_id = Mail -----------CHECKING THIS--- + | + --> service_line[1].sale_channel_id = Phone + """ + # ARRANGE + self.product1 = self.env["product.product"].create( + { + "name": "Test Product 1", + } + ) + + self.board_service1 = self.env["pms.board.service"].create( + { + "name": "Test Board Service 1", + "default_code": "CB1", + } + ) + self.board_service_line1 = self.env["pms.board.service.line"].create( + { + "product_id": self.product1.id, + "pms_board_service_id": self.board_service1.id, + "amount": 10, + } + ) + + self.board_service_room_type1 = self.env["pms.board.service.room.type"].create( + { + "pms_room_type_id": self.room_type_double.id, + "pms_board_service_id": self.board_service1.id, + } + ) + + self.reservation = self.env["pms.reservation"].create( + { + "checkin": fields.date.today(), + "checkout": fields.date.today() + datetime.timedelta(days=3), + "room_type_id": self.room_type_double.id, + "partner_id": self.partner1.id, + "pms_property_id": self.pms_property1.id, + "pricelist_id": self.pricelist1.id, + "board_service_room_id": self.board_service_room_type1.id, + "sale_channel_origin_id": self.sale_channel_door.id, + } + ) + self.env["pms.service.line"].create( + { + "service_id": self.reservation.service_ids.id, + "sale_channel_id": self.sale_channel_phone.id + } + ) + # ACT + self.reservation.service_ids.sale_channel_origin_id = self.sale_channel_mail + + # ASSERT + self.assertIn( + self.sale_channel_mail, + self.reservation.service_ids.service_line_ids.mapped("sale_channel_id"), + "new sale_channel_origin_id of board service must be changed in lines with same sale_channel" + ) + + @freeze_time("2002-01-15") + def test_change_origin_board_service_no_change_in_lines(self): + """ + Check that when changing sale_channel_origin_id of board_service, those of its + service_lines that didn't match with the changed origin shouldn't be changed + + Service --> sale_channel_origin_id = Door sale_channel_ids = {Door, Phone} + | + --> service_line[0].sale_channel_id = Door + | + --> service_line[1].sale_channel_id = Phone + + Change service origin to mail, expected results: + Service --> sale_channel_origin_id = Mail sale_channel_ids = {Mail, Phone} + | + --> service_line[0].sale_channel_id = Mail + | + --> service_line[1].sale_channel_id = Phone -----------CHECKING THIS--- + """ + # ARRANGE + self.product1 = self.env["product.product"].create( + { + "name": "Test Product 1", + } + ) + + self.board_service1 = self.env["pms.board.service"].create( + { + "name": "Test Board Service 1", + "default_code": "CB1", + } + ) + self.board_service_line1 = self.env["pms.board.service.line"].create( + { + "product_id": self.product1.id, + "pms_board_service_id": self.board_service1.id, + "amount": 10, + } + ) + + self.board_service_room_type1 = self.env["pms.board.service.room.type"].create( + { + "pms_room_type_id": self.room_type_double.id, + "pms_board_service_id": self.board_service1.id, + } + ) + + self.reservation = self.env["pms.reservation"].create( + { + "checkin": fields.date.today(), + "checkout": fields.date.today() + datetime.timedelta(days=3), + "room_type_id": self.room_type_double.id, + "partner_id": self.partner1.id, + "pms_property_id": self.pms_property1.id, + "pricelist_id": self.pricelist1.id, + "board_service_room_id": self.board_service_room_type1.id, + "sale_channel_origin_id": self.sale_channel_door.id, + } + ) + self.env["pms.service.line"].create( + { + "service_id": self.reservation.service_ids.id, + "sale_channel_id": self.sale_channel_phone.id + } + ) + # ACT + self.reservation.service_ids.sale_channel_origin_id = self.sale_channel_mail + + # ASSERT + self.assertIn( + self.sale_channel_phone, + self.reservation.service_ids.service_line_ids.mapped("sale_channel_id"), + "new sale_channel_origin_id of board service mustn't changed in lines with different sale_channel" + ) + + @freeze_time("2002-01-17") + def test_change_origin_board_service_in_sale_channels(self): + """ + When sale_channel_origin_id of board_service is changed, the sale_channel_ids + of its reservation and folio are recalculated. Check that these calculations are correct + + Reservation --> sale_channel_origin = Door sale_channel_ids = Door + | + ---> board_service.sale_channel_origin = Door + + Change origin of board services to Phone and check sale_channel_ids of reservation and folio: + Reservation --> sale_channel_origin = Door sale_channel_ids = {Door, Phone} + | + ---> board_service.sale_channel_origin = Phone + + Reservation.folio_id.sale_channel_ids = {Door, Phone} + """ + # ARRANGE + self.product1 = self.env["product.product"].create( + { + "name": "Test Product 1", + } + ) + + self.board_service1 = self.env["pms.board.service"].create( + { + "name": "Test Board Service 1", + "default_code": "CB1", + } + ) + self.board_service_line1 = self.env["pms.board.service.line"].create( + { + "product_id": self.product1.id, + "pms_board_service_id": self.board_service1.id, + "amount": 10, + } + ) + + self.board_service_room_type1 = self.env["pms.board.service.room.type"].create( + { + "pms_room_type_id": self.room_type_double.id, + "pms_board_service_id": self.board_service1.id, + } + ) + self.reservation = self.env["pms.reservation"].create( + { + "checkin": fields.date.today(), + "checkout": fields.date.today() + datetime.timedelta(days=3), + "room_type_id": self.room_type_double.id, + "partner_id": self.partner1.id, + "pms_property_id": self.pms_property1.id, + "pricelist_id": self.pricelist1.id, + "board_service_room_id": self.board_service_room_type1.id, + "sale_channel_origin_id": self.sale_channel_door.id, + } + ) + # ACT + self.reservation.service_ids.sale_channel_origin_id = self.sale_channel_phone + + sale_channel_ids = [ + self.reservation.folio_id.sale_channel_ids.ids, + self.reservation.sale_channel_ids.ids, + ] + + expected_sale_channel_ids = [self.sale_channel_door.id, self.sale_channel_phone.id] + # ASSERT + for sale_channel in sale_channel_ids: + with self.subTest(k=sale_channel): + self.assertItemsEqual( + sale_channel, + expected_sale_channel_ids, + "sale_channel_ids must contain sale_channel_origin_id of all board_service" + ) + + @freeze_time("2002-01-19") + def test_change_origin_reservation_change_origin_services(self): + """ + When sale_channel_origin_id of reservation is changed, + sale_channel_origin_id of its services having the same origin + must also be changed + + Reservation ---> sale_channel_origin = Door + | + --> service.sale_channel_origin = Door + + Change sale_channel_origin to Mail, expected results: + Reservation ---> sale_channel_origin = Mail + | + --> service.sale_channel_origin = Mail ----CHECKING THIS--- + + """ + # ARRANGE + self.product1 = self.env["product.product"].create( + { + "name": "Test Product 1", + } + ) + + self.board_service1 = self.env["pms.board.service"].create( + { + "name": "Test Board Service 1", + "default_code": "CB1", + } + ) + self.board_service_line1 = self.env["pms.board.service.line"].create( + { + "product_id": self.product1.id, + "pms_board_service_id": self.board_service1.id, + "amount": 10, + } + ) + + self.board_service_room_type1 = self.env["pms.board.service.room.type"].create( + { + "pms_room_type_id": self.room_type_double.id, + "pms_board_service_id": self.board_service1.id, + } + ) + + self.reservation = self.env["pms.reservation"].create( + { + "checkin": fields.date.today(), + "checkout": fields.date.today() + datetime.timedelta(days=3), + "room_type_id": self.room_type_double.id, + "partner_id": self.partner1.id, + "pms_property_id": self.pms_property1.id, + "pricelist_id": self.pricelist1.id, + "board_service_room_id": self.board_service_room_type1.id, + "sale_channel_origin_id": self.sale_channel_door.id, + } + ) + # ACT + self.reservation.sale_channel_origin_id = self.sale_channel_mail + + # ASSERT + self.assertIn( + self.reservation.sale_channel_origin_id, + self.reservation.service_ids.sale_channel_origin_id, + "sale_channel_origin_id of service must be the same that its reservation " + ) + + @freeze_time("2002-02-01") + def test_reservation_sale_origin_in_service(self): + """ + When a reservation is created with service, the sale_channel_origin_id + is indicated in reservation. Therefore, the service takes + the sale_channel_origin of its reservation + + Reservation --> sale_channel_origin_id = Door + | + --> service.sale_channel_origin_id? It must be Door + """ + # ARRANGE + self.product1 = self.env["product.product"].create( + { + "name": "Test Product 1", + "per_day": True, + "consumed_on": "after", + "is_extra_bed": True, + } + ) + + self.reservation = self.env["pms.reservation"].create( + { + "checkin": fields.date.today(), + "checkout": fields.date.today() + datetime.timedelta(days=2), + "room_type_id": self.room_type_double.id, + "partner_id": self.partner1.id, + "pms_property_id": self.pms_property1.id, + "pricelist_id": self.pricelist1.id, + "sale_channel_origin_id": self.sale_channel_door.id, + } + ) + # ACT + self.service1 = self.env["pms.service"].create( + { + "reservation_id": self.reservation.id, + "product_id": self.product1.id, + "is_board_service": False, + } + ) + # ASSERT + self.assertEqual( + self.reservation.sale_channel_origin_id, + self.service1.sale_channel_origin_id, + "sale_channel_origin of service must be the same as its reservation" + ) + + @freeze_time("2002-02-03") + def test_origin_different_in_services_check_sale_channel_ids(self): + """ + Check that sale_channel_ids is calculated well (in folio and + reservation) when a reservation has services from different sale_channels + + Reservation --> sale_channel_origin = Door sale_channel_ids = Door + | + --> service.sale_channel_origin = Door + + Add in reservation another service with sale_channel_origin = Phone, expected results: + + Reservation --> sale_channel_origin = Door sale_channel_ids = Door, Phone + | + --> service[0].sale_channel_origin = Door + | + --> service[1].sale_channel_origin = Phone + + Reservation.folio_id.sale_channels = {Door, Phone} + + Check sale_channel_ids of reservation and its folio + """ + # ARRANGE + self.product1 = self.env["product.product"].create( + { + "name": "Test Product 1", + "per_day": True, + "consumed_on": "after", + "is_extra_bed": True, + } + ) + + self.reservation = self.env["pms.reservation"].create( + { + "checkin": fields.date.today(), + "checkout": fields.date.today() + datetime.timedelta(days=2), + "room_type_id": self.room_type_double.id, + "partner_id": self.partner1.id, + "pms_property_id": self.pms_property1.id, + "pricelist_id": self.pricelist1.id, + "sale_channel_origin_id": self.sale_channel_door.id, + } + ) + # ACT + self.service1 = self.env["pms.service"].create( + { + "reservation_id": self.reservation.id, + "product_id": self.product1.id, + "is_board_service": False, + } + ) + self.service2 = self.env["pms.service"].create( + { + "reservation_id": self.reservation.id, + "product_id": self.product1.id, + "is_board_service": False, + "sale_channel_origin_id": self.sale_channel_phone.id, + } + ) + + sale_channel_ids = [ + self.reservation.folio_id.sale_channel_ids, + self.reservation.sale_channel_ids, + ] + + expected_sale_channel_ids = self.reservation.service_ids.mapped("sale_channel_origin_id") + + # ASSERT + for sale_channel in sale_channel_ids: + with self.subTest(k=sale_channel): + self.assertItemsEqual( + sale_channel, + expected_sale_channel_ids, + "sale_channel_ids must contain sale_channel_id of all board_service_lines" + ) + + @freeze_time("2002-02-16") + def test_change_origin_service_not_change_reservation_origin(self): + """ + When you change the sale_channel_origin_id of a service in a reservation + that matched the origin of its reservation, if that reservation has reservation_lines + with that sale_channel_id, it doesn't change the origin of reservation + + Reservation --> sale_channel_origin = Door + | + --> service.sale_channel_origin = Door + + Change sale_channel_origin of service to Phone, expected results: + + Reservation --> sale_channel_origin = Door ----CHECKING THIS--- + | + --> service.sale_channel_origin = Phone + + """ + # ARRANGE + self.product1 = self.env["product.product"].create( + { + "name": "Test Product 1", + "per_day": True, + "consumed_on": "after", + "is_extra_bed": True, + } + ) + + self.reservation = self.env["pms.reservation"].create( + { + "checkin": fields.date.today(), + "checkout": fields.date.today() + datetime.timedelta(days=2), + "room_type_id": self.room_type_double.id, + "partner_id": self.partner1.id, + "pms_property_id": self.pms_property1.id, + "pricelist_id": self.pricelist1.id, + "sale_channel_origin_id": self.sale_channel_door.id, + } + ) + + self.service1 = self.env["pms.service"].create( + { + "reservation_id": self.reservation.id, + "product_id": self.product1.id, + "is_board_service": False, + } + ) + # ACT + self.reservation.service_ids.sale_channel_origin_id = self.sale_channel_phone.id + # ASSERT + self.assertNotEqual( + self.reservation.sale_channel_origin_id, + self.reservation.service_ids.sale_channel_origin_id, + "sale_channel_origin_id mustn't match with sale_channel_origin_id of its reservation" + ) + + @freeze_time("2002-02-23") + def test_change_origin_in_services_check_sale_channel_ids(self): + """ + Check that sale_channel_ids is calculated well (in folio and + reservation) when a service of a reservation change its sale_channel_origin + + Reservation --> sale_channel_origin = Door sale_channel_ids = Door + | + --> service.sale_channel_origin = Door + + Change sale_channel_origin of service to Mail, expected results: + + Reservation --> sale_channel_origin = Door + --> sale_channel_ids = Door, Mail -----CHECKING THIS---- + | + --> service.sale_channel_origin = Mail + + Reservation.folio_id.sale_channels = {Door, Mail} -----CHECKING THIS---- + + Check sale_channel_ids of reservation and its folio + """ + # ARRANGE + self.product1 = self.env["product.product"].create( + { + "name": "Test Product 1", + "per_day": True, + "consumed_on": "after", + "is_extra_bed": True, + } + ) + + self.reservation = self.env["pms.reservation"].create( + { + "checkin": fields.date.today(), + "checkout": fields.date.today() + datetime.timedelta(days=2), + "room_type_id": self.room_type_double.id, + "partner_id": self.partner1.id, + "pms_property_id": self.pms_property1.id, + "pricelist_id": self.pricelist1.id, + "sale_channel_origin_id": self.sale_channel_door.id, + } + ) + + self.service1 = self.env["pms.service"].create( + { + "reservation_id": self.reservation.id, + "product_id": self.product1.id, + "is_board_service": False, + } + ) + + # ACT + self.service1.sale_channel_origin_id = self.sale_channel_mail + + sale_channel_ids = [ + self.reservation.folio_id.sale_channel_ids.ids, + self.reservation.sale_channel_ids.ids, + ] + + expected_sale_channel_ids = [self.sale_channel_door.id, self.sale_channel_mail.id] + + # ASSERT + for sale_channel in sale_channel_ids: + with self.subTest(k=sale_channel): + self.assertItemsEqual( + sale_channel, + expected_sale_channel_ids, + "sale_channel_ids must contain sale_channel_origin_id of all services" + ) + + @freeze_time("2002-02-25") + def test_change_origin_in_reservation_change_origin_service(self): + """ + Check that when change sale_channel_origin of a reservation, sale_channel_origin + of services that match with the origin changed, change too + + Service --> sale_channel_origin_id = Door sale_channel_ids = {Door, Phone} + | + --> service[0].sale_channel_id = Door + | + --> service[1].sale_channel_id = Phone + + Change service origin to mail, expected results: + Reservation --> sale_channel_origin_id = Mail sale_channel_ids = {Mail, Phone} + | + --> service[0].sale_channel_id = Mail -----------CHECKING THIS--- + | + --> service[1].sale_channel_id = Phone + """ + # ARRANGE + self.product1 = self.env["product.product"].create( + { + "name": "Test Product 1", + "per_day": True, + "consumed_on": "after", + "is_extra_bed": True, + } + ) + + self.reservation = self.env["pms.reservation"].create( + { + "checkin": fields.date.today(), + "checkout": fields.date.today() + datetime.timedelta(days=2), + "room_type_id": self.room_type_double.id, + "partner_id": self.partner1.id, + "pms_property_id": self.pms_property1.id, + "pricelist_id": self.pricelist1.id, + "sale_channel_origin_id": self.sale_channel_door.id, + } + ) + + self.service1 = self.env["pms.service"].create( + { + "reservation_id": self.reservation.id, + "product_id": self.product1.id, + "is_board_service": False, + } + ) + self.service2 = self.env["pms.service"].create( + { + "reservation_id": self.reservation.id, + "product_id": self.product1.id, + "is_board_service": False, + "sale_channel_origin_id": self.sale_channel_phone.id, + } + ) + + # ACT + self.reservation.sale_channel_origin_id = self.sale_channel_mail + + # ASSERT + self.assertIn( + self.reservation.sale_channel_origin_id, + self.reservation.service_ids.mapped("sale_channel_origin_id"), + "sale_channel_origin_id of that service should be changed" + ) + + @freeze_time("2002-03-29") + def test_change_origin_in_reservation_no_change_origin_service(self): + """ + Check that when change sale_channel_origin of a reservation, sale_channel_origin + of services that don't match with the origin changed don't change + + Service --> sale_channel_origin_id = Door sale_channel_ids = {Door, Phone} + | + --> service[0].sale_channel_id = Door + | + --> service[1].sale_channel_id = Phone + + Change service origin to mail, expected results: + Reservation --> sale_channel_origin_id = Mail sale_channel_ids = {Mail, Phone} + | + --> service[0].sale_channel_id = Mail + | + --> service[1].sale_channel_id = Phone -----------CHECKING THIS--- + """ + # ARRANGE + self.product1 = self.env["product.product"].create( + { + "name": "Test Product 1", + "per_day": True, + "consumed_on": "after", + "is_extra_bed": True, + } + ) + + self.reservation = self.env["pms.reservation"].create( + { + "checkin": fields.date.today(), + "checkout": fields.date.today() + datetime.timedelta(days=2), + "room_type_id": self.room_type_double.id, + "partner_id": self.partner1.id, + "pms_property_id": self.pms_property1.id, + "pricelist_id": self.pricelist1.id, + "sale_channel_origin_id": self.sale_channel_door.id, + } + ) + + self.service1 = self.env["pms.service"].create( + { + "reservation_id": self.reservation.id, + "product_id": self.product1.id, + "is_board_service": False, + } + ) + self.service2 = self.env["pms.service"].create( + { + "reservation_id": self.reservation.id, + "product_id": self.product1.id, + "is_board_service": False, + "sale_channel_origin_id": self.sale_channel_phone.id, + } + ) + + # ACT + self.reservation.sale_channel_origin_id = self.sale_channel_mail + + # ASSERT + self.assertIn( + self.sale_channel_phone, + self.reservation.service_ids.mapped("sale_channel_origin_id"), + "sale_channel_origin_id of that service shouldn't be changed" + ) + + @freeze_time("2002-03-01") + def test_new_service_in_folio_sale_channel_origin(self): + """ + Check that when a service is created within a folio already created, + this service will use the sale_channel_origin_id of the folio as + its sale_channel_origin_id + + Folio ----> sale_channel_origin_id = Door + | + ----> service.sale_channel_origin_id? It must be Door + """ + # ARRANGE + self.product1 = self.env["product.product"].create( + { + "name": "Test Product 1", + "per_day": True, + "consumed_on": "after", + "is_extra_bed": True, + } + ) + self.folio1 = self.env["pms.folio"].create( + { + "pms_property_id": self.pms_property1.id, + "partner_name": self.partner1.name, + "sale_channel_origin_id": self.sale_channel_door.id, + } + ) + # ACT + self.service1 = self.env["pms.service"].create( + { + "product_id": self.product1.id, + "is_board_service": False, + "folio_id":self.folio1.id, + } + ) + # ASSERT + self.assertEqual( + self.folio1.sale_channel_origin_id, + self.service1.sale_channel_origin_id, + "Service that is just created must have its folio sale_channel_origin" + ) + + @freeze_time("2002-03-03") + def test_change_origin_folio_change_origin_one_service(self): + """ + Check that when a folio has a service, changing the sale_channel_origin + of folio changes sale_channel_origin of it service + + Folio ----> sale_channel_origin_id = Door + | + ----> service.sale_channel_origin_id = Door + + Change sale_channel_origin of folio to Mail + Folio ----> sale_channel_origin_id = Mail + | + ----> service.sale_channel_origin_id = Mail ---CHECKING THIS--- + """ + # ARRANGE + self.product1 = self.env["product.product"].create( + { + "name": "Test Product 1", + "per_day": True, + "consumed_on": "after", + "is_extra_bed": True, + } + ) + self.folio1 = self.env["pms.folio"].create( + { + "pms_property_id": self.pms_property1.id, + "partner_name": self.partner1.name, + "sale_channel_origin_id": self.sale_channel_door.id, + } + ) + + self.service1 = self.env["pms.service"].create( + { + "product_id": self.product1.id, + "is_board_service": False, + "folio_id": self.folio1.id, + } + ) + # ACT + self.folio1.sale_channel_origin_id = self.sale_channel_mail.id + + # ASSERT + self.assertEqual( + self.folio1.sale_channel_origin_id, + self.service1.sale_channel_origin_id, + "Service must have equal sale_channel_origin than folio" + ) + + @freeze_time("2002-03-05") + def test_change_origin_service_change_origin_folio(self): + """ + When a folio has only one service, when changing the service sale_channel_origin + folio.sale_channel_origin will also change + + Folio ----> sale_channel_origin_id = Door + | + ----> service.sale_channel_origin_id = Door + + Change sale_channel_origin of service to Mail + Folio ----> sale_channel_origin_id = Mail ---CHECKING THIS--- + | + ----> service.sale_channel_origin_id = Mail + """ + # ARRANGE + self.product1 = self.env["product.product"].create( + { + "name": "Test Product 1", + "per_day": True, + "consumed_on": "after", + "is_extra_bed": True, + } + ) + self.folio1 = self.env["pms.folio"].create( + { + "pms_property_id": self.pms_property1.id, + "partner_name": self.partner1.name, + "sale_channel_origin_id": self.sale_channel_door.id, + } + ) + + self.service1 = self.env["pms.service"].create( + { + "product_id": self.product1.id, + "is_board_service": False, + "folio_id": self.folio1.id, + } + ) + # ACT + self.service1.sale_channel_origin_id = self.sale_channel_mail.id + + # ASSERT + self.assertEqual( + self.folio1.sale_channel_origin_id, + self.service1.sale_channel_origin_id, + "Service must have equal sale_channel_origin than folio" + ) + + @freeze_time("2002-03-07") + def test_folio_sale_channels_with_service_different_origins(self): + """ + Check that on a folio with services with differents sale_channel_origin + the sale_channel_ids of folio are calculated well. + In this case sale_channel_ids must be formed by sale_channel_origin of its + services + + Folio ----> sale_channel_origin_id = Door + ----> sale_cahnnel_ids = {Door, Mail} ---CHECKING THIS---- + | + ----> service.sale_channel_origin_id = Door + | + ----> service.sale_channel_origin_id = Mail + """ + # ARRANGE + self.product1 = self.env["product.product"].create( + { + "name": "Test Product 1", + "per_day": True, + "consumed_on": "after", + "is_extra_bed": True, + } + ) + self.folio1 = self.env["pms.folio"].create( + { + "pms_property_id": self.pms_property1.id, + "partner_name": self.partner1.name, + "sale_channel_origin_id": self.sale_channel_door.id, + } + ) + # ACT + self.service1 = self.env["pms.service"].create( + { + "product_id": self.product1.id, + "is_board_service": False, + "folio_id": self.folio1.id, + } + ) + self.service2 = self.env["pms.service"].create( + { + "product_id": self.product1.id, + "is_board_service": False, + "folio_id": self.folio1.id, + "sale_channel_origin_id": self.sale_channel_mail.id + } + ) + + expected_sale_channels = self.folio1.service_ids.mapped("sale_channel_origin_id") + + # ASSERT + self.assertEqual( + self.folio1.sale_channel_ids, + expected_sale_channels, + "sale_channel_ids must be the set of sale_channel_origin of its services" + ) + + @freeze_time("2002-03-10") + def test_change_origin_folio_change_origin_service(self): + """ + Check that when a folio has several services with different sale_channel_origin_id + and change sale_channel_origin_id of folio, only changes origin of those services that + match with the sale_channel_origin changed + + Folio ----> sale_channel_origin_id = Door + | + ----> service[0].sale_channel_origin_id = Door + | + ----> service[1].sale_channel_origin_id = Mail + + Change origin of folio to Phone, expected results: + Folio ----> sale_channel_origin_id = Phone + | + ----> service[0].sale_channel_origin_id = Phone ---CHECKIN THIS--- + | + ----> service[1].sale_channel_origin_id = Mail + """ + # ARRANGE + self.product1 = self.env["product.product"].create( + { + "name": "Test Product 1", + "per_day": True, + "consumed_on": "after", + "is_extra_bed": True, + } + ) + self.folio1 = self.env["pms.folio"].create( + { + "pms_property_id": self.pms_property1.id, + "partner_name": self.partner1.name, + "sale_channel_origin_id": self.sale_channel_door.id, + } + ) + + self.service1 = self.env["pms.service"].create( + { + "product_id": self.product1.id, + "is_board_service": False, + "folio_id": self.folio1.id, + } + ) + self.service2 = self.env["pms.service"].create( + { + "product_id": self.product1.id, + "is_board_service": False, + "folio_id": self.folio1.id, + "sale_channel_origin_id": self.sale_channel_mail.id + } + ) + # ACT + self.folio1.sale_channel_origin_id = self.sale_channel_phone.id + + # ASSERT + self.assertIn( + self.sale_channel_phone, + self.folio1.service_ids.mapped("sale_channel_origin_id"), + "sale_channel_origin_id of that service must be changed" + ) + + @freeze_time("2002-03-13") + def test_change_origin_folio_no_change_origin_service(self): + """ + Check that when a folio has several services with different sale_channel_origin_id + and change sale_channel_origin_id of folio, only changes origin of those services that + match with the sale_channel_origin changed. Then services that didn't initially + match with sale_channel_origin of folio shouldn't have changed + + Folio ----> sale_channel_origin_id = Door + | + ----> service[0].sale_channel_origin_id = Door + | + ----> service[1].sale_channel_origin_id = Mail + + Change origin of folio to Phone, expected results: + Folio ----> sale_channel_origin_id = Phone + | + ----> service[0].sale_channel_origin_id = Phone + | + ----> service[1].sale_channel_origin_id = Mail ---CHECKIN THIS--- + """ + # ARRANGE + self.product1 = self.env["product.product"].create( + { + "name": "Test Product 1", + "per_day": True, + "consumed_on": "after", + "is_extra_bed": True, + } + ) + self.folio1 = self.env["pms.folio"].create( + { + "pms_property_id": self.pms_property1.id, + "partner_name": self.partner1.name, + "sale_channel_origin_id": self.sale_channel_door.id, + } + ) + + self.service1 = self.env["pms.service"].create( + { + "product_id": self.product1.id, + "is_board_service": False, + "folio_id": self.folio1.id, + } + ) + self.service2 = self.env["pms.service"].create( + { + "product_id": self.product1.id, + "is_board_service": False, + "folio_id": self.folio1.id, + "sale_channel_origin_id": self.sale_channel_mail.id + } + ) + # ACT + self.folio1.sale_channel_origin_id = self.sale_channel_phone.id + + # ASSERT + self.assertIn( + self.sale_channel_mail, + self.folio1.service_ids.mapped("sale_channel_origin_id"), + "sale_channel_origin_id of that service mustn't be changed" + )