feat(dapp): add coupon tests (#1035)

VmMad · KeitoTadashi · web-flow · commit fb458520dd99 · 2026-01-19T11:37:45.000+01:00
* feat(dapp): add coupon tests

* fix: add missing util

* chore: remove old createCoupon and use new methods

---------

Co-authored-by: Jose Luis Torres Corbalan &lt;jltorres@boxfish.studio&gt;
Co-authored-by: Keito &lt;64607484+KeitoTadashi@users.noreply.github.com&gt;
diff --git a/dapp/tests/management/management.spec.ts b/dapp/tests/management/management.spec.ts
@@ -4,19 +4,20 @@
 import { resolve } from 'path';
 import { normalizeIotaName } from '@iota/iota-names-sdk';
 import { Ed25519Keypair } from '@iota/iota-sdk/keypairs/ed25519';
-import { formatAddress, NANOS_PER_IOTA } from '@iota/iota-sdk/utils';
+import { formatAddress } from '@iota/iota-sdk/utils';
 
 import { formatDate } from '@/lib/utils/format/formatDate';
 
 import { expect, test } from '../helpers/fixtures';
+import { addToCouponList } from '../setup/toggleSmartContract';
 import { iotaNamesClient } from '../setup/utils';
 import {
     addSubnameName,
     connectName,
     connectWallet,
-    createCoupon,
     createWallet,
     editSetup,
+    generateRandomCoupon,
     generateRandomName,
     generateRandomSubname,
     getAddressByIndexPath,
@@ -664,12 +665,8 @@ test.describe.serial('Name Management Tests', () => {
         const responsePurchase = await purchaseName(name, keypair);
         expect(responsePurchase.effects?.status.status).toBe('success');
 
-        const couponCode = 'FIXED_1000';
-        await createCoupon({
-            code: couponCode,
-            type: 'fixed',
-            value: BigInt(1000) * NANOS_PER_IOTA,
-        });
+        const couponCode = generateRandomCoupon('E2E100OFF');
+        await addToCouponList(couponCode);
 
         await page.goto('/my-names');
         await expect(
diff --git a/dapp/tests/purchase/purchase.spec.ts b/dapp/tests/purchase/purchase.spec.ts
@@ -8,7 +8,14 @@ import { expect } from '@playwright/test';
 import { denormalizeName } from '@/lib/utils';
 
 import { test } from '../helpers/fixtures';
-import { connectWallet, createWallet, generateRandomName, requestFaucetTokens } from '../utils';
+import { addToCouponList } from '../setup/toggleSmartContract';
+import {
+    connectWallet,
+    createWallet,
+    generateRandomCoupon,
+    generateRandomName,
+    requestFaucetTokens,
+} from '../utils';
 
 test.describe.serial('Purchase Name Tests', () => {
     test.beforeAll(async ({ appPage, context, extensionPage, extensionName, sharedState }) => {
@@ -102,6 +109,61 @@ test.describe.serial('Purchase Name Tests', () => {
         await expect(nameMessage).toContainText('Name is already taken.');
     });
 
+    test('Test with a coupon', async ({ appPage: page, context }) => {
+        const couponCode = generateRandomCoupon('E2E100OFF');
+        const name = generateRandomName('coupon');
+
+        await addToCouponList(couponCode);
+        await page.getByPlaceholder('Search for your IOTA name').click();
+        await page.getByPlaceholder('Check name availability').fill(name);
+
+        const purchaseCardLocator = page.getByTestId('purchase-name-card');
+
+        await purchaseCardLocator.waitFor({ state: 'visible', timeout: 10_000 });
+        await purchaseCardLocator.hover();
+        await purchaseCardLocator.getByRole('button', { name: 'Buy' }).click({ timeout: 10_000 });
+        await expect(page.getByTestId('name-purchase-title')).toContainText(
+            '@' + denormalizeName(name),
+        );
+
+        await page.getByPlaceholder('Have a discount code?').fill(couponCode);
+        await page.getByRole('button', { name: '+ Apply Coupon' }).click();
+
+        await expect(page.getByRole('button', { name: couponCode })).toBeVisible({
+            timeout: 5_000,
+        });
+
+        await page.getByRole('button', { name: 'Buy' }).click({ timeout: 10_000 });
+        (await context.waitForEvent('page')).getByRole('button', { name: 'Approve' }).click();
+
+        await expect(page.getByText('Successfully registered name')).toBeVisible({
+            timeout: 30_000,
+        });
+    });
+
+    test('Test with an invalid coupon', async ({ appPage: page, context }) => {
+        const couponCode = generateRandomCoupon('E2E100OFF');
+        const name = generateRandomName('invalid');
+
+        await page.getByPlaceholder('Search for your IOTA name').click();
+        await page.getByPlaceholder('Check name availability').fill(name);
+
+        const purchaseCardLocator = page.getByTestId('purchase-name-card');
+
+        await purchaseCardLocator.waitFor({ state: 'visible', timeout: 10_000 });
+        await purchaseCardLocator.hover();
+        await purchaseCardLocator.getByRole('button', { name: 'Buy' }).click({ timeout: 10_000 });
+        await expect(page.getByTestId('name-purchase-title')).toContainText(
+            '@' + denormalizeName(name),
+        );
+
+        await page.getByPlaceholder('Have a discount code?').fill(couponCode);
+        await page.getByRole('button', { name: '+ Apply Coupon' }).click();
+
+        await expect(page.getByText('Invalid coupon')).toBeVisible({
+            timeout: 5_000,
+        });
+    });
     test('Buy with a different expiration time', async ({ appPage: page, context }) => {
         const YEARS = 5;
         // Name bought when initializing localnet with scripts/tests/register-name.ts
diff --git a/dapp/tests/setup/toggleSmartContract.ts b/dapp/tests/setup/toggleSmartContract.ts
@@ -2,11 +2,14 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { Transaction } from '@iota/iota-sdk/transactions';
+import { blake2b } from '@noble/hashes/blake2';
+import { bytesToHex } from '@noble/hashes/utils';
 import { expect } from '@playwright/test';
 
 import { adminKeypair, client, getAuthorizedSmartContractTypes, iotaNamesClient } from './utils';
 
 const envs = {
+    COUPONS: iotaNamesClient.getPackage('couponsPackageId'),
     IOTA_NAMES_PACKAGE_ADDRESS: iotaNamesClient.getPackage('packageId'),
     IOTA_NAMES_OBJECT_ID: iotaNamesClient.getPackage('iotaNamesObjectId'),
     ADMIN_CAP: iotaNamesClient.getPackage('adminCap'),
@@ -95,3 +98,53 @@ export async function toggleSmartContractMode(mode: 'auctions' | 'purchases'): P
     expect(finalState.isAuctionAuthorized).toBe(targetState.isAuctionAuthorized);
     expect(finalState.isPaymentAuthorized).toBe(targetState.isPaymentAuthorized);
 }
+
+export async function addToCouponList(coupon: string): Promise<void> {
+    if (!process.env.ADMIN_MNEMONIC) {
+        throw new Error('env ADMIN_MNEMONIC not set. Cannot toggle smart contract mode.');
+    }
+
+    const target = `${envs.COUPONS}::coupon_house::admin_add_percentage_coupon`;
+    const rulesTarget = `${envs.COUPONS}::rules::new_empty_rules`;
+
+    const tx = new Transaction();
+
+    const [rules] = tx.moveCall({
+        target: rulesTarget,
+        arguments: [],
+    });
+    const couponCodeHash = bytesToHex(blake2b(coupon, { dkLen: 32 }));
+
+    tx.moveCall({
+        target,
+        arguments: [
+            tx.object(envs.ADMIN_CAP),
+            tx.object(envs.IOTA_NAMES_OBJECT_ID),
+            tx.pure.string(couponCodeHash),
+            tx.pure.u64(100),
+            tx.object(rules),
+        ],
+    });
+
+    tx.setSender(adminKeypair.toIotaAddress());
+
+    const resp = await client.signAndExecuteTransaction({
+        transaction: await tx.build({
+            client,
+        }),
+        signer: adminKeypair,
+        options: {
+            showEffects: true,
+        },
+    });
+
+    if (resp.effects?.status.status === 'failure') {
+        throw new Error(
+            `Failed to add coupon ${coupon} to coupon list: ${JSON.stringify(resp.effects.status)}`,
+        );
+    }
+
+    await client.waitForTransaction({
+        digest: resp.digest,
+    });
+}
diff --git a/dapp/tests/utils.ts b/dapp/tests/utils.ts
@@ -7,13 +7,11 @@ import type { BrowserContext, Page } from '@playwright/test';
 
 import 'dotenv/config';
 
-import { execFileSync, execSync } from 'child_process';
+import { execFileSync } from 'child_process';
 import { IotaNamesTransaction, isSubname, NameRecord } from '@iota/iota-names-sdk';
 import type { Signer } from '@iota/iota-sdk/cryptography';
 import { Transaction } from '@iota/iota-sdk/transactions';
 import { NANOS_PER_IOTA } from '@iota/iota-sdk/utils';
-import { blake2b } from '@noble/hashes/blake2';
-import { bytesToHex } from '@noble/hashes/utils';
 
 import { buildCreateAuctionTransaction, buildPlaceBidTransaction } from '@/auctions';
 import { CONFIG } from '@/config';
@@ -445,45 +443,9 @@ export function generateRandomSubname(subname: string, parentName: string) {
     return `${subname}${random}.${parentName}`;
 }
 
-interface CreateCouponOptions {
-    code: string;
-    type: 'fixed' | 'percentage';
-    value: bigint;
-}
-
-export async function createCoupon({ code, type, value }: CreateCouponOptions) {
-    const couponCodeHash = bytesToHex(blake2b(code, { dkLen: 32 }));
-
-    const couponsPackageId = iotaNamesClient.getPackage('couponsPackageId');
-    const iotaNamesObjectId = iotaNamesClient.getPackage('iotaNamesObjectId');
-    const adminCapId = iotaNamesClient.getPackage('adminCap');
-    const adminAddress = iotaNamesClient.getPackage('adminAddress');
-
-    const functionName =
-        type === 'fixed' ? 'admin_add_fixed_coupon' : 'admin_add_percentage_coupon';
-
-    const command = `iota client ptb \
-        --move-call ${couponsPackageId}::rules::new_empty_rules \
-        --assign empty_rules \
-        --move-call ${couponsPackageId}::coupon_house::${functionName} \
-            @${adminCapId} \
-            @${iotaNamesObjectId} \
-            '"${couponCodeHash}"' \
-            ${value.toString()} \
-            empty_rules \
-        --gas-budget 50000000 \
-        --sender @${adminAddress}`;
-
-    console.log(`Creating ${type} coupon "${code}" with hash ${couponCodeHash}...`);
-
-    try {
-        const output = execSync(command, { encoding: 'utf-8' });
-        console.log(`Created ${type} coupon "${code}" successfully`);
-        return output;
-    } catch (error) {
-        console.error(`Failed to create coupon "${code}":`, error);
-        throw error;
-    }
+export function generateRandomCoupon(coupon: string) {
+    const random = Math.floor(Math.random() * 10_000);
+    return `${coupon}${random}`.toUpperCase();
 }
 
 export async function checkAddressBalanceWithRetries(address: string): Promise<void> {
