test: e2e scenarios

packages/metadata/src/providers/cachingProxy.provider.ts

@@ -4,7 +4,7 @@ import { z } from "zod";
 import { ICache } from "@grants-stack-indexer/repository";
 import { ICacheable, ILogger } from "@grants-stack-indexer/shared";
 
-import { IMetadataProvider } from "../internal.js";
+import { IMetadataProvider, isValidCid } from "../internal.js";
 
 /**
  * A metadata provider that caches metadata lookups from the underlying provider.
@@ -26,6 +26,10 @@ export class CachingMetadataProvider implements IMetadataProvider, ICacheable {
 
     /** @inheritdoc */
     async getMetadata<T>(ipfsCid: string, validateContent?: z.ZodSchema<T>): Promise<T | null> {
+        if (ipfsCid === "" || !isValidCid(ipfsCid)) {
+            return null;
+        }
+
         let cachedMetadata: T | null | undefined = undefined;
         try {
             cachedMetadata = (await this.cache.get(ipfsCid)) as T | null;

packages/metadata/test/providers/cachingProxy.provider.spec.ts

@@ -34,7 +34,7 @@ describe("CachingMetadataProvider", () => {
     });
 
     describe("getMetadata", () => {
-        const testCid = "QmTest123";
+        const testCid = "bafkreihrjyu5tney6wia2hmkertc74nzfpsgxw2epvnxm72bxj6ifnd4ku";
         const testData = { foo: "bar" };
         const testSchema = z.object({ foo: z.string() });
 
@@ -96,5 +96,17 @@ describe("CachingMetadataProvider", () => {
             expect(result).toBeNull();
             expect(mockCache.set).toHaveBeenCalled();
         });
+
+        it("returns null when cid is empty", async () => {
+            const result = await provider.getMetadata("", testSchema);
+
+            expect(result).toBeNull();
+        });
+
+        it("returns null when cid is not valid", async () => {
+            const result = await provider.getMetadata("invalid", testSchema);
+
+            expect(result).toBeNull();
+        });
     });
 });

tests/e2e/src/mocks/envio-graphql-server.mock.ts

@@ -78,19 +78,7 @@ export class MockEnvioIndexer {
      */
     private createGraphQLHandler(): RequestHandler {
         return (req: Request, res: Response): void => {
-            const { query } = req.body as GraphQLRequest;
-
-            if (query.includes("getEventsAfterBlockNumberAndLogIndex")) {
-                const events = [...this.events];
-                this.events = [];
-                res.json({ data: { raw_events: events } });
-                return;
-            }
-
-            if (query.includes("getEvents")) {
-                res.json({ data: { raw_events: this.events } });
-                return;
-            }
+            const { query, variables } = req.body as GraphQLRequest;
 
             if (query.includes("getTotalEventsInBlock")) {
                 res.json({
@@ -104,6 +92,30 @@ export class MockEnvioIndexer {
                 return;
             }
 
+            // Extract chainId from variables if present, fallback to query string extraction
+            const chainId = variables?.chainId
+                ? Number(variables.chainId)
+                : ((): number | null => {
+                      const chainIdMatch = query.match(/chainId:\s*(\d+)/);
+                      return chainIdMatch ? parseInt(chainIdMatch[1]!, 10) : null;
+                  })();
+
+            // Filter events by chainId if specified
+            const events = chainId
+                ? [...this.events].filter((event) => event.chainId === chainId)
+                : [...this.events];
+
+            // remove filtered events from the original events array
+            this.events = this.events.filter((event) => !events.includes(event));
+
+            if (
+                query.includes("getEventsAfterBlockNumberAndLogIndex") ||
+                query.includes("getEvents")
+            ) {
+                res.json({ data: { raw_events: events } });
+                return;
+            }
+
             res.json({ data: null });
         };
     }

tests/e2e/src/utils/processing-service.ts

@@ -1,6 +1,8 @@
 import { ChildProcess, spawn } from "child_process";
 import path from "path";
 
+import { stringify } from "@grants-stack-indexer/shared";
+
 import { StartupFailed } from "../exceptions/index.js";
 import { BASE_NODE_ENV_VARS } from "./constants.js";
 
@@ -13,6 +15,13 @@ interface ProcessingServiceConfig {
     indexerAdminSecret: string;
     logLevel?: string;
     nodeEnv?: string;
+    chains?: Array<{
+        id: number;
+        name: string;
+        rpcUrls: string[];
+        fetchLimit?: number;
+        fetchDelayMs?: number;
+    }>;
 }
 
 /**
@@ -24,13 +33,19 @@ interface ProcessingServiceConfig {
  * - Process lifecycle management
  * - Configurable service parameters
  * - Startup validation
+ * - Multi-chain support
  *
  * @example
  * ```typescript
  * const config = {
  *   databaseUrl: "postgresql://...",
  *   indexerGraphQLUrl: "http://localhost:4000/v1/graphql",
- *   indexerAdminSecret: "test-secret"
+ *   indexerAdminSecret: "test-secret",
+ *   chains: [{
+ *     id: 1,
+ *     name: "mainnet",
+ *     rpcUrls: ["https://eth.llamarpc.com"]
+ *   }]
  * };
  *
  * const service = new ProcessingService(config);
@@ -41,10 +56,20 @@ interface ProcessingServiceConfig {
 export class ProcessingServiceManager {
     private process: ChildProcess | null = null;
     private readonly processingPath: string;
-    private CHAIN_ID: number = 1;
+    private readonly defaultChains = [
+        {
+            id: 1,
+            name: "mainnet",
+            rpcUrls: ["https://eth.llamarpc.com", "https://rpc.flashbots.net/fast"],
+            fetchLimit: 30,
+            fetchDelayMs: 50,
+        },
+    ];
+    private chains: ProcessingServiceConfig["chains"];
 
     constructor(private readonly config: ProcessingServiceConfig) {
         this.processingPath = path.resolve(__dirname, "../../../../apps/processing");
+        this.chains = this.config.chains ?? this.defaultChains;
     }
 
     /**
@@ -78,7 +103,7 @@ export class ProcessingServiceManager {
             DATABASE_SCHEMA: "public",
 
             // Chain Configuration
-            CHAINS: `[{"id":${this.CHAIN_ID},"name":"mainnet","rpcUrls":["https://eth.llamarpc.com","https://rpc.flashbots.net/fast"],"fetchLimit":30,"fetchDelayMs":50}]`,
+            CHAINS: stringify(this.chains),
 
             // Logging
             LOG_LEVEL: this.config.logLevel ?? "debug",
@@ -128,10 +153,16 @@ export class ProcessingServiceManager {
     private setupProcessHandlers(resolve: () => void, reject: (error: Error) => void): void {
         if (!this.process) return;
 
+        let startedChains = 0;
+        const totalChains = this.config.chains?.length ?? 1;
+
         this.process.stdout?.on("data", (data) => {
             const output = (data as Buffer).toString();
-            if (output.includes(`Starting orchestrator for chain ${this.CHAIN_ID}`)) {
-                resolve();
+            if (output.includes("Starting orchestrator for chain")) {
+                startedChains++;
+                if (startedChains === totalChains) {
+                    resolve();
+                }
             }
         });
 

tests/e2e/src/utils/test-helper.ts

@@ -6,6 +6,17 @@ import type { GlobalTestState } from "./test-environment.js";
 import { DatabaseManager } from "./database-manager.js";
 import { ProcessingServiceManager } from "./processing-service.js";
 
+/**
+ * Configuration for test chains
+ */
+export interface TestChainConfig {
+    id: number;
+    name: string;
+    rpcUrls: string[];
+    fetchLimit?: number;
+    fetchDelayMs?: number;
+}
+
 /**
  * TestHelper is a utility class for managing the test environment on a per-test-file scope
  * It provides methods for starting and stopping the processing service,
@@ -15,6 +26,7 @@ import { ProcessingServiceManager } from "./processing-service.js";
  * - Processing service management
  * - Database management
  * - Event management
+ * - Multi-chain support
  */
 export class TestHelper {
     private processingService: ProcessingServiceManager | null = null;
@@ -30,12 +42,14 @@ export class TestHelper {
 
     /**
      * Starts the processing service
+     * @param chains - Optional chain configurations to use
      */
-    public async startProcessingService(): Promise<void> {
+    public async startProcessingService(chains?: TestChainConfig[]): Promise<void> {
         this.processingService = new ProcessingServiceManager({
             databaseUrl: this.globalState.databaseUrl,
             indexerGraphQLUrl: `${this.globalState.envioIndexerUrl}/v1/graphql`,
             indexerAdminSecret: "secret", // for mock server it's not used, so we passed a dummy value
+            chains,
         });
         await this.processingService.start();
     }