first test for bonded slash added

jest.config.ts

@@ -0,0 +1,4 @@
+export default {
+    preset: 'ts-jest',
+    testMatch: ['**/tests/**/*.test.ts'],
+}

package.json

@@ -28,9 +28,11 @@
     "@subql/types": "1.7.3-2",
     "@zeitgeistpm/type-defs": "^1.0.0",
     "@zeroio/type-definitions": "^0.0.14",
-    "jest": "^29.3.1",
+    "jest": "^29.5.0",
     "moonbeam-types-bundle": "^2.0.8",
-    "ts-jest": "^29.0.3",
+    "ts-jest": "^29.1.0",
+    "ts-node": "^10.9.1",
+    "@types/jest": "^29.5.1",
     "typescript": "^4.1.3"
   },
   "exports": {

tests/reward.test.ts

@@ -0,0 +1,74 @@
+import { AccumulatedReward, Reward, RewardType } from '../src/types';
+import { handleRelaychainPooledStakingBondedSlash } from "../src/mappings/rewards/history/relaychain"
+import { SubstrateTestEventBuilder, mockNumber, mockAddress } from "./utils/mockFunctions"
+
+
+const MOCK_GENESIS = "0xb0a8d493285c2df73290dfb7e61f870f17b41801197a149ca93654499ea3dafe"
+const DIRECT_STAKING_TYPE = "relaychain"
+const POOLED_STAKING_TYPE = "nomination-pool"
+
+const mockBondedPools = {
+	42: {
+		unwrap : function() {
+			return {points: mockNumber(1000)}
+		}
+	}
+}
+
+// Mock the API object using Jest
+let mockAPI = {
+	queryMulti: jest.fn((data) => {return data}),
+	query: {
+		staking: {
+			payee: {
+				isStaked: true,
+			}
+		},
+		nominationPools: {
+			bondedPools: async function(poolId) {
+				return mockBondedPools[poolId]
+			},
+
+			poolMembers: {
+				entries: async function() {
+					return [
+						[
+							mockAddress("JHXFqYWQFFr5RkHVzviRiKhY7tutyGcYQb6kUyoScSir862"),
+							{
+								points: mockNumber(100)
+							}
+						]
+					]
+				}
+			}
+		}
+	},
+};
+
+describe('handlePoolBondedSlash', () => {
+	let rewardEvent
+	let poolId
+	let slashAmount
+
+	beforeAll(() => {
+		(global as any).api = mockAPI;
+		poolId = mockNumber(42)
+		slashAmount = mockNumber(1000)
+
+		rewardEvent = new SubstrateTestEventBuilder().buildEventForPoolSlashed(poolId, slashAmount)
+	});
+
+	it('Slash for account calculated correctly', async () => {
+		jest.spyOn(AccumulatedReward, "get").mockResolvedValue(undefined)
+		jest.spyOn(AccumulatedReward.prototype, "save").mockImplementation(function (this: AccumulatedReward) {
+			console.log(this)
+			return Promise.resolve()
+		})
+		jest.spyOn(Reward.prototype, "save").mockImplementation(function (this: Reward) {
+			expect(this.amount).toBe(BigInt(100))
+			return Promise.resolve()
+		})
+
+		await handleRelaychainPooledStakingBondedSlash(rewardEvent, MOCK_GENESIS, POOLED_STAKING_TYPE);
+	});
+});

tests/utils/mockFunctions.ts

@@ -0,0 +1,61 @@
+import { AnyTuple } from '@polkadot/types-codec/types';
+import { IEvent } from '@polkadot/types/types';
+import { EventRecord } from '@polkadot/types/interfaces';
+import { SubstrateBlock, SubstrateEvent, SubstrateExtrinsic } from "@subql/types";
+
+export class SubstrateTestEventBuilder<T extends AnyTuple = AnyTuple> {
+    private _event: Partial<SubstrateEvent> = {};
+
+    withExtrinsic(extrinsic: SubstrateExtrinsic): SubstrateTestEventBuilder<T> {
+        this._event.extrinsic = extrinsic;
+        return this;
+    }
+
+    withBlock(timestamp: Date = new Date(), blockNumber: number = 1): SubstrateTestEventBuilder<T> {
+        this._event.block = {
+            timestamp: timestamp,
+            block: {
+                header: {
+                    number: mockNumber(blockNumber)
+                }
+            }
+        } as SubstrateBlock
+        return this;
+    }
+
+    withEvent(eventData): SubstrateTestEventBuilder<T> {
+        this._event.event = {data: eventData, method: 'method', section: 'section'} as unknown as IEvent<AnyTuple, unknown>
+        this._event.block.events = []
+        const event = {event: {data: eventData, method: 'method', section: 'section'}} as EventRecord
+        this._event.block.events.push(event)
+        return this
+    }
+
+    build(): SubstrateEvent<T> {
+        return this._event as SubstrateEvent<T>;
+    }
+
+    buildEventForRewards(rewardAccountId, amount): SubstrateEvent<T> {
+        return this.withBlock().withEvent([rewardAccountId, amount]).build()
+    }
+
+    buildEventForPoolSlashed(poolId, amount): SubstrateEvent<T> {
+        return this.withBlock().withEvent([poolId, amount]).build()
+    }
+}
+
+
+export function mockAddress(toStringValue: string): unknown {
+    return {
+        toString: jest.fn().mockReturnValue(toStringValue),
+        toRawType: jest.fn().mockReturnValue('AccountId')
+    }
+}
+
+export function mockNumber(number: number): unknown {
+    return {
+        toString: jest.fn().mockReturnValue(number.toString()),
+        toNumber: jest.fn().mockReturnValue(number),
+        toBigInt: jest.fn().mockReturnValue(BigInt(number))
+    }
+}