audrius/pms
1
0
Fork 1
mirror of https://github.com/OCA/pms.git synced 2025-01-29 00:17:45 +02:00
Code Issues Packages Projects Releases Wiki Activity

Code review (#62)

Browse Source 
* [REF] pms: refactor amenity type

* [REF] pms: refactor amenity

* [REF]Refactor amenity views and demo data

* [WIP] master model 2nd day

* [WIP] Master model refactor

* [WIP] Refactor in tests

* [WIP] Add mandatory sequence in pms_property at tests and fix create in folio, reservation and checkin

* [WIP] Test refactor

* [WIP]Refactor pms_room, pms_room_clousure_reason and pms_room_type

* [WIP]review of guidelines in master models

* [WIP]test refactor

* [WIP]review guidelines in master models 2

* [WIP] fixed fields in pms_l10n_es

* [WIP]Refactor product_product, product_template, res_company, res_partner and res_user

* [IMP] Add common.py for tests

* [WIP] Refactor fields in pms.folio and pms.reservation

* [WIP] Review guidelines in pms.reservation, pms.reservation.line and rename availability models

* [WIP] Rename availability models

* [WIP] Refactor availability models

* [WIP] Refactor availity models 2

* [WIP] Pms: add sequences creation in pms_property create

* [WIP] Fix sequence creation in pmp.property

* [REF] Refactor fields in res_partner and rename date_overnight

* [REF] Refactoring master models tests

* [FIX] Fix sequence create in pms.reservation

* [REF] Refactor helps in master and availability models

* [IMP] Extend test coverage in test_pms_reservation

* [REF] Refactor fields in pms_reservation

* [REF] Refactor fields in pms_reservation 2

* [REF] Refactor fields in service flow

* [REF] Refactor pms_reservation

* [REF] Refactor pms_reservation 2

* [REF] draft button removed from view

* [REF] change no_show to arrival_delayed in field state of pms_reservation

* [REF] Add compute_preferred_room_id in pms_reservation

* [REF] Fix cache problem in test_reservation_action_checkout

Co-authored-by: braisab <braisterbutalino@gmail.com>
Co-authored-by: Sara Lago <saralago126@gmail.com>
Co-authored-by: Brais Abeijón <>
This commit is contained in:
Miguel Padin
2021-04-15 01:01:11 +02:00
committed by GitHub
parent eace7de663
commit 0d03152402
79 changed files with 3920 additions and 2480 deletions
Download Patch File Download Diff File Expand all files Collapse all files

710
pms/tests/test_pms_reservation.py
View File

@@ -3,25 +3,61 @@ import datetime
from freezegun import freeze_time
from odoo import fields
from odoo.exceptions import ValidationError
from .common import TestHotel
from odoo.exceptions import UserError, ValidationError
from odoo.tests import common
@freeze_time("2012-01-14")
class TestPmsReservations(TestHotel):
class TestPmsReservations(common.SavepointCase):
def create_common_scenario(self):
# create a room type availability
self.room_type_availability = self.env[
"pms.room.type.availability.plan"
].create({"name": "Availability plan for TEST"})
self.test_pricelist1 = self.env["product.pricelist"].create(
{
"name": "test pricelist 1",
}
)
# create a room type availability
self.room_type_availability = self.env["pms.availability.plan"].create(
{
"name": "Availability plan for TEST",
"pms_pricelist_ids": [(6, 0, [self.test_pricelist1.id])],
}
)
# create a sequences
self.folio_sequence = self.env["ir.sequence"].create(
{
"name": "PMS Folio",
"code": "pms.folio",
"padding": 4,
"company_id": self.env.ref("base.main_company").id,
}
)
self.reservation_sequence = self.env["ir.sequence"].create(
{
"name": "PMS Reservation",
"code": "pms.reservation",
"padding": 4,
"company_id": self.env.ref("base.main_company").id,
}
)
self.checkin_sequence = self.env["ir.sequence"].create(
{
"name": "PMS Checkin",
"code": "pms.checkin.partner",
"padding": 4,
"company_id": self.env.ref("base.main_company").id,
}
)
# create a property
self.property = self.env["pms.property"].create(
{
"name": "MY PMS TEST",
"company_id": self.env.ref("base.main_company").id,
"default_pricelist_id": self.env.ref("product.list0").id,
"default_pricelist_id": self.test_pricelist1.id,
"folio_sequence_id": self.folio_sequence.id,
"reservation_sequence_id": self.reservation_sequence.id,
"checkin_sequence_id": self.checkin_sequence.id,
}
)
@@ -35,7 +71,7 @@ class TestPmsReservations(TestHotel):
{
"pms_property_ids": [self.property.id],
"name": "Double Test",
"code_type": "DBL_Test",
"default_code": "DBL_Test",
"class_id": self.room_type_class.id,
}
)
@@ -70,11 +106,15 @@ class TestPmsReservations(TestHotel):
self.demo_user = self.env.ref("base.user_admin")
def create_multiproperty_scenario(self):
self.create_common_scenario()
self.property1 = self.env["pms.property"].create(
{
"name": "Property_1",
"company_id": self.env.ref("base.main_company").id,
"default_pricelist_id": self.env.ref("product.list0").id,
"folio_sequence_id": self.folio_sequence.id,
"reservation_sequence_id": self.reservation_sequence.id,
"checkin_sequence_id": self.checkin_sequence.id,
}
)
@@ -83,6 +123,9 @@ class TestPmsReservations(TestHotel):
"name": "Property_2",
"company_id": self.env.ref("base.main_company").id,
"default_pricelist_id": self.env.ref("product.list0").id,
"folio_sequence_id": self.folio_sequence.id,
"reservation_sequence_id": self.reservation_sequence.id,
"checkin_sequence_id": self.checkin_sequence.id,
}
)
@@ -91,6 +134,9 @@ class TestPmsReservations(TestHotel):
"name": "Property_3",
"company_id": self.env.ref("base.main_company").id,
"default_pricelist_id": self.env.ref("product.list0").id,
"folio_sequence_id": self.folio_sequence.id,
"reservation_sequence_id": self.reservation_sequence.id,
"checkin_sequence_id": self.checkin_sequence.id,
}
)
self.room_type_class = self.env["pms.room.type.class"].create(
@@ -109,6 +155,7 @@ class TestPmsReservations(TestHotel):
# reservation should start on checkin day
# ARRANGE
self.create_common_scenario()
today = fields.date.today()
checkin = today + datetime.timedelta(days=8)
checkout = checkin + datetime.timedelta(days=11)
@@ -116,9 +163,9 @@ class TestPmsReservations(TestHotel):
reservation_vals = {
"checkin": checkin,
"checkout": checkout,
"room_type_id": self.room_type_3.id,
"room_type_id": self.room_type_double.id,
"partner_id": customer.id,
"pms_property_id": self.main_hotel_property.id,
"pms_property_id": self.property.id,
}
# ACT
@@ -134,7 +181,7 @@ class TestPmsReservations(TestHotel):
def test_create_reservation_end_date(self):
# TEST CASE
# reservation should end on checkout day
self.create_common_scenario()
# ARRANGE
today = fields.date.today()
checkin = today + datetime.timedelta(days=8)
@@ -143,9 +190,9 @@ class TestPmsReservations(TestHotel):
reservation_vals = {
"checkin": checkin,
"checkout": checkout,
"room_type_id": self.room_type_3.id,
"room_type_id": self.room_type_double.id,
"partner_id": customer.id,
"pms_property_id": self.main_hotel_property.id,
"pms_property_id": self.property.id,
}
# ACT
@@ -637,7 +684,7 @@ class TestPmsReservations(TestHotel):
self.assertEqual(r1, reservations[0])
@freeze_time("1981-11-01")
def test_order_priority_left_for_checkin(self):
def test_order_priority_allowed_checkin(self):
# ARRANGE
self.create_common_scenario()
r1 = self.env["pms.reservation"].create(
@@ -658,7 +705,7 @@ class TestPmsReservations(TestHotel):
"pms_property_id": self.property.id,
}
)
r1.left_for_checkin = False
r1.allowed_checkin = False
# ACT
reservations = self.env["pms.reservation"].search(
[("pms_property_id", "=", self.property.id)]
@@ -667,7 +714,7 @@ class TestPmsReservations(TestHotel):
self.assertEqual(r1, reservations[0])
@freeze_time("1981-11-01")
def test_order_priority_left_for_checkout(self):
def test_order_priority_allowed_checkout(self):
# ARRANGE
self.create_common_scenario()
r1 = self.env["pms.reservation"].create(
@@ -688,7 +735,7 @@ class TestPmsReservations(TestHotel):
"pms_property_id": self.property.id,
}
)
r1.left_for_checkout = True
r1.allowed_checkout = True
# ACT
reservations = self.env["pms.reservation"].search(
[("pms_property_id", "=", self.property.id)]
@@ -816,7 +863,9 @@ class TestPmsReservations(TestHotel):
checkin.flush()
# ACT
r1.action_reservation_checkout()
with freeze_time("1981-11-02"):
r1._cache.clear()
r1.action_reservation_checkout()
# ASSERT
self.assertEqual(
@@ -861,7 +910,7 @@ class TestPmsReservations(TestHotel):
(4, self.property2.id),
],
"name": "Single",
"code_type": "SIN",
"default_code": "SIN",
"class_id": self.room_type_class.id,
"list_price": 30,
}
@@ -903,3 +952,622 @@ class TestPmsReservations(TestHotel):
with self.subTest(k=test_case):
with self.assertRaises(ValidationError):
self.reservation_test.write(test_case)
@freeze_time("1950-11-01")
def _test_check_date_order(self):
self.create_common_scenario()
customer = self.env.ref("base.res_partner_12")
reservation = self.env["pms.reservation"].create(
{
"pms_property_id": self.property.id,
"checkin": fields.date.today(),
"checkout": fields.date.today() + datetime.timedelta(days=3),
"partner_id": customer.id,
}
)
reservation.flush()
self.assertEqual(
str(reservation.date_order),
str(fields.date.today()),
"Date Order isn't correct",
)
def _test_check_checkin_datetime(self):
self.create_common_scenario()
customer = self.env.ref("base.res_partner_12")
reservation = self.env["pms.reservation"].create(
{
"pms_property_id": self.property.id,
"checkin": fields.date.today() + datetime.timedelta(days=300),
"checkout": fields.date.today() + datetime.timedelta(days=305),
"partner_id": customer.id,
}
)
r = reservation.checkin
checkin_expected = datetime.datetime(r.year, r.month, r.day, 14, 00)
# checkin_expected = checkin_expected.astimezone(self.property.tz.value)
self.assertEqual(
str(reservation.checkin_datetime),
str(checkin_expected),
"Date Order isn't correct",
)
def test_check_allowed_room_ids(self):
self.create_common_scenario()
customer = self.env.ref("base.res_partner_12")
availability_rule = self.env["pms.availability.plan.rule"].create(
{
"pms_property_id": self.property.id,
"room_type_id": self.room_type_double.id,
"availability_plan_id": self.room_type_availability.id,
"date": fields.date.today() + datetime.timedelta(days=153),
}
)
reservation = self.env["pms.reservation"].create(
{
"pms_property_id": self.property.id,
"checkin": fields.date.today() + datetime.timedelta(days=150),
"checkout": fields.date.today() + datetime.timedelta(days=152),
"partner_id": customer.id,
"room_type_id": self.room_type_double.id,
"pricelist_id": self.test_pricelist1.id,
}
)
self.assertEqual(
reservation.allowed_room_ids,
availability_rule.room_type_id.room_ids,
"Rooms allowed don't match",
)
def _test_partner_is_agency(self):
self.create_common_scenario()
sale_channel1 = self.env["pms.sale.channel"].create(
{"name": "Test Indirect", "channel_type": "indirect"}
)
agency = self.env["res.partner"].create(
{
"name": "partner1",
"is_agency": True,
"sale_channel_id": sale_channel1.id,
}
)
reservation = self.env["pms.reservation"].create(
{
"pms_property_id": self.property.id,
"checkin": fields.date.today() + datetime.timedelta(days=150),
"checkout": fields.date.today() + datetime.timedelta(days=152),
# "partner_id": False,
"agency_id": agency.id,
# "folio_id":False,
}
)
reservation.flush()
self.assertEqual(
reservation.partner_id.id,
agency.id,
"Partner_id doesn't match with agency_id",
)
def test_agency_pricelist(self):
self.create_common_scenario()
sale_channel1 = self.env["pms.sale.channel"].create(
{
"name": "Test Indirect",
"channel_type": "indirect",
"product_pricelist_ids": [(6, 0, [self.test_pricelist1.id])],
}
)
agency = self.env["res.partner"].create(
{
"name": "partner1",
"is_agency": True,
"sale_channel_id": sale_channel1.id,
"apply_pricelist": True,
}
)
reservation = self.env["pms.reservation"].create(
{
"pms_property_id": self.property.id,
"checkin": fields.date.today() + datetime.timedelta(days=150),
"checkout": fields.date.today() + datetime.timedelta(days=152),
"agency_id": agency.id,
}
)
self.assertEqual(
reservation.pricelist_id.id,
reservation.agency_id.property_product_pricelist.id,
"Rervation pricelist doesn't match with Agency pricelist",
)
def test_compute_access_url(self):
self.create_common_scenario()
customer = self.env.ref("base.res_partner_12")
reservation = self.env["pms.reservation"].create(
{
"pms_property_id": self.property.id,
"checkin": fields.date.today() + datetime.timedelta(days=150),
"checkout": fields.date.today() + datetime.timedelta(days=152),
"partner_id": customer.id,
}
)
url = "/my/reservations/%s" % reservation.id
self.assertEqual(reservation.access_url, url, "Reservation url isn't correct")
def test_compute_ready_for_checkin(self):
self.create_common_scenario()
self.host1 = self.env["res.partner"].create(
{
"name": "Miguel",
"phone": "654667733",
"email": "miguel@example.com",
}
)
self.host2 = self.env["res.partner"].create(
{
"name": "Brais",
"phone": "654437733",
"email": "brais@example.com",
}
)
self.reservation = self.env["pms.reservation"].create(
{
"checkin": "2012-01-14",
"checkout": "2012-01-17",
"partner_id": self.host1.id,
"allowed_checkin": True,
"pms_property_id": self.property.id,
"adults": 3,
}
)
self.checkin1 = self.env["pms.checkin.partner"].create(
{
"partner_id": self.host1.id,
"reservation_id": self.reservation.id,
}
)
self.checkin2 = self.env["pms.checkin.partner"].create(
{
"partner_id": self.host2.id,
"reservation_id": self.reservation.id,
}
)
self.reservation.checkin_partner_ids = [
(6, 0, [self.checkin1.id, self.checkin2.id])
]
self.assertTrue(
self.reservation.ready_for_checkin,
"Reservation should is ready for checkin",
)
def test_check_checkin_less_checkout(self):
self.create_common_scenario()
self.host1 = self.env["res.partner"].create(
{
"name": "Host1",
}
)
with self.assertRaises(ValidationError):
self.env["pms.reservation"].create(
{
"checkin": fields.date.today() + datetime.timedelta(days=3),
"checkout": fields.date.today(),
"pms_property_id": self.property.id,
"partner_id": self.host1.id,
}
)
def test_check_adults(self):
self.create_common_scenario()
self.host1 = self.env["res.partner"].create(
{
"name": "Host1",
}
)
with self.assertRaises(ValidationError):
self.env["pms.reservation"].create(
{
"checkin": fields.date.today() + datetime.timedelta(days=3),
"checkout": fields.date.today(),
"pms_property_id": self.property.id,
"partner_id": self.host1.id,
"room_type_id": self.room_type_double.id,
"adults": 4,
}
)
def test_check_arrival_hour(self):
self.create_common_scenario()
self.host1 = self.env["res.partner"].create(
{
"name": "Host1",
}
)
with self.assertRaises(ValidationError):
self.env["pms.reservation"].create(
{
"checkin": fields.date.today(),
"checkout": fields.date.today() + datetime.timedelta(days=3),
"pms_property_id": self.property.id,
"partner_id": self.host1.id,
"arrival_hour": "14:00:00",
}
)
def test_check_departure_hour(self):
self.create_common_scenario()
self.host1 = self.env["res.partner"].create(
{
"name": "Host1",
}
)
with self.assertRaises(ValidationError):
self.env["pms.reservation"].create(
{
"checkin": fields.date.today(),
"checkout": fields.date.today() + datetime.timedelta(days=3),
"pms_property_id": self.property.id,
"partner_id": self.host1.id,
"departure_hour": "14:00:00",
}
)
def test_check_property_integrity_room(self):
self.create_common_scenario()
self.property2 = self.env["pms.property"].create(
{
"name": "MY PMS TEST",
"company_id": self.env.ref("base.main_company").id,
"default_pricelist_id": self.test_pricelist1.id,
"folio_sequence_id": self.folio_sequence.id,
"reservation_sequence_id": self.reservation_sequence.id,
"checkin_sequence_id": self.checkin_sequence.id,
}
)
self.host1 = self.env["res.partner"].create(
{
"name": "Host1",
}
)
self.room_type_double.pms_property_ids = [
(6, 0, [self.property.id, self.property2.id])
]
with self.assertRaises(ValidationError):
self.env["pms.reservation"].create(
{
"checkin": fields.date.today(),
"checkout": fields.date.today() + datetime.timedelta(days=3),
"pms_property_id": self.property2.id,
"partner_id": self.host1.id,
"room_type_id": self.room_type_double.id,
"preferred_room_id": self.room1.id,
}
)
def test_shared_folio_true(self):
self.create_common_scenario()
self.host1 = self.env["res.partner"].create(
{
"name": "Host1",
}
)
self.reservation = self.env["pms.reservation"].create(
{
"checkin": fields.date.today() + datetime.timedelta(days=60),
"checkout": fields.date.today() + datetime.timedelta(days=65),
"pms_property_id": self.property.id,
"partner_id": self.host1.id,
}
)
self.reservation2 = self.env["pms.reservation"].create(
{
"checkin": fields.date.today() + datetime.timedelta(days=60),
"checkout": fields.date.today() + datetime.timedelta(days=64),
"pms_property_id": self.property.id,
"partner_id": self.host1.id,
"folio_id": self.reservation.folio_id.id,
}
)
self.assertTrue(
self.reservation.shared_folio,
"Folio.reservations > 1, so reservation.shared_folio must be True",
)
def test_shared_folio_false(self):
self.create_common_scenario()
self.host1 = self.env["res.partner"].create(
{
"name": "Host1",
}
)
self.reservation = self.env["pms.reservation"].create(
{
"checkin": fields.date.today() + datetime.timedelta(days=60),
"checkout": fields.date.today() + datetime.timedelta(days=65),
"pms_property_id": self.property.id,
"partner_id": self.host1.id,
}
)
self.assertFalse(
self.reservation.shared_folio,
"Folio.reservations = 1, so reservation.shared_folio must be False",
)
@freeze_time("1982-11-01")
def test_reservation_action_cancel_fail(self):
self.create_common_scenario()
self.host1 = self.env["res.partner"].create(
{
"name": "Host1",
}
)
reservation = self.env["pms.reservation"].create(
{
"checkin": fields.date.today(),
"checkout": fields.date.today() + datetime.timedelta(days=1),
"room_type_id": self.room_type_double.id,
"partner_id": self.host1.id,
"pms_property_id": self.property.id,
}
)
reservation.state = "cancelled"
with self.assertRaises(UserError):
reservation.action_cancel()
@freeze_time("1983-11-01")
def test_cancelation_reason_noshow(self):
self.create_common_scenario()
Pricelist = self.env["product.pricelist"]
self.cancelation_rule = self.env["pms.cancelation.rule"].create(
{
"name": "Cancelation Rule Test",
"pms_property_ids": [self.property.id],
"penalty_noshow": 50,
}
)
self.pricelist = Pricelist.create(
{
"name": "Pricelist Test",
"pms_property_ids": [self.property.id],
"cancelation_rule_id": self.cancelation_rule.id,
}
)
self.host1 = self.env["res.partner"].create(
{
"name": "Host1",
}
)
reservation = self.env["pms.reservation"].create(
{
"checkin": fields.date.today() + datetime.timedelta(days=-5),
"checkout": fields.date.today() + datetime.timedelta(days=-3),
"room_type_id": self.room_type_double.id,
"partner_id": self.host1.id,
"pms_property_id": self.property.id,
"pricelist_id": self.pricelist.id,
}
)
reservation.action_cancel()
reservation.flush()
self.assertEqual(
reservation.cancelled_reason,
"noshow",
"If reservation has already passed and no checkin,"
"cancelled_reason must be 'noshow'",
)
@freeze_time("1984-11-01")
def test_cancelation_reason_intime(self):
self.create_common_scenario()
Pricelist = self.env["product.pricelist"]
self.cancelation_rule = self.env["pms.cancelation.rule"].create(
{
"name": "Cancelation Rule Test",
"pms_property_ids": [self.property.id],
"days_intime": 3,
}
)
self.pricelist = Pricelist.create(
{
"name": "Pricelist Test",
"pms_property_ids": [self.property.id],
"cancelation_rule_id": self.cancelation_rule.id,
}
)
self.host1 = self.env["res.partner"].create(
{
"name": "Host1",
}
)
reservation = self.env["pms.reservation"].create(
{
"checkin": fields.date.today() + datetime.timedelta(days=5),
"checkout": fields.date.today() + datetime.timedelta(days=8),
"room_type_id": self.room_type_double.id,
"partner_id": self.host1.id,
"pms_property_id": self.property.id,
"pricelist_id": self.pricelist.id,
}
)
reservation.action_cancel()
reservation.flush()
self.assertEqual(reservation.cancelled_reason, "intime", "-----------")
@freeze_time("1985-11-01")
def _test_cancelation_reason_late(self):
self.create_common_scenario()
Pricelist = self.env["product.pricelist"]
self.cancelation_rule = self.env["pms.cancelation.rule"].create(
{
"name": "Cancelation Rule Test",
"pms_property_ids": [self.property.id],
"days_late": 3,
}
)
self.pricelist = Pricelist.create(
{
"name": "Pricelist Test",
"pms_property_ids": [self.property.id],
"cancelation_rule_id": self.cancelation_rule.id,
}
)
self.host1 = self.env["res.partner"].create(
{
"name": "Host1",
}
)
reservation = self.env["pms.reservation"].create(
{
"checkin": fields.date.today() + datetime.timedelta(days=1),
"checkout": fields.date.today() + datetime.timedelta(days=4),
"room_type_id": self.room_type_double.id,
"partner_id": self.host1.id,
"pms_property_id": self.property.id,
"pricelist_id": self.pricelist.id,
}
)
reservation.action_cancel()
reservation.flush()
self.assertEqual(reservation.cancelled_reason, "late", "-----------")
def test_compute_checkin_partner_count(self):
self.create_common_scenario()
self.host1 = self.env["res.partner"].create(
{
"name": "Miguel",
"phone": "654667733",
"email": "miguel@example.com",
}
)
self.host2 = self.env["res.partner"].create(
{
"name": "Brais",
"phone": "654437733",
"email": "brais@example.com",
}
)
self.reservation = self.env["pms.reservation"].create(
{
"checkin": "2013-01-14",
"checkout": "2013-01-17",
"partner_id": self.host1.id,
"pms_property_id": self.property.id,
"adults": 3,
}
)
self.checkin1 = self.env["pms.checkin.partner"].create(
{
"partner_id": self.host1.id,
"reservation_id": self.reservation.id,
}
)
self.checkin2 = self.env["pms.checkin.partner"].create(
{
"partner_id": self.host2.id,
"reservation_id": self.reservation.id,
}
)
self.reservation.checkin_partner_ids = [
(6, 0, [self.checkin1.id, self.checkin2.id])
]
self.assertEqual(
self.reservation.checkin_partner_count,
len(self.reservation.checkin_partner_ids),
"Checkin_partner_count must be match with number of checkin_partner_ids",
)
def test_compute_checkin_partner_pending_count(self):
self.create_common_scenario()
self.host1 = self.env["res.partner"].create(
{
"name": "Miguel",
"phone": "654667733",
"email": "miguel@example.com",
}
)
self.host2 = self.env["res.partner"].create(
{
"name": "Brais",
"phone": "654437733",
"email": "brais@example.com",
}
)
self.reservation = self.env["pms.reservation"].create(
{
"checkin": "2014-01-14",
"checkout": "2014-01-17",
"partner_id": self.host1.id,
"pms_property_id": self.property.id,
"adults": 3,
}
)
self.checkin1 = self.env["pms.checkin.partner"].create(
{
"partner_id": self.host1.id,
"reservation_id": self.reservation.id,
}
)
self.checkin2 = self.env["pms.checkin.partner"].create(
{
"partner_id": self.host2.id,
"reservation_id": self.reservation.id,
}
)
self.reservation.checkin_partner_ids = [
(6, 0, [self.checkin1.id, self.checkin2.id])
]
count_expected = self.reservation.adults - len(
self.reservation.checkin_partner_ids
)
self.assertEqual(
self.reservation.checkin_partner_pending_count,
count_expected,
"Checkin_partner_pending_count isn't correct",
)
@freeze_time("1982-11-01")
def test_reservation_action_checkout_fail(self):
self.create_common_scenario()
host = self.env["res.partner"].create(
{
"name": "Miguel",
"phone": "654667733",
"email": "miguel@example.com",
}
)
reservation = self.env["pms.reservation"].create(
{
"checkin": fields.date.today(),
"checkout": fields.date.today() + datetime.timedelta(days=1),
"partner_id": host.id,
"allowed_checkout": True,
"pms_property_id": self.property.id,
}
)
with self.assertRaises(UserError):
reservation.action_reservation_checkout()