@budibase/worker 2.6.8-alpha.10 → 2.6.8-alpha.12

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@budibase/worker",
   "email": "hi@budibase.com",
-  "version": "2.6.8-alpha.10",
+  "version": "2.6.8-alpha.12",
   "description": "Budibase background service",
   "main": "src/index.ts",
   "repository": {
@@ -37,10 +37,10 @@
   "author": "Budibase",
   "license": "GPL-3.0",
   "dependencies": {
-    "@budibase/backend-core": "2.6.8-alpha.10",
-    "@budibase/pro": "2.6.8-alpha.10",
-    "@budibase/string-templates": "2.6.8-alpha.10",
-    "@budibase/types": "2.6.8-alpha.10",
+    "@budibase/backend-core": "2.6.8-alpha.12",
+    "@budibase/pro": "2.6.8-alpha.12",
+    "@budibase/string-templates": "2.6.8-alpha.12",
+    "@budibase/types": "2.6.8-alpha.12",
     "@koa/router": "8.0.8",
     "@sentry/node": "6.17.7",
     "@techpass/passport-openidconnect": "0.3.2",
@@ -102,5 +102,5 @@
     "typescript": "4.7.3",
     "update-dotenv": "1.1.1"
   },
-  "gitHead": "bcc68ebca7f6a471883eca92678c9ab4ab34dc2a"
+  "gitHead": "90d65824eb665b2b57181153a40fc140a607e7ff"
 }

package/src/api/routes/global/tests/groups.spec.ts

@@ -1,5 +1,9 @@
 import { events } from "@budibase/backend-core"
+import { generator } from "@budibase/backend-core/tests"
 import { structures, TestConfiguration, mocks } from "../../../../tests"
+import { UserGroup } from "@budibase/types"
+
+mocks.licenses.useGroups()
 
 describe("/api/global/groups", () => {
   const config = new TestConfiguration()
@@ -113,4 +117,118 @@ describe("/api/global/groups", () => {
       })
     })
   })
+
+  describe("find users", () => {
+    describe("without users", () => {
+      let group: UserGroup
+      beforeAll(async () => {
+        group = structures.groups.UserGroup()
+        await config.api.groups.saveGroup(group)
+      })
+
+      it("should return empty", async () => {
+        const result = await config.api.groups.searchUsers(group._id!)
+        expect(result.body).toEqual({
+          users: [],
+          bookmark: undefined,
+          hasNextPage: false,
+        })
+      })
+    })
+
+    describe("existing users", () => {
+      let groupId: string
+      let users: { _id: string; email: string }[] = []
+
+      beforeAll(async () => {
+        groupId = (
+          await config.api.groups.saveGroup(structures.groups.UserGroup())
+        ).body._id
+
+        await Promise.all(
+          Array.from({ length: 30 }).map(async (_, i) => {
+            const email = `user${i}@${generator.domain()}`
+            const user = await config.api.users.saveUser({
+              ...structures.users.user(),
+              email,
+            })
+            users.push({ _id: user.body._id, email })
+          })
+        )
+        users = users.sort((a, b) => a._id.localeCompare(b._id))
+        await config.api.groups.updateGroupUsers(groupId, {
+          add: users.map(u => u._id),
+          remove: [],
+        })
+      })
+
+      describe("pagination", () => {
+        it("should return first page", async () => {
+          const result = await config.api.groups.searchUsers(groupId)
+          expect(result.body).toEqual({
+            users: users.slice(0, 10),
+            bookmark: users[10]._id,
+            hasNextPage: true,
+          })
+        })
+
+        it("given a bookmark, should return skip items", async () => {
+          const result = await config.api.groups.searchUsers(groupId, {
+            bookmark: users[7]._id,
+          })
+          expect(result.body).toEqual({
+            users: users.slice(7, 17),
+            bookmark: users[17]._id,
+            hasNextPage: true,
+          })
+        })
+
+        it("bookmarking the last page, should return last page info", async () => {
+          const result = await config.api.groups.searchUsers(groupId, {
+            bookmark: users[20]._id,
+          })
+          expect(result.body).toEqual({
+            users: users.slice(20),
+            bookmark: undefined,
+            hasNextPage: false,
+          })
+        })
+      })
+
+      describe("search by email", () => {
+        it('should be able to search "starting" by email', async () => {
+          const result = await config.api.groups.searchUsers(groupId, {
+            emailSearch: `user1`,
+          })
+
+          const matchedUsers = users
+            .filter(u => u.email.startsWith("user1"))
+            .sort((a, b) => a.email.localeCompare(b.email))
+
+          expect(result.body).toEqual({
+            users: matchedUsers.slice(0, 10),
+            bookmark: matchedUsers[10].email,
+            hasNextPage: true,
+          })
+        })
+
+        it("should be able to bookmark when searching by email", async () => {
+          const matchedUsers = users
+            .filter(u => u.email.startsWith("user1"))
+            .sort((a, b) => a.email.localeCompare(b.email))
+
+          const result = await config.api.groups.searchUsers(groupId, {
+            emailSearch: `user1`,
+            bookmark: matchedUsers[4].email,
+          })
+
+          expect(result.body).toEqual({
+            users: matchedUsers.slice(4),
+            bookmark: undefined,
+            hasNextPage: false,
+          })
+        })
+      })
+    })
+  })
 })

package/src/tests/api/groups.ts

@@ -23,4 +23,34 @@ export class GroupsAPI extends TestAPI {
       .expect("Content-Type", /json/)
       .expect(200)
   }
+
+  searchUsers = (
+    id: string,
+    params?: { bookmark?: string; emailSearch?: string }
+  ) => {
+    let url = `/api/global/groups/${id}/users?`
+    if (params?.bookmark) {
+      url += `bookmark=${params.bookmark}&`
+    }
+    if (params?.emailSearch) {
+      url += `emailSearch=${params.emailSearch}&`
+    }
+    return this.request
+      .get(url)
+      .set(this.config.defaultHeaders())
+      .expect("Content-Type", /json/)
+      .expect(200)
+  }
+
+  updateGroupUsers = (
+    id: string,
+    body: { add: string[]; remove: string[] }
+  ) => {
+    return this.request
+      .post(`/api/global/groups/${id}/users`)
+      .send(body)
+      .set(this.config.defaultHeaders())
+      .expect("Content-Type", /json/)
+      .expect(200)
+  }
 }