byreal-test 1.0.0

package/cli.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+'use strict';
+
+const { Command } = require('commander');
+const chalk = require('chalk');
+const path = require('path');
+const { runSuites, listTests } = require('./src/runner');
+const { printReport, saveReport } = require('./src/reporter');
+const allSuites = require('./src/suites');
+
+const program = new Command();
+
+program
+  .name('byreal-test')
+  .description('Byreal CLI test suite — validates byreal-cli commands and generates reports')
+  .version('1.0.0');
+
+program
+  .command('run')
+  .description('Run test suites against byreal-cli')
+  .option('--suite <name>', `Run specific suite (${allSuites.map(s => s.name).join(', ')})`)
+  .option('--all', 'Include auth-required suites (requires wallet configured)')
+  .option('--timeout <ms>', 'Per-test timeout in milliseconds', '20000')
+  .option('--output <file>', 'Save markdown report to file (e.g. report.md)')
+  .option('--verbose', 'Show raw command output for each test')
+  .action(async (opts) => {
+    const timeout = parseInt(opts.timeout, 10);
+
+    let suites = allSuites;
+
+    if (opts.suite) {
+      suites = allSuites.filter(s => s.name === opts.suite);
+      if (suites.length === 0) {
+        console.error(chalk.red(
+          `\n  Suite "${opts.suite}" not found.\n  Available: ${allSuites.map(s => s.name).join(', ')}\n`
+        ));
+        process.exit(1);
+      }
+    }
+
+    if (!opts.all) {
+      suites = suites
+        .map(s => ({ ...s, cases: s.cases.filter(c => !c.requiresAuth) }))
+        .filter(s => s.cases.length > 0);
+    }
+
+    console.log(chalk.bold('\n  byreal-test v1.0.0\n'));
+    if (!opts.all) {
+      console.log(chalk.dim('  (Auth-required tests skipped. Use --all to include wallet tests.)\n'));
+    }
+
+    const results = await runSuites(suites, { timeout, verbose: opts.verbose });
+    printReport(results);
+
+    if (opts.output) {
+      const outPath = path.resolve(opts.output);
+      await saveReport(results, outPath);
+      console.log(chalk.dim(`  Report saved to: ${outPath}\n`));
+    }
+
+    const failed = results.flatMap(r => r.cases).filter(c => c.status === 'FAIL').length;
+    process.exit(failed > 0 ? 1 : 0);
+  });
+
+program
+  .command('list')
+  .description('List all available test cases')
+  .option('--suite <name>', 'Filter by suite name')
+  .option('--all', 'Include auth-required tests')
+  .action((opts) => {
+    listTests(allSuites, opts);
+  });
+
+program.parse(process.argv);

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "byreal-test",
+  "version": "1.0.0",
+  "description": "Byreal CLI test suite - runs byreal-cli commands and generates test reports",
+  "main": "cli.js",
+  "bin": {
+    "byreal-test": "cli.js"
+  },
+  "scripts": {
+    "start": "node cli.js run",
+    "test": "node cli.js run"
+  },
+  "files": [
+    "cli.js",
+    "src/"
+  ],
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "cli-table3": "^0.6.5",
+    "commander": "^12.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "license": "MIT"
+}

package/src/reporter.js

@@ -0,0 +1,87 @@
+'use strict';
+
+const chalk = require('chalk');
+const fs = require('fs');
+const path = require('path');
+
+function printReport(results) {
+  const allCases = results.flatMap(r => r.cases);
+  const passed = allCases.filter(c => c.status === 'PASS').length;
+  const failed = allCases.filter(c => c.status === 'FAIL').length;
+  const skipped = allCases.filter(c => c.status === 'SKIP').length;
+  const total = allCases.length;
+  const totalElapsed = allCases.reduce((sum, c) => sum + (c.elapsed || 0), 0);
+
+  const separator = '─'.repeat(62);
+  console.log(`  ${separator}`);
+
+  const passStr = chalk.green(`${passed} passed`);
+  const failStr = failed > 0 ? chalk.red(` | ${failed} failed`) : '';
+  const skipStr = skipped > 0 ? chalk.yellow(` | ${skipped} skipped`) : '';
+  const timeStr = chalk.dim(` | ${totalElapsed}ms total`);
+
+  console.log(`  ${passStr}${failStr}${skipStr}${timeStr}`);
+  console.log(`  ${separator}\n`);
+
+  if (failed > 0) {
+    console.log(chalk.red.bold('  Failed tests:'));
+    for (const suite of results) {
+      for (const c of suite.cases) {
+        if (c.status === 'FAIL') {
+          console.log(`    ${chalk.red('✗')} [${suite.name}] ${c.name}`);
+          if (c.failReason) {
+            console.log(`      ${chalk.dim('→')} ${chalk.dim(c.failReason)}`);
+          }
+        }
+      }
+    }
+    console.log('');
+  }
+}
+
+function buildMarkdown(results) {
+  const allCases = results.flatMap(r => r.cases);
+  const passed = allCases.filter(c => c.status === 'PASS').length;
+  const failed = allCases.filter(c => c.status === 'FAIL').length;
+  const skipped = allCases.filter(c => c.status === 'SKIP').length;
+  const totalElapsed = allCases.reduce((sum, c) => sum + (c.elapsed || 0), 0);
+
+  const now = new Date().toISOString().replace('T', ' ').slice(0, 19) + ' UTC';
+  const statusBadge = failed === 0 ? '✅ PASSED' : '❌ FAILED';
+
+  let md = `# Byreal-CLI Test Report\n\n`;
+  md += `| | |\n|---|---|\n`;
+  md += `| **Status** | ${statusBadge} |\n`;
+  md += `| **Generated** | ${now} |\n`;
+  md += `| **Passed** | ${passed} |\n`;
+  if (failed > 0) md += `| **Failed** | ${failed} |\n`;
+  if (skipped > 0) md += `| **Skipped** | ${skipped} |\n`;
+  md += `| **Total time** | ${totalElapsed}ms |\n\n`;
+
+  for (const suite of results) {
+    const suiteFailed = suite.cases.filter(c => c.status === 'FAIL').length;
+    const suiteIcon = suiteFailed > 0 ? '❌' : '✅';
+    md += `## ${suiteIcon} Suite: ${suite.name}\n\n`;
+    md += `| # | Test | Status | Time | Notes |\n`;
+    md += `|---|------|:------:|-----:|-------|\n`;
+    suite.cases.forEach((c, i) => {
+      const icon = c.status === 'PASS' ? '✅' : c.status === 'SKIP' ? '⏭️' : '❌';
+      const note = c.failReason || c.reason || c.note || '';
+      md += `| ${i + 1} | ${c.name} | ${icon} | ${c.elapsed || 0}ms | ${note} |\n`;
+    });
+    md += '\n';
+  }
+
+  return md;
+}
+
+async function saveReport(results, filePath) {
+  const md = buildMarkdown(results);
+  const dir = path.dirname(filePath);
+  if (dir && dir !== '.') {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(filePath, md, 'utf8');
+}
+
+module.exports = { printReport, saveReport };

package/src/runner.js

@@ -0,0 +1,188 @@
+'use strict';
+
+const { execSync } = require('child_process');
+const chalk = require('chalk');
+
+function stripAnsi(str) {
+  return str
+    .replace(/\x1b\[[0-9;]*m/g, '')
+    .replace(/\x1b\][^\x07]*\x07/g, '')
+    .replace(/\x1b[()][AB012]/g, '');
+}
+
+/**
+ * Try to extract JSON from CLI output.
+ * byreal-cli may prepend update banners or other text before the JSON payload.
+ */
+function parseJsonOutput(stdout) {
+  const clean = stripAnsi(stdout).trim();
+  const jsonStart = clean.search(/[[\{]/);
+  if (jsonStart === -1) return null;
+  try {
+    return JSON.parse(clean.slice(jsonStart));
+  } catch {
+    return null;
+  }
+}
+
+async function runCase(testCase, opts = {}) {
+  const {
+    cmd,
+    validate,
+    setupFn,
+    expectError = false,
+    timeout = opts.timeout || 20000,
+  } = testCase;
+
+  let finalCmd = typeof cmd === 'function' ? null : cmd;
+
+  if (setupFn) {
+    let setupData;
+    try {
+      setupData = setupFn();
+    } catch (err) {
+      return {
+        ...testCase,
+        status: 'SKIP',
+        reason: `setup failed: ${err.message}`,
+        elapsed: 0,
+      };
+    }
+    if (!setupData) {
+      return {
+        ...testCase,
+        status: 'SKIP',
+        reason: 'setup returned null (dependency unavailable)',
+        elapsed: 0,
+      };
+    }
+    finalCmd = typeof cmd === 'function' ? cmd(setupData) : cmd;
+  }
+
+  if (opts.verbose) {
+    process.stdout.write(chalk.dim(`\n      $ ${finalCmd}\n`));
+  }
+
+  const start = Date.now();
+  try {
+    const stdout = execSync(finalCmd, {
+      timeout,
+      encoding: 'utf8',
+      maxBuffer: 10 * 1024 * 1024,
+    });
+    const elapsed = Date.now() - start;
+
+    let passed = true;
+    let failReason = '';
+
+    if (validate) {
+      try {
+        const result = validate(stdout, parseJsonOutput);
+        if (result === false) {
+          passed = false;
+          failReason = 'validation failed';
+        } else if (typeof result === 'string') {
+          passed = false;
+          failReason = result;
+        }
+      } catch (err) {
+        passed = false;
+        failReason = `validate threw: ${err.message}`;
+      }
+    }
+
+    return {
+      ...testCase,
+      status: passed ? 'PASS' : 'FAIL',
+      stdout: opts.verbose ? stdout : undefined,
+      elapsed,
+      failReason,
+    };
+  } catch (err) {
+    const elapsed = Date.now() - start;
+
+    if (expectError) {
+      return {
+        ...testCase,
+        status: 'PASS',
+        elapsed,
+        note: 'expected error received',
+      };
+    }
+
+    const isTimeout = err.killed || String(err.message).includes('ETIMEDOUT');
+    const errorDetail = isTimeout
+      ? `timeout after ${timeout}ms`
+      : (err.stderr?.toString()?.slice(0, 200) || err.message?.slice(0, 200) || 'unknown error');
+
+    return {
+      ...testCase,
+      status: 'FAIL',
+      elapsed,
+      failReason: errorDetail,
+      stdout: opts.verbose ? err.stdout?.toString() : undefined,
+    };
+  }
+}
+
+async function runSuites(suites, opts = {}) {
+  const results = [];
+
+  for (const suite of suites) {
+    console.log(chalk.bold(`  Suite: ${suite.name}`));
+    const suiteResult = { name: suite.name, cases: [] };
+
+    for (const testCase of suite.cases) {
+      const label = testCase.name.padEnd(48);
+      process.stdout.write(`    ${chalk.dim('○')} ${chalk.dim(label)}`);
+
+      const result = await runCase(testCase, opts);
+      suiteResult.cases.push(result);
+
+      if (result.status === 'PASS') {
+        process.stdout.write(
+          `\r    ${chalk.green('✓')} ${label} ${chalk.dim(`[${result.elapsed}ms]`)}\n`
+        );
+      } else if (result.status === 'SKIP') {
+        process.stdout.write(
+          `\r    ${chalk.yellow('–')} ${label} ${chalk.yellow('SKIPPED')}  ${chalk.dim(result.reason || '')}\n`
+        );
+      } else {
+        process.stdout.write(
+          `\r    ${chalk.red('✗')} ${label} ${chalk.dim(`[${result.elapsed}ms]`)}  ${chalk.red(result.failReason || '')}\n`
+        );
+      }
+    }
+
+    console.log('');
+    results.push(suiteResult);
+  }
+
+  return results;
+}
+
+function listTests(suites, opts = {}) {
+  const Table = require('cli-table3');
+  const table = new Table({
+    head: ['Suite', 'ID', 'Test name', 'Auth required'],
+    style: { head: ['cyan'] },
+    colWidths: [12, 28, 42, 14],
+  });
+
+  for (const suite of suites) {
+    if (opts.suite && suite.name !== opts.suite) continue;
+    for (const c of suite.cases) {
+      if (!opts.all && c.requiresAuth) continue;
+      table.push([
+        suite.name,
+        c.id,
+        c.name,
+        c.requiresAuth ? chalk.yellow('Yes') : chalk.dim('No'),
+      ]);
+    }
+  }
+
+  console.log('\n' + table.toString() + '\n');
+}
+
+module.exports = { runSuites, listTests, parseJsonOutput };

package/src/suites/health.js

@@ -0,0 +1,48 @@
+'use strict';
+
+module.exports = {
+  name: 'health',
+  cases: [
+    {
+      id: 'health.version',
+      name: 'CLI version check',
+      cmd: 'byreal-cli --version',
+      validate: (stdout) => {
+        if (!/\d+\.\d+\.\d+/.test(stdout.trim())) return 'version string not found';
+        return true;
+      },
+      requiresAuth: false,
+    },
+    {
+      id: 'health.catalog',
+      name: 'Catalog list (all capabilities)',
+      cmd: 'byreal-cli catalog list',
+      validate: (stdout) => {
+        if (!stdout.includes('dex.pool.list')) return 'expected dex.pool.list in output';
+        if (!stdout.includes('dex.token.list')) return 'expected dex.token.list in output';
+        return true;
+      },
+      requiresAuth: false,
+    },
+    {
+      id: 'health.config',
+      name: 'Config list',
+      cmd: 'byreal-cli config list',
+      validate: (stdout) => {
+        if (stdout.trim().length === 0) return 'empty output';
+        return true;
+      },
+      requiresAuth: false,
+    },
+    {
+      id: 'health.update-check',
+      name: 'Update check',
+      cmd: 'byreal-cli update check',
+      validate: (stdout) => {
+        if (stdout.trim().length === 0) return 'empty output';
+        return true;
+      },
+      requiresAuth: false,
+    },
+  ],
+};

package/src/suites/index.js

@@ -0,0 +1,9 @@
+'use strict';
+
+const health = require('./health');
+const pools = require('./pools');
+const tokens = require('./tokens');
+const overview = require('./overview');
+const wallet = require('./wallet');
+
+module.exports = [health, pools, tokens, overview, wallet];

package/src/suites/overview.js

@@ -0,0 +1,31 @@
+'use strict';
+
+module.exports = {
+  name: 'overview',
+  cases: [
+    {
+      id: 'overview.global',
+      name: 'Global overview (JSON)',
+      cmd: 'byreal-cli overview -o json',
+      validate: (stdout, parse) => {
+        const res = parse(stdout);
+        if (!res?.success) return 'success != true';
+        const data = res?.data;
+        if (!data || typeof data !== 'object' || Array.isArray(data)) return 'data field missing or wrong type';
+        if (data.tvl === undefined) return 'missing field: tvl';
+        return true;
+      },
+      requiresAuth: false,
+    },
+    {
+      id: 'overview.global.table',
+      name: 'Global overview (table render)',
+      cmd: 'byreal-cli overview',
+      validate: (stdout) => {
+        if (stdout.trim().length === 0) return 'empty output';
+        return true;
+      },
+      requiresAuth: false,
+    },
+  ],
+};

package/src/suites/pools.js

@@ -0,0 +1,132 @@
+'use strict';
+
+const { execSync } = require('child_process');
+const { parseJsonOutput } = require('../runner');
+
+/** Fetch the first pool ID from the list; used by info/analyze/top-positions tests. */
+function fetchFirstPoolId() {
+  try {
+    const out = execSync('byreal-cli pools list --page-size 1 -o json', {
+      encoding: 'utf8',
+      timeout: 15000,
+    });
+    const res = parseJsonOutput(out);
+    const pools = res?.data?.pools;
+    if (!Array.isArray(pools) || pools.length === 0) return null;
+    const pool = pools[0];
+    return pool.id || pool.address || pool.poolAddress || null;
+  } catch {
+    return null;
+  }
+}
+
+module.exports = {
+  name: 'pools',
+  cases: [
+    {
+      id: 'pools.list.basic',
+      name: 'List pools (default sort: tvl)',
+      cmd: 'byreal-cli pools list -o json',
+      validate: (stdout, parse) => {
+        const pools = parse(stdout)?.data?.pools;
+        if (!Array.isArray(pools)) return 'data.pools is not an array';
+        if (pools.length === 0) return 'expected non-empty array';
+        return true;
+      },
+      requiresAuth: false,
+    },
+    {
+      id: 'pools.list.sort-apr',
+      name: 'List pools sorted by apr24h',
+      cmd: 'byreal-cli pools list --sort-field apr24h -o json',
+      validate: (stdout, parse) => {
+        const pools = parse(stdout)?.data?.pools;
+        if (!Array.isArray(pools)) return 'data.pools is not an array';
+        if (pools.length === 0) return 'expected non-empty array';
+        return true;
+      },
+      requiresAuth: false,
+    },
+    {
+      id: 'pools.list.sort-volume',
+      name: 'List pools sorted by volumeUsd24h',
+      cmd: 'byreal-cli pools list --sort-field volumeUsd24h -o json',
+      validate: (stdout, parse) => {
+        const pools = parse(stdout)?.data?.pools;
+        if (!Array.isArray(pools)) return 'data.pools is not an array';
+        if (pools.length === 0) return 'expected non-empty array';
+        return true;
+      },
+      requiresAuth: false,
+    },
+    {
+      id: 'pools.list.sort-fee',
+      name: 'List pools sorted by feeUsd24h',
+      cmd: 'byreal-cli pools list --sort-field feeUsd24h -o json',
+      validate: (stdout, parse) => {
+        const pools = parse(stdout)?.data?.pools;
+        if (!Array.isArray(pools)) return 'data.pools is not an array';
+        return true;
+      },
+      requiresAuth: false,
+    },
+    {
+      id: 'pools.list.page-size',
+      name: 'List pools page-size=5',
+      cmd: 'byreal-cli pools list --page-size 5 -o json',
+      validate: (stdout, parse) => {
+        const pools = parse(stdout)?.data?.pools;
+        if (!Array.isArray(pools)) return 'data.pools is not an array';
+        if (pools.length > 5) return `expected ≤5 items, got ${pools.length}`;
+        return true;
+      },
+      requiresAuth: false,
+    },
+    {
+      id: 'pools.list.stable',
+      name: 'List stable pools (category=1)',
+      cmd: 'byreal-cli pools list --category 1 -o json',
+      validate: (stdout, parse) => {
+        const pools = parse(stdout)?.data?.pools;
+        if (!Array.isArray(pools)) return 'data.pools is not an array';
+        return true;
+      },
+      requiresAuth: false,
+    },
+    {
+      id: 'pools.info.basic',
+      name: 'Pool info (first pool from list)',
+      requiresAuth: false,
+      setupFn: fetchFirstPoolId,
+      cmd: (poolId) => `byreal-cli pools info ${poolId} -o json`,
+      validate: (stdout, parse) => {
+        const res = parse(stdout);
+        if (!res?.success) return 'success != true';
+        if (!res?.data || typeof res.data !== 'object') return 'data field missing';
+        return true;
+      },
+    },
+    {
+      id: 'pools.analyze.basic',
+      name: 'Pool analyze (first pool from list)',
+      requiresAuth: false,
+      setupFn: fetchFirstPoolId,
+      cmd: (poolId) => `byreal-cli pools analyze ${poolId}`,
+      validate: (stdout) => {
+        if (stdout.trim().length === 0) return 'empty output';
+        return true;
+      },
+    },
+    {
+      id: 'pools.top-positions.basic',
+      name: 'Top positions in pool',
+      requiresAuth: false,
+      setupFn: fetchFirstPoolId,
+      cmd: (poolId) => `byreal-cli positions top-positions --pool ${poolId}`,
+      validate: (stdout) => {
+        if (stdout.trim().length === 0) return 'empty output';
+        return true;
+      },
+    },
+  ],
+};

package/src/suites/tokens.js

@@ -0,0 +1,35 @@
+'use strict';
+
+module.exports = {
+  name: 'tokens',
+  cases: [
+    {
+      id: 'tokens.list.basic',
+      name: 'List tokens (default)',
+      cmd: 'byreal-cli tokens list -o json',
+      validate: (stdout, parse) => {
+        const tokens = parse(stdout)?.data?.tokens;
+        if (!Array.isArray(tokens)) return 'data.tokens is not an array';
+        if (tokens.length === 0) return 'expected non-empty array';
+        return true;
+      },
+      requiresAuth: false,
+    },
+    {
+      id: 'tokens.list.fields',
+      name: 'Token items have required fields',
+      cmd: 'byreal-cli tokens list --page-size 5 -o json',
+      validate: (stdout, parse) => {
+        const tokens = parse(stdout)?.data?.tokens;
+        if (!Array.isArray(tokens) || tokens.length === 0) return 'expected non-empty array';
+        const token = tokens[0];
+        const requiredFields = ['symbol', 'mint'];
+        for (const f of requiredFields) {
+          if (token[f] === undefined) return `missing field: ${f}`;
+        }
+        return true;
+      },
+      requiresAuth: false,
+    },
+  ],
+};

package/src/suites/wallet.js

@@ -0,0 +1,39 @@
+'use strict';
+
+module.exports = {
+  name: 'wallet',
+  cases: [
+    {
+      id: 'wallet.address',
+      name: 'Wallet address configured',
+      cmd: 'byreal-cli wallet address',
+      validate: (stdout) => {
+        const trimmed = stdout.trim();
+        if (trimmed.length === 0) return 'empty output';
+        if (trimmed.includes('WALLET_NOT_CONFIGURED')) return 'wallet not configured';
+        return true;
+      },
+      requiresAuth: true,
+    },
+    {
+      id: 'wallet.balance',
+      name: 'Wallet balance',
+      cmd: 'byreal-cli wallet balance',
+      validate: (stdout) => {
+        if (stdout.trim().length === 0) return 'empty output';
+        return true;
+      },
+      requiresAuth: true,
+    },
+    {
+      id: 'wallet.info',
+      name: 'Wallet info',
+      cmd: 'byreal-cli wallet info',
+      validate: (stdout) => {
+        if (stdout.trim().length === 0) return 'empty output';
+        return true;
+      },
+      requiresAuth: true,
+    },
+  ],
+};