poll.test.ts

import { test, expect } from '@playwright/test'
import {
  areaVote,
  createPoll,
  createProposal,
  fastForward,
  goToPost,
  predictionProbability,
  predictionStatementCreate,
  results,
  vote,
} from './poll'
import { register, newWindow, randomString, idfy } from './generic'
import { gotoGroup, createArea, createGroup, joinGroup } from './group'
import 'dotenv/config'

test.describe('Basic-Post-Integration-Tests', () => {
  test.describe.configure({ mode: 'serial' })
  // Public so the second (freshly registered) user can join and reach the poll
  const group = { name: 'Test Group Poll' + randomString(), public: true }
  const poll = { title: 'Test Poll Create and Go ' + randomString(), date: false }

  test('Create-Post', async ({ page }) => {
    await register(page)

    await createGroup(page, group)
    //Random poll name
    await createPoll(page, poll)
  })

  test('Go-To-Post', async ({ page }) => {
    await register(page)

    // Different user than Create-Post, so join the group before viewing the poll
    await joinGroup(page, group)
    await gotoGroup(page, group)

    //Random poll name
    await goToPost(page, poll)
  })
})

test.skip('Area-Vote', async ({ page }) => {
  test.setTimeout(0)
  await register(page)

  const group = { name: 'Test Poll Area ' + randomString(), public: false }

  await createGroup(page, group)

  const area = 'Test Tag ' + randomString()
  await createArea(page, group, area)

  await gotoGroup(page, group)

  await createPoll(page, { phase_time: 1 })

  // Testing that there's atleaest one default tag, and testing canceling that vote
  await page.getByRole('radio').nth(0).check()
  await page.getByRole('button', { name: 'Submit' }).click()
  await expect(page.getByText('Successfully voted for area')).toBeVisible()
  await page.getByRole('button', { name: 'Cancel' }).click()
  await expect(page.getByText('Vote cancelled')).toBeVisible()

  await areaVote(page, { area })

  await fastForward(page, 1)

  await page.waitForTimeout(1000)
  await expect(page.getByRole('button', { name: area })).toBeVisible()

  // await page.waitForTimeout(8000)
  // await page.mouse.wheel(0, -250000)
  // await page.screenshot({ path: 'tests/screenshots/area.png', fullPage: true });

  await page.reload()
  await page.waitForLoadState('networkidle')

  // await expect(page).toHaveScreenshot('tests/screenshots/area.png');
  await expect(page.getByRole('button', { name: area })).toBeVisible()
})

test('Proposal-Spam-Test', async ({ page }) => {
  test.setTimeout(120000)
  await register(page)

  const rand = randomString()
  const group = { name: 'Test Group Proposals ' + rand, public: false }

  await createGroup(page, group)

  await gotoGroup(page, group)

  await createPoll(page, { phase_time: 1 })

  for (let i = 0; i < 10; i++) {
    await createProposal(page, { title: `Title ${i}`, description: `Description ${i}` })
  }

  expect(page.getByText('Title 9 Description 9 0')).toBeDefined()
  expect(page.getByText('Title 0 Description 0 0')).toBeDefined()

  // Wait for all of the "Successfully added proposal" to go away before screenshotting, since they don't remain on reload
  // await page.waitForTimeout(8000)
  // await page.mouse.wheel(0, -20000)
  // const before = await page.screenshot();

  // await page.reload();
  // await page.waitForLoadState('networkidle');
  // const after = await page.screenshot();
  // expect(after).toEqual(before)
})

test.skip('Prediction-Creation', async ({ page }) => {
  await register(page)

  const group = { name: 'Test Poll Prediction ' + randomString(), public: false }

  await createGroup(page, group)

  const area = 'Test Tag ' + randomString()
  await createArea(page, group, area)

  await gotoGroup(page, group)

  await createPoll(page, { phase_time: 1 })

  await areaVote(page, { area })

  await fastForward(page, 1)

  const proposal = { title: 'Test Proposal' }
  await createProposal(page, proposal)

  await fastForward(page, 1)

  const prediction = { title: 'Test Prediction' }
  await predictionStatementCreate(page, proposal, prediction)
  await predictionStatementCreate(page, proposal, prediction)
  await predictionStatementCreate(page, proposal, prediction)
  await predictionStatementCreate(page, proposal, prediction)
})

test.skip('Prediction-Statements', async ({ page }) => {
  // test.setTimeout(520000);

  await register(page)

  const group = { name: 'Test Prediction Statement ' + randomString(), public: true }

  await createGroup(page, group)

  const area = 'Tag imact test ' + Math.random().toString(36).slice(2, 10)
  await createArea(page, group, area)

  await gotoGroup(page, group)

  //TODO: Make this test faster by decreasing time between phases more
  await createPoll(page, { phase_time: 1 })

  await areaVote(page, { area })

  await fastForward(page, 1)

  const proposal = { title: 'Test 1' }
  const proposal2 = { title: 'Test 2' }
  await createProposal(page, proposal)
  await createProposal(page, proposal2)

  await fastForward(page, 1)

  await predictionStatementCreate(page, proposal, { title: 'Pred1-1' })
  await predictionStatementCreate(page, proposal, { title: 'Pred1-2' })
  await predictionStatementCreate(page, proposal, { title: 'Pred1-3' })
  await predictionStatementCreate(page, proposal2, { title: 'Pred2-1' })

  await predictionStatementCreate(page, proposal2, { title: 'Pred2-2' })
  await predictionStatementCreate(page, proposal2, { title: 'Pred2-3' })
  await predictionStatementCreate(page, proposal2, { title: 'Pred2-4' })
  await predictionStatementCreate(page, proposal2, { title: 'Pred2-5' })
  await predictionStatementCreate(page, proposal2, { title: 'Pred2-6' })
  await predictionStatementCreate(page, proposal2, { title: 'Pred2-7' })
  await predictionStatementCreate(page, proposal2, { title: 'Pred2-8' })

  //TODO Screenshot tests
})

test.skip('Prediction-Probability', async ({ page }) => {
  test.setTimeout(50000)
  // await page.waitForTimeout(12000)
  await register(page)

  const group = { name: 'Test Group Probability Voting', public: true }

  await createGroup(page, group)

  const area = 'Probability test ' + randomString()
  await createArea(page, group, area)

  await gotoGroup(page, group)

  await createPoll(page, { phase_time: 1 })

  await areaVote(page, { area })

  await fastForward(page, 1)

  const proposal = { title: 'Test ' + randomString() }
  await createProposal(page, proposal)
  await createProposal(page, proposal)

  await fastForward(page, 1)

  const prediction = { title: 'Test Pred ' + randomString(), vote: 2 }
  await predictionStatementCreate(page, proposal)

  await fastForward(page, 1)

  await predictionProbability(page, proposal, prediction)

  await fastForward(page, 1)

  await page.waitForTimeout(300)
  await page.reload()
  await page
    .locator(`#${idfy(proposal.title)}`)
    .first()
    .locator('button', { hasText: 'See More' })
    .click()

  // Wait for probability to be calculated. If a single better bets 40% on an area that no one has ever voted on before, expect 40% aggregate bet
  expect(await page.getByText('Probability: 40%').click({ timeout: 10000 }))
})

test.skip('Prediction-Probabilities', async ({ page }) => {
  test.setTimeout(50000)
  // await page.waitForTimeout(12000)
  await register(page)

  const group = { name: 'Test Group Probability-voting', public: true }
  const area = 'Tag imact test ' + randomString()
  const poll = { phase_time: 1, title: 'Test Poll' + randomString() }
  const proposal = { title: 'Test ' + randomString() }
  const prediction = { title: 'Test Pred ' + randomString(), vote: 2 }

  await createGroup(page, group)

  await createArea(page, group, area)

  await gotoGroup(page, group)

  await createPoll(page, poll)

  await areaVote(page, { area })

  await fastForward(page, 1)

  await createProposal(page, proposal)
  await createProposal(page, proposal)

  await fastForward(page, 1)

  await predictionStatementCreate(page, proposal, prediction)

  await fastForward(page, 1)

  const bPage = await newWindow()

  await register(bPage)

  await joinGroup(bPage, group)

  await goToPost(bPage, poll)

  await predictionProbability(page, proposal, prediction)
  await predictionProbability(bPage, proposal, prediction)

  await fastForward(page, 1)

  await page.waitForTimeout(400)
  await page.reload()
  await page
    .locator(`#${idfy(proposal.title)}`)
    .first()
    .locator('button', { hasText: 'See More' })
    .click()

  expect(await page.getByText('Probability: 40%').click({ timeout: 10000 }))
})

test.skip('Prediction-Probabilities-2', async ({ page }) => {
  test.setTimeout(50000)
  // await page.waitForTimeout(12000)
  await register(page)

  const group = { name: 'Test Group Probability-voting', public: true }
  const area = 'Tag imact test ' + randomString()
  const poll = { phase_time: 1, title: 'Test Poll' + randomString() }
  const proposal = { title: 'Test ' + randomString() }
  const prediction = { title: 'Test Pred ' + randomString(), vote: 2 }

  await createGroup(page, group)

  await createArea(page, group, area)

  await gotoGroup(page, group)

  await createPoll(page, poll)

  await areaVote(page, { area })

  await fastForward(page, 1)

  await createProposal(page, proposal)
  await createProposal(page, proposal)

  await fastForward(page, 1)

  await predictionStatementCreate(page, proposal, prediction)

  await fastForward(page, 1)

  const bPage = await newWindow()

  await register(bPage)

  await joinGroup(bPage, group)

  await goToPost(bPage, poll)

  await predictionProbability(page, proposal, prediction)
  await predictionProbability(bPage, proposal, { title: prediction.title, vote: 1 })

  await fastForward(page, 1)

  await page.waitForTimeout(400)
  await page.reload()
  await page
    .locator(`#${idfy(proposal.title)}`)
    .first()
    .locator('button', { hasText: 'See More' })
    .click()

  expect(await page.getByText('Probability: 30%').click({ timeout: 10000 }))
})

test('Poll-Start-To-Finish', async ({ page }) => {
  // Long multi-phase flow (group, poll, proposals, several fast-forwards, votes, results)
  test.slow()
  await register(page)

  const group = { name: 'Test Poll start to finish ' + randomString(), public: false }
  await createGroup(page, group)

  // await createArea(page, group, 'Tag 1')

  // for (let i = 0; i < 30; i++) {

  await createPoll(page, { title: 'title' + randomString(), phase_time: 1 })

  // await areaVote(page, { area: 'Tag 1' })
  //
  // await fastForward(page, 1)

  const proposal = { title: 'Test Proposal' + randomString(), vote: 2 }
  const proposal2 = { title: 'Test Proposal 2' + randomString(), vote: 3 }
  await createProposal(page, proposal)
  await createProposal(page, proposal2)

  // await predictionStatementCreate(page, proposal)
  //
  // await fastForward(page, 1)
  //
  // await predictionProbability(page, proposal)
  //
  // await page.waitForTimeout(500)

  await fastForward(page, 3)
  await page.reload()

  await vote(page, proposal)
  await vote(page, proposal2)

  await fastForward(page, 1)

  await results(page)
})

test('Date-Poll', async ({ page }) => {
  await register(page)

  const group = { name: 'Test Group Poll' + randomString(), public: false }
  const poll = { title: 'Test Group Poll', date: true }

  try {
    await createGroup(page, group)
  } catch {
    await gotoGroup(page, group)
  }

  await gotoGroup(page, group)

  await createPoll(page, poll)

  await page.locator('#weekView > button:nth-child(45)').click()
  await page.locator('#weekView > button:nth-child(46)').click()
  await page.locator('#weekView > button:nth-child(55)').click()
  await page.locator('#weekView > button:nth-child(64)').click()
  await page.getByRole('button', { name: 'Submit' }).click()

  await fastForward(page, 1)

  await expect(page.getByText('Results', { exact: true })).toBeVisible()
})