@5ive-tech/cli 1.0.22 → 1.0.24

package/dist/commands/test.js

@@ -1,12 +1,12 @@
 // Test command.
 import { readFile, readdir, stat } from 'fs/promises';
-import { join, basename, isAbsolute } from 'path';
+import { join, basename } from 'path';
 import ora from 'ora';
 import { FiveSDK, FiveTestRunner, TestDiscovery } from '@5ive-tech/sdk';
 import { ConfigManager } from '../config/ConfigManager.js';
 import { Connection, Keypair } from '@solana/web3.js';
 import { FiveFileManager } from '../utils/FiveFileManager.js';
-import { loadBuildManifest, loadProjectConfig } from '../project/ProjectLoader.js';
+import { loadProjectConfig } from '../project/ProjectLoader.js';
 import { section, success as uiSuccess, error as uiError } from '../utils/cli-ui.js';
 /**
  * 5IVE test command implementation
@@ -18,8 +18,8 @@ export const testCommand = {
     options: [
         {
             flags: '-p, --pattern <pattern>',
-            description: 'Test file pattern (default: **/*.test.json)',
-            defaultValue: '**/*.test.json'
+            description: 'Test discovery pattern (default: *)',
+            defaultValue: '*'
         },
         {
             flags: '-f, --filter <filter>',
@@ -107,6 +107,16 @@ export const testCommand = {
             description: 'Include detailed cost analysis in results',
             defaultValue: false
         },
+        {
+            flags: '--allow-mainnet-tests',
+            description: 'Allow on-chain tests on mainnet (requires --max-cost-sol)',
+            defaultValue: false
+        },
+        {
+            flags: '--max-cost-sol <amount>',
+            description: 'Maximum SOL budget for on-chain test runs',
+            required: false
+        },
         {
             flags: '--project <path>',
             description: 'Project directory or five.toml path',
@@ -150,7 +160,6 @@ export const testCommand = {
         const { logger } = context;
         try {
             const projectContext = await loadProjectConfig(options.project, process.cwd());
-            const manifest = projectContext ? await loadBuildManifest(projectContext.rootDir) : null;
             // Apply project defaults if not provided
             if (!options.target && projectContext?.config.cluster) {
                 options.target = projectContext.config.cluster;
@@ -161,16 +170,9 @@ export const testCommand = {
             if (!options.keypair && projectContext?.config.keypairPath) {
                 options.keypair = projectContext.config.keypairPath;
             }
-            let testPath = args[0] ||
+            const testPath = args[0] ||
                 (projectContext ? join(projectContext.rootDir, 'tests') : undefined) ||
                 './tests';
-            if (!args[0] && manifest?.artifact_path) {
-                testPath = isAbsolute(manifest.artifact_path)
-                    ? manifest.artifact_path
-                    : projectContext
-                        ? join(projectContext.rootDir, manifest.artifact_path)
-                        : manifest.artifact_path;
-            }
             // Handle on-chain testing mode
             if (options.onChain) {
                 await runOnChainTests(testPath, options, context);
@@ -220,9 +222,16 @@ export const testCommand = {
 async function discoverTestSuites(testPath, options, logger) {
     const testSuites = [];
     const compiledVTests = new Map();
+    const loadedJsonSuites = new Set();
     try {
         // Use new TestDiscovery to find both .test.json and .v files
         const discoveredTests = await TestDiscovery.discoverTests(testPath, { verbose: options.verbose });
+        const discoveredVTests = discoveredTests.filter((t) => t.type === 'v-source' && t.source);
+        // Fallback for SDK versions that do not yet discover pub test_* .v tests.
+        if (discoveredVTests.length === 0) {
+            const fallbackVTests = await discoverVTestsLocally(testPath);
+            discoveredTests.push(...fallbackVTests);
+        }
         if (discoveredTests.length === 0 && options.verbose) {
             logger.info('No tests discovered');
         }
@@ -234,9 +243,13 @@ async function discoverTestSuites(testPath, options, logger) {
                 if (!compiledVTests.has(test.path)) {
                     const spinner = ora(`Compiling ${basename(test.path)}...`).start();
                     try {
-                        const compilation = await TestDiscovery.compileVTest(test.path);
+                        const source = await readFile(test.path, 'utf8');
+                        const compilation = await FiveSDK.compile({ filename: test.path, content: source }, { debug: options.verbose, optimize: false });
                         if (compilation.success && compilation.bytecode) {
-                            compiledVTests.set(test.path, compilation.bytecode);
+                            compiledVTests.set(test.path, {
+                                bytecode: compilation.bytecode,
+                                abi: compilation.abi
+                            });
                             spinner.succeed(`Compiled ${basename(test.path)}`);
                         }
                         else {
@@ -252,33 +265,35 @@ async function discoverTestSuites(testPath, options, logger) {
                     }
                 }
                 // Create test case from compiled .v file
-                const bytecode = compiledVTests.get(test.path);
-                if (bytecode) {
-                    // Write bytecode to temp location
-                    const fs = await import('fs/promises');
-                    const tmpDir = join(process.cwd(), '.five', 'test-cache');
-                    await fs.mkdir(tmpDir, { recursive: true });
-                    const bytecodeFile = join(tmpDir, `${test.name.replace(/:/g, '_')}.bin`);
-                    await fs.writeFile(bytecodeFile, bytecode);
+                const compiled = compiledVTests.get(test.path);
+                if (compiled && test.source) {
+                    const sourceMeta = test.source;
                     const suite = suiteMap.get(test.path) || [];
                     suite.push({
                         name: test.name,
-                        bytecode: bytecodeFile,
-                        input: undefined,
-                        accounts: undefined,
+                        bytecode: test.path,
+                        sourceFile: test.path,
+                        functionRef: test.source.functionName,
+                        parameters: test.parameters || [],
+                        inlineBytecode: compiled.bytecode,
+                        inlineAbi: compiled.abi,
                         expected: {
                             success: true,
-                            result: test.parameters ? test.parameters[test.parameters.length - 1] : undefined
+                            result: sourceMeta?.expectsResult ? sourceMeta?.expectedResult : undefined
                         }
                     });
                     suiteMap.set(test.path, suite);
                 }
             }
             else if (test.type === 'json-suite') {
+                if (loadedJsonSuites.has(test.path)) {
+                    continue;
+                }
                 // Load .test.json suite
                 const suite = await loadTestSuite(test.path);
                 if (suite) {
                     testSuites.push(suite);
+                    loadedJsonSuites.add(test.path);
                 }
             }
         }
@@ -308,10 +323,15 @@ async function loadTestSuite(filePath) {
     try {
         const content = await readFile(filePath, 'utf8');
         const data = JSON.parse(content);
+        const testCases = data.tests || data.testCases || [];
+        // Ignore fixture-shaped JSON files in local test mode.
+        if (!Array.isArray(testCases)) {
+            return null;
+        }
         return {
             name: data.name || basename(filePath, '.test.json'),
             description: data.description,
-            testCases: data.tests || data.testCases || []
+            testCases
         };
     }
     catch (error) {
@@ -319,6 +339,101 @@ async function loadTestSuite(filePath) {
         return null;
     }
 }
+async function discoverVTestsLocally(testPath) {
+    const vFiles = await findFilesByExtension(testPath, '.v');
+    const tests = [];
+    for (const file of vFiles) {
+        const content = await readFile(file, 'utf8');
+        const lines = content.split('\n');
+        let pendingParams;
+        for (const rawLine of lines) {
+            const line = rawLine.trim();
+            const paramsMatch = line.match(/@test-params(?:\s+(.*))?$/);
+            if (paramsMatch) {
+                const paramsStr = (paramsMatch[1] || '').trim();
+                if (paramsStr.length === 0) {
+                    pendingParams = [];
+                }
+                else if (paramsStr.startsWith('[')) {
+                    const parsed = JSON.parse(paramsStr);
+                    pendingParams = Array.isArray(parsed) ? parsed : [];
+                }
+                else {
+                    pendingParams = paramsStr
+                        .split(/\s+/)
+                        .filter(Boolean)
+                        .map(parseTestParamToken);
+                }
+                continue;
+            }
+            const funcMatch = line.match(/^pub\s+(?:fn\s+)?(test_[A-Za-z0-9_]*|[A-Za-z0-9_]*_test)\s*\([^)]*\)\s*(?:->\s*([A-Za-z0-9_<>\[\]]+))?/);
+            if (!funcMatch)
+                continue;
+            const functionName = funcMatch[1];
+            const hasReturnValue = !!funcMatch[2];
+            const [parameters, expectedResult, expectsResult] = splitParamsAndExpectation(pendingParams, hasReturnValue);
+            tests.push({
+                name: `${basename(file, '.v')}::${functionName}`,
+                path: file,
+                type: 'v-source',
+                source: {
+                    functionName,
+                    expectedResult,
+                    expectsResult
+                },
+                parameters: parameters.length > 0 ? parameters : undefined
+            });
+            pendingParams = undefined;
+        }
+    }
+    return tests;
+}
+async function findFilesByExtension(testPath, extension) {
+    const result = [];
+    const stats = await stat(testPath);
+    if (stats.isFile()) {
+        if (testPath.endsWith(extension)) {
+            result.push(testPath);
+        }
+        return result;
+    }
+    const entries = await readdir(testPath, { recursive: true });
+    for (const entry of entries) {
+        if (typeof entry !== 'string')
+            continue;
+        if (!entry.endsWith(extension))
+            continue;
+        const fullPath = join(testPath, entry);
+        if (fullPath.includes('node_modules'))
+            continue;
+        const entryStats = await stat(fullPath);
+        if (entryStats.isFile()) {
+            result.push(fullPath);
+        }
+    }
+    return result;
+}
+function splitParamsAndExpectation(values, hasReturnValue) {
+    const parsed = Array.isArray(values) ? values : [];
+    if (!hasReturnValue || parsed.length === 0) {
+        return [parsed, undefined, false];
+    }
+    return [parsed.slice(0, parsed.length - 1), parsed[parsed.length - 1], true];
+}
+function parseTestParamToken(token) {
+    if ((token.startsWith('"') && token.endsWith('"')) ||
+        (token.startsWith("'") && token.endsWith("'"))) {
+        return token.slice(1, -1);
+    }
+    if (token === 'true')
+        return true;
+    if (token === 'false')
+        return false;
+    const asNumber = Number(token);
+    if (!Number.isNaN(asNumber))
+        return asNumber;
+    return token;
+}
 /**
  * Run all test suites
  */
@@ -346,18 +461,25 @@ async function runSingleTest(testCase, sdk, options, context) {
     const { logger } = context;
     const startTime = Date.now();
     try {
-        // Load bytecode using centralized manager
-        const fileManager = FiveFileManager.getInstance();
-        const loadedFile = await fileManager.loadFile(testCase.bytecode, {
-            validateFormat: true
-        });
-        const bytecode = loadedFile.bytecode;
-        // Validation already done by file manager with validateFormat: true
-        const validation = { valid: true }; // Skip redundant validation
-        // Validation handled by centralized file manager
+        let bytecode;
+        let abi = testCase.inlineAbi;
+        if (testCase.inlineBytecode) {
+            bytecode = testCase.inlineBytecode;
+        }
+        else {
+            // Load bytecode using centralized manager
+            const fileManager = FiveFileManager.getInstance();
+            const loadedFile = await fileManager.loadFile(testCase.bytecode, {
+                validateFormat: true
+            });
+            bytecode = loadedFile.bytecode;
+            if (!abi) {
+                abi = loadedFile.abi;
+            }
+        }
         // Parse input parameters if specified
-        let parameters = [];
-        if (testCase.input) {
+        let parameters = testCase.parameters || [];
+        if (parameters.length === 0 && testCase.input) {
             const inputData = await readFile(testCase.input, 'utf8');
             try {
                 parameters = JSON.parse(inputData);
@@ -368,12 +490,11 @@ async function runSingleTest(testCase, sdk, options, context) {
             }
         }
         // Execute with timeout using 5IVE SDK
-        const executionPromise = FiveSDK.executeLocally(bytecode, 0, // Default to first function
-        parameters, {
+        const executionPromise = FiveSDK.executeLocally(bytecode, testCase.functionRef ?? 0, parameters, {
             debug: options.verbose,
             trace: options.verbose,
             computeUnitLimit: options.maxCu,
-            abi: loadedFile.abi // Pass ABI for function name resolution
+            abi // Pass ABI for function name resolution
         });
         const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('Test timeout')), options.timeout));
         const result = await Promise.race([executionPromise, timeoutPromise]);
@@ -528,19 +649,39 @@ async function runOnChainTests(testPath, options, context) {
         logger.info(`${targetPrefix} Testing on ${config.target}`);
         logger.info(`Network: ${config.networks[config.target].rpcUrl}`);
         logger.info(`Keypair: ${config.keypairPath}`);
-        // Discover .bin test files
+        // Discover artifact test files (legacy on-chain mode)
         const testFiles = await discoverBinFiles(testPath, options);
-        if (testFiles.length === 0) {
-            logger.warn('No .bin test files found');
-            return;
+        if (testFiles.length > 0) {
+            logger.info(`Found ${testFiles.length} artifact test script(s)`);
         }
-        logger.info(`Found ${testFiles.length} test script(s)`);
         // Setup Solana connection and keypair
         const connection = new Connection(config.networks[config.target].rpcUrl, 'confirmed');
         const signerKeypair = await loadKeypair(config.keypairPath);
         logger.info(`Deployer: ${signerKeypair.publicKey.toString()}`);
-        // Run batch testing
-        const results = await runBatchOnChainTests(testFiles, connection, signerKeypair, options, config);
+        const maxCostLamports = parseMaxCostLamports(options.maxCostSol);
+        if (config.target === 'mainnet') {
+            if (!options.allowMainnetTests) {
+                throw new Error('mainnet on-chain tests require --allow-mainnet-tests');
+            }
+            if (maxCostLamports === undefined) {
+                throw new Error('mainnet on-chain tests require --max-cost-sol <amount>');
+            }
+        }
+        await ensureOnChainBalance(connection, signerKeypair, config.target, logger);
+        const discovered = await TestDiscovery.discoverTests(testPath, { verbose: options.verbose });
+        const vTests = discovered.filter((t) => t.type === 'v-source' && t.source);
+        let results;
+        if (vTests.length > 0) {
+            results = await runDiscoveredVOnChainTests(vTests, connection, signerKeypair, options, config, maxCostLamports);
+        }
+        else {
+            // Fall back to artifact-driven on-chain mode
+            if (testFiles.length === 0) {
+                logger.warn('No on-chain tests discovered (.v test functions or .bin/.five artifacts)');
+                return;
+            }
+            results = await runBatchOnChainTests(testFiles, connection, signerKeypair, options, config, maxCostLamports);
+        }
         // Display comprehensive results
         displayOnChainTestResults(results, options, logger);
         // Exit with appropriate code
@@ -557,6 +698,29 @@ async function runOnChainTests(testPath, options, context) {
         throw error;
     }
 }
+function parseMaxCostLamports(raw) {
+    if (raw === undefined || raw === null || raw === '')
+        return undefined;
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        throw new Error(`Invalid --max-cost-sol value: ${raw}`);
+    }
+    return Math.floor(parsed * 1_000_000_000);
+}
+async function ensureOnChainBalance(connection, signerKeypair, target, logger) {
+    const minLamports = 200_000_000; // 0.2 SOL baseline
+    const balance = await connection.getBalance(signerKeypair.publicKey, 'confirmed');
+    if (balance >= minLamports) {
+        return;
+    }
+    if (target === 'local' || target === 'localnet') {
+        logger.info('Low localnet balance detected; requesting airdrop...');
+        const sig = await connection.requestAirdrop(signerKeypair.publicKey, 2_000_000_000);
+        await connection.confirmTransaction(sig, 'confirmed');
+        return;
+    }
+    throw new Error(`Insufficient balance for on-chain tests on ${target}. Balance=${(balance / 1e9).toFixed(6)} SOL`);
+}
 /**
  * Run tests using modern SDK-based test runner
  */
@@ -571,7 +735,7 @@ async function runWithSdkRunner(testPath, options, context) {
         verbose: options.verbose,
         debug: options.verbose,
         trace: options.verbose,
-        pattern: options.filter || '*',
+        pattern: options.filter || options.pattern || '*',
         failFast: false
     });
     try {
@@ -703,7 +867,7 @@ async function loadKeypair(keypairPath) {
 /**
  * Run batch on-chain tests with deploy → execute → verify pipeline
  */
-async function runBatchOnChainTests(testFiles, connection, signerKeypair, options, config) {
+async function runBatchOnChainTests(testFiles, connection, signerKeypair, options, config, maxCostLamports) {
     const results = [];
     const startTime = Date.now();
     let totalCost = 0;
@@ -763,6 +927,9 @@ async function runBatchOnChainTests(testFiles, connection, signerKeypair, option
             const testDuration = Date.now() - testStartTime;
             const testCost = (deployResult.deploymentCost || 0) + (executeResult.cost || 0);
             totalCost += testCost;
+            if (maxCostLamports !== undefined && totalCost > maxCostLamports) {
+                throw new Error(`On-chain test cost cap exceeded: ${(totalCost / 1e9).toFixed(6)} SOL > ${(maxCostLamports / 1e9).toFixed(6)} SOL`);
+            }
             const passed = deployResult.success && executeResult.success;
             if (passed) {
                 spinner.succeed(`[${i + 1}/${testFiles.length}] ${scriptName} OK (${testDuration}ms, ${(testCost / 1e9).toFixed(4)} SOL)`);
@@ -815,6 +982,188 @@ async function runBatchOnChainTests(testFiles, connection, signerKeypair, option
         results
     };
 }
+async function runDiscoveredVOnChainTests(discoveredVTests, connection, signerKeypair, options, config, maxCostLamports) {
+    const grouped = new Map();
+    for (const test of discoveredVTests) {
+        const tests = grouped.get(test.path) || [];
+        tests.push(test);
+        grouped.set(test.path, tests);
+    }
+    const results = [];
+    let totalCost = 0;
+    const start = Date.now();
+    for (const [sourceFile, tests] of grouped.entries()) {
+        const source = await readFile(sourceFile, 'utf8');
+        const compilation = await FiveSDK.compile({ filename: sourceFile, content: source }, { debug: options.verbose, optimize: false });
+        if (!compilation.success || !compilation.bytecode) {
+            for (const test of tests) {
+                results.push({
+                    scriptFile: `${sourceFile}::${test.source.functionName}`,
+                    passed: false,
+                    totalDuration: 0,
+                    totalCost: 0,
+                    error: `Compilation failed: ${compilation.errors?.join(', ')}`
+                });
+            }
+            continue;
+        }
+        const fixture = await loadOnChainFixture(sourceFile);
+        const deploy = await FiveSDK.deployToSolana(compilation.bytecode, connection, signerKeypair, {
+            debug: options.verbose || false,
+            network: config.target,
+            computeBudget: 1_000_000,
+            maxRetries: 3
+        });
+        totalCost += deploy.deploymentCost || 0;
+        if (!deploy.success || !deploy.programId) {
+            for (const test of tests) {
+                results.push({
+                    scriptFile: `${sourceFile}::${test.source.functionName}`,
+                    passed: false,
+                    deployResult: {
+                        success: false,
+                        error: deploy.error,
+                        cost: deploy.deploymentCost || 0
+                    },
+                    totalDuration: 0,
+                    totalCost: deploy.deploymentCost || 0,
+                    error: `Deployment failed: ${deploy.error || 'unknown error'}`
+                });
+            }
+            continue;
+        }
+        for (const test of tests) {
+            const testStart = Date.now();
+            const fixtureSpec = fixture?.tests?.[test.source.functionName];
+            const expectedSuccess = fixtureSpec?.expected?.success ?? true;
+            const params = fixtureSpec?.parameters ?? test.parameters ?? [];
+            const { accounts, error: fixtureError } = await createPerTestFixtureAccounts(connection, signerKeypair, fixture, fixtureSpec, options.verbose);
+            if (fixtureError) {
+                results.push({
+                    scriptFile: `${sourceFile}::${test.source.functionName}`,
+                    passed: false,
+                    deployResult: {
+                        success: true,
+                        scriptAccount: deploy.programId,
+                        transactionId: deploy.transactionId,
+                        cost: deploy.deploymentCost || 0
+                    },
+                    totalDuration: Date.now() - testStart,
+                    totalCost: 0,
+                    error: fixtureError
+                });
+                continue;
+            }
+            const execute = await FiveSDK.executeOnSolana(deploy.programId, connection, signerKeypair, test.source.functionName, params, accounts, {
+                debug: options.verbose || false,
+                network: config.target,
+                computeUnitLimit: 1_000_000,
+                maxRetries: 3,
+                abi: compilation.abi
+            });
+            const testCost = execute.cost || 0;
+            totalCost += testCost;
+            if (maxCostLamports !== undefined && totalCost > maxCostLamports) {
+                throw new Error(`On-chain test cost cap exceeded: ${(totalCost / 1e9).toFixed(6)} SOL > ${(maxCostLamports / 1e9).toFixed(6)} SOL`);
+            }
+            const passed = expectedSuccess ? execute.success : !execute.success;
+            const errorContains = fixtureSpec?.expected?.errorContains;
+            const errorMatches = errorContains
+                ? (execute.error || '').includes(errorContains)
+                : true;
+            results.push({
+                scriptFile: `${sourceFile}::${test.source.functionName}`,
+                passed: passed && errorMatches,
+                deployResult: {
+                    success: true,
+                    scriptAccount: deploy.programId,
+                    transactionId: deploy.transactionId,
+                    cost: deploy.deploymentCost || 0
+                },
+                executeResult: {
+                    success: execute.success || false,
+                    transactionId: execute.transactionId,
+                    computeUnitsUsed: execute.computeUnitsUsed,
+                    cost: execute.cost,
+                    result: execute.result,
+                    error: execute.error
+                },
+                totalDuration: Date.now() - testStart,
+                totalCost: testCost,
+                error: passed && errorMatches ? undefined : execute.error
+            });
+        }
+    }
+    const passed = results.filter((r) => r.passed).length;
+    const failed = results.length - passed;
+    return {
+        totalScripts: results.length,
+        passed,
+        failed,
+        totalCost,
+        totalDuration: Date.now() - start,
+        results
+    };
+}
+async function loadOnChainFixture(sourceFile) {
+    const fixturePath = sourceFile.replace(/\.v$/, '.test.json');
+    try {
+        const content = await readFile(fixturePath, 'utf8');
+        return JSON.parse(content);
+    }
+    catch {
+        return undefined;
+    }
+}
+async function createPerTestFixtureAccounts(connection, signerKeypair, fixture, testSpec, verbose) {
+    const required = testSpec?.accounts || [];
+    if (required.length === 0) {
+        return { accounts: [] };
+    }
+    if (!fixture?.accounts) {
+        return { accounts: [], error: 'Fixture accounts are required but no companion .test.json accounts block was found' };
+    }
+    const { PublicKey, SystemProgram, Transaction, sendAndConfirmTransaction } = await import('@solana/web3.js');
+    const createdAccounts = [];
+    for (const accountName of required) {
+        const spec = fixture.accounts[accountName];
+        if (!spec) {
+            return { accounts: [], error: `Fixture account '${accountName}' not found in companion fixture file` };
+        }
+        if (spec.is_signer) {
+            return {
+                accounts: [],
+                error: `Fixture account '${accountName}' requests is_signer=true; external signer fixtures are not supported yet`
+            };
+        }
+        const owner = resolveFixtureOwner(spec.owner, signerKeypair.publicKey.toBase58());
+        const dataLen = spec.data_len || 0;
+        const lamports = spec.lamports ?? (await connection.getMinimumBalanceForRentExemption(dataLen));
+        const keypair = Keypair.generate();
+        const tx = new Transaction().add(SystemProgram.createAccount({
+            fromPubkey: signerKeypair.publicKey,
+            newAccountPubkey: keypair.publicKey,
+            lamports,
+            space: dataLen,
+            programId: new PublicKey(owner)
+        }));
+        await sendAndConfirmTransaction(connection, tx, [signerKeypair, keypair], { commitment: 'confirmed' });
+        createdAccounts.push(keypair.publicKey.toBase58());
+        if (verbose) {
+            console.log(`[on-chain fixture] created ${accountName}=${keypair.publicKey.toBase58()}`);
+        }
+    }
+    return { accounts: createdAccounts };
+}
+function resolveFixtureOwner(owner, fallback) {
+    if (!owner || owner === 'system') {
+        return '11111111111111111111111111111111';
+    }
+    if (owner === 'payer') {
+        return fallback;
+    }
+    return owner;
+}
 /**
  * Display comprehensive on-chain test results
  */