def test_is_compare():
"""Ensures that `is` operator works correctly."""
some_container = Some(1)
assert Nothing.bind(lambda state: state) is Nothing
assert some_container.rescue(lambda: Some('fix')) is some_container
assert some_container is not Some(1)
def test_success(service: ShowPricesForm, house, reservation, user, rate_plan,
room_type, room):
policy_1 = Policy(id=101, house_id=house.id, name='P1')
policy_2 = Policy(id=102, house_id=house.id, name='P2')
service._houses_repo = Mock(get=Mock(return_value=Some(house)))
service._reservations_repo = Mock(get=Mock(return_value=Some(reservation)))
service._prices_repo = Mock(select_plans=Mock(return_value=[rate_plan]))
service._roomtypes_repo = Mock(select=Mock(return_value=[room_type]))
service._rooms_repo = Mock(select=Mock(return_value=[room]))
service._policies_repo = Mock(select=Mock(
return_value=[policy_1, policy_2]))
result = service.execute(house.id, reservation.id, reservation.rooms[0].id,
user)
assert is_successful(result)
ctx = result.unwrap()
assert isinstance(ctx, ReservationPricesUpdateContext)
assert ctx.house == house
assert ctx.reservation == reservation
assert ctx.reservation_room == reservation.rooms[0]
assert ctx.rate_plans == [rate_plan]
assert ctx.room_types == [room_type]
assert ctx.rooms == [room]
assert ctx.policies == [policy_1, policy_2]
def test_success(service: UpdateRoomClose, context: Context, house, room,
reservation):
_reservation = attr.evolve(reservation, is_verified=True)
service._houses_repo = Mock(get=Mock(return_value=Some(house)))
service._rooms_repo = Mock(get=Mock(return_value=Some(room)))
service._reservations_repo = Mock(
accept=Mock(return_value=Some(_reservation)),
get=Mock(return_value=Some(reservation)),
is_room_busy=Mock(return_value=False),
save=Mock(
return_value=(Some(attr.evolve(reservation, is_verified=False)),
True)),
)
result = service.execute(
'111-222-1',
house.id,
room.id,
context.start_date,
context.end_date,
RoomCloseReasons.MAINTENANCE,
context.user,
)
assert is_successful(result), result.failure()
ctx = result.unwrap()
assert isinstance(ctx, ReservationUpdateContext)
assert ctx.reservation == _reservation
assert ctx.start_date == datetime.date.today()
assert ctx.end_date == datetime.date.today() + datetime.timedelta(days=2)
def test_equality():
"""Ensures that containers can be compared."""
assert Nothing is Nothing # noqa: WPS312
assert Nothing == _Nothing() == _Nothing(None)
assert Some(5) == Some(5)
assert hash(Some(1))
assert hash(Nothing)
def test_nonequality():
"""Ensures that containers are not compared to regular values."""
assert Nothing is not None
assert Nothing != None # noqa: E711
assert _Nothing(None) != None # noqa: E711
assert Some(5) != 5
assert Some(3) is not Some(3)
def test_success(
service: UpdateReservationPrices,
context: Context,
house,
reservation,
rate_plan,
room_type,
room,
user,
cancellation_policy,
):
_reservation = attr.evolve(reservation, price_accepted=Decimal(3600))
service._houses_repo = Mock(get=Mock(return_value=Some(house)))
service._roomtypes_repo = Mock(select=Mock(return_value=[room_type]))
service._rooms_repo = Mock(select=Mock(return_value=[room]))
service._prices_repo = Mock(get_plan=Mock(return_value=Some(rate_plan)))
service._reservations_repo = Mock(
get=Mock(return_value=Some(reservation)),
save=Mock(return_value=(Some(_reservation), True)))
service._policies_repo = Mock(get=Mock(
return_value=Some(cancellation_policy)))
result = service.execute(house.id,
reservation.id,
reservation.rooms[0].id,
rate_plan.id,
user,
prices=context.prices)
assert is_successful(result)
assert result.unwrap() == _reservation
def test_success(service: CreateRoomClose, context: Context, house, room):
reservation = Reservation(
id=111,
house_id=house.id,
connection_id=None,
source=ReservationSources.MANUAL,
channel=None,
channel_id="",
checkin=context.start_date,
checkout=context.end_date,
booked_at=timezone.now(),
status=ReservationStatuses.CLOSE,
is_verified=True,
)
service._houses_repo = Mock(get=Mock(return_value=Some(house)))
service._rooms_repo = Mock(get=Mock(return_value=Some(room)))
service._reservations_repo = Mock(
save=Mock(
return_value=(Some(attr.evolve(reservation, is_verified=False)),
True)),
accept=Mock(return_value=Some(reservation)),
is_room_busy=Mock(return_value=False),
)
result = service.execute(house.id, room.id, context.start_date,
context.end_date, RoomCloseReasons.MAINTENANCE,
context.user)
assert is_successful(result), result.failure()
assert result.unwrap() == attr.evolve(reservation, is_verified=True)
def test_bind_optional():
"""Ensures that bind_optional works correctly."""
def factory(inner_value: int) -> Optional[int]:
return inner_value if inner_value else None
assert Some(1).bind_optional(factory) == Some(1)
assert Some(0).bind_optional(factory) == Nothing
assert Nothing.bind_optional(factory) == Nothing
def test_read(args: dict):
config = MapReader(args).read
assert config("a", int) == Some(1)
assert config("b", str) == Some("B")
assert config("c", str) == Nothing
assert config("a", str) == Nothing
def test_rescue_some():
"""Ensures that rescue works for Some container."""
def factory(_) -> Maybe[int]:
return Some(10)
bound = Some(5).rescue(factory)
assert bound == Some(5)
def test_hbox_layout(self):
layout = HBoxLayout()
container = Frame(self.context, layout)
container.bounds = Bounds(5, 5, 90, 90)
child1 = Panel(self.context)
child1.preferred_size_override = Some(Dimension(20, 50))
child1.set_color(StyleKeys.Background, RGBA(1, 0, 0, 1))
container.add(child1)
child2 = Panel(self.context)
child2.preferred_size_override = Some(Dimension(15, 60))
child2.minimum_size_override = Some(Dimension(15, 60))
child2.set_color(StyleKeys.Background, RGBA(0, 1, 0, 1))
container.add(child2)
child3 = Panel(self.context)
child3.preferred_size_override = Some(Dimension(30, 40))
child3.minimum_size_override = Some(Dimension(10, 20))
child3.set_color(StyleKeys.Background, RGBA(0, 0, 1, 1))
container.add(child3)
def test(direction: BoxDirection, spacing: float, padding: Insets, align: BoxAlign):
container.bounds = Bounds(5, 5, 90, 90)
layout.spacing = spacing
layout.padding = padding
layout.align = align
self.assertEqual(True, container.layout_pending)
self.context.process()
self.assertEqual(False, container.layout_pending)
(top, right, bottom, left) = padding.tuple
prefix = f"hbox-{direction.name}-{spacing}-{top},{right},{bottom},{left}-{align.name}-"
self.assertImage(prefix + "full-size", self.context)
container.bounds = Bounds(5, 5, 45, 45)
self.assertEqual(True, container.layout_pending)
self.context.process()
self.assertEqual(False, container.layout_pending)
self.assertImage(prefix + "half-size", self.context)
for d in BoxDirection:
for s in [0, 10]:
for p in [Insets(0, 0, 0, 0), Insets(15, 20, 10, 5)]:
for a in BoxAlign:
test(d, s, p, a)
def test_on_style_change(self):
lookup = StyleLookup()
changes = []
lookup.on_style_change.subscribe(changes.append)
self.assertEqual([], changes)
lookup.set_color("color1", RGBA(1, 0, 0, 1))
lookup.set_color("color1",
RGBA(1, 0, 0,
1)) # Should ignore duplicated requests.
self.assertEqual(
[ColorChangeEvent(lookup, "color1", Some(RGBA(1, 0, 0, 1)))],
changes)
lookup.set_color("color2", RGBA(0, 1, 0, 1))
self.assertEqual(
[ColorChangeEvent(lookup, "color2", Some(RGBA(0, 1, 0, 1)))],
changes[1:])
lookup.set_color("color2", RGBA(0, 1, 1, 1))
self.assertEqual(
[ColorChangeEvent(lookup, "color2", Some(RGBA(0, 1, 1, 1)))],
changes[2:])
font = ToyFontFace("Sans")
lookup.set_font("font1", font)
self.assertEqual([FontChangeEvent(lookup, "font1", Some(font))],
changes[3:])
lookup.clear_color("color1")
lookup.clear_font("font1")
self.assertEqual([ColorChangeEvent(lookup, "color1", Nothing)],
changes[4:5])
self.assertEqual([FontChangeEvent(lookup, "font1", Nothing)],
changes[5:])
padding = Insets(5, 5, 5, 5)
lookup.set_insets("padding", padding)
self.assertEqual([InsetsChangeEvent(lookup, "padding", Some(padding))],
changes[6:])
lookup.clear_insets("padding")
self.assertEqual([InsetsChangeEvent(lookup, "padding", Nothing)],
changes[7:])
def test_success_not_changed_quotation(service: UpdateReservationInOdoo, house,
user, reservation, room_type):
api = Mock(
update_opportunity=Mock(return_value=None),
get_quotation_items=Mock(return_value=[
{
'id': 1230,
'product_id': [room_type.id, room_type.name],
'item_date': datetime.date.today().strftime(DATE_FORMAT),
'product_uom_qty': 1.0,
'price_unit': 1120.0,
},
{
'id':
1231,
'product_id': [room_type.id, room_type.name],
'item_date': (
datetime.date.today() +
datetime.timedelta(days=1)).strftime(DATE_FORMAT),
'product_uom_qty':
1.0,
'price_unit':
1120.0,
},
{
'id':
1232,
'product_id': [room_type.id, room_type.name],
'item_date': (
datetime.date.today() +
datetime.timedelta(days=2)).strftime(DATE_FORMAT),
'product_uom_qty':
1.0,
'price_unit':
1120.0,
},
]),
get_quotation=Mock(return_value=Some(Mock(id=321, state='draft'))),
unlock_quotation=Mock(return_value=None),
confirm_quotation=Mock(return_value=None),
update_quotation_items=Mock(return_value=None),
)
service._houses_repo = Mock(get=Mock(return_value=Some(house)))
service._reservations_repo = Mock(get=Mock(return_value=Some(reservation)))
service._members_repo = Mock(get_user_by_id=Mock(return_value=Some(user)))
service.get_rpc_api = Mock(return_value=api)
result = service.execute(house.id, reservation.id, user_id=user.id)
assert is_successful(result)
api.update_opportunity.assert_called_once()
api.get_quotation_items.assert_called_once()
api.get_quotation.assert_not_called()
api.unlock_quotation.assert_not_called()
api.update_quotation_items.assert_not_called()
api.confirm_quotation.assert_not_called()
def test_success_for_canceled(service: CancelReservation, house, reservation,
user):
_reservation = attr.evolve(reservation, status=ReservationStatuses.CANCEL)
service._houses_repo = Mock(get=Mock(return_value=Some(house)))
service._reservations_repo = Mock(get=Mock(
return_value=Some(_reservation)))
result = service.execute(house.id, reservation.id, user)
assert is_successful(result)
assert result.unwrap() == _reservation
def test_success(service: DeleteRoomClose, house, reservation, user):
_reservation = attr.evolve(reservation, status=ReservationStatuses.CANCEL)
service._houses_repo = Mock(get=Mock(return_value=Some(house)))
service._reservations_repo = Mock(
get=Mock(return_value=Some(reservation)),
save=Mock(return_value=(Some(_reservation), True)))
result = service.execute('111-222-1', house.id, user)
assert is_successful(result), result.failure()
assert result.unwrap() == _reservation
def test_success(service: CancelReservationInOdoo, house, reservation, user):
service._houses_repo = Mock(get=Mock(return_value=Some(house)))
service._reservations_repo = Mock(get=Mock(return_value=Some(reservation)))
service._members_repo = Mock(get_user_by_id=Mock(return_value=Some(user)))
service.get_rpc_api = Mock(
return_value=Mock(cancel_opportunity=Mock(return_value=None),
cancel_quotation=Mock(return_value=None)))
result = service.execute(house.id, reservation.id, user_id=user.id)
assert is_successful(result)
assert result.unwrap()
def test_success(service: UpdateReservationGuest, house, reservation):
_reservation = attr.evolve(reservation, guest_name='John')
service._houses_repo = Mock(get=Mock(return_value=Some(house)))
service._reservations_repo = Mock(
get=Mock(return_value=Some(reservation)),
save=Mock(return_value=(Some(_reservation), True)))
result = service.execute(house.id, reservation.id, 11, 'name',
'John Smith')
assert is_successful(result)
assert result.unwrap() == _reservation
def test_success(
service: CalculateNewReservation,
context: Context,
house,
room_type,
rate_plan,
rate,
user,
last_min_discount,
availability_discount,
los_discount,
):
rates = [rate, attr.evolve(rate, id=101, occupancy=3)]
period = [
context.start_date, context.start_date + datetime.timedelta(days=1)
]
service._houses_repo = Mock(get=Mock(return_value=Some(house)))
service._roomtypes_repo = Mock(get=Mock(return_value=Some(room_type)))
service._prices_repo = Mock(
get_plan=Mock(return_value=Some(rate_plan)),
select_rates=Mock(return_value=rates),
select_prices=Mock(return_value={
period[0]: Decimal(100),
period[1]: Decimal(110)
}),
select_restrictions=Mock(return_value={
period[0]: Decimal(80),
period[1]: Decimal(80)
}),
)
service._discounts_repo = Mock(select=Mock(
return_value={
DiscountTypes.LAST_MINUTE: [last_min_discount],
DiscountTypes.AVAILABILITY: [availability_discount],
DiscountTypes.LOS: [los_discount],
}))
service._occupancy_repo = Mock(get=Mock(return_value={
period[0]: 3,
period[1]: 1
}))
result = service.execute(house.id, room_type.id, rate_plan.id,
context.start_date, context.end_date, 2, user)
assert is_successful(result), result.failure()
ctx = result.unwrap()
assert isinstance(ctx, ReservationCalcContext)
assert ctx.room_type == room_type
assert ctx.rate_plan == rate_plan
assert ctx.rates == rates
assert ctx.rate == rate
assert ctx.prices == {period[0]: Decimal(80), period[1]: Decimal("93.50")}
def test_success_for_accepted(service: AcceptHoldReservation, house,
reservation, user):
_reservation = attr.evolve(reservation, status=ReservationStatuses.NEW)
service._houses_repo = Mock(get=Mock(return_value=Some(house)))
service._reservations_repo = Mock(get=Mock(
return_value=Some(_reservation)))
service.get_rpc_api = Mock(return_value=Mock(confirm_quotation=Mock(
return_value=None)))
result = service.execute(house.id, reservation.id, user)
assert is_successful(result)
assert result.unwrap()
def test_items(self):
layout = BorderLayout()
container = Frame(self.context, layout)
child1 = Panel(self.context)
child2 = Panel(self.context)
child3 = Panel(self.context)
child4 = Panel(self.context)
child5 = Panel(self.context)
container.add(child1)
container.add(child2, Border.Left)
container.add(child3, Border.Top, Insets(2, 2, 2, 2))
container.add(child4, Border.Right, padding=Insets(5, 5, 5, 5))
container.add(child5,
region=Border.Bottom,
padding=Insets(10, 10, 10, 10))
def assert_item(item: BorderItem, child: Component, border: Border,
padding: Insets) -> None:
self.assertEqual(child, item.component.unwrap())
self.assertEqual(border, item.border)
self.assertEqual(padding, item.padding)
assert_item(layout.areas[Border.Center], child1, Border.Center,
Insets(0, 0, 0, 0))
assert_item(layout.areas[Border.Top], child3, Border.Top,
Insets(2, 2, 2, 2))
assert_item(layout.areas[Border.Right], child4, Border.Right,
Insets(5, 5, 5, 5))
assert_item(layout.areas[Border.Bottom], child5, Border.Bottom,
Insets(10, 10, 10, 10))
assert_item(layout.areas[Border.Left], child2, Border.Left,
Insets(0, 0, 0, 0))
container.add(child1, Border.Right)
container.remove(child2)
container.remove(child3)
assert_item(layout.areas[Border.Right], child1, Border.Right,
Insets(0, 0, 0, 0))
# noinspection PyTypeChecker
children = Fold.collect_all(
map(lambda a: a.component, layout.areas.values()), Some(
())).unwrap()
self.assertEqual({child5, child1}, set(children))
self.assertEqual(Nothing, layout.areas[Border.Top].component)
self.assertEqual(Some(child1), layout.areas[Border.Right].component)
self.assertEqual(Some(child5), layout.areas[Border.Bottom].component)
self.assertEqual(Nothing, layout.areas[Border.Left].component)
def test_success(service: AcceptReservationChanges, house, reservation, user):
_reservation = attr.evolve(reservation, is_verified=True)
service._houses_repo = Mock(get=Mock(return_value=Some(house)))
service._reservations_repo = Mock(
get=Mock(return_value=Some(reservation)),
accept=Mock(return_value=Some(_reservation)))
result = service.execute(house.id,
reservation.id,
user,
price_ids=[311, 313])
assert is_successful(result)
assert result.unwrap() == _reservation
def test_success(service: AttachContactToReservation, context: Context, house,
reservation):
_reservation = attr.evolve(reservation,
guest_contact_id=200,
guest_contact_ids=[200])
service._houses_repo = Mock(get=Mock(return_value=Some(house)))
service._reservations_repo = Mock(
get=Mock(return_value=Some(reservation)),
save=Mock(return_value=(Some(_reservation), True)))
result = service.execute(house.id, reservation.id, 200)
assert is_successful(result)
assert result.unwrap()
def test_immutability_success():
"""Ensures that Success container is immutable."""
with pytest.raises(ImmutableStateError):
Some(0)._inner_state = 1 # noqa: WPS437
with pytest.raises(ImmutableStateError):
Some(1).missing = 2
with pytest.raises(ImmutableStateError):
del Some(0)._inner_state # type: ignore # noqa: WPS420, WPS437
with pytest.raises(AttributeError):
Some(1).missing # type: ignore # noqa: WPS428
def test_no_anchor(self):
self.context.process()
self.assertImage("no-anchor", self.context)
self.child.preferred_size_override = Some(Dimension(120, 130))
self.context.process()
self.assertImage("no-anchor-over-sized", self.context)
self.child.minimum_size_override = Some(Dimension(60, 40))
self.container.bounds = Bounds(0, 0, 50, 50)
self.context.process()
self.assertImage("no-anchor-min-size", self.context)
def test_success(service: UpdateReservationCache, house, reservation,
rate_plan, user):
service._houses_repo = Mock(get=Mock(return_value=Some(house)))
service._reservations_repo = Mock(select=Mock(return_value=[reservation]))
service._cache_repo = Mock(save=Mock(return_value=True),
delete=Mock(return_value=None))
service._prices_repo = Mock(select_plans=Mock(return_value=[rate_plan]))
service._members_repo = Mock(get_bot_user=Mock(return_value=Some(user)))
service.get_rpc_api = Mock(return_value=Mock(
select_invoices_for_order=Mock(return_value=[
Mock(id=987, amount_total=50.0, amount_residual=20.0)
])))
result = service.execute(house_id=house.id)
assert is_successful(result)
def create(self, key: str) -> Maybe[BlenderImage]:
if key is None:
raise ValueError("Argument 'key' is required.")
try:
# noinspection PyTypeChecker
return Some(BlenderImage(bpy.data.images[key]))
except KeyError:
if Path(bpy.path.abspath(key)).exists():
images = cast(BlendDataImages, bpy.data.images)
image = images.load(key, check_existing=False)
return Some(BlenderImage(image))
return Nothing
def test_validation(self):
canvas = Canvas(self.context)
canvas.validate()
self.assertEqual(True, canvas.valid)
image = self.context.toolkit.images[FixturePath]
canvas.image = Some(image)
self.assertEqual(False, canvas.valid)
canvas.validate()
self.assertEqual(True, canvas.valid)
def test_style(lookup: StyleLookup):
canvas.validate()
lookup.set_insets("NonExistentKey", Insets(10, 10, 10, 10))
self.assertEqual(True, canvas.valid)
canvas.validate()
lookup.set_insets(StyleKeys.Padding, Insets(10, 10, 10, 10))
self.assertEqual(False, canvas.valid)
test_style(self.context.look_and_feel)
test_style(canvas)
def test_select_reservation_ok(service: RegisterReservationInOdoo, context: Context, house, reservation):
service._reservations_repo = Mock(get=Mock(return_value=Some(reservation)))
context.house = house
result = service.select_reservation(context)
assert is_successful(result)
assert result.unwrap().reservation == reservation
def test_select_house_ok(service: UpdateReservationPrices, context: Context,
house):
service._houses_repo = Mock(get=Mock(return_value=Some(house)))
result = service.select_house(context)
assert is_successful(result)
assert result.unwrap().house == house
def test_select_user_ok(service: RegisterReservationInOdoo, context: Context, house, user):
service._members_repo = Mock(get_user_by_id=Mock(return_value=Some(user)))
context.house = house
result = service.select_user(context)
assert is_successful(result)
assert result.unwrap().user == user
