lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

receipt_listing_economics.rs (5629B)


      1 use super::*;
      2 
      3 #[tokio::test]
      4 async fn monetary_listings_sign_install_deliver_and_reopen_without_repricing_or_new_issuance() {
      5     let mut relay = Relay::new().await;
      6     let ready = Ready::new(&relay, StartMode::Online, PublicSigner::new(), true).await;
      7     let mut expected = Vec::new();
      8     for (id, price, contents, expected_price) in [
      9         (
     10             240,
     11             json!({"type":"fixed","rate":{"currency":"CAD","minor":"325","exponent":2},
     12             "basis":"2","discount_bps":1000,"tiers":[{"from":"10","rate":{"currency":"CAD","minor":"299","exponent":2}}]}),
     13             json!({"type":"fixed","quantity":{"amount":"0.5","unit":"kg"}}),
     14             Some("3.25"),
     15         ),
     16         (
     17             241,
     18             json!({"type":"variable_weight","measurement_unit":"kg","minimum_per_sale_unit":"0.8",
     19             "maximum_per_sale_unit":"1.2","rate":{"currency":"CAD","minor":"325","exponent":2},
     20             "basis":"1","maximum_per_sale_unit_total":{"currency":"CAD","minor":"400","exponent":2}}),
     21             json!({"type":"estimated","quantity":{"amount":"1","unit":"kg"}}),
     22             None,
     23         ),
     24     ] {
     25         let mut wire = serde_json::to_value(input(id)).unwrap();
     26         wire["summary"] = json!("Native carrot offering");
     27         wire["profile"]["media"] = json!([{"url":"https://media.fixture.invalid/carrot",
     28             "sha256":"ab".repeat(32),"mime":"image/jpeg","alt":"Carrot 🥕"},
     29             {"url":"ipfs://declared-object","sha256":"00".repeat(32),
     30             "mime":"application/octet-stream","alt":""}]);
     31         wire["profile"]["options"][0]["price"] = price;
     32         wire["profile"]["options"][0]["unit"]["contents"] = contents;
     33         wire["profile"]["options"][0]["supply"] = json!({"type":"estimated","amount":"10",
     34             "window":{"start":"1793480400","end":"1793487600","timezone":"America/Toronto"}});
     35         let captured = PublishInput::parse(&serde_json::to_vec(&wire).unwrap()).unwrap();
     36         let deadline = now() + 120;
     37         let receipt = ready
     38             .client
     39             .listings()
     40             .publish(ready.context(id, deadline), captured.clone())
     41             .await
     42             .unwrap();
     43         assert_eq!(
     44             receipt.business_installation(),
     45             BusinessInstallation::Installed
     46         );
     47         assert_eq!(receipt.issuance(), Issuance::Obtained);
     48         assert_eq!(receipt.delivery(), Delivery::Observed);
     49         let listing = receipt.business_result().unwrap().clone();
     50         assert_eq!(listing.terms(), captured.terms());
     51         let raw = tokio::time::timeout(Duration::from_secs(5), relay.events.recv())
     52             .await
     53             .unwrap()
     54             .unwrap();
     55         let independent = nostr::Event::from_json(&raw).unwrap();
     56         independent.verify().unwrap();
     57         assert_eq!(independent.kind.as_u16(), 30402);
     58         assert_eq!(independent.id.as_bytes(), listing.revision().as_bytes());
     59         let prices: Vec<_> = independent
     60             .tags
     61             .iter()
     62             .filter(|tag| tag.as_slice()[0] == "price")
     63             .collect();
     64         match expected_price {
     65             Some(amount) => {
     66                 assert_eq!(prices.len(), 1);
     67                 assert_eq!(prices[0].as_slice(), ["price", amount, "CAD"]);
     68                 assert_eq!(independent.tags.len(), 9);
     69             }
     70             None => assert!(prices.is_empty()),
     71         }
     72         let profile_tag = independent
     73             .tags
     74             .iter()
     75             .find(|tag| tag.as_slice()[0] == "radroots:listing")
     76             .unwrap();
     77         let actual: serde_json::Value = serde_json::from_str(&profile_tag.as_slice()[1]).unwrap();
     78         assert_eq!(actual, wire["profile"]);
     79         assert_eq!(listing.terms().media().len(), 2);
     80         let replay = ready
     81             .client
     82             .listings()
     83             .publish(ready.context(id, deadline), captured)
     84             .await
     85             .unwrap();
     86         assert_eq!(
     87             replay.operation_checkpoint(),
     88             receipt.operation_checkpoint()
     89         );
     90         expected.push((
     91             id,
     92             listing,
     93             receipt.command_digest(),
     94             receipt.operation_checkpoint(),
     95         ));
     96     }
     97     assert_eq!(ready.signer.calls.load(Ordering::SeqCst), 2);
     98     assert_eq!(ready.signer.private_calls.load(Ordering::SeqCst), 0);
     99     assert_eq!(relay.requests.load(Ordering::SeqCst), 0);
    100     assert_eq!(relay.count.load(Ordering::SeqCst), 2);
    101     ready.client.close().await.unwrap();
    102     let store = ready.fixture.reopen(ready.input.clone()).await;
    103     let (client, scope) = open(
    104         &ready.fixture,
    105         &store,
    106         &relay,
    107         "cache-monetary-reopen",
    108         ready.signer.clone(),
    109         (&ready.input, &ready.proof),
    110         StartMode::Online,
    111     )
    112     .await;
    113     for (id, listing, digest, checkpoint) in expected {
    114         let retained = client
    115             .operations(&scope)
    116             .get(OperationId::from_bytes([id; 32]))
    117             .await
    118             .unwrap()
    119             .unwrap();
    120         assert_eq!(
    121             retained.business_result().unwrap().as_listing().unwrap(),
    122             &listing
    123         );
    124         assert_eq!(retained.operation_checkpoint(), checkpoint);
    125         let resumed = client
    126             .operations(&scope)
    127             .resume(OperationId::from_bytes([id; 32]), Some(digest))
    128             .await
    129             .unwrap();
    130         assert_eq!(resumed.operation_checkpoint(), checkpoint);
    131     }
    132     assert_eq!(ready.signer.calls.load(Ordering::SeqCst), 2);
    133     assert_eq!(relay.count.load(Ordering::SeqCst), 2);
    134     client.close().await.unwrap();
    135     stop(relay).await;
    136 }