API Maker
The backend engine for the AI era
CoverageEpisode 62 6:46 14 chapters November 2026
Which lines of your backend did the tests really run? Turn on one switch and every run of the test cases counts its lines, in TypeScript, Python, PHP, C#, Go, Rust, Java and Kotlin. See the report of a run, the red lines no test reached, the two tests that cover them, a utility class of Python in the same report, and the same coverage in VS Code, WebStorm and CI.
In the playlists The complete course Testing & debugging
Which lines of your backend did the tests really run? In this video, every run of the test cases answers that, file by file and line by line. It works in TypeScript, in Python, and in six more languages. You see it on the page, in your editor, and in CI.
Measuring coverage is usually hard. You need a coverage tool for each language: c8 for Node, coverage dot py, go test dash cover, and JaCoCo for Java. Each one has its own report. You merge the reports in CI. And code that runs on a server is rarely measured at all. With API Maker, there is one switch, and every run of the test cases counts its lines. There is one report for every language, by the files of your repository.
There is lcov for VS Code and WebStorm. And the numbers come in the answer of one API call, for CI. In this video: the switch and a run, the report, the lines of a file, two tests for the red lines, Python and its utility classes, how each language counts, npm run test and your editor, and CI.
Test Cases is on the dashboard. Delivery Fee, a custom API of Calm Home, has a test case with two tests. At the bottom of the list is a switch: Collect the code coverage. It is on by default for the runs of this browser, and it slows a run a little. The test case runs Delivery Fee twice: first a parcel of two kilos, then one of ten, both in the city.
Click Run. Two of two pass.
Open the Coverage tab of the run. Most of the lines ran, but not all. There are three files: the custom API Delivery Fee, the utility class pricing slash Rates that it uses, and the test case itself. The lowest comes first, so what needs a test is at the top.
Here is Delivery Fee, line by line. Green shows the lines that ran. Red shows the lines no test reached. Lines eight and nine were missed, where a parcel without a weight is refused. So were twelve and thirteen, where express doubles the fee. A line without a mark holds no code. And next, in pricing slash Rates, the rate of the country never ran either. Here is how lines of TypeScript are counted.
A test run starts the V8 profiler in the sandbox of the account. The code is compiled again, with a counter on every block. And each count goes back to its line of TypeScript, through the source map. Counting starts with the run, and stops when it ends. The code that serves your API is never changed.
Back to the test case. We add two tests for the red lines: an express parcel to the country, which costs twice as much, and a parcel of zero kilos, which is refused. Save, and Run. Four of four pass. Every file is at one hundred percent, so every line ran.
Loyalty Points is a custom API written in Python. It takes the tier of a customer from loyalty slash Tiers, a Python utility class, and its test case is in Python too. Click Run all. Six of six pass. There are six files, each with the badge of its language. In Tiers, in Python, all lines ran. And then, in Loyalty Points, the refusal of an order without a total never ran.
Every language counts its own lines, in a build made for the test run. TypeScript uses the V8 profiler and the source map. Python uses sys dot monitoring. Go uses go tool cover. PHP, C sharp, and Rust use a counter before each statement. Java and Kotlin use counters written into their compiled classes. Custom APIs, test cases, and utility classes, in all eight languages, go into one report.
Clear coverage removes the coverage of the last run, but its results stay. Clear results removes both. The last run is kept for thirty days, so the page shows it again after a reload.
In the folder of the local client, npm run test runs the same tests on the server, and prints the coverage of every file. It writes coverage slash lcov dot info, with the paths of your files. Then Coverage Gutters in VS Code, or Show Coverage Data in WebStorm, mark the lines in your editor.
For CI, a run is one call: POST run, with coverage set to true. The answer holds the results, and the coverage of every file, with its totals. npm run test exits with zero when everything passed. It also writes coverage-summary dot json, in the shape that istanbul uses, so a job can require a minimum coverage.
Good to know. A sandbox on Bun has no profiler. The run says so, and counts no TypeScript. Java and Kotlin count their lines on JDK twenty four and later. Hooks, events, and schedulers that ran during the tests are named in a warning, but not counted. And a very large report keeps only its totals, until the next run.
Here are the best practices. Read the red lines, not only the percentage. Each one is a case that no test checks. Mock g dot sys to reach the error paths. Keep coverage on in CI, with a minimum. And run the tests after every change. The next run shows what the change left untested.
To sum up. With one switch, every run of the test cases counts its lines. The report lists every file: the test cases, the custom APIs they ran, and the utility classes they used. Red lines show what no test reached. Eight languages are each counted in their own way. And npm run test brings it to your editor, and to CI. Next: debugging, from a failing call to the line that broke.
API Maker. Build faster, spend smarter, deliver better.
Length 9:10Debugging
Length 6:32Test cases
Length 5:28Languages
Length 6:03Utility classes