Merge pull request #465 from AmbireTech/post-spender-leaf

elpiel · web-flow · commit a1da9ff735b3 · 2022-01-18T16:32:19.000+02:00
POST /v5/channel/:id/spender/:addr + tests
diff --git a/sentry/src/lib.rs b/sentry/src/lib.rs
@@ -29,7 +29,7 @@ use {
         campaign::{campaign_list, create_campaign, update_campaign},
         cfg::config,
         channel::{
-            channel_list, create_validator_messages, get_accounting_for_channel,
+            add_spender_leaf, channel_list, create_validator_messages, get_accounting_for_channel,
             get_all_spender_limits, get_spender_limits, last_approved,
         },
         event_aggregate::list_channel_event_aggregates,
@@ -360,6 +360,24 @@ async fn channels_router<C: Locked + 'static>(
             .await?;
 
         get_spender_limits(req, app).await
+    } else if let (Some(caps), &Method::POST) = (
+        CHANNEL_SPENDER_LEAF_AND_TOTAL_DEPOSITED.captures(&path),
+        method,
+    ) {
+        let param = RouteParams(vec![
+            caps.get(1)
+                .map_or("".to_string(), |m| m.as_str().to_string()), // channel ID
+            caps.get(2)
+                .map_or("".to_string(), |m| m.as_str().to_string()), // spender addr
+        ]);
+        req.extensions_mut().insert(param);
+        req = Chain::new()
+            .chain(AuthRequired)
+            .chain(ChannelLoad)
+            .apply(req, app)
+            .await?;
+
+        add_spender_leaf(req, app).await
     } else if let (Some(caps), &Method::GET) = (CHANNEL_ALL_SPENDER_LIMITS.captures(&path), method)
     {
         let param = RouteParams(vec![caps
diff --git a/sentry/src/routes/channel.rs b/sentry/src/routes/channel.rs
@@ -1,5 +1,5 @@
 use crate::db::{
-    accounting::{get_all_accountings_for_channel, Side},
+    accounting::{get_all_accountings_for_channel, update_accounting, Side},
     event_aggregate::{latest_approve_state_v5, latest_heartbeats, latest_new_state_v5},
     insert_channel, insert_validator_messages, list_channels,
     spendable::{fetch_spendable, get_all_spendables_for_channel, update_spendable},
@@ -310,6 +310,38 @@ pub async fn get_all_spender_limits<C: Locked + 'static>(
     Ok(success_response(serde_json::to_string(&res)?))
 }
 
+/// internally, to make the validator worker to add a spender leaf in NewState we'll just update Accounting
+pub async fn add_spender_leaf<C: Locked + 'static>(
+    req: Request<Body>,
+    app: &Application<C>,
+) -> Result<Response<Body>, ResponseError> {
+    let route_params = req
+        .extensions()
+        .get::<RouteParams>()
+        .expect("request should have route params");
+    let spender = Address::from_str(&route_params.index(1))?;
+
+    let channel = req
+        .extensions()
+        .get::<Channel>()
+        .expect("Request should have Channel")
+        .to_owned();
+
+    update_accounting(
+        app.pool.clone(),
+        channel.id(),
+        spender,
+        Side::Spender,
+        UnifiedNum::from_u64(0),
+    )
+    .await?;
+
+    // TODO: Replace with SpenderResponse
+    Ok(success_response(serde_json::to_string(&SuccessResponse {
+        success: true,
+    })?))
+}
+
 async fn get_corresponding_new_state(
     pool: &DbPool,
     logger: &Logger,
@@ -388,6 +420,7 @@ mod test {
     use adapter::primitives::Deposit;
     use hyper::StatusCode;
     use primitives::{
+        test_util::{ADVERTISER, CREATOR, GUARDIAN, PUBLISHER},
         util::tests::prep_db::{ADDRESSES, DUMMY_CAMPAIGN, IDS},
         BigNum,
     };
@@ -596,4 +629,86 @@ mod test {
             assert_eq!(expected, res.expect_err("Should return an error"));
         }
     }
+
+    #[tokio::test]
+    async fn adds_and_retrieves_spender_leaf() {
+        let app = setup_dummy_app().await;
+        let channel = DUMMY_CAMPAIGN.channel;
+
+        insert_channel(&app.pool, channel)
+            .await
+            .expect("should insert channel");
+
+        let get_accounting_request = |channel: Channel| {
+            Request::builder()
+                .extension(channel)
+                .body(Body::empty())
+                .expect("Should build Request")
+        };
+        let add_spender_request = |channel: Channel| {
+            let param = RouteParams(vec![channel.id().to_string(), CREATOR.to_string()]);
+            Request::builder()
+                .extension(channel)
+                .extension(param)
+                .body(Body::empty())
+                .expect("Should build Request")
+        };
+
+        // Calling with non existent accounting
+        let res = add_spender_leaf(add_spender_request(channel), &app)
+            .await
+            .expect("Should add");
+        assert_eq!(StatusCode::OK, res.status());
+
+        let res = get_accounting_for_channel(get_accounting_request(channel), &app)
+            .await
+            .expect("should get response");
+        assert_eq!(StatusCode::OK, res.status());
+
+        let accounting_response = res_to_accounting_response(res).await;
+
+        // Making sure a new entry has been created
+        assert_eq!(
+            accounting_response.balances.spenders.get(&CREATOR),
+            Some(&UnifiedNum::from_u64(0)),
+        );
+
+        let mut balances = Balances::<CheckedState>::new();
+        balances
+            .spend(*CREATOR, *PUBLISHER, UnifiedNum::from_u64(200))
+            .expect("should not overflow");
+        balances
+            .spend(*ADVERTISER, *GUARDIAN, UnifiedNum::from_u64(100))
+            .expect("Should not overflow");
+        spend_amount(app.pool.clone(), channel.id(), balances.clone())
+            .await
+            .expect("should spend");
+
+        let res = get_accounting_for_channel(get_accounting_request(channel), &app)
+            .await
+            .expect("should get response");
+        assert_eq!(StatusCode::OK, res.status());
+
+        let accounting_response = res_to_accounting_response(res).await;
+
+        assert_eq!(balances, accounting_response.balances);
+
+        let res = add_spender_leaf(add_spender_request(channel), &app)
+            .await
+            .expect("Should add");
+        assert_eq!(StatusCode::OK, res.status());
+
+        let res = get_accounting_for_channel(get_accounting_request(channel), &app)
+            .await
+            .expect("should get response");
+        assert_eq!(StatusCode::OK, res.status());
+
+        let accounting_response = res_to_accounting_response(res).await;
+
+        // Balances shouldn't change
+        assert_eq!(
+            accounting_response.balances.spenders.get(&CREATOR),
+            balances.spenders.get(&CREATOR),
+        );
+    }
 }
