sounding 0.0.0 → 0.0.2

package/lib/create-browser-manager.js

@@ -0,0 +1,132 @@
+const { resolveBaseUrl } = require('./create-request-client')
+
+function resolveModuleFromApp(appPath, moduleId) {
+  return require(require.resolve(moduleId, { paths: [appPath, process.cwd(), __dirname] }))
+}
+
+function defaultLoadPlaywright(appPath) {
+  return resolveModuleFromApp(appPath, 'playwright')
+}
+
+function defaultLoadPlaywrightTest(appPath) {
+  return resolveModuleFromApp(appPath, '@playwright/test')
+}
+
+function resolveProjectOptions(projectName, devices = {}) {
+  if (projectName === 'mobile') {
+    return (
+      devices['iPhone 13'] || {
+        viewport: {
+          width: 390,
+          height: 844,
+        },
+        isMobile: true,
+        hasTouch: true,
+      }
+    )
+  }
+
+  return {}
+}
+
+function createBrowserManager({
+  sails,
+  getConfig,
+  appPathResolver = () => sails?.config?.appPath || process.cwd(),
+  loadPlaywright = defaultLoadPlaywright,
+  loadPlaywrightTest = defaultLoadPlaywrightTest,
+} = {}) {
+  let session = null
+
+  async function open(options = {}) {
+    if (session) {
+      return session
+    }
+
+    const config = typeof getConfig === 'function' ? getConfig() : sails?.config?.sounding || {}
+
+    if (config.browser?.enabled === false) {
+      throw new Error('Sounding browser support is disabled in `config/sounding.js`.')
+    }
+
+    const appPath = appPathResolver()
+    const playwright = await loadPlaywright(appPath)
+    const playwrightTest = await Promise.resolve()
+      .then(() => loadPlaywrightTest(appPath))
+      .catch(() => null)
+
+    const browserTypeName = options.type || config.browser?.type || 'chromium'
+    const browserType = playwright?.[browserTypeName]
+
+    if (!browserType?.launch) {
+      throw new Error(
+        `Sounding could not find a Playwright browser type named \`${browserTypeName}\`.`
+      )
+    }
+
+    const projectName =
+      options.project ||
+      config.browser?.defaultProject ||
+      config.browser?.projects?.[0] ||
+      'desktop'
+
+    const browser = await browserType.launch({
+      headless: true,
+      ...(config.browser?.launchOptions || {}),
+      ...(options.launchOptions || {}),
+    })
+
+    const context = await browser.newContext({
+      baseURL: resolveBaseUrl({ sails, getConfig }),
+      ...resolveProjectOptions(projectName, playwright.devices || {}),
+      ...(options.contextOptions || {}),
+    })
+
+    const page = await context.newPage()
+
+    session = {
+      playwright,
+      browser,
+      context,
+      page,
+      expect: playwrightTest?.expect,
+      project: projectName,
+    }
+
+    return session
+  }
+
+  async function close() {
+    if (!session) {
+      return
+    }
+
+    await session.context?.close?.()
+    await session.browser?.close?.()
+    session = null
+  }
+
+  return {
+    open,
+    close,
+    get active() {
+      return Boolean(session?.page)
+    },
+    get page() {
+      return session?.page
+    },
+    get context() {
+      return session?.context
+    },
+    get expect() {
+      return session?.expect
+    },
+  }
+}
+
+module.exports = {
+  createBrowserManager,
+  defaultLoadPlaywright,
+  defaultLoadPlaywrightTest,
+  resolveProjectOptions,
+}

package/lib/create-expect.js

@@ -0,0 +1,155 @@
+const assert = require('node:assert/strict')
+
+function getPath(target, path) {
+  return path.split('.').reduce((current, segment) => current?.[segment], target)
+}
+
+function getHeader(actual, name) {
+  if (typeof actual?.header === 'function') {
+    return actual.header(name)
+  }
+
+  if (typeof actual?.headers?.get === 'function') {
+    return actual.headers.get(name)
+  }
+
+  return actual?.headers?.[name]
+}
+
+function resolveStructuredValue(actual) {
+  if (actual?.data !== undefined) {
+    return actual.data
+  }
+
+  return actual
+}
+
+function shouldUseFallback(actual) {
+  return Boolean(
+    actual &&
+      typeof actual === 'object' &&
+      !Array.isArray(actual) &&
+      actual.status === undefined &&
+      actual.data === undefined &&
+      typeof actual.header !== 'function' &&
+      typeof actual.headers?.get !== 'function'
+  )
+}
+
+function createExpect(actual, { fallback } = {}) {
+  if (fallback && shouldUseFallback(actual)) {
+    return fallback(actual)
+  }
+
+  return {
+    toBe(expected) {
+      assert.strictEqual(actual, expected)
+    },
+
+    toEqual(expected) {
+      assert.deepStrictEqual(actual, expected)
+    },
+
+    toContain(expected) {
+      if (typeof actual === 'string') {
+        assert.ok(actual.includes(expected))
+        return
+      }
+
+      if (Array.isArray(actual)) {
+        assert.ok(actual.includes(expected))
+        return
+      }
+
+      throw new TypeError('Sounding expect().toContain() only supports strings and arrays in v0.0.1.')
+    },
+
+    toMatch(expected) {
+      if (expected instanceof RegExp) {
+        assert.match(actual, expected)
+        return
+      }
+
+      assert.ok(String(actual).includes(String(expected)))
+    },
+
+    toBeTruthy() {
+      assert.ok(actual)
+    },
+
+    toBeFalsy() {
+      assert.ok(!actual)
+    },
+
+    toBeDefined() {
+      assert.notStrictEqual(actual, undefined)
+    },
+
+    toHaveStatus(expected) {
+      assert.strictEqual(actual?.status, expected)
+    },
+
+    toHaveHeader(name, expected) {
+      const header = getHeader(actual, name)
+      assert.notStrictEqual(header, null)
+      assert.notStrictEqual(header, undefined)
+
+      if (expected !== undefined) {
+        assert.strictEqual(header, expected)
+      }
+    },
+
+    toRedirectTo(expected) {
+      const location = getHeader(actual, 'location')
+      assert.strictEqual(location, expected)
+    },
+
+    toHaveJsonPath(path, expected) {
+      const value = getPath(resolveStructuredValue(actual), path)
+      assert.deepStrictEqual(value, expected)
+    },
+
+    toBeInertiaPage(component) {
+      const value = resolveStructuredValue(actual)
+      assert.strictEqual(value?.component, component)
+    },
+
+    toHaveProp(path, expected) {
+      const value = getPath(resolveStructuredValue(actual)?.props, path)
+      assert.deepStrictEqual(value, expected)
+    },
+
+    toMatchProp(path, expected) {
+      const value = getPath(resolveStructuredValue(actual)?.props, path)
+
+      if (expected instanceof RegExp) {
+        assert.match(String(value), expected)
+        return
+      }
+
+      assert.ok(String(value).includes(String(expected)))
+    },
+
+    toHaveSharedProp(path, expected) {
+      const value = getPath(resolveStructuredValue(actual)?.props, path)
+      assert.deepStrictEqual(value, expected)
+    },
+
+    toHaveValidationError(path, expected) {
+      const value = getPath(resolveStructuredValue(actual)?.props?.errors, path)
+      assert.notStrictEqual(value, undefined)
+
+      if (expected !== undefined) {
+        assert.deepStrictEqual(value, expected)
+      }
+    },
+  }
+}
+
+createExpect.withFallback = function withFallback(fallback) {
+  return function soundingExpect(actual) {
+    return createExpect(actual, { fallback })
+  }
+}
+
+module.exports = { createExpect }

package/lib/create-helper-runner.js

@@ -0,0 +1,55 @@
+function resolveHelper(sails, identity) {
+  return identity
+    .split('.')
+    .reduce((current, segment) => current?.[segment], sails.helpers)
+}
+
+function createHelperRunner({ sails }) {
+  async function invoke(identity, inputs = {}) {
+    const helper = resolveHelper(sails, identity)
+
+    if (!helper) {
+      throw new Error(`Unknown Sounding helper: ${identity}`)
+    }
+
+    if (typeof helper.with === 'function') {
+      return helper.with(inputs)
+    }
+
+    if (typeof helper === 'function') {
+      return helper(inputs)
+    }
+
+    throw new Error(`Sounding helper \`${identity}\` is not callable.`)
+  }
+
+  function buildProxy(path = []) {
+    const callable = async (...args) => {
+      if (path.length === 0) {
+        const [identity, inputs = {}] = args
+        return invoke(identity, inputs)
+      }
+
+      const [inputs = {}] = args
+      return invoke(path.join('.'), inputs)
+    }
+
+    return new Proxy(callable, {
+      get(_target, property) {
+        if (property === 'path') {
+          return path.join('.')
+        }
+
+        if (typeof property !== 'string') {
+          return undefined
+        }
+
+        return buildProxy([...path, property])
+      },
+    })
+  }
+
+  return buildProxy()
+}
+
+module.exports = { createHelperRunner }