chore: added initial setup for walletconnect integration tests

Author: andreabadesso

packages/hathor-rpc-handler/integration-tests/README.md

@@ -0,0 +1,51 @@
+# Hathor RPC Handler - Integration Tests
+
+This directory contains integration tests for the `hathor-rpc-handler` package.
+These tests interact with real external services (like a WalletConnect relay server and Redis) running in Docker containers.
+
+## Prerequisites
+
+- Docker
+- Docker Compose
+- Node.js (>=20 recommended)
+- Yarn (v4+ recommended)
+
+Ensure Docker Desktop (or Docker Engine with Docker Compose plugin) is running before executing the tests.
+
+## Running the Tests
+
+1.  **Install Dependencies:**
+    If you haven't already, navigate to the root directory of the `hathor-rpc-lib` monorepo and run:
+    ```bash
+    yarn install
+    ```
+    This installs dependencies for all packages, including the required WalletConnect libraries.
+
+2.  **Execute Tests:**
+    Navigate to the `packages/hathor-rpc-handler` directory:
+    ```bash
+    cd packages/hathor-rpc-handler
+    ```
+    Then, run the integration test script:
+    ```bash
+    yarn test:integration
+    # or
+    # npm run test:integration
+    ```
+
+This command will:
+- Start the required Docker containers (Redis, WalletConnect Relay) using `docker-compose up` (handled by `jest.globalSetup.ts`).
+- Run the Jest integration tests located in `integration-tests/src` sequentially (`--runInBand`).
+- Stop and remove the Docker containers using `docker-compose down` (handled by `jest.globalTeardown.ts`).
+
+## Test Environment
+
+- **Docker:** Uses `integration-tests/docker-compose.yml` to define and manage the test environment services.
+- **Jest:** Configured via `integration-tests/jest.config.js`, using global setup/teardown scripts.
+- **WalletConnect:** Connects to a local relay server running in Docker at `ws://localhost:5555`.
+- **Hathor Wallet:** Uses a pre-defined test seed phrase (`integration-tests/src/config.ts`) to initialize a wallet instance.
+
+## Adding New Tests
+
+- Create new test files (e.g., `myFeature.test.ts`) inside the `integration-tests/src` directory.
+- Utilize the helper functions in `walletConnectClient.ts` and `hathorWallet.ts` to interact with the initialized clients/wallets. 

packages/hathor-rpc-handler/integration-tests/docker-compose.yml

@@ -0,0 +1,25 @@
+version: '3.8'
+
+services:
+  redis:
+    image: redis:latest
+    ports:
+      # Expose Redis port mainly for debugging if needed, not strictly necessary for relay
+      - "6379:6379" 
+    healthcheck:
+      test: ["CMD", "redis-cli", "ping"]
+      interval: 1s
+      timeout: 3s
+      retries: 30
+
+  relay:
+    image: reown/relay
+    ports:
+      - "5555:5000" # Expose relay port
+    environment:
+      - REDIS_URL=redis://redis:6379/0 # Use service name 'redis' for internal communication
+    depends_on:
+      redis:
+        condition: service_healthy # Wait for Redis to be healthy
+    # Add a simple healthcheck if possible (e.g., checking if the port is open)
+    # Or rely on depends_on and --wait in docker-compose up 

packages/hathor-rpc-handler/integration-tests/jest.config.js

@@ -0,0 +1,27 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  rootDir: '.', // Look for tests in the integration-tests directory
+  roots: [
+    '<rootDir>/src' // Source files for tests
+  ],
+  testMatch: [
+    '**/__tests__/**/*.+(ts|tsx|js)',
+    '**/?(*.)+(spec|test).+(ts|tsx|js)'
+  ],
+  transform: {
+    '^.+.tsx?$': ['ts-jest', {
+      // ts-jest configuration options
+      tsconfig: 'tsconfig.json' // Assuming tsconfig is in hathor-rpc-handler root
+    }]
+  },
+  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json', 'node'],
+  // Specify global setup and teardown scripts
+  globalSetup: '<rootDir>/jest.globalSetup.ts',
+  globalTeardown: '<rootDir>/jest.globalTeardown.ts',
+  // Run tests sequentially because they share the Docker environment
+  maxWorkers: 1,
+  // Set a longer timeout for integration tests and hooks
+  testTimeout: 90000, // 90 seconds
+}; 

packages/hathor-rpc-handler/integration-tests/jest.globalSetup.ts

@@ -0,0 +1,26 @@
+import { execSync } from 'child_process';
+import * as path from 'path';
+
+const integrationTestsDir = __dirname; // Correctly refers to the integration-tests directory
+const composeFile = path.join(integrationTestsDir, 'docker-compose.yml');
+
+export default async () => {
+  console.log('\nSetting up integration test environment...');
+  try {
+    // Use --wait to ensure services are healthy/running before proceeding
+    execSync(`docker compose -f "${composeFile}" up -d --wait`, { stdio: 'inherit' });
+    console.log('Docker containers started successfully.');
+    // Add a small delay just in case services need a moment to fully initialize after becoming "healthy"
+    await new Promise(resolve => setTimeout(resolve, 3000)); // 3 seconds delay
+    console.log('Integration test environment setup complete.');
+  } catch (error) {
+    console.error('Failed to start Docker containers:', error);
+    // Optionally, try to bring down containers if setup failed partially
+    try {
+      execSync(`docker compose -f "${composeFile}" down`, { stdio: 'inherit' });
+    } catch (downError) {
+      console.error('Failed to run docker compose down after setup error:', downError);
+    }
+    process.exit(1); // Exit if setup fails
+  }
+}; 

packages/hathor-rpc-handler/integration-tests/jest.globalTeardown.ts

@@ -0,0 +1,16 @@
+import { execSync } from 'child_process';
+import * as path from 'path';
+
+const integrationTestsDir = __dirname; // Correctly refers to the integration-tests directory
+const composeFile = path.join(integrationTestsDir, 'docker-compose.yml');
+
+export default async () => {
+  console.log('\nTearing down integration test environment...');
+  try {
+    execSync(`docker compose -f "${composeFile}" down -v --remove-orphans`, { stdio: 'inherit' });
+    console.log('Docker containers stopped and removed successfully.');
+  } catch (error) {
+    console.error('Failed to stop Docker containers:', error);
+    // Don't exit here, as tests might have finished, but teardown failed.
+  }
+}; 

packages/hathor-rpc-handler/integration-tests/src/config.ts

@@ -0,0 +1 @@
+export const HATHOR_TEST_SEED = 'castle item critic hand disorder girl across prevent claw fault vacuum combine food debris arrow member autumn half spirit sick priority evil step genius';

packages/hathor-rpc-handler/integration-tests/src/connection.test.ts

@@ -0,0 +1,67 @@
+import {
+  initializeWalletConnectClient,
+  getWalletConnectClient,
+  disconnectWalletConnectClient,
+} from './walletConnectClient';
+
+jest.setTimeout(120000); // Set longer timeout for the entire test suite
+
+describe('WalletConnect Connection', () => {
+  // Initialize client and wait for relay connection before tests
+  beforeAll(async () => {
+    try {
+      const client = await initializeWalletConnectClient();
+      console.log('Test Suite: WalletConnect client object initialized.');
+
+      if (client.core.relayer.connected) {
+        console.log('Test Suite: Relayer already connected.');
+        return; // Already connected
+      }
+
+      console.log('Test Suite: Waiting for relayer connection...');
+      await new Promise<void>((resolve, reject) => {
+        // Timeout if connection takes too long
+        const timeout = setTimeout(() => {
+          console.error('Test Suite: Relayer connection attempt timed out.');
+          reject(new Error('Relayer connection timeout'));
+        }, 60000); // Increased timeout to 60 seconds
+
+        // Use .once() as we only need the first connection event for setup
+        client.core.relayer.once('relayer_connect', () => {
+          clearTimeout(timeout);
+          console.log("Test Suite: 'relayer_connect' event received.");
+          resolve();
+        });
+
+        client.core.relayer.once('relayer_error', (error: Error) => {
+          clearTimeout(timeout);
+          console.error("Test Suite: 'relayer_error' event received.", error);
+          reject(error);
+        });
+      });
+
+    } catch (error) {
+      console.error('Test Suite Error: Failed during WalletConnect client initialization or connection wait', error);
+      // Optionally throw to fail the suite immediately
+      throw error; 
+    }
+  });
+
+  // Disconnect client after all tests in this suite have run
+  afterAll(async () => {
+    // No need for complex cleanup with done() since we're using --forceExit
+    await disconnectWalletConnectClient();
+    console.log('Test Suite: WalletConnect client disconnected.');
+  });
+
+  it('should initialize the WalletConnect client successfully', () => {
+    // The beforeAll block handles initialization, so we just check if getClient works
+    expect(() => getWalletConnectClient()).not.toThrow();
+    const client = getWalletConnectClient();
+    expect(client).toBeDefined();
+    // Add more specific checks if needed, e.g., client properties
+    expect(client.core.relayer.connected).toBe(true); // Check if relay connection is active
+  });
+
+  // Add more tests related to connection status or initial setup here
+}); 

packages/hathor-rpc-handler/integration-tests/src/hathorWallet.ts

@@ -0,0 +1,56 @@
+import { HathorWallet } from '@hathor/wallet-lib';
+import { HATHOR_TEST_SEED } from './config';
+
+let walletInstance: HathorWallet | null = null;
+
+/**
+ * Initializes and returns a singleton HathorWallet instance for testing.
+ * 
+ * Note: This basic initialization might need adjustments depending on 
+ * specific test requirements (e.g., network, server).
+ */
+export function initializeHathorWallet(): HathorWallet {
+  if (walletInstance) {
+    return walletInstance;
+  }
+
+  // Basic configuration, adjust as necessary
+  const walletConfig = {
+    seed: HATHOR_TEST_SEED,
+    network: 'testnet', // Assuming testnet for integration tests
+    connection: undefined, // Use default connection or configure if needed
+    password: '123', // Default password for testing
+    pinCode: '123', // Default pin for testing
+  };
+
+  walletInstance = new HathorWallet(walletConfig);
+  
+  // Start the wallet (important step)
+  // Note: Starting might involve network requests, ensure environment allows this.
+  // Consider if starting should happen here or per-test suite.
+  // For now, let's assume starting here is fine.
+  // await walletInstance.start(); // Uncomment and handle async if needed
+  
+  console.log('Hathor Wallet initialized for testing.');
+  return walletInstance;
+}
+
+/**
+ * Gets the initialized HathorWallet instance.
+ * Throws an error if the wallet hasn't been initialized.
+ */
+export function getHathorWallet(): HathorWallet {
+  if (!walletInstance) {
+    throw new Error('Hathor Wallet is not initialized. Call initializeHathorWallet first.');
+  }
+  return walletInstance;
+}
+
+// Optional: Add a function to stop/clean up the wallet if necessary
+export async function stopHathorWallet(): Promise<void> {
+  if (walletInstance) {
+    // await walletInstance.stop(); // Uncomment if wallet needs explicit stopping
+    walletInstance = null;
+    console.log('Hathor Wallet stopped.');
+  }
+} 

packages/hathor-rpc-handler/integration-tests/src/walletConnectClient.ts

@@ -0,0 +1,65 @@
+import Client from '@walletconnect/sign-client';
+import {
+  WC_APP_METADATA,
+  WC_LOGGER_LEVEL,
+  WC_PROJECT_ID,
+  WC_RELAY_URL,
+} from './walletConnectConfig';
+
+let clientInstance: Client | null = null;
+
+/**
+ * Initializes and returns a singleton WalletConnect Client instance.
+ */
+export async function initializeWalletConnectClient(): Promise<Client> {
+  if (clientInstance) {
+    console.log('WalletConnect Client already initialized.');
+    return clientInstance;
+  }
+
+  console.log(`Initializing WalletConnect Client with relay: ${WC_RELAY_URL}`);
+  try {
+    clientInstance = await Client.init({
+      logger: WC_LOGGER_LEVEL,
+      relayUrl: WC_RELAY_URL,
+      projectId: WC_PROJECT_ID,
+      metadata: WC_APP_METADATA,
+    });
+
+    return clientInstance;
+  } catch (error) {
+    console.error('Failed to initialize WalletConnect client:', error);
+    throw error; // Re-throw error to fail tests if connection fails
+  }
+}
+
+/**
+ * Gets the initialized WalletConnect Client instance.
+ * Throws an error if the client hasn't been initialized.
+ */
+export function getWalletConnectClient(): Client {
+  if (!clientInstance) {
+    throw new Error('WalletConnect client is not initialized. Call initializeWalletConnectClient first.');
+  }
+  return clientInstance;
+}
+
+/**
+ * Disconnects the WalletConnect client if it's initialized.
+ */
+export async function disconnectWalletConnectClient(): Promise<void> {
+  if (clientInstance) {
+    try {
+      console.log('Disconnecting WalletConnect Client...');
+      // Just nullify the client and let garbage collection handle cleanup
+      clientInstance = null;
+      console.log('WalletConnect Client disconnected.');
+    } catch (error) {
+      console.error('Error during WalletConnect client disconnection:', error);
+      // Ensure client is nullified
+      clientInstance = null;
+    }
+  } else {
+    console.log('WalletConnect Client was not initialized, no need to disconnect.');
+  }
+} 

packages/hathor-rpc-handler/integration-tests/src/walletConnectConfig.ts

@@ -0,0 +1,15 @@
+import { SignClientTypes } from '@walletconnect/types'; // Import Metadata type
+
+// Use the Project ID observed in the working relay log
+export const WC_PROJECT_ID = '8264fff563181da658ce64ee80e80458';
+
+export const WC_RELAY_URL = 'ws://localhost:5555'; // Keep as localhost for now
+
+export const WC_LOGGER_LEVEL = 'debug';
+
+export const WC_APP_METADATA: SignClientTypes.Metadata = {
+  name: 'Hathor RPC Integration Test',
+  description: 'Integration tests for hathor-rpc-handler',
+  url: '#', // Placeholder URL
+  icons: [], // Placeholder Icons
+};