Testing a hook or an adapter alone

/// Messages for tests: it keeps each message it is asked to send, with the customer's name.
#[derive(Default)]
struct TestMessages {
    told: RefCell<Vec<String>>,
}

impl Messages for TestMessages {
    fn tell(&self, customer: &str, message: &str) {
        self.told
            .borrow_mut()
            .push(format!("{customer}: {message}"));
    }
}

/// Refunds for tests: it keeps each refund it is asked to give, with its receipt.
#[derive(Default)]
struct TestRefunds {
    given: RefCell<Vec<String>>,
}

impl Refunds for TestRefunds {
    fn refund(&self, receipt: &str, amount: i64) {
        self.given
            .borrow_mut()
            .push(format!("{amount} back on {receipt}"));
    }
}

/// What `before_retrying` decides for Ned's shipping, which failed with this reason after he
/// paid 50, and the refunds it asked for.
fn before_retrying(
    reason: Option<Reason>,
) -> Result<(Option<FailWorkflow>, Vec<String>), Error> {
    let refunds = TestRefunds::default();
    let mut contributions = Contributions::default();
    let decision = FailedShipping.before_retrying(
        reason,
        "R-A-12".to_owned(),
        50,
        &refunds,
        contributions.contributor(),
    )?;
    Ok((decision, refunds.given.into_inner()))
}

#[test]
fn failed_shipping_refunds_and_gives_up_a_shipping_that_failed_with_over_parcel_limit()
-> Result<(), Error> {
    let (decision, refunds) = before_retrying(Some(Reason::from("over-parcel-limit")))?;
    assert_eq!(
        decision.fails_workflow().map(Reason::code),
        Some("no-carrier-can-take-it")
    );
    assert_eq!(refunds, ["50 back on R-A-12"]);
    Ok(())
}

#[test]
fn failed_shipping_lets_a_shipping_that_failed_with_too_heavy_be_retried() -> Result<(), Error>
{
    let (decision, refunds) = before_retrying(Some(Reason::from("too-heavy")))?;
    assert!(decision.keeps_default());
    assert!(refunds.is_empty());
    Ok(())
}

#[test]
fn failed_shipping_lets_a_shipping_that_ended_in_an_error_be_retried() -> Result<(), Error> {
    let (decision, refunds) = before_retrying(None)?;
    assert!(decision.keeps_default());
    assert!(refunds.is_empty());
    Ok(())
}

#[test]
fn failed_shipping_refunds_a_shipping_the_executor_gave_up() -> Result<(), Error> {
    let refunds = TestRefunds::default();
    let mut contributions = Contributions::default();
    let decision = FailedShipping.given_up(
        StepFailureCause::RetriesExhausted,
        "R-A-14".to_owned(),
        20,
        &refunds,
        contributions.contributor(),
    )?;
    assert!(decision.keeps_default());
    assert_eq!(refunds.given.into_inner(), ["20 back on R-A-14"]);
    assert_eq!(
        contributions.read::<String>("refund"),
        Read::Present("20 back on R-A-14: retries exhausted".to_owned())
    );
    Ok(())
}

#[test]
fn audit_writes_the_step_the_amount_and_the_receipt() -> Result<(), Error> {
    let mut contributions = Contributions::default();
    Audit.charged(
        step_name!("charge"),
        30,
        "R-A-1".to_owned(),
        contributions.contributor(),
    )?;
    assert_eq!(
        contributions.read::<String>("audit"),
        Read::Present("charge took 30, receipt R-A-1".to_owned())
    );
    Ok(())
}

#[test]
fn notify_gives_a_gift_cards_code_and_says_sorry_for_a_failed_order() -> Result<(), Error> {
    let messages = TestMessages::default();
    Notify.succeeded(
        "Kim".to_owned(),
        "A-9".to_owned(),
        None,
        Some("G-A-9".to_owned()),
        &messages,
    )?;
    Notify.failed("Lee".to_owned(), "A-10".to_owned(), &messages)?;
    assert_eq!(
        messages.told.into_inner(),
        [
            "Kim: Order A-9 is paid: your gift card's code is G-A-9.",
            "Lee: Sorry, order A-10 could not be completed.",
        ]
    );
    Ok(())
}

/// Gil's parcel, as the warehouse describes it.
fn gils_parcel() -> Parcel {
    Parcel {
        weight: 60,
        size: [120, 80, 60],
    }
}

#[test]
fn parcels_gives_the_shipping_the_parcels_weight() -> Result<(), Error> {
    let weight = Orders { channel: "email" }.parcels("weight", gils_parcel())?;
    assert_eq!(
        weight
            .as_ref()
            .and_then(|value| value.downcast_ref::<i64>()),
        Some(&60)
    );
    Ok(())
}

#[test]
fn parcels_leaves_every_other_input_to_the_data_bag() -> Result<(), Error> {
    let receipt = Orders { channel: "email" }.parcels("receipt", gils_parcel())?;
    assert!(receipt.is_none());
    Ok(())
}