fg-devkit 1.17.3 → 1.19.2

package/scripts/piwik-dimensions.test.mjs

@@ -0,0 +1,400 @@
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import path from 'node:path'
+import test from 'node:test'
+import { fileURLToPath } from 'node:url'
+
+import {
+  accountFromPiwikUrl,
+  defaultEnvironmentPair,
+  defaultPiwikEnvironment,
+  discoverPiwikSites,
+  normalizeDimension,
+  uniquePiwikEnvironments,
+} from './piwik-common.mjs'
+import {
+  diffDimensions,
+  diffEnvironments,
+  formatDimensionReport,
+  formatEnvironmentReport,
+  parseDimensionSource,
+  planCreates,
+  planEnvironmentMigration,
+  planLocalPull,
+  rewriteDimensionNumbers,
+} from './piwik-dimensions.mjs'
+
+const scriptDir = path.dirname(fileURLToPath(import.meta.url))
+
+const bookingSource = `
+export const customDimensions = {
+  clientNumber: 1,
+  rowsBooked: 7,
+  rowsFailed: 13,
+} as const
+`
+
+const portalSource = `
+export const customDimensions = {
+  action: 1,
+  serviceName: 24,
+  deprecated: 25 // Unused - accidentally added
+} as const
+
+export const sessionDimensions = {
+  permission: 18,
+  organizationName: 26
+} as const
+`
+
+const appSource = `
+/* eslint-disable perfectionist/sort-enums */
+export enum SessionCustomDimensions {
+  OS = 1,
+  hasFriskvard = 2,
+}
+
+export enum CustomDimensions {
+  deviceLocale = 18,
+  eventTimestamp = 78,
+}
+`
+
+test('parses const maps and enums into event and session scopes', () => {
+  const booking = parseDimensionSource(bookingSource, 'src/analytics/dimensions.ts')
+  assert.deepEqual(
+    booking.map((item) => [item.scope, item.slot, item.key]),
+    [
+      ['event', 1, 'clientNumber'],
+      ['event', 7, 'rowsBooked'],
+      ['event', 13, 'rowsFailed'],
+    ],
+  )
+
+  const portal = parseDimensionSource(portalSource, 'src/analytics/dimensions.ts')
+  assert.equal(portal.find((item) => item.key === 'deprecated')?.slot, 25)
+  assert.equal(portal.find((item) => item.key === 'permission')?.scope, 'session')
+  assert.equal(portal.find((item) => item.key === 'serviceName')?.scope, 'event')
+
+  const app = parseDimensionSource(appSource, 'src/util/piwikDimensions.ts')
+  assert.equal(app.find((item) => item.key === 'OS')?.scope, 'session')
+  assert.equal(app.find((item) => item.key === 'deviceLocale')?.scope, 'event')
+  assert.equal(app.find((item) => item.key === 'eventTimestamp')?.slot, 78)
+})
+
+test('rejects a duplicated slot in one scope', () => {
+  assert.throws(
+    () => parseDimensionSource('export const customDimensions = { a: 1, b: 1 } as const'),
+    /Duplicate event slot 1/,
+  )
+})
+
+test('matches the app id to tracking_id even when the Piwik slot differs', () => {
+  const locals = parseDimensionSource(`
+    export const customDimensions = { active: 46 } as const
+  `)
+  const remotes = [
+    {
+      id: '1',
+      name: 'active',
+      slot: 29,
+      trackingId: 46,
+      scope: 'event',
+      active: true,
+      caseSensitive: false,
+      description: 'Active',
+    },
+  ]
+  const diff = diffDimensions(locals, remotes)
+  assert.equal(diff.inSync.length, 1)
+  assert.equal(diff.missing.length, 0)
+  assert.equal(diff.inSync[0].remote.slot, 29)
+  const report = formatDimensionReport(diff, planCreates(diff.missing, remotes))
+  assert.match(report, /│ 29\s+│ 46\s+│ active\s+│ active\s+│ Active\s+│ in sync\s+│ Active\s+│/)
+  assert.equal(planCreates(diff.missing, remotes).creates.length, 0)
+})
+
+test('diff matches on tracking_id and plans creates in order', () => {
+  const locals = parseDimensionSource(portalSource)
+  const remotes = [
+    { id: '1', name: 'action', slot: 1, trackingId: 1, scope: 'event', active: true, caseSensitive: false, description: '' },
+    { id: '2', name: 'Old name', slot: 8, trackingId: 18, scope: 'session', active: true, caseSensitive: false, description: '' },
+    { id: '3', name: 'extra', slot: 2, trackingId: 2, scope: 'event', active: false, caseSensitive: false, description: '' },
+  ]
+  const diff = diffDimensions(locals, remotes)
+  assert.equal(diff.inSync.length, 1)
+  assert.equal(diff.nameMismatch[0].local.key, 'permission')
+  assert.equal(diff.remoteOnly[0].name, 'extra')
+  assert.equal(diff.trackingMismatch[0].remote.trackingId, 18)
+
+  const plan = planCreates(diff.missing, remotes)
+  assert.deepEqual(
+    plan.creates.map((item) => `${item.scope}:${item.slot}`),
+    [],
+  )
+  assert.match(plan.blocked[0].reason, /Next tracking_id is 3/)
+  const report = formatDimensionReport(diff, plan)
+  assert.match(report, /different name/)
+  assert.match(report, /cannot add/)
+})
+
+test('status stays in one column when a name is long', () => {
+  const longName = 'bookingConfirmationStep'.repeat(2)
+  const locals = parseDimensionSource(`
+    export const customDimensions = { ${longName}: 1, short: 2 } as const
+  `)
+  const remotes = [longName, 'short'].map((name, index) => ({
+    id: String(index + 1),
+    name,
+    slot: index + 1,
+    trackingId: index + 1,
+    scope: 'event',
+    active: true,
+    caseSensitive: false,
+    description: '',
+  }))
+  const report = formatDimensionReport(diffDimensions(locals, remotes), { creates: [], blocked: [] })
+  const statusAt = report
+    .split('\n')
+    .filter((line) => line.startsWith('│') && line.includes('in sync'))
+    .map((line) => line.indexOf('in sync'))
+  assert.equal(statusAt.length, 2)
+  assert.equal(statusAt[0], statusAt[1])
+  assert.ok(statusAt[0] > longName.length)
+})
+
+test('report rows are ordered by scope and numeric slot', () => {
+  const locals = parseDimensionSource(`
+    export const customDimensions = { a: 1, b: 2, c: 10, d: 13 } as const
+    export const sessionDimensions = { permission: 2 } as const
+  `)
+  const remotes = [1, 2, 10].map((slot) => ({
+    id: String(slot),
+    name: locals.find((item) => item.scope === 'event' && item.slot === slot)?.key ?? '',
+    slot,
+    trackingId: slot,
+    scope: 'event',
+    active: true,
+    caseSensitive: false,
+    description: '',
+  }))
+  const diff = diffDimensions(locals, remotes)
+  const plan = planCreates(diff.missing, remotes)
+  const report = formatDimensionReport(diff, plan)
+  const eventAt = report.indexOf('\nevent\n')
+  const sessionAt = report.indexOf('\nsession\n')
+  assert.ok(eventAt >= 0 && sessionAt > eventAt)
+  const ids = report
+    .split('\n')
+    .filter((line) => line.startsWith('│') && !line.includes('tracking_id'))
+    .map((line) => line.split('│')[2].trim())
+  assert.deepEqual(ids, ['1', '2', '10', '13', '2'])
+})
+
+test('creates the next free slots and blocks a later gap', () => {
+  const locals = parseDimensionSource(`
+    export const customDimensions = { a: 1, b: 2, c: 4 } as const
+  `)
+  const plan = planCreates(locals, [])
+  assert.deepEqual(
+    plan.creates.map((item) => item.slot),
+    [1, 2],
+  )
+  assert.equal(plan.blocked.length, 1)
+  assert.match(plan.blocked[0].reason, /Next tracking_id is 3/)
+})
+
+test('product slots can be chosen when they are free', () => {
+  const locals = parseDimensionSource(`
+    export const productDimensions = { color: 2, size: 4 } as const
+  `)
+  const plan = planCreates(locals, [
+    { id: 'p', name: 'taken', slot: 2, trackingId: 2, scope: 'product', active: true, caseSensitive: false, description: '' },
+  ])
+  assert.deepEqual(
+    plan.creates.map((item) => item.key),
+    ['size'],
+  )
+  assert.match(plan.blocked[0].reason, /already used/)
+})
+
+test('event and session share one tracking_id sequence', () => {
+  const locals = parseDimensionSource(`
+    export const sessionDimensions = { permission: 1 } as const
+    export const customDimensions = { action: 2 } as const
+  `)
+  const plan = planCreates(locals, [])
+  assert.deepEqual(
+    plan.creates.map((item) => `${item.scope}:${item.slot}`),
+    ['session:1', 'event:2'],
+  )
+})
+
+test('discovers account and website id from env modules', () => {
+  const sites = discoverPiwikSites(`
+    const production: EnvironmentConstants = {
+      environment: 'production',
+      piwikUrl: 'https://terveystalo.piwik.pro',
+      piwikId: '475754f6-f457-4203-9d8f-c58b510fadba',
+    }
+    const developmentEnvironment: EnvironmentConstants = {
+      environment: 'development',
+      piwikProBaseUrl: 'https://terveystalo.piwik.pro',
+      piwikProId: '6931c50c-b8ea-4960-8153-6916586ecd5b',
+    }
+  `)
+  assert.equal(accountFromPiwikUrl(sites[0].url), 'terveystalo')
+  assert.equal(sites[0].websiteId, '475754f6-f457-4203-9d8f-c58b510fadba')
+  assert.equal(sites[1].environment, 'development')
+  assert.equal(sites[1].websiteId, '6931c50c-b8ea-4960-8153-6916586ecd5b')
+})
+
+test('environments that share a piwik id collapse to one choice', () => {
+  const unique = uniquePiwikEnvironments([
+    { environment: 'localhost', account: 'terveystalo', websiteId: '049864b3-ba27-42ca-b89f-ad2b130aa64b' },
+    { environment: 'development', account: 'terveystalo', websiteId: '049864b3-ba27-42ca-b89f-ad2b130aa64b' },
+    { environment: 'preprod', account: 'terveystalo', websiteId: '049864b3-ba27-42ca-b89f-ad2b130aa64b' },
+    { environment: 'production', account: 'terveystalo', websiteId: '475754f6-f457-4203-9d8f-c58b510fadba' },
+  ])
+  assert.deepEqual(
+    unique.map((site) => site.environment),
+    ['preprod', 'production'],
+  )
+  assert.equal(defaultPiwikEnvironment(unique), 'preprod')
+  assert.equal(defaultPiwikEnvironment([{ environment: 'production' }]), 'production')
+})
+
+test('normalizes a JSON:API custom dimension', () => {
+  const remote = normalizeDimension(
+    {
+      id: 'abc',
+      attributes: {
+        name: 'Rows booked',
+        slot: 7,
+        tracking_id: 7,
+        scope: 'event',
+        active: true,
+        case_sensitive: false,
+        website_id: 'site',
+      },
+    },
+    'event',
+  )
+  assert.equal(remote.slot, 7)
+  assert.equal(remote.scope, 'event')
+  assert.equal(remote.websiteId, 'site')
+})
+
+test('environment pair defaults to a non-production source and production target', () => {
+  assert.deepEqual(
+    defaultEnvironmentPair([{ environment: 'preprod' }, { environment: 'production' }]),
+    { from: 'preprod', to: 'production' },
+  )
+  assert.deepEqual(
+    defaultEnvironmentPair([{ environment: 'staging' }, { environment: 'production' }]),
+    { from: 'staging', to: 'production' },
+  )
+})
+
+/**
+ * @param {Record<string, unknown>} overrides
+ */
+function remoteDimension(overrides) {
+  return {
+    id: '1',
+    name: 'active',
+    slot: 1,
+    trackingId: 1,
+    scope: 'event',
+    active: true,
+    caseSensitive: false,
+    description: '',
+    ...overrides,
+  }
+}
+
+test('compares environments on tracking_id and keeps in-sync rows', () => {
+  const source = [
+    remoteDimension({ id: 'a', name: 'active', slot: 29, trackingId: 46, description: 'Active' }),
+    remoteDimension({ id: 'b', name: 'step', slot: 30, trackingId: 47 }),
+  ]
+  const target = [
+    remoteDimension({ id: 'c', name: 'active', slot: 12, trackingId: 46, description: 'Active' }),
+  ]
+  const diff = diffEnvironments(source, target)
+  assert.equal(diff.inSync.length, 1)
+  assert.equal(diff.inSync[0].target.slot, 12)
+  assert.equal(diff.missing[0].trackingId, 47)
+  const plan = planEnvironmentMigration(diff, target)
+  assert.equal(plan.creates.length, 0)
+  assert.match(plan.blocked[0].reason, /Next tracking_id is 1/)
+  const report = formatEnvironmentReport(diff, plan, 'preprod', 'production')
+  assert.match(report, /│ 29\s+│ 46\s+│ active\s+│ 12\s+│ 46\s+│ active\s+│ Active\s+│ in sync\s+│ Active\s+│/)
+  assert.match(report, /tracking_id preprod/)
+  assert.match(report, /tracking_id production/)
+  assert.match(report, /in sync/)
+})
+
+test('plans environment migration in tracking_id order and blocks a gap', () => {
+  const source = [
+    remoteDimension({ name: 'one', trackingId: 1, slot: 1 }),
+    remoteDimension({ id: '2', name: 'two', trackingId: 2, slot: 2, description: 'Second' }),
+    remoteDimension({ id: '4', name: 'four', trackingId: 4, slot: 4 }),
+  ]
+  const target = [
+    remoteDimension({ name: 'old', trackingId: 1, slot: 8, description: 'Old' }),
+    remoteDimension({ id: 'x', name: 'extra', trackingId: 9, slot: 9 }),
+  ]
+  const diff = diffEnvironments(source, target)
+  assert.deepEqual(diff.changed[0].fields, ['name', 'description'])
+  assert.equal(diff.targetOnly[0].name, 'extra')
+  const plan = planEnvironmentMigration(diff, target)
+  assert.deepEqual(
+    plan.creates.map((item) => item.slot),
+    [2],
+  )
+  assert.match(plan.blocked[0].reason, /Next tracking_id is 3/)
+  const report = formatEnvironmentReport(diff, plan, 'staging', 'production')
+  assert.match(report, /different name, different description/)
+  assert.match(report, /cannot add/)
+  assert.match(report, /only in production/)
+})
+
+test('pull plans tracking id updates from Piwik into the local map', () => {
+  const locals = parseDimensionSource(`
+    export const customDimensions = { active: 29, step: 30 } as const
+  `)
+  const remotes = [
+    remoteDimension({ name: 'active', slot: 12, trackingId: 46 }),
+    remoteDimension({ id: '2', name: 'step', slot: 13, trackingId: 30 }),
+    remoteDimension({ id: '3', name: 'extra', slot: 14, trackingId: 50 }),
+  ]
+  const plan = planLocalPull(locals, remotes)
+  assert.equal(plan.updates.length, 1)
+  assert.equal(plan.updates[0].local.key, 'active')
+  assert.equal(plan.updates[0].next, 46)
+  assert.equal(plan.inSync.length, 1)
+  assert.equal(plan.remoteOnly[0].name, 'extra')
+  const source = 'export const customDimensions = { active: 29, step: 30 } as const\n'
+  assert.equal(
+    rewriteDimensionNumbers(source, [{ key: 'active', from: 29, to: 46 }]),
+    'export const customDimensions = { active: 46, step: 30 } as const\n',
+  )
+})
+
+test('parses the real consumer dimension files when they are checked out beside fg-devkit', () => {
+  const files = [
+    ['../../bokningsverktyget-ui/src/analytics/dimensions.ts', 'event', 'rowsBooked', 7],
+    ['../../webbportalen-ui/src/analytics/dimensions.ts', 'session', 'organizationName', 26],
+    ['../../feelgood-app/src/util/piwikDimensions.ts', 'event', 'eventTimestamp', 78],
+  ]
+  for (const [relative, scope, key, slot] of files) {
+    const file = path.join(scriptDir, relative)
+    if (!fs.existsSync(file)) continue
+    const dimensions = parseDimensionSource(fs.readFileSync(file, 'utf8'), relative)
+    const found = dimensions.find((item) => item.key === key)
+    assert.ok(found, `${key} missing in ${relative}`)
+    assert.equal(found.scope, scope)
+    assert.equal(found.slot, slot)
+  }
+})