Added eager/lazy URL service parity coverage

ref https://linear.app/ghost/issue/HKG-1817

- the whole point of this milestone is to swap the eager service for the lazy one without changing any URL, so the lazy service is only trustworthy if it provably returns the same answer as the eager service for the same inputs; this integration test is that proof, run against real fixtures and a real findResource over the model layer
- drove both services from one identical routing set per scenario and fed the lazy service the exact records the eager service cached, so any difference the test reports is a routing-logic divergence and not a data-shape artefact
- compared all three directions a caller depends on: forward (relative and absolute URL for every cached resource, including the resources that resolve to /404/), ownership (every router against every resource), and reverse (every eager-generated URL resolves back to the same resource and type)
- asserted the reverse lookup returns the same record shape as the eager service, not just the same id and type: exact field-set parity, matching slug/name, no leaked title, and relations trimmed to {id, slug}, so a divergence like lazy returning the post body or untrimmed author rows can't slip through
- added a date-based permalink scenario and asserted both services 404 a wrong-date variant of a generated URL, locking the canonical re-check so lazy can't resolve a non-canonical URL the eager service rejects
- added a featured-collection scenario alongside the default set specifically to exercise priority fallthrough; this is what caught the ownership exclusivity bug now fixed in the service, where a catch-all router claimed resources already owned by a higher-priority collection
- guarded against a vacuous pass by asserting the fixtures actually produce cached resources and generated URLs, so the parity assertions can never silently iterate over nothing

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: vershwal

ghost/core/test/integration/url-service-parity.test.js

@@ -0,0 +1,229 @@
+const assert = require('node:assert/strict');
+const sinon = require('sinon');
+const testUtils = require('../utils');
+const models = require('../../core/server/models');
+const UrlService = require('../../core/server/services/url/url-service');
+const LazyUrlService = require('../../core/server/services/url/lazy-url-service');
+const {createFindResource} = require('../../core/server/services/url/lazy-find-resource');
+
+const RESOURCE_TYPES = ['posts', 'pages', 'tags', 'authors'];
+
+// Routing sets registered identically on both services. Slug-backed permalinks
+// only, since that is Ghost's default shape and the one resolveUrl queries by.
+const SCENARIOS = [
+    {
+        name: 'default routing set',
+        routes: [
+            {identifier: 'posts-router', filter: 'featured:false', resourceType: 'posts', permalink: '/:slug/'},
+            {identifier: 'authors-router', filter: null, resourceType: 'authors', permalink: '/author/:slug/'},
+            {identifier: 'tags-router', filter: null, resourceType: 'tags', permalink: '/tag/:slug/'},
+            {identifier: 'pages-router', filter: null, resourceType: 'pages', permalink: '/:slug/'}
+        ]
+    },
+    {
+        name: 'featured collection with priority fallthrough',
+        routes: [
+            {identifier: 'featured-router', filter: 'featured:true', resourceType: 'posts', permalink: '/featured/:slug/'},
+            {identifier: 'posts-router', filter: null, resourceType: 'posts', permalink: '/:slug/'},
+            {identifier: 'tags-router', filter: null, resourceType: 'tags', permalink: '/tag/:slug/'},
+            {identifier: 'authors-router', filter: null, resourceType: 'authors', permalink: '/author/:slug/'}
+        ]
+    },
+    {
+        name: 'date-based post permalinks',
+        routes: [
+            {identifier: 'posts-router', filter: null, resourceType: 'posts', permalink: '/:year/:month/:slug/'},
+            {identifier: 'tags-router', filter: null, resourceType: 'tags', permalink: '/tag/:slug/'},
+            {identifier: 'authors-router', filter: null, resourceType: 'authors', permalink: '/author/:slug/'}
+        ]
+    }
+];
+
+function waitUntilFinished(urlService, timeout = 5000) {
+    return new Promise((resolve, reject) => {
+        const start = Date.now();
+        (function retry() {
+            if (urlService.hasFinished()) {
+                return resolve();
+            }
+            if (Date.now() - start > timeout) {
+                return reject(new Error('Eager UrlService did not finish in time'));
+            }
+            setTimeout(retry, 50);
+        })();
+    });
+}
+
+describe('Integration: eager/lazy URL service parity', function () {
+    before(testUtils.teardownDb);
+    before(testUtils.setup('users:roles', 'posts'));
+    after(testUtils.teardownDb);
+
+    after(function () {
+        sinon.restore();
+    });
+
+    SCENARIOS.forEach(function (scenario) {
+        describe(scenario.name, function () {
+            let eager;
+            let lazy;
+
+            before(async function () {
+                eager = new UrlService();
+                scenario.routes.forEach(r => eager.onRouterAddedType(r.identifier, r.filter, r.resourceType, r.permalink));
+                eager.init();
+                await waitUntilFinished(eager);
+
+                lazy = new LazyUrlService({findResource: createFindResource(models)});
+                scenario.routes.forEach(r => lazy.onRouterAddedType(r.identifier, r.filter, r.resourceType, r.permalink));
+            });
+
+            after(function () {
+                eager.reset();
+            });
+
+            function cachedResourcesByType() {
+                return RESOURCE_TYPES.map(type => ({
+                    type,
+                    resources: eager.resources.getAllByType(type) || []
+                }));
+            }
+
+            function allGeneratedUrls() {
+                const urls = [];
+                eager.urlGenerators.forEach((generator) => {
+                    generator.getUrls().forEach((entry) => {
+                        urls.push({url: entry.url, id: entry.resource.data.id});
+                    });
+                });
+                return urls;
+            }
+
+            it('loaded a non-trivial fixture set so the comparison is not vacuous', function () {
+                const total = cachedResourcesByType().reduce((sum, group) => sum + group.resources.length, 0);
+                assert.ok(total > 0, 'expected the eager service to cache at least one resource');
+                assert.ok(allGeneratedUrls().length > 0, 'expected the eager service to generate at least one url');
+            });
+
+            it('forward lookup returns the same relative URL for every cached resource', function () {
+                for (const {type, resources} of cachedResourcesByType()) {
+                    for (const resource of resources) {
+                        const id = resource.data.id;
+                        const lazyResource = Object.assign({}, resource.data, {type});
+
+                        assert.equal(
+                            lazy.getUrlForResource(lazyResource),
+                            eager.getUrlByResourceId(id),
+                            `relative URL mismatch for ${type} ${id}`
+                        );
+                    }
+                }
+            });
+
+            it('forward lookup returns the same absolute URL for every cached resource', function () {
+                for (const {type, resources} of cachedResourcesByType()) {
+                    for (const resource of resources) {
+                        const id = resource.data.id;
+                        const lazyResource = Object.assign({}, resource.data, {type});
+
+                        assert.equal(
+                            lazy.getUrlForResource(lazyResource, {absolute: true}),
+                            eager.getUrlByResourceId(id, {absolute: true}),
+                            `absolute URL mismatch for ${type} ${id}`
+                        );
+                    }
+                }
+            });
+
+            it('agrees with the eager service on which router owns each resource', function () {
+                for (const {type, resources} of cachedResourcesByType()) {
+                    for (const resource of resources) {
+                        const id = resource.data.id;
+                        const lazyResource = Object.assign({}, resource.data, {type});
+
+                        for (const route of scenario.routes) {
+                            assert.equal(
+                                lazy.ownsResource(route.identifier, lazyResource),
+                                eager.owns(route.identifier, id),
+                                `ownership mismatch for router ${route.identifier} and ${type} ${id}`
+                            );
+                        }
+                    }
+                }
+            });
+
+            it('reverse lookup resolves every eager-generated URL to the same resource', async function () {
+                for (const {url, id} of allGeneratedUrls()) {
+                    const eagerEnvelope = eager.getResource(url);
+                    const resolved = await lazy.resolveUrl(url);
+
+                    assert.ok(resolved, `lazy resolveUrl returned null for ${url}`);
+                    assert.equal(resolved.id, id, `resolved id mismatch for ${url}`);
+                    assert.equal(resolved.type, eagerEnvelope.config.type, `resolved type mismatch for ${url}`);
+                }
+            });
+
+            it('reverse lookup returns the same record shape as the eager service', async function () {
+                for (const {url} of allGeneratedUrls()) {
+                    const eagerEnvelope = eager.getResource(url);
+                    const eagerFlat = Object.assign({}, eagerEnvelope.data, {type: eagerEnvelope.config.type});
+                    const resolved = await lazy.resolveUrl(url);
+
+                    // Exact field-set parity guards against lazy leaking fields the
+                    // eager backend strips (e.g. title/html/mobiledoc on posts,
+                    // email on authors), which would change downstream behaviour.
+                    assert.deepEqual(
+                        Object.keys(resolved).sort(),
+                        Object.keys(eagerFlat).sort(),
+                        `field-set mismatch for ${url}`
+                    );
+
+                    assert.equal(resolved.slug, eagerFlat.slug, `slug mismatch for ${url}`);
+                    if ('name' in eagerFlat) {
+                        assert.equal(resolved.name, eagerFlat.name, `name mismatch for ${url}`);
+                    }
+                    assert.ok(!('title' in resolved), `lazy leaked title for ${url}`);
+
+                    // Relations stay trimmed to {id, slug} like eager's withRelatedFields.
+                    for (const key of ['tags', 'authors']) {
+                        if (Array.isArray(resolved[key])) {
+                            resolved[key].forEach((relation) => {
+                                assert.deepEqual(
+                                    Object.keys(relation).sort(),
+                                    ['id', 'slug'],
+                                    `${key} relation not trimmed for ${url}`
+                                );
+                            });
+                        }
+                    }
+                }
+            });
+
+            it('reverse lookup returns null for an unknown URL, like the eager service', async function () {
+                assert.equal(eager.getResource('/this-does-not-exist/'), null);
+                assert.equal(await lazy.resolveUrl('/this-does-not-exist/'), null);
+            });
+
+            if (scenario.routes.some(r => r.permalink.includes(':year'))) {
+                it('agrees with the eager service that a non-canonical (wrong-date) URL 404s', async function () {
+                    let checked = 0;
+                    for (const {url} of allGeneratedUrls()) {
+                        const yearMatch = url.match(/^\/(\d{4})\//);
+                        if (!yearMatch) {
+                            continue;
+                        }
+                        // Swap the year for one the post wasn't published in: a
+                        // valid permalink shape that is not this post's canonical
+                        // URL, so both services must reject it.
+                        const variant = url.replace(/^\/\d{4}\//, `/${Number(yearMatch[1]) - 1}/`);
+
+                        assert.equal(eager.getResource(variant), null, `eager resolved non-canonical ${variant}`);
+                        assert.equal(await lazy.resolveUrl(variant), null, `lazy resolved non-canonical ${variant}`);
+                        checked += 1;
+                    }
+                    assert.ok(checked > 0, 'expected at least one date-based URL to mutate');
+                });
+            }
+        });
+    });
+});