gnd: trim verbose inline comments in test module

Author: dimitrovmaksim

gnd/src/commands/test/assertion.rs

@@ -77,13 +77,10 @@ async fn run_single_assertion(
     }
 }
 
-/// Reorder `actual` arrays to align with `expected`'s element ordering.
+/// Reorder `actual` arrays to match `expected`'s element order for cleaner diffs.
 ///
-/// When a test fails, the raw diff can be misleading if array elements appear
-/// in a different order — every line shows as changed even if only one field
-/// differs. This function reorders `actual` so that elements are paired with
-/// their closest match in `expected`, producing a diff that highlights only
-/// real value differences.
+/// Without this, out-of-order elements show every field as changed even when
+/// only one field differs.
 pub(super) fn align_for_diff(
     expected: &serde_json::Value,
     actual: &serde_json::Value,
@@ -132,12 +129,8 @@ pub(super) fn align_for_diff(
     }
 }
 
-/// Score how similar two JSON values are for use in [`align_for_diff`].
-///
-/// For objects, counts the number of fields whose values are equal in both.
-/// A matching `"id"` field is weighted heavily (+100) since it is the
-/// strongest signal that two objects represent the same entity.
-/// For all other value types, returns 1 if equal, 0 otherwise.
+/// Score JSON similarity for [`align_for_diff`].
+/// Objects: matching `"id"` = 100, other equal fields = 1. Non-objects: 0 or 1.
 fn json_similarity(a: &serde_json::Value, b: &serde_json::Value) -> usize {
     match (a, b) {
         (serde_json::Value::Object(a_obj), serde_json::Value::Object(b_obj)) => {
@@ -162,13 +155,9 @@ fn json_similarity(a: &serde_json::Value, b: &serde_json::Value) -> usize {
     }
 }
 
-/// Compare two JSON values for equality (ignoring key ordering in objects).
+/// Compare JSON values for equality, ignoring object key ordering.
 ///
-/// Also handles string-vs-number coercion: GraphQL returns `BigInt` and
-/// `BigDecimal` fields as JSON strings (e.g., `"1000000000000000000"`),
-/// but test authors may write them as JSON numbers. This function treats
-/// `String("123")` and `Number(123)` as equal when they represent the
-/// same value.
+/// Coerces string/number: `"123"` == `123` to handle GraphQL `BigInt`/`BigDecimal`.
 fn json_equal(a: &serde_json::Value, b: &serde_json::Value) -> bool {
     match (a, b) {
         (serde_json::Value::Null, serde_json::Value::Null) => true,

gnd/src/commands/test/block_stream.rs

@@ -63,21 +63,15 @@ impl BlockStreamBuilder<Chain> for StaticStreamBuilder {
     }
 }
 
-/// A `Stream` that synchronously yields pre-defined blocks one at a time.
-///
-/// Each `poll_next` call returns the next block immediately (no async waiting).
-/// When all blocks have been emitted, returns `None` to signal stream completion,
-/// which tells the indexer that sync is done.
+/// A `Stream` that yields pre-defined blocks synchronously.
+/// Returns `None` when all blocks are emitted, signaling sync completion.
 struct StaticStream {
     blocks: Vec<BlockWithTriggers<Chain>>,
     current_idx: usize,
 }
 
 impl StaticStream {
-    /// Create a new stream, optionally skipping past already-processed blocks.
-    ///
-    /// `skip_to`: If `Some(i)`, start from block `i+1` (block `i` was already processed).
-    /// If `None`, start from the beginning.
+    /// `skip_to`: if `Some(i)`, start from block `i+1` (block `i` already processed).
     fn new(blocks: Vec<BlockWithTriggers<Chain>>, skip_to: Option<usize>) -> Self {
         Self {
             blocks,

gnd/src/commands/test/eth_calls.rs

@@ -1,9 +1,7 @@
-//! Pre-populates the eth_call cache with mock responses for `gnd test`.
+//! Populates the eth_call cache with mock responses for `gnd test`.
 //!
-//! Function signatures use graph-node's convention: `name(inputs):(outputs)`
-//! e.g. `"balanceOf(address):(uint256)"`, `"getReserves():(uint112,uint112,uint32)"`.
-//! Call data is encoded using the same path as production graph-node, so cache
-//! IDs match exactly what the runtime generates.
+//! Signatures use graph-node's `name(inputs):(outputs)` convention.
+//! Encoding matches production graph-node so cache IDs align with the runtime.
 
 use super::schema::{MockEthCall, TestFile};
 use super::trigger::json_to_sol_value;
@@ -92,16 +90,8 @@ fn encode_return_value(function_sig: &str, returns: &[serde_json::Value]) -> Res
         .map_err(|e| anyhow!("Failed to encode return value: {}", e))
 }
 
-/// Convert a graph-node style function signature to alloy's expected format.
-///
-/// Graph-node uses `name(inputs):(outputs)` while alloy expects
-/// `name(inputs) returns (outputs)`.
-///
-/// Examples:
-/// - `"balanceOf(address):(uint256)"` → `"balanceOf(address) returns (uint256)"`
-/// - `"name():(string)"` → `"name() returns (string)"`
-/// - `"transfer(address,uint256)"` → `"transfer(address,uint256)"` (no change)
-/// - `"balanceOf(address) returns (uint256)"` → unchanged (already alloy format)
+/// Convert graph-node `name(inputs):(outputs)` to alloy `name(inputs) returns (outputs)`.
+/// Passes through signatures already in alloy format or without outputs.
 fn to_alloy_signature(sig: &str) -> String {
     // If it already contains "returns", assume alloy format.
     if sig.contains(" returns ") {

gnd/src/commands/test/mod.rs

@@ -112,8 +112,7 @@ pub async fn run_test(opt: TestOpt) -> Result<()> {
         return matchstick::run(&opt).await;
     }
 
-    // Build the subgraph first so the WASM and schema are available in build/.
-    // This mirrors what a user would do manually before running tests.
+    // Build the subgraph first (WASM and schema must be available in build/).
     if !opt.skip_build {
         step(Step::Generate, "Building subgraph");
         let build_opt = crate::commands::BuildOpt {

gnd/src/commands/test/noop.rs

@@ -1,10 +1,8 @@
-//! Noop/stub trait implementations for the mock `Chain`.
+//! Noop trait implementations for the mock `Chain`.
 //!
-//! These types satisfy the trait bounds required by the `Chain` constructor
-//! but are never called during normal test execution because:
-//! - Triggers are provided directly via `StaticStreamBuilder` (no scanning needed)
-//! - The real `EthereumRuntimeAdapterBuilder` is used for host functions
-//!   (ethereum.call, ethereum.getBalance, ethereum.hasCode), backed by the call cache
+//! Satisfy `Chain` constructor bounds but are never called:
+//! - Triggers come from `StaticStreamBuilder` (no scanning)
+//! - Host functions use `EthereumRuntimeAdapterBuilder` with the eth_call cache
 
 use async_trait::async_trait;
 use graph::blockchain::block_stream::{BlockRefetcher, BlockWithTriggers, FirehoseCursor};