Add integration tests (metaplex-foundation#1009)

* Add integration tests

* Add default rule set creation

* Build token metadata dependencies

* Fix dependencies build

* Change order

* Running all tests

Author: febo

.github/workflows/integration-reusable.yml

@@ -77,13 +77,12 @@ jobs:
           key: program-${{ inputs.name }}-${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
         if: ${{ env.CACHE != 'false' }}
 
-      # Install JS SDK deps
-      - uses: ./.github/actions/yarn-install-and-build
+      # Build Rust Programs
+      - uses: ./.github/actions/program
         with:
-          cache_id: sdk-${{ inputs.name }}
-          working_dir: ./${{ inputs.name }}/js
+          name: token-metadata
+        if: ${{ inputs.build_token_metadata }}
 
-      # Build Rust Programs
       - uses: ./.github/actions/build-program
         with:
           name: token-metadata
@@ -93,6 +92,12 @@ jobs:
         with:
           name: ${{ inputs.name }}
 
+      # Install JS SDK deps
+      - uses: ./.github/actions/yarn-install-and-build
+        with:
+          cache_id: sdk-${{ inputs.name }}
+          working_dir: ./${{ inputs.name }}/js
+
       # Start local validator
       - name: start-local-test-validator
         working-directory: ./${{ inputs.name }}/js
@@ -109,4 +114,3 @@ jobs:
         working-directory: ./${{ inputs.name }}/js
         run: yarn amman:stop
         continue-on-error: true
-

.github/workflows/integration.yml

@@ -26,6 +26,7 @@ jobs:
         node:
           - name: "fixed-price-sale"
           # - name: "hydra"
+          - name: "token-metadata"
           - name: "candy-machine-core"
     uses: ./.github/workflows/integration-reusable.yml
     with:

token-metadata/js/test/setup/txs-init.ts

@@ -72,6 +72,7 @@ import {
   TOKEN_PROGRAM_ID,
 } from '@solana/spl-token';
 import { findTokenRecordPda } from '../utils/programmable';
+import { encode } from '@msgpack/msgpack';
 
 export class InitTransactions {
   readonly getKeypair: LoadOrGenKeypair | GenLabeledKeypair;
@@ -688,6 +689,86 @@ export class InitTransactions {
     };
   }
 
+  async createDefaultRuleSet(
+    t: Test,
+    handler: PayerTransactionHandler,
+    payer: Keypair,
+    amount = 1,
+  ): Promise<{
+    tx: ConfirmedTransactionAssertablePromise;
+    ruleSet: PublicKey;
+  }> {
+    const allowList = [Array.from(PROGRAM_ID.toBytes())];
+    const transferRules = {
+      All: {
+        rules: [
+          {
+            Amount: {
+              amount,
+              operator: 2 /* equal */,
+              field: 'Amount',
+            },
+          },
+          {
+            Any: {
+              rules: [
+                {
+                  ProgramOwnedList: {
+                    programs: allowList,
+                    field: 'Destination',
+                  },
+                },
+                {
+                  ProgramOwnedList: {
+                    programs: allowList,
+                    field: 'Source',
+                  },
+                },
+                {
+                  ProgramOwnedList: {
+                    programs: allowList,
+                    field: 'Authority',
+                  },
+                },
+              ],
+            },
+          },
+        ],
+      },
+    };
+
+    const ruleSetName = 'default_ruleset_test';
+    const ruleSet = {
+      libVersion: 1,
+      ruleSetName: ruleSetName,
+      owner: Array.from(payer.publicKey.toBytes()),
+      operations: {
+        'Transfer:TransferDelegate': transferRules,
+        'Delegate:Sale': 'Pass',
+        'Delegate:Transfer': 'Pass',
+        'Delegate:LockedTransfer': 'Pass',
+      },
+    };
+    const serializedRuleSet = encode(ruleSet);
+
+    // find the rule set PDA
+    const [ruleSetPda] = PublicKey.findProgramAddressSync(
+      [Buffer.from('rule_set'), payer.publicKey.toBuffer(), Buffer.from(ruleSetName)],
+      TOKEN_AUTH_RULES_ID,
+    );
+
+    // creates the rule set
+    const { tx: createRuleSetTx } = await this.createRuleSet(
+      t,
+      payer,
+      ruleSetPda,
+      serializedRuleSet,
+      handler,
+    );
+
+    return { tx: createRuleSetTx, ruleSet: ruleSetPda };
+  }
+
   async createMintAccount(
     payer: Keypair,
     connection: Connection,

token-metadata/js/test/transfer.test.ts

@@ -1082,41 +1082,15 @@ test('Transfer: ProgrammableNonFungible with address lookup table (LUT)', async
   const destination = Keypair.generate();
   amman.airdrop(connection, destination.publicKey, 1);
 
-  //-- set up our rule set with one pubkey match rule for transfer.
-
-  const ruleSetName = 'transfer_test';
-  const ruleSet = {
-    libVersion: 1,
-    ruleSetName: ruleSetName,
-    owner: Array.from(owner.publicKey.toBytes()),
-    operations: {
-      'Transfer:Owner': {
-        ProgramOwned: {
-          program: Array.from(owner.publicKey.toBytes()),
-          field: 'Destination',
-        },
-      },
-    },
-  };
-  const serializedRuleSet = encode(ruleSet);
-
-  //-- Find the ruleset PDA
-  const [ruleSetPda] = PublicKey.findProgramAddressSync(
-    [Buffer.from('rule_set'), payer.publicKey.toBuffer(), Buffer.from(ruleSetName)],
-    TOKEN_AUTH_RULES_ID,
-  );
-
-  //-- create the ruleset at the PDA address with the serialized ruleset values.
-  const { tx: createRuleSetTx } = await API.createRuleSet(
+  const { tx: createRuleSetTx, ruleSet: ruleSetPda } = await API.createDefaultRuleSet(
     t,
-    payer,
-    ruleSetPda,
-    serializedRuleSet,
     handler,
+    payer,
+    1,
   );
   await createRuleSetTx.assertSuccess(t);
 
-  //-- create an NFT with the programmable config stored on the metadata.
+  // create an NFT with the programmable config stored on the metadata.
   const { mint, metadata, masterEdition, token } = await createAndMintDefaultAsset(
     t,
     connection,
@@ -1155,7 +1129,7 @@ test('Transfer: ProgrammableNonFungible with address lookup table (LUT)', async
   const { tx, lookupTable } = await createLookupTable(payer.publicKey, payer, handler, connection);
   await tx.assertSuccess(t);
 
-  //-- adds addresses to the lookup table
+  // adds addresses to the lookup table
 
   const addresses = [
     owner.publicKey,
@@ -1206,7 +1180,7 @@ test('Transfer: ProgrammableNonFungible with address lookup table (LUT)', async
 
   const lookupTableAccount = await connection.getAddressLookupTable(lookupTable);
 
-  console.log('[ Waiting for lookup table activation ]');
+  console.log('[ waiting for lookup table activation ]');
   await sleep(1000);
 
   await createAndSendV0Tx(payer, [transferIx], connection, [lookupTableAccount.value]);