The bug life cycle, alternate states, and handling a "cannot reproduce" defect

// Bug state machine in code
package com.bank.qa;

public enum BugState {
    NEW, ASSIGNED, OPEN, FIXED, RETEST, VERIFIED, CLOSED,
    // Alternate states
    REOPENED, REJECTED, DUPLICATE, DEFERRED, NOT_REPRODUCIBLE
}

public class BugLifecycle {

    private BugState state = BugState.NEW;

    public void assign(String developer) {
        if (state != BugState.NEW && state != BugState.REOPENED) {
            throw new IllegalStateException(
                "Can only assign from NEW or REOPENED, current: " + state
            );
        }
        this.state = BugState.ASSIGNED;
    }

    public void startWork() {
        if (state != BugState.ASSIGNED) {
            throw new IllegalStateException("Must be ASSIGNED first");
        }
        this.state = BugState.OPEN;
    }

    public void markFixed(String commitId) {
        if (state != BugState.OPEN) {
            throw new IllegalStateException("Must be OPEN to fix");
        }
        this.state = BugState.FIXED;
    }

    public void retest() { this.state = BugState.RETEST; }
    public void verify() { this.state = BugState.VERIFIED; }
    public void close()  { this.state = BugState.CLOSED; }
    public void reopen() { this.state = BugState.REOPENED; }
}

// Testing alternate state transitions
package com.bank.qa;

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

public class BugLifecycleTest {

    @Test
    void reopenedBugCanBeReassigned() {
        BugLifecycle bug = new BugLifecycle();
        bug.assign("Rajesh");
        bug.startWork();
        bug.markFixed("abc123");
        bug.retest();
        bug.verify();
        bug.close();
        bug.reopen();  // Bug came back
        bug.assign("Rajesh");  // Re-assign, preserving history
        assertEquals(BugState.ASSIGNED, bug.getState());
    }

    @Test
    void cannotAssignFromFixedState() {
        BugLifecycle bug = new BugLifecycle();
        bug.assign("Rajesh");
        bug.startWork();
        bug.markFixed("abc123");
        assertThrows(IllegalStateException.class, () ->
            bug.assign("Priya")
        );
    }
}

# Capturing a HAR file for network evidence
# In Playwright, record HAR automatically
npx playwright test --grep "failing-test" -- --har=evidence/bug-4521.har

# In Chrome DevTools:
# Network tab -> right-click -> Save all as HAR with content

// Bug report with complete reproduction context
package com.bank.qa;

public class CannotReproduceBugReport {
    String bugId = "BUG-4521";
    String title = "Debit fails for dormant accounts over 180 days";

    // Environment
    String os = "macOS 14.2";
    String browser = "Chrome 121.0.6167.85";
    String environment = "staging-2";
    String appVersion = "v3.14.2 (commit abc123)";

    // Data
    String accountId = "ACC-78901";
    String accountState = "DORMANT (inactive 185 days)";
    String amount = "5000.00";

    // Steps
    String[] steps = {
        "1. Log in as teller user T-001",
        "2. Navigate to /accounts/ACC-78901",
        "3. Click 'Debit' button",
        "4. Enter amount 5000.00",
        "5. Click 'Confirm'",
        "6. ACTUAL: Error 500 'NullPointerException'",
        "7. EXPECTED: Debit processed or clear rejection message"
    };

    // Evidence
    String screenRecording = "evidence/bug-4521-recording.mp4";
    String serverLog = "evidence/bug-4521-server.log";
    String traceId = "trace-abc-123-def-456";
    String harFile = "evidence/bug-4521.har";
}

// Minimal repro: distilled to the smallest failing case
package com.bank.service;

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertThrows;

public class DormantAccountDebitReproTest {

    @Test
    void debitFailsForAccountDormantOver180Days() {
        // Minimal data: just the dormant state matters
        Account account = new Account("ACC-TEST",
            new java.math.BigDecimal("50000.00"));
        account.setLastActivityDate(
            java.time.LocalDate.now().minusDays(185)
        );
        account.setStatus(AccountStatus.DORMANT);

        DebitService service = new DebitService();

        // This is the exact failure: NPE because dormant
        // accounts have null reactivation date
        assertThrows(NullPointerException.class, () ->
            service.debit(account, new java.math.BigDecimal("5000.00"))
        );
    }
}

Original vague report:
  "Sometimes debits fail for some accounts"

Minimal deterministic repro:
  "Debit fails with NullPointerException for any account
   dormant over 180 days, because the reactivation date
   field is null and the debit service does not check
   for null before calling .isAfter()"

// Race condition example: only fails under concurrency
package com.bank.service;

import org.junit.jupiter.api.Test;
import java.util.concurrent.*;
import java.math.BigDecimal;
import static org.junit.jupiter.api.Assertions.assertEquals;

public class RaceConditionReproTest {

    @Test
    void concurrentTransfersRevealRaceCondition() throws Exception {
        Account shared = new Account("ACC-001", new BigDecimal("10000.00"));
        TransferService service = new TransferService();
        ExecutorService executor = Executors.newFixedThreadPool(10);

        // Submit 10 concurrent debits of 1000 each
        var futures = new java.util.ArrayList<Future<?>>();
        for (int i = 0; i < 10; i++) {
            futures.add(executor.submit(() ->
                service.debit(shared, new BigDecimal("1000.00"))
            ));
        }
        for (var f : futures) f.get();
        executor.shutdown();

        // Without synchronization, balance may not be 0
        assertEquals(new BigDecimal("0.00"), shared.getBalance());
    }
}

// Instrumentation for a bug that cannot be reproduced
package com.bank.service;

import java.util.logging.Logger;

public class DebitService {
    private static final Logger log =
        Logger.getLogger(DebitService.class.getName());

    public void debit(Account account, java.math.BigDecimal amount) {
        // Extra logging for BUG-4521 investigation
        log.info(String.format(
            "[BUG-4521] debit called: account=%s status=%s "
            + "lastActivity=%s reactivationDate=%s amount=%s",
            account.getId(), account.getStatus(),
            account.getLastActivityDate(),
            account.getReactivationDate(), amount
        ));

        if (account.getReactivationDate() == null) {
            log.severe("[BUG-4521] reactivationDate is null!");
            // Now we will capture this in production logs
        }
        // ... rest of debit logic
    }
}

// Bug report template as code
package com.bank.qa;

public class BugReportTemplate {
    String id = "BUG-4521";
    String title = "Debit fails for dormant accounts over 180 days";
    String severity = "CRITICAL";
    String priority = null; // Set in triage
    String environment = "staging-2, Chrome 121, macOS 14.2";
    String appVersion = "v3.14.2 (commit abc123)";
    String[] stepsToReproduce = {
        "1. Log in as teller T-001",
        "2. Navigate to /accounts/ACC-78901",
        "3. Click Debit button",
        "4. Enter amount 5000.00",
        "5. Click Confirm",
    };
    String expectedResult = "Debit processed or clear rejection";
    String actualResult = "Error 500 NullPointerException";
    String[] evidence = {
        "screenshot: bug-4521-screenshot.png",
        "video: bug-4521-recording.mp4",
        "trace: trace-abc-123-def-456",
        "server-log: bug-4521-server.log",
    };
    String workaround = "Use accounts active within 180 days";
    int affectedUsers = 1200; // Dormant account holders
}