@budibase/worker 1.0.200-alpha.3 → 1.0.200

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

@@ -1,19 +1,20 @@
 jest.mock("nodemailer")
-const { config, request, mocks, structures } = require("../../../tests")
-const sendMailMock = mocks.email.mock()
-const { events } = require("@budibase/backend-core")
+const setup = require("./utilities")
+const sendMailMock = setup.emailMock()
 
 describe("/api/global/users", () => {
+  let request = setup.getRequest()
+  let config = setup.getConfig()
+  let code
 
   beforeAll(async () => {
-    await config.beforeAll()
+    await config.init()
   })
 
-  afterAll(async () => {
-    await config.afterAll()
-  })
+  afterAll(setup.afterAll)
 
-  const sendUserInvite = async () => {
+  it("should be able to generate an invitation", async () => {
+    // initially configure settings
     await config.saveSmtpConfig()
     await config.saveSettingsConfig()
     const res = await request
@@ -24,26 +25,16 @@ describe("/api/global/users", () => {
       .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()
+    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=")
+    code = parts[1].split("\"")[0].split("&")[0]
     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({
@@ -56,282 +47,5 @@ describe("/api/global/users", () => {
     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 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 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()
-    })
   })
 })

package/src/{tests → api/routes/tests/utilities}/TestConfiguration.js

@@ -1,22 +1,21 @@
-require("./mocks")
-require("../db").init()
-const env = require("../environment")
+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 { Configs, LOGO_URL } = require("../../../../constants")
+const { getGlobalUserByEmail } = require("@budibase/backend-core/utils")
 const { createASession } = require("@budibase/backend-core/sessions")
+const { newid } = require("@budibase/backend-core/src/hashing")
 const { TENANT_ID, CSRF_TOKEN } = require("./structures")
-const structures = require("./structures")
 const { doInTenant } = require("@budibase/backend-core/tenancy")
 
 class TestConfiguration {
   constructor(openServer = true) {
     if (openServer) {
-      env.PORT = "0" // random port
-      this.server = require("../index")
+      env.PORT = 4012
+      this.server = require("../../../../index")
       // we need the request for logging in, involves cookies, hard to fake
       this.request = supertest(this.server)
     }
@@ -26,8 +25,6 @@ class TestConfiguration {
     return this.request
   }
 
-  // UTILS
-
   async _req(config, params, controlFunc) {
     const request = {}
     // fake cookies, we don't need them
@@ -51,37 +48,25 @@ class TestConfiguration {
     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,
+  async init(createUser = true) {
+    if (createUser) {
+      // 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
-    )
+        null,
+        controllers.users.save
+      )
+    }
     await createASession("us_uuid1", {
       sessionId: "sessionid",
       tenantId: TENANT_ID,
@@ -89,6 +74,12 @@ class TestConfiguration {
     })
   }
 
+  async end() {
+    if (this.server) {
+      await this.server.close()
+    }
+  }
+
   cookieHeader(cookies) {
     return {
       Cookie: [cookies],
@@ -112,32 +103,25 @@ class TestConfiguration {
 
   async getUser(email) {
     return doInTenant(TENANT_ID, () => {
-      return users.getGlobalUserByEmail(email)
+      return getGlobalUserByEmail(email)
     })
   }
 
-  async createUser(email, password) {
-    const user = await this.getUser(structures.users.email)
+  async createUser(email = "test@test.com", password = "test") {
+    const user = await this.getUser(email)
     if (user) {
       return user
     }
     await this._req(
-      structures.users.user({ email, password }),
+      {
+        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(
@@ -162,26 +146,37 @@ class TestConfiguration {
     }
   }
 
-  // CONFIGS - SETTINGS
-
   async saveSettingsConfig() {
     await this.deleteConfig(Configs.SETTINGS)
     await this._req(
-      structures.configs.settings(),
+      {
+        type: Configs.SETTINGS,
+        config: {
+          platformUrl: "http://localhost:10000",
+          logoUrl: LOGO_URL,
+          company: "Budibase",
+        },
+      },
       null,
       controllers.config.save
     )
   }
 
-  // CONFIGS - GOOGLE
-
-  async saveGoogleConfig() {
+  async saveOAuthConfig() {
     await this.deleteConfig(Configs.GOOGLE)
-    await this._req(structures.configs.google(), null, controllers.config.save)
+    await this._req(
+      {
+        type: Configs.GOOGLE,
+        config: {
+          clientID: "clientId",
+          clientSecret: "clientSecret",
+        },
+      },
+      null,
+      controllers.config.save
+    )
   }
 
-  // CONFIGS - OIDC
-
   getOIDConfigCookie(configId) {
     const token = jwt.sign(configId, env.JWT_SECRET)
     return this.cookieHeader([[`${Cookies.OIDC_CONFIG}=${token}`]])
@@ -189,27 +184,75 @@ class TestConfiguration {
 
   async saveOIDCConfig() {
     await this.deleteConfig(Configs.OIDC)
-    const config = structures.configs.oidc()
+    const config = {
+      type: Configs.OIDC,
+      config: {
+        configs: [
+          {
+            configUrl: "http://someconfigurl",
+            clientID: "clientId",
+            clientSecret: "clientSecret",
+            logo: "Microsoft",
+            name: "Active Directory",
+            uuid: newid(),
+          },
+        ],
+      },
+    }
 
     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)
+    await this._req(
+      {
+        type: Configs.SMTP,
+        config: {
+          port: 12345,
+          host: "smtptesthost.com",
+          from: "testfrom@test.com",
+          subject: "Hello!",
+        },
+      },
+      null,
+      controllers.config.save
+    )
   }
 
   async saveEtherealSmtpConfig() {
     await this.deleteConfig(Configs.SMTP)
     await this._req(
-      structures.configs.smtpEthereal(),
+      {
+        type: Configs.SMTP,
+        config: {
+          port: 587,
+          host: "smtp.ethereal.email",
+          secure: false,
+          auth: {
+            user: "don.bahringer@ethereal.email",
+            pass: "yCKSH8rWyUPbnhGYk9",
+          },
+          connectionTimeout: 1000, // must be less than the jest default of 5000
+        },
+      },
       null,
       controllers.config.save
     )
   }
+
+  async saveAdminUser() {
+    await this._req(
+      {
+        email: "testuser@test.com",
+        password: "test@test.com",
+        tenantId: TENANT_ID,
+      },
+      null,
+      controllers.users.adminUser
+    )
+  }
 }
 
 module.exports = TestConfiguration

package/src/api/routes/tests/utilities/controllers.js

@@ -0,0 +1,7 @@
+module.exports = {
+  email: require("../../../controllers/global/email"),
+  workspaces: require("../../../controllers/global/workspaces"),
+  config: require("../../../controllers/global/configs"),
+  templates: require("../../../controllers/global/templates"),
+  users: require("../../../controllers/global/users"),
+}

package/src/api/routes/tests/utilities/index.js

@@ -0,0 +1,41 @@
+const TestConfig = require("./TestConfiguration")
+
+let request, config
+
+exports.beforeAll = () => {
+  config = new TestConfig()
+  request = config.getRequest()
+}
+
+exports.afterAll = async () => {
+  if (config) {
+    await config.end()
+  }
+  request = null
+  config = null
+}
+
+exports.getRequest = () => {
+  if (!request) {
+    exports.beforeAll()
+  }
+  return request
+}
+
+exports.getConfig = () => {
+  if (!config) {
+    exports.beforeAll()
+  }
+  return config
+}
+
+exports.emailMock = () => {
+  // mock the email system
+  const sendMailMock = jest.fn()
+  const nodemailer = require("nodemailer")
+  nodemailer.createTransport.mockReturnValue({
+    sendMail: sendMailMock,
+    verify: jest.fn(),
+  })
+  return sendMailMock
+}

package/src/api/routes/tests/utilities/structures.js

@@ -0,0 +1,2 @@
+exports.TENANT_ID = "default"
+exports.CSRF_TOKEN = "e3727778-7af0-4226-b5eb-f43cbe60a306"

package/src/api/utilities/index.js

@@ -0,0 +1,33 @@
+const { getGlobalDB } = require("@budibase/backend-core/tenancy")
+const { getGlobalUserParams } = require("@budibase/backend-core/db")
+
+/**
+ * Retrieves all users from the current tenancy.
+ */
+exports.allUsers = async () => {
+  const db = getGlobalDB()
+  const response = await db.allDocs(
+    getGlobalUserParams(null, {
+      include_docs: true,
+    })
+  )
+  return response.rows.map(row => row.doc)
+}
+
+/**
+ * Gets a user by ID from the global database, based on the current tenancy.
+ */
+exports.getUser = async userId => {
+  const db = getGlobalDB()
+  let user
+  try {
+    user = await db.get(userId)
+  } catch (err) {
+    // no user found, just return nothing
+    user = {}
+  }
+  if (user) {
+    delete user.password
+  }
+  return user
+}