BookKeeper Server Testing

class ServerTester {
    // Constructors
    ServerTester(ServerConfiguration conf) throws Exception;
    ServerTester(ServerConfiguration conf, Bookie b) throws Exception;
    
    // Auto Recovery Management
    void startAutoRecovery() throws Exception;
    void stopAutoRecovery();
    Auditor getAuditor();
    ReplicationWorker getReplicationWorker();
    
    // Access Methods
    ServerConfiguration getConfiguration();
    BookieServer getServer();
    TestStatsProvider getStatsProvider();
    BookieSocketAddress getAddress();
    
    // Resource Management
    void shutdown() throws Exception;
}

static class MockUncleanShutdownDetection implements UncleanShutdownDetection {
    // Lifecycle Registration
    void registerStartUp();
    void registerCleanShutdown();
    
    // State Queries
    boolean lastShutdownWasUnclean();
    boolean getStartRegistered();
    boolean getShutdownRegistered();
}

class ServerConfiguration extends AbstractConfiguration {
    // Common configuration methods for BookKeeper server
    // (This is part of the BookKeeper API, not defined in testmocks)
}

interface UncleanShutdownDetection {
    void registerStartUp();
    void registerCleanShutdown();
    boolean lastShutdownWasUnclean();
}

class BookieServer {
    // BookKeeper server instance
    // (Part of BookKeeper server API)
}

class Auditor {
    // Auto-recovery auditor component
    // (Part of BookKeeper auto-recovery)
}

class ReplicationWorker {
    // Auto-recovery replication worker
    // (Part of BookKeeper auto-recovery)
}

class BookieSocketAddress {
    // Bookie network address
    // (Part of BookKeeper API)
}

import org.apache.bookkeeper.test.ServerTester;
import org.apache.bookkeeper.conf.ServerConfiguration;

// Create server configuration
ServerConfiguration conf = new ServerConfiguration();
conf.setBookiePort(0); // Use ephemeral port
conf.setJournalDirName("/tmp/bk-journal");
conf.setLedgerDirNames(new String[]{"/tmp/bk-ledgers"});
conf.setMetadataServiceUri("zk+null://localhost/ledgers");

// Create and start server tester
ServerTester serverTester = new ServerTester(conf);

// Access server components
BookieServer server = serverTester.getServer();
BookieSocketAddress address = serverTester.getAddress();
TestStatsProvider statsProvider = serverTester.getStatsProvider();

System.out.println("Server running on: " + address);

// Shutdown when done
serverTester.shutdown();

ServerConfiguration conf = new ServerConfiguration();
// Configure as above...

ServerTester serverTester = new ServerTester(conf);

// Start auto-recovery components
serverTester.startAutoRecovery();

// Access auto-recovery components
Auditor auditor = serverTester.getAuditor();
ReplicationWorker replicationWorker = serverTester.getReplicationWorker();

// Test auto-recovery functionality
// (perform operations that trigger recovery)

// Stop auto-recovery
serverTester.stopAutoRecovery();

// Shutdown server
serverTester.shutdown();

import org.apache.bookkeeper.bookie.Bookie;

ServerConfiguration conf = new ServerConfiguration();
// Configure as above...

// Create custom bookie instance
Bookie customBookie = new Bookie(conf);

// Create server tester with custom bookie
ServerTester serverTester = new ServerTester(conf, customBookie);

// Test with custom bookie behavior
// ...

serverTester.shutdown();

import org.apache.bookkeeper.test.ServerTester.MockUncleanShutdownDetection;

// Create mock shutdown detection
MockUncleanShutdownDetection shutdownDetection = new MockUncleanShutdownDetection();

// Simulate server startup
shutdownDetection.registerStartUp();
assert shutdownDetection.getStartRegistered();

// Simulate clean shutdown
shutdownDetection.registerCleanShutdown();
assert shutdownDetection.getShutdownRegistered();
assert !shutdownDetection.lastShutdownWasUnclean();

// Test unclean shutdown scenario
MockUncleanShutdownDetection uncleanDetection = new MockUncleanShutdownDetection();
uncleanDetection.registerStartUp();
// Don't register clean shutdown
assert uncleanDetection.lastShutdownWasUnclean();

ServerTester serverTester = new ServerTester(conf);
TestStatsProvider statsProvider = serverTester.getStatsProvider();

// Access statistics during testing
TestStatsProvider.TestOpStatsLogger opStats = statsProvider.getOpStatsLogger("test.operation");
TestStatsProvider.TestCounter counter = statsProvider.getCounter("test.counter");

// Perform operations and verify statistics
// ...

// Check collected statistics
long successCount = opStats.getSuccessCount();
double avgLatency = opStats.getSuccessAverage();
long counterValue = counter.get();

System.out.println("Operations: " + successCount + ", Avg latency: " + avgLatency);

serverTester.shutdown();

public class BookKeeperIntegrationTest {
    private ServerTester serverTester;
    private PulsarMockBookKeeper mockBk;
    
    @Before
    public void setUp() throws Exception {
        // Set up server
        ServerConfiguration conf = new ServerConfiguration();
        conf.setBookiePort(0);
        conf.setJournalDirName(createTempDir());
        conf.setLedgerDirNames(new String[]{createTempDir()});
        
        serverTester = new ServerTester(conf);
        
        // Set up client
        OrderedExecutor executor = OrderedExecutor.newBuilder()
            .numThreads(1)
            .name("test")
            .build();
        mockBk = new PulsarMockBookKeeper(executor);
    }
    
    @Test
    public void testServerClientInteraction() throws Exception {
        // Test server and client together
        LedgerHandle ledger = mockBk.createLedger(DigestType.CRC32, "password".getBytes());
        ledger.addEntry("test".getBytes());
        
        // Verify server statistics
        TestStatsProvider stats = serverTester.getStatsProvider();
        // Check relevant metrics...
        
        ledger.close();
    }
    
    @After
    public void tearDown() throws Exception {
        if (mockBk != null) {
            mockBk.close();
        }
        if (serverTester != null) {
            serverTester.shutdown();
        }
    }
}