@open-xchange/appsuite-codeceptjs 0.1.0

package/src/soap/soap.js

@@ -0,0 +1,172 @@
+/**
+ * @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 { performance, PerformanceObserver } = require('node:perf_hooks')
+const SOAP = require('soap')
+const dotenv = require('dotenv')
+
+let AbortError
+const pRetry = import('p-retry').then(module => {
+  AbortError = module.AbortError
+  return module.default
+})
+
+dotenv.config({ path: '.env' })
+dotenv.config({ path: '.env.defaults' })
+
+// This flag enables debug output including timing information.
+const debug = process.env.DEBUG_SOAP === 'true'
+
+// This URL is used to create the SOAP client.
+const provisioningUrl = String(process.env.PROVISIONING_URL).replace(/\/$/, '')
+
+// This user is used to authenticate against the provisioning API.
+const provisioningAuth = {
+  auth: {
+    login: process.env.E2E_ADMIN_USER,
+    password: process.env.E2E_ADMIN_PW
+  }
+}
+
+/**
+ * This code creates a PerformanceObserver instance which asynchronously observes
+ * performance measurement events. It logs the name of the event (which is the name
+ * of the SOAP method in this context) and the time it took to execute in milliseconds.
+ *
+ * This is used for performance tracking of the SOAP methods.
+ * @see https://nodejs.org/api/perf_hooks.html
+ * @params {PerformanceObserverEntryList} items The list of performance entries.
+ * @returns {void}
+ */
+const obs = new PerformanceObserver((items) => {
+  items.getEntries().forEach((entry) => {
+    if (debug) console.log(`${entry.name} took ${Math.round(entry.duration)}ms`)
+  })
+})
+obs.observe({ entryTypes: ['measure'] })
+
+async function logSoapError (e) {
+  console.error(e?.originalError?.root?.Envelope?.Body?.Fault?.faultstring || e.message)
+}
+
+/**
+ * This function checks if the specified error should abort the retry.
+ * @param {Error} error The error to check.
+ * @returns {boolean} True if the error should abort the retry, false otherwise.
+ **/
+function shouldAbortRetry (error) {
+  try {
+    const fault = error.root.Envelope.Body.Fault
+    const details = fault.detail
+    const blockedFaultStrings = [
+      /Context \d+ already exists/,
+      /Authentication failed/,
+      /Context \d+ does not exist/,
+      /CloudPluginException: username .* already exists/,
+      /CloudPluginException: context name must begin/,
+      /The displayname is already used/,
+      /already exists in this context/,
+      /Shared Domain already exists/,
+      /Shared Domain already in use/,
+      /No such user/
+    ]
+    const blockedExceptions = [
+      'ContextExistsException',
+      'InvalidCredentialsException',
+      'NoSuchContextException'
+    ]
+    // return "details object contains any of the blocked items"
+    return blockedFaultStrings.some(msg => msg.test(fault.faultstring)) ||
+      blockedExceptions.some(exception => Object.hasOwnProperty.call(details, exception))
+  } catch (e) {
+    // some other error which is never blocked
+    return false
+  }
+}
+
+/**
+ * This function creates a SOAP client for the specified service type.
+ * @param {string} type The name of the service type.
+ * @returns {Promise<Object>} The SOAP client.
+ */
+async function createClientAsync (type) {
+  const startMark = `${type}-start`
+  const endMark = `${type}-end`
+  performance.mark(startMark)
+  const endpoint = `${provisioningUrl}/webservices/${type}`
+  const url = `${endpoint}/?wsdl`
+  const client = await SOAP.createClientAsync(url, {
+    endpoint,
+    suppressStack: true,
+    wsdl_options: {
+      forever: true
+    },
+    gzip: true
+  })
+
+  // https://stackoverflow.com/questions/30740415/namespace-for-array-field-in-node-soap-client-node-js
+  client.wsdl.definitions.xmlns.ns1 = 'http://dataobjects.soap.admin.openexchange.com/xsd'
+  client.wsdl.xmlnsInEnvelope = client.wsdl._xmlnsMap()
+  performance.mark(endMark)
+  performance.measure(`  ⏱ SOAP: ${type} -> createClientAsync`, startMark, endMark)
+
+  // This proxy effectively adds error handling, authentication and performance measurements to all methods of the SOAP client.
+  return new Proxy(client, {
+    get (target, prop, receiver) {
+      const origMethod = Reflect.get(target, prop, receiver)
+      if (typeof origMethod === 'function') {
+        return async function (options, clientOptions, ...args) {
+          const startMark = `${prop}-start`
+          const endMark = `${prop}-end`
+          performance.mark(startMark)
+          const soapOptions = { ...provisioningAuth, ...options }
+          if (soapOptions.auth) {
+            // only send login and password instead of complete admin object.
+            // this can fail because of ambiguous namespacing
+            soapOptions.auth = { login: soapOptions.auth.login, password: soapOptions.auth.password }
+          }
+
+          const result = await (await pRetry)(() => origMethod.apply(this, [soapOptions, { timeout: 10000, ...clientOptions }, ...args]), {
+            retries: 3,
+            onFailedAttempt: async error => {
+              if (shouldAbortRetry(error)) throw new (await AbortError)(error)
+              console.log(`Attempt ${error.attemptNumber} failed. There are ${error.retriesLeft} retries left.`)
+            }
+          }).catch(e => {
+            const soapError = e?.originalError?.root?.Envelope?.Body?.Fault
+            throw new Error(soapError?.faultstring || e.message)
+          })
+          performance.mark(endMark)
+          performance.measure(`  ⏱ SOAP: ${type} -> ${prop}`, startMark, endMark)
+          // Return only the first result from the SOAP method call, as we don't need the SOAP envelope and other stuff.
+          if (!result || !result[0]) return
+          return result[0]?.return
+        }
+      } else {
+        return origMethod
+      }
+    }
+  })
+}
+
+module.exports = {
+  createClientAsync,
+  logSoapError
+}

package/src/users/reseller.js

@@ -0,0 +1,233 @@
+/**
+ * @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 event = require('../event')
+
+const users = []
+const usersToRemove = []
+const preprovisionedUsers = []
+const util = require('../util')
+const short = require('short-uuid')
+const resellerUserService = require('../soap/services/resellerUser')
+const oxaasService = require('../soap/services/oxaas')
+
+class User {
+  constructor (opt) {
+    this.userdata = opt.user
+    this.context = opt.context
+    this.session = {}
+    this.userAttributes = this.userdata.userAttributes || {}
+    return new Proxy(this, {
+      get (target, prop) {
+        return prop in target ? target[prop] : target.userdata[prop]
+      }
+    })
+  }
+
+  async remove () {
+    await resellerUserService.remove(
+      this.context.id,
+      this.get('id')
+    ).catch(async (err) => {
+      if (/No such user/.test(err.faultstring)) return // ignore
+      throw new util.PropagatedError(err)
+    })
+    users.splice(0, users.length, ...users.filter(u => u !== this))
+    event.emit(event.provisioning.user.removed, this)
+  }
+
+  async hasConfig (key, value) {
+    // Config structure is the following { userAttributes: { entries: [{ key: 'config', value: { entries: [{ key: 'key', value: value }] }}]} }
+    // Note that the soap lib will replace arrays with a single element by that element
+
+    // check if config exists and create config path if it does not exist
+    const userAttributes = this.userdata.userAttributes = this.userdata.userAttributes || {}
+    const entries = userAttributes.entries = userAttributes.entries ? [].concat(userAttributes.entries) : []
+    let configEntry = entries.find(entry => entry.key === 'config')
+    if (!configEntry) {
+      entries.push({ key: 'config', value: {} })
+      configEntry = entries[entries.length - 1]
+    }
+    const config = configEntry.value
+    const configEntries = config.entries = config.entries ? [].concat(config.entries) : []
+    let targetConfig = configEntries.find(entry => entry.key === key)
+    if (!targetConfig) {
+      configEntries.push({ key })
+      targetConfig = configEntries[configEntries.length - 1]
+    }
+    targetConfig.value = value
+
+    return resellerUserService.change(this.context, this.userdata)
+  }
+
+  hasAccessCombination (accessCombinationName) {
+    return resellerUserService.changeByModuleAccessName(this.context, this.get('id'), accessCombinationName)
+  }
+
+  getModuleAccess () {
+    return resellerUserService.getModuleAccess(this.context, this.get('id'))
+  }
+
+  async hasModuleAccess (moduleAccess) {
+    const currentAccess = await this.getModuleAccess()
+    return resellerUserService.changeByModuleAccess(this.context, this.get('id'), currentAccess, moduleAccess)
+  }
+
+  hasQuota (quota) {
+    return oxaasService.setMailQuota({
+      ctxid: this.context.id,
+      usrid: this.get('id'),
+      quota,
+      creds: util.admin()
+    }).catch((err) => { throw new util.PropagatedError(err) })
+  }
+
+  hasAlias (alias) {
+    // See if this alias has already been declared
+    if (this.userdata.aliases.includes(alias)) {
+      return
+    }
+    // If not, add it and save
+    this.userdata.aliases.push(alias)
+    const userdata = { id: this.get('id'), aliases: this.userdata.aliases }
+    return resellerUserService.change(this.context, userdata)
+  }
+
+  hasCapability (capability) {
+    this._setCapability(capability, true)
+  }
+
+  _setCapability (cap, value) {
+    const userAttributes = this.userAttributes
+    const configMap = userAttributes.entries.find(entry => entry.key === 'config') || { key: 'config' }
+    configMap.value = configMap.value || { entries: [] }
+    configMap.value.entries.push({ key: `com.openexchange.capability.${cap}`, value })
+
+    return resellerUserService.change(this.context, { id: this.get('id'), userAttributes })
+  }
+
+  doesntHaveCapability (capability) {
+    this._setCapability(capability, false)
+  }
+
+  get (key) {
+    return this.userdata[key]
+  }
+
+  // eslint-disable-next-line camelcase
+  static getRandom ({ name = 'test.user', password = util.getDefaultUserPassword(), sur_name = '', given_name = 'User' } = {}) {
+    const id = short.generate().slice(0, 9).toLowerCase()
+    // eslint-disable-next-line camelcase
+    if (!sur_name) sur_name = id
+    return {
+      name: `${name}-${id}`,
+      password,
+      // eslint-disable-next-line camelcase
+      sur_name,
+      // eslint-disable-next-line camelcase
+      given_name
+    }
+  }
+
+  get login () {
+    const { name, password } = this.userdata
+    return { name, password }
+  }
+
+  static async create (user = User.getRandom(), ctx = {}, preprovisioned = false) {
+    if (preprovisionedUsers.length > 0 && !preprovisioned) {
+      let index = 0
+      if (ctx.id) index = preprovisionedUsers.findIndex(u => u.context.id === ctx.id)
+      if (index !== -1) {
+        const currentUser = preprovisionedUsers[index]
+        preprovisionedUsers.splice(index, 1)
+        usersToRemove.push(currentUser)
+        users.push(currentUser)
+        return currentUser
+      }
+    }
+
+    if (!ctx.id || !ctx.name) {
+      const contexts = require('../contexts/reseller')()
+      // @ts-ignore
+      ctx = contexts[0] || await contexts.create()
+    }
+    const usrdata = {
+      ...{
+        primaryEmail: `${user.name}@${util.mxDomain()}`,
+        display_name: user.name,
+        sur_name: user.sur_name,
+        given_name: user.given_name,
+        name: user.name,
+        email1: `${user.name}@${util.mxDomain()}`,
+        password: user.password,
+        imapLogin: user.name,
+        imapServer: user.imapServer || util.imapServer(),
+        smtpServer: user.smtpServer || util.smtpServer()
+      },
+      ...user
+    }
+    event.emit(event.provisioning.user.create, usrdata, ctx)
+
+    let data
+    try {
+      data = await resellerUserService.createByModuleAccessName(ctx, usrdata)
+    } catch (error) {
+      if (!/FLD-0038/.test(error.faultstring)) {
+        throw new util.PropagatedError(error)
+      }
+      return new Promise(function (resolve, reject) {
+        setTimeout(function () {
+          User.create(user, ctx).then(resolve, reject)
+        }, 1000)
+      })
+    }
+    const newUser = new User({ user: data, context: ctx })
+    if (!preprovisioned) users.push(newUser)
+    if (preprovisioned) preprovisionedUsers.push(newUser)
+    event.emit(event.provisioning.user.created, newUser)
+    return newUser
+  }
+
+  change (userdata) {
+    return resellerUserService.change(this.context, userdata)
+  }
+
+  static async removeAll () {
+    // Make sure to also remove the preprovisioned users
+    users.splice(0, 0, ...usersToRemove.splice(0, usersToRemove.length))
+    let user = users.pop()
+    while (user) {
+      await user.remove()
+      user = users.pop()
+    }
+    return users
+  }
+}
+
+module.exports = () => {
+  return new Proxy(users, {
+    // act like an array if an index is being used
+    get (target, prop) {
+      if (prop in target) { return target[prop] }
+      return User[prop]
+    }
+  })
+}

package/src/users/users.js

@@ -0,0 +1,183 @@
+/**
+ * @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.
+ */
+
+/* eslint-disable camelcase */
+const event = require('../event')
+
+const users = []
+const util = require('../util')
+const short = require('short-uuid')
+const userService = require('../soap/services/user')
+
+class User {
+  constructor (opt) {
+    this.userdata = opt.user
+    this.context = opt.context
+    return new Proxy(this, {
+      get (target, prop) {
+        return prop in target ? target[prop] : target.userdata[prop]
+      }
+    })
+  }
+
+  async remove () {
+    await userService.remove(this.context, this.get('id'))
+    users.splice(0, users.length, ...users.filter(u => u !== this))
+    event.emit(event.provisioning.user.removed, this)
+  }
+
+  async hasConfig (key, value) {
+    // Config structure is the following { userAttributes: { entries: [{ key: 'config', value: { entries: [{ key: 'key', value: value }] }}]} }
+    // Note that the soap lib will replace arrays with a single element by that element
+
+    // check if config exists and create config path if it does not exist
+    const userAttributes = this.userdata.userAttributes = this.userdata.userAttributes || {}
+    const entries = userAttributes.entries = userAttributes.entries ? [].concat(userAttributes.entries) : []
+    let configEntry = entries.find(entry => entry.key === 'config')
+    if (!configEntry) {
+      entries.push({ key: 'config', value: {} })
+      configEntry = entries[entries.length - 1]
+    }
+    const config = configEntry.value
+    const configEntries = config.entries = config.entries ? [].concat(config.entries) : []
+    let targetConfig = configEntries.find(entry => entry.key === key)
+    if (!targetConfig) {
+      configEntries.push({ key })
+      targetConfig = configEntries[configEntries.length - 1]
+    }
+    targetConfig.value = value
+
+    return userService.change(this.context, this.userdata)
+  }
+
+  hasAlias (alias) {
+    // See if this alias has already been declared
+    if (this.userdata.aliases.includes(alias)) return
+    // If not, add it and save
+    this.userdata.aliases.push(alias)
+    return userService.change(this.context, this.userdata)
+  }
+
+  doesntHaveAlias (alias) {
+    const index = this.userdata.aliases.indexOf(alias)
+    // See if this alias has already been declared
+    if (index < 0) return
+    this.userdata.aliases.splice(index)
+    return userService.change(this.context, this.userdata)
+  }
+
+  hasAccessCombination (accessCombinationName) {
+    return userService.changeByModuleAccessName(this.context, this.get('id'), accessCombinationName)
+  }
+
+  getModuleAccess () {
+    return userService.getModuleAccess(this.context, this.get('id'))
+  }
+
+  async hasModuleAccess (moduleAccess) {
+    const currentAccess = await this.getModuleAccess()
+    return userService.changeByModuleAccess(this.context, this.get('id'), currentAccess, moduleAccess)
+  }
+
+  hasCapability (capsToAdd) {
+    return userService.changeCapabilities(this.context, this.get('id'), capsToAdd)
+  }
+
+  doesntHaveCapability (capsToRemove) {
+    return userService.changeCapabilities(this.context, this.get('id'), undefined, capsToRemove)
+  }
+
+  get login () {
+    return `${this.get('name')}@${this.context.id}`
+  }
+
+  get (key) {
+    return this.userdata[key]
+  }
+
+  toJSON () {
+    return {
+      context: { ...this.context },
+      ...this.userdata
+    }
+  }
+
+  static getRandom ({ name = 'test.user', password = util.getDefaultUserPassword(), sur_name = '', given_name = 'User' } = {}) {
+    const id = short.generate().slice(0, 9).toLowerCase()
+    // eslint-disable-next-line camelcase
+    if (!sur_name) sur_name = id
+    if (name === 'test.user') name = `${name}-${id}`
+    const domain = util.mxDomain()
+    return {
+      name,
+      primaryEmail: `${name}@${domain}`,
+      email1: `${name}@${domain}`,
+      password,
+      sur_name,
+      given_name
+    }
+  }
+
+  static async create (user = this.getRandom(), ctx = {}) {
+    const usrdata = Object.assign({
+      display_name: user.name,
+      imapLogin: user.name,
+      imapServer: util.imapServer(),
+      smtpServer: util.smtpServer()
+    }, user)
+    event.emit(event.provisioning.user.create, usrdata, ctx)
+    const contexts = require('../contexts/contexts')()
+    let userContext
+    try {
+      // @ts-ignore
+      userContext = await contexts.reuse(ctx, ctx.admin, ctx.auth)
+    } catch (e) {
+      // @ts-ignore
+      userContext = await contexts.create(Object.assign({ maxQuota: 1000 }, ctx))
+    }
+    const data = await userService.create(userContext, usrdata)
+    const index = users.push(new User({ user: data, context: userContext })) - 1
+    event.emit(event.provisioning.user.created, users[index])
+    return users[index]
+  }
+
+  change (userdata) {
+    return userService.change(this.context, userdata)
+  }
+
+  static async removeAll () {
+    let user = users.pop()
+    while (user) {
+      await user.remove()
+      user = users.pop()
+    }
+    return users
+  }
+}
+
+module.exports = () => {
+  return new Proxy(users, {
+    // act like an array if an index is being used
+    get (target, prop) {
+      if (prop in target) { return target[prop] }
+      return User[prop]
+    }
+  })
+}

package/src/users.js

@@ -0,0 +1,29 @@
+/**
+ * @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.
+ */
+
+let moduleToLoad
+
+if (process.env.PROVISIONING_API === 'reseller') {
+  moduleToLoad = './users/reseller'
+} else {
+  moduleToLoad = './users/users'
+}
+
+module.exports = require(moduleToLoad)