test: remove redundant error case in integration tests (#679)

Refactor: Remove fake data test cases from integration tests in core-sdk package

Author: bonnie57

packages/core-sdk/test/integration/dispute.test.ts

@@ -87,22 +87,6 @@ describe("Dispute Functions", () => {
       disputeId = response.disputeId!;
     });
 
-    it("should validate all enum values defined in DisputeTargetTag", async () => {
-      const allTags = Object.values(DisputeTargetTag);
-
-      for (const tag of allTags) {
-        const tagHex: Hex = toHex(tag, { size: 32 });
-        const { allowed } = await clientA.dispute.disputeModuleClient.isWhitelistedDisputeTag({
-          tag: tagHex,
-        });
-        if (tag === DisputeTargetTag.IN_DISPUTE) {
-          expect(allowed).equal(false);
-        } else {
-          expect(allowed).equal(true);
-        }
-      }
-    });
-
     it("should raise disputes with different DisputeTargetTag enum values", async () => {
       const allTags = Object.values(DisputeTargetTag);
 
@@ -127,18 +111,6 @@ describe("Dispute Functions", () => {
       }
     });
 
-    it("should reject a dispute with an invalid tag not defined in the enum", async () => {
-      await expect(
-        clientA.dispute.raiseDispute({
-          targetIpId: ipIdB,
-          cid: await generateCID(),
-          targetTag: "INVALID_TAG" as DisputeTargetTag,
-          liveness: 2592000,
-          bond: minimumBond,
-        }),
-      ).to.be.rejectedWith("The target tag INVALID_TAG is not whitelisted");
-    });
-
     it("should be able to counter existing dispute once", async () => {
       const assertionId = await clientB.dispute.disputeIdToAssertionId(disputeId!);
       const counterEvidenceCID = await generateCID();
@@ -473,19 +445,6 @@ describe("Dispute Functions", () => {
       expect(responses[1].txHash).to.be.a("string");
     });
 
-    it("should fail when trying to tag with invalid dispute ID", async () => {
-      await expect(
-        clientA.dispute.tagIfRelatedIpInfringed({
-          infringementTags: [
-            {
-              ipId: childIpId,
-              disputeId: 999999n,
-            },
-          ],
-        }),
-      ).to.be.rejected;
-    });
-
     it("should resolve a dispute successfully when initiated by dispute initiator", async () => {
       await settleAssertion(TEST_PRIVATE_KEY, disputeId);
 

packages/core-sdk/test/integration/group.test.ts

@@ -217,28 +217,6 @@ describe("Group Functions", () => {
       expect(result.groupId).to.be.a("string");
     });
 
-    it("should fail when trying to add unregistered IP to group", async () => {
-      await expect(
-        client.groupClient.registerGroupAndAttachLicenseAndAddIps({
-          groupPool: groupPoolAddress,
-          maxAllowedRewardShare: 5,
-          ipIds: [zeroAddress], // Invalid IP address
-          licenseData: {
-            licenseTermsId,
-            licensingConfig: {
-              isSet: true,
-              mintingFee: 0n,
-              licensingHook: zeroAddress,
-              hookData: zeroAddress,
-              commercialRevShare: 0,
-              disabled: false,
-              expectMinimumGroupRewardShare: 0,
-              expectGroupRewardPool: zeroAddress,
-            },
-          },
-        }),
-      ).to.be.rejectedWith("Failed to register group and attach license and add ips");
-    });
     describe("Add IPs to Group and Remove IPs from Group", () => {
       let ipIds: Address[];
       it("should successfully add multiple IPs to group", async () => {
@@ -275,39 +253,6 @@ describe("Group Functions", () => {
         });
         expect(result.txHash).to.be.a("string");
       });
-
-      it("should fail when trying to remove IPs from a non-existent group", async () => {
-        const registerResult = await client.ipAsset.mintAndRegisterIpAssetWithPilTerms({
-          spgNftContract,
-          licenseTermsData,
-        });
-        const testIpId = registerResult.ipId!;
-
-        const nonExistentGroupId = zeroAddress;
-
-        await expect(
-          client.groupClient.removeIpsFromGroup({
-            groupIpId: nonExistentGroupId,
-            ipIds: [testIpId],
-          }),
-        ).to.be.rejectedWith("Failed to remove IPs from group");
-      });
-
-      it("should fail when trying to remove non-existent IPs from a group", async () => {
-        const groupResult = await client.groupClient.registerGroup({
-          groupPool: groupPoolAddress,
-        });
-        const testGroupId = groupResult.groupId!;
-
-        const nonExistentIpId = zeroAddress;
-
-        await expect(
-          client.groupClient.removeIpsFromGroup({
-            groupIpId: testGroupId,
-            ipIds: [nonExistentIpId],
-          }),
-        ).to.be.rejectedWith("Failed to remove IPs from group");
-      });
     });
   });
 
@@ -488,28 +433,6 @@ describe("Group Functions", () => {
       expect(result.claimedReward?.[0].amount[0]).to.equal(10n);
     });
 
-    it("should fail when trying to claim reward for a non-existent group", async () => {
-      const nonExistentGroupId = zeroAddress;
-      await expect(
-        client.groupClient.claimReward({
-          groupIpId: nonExistentGroupId,
-          currencyToken: WIP_TOKEN_ADDRESS,
-          memberIpIds: [ipId],
-        }),
-      ).to.be.rejectedWith("Failed to claim reward");
-    });
-
-    it("should fail when trying to claim reward with invalid token address", async () => {
-      const invalidTokenAddress = zeroAddress;
-      await expect(
-        client.groupClient.claimReward({
-          groupIpId: groupIpId,
-          currencyToken: invalidTokenAddress,
-          memberIpIds: [ipId],
-        }),
-      ).to.be.rejectedWith("Failed to claim reward");
-    });
-
     it("should successfully collect royalties and claim reward in one transaction", async () => {
       const ipIds: Address[] = [];
 

packages/core-sdk/test/integration/ipAccount.test.ts

@@ -68,17 +68,6 @@ describe("IPAccount Functions", () => {
       });
       expect(response.txHash).to.be.a("string");
     });
-
-    it("should fail with invalid ipId", async () => {
-      await expect(
-        client.ipAccount.execute({
-          to: permissionAddress,
-          value: 0,
-          data: data,
-          ipId: "0x0000000000000000000000000000000000000000",
-        }),
-      ).to.be.rejected;
-    });
   });
 
   describe("executeWithSig", () => {
@@ -127,19 +116,6 @@ describe("IPAccount Functions", () => {
       ).to.be.rejectedWith("IPAccount__ExpiredSignature");
     });
 
-    it("should fail with invalid signature format", async () => {
-      await expect(
-        client.ipAccount.executeWithSig({
-          to: permissionAddress,
-          data: data,
-          ipId: ipId,
-          signer: TEST_WALLET_ADDRESS,
-          deadline: VALID_DEADLINE,
-          signature: "0x1234567890abcdef" as Hex, // Invalid signature format
-        }),
-      ).to.be.rejectedWith("IPAccount__InvalidSignature");
-    });
-
     it("should fail with signature from wrong signer", async () => {
       // Generate signature with wrong signer
       const wrongSigner = "0x1234567890123456789012345678901234567890" as Address;
@@ -167,158 +143,6 @@ describe("IPAccount Functions", () => {
       ).to.be.rejectedWith("IPAccount__InvalidSignature");
     });
 
-    it("should fail with invalid ipId format", async () => {
-      const nonceResult = await client.ipAccount.getIpAccountNonce(ipId);
-
-      const { signature } = await getSignature({
-        state: nonceResult,
-        to: permissionAddress,
-        encodeData: data,
-        wallet: walletClient,
-        verifyingContract: ipId,
-        deadline: VALID_DEADLINE,
-        chainId: aeneid,
-      });
-
-      await expect(
-        client.ipAccount.executeWithSig({
-          to: permissionAddress,
-          data: data,
-          ipId: "0x123" as Address, // Invalid address format
-          signer: TEST_WALLET_ADDRESS,
-          deadline: VALID_DEADLINE,
-          signature: signature,
-        }),
-      ).to.be.rejectedWith("Invalid address: 0x123.");
-    });
-
-    it("should fail when IP account does not exist", async () => {
-      // Create a real non-existent IP address (but with correct format)
-      const nonExistentIpId = "0x1111111111111111111111111111111111111111" as Address;
-
-      // Generate signature for this non-existent IP
-      // Note: We need to try to get nonce first, if IP doesn't exist, this step should fail
-      try {
-        const nonceResult = await client.ipAccount.getIpAccountNonce(nonExistentIpId);
-
-        const { signature } = await getSignature({
-          state: nonceResult,
-          to: permissionAddress,
-          encodeData: data,
-          wallet: walletClient,
-          verifyingContract: nonExistentIpId, // Use non-existent IP as verifying contract
-          deadline: VALID_DEADLINE,
-          chainId: aeneid,
-        });
-
-        await expect(
-          client.ipAccount.executeWithSig({
-            to: permissionAddress,
-            data: data,
-            ipId: nonExistentIpId,
-            signer: TEST_WALLET_ADDRESS,
-            deadline: VALID_DEADLINE,
-            signature: signature,
-          }),
-        ).to.be.rejectedWith("IPAccount__InvalidSignature"); // Should fail because IP doesn't exist
-      } catch (error) {
-        // If getting nonce fails, it means IP indeed doesn't exist, which is also our expected result
-        expect((error as Error).message).to.include("Failed to get the IP Account nonce");
-      }
-    });
-
-    it("should fail with unauthorized signer", async () => {
-      // Test various unauthorized signer scenarios
-      const unauthorizedSigner = "0x2222222222222222222222222222222222222222" as Address;
-
-      const nonceResult = await client.ipAccount.getIpAccountNonce(ipId);
-      const { signature } = await getSignature({
-        state: nonceResult,
-        to: permissionAddress,
-        encodeData: data,
-        wallet: walletClient,
-        verifyingContract: ipId,
-        deadline: VALID_DEADLINE,
-        chainId: aeneid,
-      });
-
-      await expect(
-        client.ipAccount.executeWithSig({
-          to: permissionAddress,
-          data: data,
-          ipId: ipId,
-          signer: unauthorizedSigner, // Unauthorized signer
-          deadline: VALID_DEADLINE,
-          signature: signature,
-        }),
-      ).to.be.rejectedWith("IPAccount__InvalidSignature"); // Contract returns InvalidSignature for permission issues
-    });
-
-    it("should fail with signature for wrong data", async () => {
-      // Generate signature for different data than what we execute
-      const wrongData = encodeFunctionData({
-        abi: accessControllerAbi,
-        functionName: "setTransientPermission",
-        args: [
-          getAddress("0x1234567890123456789012345678901234567890"),
-          getAddress(TEST_WALLET_ADDRESS),
-          getAddress(coreMetadataModule),
-          toFunctionSelector("function setAll(address,string,bytes32,bytes32)"),
-          AccessPermission.DENY,
-        ],
-      });
-
-      const nonceResult = await client.ipAccount.getIpAccountNonce(ipId);
-
-      const { signature } = await getSignature({
-        state: nonceResult,
-        to: permissionAddress,
-        encodeData: wrongData, // Sign wrong data
-        wallet: walletClient,
-        verifyingContract: ipId,
-        deadline: VALID_DEADLINE,
-        chainId: aeneid,
-      });
-
-      await expect(
-        client.ipAccount.executeWithSig({
-          to: permissionAddress,
-          data: data, // Execute with original data, not the signed data
-          ipId: ipId,
-          signer: TEST_WALLET_ADDRESS,
-          deadline: VALID_DEADLINE,
-          signature: signature,
-        }),
-      ).to.be.rejectedWith("IPAccount__InvalidSignature"); // Should fail because data doesn't match signature
-    });
-
-    it("should fail with signature for wrong target address", async () => {
-      // Generate signature for different target address than what we execute
-      const wrongTarget = "0x1234567890123456789012345678901234567890" as Address;
-      const nonceResult = await client.ipAccount.getIpAccountNonce(ipId);
-
-      const { signature } = await getSignature({
-        state: nonceResult,
-        to: wrongTarget, // Sign for wrong target
-        encodeData: data,
-        wallet: walletClient,
-        verifyingContract: ipId,
-        deadline: VALID_DEADLINE,
-        chainId: aeneid,
-      });
-
-      await expect(
-        client.ipAccount.executeWithSig({
-          to: permissionAddress, // Execute with original target, not the signed target
-          data: data,
-          ipId: ipId,
-          signer: TEST_WALLET_ADDRESS,
-          deadline: VALID_DEADLINE,
-          signature: signature,
-        }),
-      ).to.be.rejectedWith("IPAccount__InvalidSignature"); // Should fail because target doesn't match signature
-    });
-
     it("should execute with zero value transaction", async () => {
       // Test successful execution with zero value
       const nonceResult = await client.ipAccount.getIpAccountNonce(ipId);
@@ -347,32 +171,18 @@ describe("IPAccount Functions", () => {
     });
   });
 
-  describe("getIpAccountNonce", () => {
-    it("should successfully return account nonce", async () => {
-      const response = await client.ipAccount.getIpAccountNonce(ipId);
-      expect(response).to.be.a("string");
-    });
-
-    it("should fail with invalid ipId", async () => {
-      await expect(client.ipAccount.getIpAccountNonce("0x0000000000000000000000000000000000000000"))
-        .to.be.rejected;
-    });
+  it("should successfully return account nonce", async () => {
+    const response = await client.ipAccount.getIpAccountNonce(ipId);
+    expect(response).to.be.a("string");
   });
 
-  describe("getToken", () => {
-    it("should successfully return token information", async () => {
-      const response = await client.ipAccount.getToken(ipId);
+  it("should successfully return token information", async () => {
+    const response = await client.ipAccount.getToken(ipId);
 
-      expect(response.chainId).to.be.a("bigint");
-      expect(response.tokenContract).to.be.a("string");
-      expect(response.tokenId).to.be.a("bigint");
-      expect(response.tokenContract).to.equal(mockERC721);
-    });
-
-    it("should fail with invalid ipId", async () => {
-      await expect(client.ipAccount.getToken("0x0000000000000000000000000000000000000000")).to.be
-        .rejected;
-    });
+    expect(response.chainId).to.be.a("bigint");
+    expect(response.tokenContract).to.be.a("string");
+    expect(response.tokenId).to.be.a("bigint");
+    expect(response.tokenContract).to.equal(mockERC721);
   });
 
   it("should successfully set ip metadata", async () => {