Run legacy Mac OS X versions on Apple Silicon with the new Virtual Intel Mac project. Easily virtualize everything from Tiger to Monterey on your modern Mac. Perfect for running older 32-bit Intel or PPC apps. #AppleSilicon #MacOS #Virtualization #RetroComputing

Fixes APP-3542. Follows the APP-2859 investigation. The web List has mounted every loaded row since virtualization was removed in 2023 so lists could scroll the window. Long sessions on a feed keep...

* Why isolated testing matters for resilient microservices * Designing microservice unit tests and component tests that catch real bugs * When to mock, when to virtualize: practical WireMock and Mockito patterns * Producing reliable test data: isolation strategies for persistence * How to measure coverage and prevent flaky tests * Actionable patterns: checklists, templates, and runnable examples You need deterministic, fast feedback from each service before you push a change across teams. _Isolated testing_ is the pragmatic way to give you that feedback—it lets you validate a microservice's business logic, persistence, and API contract without bringing up the entire distributed system. The symptoms are familiar: slow, brittle end-to-end runs that take your CI pipeline from minutes to hours; developers skipping tests because they’re flaky; production failures that started as a subtle contract mismatch; long repro cycles because the bug only shows up when dozens of services are live. Those problems trace back to tests that rely on noisy dependencies and global state instead of exercising a single service in a controlled way. ## Why isolated testing matters for resilient microservices Isolated testing gives you three guarantees that change developer behavior and velocity: _determinism_ , _speed_ , and _localizable failure signals_. When you can verify one service's logic and contract in isolation you reduce coupling between teams and limit blast radius during debugging. Contract testing can then verify integration points without running the world, preventing surprises at deploy time . For example, consumer-driven contract tests catch mismatches that would otherwise only appear in an expensive end-to-end run . * Determinism: Tests that don’t depend on network timing or external rate limits fail only when code is wrong. That reduces false positives and developer context switching. * Speed: Unit and component tests run orders of magnitude faster than environment-heavy E2E pipelines, giving you immediate feedback inside the IDE or CI stage. * Localizable failures: Isolated failures point at a single service boundary and a narrow set of assumptions; root cause analysis becomes a developer task, not a firefighting exercise. > **Important:** big system tests are still necessary for release validation, but they should _complement_ an otherwise comprehensive suite of isolated tests to avoid the cost and flakiness of “only-in-integration” bug discovery. Pact-style contract testing helps bridge that gap without the heavy fragility of full E2E runs . ## Designing microservice unit tests and component tests that catch real bugs Two test tiers matter most for isolation: **microservice unit tests** and **component tests**. * Microservice unit tests: fast, in-process tests that verify pure business logic and edge cases. Use `@ExtendWith(MockitoExtension.class)`-style mocking for in-memory collaborators; keep these tests sub-100ms and deterministic. Don’t mock value objects or simple data holders; mock behaviorful collaborators only . Example `Mockito` unit test (Java / JUnit 5): import static org.mockito.BDDMockito.*; import static org.junit.jupiter.api.Assertions.*; @ExtendWith(MockitoExtension.class) class PricingServiceTest { @Mock ExternalRatesClient ratesClient; @InjectMocks PricingService pricingService; @Test void computesDiscountForPreferredCustomer() { given(ratesClient.getRate("USD")).willReturn(new Rate(1.2)); var result = pricingService.computePrice(100, "USD", /*preferred=*/ true); assertEquals(84, result); // deterministic business logic assertion then(ratesClient).should().getRate("USD"); } } `Mockito`’s idioms and guidance (e.g., _do not mock types you don’t own_) are documented on the framework site. Use `when`/`then` for stubbing and `verify` for interaction checks—only where interactions are part of the contract . * Component tests: exercise the service’s external face (HTTP/gRPC entrypoints, filters, serialization) but keep downstream dependencies simulated. Use lightweight HTTP virtualization (WireMock) to stub other services while running the service under test in a JUnit-managed lifecycle or with `@SpringBootTest`-style slice that starts the web layer . Example WireMock + Spring Boot (conceptual): @ExtendWith(WireMockExtension.class) @SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT) class OrderControllerComponentTest { @RegisterExtension static WireMockExtension wm = WireMockExtension.newInstance() .options(WireMockConfiguration.wireMockConfig().dynamicPort()).build(); @Test void postsEnrichmentAndReturnsOrder() { wm.stubFor(get("/inventory/sku/123").willReturn(aResponse() .withHeader("Content-Type", "application/json") .withBody("{\"inStock\":true}"))); // call controller, assert enriched response } } WireMock runs as a controllable HTTP server and exposes admin APIs for mappings and request logs—perfect for deterministic component tests . Design rules to apply: * Keep unit tests small and focused; favor state verification for logic and behavior verification only when interactions are contract-critical . * Let component tests cover serialization, input validation, and the HTTP contract with mocked downstream services. * Avoid broad “integration” tests that bring up dozens of services for routine change validation. ## When to mock, when to virtualize: practical WireMock and Mockito patterns You need a decision rule that your team can apply quickly: * Use `Mockito` (in-process mocks) when: * The collaborator is a library or DAO you control and you want extremely fast execution. * You need to verify internal interactions or avoid setting up a heavyweight dependency. * You are testing pure computation or business rules. * Use `WireMock` (HTTP service virtualization) when: * The dependency is an HTTP API or external microservice you cannot run locally cheaply. * You need to assert request/response shapes, headers, and error codes. * You want to capture and replay real responses during test development . * Use `Testcontainers` (real containers) when: * You must test against a real database, broker, or service binary because in-memory alternatives differ too much from production behavior. * You need to exercise SQL dialect specifics, real transactions, or native extensions . Tool comparison (quick reference): Tool | Primary use | Strength | Trade-off ---|---|---|--- **Mockito** | In-process unit tests | Fast, expressive, integrates with JUnit 5. | Can't simulate network or HTTP-layer behavior. **WireMock** | HTTP service virtualization | Realistic HTTP behavior, record/playback, admin API. | Only simulates network; provider contract still needs verification. **Testcontainers** | Containerized integration (DBs, brokers) | Runs real binaries; reliable environment parity. | Slower; CI must support Docker. **Pact / Contract tests** | Consumer-driven contract verification | Prevents contract drift without full E2E. | Extra CI coordination for provider verification. WireMock practical pattern — record & replay + strict verification: * Record a small set of realistic HTTP interactions from a staging provider. * Keep those recordings minimal (only what your consumer needs). * Add verification steps in the test to assert the _shape_ of outgoing requests. * Persist the stub mappings as test artifacts so CI can use the same inputs . Mockito anti-patterns to avoid: * Mocking types you don't own (creates brittle tests). * Mocking across modules instead of relying on fakes or small in-memory implementations where appropriate . ## Producing reliable test data: isolation strategies for persistence Persistence is the most common source of test instability. Use explicit strategies rather than ad-hoc SQL dumps. Patterns I use daily: 1. Migration-first test DB: run `flyway`/`liquibase` in your test startup so schema evolution is tested with the code and your migrations are repeatable . 2. Ephemeral DB per test worker: use Testcontainers to spin up a fresh Postgres/MySQL instance per CI worker or test suite, or use a unique schema name to avoid cross-test leakage . 3. Minimal, idempotent seed data: load the smallest dataset necessary for the scenario using SQL fixtures or data builders; keep seed scripts separate from schema migrations. 4. Snapshot/restore for heavy datasets: for large, expensive datasets take a snapshot and restore it per pipeline node to speed up provisioning. 5. Parallel-safe schema naming: if tests run in parallel, create per-worker schemas like `test_<pipeline_id>_<worker>` and have migrations target that schema. Example Testcontainers Postgres snippet (Java): PostgreSQLContainer<?> pg = new PostgreSQLContainer<>("postgres:15") .withDatabaseName("testdb") .withUsername("test") .withPassword("test"); pg.start(); // wire app under test to pg.getJdbcUrl(), run Flyway migrate, run tests. Running `Flyway` as part of the test bootstrap (or as a CI step) ensures your schema matches production migration order and reduces surprises . Use `clean` + `migrate` in disposable test contexts, but never enable `cleanOnValidationError` in production automation . ## How to measure coverage and prevent flaky tests Coverage without test quality is a vanity metric. Use code coverage tools to **measure gaps** , then use mutation testing to validate the tests themselves. * Use **JaCoCo** to collect line/branch/method coverage in Java builds and fail CI when critical modules regress coverage below team-agreed thresholds . * Use **PIT / PITEST** mutation testing periodically to surface missing assertions and low-quality tests; if a mutant survives, add a test that would kill it or harden assertions . But coverage is only one axis. Flaky tests eat velocity—Google’s testing teams documented that nondeterministic tests are costly and that larger tests tend to flake more often; many flakiness causes are environmental (timing, external services, resource contention) . Address the causes directly: * Avoid hard `Thread.sleep()` calls; prefer explicit waits or polling with timeouts. * Replace network calls with virtualized endpoints in component tests. * Use containerized databases per test run to eliminate shared state. * Quarantine tests with repeated failures rather than letting them silently erode trust. * Collect and attach detailed logs and thread dumps on failure for forensic analysis. > **Callout:** Google reports that a non-trivial fraction of large tests are flaky and that reruns and quarantines are necessary mitigations until root causes are fixed. Treat flakiness as a first-class engineering problem, not an inconvenience. Checklist to reduce flakiness: * Use deterministic clocks (`Clock` injection or `Clock.fixed(...)` in Java) for time-sensitive logic. * Replace external HTTP with WireMock scenarios during CI. * Ensure test parallelism is safe: unique DB/schema per worker. * Fail builds on resource/time budget breaches rather than silently retrying forever. ## Actionable patterns: checklists, templates, and runnable examples The following is a compact, runnable protocol you can adopt this week to get reliable isolated tests. 1. Local developer loop (goal: < 3 minutes feedback) * Run unit tests with `mvn -DskipITs test` (Mockito for in-process doubles). * Run a small component test profile that starts WireMock and an in-memory slice of your app (`./mvnw -Pcomponent-test`). 2. CI loop (goal: fast, deterministic pre-merge) * Run unit tests + JaCoCo coverage. * Run component tests that use WireMock stubs committed to the repo (no live network). * Run a limited integration stage with Testcontainers for DB compatibility and Flyway migrations. 3. Pre-release (goal: final assurance) * Execute contract verification (Pact provider tests for any consumer contracts). * Run a small set of fast smoke E2E scenarios against a production-like environment. Executable docker-compose snippet for a reproducible component test sandbox (save as `docker-compose.yml` and include `mappings/` for WireMock stubs): version: '3.8' services: postgres: image: postgres:15 environment: POSTGRES_DB: testdb POSTGRES_USER: test POSTGRES_PASSWORD: test ports: - "5432:5432" healthcheck: test: ["CMD-SHELL", "pg_isready -U test"] interval: 5s retries: 5 wiremock: image: wiremock/wiremock:3.0.0 volumes: - ./mappings:/home/wiremock/mappings:ro ports: - "8081:8080" Quick replication recipe (3 commands): docker compose up -d # run Flyway migrations against jdbc:postgresql://localhost:5432/testdb mvn -Dflyway.url=jdbc:postgresql://localhost:5432/testdb -Dflyway.user=test \ -Dflyway.password=test -q flyway:clean flyway:migrate # run your component tests pointing to WireMock at http://localhost:8081 mvn -Pcomponent-test test Practical test checklist to copy into PR templates: * [ ] Unit tests added for new business logic (100% of new logic branches). * [ ] Component test created or updated that stubs downstream HTTP with WireMock. * [ ] DB migrations included and executed in a disposable environment (Flyway). * [ ] No hard `sleep()` in test code; explicit waits used. * [ ] Coverage thresholds and mutation test baseline recorded. Sources Stubbing | WireMock - Official WireMock documentation describing stubbing, mapping persistence, and server usage used to show how to create and manage HTTP stubs and scenarios. Mockito framework site - Official Mockito guidance and philosophy, including recommendations like _do not mock types you don’t own_. Testcontainers - Documentation and quickstarts for running real databases and other dependencies in disposable containers for tests. Pact Docs - Overview of consumer-driven contract testing and how contract tests reduce brittle full-system integration. Flaky Tests at Google and How We Mitigate Them (Google Testing Blog) - Analysis and mitigation patterns for flaky tests and their impact on engineering velocity. Test Double (Martin Fowler) - Definitions of test doubles (mocks, stubs, fakes) and the trade-offs between state vs behaviour verification. Introduction to WireMock | Baeldung - Practical examples integrating WireMock with JUnit and Spring Boot; useful for component-test patterns and code snippets. JaCoCo Java Code Coverage Library - Official JaCoCo documentation for capturing coverage metrics in Java builds. JUnit 5 User Guide - Lifecycle and extension guidance for building deterministic unit and component tests in Java. Flyway / Redgate Documentation - Flyway configuration and migration practices for keeping test schemas aligned with production migrations. PIT Mutation Testing (pitest) - Mutation testing tooling for Java to validate test quality beyond coverage. .

Summary of Changes Fixes an issue where visiting a custom labeler profile with a large list of declared labels on desktop web causes Chrome tabs to freeze, lag severely, or crash with an &quot;Aw, ...

Check out the Chaotic: Virtualize community on Discord - hang out with 19 other members and enjoy free voice and text chat.