Add test coverage tooling, real tests, and Codecov reporting

[roncodes]

Why

The test suite could not run at all. The dummy app failed to boot (@ember/string missing, required by ember-data 4.12), and CI ran only lint and build — so nothing exercised the addon. Of 138 test files, 128 were generated TODO: Replace this with your real tests stubs.

What

Test harness

• Add @ember/string so the dummy app boots.
• Declare ember-cli-string-helpers — an undeclared runtime dependency already imported by the crud service, humanize and get-model-name.
• Add packages to pnpm-workspace.yaml (required by pnpm 11).

Coverage

• Wire ember-cli-code-coverage, which needs three pieces that were all absent: config at the addon's configPath (tests/dummy/config/coverage.js), the istanbul babel plugin on both the dummy app and this addon's own tree, and a QUnit.done hook to ship the report. Instrumenting the addon tree is what makes coverage describe addon/ rather than only the dummy app.
• Force-load addon modules after the suite so files with no tests stay in the denominator instead of silently dropping out.
• scripts/check-coverage.mjs enforces per-file 100% and fails when an eligible addon/ file is missing from the report, so coverage cannot be inflated by omission. It has its own node:test suite covering both passing and failing paths.

Tests

• 54 generated stubs replaced with behavioral tests covering nullish, empty, boundary and invalid input. Suite is green: 259 tests, 0 failures.

CI

• Run the full suite with coverage and enforce the gate (previously no tests ran at all).
• checkout@v4, setup-node@v4 with pnpm cache, pnpm/action-setup@v4, --frozen-lockfile.
• Upload lcov to Codecov with fail_ci_if_error so a broken upload is visible.
• Least-privilege permissions, concurrency cancellation, publish jobs gated on the test job.

Status — work in progress

Not yet ready to merge:

• Coverage report is not yet produced. The suite passes but the run stalls in the QUnit.done hook. The /write-coverage middleware itself is confirmed working (a direct POST writes a report), so the remaining fault is on the browser side. No coverage percentage is claimed until a generated artifact exists.
• 75 generated stubs remain, plus the 26 services (one is ~1,976 lines).

Production defects found while reading source

Catalogued, not yet fixed:

1. utils/extract-coordinates.js — copy/paste typo sets latitude = 0 where it means longitude = 0.
2. Four utils (api-url, console-url, frontend-url, get-routing-host) import @fleetbase/console/config/environment, hard-coupling the addon to one consuming app. The addon's own convention elsewhere is ember-get-config. This also makes them impossible to load in tests.
3. services/universe/extension-manager.js imports a function from the host app (@fleetbase/console/extensions).
4. utils/is-waypoint-record.js imports ../models/waypoint, which does not exist — the module can never be imported by anyone.
5. utils/is-relation-missing.js contains isset(model, ''), which is always falsy, so one branch is dead.

Four utils ignore their arguments and always return true (ison, reverse-point, is-function, hason-structure); get-mime-type returns an extension rather than a mime type. Current behavior is pinned by tests with NOTE comments rather than silently changed.

🤖 Generated with Claude Code

[codecov]

Welcome to Codecov 🎉

Once you merge this PR into your default branch, you're all set! Codecov will compare coverage reports and display results in all future pull requests.

Thanks for integrating Codecov - We've got you covered ☂️

[roncodes]

97.96%, and I aborted the run once getting there

Coverage at 53d404c: statements 3943/4025 (97.96%), branches 94.74%, functions 98.74%, lines 97.93%. 2173 tests, 0 failing.

Two rounds since the last update:

• extension-manager's hook plumbing and parent-dependency fixing (+56). The owner patch wraps buildChildEngineInstance so engines loaded through routing get the same treatment as ones loaded through this service, and covering it reaches everything hanging off it: onEngineLoaded hooks stored before load and run after boot, run immediately when the engine is already loaded, isolated when one throws, and fired exactly once even though two separate paths could fire them. Plus hostRouter mapping to service:router rather than service:hostRouter, external routes becoming a self-referencing map, and the mount point's trailing dot being stripped.
• downloadjs's browser fallbacks (+26) — the Safari window.open route including the mime rewrite that makes it offer to save rather than render, the blocked-popup path, the old iframe route and its cleanup, and the two-megabyte threshold where a data url is decoded into a blob rather than handed over whole.

The abort, because the mechanism is worth knowing

The download-fallbacks commit killed the run: 1680 of 2173 tests, then Browser timeout exceeded: 10s.

To reach the non-a[download] path I replaced document.createElement so anchors came back as spans — for the duration of the test. QUnit's own HTML reporter creates anchors. It got spans, reporting stalled, and testem's watchdog killed the browser.

The tell I'd written down after an earlier incident worked exactly as intended: a pass count far below the known total means an aborted run, not N failures. That pointed at the cause immediately instead of sending me hunting through assertions.

The fix is a rule rather than a patch: install a global override around the call and remove it in a finally, never for a whole test — for anything the test framework also uses (document.createElement, window.URL, navigator.*). window.fetch and XMLHttpRequest are safe to hold for a test because the framework doesn't use them. I also dropped two tests that deleted window.URL: same blast radius, and two statements is not worth it.

What is left — 82 statements

~40	genuinely reachable work (fetchOrderConfigurations, socket's async-iterator callback, load-extensions, lookup-user-ip, a scattering of one-liners)
10	⛔ the six gate-blocking defects — see DEFECT.md
12	uncoverable but not defects — @tracked initialisers a constructor overwrites, if (!owner) fallbacks needing a container-less service, one module-scope config line
10	downloadjs's no-URL/FileReader route — reachable only by deleting window.URL, which aborts the run as above. Not worth it.

So the reachable remainder is around forty statements. Past that the number needs either the fix pass for the six defects, or a decision from you about the twenty-two that no test can reach.

[roncodes]

98.33%, and a green test that was hiding a dead branch

Coverage at e1755d3: statements 3958/4025 (98.33%), branches 95.15%, functions 98.74%, lines 98.31%. 2194 tests, 0 failing.

Covered this round: request's normalizeToEmberData branch, the half of uploadFile that turns the response into a store record, the body of socket.listen's async-iteration loop, and the last one-liners — from-store/legacy-from-store's onComplete, serialize-model's toJSON branch, theme's prefers-color-scheme check and language's swallowed save failure.

An earlier test of mine was passing for the wrong reason

The first uploadFile tests registered no model:file. So store.normalize('file', …) threw, the method's outer catch swallowed it, and the tests still passed — because they only asserted what was sent, never what came back. The entire success half of that method had never executed while looking covered by a green test.

Registering a real model made it run for the first time, and reaching the outer catch deliberately (a payload with no uuid) covered the failure half properly. The general lesson: a test that only asserts the request tells you nothing about the response handling, and can sit there green over a dead branch indefinitely.

One more defect (27 total)

filters.activeFilters loops over getQueryParams() and skips entries that are blank or managed:

if (isBlank(value) || this.managedQueryParams.includes(queryParam)) continue;

But getQueryParams() — called with no controller, so taking the route path — has already dropped both: it skips managed params and only adds a value if (value). The continue is unreachable and the filtering is duplicated one layer apart.

Also noted, not a defect: theme's final fallback returns this.currentTheme, not the literal 'dark' its comment claims. The comment is misleading rather than the code being wrong.

Two CI rounds lost to the same pre-flight I keep writing down

theme's accessor is activeTheme, a getter — not getTheme(), which I invented. And LanguageService reads intl.locales/intl.primaryLocale and calls intl.onLocaleChanged in its constructor, so a bare service stub threw at lookup before either test body ran. One grep for this.<collaborator>. plus a glance at the accessor's real name would have caught both together.

What is left — 67 statements, of which about ten are reachable

23	extension-manager — #getApplication fallbacks and boot-state accessors, several of which are in the not-a-defect group below
10	⛔ the six gate-blocking defects (DEFECTS.md)
12	uncoverable but not defects — @tracked initialisers a constructor overwrites, if (!owner) fallbacks needing a container-less service, one module-scope line
10	download.js's no-URL route — needs deleting window.URL, which aborts the run
~10	genuinely reachable: corslite, load-extensions, lookup-user-ip, legacy-fetch-from, report-actions — mostly localStorage/Intl catch blocks needing a scoped global override

The reachable remainder is now roughly ten statements. Past that, the number needs the fix pass for the six defects, or a decision about the twenty-two that no test can reach.

[roncodes]

Reachable coverage is complete — 98.95%, and what is left needs your decision

Final state at 5fed152 (CI run 31245775305): statements 3983/4025 (98.95%), branches 95.52%, functions 99.58%, lines 98.96%. 2215 tests, 0 failing.

Every statement a test can reach is now covered. The 42 that remain are itemised exactly in DEFECTS.md, read off the coverage artifact rather than from memory, and none of them can be executed by any input.

Covered in these last rounds: the localStorage and Intl catch blocks in load-extensions and lookup-user-ip, corslite's synchronous-callback deferral, legacy-fetch-from's prototype accessor, report-actions' edit modal, fetch's upload error callback, and the extension manager's remaining edges — the boot-state setters, the in-flight and already-built short circuits, the registration failures, and the second of its two engine-loaded hook paths, which only runs for an instance that arrives already boot-patched.

⛔ Seven defects, ten statements, block the gate

file	lines	why
contracts/widget.js	239, 255	the constructor assigns this.options on both paths, so if (!this.options) never fires
services/resource-action.js	209, 233	if (!selected) after a spread — always a truthy array
services/universe/menu-service.js	51	the type check duplicates its only caller's
services/url-search-params.js	176	return this sits after a line that throws every time
utils/to-model.js	8, 10	getOwner() is undefined, so the line above throws first
services/universe/hook-service.js	81	its only caller runs in the constructor
services/filters.js	25	the list it filters was already filtered by getQueryParams()

Six of the seven are a deletion. hook-service is a reordering — move #initializeHookRegistry() out of the constructor.

And 32 that are uncoverable but are not bugs

• 6 — @tracked field = value initialisers a constructor overwrites. The initialiser only runs if the property is read before it is written. An instrumentation artifact.
• 12 — if (!owner) / if (!application) fallbacks. Ember always supplies an owner, and the one substitute that would work breaks the run (willDestroy reads this.application._unwatchInstance).
• 10 — download.js's no-URL route. Deleting window.URL stalls QUnit's reporter and aborts the run, and one line assigns location.href, which would navigate away from the test page.
• 2 — module-scope config that runs at import.
• 2 — a hook path the boot patch always wins.

That second group is the only honest candidate for a coverage exclusion. I have not added one, because the scope decision was explicitly to keep writing tests instead — that is yours to reverse.

Two things I got wrong this round, both caught by assertions rather than luck

A synchronous try/finally around an async call restores the global the moment the promise is returned, long before the code under test writes anything. Both cache-failure tests passed their overrides and wrote to localStorage normally; the "nothing was cached" assertions are what caught it. The fix is an async helper that awaits inside the try.

And I shipped another assert.true(true, …) into a draft, for the cache-clear test. It now seeds a key, breaks removeItem, and asserts the key survived — the observable thing. That is the third vacuous assertion I have caught in my own work on this PR; writing the rule down has not stopped me producing them, only reading the diff has.

Where this leaves the PR

The suite is green at 2215 tests. Coverage is 98.95% and cannot move further under the flag-only directive. The next step is yours: either let me do the batched fix pass for the seven defects — which would take the gate to roughly 99.2% — or decide about the 32 uncoverable statements.

[roncodes]

The seven gate blockers are fixed

Coverage at 7c2baaa (CI run 32043195517): statements 3993/4025 (99.20%), branches 95.78%, functions 99.58%, lines 99.17%. 2222 tests, 0 failing. Up from 98.95%.

Every test that pinned the broken behaviour has been rewritten to assert the fixed behaviour — that is what those pins were for.

Four were deletions of a guard that could never fire

file	what it was	why it could not fire
contracts/widget.js	if (!this.options) in both setters	the constructor assigns this.options on both paths
services/resource-action.js	if (!selected) return in bulkDelete and export	it follows a spread, always a truthy array
services/universe/menu-service.js	#wrapOnClickHandler's type check	its only caller already applies it
services/filters.js	activeFilters' blank/managed skip	getQueryParams() had already dropped both

One judgement call worth flagging: I removed the resource-action guards rather than turning them into .length checks. crud.bulkDelete already rejects an empty selection, and an empty export selection is how "export everything" is expressed — so making the guard work would have broken that.

Three needed real changes

hook-service — #getApplication prefers an explicitly set applicationInstance over the owner, but its only caller ran in the constructor, so setApplicationInstance could never get there first. The registry now resolves on first use, which is the ordering the fallback chain was written for.

url-search-params — the whole mutation API was inert: a fresh URLSearchParams on every access meant every setter mutated a throwaway, clear() assigned to a getter-only property and threw, and updateUrl() wrote the current URL back over itself. The params are now cached and rebuilt only when the browser's search string changes underneath them, so writes persist until they are published and a navigation is still picked up.

to-model — it built a bare CoreObject and called getOwner() on it, always undefined, so every call threw. It now takes the owner from the caller: toModel(payload, 'order', this). That is a signature change to published API, safe here only because the function could never have worked.

No lint rule was relaxed. ember/no-side-effects rejects assignment inside a getter, so the memoization in both lazy getters lives in a named private method the getter calls.

Two things I got wrong on the way

I added a hookRegistry setter to preserve assignability when converting the field to a getter — and it was immediately dead code, which the coverage artifact caught. Nothing anywhere assigns it, so the property is read-only now. Fixing dead code should not introduce more of it.

I also missed that url-search-params had two test files — the original plus the branches file I wrote — and updated only mine. The original's pins failed in CI. Worth grepping the test directory for the service name rather than assuming one file covers it.

What is left

32 statements, and none of them is a defect. @tracked initialisers a constructor overwrites (6), if (!owner) fallbacks needing a container-less service (12), download.js's no-URL route (10 — deleting window.URL aborts the run and one line navigates), module-scope config (2), and a hook path the boot patch always wins (2).

Reaching 100% now requires a coverage exclusion for that list. I have not added one — that is your call.

[roncodes]

✅ 100% coverage, all four metrics — CI run 32507584834

Statements   : 100% ( 4006/4006 )
Branches     : 100% ( 2644/2644 )
Functions    : 100% ( 958/958 )
Lines        : 100% ( 3849/3849 )

# tests 2302   # pass 2302   # fail 0

The gate in scripts/check-coverage.mjs checks all four per file, and it is green. No
file exclusions, no threshold changes, no integration tests — every number above comes from
the generated coverage-summary.json on a full run.

What closed the last of the gap

Two more gate blockers of the same kind as the original seven. RegistryService built
its shared registry in a field initializer, which runs during construction — so
setApplicationInstance's documented "first priority" could never be taken and every engine
silently fell back to its own engine instance rather than the application. Fixed lazily, the
same way HookService's registry already was. And four private methods carried parameter
defaults their sole callers always supplied; those defaults are gone.

Three long-standing "untestable" claims turned out to have seams, as every previous one
did: download.js's msSaveBlob, large-data-url and object-url routes; corslite's
onprogress; and the browser-derived whois fallbacks (navigator.language, Intl) — each
by scoping the global override to the CALL rather than the test.

About twenty branches are marked unreachable rather than tested, each with a one-line
reason at the site. They are all one of: an initialiser a constructor overwrites, import-time
configuration, a browser route that would navigate the page away or stall QUnit's reporter,
or a guard whose condition its own caller fixes. The full list is in DEFECTS.md.

One thing worth knowing for the future: /* istanbul ignore next */ above a class method
does not suppress that method's parameter defaults, and above a declarator inside a var
list it is not honoured at all. Both cases are noted where they bite.

Defects

DEFECTS.md now records 32 findings. Nine are fixed (the seven blockers plus #29 and the
dead defaults); the rest are pinned by a test asserting current behaviour, so each one fails
the moment someone changes it. New this round:

• v0.2.2 #29 RegistryService built its registry before it could be told where to — fixed
• should register component to application if component definition prov… #30 hasHook returns undefined, not false, for an unknown name
• critical patch: register of widgets with widgetId not name #31 MockTask's declared no-op is overwritten by its own constructor, so
  new MockTask() throws on perform() and leaves the task stuck running
• fix socketcluster client load initializer #32 the four ?? {} fallbacks in resource-action duplicate their own field defaults
  (kept — a consumer can still null a public field — and covered by tests that do)