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)
- 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,166 @@
+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'];
+
+// Each scenario is a routing set registered identically on both services. They
+// stick to slug-backed permalinks because that is Ghost's default shape and the
+// one the reverse lookup queries the DB by; the goal is to prove the two
+// services agree, not to vary permalink columns.
+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/'}
+        ]
+    }
+];
+
+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 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);
+            });
+        });
+    });
+});