Refactor should handle OrdersMatched test

Author: james-toussaint

src/Modules/IexecPoco.ts

@@ -131,6 +131,7 @@ export function handleOrdersMatched(event: OrdersMatchedEvent): void {
     fetchAccount(viewedDeal.requester.toHex()).save();
     fetchAccount(viewedDeal.beneficiary.toHex()).save();
     fetchAccount(viewedDeal.callback.toHex()).save();
+
     let deal = fetchDeal(event.params.dealid.toHex());
     deal.app = viewedDeal.app.pointer.toHex();
     deal.appOwner = viewedDeal.app.owner.toHex();

test/Modules/IexecPoco.test.ts

@@ -1,99 +1,59 @@
 // SPDX-FileCopyrightText: 2024-2025 IEXEC BLOCKCHAIN TECH <[email protected]>
 // SPDX-License-Identifier: Apache-2.0
 
-import { Address, BigInt, Bytes, ethereum } from '@graphprotocol/graph-ts';
-import {
-    assert,
-    createMockedFunction,
-    describe,
-    newTypedMockEventWithParams,
-    test,
-} from 'matchstick-as/assembly/index';
+import { BigInt, ethereum } from '@graphprotocol/graph-ts';
+import { assert, describe, newTypedMockEventWithParams, test } from 'matchstick-as/assembly/index';
 import { OrdersMatched } from '../../generated/Core/IexecInterfaceToken';
 import { handleOrdersMatched } from '../../src/Modules';
+import { EventParamBuilder } from '../utils/EventParamBuilder';
+import { buildDeal, mockAddress, mockBytes32, mockViewDeal } from '../utils/mock';
+import { nRLCToRLC } from '../utils/utils';
+
+const pocoAddress = mockAddress('pocoAddress');
+const dealId = mockBytes32('dealId');
+const appHash = mockBytes32('appHash');
+const datasetHash = mockBytes32('datasetHash');
+const workerpoolHash = mockBytes32('workerpoolHash');
+const requestHash = mockBytes32('requestHash');
+const timestamp = BigInt.fromI32(123456789);
+const appAddress = mockAddress('appAddress');
+const appOwner = mockAddress('appOwner');
+const appPrice = BigInt.fromI32(1);
+const datasetAddress = mockAddress('datasetAddress');
+const datasetOwner = mockAddress('datasetOwner');
+const datasetPrice = BigInt.fromI32(2);
+const workerpoolAddress = mockAddress('workerpoolAddress');
+const workerpoolOwner = mockAddress('workerpoolOwner');
+const workerpoolPrice = BigInt.fromI32(3);
+const trust = BigInt.fromI32(4);
+const category = BigInt.fromI32(5);
+const tag = mockBytes32('tag');
+const requester = mockAddress('requester');
+const beneficiary = mockAddress('beneficiary');
+const callback = mockAddress('callback');
+const params = 'params';
+const startTime = BigInt.fromI32(6);
+const botFirst = BigInt.fromI32(7);
+const botSize = BigInt.fromI32(8);
+const workerStake = BigInt.fromI32(9);
+const schedulerRewardRatio = BigInt.fromI32(10);
+const sponsor = mockAddress('sponsor');
 
 describe('IexecPoco', () => {
     test('Should handle OrdersMatched', () => {
-        let pocoProxyAddress = Address.fromString('0x89205A3A3b2A69De6Dbf7f01ED13B2108B2c43e7');
-        const dealId = Bytes.fromHexString(
-            '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef',
-        );
-        const appHash = dealId;
-        const datasetHash = dealId;
-        const workerpoolHash = dealId;
-        const requestHash = dealId;
-        const sponsor = Address.fromString('0xabcdef1234567890abcdef1234567890abcdef12');
-        const timestamp = BigInt.fromI32(123456789);
-        const assetAddress = Address.fromString('0x90cBa2Bbb19ecc291A12066Fd8329D65FA1f1947');
-        const assetOwner = Address.fromString('0x90cBa2Bbb19ecc291A12066Fd8329D65FA1f1947');
-        const assetPrice = 100;
-        const uint256 = 200;
-        const bytes32 = dealId; // change it
-        const address = assetAddress; // change it
-        const string = 'a string';
-        createMockedFunction(
-            pocoProxyAddress,
-            'viewDeal',
-            'viewDeal(bytes32):(((address,address,uint256),(address,address,uint256),(address,address,uint256),uint256,uint256,bytes32,address,address,address,string,uint256,uint256,uint256,uint256,uint256,address))',
-        )
-            .withArgs([ethereum.Value.fromFixedBytes(dealId)])
-            .returns([
-                ethereum.Value.fromTuple(
-                    changetype<ethereum.Tuple>([
-                        ethereum.Value.fromTuple(
-                            // app
-                            changetype<ethereum.Tuple>([
-                                ethereum.Value.fromAddress(assetAddress),
-                                ethereum.Value.fromAddress(assetOwner),
-                                ethereum.Value.fromI32(assetPrice),
-                            ]),
-                        ),
-                        ethereum.Value.fromTuple(
-                            // dataset
-                            changetype<ethereum.Tuple>([
-                                ethereum.Value.fromAddress(assetAddress),
-                                ethereum.Value.fromAddress(assetOwner),
-                                ethereum.Value.fromI32(assetPrice),
-                            ]),
-                        ),
-                        ethereum.Value.fromTuple(
-                            // workerpool
-                            changetype<ethereum.Tuple>([
-                                ethereum.Value.fromAddress(assetAddress),
-                                ethereum.Value.fromAddress(assetOwner),
-                                ethereum.Value.fromI32(assetPrice),
-                            ]),
-                        ),
-                        ethereum.Value.fromI32(uint256), // trust
-                        ethereum.Value.fromI32(uint256), // category
-                        ethereum.Value.fromFixedBytes(bytes32), // tag
-                        ethereum.Value.fromAddress(address), // requester
-                        ethereum.Value.fromAddress(address), // beneficiary
-                        ethereum.Value.fromAddress(address), // callback
-                        ethereum.Value.fromString(string), // params
-                        ethereum.Value.fromI32(uint256), // startTime
-                        ethereum.Value.fromI32(uint256), // botFirst
-                        ethereum.Value.fromI32(uint256), // botSize
-                        ethereum.Value.fromI32(uint256), // workerStake
-                        ethereum.Value.fromI32(uint256), // schedulerRewardRatio
-                        ethereum.Value.fromAddress(sponsor), // sponsor
-                    ]),
-                ),
-            ]);
-
+        mockViewDeal(pocoAddress, dealId).returns([buildDefaultDeal()]);
         // Create the mock event
-        let mockEvent = newTypedMockEventWithParams<OrdersMatched>([
-            new ethereum.EventParam('dealid', ethereum.Value.fromFixedBytes(dealId)),
-            new ethereum.EventParam('appHash', ethereum.Value.fromFixedBytes(appHash)),
-            new ethereum.EventParam('datasetHash', ethereum.Value.fromFixedBytes(datasetHash)),
-            new ethereum.EventParam(
-                'workerpoolHash',
-                ethereum.Value.fromFixedBytes(workerpoolHash),
-            ),
-            new ethereum.EventParam('requestHash', ethereum.Value.fromFixedBytes(requestHash)),
-        ]);
+        let mockEvent = newTypedMockEventWithParams<OrdersMatched>(
+            EventParamBuilder.init()
+                .bytes('dealid', dealId)
+                .bytes('appHash', appHash)
+                .bytes('datasetHash', datasetHash)
+                .bytes('workerpoolHash', workerpoolHash)
+                .bytes('requestHash', requestHash)
+                .build(),
+        );
         mockEvent.block.timestamp = timestamp;
-        mockEvent.address = pocoProxyAddress;
+        mockEvent.address = pocoAddress;
 
         // Call the handler
         handleOrdersMatched(mockEvent);
@@ -106,13 +66,77 @@ describe('IexecPoco', () => {
 
         assert.fieldEquals('OrdersMatched', entityId, 'deal', dealId.toHex());
         assert.fieldEquals('OrdersMatched', entityId, 'timestamp', timestamp.toString());
+        // Check deal
+        assert.fieldEquals('Deal', dealId.toHex(), 'app', appAddress.toHex());
+        assert.fieldEquals('Deal', dealId.toHex(), 'appOwner', appOwner.toHex());
+        assert.fieldEquals('Deal', dealId.toHex(), 'appPrice', nRLCToRLC(appPrice).toString());
+        assert.fieldEquals('Deal', dealId.toHex(), 'dataset', datasetAddress.toHex());
+        assert.fieldEquals('Deal', dealId.toHex(), 'datasetOwner', datasetOwner.toHex());
+        assert.fieldEquals(
+            'Deal',
+            dealId.toHex(),
+            'datasetPrice',
+            nRLCToRLC(datasetPrice).toString(),
+        );
+        assert.fieldEquals('Deal', dealId.toHex(), 'workerpool', workerpoolAddress.toHex());
+        assert.fieldEquals('Deal', dealId.toHex(), 'workerpoolOwner', workerpoolOwner.toHex());
+        assert.fieldEquals(
+            'Deal',
+            dealId.toHex(),
+            'workerpoolPrice',
+            nRLCToRLC(workerpoolPrice).toString(),
+        );
+        assert.fieldEquals('Deal', dealId.toHex(), 'trust', trust.toString());
+        assert.fieldEquals('Deal', dealId.toHex(), 'category', category.toString());
+        assert.fieldEquals('Deal', dealId.toHex(), 'tag', tag.toHex());
+        assert.fieldEquals('Deal', dealId.toHex(), 'requester', requester.toHex());
+        assert.fieldEquals('Deal', dealId.toHex(), 'beneficiary', beneficiary.toHex());
+        assert.fieldEquals('Deal', dealId.toHex(), 'callback', callback.toHex());
+        assert.fieldEquals('Deal', dealId.toHex(), 'params', params);
+        assert.fieldEquals('Deal', dealId.toHex(), 'startTime', startTime.toString());
+        assert.fieldEquals('Deal', dealId.toHex(), 'botFirst', botFirst.toString());
+        assert.fieldEquals('Deal', dealId.toHex(), 'botSize', botSize.toString());
+        assert.fieldEquals('Deal', dealId.toHex(), 'workerStake', workerStake.toString());
+        assert.fieldEquals(
+            'Deal',
+            dealId.toHex(),
+            'schedulerRewardRatio',
+            schedulerRewardRatio.toString(),
+        );
         assert.fieldEquals('Deal', dealId.toHex(), 'sponsor', sponsor.toHex());
-        // TODO: Verify others fields
+        // TODO: Check other saved entities
 
         // Assert that a transaction was logged (if applicable)
         const transactionId = mockEvent.transaction.hash.toHex();
         assert.fieldEquals('Transaction', transactionId, 'id', transactionId);
     });
 });
 
+function buildDefaultDeal(): ethereum.Value {
+    return buildDeal(
+        appAddress,
+        appOwner,
+        appPrice,
+        datasetAddress,
+        datasetOwner,
+        datasetPrice,
+        workerpoolAddress,
+        workerpoolOwner,
+        workerpoolPrice,
+        trust,
+        category,
+        tag,
+        requester,
+        beneficiary,
+        callback,
+        params,
+        startTime,
+        botFirst,
+        botSize,
+        workerStake,
+        schedulerRewardRatio,
+        sponsor,
+    );
+}
+
 export { OrdersMatched };

test/utils/EventParamBuilder.ts

@@ -0,0 +1,36 @@
+// SPDX-FileCopyrightText: 2025 IEXEC BLOCKCHAIN TECH <[email protected]>
+// SPDX-License-Identifier: Apache-2.0
+
+import { Address, BigInt, Bytes, ethereum } from '@graphprotocol/graph-ts';
+
+export class EventParamBuilder {
+    private params: ethereum.EventParam[] = new Array<ethereum.EventParam>();
+
+    static init(): EventParamBuilder {
+        return new EventParamBuilder();
+    }
+
+    address(key: string, value: Address): EventParamBuilder {
+        this.params.push(new ethereum.EventParam(key, ethereum.Value.fromAddress(value)));
+        return this;
+    }
+
+    bytes(key: string, value: Bytes): EventParamBuilder {
+        this.params.push(new ethereum.EventParam(key, ethereum.Value.fromBytes(value)));
+        return this;
+    }
+
+    bigInt(key: string, value: BigInt): EventParamBuilder {
+        this.params.push(new ethereum.EventParam(key, ethereum.Value.fromUnsignedBigInt(value)));
+        return this;
+    }
+
+    string(key: string, value: string): EventParamBuilder {
+        this.params.push(new ethereum.EventParam(key, ethereum.Value.fromString(value)));
+        return this;
+    }
+
+    build(): ethereum.EventParam[] {
+        return this.params;
+    }
+}

test/utils/mock.ts

@@ -0,0 +1,88 @@
+// SPDX-FileCopyrightText: 2025 IEXEC BLOCKCHAIN TECH <[email protected]>
+// SPDX-License-Identifier: Apache-2.0
+
+import { Address, BigInt, ByteArray, Bytes, crypto, ethereum } from '@graphprotocol/graph-ts';
+import { createMockedFunction, MockedFunction } from 'matchstick-as';
+
+export function mockBytes32(input: string): Bytes {
+    return Bytes.fromHexString(crypto.keccak256(ByteArray.fromUTF8(input)).toHex());
+}
+
+export function mockAddress(input: string): Address {
+    return Address.fromString(mockBytes32(input).toHex().slice(0, 42));
+}
+
+export function mockViewDeal(pocoProxyAddress: Address, dealId: Bytes): MockedFunction {
+    return createMockedFunction(
+        pocoProxyAddress,
+        'viewDeal',
+        'viewDeal(bytes32):(((address,address,uint256),(address,address,uint256),(address,address,uint256),uint256,uint256,bytes32,address,address,address,string,uint256,uint256,uint256,uint256,uint256,address))',
+    ).withArgs([ethereum.Value.fromFixedBytes(dealId)]);
+}
+
+export function buildDeal(
+    appAddress: Address,
+    appOwner: Address,
+    appPrice: BigInt,
+    datasetAddress: Address,
+    datasetOwner: Address,
+    datasetPrice: BigInt,
+    workerpoolAddress: Address,
+    workerpoolOwner: Address,
+    workerpoolPrice: BigInt,
+    trust: BigInt,
+    category: BigInt,
+    tag: Bytes,
+    requester: Address,
+    beneficiary: Address,
+    callback: Address,
+    params: string,
+    startTime: BigInt,
+    botFirst: BigInt,
+    botSize: BigInt,
+    workerStake: BigInt,
+    schedulerRewardRatio: BigInt,
+    sponsor: Address,
+): ethereum.Value {
+    return ethereum.Value.fromTuple(
+        changetype<ethereum.Tuple>([
+            ethereum.Value.fromTuple(
+                // app
+                changetype<ethereum.Tuple>([
+                    ethereum.Value.fromAddress(appAddress),
+                    ethereum.Value.fromAddress(appOwner),
+                    ethereum.Value.fromI32(appPrice.toI32()),
+                ]),
+            ),
+            ethereum.Value.fromTuple(
+                // dataset
+                changetype<ethereum.Tuple>([
+                    ethereum.Value.fromAddress(datasetAddress),
+                    ethereum.Value.fromAddress(datasetOwner),
+                    ethereum.Value.fromI32(datasetPrice.toI32()),
+                ]),
+            ),
+            ethereum.Value.fromTuple(
+                // workerpool
+                changetype<ethereum.Tuple>([
+                    ethereum.Value.fromAddress(workerpoolAddress),
+                    ethereum.Value.fromAddress(workerpoolOwner),
+                    ethereum.Value.fromI32(workerpoolPrice.toI32()),
+                ]),
+            ),
+            ethereum.Value.fromI32(trust.toI32()),
+            ethereum.Value.fromI32(category.toI32()),
+            ethereum.Value.fromFixedBytes(tag),
+            ethereum.Value.fromAddress(requester),
+            ethereum.Value.fromAddress(beneficiary),
+            ethereum.Value.fromAddress(callback),
+            ethereum.Value.fromString(params),
+            ethereum.Value.fromI32(startTime.toI32()),
+            ethereum.Value.fromI32(botFirst.toI32()),
+            ethereum.Value.fromI32(botSize.toI32()),
+            ethereum.Value.fromI32(workerStake.toI32()),
+            ethereum.Value.fromI32(schedulerRewardRatio.toI32()),
+            ethereum.Value.fromAddress(sponsor),
+        ]),
+    );
+}

test/utils/utils.ts

@@ -0,0 +1,9 @@
+// SPDX-FileCopyrightText: 2025 IEXEC BLOCKCHAIN TECH <[email protected]>
+// SPDX-License-Identifier: Apache-2.0
+
+import { BigDecimal, BigInt } from '@graphprotocol/graph-ts';
+
+export function nRLCToRLC(value: BigInt): BigDecimal {
+    let divisor = BigDecimal.fromString('1000000000');
+    return value.divDecimal(divisor);
+}