<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>testing on Aftermarket.dev</title>
    <link>https://aftermarket.dev/tags/testing/</link>
    <description>Recent content in testing on Aftermarket.dev</description>
    <generator>Hugo -- gohugo.io</generator>
    <language>en-us</language>
    <lastBuildDate>Sat, 31 Oct 2026 00:00:00 +0000</lastBuildDate><atom:link href="https://aftermarket.dev/tags/testing/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>AfterDiff Gets a Live Shadow Mode to Test New Versions on Real Traffic</title>
      <link>https://aftermarket.dev/afterdiff-gets-a-live-shadow-mode-to-test-new-versions-on-real-traffic/</link>
      <pubDate>Sat, 31 Oct 2026 00:00:00 +0000</pubDate>
      
      <guid>https://aftermarket.dev/afterdiff-gets-a-live-shadow-mode-to-test-new-versions-on-real-traffic/</guid>
      <description>Aftermarket 0.10.0 adds aftermarket shadow. It&amp;rsquo;s AfterDiff, but on live traffic instead of a recording.
Replay is good at one thing. You record what a client sends, play it to the old and the new version, and read the differences. But a recording only holds what happened while it ran. The odd request that comes once a week isn&amp;rsquo;t in the file, and neither is the client nobody remembered.
Shadow puts the new version next to the old one while real users keep going.</description>
    </item>
    
    <item>
      <title>Aftermarket Fixes Five Shadow Mode Bugs Found in Review</title>
      <link>https://aftermarket.dev/aftermarket-fixes-five-shadow-mode-bugs-found-in-review/</link>
      <pubDate>Sat, 31 Oct 2026 00:00:00 +0000</pubDate>
      
      <guid>https://aftermarket.dev/aftermarket-fixes-five-shadow-mode-bugs-found-in-review/</guid>
      <description>Aftermarket 0.10.1 is a fix release for aftermarket shadow, the live mode of AfterDiff that came out earlier today. A second reviewer went through it looking for ways to break its promises, and found five real bugs. None of them touched what clients get back from the primary. They were about what the candidate got and what the report said.
Here&amp;rsquo;s the list.
Stopping made the candidate look broken. On Ctrl-C, shadow waits a while for queued copies and then stops.</description>
    </item>
    
    <item>
      <title>How AfterBridge Was Tested</title>
      <link>https://aftermarket.dev/how-afterbridge-was-tested/</link>
      <pubDate>Thu, 22 Oct 2026 00:00:00 +0000</pubDate>
      
      <guid>https://aftermarket.dev/how-afterbridge-was-tested/</guid>
      <description>AfterBridge makes four promises. The files it reads are never written. Nothing a request sends reaches SQL or the file system. A file that is half written is never served. And every answer is exactly what the file holds, values and types alike. Most of the testing went into the third and the fourth, because that&amp;rsquo;s where reading someone else&amp;rsquo;s files goes wrong.
Half files The main test has a writer rewriting an export over and over, in random pieces, sometimes stopping in the middle of a line, with short pauses, while requests keep coming.</description>
    </item>
    
    <item>
      <title>How AfterConfig Was Tested to Never Write a Vendor Config File</title>
      <link>https://aftermarket.dev/how-afterconfig-was-tested-to-never-write-a-vendor-config-file/</link>
      <pubDate>Wed, 21 Oct 2026 00:00:00 +0000</pubDate>
      
      <guid>https://aftermarket.dev/how-afterconfig-was-tested-to-never-write-a-vendor-config-file/</guid>
      <description>AfterConfig makes four promises, and the tests go after each one. It never writes the vendor&amp;rsquo;s file. It never changes what the overlay doesn&amp;rsquo;t name. A failed apply leaves the old output alone. And it never prints a secret.
The vendor&amp;rsquo;s file The test makes the vendor&amp;rsquo;s file read-only and runs every command against it. Then it names that file as the output in six ways: directly, through a symbolic link, through a hard link, through a linked folder, as a relative path, and with a .</description>
    </item>
    
    <item>
      <title>How AfterGuard Was Tested to Let Nothing Ambiguous Through</title>
      <link>https://aftermarket.dev/how-afterguard-was-tested-to-let-nothing-ambiguous-through/</link>
      <pubDate>Wed, 21 Oct 2026 00:00:00 +0000</pubDate>
      
      <guid>https://aftermarket.dev/how-afterguard-was-tested-to-let-nothing-ambiguous-through/</guid>
      <description>A security gateway is only as good as its worst gap, so AfterGuard got a written threat model before any code, and every promise in it got a test. Six promises: nothing ambiguous gets through, a denied request never reaches the app, allowed traffic passes byte for byte, limits hold and memory stays bounded, a client can&amp;rsquo;t choose its identity or address, and no secret reaches a log.
Nothing ambiguous This is the one that matters most.</description>
    </item>
    
    <item>
      <title>How AfterHook Was Tested to Turn Every Change Into One Event</title>
      <link>https://aftermarket.dev/how-afterhook-was-tested-to-turn-every-change-into-one-event/</link>
      <pubDate>Wed, 21 Oct 2026 00:00:00 +0000</pubDate>
      
      <guid>https://aftermarket.dev/how-afterhook-was-tested-to-turn-every-change-into-one-event/</guid>
      <description>AfterHook makes four promises. Every change gives exactly one event. Nothing is lost while the receiver is down or across restarts. A source that didn&amp;rsquo;t change by meaning sends nothing. And a half-written file is never reported. The tests go after each one, with a fake clock so a test can jump past retry waits without sleeping through them.
One change, one event A random test makes 200 edits to a JSON file.</description>
    </item>
    
    <item>
      <title>How AfterSchema Was Tested</title>
      <link>https://aftermarket.dev/how-afterschema-was-tested/</link>
      <pubDate>Wed, 21 Oct 2026 00:00:00 +0000</pubDate>
      
      <guid>https://aftermarket.dev/how-afterschema-was-tested/</guid>
      <description>AfterSchema makes two promises that matter. It never writes a database. And when schema test says an old read gives the same rows through the views, it does: same values, same types, same column names. The tests go after both.
Same rows, checked hard The main test builds random tables, then a new version of each with renamed columns, numbers stored times 100, and columns split in two. It writes a mapping that should give the old values back and runs reads over every column against both.</description>
    </item>
    
    <item>
      <title>How TOML Support in AfterConfig Was Tested</title>
      <link>https://aftermarket.dev/how-toml-support-in-afterconfig-was-tested/</link>
      <pubDate>Wed, 21 Oct 2026 00:00:00 +0000</pubDate>
      
      <guid>https://aftermarket.dev/how-toml-support-in-afterconfig-was-tested/</guid>
      <description>TOML in AfterConfig makes one promise on top of the old ones: the output is the vendor&amp;rsquo;s file with only your changes in it. Comments, spacing and every untouched line come through byte for byte. The tests try to catch it breaking that, or getting a value wrong while keeping the layout.
Reading TOML the way the spec does AfterConfig has its own TOML reader, since the project uses no outside libraries.</description>
    </item>
    
    <item>
      <title>How AfterAPI Was Tested Against an Old Client Test Suite</title>
      <link>https://aftermarket.dev/how-afterapi-was-tested-against-an-old-client-test-suite/</link>
      <pubDate>Tue, 20 Oct 2026 00:00:00 +0000</pubDate>
      
      <guid>https://aftermarket.dev/how-afterapi-was-tested-against-an-old-client-test-suite/</guid>
      <description>AfterAPI makes one main promise: an old client keeps working against a new API, and nothing it doesn&amp;rsquo;t cover gets touched. The tests were written to try to break that promise.
An old client with its own test suite The example in examples/customer-api has three parts. There&amp;rsquo;s a v1 service, a v2 service with a different shape, and the old client&amp;rsquo;s test suite. The suite has twelve checks, and they&amp;rsquo;re strict.</description>
    </item>
    
    <item>
      <title>How AfterTest and AfterDiff Were Tested With Secrets in Every Request</title>
      <link>https://aftermarket.dev/how-aftertest-and-afterdiff-were-tested-with-secrets-in-every-request/</link>
      <pubDate>Tue, 20 Oct 2026 00:00:00 +0000</pubDate>
      
      <guid>https://aftermarket.dev/how-aftertest-and-afterdiff-were-tested-with-secrets-in-every-request/</guid>
      <description>A recorder sits on real traffic and writes it to disk. So it makes two promises, and the tests go after both. It must not change a single byte on the way through. And no secret may end up in the file.
Not a byte changed One test sends 300 random requests straight to a test server and then through record, and compares what each side saw. The traffic is deliberately awkward: binary bodies, gzip, chunked bodies, bodies of unknown length, %2F and ü in paths, ; in query strings, HEAD, 204 and 304.</description>
    </item>
    
    <item>
      <title>How AfterPatch Was Tested Before Its First Release</title>
      <link>https://aftermarket.dev/how-afterpatch-was-tested-before-its-first-release/</link>
      <pubDate>Mon, 19 Oct 2026 00:00:00 +0000</pubDate>
      
      <guid>https://aftermarket.dev/how-afterpatch-was-tested-before-its-first-release/</guid>
      <description>A repair tool earns trust in one way: it has to leave alone everything it isn&amp;rsquo;t supposed to touch. So most of the AfterPatch tests don&amp;rsquo;t check the repairs. They check what happens around them.
Every number here comes from the recorded results in the repository&amp;rsquo;s test/results folder, written by a script, not by hand.
The headline test The first test sends 400 random requests straight to a test server, then sends the same 400 through AfterPatch.</description>
    </item>
    
  </channel>
</rss>
