Testing a whole journey

/// A bank for tests: it charges every card, or its network is down.
#[derive(Clone, Copy)]
enum TestBank {
    Charges,
    IsDown,
}

#[async_trait]
impl Payments for TestBank {
    async fn charge(
        &self,
        order: &str,
        _: &str,
        _: i64,
    ) -> Result<Option<String>, NetworkDown> {
        match self {
            TestBank::Charges => Ok(Some(format!("R-{order}"))),
            TestBank::IsDown => Err(NetworkDown),
        }
    }

    async fn replacement(&self, _: &str) -> Option<String> {
        None
    }
}

/// A carrier for tests: it books every parcel, and collects every parcel or none.
#[derive(Clone, Copy)]
enum TestCarrier {
    CollectsAll,
    CollectsNone,
}

#[async_trait]
impl Carrier for TestCarrier {
    async fn book(&self, order: &str, _: i64) -> Result<String, BookingFailed> {
        Ok(format!("T-{order}"))
    }

    async fn collects(&self, _: i64) -> bool {
        matches!(self, TestCarrier::CollectsAll)
    }
}

/// Runs an order of 30 with a parcel of this weight, through the shop's real steps and
/// policies, with the test's bank and carriers in place of the shop's, and gives back its
/// journey's path.
async fn path_of(
    order: &str,
    weight: i64,
    bank: TestBank,
    carrier: TestCarrier,
) -> Result<Vec<String>, Error> {
    let recorder = RecordingReporter::default();
    let instance = Orders::builder()
        .channel("email")
        .initial_data(NewOrder {
            order: order.to_owned(),
            customer: "Ann".to_owned(),
            price: 30,
            discount: None,
            parcel: Parcel {
                weight,
                size: [20, 15, 5],
            },
            card: Some("ann-2028".to_owned()),
            gift_card: false,
        })
        .reporter(recorder.clone())
        .fake_provider::<dyn Payments>("bank", move || Ok(provide!(bank)))
        .fake_provider::<dyn Carrier>("carriers", move || Ok(provide!(carrier)))
        .create()?;
    local_executor_for!(Orders).run(instance).await?;
    Ok(recorder.path())
}

#[tokio::test]
async fn an_order_the_bank_charges_and_the_carrier_takes_is_shipped() -> Result<(), Error> {
    assert_eq!(
        path_of("A-1", 2, TestBank::Charges, TestCarrier::CollectsAll).await?,
        [
            "lookup attempt 1 succeeded",
            "price attempt 1 succeeded",
            "charge attempt 1 succeeded",
            "ship attempt 1 succeeded",
            "journey succeeded",
        ]
    );
    Ok(())
}

#[tokio::test]
async fn a_parcel_over_the_limit_is_given_up_after_its_first_attempt() -> Result<(), Error> {
    assert_eq!(
        path_of("A-2", 90, TestBank::Charges, TestCarrier::CollectsAll).await?,
        [
            "lookup attempt 1 succeeded",
            "price attempt 1 succeeded",
            "charge attempt 1 succeeded",
            "ship attempt 1 failed: over-parcel-limit",
            "ship given up: FailWorkflow from failed_shipping",
            "journey failed at ship: no-carrier-can-take-it",
        ]
    );
    Ok(())
}

#[tokio::test]
async fn a_charge_whose_bank_is_down_is_given_up_and_never_rescued() -> Result<(), Error> {
    assert_eq!(
        path_of("A-3", 2, TestBank::IsDown, TestCarrier::CollectsAll).await?,
        [
            "lookup attempt 1 succeeded",
            "price attempt 1 succeeded",
            "charge attempt 1 terminated abnormally: the payment network is down",
            "charge given up: FailWorkflow from outage",
            "journey failed at charge: payment-network-down",
        ]
    );
    Ok(())
}

#[tokio::test]
async fn a_parcel_no_carrier_collects_is_tried_once_more_then_given_up() -> Result<(), Error> {
    assert_eq!(
        path_of("A-4", 60, TestBank::Charges, TestCarrier::CollectsNone).await?,
        [
            "lookup attempt 1 succeeded",
            "price attempt 1 succeeded",
            "charge attempt 1 succeeded",
            "ship attempt 1 failed: too-heavy",
            "ship retrying",
            "ship attempt 2 failed: too-heavy",
            "ship given up: retries exhausted",
            "journey failed at ship: too-heavy",
        ]
    );
    Ok(())
}