@budibase/worker 1.2.58 → 1.3.1

package/scripts/load/users.js

@@ -1,97 +0,0 @@
-// get the JWT secret etc
-require("../../src/environment")
-require("@budibase/backend-core").init()
-const {
-  getProdAppID,
-  generateGlobalUserID,
-} = require("@budibase/backend-core/db")
-const { doInTenant, getGlobalDB } = require("@budibase/backend-core/tenancy")
-const users = require("../../src/sdk/users")
-const { publicApiUserFix } = require("../../src/utilities/users")
-const { hash } = require("@budibase/backend-core/utils")
-
-const USER_LOAD_NUMBER = 10000
-const BATCH_SIZE = 200
-const PASSWORD = "test"
-const TENANT_ID = "default"
-
-const APP_ID = process.argv[2]
-
-const words = [
-  "test",
-  "testing",
-  "budi",
-  "mail",
-  "age",
-  "risk",
-  "load",
-  "uno",
-  "arm",
-  "leg",
-  "pen",
-  "glass",
-  "box",
-  "chicken",
-  "bottle",
-]
-
-if (!APP_ID) {
-  console.error("Must supply app ID as first CLI option!")
-  process.exit(-1)
-}
-
-const WORD_1 = words[Math.floor(Math.random() * words.length)]
-const WORD_2 = words[Math.floor(Math.random() * words.length)]
-let HASHED_PASSWORD
-
-function generateUser(count) {
-  return {
-    _id: generateGlobalUserID(),
-    password: HASHED_PASSWORD,
-    email: `${WORD_1}${count}@${WORD_2}.com`,
-    roles: {
-      [getProdAppID(APP_ID)]: "BASIC",
-    },
-    status: "active",
-    forceResetPassword: false,
-    firstName: "John",
-    lastName: "Smith",
-  }
-}
-
-async function run() {
-  HASHED_PASSWORD = await hash(PASSWORD)
-  return doInTenant(TENANT_ID, async () => {
-    const db = getGlobalDB()
-    for (let i = 0; i < USER_LOAD_NUMBER; i += BATCH_SIZE) {
-      let userSavePromises = []
-      for (let j = 0; j < BATCH_SIZE; j++) {
-        // like the public API
-        const ctx = publicApiUserFix({
-          request: {
-            body: generateUser(i + j),
-          },
-        })
-        userSavePromises.push(
-          users.save(ctx.request.body, {
-            hashPassword: false,
-            requirePassword: true,
-            bulkCreate: true,
-          })
-        )
-      }
-      const allUsers = await Promise.all(userSavePromises)
-      await db.bulkDocs(allUsers)
-      console.log(`${i + BATCH_SIZE} users have been created.`)
-    }
-  })
-}
-
-run()
-  .then(() => {
-    console.log(`Generated ${USER_LOAD_NUMBER} users!`)
-  })
-  .catch(err => {
-    console.error("Failed for reason: ", err)
-    process.exit(-1)
-  })

package/src/api/routes/tests/users.spec.js

@@ -1,390 +0,0 @@
-jest.mock("nodemailer")
-const { config, request, mocks, structures } = require("../../../tests")
-const sendMailMock = mocks.email.mock()
-const { events } = require("@budibase/backend-core")
-describe("/api/global/users", () => {
-
-  beforeAll(async () => {
-    await config.beforeAll()
-  })
-
-  afterAll(async () => {
-    await config.afterAll()
-  })
-
-  const sendUserInvite = async () => {
-    await config.saveSmtpConfig()
-    await config.saveSettingsConfig()
-    const res = await request
-      .post(`/api/global/users/invite`)
-      .send({
-        email: "invite@test.com",
-      })
-      .set(config.defaultHeaders())
-      .expect("Content-Type", /json/)
-      .expect(200)
-
-    const emailCall = sendMailMock.mock.calls[0][0]
-    // after this URL there should be a code
-    const parts = emailCall.html.split("http://localhost:10000/builder/invite?code=")
-    const code = parts[1].split("\"")[0].split("&")[0]
-    return { code, res }
-  }
-
-  it("should be able to generate an invitation", async () => {
-    const { code, res } = await sendUserInvite()
-
-    expect(res.body).toEqual({ message: "Invitation has been sent." })
-    expect(sendMailMock).toHaveBeenCalled()
-    expect(code).toBeDefined()
-    expect(events.user.invited).toBeCalledTimes(1)
-  })
-
-  it("should be able to create new user from invite", async () => {
-    const { code } = await sendUserInvite()
-
-    const res = await request
-      .post(`/api/global/users/invite/accept`)
-      .send({
-        password: "newpassword",
-        inviteCode: code,
-      })
-      .expect("Content-Type", /json/)
-      .expect(200)
-    expect(res.body._id).toBeDefined()
-    const user = await config.getUser("invite@test.com")
-    expect(user).toBeDefined()
-    expect(user._id).toEqual(res.body._id)
-    expect(events.user.inviteAccepted).toBeCalledTimes(1)
-    expect(events.user.inviteAccepted).toBeCalledWith(user)
-  })
-
-  const createUser = async (user) => {
-    const existing = await config.getUser(user.email)
-    if (existing) {
-      await deleteUser(existing._id)
-    }
-    return saveUser(user)
-  }
-
-  const updateUser = async (user) => {
-    const existing = await config.getUser(user.email)
-    user._id = existing._id
-    return saveUser(user)
-  }
-
-  const saveUser = async (user) => {
-    const res = await request
-      .post(`/api/global/users`)
-      .send(user)
-      .set(config.defaultHeaders())
-      .expect("Content-Type", /json/)
-      .expect(200)
-    return res.body
-  }
-
-
-  const bulkCreateUsers = async (users) => {
-    const res = await request
-      .post(`/api/global/users/bulkCreate`)
-      .send(users)
-      .set(config.defaultHeaders())
-      .expect("Content-Type", /json/)
-      .expect(200)
-    return res.body
-  }
-
-  const bulkDeleteUsers = async (users) => {
-    const res = await request
-      .post(`/api/global/users/bulkDelete`)
-      .send(users)
-      .set(config.defaultHeaders())
-      .expect("Content-Type", /json/)
-      .expect(200)
-    return res.body
-  }
-
-
-
-  const deleteUser = async (email) => {
-    const user = await config.getUser(email)
-    if (user) {
-      await request
-        .delete(`/api/global/users/${user._id}`)
-        .set(config.defaultHeaders())
-        .expect("Content-Type", /json/)
-        .expect(200)
-    }
-  }
-
-  describe("create", () => {
-    it("should be able to create a basic user", async () => {
-      jest.clearAllMocks()
-      const user = structures.users.user({ email: "basic@test.com" })
-      await createUser(user)
-
-      expect(events.user.created).toBeCalledTimes(1)
-      expect(events.user.updated).not.toBeCalled()
-      expect(events.user.permissionBuilderAssigned).not.toBeCalled()
-      expect(events.user.permissionAdminAssigned).not.toBeCalled()
-    })
-
-    it("should be able to bulkCreate users with different permissions", async () => {
-      jest.clearAllMocks()
-      const builder = structures.users.builderUser({ email: "bulkbasic@test.com" })
-      const admin = structures.users.adminUser({ email: "bulkadmin@test.com" })
-      const user = structures.users.user({ email: "bulkuser@test.com" })
-
-      let toCreate = { users: [builder, admin, user], groups: [] }
-      await bulkCreateUsers(toCreate)
-
-      expect(events.user.created).toBeCalledTimes(3)
-      expect(events.user.permissionAdminAssigned).toBeCalledTimes(1)
-      expect(events.user.permissionBuilderAssigned).toBeCalledTimes(1)
-    })
-
-
-    it("should be able to create an admin user", async () => {
-      jest.clearAllMocks()
-      const user = structures.users.adminUser({ email: "admin@test.com" })
-      await createUser(user)
-
-      expect(events.user.created).toBeCalledTimes(1)
-      expect(events.user.updated).not.toBeCalled()
-      expect(events.user.permissionBuilderAssigned).not.toBeCalled()
-      expect(events.user.permissionAdminAssigned).toBeCalledTimes(1)
-    })
-
-    it("should be able to create a builder user", async () => {
-      jest.clearAllMocks()
-      const user = structures.users.builderUser({ email: "builder@test.com" })
-      await createUser(user)
-
-      expect(events.user.created).toBeCalledTimes(1)
-      expect(events.user.updated).not.toBeCalled()
-      expect(events.user.permissionBuilderAssigned).toBeCalledTimes(1)
-      expect(events.user.permissionAdminAssigned).not.toBeCalled()
-    })
-
-    it("should be able to assign app roles", async () => {
-      jest.clearAllMocks()
-      const user = structures.users.user({ email: "assign-roles@test.com" })
-      user.roles = {
-        "app_123": "role1",
-        "app_456": "role2",
-      }
-
-      await createUser(user)
-      const savedUser = await config.getUser(user.email)
-
-      expect(events.user.created).toBeCalledTimes(1)
-      expect(events.user.updated).not.toBeCalled()
-      expect(events.role.assigned).toBeCalledTimes(2)
-      expect(events.role.assigned).toBeCalledWith(savedUser, "role1")
-      expect(events.role.assigned).toBeCalledWith(savedUser, "role2")
-    })
-  })
-
-  describe("update", () => {
-    it("should be able to update a basic user", async () => {
-      let user = structures.users.user({ email: "basic-update@test.com" })
-      await createUser(user)
-      jest.clearAllMocks()
-
-      await updateUser(user)
-
-      expect(events.user.created).not.toBeCalled()
-      expect(events.user.updated).toBeCalledTimes(1)
-      expect(events.user.permissionBuilderAssigned).not.toBeCalled()
-      expect(events.user.permissionAdminAssigned).not.toBeCalled()
-      expect(events.user.passwordForceReset).not.toBeCalled()
-    })
-
-    it("should be able to force reset password", async () => {
-      let user = structures.users.user({ email: "basic-password-update@test.com" })
-      await createUser(user)
-      jest.clearAllMocks()
-
-      user.forceResetPassword = true
-      user.password = "tempPassword"
-      await updateUser(user)
-
-      expect(events.user.created).not.toBeCalled()
-      expect(events.user.updated).toBeCalledTimes(1)
-      expect(events.user.permissionBuilderAssigned).not.toBeCalled()
-      expect(events.user.permissionAdminAssigned).not.toBeCalled()
-      expect(events.user.passwordForceReset).toBeCalledTimes(1)
-    })
-
-    it("should be able to update a basic user to an admin user", async () => {
-      let user = structures.users.user({ email: "basic-update-admin@test.com" })
-      await createUser(user)
-      jest.clearAllMocks()
-
-      await updateUser(structures.users.adminUser(user))
-
-      expect(events.user.created).not.toBeCalled()
-      expect(events.user.updated).toBeCalledTimes(1)
-      expect(events.user.permissionBuilderAssigned).not.toBeCalled()
-      expect(events.user.permissionAdminAssigned).toBeCalledTimes(1)
-    })
-
-    it("should be able to update a basic user to a builder user", async () => {
-      let user = structures.users.user({ email: "basic-update-builder@test.com" })
-      await createUser(user)
-      jest.clearAllMocks()
-
-      await updateUser(structures.users.builderUser(user))
-
-      expect(events.user.created).not.toBeCalled()
-      expect(events.user.updated).toBeCalledTimes(1)
-      expect(events.user.permissionBuilderAssigned).toBeCalledTimes(1)
-      expect(events.user.permissionAdminAssigned).not.toBeCalled()
-    })
-
-    it("should be able to update an admin user to a basic user", async () => {
-      let user = structures.users.adminUser({ email: "admin-update-basic@test.com" })
-      await createUser(user)
-      jest.clearAllMocks()
-
-      user.admin.global = false
-      await updateUser(user)
-
-      expect(events.user.created).not.toBeCalled()
-      expect(events.user.updated).toBeCalledTimes(1)
-      expect(events.user.permissionAdminRemoved).toBeCalledTimes(1)
-      expect(events.user.permissionBuilderRemoved).not.toBeCalled()
-    })
-
-    it("should be able to update an builder user to a basic user", async () => {
-      let user = structures.users.builderUser({ email: "builder-update-basic@test.com" })
-      await createUser(user)
-      jest.clearAllMocks()
-
-      user.builder.global = false
-      await updateUser(user)
-
-      expect(events.user.created).not.toBeCalled()
-      expect(events.user.updated).toBeCalledTimes(1)
-      expect(events.user.permissionBuilderRemoved).toBeCalledTimes(1)
-      expect(events.user.permissionAdminRemoved).not.toBeCalled()
-    })
-
-    it("should be able to assign app roles", async () => {
-      const user = structures.users.user({ email: "assign-roles-update@test.com" })
-      await createUser(user)
-      jest.clearAllMocks()
-
-      user.roles = {
-        "app_123": "role1",
-        "app_456": "role2",
-      }
-      await updateUser(user)
-      const savedUser = await config.getUser(user.email)
-
-      expect(events.user.created).not.toBeCalled()
-      expect(events.user.updated).toBeCalledTimes(1)
-      expect(events.role.assigned).toBeCalledTimes(2)
-      expect(events.role.assigned).toBeCalledWith(savedUser, "role1")
-      expect(events.role.assigned).toBeCalledWith(savedUser, "role2")
-    })
-
-    it("should be able to unassign app roles", async () => {
-      const user = structures.users.user({ email: "unassign-roles@test.com" })
-      user.roles = {
-        "app_123": "role1",
-        "app_456": "role2",
-      }
-      await createUser(user)
-      jest.clearAllMocks()
-
-      user.roles = {}
-      await updateUser(user)
-      const savedUser = await config.getUser(user.email)
-
-      expect(events.user.created).not.toBeCalled()
-      expect(events.user.updated).toBeCalledTimes(1)
-      expect(events.role.unassigned).toBeCalledTimes(2)
-      expect(events.role.unassigned).toBeCalledWith(savedUser, "role1")
-      expect(events.role.unassigned).toBeCalledWith(savedUser, "role2")
-    })
-
-    it("should be able to update existing app roles", async () => {
-      const user = structures.users.user({ email: "update-roles@test.com" })
-      user.roles = {
-        "app_123": "role1",
-        "app_456": "role2",
-      }
-      await createUser(user)
-      jest.clearAllMocks()
-
-      user.roles = {
-        "app_123": "role1",
-        "app_456": "role2-edit",
-      }
-      await updateUser(user)
-      const savedUser = await config.getUser(user.email)
-
-      expect(events.user.created).not.toBeCalled()
-      expect(events.user.updated).toBeCalledTimes(1)
-      expect(events.role.unassigned).toBeCalledTimes(1)
-      expect(events.role.unassigned).toBeCalledWith(savedUser, "role2")
-      expect(events.role.assigned).toBeCalledTimes(1)
-      expect(events.role.assigned).toBeCalledWith(savedUser, "role2-edit")
-    })
-  })
-
-  describe("destroy", () => {
-    it("should be able to destroy a basic user", async () => {
-      let user = structures.users.user({ email: "destroy@test.com" })
-      await createUser(user)
-      jest.clearAllMocks()
-
-      await deleteUser(user.email)
-
-      expect(events.user.deleted).toBeCalledTimes(1)
-      expect(events.user.permissionBuilderRemoved).not.toBeCalled()
-      expect(events.user.permissionAdminRemoved).not.toBeCalled()
-    })
-
-    it("should be able to destroy an admin user", async () => {
-      let user = structures.users.adminUser({ email: "destroy-admin@test.com" })
-      await createUser(user)
-      jest.clearAllMocks()
-
-      await deleteUser(user.email)
-
-      expect(events.user.deleted).toBeCalledTimes(1)
-      expect(events.user.permissionBuilderRemoved).not.toBeCalled()
-      expect(events.user.permissionAdminRemoved).toBeCalledTimes(1)
-    })
-
-    it("should be able to destroy a builder user", async () => {
-      let user = structures.users.builderUser({ email: "destroy-admin@test.com" })
-      await createUser(user)
-      jest.clearAllMocks()
-
-      await deleteUser(user.email)
-
-      expect(events.user.deleted).toBeCalledTimes(1)
-      expect(events.user.permissionBuilderRemoved).toBeCalledTimes(1)
-      expect(events.user.permissionAdminRemoved).not.toBeCalled()
-    })
-
-    it("should be able to bulk delete users with different permissions", async () => {
-      jest.clearAllMocks()
-      const builder = structures.users.builderUser({ email: "basic@test.com" })
-      const admin = structures.users.adminUser({ email: "admin@test.com" })
-      const user = structures.users.user({ email: "user@test.com" })
-
-      let toCreate = { users: [builder, admin, user], groups: [] }
-      let createdUsers = await bulkCreateUsers(toCreate)
-      await bulkDeleteUsers({ userIds: [createdUsers[0]._id, createdUsers[1]._id, createdUsers[2]._id] })
-      expect(events.user.deleted).toBeCalledTimes(3)
-      expect(events.user.permissionAdminRemoved).toBeCalledTimes(1)
-      expect(events.user.permissionBuilderRemoved).toBeCalledTimes(1)
-
-    })
-
-  })
-})

package/src/tests/TestConfiguration.js

@@ -1,231 +0,0 @@
-require("./mocks")
-require("../db").init()
-const env = require("../environment")
-const controllers = require("./controllers")
-const supertest = require("supertest")
-const { jwt } = require("@budibase/backend-core/auth")
-const { Cookies, Headers } = require("@budibase/backend-core/constants")
-const { Configs } = require("../constants")
-const { users } = require("@budibase/backend-core")
-const { createASession } = require("@budibase/backend-core/sessions")
-const { TENANT_ID, CSRF_TOKEN } = require("./structures")
-const structures = require("./structures")
-const { doInTenant } = require("@budibase/backend-core/tenancy")
-const { groups } = require("@budibase/pro")
-class TestConfiguration {
-  constructor(openServer = true) {
-    if (openServer) {
-      env.PORT = "0" // random port
-      this.server = require("../index")
-      // we need the request for logging in, involves cookies, hard to fake
-      this.request = supertest(this.server)
-    }
-  }
-
-  getRequest() {
-    return this.request
-  }
-
-  // UTILS
-
-  async _req(config, params, controlFunc) {
-    const request = {}
-    // fake cookies, we don't need them
-    request.cookies = { set: () => {}, get: () => {} }
-    request.config = { jwtSecret: env.JWT_SECRET }
-    request.appId = this.appId
-    request.user = { appId: this.appId, tenantId: TENANT_ID }
-    request.query = {}
-    request.request = {
-      body: config,
-    }
-    request.throw = (status, err) => {
-      throw { status, message: err }
-    }
-    if (params) {
-      request.params = params
-    }
-    await doInTenant(TENANT_ID, () => {
-      return controlFunc(request)
-    })
-    return request.body
-  }
-
-  // SETUP / TEARDOWN
-
-  async beforeAll() {
-    await this.login()
-  }
-
-  async afterAll() {
-    if (this.server) {
-      await this.server.close()
-    }
-  }
-
-  // USER / AUTH
-
-  async login() {
-    // create a test user
-    await this._req(
-      {
-        email: "test@test.com",
-        password: "test",
-        _id: "us_uuid1",
-        builder: {
-          global: true,
-        },
-        admin: {
-          global: true,
-        },
-      },
-      null,
-      controllers.users.save
-    )
-    await createASession("us_uuid1", {
-      sessionId: "sessionid",
-      tenantId: TENANT_ID,
-      csrfToken: CSRF_TOKEN,
-    })
-  }
-
-  cookieHeader(cookies) {
-    return {
-      Cookie: [cookies],
-    }
-  }
-
-  defaultHeaders() {
-    const user = {
-      _id: "us_uuid1",
-      userId: "us_uuid1",
-      sessionId: "sessionid",
-      tenantId: TENANT_ID,
-    }
-    const authToken = jwt.sign(user, env.JWT_SECRET)
-    return {
-      Accept: "application/json",
-      ...this.cookieHeader([`${Cookies.Auth}=${authToken}`]),
-      [Headers.CSRF_TOKEN]: CSRF_TOKEN,
-    }
-  }
-
-  async getUser(email) {
-    return doInTenant(TENANT_ID, () => {
-      return users.getGlobalUserByEmail(email)
-    })
-  }
-
-  async getGroup(id) {
-    return doInTenant(TENANT_ID, () => {
-      return groups.get(id)
-    })
-  }
-
-  async saveGroup(group) {
-    const res = await this.getRequest()
-      .post(`/api/global/groups`)
-      .send(group)
-      .set(this.defaultHeaders())
-      .expect("Content-Type", /json/)
-      .expect(200)
-    return res.body
-  }
-
-  async createUser(email, password) {
-    const user = await this.getUser(structures.users.email)
-    if (user) {
-      return user
-    }
-    await this._req(
-      structures.users.user({ email, password }),
-      null,
-      controllers.users.save
-    )
-  }
-
-  async saveAdminUser() {
-    await this._req(
-      structures.users.user({ tenantId: TENANT_ID }),
-      null,
-      controllers.users.adminUser
-    )
-  }
-
-  // CONFIGS
-
-  async deleteConfig(type) {
-    try {
-      const cfg = await this._req(
-        null,
-        {
-          type,
-        },
-        controllers.config.find
-      )
-      if (cfg) {
-        await this._req(
-          null,
-          {
-            id: cfg._id,
-            rev: cfg._rev,
-          },
-          controllers.config.destroy
-        )
-      }
-    } catch (err) {
-      // don't need to handle error
-    }
-  }
-
-  // CONFIGS - SETTINGS
-
-  async saveSettingsConfig() {
-    await this.deleteConfig(Configs.SETTINGS)
-    await this._req(
-      structures.configs.settings(),
-      null,
-      controllers.config.save
-    )
-  }
-
-  // CONFIGS - GOOGLE
-
-  async saveGoogleConfig() {
-    await this.deleteConfig(Configs.GOOGLE)
-    await this._req(structures.configs.google(), null, controllers.config.save)
-  }
-
-  // CONFIGS - OIDC
-
-  getOIDConfigCookie(configId) {
-    const token = jwt.sign(configId, env.JWT_SECRET)
-    return this.cookieHeader([[`${Cookies.OIDC_CONFIG}=${token}`]])
-  }
-
-  async saveOIDCConfig() {
-    await this.deleteConfig(Configs.OIDC)
-    const config = structures.configs.oidc()
-
-    await this._req(config, null, controllers.config.save)
-    return config
-  }
-
-  // CONFIGS - SMTP
-
-  async saveSmtpConfig() {
-    await this.deleteConfig(Configs.SMTP)
-    await this._req(structures.configs.smtp(), null, controllers.config.save)
-  }
-
-  async saveEtherealSmtpConfig() {
-    await this.deleteConfig(Configs.SMTP)
-    await this._req(
-      structures.configs.smtpEthereal(),
-      null,
-      controllers.config.save
-    )
-  }
-}
-
-module.exports = TestConfiguration