test(integration-tests): fix routing in tests

Signed-off-by: Joseph Livesey <[email protected]>

Author: suchapalaver

integration-tests/src/constants.rs

@@ -5,7 +5,8 @@
 //! Constants used in the integration tests for the TAP RAV generation
 //! their value is taken from local-network .env variable
 
-pub const INDEXER_URL: &str = "http://localhost:7601";
+// Keep for backwards compatibility if needed
+// pub const INDEXER_URL: &str = "http://localhost:7601";
 
 pub const GATEWAY_API_KEY: &str = "deadbeefdeadbeefdeadbeefdeadbeef";
 pub const GATEWAY_URL: &str = "http://localhost:7700";
@@ -24,8 +25,12 @@ pub const ACCOUNT0_SECRET: &str =
     "ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80";
 pub const CHAIN_ID: u64 = 1337;
 
+// Use the test subgraph ID for TAP receipt generation testing
 pub const SUBGRAPH_ID: &str = "QmRcucmbxAXLaAZkkCR8Bdj1X7QGPLjfRmQ5H6tFhGqiHX";
 
+// Network subgraph ID - used by gateway for network information
+pub const NETWORK_SUBGRAPH_ID: &str = "Qmc2CbqucMvaS4GFvt2QUZWvRwSZ3K5ipeGvbC6UUBf616";
+
 pub const GRAPH_URL: &str = "http://localhost:8000/subgraphs/name/graph-network";
 
 pub const GRT_DECIMALS: u8 = 18;

integration-tests/src/load_test.rs

@@ -11,11 +11,11 @@ use tokio::{sync::Semaphore, task, time::Instant};
 
 use crate::{
     constants::{
-        ACCOUNT0_SECRET, CHAIN_ID, GRAPH_URL, INDEXER_URL, MAX_RECEIPT_VALUE, SUBGRAPH_ID,
-        TAP_VERIFIER_CONTRACT,
+        ACCOUNT0_SECRET, CHAIN_ID, GATEWAY_API_KEY, GATEWAY_URL, GRAPH_URL, MAX_RECEIPT_VALUE,
+        SUBGRAPH_ID, TAP_VERIFIER_CONTRACT,
     },
     utils::{
-        create_request, create_tap_receipt, create_tap_receipt_v2, encode_v2_receipt,
+        create_request_with_api_key, create_tap_receipt, create_tap_receipt_v2, encode_v2_receipt,
         find_allocation,
     },
 };
@@ -109,13 +109,14 @@ async fn create_and_send_receipts(
     )?;
 
     let receipt_json = serde_json::to_string(&receipt).unwrap();
-    let response = create_request(
+    let response = create_request_with_api_key(
         &http_client,
-        format!("{INDEXER_URL}/subgraphs/id/{SUBGRAPH_ID}").as_str(),
+        format!("{GATEWAY_URL}/api/subgraphs/id/{SUBGRAPH_ID}").as_str(),
         &receipt_json,
         &json!({
             "query": "{ _meta { block { number } } }"
         }),
+        GATEWAY_API_KEY,
     )
     .send()
     .await?;
@@ -225,13 +226,14 @@ async fn create_and_send_receipts_v2(
     )?;
 
     let receipt_encoded = encode_v2_receipt(&receipt)?;
-    let response = create_request(
+    let response = create_request_with_api_key(
         &http_client,
-        format!("{INDEXER_URL}/subgraphs/id/{SUBGRAPH_ID}").as_str(),
+        format!("{GATEWAY_URL}/api/subgraphs/id/{SUBGRAPH_ID}").as_str(),
         &receipt_encoded,
         &json!({
             "query": "{ _meta { block { number } } }"
         }),
+        GATEWAY_API_KEY,
     )
     .send()
     .await?;

integration-tests/src/main.rs

@@ -43,6 +43,9 @@ enum Commands {
 
     #[clap(name = "debug")]
     Debug,
+
+    #[clap(name = "verify")]
+    VerifyGateway,
 }
 
 #[tokio::main]
@@ -73,6 +76,10 @@ async fn main() -> Result<()> {
         Commands::Debug => {
             signature_test::test_v2_signature_recovery().await?;
         }
+        // cargo run -- verify
+        Commands::VerifyGateway => {
+            utils::verify_gateway_routing().await?;
+        }
     }
 
     Ok(())

integration-tests/src/rav_tests.rs

@@ -10,10 +10,10 @@ use thegraph_core::alloy::{primitives::Address, signers::local::PrivateKeySigner
 
 use crate::{
     constants::{
-        ACCOUNT0_SECRET, CHAIN_ID, GATEWAY_API_KEY, GATEWAY_URL, GRAPH_URL, INDEXER_URL,
-        MAX_RECEIPT_VALUE, SUBGRAPH_ID, TAP_AGENT_METRICS_URL, TAP_VERIFIER_CONTRACT,
+        ACCOUNT0_SECRET, CHAIN_ID, GATEWAY_API_KEY, GATEWAY_URL, GRAPH_URL, MAX_RECEIPT_VALUE,
+        SUBGRAPH_ID, TAP_AGENT_METRICS_URL, TAP_VERIFIER_CONTRACT,
     },
-    utils::{create_request, create_tap_receipt, find_allocation},
+    utils::{create_request_with_api_key, create_tap_receipt, find_allocation},
     MetricsChecker,
 };
 
@@ -190,13 +190,14 @@ pub async fn test_invalid_chain_id() -> Result<()> {
     )?;
 
     let receipt_json = serde_json::to_string(&receipt).unwrap();
-    let response = create_request(
+    let response = create_request_with_api_key(
         &http_client,
-        format!("{INDEXER_URL}/subgraphs/id/{SUBGRAPH_ID}").as_str(),
+        format!("{GATEWAY_URL}/api/subgraphs/id/{SUBGRAPH_ID}").as_str(),
         &receipt_json,
         &json!({
             "query": "{ _meta { block { number } } }"
         }),
+        GATEWAY_API_KEY,
     )
     .send()
     .await?;

integration-tests/src/utils.rs

@@ -19,7 +19,9 @@ use tap_graph::Receipt;
 use thegraph_core::alloy::{primitives::Address, signers::local::PrivateKeySigner};
 use thegraph_core::CollectionId;
 
-use crate::constants::{GRAPH_TALLY_COLLECTOR_CONTRACT, TEST_DATA_SERVICE};
+use crate::constants::{
+    GATEWAY_API_KEY, GATEWAY_URL, GRAPH_TALLY_COLLECTOR_CONTRACT, SUBGRAPH_ID, TEST_DATA_SERVICE,
+};
 
 pub fn create_tap_receipt(
     value: u128,
@@ -116,7 +118,8 @@ pub fn encode_v2_receipt(receipt: &Eip712SignedMessage<tap_graph::v2::Receipt>)
     Ok(base64_encoded)
 }
 
-// Function to create a configured request
+// Function to create a configured request (currently unused - kept for compatibility)
+#[allow(dead_code)]
 pub fn create_request(
     client: &reqwest::Client,
     url: &str,
@@ -126,7 +129,24 @@ pub fn create_request(
     client
         .post(url)
         .header("Content-Type", "application/json")
-        .header("Tap-Receipt", receipt_json)
+        .header("tap-receipt", receipt_json)
+        .json(query)
+        .timeout(Duration::from_secs(10))
+}
+
+// Function to create a configured request with gateway API key
+pub fn create_request_with_api_key(
+    client: &reqwest::Client,
+    url: &str,
+    receipt_json: &str,
+    query: &serde_json::Value,
+    api_key: &str,
+) -> reqwest::RequestBuilder {
+    client
+        .post(url)
+        .header("Content-Type", "application/json")
+        .header("tap-receipt", receipt_json)
+        .header("Authorization", format!("Bearer {api_key}"))
         .json(query)
         .timeout(Duration::from_secs(10))
 }
@@ -162,3 +182,69 @@ pub async fn find_allocation(http_client: Arc<Client>, url: &str) -> Result<Stri
         .map(|id| id.to_string())
         .ok_or_else(|| anyhow::anyhow!("No valid allocation ID found"))
 }
+
+pub async fn verify_gateway_routing() -> Result<()> {
+    println!("🔍 Verifying gateway routing configuration...");
+
+    let client = Arc::new(Client::new());
+
+    // Test 1: Verify gateway is responding
+    println!("📡 Testing gateway availability...");
+    let gateway_response = client
+        .get(format!("{GATEWAY_URL}/health"))
+        .timeout(Duration::from_secs(5))
+        .send()
+        .await;
+
+    match gateway_response {
+        Ok(resp) => {
+            if resp.status().is_success() {
+                println!("✅ Gateway is responding at {GATEWAY_URL}");
+            } else {
+                println!("⚠️  Gateway responded with status: {}", resp.status());
+            }
+        }
+        Err(e) => {
+            println!("❌ Gateway not reachable: {e}");
+            return Err(anyhow::anyhow!("Gateway not reachable: {}", e));
+        }
+    }
+
+    // Test 2: Try a simple GraphQL query through the gateway
+    println!("📊 Testing subgraph query routing through gateway...");
+    let query_response = client
+        .post(format!("{GATEWAY_URL}/api/subgraphs/id/{SUBGRAPH_ID}"))
+        .header("Content-Type", "application/json")
+        .header("Authorization", format!("Bearer {GATEWAY_API_KEY}"))
+        .json(&json!({
+            "query": "{ _meta { block { number } } }"
+        }))
+        .timeout(Duration::from_secs(10))
+        .send()
+        .await?;
+
+    let status = query_response.status();
+    let response_text = query_response.text().await?;
+
+    println!("📋 Gateway response status: {status}");
+    println!("📋 Gateway response body: {response_text}");
+
+    if status.is_success() {
+        println!("✅ Gateway successfully routed query to subgraph {SUBGRAPH_ID}");
+    } else if status == 404 && response_text.contains("subgraph not found") {
+        println!(
+            "❌ Gateway routing issue: Subgraph {SUBGRAPH_ID} not found in gateway's routing table"
+        );
+        println!(
+            "💡 This confirms the root cause - gateway cannot route to the specified subgraph ID"
+        );
+        return Err(anyhow::anyhow!(
+            "Gateway routing verification failed: subgraph not found"
+        ));
+    } else {
+        println!("⚠️  Unexpected gateway response: {status} - {response_text}");
+    }
+
+    println!("🎯 Gateway routing verification complete!");
+    Ok(())
+}