@bytebrand/export-cars 1.26.46 → 1.26.48

package/test/fixtures/ooyyo/OoyyoFormat.xsd

@@ -0,0 +1,116 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsd:schema elementFormDefault="qualified" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
+    <xsd:element name="ooyyo">
+        <xsd:complexType>
+            <xsd:choice minOccurs="0" maxOccurs="unbounded">
+                <xsd:element ref="ad"/>
+            </xsd:choice>
+        </xsd:complexType>
+    </xsd:element>
+    <xsd:element name="ad">
+        <xsd:complexType mixed="true">
+            <xsd:choice minOccurs="0" maxOccurs="unbounded">
+                <xsd:element ref="url"/>
+                <xsd:element ref="title"/>
+                <xsd:element ref="content"/>
+                <xsd:element ref="price"/>
+                <xsd:element ref="make"/>
+                <xsd:element ref="model"/>
+                <xsd:element ref="engine_size"/>
+                <xsd:element ref="trim"/>
+                <xsd:element ref="body_type"/>
+                <xsd:element ref="color"/>
+                <xsd:element ref="year"/>
+                <xsd:element ref="mileage"/>
+                <xsd:element ref="fuel_type"/>
+                <xsd:element ref="transmission"/>
+                <xsd:element ref="euronorm"/>
+                <xsd:element ref="power"/>
+                <xsd:element ref="doors"/>
+                <xsd:element ref="seats"/>
+                <xsd:element ref="gears"/>
+                <xsd:element ref="location"/>
+                <xsd:element ref="pictures"/>
+                <xsd:element ref="vin"/>
+                <xsd:element ref="is_new"/>
+                <xsd:element ref="date"/>
+                <xsd:element ref="time"/>
+            </xsd:choice>
+        </xsd:complexType>
+    </xsd:element>
+    <xsd:element name="url" type="xsd:string"/>
+    <xsd:element name="title" type="xsd:string"/>
+    <xsd:element name="content" type="xsd:string"/>
+    <xsd:element name="price">
+        <xsd:complexType>
+            <xsd:simpleContent>
+                <xsd:extension base="xsd:string">
+                    <xsd:attribute name="unit" type="xsd:string" use="required"/>
+                </xsd:extension>
+            </xsd:simpleContent>
+        </xsd:complexType>
+    </xsd:element>
+    <xsd:element name="make" type="xsd:string"/>
+    <xsd:element name="model" type="xsd:string"/>
+    <xsd:element name="engine_size">
+        <xsd:complexType>
+            <xsd:simpleContent>
+                <xsd:extension base="xsd:string">
+                    <xsd:attribute name="unit" type="xsd:string" use="required"/>
+                </xsd:extension>
+            </xsd:simpleContent>
+        </xsd:complexType>
+    </xsd:element>
+    <xsd:element name="trim" type="xsd:string"/>
+    <xsd:element name="body_type" type="xsd:string"/>
+    <xsd:element name="color" type="xsd:string"/>
+    <xsd:element name="year" type="xsd:string"/>
+    <xsd:element name="mileage">
+        <xsd:complexType>
+            <xsd:simpleContent>
+                <xsd:extension base="xsd:string">
+                    <xsd:attribute name="unit" type="xsd:string" use="required"/>
+                </xsd:extension>
+            </xsd:simpleContent>
+        </xsd:complexType>
+    </xsd:element>
+    <xsd:element name="fuel_type" type="xsd:string"/>
+    <xsd:element name="transmission" type="xsd:string"/>
+    <xsd:element name="euronorm" type="xsd:string"/>
+    <xsd:element name="power">
+        <xsd:complexType>
+            <xsd:simpleContent>
+                <xsd:extension base="xsd:string">
+                    <xsd:attribute name="unit" type="xsd:string" use="required"/>
+                </xsd:extension>
+            </xsd:simpleContent>
+        </xsd:complexType>
+    </xsd:element>
+    <xsd:element name="doors" type="xsd:string"/>
+    <xsd:element name="seats" type="xsd:string"/>
+    <xsd:element name="gears" type="xsd:string"/>
+    <xsd:element name="location">
+        <xsd:complexType mixed="true">
+            <xsd:choice minOccurs="0" maxOccurs="unbounded">
+                <xsd:element ref="city"/>
+                <xsd:element ref="postcode"/>
+                <xsd:element ref="region"/>
+            </xsd:choice>
+        </xsd:complexType>
+    </xsd:element>
+    <xsd:element name="city" type="xsd:string"/>
+    <xsd:element name="postcode" type="xsd:string"/>
+    <xsd:element name="region" type="xsd:string"/>
+    <xsd:element name="pictures">
+        <xsd:complexType mixed="true">
+            <xsd:choice minOccurs="0" maxOccurs="unbounded">
+                <xsd:element ref="picture"/>
+            </xsd:choice>
+        </xsd:complexType>
+    </xsd:element>
+    <xsd:element name="picture" type="xsd:string"/>
+    <xsd:element name="vin" type="xsd:string"/>
+    <xsd:element name="is_new" type="xsd:string"/>
+    <xsd:element name="date" type="xsd:string"/>
+    <xsd:element name="time" type="xsd:string"/>
+</xsd:schema>

package/test/fixtures/ooyyo.fixture.ts

@@ -0,0 +1,53 @@
+import { car as baseCar, images } from './meinstadt.fixture';
+
+export { NOW, images } from './meinstadt.fixture';
+
+// German labels as @bytebrand/i18n-dictionaries `de` returns them (OoyyoTransformer.translate).
+const LABELS: Record<string, string> = {
+  selector_exteriorColor_red: 'Außenfarbe Rot',
+  selector_category_combi: 'Kombi',
+  selector_category_suv: 'SUV/Geländewagen',
+  selector_fuel_petrol: 'Benzin',
+  selector_fuel_electrical: 'Elektro',
+  selector_gearbox_manualShift: 'Manuell',
+  selector_gearbox_automatic: 'Automatik',
+};
+
+export const translate = (selector: string): string => LABELS[selector] ?? '';
+
+export const region = async (postcode: string): Promise<string> =>
+  ({ '04103': 'Sachsen', '10115': 'Berlin', '80331': 'Bayern' } as Record<string, string>)[postcode] ?? '';
+
+// A complete, sellable OOYYO car (CBD shape as the base export delivers it).
+export const car = (id: string, overrides: Record<string, any> = {}): any => baseCar(id, {
+  'metaData.creationDate': 1783408438, // 07.07.2026 07:13:58 UTC = 09:13 Berlin
+  'metaData.vin': 'WVWZZZ1KZAW000001',
+  'mainData.constructionYear': 2024,
+  'engineData.cubicCapacity': 1199,
+  'driveSuspension.gears': 6,
+  'location.zipCode': 4103,
+  'location.city': 'Leipzig',
+  'location.countryCode': 'DE',
+  'offer.offerDescription': '**Ausstattung**\\\\* ABS\\\\* Klimaanlage\\\\Fahrzeug in gutem Zustand – Prüfung bestanden.',
+  ...overrides,
+});
+
+export const source = (id: string, overrides: Record<string, any> = {}) => ({ car: car(id, overrides), images: images(id) });
+
+// 20 representative cars: makes, used/new, petrol/BEV, postcodes with and without leading zero.
+export const twentyCars = () => Array.from({ length: 20 }, (_, i) => {
+  const id = `car${String(i).padStart(2, '0')}`;
+  const variants: Record<string, any>[] = [
+    {},
+    { 'mainData.make': 'Škoda', 'mainData.model': 'Octavia', 'mainData.subModel': 'Combi 2.0 TDI Größe L' },
+    { 'mainData.condition': 'selector_condition_new', 'mainData.firstRegistration': null, 'mainData.mileage': 0, 'mainData.constructionYear': 2026 },
+    { 'consumption.fuel': 'selector_fuel_electrical', 'engineData.cubicCapacity': null, 'mainData.make': 'Tesla', 'mainData.model': 'Model 3' },
+    { 'location.zipCode': 10115, 'location.city': 'Berlin' },
+    { 'location.zipCode': 80331, 'location.city': 'München', 'mainData.category': 'selector_category_suv' },
+    { 'environmentEmissions.emissionClass': 'selector_unknown' },
+    { 'offer.offerDescription': '' },
+    { 'metaData.vin': 'FAKEVIN' },
+    { 'driveSuspension.gearbox': 'selector_gearbox_automatic', 'price.currentSalesPrice': 26900 },
+  ];
+  return source(id, variants[i % variants.length]);
+});

package/test/mapping-csv.test.ts

@@ -0,0 +1,65 @@
+// Run: npm test (ts-node, no test framework needed)
+// Mapping rules from the public CSV of the mapping sheet tab (no Sheets API key) — pure, no I/O.
+import * as assert from 'node:assert/strict';
+
+import { MappingService, mappingSheetCsvUrl } from '../src/services/mapping.service';
+
+const service = new MappingService({ config: {} } as any);
+
+// Excerpt of the tab mobile_yescar as gviz returns it (13.11.2026): quoted cells, an unnamed column,
+// trailing empty columns, selector rows that group onto the first row of their importField.
+const CSV = [
+  '"importField","importFieldType","autodeField","autodeFieldType","importFieldSelector","autodeFieldSelector","","custom","",""',
+  '"[\'0\']","string","persistentId","string","","","","yes","",""',
+  '"[\'2\']","categoryOrClass_selector","mainData.category","selector","cabrio/roadster","selector_category_convertible","note","","",""',
+  '"[\'2\']","categoryOrClass_selector","mainData.category","selector","Kombi, Van","selector_category_combi","","","",""',
+  '"[\'3\']","string","mainData.make","string","","","","","",""',
+  '"[\'110\']","selector","driveSuspension.gearbox","selector","1","selector_gearbox_manualShift","","","",""',
+  '"[\'110\']","selector","driveSuspension.gearbox","selector","3","selector_gearbox_automatic","","","",""',
+  '"[\'999\']","string","","string","","","","","",""',
+  '',
+].join('\n');
+
+const tests: Array<[string, () => void]> = [
+  ['url: gviz CSV of the tab by title, title URL-encoded, no key', () => {
+    assert.equal(
+      mappingSheetCsvUrl('147qz9sTgs1wi13ua8YKa0IgfxAn1X_qH6LkGnAnzeyY', 'mobile_yescar'),
+      'https://docs.google.com/spreadsheets/d/147qz9sTgs1wi13ua8YKa0IgfxAn1X_qH6LkGnAnzeyY/gviz/tq?tqx=out:csv&sheet=mobile_yescar',
+    );
+    assert.ok(mappingSheetCsvUrl('x', 'a b&c').endsWith('sheet=a%20b%26c'));
+  }],
+
+  ['rules: same post-processing as the Sheets API rows (empty keys dropped, selectors grouped, rows without autodeField out)', () => {
+    const rules = service.rulesFromCsv(CSV, 'mobile_yescar') as any[];
+    assert.deepEqual(rules.map(r => r.importField), ["['0']", "['2']", "['3']", "['110']"]);
+    assert.deepEqual(rules[0], { importField: "['0']", importFieldType: 'string', autodeField: 'persistentId', autodeFieldType: 'string', custom: 'yes' });
+    assert.deepEqual(rules[1].selectors, ['cabrio/roadster:selector_category_convertible', 'Kombi, Van:selector_category_combi']);
+    assert.equal(rules[1].importFieldSelector, undefined);
+    assert.equal(rules[1][''], undefined, 'unnamed column is not part of the rule');
+    assert.deepEqual(rules[3].selectors, ['1:selector_gearbox_manualShift', '3:selector_gearbox_automatic']);
+    assert.deepEqual(Object.keys(rules[2]).sort(), ['autodeField', 'autodeFieldType', 'importField', 'importFieldType']);
+  }],
+
+  ['not the tab (sign-in page / other table) -> error, never an empty mapping', () => {
+    assert.throws(() => service.rulesFromCsv('<!DOCTYPE html><html><body>Sign in</body></html>', 'mobile_yescar'), /not readable as CSV.*shared/);
+    assert.throws(() => service.rulesFromCsv('', 'mobile_yescar'), /not readable as CSV/);
+    assert.throws(() => service.rulesFromCsv('"a","b"\n"1","2"\n', 'mobile_yescar'), /missing columns importField/);
+  }],
+
+  ['a tab with the columns but no usable rule -> error', () => {
+    const header = '"importField","importFieldType","autodeField","autodeFieldType"';
+    assert.throws(() => service.rulesFromCsv(`${header}\n"[\'1\']","string","",""\n`, 'mobile'), /has no rule/);
+  }],
+];
+
+let failed = 0;
+for (const [name, fn] of tests) {
+  try {
+    fn();
+    console.log(`ok   ${name}`);
+  } catch (e) {
+    failed += 1;
+    console.error(`FAIL ${name}\n     ${e.message}`);
+  }
+}
+if (failed) process.exit(1);

package/test/ooyyo-feed-run.test.ts

@@ -0,0 +1,293 @@
+// Run: npm test (ts-node, no test framework needed)
+// Integration (ADV-331): real files in a temp dir (base export snapshot, output, state), real XML
+// builder, read-back verifier, gzip, guard and ADV-336 clean-image selection; only the HTTP image
+// check and the postcode table are faked. Covers the partner's full-replacement risk: a partly valid,
+// empty, stale or collapsed snapshot is never published, the last good file stays.
+import * as assert from 'node:assert/strict';
+import { promises as fs } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { gunzipSync } from 'zlib';
+import { XMLParser } from 'fast-xml-parser';
+
+import { FeedGuard, FeedGuardError, FeedGuardOptions } from '../src/services/feed-guard';
+import { OoyyoFeedRun, OoyyoSourceCar } from '../src/services/ooyyo-feed-run';
+import { verifyOoyyoXml } from '../src/services/ooyyo-feed-verify';
+import { OoyyoXmlBuilder } from '../src/formats/ooyyo-xml.builder';
+import { OoyyoExclusion, toOoyyoImages } from '../src/transformers/ooyyo.transformer';
+import { selectOpenAiImageFields } from '../src/transformers/openai-image-fields';
+import { buildImagesService } from './fixtures/images-service.harness';
+import { NOW, region, source, translate, twentyCars } from './fixtures/ooyyo.fixture';
+
+const HOUR = 60 * 60 * 1000;
+const imagesService = buildImagesService();
+
+interface World {
+  root: string;
+  source: string;
+  xml: string;
+  gz: string;
+  state: string;
+  brokenImages: Set<string>;
+  allImagesBroken: boolean;
+}
+
+const newWorld = async (): Promise<World> => {
+  const root = await fs.mkdtemp(join(tmpdir(), 'ooyyo-'));
+  return {
+    root,
+    source: join(root, 'cars-export'),
+    xml: join(root, 'ooyyo-dryrun', 'ooyyo.xml'),
+    gz: join(root, 'ooyyo-dryrun', 'ooyyo.xml.gz'),
+    state: join(root, 'ooyyo-state', 'dryrun'),
+    brokenImages: new Set(),
+    allImagesBroken: false,
+  };
+};
+
+const writeSource = async (world: World, cars: OoyyoSourceCar[], chunkSize = 5, mtime = NOW) => {
+  await fs.rm(world.source, { recursive: true, force: true });
+  await fs.mkdir(world.source, { recursive: true });
+  for (let i = 0; i * chunkSize < cars.length; i++) {
+    const file = join(world.source, `cars.${i}.json`);
+    await fs.writeFile(file, JSON.stringify(cars.slice(i * chunkSize, (i + 1) * chunkSize)));
+    await fs.utimes(file, mtime, mtime);
+  }
+};
+
+const guardOptions = (world: World, extra: Partial<FeedGuardOptions> = {}): FeedGuardOptions => ({
+  stateDir: world.state,
+  minSourceItems: 1,
+  minPublishedItems: 1,
+  maxDropPercent: 20,
+  maxSourceAgeHours: 26,
+  maxStaleHours: 48,
+  acceptDrop: false,
+  ...extra,
+});
+
+const run = async (world: World, { at = NOW, guard = {} }: { at?: Date; guard?: Partial<FeedGuardOptions> } = {}) => {
+  const forEachChunk = async (fn: (cars: OoyyoSourceCar[]) => Promise<void>) => {
+    const names = (await fs.readdir(world.source)).sort((a, b) => Number(a.split('.')[1]) - Number(b.split('.')[1]));
+    for (const name of names) {
+      await fn(JSON.parse(await fs.readFile(join(world.source, name), 'utf8')));
+    }
+  };
+  const feed = new OoyyoFeedRun(
+    {
+      forEachChunk,
+      filterCar: ({ car: c }) => (c?.metaData?.imagesCount ?? 0) > 0,
+      resolveImages: async ({ car: c, images: list }) => {
+        const clean = imagesService.getCleanImages(c._id, list);
+        const checks = clean.map(i => ({ url: i.url, ok: !world.allImagesBroken && !world.brokenImages.has(i.url) }));
+        return toOoyyoImages(selectOpenAiImageFields(clean, checks));
+      },
+      translate,
+      region,
+      imageStats: () => ({ ok: 1 }),
+      guard: new FeedGuard(guardOptions(world, guard)),
+    },
+    {
+      runId: 'test',
+      dryRun: true,
+      domain: 'auto.de',
+      sourceDirectory: world.source,
+      sourceBaseFileName: 'cars',
+      xmlFile: world.xml,
+      gzFile: world.gz,
+      stateDir: world.state,
+      now: () => at,
+    },
+  );
+  return feed.run();
+};
+
+const blocked = async (promise: Promise<unknown>, code: string) => {
+  await assert.rejects(promise, (error: any) => error instanceof FeedGuardError && error.code === code);
+};
+
+const parse = (xml: string) => new XMLParser({ ignoreAttributes: false, attributeNamePrefix: '@', parseTagValue: false, isArray: n => n === 'ad' || n === 'picture' })
+  .parse(xml).ooyyo;
+const readAds = async (world: World) => parse(await fs.readFile(world.xml, 'utf8')).ad as any[];
+const idsOf = (ads: any[]) => ads.map(ad => String(ad.url).split('/vehicle/')[1].split('?')[0]);
+const exists = (file: string) => fs.stat(file).then(() => true, () => false);
+const report = async (world: World) => JSON.parse(await fs.readFile(join(world.state, 'last-run-report.json'), 'utf8'));
+
+const tests: Array<[string, () => Promise<void>]> = [
+  ['20 representative cars: all published, XML verified, gzip identical, partner rules hold on every ad', async () => {
+    const world = await newWorld();
+    await writeSource(world, twentyCars());
+    const r = await run(world);
+    assert.equal(r.status, 'published');
+    assert.equal(r.items, 20);
+    assert.deepEqual(r.excluded, {});
+    assert.equal(r.verify.issues, 0);
+    const xml = await fs.readFile(world.xml, 'utf8');
+    assert.ok(xml.startsWith('<?xml version="1.0" encoding="UTF-8"?>\n<ooyyo xsi:noNamespaceSchemaLocation="OoyyoFormat.xsd"'));
+    assert.equal(gunzipSync(await fs.readFile(world.gz)).toString('utf8'), xml);
+    assert.deepEqual(verifyOoyyoXml(xml, 20).issues, []);
+    const ads = await readAds(world);
+    assert.equal(ads.length, 20);
+    for (const ad of ads) {
+      assert.equal(ad.price['@unit'], 'EUR');
+      assert.match(ad.price['#text'], /^[1-9]\d*$/);
+      assert.match(ad.year, /^20\d\d$/);
+      assert.ok(ad.pictures.picture.length >= 1);
+      assert.ok(ad.url.length <= 1500);
+      assert.ok(!JSON.stringify(ad).includes('noimage'));
+    }
+    assert.equal(ads[1].make, 'Škoda');
+    assert.equal(ads[1].trim, 'Combi 2.0 TDI Größe L');
+    assert.equal(ads[0].location.postcode, '04103');
+    assert.equal(ads[0].location.region, 'Sachsen');
+    assert.equal(ads[6].euronorm, undefined, 'unknown euronorm left out');
+    assert.equal(ads[7].content, undefined, 'empty description left out');
+    assert.equal(ads[8].vin, undefined, 'malformed VIN left out');
+    // 4103 -> 04103 on every car except the 4 Berlin / München variants
+    assert.equal(r.postcodePadded, 16);
+    assert.equal(r.lastGood.publishedItems, 20);
+    assert.ok(r.bytes.gz < r.bytes.xml);
+  }],
+
+  ['cars OOYYO would reject are excluded with a reason, the rest is published', async () => {
+    const world = await newWorld();
+    const noHero = source('nohero');
+    noHero.images = noHero.images.filter(i => i.imageCodePredicted !== 'ext_f_right');
+    const noPics = source('nopics');
+    noPics.car.metaData.imagesCount = 0;
+    await writeSource(world, [
+      ...twentyCars(),
+      source('car00'), // duplicate id
+      source('sold', { 'offer.offerAvailability': 'selector_offerAvailability_sold' }),
+      source('resv', { 'offer.offerAvailability': 'selector_offerAvailability_reserved' }),
+      source('noprice', { 'price.currentSalesPrice': 0 }),
+      source('sonst', { 'mainData.model': 'SONSTIGE' }),
+      source('noyear', { 'mainData.firstRegistration': null, 'mainData.constructionYear': null }),
+      source('x'.repeat(1500)), // URL > 1,500 characters
+      noHero,
+      noPics,
+    ]);
+    const r = await run(world);
+    assert.equal(r.items, 20);
+    assert.deepEqual(r.excluded, {
+      [OoyyoExclusion.duplicateId]: 1,
+      [OoyyoExclusion.notAvailable]: 2,
+      [OoyyoExclusion.noPrice]: 1,
+      [OoyyoExclusion.noModel]: 1,
+      [OoyyoExclusion.noYear]: 1,
+      [OoyyoExclusion.urlTooLong]: 1,
+      [OoyyoExclusion.noImage]: 1,
+      [OoyyoExclusion.filtered]: 1,
+    });
+    assert.equal(idsOf(await readAds(world)).length, 20);
+  }],
+
+  ['1 bad ad out of 20 in the written file (builder regression): NOT published, live file keeps all 20', async () => {
+    const world = await newWorld();
+    await writeSource(world, twentyCars());
+    await run(world);
+    const goodXml = await fs.readFile(world.xml, 'utf8');
+    const goodGz = await fs.readFile(world.gz);
+    const original = OoyyoXmlBuilder.toXml;
+    let n = 0;
+    OoyyoXmlBuilder.toXml = (item) => {
+      const xml = original(item);
+      n += 1;
+      return n === 7 ? xml.replace('unit="EUR"', 'unit="euro"') : xml;
+    };
+    try {
+      await blocked(run(world, { at: new Date(NOW.getTime() + HOUR) }), 'verify_failed');
+    } finally {
+      OoyyoXmlBuilder.toXml = original;
+    }
+    assert.equal(await fs.readFile(world.xml, 'utf8'), goodXml, 'published XML untouched');
+    assert.ok((await fs.readFile(world.gz)).equals(goodGz), 'published gzip untouched');
+    assert.ok(await exists(`${world.xml}.rejected`));
+    const rep = await report(world);
+    assert.equal(rep.status, 'blocked');
+    assert.equal(rep.verify.issues, 2); // unit + partner price rule, both on ad 6
+    assert.ok(rep.verify.firstIssues.every((i: any) => i.ad === 6));
+    assert.equal(rep.lastGood.publishedItems, 20);
+    assert.ok(!(await exists(world.gz.replace(/\.gz$/, '.tmp.gz'))));
+  }],
+
+  ['zero readable listings (image service down): blocked, last good kept', async () => {
+    const world = await newWorld();
+    await writeSource(world, twentyCars());
+    await run(world);
+    world.allImagesBroken = true;
+    await blocked(run(world, { at: new Date(NOW.getTime() + HOUR) }), 'published_too_small');
+    assert.equal((await readAds(world)).length, 20);
+    assert.deepEqual((await report(world)).excluded, { [OoyyoExclusion.noImage]: 20 });
+  }],
+
+  ['source outage / partial / stale snapshot: blocked before any output is touched', async () => {
+    const world = await newWorld();
+    await writeSource(world, twentyCars());
+    await run(world);
+    const good = await fs.readFile(world.xml, 'utf8');
+    // missing chunk (transport / base export failure mid-way)
+    await fs.rm(join(world.source, 'cars.1.json'));
+    await blocked(run(world), 'source_partial');
+    // empty snapshot
+    await fs.rm(world.source, { recursive: true, force: true });
+    await blocked(run(world), 'source_empty');
+    // stale snapshot (base export did not run for > 26 h)
+    await writeSource(world, twentyCars(), 5, new Date(NOW.getTime() - 27 * HOUR));
+    await blocked(run(world), 'source_stale');
+    assert.equal(await fs.readFile(world.xml, 'utf8'), good);
+  }],
+
+  ['sold / deleted cars leave with the next run (normal sync); a collapse needs acceptDrop', async () => {
+    const world = await newWorld();
+    const cars = twentyCars();
+    await writeSource(world, cars);
+    await run(world);
+    // 2 of 20 sold / deleted: -10 %, published
+    await writeSource(world, cars.slice(2));
+    const r = await run(world, { at: new Date(NOW.getTime() + HOUR) });
+    assert.equal(r.items, 18);
+    assert.ok(!idsOf(await readAds(world)).includes('car00'));
+    // half of the stock gone at once: blocked
+    await writeSource(world, cars.slice(2, 11));
+    await blocked(run(world, { at: new Date(NOW.getTime() + 2 * HOUR) }), 'count_drop');
+    assert.equal((await readAds(world)).length, 18);
+    // a real stock reduction is confirmed once with acceptDrop
+    const accepted = await run(world, { at: new Date(NOW.getTime() + 3 * HOUR), guard: { acceptDrop: true } });
+    assert.equal(accepted.items, 9);
+  }],
+
+  ['stale last good is reported; a concurrent run is locked out', async () => {
+    const world = await newWorld();
+    await writeSource(world, twentyCars());
+    await run(world);
+    world.allImagesBroken = true;
+    const later = new Date(NOW.getTime() + 49 * HOUR);
+    await writeSource(world, twentyCars(), 5, later);
+    await blocked(run(world, { at: later }), 'published_too_small');
+    const rep = await report(world);
+    assert.equal(rep.stale, true);
+    assert.ok(rep.lastGoodAgeHours > 48);
+    world.allImagesBroken = false;
+    await fs.writeFile(join(world.state, 'run.lock'), JSON.stringify({ runId: 'other' }));
+    await blocked(run(world, { at: later }), 'locked');
+  }],
+];
+
+(async () => {
+  let failed = 0;
+  for (const [name, fn] of tests) {
+    try {
+      await fn();
+      console.log(`ok - ${name}`);
+    } catch (error) {
+      failed += 1;
+      console.log(`not ok - ${name}\n${error?.stack ?? error}`);
+    }
+  }
+  if (failed) {
+    console.log(`${failed} of ${tests.length} failed`);
+    process.exit(1);
+  }
+  console.log(`ooyyo-feed-run: ${tests.length} passed`);
+})();