@teleporthq/teleport-plugin-next-workflows 0.43.41 → 0.43.44

package/__tests__/cart-availability-add-to-cart.test.ts

@@ -352,6 +352,53 @@ describe('buildAddToCartLimitCheck — runtime semantics', () => {
     expect(result.existingItemId).toBe('cart-1')
   })
 
+  // Variant-aware de-dup: a cart line is identified by product AND variant.
+  const buildParamsV = (
+    productId: string,
+    variantId: string | null,
+    quantity: number,
+    settings: any,
+    product: any,
+    cartItems: any[]
+  ): any[] => {
+    const arr: any[] = new Array(14).fill(null)
+    arr[0] = { productId, variantId, quantity }
+    arr[2] = settings
+    arr[6] = product ? { found: true, product } : { found: false, product: null }
+    arr[13] = cartItems
+    return arr
+  }
+
+  it('same product, DIFFERENT variant already in cart → treated as a NEW line (no increment)', () => {
+    const params = buildParamsV('a', 'a__blue', 1, baseSettings(), { name: 'Tee', quantity: 5 }, [
+      { id: 'cart-red', productId: 'a', variantId: 'a__red', quantity: 1 },
+    ])
+    const result = fn({}, params)
+    expect(result.canAdd).toBe(true)
+    expect(result.shouldIncrement).toBe(false)
+    expect(result.existingItemId).toBe(null)
+  })
+
+  it('same product, SAME variant already in cart → increments THAT line', () => {
+    const params = buildParamsV('a', 'a__red', 1, baseSettings(), { name: 'Tee', quantity: 5 }, [
+      { id: 'cart-red', productId: 'a', variantId: 'a__red', quantity: 1 },
+      { id: 'cart-blue', productId: 'a', variantId: 'a__blue', quantity: 1 },
+    ])
+    const result = fn({}, params)
+    expect(result.canAdd).toBe(true)
+    expect(result.shouldIncrement).toBe(true)
+    expect(result.existingItemId).toBe('cart-red')
+  })
+
+  it('flat product (no variantId) matches the flat cart line', () => {
+    const params = buildParamsV('a', null, 1, baseSettings(), { name: 'Mug', quantity: 5 }, [
+      { id: 'cart-flat', productId: 'a', quantity: 2 },
+    ])
+    const result = fn({}, params)
+    expect(result.shouldIncrement).toBe(true)
+    expect(result.existingItemId).toBe('cart-flat')
+  })
+
   it('new item would exceed maxQuantityPerProduct → canAdd:false, names product', () => {
     const params = buildParams(
       'a',

package/__tests__/component-scope-trigger-routing.test.ts

@@ -0,0 +1,130 @@
+// Routing guard for the `'component'` trigger scope: an `event-component-loaded`
+// workflow must be generated ONLY into the component it is bound to (matched by
+// the emitted component name, with a normalized-compare and componentId
+// fallback) — never into pages, never into unrelated components. This is the
+// fix for the original bug where a component workflow authored with page scope
+// was stripped from the component and silently fanned out to every page.
+
+import { createNextWorkflowPlugin } from '../src/workflow-component-plugin'
+
+const componentLoadedWorkflow = (config: Record<string, unknown>) => ({
+  id: 'wf-comp-loaded',
+  name: 'Auto-open Sidebar Group',
+  trigger: {
+    type: 'event-component-loaded',
+    nodeId: 'trigger-component-loaded',
+    scope: 'component',
+    config,
+  },
+  nodes: [
+    {
+      id: 'update-1',
+      type: 'state-update-local-state',
+      config: { property: 'sidebarGroupOpen', value: 'guilds' },
+      stepNumber: 1,
+      label: 'Set group',
+    },
+  ],
+  edges: [{ id: 'e1', source: 'trigger-component-loaded', target: 'update-1' }],
+})
+
+const jsxComponentChunk = () => ({
+  type: 'chunk-type-ast',
+  name: 'jsx-component',
+  content: {
+    type: 'VariableDeclaration',
+    declarations: [
+      {
+        type: 'VariableDeclarator',
+        init: {
+          type: 'ArrowFunctionExpression',
+          body: {
+            type: 'BlockStatement',
+            body: [{ type: 'ReturnStatement', argument: null }],
+          },
+        },
+      },
+    ],
+  },
+})
+
+const buildStructure = (uidl: Record<string, unknown>, workflow: any): any => ({
+  uidl: {
+    node: { type: 'element', content: { elementType: 'container', name: 'Container' } },
+    stateDefinitions: { sidebarGroupOpen: { type: 'string', defaultValue: '' } },
+    ...uidl,
+  },
+  chunks: [jsxComponentChunk()],
+  options: {
+    workflows: { workflows: { [workflow.id]: workflow }, customNodes: {} },
+  },
+  dependencies: {},
+})
+
+const getWorkflowModule = async (
+  uidl: Record<string, unknown>,
+  workflow: any,
+  isPage: boolean
+): Promise<string | null> => {
+  const plugin = createNextWorkflowPlugin({ isPage })
+  const structure = buildStructure(uidl, workflow)
+  await plugin(structure as any)
+  const moduleChunk = (structure.chunks as any[]).find((c: any) => c.name === 'workflow-module')
+  return moduleChunk ? String(moduleChunk.content) : null
+}
+
+describe('component-scope trigger routing', () => {
+  it('generates the workflow into the component matching componentName', async () => {
+    const code = await getWorkflowModule(
+      { name: 'Navigation' },
+      componentLoadedWorkflow({ componentId: 'TQ_QmitTH632i', componentName: 'Navigation' }),
+      false
+    )
+    expect(code).not.toBeNull()
+    expect(code).toContain('Component loaded')
+    expect(code).toContain("componentName: 'Navigation'")
+  })
+
+  it('matches case/separator-insensitively (generator may re-case the name)', async () => {
+    const code = await getWorkflowModule(
+      { name: 'CookieConsent' },
+      componentLoadedWorkflow({ componentName: 'Cookie Consent' }),
+      false
+    )
+    expect(code).not.toBeNull()
+    expect(code).toContain('Component loaded')
+  })
+
+  it('falls back to componentId when the name does not match', async () => {
+    const code = await getWorkflowModule(
+      { name: 'Navigation', outputOptions: { fileName: 'navigation' } },
+      componentLoadedWorkflow({ componentId: 'navigation', componentName: 'Renamed Later' }),
+      false
+    )
+    expect(code).not.toBeNull()
+    expect(code).toContain('Component loaded')
+  })
+
+  it('does NOT generate into an unrelated component', async () => {
+    const code = await getWorkflowModule(
+      { name: 'Footer' },
+      componentLoadedWorkflow({ componentId: 'TQ_QmitTH632i', componentName: 'Navigation' }),
+      false
+    )
+    expect(code).toBeNull()
+  })
+
+  it('does NOT generate into pages', async () => {
+    const code = await getWorkflowModule(
+      { name: 'Navigation', outputOptions: { pageId: 'page-1', fileName: 'home' } },
+      componentLoadedWorkflow({ componentId: 'TQ_QmitTH632i', componentName: 'Navigation' }),
+      true
+    )
+    expect(code).toBeNull()
+  })
+
+  it('matches nothing when both componentId and componentName are missing', async () => {
+    const code = await getWorkflowModule({ name: 'Navigation' }, componentLoadedWorkflow({}), false)
+    expect(code).toBeNull()
+  })
+})

package/__tests__/cron-route-loop-templateparams.test.ts

@@ -0,0 +1,144 @@
+// Regression test for the abandoned-cart reminder feature's codegen dependency:
+// a scheduled (cron) workflow must generate a route that (a) executes a
+// `general-loop` body per row and (b) merges an email node's `templateParams`
+// into its component body — the cron route previously used a naive inline loop
+// that did neither, so a per-cart reminder email would ship raw {{token}} merge
+// fields and its loop body would never run.
+import { generateCronAPIRoute } from '../src/api-route-generator'
+
+const TRIGGER_ID = 'cron-1'
+const SCAN_ID = 'scan-1'
+const LOOP_ID = 'loop-1'
+const SHIM_ID = 'shim-1'
+const CREATE_ID = 'create-1'
+const EMAIL_ID = 'email-1'
+
+const buildCronWorkflow = (): any => ({
+  id: 'wf-abandoned-cart',
+  name: 'Abandoned Cart Reminder',
+  trigger: {
+    type: 'event-cron-triggered',
+    nodeId: TRIGGER_ID,
+    scope: 'global',
+    config: { schedule: '0 * * * *', timezone: 'UTC', urlPath: 'cron_abandoned' },
+  },
+  nodes: [
+    {
+      id: SCAN_ID,
+      type: 'data-raw-query',
+      config: { dataSourceId: 'ds-1', query: 'SELECT 1', params: ['2'] },
+      executionEnv: 'server',
+      stepNumber: 1,
+      label: 'Scan Abandoned Carts',
+    },
+    {
+      id: LOOP_ID,
+      type: 'general-loop',
+      config: {
+        loopType: 'forEach',
+        collection: { type: 'workflowContext', nodeId: SCAN_ID, path: [SCAN_ID, 'result'] },
+        itemVariable: 'cart',
+      },
+      executionEnv: 'server',
+      stepNumber: 2,
+      label: 'Loop Over Each Abandoned Cart',
+    },
+    {
+      id: SHIM_ID,
+      type: 'general-custom-js',
+      config: { code: 'function customHandler(p){return {email:"a@b.c"}}', context: 'server' },
+      executionEnv: 'server',
+      stepNumber: 3,
+      label: 'Build Reminder Payload',
+    },
+    {
+      id: CREATE_ID,
+      type: 'data-create-item',
+      config: { dataSourceId: 'ds-1', tableName: 'teleport_abandoned_carts', columnMappings: [] },
+      executionEnv: 'server',
+      stepNumber: 4,
+      label: 'Record Abandoned Cart',
+    },
+    {
+      id: EMAIL_ID,
+      type: 'email-resend',
+      config: {
+        to: { type: 'workflowContext', nodeId: SHIM_ID, path: [SHIM_ID, 'email'] },
+        subject: 'You left something in your cart at {{companyName}}',
+        body: '<p>Hi {{customerName}}</p>',
+        templateParams: [
+          { key: 'customerName', value: 'Jane' },
+          { key: 'companyName', value: 'Acme' },
+        ],
+        apiKey: '',
+        emailType: 'transactional',
+      },
+      executionEnv: 'server',
+      stepNumber: 5,
+      label: 'Send Abandoned Cart Reminder',
+    },
+  ],
+  edges: [
+    { id: 'e1', source: TRIGGER_ID, target: SCAN_ID },
+    { id: 'e2', source: SCAN_ID, target: LOOP_ID },
+    {
+      id: 'e3',
+      source: LOOP_ID,
+      target: SHIM_ID,
+      sourceHandle: 'loop',
+      targetHandle: 'loop-body-in',
+    },
+    {
+      id: 'e4',
+      source: SHIM_ID,
+      target: CREATE_ID,
+      sourceHandle: 'loop-body-out',
+      targetHandle: 'loop-body-in',
+    },
+    {
+      id: 'e5',
+      source: CREATE_ID,
+      target: EMAIL_ID,
+      sourceHandle: 'loop-body-out',
+      targetHandle: 'loop-body-in',
+    },
+    {
+      id: 'e6',
+      source: EMAIL_ID,
+      target: LOOP_ID,
+      sourceHandle: 'loop-body-out',
+      targetHandle: 'loop-back',
+    },
+  ],
+})
+
+describe('generateCronAPIRoute — loop + templateParams support', () => {
+  const route = generateCronAPIRoute(buildCronWorkflow())
+
+  it('uses the loop-capable executor (handles general-loop body discovery)', () => {
+    // The shared execution loop keys the loop body off the 'loop' sourceHandle
+    // and walks 'loop-body-out' edges — markers absent from the old naive loop.
+    expect(route).toContain("e.sourceHandle === 'loop'")
+    expect(route).toContain('loop-body-out')
+  })
+
+  it('merges templateParams into email body + subject', () => {
+    // Both the top-level and loop-body execution paths apply the merge; the
+    // email node lives in the loop body here.
+    expect(route).toContain('utils.applyTemplateParams(bResolved.body, bResolved.templateParams)')
+    expect(route).toContain(
+      'utils.applyTemplateParams(bResolved.subject, bResolved.templateParams)'
+    )
+  })
+
+  it('bakes the scan + loop + email nodes into the server WORKFLOW_CONFIG', () => {
+    expect(route).toContain('"type": "general-loop"')
+    expect(route).toContain('"type": "email-resend"')
+    expect(route).toContain('"type": "data-raw-query"')
+  })
+
+  it('emits a self-contained cron handler with the schedule + success response', () => {
+    expect(route).toContain("schedule: '0 * * * *'")
+    expect(route).toContain('res.status(200).json({ success: true')
+  })
+})

package/__tests__/data-api-on-conflict-do-nothing.test.ts

@@ -0,0 +1,35 @@
+import { generateDataAPIRoute } from '../src/data-api-route-generator'
+import { dataCreateItem } from '../src/nodes/data/data-create-item'
+
+// Idempotent insert support. The "Resolve Current User" custom node re-ensures
+// a guest's anonymous `users` row on EVERY resolution so the identity is
+// self-healing after a database reset / re-provision. That insert targets a
+// row that usually already exists, so it MUST be a no-op on conflict rather
+// than a 23505 error that aborts the resolve-user (and therefore checkout).
+
+describe('data-api handleCreate — ON CONFLICT DO NOTHING', () => {
+  const code = generateDataAPIRoute()
+
+  it('appends ON CONFLICT DO NOTHING only when the caller opts in', () => {
+    expect(code).toContain('body.onConflictDoNothing')
+    expect(code).toContain('ON CONFLICT DO NOTHING')
+    // Default path stays a plain insert — the clause is gated behind the flag.
+    expect(code).toMatch(/onConflictClause\s*=\s*body\.onConflictDoNothing\s*\?/)
+  })
+
+  it('falls back to the supplied id when a conflict returns no row', () => {
+    // With ON CONFLICT DO NOTHING a pre-existing row yields no RETURNING row,
+    // so the response must still surface the intended id for downstream nodes.
+    expect(code).toContain("var idIdx = columns.indexOf('id')")
+    expect(code).toMatch(/resolvedId\s*=\s*item\s*\?/)
+  })
+})
+
+describe('data_create_item — forwards the idempotency flag', () => {
+  const handlerCode = dataCreateItem.generateHandler()
+
+  it('passes config.onConflictDoNothing through to the data-api request body', () => {
+    expect(handlerCode).toContain('config.onConflictDoNothing === true')
+    expect(handlerCode).toContain('reqBody.onConflictDoNothing = true')
+  })
+})

package/__tests__/email-body-context-resolution.test.ts

@@ -19,6 +19,8 @@ import { generateSharedRuntimeUtilsCode } from '../src'
 type SharedUtils = {
   resolveConfig: (cfg: unknown, ctx: Record<string, unknown>) => any
   resolveRichTextContext: (html: string, ctx: Record<string, unknown>) => string
+  applyTemplateParams: (text: string, params: unknown) => string
+  expandListBlocks: (text: string, lists: Record<string, unknown>) => string
 }
 
 function loadSharedRuntime(): SharedUtils {
@@ -121,3 +123,127 @@ describe('email body inline-context resolution', () => {
     expect(out).not.toContain('Reset URL</span>')
   })
 })
+
+// Guards the component-body path: a send-email node whose body is a serialized
+// email-template component carries flat {{token}} merge fields filled at runtime
+// from templateParams (resolveConfig resolves each param's context ref first,
+// then executeNodes calls applyTemplateParams on body + subject).
+describe('email template params substitution', () => {
+  const utils = loadSharedRuntime()
+
+  it('exposes applyTemplateParams from the generated runtime', () => {
+    expect(typeof utils.applyTemplateParams).toBe('function')
+  })
+
+  it('fills {{token}} in body + subject from resolved templateParams (executeNodes flow)', () => {
+    const config = {
+      subject: 'Reset {{recipientEmail}}',
+      body: '<a href="{{resetUrl}}">Reset</a> for {{recipientEmail}}',
+      templateParams: [
+        {
+          key: 'resetUrl',
+          value: { type: 'workflowContext', nodeId: 'N1', path: ['N1', 'result'] },
+        },
+        { key: 'recipientEmail', value: 'jane@example.com' },
+      ],
+    }
+    // Step 1: resolveConfig resolves each param's context ref (as executeNodes does).
+    const resolved = utils.resolveConfig(config, {
+      N1: { result: 'https://app.example.com/reset-password?token=abc' },
+    })
+    // Step 2: executeNodes applies the params to body + subject.
+    const body = utils.applyTemplateParams(resolved.body, resolved.templateParams)
+    const subject = utils.applyTemplateParams(resolved.subject, resolved.templateParams)
+    expect(body).toBe(
+      '<a href="https://app.example.com/reset-password?token=abc">Reset</a> for jane@example.com'
+    )
+    expect(subject).toBe('Reset jane@example.com')
+  })
+
+  it('leaves unknown tokens verbatim (never blanks a campaign {{name}})', () => {
+    const out = utils.applyTemplateParams('Hi {{name}}, reset: {{resetUrl}}', [
+      { key: 'resetUrl', value: 'https://x/reset?token=1' },
+    ])
+    expect(out).toBe('Hi {{name}}, reset: https://x/reset?token=1')
+  })
+
+  it('does not partial-match longer tokens ({{total}} vs {{totalAmount}})', () => {
+    const out = utils.applyTemplateParams('{{total}} of {{totalAmount}}', [
+      { key: 'total', value: '5' },
+      { key: 'totalAmount', value: '$99' },
+    ])
+    expect(out).toBe('5 of $99')
+  })
+
+  it('is a no-op when there are no params or body is not a string', () => {
+    expect(utils.applyTemplateParams('{{x}}', [])).toBe('{{x}}')
+    expect(utils.applyTemplateParams('{{x}}', undefined)).toBe('{{x}}')
+  })
+
+  // ── Array-mapper loop-block expansion (builder array mapper → email list) ──
+
+  it('expands a <!--tq:each--> block from an array templateParam, once per row', () => {
+    const body =
+      'Items:<!--tq:each products--><li>{{quantity}}x <strong>{{product_name}}</strong> — {{companyName}}</li><!--/tq:each-->end'
+    const out = utils.applyTemplateParams(body, [
+      {
+        key: 'products',
+        value: [
+          { product_name: 'Espresso Beans', quantity: 2 },
+          { product_name: 'Ceramic Mug', quantity: 1 },
+        ],
+      },
+      { key: 'companyName', value: 'Acme Inc.' },
+    ])
+    // one <li> per row, row tokens filled from the row object
+    expect(out).toContain('<li>2x <strong>Espresso Beans</strong> — Acme Inc.</li>')
+    expect(out).toContain('<li>1x <strong>Ceramic Mug</strong> — Acme Inc.</li>')
+    // the {{companyName}} inside the row (not a row field) resolved via the flat fill
+    expect(out).not.toContain('{{companyName}}')
+    // no leftover sentinels or tokens
+    expect(out).not.toContain('<!--tq:each')
+    expect(out).not.toContain('<!--/tq:each-->')
+    expect(out).not.toContain('{{product_name}}')
+  })
+
+  it('HTML-escapes per-row values (no markup injection from item data)', () => {
+    const out = utils.expandListBlocks('<!--tq:each products-->[{{name}}]<!--/tq:each-->', {
+      products: [{ name: '<b>x</b> & "y"' }],
+    })
+    expect(out).toBe('[&lt;b&gt;x&lt;/b&gt; &amp; &quot;y&quot;]')
+  })
+
+  it('renders an empty string for a missing/non-array list key', () => {
+    const body = 'a<!--tq:each products-->{{name}}<!--/tq:each-->b'
+    expect(utils.applyTemplateParams(body, [])).toBe('ab')
+    expect(utils.applyTemplateParams(body, [{ key: 'products', value: 'not-an-array' }])).toBe('ab')
+  })
+
+  it('resolveConfig preserves an array-valued templateParam so the block expands', () => {
+    // Mirrors the withdrawal send node: templateParams is an array of {key,value}
+    // where value is a workflowContext ref that resolves to the items array.
+    const config = {
+      body: 'X<!--tq:each products--><li>{{quantity}}x {{product_name}}</li><!--/tq:each-->Y',
+      templateParams: [
+        {
+          key: 'products',
+          value: {
+            type: 'workflowContext',
+            nodeId: 'assemble',
+            path: ['assemble', 'selectedItems'],
+          },
+        },
+        { key: 'companyName', value: 'Acme Inc.' },
+      ],
+    }
+    const ctx = {
+      assemble: { selectedItems: [{ product_name: 'Espresso Beans', quantity: 3 }] },
+    }
+    const resolved = utils.resolveConfig(config, ctx)
+    // the array survived resolution (was not String()-joined)
+    expect(Array.isArray(resolved.templateParams[0].value)).toBe(true)
+    const out = utils.applyTemplateParams(resolved.body, resolved.templateParams)
+    expect(out).toContain('<li>3x Espresso Beans</li>')
+    expect(out).not.toContain('<!--tq:each')
+  })
+})

package/__tests__/page-loaded-scoping-skip.test.ts

@@ -0,0 +1,97 @@
+// `event-page-loaded` scoping guard: a page-loaded workflow with NO page
+// scoping (no pageId, no selectedPages, no allPages) must be SKIPPED, not
+// injected into every page. Silent all-pages fan-out masked mis-scoped
+// workflows whose state target lives in a component (the setter no-ops on
+// pages). Explicit `allPages: true` is the supported way to run everywhere.
+
+import { createNextWorkflowPlugin } from '../src/workflow-component-plugin'
+
+const pageLoadedWorkflow = (config: Record<string, unknown>) => ({
+  id: 'wf-page-loaded',
+  name: 'Page Init',
+  trigger: {
+    type: 'event-page-loaded',
+    nodeId: 'trigger-page-loaded',
+    scope: 'page',
+    config,
+  },
+  nodes: [
+    {
+      id: 'update-1',
+      type: 'state-update-local-state',
+      config: { property: 'ready', value: 'true' },
+      stepNumber: 1,
+      label: 'Set ready',
+    },
+  ],
+  edges: [{ id: 'e1', source: 'trigger-page-loaded', target: 'update-1' }],
+})
+
+const jsxComponentChunk = () => ({
+  type: 'chunk-type-ast',
+  name: 'jsx-component',
+  content: {
+    type: 'VariableDeclaration',
+    declarations: [
+      {
+        type: 'VariableDeclarator',
+        init: {
+          type: 'ArrowFunctionExpression',
+          body: {
+            type: 'BlockStatement',
+            body: [{ type: 'ReturnStatement', argument: null }],
+          },
+        },
+      },
+    ],
+  },
+})
+
+const getWorkflowModule = async (workflow: any, pageId: string): Promise<string | null> => {
+  const plugin = createNextWorkflowPlugin({ isPage: true })
+  const structure: any = {
+    uidl: {
+      name: 'Page',
+      outputOptions: { pageId, fileName: pageId },
+      node: { type: 'element', content: { elementType: 'container', name: 'Container' } },
+      stateDefinitions: { ready: { type: 'string', defaultValue: '' } },
+    },
+    chunks: [jsxComponentChunk()],
+    options: {
+      workflows: { workflows: { [workflow.id]: workflow }, customNodes: {} },
+    },
+    dependencies: {},
+  }
+  await plugin(structure)
+  const moduleChunk = (structure.chunks as any[]).find((c: any) => c.name === 'workflow-module')
+  return moduleChunk ? String(moduleChunk.content) : null
+}
+
+describe('event-page-loaded scoping', () => {
+  it('SKIPS a workflow with no page scoping at all (empty config)', async () => {
+    const code = await getWorkflowModule(pageLoadedWorkflow({}), 'page-1')
+    expect(code).toBeNull()
+  })
+
+  it('generates into every page when allPages is true', async () => {
+    const codeA = await getWorkflowModule(pageLoadedWorkflow({ allPages: true }), 'page-1')
+    const codeB = await getWorkflowModule(pageLoadedWorkflow({ allPages: true }), 'page-2')
+    expect(codeA).toContain('Page loaded')
+    expect(codeB).toContain('Page loaded')
+  })
+
+  it('generates only into the matching page when pageId is set', async () => {
+    const match = await getWorkflowModule(pageLoadedWorkflow({ pageId: 'page-1' }), 'page-1')
+    const mismatch = await getWorkflowModule(pageLoadedWorkflow({ pageId: 'page-1' }), 'page-2')
+    expect(match).toContain('Page loaded')
+    expect(mismatch).toBeNull()
+  })
+
+  it('generates into pages listed in selectedPages', async () => {
+    const config = { selectedPages: [{ id: 'page-1' }, { id: 'page-3' }] }
+    const inList = await getWorkflowModule(pageLoadedWorkflow(config), 'page-3')
+    const notInList = await getWorkflowModule(pageLoadedWorkflow(config), 'page-2')
+    expect(inList).toContain('Page loaded')
+    expect(notInList).toBeNull()
+  })
+})