✨ Introduce bot v2 in builder (#328)

Also, the new engine is the default for updated typebots for viewer

Closes #211

apps/viewer/src/features/blocks/inputs/fileUpload/fileUpload.spec.ts

@@ -8,7 +8,6 @@ import {
   importTypebotInDatabase,
   injectFakeResults,
 } from 'utils/playwright/databaseActions'
-import { typebotViewer } from 'utils/playwright/testHelpers'
 import { getTestAsset } from '@/test/utils/playwright'
 import { Plan } from 'db'
 
@@ -21,18 +20,16 @@ test('should work as expected', async ({ page, browser }) => {
     publicId: `${typebotId}-public`,
   })
   await page.goto(`/${typebotId}-public`)
-  await typebotViewer(page)
+  await page
     .locator(`input[type="file"]`)
     .setInputFiles([
       getTestAsset('typebots/api.json'),
       getTestAsset('typebots/fileUpload.json'),
       getTestAsset('typebots/hugeGroup.json'),
     ])
-  await expect(typebotViewer(page).locator(`text="3"`)).toBeVisible()
-  await typebotViewer(page).locator('text="Upload 3 files"').click()
-  await expect(
-    typebotViewer(page).locator(`text="3 files uploaded"`)
-  ).toBeVisible()
+  await expect(page.locator(`text="3"`)).toBeVisible()
+  await page.locator('text="Upload 3 files"').click()
+  await expect(page.locator(`text="3 files uploaded"`)).toBeVisible()
   await page.goto(`${process.env.NEXTAUTH_URL}/typebots/${typebotId}/results`)
   await expect(page.getByRole('link', { name: 'api.json' })).toHaveAttribute(
     'href',
@@ -100,18 +97,16 @@ test.describe('Storage limit is reached', () => {
     page,
   }) => {
     await page.goto(`/${typebotId}-public`)
-    await typebotViewer(page)
+    await page
       .locator(`input[type="file"]`)
       .setInputFiles([
         getTestAsset('typebots/api.json'),
         getTestAsset('typebots/fileUpload.json'),
         getTestAsset('typebots/hugeGroup.json'),
       ])
-    await expect(typebotViewer(page).locator(`text="3"`)).toBeVisible()
-    await typebotViewer(page).locator('text="Upload 3 files"').click()
-    await expect(
-      typebotViewer(page).locator(`text="3 files uploaded"`)
-    ).toBeVisible()
+    await expect(page.locator(`text="3"`)).toBeVisible()
+    await page.locator('text="Upload 3 files"').click()
+    await expect(page.locator(`text="3 files uploaded"`)).toBeVisible()
     await page.evaluate(() =>
       window.localStorage.setItem('workspaceId', 'starterWorkspace')
     )

apps/viewer/src/features/blocks/inputs/fileUpload/fileUploadV2.spec.ts

@@ -1,117 +0,0 @@
-import test, { expect } from '@playwright/test'
-import { createId } from '@paralleldrive/cuid2'
-import { parse } from 'papaparse'
-import { readFileSync } from 'fs'
-import { isDefined } from 'utils'
-import {
-  createWorkspaces,
-  importTypebotInDatabase,
-  injectFakeResults,
-} from 'utils/playwright/databaseActions'
-import { getTestAsset } from '@/test/utils/playwright'
-import { Plan } from 'db'
-
-const THREE_GIGABYTES = 3 * 1024 * 1024 * 1024
-
-test('should work as expected', async ({ page, browser }) => {
-  const typebotId = createId()
-  await importTypebotInDatabase(getTestAsset('typebots/fileUpload.json'), {
-    id: typebotId,
-    publicId: `${typebotId}-public`,
-  })
-  await page.goto(`/next/${typebotId}-public`)
-  await page
-    .locator(`input[type="file"]`)
-    .setInputFiles([
-      getTestAsset('typebots/api.json'),
-      getTestAsset('typebots/fileUpload.json'),
-      getTestAsset('typebots/hugeGroup.json'),
-    ])
-  await expect(page.locator(`text="3"`)).toBeVisible()
-  await page.locator('text="Upload 3 files"').click()
-  await expect(page.locator(`text="3 files uploaded"`)).toBeVisible()
-  await page.goto(`${process.env.NEXTAUTH_URL}/typebots/${typebotId}/results`)
-  await expect(page.getByRole('link', { name: 'api.json' })).toHaveAttribute(
-    'href',
-    /.+\/api\.json/
-  )
-  await expect(
-    page.getByRole('link', { name: 'fileUpload.json' })
-  ).toHaveAttribute('href', /.+\/fileUpload\.json/)
-  await expect(
-    page.getByRole('link', { name: 'hugeGroup.json' })
-  ).toHaveAttribute('href', /.+\/hugeGroup\.json/)
-
-  await page.click('[data-testid="checkbox"] >> nth=0')
-  const [download] = await Promise.all([
-    page.waitForEvent('download'),
-    page.getByRole('button', { name: 'Export' }).click(),
-  ])
-  const downloadPath = await download.path()
-  expect(downloadPath).toBeDefined()
-  const file = readFileSync(downloadPath as string).toString()
-  const { data } = parse(file)
-  expect(data).toHaveLength(2)
-  expect((data[1] as unknown[])[1]).toContain(process.env.S3_ENDPOINT)
-
-  const urls = (
-    await Promise.all(
-      [
-        page.getByRole('link', { name: 'api.json' }),
-        page.getByRole('link', { name: 'fileUpload.json' }),
-        page.getByRole('link', { name: 'hugeGroup.json' }),
-      ].map((elem) => elem.getAttribute('href'))
-    )
-  ).filter(isDefined)
-
-  const page2 = await browser.newPage()
-  await page2.goto(urls[0])
-  await expect(page2.locator('pre')).toBeVisible()
-
-  page.getByRole('button', { name: 'Delete' }).click()
-  await page.locator('button >> text="Delete"').click()
-  await expect(page.locator('text="api.json"')).toBeHidden()
-  await page2.goto(urls[0])
-  await expect(page2.locator('pre')).toBeHidden()
-})
-
-test.describe('Storage limit is reached', () => {
-  const typebotId = createId()
-  const workspaceId = createId()
-
-  test.beforeAll(async () => {
-    await createWorkspaces([{ id: workspaceId, plan: Plan.STARTER }])
-    await importTypebotInDatabase(getTestAsset('typebots/fileUpload.json'), {
-      id: typebotId,
-      publicId: `${typebotId}-public`,
-      workspaceId,
-    })
-    await injectFakeResults({
-      typebotId,
-      count: 20,
-      fakeStorage: THREE_GIGABYTES,
-    })
-  })
-
-  test("shouldn't upload anything if limit has been reached", async ({
-    page,
-  }) => {
-    await page.goto(`/next/${typebotId}-public`)
-    await page
-      .locator(`input[type="file"]`)
-      .setInputFiles([
-        getTestAsset('typebots/api.json'),
-        getTestAsset('typebots/fileUpload.json'),
-        getTestAsset('typebots/hugeGroup.json'),
-      ])
-    await expect(page.locator(`text="3"`)).toBeVisible()
-    await page.locator('text="Upload 3 files"').click()
-    await expect(page.locator(`text="3 files uploaded"`)).toBeVisible()
-    await page.evaluate(() =>
-      window.localStorage.setItem('workspaceId', 'starterWorkspace')
-    )
-    await page.goto(`${process.env.NEXTAUTH_URL}/typebots/${typebotId}/results`)
-    await expect(page.locator('text="150%"')).toBeVisible()
-    await expect(page.locator('text="api.json"')).toBeHidden()
-  })
-})

apps/viewer/src/features/blocks/integrations/chatwoot/chatwoot.spec.ts

@@ -3,7 +3,6 @@ import { createId } from '@paralleldrive/cuid2'
 import { createTypebots } from 'utils/playwright/databaseActions'
 import { parseDefaultGroupWithBlock } from 'utils/playwright/databaseHelpers'
 import { defaultChatwootOptions, IntegrationBlockType } from 'models'
-import { typebotViewer } from 'utils/playwright/testHelpers'
 
 const typebotId = createId()
 
@@ -26,6 +25,6 @@ test('should work as expected', async ({ page }) => {
     },
   ])
   await page.goto(`/${typebotId}-public`)
-  await typebotViewer(page).getByRole('button', { name: 'Go' }).click()
+  await page.getByRole('button', { name: 'Go' }).click()
   await expect(page.locator('#chatwoot_live_chat_widget')).toBeVisible()
 })

apps/viewer/src/features/blocks/integrations/chatwoot/chatwootV2.spec.ts

@@ -1,30 +0,0 @@
-import test, { expect } from '@playwright/test'
-import { createId } from '@paralleldrive/cuid2'
-import { createTypebots } from 'utils/playwright/databaseActions'
-import { parseDefaultGroupWithBlock } from 'utils/playwright/databaseHelpers'
-import { defaultChatwootOptions, IntegrationBlockType } from 'models'
-
-const typebotId = createId()
-
-const chatwootTestWebsiteToken = 'tueXiiqEmrWUCZ4NUyoR7nhE'
-
-test('should work as expected', async ({ page }) => {
-  await createTypebots([
-    {
-      id: typebotId,
-      ...parseDefaultGroupWithBlock(
-        {
-          type: IntegrationBlockType.CHATWOOT,
-          options: {
-            ...defaultChatwootOptions,
-            websiteToken: chatwootTestWebsiteToken,
-          },
-        },
-        { withGoButton: true }
-      ),
-    },
-  ])
-  await page.goto(`/next/${typebotId}-public`)
-  await page.getByRole('button', { name: 'Go' }).click()
-  await expect(page.locator('#chatwoot_live_chat_widget')).toBeVisible()
-})

apps/viewer/src/features/blocks/integrations/sendEmail/sendEmail.spec.ts

@@ -3,7 +3,6 @@ import { createSmtpCredentials } from '../../../../test/utils/databaseActions'
 import { createId } from '@paralleldrive/cuid2'
 import { SmtpCredentialsData } from 'models'
 import { importTypebotInDatabase } from 'utils/playwright/databaseActions'
-import { typebotViewer } from 'utils/playwright/testHelpers'
 import { getTestAsset } from '@/test/utils/playwright'
 
 export const mockSmtpCredentials: SmtpCredentialsData = {
@@ -33,23 +32,8 @@ test('should send an email', async ({ page }) => {
     publicId: `${typebotId}-public`,
   })
   await page.goto(`/${typebotId}-public`)
-  const [response] = await Promise.all([
-    page.waitForResponse((resp) =>
-      resp.request().url().includes(`integrations/email`)
-    ),
-    typebotViewer(page).locator('text=Send email').click(),
-  ])
-  const { previewUrl } = await response.json()
-  await page.goto(previewUrl)
-  await expect(page.locator('text="Hey!"')).toBeVisible()
-  await expect(
-    page.locator(`text="${mockSmtpCredentials.from.name}"`)
-  ).toBeVisible()
-  await expect(page.locator('text="<test1@gmail.com>" >> nth=0')).toBeVisible()
-  await expect(page.locator('text="<test2@gmail.com>" >> nth=0')).toBeVisible()
-  await expect(
-    page.locator('text="<baptiste.arnaud95@gmail.com>" >> nth=0')
-  ).toBeVisible()
+  await page.locator('text=Send email').click()
+  await expect(page.getByText('Email sent!')).toBeVisible()
   await page.goto(`${process.env.NEXTAUTH_URL}/typebots/${typebotId}/results`)
   await page.click('text="See logs"')
   await expect(page.locator('text="Email successfully sent"')).toBeVisible()

apps/viewer/src/features/blocks/integrations/sendEmail/sendEmailV2.spec.ts

@@ -1,40 +0,0 @@
-import test, { expect } from '@playwright/test'
-import { createSmtpCredentials } from '../../../../test/utils/databaseActions'
-import { createId } from '@paralleldrive/cuid2'
-import { SmtpCredentialsData } from 'models'
-import { importTypebotInDatabase } from 'utils/playwright/databaseActions'
-import { getTestAsset } from '@/test/utils/playwright'
-
-const mockSmtpCredentials: SmtpCredentialsData = {
-  from: {
-    email: 'sunny.cremin66@ethereal.email',
-    name: 'Sunny Cremin',
-  },
-  host: 'smtp.ethereal.email',
-  port: 587,
-  username: 'sunny.cremin66@ethereal.email',
-  password: 'yJDHkf2bYbNydaRvTq',
-}
-
-test.beforeAll(async () => {
-  try {
-    const credentialsId = 'send-email-credentials'
-    await createSmtpCredentials(credentialsId, mockSmtpCredentials)
-  } catch (err) {
-    console.error(err)
-  }
-})
-
-test('should send an email', async ({ page }) => {
-  const typebotId = createId()
-  await importTypebotInDatabase(getTestAsset('typebots/sendEmail.json'), {
-    id: typebotId,
-    publicId: `${typebotId}-public`,
-  })
-  await page.goto(`/next/${typebotId}-public`)
-  await page.locator('text=Send email').click()
-  await expect(page.getByText('Email sent!')).toBeVisible()
-  await page.goto(`${process.env.NEXTAUTH_URL}/typebots/${typebotId}/results`)
-  await page.click('text="See logs"')
-  await expect(page.locator('text="Email successfully sent"')).toBeVisible()
-})

apps/viewer/src/features/blocks/integrations/webhook/webhook.spec.ts

@@ -1,190 +1,67 @@
 import test, { expect } from '@playwright/test'
 import { createId } from '@paralleldrive/cuid2'
-import { HttpMethod, Typebot } from 'models'
+import { HttpMethod } from 'models'
 import {
   createWebhook,
   importTypebotInDatabase,
 } from 'utils/playwright/databaseActions'
-import { typebotViewer } from 'utils/playwright/testHelpers'
-import { apiToken } from 'utils/playwright/databaseSetup'
 import { getTestAsset } from '@/test/utils/playwright'
 
 const typebotId = createId()
 
-test.describe('Bot', () => {
-  test.beforeEach(async () => {
-    await importTypebotInDatabase(getTestAsset('typebots/webhook.json'), {
-      id: typebotId,
-      publicId: `${typebotId}-public`,
+test.beforeEach(async () => {
+  await importTypebotInDatabase(getTestAsset('typebots/webhook.json'), {
+    id: typebotId,
+    publicId: `${typebotId}-public`,
+  })
+
+  try {
+    await createWebhook(typebotId, {
+      id: 'failing-webhook',
+      url: 'http://localhost:3001/api/mock/fail',
+      method: HttpMethod.POST,
     })
 
-    try {
-      await createWebhook(typebotId, {
-        id: 'failing-webhook',
-        url: 'http://localhost:3001/api/mock/fail',
-        method: HttpMethod.POST,
-      })
+    await createWebhook(typebotId, {
+      id: 'partial-body-webhook',
+      url: 'http://localhost:3000/api/mock/webhook-easy-config',
+      method: HttpMethod.POST,
+      body: `{
+          "name": "{{Name}}",
+          "age": {{Age}},
+          "gender": "{{Gender}}"
+        }`,
+    })
 
-      await createWebhook(typebotId, {
-        id: 'partial-body-webhook',
-        url: 'http://localhost:3000/api/mock/webhook-easy-config',
-        method: HttpMethod.POST,
-        body: `{
-        "name": "{{Name}}",
-        "age": {{Age}},
-        "gender": "{{Gender}}"
-      }`,
-      })
-
-      await createWebhook(typebotId, {
-        id: 'full-body-webhook',
-        url: 'http://localhost:3000/api/mock/webhook-easy-config',
-        method: HttpMethod.POST,
-        body: `{{Full body}}`,
-      })
-    } catch (err) {
-      // Webhooks already created
-    }
-  })
-
-  test('should execute webhooks properly', async ({ page }) => {
-    await page.goto(`/${typebotId}-public`)
-    await typebotViewer(page).locator('text=Send failing webhook').click()
-    await typebotViewer(page)
-      .locator('[placeholder="Type a name..."]')
-      .fill('John')
-    await typebotViewer(page).locator('text="Send"').click()
-    await typebotViewer(page)
-      .locator('[placeholder="Type an age..."]')
-      .fill('30')
-    await typebotViewer(page).locator('text="Send"').click()
-    await typebotViewer(page).locator('text="Male"').click()
-    await expect(
-      typebotViewer(page).getByText('{"name":"John","age":25,"gender":"male"}')
-    ).toBeVisible()
-    await expect(
-      typebotViewer(page).getByText('{"name":"John","age":30,"gender":"Male"}')
-    ).toBeVisible()
-    await page.goto(`http://localhost:3000/typebots/${typebotId}/results`)
-    await page.click('text="See logs"')
-    await expect(
-      page.locator('text="Webhook successfuly executed." >> nth=1')
-    ).toBeVisible()
-    await expect(page.locator('text="Webhook returned an error"')).toBeVisible()
-  })
+    await createWebhook(typebotId, {
+      id: 'full-body-webhook',
+      url: 'http://localhost:3000/api/mock/webhook-easy-config',
+      method: HttpMethod.POST,
+      body: `{{Full body}}`,
+    })
+  } catch (err) {
+    console.log(err)
+  }
 })
 
-test.describe('API', () => {
-  const typebotId = 'webhook-flow'
-
-  test.beforeAll(async () => {
-    try {
-      await importTypebotInDatabase(getTestAsset('typebots/api.json'), {
-        id: typebotId,
-      })
-      await createWebhook(typebotId)
-    } catch (err) {
-      console.log(err)
-    }
-  })
-
-  test('can list typebots', async ({ request }) => {
-    expect((await request.get(`/api/typebots`)).status()).toBe(401)
-    const response = await request.get(`/api/typebots`, {
-      headers: { Authorization: `Bearer ${apiToken}` },
-    })
-    const { typebots } = (await response.json()) as { typebots: Typebot[] }
-    expect(typebots.length).toBeGreaterThanOrEqual(1)
-    expect(typebots.find((typebot) => typebot.id === typebotId)).toMatchObject({
-      id: typebotId,
-      name: 'My typebot',
-    })
-  })
-
-  test('can get webhook blocks', async ({ request }) => {
-    expect(
-      (await request.get(`/api/typebots/${typebotId}/webhookBlocks`)).status()
-    ).toBe(401)
-    const response = await request.get(
-      `/api/typebots/${typebotId}/webhookBlocks`,
-      {
-        headers: { Authorization: `Bearer ${apiToken}` },
-      }
-    )
-    const { blocks } = await response.json()
-    expect(blocks).toHaveLength(1)
-    expect(blocks[0]).toEqual({
-      blockId: 'webhookBlock',
-      name: 'Webhook > webhookBlock',
-    })
-  })
-
-  test('can subscribe webhook', async ({ request }) => {
-    expect(
-      (
-        await request.post(
-          `/api/typebots/${typebotId}/blocks/webhookBlock/subscribeWebhook`,
-          { data: { url: 'https://test.com' } }
-        )
-      ).status()
-    ).toBe(401)
-    const response = await request.post(
-      `/api/typebots/${typebotId}/blocks/webhookBlock/subscribeWebhook`,
-      {
-        headers: {
-          Authorization: `Bearer ${apiToken}`,
-        },
-        data: { url: 'https://test.com' },
-      }
-    )
-    const body = await response.json()
-    expect(body).toEqual({
-      message: 'success',
-    })
-  })
-
-  test('can unsubscribe webhook', async ({ request }) => {
-    expect(
-      (
-        await request.post(
-          `/api/typebots/${typebotId}/blocks/webhookBlock/unsubscribeWebhook`
-        )
-      ).status()
-    ).toBe(401)
-    const response = await request.post(
-      `/api/typebots/${typebotId}/blocks/webhookBlock/unsubscribeWebhook`,
-      {
-        headers: { Authorization: `Bearer ${apiToken}` },
-      }
-    )
-    const body = await response.json()
-    expect(body).toEqual({
-      message: 'success',
-    })
-  })
-
-  test('can get a sample result', async ({ request }) => {
-    expect(
-      (
-        await request.get(
-          `/api/typebots/${typebotId}/blocks/webhookBlock/sampleResult`
-        )
-      ).status()
-    ).toBe(401)
-    const response = await request.get(
-      `/api/typebots/${typebotId}/blocks/webhookBlock/sampleResult`,
-      {
-        headers: { Authorization: `Bearer ${apiToken}` },
-      }
-    )
-    const data = await response.json()
-    expect(data).toMatchObject({
-      message: 'This is a sample result, it has been generated ⬇️',
-      Welcome: 'Hi!',
-      Email: 'test@email.com',
-      Name: 'answer value',
-      Services: 'Website dev, Content Marketing, Social Media, UI / UX Design',
-      'Additional information': 'answer value',
-    })
-  })
+test('should execute webhooks properly', async ({ page }) => {
+  await page.goto(`/${typebotId}-public`)
+  await page.locator('text=Send failing webhook').click()
+  await page.locator('[placeholder="Type a name..."]').fill('John')
+  await page.locator('text="Send"').click()
+  await page.locator('[placeholder="Type an age..."]').fill('30')
+  await page.locator('text="Send"').click()
+  await page.locator('text="Male"').click()
+  await expect(
+    page.getByText('{"name":"John","age":25,"gender":"male"}')
+  ).toBeVisible()
+  await expect(
+    page.getByText('{"name":"John","age":30,"gender":"Male"}')
+  ).toBeVisible()
+  await page.goto(`http://localhost:3000/typebots/${typebotId}/results`)
+  await page.click('text="See logs"')
+  await expect(
+    page.locator('text="Webhook successfuly executed." >> nth=1')
+  ).toBeVisible()
+  await expect(page.locator('text="Webhook returned an error"')).toBeVisible()
 })

apps/viewer/src/features/blocks/integrations/webhook/webhookV2.spec.ts

@@ -1,67 +0,0 @@
-import test, { expect } from '@playwright/test'
-import { createId } from '@paralleldrive/cuid2'
-import { HttpMethod } from 'models'
-import {
-  createWebhook,
-  importTypebotInDatabase,
-} from 'utils/playwright/databaseActions'
-import { getTestAsset } from '@/test/utils/playwright'
-
-const typebotId = createId()
-
-test.beforeEach(async () => {
-  await importTypebotInDatabase(getTestAsset('typebots/webhook.json'), {
-    id: typebotId,
-    publicId: `${typebotId}-public`,
-  })
-
-  try {
-    await createWebhook(typebotId, {
-      id: 'failing-webhook',
-      url: 'http://localhost:3001/api/mock/fail',
-      method: HttpMethod.POST,
-    })
-
-    await createWebhook(typebotId, {
-      id: 'partial-body-webhook',
-      url: 'http://localhost:3000/api/mock/webhook-easy-config',
-      method: HttpMethod.POST,
-      body: `{
-          "name": "{{Name}}",
-          "age": {{Age}},
-          "gender": "{{Gender}}"
-        }`,
-    })
-
-    await createWebhook(typebotId, {
-      id: 'full-body-webhook',
-      url: 'http://localhost:3000/api/mock/webhook-easy-config',
-      method: HttpMethod.POST,
-      body: `{{Full body}}`,
-    })
-  } catch (err) {
-    // Webhooks already created
-  }
-})
-
-test('should execute webhooks properly', async ({ page }) => {
-  await page.goto(`/next/${typebotId}-public`)
-  await page.locator('text=Send failing webhook').click()
-  await page.locator('[placeholder="Type a name..."]').fill('John')
-  await page.locator('text="Send"').click()
-  await page.locator('[placeholder="Type an age..."]').fill('30')
-  await page.locator('text="Send"').click()
-  await page.locator('text="Male"').click()
-  await expect(
-    page.getByText('{"name":"John","age":25,"gender":"male"}')
-  ).toBeVisible()
-  await expect(
-    page.getByText('{"name":"John","age":30,"gender":"Male"}')
-  ).toBeVisible()
-  await page.goto(`http://localhost:3000/typebots/${typebotId}/results`)
-  await page.click('text="See logs"')
-  await expect(
-    page.locator('text="Webhook successfuly executed." >> nth=1')
-  ).toBeVisible()
-  await expect(page.locator('text="Webhook returned an error"')).toBeVisible()
-})

apps/viewer/src/features/blocks/logic/typebotLink/typebotLink.spec.ts

@@ -1,9 +1,8 @@
 import { getTestAsset } from '@/test/utils/playwright'
 import test, { expect } from '@playwright/test'
 import { importTypebotInDatabase } from 'utils/playwright/databaseActions'
-import { typebotViewer } from 'utils/playwright/testHelpers'
 
-const typebotId = 'cl0ibhi7s0018n21aarlmg0cm1'
+const typebotId = 'cl0ibhi7s0018n21aarlmg0cm'
 const linkedTypebotId = 'cl0ibhv8d0130n21aw8doxhj5'
 
 test.beforeAll(async () => {
@@ -23,16 +22,9 @@ test.beforeAll(async () => {
 
 test('should work as expected', async ({ page }) => {
   await page.goto(`/${typebotId}-public`)
-  await typebotViewer(page).locator('input').fill('Hello there!')
-  await Promise.all([
-    page.waitForResponse(
-      (resp) =>
-        resp.request().url().includes(`/api/typebots/t/results`) &&
-        resp.status() === 200 &&
-        resp.request().method() === 'PUT'
-    ),
-    typebotViewer(page).locator('input').press('Enter'),
-  ])
+  await page.locator('input').fill('Hello there!')
+  await page.locator('input').press('Enter')
+  await expect(page.getByText('Cheers!')).toBeVisible()
   await page.goto(`${process.env.NEXTAUTH_URL}/typebots/${typebotId}/results`)
   await expect(page.locator('text=Hello there!')).toBeVisible()
 })

apps/viewer/src/features/blocks/logic/typebotLink/typebotLinkV2.spec.ts

@@ -1,30 +0,0 @@
-import { getTestAsset } from '@/test/utils/playwright'
-import test, { expect } from '@playwright/test'
-import { importTypebotInDatabase } from 'utils/playwright/databaseActions'
-
-const typebotId = 'cl0ibhi7s0018n21aarlmg0cm'
-const linkedTypebotId = 'cl0ibhv8d0130n21aw8doxhj5'
-
-test.beforeAll(async () => {
-  try {
-    await importTypebotInDatabase(
-      getTestAsset('typebots/linkTypebots/1.json'),
-      { id: typebotId, publicId: `${typebotId}-public` }
-    )
-    await importTypebotInDatabase(
-      getTestAsset('typebots/linkTypebots/2.json'),
-      { id: linkedTypebotId, publicId: `${linkedTypebotId}-public` }
-    )
-  } catch (err) {
-    console.error(err)
-  }
-})
-
-test('should work as expected', async ({ page }) => {
-  await page.goto(`/next/${typebotId}-public`)
-  await page.locator('input').fill('Hello there!')
-  await page.locator('input').press('Enter')
-  await expect(page.getByText('Cheers!')).toBeVisible()
-  await page.goto(`${process.env.NEXTAUTH_URL}/typebots/${typebotId}/results`)
-  await expect(page.locator('text=Hello there!')).toBeVisible()
-})