@dnax/ui 0.0.48 → 0.0.50

package/lib/pagePadding.test.ts

@@ -0,0 +1,37 @@
+// Tests unitaires du padding utilisateur de QPage (prop `padding`).
+import { describe, expect, it } from "bun:test"
+import { PAGE_PADDING, resolvePagePadding } from "./pagePadding"
+
+describe("resolvePagePadding", () => {
+  it("applique 14px sur la prop booléenne (modifier)", () => {
+    expect(resolvePagePadding(true)).toBe(PAGE_PADDING)
+    expect(resolvePagePadding(true)).toBe("14px")
+  })
+
+  it("n'applique aucun padding si la prop est absente ou fausse", () => {
+    expect(resolvePagePadding()).toBeUndefined()
+    expect(resolvePagePadding(false)).toBeUndefined()
+    expect(resolvePagePadding("")).toBeUndefined()
+    expect(resolvePagePadding("   ")).toBeUndefined()
+    expect(resolvePagePadding(null)).toBeUndefined()
+  })
+
+  it("rend la valeur CSS explicite telle quelle", () => {
+    expect(resolvePagePadding("12px")).toBe("12px")
+    expect(resolvePagePadding(" 2rem ")).toBe("2rem")
+    // Plusieurs valeurs : la prop reste une longueur CSS quelconque
+    expect(resolvePagePadding("12px 24px")).toBe("12px 24px")
+  })
+
+  it("ajoute l'unité manquante (une longueur nue invaliderait le calc())", () => {
+    expect(resolvePagePadding("12")).toBe("12px")
+    expect(resolvePagePadding("1.5")).toBe("1.5px")
+    expect(resolvePagePadding(18)).toBe("18px")
+    expect(resolvePagePadding(0)).toBe("0px")
+  })
+
+  it("ignore les nombres non finis", () => {
+    expect(resolvePagePadding(Number.NaN)).toBeUndefined()
+    expect(resolvePagePadding(Number.POSITIVE_INFINITY)).toBeUndefined()
+  })
+})

package/lib/pagePadding.ts

@@ -0,0 +1,32 @@
+// pagePadding — padding utilisateur du QPage (prop `padding`).
+//
+// Quasar n'expose qu'un booléen (`padding` = 16px) ; dnax.ui accepte aussi une valeur
+// CSS explicite (`padding="12px"`), d'où la normalisation :
+//   - `true` (modifier, `<q-page padding>`) → PAGE_PADDING (14px, défaut du DS)
+//   - nombre ou chaîne numérique ("12")     → "12px" (une longueur sans unité
+//     invaliderait tout le `calc()` de composition dans styles/main.css)
+//   - toute autre chaîne ("2rem", "12px 24px") → rendue telle quelle
+//   - absent, `false` ou chaîne vide        → aucun padding
+//
+// La longueur retournée est posée dans `--q-page-padding` (le composant), lue par la
+// règle `.q-page` de `styles/main.css` — là où elle est composée avec les offsets des
+// barres `fixed` (`lib/fixedLayout.ts`) et la safe-area basse.
+
+/** Padding appliqué par la prop booléenne `padding` — défaut du design system. */
+export const PAGE_PADDING = "14px"
+
+/** Nombre nu ("12", "1.5") → longueur CSS ("12px", "1.5px") ; sinon valeur inchangée. */
+const withUnit = (value: string): string => (/^-?\d*\.?\d+$/.test(value) ? `${value}px` : value)
+
+/**
+ * Longueur CSS à poser dans `--q-page-padding`, ou `undefined` quand aucun padding
+ * n'est demandé (prop absente, `false`, chaîne vide).
+ */
+export function resolvePagePadding(padding?: boolean | string | number | null): string | undefined {
+  if (padding === true) return PAGE_PADDING
+  if (typeof padding === "number") return Number.isFinite(padding) ? `${padding}px` : undefined
+  if (typeof padding !== "string") return undefined
+
+  const value = padding.trim()
+  return value ? withUnit(value) : undefined
+}

package/lib/qrcode.test.ts

@@ -0,0 +1,103 @@
+// Tests unitaires de l'encodage QR et du tracé SVG (`<q-qrcode>`).
+import { describe, expect, it } from "bun:test"
+import {
+  encodeQr,
+  isDark,
+  qrPath,
+  qrSize,
+  qrSvg,
+  qrTotalSize,
+  qrViewBox,
+  svgEscape,
+  type QrMatrix,
+} from "./qrcode"
+
+/** Matrice carrée décrite par des lignes de `.` (clair) et `#` (sombre) */
+const matrixOf = (rows: string[]): QrMatrix => ({
+  size: rows.length,
+  data: rows.flatMap((row) => [...row].map((char) => (char === "#" ? 1 : 0))),
+})
+
+describe("encodeQr", () => {
+  it("encode une valeur en matrice carrée (4 × version + 17)", () => {
+    const matrix = encodeQr("https://dnax.io")
+    expect(matrix).toBeDefined()
+    expect(matrix!.size % 4).toBe(1)
+    expect(matrix!.size).toBeGreaterThanOrEqual(21)
+    expect(matrix!.data.length).toBe(matrix!.size * matrix!.size)
+  })
+
+  it("encode en QR (finders de coin : 7 modules sombres puis un clair)", () => {
+    const matrix = encodeQr("hello")
+    // Coins haut-gauche, haut-droit et bas-gauche : 7 sombres, puis 1 clair
+    for (let i = 0; i < 7; i++) {
+      expect(isDark(matrix!, i, 0)).toBe(true)
+      expect(isDark(matrix!, 0, i)).toBe(true)
+    }
+    expect(isDark(matrix!, 7, 0)).toBe(false)
+  })
+
+  it("grandit avec la charge utile et le niveau de correction", () => {
+    const small = encodeQr("hi", { ecc: "L" })!
+    const long = encodeQr("x".repeat(300), { ecc: "H" })!
+    expect(long.size).toBeGreaterThan(small.size)
+  })
+
+  it("rend `undefined` sur une valeur vide ou trop longue (jamais d'exception)", () => {
+    expect(encodeQr("")).toBeUndefined()
+    expect(encodeQr("y".repeat(5000), { ecc: "H" })).toBeUndefined()
+  })
+})
+
+describe("qrPath / qrViewBox / qrTotalSize", () => {
+  const matrix = matrixOf([".#..", "###.", "..#.", ".##."])
+
+  it("trace une sous-forme par plage horizontale", () => {
+    expect(qrPath(matrix)).toBe("M1 0h1v1h-1z" + "M0 1h3v1h-3z" + "M2 2h1v1h-1z" + "M1 3h2v1h-2z")
+  })
+
+  it("décale le tracé de la zone de silence", () => {
+    expect(qrPath(matrix, 2)).toBe("M3 2h1v1h-1z" + "M2 3h3v1h-3z" + "M4 4h1v1h-1z" + "M3 5h2v1h-2z")
+  })
+
+  it("garde une matrice vide silencieuse", () => {
+    expect(qrPath(matrixOf(["....", "...."]))).toBe("")
+  })
+
+  it("expose la taille totale et le viewBox", () => {
+    expect(qrTotalSize(matrix)).toBe(4)
+    expect(qrTotalSize(matrix, 4)).toBe(12)
+    expect(qrViewBox(matrix, 4)).toBe("0 0 12 12")
+  })
+
+  it("lit les modules hors matrice comme clairs", () => {
+    expect(isDark(matrix, -1, 0)).toBe(false)
+    expect(isDark(matrix, 0, 99)).toBe(false)
+  })
+})
+
+describe("qrSize / svgEscape / qrSvg", () => {
+  const matrix = matrixOf([".#", "#."])
+
+  it("normalise la taille CSS", () => {
+    expect(qrSize(200)).toBe("200px")
+    expect(qrSize("12rem")).toBe("12rem")
+    expect(qrSize(undefined)).toBe("160px")
+    expect(qrSize(0)).toBe("160px")
+  })
+
+  it("échappe ce qui part dans un SVG sérialisé", () => {
+    expect(svgEscape(`<b title="x">&`)).toBe("&lt;b title=&quot;x&quot;&gt;&amp;")
+  })
+
+  it("sérialise un SVG complet (fond, tracé, étiquette)", () => {
+    const svg = qrSvg(matrix, { margin: 1, color: "#111", background: "#fff", label: "QR" })
+
+    expect(svg).toContain('viewBox="0 0 4 4"')
+    expect(svg).toContain('<rect width="4" height="4" fill="#fff"/>')
+    expect(svg).toContain('d="M2 1h1v1h-1zM1 2h1v1h-1z"')
+    expect(svg).toContain('fill="#111"')
+    expect(svg).toContain('aria-label="QR"')
+    expect(svg).toContain('role="img"')
+  })
+})

package/lib/qrcode.ts

@@ -0,0 +1,125 @@
+// qrcode — encodage QR et tracé SVG. Le moteur d'encodage est la dépendance `qrcode`
+// (déjà présente, sans types — cf. `shims.d.ts`) : elle fournit la matrice de modules, ce
+// module la traduit en **chemin SVG** (une suite de rectangles horizontaux, bien plus
+// compact qu'un carré par module) — d'où un rendu net à toutes les tailles, thémable et
+// rendable en SSR.
+//
+// Pur (aucun DOM) → testable hors navigateur, comme `lib/pagePadding.ts`.
+import QRCode from "qrcode"
+
+/** Niveau de correction d'erreur : L (~7 %) → H (~30 %) */
+export type QrEcc = "L" | "M" | "Q" | "H"
+
+/** Matrice de modules : `data[y * size + x]` vaut 1 pour un module sombre */
+export interface QrMatrix {
+  /** Côté de la matrice, en modules (21, 25, 29… : 4 × version + 17) */
+  size: number
+  /** Modules, ligne par ligne */
+  data: ArrayLike<number>
+}
+
+export interface QrEncodeOptions {
+  /** Correction d'erreur (défaut `"M"`) */
+  ecc?: QrEcc
+  /** Version forcée du QR (1 → 40). Par défaut la plus petite qui contient la donnée. */
+  version?: number
+}
+
+/** Un module est-il sombre ? (`x`/`y` hors matrice → clair, jamais d'exception) */
+export const isDark = (matrix: QrMatrix, x: number, y: number): boolean => {
+  if (x < 0 || y < 0 || x >= matrix.size || y >= matrix.size) return false
+  return matrix.data[y * matrix.size + x] === 1
+}
+
+/**
+ * Encode une valeur en matrice QR. `undefined` quand la donnée ne tient pas (trop longue
+ * pour la correction d'erreur demandée) : à l'appelant de décider quoi afficher.
+ */
+export function encodeQr(value: string, options: QrEncodeOptions = {}): QrMatrix | undefined {
+  if (typeof value !== "string" || value === "") return undefined
+
+  try {
+    const settings: Record<string, unknown> = { errorCorrectionLevel: options.ecc ?? "M" }
+    if (typeof options.version === "number") settings.version = options.version
+
+    return QRCode.create(value, settings).modules
+  } catch {
+    return undefined
+  }
+}
+
+/** Côté total de l'image (matrice + zone de silence), en modules */
+export function qrTotalSize(matrix: QrMatrix, margin = 0): number {
+  return matrix.size + 2 * Math.max(0, Math.floor(margin))
+}
+
+/**
+ * Chemin SVG de la matrice : une sous-forme par **plage horizontale** de modules sombres
+ * (`M x y h largeur v1 h-largeur z`). `margin` ajoute la zone de silence, en modules — le
+ * QR doit garder un fond clair autour de lui pour être lisible par un lecteur.
+ */
+export function qrPath(matrix: QrMatrix, margin = 0): string {
+  const offset = Math.max(0, Math.floor(margin))
+  const parts: string[] = []
+
+  for (let y = 0; y < matrix.size; y++) {
+    let x = 0
+    while (x < matrix.size) {
+      if (!isDark(matrix, x, y)) {
+        x++
+        continue
+      }
+
+      let run = 1
+      while (x + run < matrix.size && isDark(matrix, x + run, y)) run++
+
+      const px = x + offset
+      const py = y + offset
+      parts.push(`M${px} ${py}h${run}v1h-${run}z`)
+      x += run
+    }
+  }
+
+  return parts.join("")
+}
+
+/** `viewBox` du rendu (matrice + zone de silence) */
+export function qrViewBox(matrix: QrMatrix, margin = 0): string {
+  const total = qrTotalSize(matrix, margin)
+  return `0 0 ${total} ${total}`
+}
+
+/** Taille CSS : nombre → px, chaîne CSS telle quelle, sinon `160px`. */
+export function qrSize(value: unknown): string {
+  if (typeof value === "number" && Number.isFinite(value) && value > 0) return `${value}px`
+  if (typeof value === "string" && value.trim() !== "") return value.trim()
+  return "160px"
+}
+
+/** Échappe un texte destiné à un attribut d'un SVG **sérialisé** (chaîne, pas template). */
+export const svgEscape = (value: string): string =>
+  value
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+
+/** SVG complet (chaîne) — pour un téléchargement, un presse-papier ou un `<img src>`. */
+export function qrSvg(
+  matrix: QrMatrix,
+  options: { margin?: number; color?: string; background?: string; label?: string } = {},
+): string {
+  const margin = options.margin ?? 0
+  const total = qrTotalSize(matrix, margin)
+  const color = options.color || "#000"
+  const background = options.background || "#fff"
+  const label = options.label ? ` aria-label="${svgEscape(options.label)}"` : ""
+
+  return (
+    `<svg xmlns="http://www.w3.org/2000/svg" viewBox="${qrViewBox(matrix, margin)}" ` +
+    `width="${total}" height="${total}" role="img"${label}>` +
+    `<rect width="${total}" height="${total}" fill="${svgEscape(background)}"/>` +
+    `<path d="${qrPath(matrix, margin)}" fill="${svgEscape(color)}" shape-rendering="crispEdges"/>` +
+    `</svg>`
+  )
+}

package/lib/spreadsheetChanges.test.ts

@@ -0,0 +1,230 @@
+// Tests unitaires du suivi des modifications du tableur (delta référence → état courant).
+import { describe, expect, it } from "bun:test"
+import {
+  deepEqual,
+  diffDocuments,
+  diffRows,
+  diffSheets,
+  sameCellValue,
+  type QSpreadsheetDocumentPayload,
+} from "./spreadsheetChanges"
+
+describe("sameCellValue", () => {
+  it("tient « vide » pour équivalent (null / undefined / \"\")", () => {
+    expect(sameCellValue(null, undefined)).toBe(true)
+    expect(sameCellValue("", null)).toBe(true)
+    expect(sameCellValue("", "")).toBe(true)
+    // … mais une valeur effacée n'est pas « identique » à une valeur présente
+    expect(sameCellValue(null, 0)).toBe(false)
+    expect(sameCellValue("", "x")).toBe(false)
+  })
+
+  it("compare les primitives, NaN compris", () => {
+    expect(sameCellValue(18.5, 18.5)).toBe(true)
+    expect(sameCellValue("a", "b")).toBe(false)
+    expect(sameCellValue(NaN, NaN)).toBe(true)
+    expect(sameCellValue(0, false)).toBe(false)
+  })
+
+  it("compare les tableaux (multiselect) élément par élément", () => {
+    expect(sameCellValue(["a", "b"], ["a", "b"])).toBe(true)
+    expect(sameCellValue(["a", "b"], ["b", "a"])).toBe(false)
+    expect(sameCellValue(["a"], ["a", "b"])).toBe(false)
+    expect(sameCellValue([], [])).toBe(true)
+  })
+})
+
+describe("deepEqual", () => {
+  it("ignore l'ordre des clés (records reconstruits)", () => {
+    expect(deepEqual({ a: 1, b: 2 }, { b: 2, a: 1 })).toBe(true)
+    expect(deepEqual({ a: 1 }, { a: 1, b: 2 })).toBe(false)
+  })
+
+  it("respecte l'ordre des tableaux et descend en profondeur", () => {
+    expect(deepEqual([1, 2], [1, 2])).toBe(true)
+    expect(deepEqual([1, 2], [2, 1])).toBe(false)
+    expect(deepEqual({ a: { b: [1, { c: 2 }] } }, { a: { b: [1, { c: 2 }] } })).toBe(true)
+    expect(deepEqual({ a: { b: [1, { c: 2 }] } }, { a: { b: [1, { c: 3 }] } })).toBe(false)
+  })
+})
+
+const row = (key: string, values: Record<string, any> = {}) => ({ _key: key, ...values })
+
+describe("diffRows", () => {
+  it("sépare ajoutées / modifiées / supprimées", () => {
+    const before = [row("a", { name: "Ada" }), row("b", { name: "Grace" })]
+    const after = [row("a", { name: "Ada" }), row("c", { name: "Alan" })]
+    const delta = diffRows(before, after, { columns: ["name"], sheet: "s1" })
+    expect(delta.added.map((r) => r.key)).toEqual(["c"])
+    expect(delta.deleted.map((r) => r.key)).toEqual(["b"])
+    expect(delta.updated).toHaveLength(0)
+    expect(delta.added[0]).toMatchObject({ sheet: "s1", row: { name: "Alan" } })
+  })
+
+  it("identifie par `_key` : un réordonnancement n'est pas une modification", () => {
+    const before = [row("a", { n: 1 }), row("b", { n: 2 })]
+    const after = [row("b", { n: 2 }), row("a", { n: 1 })]
+    const delta = diffRows(before, after, { columns: ["n"] })
+    expect(delta.added).toHaveLength(0)
+    expect(delta.deleted).toHaveLength(0)
+    expect(delta.updated).toHaveLength(0)
+  })
+
+  it("liste les colonnes modifiées", () => {
+    const delta = diffRows(
+      [row("a", { name: "Ada", age: 36, city: "London" })],
+      [row("a", { name: "Ada", age: 37, city: "London" })],
+      { columns: ["name", "age", "city"] },
+    )
+    expect(delta.updated).toHaveLength(1)
+    expect(delta.updated[0]!.columns).toEqual(["age"])
+    expect(delta.updated[0]!.before).toMatchObject({ age: 36 })
+    expect(delta.updated[0]!.row).toMatchObject({ age: 37 })
+  })
+
+  it("ne compare que le schéma courant (colonne supprimée / ajoutée vide)", () => {
+    // colonne supprimée : le schéma ne la contient plus → aucune ligne « modifiée »
+    const removed = diffRows(
+      [row("a", { name: "Ada", gone: 5 })],
+      [row("a", { name: "Ada" })],
+      { columns: ["name"] },
+    )
+    expect(removed.updated).toHaveLength(0)
+    // colonne ajoutée vide : "" vs absence = « vide » des deux côtés → rien non plus
+    const added = diffRows([row("a", { name: "Ada" })], [row("a", { name: "Ada", extra: "" })], {
+      columns: ["name", "extra"],
+    })
+    expect(added.updated).toHaveLength(0)
+  })
+
+  it("compare les valeurs de type tableau (multiselect)", () => {
+    const delta = diffRows(
+      [row("a", { tags: ["design", "docs"] })],
+      [row("a", { tags: ["design", "backend"] })],
+      { columns: ["tags"] },
+    )
+    expect(delta.updated[0]!.columns).toEqual(["tags"])
+  })
+
+  it("sans schéma déclaré, compare les clés des lignes (`_key` exclue)", () => {
+    const delta = diffRows([row("a", { n: 1 })], [row("a", { n: 2 })])
+    expect(delta.updated[0]!.columns).toEqual(["n"])
+  })
+
+  it("ignore les lignes sans clé (non identifiables)", () => {
+    const delta = diffRows([{ n: 1 }], [{ n: 1 }])
+    expect(delta.added).toHaveLength(0)
+    expect(delta.deleted).toHaveLength(0)
+  })
+})
+
+describe("diffSheets", () => {
+  const sheet = (key: string, name: string, columns?: any[]) => ({ key, name, columns, rows: [] })
+
+  it("sépare ajoutées / supprimées", () => {
+    const delta = diffSheets([sheet("a", "A")], [sheet("a", "A"), sheet("b", "B")])
+    expect(delta.added.map((s) => s.key)).toEqual(["b"])
+    expect(delta.deleted).toHaveLength(0)
+
+    const back = diffSheets([sheet("a", "A"), sheet("b", "B")], [sheet("a", "A")])
+    expect(back.deleted.map((s) => s.key)).toEqual(["b"])
+    expect(back.added).toHaveLength(0)
+  })
+
+  it("détecte un renommage et un changement de schéma", () => {
+    const renamed = diffSheets([sheet("a", "A")], [sheet("a", "B")])
+    expect(renamed.updated[0]).toMatchObject({ key: "a", changed: ["name"] })
+
+    const schema = diffSheets(
+      [sheet("a", "A", ["x"])],
+      [sheet("a", "A", ["x", "y"])],
+    )
+    expect(schema.updated[0]!.changed).toEqual(["columns"])
+  })
+
+  it("ne signale rien quand la feuille est inchangée", () => {
+    const delta = diffSheets([sheet("a", "A", ["x"])], [sheet("a", "A", ["x"])])
+    expect(delta.added).toHaveLength(0)
+    expect(delta.updated).toHaveLength(0)
+    expect(delta.deleted).toHaveLength(0)
+  })
+})
+
+describe("diffDocuments", () => {
+  const doc = (over: Partial<QSpreadsheetDocumentPayload> = {}): QSpreadsheetDocumentPayload => ({
+    version: 1,
+    active: "s1",
+    sheets: [{ key: "s1", name: "One", columns: ["name", "age"], rows: [row("a", { name: "Ada", age: 36 })] }],
+    ...over,
+  })
+
+  it("référence identique → rien de modifié", () => {
+    const changes = diffDocuments(doc(), doc())
+    expect(changes.dirty).toBe(false)
+    expect(changes.count).toBe(0)
+    expect(changes.rows.added).toHaveLength(0)
+    expect(changes.extras).toEqual([])
+  })
+
+  it("sans référence → aucun delta (pas de faux positif)", () => {
+    expect(diffDocuments(null, doc()).dirty).toBe(false)
+  })
+
+  it("une cellule modifiée → ligne mise à jour, avec sa feuille et sa colonne", () => {
+    const after = doc()
+    after.sheets![0]!.rows = [row("a", { name: "Ada", age: 37 })]
+    const changes = diffDocuments(doc(), after)
+    expect(changes.dirty).toBe(true)
+    expect(changes.count).toBe(1)
+    expect(changes.rows.updated[0]).toMatchObject({ sheet: "s1", key: "a", columns: ["age"] })
+  })
+
+  it("changer d'onglet actif n'est pas une modification", () => {
+    const before = doc({ active: "s1" })
+    const after = doc({ active: "s1" })
+    after.active = "s1"
+    expect(diffDocuments(before, after).dirty).toBe(false)
+    // et une valeur `active` différente non plus
+    expect(diffDocuments(doc({ active: "s1" }), doc({ active: "s9" })).dirty).toBe(false)
+  })
+
+  it("une mise en forme seule rend le document modifié (extras)", () => {
+    const before = doc()
+    const after = doc()
+    ;(after.sheets![0] as any).formats = { "0:name": { bold: true } }
+    const changes = diffDocuments(before, after)
+    expect(changes.dirty).toBe(true)
+    expect(changes.rows.updated).toHaveLength(0)
+    expect(changes.extras).toEqual(["formats"])
+    // … et elle compte pour un élément (indicateur « 1 modified »)
+    expect(changes.count).toBe(1)
+  })
+
+  it("feuille ajoutée : portée par `sheets.added`, ses lignes ne sont pas répétées dans `rows`", () => {
+    const after = doc()
+    after.sheets!.push({ key: "s2", name: "Two", columns: ["name"], rows: [row("z", { name: "Zoe" })] })
+    const changes = diffDocuments(doc(), after)
+    expect(changes.sheets.added.map((s) => s.key)).toEqual(["s2"])
+    expect(changes.rows.added).toHaveLength(0)
+    expect(changes.count).toBe(1)
+  })
+
+  it("feuille supprimée : portée par `sheets.deleted`", () => {
+    const before = doc()
+    before.sheets!.push({ key: "s2", name: "Two", columns: ["name"], rows: [row("z", { name: "Zoe" })] })
+    const changes = diffDocuments(before, doc())
+    expect(changes.sheets.deleted.map((s) => s.key)).toEqual(["s2"])
+    expect(changes.rows.deleted).toHaveLength(0)
+  })
+
+  it("colonne supprimée : changement de schéma, pas de bruit sur les lignes", () => {
+    const before = doc()
+    before.sheets![0]!.columns = ["name", "age"]
+    const after = doc()
+    after.sheets![0]!.columns = ["name"]
+    after.sheets![0]!.rows = [row("a", { name: "Ada" })]
+    const changes = diffDocuments(before, after)
+    expect(changes.sheets.updated[0]!.changed).toEqual(["columns"])
+    expect(changes.rows.updated).toHaveLength(0)
+  })
+})