@bytebrand/export-cars 1.26.27 → 1.26.29

package/test/google-feed-item-row.test.ts

@@ -1,121 +1,135 @@
-// Run: npm test (ts-node, no test framework needed)
-import * as assert from 'node:assert/strict';
-import { buildGoogleFeedItemRow } from '../src/transformers/google-feed-item-row';
-import { googleElectricRange, googleElectricRangeSource } from '../src/transformers/google-feed-envkv';
-
-const exportedAt = new Date('2026-10-08T23:30:00.000Z');
-
-const car = (fuel: string, extra: Record<string, any> = {}): any => ({
-  _id: 'cbd-1',
-  metaData: { vehicleId: 'veh-1' },
-  consumption: { fuel },
-  engineData: 'hybridPlugin' in extra ? { hybridPlugin: extra.hybridPlugin } : {},
-  battery: extra.battery || {},
-});
-
-// Shape of what GoogleTransformer returns after dropping the empty optional attributes.
-const item = (extra: Record<string, any> = {}): any => ({
-  id: 'cbd-1',
-  brand: 'VW',
-  model: 'Golf',
-  condition: 'Used',
-  engine: 'Gasoline',
-  price: '19990.5 EUR',
-  availability: 'in_stock',
-  ...extra,
-});
-
-const cases: Array<[string, () => void]> = [
-  ['combustion car: sent values, omitted attributes are null', () => {
-    const row = buildGoogleFeedItemRow(
-      car('selector_fuel_petrol', { hybridPlugin: false }),
-      item({ fuel_consumption: '5.1l/100km', co2_emissions: '118g/km' }),
-      '12345',
-      exportedAt,
-    );
-    assert.deepEqual(row, {
-      partitionDay: '2026-10-08',
-      exportedAt: '2026-10-08T23:30:00.000Z',
-      feed: 'google',
-      runId: '12345',
-      itemId: 'cbd-1',
-      vehicleId: 'veh-1',
-      make: 'VW',
-      model: 'Golf',
-      condition: 'Used',
-      fuel: 'selector_fuel_petrol',
-      hybridPlugin: false,
-      engine: 'Gasoline',
-      electricRange: null,
-      fuelConsumption: '5.1l/100km',
-      fuelConsumptionDischarged: null,
-      energyConsumption: null,
-      co2Emissions: '118g/km',
-      rangeSourceField: null,
-      price: 19990.5,
-      availability: 'in_stock',
-    });
-  }],
-  ['BEV: range source is the field the range came from', () => {
-    const bev = car('selector_fuel_electrical', { battery: { batteryRangeElectric: 400 } });
-    const row = buildGoogleFeedItemRow(
-      bev,
-      item({ engine: 'Electric', electric_range: googleElectricRange(bev), energy_consumption: '16.5kWh/100km', co2_emissions: '0g/km' }),
-      '12345',
-      exportedAt,
-    );
-    assert.equal(row.electricRange, '400km');
-    assert.equal(row.rangeSourceField, 'battery.batteryRangeElectric');
-    assert.equal(row.hybridPlugin, null);
-    assert.equal(row.energyConsumption, '16.5kWh/100km');
-    assert.equal(row.co2Emissions, '0g/km');
-  }],
-  ['plug-in: EAER first, then WLTP range, then delivered range', () => {
-    const phev = (battery: object) => car('selector_fuel_hybridElectricalPetrol', { hybridPlugin: true, battery });
-    assert.equal(googleElectricRangeSource(phev({ wltpTotalRange: 62, wltpRange: 59 })), 'battery.wltpTotalRange');
-    assert.equal(googleElectricRangeSource(phev({ wltpTotalRange: 0, wltpRange: 59 })), 'battery.wltpRange');
-    assert.equal(googleElectricRangeSource(phev({ batteryRangeElectric: 50 })), 'battery.batteryRangeElectric');
-    assert.equal(googleElectricRangeSource(phev({ wltpTotalRangeCity: 70 })), null);
-  }],
-  ['range source agrees with googleElectricRange', () => {
-    const cars = [
-      car('selector_fuel_electrical', { battery: { wltpRange: 451, batteryRangeElectric: 400 } }),
-      car('selector_fuel_electrical', { battery: { wltpRange: 0 } }),
-      car('selector_fuel_hybridElectricalPetrol', { hybridPlugin: false, battery: { wltpRange: 50 } }),
-      car('selector_fuel_petrol', { battery: { wltpRange: 50 } }),
-    ];
-    for (const c of cars) {
-      assert.equal(googleElectricRangeSource(c) === null, googleElectricRange(c) === undefined);
-    }
-    assert.equal(googleElectricRangeSource(cars[0]), 'battery.wltpRange');
-  }],
-  ['no range source when the item carries no electric_range', () => {
-    const bev = car('selector_fuel_electrical', { battery: { wltpRange: 451 } });
-    assert.equal(buildGoogleFeedItemRow(bev, item(), null, exportedAt).rangeSourceField, null);
-  }],
-  ['missing run id, vehicle id and unparsable price become null', () => {
-    const row = buildGoogleFeedItemRow(
-      { consumption: {} } as any,
-      item({ price: ' EUR', availability: undefined }),
-      undefined,
-      exportedAt,
-    );
-    assert.equal(row.runId, null);
-    assert.equal(row.vehicleId, null);
-    assert.equal(row.fuel, null);
-    assert.equal(row.price, null);
-    assert.equal(row.availability, null);
-  }],
-];
-
-let failed = 0;
-for (const [name, fn] of cases) {
-  try {
-    fn();
-    console.log(`ok   ${name}`);
-  } catch (e) {
-    failed++;
-    console.log(`FAIL ${name}\n     ${(e as Error).message}`);
-  }
-}
-if (failed) process.exit(1);
+// Run: npm test (ts-node, no test framework needed)
+import * as assert from 'node:assert/strict';
+import { buildGoogleFeedItemRow } from '../src/transformers/google-feed-item-row';
+import { googleElectricRange, googleElectricRangeSource } from '../src/transformers/google-feed-envkv';
+
+const exportedAt = new Date('2026-10-08T23:30:00.000Z');
+
+const car = (fuel: string, extra: Record<string, any> = {}): any => ({
+  _id: 'cbd-1',
+  metaData: { vehicleId: 'veh-1' },
+  consumption: { fuel },
+  engineData: 'hybridPlugin' in extra ? { hybridPlugin: extra.hybridPlugin } : {},
+  battery: extra.battery || {},
+});
+
+// Shape of what GoogleTransformer returns after dropping the empty optional attributes.
+const item = (extra: Record<string, any> = {}): any => ({
+  id: 'cbd-1',
+  brand: 'VW',
+  model: 'Golf',
+  condition: 'Used',
+  engine: 'Gasoline',
+  price: '19990.5 EUR',
+  availability: 'in_stock',
+  ...extra,
+});
+
+const cases: Array<[string, () => void]> = [
+  ['combustion car: sent values, omitted attributes are null', () => {
+    const row = buildGoogleFeedItemRow(
+      car('selector_fuel_petrol', { hybridPlugin: false }),
+      item({ fuel_consumption: '5.1l/100km', co2_emissions: '118g/km' }),
+      '12345',
+      exportedAt,
+    );
+    assert.deepEqual(row, {
+      partitionDay: '2026-10-08',
+      exportedAt: '2026-10-08T23:30:00.000Z',
+      feed: 'google',
+      runId: '12345',
+      itemId: 'cbd-1',
+      vehicleId: 'veh-1',
+      make: 'VW',
+      model: 'Golf',
+      condition: 'Used',
+      fuel: 'selector_fuel_petrol',
+      hybridPlugin: false,
+      engine: 'Gasoline',
+      electricRange: null,
+      fuelConsumption: '5.1l/100km',
+      fuelConsumptionDischarged: null,
+      energyConsumption: null,
+      co2Emissions: '118g/km',
+      rangeSourceField: null,
+      price: 19990.5,
+      availability: 'in_stock',
+      publicationGate: null,
+      estimatedAttributes: null,
+    });
+  }],
+  ['publication gate: mode and estimated attributes; none estimated is null', () => {
+    const petrol = car('selector_fuel_petrol', { hybridPlugin: false });
+    const gated = buildGoogleFeedItemRow(petrol, item(), '12345', exportedAt, {
+      mode: 'enforce',
+      estimatedAttributes: ['fuel_consumption', 'co2_emissions'],
+    });
+    assert.equal(gated.publicationGate, 'enforce');
+    assert.equal(gated.estimatedAttributes, 'fuel_consumption,co2_emissions');
+    const clean = buildGoogleFeedItemRow(petrol, item(), '12345', exportedAt, { mode: 'audit', estimatedAttributes: [] });
+    assert.equal(clean.publicationGate, 'audit');
+    assert.equal(clean.estimatedAttributes, null);
+  }],
+  ['BEV: range source is the field the range came from', () => {
+    const bev = car('selector_fuel_electrical', { battery: { batteryRangeElectric: 400 } });
+    const row = buildGoogleFeedItemRow(
+      bev,
+      item({ engine: 'Electric', electric_range: googleElectricRange(bev), energy_consumption: '16.5kWh/100km', co2_emissions: '0g/km' }),
+      '12345',
+      exportedAt,
+    );
+    assert.equal(row.electricRange, '400km');
+    assert.equal(row.rangeSourceField, 'battery.batteryRangeElectric');
+    assert.equal(row.hybridPlugin, null);
+    assert.equal(row.energyConsumption, '16.5kWh/100km');
+    assert.equal(row.co2Emissions, '0g/km');
+  }],
+  ['plug-in: EAER first, then WLTP range, then delivered range', () => {
+    const phev = (battery: object) => car('selector_fuel_hybridElectricalPetrol', { hybridPlugin: true, battery });
+    assert.equal(googleElectricRangeSource(phev({ wltpTotalRange: 62, wltpRange: 59 })), 'battery.wltpTotalRange');
+    assert.equal(googleElectricRangeSource(phev({ wltpTotalRange: 0, wltpRange: 59 })), 'battery.wltpRange');
+    assert.equal(googleElectricRangeSource(phev({ batteryRangeElectric: 50 })), 'battery.batteryRangeElectric');
+    assert.equal(googleElectricRangeSource(phev({ wltpTotalRangeCity: 70 })), null);
+  }],
+  ['range source agrees with googleElectricRange', () => {
+    const cars = [
+      car('selector_fuel_electrical', { battery: { wltpRange: 451, batteryRangeElectric: 400 } }),
+      car('selector_fuel_electrical', { battery: { wltpRange: 0 } }),
+      car('selector_fuel_hybridElectricalPetrol', { hybridPlugin: false, battery: { wltpRange: 50 } }),
+      car('selector_fuel_petrol', { battery: { wltpRange: 50 } }),
+    ];
+    for (const c of cars) {
+      assert.equal(googleElectricRangeSource(c) === null, googleElectricRange(c) === undefined);
+    }
+    assert.equal(googleElectricRangeSource(cars[0]), 'battery.wltpRange');
+  }],
+  ['no range source when the item carries no electric_range', () => {
+    const bev = car('selector_fuel_electrical', { battery: { wltpRange: 451 } });
+    assert.equal(buildGoogleFeedItemRow(bev, item(), null, exportedAt).rangeSourceField, null);
+  }],
+  ['missing run id, vehicle id and unparsable price become null', () => {
+    const row = buildGoogleFeedItemRow(
+      { consumption: {} } as any,
+      item({ price: ' EUR', availability: undefined }),
+      undefined,
+      exportedAt,
+    );
+    assert.equal(row.runId, null);
+    assert.equal(row.vehicleId, null);
+    assert.equal(row.fuel, null);
+    assert.equal(row.price, null);
+    assert.equal(row.availability, null);
+  }],
+];
+
+let failed = 0;
+for (const [name, fn] of cases) {
+  try {
+    fn();
+    console.log(`ok   ${name}`);
+  } catch (e) {
+    failed++;
+    console.log(`FAIL ${name}\n     ${(e as Error).message}`);
+  }
+}
+if (failed) process.exit(1);

package/test/image-url-validator.test.ts

@@ -0,0 +1,110 @@
+// Run: npm test (ts-node, no test framework needed)
+// Local stub image host — no real network. requireHttps is switched off only for the stub server.
+import * as assert from 'node:assert/strict';
+import { createServer, IncomingMessage, ServerResponse } from 'http';
+import { AddressInfo } from 'net';
+import { ImageUrlRejectReason as R, ImageUrlValidator } from '../src/services/image-url-validator.service';
+
+const hits: Record<string, number> = {};
+const JPEG = Buffer.from([0xff, 0xd8, 0xff, 0xe0, 0x00, 0x10]);
+
+const routes: Record<string, (req: IncomingMessage, res: ServerResponse) => void> = {
+  '/ok.jpg': (_, res) => { res.writeHead(200, { 'Content-Type': 'image/jpeg' }); res.end(JPEG); },
+  '/ok.png': (_, res) => { res.writeHead(200, { 'Content-Type': 'image/png' }); res.end(); },
+  '/photo.webp': (_, res) => { res.writeHead(200, { 'Content-Type': 'image/webp' }); res.end(); },
+  '/page.html': (_, res) => { res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' }); res.end('<html>'); },
+  // images.auto.de answers unknown images exactly like this: 404 with a placeholder JPEG body
+  '/missing.jpg': (_, res) => { res.writeHead(404, { 'Content-Type': 'image/jpeg' }); res.end(JPEG); },
+  '/forbidden.jpg': (_, res) => { res.writeHead(403, { 'Content-Type': 'text/html' }); res.end('Just a moment...'); },
+  '/error.jpg': (_, res) => { res.writeHead(503); res.end(); },
+  '/moved.jpg': (_, res) => { res.writeHead(302, { Location: '/ok.jpg' }); res.end(); },
+  '/loop.jpg': (_, res) => { res.writeHead(302, { Location: '/loop.jpg' }); res.end(); },
+  '/slow.jpg': (_, res) => { setTimeout(() => { res.writeHead(200, { 'Content-Type': 'image/jpeg' }); res.end(); }, 400); },
+  '/no-head.jpg': (req, res) => {
+    if (req.method === 'HEAD') { res.writeHead(405); res.end(); return; }
+    res.writeHead(200, { 'Content-Type': 'image/jpeg' }); res.end(JPEG);
+  },
+  '/carimage/noimage/7pNvWELuWhZX/large-cached.jpeg': (_, res) => { res.writeHead(200, { 'Content-Type': 'image/jpeg' }); res.end(JPEG); },
+};
+
+const server = createServer((req, res) => {
+  const path = req.url.split('?')[0];
+  hits[path] = (hits[path] ?? 0) + 1;
+  (routes[path] ?? ((_, r) => { r.writeHead(404); r.end(); }))(req, res);
+});
+
+(async () => {
+  await new Promise<void>(resolve => server.listen(0, '127.0.0.1', resolve));
+  const base = `http://127.0.0.1:${(server.address() as AddressInfo).port}`;
+  const validator = (options = {}) => new ImageUrlValidator({ requireHttps: false, timeoutMs: 150, ...options });
+  const expectReject = async (path: string, reason: R, status?: number) => {
+    const check = await validator().validate(`${base}${path}`);
+    assert.equal(check.ok, false);
+    assert.equal(check.reason, reason);
+    if (status) assert.equal(check.status, status);
+  };
+
+  const cases: Array<[string, () => Promise<void>]> = [
+    ['200 image/jpeg and image/png are valid', async () => {
+      assert.equal((await validator().validate(`${base}/ok.jpg`)).ok, true);
+      assert.equal((await validator().validate(`${base}/ok.png`)).ok, true);
+    }],
+    ['404 with an image/jpeg placeholder body is rejected on status', () => expectReject('/missing.jpg', R.httpStatus, 404)],
+    ['403 (WAF / challenge) is rejected', () => expectReject('/forbidden.jpg', R.httpStatus, 403)],
+    ['5xx is rejected', () => expectReject('/error.jpg', R.httpStatus, 503)],
+    ['wrong MIME (HTML) is rejected', () => expectReject('/page.html', R.wrongMime)],
+    ['WebP is rejected unless the partner allows it', async () => {
+      await expectReject('/photo.webp', R.wrongMime);
+      assert.equal((await validator({ allowedMimeTypes: ['image/webp'] }).validate(`${base}/photo.webp`)).ok, true);
+    }],
+    ['a redirect within the limit is followed and the final URL kept', async () => {
+      const check = await validator().validate(`${base}/moved.jpg`);
+      assert.equal(check.ok, true);
+      assert.equal(check.finalUrl, `${base}/ok.jpg`);
+    }],
+    ['redirect loop is rejected', () => expectReject('/loop.jpg', R.tooManyRedirects)],
+    ['timeout is rejected', () => expectReject('/slow.jpg', R.timeout)],
+    ['HEAD not allowed (405) falls back to GET', async () => {
+      assert.equal((await validator().validate(`${base}/no-head.jpg`)).ok, true);
+    }],
+    ['placeholder URL is rejected without any request', async () => {
+      await expectReject('/carimage/noimage/7pNvWELuWhZX/large-cached.jpeg', R.placeholder);
+      assert.equal(hits['/carimage/noimage/7pNvWELuWhZX/large-cached.jpeg'], undefined);
+    }],
+    ['non-HTTPS, credentials and relative URLs are rejected without a request', async () => {
+      const strict = new ImageUrlValidator();
+      assert.equal((await strict.validate(`${base}/ok.png`)).reason, R.notHttps);
+      assert.equal((await strict.validate('https://user:secret@images.auto.de/carimage/a/b/large-cached.jpeg')).reason, R.credentials);
+      assert.equal((await strict.validate('/carimage/a/b/large-cached.jpeg')).reason, R.invalidUrl);
+      assert.equal((await strict.validate('ftp://images.auto.de/a.jpg')).reason, R.invalidUrl);
+    }],
+    ['each URL is probed once per run (cached) and counted once', async () => {
+      const v = validator();
+      const before = hits['/ok.jpg'];
+      await v.validateAll([`${base}/ok.jpg`, `${base}/ok.jpg`, `${base}/missing.jpg`]);
+      await v.validate(`${base}/ok.jpg`);
+      assert.equal(hits['/ok.jpg'] - before, 1);
+      assert.deepEqual(v.stats, { ok: 1, [R.httpStatus]: 1 });
+    }],
+    ['probe budget: URLs beyond maxProbes are reported, not fetched', async () => {
+      const v = validator({ maxProbes: 1 });
+      const [first, second] = await v.validateAll([`${base}/ok.jpg`, `${base}/ok.png`]);
+      assert.equal(first.ok, true);
+      assert.equal(second.reason, R.budgetExhausted);
+    }],
+  ];
+
+  let failed = 0;
+  for (const [name, fn] of cases) {
+    try {
+      await fn();
+      console.log(`ok   ${name}`);
+    } catch (e) {
+      failed += 1;
+      console.error(`FAIL ${name}\n     ${e.message}`);
+    }
+  }
+  (server as any).closeAllConnections?.(); // Node ≥18.2; @types/node here is older
+  server.close();
+  if (failed) process.exit(1);
+})();

package/test/images-regression.test.ts

@@ -0,0 +1,23 @@
+// Run: npm test (ts-node, no test framework needed)
+// ADV-336 regression lock: the image URLs every existing partner export (Google, Meta-marketing,
+// default partners) builds must stay byte-identical. images.golden.json was recorded from the
+// ImagesService BEFORE the clean profile was added — never regenerate it to make this test pass.
+import * as assert from 'node:assert/strict';
+import { readFileSync } from 'fs';
+import { snapshotExistingImageOutputs } from './fixtures/images-service.harness';
+
+const golden = JSON.parse(readFileSync(`${__dirname}/fixtures/images.golden.json`, 'utf8'));
+
+snapshotExistingImageOutputs().then((actual) => {
+  let failed = 0;
+  for (const name of Object.keys(golden)) {
+    try {
+      assert.deepEqual(actual[name], golden[name]);
+      console.log(`ok   existing image outputs unchanged: ${name}`);
+    } catch (e) {
+      failed += 1;
+      console.error(`FAIL existing image outputs changed: ${name}\n     ${e.message}`);
+    }
+  }
+  if (failed) process.exit(1);
+});