fix: tests

Author: 0xkenj1

apps/processing/test/unit/sharedDependencies.service.spec.ts

@@ -47,6 +47,7 @@ vi.mock("@grants-stack-indexer/repository", () => ({
     KyselyTransactionManager: vi.fn(),
     KyselyPricingCache: vi.fn(),
     KyselyMetadataCache: vi.fn(),
+    KyselyLegacyProjectRepository: vi.fn(),
     InMemoryPricingCache: vi.fn(),
     InMemoryMetadataCache: vi.fn(),
 }));

packages/data-flow/test/unit/eventsProcessor.spec.ts

@@ -2,6 +2,7 @@ import { beforeEach, describe, expect, it, vi } from "vitest";
 
 import {
     AlloProcessor,
+    AlloV1ToV2ProfileMigrationProcessor,
     ProcessorDependencies,
     RegistryProcessor,
     StrategyProcessor,
@@ -22,24 +23,31 @@ vi.mock("@grants-stack-indexer/processors", () => ({
     AlloProcessor: vi.fn(),
     RegistryProcessor: vi.fn(),
     StrategyProcessor: vi.fn(),
+    AlloV1ToV2ProfileMigrationProcessor: vi.fn(),
 }));
 
 describe("EventsProcessor", () => {
     let eventsProcessor: EventsProcessor;
     let mockAlloProcessor: AlloProcessor;
     let mockRegistryProcessor: RegistryProcessor;
     let mockStrategyProcessor: StrategyProcessor;
+    let mockAlloV1ToV2ProfileMigrationProcessor: AlloV1ToV2ProfileMigrationProcessor;
     const chainId = 1 as ChainId;
     const mockDependencies = {} as ProcessorDependencies;
 
     beforeEach(() => {
         mockAlloProcessor = { process: vi.fn() } as unknown as AlloProcessor;
         mockRegistryProcessor = { process: vi.fn() } as unknown as RegistryProcessor;
         mockStrategyProcessor = { process: vi.fn() } as unknown as StrategyProcessor;
-
+        mockAlloV1ToV2ProfileMigrationProcessor = {
+            process: vi.fn(),
+        } as unknown as AlloV1ToV2ProfileMigrationProcessor;
         vi.mocked(AlloProcessor).mockImplementation(() => mockAlloProcessor);
         vi.mocked(RegistryProcessor).mockImplementation(() => mockRegistryProcessor);
         vi.mocked(StrategyProcessor).mockImplementation(() => mockStrategyProcessor);
+        vi.mocked(AlloV1ToV2ProfileMigrationProcessor).mockImplementation(
+            () => mockAlloV1ToV2ProfileMigrationProcessor,
+        );
 
         eventsProcessor = new EventsProcessor(chainId, mockDependencies);
     });
@@ -98,6 +106,32 @@ describe("EventsProcessor", () => {
         expect(result).toBe(mockChangeset);
     });
 
+    it("process AlloV1ToV2ProfileMigration events using AlloV1ToV2ProfileMigrationProcessor", async () => {
+        const v1ChainId = 1 as ChainId;
+        const v1ProjectId = "1";
+        const v2ProjectId = "2";
+        const mockChangeset: Changeset[] = [
+            {
+                type: "InsertLegacyProject",
+                args: { legacyProject: { v1ChainId, v1ProjectId, v2ProjectId } },
+            },
+        ];
+        const mockEvent = {
+            contractName: "AlloV1ToV2ProfileMigration",
+            eventName: "ProfileMigrated",
+            args: { v1ChainId, v1ProjectId, v2ProjectId },
+        } as unknown as ProcessorEvent<"AlloV1ToV2ProfileMigration", "ProfileMigrated">;
+
+        vi.spyOn(mockAlloV1ToV2ProfileMigrationProcessor, "process").mockResolvedValue(
+            mockChangeset,
+        );
+
+        const result = await eventsProcessor.processEvent(mockEvent);
+
+        expect(mockAlloV1ToV2ProfileMigrationProcessor.process).toHaveBeenCalledWith(mockEvent);
+        expect(result).toBe(mockChangeset);
+    });
+
     it("throw InvalidEvent for unknown event types", async () => {
         const mockEvent: ProcessorEvent<ContractName, AnyEvent> = {
             contractName: "Unknown" as unknown as ContractName,

packages/processors/src/processors/alloV1ToV2ProfileMigration/handlers/ProfileMigrated.ts

@@ -31,7 +31,7 @@ export class ProfileMigratedHandler
                 args: {
                     legacyProject: {
                         v1ProjectId: alloV1,
-                        v1ChainId: alloV1ChainId,
+                        v1ChainId: Number(alloV1ChainId) as ChainId,
                         v2ProjectId: alloV2,
                     },
                 },

packages/processors/test/alloV1ToV2Migration/allo/alloV1ToV2Migration.processor.spec.ts

@@ -0,0 +1,87 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import type { EvmProvider } from "@grants-stack-indexer/chain-providers";
+import type { IMetadataProvider } from "@grants-stack-indexer/metadata";
+import type { IPricingProvider } from "@grants-stack-indexer/pricing";
+import type {
+    IApplicationReadRepository,
+    IProjectReadRepository,
+    IRoundReadRepository,
+} from "@grants-stack-indexer/repository";
+import type { ChainId, ILogger, ProcessorEvent } from "@grants-stack-indexer/shared";
+
+import { UnsupportedEventException } from "../../../src/internal.js";
+import {
+    AlloV1ToV2ProfileMigrationProcessor,
+    ProfileMigratedHandler,
+} from "../../../src/processors/alloV1ToV2ProfileMigration/index.js";
+
+// Mock the handlers
+vi.mock("../../../src/processors/alloV1ToV2ProfileMigration/handlers/ProfileMigrated.ts", () => {
+    const ProfileMigratedHandler = vi.fn();
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    ProfileMigratedHandler.prototype.handle = vi.fn();
+    return {
+        ProfileMigratedHandler,
+    };
+});
+
+describe("AlloV1ToV2ProfileMigrationProcessor", () => {
+    const mockChainId = 10 as ChainId;
+    let processor: AlloV1ToV2ProfileMigrationProcessor;
+    let mockEvmProvider: EvmProvider;
+    let mockPricingProvider: IPricingProvider;
+    let mockMetadataProvider: IMetadataProvider;
+    let mockRoundRepository: IRoundReadRepository;
+    const logger: ILogger = {
+        debug: vi.fn(),
+        error: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+    };
+    beforeEach(() => {
+        mockEvmProvider = {} as EvmProvider;
+        mockPricingProvider = {} as IPricingProvider;
+        mockMetadataProvider = {} as IMetadataProvider;
+        mockRoundRepository = {} as IRoundReadRepository;
+
+        processor = new AlloV1ToV2ProfileMigrationProcessor(mockChainId, {
+            evmProvider: mockEvmProvider,
+            pricingProvider: mockPricingProvider,
+            metadataProvider: mockMetadataProvider,
+            roundRepository: mockRoundRepository,
+            projectRepository: {} as IProjectReadRepository,
+            applicationRepository: {} as IApplicationReadRepository,
+            logger,
+        });
+
+        // Reset mocks before each test
+        vi.clearAllMocks();
+    });
+
+    it("call ProfileMigratedHandler for PoolCreated event", async () => {
+        const mockEvent: ProcessorEvent<"AlloV1ToV2ProfileMigration", "ProfileMigrated"> = {
+            eventName: "ProfileMigrated",
+            // Add other necessary event properties here
+        } as ProcessorEvent<"AlloV1ToV2ProfileMigration", "ProfileMigrated">;
+
+        vi.spyOn(ProfileMigratedHandler.prototype, "handle").mockResolvedValue([]);
+
+        await processor.process(mockEvent);
+
+        expect(ProfileMigratedHandler).toHaveBeenCalledWith(
+            mockEvent,
+            mockChainId,
+            processor["dependencies"],
+        );
+        expect(ProfileMigratedHandler.prototype.handle).toHaveBeenCalled();
+    });
+
+    it("throw an error for unknown event names", async () => {
+        const mockEvent = {
+            eventName: "UnknownEvent",
+        } as unknown as ProcessorEvent<"AlloV1ToV2ProfileMigration", "ProfileMigrated">;
+
+        await expect(() => processor.process(mockEvent)).rejects.toThrow(UnsupportedEventException);
+    });
+});

packages/processors/test/alloV1ToV2Migration/allo/handlers/profileMigrated.handler.spec.ts

@@ -0,0 +1,76 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import type {
+    Bytes32String,
+    ChainId,
+    ILogger,
+    ProcessorEvent,
+    TimestampMs,
+} from "@grants-stack-indexer/shared";
+
+import { ProfileMigratedHandler } from "../../../../src/processors/alloV1ToV2ProfileMigration/index.js";
+
+function createMockEvent(
+    overrides: Partial<ProcessorEvent<"AlloV1ToV2ProfileMigration", "ProfileMigrated">> = {},
+): ProcessorEvent<"AlloV1ToV2ProfileMigration", "ProfileMigrated"> {
+    return {
+        blockNumber: 116385567,
+        blockTimestamp: 1708369911 as TimestampMs,
+        chainId: 10 as ChainId,
+        contractName: "AlloV1ToV2ProfileMigration",
+        eventName: "ProfileMigrated",
+        logIndex: 123,
+        srcAddress: "0x1133eA7Af70876e64665ecD07C0A0476d09465a1",
+        params: {
+            alloV1ChainId: "10",
+            alloV1: "0x1133eA7Af70876e64665ecD07C0A0476d09465a1" as Bytes32String,
+            alloV2: "0x1133eA7Af70876e64665ecD07C0A0476d09465a1" as Bytes32String,
+            nonce: "1",
+        },
+        transactionFields: {
+            hash: "0x6e5a7115323ac1712f7c27adff46df2216324a4ad615a8c9ce488c32a1f3a035",
+            transactionIndex: 6,
+            from: "0x95222290DD7278Aa3Ddd389Cc1E1d165CC4BAfe5Address",
+        },
+        ...overrides,
+    };
+}
+
+describe("ProfileMigratedHandler", () => {
+    let mockLogger: ILogger;
+    let handler: ProfileMigratedHandler;
+
+    const mockDependencies = (): { logger: ILogger } => ({
+        logger: mockLogger,
+    });
+
+    beforeEach(() => {
+        mockLogger = {
+            warn: vi.fn(),
+        } as unknown as ILogger;
+    });
+
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+
+    it("returns a changeset to insert a legacy project", async () => {
+        const mockEvent = createMockEvent();
+
+        handler = new ProfileMigratedHandler(mockEvent, 10 as ChainId, mockDependencies());
+
+        const result = await handler.handle();
+        expect(result).toEqual([
+            {
+                type: "InsertLegacyProject",
+                args: {
+                    legacyProject: {
+                        v1ChainId: Number(mockEvent.params.alloV1ChainId) as ChainId,
+                        v1ProjectId: mockEvent.params.alloV1,
+                        v2ProjectId: mockEvent.params.alloV2,
+                    },
+                },
+            },
+        ]);
+    });
+});

packages/shared/src/types/events/common.ts

@@ -1,6 +1,6 @@
 import { Hex } from "viem";
 
-import { Address, TimestampMs } from "../../internal.js";
+import { Address, AlloV1ToV2ProfileMigrationEventParams, TimestampMs } from "../../internal.js";
 import {
     AlloEvent,
     AlloEventParams,
@@ -48,7 +48,11 @@ export type EventParams<T extends ContractName, E extends ContractToEventName<T>
         ? E extends RegistryEvent
             ? RegistryEventParams<E>
             : never
-        : never;
+        : T extends "AlloV1ToV2ProfileMigration"
+          ? E extends AlloV1ToV2ProfileMigrationEvent
+              ? AlloV1ToV2ProfileMigrationEventParams<E>
+              : never
+          : never;
 
 /**
  * This type represents events fetched from the indexer.