@open-xchange/appsuite-codeceptjs 0.1.0

package/src/appsuiteHttpClient.js

@@ -0,0 +1,155 @@
+/**
+ * @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 querystring = require('node:querystring')
+
+const pRetry = import('p-retry').then(module => module.default)
+
+const cache = {}
+const baseURL = codecept.config.get().helpers.Playwright.url.replace(/\/$/, '')
+
+async function fetchWithRetry (url, options) {
+  return (await pRetry)(async () => {
+    const res = await fetch(url, options)
+    let data
+    if (res.headers.get('content-type')?.includes('application/json')) {
+      data = await res.json()
+    } else {
+      data = await res.text()
+    }
+    if (data.error === 'A mail account with the given E-Mail address already exists.') {
+      console.log('A mail account with the given E-Mail address already exists.')
+      return true
+    }
+    if (data.error) throw new Error(`HTTP Request Error: ${JSON.stringify(data)}`)
+
+    return { data, res }
+  }, {
+    retries: 4,
+    onFailedAttempt: error => {
+      console.error(`Attempt ${error.attemptNumber} failed. There are ${error.retriesLeft} retries left.`, error)
+    }
+  })
+}
+
+function createHttpClient (options) {
+  options = options || {}
+  let user = options.user || codecept.container.support('users')[0]
+  if (user.toJSON) user = user.toJSON()
+
+  async function request (url, options = {}) {
+    if (user) {
+      if (!cache[user.name]) await login(user)
+      options.headers = { Cookie: cache[user.name].cookies, ...options.headers }
+      if (!options.params) options.params = {}
+      options.params.session = cache[user.name].session
+    }
+    if (options.params) {
+      const urlObj = new URL(baseURL + url)
+      urlObj.search = new URLSearchParams(options.params).toString()
+      url = urlObj.toString()
+    } else {
+      url = baseURL + url
+    }
+
+    return fetchWithRetry(url, options)
+  }
+
+  return {
+    get (url, options = {}) {
+      return request(url, { ...options, method: 'GET' })
+    },
+    post (url, body, options = {}) {
+      options = { ...options, method: 'POST', headers: { ...options.headers } }
+      if (body instanceof FormData) {
+        options.body = body
+      } else {
+        // Unify content-type header
+        if (options.headers['content-type']) {
+          options.headers['Content-Type'] = options.headers['content-type']
+          delete options.headers['content-type']
+        }
+        // Set default content-type header
+        if (!options.headers['Content-Type']) options.headers['Content-Type'] = 'application/json'
+        options.body = JSON.stringify(body)
+      }
+      return request(url, options)
+    },
+    put (url, body, options = {}) {
+      options = { ...options, method: 'PUT', headers: { 'Content-Type': 'application/json', ...options.headers } }
+      if (body) options.body = JSON.stringify(body)
+      return request(url, options)
+    },
+    delete (url, options = {}) {
+      return request(url, { ...options, method: 'DELETE' })
+    }
+  }
+}
+
+/**
+ * Logs in a user and returns the session data.
+ *
+ * @param {object} user - The user object containing the name and password.
+ * @returns {Promise<object>} - A promise that resolves to the session data.
+ * @throws {Error} - If there is an error during the login process.
+ */
+async function login (user) {
+  if (cache[user.name]) {
+    const { session, cookies } = await cache[user.name]
+    try {
+      if ((await fetchWithRetry(baseURL + '/api/system', {
+        headers: { Cookie: cookies },
+        params: {
+          action: 'ping',
+          timestamp: (new Date()).getTime(),
+          session
+        }
+      })).data.data === true) {
+        return cache[user.name]
+      }
+    } catch (e) {
+      delete cache[user.name]
+    }
+  }
+
+  const { data, res } = await fetchWithRetry(baseURL + '/api/login', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/x-www-form-urlencoded; charset=utf-8'
+    },
+    body: querystring.stringify(Object.assign({
+      action: 'login',
+      client: 'open-xchange-appsuite'
+    }, user.login || {
+      name: `${user.name}${user.context.id ? '@' + user.context.id : ''}`,
+      password: user.password
+    }))
+  })
+  cache[user.name] = {
+    ...data,
+    cookies: res.headers.getSetCookie().map(item => item.split(';')[0]).join(';')
+  }
+}
+
+module.exports = {
+  createHttpClient,
+  login
+}

package/src/chai.d.ts

@@ -0,0 +1,6 @@
+declare module Chai {
+  interface Assertion {
+    accessible: void;
+  }
+}
+export {}

package/src/chai.js

@@ -0,0 +1,58 @@
+/**
+ * @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.
+ */
+
+import('chai').then(chai => {
+  const chaiSubset = require('chai-subset')
+  chai.use(chaiSubset)
+
+  chai.util.addProperty(chai.Assertion.prototype, 'accessible', function () {
+    const problems = ['\n', 'Accessibility Violations (' + this._obj.violations.length + ')', '---']
+    const pad = '\n        '
+    if (this._obj.violations.length) {
+      for (const violation of this._obj.violations) {
+        problems.push(pad + '[' + violation.impact.toUpperCase() + '] ' + violation.help + ' (ID: ' + violation.id + ')\n')
+        for (const node of violation.nodes) {
+          problems.push(node.failureSummary.split('\n').join(pad))
+          problems.push('    ' + node.target + ' => ' + node.html)
+          const relatedNodes = []
+          for (const combinedNodes of [node.all, node.any, node.none]) {
+            if (combinedNodes.length > 0) {
+              for (const any of combinedNodes) {
+                for (const relatedNode of any.relatedNodes) {
+                  relatedNodes.push('      ' + relatedNode.target + ' => ' + relatedNode.html)
+                }
+              }
+            }
+          }
+          if (relatedNodes.length > 0) problems.push(relatedNodes.join(pad))
+        }
+        problems.push(pad + '---\n')
+      }
+    }
+    this.assert(
+      this._obj.violations.length === 0,
+      `expected to have no violations:\n        ${problems.join(pad)}`,
+      'expected to have violations'
+    )
+  })
+
+  globalThis.expect = chai.expect
+  globalThis.assert = chai.assert
+})

package/src/contexts/contexts.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 created = []
+const users = require('../users/users')()
+const util = require('../util')
+const event = require('../event')
+const contextService = require('../soap/services/context')
+const utilService = require('../soap/services/util')
+
+class Context {
+  constructor ({ ctxdata, admin, auth }) {
+    this.id = ctxdata.id
+    this.ctxdata = ctxdata
+    admin.login = admin.login || admin.name
+    this.admin = admin
+    this.auth = auth
+    return new Proxy(this, {
+      get (target, prop) {
+        return prop in target ? target[prop] : target.ctxdata[prop]
+      }
+    })
+  }
+
+  async remove () {
+    const defaultContext = await contextService.getDefault()
+    // do not remove default context
+    if (defaultContext !== undefined && this.ctxdata.id === defaultContext.id) throw new Error('Cannot remove default context')
+    try {
+      await contextService.remove(this.ctxdata.id)
+    } catch (e) {
+      if (!/Context \d+ does not exist/.test(e.message)) throw new util.PropagatedError(e)
+      else console.error(e.message)
+    }
+    created.splice(0, created.length, ...created.filter(c => c !== this))
+    users.splice(0, users.length, ...users.filter(u => u.context.id !== this.id))
+    event.emit(event.provisioning.context.removed, this)
+  }
+
+  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 emptyConfig = { entries: [{ key: 'config', value: null }] }
+    this.ctxdata.userAttributes = this.ctxdata.userAttributes || emptyConfig
+    const userAttributes = this.ctxdata.userAttributes
+    const entries = userAttributes.entries = userAttributes.entries ? [].concat(userAttributes.entries) : []
+    let configEntry = entries.find(e => e.key === 'config')
+    if (!configEntry) {
+      entries.push({ key: 'config', value: {} })
+      configEntry = entries[entries.length - 1]
+    }
+    const config = configEntry.value = configEntry.value || { entries: [] }
+    const configEntries = config.entries = config.entries ? [].concat(config.entries) : []
+    let targetConfig = configEntries.find(e => e.key === key)
+    if (!targetConfig) {
+      configEntries.push({ key })
+      targetConfig = configEntries[configEntries.length - 1]
+    }
+    targetConfig.value = value
+
+    return contextService.change({ id: this.ctxdata.id, userAttributes })
+  }
+
+  hasCapability (capsToAdd) {
+    return contextService.changeCapabilities(this.id, capsToAdd, undefined)
+  }
+
+  doesntHaveCapability (capsToRemove) {
+    return contextService.changeCapabilities(this.id, undefined, capsToRemove)
+  }
+
+  hasAccessCombination (accessCombinationName) {
+    return contextService.changeModuleAccessByName(this.id, accessCombinationName)
+  }
+
+  getModuleAccess () {
+    return contextService.getModuleAccess(this.id)
+  }
+
+  hasModuleAccess (moduleAccess) {
+    return contextService.changeModuleAccess(this.id, moduleAccess)
+  }
+
+  hasQuota (maxQuota) {
+    this.ctxdata.maxQuota = maxQuota
+    return contextService.change({ id: this.id, maxQuota })
+  }
+
+  static async create (ctx = { }, adminUser = { }, auth = util.admin()) {
+    adminUser = Object.assign({
+      name: 'oxadmin',
+      password: 'secret',
+      display_name: 'context admin',
+      sur_name: 'admin',
+      given_name: 'context',
+      email1: `${adminUser.name || 'oxadmin'}@${util.mxDomain()}`,
+      primaryEmail: `${adminUser.name || 'oxadmin'}@${util.mxDomain()}`
+    }, adminUser)
+
+    let filestoreId = ctx.filestoreId
+
+    if (typeof filestoreId === 'undefined') {
+      filestoreId = await utilService.getFilestorageId()
+    }
+    const newCtx = Object.assign({ id: Number(util.userContextId()), maxQuota: -1, filestoreId }, ctx)
+    event.emit(event.provisioning.context.create, newCtx, adminUser, auth)
+    let data
+
+    try {
+      data = await contextService.create(newCtx)
+    } catch (e) {
+      newCtx.id = util.addJitter(newCtx.id)
+      return this.create(newCtx)
+    }
+
+    const context = new Context({ ctxdata: data, admin: adminUser, auth })
+    created.push(context)
+    // only provide defaults for fresh contexts
+    await context.hasAccessCombination('all')
+    event.emit(event.provisioning.context.created, context)
+    return context
+  }
+
+  static async reuse (ctx, admin = { login: 'oxadmin', password: 'secret' }, auth = util.admin()) {
+    const searchCtx = Object.assign({ id: util.userContextId() }, ctx)
+    const existingContext = created.find(c => c.id === searchCtx.id)
+    if (existingContext) return existingContext
+
+    const data = await contextService.get(searchCtx)
+
+    const context = new Context({ ctxdata: data, admin, auth })
+    return context
+  }
+
+  static async removeAll (auth) {
+    let ctxt = created.pop()
+    while (ctxt) {
+      if (auth) ctxt.auth = auth
+      await ctxt.remove()
+      ctxt = created.pop()
+    }
+    return created
+  }
+}
+
+module.exports = () => {
+  return new Proxy(created, {
+    get: function (target, prop) {
+      if (prop in target) return target[prop]
+      return Context[prop]
+    }
+  })
+}

package/src/contexts/reseller.js

@@ -0,0 +1,248 @@
+/**
+ * @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 = require('../users/reseller')()
+const util = require('../util')
+const resellerContextService = require('../soap/services/resellerContext')
+const resellerUserService = require('../soap/services/resellerUser')
+const contexts = []
+const created = []
+
+class ResellerContext {
+  constructor (ctx, admin, auth) {
+    this.ctxdata = ctx
+    this.admin = admin
+    this.auth = auth
+    this.id = ctx.id
+    this.userAttributes = ctx.userAttributes
+
+    return new Proxy(this, {
+      get (target, prop) {
+        return prop in target ? target[prop] : target.ctxdata[prop]
+      }
+    })
+  }
+
+  static async removeAll (auth) {
+    let ctx = created.pop()
+    while (ctx) {
+      if (auth) ctx.auth = auth
+      await ctx.remove()
+      ctx = created.pop()
+    }
+    return ResellerContext
+  }
+
+  async remove () {
+    await resellerContextService.remove(this.id)
+    contexts.splice(0, contexts.length, ...contexts.filter(c => c !== this))
+    created.splice(0, created.length, ...created.filter(c => c !== this))
+    users.splice(0, users.length, ...users.filter(u => u.context.id !== this.id))
+    event.emit(event.provisioning.context.removed, this)
+  }
+
+  hasCapability (capability) {
+    return this._setCapability(capability, 'true')
+  }
+
+  _setCapability (cap, value) {
+    const userAttributes = this.userAttributes || { entries: [] }
+    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 resellerContextService.change({
+      ctx: {
+        id: this.id,
+        userAttributes
+      }
+    }).then(() => {
+      return resellerContextService.get({
+        ctx: { id: this.id },
+        auth: { login: this.admin.name, password: this.admin.password }
+      })
+    }).then(r => {
+      this.ctxdata = r[0].return
+      return this
+    }).catch((err) => { throw new util.PropagatedError(err) })
+  }
+
+  doesntHaveCapability (capability) {
+    return this._setCapability(capability, false)
+  }
+
+  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 emptyConfig = { entries: [{ key: 'config', value: null }] }
+    this.ctxdata.userAttributes = this.ctxdata.userAttributes || emptyConfig
+    const userAttributes = this.ctxdata.userAttributes
+    const entries = userAttributes.entries = userAttributes.entries ? [].concat(userAttributes.entries) : []
+    let configEntry = entries.find(e => e.key === 'config')
+    if (!configEntry) {
+      entries.push({ key: 'config', value: {} })
+      configEntry = entries[entries.length - 1]
+    }
+    const config = configEntry.value = configEntry.value || { entries: [] }
+    const configEntries = config.entries = config.entries ? [].concat(config.entries) : []
+    let targetConfig = configEntries.find(e => e.key === key)
+    if (!targetConfig) {
+      configEntries.push({ key })
+      targetConfig = configEntries[configEntries.length - 1]
+    }
+    targetConfig.value = value
+
+    return resellerContextService.change({ id: this.ctxdata.id, userAttributes })
+  }
+
+  hasTaxonomy (taxonomy) {
+    // check if config exists and create config path if it does not exist
+    const userAttributes = this.ctxdata.userAttributes || {}
+    const entries = userAttributes.entries = userAttributes.entries ? [].concat(userAttributes.entries) : []
+    let taxonomyEntry = entries.find(e => e.key === 'taxonomy')
+    if (!taxonomyEntry) {
+      entries.push({ key: 'taxonomy', value: { entries: [{ key: 'types' }] } })
+      taxonomyEntry = entries[entries.length - 1]
+    }
+    const targetEntry = taxonomyEntry.value.entries.find(e => e.key === 'types')
+    targetEntry.value = taxonomy
+
+    return resellerContextService.change({ id: this.ctxdata.id, userAttributes })
+  }
+
+  hasQuota (maxQuota) {
+    this.ctxdata.maxQuota = maxQuota
+    return resellerContextService.change({ id: this.id, maxQuota })
+  }
+
+  getModuleAccess () {
+    return resellerContextService.getModuleAccess(this.id)
+  }
+
+  async hasModuleAccess (moduleAccess) {
+    return resellerContextService.changeModuleAccess(this.id, moduleAccess)
+  }
+
+  get users () {
+    return resellerUserService.listAll({
+      ctx: { id: this.ctxdata.id }
+    }).then(([{ return: list }]) => {
+      return Promise.all(
+        list.map(u =>
+          resellerUserService.get({
+            user: { id: u.id },
+            ctx: { id: this.ctxdata.id },
+            auth: this.auth
+          }).then(([{ return: user }]) => user, (err) => { throw new util.PropagatedError(err) })
+        )
+      )
+    }, (err) => { throw new util.PropagatedError(err) })
+  }
+
+  static defaultAdmin () {
+    return {
+      password: 'secret',
+      display_name: 'context admin',
+      sur_name: 'admin',
+      given_name: 'context',
+      email1: `oxadmin@${util.mxDomain()}`,
+      primaryEmail: `oxadmin@${util.mxDomain()}`
+    }
+  }
+
+  static async create (ctx = { }, adminUser = { }, auth = util.admin(), numberOfUsers = Number(process.env.PROVISIONING_USERS || 10)) {
+    ctx = Object.assign({ id: util.userContextId(), maxQuota: -1 }, ctx)
+    adminUser = Object.assign({
+      name: `${ctx.name || ctx.id}_admin`
+    }, this.defaultAdmin(), adminUser)
+    let data; let neededPrefix = ctx._auto_prefix
+    delete ctx._auto_prefix
+    ctx.name = (process.env.CONTEXT_PREFIX || '') + (ctx.name || `${ctx.id}`)
+    event.emit(event.provisioning.context.create, ctx, adminUser, auth)
+    try {
+      data = await resellerContextService.create({
+        ctx,
+        admin_user: adminUser,
+        auth
+      })
+    } catch (error) {
+      if (!neededPrefix && error.message.match(/name must beginn with ([^ ;]+)/)) {
+        const oldName = ctx.name
+        delete ctx.name
+        neededPrefix = error.message.match(/name must beginn with ([^ ;]+)/)[1]
+        return ResellerContext.create(Object.assign({
+          _auto_prefix: true,
+          name: `${neededPrefix}${oldName}`
+        }, ctx), adminUser, auth)
+      }
+      if (error.message.match(/already exists/)) {
+        const id = String(util.addJitter(Number.parseInt(ctx.id, 10)))
+        return ResellerContext.create(Object.assign({}, ctx, { name: ctx.name.replace(/_\d+/, `_${id}`), id }))
+      }
+      throw new util.PropagatedError(error)
+    }
+    const index = created.push(new ResellerContext(data, adminUser, auth)) - 1
+    event.emit(event.provisioning.context.created, created[index])
+
+    for (let i = 0; i < numberOfUsers; i++) {
+      // @ts-ignore
+      await users.create(users.getRandom(), created[index], true)
+    }
+
+    return created[index]
+  }
+
+  static async reuse (ctx, adminUser = ResellerContext.defaultAdmin(), auth = util.admin()) {
+    const existingContext = created.find(c => (c.name === ctx.name) || (c.id === ctx.id) || (new RegExp(`_${ctx.id}$`).test(c.name)))
+    if (existingContext) return existingContext
+
+    await ResellerContext.fetchContexts()
+    const remoteCtx = contexts.find(c => (c.name === ctx.name) || (c.id === ctx.id) || (new RegExp(`_${ctx.id}$`).test(c.name)))
+    if (!remoteCtx.auth) remoteCtx.auth = auth
+    if (!remoteCtx.admin_user) remoteCtx.admin_user = adminUser
+    return remoteCtx
+  }
+
+  static async all () {
+    if (contexts.length === 0) await this.fetchContexts()
+    return created.concat(contexts)
+  }
+
+  static async fetchContexts () {
+    const list = await resellerContextService.listAll()
+      .catch((err) => { throw new util.PropagatedError(err) })
+    contexts.splice(0, contexts.length)
+    contexts.push.apply(contexts, list.map(c => new ResellerContext(c)))
+  }
+}
+
+// can't return the class directly, because codecept tries to execute functions
+module.exports = function () {
+  ResellerContext.fetchContexts()
+  return new Proxy(created, {
+    // act like an array if an index is being used
+    get (target, prop) {
+      if (prop in target) return target[prop]
+      return ResellerContext[prop]
+    }
+  })
+}

package/src/contexts.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 = './contexts/reseller'
+} else {
+  moduleToLoad = './contexts/contexts'
+}
+
+module.exports = require(moduleToLoad)