@bytebrand/export-cars 1.26.39 → 1.26.41

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

@@ -0,0 +1,365 @@
+// Run: npm test (ts-node, no test framework needed)
+// ADV-319 acceptance: 20 real vehicle cases plus sold / reserved / no image / price change /
+// source outage / duplicate id, and the guard (stale source, count drop, lock, atomic publish).
+// Integration: real files in a temp dir (base export snapshot, output, state), the real
+// CriteoTransformer, GoogleXmlBuilder and FeedGuard; only the marketing image lookup is faked.
+// The 20 cars are anonymized copies of DEV base export cars (05.11.2026): synthetic ids, only the
+// fields the Criteo mapping reads, no dealer data.
+import * as assert from 'node:assert/strict';
+import { promises as fs } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+
+import { FeedGuard, FeedGuardError, FeedGuardOptions } from '../src/services/feed-guard';
+import { CriteoFeedRun, CriteoRunReport, CriteoSourceCar } from '../src/services/criteo-feed-run';
+import { CriteoTransformer } from '../src/transformers/criteo.transformer';
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const REAL_CARS: any[] = require('./fixtures/criteo-20-cases.json');
+
+const NOW = new Date('2026-11-06T08:00:00Z');
+const HOUR = 60 * 60 * 1000;
+const id = (n: number) => `00000000-0000-4000-8000-${String(n).padStart(12, '0')}`;
+const imageUrl = (carId: string) => `https://images.autode-dev.de/generated_images/x/${carId}/criteo-Test.jpg`;
+
+interface World {
+  root: string;
+  source: string;
+  xml: string;
+  state: string;
+  noImage: Set<string>;
+}
+
+const newWorld = async (): Promise<World> => {
+  const root = await fs.mkdtemp(join(tmpdir(), 'criteo-'));
+  return {
+    root,
+    source: join(root, 'cars-export'),
+    xml: join(root, 'criteo-export', 'api_export_cars_criteo.xml'),
+    state: join(root, 'criteo-state'),
+    noImage: new Set(),
+  };
+};
+
+const clone = <T>(value: T): T => JSON.parse(JSON.stringify(value));
+const realSources = (): CriteoSourceCar[] => REAL_CARS.map(car => ({ car: clone(car), images: [] }));
+
+const writeSource = async (world: World, cars: CriteoSourceCar[], { chunkSize = 6, mtime = NOW, skipChunk = -1 } = {}) => {
+  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++) {
+    if (i === skipChunk) {
+      continue;
+    }
+    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 = {} as Partial<FeedGuardOptions> } = {}): Promise<CriteoRunReport> => {
+  const transformer = new CriteoTransformer(
+    {} as any,
+    { config: { isCriteo: true, imageType: 'marketing', domain: 'autode-dev.de' } } as any,
+    { getImages: async (car: any) => (world.noImage.has(car._id) ? [] : [imageUrl(car._id)]) } as any,
+  );
+  const feedRun = new CriteoFeedRun(
+    {
+      forEachChunk: async (fn) => {
+        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')));
+        }
+      },
+      filterCar: ({ car }) => (car?.metaData?.imagesCount ?? 0) >= 4,
+      transform: source => transformer.transform(source),
+      guard: new FeedGuard(guardOptions(world, guard)),
+    },
+    {
+      runId: 'test',
+      domain: 'autode-dev.de',
+      sourceDirectory: world.source,
+      sourceBaseFileName: 'cars',
+      xmlFile: world.xml,
+      stateDir: world.state,
+      now: () => at,
+    },
+  );
+  return feedRun.run();
+};
+
+const readReport = async (world: World): Promise<CriteoRunReport> =>
+  JSON.parse(await fs.readFile(join(world.state, 'last-run-report.json'), 'utf8'));
+
+// id -> field -> value of the published XML
+const readItems = async (file: string): Promise<Map<string, Record<string, string>>> => {
+  const xml = await fs.readFile(file, 'utf8');
+  const items = new Map<string, Record<string, string>>();
+  for (const [, body] of xml.matchAll(/<item>([\s\S]*?)<\/item>/g)) {
+    const fields: Record<string, string> = {};
+    for (const [, key, value] of body.matchAll(/<g:(\w+)>([\s\S]*?)<\/g:\1>/g)) {
+      fields[key] = value.replace(/\s+/g, ' ').trim();
+    }
+    items.set(fields.id, fields);
+  }
+  return items;
+};
+
+const exists = (file: string) => fs.access(file).then(() => true, () => false);
+
+const blocked = async (promise: Promise<unknown>, code: string) => {
+  await assert.rejects(promise, (error: any) => error instanceof FeedGuardError && error.code === code);
+};
+
+const tests: Array<[string, () => Promise<void>]> = [
+  ['20 real cars: every car is published once, in source order, with the legacy field order', async () => {
+    const world = await newWorld();
+    await writeSource(world, realSources());
+    const report = await run(world);
+    assert.equal(report.status, 'published');
+    assert.equal(report.items, 20);
+    assert.deepEqual(report.excluded, {});
+    const items = await readItems(world.xml);
+    assert.deepEqual([...items.keys()], REAL_CARS.map(car => car._id));
+    const xml = await fs.readFile(world.xml, 'utf8');
+    assert.ok(xml.startsWith('<?xml version="1.0" encoding="UTF-8"?><rss version="2.0" xmlns:g="http://base.google.com/ns/1.0">'));
+    assert.ok(xml.trimEnd().endsWith('</channel></rss>'));
+    assert.ok(!/object Object|>default<|<g:amount>0 EUR|&amp;#|undefined|NaN/.test(xml));
+    const first = xml.match(/<item>([\s\S]*?)<\/item>/)[1];
+    assert.deepEqual([...first.matchAll(/<g:(\w+)>/g)].map(m => m[1]).filter(k => !['months', 'amount'].includes(k)), [
+      'id', 'title', 'description', 'google_product_category', 'product_type', 'link', 'image_link', 'condition',
+      'availability', 'brand', 'price', 'sale_price', 'energy_efficiency_class', 'color', 'installment', 'custom_label_0',
+    ]);
+  }],
+  ['20 real cars: id, link, image, price and condition follow the source car', async () => {
+    const world = await newWorld();
+    await writeSource(world, realSources());
+    await run(world);
+    const items = await readItems(world.xml);
+    for (const car of REAL_CARS) {
+      const item = items.get(car._id);
+      assert.equal(item.link, `https://www.autode-dev.de/search/vehicle/${car._id}?source=criteo&amp;medium=cpc&amp;campaign=retargeting`);
+      assert.equal(item.image_link, imageUrl(car._id));
+      assert.equal(item.price, `${car.price.currentSalesPrice} EUR`, car._id);
+      assert.equal(item.sale_price, `${car.price.currentSalesPrice} EUR`, car._id);
+      assert.equal(item.brand, car.mainData.make);
+      assert.equal(item.condition, car.mainData.condition === 'selector_condition_new' ? 'Neu' : 'Gebraucht');
+      assert.equal(
+        item.availability,
+        car.offer.availabilityMode === 'selector_availabilityMode_always' ? 'Sofort' : 'Ab einem bestimmten Datum',
+      );
+    }
+  }],
+  ['20 real cars: brand aliases, apostrophe, unknown energy class and missing rates', async () => {
+    const world = await newWorld();
+    await writeSource(world, realSources());
+    const report = await run(world);
+    const items = await readItems(world.xml);
+    assert.equal(items.get(id(4)).title, 'Mercedes S 580');
+    assert.equal(items.get(id(6)).title, 'VW T-Roc');
+    assert.equal(items.get(id(12)).title, 'Kia cee&apos;d');
+    assert.equal(items.get(id(1)).energy_efficiency_class, 'D');
+    assert.equal(items.get(id(15)).energy_efficiency_class, undefined);
+    assert.equal(report.withoutEnergyClass, 1);
+    assert.equal(items.get(id(1)).custom_label_0, '309 EUR mtl.');
+    for (const n of [16, 17]) {
+      assert.equal(items.get(id(n)).installment, undefined);
+      assert.equal(items.get(id(n)).custom_label_0, undefined);
+    }
+    assert.equal(report.withRate, 18);
+  }],
+  ['sold car is left out and reported as removed by the next run', async () => {
+    const world = await newWorld();
+    await writeSource(world, realSources());
+    await run(world);
+    const cars = realSources();
+    cars[2].car.offer.offerAvailability = 'selector_offerAvailability_sold';
+    await writeSource(world, cars);
+    const report = await run(world, { at: new Date(NOW.getTime() + HOUR) });
+    assert.equal(report.excluded.reserved_or_sold, 1);
+    assert.equal((await readItems(world.xml)).has(id(3)), false);
+    assert.deepEqual(report.ids, { added: 0, removed: 1, kept: 19, removedSample: [id(3)] });
+  }],
+  ['reserved car is left out', async () => {
+    const world = await newWorld();
+    const cars = realSources();
+    cars[5].car.offer.offerAvailability = 'selector_offerAvailability_reserved';
+    await writeSource(world, cars);
+    const report = await run(world);
+    assert.equal(report.items, 19);
+    assert.equal(report.excluded.reserved_or_sold, 1);
+    assert.equal((await readItems(world.xml)).has(id(6)), false);
+  }],
+  ['car that went offline (not in the snapshot any more) drops out of the next full file', async () => {
+    const world = await newWorld();
+    await writeSource(world, realSources());
+    await run(world);
+    await writeSource(world, realSources().filter(source => source.car._id !== id(9)));
+    const report = await run(world, { at: new Date(NOW.getTime() + HOUR) });
+    assert.equal((await readItems(world.xml)).has(id(9)), false);
+    assert.equal(report.ids.removed, 1);
+  }],
+  ['car without a marketing image is left out, no placeholder', async () => {
+    const world = await newWorld();
+    world.noImage.add(id(7));
+    await writeSource(world, realSources());
+    const report = await run(world);
+    assert.equal(report.excluded.no_marketing_image, 1);
+    assert.equal((await readItems(world.xml)).has(id(7)), false);
+    assert.ok(!(await fs.readFile(world.xml, 'utf8')).includes('noimage'));
+  }],
+  ['price change shows up in the next run under the same id', async () => {
+    const world = await newWorld();
+    await writeSource(world, realSources());
+    await run(world);
+    const cars = realSources();
+    cars[0].car.price.currentSalesPrice = 25990;
+    await writeSource(world, cars);
+    const report = await run(world, { at: new Date(NOW.getTime() + HOUR) });
+    const item = (await readItems(world.xml)).get(id(1));
+    assert.equal(item.price, '25990 EUR');
+    assert.equal(item.sale_price, '25990 EUR');
+    assert.deepEqual(report.ids, { added: 0, removed: 0, kept: 20, removedSample: [] });
+  }],
+  ['car without a valid price is left out instead of "0 EUR"', async () => {
+    const world = await newWorld();
+    const cars = realSources();
+    cars[0].car.price.currentSalesPrice = 0;
+    delete cars[1].car.price.currentSalesPrice;
+    // garbage from upstream, not a valid schema value
+    (cars[2].car.price as any).currentSalesPrice = 'abc';
+    await writeSource(world, cars);
+    const report = await run(world);
+    assert.equal(report.excluded.no_valid_price, 3);
+    assert.equal(report.items, 17);
+    assert.ok(!(await fs.readFile(world.xml, 'utf8')).includes('>0 EUR<'));
+  }],
+  ['duplicate id is published once', async () => {
+    const world = await newWorld();
+    const cars = realSources();
+    cars.push({ car: clone(REAL_CARS[0]), images: [] });
+    await writeSource(world, cars);
+    const report = await run(world);
+    assert.equal(report.items, 20);
+    assert.equal(report.excluded.duplicate_id, 1);
+    const xml = await fs.readFile(world.xml, 'utf8');
+    assert.equal(xml.split(`<g:id>${id(1)}</g:id>`).length - 1, 1);
+  }],
+  ['car without an id is left out', async () => {
+    const world = await newWorld();
+    const cars = realSources();
+    cars[0].car._id = '';
+    await writeSource(world, cars);
+    const report = await run(world);
+    assert.equal(report.excluded.no_id, 1);
+    assert.equal(report.items, 19);
+  }],
+  ['source outage: empty snapshot is blocked, last good file and state untouched', async () => {
+    const world = await newWorld();
+    await writeSource(world, realSources());
+    await run(world);
+    const before = await fs.readFile(world.xml, 'utf8');
+    const lastGood = await fs.readFile(join(world.state, 'last-good.json'), 'utf8');
+    await writeSource(world, []);
+    await blocked(run(world, { at: new Date(NOW.getTime() + HOUR) }), 'source_empty');
+    assert.equal(await fs.readFile(world.xml, 'utf8'), before);
+    assert.equal(await fs.readFile(join(world.state, 'last-good.json'), 'utf8'), lastGood);
+    const report = await readReport(world);
+    assert.equal(report.status, 'blocked');
+    assert.equal(report.guard.code, 'source_empty');
+  }],
+  ['source outage: missing snapshot directory is blocked', async () => {
+    const world = await newWorld();
+    await blocked(run(world), 'source_empty');
+    assert.equal(await exists(world.xml), false);
+  }],
+  ['partial snapshot (missing chunk) is blocked', async () => {
+    const world = await newWorld();
+    await writeSource(world, realSources(), { skipChunk: 1 });
+    await blocked(run(world), 'source_partial');
+    assert.equal(await exists(world.xml), false);
+  }],
+  ['stale snapshot is blocked', async () => {
+    const world = await newWorld();
+    await writeSource(world, realSources(), { mtime: new Date(NOW.getTime() - 27 * HOUR) });
+    await blocked(run(world), 'source_stale');
+  }],
+  ['stock drop over 20% is blocked, published again with acceptDrop', async () => {
+    const world = await newWorld();
+    await writeSource(world, realSources());
+    await run(world);
+    await writeSource(world, realSources().slice(0, 10));
+    const later = new Date(NOW.getTime() + HOUR);
+    await blocked(run(world, { at: later }), 'count_drop');
+    assert.equal((await readItems(world.xml)).size, 20);
+    assert.ok(await exists(`${world.xml}.rejected`));
+    const report = await run(world, { at: later, guard: { acceptDrop: true } });
+    assert.equal(report.items, 10);
+    assert.equal(report.ids.removed, 10);
+  }],
+  ['legitimate empty stock (cars in the snapshot, none publishable) is blocked as published_too_small', async () => {
+    const world = await newWorld();
+    const cars = realSources().map(source => {
+      source.car.offer.offerAvailability = 'selector_offerAvailability_sold';
+      return source;
+    });
+    await writeSource(world, cars);
+    await blocked(run(world), 'published_too_small');
+  }],
+  ['a second run while one holds the lock is refused', async () => {
+    const world = await newWorld();
+    await writeSource(world, realSources());
+    await fs.mkdir(world.state, { recursive: true });
+    await fs.writeFile(join(world.state, 'run.lock'), '{}');
+    await blocked(run(world), 'locked');
+  }],
+  ['blocked run reports a stale last good file after maxStaleHours', async () => {
+    const world = await newWorld();
+    await writeSource(world, realSources());
+    await run(world);
+    await writeSource(world, []);
+    await blocked(run(world, { at: new Date(NOW.getTime() + 49 * HOUR) }), 'source_empty');
+    const report = await readReport(world);
+    assert.equal(report.stale, true);
+    assert.ok(report.lastGoodAgeHours > 48);
+  }],
+  ['publish is atomic: previous file kept as .prev, no temp file left, report has the metrics', async () => {
+    const world = await newWorld();
+    await writeSource(world, realSources());
+    await run(world);
+    await run(world, { at: new Date(NOW.getTime() + HOUR) });
+    assert.ok(await exists(`${world.xml}.prev`));
+    assert.equal(await exists(`${world.xml}.tmp`), false);
+    const report = await readReport(world);
+    assert.equal(report.status, 'published');
+    assert.equal(report.source.cars, 20);
+    assert.equal(report.source.files, 4);
+    assert.equal(report.source.ageHours, 1);
+    assert.equal(report.lastGood.publishedItems, 20);
+    assert.equal(typeof report.durationMs, 'number');
+  }],
+];
+
+(async () => {
+  let failed = 0;
+  for (const [name, fn] of tests) {
+    try {
+      await fn();
+      console.log(`ok   ${name}`);
+    } catch (e) {
+      failed += 1;
+      console.error(`FAIL ${name}\n     ${e.message}`);
+    }
+  }
+  if (failed) process.exit(1);
+})();

package/test/criteo-mapping.test.ts

@@ -1,122 +1,122 @@
-// Run: npm test (ts-node, no test framework needed)
-// ADV-319: Criteo item mapping bugs found in the DEV feed of 27.10.2026.
-// - custom_label_0 was "[object Object] EUR mtl." for every car;
-// - a car without a rate got "<g:months>0</g:months><g:amount>0 EUR</g:amount>";
-// - a title with an apostrophe was escaped twice ("cee&amp;#39;d");
-// - an unknown energy class was sent as the literal "default".
-import * as assert from 'node:assert/strict';
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { CriteoTransformer } from '../src/transformers/criteo.transformer';
-import { GoogleXmlBuilder } from '../src/formats/google-xml.builder';
-
-const IMAGE = 'https://images.autode-dev.de/generated_images/0/0/0/00000000-0000-4000-8000-000000000001/criteo-Test.jpg';
-
-const baseCar = (patch: any = {}): any => ({
-  _id: '00000000-0000-4000-8000-000000000001',
-  mainData: { make: 'Volkswagen', model: 'Golf', condition: 'selector_condition_used', category: 'selector_category_limousine' },
-  price: { currentSalesPrice: 19990 },
-  offer: { availabilityMode: 'selector_availabilityMode_always' },
-  environmentEmissions: { wltpEnergyEfficiencyClass: 'selector_energyEfficiencyClass_d' },
-  rate: { monthlyInstallment: 164.6, paybackPeriod: 60 },
-  metaData: { ownerId: 'test-dealer', imagesCount: 5 },
-  ...patch,
-});
-
-const transformer = new CriteoTransformer(
-  {} as any,
-  { config: { isCriteo: true, imageType: 'marketing', domain: 'autode-dev.de' } } as any,
-  { getImages: async () => [IMAGE] } as any,
-);
-
-const renderItem = async (item: any): Promise<string> => {
-  const file = path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'criteo-mapping-')), 'feed.xml');
-  const builder = new GoogleXmlBuilder(file);
-  await builder.buildStart('autode-dev.de');
-  await builder.addItem(item);
-  await builder.buildEnd();
-  return fs.readFileSync(file, 'utf8');
-};
-
-const tests: Array<[string, () => Promise<void>]> = [
-  ['custom_label_0 carries the rounded monthly rate, installment keeps months and amount', async () => {
-    const item = await transformer.transform({ car: baseCar(), images: [] });
-    assert.equal(item?.custom_label_0, '165 EUR mtl.');
-    assert.deepEqual(item?.installment, { paybackPeriod: 60, monthlyInstallment: 165 });
-    const xml = await renderItem(item);
-    assert.match(xml, /<g:months>60<\/g:months>/);
-    assert.match(xml, /<g:amount>165 EUR<\/g:amount>/);
-    assert.ok(!xml.includes('[object Object]'));
-  }],
-  ['car without a rate has no installment and no custom_label_0', async () => {
-    for (const rate of [undefined, null, {}, { monthlyInstallment: 0, paybackPeriod: 0 }, { monthlyInstallment: 199 }, { paybackPeriod: 48 }]) {
-      const item = await transformer.transform({ car: baseCar({ rate }), images: [] });
-      assert.ok(item, `item for rate ${JSON.stringify(rate)}`);
-      assert.ok(!('installment' in item), `installment for rate ${JSON.stringify(rate)}`);
-      assert.ok(!('custom_label_0' in item), `custom_label_0 for rate ${JSON.stringify(rate)}`);
-      const xml = await renderItem(item);
-      assert.ok(!xml.includes('g:installment') && !xml.includes('g:custom_label_0'));
-    }
-  }],
-  ['title with an apostrophe is escaped once, by the XML builder', async () => {
-    const item = await transformer.transform({
-      car: baseCar({ mainData: { make: 'Kia', model: "cee'd", condition: 'selector_condition_used' } }),
-      images: [],
-    });
-    assert.equal(item?.title, "Kia cee'd");
-    const xml = await renderItem(item);
-    assert.match(xml, /<g:title>Kia cee&apos;d<\/g:title>/);
-    assert.ok(!xml.includes('&amp;#39;'));
-  }],
-  ['title keeps the Mercedes / VW brand aliases (ACF-6332, ACF-6534)', async () => {
-    const vw = await transformer.transform({ car: baseCar(), images: [] });
-    assert.equal(vw?.title, 'VW Golf');
-    assert.equal(vw?.brand, 'Volkswagen');
-    const mb = await transformer.transform({
-      car: baseCar({ mainData: { make: 'Mercedes-Benz', model: 'A 180', condition: 'selector_condition_used' } }),
-      images: [],
-    });
-    assert.equal(mb?.title, 'Mercedes A 180');
-  }],
-  ['known energy class is sent, unknown or missing class leaves the element out', async () => {
-    const known = await transformer.transform({ car: baseCar(), images: [] });
-    assert.equal(known?.energy_efficiency_class, 'D');
-    for (const environmentEmissions of [{ wltpEnergyEfficiencyClass: 'selector_unknown' }, {}, undefined]) {
-      const item = await transformer.transform({ car: baseCar({ environmentEmissions }), images: [] });
-      assert.ok(item && !('energy_efficiency_class' in item));
-      const xml = await renderItem(item);
-      assert.ok(!xml.includes('g:energy_efficiency_class') && !xml.includes('>default<'));
-    }
-  }],
-  ['unchanged legacy fields: id, link params, price, condition, availability', async () => {
-    const item = await transformer.transform({ car: baseCar(), images: [] });
-    assert.equal(item?.id, '00000000-0000-4000-8000-000000000001');
-    assert.equal(
-      item?.link,
-      'https://www.autode-dev.de/search/vehicle/00000000-0000-4000-8000-000000000001?source=criteo&medium=cpc&campaign=retargeting',
-    );
-    assert.equal(item?.price, '19990 EUR');
-    assert.equal(item?.sale_price, '19990 EUR');
-    assert.equal(item?.condition, 'Gebraucht');
-    assert.equal(item?.availability, 'Sofort');
-    assert.deepEqual(Object.keys(item as any), [
-      'id', 'title', 'description', 'google_product_category', 'product_type', 'link', 'image_link', 'condition',
-      'availability', 'brand', 'price', 'sale_price', 'energy_efficiency_class', 'color', 'installment', 'custom_label_0',
-    ]);
-  }],
-];
-
-(async () => {
-  let failed = 0;
-  for (const [name, fn] of tests) {
-    try {
-      await fn();
-      console.log(`ok   ${name}`);
-    } catch (e) {
-      failed += 1;
-      console.error(`FAIL ${name}\n     ${e.message}`);
-    }
-  }
-  if (failed) process.exit(1);
-})();
+// Run: npm test (ts-node, no test framework needed)
+// ADV-319: Criteo item mapping bugs found in the DEV feed of 27.10.2026.
+// - custom_label_0 was "[object Object] EUR mtl." for every car;
+// - a car without a rate got "<g:months>0</g:months><g:amount>0 EUR</g:amount>";
+// - a title with an apostrophe was escaped twice ("cee&amp;#39;d");
+// - an unknown energy class was sent as the literal "default".
+import * as assert from 'node:assert/strict';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { CriteoTransformer } from '../src/transformers/criteo.transformer';
+import { GoogleXmlBuilder } from '../src/formats/google-xml.builder';
+
+const IMAGE = 'https://images.autode-dev.de/generated_images/0/0/0/00000000-0000-4000-8000-000000000001/criteo-Test.jpg';
+
+const baseCar = (patch: any = {}): any => ({
+  _id: '00000000-0000-4000-8000-000000000001',
+  mainData: { make: 'Volkswagen', model: 'Golf', condition: 'selector_condition_used', category: 'selector_category_limousine' },
+  price: { currentSalesPrice: 19990 },
+  offer: { availabilityMode: 'selector_availabilityMode_always' },
+  environmentEmissions: { wltpEnergyEfficiencyClass: 'selector_energyEfficiencyClass_d' },
+  rate: { monthlyInstallment: 164.6, paybackPeriod: 60 },
+  metaData: { ownerId: 'test-dealer', imagesCount: 5 },
+  ...patch,
+});
+
+const transformer = new CriteoTransformer(
+  {} as any,
+  { config: { isCriteo: true, imageType: 'marketing', domain: 'autode-dev.de' } } as any,
+  { getImages: async () => [IMAGE] } as any,
+);
+
+const renderItem = async (item: any): Promise<string> => {
+  const file = path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'criteo-mapping-')), 'feed.xml');
+  const builder = new GoogleXmlBuilder(file);
+  await builder.buildStart('autode-dev.de');
+  await builder.addItem(item);
+  await builder.buildEnd();
+  return fs.readFileSync(file, 'utf8');
+};
+
+const tests: Array<[string, () => Promise<void>]> = [
+  ['custom_label_0 carries the rounded monthly rate, installment keeps months and amount', async () => {
+    const item = await transformer.transform({ car: baseCar(), images: [] });
+    assert.equal(item?.custom_label_0, '165 EUR mtl.');
+    assert.deepEqual(item?.installment, { paybackPeriod: 60, monthlyInstallment: 165 });
+    const xml = await renderItem(item);
+    assert.match(xml, /<g:months>60<\/g:months>/);
+    assert.match(xml, /<g:amount>165 EUR<\/g:amount>/);
+    assert.ok(!xml.includes('[object Object]'));
+  }],
+  ['car without a rate has no installment and no custom_label_0', async () => {
+    for (const rate of [undefined, null, {}, { monthlyInstallment: 0, paybackPeriod: 0 }, { monthlyInstallment: 199 }, { paybackPeriod: 48 }]) {
+      const item = await transformer.transform({ car: baseCar({ rate }), images: [] });
+      assert.ok(item, `item for rate ${JSON.stringify(rate)}`);
+      assert.ok(!('installment' in item), `installment for rate ${JSON.stringify(rate)}`);
+      assert.ok(!('custom_label_0' in item), `custom_label_0 for rate ${JSON.stringify(rate)}`);
+      const xml = await renderItem(item);
+      assert.ok(!xml.includes('g:installment') && !xml.includes('g:custom_label_0'));
+    }
+  }],
+  ['title with an apostrophe is escaped once, by the XML builder', async () => {
+    const item = await transformer.transform({
+      car: baseCar({ mainData: { make: 'Kia', model: "cee'd", condition: 'selector_condition_used' } }),
+      images: [],
+    });
+    assert.equal(item?.title, "Kia cee'd");
+    const xml = await renderItem(item);
+    assert.match(xml, /<g:title>Kia cee&apos;d<\/g:title>/);
+    assert.ok(!xml.includes('&amp;#39;'));
+  }],
+  ['title keeps the Mercedes / VW brand aliases (ACF-6332, ACF-6534)', async () => {
+    const vw = await transformer.transform({ car: baseCar(), images: [] });
+    assert.equal(vw?.title, 'VW Golf');
+    assert.equal(vw?.brand, 'Volkswagen');
+    const mb = await transformer.transform({
+      car: baseCar({ mainData: { make: 'Mercedes-Benz', model: 'A 180', condition: 'selector_condition_used' } }),
+      images: [],
+    });
+    assert.equal(mb?.title, 'Mercedes A 180');
+  }],
+  ['known energy class is sent, unknown or missing class leaves the element out', async () => {
+    const known = await transformer.transform({ car: baseCar(), images: [] });
+    assert.equal(known?.energy_efficiency_class, 'D');
+    for (const environmentEmissions of [{ wltpEnergyEfficiencyClass: 'selector_unknown' }, {}, undefined]) {
+      const item = await transformer.transform({ car: baseCar({ environmentEmissions }), images: [] });
+      assert.ok(item && !('energy_efficiency_class' in item));
+      const xml = await renderItem(item);
+      assert.ok(!xml.includes('g:energy_efficiency_class') && !xml.includes('>default<'));
+    }
+  }],
+  ['unchanged legacy fields: id, link params, price, condition, availability', async () => {
+    const item = await transformer.transform({ car: baseCar(), images: [] });
+    assert.equal(item?.id, '00000000-0000-4000-8000-000000000001');
+    assert.equal(
+      item?.link,
+      'https://www.autode-dev.de/search/vehicle/00000000-0000-4000-8000-000000000001?source=criteo&medium=cpc&campaign=retargeting',
+    );
+    assert.equal(item?.price, '19990 EUR');
+    assert.equal(item?.sale_price, '19990 EUR');
+    assert.equal(item?.condition, 'Gebraucht');
+    assert.equal(item?.availability, 'Sofort');
+    assert.deepEqual(Object.keys(item as any), [
+      'id', 'title', 'description', 'google_product_category', 'product_type', 'link', 'image_link', 'condition',
+      'availability', 'brand', 'price', 'sale_price', 'energy_efficiency_class', 'color', 'installment', 'custom_label_0',
+    ]);
+  }],
+];
+
+(async () => {
+  let failed = 0;
+  for (const [name, fn] of tests) {
+    try {
+      await fn();
+      console.log(`ok   ${name}`);
+    } catch (e) {
+      failed += 1;
+      console.error(`FAIL ${name}\n     ${e.message}`);
+    }
+  }
+  if (failed) process.exit(1);
+})();