@cspeach/cli 1.1.18 → 1.1.19

package/test-harness/fe-draft/variants.ts

@@ -0,0 +1,196 @@
+// cspeach-cli/test-harness/fe-draft/variants.ts
+//
+// L1-3 — backend VARIANTS of the captured draft `$metadata`, built IN MEMORY.
+//
+// The captured ZUI_LAS_INSPECTIONLOG_O4 service carries Severity and Status as
+// raw one-letter codes with no text (that is what the real system emitted), and
+// every LineItem column is labelled. The `labels` / `no-raw-codes` checks need
+// a positive case and negatives, so these pure transforms derive them from the
+// capture. The result is written only to the harness's temp folder; the
+// scrubbed capture in fixtures/metadata/ is never written, copied or edited.
+//
+// Said plainly: the coded-with-text shape is HARNESS-BUILT, not captured. A
+// real capture of it is owed once a stack built with the current RAP rules
+// exists (CAPTURE.md, "Not present anywhere on the system").
+
+const ENTITY_TYPE = 'InspectionLogType';
+const CODED = [
+  { property: 'Severity', text: 'SeverityText' },
+  { property: 'Status', text: 'StatusText' },
+] as const;
+
+function mustReplace(xml: string, find: RegExp, replace: (m: string) => string, what: string): string {
+  if (!find.test(xml)) throw new Error(`variant anchor not found in the captured metadata: ${what}`);
+  return xml.replace(find, replace);
+}
+
+/**
+ * Give Severity and Status a text: a `…Text` property on the entity type and
+ * `SAP__common.Text` on the code, with `SAP__UI.TextArrangement` TextOnly when
+ * asked. Without an arrangement the OData default applies (TextFirst →
+ * "Open (O)"), which is the negative case for `no-raw-codes`.
+ */
+export function withCodeTexts(xml: string, arrangement?: 'TextOnly'): string {
+  let out = mustReplace(
+    xml,
+    new RegExp(`(<EntityType Name="${ENTITY_TYPE}"[^>]*>(?:(?!</EntityType>)[\\s\\S])*?<Property Name="Status"[^>]*/>)`),
+    (m) => m + CODED.map((c) => `<Property Name="${c.text}" Type="Edm.String" MaxLength="20"/>`).join(''),
+    `${ENTITY_TYPE}/Status property`,
+  );
+  const arr = arrangement
+    ? `<Annotation Term="SAP__UI.TextArrangement" EnumMember="SAP__UI.TextArrangementType/${arrangement}"/>`
+    : '';
+  for (const c of CODED) {
+    out = mustReplace(
+      out,
+      new RegExp(`<Annotations Target="SAP__self\\.${ENTITY_TYPE}/${c.property}">`),
+      (m) => `${m}<Annotation Term="SAP__common.Text" Path="${c.text}">${arr}</Annotation>`,
+      `${ENTITY_TYPE}/${c.property} annotations`,
+    );
+  }
+  return out;
+}
+
+/** Strip every label a Fiori header could use: Common.Label/Heading/QuickInfo and DataField Label. */
+export function withoutLabels(xml: string): string {
+  const out = xml
+    .replace(/<Annotation Term="SAP__common\.(?:Label|Heading|QuickInfo)" String="[^"]*"\/>/g, '')
+    .replace(/<PropertyValue Property="Label" String="[^"]*"\/>/g, '');
+  if (out === xml) throw new Error('variant anchor not found in the captured metadata: no labels to strip');
+  return out;
+}
+
+const SEVERITY_TEXT: Record<string, string> = { H: 'High', M: 'Medium', L: 'Low' };
+const STATUS_TEXT: Record<string, string> = { O: 'Open', C: 'Closed' };
+
+/**
+ * L1-5b — value helps on the two coded fields, built in memory (the capture has
+ * value helps only on the draft-admin user fields, CAPTURE.md). Status gets a
+ * FIXED-VALUES value help (a dropdown popover at runtime), Severity a plain
+ * value list (a dialog). Each reads a small code-list entity set added to the
+ * service (`StatusVH`, `SeverityVH`: Code + Text). Apply AFTER withCodeTexts.
+ * Harness-built, not captured — said plainly, like withCodeTexts.
+ */
+export function withValueHelps(xml: string): string {
+  const vhTypes = ['StatusVH', 'SeverityVH']
+    .map(
+      (n) =>
+        `<EntityType Name="${n}Type"><Key><PropertyRef Name="Code"/></Key>` +
+        `<Property Name="Code" Type="Edm.String" Nullable="false" MaxLength="1"/>` +
+        `<Property Name="Text" Type="Edm.String" MaxLength="20"/></EntityType>`,
+    )
+    .join('');
+  let out = mustReplace(
+    xml,
+    new RegExp(`<EntityType Name="${ENTITY_TYPE}"`),
+    (m) => vhTypes + m,
+    `${ENTITY_TYPE} entity type`,
+  );
+  out = mustReplace(
+    out,
+    /<EntityContainer Name="Container">/,
+    (m) =>
+      m +
+      '<EntitySet Name="StatusVH" EntityType="SAP__self.StatusVHType"/>' +
+      '<EntitySet Name="SeverityVH" EntityType="SAP__self.SeverityVHType"/>',
+    'entity container',
+  );
+  const valueList = (local: string, set: string, label: string) =>
+    `<Annotation Term="SAP__common.ValueList"><Record>` +
+    `<PropertyValue Property="Label" String="${label}"/>` +
+    `<PropertyValue Property="CollectionPath" String="${set}"/>` +
+    `<PropertyValue Property="Parameters"><Collection>` +
+    `<Record Type="SAP__common.ValueListParameterInOut"><PropertyValue Property="LocalDataProperty" PropertyPath="${local}"/><PropertyValue Property="ValueListProperty" String="Code"/></Record>` +
+    `<Record Type="SAP__common.ValueListParameterDisplayOnly"><PropertyValue Property="ValueListProperty" String="Text"/></Record>` +
+    `</Collection></PropertyValue></Record></Annotation>`;
+  out = mustReplace(
+    out,
+    new RegExp(`<Annotations Target="SAP__self\\.${ENTITY_TYPE}/Status">`),
+    (m) => m + valueList('Status', 'StatusVH', 'Status') + '<Annotation Term="SAP__common.ValueListWithFixedValues"/>',
+    `${ENTITY_TYPE}/Status annotations`,
+  );
+  out = mustReplace(
+    out,
+    new RegExp(`<Annotations Target="SAP__self\\.${ENTITY_TYPE}/Severity">`),
+    (m) => m + valueList('Severity', 'SeverityVH', 'Severity'),
+    `${ENTITY_TYPE}/Severity annotations`,
+  );
+  // The code lists' own labels + the text of each code (so the dialog columns are labelled).
+  const vhAnn = (n: string) =>
+    `<Annotations Target="SAP__self.${n}Type/Code"><Annotation Term="SAP__common.Label" String="Code"/>` +
+    `<Annotation Term="SAP__common.Text" Path="Text"/></Annotations>` +
+    `<Annotations Target="SAP__self.${n}Type/Text"><Annotation Term="SAP__common.Label" String="Description"/></Annotations>`;
+  out = mustReplace(
+    out,
+    new RegExp(`<Annotations Target="SAP__self\\.${ENTITY_TYPE}/Status">`),
+    (m) => vhAnn('StatusVH') + vhAnn('SeverityVH') + m,
+    'value-help annotations anchor',
+  );
+  return out;
+}
+
+/** Rows of the two code lists withValueHelps adds. */
+export const VALUE_HELP_ROWS = {
+  StatusVH: Object.entries(STATUS_TEXT).map(([Code, Text]) => ({ Code, Text })),
+  SeverityVH: Object.entries(SEVERITY_TEXT).map(([Code, Text]) => ({ Code, Text })),
+};
+
+/**
+ * The mock backend's behaviour for the draft root, as a fe-mockserver
+ * `<EntitySet>.js` module (CommonJS source, written into the harness temp dir):
+ * the text of each code follows the code (a RAP service reads it through an
+ * association; the mock stores it), and — for the negative test — activation is
+ * REJECTED with a 400 and an SAP message while Status is `rejectStatus`.
+ */
+export function inspectionLogHooks(opts: { rejectStatus?: string } = {}): string {
+  return `'use strict';
+const STATUS_TEXT = ${JSON.stringify(STATUS_TEXT)};
+const SEVERITY_TEXT = ${JSON.stringify(SEVERITY_TEXT)};
+const REJECT = ${JSON.stringify(opts.rejectStatus ?? null)};
+function texts(d) {
+  if (d && typeof d === 'object') {
+    if ('Status' in d) d.StatusText = STATUS_TEXT[d.Status] || '';
+    if ('Severity' in d) d.SeverityText = SEVERITY_TEXT[d.Severity] || '';
+  }
+  return d;
+}
+// The mock answers the dynamic feature-control fields (__EntityControl /
+// __OperationControl) with empty strings, which FE reads as "not updatable":
+// the draft opens read-only. A RAP backend computes them; the mock says yes.
+function control(d) {
+  if (d && typeof d === 'object') {
+    if ('__EntityControl' in d) d.__EntityControl = { Deletable: true, Updatable: true };
+    if ('__OperationControl' in d) d.__OperationControl = { Edit: true };
+  }
+  return d;
+}
+module.exports = {
+  onAfterRead: async function (data) { if (Array.isArray(data)) data.forEach(control); else control(data); return data; },
+  addEntry: function (entry, req) { return this.base.addEntry(texts(entry), req); },
+  updateEntry: function (keys, updated, patch, req) { return this.base.updateEntry(keys, texts(Object.assign({}, patch)), req); },
+  onBeforeAction: async function (def, data, keys, req) {
+    if (REJECT !== null && /Activate$/.test(String(def && def.name))) {
+      const rows = await this.base.fetchEntries(keys, req);
+      const row = rows && rows[0];
+      if (row && row.Status === REJECT) {
+        this.throwError('CSP-HARNESS-REJECT: status ' + REJECT + ' cannot be saved', 400, {
+          code: 'CSP/001', message: 'CSP-HARNESS-REJECT: status ' + REJECT + ' cannot be saved', numericSeverity: 4, target: 'Status',
+        });
+      }
+    }
+    return data;
+  },
+};
+`;
+}
+
+/** The seeded rows plus the text for each code (for the withCodeTexts variants). */
+export function rowsWithTexts<T extends { Severity: string; Status: string }>(
+  rows: readonly T[],
+): Array<T & { SeverityText: string; StatusText: string }> {
+  return rows.map((r) => ({
+    ...r,
+    SeverityText: SEVERITY_TEXT[r.Severity] ?? '',
+    StatusText: STATUS_TEXT[r.Status] ?? '',
+  }));
+}

package/vitest.smoke-e2e.config.ts

@@ -0,0 +1,20 @@
+// The `smoke-e2e` vitest project (L1-2b): the lane-1 smoke checks against the
+// offline Fiori Elements harness in test-harness/. NOT part of `pnpm test` — it
+// needs a local Edge/Chrome and the UI5 CDN. Run: `pnpm test:smoke-e2e`.
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    name: 'smoke-e2e',
+    include: ['test-harness/**/*.e2e.test.ts'],
+    environment: 'node',
+    pool: 'forks',
+    // One browser at a time; the files share the CDN cache per process anyway.
+    fileParallelism: false,
+    testTimeout: 240_000,
+    hookTimeout: 600_000,
+  },
+  resolve: {
+    conditions: ['node'],
+  },
+});