Working with agents

/// Works out what an order costs: its price, less its discount if it has one, given back as the
/// amount to charge. A discount takes at most half the price off.
#[derive(Step)]
struct Price {
    #[input]
    price: i64,
    #[input]
    discount: Option<i64>,
}

#[step]
impl Price {
    async fn run(self, #[contributor] mut contributor: Contributor<'_>) -> Result<Outcome, Error> {
        let discount = self.discount.unwrap_or(0).min(self.price / 2);
        contributor.contribute("amount", self.price - discount);
        Self::succeed()
    }
}

/// The shop's workflow as an agent proposes to change it: a parcel the carrier won't collect
/// is given up at once, without trying the backup carrier.
#[workflow(name = "orders", reporters = [Log, Desk], policies = [Notify])]
#[with_step(Lookup, name = "lookup", policies = [AlreadyCompleted])]
#[with_step(Price, name = "price")]
#[with_step(Charge, name = "charge", rescue = RenewCard, policies = [Audit, Outage])]
#[with_step(Ship, name = "ship", policies = [FailedShipping])]
struct Proposed;

#[role]
#[async_trait]
impl Refunds for Proposed {
    async fn refund(&self, receipt: &str, amount: i64) {
        network().await;
        println!("the bank gives {amount} back on receipt {receipt}");
    }
}

#[role]
#[async_trait]
impl Messages for Proposed {
    async fn tell(&self, customer: &str, message: &str) {
        network().await;
        println!("email to {customer}: {message}");
    }
}

#[workflow]
impl Proposed {
    /// Names each journey after its order.
    #[id_generator]
    fn order_number(&self, data: &DataBag) -> Result<String, Error> {
        Ok(data.required("order")?)
    }

    /// Gives the shipping the weight of the order's parcel.
    #[input_adapter(steps = ["ship"])]
    fn parcels(
        &self,
        #[key] key: &str,
        #[from_workflow] parcel: Parcel,
    ) -> Result<Option<AnyValue>, Error> {
        if key != "weight" {
            return Self::from_data_bag();
        }
        Self::supply(parcel.weight)
    }

    /// The order book, which has the orders completed before today.
    #[provider(key = "order_book")]
    fn ledger(&self) -> Result<Provided<dyn OrderBook>, Error> {
        Ok(provide!(Ledger {
            completed: vec!["A-13"],
        }))
    }

    /// The bank, as the payment client of the journey.
    #[provider(key = "payments")]
    fn bank(&self) -> Result<Provided<dyn Payments>, Error> {
        Ok(provide!(Bank { this_year: 2026 }))
    }

    /// The main carrier.
    #[provider(key = "carrier", per_attempt)]
    fn carriers(&self) -> Result<Provided<dyn Carrier>, Error> {
        Ok(provide!(MainCarrier))
    }
}

/// What the shop knows about an order of 30 with a parcel of this weight.
fn order_of(order: &str, weight: i64) -> NewOrder {
    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,
    }
}

/// 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(order_of(order, weight))
        .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())
}

/// Runs the same order as `path_of`, through the proposed workflow.
async fn proposed_path_of(
    order: &str,
    weight: i64,
    bank: TestBank,
    carrier: TestCarrier,
) -> Result<Vec<String>, Error> {
    let recorder = RecordingReporter::default();
    let instance = Proposed::builder()
        .initial_data(order_of(order, weight))
        .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!(Proposed).run(instance).await?;
    Ok(recorder.path())
}

#[tokio::test]
async fn the_proposed_flow_keeps_two_approved_paths_and_changes_two() -> Result<(), Error> {
    let kept = [
        ("A-1", 2, TestBank::Charges, TestCarrier::CollectsAll),
        ("A-3", 2, TestBank::IsDown, TestCarrier::CollectsAll),
    ];
    for (order, weight, bank, carrier) in kept {
        assert_eq!(
            proposed_path_of(order, weight, bank, carrier).await?,
            path_of(order, weight, bank, carrier).await?
        );
    }
    assert_eq!(
        proposed_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: failure",
            "journey failed at ship: over-parcel-limit",
        ]
    );
    assert_eq!(
        proposed_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 given up: failure",
            "journey failed at ship: too-heavy",
        ]
    );
    Ok(())
}