fix: 🐛 cleanup all skipped tests

Author: prashantasdeveloper

envs/7.0.0.env

@@ -1,5 +1,5 @@
 CHAIN_IMAGE=polymeshassociation/polymesh:latest-develop-debian
-SUBQUERY_INDEXER_IMAGE=polymeshassociation/polymesh-subquery:v18.0.2-alpha.3
+SUBQUERY_INDEXER_IMAGE=polymeshassociation/polymesh-subquery:v18.0.2-alpha.4
 
 SUBQUERY_QUERY_IMAGE=onfinality/subql-query:v2.11.0
 REST_IMAGE=polymeshassociation/polymesh-rest-api:v7.0.0-alpha.5

src/__tests__/rest/compliance/fungible/tradeWithCompliance.ts

@@ -9,6 +9,7 @@ import { ProcessMode, TxBase } from '~/rest/common';
 import { blockedIdentityRequirements, complianceRequirementsParams } from '~/rest/compliance';
 import { Identity } from '~/rest/identities/interfaces';
 import { fungibleInstructionParams, venueParams } from '~/rest/settlements/params';
+import { awaitMiddlewareSyncedForRestApi } from '~/util';
 
 const handles = ['issuer', 'blocked', 'investor'];
 let factory: TestFactory;
@@ -189,6 +190,9 @@ describe('Compliance Requirements for Fungible Assets', () => {
     expect(blockedReceiverInstruction).toEqual(
       assertTagPresent(expect, 'settlement.addAndAffirmWithMediators')
     );
+
+    await awaitMiddlewareSyncedForRestApi(investorInstruction, restClient);
+    await awaitMiddlewareSyncedForRestApi(blockedReceiverInstruction, restClient);
   });
 
   it('should be able to call affirm on instruction for both receivers', async () => {
@@ -249,8 +253,7 @@ describe('Compliance Requirements for Fungible Assets', () => {
     );
   });
 
-  // Failing due to historical settlements
-  it.skip('should have affirmed the instruction for investor', async () => {
+  it('should have affirmed the instruction for investor', async () => {
     const instruction = await restClient.settlements.getInstruction(investorInstructionId);
 
     expect(instruction).toEqual(
@@ -260,8 +263,7 @@ describe('Compliance Requirements for Fungible Assets', () => {
     );
   });
 
-  // Failing due to historical settlements
-  it.skip('should have failed the instruction for blocked did', async () => {
+  it('should have failed the instruction for blocked did', async () => {
     const instruction = await restClient.settlements.getInstruction(blockedInstructionId);
 
     expect(instruction).toEqual(

src/__tests__/rest/portfolios/transfers.ts

@@ -7,7 +7,7 @@ import { createAssetParams } from '~/rest/assets/params';
 import { ProcessMode, TxBase } from '~/rest/common';
 import { Identity } from '~/rest/identities/interfaces';
 import { moveAssetParams, portfolioParams, setCustodianParams } from '~/rest/portfolios';
-import { randomNonce } from '~/util';
+import { awaitMiddlewareSyncedForRestApi, randomNonce } from '~/util';
 
 const handles = ['issuer', 'custodian'];
 let factory: TestFactory;
@@ -128,6 +128,8 @@ describe('Portfolio Asset Transfers', () => {
 
     expect(result).toEqual(assertTagPresent(expect, 'portfolio.movePortfolioFunds'));
 
+    await awaitMiddlewareSyncedForRestApi(result, restClient);
+
     const portfolio = await restClient.portfolios.getPortfolio(issuer.did, custodyPortfolioId);
 
     expect(portfolio).toEqual(
@@ -148,23 +150,40 @@ describe('Portfolio Asset Transfers', () => {
     );
   });
 
-  // TODO: this throws an internal server error "Error: Error in middleware V2 query: more than one row returned by a subquery used as an expression"
-  it.skip("should have created transaction history for the asset's transfer", async () => {
+  it("should have created transaction history for the asset's transfer", async () => {
     const result = await restClient.portfolios.getTransactionHistory(issuer.did, '0');
 
     expect(result.results).toEqual(
       expect.arrayContaining([
         expect.objectContaining({
-          asset: assetId,
-          amount: '1000',
-          from: custodyPortfolioId,
-          to: '0',
+          legs: [
+            expect.objectContaining({
+              asset: assetId,
+              amount: '1000',
+              from: {
+                did: issuer.did,
+              },
+              to: {
+                did: issuer.did,
+                id: '1',
+              },
+            }),
+          ],
         }),
         expect.objectContaining({
-          asset: assetId,
-          amount: '1000',
-          from: '0',
-          to: custodyPortfolioId,
+          legs: [
+            expect.objectContaining({
+              asset: assetId,
+              amount: '1000',
+              from: {
+                did: issuer.did,
+                id: '1',
+              },
+              to: {
+                did: issuer.did,
+              },
+            }),
+          ],
         }),
       ])
     );

src/__tests__/sdk/identities/claims.ts

@@ -1,7 +1,9 @@
 import { Polymesh } from '@polymeshassociation/polymesh-sdk';
+import { FungibleAsset } from '@polymeshassociation/polymesh-sdk/types';
 
 import { TestFactory } from '~/helpers';
 import { Identity } from '~/rest/identities';
+import { createAsset } from '~/sdk/assets/createAsset';
 import { manageClaims } from '~/sdk/identities/claims';
 
 let factory: TestFactory;
@@ -10,19 +12,21 @@ const handles = ['claimTarget'];
 describe('manageClaims', () => {
   let sdk: Polymesh;
   let targetIdentity: Identity;
+  let asset: FungibleAsset;
 
   beforeAll(async () => {
     factory = await TestFactory.create({ handles });
     targetIdentity = factory.getSignerIdentity(handles[0]);
     sdk = factory.polymeshSdk;
+
+    asset = await createAsset(sdk, {});
   });
 
   afterAll(async () => {
     await factory.close();
   });
 
-  // TODO, this case can be flakey
-  it.skip('should execute manageClaims without errors', async () => {
-    await expect(manageClaims(sdk, targetIdentity.did)).resolves.not.toThrow();
+  it('should execute manageClaims without errors', async () => {
+    await expect(manageClaims(sdk, targetIdentity.did, asset.id)).resolves.not.toThrow();
   });
 });

src/sdk/identities/claims.ts

@@ -12,7 +12,11 @@ import assert from 'node:assert';
     - Get claims targeting a given Identity
     - Get claims issued by given Identity
 */
-export const manageClaims = async (sdk: Polymesh, targetDid: string): Promise<void> => {
+export const manageClaims = async (
+  sdk: Polymesh,
+  targetDid: string,
+  assetId: string
+): Promise<void> => {
   const identity = await sdk.getSigningIdentity();
   assert(identity);
 
@@ -27,8 +31,8 @@ export const manageClaims = async (sdk: Polymesh, targetDid: string): Promise<vo
           claim: {
             type: ClaimType.Accredited,
             scope: {
-              type: ScopeType.Ticker,
-              value: 'TICKER',
+              type: ScopeType.Asset,
+              value: assetId,
             },
           },
         },

src/sdk/identities/portfolios.ts

@@ -54,7 +54,7 @@ export const managePortfolios = async (sdk: Polymesh, asset: FungibleAsset): Pro
   assert(transferTx.isSuccess);
 
   const customPortfolioBalanceAfter = await examplePortfolio.getAssetBalances({
-    assets: [asset.id, 'TOKEN_2', 'TOKEN_3'],
+    assets: [asset.id],
   });
 
   const [{ total: tokensInCustomPortfolio }] = customPortfolioBalanceAfter;