test: fix tests and cleanup

carlosvdr · carlosvdr · commit 3be8d309ef10 · 2025-01-24T18:03:56.000-06:00
diff --git a/crates/tap-agent/src/agent/sender_accounts_manager.rs b/crates/tap-agent/src/agent/sender_accounts_manager.rs
@@ -620,9 +620,9 @@ mod tests {
         },
         test::{
             actors::{DummyActor, MockSenderAccount, MockSenderAllocation, TestableActor},
-            create_rav, create_received_receipt, create_sender_accounts_manager, get_config,
-            get_grpc_url, store_rav, store_receipt, ALLOCATION_ID_0, ALLOCATION_ID_1, INDEXER,
-            SENDER_2, TAP_EIP712_DOMAIN_SEPARATOR,
+            create_rav, create_received_receipt, create_sender_accounts_manager, get_grpc_url,
+            get_sender_account_config, store_rav, store_receipt, ALLOCATION_ID_0, ALLOCATION_ID_1,
+            INDEXER, SENDER_2, TAP_EIP712_DOMAIN_SEPARATOR,
         },
     };
 
@@ -646,7 +646,7 @@ mod tests {
     }
 
     async fn create_state(pgpool: PgPool) -> (String, State) {
-        let config = get_config();
+        let config = get_sender_account_config();
         let senders_to_signers = vec![(SENDER.1, vec![SIGNER.1])].into_iter().collect();
         let escrow_accounts = EscrowAccounts::new(HashMap::new(), senders_to_signers);
 
diff --git a/crates/tap-agent/src/agent/sender_allocation.rs b/crates/tap-agent/src/agent/sender_allocation.rs
@@ -410,11 +410,6 @@ impl SenderAllocationState {
         self.tap_manager.remove_obsolete_receipts().await?;
 
         let signers = signers_trimmed(self.escrow_accounts.clone(), self.sender).await?;
-        println!(
-            "Allocation that will look for {:#?} and signer {:#?}",
-            self.allocation_id.encode_hex(),
-            signers
-        );
         let res = sqlx::query!(
             r#"
             SELECT
diff --git a/crates/tap-agent/src/test.rs b/crates/tap-agent/src/test.rs
@@ -70,7 +70,7 @@ const TAP_SENDER_TIMEOUT: Duration = Duration::from_secs(30);
 const RAV_REQUEST_BUFFER: Duration = Duration::from_secs(60);
 const ESCROW_POLLING_INTERVAL: Duration = Duration::from_secs(30);
 
-pub fn get_config() -> &'static SenderAccountConfig {
+pub fn get_sender_account_config() -> &'static SenderAccountConfig {
     Box::leak(Box::new(SenderAccountConfig {
         rav_request_buffer: RAV_REQUEST_BUFFER,
         max_amount_willing_to_lose_grt: TRIGGER_VALUE + 100,
@@ -186,7 +186,7 @@ pub async fn create_sender_accounts_manager(
     Arc<Notify>,
     (ActorRef<SenderAccountsManagerMessage>, JoinHandle<()>),
 ) {
-    let config = get_config();
+    let config = get_sender_account_config();
     let (_allocations_tx, allocations_rx) = watch::channel(HashMap::new());
     let escrow_subgraph = Box::leak(Box::new(
         SubgraphClient::new(
diff --git a/crates/tap-agent/tests/sender_account_manager_test.rs b/crates/tap-agent/tests/sender_account_manager_test.rs
@@ -8,15 +8,14 @@ use indexer_tap_agent::{
         sender_account::SenderAccountMessage, sender_accounts_manager::SenderAccountsManagerMessage,
     },
     test::{
-        create_received_receipt, create_sender_accounts_manager, store_receipt, ALLOCATION_ID_0,
-        TAP_EIP712_DOMAIN_SEPARATOR,
+        create_received_receipt, create_sender_accounts_manager, get_grpc_url, store_receipt,
+        ALLOCATION_ID_0,
     },
 };
 use ractor::ActorRef;
 use reqwest::Url;
 use serde_json::json;
 use sqlx::PgPool;
-use tap_aggregator::server::run_server;
 use test_assets::{flush_messages, TAP_SENDER as SENDER, TAP_SIGNER as SIGNER};
 use wiremock::{
     matchers::{body_string_contains, method},
@@ -25,27 +24,11 @@ use wiremock::{
 
 const TRIGGER_VALUE: u128 = 100;
 
+// This test should ensure the full flow starting from
+// sender account manager layer to work, up to closing an allocation
 #[sqlx::test(migrations = "../../migrations")]
-async fn test_account_manger_to_sender_allocation_closing(pgpool: PgPool) {
-    let (handle, aggregator_endpoint) = run_server(
-        0,
-        SIGNER.0.clone(),
-        vec![SIGNER.1].into_iter().collect(),
-        TAP_EIP712_DOMAIN_SEPARATOR.clone(),
-        100 * 1024,
-        100 * 1024,
-        1,
-    )
-    .await
-    .unwrap();
-
-    let aggregator_endpoint = Some(
-        Url::from_str(&("http://".to_owned() + &aggregator_endpoint.to_string()))
-            .expect("This shouldn't fail"),
-    );
-
+async fn sender_account_manager_layer_test(pgpool: PgPool) {
     let mock_network_subgraph_server: MockServer = MockServer::start().await;
-
     mock_network_subgraph_server
         .register(
             Mock::given(method("POST"))
@@ -68,19 +51,17 @@ async fn test_account_manger_to_sender_allocation_closing(pgpool: PgPool) {
 
     let mock_escrow_subgraph_server: MockServer = MockServer::start().await;
     mock_escrow_subgraph_server
-        .register(
-            Mock::given(method("POST"))
-                //.and(body_string_contains("TapTransactions"))
-                .respond_with(ResponseTemplate::new(200).set_body_json(json!({ "data": {
-                        "transactions": [],
-                    }
-                }))),
-        )
+        .register(Mock::given(method("POST")).respond_with(
+            ResponseTemplate::new(200).set_body_json(json!({ "data": {
+                    "transactions": [],
+                }
+            })),
+        ))
         .await;
 
     let (prefix, notify, (actor, join_handle)) = create_sender_accounts_manager()
         .pgpool(pgpool.clone())
-        .aggregator_endpoint(aggregator_endpoint.expect("should be valid"))
+        .aggregator_endpoint(Url::from_str(&get_grpc_url().await).unwrap())
         .network_subgraph(&mock_network_subgraph_server.uri())
         .escrow_subgraph(&mock_escrow_subgraph_server.uri())
         .call()
@@ -93,7 +74,7 @@ async fn test_account_manger_to_sender_allocation_closing(pgpool: PgPool) {
         .unwrap();
     flush_messages(&notify).await;
 
-    // // verify if create sender account
+    // verify if create sender account
     let actor_ref =
         ActorRef::<SenderAccountMessage>::where_is(format!("{}:{}", prefix.clone(), SENDER.1));
     assert!(actor_ref.is_some());
@@ -103,9 +84,7 @@ async fn test_account_manger_to_sender_allocation_closing(pgpool: PgPool) {
         .await
         .unwrap();
 
-    // Create a sender allocation inside sender account
-
-    // // we expect it to create a sender allocation
+    // we expect it to create a sender allocation
     actor_ref
         .clone()
         .unwrap()
@@ -151,9 +130,4 @@ async fn test_account_manger_to_sender_allocation_closing(pgpool: PgPool) {
     // safely stop the manager
     actor.stop_and_wait(None, None).await.unwrap();
     join_handle.await.unwrap();
-
-    // Stop the TAP aggregator server.
-    handle.abort();
-    // handle.stop().unwrap();
-    // handle.stopped().await;
 }
diff --git a/crates/tap-agent/tests/sender_account_test.rs b/crates/tap-agent/tests/sender_account_test.rs
@@ -5,15 +5,12 @@ use std::{collections::HashSet, str::FromStr, sync::atomic::AtomicU32};
 
 use indexer_tap_agent::{
     agent::sender_account::SenderAccountMessage,
-    test::{
-        create_received_receipt, create_sender_account, store_receipt, TAP_EIP712_DOMAIN_SEPARATOR,
-    },
+    test::{create_received_receipt, create_sender_account, get_grpc_url, store_receipt},
 };
 use ractor::concurrency::Duration;
 use reqwest::Url;
 use serde_json::json;
 use sqlx::PgPool;
-use tap_aggregator::server::run_server;
 use test_assets::{ALLOCATION_ID_0, TAP_SIGNER as SIGNER};
 use wiremock::{
     matchers::{body_string_contains, method},
@@ -24,51 +21,19 @@ pub static PREFIX_ID: AtomicU32 = AtomicU32::new(0);
 const TRIGGER_VALUE: u128 = 500;
 const RECEIPT_LIMIT: u64 = 10000;
 
+// This test should ensure the full flow starting from
+// sender account layer to work, up to closing an allocation
 #[sqlx::test(migrations = "../../migrations")]
-async fn test_rav_marked_as_last_closing_sender_allocation(pgpool: PgPool) {
-    // Start a TAP aggregator server.
-    let (handle, aggregator_endpoint) = run_server(
-        0,
-        SIGNER.0.clone(),
-        vec![SIGNER.1].into_iter().collect(),
-        TAP_EIP712_DOMAIN_SEPARATOR.clone(),
-        100 * 1024,
-        100 * 1024,
-        1,
-    )
-    .await
-    .unwrap();
-
+async fn sender_account_layer_test(pgpool: PgPool) {
     let mock_server = MockServer::start().await;
-
-    let no_allocations_closed_guard = mock_server
-        .register_as_scoped(
-            Mock::given(method("POST"))
-                .and(body_string_contains("ClosedAllocations"))
-                .respond_with(ResponseTemplate::new(200).set_body_json(json!({ "data": {
-                    "meta": {
-                        "block": {
-                            "number": 1,
-                            "hash": "hash",
-                            "timestamp": 1
-                        }
-                    },
-                    "allocations": []
-                }
-                }))),
-        )
-        .await;
-
     let mock_escrow_subgraph_server: MockServer = MockServer::start().await;
     mock_escrow_subgraph_server
-        .register(
-            Mock::given(method("POST"))
-                // .and(body_string_contains("TapTransactions"))
-                .respond_with(ResponseTemplate::new(200).set_body_json(json!({ "data": {
-                    "transactions": [],
-                }
-                }))),
-        )
+        .register(Mock::given(method("POST")).respond_with(
+            ResponseTemplate::new(200).set_body_json(json!({ "data": {
+                "transactions": [],
+            }
+            })),
+        ))
         .await;
 
     let receipt = create_received_receipt(&ALLOCATION_ID_0, &SIGNER.0, 1, 1, TRIGGER_VALUE - 100);
@@ -84,10 +49,7 @@ async fn test_rav_marked_as_last_closing_sender_allocation(pgpool: PgPool) {
         .escrow_subgraph_endpoint(&mock_escrow_subgraph_server.uri())
         .network_subgraph_endpoint(&mock_server.uri())
         .rav_request_receipt_limit(RECEIPT_LIMIT)
-        .aggregator_endpoint(
-            Url::from_str(&("http://".to_owned() + &aggregator_endpoint.to_string()))
-                .expect("This shouldnt fail"),
-        )
+        .aggregator_endpoint(Url::from_str(&get_grpc_url().await).unwrap())
         .call()
         .await;
 
@@ -99,7 +61,6 @@ async fn test_rav_marked_as_last_closing_sender_allocation(pgpool: PgPool) {
         .unwrap();
     notify.notified().await;
 
-    drop(no_allocations_closed_guard);
     mock_server
         .register(
             Mock::given(method("POST"))
@@ -138,8 +99,4 @@ async fn test_rav_marked_as_last_closing_sender_allocation(pgpool: PgPool) {
     .await
     .expect("Should not fail to fetch from scalar_tap_ravs");
     assert!(!rav_marked_as_last.is_empty());
-    // Stop the TAP aggregator server.
-    handle.abort();
-    // handle.stop().unwrap();
-    // handle.stopped().await;
 }
diff --git a/crates/tap-agent/tests/tap_agent_test.rs b/crates/tap-agent/tests/tap_agent_test.rs
@@ -17,13 +17,12 @@ use indexer_tap_agent::{
         },
         sender_allocation::SenderAllocationMessage,
     },
-    test::{actors::TestableActor, create_received_receipt, store_batch_receipts},
+    test::{actors::TestableActor, create_received_receipt, get_grpc_url, store_batch_receipts},
 };
 use ractor::{call, concurrency::JoinHandle, Actor, ActorRef};
 use reqwest::Url;
 use serde_json::json;
 use sqlx::PgPool;
-use tap_aggregator::server::run_server;
 use tap_core::receipt::{state::Checking, ReceiptWithState};
 use test_assets::{
     assert_while_retry, flush_messages, ALLOCATION_ID_0, ALLOCATION_ID_1, ALLOCATION_ID_2,
@@ -34,41 +33,24 @@ use thegraph_core::alloy::primitives::Address;
 use tokio::sync::{watch, Notify};
 use wiremock::{matchers::method, Mock, MockServer, ResponseTemplate};
 
-async fn mock_escrow_subgraph_empty_response() -> MockServer {
-    let mock_ecrow_subgraph_server: MockServer = MockServer::start().await;
-    let _mock_ecrow_subgraph = mock_ecrow_subgraph_server
-        .register(Mock::given(method("POST")).respond_with(
-            ResponseTemplate::new(200).set_body_json(json!({ "data": {
-                    "transactions": [],
-                }
-            })),
-        ))
-        .await;
-    mock_ecrow_subgraph_server
-}
 pub async fn start_agent(
     pgpool: PgPool,
 ) -> (
     String,
     Arc<Notify>,
     (ActorRef<SenderAccountsManagerMessage>, JoinHandle<()>),
-    JoinHandle<()>,
 ) {
-    let escrow_subgraph_mock_server = mock_escrow_subgraph_empty_response().await;
+    let escrow_subgraph_mock_server: MockServer = MockServer::start().await;
+    escrow_subgraph_mock_server
+        .register(Mock::given(method("POST")).respond_with(
+            ResponseTemplate::new(200).set_body_json(json!({ "data": {
+                    "transactions": [],
+                }
+            })),
+        ))
+        .await;
 
     let network_subgraph_mock_server = MockServer::start().await;
-    // Start a TAP aggregator server.
-    let (handle_aggregator, aggregator_endpoint) = run_server(
-        0,
-        TAP_SIGNER.0.clone(),
-        vec![TAP_SIGNER.1].into_iter().collect(),
-        TAP_EIP712_DOMAIN.clone(),
-        100 * 1024,
-        100 * 1024,
-        1,
-    )
-    .await
-    .unwrap();
 
     let (_escrow_tx, escrow_accounts) = watch::channel(EscrowAccounts::new(
         ESCROW_ACCOUNTS_BALANCES.clone(),
@@ -78,12 +60,10 @@ pub async fn start_agent(
 
     let (_allocations_tx, indexer_allocations1) = watch::channel(INDEXER_ALLOCATIONS.clone());
 
-    let sender_aggregator_endpoints: HashMap<_, _> = vec![(
-        TAP_SENDER.1,
-        Url::from_str(&format!("http://{}", aggregator_endpoint)).unwrap(),
-    )]
-    .into_iter()
-    .collect();
+    let sender_aggregator_endpoints: HashMap<_, _> =
+        vec![(TAP_SENDER.1, Url::from_str(&get_grpc_url().await).unwrap())]
+            .into_iter()
+            .collect();
 
     let http_client = reqwest::Client::new();
 
@@ -132,25 +112,18 @@ pub async fn start_agent(
         prefix: Some(prefix.clone()),
     };
 
-    // let actorr = SenderAccountsManager::spawn(None, SenderAccountsManager, args)
-    //     .await
-    //     .expect("Failed to start sender accounts manager actor.");
-    // actorr
-
     let actor = TestableActor::new(SenderAccountsManager);
     let notify = actor.notify.clone();
     (
         prefix,
         notify,
         Actor::spawn(None, actor, args).await.unwrap(),
-        handle_aggregator,
     )
 }
 
 #[sqlx::test(migrations = "../../migrations")]
 async fn test_start_tap_agent(pgpool: PgPool) {
-    let (prefix, notify, (_actor_ref, _handle), _aggregator_handle) =
-        start_agent(pgpool.clone()).await;
+    let (prefix, notify, (_actor_ref, _handle)) = start_agent(pgpool.clone()).await;
     flush_messages(&notify).await;
 
     // verify if create sender account
