def test_adding_new_payment_is_reflected_on_pending_payments_list(
facade: PaymentsFacade, connection: Connection,
event_bus: Mock) -> None:
customer_id = 1
assert facade.get_pending_payments(customer_id) == []
payment_uuid = uuid.uuid4()
amount = get_dollars("15.00")
description = "Example"
# with patch.object(event_bus, "post") as post_mock:
facade.start_new_payment(payment_uuid, customer_id, amount, description)
(row, ) = connection.execute(payments.select()).fetchall()
assert dict(row) == {
"uuid": str(payment_uuid),
"customer_id": customer_id,
"amount": int(amount.amount * 100),
"currency": amount.currency.iso_code,
"status": PaymentStatus.NEW.value,
"description": description,
"charge_id": None,
}
pending_payments = facade.get_pending_payments(customer_id)
assert pending_payments == [
PaymentDto(payment_uuid, amount, description, PaymentStatus.NEW.value)
]
event_bus.post.assert_called_once_with(
PaymentStarted(payment_uuid, customer_id))
def test_capture(facade: PaymentsFacade, inserted_payment: dict,
connection: Connection, event_bus: Mock) -> None:
payment_uuid = uuid.UUID(inserted_payment["uuid"])
with patch.object(ApiConsumer, "capture") as capture_mock:
facade.capture(payment_uuid, inserted_payment["customer_id"])
capture_mock.assert_called_once_with(inserted_payment["charge_id"])
assert get_payment(
connection,
inserted_payment["uuid"]).status == PaymentStatus.CAPTURED.value
event_bus.post.assert_called_once_with(
PaymentCaptured(payment_uuid, inserted_payment["customer_id"]))
def test_unsuccessful_charge(facade: PaymentsFacade, inserted_payment: dict,
connection: Connection, event_bus: Mock) -> None:
payment_uuid = uuid.UUID(inserted_payment["uuid"])
with patch.object(ApiConsumer, "charge",
side_effect=PaymentFailedError) as charge_mock:
facade.charge(payment_uuid, inserted_payment["customer_id"], "token")
charge_mock.assert_called_once_with(
get_dollars(inserted_payment["amount"] / 100), "token")
assert get_payment(
connection,
inserted_payment["uuid"]).status == PaymentStatus.FAILED.value
event_bus.post.assert_called_once_with(
PaymentFailed(payment_uuid, inserted_payment["customer_id"]))
def test_successful_charge_updates_status(facade: PaymentsFacade,
inserted_payment: dict,
connection: Connection,
event_bus: Mock) -> None:
payment_uuid = uuid.UUID(inserted_payment["uuid"])
charge_id = "SOME_CHARGE_ID"
with patch.object(ApiConsumer, "charge",
return_value=charge_id) as charge_mock:
facade.charge(uuid.UUID(inserted_payment["uuid"]),
inserted_payment["customer_id"], "token")
charge_mock.assert_called_once_with(
get_dollars(inserted_payment["amount"] / 100), "token")
payment_row = get_payment(connection, inserted_payment["uuid"])
assert payment_row.status == PaymentStatus.CHARGED.value
assert payment_row.charge_id == charge_id
event_bus.post.assert_called_once_with(
PaymentCharged(payment_uuid, inserted_payment["customer_id"]))
def facade(connection: Connection, event_bus: Mock) -> PaymentsFacade:
return PaymentsFacade(PaymentsConfig("", ""), connection, event_bus)
def test_pending_payments_returns_only_new_payments(
facade: PaymentsFacade, inserted_payment: dict,
connection: Connection) -> None:
assert facade.get_pending_payments(inserted_payment["customer_id"]) == []
def facade(self, config: PaymentsConfig, connection: Connection,
event_bus: EventBus) -> PaymentsFacade:
return PaymentsFacade(config, connection, event_bus)