Exploratory Testing Deep Dive — Beyond Scripted Testing

// test-charter-manager.js
class TestCharter {
  constructor({ area, focus, resources, duration, heuristics }) {
    this.area = area;
    this.focus = focus;
    this.resources = resources;
    this.duration = duration;
    this.heuristics = heuristics;
    this.notes = [];
    this.bugs = [];
    this.startTime = null;
  }

  begin() {
    this.startTime = new Date();
    console.log('=== New Exploratory Session ===');
    console.log(`Charter: Explore ${this.area}`);
    console.log(`Focus: ${this.focus}`);
    console.log(`Duration: ${this.duration} minutes`);
    console.log(`Heuristics: ${this.heuristics.join(', ')}\n`);
  }

  note(observation) {
    this.notes.push({
      time: new Date() - this.startTime,
      observation,
    });
    console.log(`[${Math.round((new Date() - this.startTime) / 1000)}s] ${observation}`);
  }

  foundBug(severity, description, steps) {
    this.bugs.push({ severity, description, steps });
    console.log(`  BUG FOUND [${severity}]: ${description}`);
    console.log(`  Steps: ${steps.join(' -> ')}`);
  }

  end() {
    const elapsed = Math.round((new Date() - this.startTime) / 60000);
    console.log('\n=== Session Summary ===');
    console.log(`Duration: ${elapsed} minutes`);
    console.log(`Notes taken: ${this.notes.length}`);
    console.log(`Bugs found: ${this.bugs.length}`);

    const bySeverity = { critical: 0, major: 0, minor: 0 };
    this.bugs.forEach(b => bySeverity[b.severity]++);
    console.log(`  Critical: ${bySeverity.critical}`);
    console.log(`  Major: ${bySeverity.major}`);
    console.log(`  Minor: ${bySeverity.minor}`);
  }
}

const charter = new TestCharter({
  area: 'Checkout flow — discount application',
  focus: 'Multiple discount codes interaction with cart updates',
  resources: ['Staging environment', 'test-cards.pdf', 'Charles proxy'],
  duration: 90,
  heuristics: ['CRUD sequence variation', 'Boundary testing', 'Concurrent access'],
});

charter.begin();
charter.note('Applied discount code SAVE10 — works');
charter.note('Applied SECOND discount CODE20 — discounts stacked correctly');
charter.note('Removed first discount — total recalculated correctly');
charter.note('Changed quantity — discount percentage stays correct');

charter.foundBug('critical',
  'Removing last item from cart with discount applied causes negative total',
  ['Add item A', 'Apply discount SAVE10', 'Remove item A', 'Click checkout']
);

charter.foundBug('major',
  'Discount code applied after coupon expiry bypasses validation on refresh',
  ['Open expired discount link', 'Apply code on checkout',
   'Navigate away', 'Return to checkout — discount still applied']
);

charter.end();

class HeuristicOracle {
  constructor(name, question, indicators) {
    this.name = name;
    this.question = question;
    this.indicators = indicators;
  }

  evaluate(systemBehavior) {
    console.log(`\nOracle: ${this.name}`);
    console.log(`  Question: ${this.question}`);

    const findings = [];
    this.indicators.forEach(indicator => {
      if (systemBehavior.includes(indicator)) {
        findings.push({
          indicator,
          potential_issue: `${indicator} detected — investigate "${this.name}" heuristic`,
        });
      }
    });
    return findings;
  }
}

const oracles = [
  new HeuristicOracle(
    'Consistency',
    'Does the system behave consistently across similar scenarios?',
    ['different results', 'inconsistent', 'unexpected format']
  ),
  new HeuristicOracle(
    'History',
    'Does the system behave as it used to?',
    ['changed behavior', 'regression', 'missing']
  ),
  new HeuristicOracle(
    'Identity',
    'Does the system accurately reflect its state?',
    ['stale data', 'wrong status', 'incorrect count']
  ),
  new HeuristicOracle(
    'Scope',
    'Does the change affect only what it should?',
    ['side effect', 'also changed', 'leaked']
  ),
];

const testObservations = [
  'Search results show inconsistent counts',
  'Profile page shows stale data after update',
  'Side effect: changing theme also resets font size',
];

console.log('=== Heuristic Oracle Analysis ===\n');
testObservations.forEach(obs => {
  console.log(`Observation: "${obs}"`);
  oracles.forEach(oracle => {
    const findings = oracle.evaluate(obs);
    findings.forEach(f =>
      console.log(`  ALERT: ${f.potential_issue}`));
  });
  console.log();
});

console.log('Heuristics applied: 4');
console.log('Use these oracles to guide exploration');

import time
from datetime import datetime

class ExploratorySession:
    def __init__(self, tester, charter, duration_minutes):
        self.tester = tester
        self.charter = charter
        self.duration = duration_minutes
        self.start = None
        self.end = None
        self.tasks = []
        self.bugs = []
        self.coverage = set()

    def __enter__(self):
        self.start = datetime.now()
        print(f"[{self.start.strftime('%H:%M:%S')}] Session started")
        print(f"  Tester: {self.tester}")
        print(f"  Charter: {self.charter}")
        print(f"  Timebox: {self.duration} minutes\n")
        return self

    def explore(self, area, actions, findings=None):
        self.tasks.append({
            "area": area,
            "actions": actions,
            "findings": findings or []
        })
        self.coverage.add(area)

        prefix = f"[{area}]"
        print(f"  {prefix} Exploring: {actions}")
        if findings:
            for f in findings:
                print(f"    -> {f}")

    def report_bug(self, severity, title, steps):
        self.bugs.append({
            "severity": severity,
            "title": title,
            "steps": steps,
            "timestamp": datetime.now()
        })

    def __exit__(self, *args):
        self.end = datetime.now()
        elapsed = (self.end - self.start).total_seconds() / 60
        print(f"\n[{self.end.strftime('%H:%M:%S')}] Session ended")
        print(f"  Elapsed: {elapsed:.1f}/{self.duration} minutes")
        print(f"  Areas explored: {len(self.coverage)}")
        print(f"  Bugs found: {len(self.bugs)}")
        print(f"  Coverage: {', '.join(sorted(self.coverage))}")

        if self.bugs:
            print(f"\n  Bug Summary:")
            for bug in self.bugs:
                print(f"    [{bug['severity'].upper()}] {bug['title']}")

        print(f"\n  Session {'INCOMPLETE' if elapsed < self.duration * 0.8 else 'COMPLETE'}")

with ExploratorySession("Alice", "Explore file upload with concurrent access", 30) as session:
    session.explore("Upload", "Single file upload (PDF, 2MB)",
        ["Upload complete in 3s", "Progress bar accurate"])
    session.explore("Upload", "Multiple file upload (5 files, varied sizes)",
        ["All files uploaded", "Order preserved in list"])
    session.explore("Upload", "Concurrent upload from two tabs",
        ["Both progress bars displayed separately"])
    session.report_bug("critical", "Upload overwrites file with same name without warning",
        ["Upload file named report.pdf", "Upload another report.pdf",
         "First file silently replaced"])
    session.explore("Delete", "Delete while upload in progress",
        ["Delete button disabled during upload — good UX"])
    session.report_bug("major", "Upload progress bar stuck at 99% for large files (100MB+)",
        ["Upload 100MB PDF", "Progress reaches 99%", "Stays at 99% for 30s", "Then completes"])