def test_if_in_condition_array_value():
"""Test that we can do if in statement on arrays."""
test = [
['target_value'],
[
{
'condition': 'in',
'target': [['target_value']],
'then': 'value2',
},
],
]
assert apply_if_statements(*test) == Success('value2')
def select_room_types(self, ctx: Context) -> ResultE[Context]:
try:
data = self._roomtypes_repo.select(ctx.house,
user=ctx.user,
detailed=False)
except Exception as err:
return self._error(
f"Error select Room Types for House ID={ctx.house.id}",
ctx,
self._case_errors.error,
exc=err)
ctx.room_types = {x.id: x for x in data}
return Success(ctx)
def test_if_in():
"""Test that 1 if (in) statement works."""
test = [
'target_value',
[
{
'condition': 'in',
'target': ['target_value'],
'then': 'value2',
},
],
]
assert apply_if_statements(*test) == Success('value2')
def test_if_in_condition_false():
"""Test if in condition False."""
test = [
'not_target_value',
[
{
'condition': 'in',
'target': 'target_value',
'then': 'value2',
},
],
]
assert apply_if_statements(*test) == Success('not_target_value')
async def test_inner_value(subtests):
"""Ensure that coroutine correct value is preserved for all units."""
containers = [
# We have to define these values inside the test, because
# otherwise `anyio` will `await` reused coroutines.
# And they have to be fresh. That's why we use subtests for it.
FutureResult.from_value(1),
FutureResult.from_failure(1),
FutureResult.from_io(IO(1)),
FutureResult.from_failed_io(IO(1)),
FutureResult.from_ioresult(IOSuccess(1)),
FutureResult.from_ioresult(IOFailure(1)),
FutureResult.from_result(Success(1)),
FutureResult.from_result(Failure(1)),
FutureResult.from_future(Future.from_value(1)),
FutureResult.from_failed_future(Future.from_value(1)),
FutureResult.from_typecast(Future.from_value(Success(1))),
]
for container in containers:
with subtests.test(container=container):
result_inst = await container
assert result_inst._inner_value._inner_value == 1 # noqa: WPS437
def write_changelog(self, ctx: Context) -> ResultE[Context]:
try:
self._changelog_repo.create(
ctx.user,
None,
ctx.reservation,
ChangelogActions.CREATE,
house=ctx.house,
message='Create a new Reservation',
)
except Exception as err:
Logger.warning(__name__, f"Error write changelog: {err}")
return Success(ctx)
def test_if_contains():
"""Test that 1 if (contains) statement works."""
test = [
'target_value',
[
{
'condition': 'contains',
'target': '_value',
'then': 'value2',
},
],
]
assert apply_if_statements(*test) == Success('value2')
def check_reservation(self, ctx: Context) -> ResultE[Context]:
if ctx.reservation.house_id != ctx.house.id:
return self._error(
f"Reservation ID={ctx.reservation.id} has House ID={ctx.reservation.house_id} "
f"but needs to be House ID={ctx.house.id}",
ctx,
self._case_errors.missed_reservation,
)
if ctx.reservation.status == ReservationStatuses.CLOSE:
return self._error(
f"Reservation ID={ctx.reservation.id} is Room-Close", ctx,
self._case_errors.missed_reservation)
return Success(ctx)
def test_if_is():
"""Test that 1 if (is) statement works."""
test = [
'target_value',
[
IfStatement(**{
'condition': 'is',
'target': 'target_value',
'then': 'value2',
}),
],
]
assert apply_if_statements(*test) == Success('value2')
def test_if_not():
"""Test that 1 if (not) statement works."""
test = [
'target_value',
[
{
'condition': 'not',
'target': 'not_target',
'then': 'value2',
},
],
]
assert apply_if_statements(*test) == Success('value2')
def test_if_is_condition_objects_value():
"""Test that we can do if is statement on objectss."""
test = [
{'val': 'target'},
[
IfStatement(**{
'condition': 'is',
'target': {'val': 'target'},
'then': 'value2',
}),
],
]
assert apply_if_statements(*test) == Success('value2')
def test_if_is_condition_array_value():
"""Test that we can do if is statement on arrays."""
test = [
['target_value'],
[
IfStatement(**{
'condition': 'is',
'target': ['target_value'],
'then': 'value2',
}),
],
]
assert apply_if_statements(*test) == Success('value2')
def test_if_contains_objects_in_array_value():
"""Test that we can do if contains statement on objectss."""
test = [
[{'val': 'target'}],
[
IfStatement(**{
'condition': 'contains',
'target': {'val': 'target'},
'then': 'value2',
}),
],
]
assert apply_if_statements(*test) == Success('value2')
def test_if_is_condition_false():
"""Test if condition False."""
test = [
'not_target_value',
[
IfStatement(**{
'condition': 'is',
'target': 'target_value',
'then': 'value2',
}),
],
]
assert apply_if_statements(*test) == Success('not_target_value')
def test_if_contains_condition_false():
"""Test if contains condition False."""
test = [
'not_target_value',
[
{
'condition': 'contains',
'target': 'does_not_contain',
'then': 'value2',
},
],
]
assert apply_if_statements(*test) == Success('not_target_value')
def accept_changes(self, ctx: Context) -> ResultE[Context]:
if ctx.source.is_verified:
ctx.reservation = ctx.source
return Success(ctx)
try:
data = self._reservations_repo.accept(ctx.source.id,
price_ids=ctx.price_ids)
except Exception as err:
return self._error(
f"Error accept changes for Reservation ID={ctx.source.id} in House ID={ctx.house.id}",
ctx,
self._case_errors.error,
exc=err,
)
if data == Nothing:
return self._error(
f"Error accept changes for Reservation ID={ctx.source.id} in House ID={ctx.house.id}",
ctx,
self._case_errors.error,
)
ctx.reservation = data.unwrap()
return Success(ctx)
def test_if_contains_condition_array_value():
"""Test that we can do if contains statement on arrays."""
test = [
['value', 'target'],
[
{
'condition': 'contains',
'target': 'target',
'then': 'value2',
},
],
]
assert apply_if_statements(*test) == Success('value2')
def execute(self, house_id: int, pk: int, user: '******') -> ResultE[bool]:
ctx = Context(house_id=house_id, pk=pk, user=user)
return flow(
ctx,
self.select_house,
bind_result(self.select_reservation),
bind_result(self.check_reservation),
bind_result(self.accept_reservation),
bind_result(self.confirm_quotation),
bind_result(self.write_changelog),
bind_result(lambda x: Success(True)),
)
def test_if_contains_works_with_non_strings():
"""Test that we can do if contains statement on objectss."""
test = [
123,
[
{
'condition': 'contains',
'target': '123',
'then': 'value2',
},
],
]
assert apply_if_statements(*test) == Success('value2')
def IOSuccess( # noqa: N802
inner_value: _NewValueType, ) -> IOResult[_NewValueType, Any]:
"""
Public unit function of successful :class:`~IOResult` container.
.. code:: python
>>> from returns.io import IOSuccess
>>> str(IOSuccess(1))
'<IOResult: <Success: 1>>'
"""
return _IOSuccess(Success(inner_value))
def cancel_reservation(self, ctx: Context) -> ResultE[Context]:
"""Change reservation status and save to repository"""
if ctx.source.status == ReservationStatuses.CANCEL:
# Reservation was canceled before
ctx.reservation = ctx.source
return Success(ctx)
ctx.reservation = attr.evolve(ctx.source,
status=ReservationStatuses.CANCEL)
try:
data, __ = self._reservations_repo.save(ctx.reservation)
except Exception as err:
return self._error(
f"Error save Reservation ID={ctx.reservation.id}",
ctx,
self._case_errors.error,
exc=err)
if data == Nothing:
return self._error(
f"Error save canceled Reservation ID={ctx.reservation.id}",
ctx, self._case_errors.error)
ctx.reservation = data.unwrap()
return Success(ctx)
def test_if_not_condition_array_value_with_int():
"""Test that we can do if not statement on arrays."""
test = [
[123],
[
IfStatement(**{
'condition': 'is',
'target': [123],
'then': 'value2',
}),
],
]
assert apply_if_statements(*test) == Success('value2')
def __call__(
self, creat_new_stream_command: CreateNewStreamCommand
) -> Result[Stream, FailureDetails]:
stream = StreamModel(
name=creat_new_stream_command.stream_name,
source_type=creat_new_stream_command.source_type,
source_name=creat_new_stream_command.source_name,
)
stream_project = StreamProjectModel(
stream=stream, project_id=creat_new_stream_command.project_id)
with database_session() as session:
session.add(stream_project)
session.commit()
return Success(stream.to_entity())
def test_should_return_failure_not_found_when_project_was_not_found(
get_project_details_use_case: GetProjectDetailsUseCase,
find_project_by_project_id: Mock,
) -> None:
project_id = uuid4()
project: Maybe[None] = Maybe.from_value(None)
find_project_by_project_id.return_value = Success(project)
actual = get_project_details_use_case(project_id)
find_project_by_project_id.assert_called_once()
assert isinstance(actual, Result.failure_type)
assert isinstance(actual.failure(), BusinessFailureDetails)
assert "NOT_FOUND" == actual.failure().reason
def get_lightcurve(self, payload: LightcurveServicePayload) -> dict:
detections = self.get_detections(payload)
non_detections = self.get_non_detections(payload)
light_curve_data = [detections, non_detections]
failure = get_failure_from_list(results_list=light_curve_data)
if failure:
return failure
else:
light_curve = {
"detections": light_curve_data[0].unwrap(),
"non_detections": light_curve_data[1].unwrap(),
}
return Success(light_curve)
def from_value(
cls, inner_value: _FirstType,
) -> RequiresContextResult[_FirstType, Any, NoDeps]:
"""
Creates new container with ``Success(inner_value)`` as a unit value.
.. code:: python
>>> from returns.context import RequiresContextResult
>>> from returns.result import Success
>>> assert RequiresContextResult.from_value(1)(...) == Success(1)
"""
return RequiresContextResult(lambda _: Success(inner_value))
def test_if_failed_condition_goes_to_otherwise():
"""Test that we get the then value when condition fails."""
test = [
'not_target_value',
[
{
'condition': 'is',
'target': 'target_value',
'then': 'no',
'otherwise': 'yes',
},
],
]
assert apply_if_statements(*test) == Success('yes')
def _get_object_by_id(self, object_id: str, survey_id: str):
try:
query_result = (self.db.query(psql_models.Object).filter(
psql_models.Object.oid == object_id).one_or_none())
if query_result:
return Success(query_result)
else:
return Failure(
ClientErrorException(
ObjectNotFound(object_id=object_id,
survey_id=survey_id)))
except Exception as e:
return Failure(ServerErrorException(e))
def select_reservation_room(self, ctx: Context) -> ResultE[Context]:
pk = cf.get_int_or_none(ctx.room_id) or 0
if pk <= 0:
return self._error('Missed Reservation Room ID', ctx,
self._case_errors.missed_reservation)
rooms = {x.id: x for x in ctx.reservation.rooms}
if pk not in rooms:
return self._error(
f"Unknown Room ID={pk} in Reservation ID={ctx.reservation.id} House ID={ctx.house.id}",
ctx,
self._case_errors.missed_reservation,
)
ctx.reservation_room = rooms[pk]
return Success(ctx)
def write_changelog(self, ctx: Context) -> ResultE[Context]:
try:
self._changelog_repo.create_manual(
ctx.user,
ctx.reservation,
ChangelogActions.CREATE,
{},
house=ctx.house,
message=
f"Close Room [{ctx.room.name}] for {ctx.start_date.isoformat()}..{ctx.end_date.isoformat()}",
)
except Exception as err:
Logger.warning(__name__, f"Error write changelog: {err}")
return Success(ctx)
