@ossy/platform 3.9.0 → 3.11.1

package/src/test/flow-files.js

@@ -0,0 +1,83 @@
+/**
+ * Normalize a declarative flow `files` step into Playwright `setInputFiles` payloads.
+ * Use for native file inputs (`type=file`) — form fills intentionally skip file fields.
+ *
+ * @param {unknown} files
+ * @returns {{
+ *   selector: string,
+ *   payloads: Array<string | { name: string, mimeType: string, buffer: Buffer }>
+ * }}
+ */
+export function resolveFilesTarget (files) {
+  if (files == null || typeof files !== 'object' || Array.isArray(files)) {
+    throw new Error('files step requires { selector, paths? } or { selector, items? }')
+  }
+
+  const selector = typeof files.selector === 'string' ? files.selector.trim() : ''
+  if (!selector) {
+    throw new Error('files step requires a non-empty CSS selector')
+  }
+
+  const paths = normalizePathList(files.paths ?? files.path)
+  const items = normalizeItemList(files.items ?? files.item)
+
+  if (paths.length === 0 && items.length === 0) {
+    throw new Error('files step requires at least one path or item')
+  }
+
+  /** @type {Array<string | { name: string, mimeType: string, buffer: Buffer }>} */
+  const payloads = [
+    ...paths,
+    ...items.map((item) => ({
+      name: item.name,
+      mimeType: item.mimeType,
+      buffer: Buffer.from(item.content, item.encoding ?? 'utf8'),
+    })),
+  ]
+
+  return { selector, payloads }
+}
+
+/**
+ * @param {unknown} raw
+ * @returns {string[]}
+ */
+function normalizePathList (raw) {
+  if (raw == null) return []
+  const list = Array.isArray(raw) ? raw : [raw]
+  return list.map((entry, index) => {
+    if (typeof entry !== 'string' || !entry.trim()) {
+      throw new Error(`files.paths[${index}] must be a non-empty string`)
+    }
+    return entry.trim()
+  })
+}
+
+/**
+ * @param {unknown} raw
+ * @returns {Array<{ name: string, mimeType: string, content: string, encoding?: BufferEncoding }>}
+ */
+function normalizeItemList (raw) {
+  if (raw == null) return []
+  const list = Array.isArray(raw) ? raw : [raw]
+  return list.map((entry, index) => {
+    if (entry == null || typeof entry !== 'object' || Array.isArray(entry)) {
+      throw new Error(`files.items[${index}] must be an object`)
+    }
+    const name = typeof entry.name === 'string' ? entry.name.trim() : ''
+    if (!name) {
+      throw new Error(`files.items[${index}].name must be a non-empty string`)
+    }
+    if (typeof entry.content !== 'string') {
+      throw new Error(`files.items[${index}].content must be a string`)
+    }
+    const mimeType = typeof entry.mimeType === 'string' && entry.mimeType.trim()
+      ? entry.mimeType.trim()
+      : 'application/octet-stream'
+    const encoding = entry.encoding == null ? undefined : entry.encoding
+    if (encoding != null && typeof encoding !== 'string') {
+      throw new Error(`files.items[${index}].encoding must be a string when set`)
+    }
+    return { name, mimeType, content: entry.content, encoding }
+  })
+}

package/src/test/flow-files.spec.js

@@ -0,0 +1,69 @@
+import { describe, expect, it } from '@jest/globals'
+import { resolveFilesTarget } from './flow-files.js'
+
+describe('resolveFilesTarget', () => {
+  it('accepts a single filesystem path', () => {
+    expect(resolveFilesTarget({
+      selector: ' #upload-resources ',
+      path: ' /tmp/sample.txt ',
+    })).toEqual({
+      selector: '#upload-resources',
+      payloads: ['/tmp/sample.txt'],
+    })
+  })
+
+  it('accepts multiple filesystem paths', () => {
+    expect(resolveFilesTarget({
+      selector: '#upload-resources',
+      paths: ['a.txt', 'b.txt'],
+    })).toEqual({
+      selector: '#upload-resources',
+      payloads: ['a.txt', 'b.txt'],
+    })
+  })
+
+  it('accepts in-memory buffer items', () => {
+    const resolved = resolveFilesTarget({
+      selector: '#upload-resources',
+      items: [{
+        name: 'e2e-upload.txt',
+        mimeType: 'text/plain',
+        content: 'hello from e2e',
+      }],
+    })
+    expect(resolved.selector).toBe('#upload-resources')
+    expect(resolved.payloads).toHaveLength(1)
+    expect(resolved.payloads[0]).toMatchObject({
+      name: 'e2e-upload.txt',
+      mimeType: 'text/plain',
+    })
+    expect(Buffer.isBuffer(resolved.payloads[0].buffer)).toBe(true)
+    expect(resolved.payloads[0].buffer.toString('utf8')).toBe('hello from e2e')
+  })
+
+  it('defaults mimeType for buffer items', () => {
+    const resolved = resolveFilesTarget({
+      selector: '[data-ossy-upload-input]',
+      item: { name: 'blob.bin', content: 'x' },
+    })
+    expect(resolved.payloads[0].mimeType).toBe('application/octet-stream')
+  })
+
+  it('rejects empty or invalid values', () => {
+    expect(() => resolveFilesTarget(null)).toThrow(/requires \{ selector/)
+    expect(() => resolveFilesTarget({ selector: '' })).toThrow(/non-empty CSS selector/)
+    expect(() => resolveFilesTarget({ selector: '#x' })).toThrow(/at least one path or item/)
+    expect(() => resolveFilesTarget({
+      selector: '#x',
+      paths: [''],
+    })).toThrow(/files\.paths\[0\]/)
+    expect(() => resolveFilesTarget({
+      selector: '#x',
+      items: [{ name: '', content: 'x' }],
+    })).toThrow(/files\.items\[0\]\.name/)
+    expect(() => resolveFilesTarget({
+      selector: '#x',
+      items: [{ name: 'a.txt', content: 1 }],
+    })).toThrow(/files\.items\[0\]\.content/)
+  })
+})