@live-change/user-frontend 0.9.196 → 0.9.197

package/e2e/signInEmailPassword.test.ts

@@ -0,0 +1,51 @@
+import test from 'node:test'
+import assert from 'node:assert'
+import App from '@live-change/framework'
+import randomProfile from 'random-profile-generator'
+import crypto from 'crypto'
+import passwordGenerator from 'generate-password'
+import { withBrowser } from './withBrowser.js'
+
+const app = App.app()
+const randomUserData = randomProfile.profile()
+;(randomUserData as { email?: string }).email =
+  (randomUserData as { firstName: string }).firstName.toLowerCase() + '@test.com'
+
+test('sign in with email and password', async () => {
+  await withBrowser(async (page, env) => {
+    const user = app.generateUid()
+    const email = (randomUserData as { email: string }).email
+    const password =
+      passwordGenerator.generate({ length: 10, numbers: true }) + (Math.random() * 10).toFixed()
+    const passwordHash = crypto.createHash('sha256').update(password).digest('hex')
+
+    const User = env.haveModel('user', 'User')
+    const Email = env.haveModel('email', 'Email')
+    const PasswordAuthentication = env.haveModel('passwordAuthentication', 'PasswordAuthentication')
+
+    await User.create({ id: user, roles: [] })
+    await Email.create({ id: email, email, user })
+    await PasswordAuthentication.create({ id: user, user, passwordHash })
+
+    await page.goto(env.url + '/user/sign-in-email', { waitUntil: 'networkidle' })
+    await page.fill('input#email', email)
+    await page.fill('input[type="password"]', password)
+    await page.click('button[type=submit]')
+    await page.waitForURL('**/sign-in-finished', { timeout: 10000 })
+
+    assert.ok(page.url().includes('/user/sign-in-finished'))
+    await new Promise((r) => setTimeout(r, 200))
+
+    const clientSession = await page.evaluate(
+      () => (window as unknown as { api: { client: { value: { session: string } } } }).api.client.value.session
+    )
+    const AuthenticatedUser = env.haveModel('user', 'AuthenticatedUser')
+    const authenticatedUserData = await AuthenticatedUser.get(clientSession)
+    assert.ok(authenticatedUserData, 'user authenticated server-side')
+
+    const clientUser = await page.evaluate(
+      () => (window as unknown as { api: { client: { value: { user: string } } } }).api.client.value.user
+    )
+    assert.strictEqual(clientUser, (authenticatedUserData as { user: string }).user, 'user authenticated')
+  })
+})

package/e2e/signOut.test.ts

@@ -0,0 +1,45 @@
+import test from 'node:test'
+import assert from 'node:assert'
+import App from '@live-change/framework'
+import randomProfile from 'random-profile-generator'
+import { withBrowser } from './withBrowser.js'
+
+const app = App.app()
+const name = randomProfile.profile().firstName.toLowerCase()
+const email = name + '@test.com'
+
+test('sign out', async () => {
+  await withBrowser(async (page, env) => {
+    const user = app.generateUid()
+    const User = env.haveModel('user', 'User')
+    const Email = env.haveModel('email', 'Email')
+    const AuthenticatedUser = env.haveModel('user', 'AuthenticatedUser')
+
+    await User.create({ id: user, roles: [] })
+    await Email.create({ id: email, email, user })
+    await page.goto(env.url + '/', { waitUntil: 'networkidle' })
+    const session = await page.evaluate(
+      () => (window as unknown as { api: { client: { value: { session: string } } } }).api.client.value.session
+    )
+    await AuthenticatedUser.create({ id: session, user, session })
+
+    await page.reload({ waitUntil: 'networkidle' })
+    const clientUser = await page.evaluate(
+      () => (window as unknown as { api: { client: { value: { user: string } } } }).api.client.value.user
+    )
+    assert.strictEqual(user, clientUser, 'client logged in')
+
+    await page.goto(env.url + '/user/sign-out', { waitUntil: 'networkidle' })
+    await page.waitForURL('**/sign-out-finished', { timeout: 10000 })
+    assert.ok(page.url().includes('/user/sign-out-finished'))
+
+    await new Promise((r) => setTimeout(r, 1000))
+    const clientUser2 = await page.evaluate(
+      () => (window as unknown as { api: { client: { value: { user: unknown } } } }).api.client.value.user
+    )
+    const authenticatedUserData = await AuthenticatedUser.get(session)
+
+    assert.strictEqual(!!authenticatedUserData, false, 'no server user')
+    assert.strictEqual(!!clientUser2, false, 'no client user')
+  })
+})

package/e2e/signUpEmailCode.test.ts

@@ -0,0 +1,46 @@
+import test from 'node:test'
+import assert from 'node:assert'
+import randomProfile from 'random-profile-generator'
+import { withBrowser } from './withBrowser.js'
+import { useSecretCode } from './steps.js'
+
+const user = randomProfile.profile()
+;(user as { email?: string }).email =
+  (user as { firstName: string }).firstName.toLowerCase() + '@test.com'
+const happyPath = false
+
+test('sign up with email code', async () => {
+  await withBrowser(async (page, env) => {
+    await page.goto(env.url + '/user/sign-up-email', { waitUntil: 'networkidle' })
+    await page.fill('input#email', (user as { email: string }).email)
+    await page.click('button[type=submit]')
+    await page.waitForURL('**/sent/*', { timeout: 10000 })
+
+    assert.ok(page.url().includes('/sent/'))
+    const url = page.url()
+    const authentication = url.split('/').pop()!
+
+    const authenticationData = await env.grabObject('messageAuthentication', 'Authentication', authentication)
+    assert.ok(authenticationData, 'authentication created')
+
+    await useSecretCode(page, env, authentication, happyPath)
+    await page.waitForURL('**/sign-up-finished', { timeout: 10000 })
+
+    assert.ok(page.url().includes('/user/sign-up-finished'))
+    const clientSession = await page.evaluate(
+      () => (window as unknown as { api: { client: { value: { session: string } } } }).api.client.value.session
+    )
+    const AuthenticatedUser = env.haveModel('user', 'AuthenticatedUser')
+    const authenticatedUserData = await AuthenticatedUser.get(clientSession)
+    assert.ok(authenticatedUserData, 'user authenticated server-side')
+    const clientUser = await page.evaluate(
+      () => (window as unknown as { api: { client: { value: { user: string } } } }).api.client.value.user
+    )
+    assert.strictEqual(clientUser, (authenticatedUserData as { user: string }).user, 'user authenticated')
+
+    if (!happyPath) {
+      await page.goto(url, { waitUntil: 'networkidle' })
+      assert.ok(page.url().includes('/user/sign-up-finished'))
+    }
+  })
+})

package/e2e/signUpEmailLink.test.ts

@@ -0,0 +1,46 @@
+import test from 'node:test'
+import assert from 'node:assert'
+import randomProfile from 'random-profile-generator'
+import { withBrowser } from './withBrowser.js'
+import { useSecretLink } from './steps.js'
+
+const user = randomProfile.profile()
+;(user as { email?: string }).email =
+  (user as { firstName: string }).firstName.toLowerCase() + '@test.com'
+const happyPath = false
+
+test('sign up with email link', async () => {
+  await withBrowser(async (page, env) => {
+    await page.goto(env.url + '/user/sign-up-email', { waitUntil: 'networkidle' })
+    await page.fill('input#email', (user as { email: string }).email)
+    await page.click('button[type=submit]')
+    await page.waitForURL('**/sent/*', { timeout: 10000 })
+
+    assert.ok(page.url().includes('/sent/'))
+    const url = page.url()
+    const authentication = url.split('/').pop()!
+
+    const authenticationData = await env.grabObject('messageAuthentication', 'Authentication', authentication)
+    assert.ok(authenticationData, 'authentication created')
+
+    const linkData = await useSecretLink(page, env, authentication, happyPath)
+    await page.waitForURL('**/sign-up-finished', { timeout: 10000 })
+
+    assert.ok(page.url().includes('/user/sign-up-finished'))
+    const clientSession = await page.evaluate(
+      () => (window as unknown as { api: { client: { value: { session: string } } } }).api.client.value.session
+    )
+    const AuthenticatedUser = env.haveModel('user', 'AuthenticatedUser')
+    const authenticatedUserData = await AuthenticatedUser.get(clientSession)
+    assert.ok(authenticatedUserData, 'user authenticated server-side')
+    const clientUser = await page.evaluate(
+      () => (window as unknown as { api: { client: { value: { user: string } } } }).api.client.value.user
+    )
+    assert.strictEqual(clientUser, (authenticatedUserData as { user: string }).user, 'user authenticated')
+
+    if (!happyPath) {
+      await page.goto(env.url + '/user/link/' + linkData.secretCode, { waitUntil: 'networkidle' })
+      await page.getByText('Link used').waitFor({ state: 'visible' })
+    }
+  })
+})

package/e2e/steps.ts

@@ -0,0 +1,179 @@
+import assert from 'node:assert'
+import type { Page } from 'playwright'
+import App from '@live-change/framework'
+import randomProfile from 'random-profile-generator'
+import passwordGenerator from 'generate-password'
+import type { TestEnv } from './env.js'
+
+const app = App.app()
+
+export async function haveUser(
+  env: TestEnv,
+  name?: string,
+  email?: string,
+  password?: string,
+  user: string = app.generateUid(),
+  roles: string[] = []
+): Promise<{ id: string; name: string; email: string; password: string }> {
+  if (!password) password = passwordGenerator.generate({ length: 10, numbers: true })
+  if (!name) name = randomProfile.profile().firstName
+  if (!email) {
+    name = name!
+    email = name.split(' ')[0].toLowerCase() + (Math.random() * 100).toFixed() + '@test.com'
+  }
+
+  const PasswordAuthentication = env.haveModel('passwordAuthentication', 'PasswordAuthentication')
+  const User = env.haveModel('user', 'User')
+  const Email = env.haveModel('email', 'Email')
+  const Identification = env.haveModel('userIdentification', 'Identification')
+
+  const passwordHash = PasswordAuthentication.definition.properties.passwordHash.preFilter(password)
+  await User.create({ id: user, roles })
+  await PasswordAuthentication.create({ id: user, user, passwordHash })
+  await Email.create({ id: email, email, user })
+  await Identification.create({
+    id: App.encodeIdentifier(['user_User', user]),
+    sessionOrUserType: 'user_User',
+    sessionOrUser: user,
+    name: name!
+  })
+  return { id: user, name: name!, email, password }
+}
+
+export async function useEmailLink(
+  page: Page,
+  env: TestEnv,
+  email: string,
+  prefix = '/user/link/'
+): Promise<{ authentication: unknown; link: { secretCode: string } }> {
+  const MessageAuthentication = env.haveModel('messageAuthentication', 'Authentication') as {
+    indexObjectGet: (index: string, key: unknown[], opts?: { reverse?: boolean; limit?: number }) => Promise<unknown>
+  }
+  const authentication = await MessageAuthentication.indexObjectGet('byContact', ['email', email], {
+    reverse: true,
+    limit: 1
+  })
+  const Link = env.haveModel('secretLink', 'Link') as {
+    indexObjectGet: (index: string, key: unknown) => Promise<{ secretCode: string }>
+  }
+  const link = await Link.indexObjectGet('byAuthentication', authentication)
+  await page.goto(env.url + prefix + link.secretCode, { waitUntil: 'networkidle' })
+  await new Promise((r) => setTimeout(r, 100))
+  return { authentication, link }
+}
+
+export async function amLoggedIn(page: Page, env: TestEnv, user: { id: string }): Promise<void> {
+  const AuthenticatedUser = env.haveModel('user', 'AuthenticatedUser')
+  const session = await page.evaluate(() => (window as unknown as { api: { client: { value: { session: string } } } }).api.client.value.session)
+  await AuthenticatedUser.create({ id: session, session, user: user.id })
+}
+
+export async function amLoggedOut(page: Page, env: TestEnv): Promise<void> {
+  const AuthenticatedUser = env.haveModel('user', 'AuthenticatedUser')
+  const session = await page.evaluate(() => (window as unknown as { api: { client: { value: { session: string } } } }).api.client.value.session)
+  await AuthenticatedUser.delete(session)
+}
+
+export async function useSecretCode(
+  page: Page,
+  env: TestEnv,
+  authentication: unknown,
+  happyPath: boolean
+): Promise<void> {
+  const Code = env.haveModel('secretCode', 'Code') as {
+    indexObjectGet: (index: string, key: unknown) => Promise<{ id: string; secretCode: string; expire: Date }>
+    indexRangeGet: (index: string, key: unknown) => Promise<{ id: string; secretCode: string; expire: Date }[]>
+    update: (id: string, data: { expire: Date }) => Promise<unknown>
+  }
+  let codeData = await Code.indexObjectGet('byAuthentication', authentication)
+  assert.ok(codeData, 'code created')
+
+  if (!happyPath) {
+    await sleep(200)
+    await page.waitForSelector('input#code', { state: 'visible' })
+    const wrongCode = codeData!.secretCode === '123456' ? '654321' : '123456'
+    await page.fill('input#code', wrongCode)
+    await page.fill('input#code', wrongCode)
+    await page.click('button[type=submit]')
+    // PrimeVue 4 uses <Message> with role=\"alert\" instead of a #code-help.p-error span
+    await page.getByRole('alert').waitFor({ state: 'visible' })
+  }
+
+  if (!happyPath) {
+    await sleep(200)
+    await page.waitForSelector('input#code', { state: 'visible' })
+    await Code.update(codeData!.id, { expire: new Date() })
+    await page.fill('input#code', codeData!.secretCode)
+    await page.fill('input#code', codeData!.secretCode)
+    await page.click('button[type=submit]')
+    await page.getByRole('alert').waitFor({ state: 'visible' })
+
+    await page.click('text=Resend')
+    assert.ok(page.url().includes('/sent/'))
+
+    await new Promise((r) => setTimeout(r, 200))
+    const newCodeData = await Code.indexRangeGet('byAuthentication', authentication)
+    newCodeData.sort((a, b) => new Date(b.expire).getTime() - new Date(a.expire).getTime())
+    const oldCodeData = codeData
+    codeData = newCodeData[0]
+    assert.ok(codeData, 'code exists')
+    assert.notStrictEqual(oldCodeData!.id, codeData!.id, 'code is different from previous code')
+  }
+
+  await page.waitForFunction(() => {
+    const input = document.querySelector('input#code') as HTMLInputElement
+    if(!input) return false
+    return input.value === ''
+  })
+  await page.fill('input#code', codeData!.secretCode)
+  await page.fill('input#code', codeData!.secretCode)
+  await page.click('button[type=submit]')
+  await new Promise((r) => setTimeout(r, 100))
+}
+
+export async function useSecretLink(
+  page: Page,
+  env: TestEnv,
+  authentication: unknown,
+  happyPath: boolean,
+  prefix = '/user'
+): Promise<{ secretCode: string }> {
+  const Link = env.haveModel('secretLink', 'Link') as {
+    indexObjectGet: (index: string, key: unknown) => Promise<{ id: string; secretCode: string; expire: Date }>
+    indexRangeGet: (index: string, key: unknown) => Promise<{ id: string; secretCode: string; expire: Date }[]>
+    update: (id: string, data: { expire: Date }) => Promise<unknown>
+  }
+  let linkData = await Link.indexObjectGet('byAuthentication', authentication)
+  assert.ok(linkData, 'link created')
+
+  if (!happyPath) {
+    await page.goto(env.url + prefix + '/link/[badSecret]', { waitUntil: 'networkidle' })
+    await page.getByText('Unknown link').waitFor({ state: 'visible' })
+  }
+
+  if (!happyPath) {
+    await new Promise((r) => setTimeout(r, 200))
+    await Link.update(linkData!.id, { expire: new Date() })
+    await page.goto(env.url + prefix + '/link/' + linkData!.secretCode, { waitUntil: 'networkidle' })
+    await page.getByText('Link expired').waitFor({ state: 'visible' })
+
+    await page.click('text=Resend')
+    assert.ok(page.url().includes(prefix + '/sent/'))
+
+    await new Promise((r) => setTimeout(r, 200))
+    const newLinksData = await Link.indexRangeGet('byAuthentication', authentication)
+    newLinksData.sort((a, b) => new Date(b.expire).getTime() - new Date(a.expire).getTime())
+    const oldLinkData = linkData
+    linkData = newLinksData[0]
+    assert.ok(linkData, 'link exists')
+    assert.notStrictEqual(oldLinkData!.id, linkData!.id, 'link is different from previous link')
+  }
+
+  await page.goto(env.url + prefix + '/link/' + linkData!.secretCode, { waitUntil: 'networkidle' })
+  await new Promise((r) => setTimeout(r, 100))
+  return linkData!
+}
+
+export async function sleep(ms: number) {
+  return new Promise((r) => setTimeout(r, ms))
+}

package/e2e/withBrowser.ts

@@ -0,0 +1,19 @@
+import { chromium } from 'playwright'
+import { getTestEnv } from './env.js'
+import type { TestEnv } from './env.js'
+import type { Page } from 'playwright'
+
+export async function withBrowser(
+  fn: (page: Page, env: TestEnv) => Promise<void>
+): Promise<void> {
+  const env = await getTestEnv()
+  const browser = await chromium.launch({ headless: false })
+  const context = await browser.newContext()
+  const page = await context.newPage()
+  try {
+    await fn(page, env)
+  } finally {
+    await context.close()
+    await browser.close()
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@live-change/user-frontend",
-  "version": "0.9.196",
+  "version": "0.9.197",
   "scripts": {
     "memDev": "tsx --inspect --expose-gc server/start.js memDev --enableSessions --initScript ./init.js --dbAccess",
     "localDevInit": "tsx server/start.js localDev --enableSessions --initScript ./init.js --dbAccess",
@@ -36,29 +36,29 @@
   },
   "type": "module",
   "dependencies": {
-    "@live-change/cli": "^0.9.196",
-    "@live-change/dao": "^0.9.196",
-    "@live-change/dao-vue3": "^0.9.196",
-    "@live-change/dao-websocket": "^0.9.196",
-    "@live-change/email-service": "^0.9.196",
-    "@live-change/framework": "^0.9.196",
-    "@live-change/identicon-service": "^0.9.196",
-    "@live-change/image-frontend": "^0.9.196",
-    "@live-change/message-authentication-service": "^0.9.196",
-    "@live-change/notification-service": "^0.9.196",
-    "@live-change/password-authentication-service": "^0.9.196",
-    "@live-change/pattern": "^0.9.196",
-    "@live-change/secret-code-service": "^0.9.196",
-    "@live-change/secret-link-service": "^0.9.196",
-    "@live-change/security-frontend": "^0.9.196",
-    "@live-change/security-service": "^0.9.196",
-    "@live-change/session-service": "^0.9.196",
-    "@live-change/timer-service": "^0.9.196",
-    "@live-change/upload-service": "^0.9.196",
-    "@live-change/user-identification-service": "^0.9.196",
-    "@live-change/user-service": "^0.9.196",
-    "@live-change/vue3-components": "^0.9.196",
-    "@live-change/vue3-ssr": "^0.9.196",
+    "@live-change/cli": "^0.9.197",
+    "@live-change/dao": "^0.9.197",
+    "@live-change/dao-vue3": "^0.9.197",
+    "@live-change/dao-websocket": "^0.9.197",
+    "@live-change/email-service": "^0.9.197",
+    "@live-change/framework": "^0.9.197",
+    "@live-change/identicon-service": "^0.9.197",
+    "@live-change/image-frontend": "^0.9.197",
+    "@live-change/message-authentication-service": "^0.9.197",
+    "@live-change/notification-service": "^0.9.197",
+    "@live-change/password-authentication-service": "^0.9.197",
+    "@live-change/pattern": "^0.9.197",
+    "@live-change/secret-code-service": "^0.9.197",
+    "@live-change/secret-link-service": "^0.9.197",
+    "@live-change/security-frontend": "^0.9.197",
+    "@live-change/security-service": "^0.9.197",
+    "@live-change/session-service": "^0.9.197",
+    "@live-change/timer-service": "^0.9.197",
+    "@live-change/upload-service": "^0.9.197",
+    "@live-change/user-identification-service": "^0.9.197",
+    "@live-change/user-service": "^0.9.197",
+    "@live-change/vue3-components": "^0.9.197",
+    "@live-change/vue3-ssr": "^0.9.197",
     "@vueuse/core": "^12.3.0",
     "codeceptjs-assert": "^0.0.5",
     "codeceptjs-video-helper": "0.1.3",
@@ -79,8 +79,8 @@
     "wtfnode": "^0.9.1"
   },
   "devDependencies": {
-    "@live-change/codeceptjs-helper": "^0.9.196",
-    "codeceptjs": "^3.6.10",
+    "@live-change/codeceptjs-helper": "^0.9.197",
+    "codeceptjs": "^3.7.6",
     "generate-password": "1.7.1",
     "playwright": "1.49.1",
     "random-profile-generator": "^2.3.0",
@@ -90,5 +90,5 @@
   "author": "Michał Łaszczewski <michal@laszczewski.pl>",
   "license": "BSD-3-Clause",
   "description": "",
-  "gitHead": "7f358a1cc16fb35069f6ce3f897412232f766843"
+  "gitHead": "8231c2ed8bc3beed2c732aa5727174417f19082b"
 }

package/server/app.config.js

@@ -1,8 +1,35 @@
+import dotenv from 'dotenv'
+dotenv.config()
+
 import App from "@live-change/framework"
 const app = App.app()
 
-import dotenv from 'dotenv'
-dotenv.config()
+import { fileURLToPath } from 'url'
+import { dirname, join } from 'path'
+import { accessSync, readFileSync } from 'fs'
+
+const packageJsonPath = dirname(fileURLToPath(import.meta.url))
+  .split('/').map((part, i, arr) =>
+    join(arr.slice(0, arr.length - i).join('/'), 'package.json')
+  ).find(p => { try { accessSync(p); return true } catch(e) { return false }})
+const packageJson = packageJsonPath ? JSON.parse(readFileSync(packageJsonPath, 'utf-8')) : {}
+
+const name = packageJson.name ?? "Example"
+const brandName = process.env.BRAND_NAME || (name[0].toUpperCase() + name.slice(1))
+const homepage = process.env.BASE_HREF ?? packageJson.homepage
+const brandDomain = process.env.BRAND_DOMAIN ||
+  (homepage && homepage.match(/https\:\/\/([^\/]+)/)?.[1]) || 'example.com'
+const baseHref = process.env.BASE_HREF || homepage || 'http://localhost:8001'
+const version = process.env.VERSION || packageJson.version
+
+const clientConfig = {
+  version,
+  name, brandName, brandDomain, homepage, baseHref
+}
+const baseAppConfig = {
+  ...clientConfig,
+  clientConfig: { ...clientConfig },
+}
 
 const contactTypes = ['email', 'phone']
 const remoteAccountTypes = ['google', 'linkedin']
@@ -10,6 +37,10 @@ const remoteAccountTypes = ['google', 'linkedin']
 import securityConfig from './security.config.js'
 
 app.config = {
+  ...baseAppConfig,
+  clientConfig: {
+    ...baseAppConfig.clientConfig,
+  },
   services: [
     {
       name: 'timer',

package/e2e/codecept.conf.js

@@ -1,60 +0,0 @@
-import { devices } from 'playwright'
-
-const testServerPort = process.env.TEST_URL ? 0 : require('get-port-sync')() 
-const testServerUrl = process.env.TEST_URL || `http://localhost:${testServerPort}`
-
-const device = devices['Pixel 2']
-
-exports.config = {
-  tests: './*.test.js',
-  output: './output',
-  helpers: {
-    LiveChange: {
-      require: '@live-change/codeceptjs-helper',
-      startServer: !process.env.TEST_URL,
-      enableSessions: true,
-      initScript: "./init.js",
-      port: testServerPort,
-      dev: true
-    },
-    VideoHelper: {
-      require: 'codeceptjs-video-helper'
-    },
-    AssertWrapper : {
-      require: "codeceptjs-assert"
-    },
-    Playwright: {
-      browser: 'chromium',
-      url: testServerUrl,
-      show: true,
-      emulate: {
-        ...device,
-        recordVideo: process.env.RECORD_TESTS ? {
-          dir: "./output",
-          //size: { width: 1080, height: 1920 }
-        } : undefined,
-      },
-      chromium: {
-        args: [`--force-device-scale-factor=${device.deviceScaleFactor}`]
-      }
-    }
-  },
-  include: {
-    I: './steps_file.js'
-  },
-  bootstrap: null,
-  mocha: {},
-  name: 'e2e',
-  plugins: {
-    pauseOnFail: {},
-    retryFailedStep: {
-      enabled: true
-    },
-    tryTo: {
-      enabled: true
-    },
-    screenshotOnFail: {
-      enabled: true
-    }
-  }
-}

package/e2e/connectEmailCode.test.js

@@ -1,61 +0,0 @@
-const app = require('@live-change/framework').app()
-const randomProfile = require('random-profile-generator')
-
-const email = randomProfile.profile().firstName.toLowerCase() + '@test.com' // test domain - emails not sent
-const email2 = randomProfile.profile().firstName.toLowerCase() + '2@test.com' // test domain - emails not sent
-
-const happyPath = false
-
-Feature('user')
-
-Scenario('connect email with code', async ({ I }) => {
-
-  const user = app.generateUid()
-
-  const User = await I.haveModel('user', 'User')
-  const Email = await I.haveModel('email', 'Email')
-  const AuthenticatedUser = await I.haveModel('user', 'AuthenticatedUser')
-
-  await User.create({ id: user, roles: [] })
-  await Email.create({ id: email, email, user })
-  I.amOnPage('/')
-  const session = await I.executeScript(() => api.client.value.session)
-  await AuthenticatedUser.create({ id: session, user, session })
-
-  I.amOnPage('/connected')
-  I.see(email)
-  I.dontSee(email2)
-
-  I.click('button#connect')
-
-  I.seeInCurrentUrl('/connect')
-
-  if(!happyPath) {
-    I.fillField('input#email', email)
-    I.click('button[type=submit]')
-    I.seeInCurrentUrl('/connect')
-  }
-
-  I.fillField('input#email', email2)
-  I.click('button[type=submit]')
-
-  I.seeInCurrentUrl('/sent/')
-
-  const url = await I.grabCurrentUrl()
-  const authentication = url.split('/').pop()
-
-  const authenticationData = await I.grabObject('messageAuthentication', 'Authentication', authentication)
-  console.log("AUTHENTICATION DATA", authenticationData)
-  I.assert(!!authenticationData, true, 'authentication created')
-  I.assert(authenticationData?.messageData?.user, user, 'authentication contains user')
-
-  await I.useSecretCode(authentication, happyPath)
-
-  I.seeInCurrentUrl('/connect-finished')
-
-  if(!happyPath) {
-    I.amOnPage(url)
-    I.seeInCurrentUrl('/connect-finished')
-  }
-
-})