agentvault 1.0.1 → 1.0.2

package/dist/src/testing/local-runner.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Local test runner for canister testing
+ *
+ * Provides test execution for unit, integration, and load tests against local canisters
+ */
+import type { TestRunnerOptions, TestSuite, LoadTestConfig, LoadTestResult } from './types.js';
+/**
+ * Run unit tests
+ */
+export declare function runUnitTests(options: TestRunnerOptions): Promise<TestSuite>;
+/**
+ * Run integration tests
+ */
+export declare function runIntegrationTests(options: TestRunnerOptions): Promise<TestSuite>;
+/**
+ * Run load tests
+ */
+export declare function runLoadTests(config: LoadTestConfig): Promise<LoadTestResult>;
+/**
+ * Run tests based on options
+ */
+export declare function runTests(options: TestRunnerOptions): Promise<TestSuite | LoadTestResult>;
+//# sourceMappingURL=local-runner.d.ts.map

package/dist/src/testing/local-runner.js

@@ -0,0 +1,226 @@
+/**
+ * Local test runner for canister testing
+ *
+ * Provides test execution for unit, integration, and load tests against local canisters
+ */
+import { execa } from 'execa';
+import path from 'node:path';
+import os from 'node:os';
+import fs from 'node:fs';
+const AGENTVAULT_DIR = path.join(os.homedir(), '.agentvault');
+const TEST_RESULTS_DIR = path.join(AGENTVAULT_DIR, 'test-results');
+/**
+ * Ensure test results directory exists
+ */
+function ensureTestResultsDir() {
+    if (!fs.existsSync(AGENTVAULT_DIR)) {
+        fs.mkdirSync(AGENTVAULT_DIR, { recursive: true });
+    }
+    if (!fs.existsSync(TEST_RESULTS_DIR)) {
+        fs.mkdirSync(TEST_RESULTS_DIR, { recursive: true });
+    }
+}
+/**
+ * Get test results file path
+ */
+function getTestResultsPath(agentName, testType) {
+    ensureTestResultsDir();
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    return path.join(TEST_RESULTS_DIR, `${agentName}-${testType}-${timestamp}.json`);
+}
+/**
+ * Parse vitest output to extract test results
+ */
+function parseVitestOutput(stdout) {
+    const lines = stdout.split('\n');
+    const tests = [];
+    let total = 0;
+    let passed = 0;
+    let failed = 0;
+    let skipped = 0;
+    let duration = 0;
+    for (const line of lines) {
+        const match = line.match(/^(PASS|FAIL|SKIP)\s+(.+) \((\d+)ms\)$/);
+        if (match) {
+            const [, status, nameRaw, timeRaw] = match;
+            const name = nameRaw?.trim() || 'unknown';
+            const time = timeRaw || '0';
+            tests.push({
+                name,
+                status: status === 'PASS' ? 'passed' : status === 'FAIL' ? 'failed' : 'skipped',
+                duration: parseInt(time, 10),
+            });
+            total++;
+            if (status === 'PASS')
+                passed++;
+            else if (status === 'FAIL')
+                failed++;
+            else
+                skipped++;
+        }
+        const durationMatch = line.match(/Test Files\s+(\d+)\s+passed\s+\((\d+)\)/);
+        if (durationMatch && durationMatch[2]) {
+            duration = parseInt(durationMatch[2], 10);
+        }
+    }
+    return {
+        name: 'canister-tests',
+        total,
+        passed,
+        failed,
+        skipped,
+        duration,
+        tests,
+    };
+}
+/**
+ * Run unit tests
+ */
+export async function runUnitTests(options) {
+    const vitestArgs = [
+        'run',
+        '--reporter=verbose',
+    ];
+    if (options.network) {
+        vitestArgs.push(`--env.network=${options.network}`);
+    }
+    if (options.outputFormat === 'json') {
+        vitestArgs.push('--reporter=json');
+    }
+    vitestArgs.push('tests/unit');
+    const result = await execa('npx', ['vitest', ...vitestArgs], {
+        reject: false,
+        timeout: 120_000,
+    });
+    const testSuite = parseVitestOutput(result.stdout);
+    if (options.outputFormat === 'json') {
+        const resultsPath = getTestResultsPath(options.agentName, 'unit');
+        fs.writeFileSync(resultsPath, JSON.stringify(testSuite, null, 2), 'utf8');
+        console.log(`Test results saved to ${resultsPath}`);
+    }
+    return testSuite;
+}
+/**
+ * Run integration tests
+ */
+export async function runIntegrationTests(options) {
+    const vitestArgs = [
+        'run',
+        '--reporter=verbose',
+    ];
+    if (options.network) {
+        vitestArgs.push(`--env.network=${options.network}`);
+    }
+    if (options.outputFormat === 'json') {
+        vitestArgs.push('--reporter=json');
+    }
+    vitestArgs.push('tests/integration');
+    const result = await execa('npx', ['vitest', ...vitestArgs], {
+        reject: false,
+        timeout: 300_000,
+    });
+    const testSuite = parseVitestOutput(result.stdout);
+    if (options.outputFormat === 'json') {
+        const resultsPath = getTestResultsPath(options.agentName, 'integration');
+        fs.writeFileSync(resultsPath, JSON.stringify(testSuite, null, 2), 'utf8');
+        console.log(`Test results saved to ${resultsPath}`);
+    }
+    return testSuite;
+}
+/**
+ * Run load tests
+ */
+export async function runLoadTests(config) {
+    const errors = {};
+    let totalRequests = 0;
+    let successfulRequests = 0;
+    let failedRequests = 0;
+    const responseTimes = [];
+    const startTime = Date.now();
+    const endTime = startTime + (config.duration * 1000);
+    const interval = config.duration * 1000 / (config.concurrency * 10);
+    const requestPromises = [];
+    for (let i = 0; i < config.concurrency * 10; i++) {
+        if (Date.now() >= endTime)
+            break;
+        const startTimeMs = Date.now();
+        const request = execa('npx', ['icp', 'canister', 'call', config.canisterId, config.method, ...(config.args ? [config.args] : [])], {
+            reject: false,
+            timeout: 30_000,
+        });
+        const requestPromise = request.then((result) => {
+            const responseTime = Date.now() - startTimeMs;
+            if (result.exitCode === 0) {
+                return { success: true, responseTime };
+            }
+            else {
+                const error = result.stderr || 'Unknown error';
+                errors[error] = (errors[error] || 0) + 1;
+                return { success: false, responseTime, error };
+            }
+        });
+        requestPromises.push(requestPromise);
+        await new Promise((resolve) => setTimeout(resolve, interval));
+    }
+    const results = await Promise.all(requestPromises);
+    for (const result of results) {
+        totalRequests++;
+        if (result.success) {
+            successfulRequests++;
+            responseTimes.push(result.responseTime);
+        }
+        else {
+            failedRequests++;
+            if (result.error) {
+                errors[result.error] = (errors[result.error] || 0) + 1;
+            }
+        }
+    }
+    const actualDuration = (Date.now() - startTime) / 1000;
+    const requestsPerSecond = totalRequests / actualDuration;
+    const sortedTimes = responseTimes.sort((a, b) => a - b);
+    const minResponseTime = sortedTimes[0] || 0;
+    const maxResponseTime = sortedTimes[sortedTimes.length - 1] || 0;
+    const avgResponseTime = responseTimes.length > 0
+        ? responseTimes.reduce((a, b) => a + b, 0) / responseTimes.length
+        : 0;
+    const percentiles = {
+        p50: sortedTimes[Math.floor(sortedTimes.length * 0.5)] || 0,
+        p90: sortedTimes[Math.floor(sortedTimes.length * 0.9)] || 0,
+        p95: sortedTimes[Math.floor(sortedTimes.length * 0.95)] || 0,
+        p99: sortedTimes[Math.floor(sortedTimes.length * 0.99)] || 0,
+    };
+    return {
+        totalRequests,
+        successfulRequests,
+        failedRequests,
+        requestsPerSecond,
+        avgResponseTime,
+        minResponseTime,
+        maxResponseTime,
+        percentiles,
+        errors,
+    };
+}
+/**
+ * Run tests based on options
+ */
+export async function runTests(options) {
+    switch (options.testType) {
+        case 'unit':
+            return runUnitTests(options);
+        case 'integration':
+            return runIntegrationTests(options);
+        case 'load-test':
+            if (!options.concurrency) {
+                throw new Error('Concurrency is required for load tests');
+            }
+            if (!options.loadDuration) {
+                throw new Error('Load duration is required for load tests');
+            }
+            throw new Error('Load test requires specific LoadTestConfig');
+        default:
+            throw new Error(`Unknown test type: ${options.testType}`);
+    }
+}
+//# sourceMappingURL=local-runner.js.map

package/dist/src/testing/types.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Types for local test runner
+ */
+/** Test type */
+export type TestType = 'unit' | 'integration' | 'load-test';
+/** Test result status */
+export type TestStatus = 'passed' | 'failed' | 'skipped';
+/** Individual test case result */
+export interface TestCase {
+    /** Test name */
+    name: string;
+    /** Test status */
+    status: TestStatus;
+    /** Duration in milliseconds */
+    duration: number;
+    /** Error message if failed */
+    error?: string;
+    /** Error stack if failed */
+    stack?: string;
+}
+/** Test suite result */
+export interface TestSuite {
+    /** Suite name */
+    name: string;
+    /** Total number of tests */
+    total: number;
+    /** Number of passed tests */
+    passed: number;
+    /** Number of failed tests */
+    failed: number;
+    /** Number of skipped tests */
+    skipped: number;
+    /** Duration in milliseconds */
+    duration: number;
+    /** Individual test cases */
+    tests: TestCase[];
+}
+/** Test runner options */
+export interface TestRunnerOptions {
+    /** Agent name to test */
+    agentName: string;
+    /** Network to run tests against */
+    network: string;
+    /** Test type */
+    testType: TestType;
+    /** Enable watch mode */
+    watch?: boolean;
+    /** Load test concurrency */
+    concurrency?: number;
+    /** Load test duration in seconds */
+    loadDuration?: number;
+    /** Output format */
+    outputFormat?: 'json' | 'junit' | 'html';
+    /** Verbose output */
+    verbose?: boolean;
+}
+/** Load test configuration */
+export interface LoadTestConfig {
+    /** Number of concurrent requests */
+    concurrency: number;
+    /** Test duration in seconds */
+    duration: number;
+    /** Target canister ID */
+    canisterId: string;
+    /** Method to call */
+    method: string;
+    /** Request arguments (Candid format) */
+    args?: string;
+    /** Ramp-up time in seconds */
+    rampUp?: number;
+}
+/** Load test result */
+export interface LoadTestResult {
+    /** Total requests sent */
+    totalRequests: number;
+    /** Successful requests */
+    successfulRequests: number;
+    /** Failed requests */
+    failedRequests: number;
+    /** Requests per second */
+    requestsPerSecond: number;
+    /** Average response time in milliseconds */
+    avgResponseTime: number;
+    /** Minimum response time in milliseconds */
+    minResponseTime: number;
+    /** Maximum response time in milliseconds */
+    maxResponseTime: number;
+    /** Percentiles */
+    percentiles: {
+        p50: number;
+        p90: number;
+        p95: number;
+        p99: number;
+    };
+    /** Error breakdown */
+    errors: Record<string, number>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/testing/types.js

@@ -0,0 +1,5 @@
+/**
+ * Types for local test runner
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/src/wallet/cbor-serializer.d.ts

@@ -0,0 +1,82 @@
+/**
+ * CBOR Serializer/Deserializer
+ *
+ * Uses cbor-x to encode/decode wallet data and transactions.
+ * Provides efficient binary serialization for wallet operations.
+ */
+import type { WalletData, Transaction, TransactionRequest, SignedTransaction } from './types.js';
+/**
+ * CBOR serializer options
+ */
+interface CborOptions {
+    /** Include diagnostic info */
+    diagnostic?: boolean;
+    /** Use indefinite-length encoding */
+    indefinite?: boolean;
+}
+/**
+ * Serialize wallet data to CBOR
+ *
+ * @param wallet - Wallet data to serialize
+ * @param options - CBOR encoding options
+ * @returns CBOR-encoded wallet data
+ */
+export declare function serializeWallet(wallet: WalletData, _options?: CborOptions): Uint8Array;
+/**
+ * Deserialize CBOR data to wallet
+ *
+ * @param data - CBOR-encoded wallet data
+ * @returns Deserialized wallet data
+ */
+export declare function deserializeWallet(data: Uint8Array): WalletData;
+/**
+ * Serialize transaction to CBOR
+ *
+ * @param transaction - Transaction to serialize
+ * @returns CBOR-encoded transaction
+ */
+export declare function serializeTransaction(transaction: Transaction): Uint8Array;
+/**
+ * Deserialize CBOR data to transaction
+ *
+ * @param data - CBOR-encoded transaction data
+ * @returns Deserialized transaction
+ */
+export declare function deserializeTransaction(data: Uint8Array): Transaction;
+/**
+ * Serialize transaction request to CBOR
+ *
+ * @param request - Transaction request to serialize
+ * @returns CBOR-encoded transaction request
+ */
+export declare function serializeTransactionRequest(request: TransactionRequest): Uint8Array;
+/**
+ * Deserialize CBOR data to transaction request
+ *
+ * @param data - CBOR-encoded transaction request data
+ * @returns Deserialized transaction request
+ */
+export declare function deserializeTransactionRequest(data: Uint8Array): TransactionRequest;
+/**
+ * Serialize signed transaction to CBOR
+ *
+ * @param signedTx - Signed transaction to serialize
+ * @returns CBOR-encoded signed transaction
+ */
+export declare function serializeSignedTransaction(signedTx: SignedTransaction): Uint8Array;
+/**
+ * Deserialize CBOR data to signed transaction
+ *
+ * @param data - CBOR-encoded signed transaction data
+ * @returns Deserialized signed transaction
+ */
+export declare function deserializeSignedTransaction(data: Uint8Array): SignedTransaction;
+/**
+ * Validate CBOR data structure
+ *
+ * @param data - CBOR-encoded data
+ * @returns True if data appears valid
+ */
+export declare function validateCborData(data: Uint8Array): boolean;
+export {};
+//# sourceMappingURL=cbor-serializer.d.ts.map