@bytebrand/export-cars 1.26.44 → 1.26.45

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

@@ -0,0 +1,263 @@
+// Run: npm test (ts-node, no test framework needed)
+// Integration: real files in a temp dir (base export snapshot, output, state), real CSV writer, real ZIP,
+// guard and ADV-336 clean-image selection; only HTTP (image check) and the mapping sheet row are faked.
+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 { MarktdeFeedRun, MarktdeSourceCar } from '../src/services/marktde-feed-run';
+import { zipSingleFile } from '../src/services/meinstadt-feed-run';
+import { toMarktdeImages } from '../src/transformers/marktde.transformer';
+import { selectOpenAiImageFields } from '../src/transformers/openai-image-fields';
+import { buildImagesService } from './fixtures/images-service.harness';
+import { NOW, car, images } from './fixtures/meinstadt.fixture';
+
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const AdmZip = require('adm-zip');
+
+const HOUR = 60 * 60 * 1000;
+const imagesService = buildImagesService();
+
+interface World {
+  root: string;
+  source: string;
+  csv: string;
+  zip: string;
+  state: string;
+  brokenImages: Set<string>;
+}
+
+const newWorld = async (): Promise<World> => {
+  const root = await fs.mkdtemp(join(tmpdir(), 'marktde-'));
+  return {
+    root,
+    source: join(root, 'cars-export'),
+    csv: join(root, 'marktde-dryrun', 'api_export_cars_marktde.csv'),
+    zip: join(root, 'marktde-dryrun', 'api_export_cars_marktde.zip'),
+    state: join(root, 'marktde-state', 'dryrun'),
+    brokenImages: new Set(),
+  };
+};
+
+const source = (id: string, overrides: Record<string, any> = {}): MarktdeSourceCar => ({ car: car(id, overrides), images: images(id) });
+
+const writeSource = async (world: World, cars: MarktdeSourceCar[], chunkSize = 2, 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,
+});
+
+// What MobileTransformer would return from the mapping sheet (the columns the run does not replace).
+const legacyRow = async ({ car: c }: MarktdeSourceCar): Promise<Record<string, unknown>> => ({
+  '0': '04109003',
+  '1': c.metaData.vehicleId,
+  '3': c.mainData.make,
+  '4': c.mainData.model,
+  '14': 'GENERATEDFAKEVIN0',
+  '25': 'Autohaus Test\\\\Tel. 0341 12345678\\\\**Ausstattung**\\\\* ABS\\\\',
+  '26': 'https://images.auto.de/noimage/large.jpg',
+  '99': 'undefined',
+  '402': `https://www.auto.de${c._id}?source=classifieds&medium=listing&campaign=marktde`,
+});
+
+const run = async (world: World, { at = NOW, guard = {} }: { at?: Date; guard?: Partial<FeedGuardOptions> } = {}) => {
+  const forEachChunk = async (fn: (cars: MarktdeSourceCar[]) => 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 MarktdeFeedRun(
+    {
+      forEachChunk,
+      filterCar: ({ car: c }) => (c?.metaData?.imagesCount ?? 0) > 0,
+      resolveImages: async ({ car: c, images: list }) => {
+        const clean = imagesService.getCleanImages(c._id, list);
+        return toMarktdeImages(selectOpenAiImageFields(clean, clean.map(i => ({ url: i.url, ok: !world.brokenImages.has(i.url) }))));
+      },
+      legacyRow,
+      imageStats: () => ({ ok: 1 }),
+      zip: zipSingleFile,
+      guard: new FeedGuard(guardOptions(world, guard)),
+    },
+    {
+      runId: 'test',
+      dryRun: true,
+      domain: 'auto.de',
+      sourceDirectory: world.source,
+      sourceBaseFileName: 'cars',
+      csvFile: world.csv,
+      zipFile: world.zip,
+      stateDir: world.state,
+      now: () => at,
+    },
+  );
+  return feed.run();
+};
+
+const cellsOf = (line: string): string[] => line.match(/"(?:[^"]|"")*"|(?<=^|;)(?=;|$)/g);
+const readRows = async (world: World) => (await fs.readFile(world.csv, 'utf8')).split('\n').filter(Boolean).map(cellsOf);
+const linkIds = (rows: string[][]) => rows.map(r => r[402].split('/vehicle/')[1].split('?')[0]);
+const exists = (file: string) => fs.stat(file).then(() => true, () => false);
+
+const tests: Array<[string, () => Promise<void>]> = [
+  ['first run: one row per sellable car, exclusions counted, markt.de columns replaced, ZIP holds the CSV', async () => {
+    const world = await newWorld();
+    const noImages = source('nopic');
+    noImages.car.metaData.imagesCount = 0;
+    const noHero = source('nohero');
+    noHero.images = noHero.images.filter(i => i.imageCodePredicted !== 'ext_f_right');
+    await writeSource(world, [
+      source('aaa1'),
+      source('aaa2', { 'price.vatDeductible': true, 'price.vatRate': 19, 'price.currentSalesPrice': 23800 }),
+      source('aaa3', { 'metaData.vin': 'WVWZZZ1KZAW000001', 'metaData.ownerId': 'dealer-2' }),
+      source('aaa1'),
+      noImages,
+      noHero,
+      source('sold', { 'offer.offerAvailability': 'selector_offerAvailability_sold' }),
+      source('resv', { 'offer.offerAvailability': 'selector_offerAvailability_reserved' }),
+      source('noprice', { 'price.currentSalesPrice': null }),
+      source('noveh', { 'metaData.vehicleId': '' }),
+    ]);
+    const report = await run(world);
+    const rows = await readRows(world);
+    assert.deepEqual(linkIds(rows), ['aaa1', 'aaa2', 'aaa3']);
+    for (const r of rows) {
+      assert.equal(r.length, 403);
+      assert.equal(r[0], '"04109003"', 'untouched legacy column');
+      assert.match(r[26], /^"https:\/\/images\.auto\.de\/carimage\/[^"]+hero1\/large-cached\.jpeg;/);
+      assert.ok(!r[26].includes('noimage'));
+      assert.ok(!r[25].includes('0341'), 'phone removed from description');
+      assert.ok(r[25].includes('**Ausstattung**'));
+      assert.ok(r[402].includes('?source=marktde&medium=listing&campaign=listing&utm_source=marktde'));
+      assert.ok(!r.join(';').includes('undefined'));
+    }
+    assert.deepEqual(rows.map(r => r[14]), ['""', '""', '"WVWZZZ1KZAW000001"'], 'no fake VIN');
+    assert.deepEqual(rows.map(r => [r[10], r[11], r[29]]), [
+      ['"15148"', '"1"', '"0"'],
+      ['"20000.00"', '"0"', '"19"'],
+      ['"15148"', '"1"', '"0"'],
+    ]);
+    assert.equal(report.status, 'published');
+    assert.equal(report.items, 3);
+    assert.equal(report.dealers, 2);
+    assert.deepEqual(report.excluded, { duplicate_id: 1, filtered: 1, no_valid_image: 1, reserved_or_sold: 2, no_valid_price: 1, no_vehicle_id: 1 });
+    assert.deepEqual(report.vin, { empty: 2, sent: 1 });
+    assert.deepEqual(report.vat, { deductible: 1, notDeductible: 2, rateDefaulted: 0 });
+    assert.equal(report.description.sanitized, 3);
+    assert.equal(report.description.removed.phone, 3);
+    const zip = new AdmZip(world.zip);
+    assert.deepEqual(zip.getEntries().map((e: any) => e.entryName), ['api_export_cars_marktde.csv']);
+    assert.equal(zip.readAsText('api_export_cars_marktde.csv'), await fs.readFile(world.csv, 'utf8'));
+    const saved = JSON.parse(await fs.readFile(join(world.state, 'last-run-report.json'), 'utf8'));
+    assert.equal(saved.items, 3);
+  }],
+
+  ['second run with the same snapshot: byte-identical CSV (stable ids, order, links)', async () => {
+    const world = await newWorld();
+    await writeSource(world, [source('i1'), source('i2'), source('i3')]);
+    await run(world);
+    const first = await fs.readFile(world.csv, 'utf8');
+    await run(world, { at: new Date(NOW.getTime() + HOUR) });
+    assert.equal(await fs.readFile(world.csv, 'utf8'), first);
+  }],
+
+  ['partial snapshot (missing chunk) -> blocked, last good CSV/ZIP untouched', async () => {
+    const world = await newWorld();
+    await writeSource(world, [source('p1'), source('p2'), source('p3'), source('p4')]);
+    await run(world);
+    const good = await fs.readFile(world.csv, 'utf8');
+    const goodZip = await fs.readFile(world.zip);
+    await fs.rm(join(world.source, 'cars.0.json'));
+    await assert.rejects(run(world, { at: new Date(NOW.getTime() + HOUR) }), (e: any) => e instanceof FeedGuardError && e.code === 'source_partial');
+    assert.equal(await fs.readFile(world.csv, 'utf8'), good);
+    assert.deepEqual(await fs.readFile(world.zip), goodZip);
+    const report = JSON.parse(await fs.readFile(join(world.state, 'last-run-report.json'), 'utf8'));
+    assert.equal(report.status, 'blocked');
+  }],
+
+  ['stale snapshot -> blocked before any output is written', async () => {
+    const world = await newWorld();
+    await writeSource(world, [source('s1')], 2, new Date(NOW.getTime() - 30 * HOUR));
+    await assert.rejects(run(world), (e: any) => e.code === 'source_stale');
+    assert.equal(await exists(world.csv), false);
+    assert.equal(await exists(world.zip), false);
+  }],
+
+  ['stock drop > 20 % -> blocked (rejected file kept); acceptDrop publishes it', async () => {
+    const world = await newWorld();
+    await writeSource(world, Array.from({ length: 10 }, (_, i) => source(`d${i}`)));
+    await run(world);
+    // half of the stock sold
+    await writeSource(world, Array.from({ length: 10 }, (_, i) => source(`d${i}`, { 'offer.offerAvailability': i < 5 ? 'selector_offerAvailability_sold' : undefined })));
+    await assert.rejects(run(world, { at: new Date(NOW.getTime() + HOUR) }), (e: any) => e.code === 'count_drop');
+    assert.equal((await readRows(world)).length, 10);
+    assert.equal(await exists(`${world.csv}.rejected`), true);
+    await run(world, { at: new Date(NOW.getTime() + 2 * HOUR), guard: { acceptDrop: true } });
+    assert.equal((await readRows(world)).length, 5);
+    assert.equal(await exists(`${world.csv}.prev`), true);
+  }],
+
+  ['nothing sellable -> published_too_small, never an empty file', async () => {
+    const world = await newWorld();
+    const all = [source('n1'), source('n2')];
+    for (const s of all) {
+      for (const i of imagesService.getCleanImages(s.car._id, s.images)) world.brokenImages.add(i.url);
+    }
+    await writeSource(world, all);
+    await assert.rejects(run(world), (e: any) => e.code === 'published_too_small');
+    assert.equal(await exists(world.csv), false);
+  }],
+
+  ['old vs new id: a car re-created under a new _id gets a new link but keeps its vehicle id column', async () => {
+    const world = await newWorld();
+    await writeSource(world, [source('old1', { 'metaData.vehicleId': 'V-STABLE' })]);
+    await run(world);
+    const [before] = await readRows(world);
+    await writeSource(world, [source('new1', { 'metaData.vehicleId': 'V-STABLE' })]);
+    await run(world, { at: new Date(NOW.getTime() + HOUR) });
+    const [after] = await readRows(world);
+    assert.equal(before[1], '"V-STABLE"');
+    assert.equal(after[1], '"V-STABLE"');
+    assert.notEqual(before[402], after[402]);
+  }],
+
+  ['a second run while one holds the lock is refused', async () => {
+    const world = await newWorld();
+    await writeSource(world, [source('l1')]);
+    await fs.mkdir(world.state, { recursive: true });
+    await fs.writeFile(join(world.state, 'run.lock'), '{}');
+    await assert.rejects(run(world), (e: any) => e.code === 'locked');
+  }],
+];
+
+(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/marktde-mapping.test.ts

@@ -0,0 +1,280 @@
+// Run: npm test (ts-node, no test framework needed)
+// markt.de columns (ADV-328) on top of the legacy mobile.de-style row — pure functions, no I/O.
+import * as assert from 'node:assert/strict';
+
+import { MarktdeConfig } from '../src/configs/marktde.config';
+import { Environment, ExportType, ImageType } from '../src/enums';
+import {
+  MARKTDE_COLUMNS,
+  MARKTDE_LINK_PARAMS,
+  MarktdeExclusion,
+  applyMarktdeColumns,
+  getMarktdeExclusion,
+  getMarktdeListingUrl,
+  getMarktdePriceColumns,
+  getMarktdeVin,
+  sanitizeMarktdeDescription,
+  toMarktdeImages,
+} from '../src/transformers/marktde.transformer';
+import { selectOpenAiImageFields } from '../src/transformers/openai-image-fields';
+import { convertToCSV } from '../src/utils/converter.utils';
+import { buildImagesService } from './fixtures/images-service.harness';
+import { car, eightImages, images } from './fixtures/meinstadt.fixture';
+
+const imagesService = buildImagesService();
+const C = MARKTDE_COLUMNS;
+const ctx = { domain: 'auto.de', images: ['https://images.auto.de/carimage/x/hero1/large-cached.jpeg', 'https://images.auto.de/carimage/x/side1/large-cached.jpeg'] };
+
+// The row MobileTransformer builds from the mapping sheet (only the columns the test looks at).
+const legacyRow = (c: any): Record<string, unknown> => ({
+  '0': '04109003',
+  '1': c.metaData.vehicleId,
+  '3': c.mainData.make,
+  '4': `${c.mainData.model} ${c.mainData.subModel}`,
+  '10': 'legacy-price',
+  '11': 'legacy-flag',
+  '14': 'legacy-vin',
+  '25': c.offer?.offerDescription ? 'Fahrzeugbeschreibung\\\\**Ausstattung**\\\\* ABS\\\\' : undefined,
+  '26': 'legacy-images',
+  '29': 'legacy-rate',
+  '98': '6,1',
+  '99': 'undefined',
+  '402': `https://www.auto.de${c._id}?source=classifieds&medium=listing&campaign=marktde`,
+});
+
+const tests: Array<[string, () => void | Promise<void>]> = [
+  ['column letters: B=1, K=10, L=11, O=14, Z=25, AA=26, AD=29, OM=402 (historic ACF-4370 mapping)', () => {
+    const letters = (index: number): string => {
+      let n = index + 1;
+      let out = '';
+      while (n > 0) {
+        const r = (n - 1) % 26;
+        out = String.fromCharCode(65 + r) + out;
+        n = Math.floor((n - 1) / 26);
+      }
+      return out;
+    };
+    assert.deepEqual(
+      Object.fromEntries(Object.entries(C).map(([k, v]) => [k, letters(Number(v))])),
+      { vehicleId: 'B', price: 'K', vatFlag: 'L', vin: 'O', description: 'Z', images: 'AA', vatRate: 'AD', fuelCombined: 'CU', co2: 'CV', listingUrl: 'OM' },
+    );
+  }],
+
+  ['link: auto.de vehicle page with source=marktde + identical utm_* (no classifieds, no paid medium)', () => {
+    assert.equal(
+      getMarktdeListingUrl('auto.de', 'abc123'),
+      'https://www.auto.de/search/vehicle/abc123?source=marktde&medium=listing&campaign=listing&utm_source=marktde&utm_medium=listing&utm_campaign=listing',
+    );
+    assert.ok(!MARKTDE_LINK_PARAMS.includes('classifieds'));
+    assert.ok(!/cpc|paid/.test(MARKTDE_LINK_PARAMS));
+  }],
+
+  ['VIN: own valid VIN (upper-cased) or empty — never a generated / marketing fake VIN', () => {
+    assert.equal(getMarktdeVin(car('a', { 'metaData.vin': 'wvwzzz1kzaw000001' })), 'WVWZZZ1KZAW000001');
+    assert.equal(getMarktdeVin(car('a', { 'metaData.vin': '' })), '');
+    assert.equal(getMarktdeVin(car('a', { 'marketing.fakeVIN': 'WVWZZZ1KZAW999999' })), '');
+    assert.equal(getMarktdeVin(car('a', { 'metaData.vin': 'WVWZZZ1KZAW00000' })), '', '16 chars');
+    assert.equal(getMarktdeVin(car('a', { 'metaData.vin': 'WVWZZZ1KZAWO00001' })), '', 'letter O is not allowed');
+    assert.equal(getMarktdeVin(car('a', { 'metaData.vin': 'unbekannt' })), '');
+  }],
+
+  ['price: VAT-deductible -> net K, L=0, AD=rate; gross is restored exactly as K*(1+AD)', () => {
+    const p = getMarktdePriceColumns(car('a', { 'price.currentSalesPrice': 23800, 'price.vatDeductible': true, 'price.vatRate': 19 }));
+    assert.deepEqual(p, { price: '20000.00', vatFlag: '0', vatRate: '19', deductible: true, rateDefaulted: false });
+    assert.equal(Math.round(Number(p.price) * 1.19), 23800);
+  }],
+
+  ['price: not deductible (margin scheme / exempt) -> gross K as stored, L=1, AD=0 — never +19 % on a gross price', () => {
+    assert.deepEqual(
+      getMarktdePriceColumns(car('a', { 'price.currentSalesPrice': 15148, 'price.vatDeductible': false })),
+      { price: '15148', vatFlag: '1', vatRate: '0', deductible: false, rateDefaulted: false },
+    );
+    assert.equal(getMarktdePriceColumns(car('a', { 'price.currentSalesPrice': 15148 })).vatFlag, '1', 'unknown = not deductible');
+  }],
+
+  ['price: deductible with null / 0 vatRate -> 19 % for BOTH K and AD (legacy kept K gross but AD=19)', () => {
+    for (const rate of [null, 0, undefined]) {
+      const p = getMarktdePriceColumns(car('a', { 'price.currentSalesPrice': 11900, 'price.vatDeductible': true, 'price.vatRate': rate }));
+      assert.deepEqual(p, { price: '10000.00', vatFlag: '0', vatRate: '19', deductible: true, rateDefaulted: true });
+    }
+  }],
+
+  ['price: missing / 0 / negative / text -> null (car is excluded)', () => {
+    for (const value of [null, undefined, '', 0, -5, 'abc', true]) {
+      assert.equal(getMarktdePriceColumns(car('a', { 'price.currentSalesPrice': value })), null, String(value));
+    }
+  }],
+
+  ['exclusions: sold / reserved / no price / no vehicle id / no _id', () => {
+    assert.equal(getMarktdeExclusion(car('a')), null);
+    assert.equal(getMarktdeExclusion(car('a', { 'offer.offerAvailability': 'selector_offerAvailability_sold' })), MarktdeExclusion.notAvailable);
+    assert.equal(getMarktdeExclusion(car('a', { 'offer.offerAvailability': 'selector_offerAvailability_reserved' })), MarktdeExclusion.notAvailable);
+    assert.equal(getMarktdeExclusion(car('a', { 'offer.offerAvailability': 'selector_offerAvailability_available' })), null);
+    assert.equal(getMarktdeExclusion(car('a', { 'price.currentSalesPrice': null })), MarktdeExclusion.noPrice);
+    assert.equal(getMarktdeExclusion(car('a', { 'metaData.vehicleId': '' })), MarktdeExclusion.noVehicleId);
+    assert.equal(getMarktdeExclusion(car('', {})), MarktdeExclusion.noId);
+  }],
+
+  ['images: validated clean list, hero first, no placeholders; no valid hero -> []', () => {
+    const clean = imagesService.getCleanImages('car1', eightImages('car1'));
+    const all = toMarktdeImages(selectOpenAiImageFields(clean, clean.map(i => ({ url: i.url, ok: true }))));
+    assert.equal(all.length, 8);
+    assert.match(all[0], /hero1\/large-cached\.jpeg$/);
+    assert.ok(all.every(u => !u.includes('noimage')));
+    assert.equal(toMarktdeImages(selectOpenAiImageFields(clean, clean.map(i => ({ url: i.url, ok: true }))), 3).length, 3);
+    const brokenHeroes = clean.map(i => ({ url: i.url, ok: !i.heroCandidate }));
+    assert.deepEqual(toMarktdeImages(selectOpenAiImageFields(clean, brokenHeroes)), []);
+    assert.deepEqual(toMarktdeImages(selectOpenAiImageFields(imagesService.getCleanImages('c', []), [])), []);
+  }],
+
+  ['description: URLs, e-mails, phone numbers, street / postcode lines removed; vehicle facts and markup stay', () => {
+    const text = 'Autohaus Muster GmbH\\\\Tel.: 0341 / 123 456 78\\\\Mobil: +49 (0) 171 2345678\\\\E-Mail: info@autohaus-muster.de\\\\'
+      + 'Besuchen Sie uns auf www.autohaus-muster.de oder https://autohaus-muster.de/angebote\\\\Max-Planck-Straße 19, 06796 Sandersdorf-Brehna\\\\'
+      + '**Ausstattung**\\\\* ABS\\\\HU: 08/2027\\\\Erstzulassung: 01.08.2021\\\\Kilometerstand: 125000 Km\\\\Preis: 15990 Euro\\\\Hubraum: 1598 ccm\\\\';
+    const { text: out, removed } = sanitizeMarktdeDescription(text);
+    assert.deepEqual(removed, { url: 2, email: 1, phone: 2, address: 2 });
+    for (const forbidden of ['0341', '171', '@', 'www.', 'http', 'autohaus-muster.de', 'Planck', '06796', 'Tel.:', 'E-Mail:']) {
+      assert.ok(!out.includes(forbidden), `${forbidden} left in: ${out}`);
+    }
+    for (const kept of ['Autohaus Muster GmbH', '**Ausstattung**', '* ABS', 'HU: 08/2027', 'Erstzulassung: 01.08.2021', '125000 Km', '15990 Euro', '1598 ccm']) {
+      assert.ok(out.includes(kept), `${kept} missing in: ${out}`);
+    }
+  }],
+
+  ['description: the seller name auto.de stays (brand + auto.de GmbH), links to it and contact lines go; markup untouched', () => {
+    const text = ' **auto.de | Einfach - Sicher - Online - Kaufen**\\\\\\\\ ----\\\\so funktioniert auto.de\\\\'
+      + 'Sollten Sie ein günstigeres Angebot finden als auf auto.de, dann passen wir es an.\\\\Auto.de legt höchsten Wert auf Zufriedenheit.\\\\'
+      + 'auto.de-ID: 96BAE0\\\\Tel.: 0800 0000 466\\\\WhatsApp: 0151 225 94 090\\\\SMS: 0151 225 94 090\\\\E-Mail: auto@auto.de\\\\ ---- **Basic data**\\\\'
+      + 'Mehr unter https://www.auto.de/angebote und www.auto.de\\\\';
+    const { text: out, removed } = sanitizeMarktdeDescription(text);
+    assert.deepEqual(removed, { url: 2, email: 1, phone: 3, address: 0 });
+    assert.equal(
+      out,
+      ' **auto.de | Einfach - Sicher - Online - Kaufen**\\\\\\\\ ----\\\\so funktioniert auto.de\\\\'
+      + 'Sollten Sie ein günstigeres Angebot finden als auf auto.de, dann passen wir es an.\\\\Auto.de legt höchsten Wert auf Zufriedenheit.\\\\'
+      + 'auto.de-ID: 96BAE0\\\\\\\\\\\\\\\\\\\\ ---- **Basic data**\\\\'
+      + 'Mehr unter und\\\\',
+    );
+  }],
+
+  ['description: other bare domains go ("autohaus-muster.de"), words with dots stay ("z.B.", "ca.", "1.6 TDI")', () => {
+    const { text: out, removed } = sanitizeMarktdeDescription('Alle Fahrzeuge auf autohaus-muster.de ansehen, z.B. 1.6 TDI ca. 5 l\\\\');
+    assert.equal(removed.url, 1);
+    assert.equal(out, 'Alle Fahrzeuge auf ansehen, z.B. 1.6 TDI ca. 5 l\\\\');
+    // DEV 12.11: a model name looked like a street ("…ring" + number)
+    const model = 'Untermodell: M3 Competition xDrive Touring 3.0 8-Gang St...\\\\Hubraum: 2993\\\\';
+    assert.deepEqual(sanitizeMarktdeDescription(model), { text: model, removed: { url: 0, email: 0, phone: 0, address: 0 } });
+  }],
+
+  ['description: text without contact data is returned unchanged (byte-identical)', () => {
+    const text = '**Ausstattung**\\\\* ABS\\\\* Klimaanlage\\\\Leistung: 85 kW (116 PS)\\\\Verbrauch: 6,1 l/100km\\\\';
+    const result = sanitizeMarktdeDescription(text);
+    assert.equal(result.text, text);
+    assert.deepEqual(result.removed, { url: 0, email: 0, phone: 0, address: 0 });
+    assert.deepEqual(sanitizeMarktdeDescription('').removed, { url: 0, email: 0, phone: 0, address: 0 });
+  }],
+
+  ['applyMarktdeColumns: only the markt.de columns change, every other column stays', () => {
+    const c = car('car1', { 'metaData.vin': 'WVWZZZ1KZAW000001', 'price.vatDeductible': true, 'price.vatRate': 19, 'price.currentSalesPrice': 23800, 'offer.offerDescription': 'x' });
+    const row = legacyRow(c);
+    const before = { ...row };
+    const facts = applyMarktdeColumns(row, c, ctx);
+    assert.equal(row[C.price], '20000.00');
+    assert.equal(row[C.vatFlag], '0');
+    assert.equal(row[C.vatRate], '19');
+    assert.equal(row[C.vin], 'WVWZZZ1KZAW000001');
+    assert.equal(row[C.images], ctx.images.join(';'));
+    assert.equal(row[C.listingUrl], getMarktdeListingUrl('auto.de', 'car1'));
+    assert.equal(row[C.co2], '137');
+    assert.equal(row[C.fuelCombined], '6,1');
+    assert.equal(row[C.description], before[C.description], 'description without contact data unchanged');
+    for (const key of ['0', '1', '3', '4']) {
+      assert.equal(row[key], before[key], `column ${key}`);
+    }
+    assert.equal(facts.vin, 'sent');
+    assert.equal(facts.descriptionRemovals.url, 0);
+  }],
+
+  ['applyMarktdeColumns: BEV -> fuel empty, CO2 0; nothing usable -> empty (never "undefined")', () => {
+    const bev = car('bev1', { 'consumption.fuel': 'selector_fuel_electrical', 'environmentEmissions.co2': null, 'consumption.consumptionCombined': 16.5 });
+    const row = legacyRow(bev);
+    applyMarktdeColumns(row, bev, ctx);
+    assert.equal(row[C.fuelCombined], '');
+    assert.equal(row[C.co2], '0');
+    const none = car('none1', { 'environmentEmissions.co2': null, 'consumption.consumptionCombined': null });
+    const row2 = legacyRow(none);
+    const facts = applyMarktdeColumns(row2, none, ctx);
+    assert.equal(row2[C.co2], '');
+    assert.equal(row2[C.fuelCombined], '');
+    assert.ok(facts.co2Empty && facts.fuelEmpty);
+    assert.ok(!convertToCSV(row2).includes('undefined'));
+  }],
+
+  ['applyMarktdeColumns: invalid stored VIN reported as invalid_dropped, missing as empty', () => {
+    const bad = car('v1', { 'metaData.vin': 'XYZ' });
+    assert.equal(applyMarktdeColumns(legacyRow(bad), bad, ctx).vin, 'invalid_dropped');
+    const missing = car('v2', {});
+    assert.equal(applyMarktdeColumns(legacyRow(missing), missing, ctx).vin, 'empty');
+  }],
+
+  ['20 fixtures: one CSV line each, 403 columns, B = vehicle id, OM = link with the car id, UTF-8 German text', () => {
+    const variants: Array<Record<string, any>> = [
+      {}, { 'price.vatDeductible': true, 'price.vatRate': 19 }, { 'price.vatDeductible': true, 'price.vatRate': null },
+      { 'consumption.fuel': 'selector_fuel_electrical' }, { 'metaData.vin': 'WVWZZZ1KZAW000001' }, { 'metaData.vin': 'bad' },
+      { 'mainData.subModel': null }, { 'mainData.make': 'Škoda', 'mainData.model': 'Octavia Combi' }, { 'mainData.firstRegistration': null },
+      { 'environmentEmissions.co2': null }, { 'consumption.consumptionCombined': null }, { 'offer.offerDescription': 'x' },
+      { 'price.currentSalesPrice': 79999 }, { 'price.currentSalesPrice': 1 }, { 'mainData.mileage': 0 },
+      { 'mainData.make': 'Mercedes-Benz', 'mainData.model': 'C 200 "Avantgarde"' }, { 'metaData.ownerId': 'dealer-2' },
+      { 'price.vatDeductible': true, 'price.vatRate': 7 }, { 'mainData.accidentDamaged': true }, { 'consumption.fuel': 'selector_fuel_diesel' },
+    ];
+    assert.equal(variants.length, 20);
+    variants.forEach((overrides, i) => {
+      const id = `fx${String(i).padStart(2, '0')}abcdef`;
+      const c = car(id, overrides);
+      const row = legacyRow(c);
+      applyMarktdeColumns(row, c, { domain: 'auto.de', images: imagesService.getCleanImages(id, images(id)).map(x => x.url) });
+      const line = convertToCSV(row);
+      assert.ok(!line.includes('\n'), 'one line per car');
+      // quote-aware split: the image cell carries `;` between URLs inside its quotes
+      const cells = line.match(/"(?:[^"]|"")*"|(?<=^|;)(?=;|$)/g);
+      assert.equal(cells.length, 403, `fixture ${i}: column count`);
+      assert.equal(cells[1], `"${c.metaData.vehicleId}"`);
+      assert.ok(cells[26].includes('hero1') && cells[26].includes(';'));
+      assert.ok(cells[402].includes(`/search/vehicle/${id}?source=marktde`));
+      assert.ok(!line.includes('undefined'), `fixture ${i}`);
+    });
+  }],
+
+  ['config: dry-run by default (marktde-dryrun), live only with marktdeDryRun=false; legacy sheet + file names', () => {
+    const base = { environment: Environment.PRODUCTION, exportType: ExportType.MARKTDE, apikey: 'k' } as any;
+    const dry = new MarktdeConfig(base);
+    assert.equal(dry.dryRun, true);
+    assert.deepEqual(dry.outputFiles, ['resources/marktde-dryrun/api_export_cars_marktde.csv', 'resources/marktde-dryrun/api_export_cars_marktde.zip']);
+    assert.equal(dry.stateDir, 'resources/marktde-state/dryrun');
+    assert.equal(dry.mappingSpreadsheetTitle, 'mobile_yescar');
+    assert.equal(dry.campaign, 'marktde');
+    assert.equal(dry.imageType, ImageType.default);
+    assert.equal(dry.domain, 'auto.de');
+    assert.equal(new MarktdeConfig({ ...base, marktdeDryRun: 'true' }).dryRun, true);
+    assert.equal(new MarktdeConfig({ ...base, marktdeDryRun: 'nope' }).dryRun, true);
+    const live = new MarktdeConfig({ ...base, marktdeDryRun: 'false' });
+    assert.equal(live.dryRun, false);
+    assert.equal(live.outputFiles[0], 'resources/marktde-export/api_export_cars_marktde.csv');
+    assert.equal(live.feedGuard.minPublishedItems, 1);
+    assert.equal(new MarktdeConfig({ ...base, feedGuardMinPublishedItems: '50' }).feedGuard.minPublishedItems, 50);
+  }],
+];
+
+(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);
+})();