Testing a step alone

/// A bank for tests: it answers every charge as the test chose, and has replaced every card
/// with one named after its holder that expires in 2029.
enum TestBank {
    Charges,
    Declines,
    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::Declines => Ok(None),
            TestBank::IsDown => Err(NetworkDown),
        }
    }

    async fn replacement(&self, card: &str) -> Option<String> {
        let (holder, _) = card.rsplit_once('-')?;
        Some(format!("{holder}-2029"))
    }
}

/// A carrier for tests: it books and collects every parcel, or its booking system is down.
enum TestCarrier {
    Works,
    IsDown,
}

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

    async fn collects(&self, _: i64) -> bool {
        true
    }
}

/// Ann's charge of 40 to her card.
fn anns_charge() -> Charge {
    Charge {
        order: "A-1".to_owned(),
        amount: 40,
        card: "ann-2028".to_owned(),
        gift_card: false,
    }
}

#[tokio::test]
async fn a_charge_the_bank_takes_gives_back_the_banks_receipt() -> Result<(), Error> {
    let mut contributions = Contributions::default();
    let outcome = anns_charge()
        .run(&TestBank::Charges, contributions.contributor())
        .await?;
    assert!(outcome.is_success());
    assert_eq!(
        contributions.read::<String>("receipt"),
        Read::Present("R-A-1".to_owned())
    );
    Ok(())
}

#[tokio::test]
async fn a_charge_the_bank_declines_fails_with_card_expired_and_no_receipt() -> Result<(), Error>
{
    let mut contributions = Contributions::default();
    let outcome = anns_charge()
        .run(&TestBank::Declines, contributions.contributor())
        .await?;
    assert_eq!(outcome.reason().map(Reason::code), Some("card-expired"));
    assert_eq!(contributions.read::<String>("receipt"), Read::Absent);
    Ok(())
}

#[tokio::test]
async fn a_charge_lets_the_error_of_a_bank_that_is_down_escape() {
    let mut contributions = Contributions::default();
    let ended = anns_charge()
        .run(&TestBank::IsDown, contributions.contributor())
        .await;
    assert!(ended.is_err());
}

#[tokio::test]
async fn renewing_an_expired_card_gives_back_the_card_that_replaced_it() -> Result<(), Error> {
    let mut contributions = Contributions::default();
    let renew = RenewCard {
        card: "jo-2024".to_owned(),
        reason: Reason::from("card-expired"),
    };
    let outcome = renew
        .run(&TestBank::Charges, contributions.contributor())
        .await?;
    assert!(outcome.is_success());
    assert_eq!(
        contributions.read::<String>("card"),
        Read::Present("jo-2029".to_owned())
    );
    Ok(())
}

#[tokio::test]
async fn a_failure_that_is_not_an_expired_card_is_not_repairable() -> Result<(), Error> {
    let mut contributions = Contributions::default();
    let renew = RenewCard {
        card: "max-2027".to_owned(),
        reason: Reason::from("nothing-to-charge"),
    };
    let outcome = renew
        .run(&TestBank::Charges, contributions.contributor())
        .await?;
    assert_eq!(outcome.reason().map(Reason::code), Some("not-repairable"));
    Ok(())
}

/// An order's shipping, for a parcel of this weight.
fn shipping(weight: i64) -> Ship {
    Ship {
        order: "A-1".to_owned(),
        weight,
        receipt: "R-A-1".to_owned(),
        gift_card: false,
    }
}

#[tokio::test]
async fn a_parcel_of_2_kg_leaves_with_its_receipt() -> Result<(), Error> {
    let mut contributions = Contributions::default();
    let mut events = StepEventReporter::default();
    let outcome = shipping(2)
        .run(
            &TestCarrier::Works,
            contributions.contributor(),
            events.async_reporter(),
        )
        .await?;
    assert!(outcome.is_success());
    assert_eq!(
        events.emitted().first().map(|event| event.message()),
        Some("the parcel leaves with receipt R-A-1")
    );
    Ok(())
}

#[tokio::test]
async fn a_parcel_of_90_kg_fails_with_over_parcel_limit_before_the_carrier_is_called()
-> Result<(), Error> {
    let mut contributions = Contributions::default();
    let mut events = StepEventReporter::default();
    let outcome = shipping(90)
        .run(
            &TestCarrier::IsDown,
            contributions.contributor(),
            events.async_reporter(),
        )
        .await?;
    assert_eq!(
        outcome.reason().map(Reason::code),
        Some("over-parcel-limit")
    );
    Ok(())
}