@open-xchange/appsuite-codeceptjs 0.1.0

package/src/helper.js

@@ -0,0 +1,817 @@
+/**
+ * @copyright Copyright (c) Open-Xchange GmbH, Germany <info@open-xchange.com>
+ * @license AGPL-3.0
+ *
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with OX App Suite. If not, see <https://www.gnu.org/licenses/agpl-3.0.txt>.
+ *
+ * Any use of the work other than as authorized under this license or copyright law is prohibited.
+ */
+
+const codecept = require('codeceptjs')
+const AxeBuilder = require('@axe-core/playwright').default
+const isEmpty = obj => [Object, Array].includes((obj || {}).constructor) && !Object.entries(obj || {}).length
+
+const Helper = require('@codeceptjs/helper')
+const { createHttpClient } = require('./appsuiteHttpClient')
+const util = require('./util')
+const fs = require('node:fs/promises')
+const crypto = require('node:crypto')
+const path = require('node:path')
+const assert = require('node:assert')
+const moment = require('moment')
+const javascriptRoot = util.getJavascriptRoot()
+
+const output = require('codeceptjs/lib/output')
+
+function delay (ms) { return new Promise(resolve => setTimeout(resolve, ms)) }
+
+async function retryPromise (fn, timeout = 5, retryDelay = 300) {
+  const start = Date.now()
+  const retry = async () => {
+    if (Date.now() - start > timeout * 1000) return Promise.reject(new Error('Timed out'))
+    await delay(retryDelay)
+    return fn().catch(retry)
+  }
+  return retry()
+}
+
+function jsonToForm (json) {
+  const form = new FormData()
+  for (const key in json) {
+    if (json[key] instanceof Object) form.append(key, JSON.stringify(json[key]))
+    else form.append(key, json[key])
+  }
+  return form
+}
+
+function setDeepValue (key, value, target) {
+  const keys = key.split('/')
+  keys.forEach(function (key, index) {
+    if (index === keys.length - 1) {
+      target[key] = value
+    } else {
+      target = target[key] = target[key] || {}
+    }
+  })
+}
+
+async function saveSetting (name, settings, options) {
+  const httpClient = createHttpClient(options)
+  const data = await httpClient.get('/api/jslob', {
+    params: { id: name, action: 'get' }
+  }).then(res => res.data.data)
+
+  for (const key in settings) {
+    const value = settings[key]
+    setDeepValue(key, value, data.tree)
+  }
+
+  return httpClient.put('/api/jslob', data.tree, {
+    params: { action: 'set', id: name }
+  })
+}
+
+async function createBlobFromFile (file) {
+  let filename, blob
+  if (typeof file === 'string') {
+    filename = path.basename(file)
+    // @ts-ignore
+    blob = new Blob([await fs.readFile(path.join(codecept_dir, file))])
+  } else {
+    filename = file.filename || file.name
+    blob = new Blob([file.content])
+  }
+  return { filename, blob }
+}
+
+async function compareBinaries (filePath1, filePath2) {
+  const [file1, file2] = await Promise.all([fs.readFile(filePath1), fs.readFile(filePath2)])
+
+  const hash1 = crypto.createHash('sha256').update(file1).digest('hex')
+  const hash2 = crypto.createHash('sha256').update(file2).digest('hex')
+
+  return hash1 === hash2
+}
+
+async function fileExists (filePath) {
+  try {
+    await fs.access(filePath)
+    return true
+  } catch (e) {
+    return false
+  }
+}
+
+class AppSuiteHelper extends Helper {
+  constructor (config) {
+    super(config)
+    codecept.locator.addFilter((locator, result) => {
+      if (typeof locator === 'string' && locator.indexOf('~') === 0) {
+        // accessibility locator
+        result.value = `[aria-label^="${locator.slice(1)}"]`
+        result.type = 'css'
+        result.output = `aria-label^=${locator.slice(1)}`
+      }
+    })
+  }
+
+  async waitForDownload (locator, filename, referenceFilePath) {
+    const { page } = this.helpers.Playwright
+    const downloadPromise = page.waitForEvent('download')
+    await page.locator(locator).click()
+    const download = await downloadPromise
+    const filePath = path.join(codecept_dir, '.tmp', download.suggestedFilename())
+
+    await download.saveAs(filePath)
+
+    // delay to ensure the file is written to disk
+    await new Promise(resolve => setTimeout(resolve, 1000))
+
+    assert.ok(await fileExists(filePath), `Downloaded file "${filename}" does not exist`)
+
+    if (!referenceFilePath) return
+    const reference = path.join(codecept_dir, referenceFilePath)
+    assert.ok(await compareBinaries(filePath, reference), `Downloaded file "${filename}" does not match the reference file`)
+  }
+
+  async grabAxeReport ({ disableRules = [], exclude = [], include = [] } = {}) {
+    const { page } = this.helpers.Playwright
+    const axeBuilder = new AxeBuilder({ page })
+    if (disableRules) axeBuilder.disableRules(disableRules)
+    if (exclude) {
+      exclude = Array.isArray(exclude) ? exclude : [exclude]
+      exclude.forEach(element => {
+        axeBuilder.exclude(element)
+      })
+    }
+    if (include) {
+      include = Array.isArray(include) ? include : [include]
+      include.forEach(element => {
+        axeBuilder.include(element)
+      })
+    }
+
+    const report = await axeBuilder.analyze()
+
+    const nodes = []
+    for (const violation of report.violations) {
+      for (const node of violation.nodes) {
+        nodes.push(node.target)
+        for (const combinedNodes of [node.all, node.any, node.none]) {
+          if (!isEmpty(combinedNodes)) {
+            for (const any of combinedNodes) {
+              for (const relatedNode of any.relatedNodes) {
+                nodes.push(relatedNode.target)
+              }
+            }
+          }
+        }
+      }
+    }
+
+    await page.evaluate(selectors => {
+      // Loop through the array of selectors and apply a red border to highlight elements
+      selectors.forEach(selector => {
+        const element = document.querySelector(selector)
+        if (element) element.style.border = '2px solid red'
+      })
+    }, nodes)
+    if (typeof report === 'string') throw report
+
+    return report
+  }
+
+  async selectFolder (id, context) {
+    const { page } = this.helpers.Playwright
+    const error = await page.evaluate(async ({ id, context, timeout }) => {
+      const { _, $, ox } = await import(`${window.location.pathname}e2e.js`)
+
+      import(`${window.location.pathname}io.ox/core/folder/api.js`).then(function ({ default: folderAPI }) {
+        function repeatUntil (cb, interval, timeout) {
+          const start = _.now()
+          const def = new $.Deferred()
+          const iterate = function () {
+            const result = cb()
+            if (result) return def.resolve(result)
+            if (_.now() - start < timeout) return _.delay(iterate, interval)
+            def.reject({ message: `Folder API could not resolve folder after ${timeout / 1000} seconds` })
+          }
+          iterate()
+          return def
+        }
+        return Promise.all([
+          repeatUntil(function () {
+            return _(folderAPI.pool.models).find(function (m) {
+              const res = m.get('title') === id || m.get('id') === id || m.get('display_title') === id
+              return context ? res && m.get('module') === context : res
+            })
+          }, 100, timeout),
+          repeatUntil(function () {
+            return ox.ui.App.getCurrentApp()
+          }, 100, timeout)
+        ]).then(function ([model, app]) {
+          // special handling for virtual folders
+          if (model.get('id').indexOf('virtual/') === 0) {
+            const body = app.getWindow().nodes.body
+            if (body) {
+              const view = body.find('.folder-tree').data('view')
+              if (view) {
+                view.trigger('virtual', model.get('id'))
+              }
+            }
+          }
+          return app.folder.set(model.get('id'))
+        })
+      }).then(function () { })
+    }, { id, context, timeout: 5000, javascriptRoot })
+    if (error) throw error
+  }
+
+  async throttleNetwork (networkConfig) {
+    // some network speed presets
+    const presets = {
+      OFFLINE: {
+        offline: true,
+        downloadThroughput: 0,
+        uploadThroughput: 0,
+        latency: 0
+      },
+      GPRS: {
+        offline: false,
+        downloadThroughput: 50 * 1024 / 8,
+        uploadThroughput: 20 * 1024 / 8,
+        latency: 500
+      },
+      '2G': {
+        offline: false,
+        downloadThroughput: 250 * 1024 / 8,
+        uploadThroughput: 50 * 1024 / 8,
+        latency: 300
+      },
+      '3G': {
+        offline: false,
+        downloadThroughput: 750 * 1024 / 8,
+        uploadThroughput: 250 * 1024 / 8,
+        latency: 100
+      },
+      '4G': {
+        offline: false,
+        downloadThroughput: 4 * 1024 * 1024 / 8,
+        uploadThroughput: 3 * 1024 * 1024 / 8,
+        latency: 20
+      },
+      DSL: {
+        offline: false,
+        downloadThroughput: 2 * 1024 * 1024 / 8,
+        uploadThroughput: 1 * 1024 * 1024 / 8,
+        latency: 5
+      },
+      // no throttling, use this to reset the connection
+      ONLINE: {
+        offline: false,
+        downloadThroughput: -1,
+        uploadThroughput: -1,
+        latency: 0
+      }
+    }
+
+    const { page } = this.helpers.Playwright
+
+    // get Chrome DevTools session
+    const devTools = await page.context().newCDPSession(page)
+
+    // Set network speed, use preset if its there
+    await devTools.send('Network.emulateNetworkConditions', presets[networkConfig.toUpperCase()] || networkConfig)
+  }
+
+  async haveSetting (obj, options) {
+    if (typeof obj === 'string') {
+      const input = obj.split('//')
+      const moduleName = input[0]
+      const key = input[1]
+      const value = options
+      obj = { [moduleName]: { [key]: value } }
+      options = arguments[2]
+    }
+    options = options || {}
+
+    // need to save settings sequentially, because concurrent requests will fail
+    for (const moduleName in obj) {
+      await saveSetting(moduleName, obj[moduleName], options)
+    }
+  }
+
+  async haveSnippet (snippet, options) {
+    const httpClient = createHttpClient(options)
+    const response = await httpClient.put('/api/snippet', snippet, { params: { action: 'new' } })
+    assert.strictEqual(response.data.error, undefined, JSON.stringify(response.data))
+    return response.data
+  }
+
+  async haveMail (data, options) {
+    const httpClient = createHttpClient(options)
+
+    let form, response
+    if (!data.folder) data.folder = 'default0/INBOX'
+    if (data.folder && (data.path || data.source)) {
+      // import the mail
+      form = new FormData()
+      if (data.path) {
+        const { blob } = await createBlobFromFile(data.path)
+        form.append('file', blob)
+      } else if (data.source) {
+        form.append('file', new Blob([data.source], { type: 'text/plain' }), data.filename || 'test.eml')
+      }
+      response = await httpClient.post('/api/mail', form, {
+        params: {
+          action: 'import',
+          folder: data.folder,
+          force: true
+        }
+      })
+    } else {
+      // send the mail
+      // transform some data
+      if (data.content) {
+        data.attachments = data.attachments || []
+        data.attachments.unshift({
+          content: data.content,
+          content_type: 'text/html',
+          disp: 'inline'
+        })
+        delete data.content
+      }
+      const files = []
+      for (let i = 1; data.attachments && i < data.attachments.length; i++) {
+        const file = data.attachments[i]
+        const { filename, blob } = await createBlobFromFile(file)
+
+        if (filename && blob) {
+          data.attachments[i] = { filename, disp: 'attachment', name: filename }
+          files.push({ filename, blob })
+        }
+      }
+      if (!(data.from instanceof Array) && data.from.get) {
+        data.from = [[data.from.get('displayname'), data.from.get('primaryEmail')]]
+      }
+      if (!(data.to instanceof Array) && data.to.get) {
+        data.to = [[data.to.get('displayname'), data.to.get('primaryEmail')]]
+      }
+      if (data.sendtype === undefined) {
+        data.sendtype = 0
+      }
+      form = jsonToForm({ json_0: data })
+      for (let i = 0; i < files.length; i++) {
+        form.append(`file_${i}`, files[i].blob, files[i].filename)
+      }
+      response = await httpClient.post('/api/mail', form, {
+        params: {
+          action: 'new',
+          force_json_response: true,
+          lineWrapAfter: 0
+        }
+      })
+    }
+    const matches = /\((\{.*?\})\)/.exec(response.data)
+    const resData = matches && matches[1] ? JSON.parse(matches[1]) : response.data
+    assert.strictEqual(resData.error, undefined, JSON.stringify(resData))
+    return resData
+  }
+
+  async haveMails (iterable, options) {
+    for (const mail of iterable) await this.haveMail(mail, options)
+  }
+
+  async haveAnAlias (alias, options = {}) {
+    console.warn('This method is deprecated, use `user.hasAlias` instead')
+    const user = options.user || codecept.container.support('users')[0]
+    return user.hasAlias(alias)
+  }
+
+  async haveMailFilterRule (rule, options) {
+    const httpClient = createHttpClient(options)
+
+    const response = await httpClient.put('/api/mailfilter/v2', rule, {
+      params: { action: 'new' }
+    })
+    assert.strictEqual(response.data.error, undefined, JSON.stringify(response.data))
+    return response.data
+  }
+
+  async haveFolder ({ title, module, permissions = [], subscribed = 1, parent }, options) {
+    const httpClient = createHttpClient(options)
+
+    const roles = { viewer: 257, reviewer: 33025, author: 4227332, administrator: 272662788, owner: 272662788 }
+    permissions = permissions.map((perm) => {
+      if (!perm.access || !perm.user) return perm
+      assert.notEqual(undefined, roles[perm.access])
+      return { entity: perm.user.userdata.id, bits: roles[perm.access], group: false }
+    })
+    const payload = { title, module, subscribed, permissions }
+    if (permissions.length === 0) delete payload.permissions
+    const response = await httpClient.put('/api/folders', payload, {
+      params: { action: 'new', folder: parent }
+    })
+    assert.strictEqual(response.data.error, undefined, JSON.stringify(response.data))
+    return response.data.data
+  }
+
+  async haveContact (contact, options) {
+    const httpClient = createHttpClient(options)
+    const response = await httpClient.put('/api/contacts', contact, {
+      params: { action: 'new' }
+    })
+    assert.strictEqual(response.data.error, undefined, JSON.stringify(response.data))
+    return response.data.data
+  }
+
+  async grabDefaultFolder (module, options = {}) {
+    const httpClient = createHttpClient(options)
+    const jslob = module === 'mail' ? 'io.ox/mail' : 'io.ox/core'
+    const response = await httpClient.put('/api/jslob', [jslob], {
+      params: { action: 'list' }
+    })
+    assert.strictEqual(response.data.error, undefined, JSON.stringify(response.data))
+    const tree = response.data.data[0].tree
+    if (module === 'mail') return tree.defaultFolder[options.type || 'inbox']
+    return tree.folder[module]
+  }
+
+  /**
+   * Uploads a file to a specified folder.
+   *
+   * @param {string} folder - The ID of the folder where the file will be uploaded.
+   * @param {string|object} file - The path to the file or an object containing the file information.
+   * @param {object} [options] - Additional options for the file upload.
+   * @returns {Promise<Object>} - The uploaded file data.
+   */
+  async haveFile (folder, file, options) {
+    options = options || {}
+    const form = new FormData()
+    // prepare file for usage
+    const { filename, blob } = await createBlobFromFile(file)
+    form.append('file', blob, filename)
+    form.append('json', JSON.stringify({
+      folder_id: folder,
+      description: ''
+    }))
+    const httpClient = createHttpClient(options)
+    const response = await httpClient.post('/api/files', form, {
+      params: {
+        action: 'new',
+        extendedResponse: true,
+        try_add_version: true,
+        cryptoAction: options.cryptoAction || ''
+      },
+      headers: null
+    })
+    const matches = /\((\{.*?\})\)/.exec(response.data)
+    const resData = matches && matches[1] ? JSON.parse(matches[1]) : response.data.updated[0]
+    assert.strictEqual(resData.error, undefined, JSON.stringify(resData))
+    return resData.data.file
+  }
+
+  async haveTask (task, options) {
+    const httpClient = createHttpClient(options)
+    const response = await httpClient.put('/api/tasks', task, {
+      params: { action: 'new' }
+    })
+    assert.strictEqual(response.data.error, undefined, JSON.stringify(response.data))
+    return response.data.data
+  }
+
+  /**
+   * Uploads an attachment to the specified module and object.
+   *
+   * @param {string} module - The module to attach the file to.
+   * @param {object} obj - The object to attach the file to.
+   * @param {string} file - The file to be attached.
+   * @param {object} options - The options for creating the HTTP client.
+   * @returns {Promise<object>} - The response data after attaching the file.
+   */
+  async haveAttachment (module, obj, file, options) {
+    const mapping = { tasks: 4, contacts: 7, drive: 137, infostore: 137, files: 137 }
+    const httpClient = createHttpClient(options)
+    const { blob, filename } = await createBlobFromFile(file)
+    const form = new FormData()
+    let response
+    let resData
+    if (module === 'calendar' || module === 'chronos') {
+      const index = obj.attachments ? obj.attachments.length : 0
+      obj = Object.assign({ attachments: [] }, obj)
+      obj.attachments.push({ filename, uri: `cid:file_${index}` })
+      form.append('file_' + index, blob, filename)
+      form.append('json_0', JSON.stringify(obj))
+      response = await httpClient.post('/api/chronos', form, {
+        params: {
+          action: 'update',
+          folder: obj.folder,
+          id: obj.id,
+          timestamp: moment().add(100000).valueOf()
+        }
+      })
+      const matches = /\((\{.*?\})\)/.exec(response.data)
+      resData = matches && matches[1] ? JSON.parse(matches[1]) : response.data.updated[0]
+      if (resData.data && resData.data.updated && resData.data.updated.length > 0) resData = resData.data.updated[0]
+    } else {
+      form.append('file_0', blob, filename)
+      form.append('json_0', JSON.stringify({ module: mapping[module], attached: obj.id, folder: obj.folder_id || obj.folder }))
+      response = await httpClient.post('/api/attachment', form, {
+        params: {
+          action: 'attach',
+          force_json_response: true
+        }
+      })
+      resData = response.data
+    }
+    assert.strictEqual(resData.error, undefined, JSON.stringify(resData))
+    return resData
+  }
+
+  async haveAppointment (appointment, options) {
+    const httpClient = createHttpClient(options)
+
+    if (appointment.startDate?.value?._isAMomentObject) appointment.startDate.value = appointment.startDate.value.format('YYYYMMDD[T]HHmmss')
+    if (appointment.endDate?.value?._isAMomentObject) appointment.endDate.value = appointment.endDate.value.format('YYYYMMDD[T]HHmmss')
+
+    if (appointment.startDate && !appointment.startDate.tzid) appointment.startDate.tzid = 'Europe/Berlin'
+    if (appointment.endDate && !appointment.endDate.tzid) appointment.endDate.tzid = 'Europe/Berlin'
+
+    if (!appointment.folder) {
+      const jslob = await httpClient.put('/api/jslob', ['io.ox/core'], {
+        params: { action: 'list' }
+      })
+      assert.strictEqual(jslob.data.error, undefined, JSON.stringify(jslob.data))
+      appointment.folder = jslob.data.data[0].tree.folder.calendar
+    }
+
+    if (appointment.folder && !appointment.folder.startsWith('cal://0/')) appointment.folder = `cal://0/${appointment.folder}`
+
+    const response = await httpClient.put('/api/chronos', appointment, {
+      params: {
+        action: 'new',
+        folder: appointment.folder
+      }
+    })
+    assert.strictEqual(response.data.error, undefined, JSON.stringify(response.data))
+    return response.data.data.created[0]
+  }
+
+  async importAppointment ({ sourcePath, folder = undefined }, options) {
+    const httpClient = createHttpClient(options)
+
+    // prepare folder
+    if (!folder) {
+      const jslob = await httpClient.put('/api/jslob', ['io.ox/core'], {
+        params: { action: 'list' }
+      })
+      assert.strictEqual(jslob.data.error, undefined, JSON.stringify(jslob.data))
+      folder = jslob.data.data[0].tree.folder.calendar
+    }
+
+    if (folder && !folder.startsWith('cal://0/')) folder = `cal://0/${folder}`
+
+    // prepare form upload
+    const form = new FormData()
+    const { blob } = await createBlobFromFile(sourcePath)
+    form.append('file', blob)
+
+    const response = await httpClient.post('/api/import', form, {
+      params: {
+        action: 'ICAL',
+        folder,
+        ignoreUIDs: true
+      }
+    })
+    assert.strictEqual(response.data.error, undefined, JSON.stringify(response.data))
+    return response
+  }
+
+  async haveResource (data, options) {
+    const httpClient = createHttpClient(options)
+    let response = await httpClient.put('/api/resource', data, {
+      params: { action: 'new' }
+    })
+    if (response.data.error && response.data.code === 'RES-0006') {
+      const { id } = (await httpClient.put('/api/resource', { pattern: data.name }, {
+        params: { action: 'search' }
+      })).data.data[0]
+      response = await httpClient.put('/api/resource', data, {
+        params: { action: 'update', id }
+      })
+      // middleware returns no data here
+      Object.assign(response.data.data, data, { id })
+    }
+    if (response.data.error) throw response.data
+    return response.data.data.id
+  }
+
+  async dontHaveResource (pattern, options) {
+    const httpClient = createHttpClient(options)
+    let data
+    if (typeof pattern.id !== 'undefined') {
+      data = [(await httpClient.get('/api/resource', {
+        params: { action: 'get', id: pattern.id }
+      })).data.data]
+    } else {
+      data = (await httpClient.put('/api/resource', { pattern }, {
+        params: { action: 'search' }
+      })).data.data
+    }
+
+    const timestamp = require('moment')().add(30, 'years').format('x')
+    return Promise.all(data.map(async ({ id }) => {
+      await httpClient.put('/api/resource', { id }, {
+        params: { action: 'delete', timestamp }
+      })
+      return { id, pattern }
+    }))
+  }
+
+  async haveGroup (group, options) {
+    const httpClient = createHttpClient(options)
+    const response = await httpClient.put('/api/group', group, {
+      params: { action: 'new' }
+    })
+    return response.data.data
+  }
+
+  async dontHaveGroup (name, options) {
+    const httpClient = createHttpClient(options)
+    const { data: { data } } = await httpClient.put('/api/group', '', {
+      params: {
+        action: 'all',
+        columns: '1,701'
+      }
+    })
+    const timestamp = require('moment')().add(30, 'years').format('x')
+    const test = typeof name.test === 'function' ? g => name.test(g[1]) : g => name === g[1]
+
+    const ids = data.filter(test).map(g => g[0])
+    return Promise.all(ids.map(async (id) => {
+      await httpClient.put('/api/group', { id }, {
+        params: {
+          action: 'delete',
+          timestamp
+        }
+      })
+      return { id, name }
+    }))
+  }
+
+  async haveLockedFile (data, options) {
+    const httpClient = createHttpClient(options)
+    const response = await httpClient.put('/api/files', data, {
+      params: {
+        action: 'lock',
+        id: data.id,
+        folder: data.folder_id
+      }
+    })
+    return response.data
+  }
+
+  async setMailCategories (data, options) {
+    const httpClient = createHttpClient(options)
+    const { mailId, folder, categories } = data
+    const response = await httpClient.put('/api/mail', { set_user_flags: categories }, {
+      params: {
+        action: 'update',
+        id: mailId,
+        folder
+      }
+    })
+    return response.data
+  }
+
+  async pressKeys (key) {
+    return [...key].forEach(k => this.helpers.Playwright.pressKey(k))
+  }
+
+  /**
+   * @param {object} options
+   * @param {object} [options.user]                 a user object as returned by provisioning helper, default is the "first" user
+   * @param {object} [options.additionalAccount]    an additional user that will be provisioned as the external account
+   * @param {string} [options.extension]            optional extension added to the mail address ("ext" will be translated to: $user.primary+ext@mailDomain)
+   * @param {string} [options.name]                 name of the account
+   * @param {string} [options.transport_auth]       transport authentication, default: 'none'
+   */
+  async haveMailAccount ({ user, additionalAccount, extension, name, transport_auth: transportAuth }) {
+    if (!user) user = inject().users[0]
+    if (!additionalAccount) additionalAccount = user
+    if (!transportAuth) transportAuth = 'none'
+
+    const httpClient = createHttpClient({ user })
+    const mailDomain = additionalAccount.get('primaryEmail').replace(/.*@/, '')
+    const imapServer = additionalAccount.get('imapServer') === 'localhost' ? mailDomain : additionalAccount.get('imapServer')
+    const smtpServer = additionalAccount.get('smtpServer') === 'localhost' ? mailDomain : additionalAccount.get('smtpServer')
+
+    const account = {
+      name,
+      primary_address: `${additionalAccount.get('primaryEmail').replace(/@.*/, '')}${extension ? '-' + extension : ''}@${mailDomain}`,
+      login: additionalAccount.get('imapLogin'),
+      password: additionalAccount.get('password'),
+      mail_url: `${additionalAccount.get('imapSchema')}${imapServer}:${additionalAccount.get('imapPort')}`,
+      transport_url: `${additionalAccount.get('smtpSchema')}${smtpServer}:${additionalAccount.get('smtpPort')}`,
+      transport_auth: transportAuth
+    }
+    const response = await httpClient.put('/api/account', account, {
+      params: {
+        action: 'new',
+        session
+      }
+    })
+    return response.data
+  }
+
+  /**
+   * @param {object} obj
+   * @param {number} timeout
+   * @param {object} options
+   * @returns
+   */
+  async waitForSetting (obj, timeout = 5, options = {}) {
+    const httpClient = createHttpClient(options)
+    const [moduleName] = Object.keys(obj)
+
+    async function checkSetting () {
+      const data = await httpClient.get('/api/jslob', {
+        params: {
+          id: moduleName,
+          action: 'get'
+        }
+      }).then(function (res) {
+        if (res.data.error) throw new Error(res.data.error)
+        return res.data.data
+      })
+      expect(data.tree).to.containSubset(obj[moduleName])
+    }
+
+    const startTime = Date.now()
+
+    return retryPromise(checkSetting, timeout).finally(() =>
+      output.say(`Waiting for settings to be saved took ${(Date.now() - startTime) / 1000} seconds`)
+    )
+  }
+
+  async waitForCapability (capability, timeout = 10, options = { shouldBe: true }) {
+    const httpClient = createHttpClient(options)
+
+    async function checkCapability () {
+      const data = await httpClient.get('/api/capabilities', {
+        params: {
+          action: 'get',
+          id: capability,
+          session
+        }
+      }).then(function (res) {
+        if (options.shouldBe && Object.keys(res.data).length === 0) throw new Error(res.data.error)
+        else if (!options.shouldBe && Object.keys(res.data).length !== 0) throw new Error(res.data.error)
+        return res.data
+      })
+      return data
+    }
+
+    const startTime = Date.now()
+    // We wait 2500ms to make sure that the cache was invalidated in the meantime
+    return retryPromise(checkCapability, timeout, 1000).finally(() =>
+      output.say(`Waiting for capability to be saved took ${(Date.now() - startTime) / 1000} seconds`)
+    )
+  }
+
+  async waitForApp () {
+    const { Playwright } = this.helpers
+
+    await Playwright.waitForInvisible('#background-loader.busy', 30)
+    await Playwright.waitForVisible({ css: 'html.complete' }, 10)
+  }
+
+  async copyToClipboard () {
+    const helper = this.helpers.Playwright
+    const { page } = helper
+    await page.evaluate(async () => { document.execCommand('copy') })
+  }
+
+  async getClipboardContent () {
+    const helper = this.helpers.Playwright
+    const { page, config } = helper
+    // make sure the browser is focused, might have lost the focus due to executing steps manually with 'pause()'
+    await page.bringToFront()
+    // reading the clipboard requires correct permissions
+    await helper.browserContext.grantPermissions(['clipboard-read'], { origin: config.url })
+    return await page.evaluate(async () => { return navigator.clipboard.readText() })
+  }
+}
+
+module.exports = AppSuiteHelper