chore: Move admin invites + user tests to HTTP (#7596)

integration-tests/api/__tests__/admin/invite.js

@@ -1,393 +0,0 @@
-const path = require("path")
-
-const setupServer = require("../../../environment-helpers/setup-server")
-const { useApi } = require("../../../environment-helpers/use-api")
-const { initDb, useDb } = require("../../../environment-helpers/use-db")
-
-const userSeeder = require("../../../helpers/user-seeder")
-const adminSeeder = require("../../../helpers/admin-seeder")
-
-jest.setTimeout(30000)
-
-describe("/admin/invites", () => {
-  let medusaProcess
-  let dbConnection
-
-  beforeAll(async () => {
-    const cwd = path.resolve(path.join(__dirname, "..", ".."))
-    dbConnection = await initDb({ cwd })
-    medusaProcess = await setupServer({ cwd })
-  })
-
-  afterAll(async () => {
-    const db = useDb()
-    await db.shutdown()
-    medusaProcess.kill()
-  })
-
-  describe("GET /admin/users", () => {
-    beforeEach(async () => {
-      await adminSeeder(dbConnection)
-      await userSeeder(dbConnection)
-    })
-
-    afterEach(async () => {
-      const db = useDb()
-      await db.teardown()
-    })
-
-    it("lists invites", async () => {
-      const api = useApi()
-
-      const response = await api
-        .get("/admin/invites", {
-          headers: {
-            "x-medusa-access-token": "test_token",
-          },
-        })
-        .catch((err) => {
-          console.log(err)
-        })
-
-      expect(response.status).toEqual(200)
-
-      expect(response.data.invites).toMatchSnapshot([
-        {
-          id: "memberInvite",
-          user_email: "invite-member@test.com",
-          role: "member",
-          accepted: false,
-          token: expect.any(String),
-          expires_at: expect.any(String),
-          created_at: expect.any(String),
-          updated_at: expect.any(String),
-        },
-        {
-          id: "adminInvite",
-          user_email: "invite-admin@test.com",
-          role: "admin",
-          accepted: false,
-          token: expect.any(String),
-          created_at: expect.any(String),
-          expires_at: expect.any(String),
-          updated_at: expect.any(String),
-        },
-      ])
-    })
-  })
-
-  describe("POST /admin/invites", () => {
-    let user
-    beforeEach(async () => {
-      const api = useApi()
-      await adminSeeder(dbConnection)
-      await userSeeder(dbConnection)
-
-      const response = await api
-        .post(
-          "/admin/users",
-          {
-            email: "test@forgottenPassword.com",
-            role: "member",
-            password: "test123453",
-          },
-          {
-            headers: { "x-medusa-access-token": "test_token" },
-          }
-        )
-        .catch((err) => console.log(err))
-
-      user = response.data.user
-    })
-
-    afterEach(async () => {
-      const db = useDb()
-      await db.teardown()
-    })
-
-    describe("Invitations", () => {
-      it("create an invite with the specified emails and role", async () => {
-        const api = useApi()
-
-        const payload = {
-          user: "test@medusa-commerce.com",
-          role: "admin",
-        }
-
-        const createReponse = await api
-          .post("/admin/invites", payload, {
-            headers: { "x-medusa-access-token": "test_token" },
-          })
-          .catch((err) => console.log(err))
-
-        const response = await api
-          .get("/admin/invites", {
-            headers: {
-              "x-medusa-access-token": "test_token",
-            },
-          })
-          .catch((err) => {
-            console.log(err)
-          })
-
-        expect(createReponse.status).toEqual(200)
-
-        expect(response.data.invites).toEqual(
-          expect.arrayContaining([
-            expect.objectContaining({ user_email: payload.user }),
-          ])
-        )
-
-        expect(response.status).toEqual(200)
-      })
-
-      it("updates invite with new role", async () => {
-        const api = useApi()
-
-        const payload = {
-          user: "invite-member@test.com",
-          role: "admin",
-        }
-
-        const createReponse = await api
-          .post("/admin/invites", payload, {
-            headers: { "x-medusa-access-token": "test_token" },
-          })
-          .catch((err) => console.log(err))
-
-        const response = await api
-          .get("/admin/invites", {
-            headers: {
-              "x-medusa-access-token": "test_token",
-            },
-          })
-          .catch((err) => {
-            console.log(err)
-          })
-
-        expect(createReponse.status).toEqual(200)
-
-        expect(response.data.invites).toEqual(
-          expect.arrayContaining([
-            expect.objectContaining({
-              user_email: payload.user,
-              role: "admin",
-            }),
-          ])
-        )
-
-        expect(response.status).toEqual(200)
-      })
-
-      it("resends invite", async () => {
-        const api = useApi()
-
-        const id = "memberInvite"
-
-        const resendResponse = await api
-          .post(
-            `/admin/invites/${id}/resend`,
-            {},
-            {
-              headers: { "x-medusa-access-token": "test_token" },
-            }
-          )
-          .catch((err) => console.log(err))
-
-        expect(resendResponse.status).toEqual(200)
-      })
-
-      it("creates a user successfully when accepting an invite (unauthorized endpoint)", async () => {
-        const api = useApi()
-
-        const inviteResponse = await api.get("/admin/invites", {
-          headers: { "x-medusa-access-token": "test_token" },
-        })
-
-        const { token, ...rest } = inviteResponse.data.invites[0]
-
-        const user = {
-          first_name: "test",
-          last_name: "testesen",
-          password: "supersecret",
-        }
-
-        const payload = { token, user }
-
-        const createResponse = await api
-          .post("/admin/invites/accept", payload)
-          .catch((err) => console.log(err))
-
-        const userResponse = await api.get("/admin/users", {
-          headers: { "x-medusa-access-token": "test_token" },
-        })
-
-        const newUser = userResponse.data.users.find(
-          (usr) => usr.email == rest.user_email
-        )
-
-        expect(newUser).toEqual(expect.objectContaining({ role: rest.role }))
-        expect(createResponse.status).toEqual(200)
-      })
-
-      it("creates a user successfully with new role after updating invite (unauthorized endpoint)", async () => {
-        const api = useApi()
-
-        const inviteResponse = await api.get("/admin/invites", {
-          headers: { "x-medusa-access-token": "test_token" },
-        })
-
-        const { token, ...rest } = inviteResponse.data.invites.find(
-          (inv) => inv.role === "member"
-        )
-
-        const user = {
-          first_name: "test",
-          last_name: "testesen",
-          password: "supersecret",
-        }
-
-        const updatePayload = {
-          user: rest.user_email,
-          role: "admin",
-        }
-
-        const updateResponse = await api
-          .post("/admin/invites", updatePayload, {
-            headers: { "x-medusa-access-token": "test_token" },
-          })
-          .catch((err) => console.log(err))
-
-        const payload = { token, user }
-
-        const createResponse = await api.post("/admin/invites/accept", payload)
-
-        const userResponse = await api.get("/admin/users", {
-          headers: { "x-medusa-access-token": "test_token" },
-        })
-
-        const newUser = userResponse.data.users.find(
-          (usr) => usr.email == rest.user_email
-        )
-
-        expect(newUser).toEqual(expect.objectContaining({ role: "admin" }))
-        expect(updateResponse.status).toEqual(200)
-        expect(createResponse.status).toEqual(200)
-      })
-      it("Fails to accept an invite given an invalid token (unauthorized endpoint)", async () => {
-        expect.assertions(2)
-        const api = useApi()
-
-        const token =
-          "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpbnZpdGVfaWQiOiJpbnZpdGVfMDFGSFFWNlpBOERRRlgySjM3UVo5SjZTOTAiLCJyb2xlIjoiYWRtaW4iLCJ1c2VyX2VtYWlsIjoic2ZAc2RmLmNvbSIsImlhdCI6MTYzMzk2NDAyMCwiZXhwIjoxNjM0NTY4ODIwfQ.ZsmDvunBxhRW1iRqvfEfWixJLZ1zZVzaEYST38Vbl00"
-
-        await api
-          .post("/admin/invites/accept", {
-            token,
-            user: {
-              first_name: "test",
-              last_name: "testesen",
-              password: "supersecret",
-            },
-          })
-          .catch((err) => {
-            expect(err.response.status).toEqual(400)
-            expect(err.response.data.message).toEqual("Token is not valid")
-          })
-      })
-
-      it("fails to accept an already accepted invite (unauthorized endpoint)", async () => {
-        expect.assertions(4)
-
-        const api = useApi()
-
-        const inviteResponse = await api.get("/admin/invites", {
-          headers: { "x-medusa-access-token": "test_token" },
-        })
-
-        const { token } = inviteResponse.data.invites[0]
-
-        const user = {
-          first_name: "test",
-          last_name: "testesen",
-          password: "supersecret",
-        }
-
-        const payload = { token, user }
-
-        const createResponse = await api.post("/admin/invites/accept", payload)
-
-        const secondPayload = {
-          user: {
-            first_name: "testesens",
-            last_name: "test",
-            password: "testesens",
-          },
-          token,
-        }
-
-        await api.post("/admin/invites/accept", secondPayload).catch((err) => {
-          expect(err.response.status).toEqual(400)
-          expect(err.response.data.message).toEqual("Invalid invite")
-          expect(err.response.data.type).toEqual("invalid_data")
-        })
-        expect(createResponse.status).toEqual(200)
-      })
-    })
-  })
-
-  describe("DELETE /admin/users", () => {
-    beforeEach(async () => {
-      await adminSeeder(dbConnection)
-      await userSeeder(dbConnection)
-    })
-
-    afterEach(async () => {
-      const db = useDb()
-      await db.teardown()
-    })
-    it("/admin/invites Deletes an invite", async () => {
-      const api = useApi()
-
-      const inviteId = "memberInvite"
-
-      const invitesBeforeDeleteRequest = await api.get("/admin/invites", {
-        headers: {
-          "x-medusa-access-token": "test_token",
-        },
-      })
-
-      const invitesBeforeDelete = invitesBeforeDeleteRequest.data.invites
-
-      const response = await api
-        .delete(`/admin/invites/${inviteId}`, {
-          headers: { "x-medusa-access-token": "test_token" },
-        })
-        .catch((err) => console.log(err))
-
-      const invitesAfterDeleteRequest = await api.get("/admin/invites", {
-        headers: {
-          "x-medusa-access-token": "test_token",
-        },
-      })
-
-      expect(response.status).toEqual(200)
-      expect(response.data).toEqual({
-        id: inviteId,
-        object: "invite",
-        deleted: true,
-      })
-
-      const invitesAfterDelete = invitesAfterDeleteRequest.data.invites
-
-      expect(invitesAfterDelete.length).toEqual(invitesBeforeDelete.length - 1)
-      expect(invitesBeforeDelete).toEqual(
-        expect.arrayContaining([expect.objectContaining({ id: inviteId })])
-      )
-
-      expect(invitesAfterDelete).toEqual(
-        expect.not.arrayContaining([expect.objectContaining({ id: inviteId })])
-      )
-    })
-  })
-})

integration-tests/helpers/create-admin-user.ts

@@ -47,4 +47,6 @@ export const createAdminUser = async (
   )
 
   adminHeaders.headers["authorization"] = `Bearer ${token}`
+
+  return { user }
 }

integration-tests/http/__tests__/invite/admin/invite.spec.ts

@@ -0,0 +1,181 @@
+import { medusaIntegrationTestRunner } from "medusa-test-utils"
+import {
+  adminHeaders,
+  createAdminUser,
+} from "../../../../helpers/create-admin-user"
+
+jest.setTimeout(30000)
+
+medusaIntegrationTestRunner({
+  testSuite: ({ dbConnection, api, getContainer }) => {
+    let invite
+    beforeEach(async () => {
+      const appContainer = getContainer()
+      await createAdminUser(dbConnection, adminHeaders, appContainer)
+
+      invite = (
+        await api.post(
+          "/admin/invites",
+          {
+            email: "invite@medusa-commerce.com",
+          },
+          adminHeaders
+        )
+      ).data.invite
+    })
+
+    describe("Admin invites", () => {
+      it("should create, list, retrieve, and accept (deleting) an invite", async () => {
+        const createdInvite = (
+          await api.post(
+            "/admin/invites",
+            {
+              email: "test@medusa-commerce.com",
+            },
+            adminHeaders
+          )
+        ).data.invite
+
+        expect(createdInvite).toEqual(
+          expect.objectContaining({
+            email: "test@medusa-commerce.com",
+          })
+        )
+
+        const listInvites = (await api.get("/admin/invites", adminHeaders)).data
+          .invites
+
+        expect(listInvites).toEqual([
+          expect.objectContaining({
+            email: "invite@medusa-commerce.com",
+          }),
+          expect.objectContaining({
+            email: "test@medusa-commerce.com",
+          }),
+        ])
+
+        const getInvite = (
+          await api.get(`/admin/invites/${createdInvite.id}`, adminHeaders)
+        ).data.invite
+
+        expect(getInvite).toEqual(
+          expect.objectContaining({
+            email: "test@medusa-commerce.com",
+          })
+        )
+
+        const signup = await api.post("/auth/user/emailpass", {
+          email: "test@medusa-commerce.com",
+          password: "secret_password",
+        })
+
+        expect(signup.status).toEqual(200)
+        expect(signup.data).toEqual({ token: expect.any(String) })
+
+        const acceptedInvite = (
+          await api.post(
+            `/admin/invites/accept?token=${createdInvite.token}`,
+            {
+              first_name: "Test",
+              last_name: "User",
+            },
+            { headers: { authorization: `Bearer ${signup.data.token}` } }
+          )
+        ).data.user
+
+        expect(acceptedInvite).toEqual(
+          expect.objectContaining({
+            email: "test@medusa-commerce.com",
+          })
+        )
+      })
+
+      it("should fail to accept an invite given an invalid token", async () => {
+        expect.assertions(2)
+        const signup = await api.post("/auth/user/emailpass", {
+          email: "test@medusa-commerce.com",
+          password: "secret_password",
+        })
+
+        // Some malformed token
+        const token =
+          "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpbnZpdGVfaWQiOiJpbnZpdGVfMDFGSFFWNlpBOERRRlgySjM3UVo5SjZTOTAiLCJyb2xlIjoiYWRtaW4iLCJ1c2VyX2VtYWlsIjoic2ZAc2RmLmNvbSIsImlhdCI6MTYzMzk2NDAyMCwiZXhwIjoxNjM0NTY4ODIwfQ.ZsmDvunBxhRW1iRqvfEfWixJLZ1zZVzaEYST38Vbl00"
+
+        await api
+          .post(
+            `/admin/invites/accept?token=${token}`,
+            {
+              first_name: "test",
+              last_name: "testesen",
+            },
+            {
+              headers: { authorization: `Bearer ${signup.data.token}` },
+            }
+          )
+          .catch((err) => {
+            expect(err.response.status).toEqual(401)
+            expect(err.response.data.message).toEqual("Unauthorized")
+          })
+      })
+
+      it("should fail to accept an already accepted invite ", async () => {
+        const signup = await api.post("/auth/user/emailpass", {
+          email: "test@medusa-commerce.com",
+          password: "secret_password",
+        })
+
+        await api.post(
+          `/admin/invites/accept?token=${invite.token}`,
+          {
+            first_name: "Test",
+            last_name: "User",
+          },
+          {
+            headers: { authorization: `Bearer ${signup.data.token}` },
+          }
+        )
+
+        const signupAgain = await api.post("/auth/user/emailpass", {
+          email: "another-test@medusa-commerce.com",
+          password: "secret_password",
+        })
+
+        await api
+          .post(
+            `/admin/invites/accept?token=${invite.token}`,
+            {
+              first_name: "Another Test",
+              last_name: "User",
+            },
+            {
+              headers: { authorization: `Bearer ${signupAgain.data.token}` },
+            }
+          )
+          .catch((e) => {
+            expect(e.response.status).toEqual(401)
+            expect(e.response.data.message).toEqual("Unauthorized")
+          })
+      })
+      it("should resend an invite", async () => {
+        const resendResponse = (
+          await api.post(`/admin/invites/${invite.id}/resend`, {}, adminHeaders)
+        ).data.invite
+
+        // Resending an invite regenerates the token
+        expect(resendResponse.token).toBeDefined()
+        expect(resendResponse.token).not.toEqual(invite.token)
+      })
+      it("should delete an invite", async () => {
+        const deleteResponse = (
+          await api.delete(`/admin/invites/${invite.id}`, adminHeaders)
+        ).data
+
+        expect(deleteResponse).toEqual({
+          id: invite.id,
+          object: "invite",
+          deleted: true,
+        })
+      })
+    })
+  },
+})

integration-tests/http/__tests__/user/admin/user.spec.ts

@@ -1,170 +1,82 @@
-const jwt = require("jsonwebtoken")
+import { medusaIntegrationTestRunner } from "medusa-test-utils"
-
+import {
-const { medusaIntegrationTestRunner } = require("medusa-test-utils")
-const {
-  createAdminUser,
   adminHeaders,
-} = require("../../../helpers/create-admin-user")
+  createAdminUser,
-const { breaking } = require("../../../helpers/breaking")
+} from "../../../../helpers/create-admin-user"
-const { ModuleRegistrationName } = require("@medusajs/modules-sdk")
 
 jest.setTimeout(30000)
 
-let userSeeder = {}
-let simpleAnalyticsConfigFactory = {}
-
 medusaIntegrationTestRunner({
-  // env: { MEDUSA_FF_MEDUSA_V2: true },
   testSuite: ({ dbConnection, getContainer, api }) => {
-    let container
+    let user
-    let userModuleService
-
-    beforeAll(() => {
-      userSeeder = require("../../../helpers/user-seeder")
-      simpleAnalyticsConfigFactory = require("../../../factories/simple-analytics-config-factory")
-    })
 
     beforeEach(async () => {
-      container = getContainer()
+      const container = getContainer()
+      const { user: adminUser } = await createAdminUser(
+        dbConnection,
+        adminHeaders,
+        container
+      )
 
-      userModuleService = container.resolve(ModuleRegistrationName.USER)
+      user = adminUser
-
-      await createAdminUser(dbConnection, adminHeaders, container)
     })
 
     describe("GET /admin/users/:id", () => {
-      beforeEach(async () => {
-        await breaking(async () => {
-          await userSeeder(dbConnection)
-        })
-      })
-
       it("should return user by id", async () => {
-        const response = await api.get("/admin/users/admin_user", adminHeaders)
+        const response = await api.get(`/admin/users/${user.id}`, adminHeaders)
-
-        const v1Response = {
-          id: "admin_user",
-          email: "admin@medusa.js",
-          api_token: "test_token",
-          role: "admin",
-          created_at: expect.any(String),
-          updated_at: expect.any(String),
-        }
 
         const v2Response = {
-          id: "admin_user",
+          id: user.id,
           email: "admin@medusa.js",
           created_at: expect.any(String),
           updated_at: expect.any(String),
         }
 
+        // BREAKING: V2 users do not have role + api_token
         expect(response.status).toEqual(200)
-        expect(response.data.user).toEqual(
+        expect(response.data.user).toEqual(expect.objectContaining(v2Response))
-          expect.objectContaining(
-            breaking(
-              () => v1Response,
-              () => v2Response
-            )
-          )
-        )
       })
     })
 
     describe("GET /admin/users", () => {
-      beforeEach(async () => {
-        await breaking(
-          async () => {
-            await userSeeder(dbConnection)
-          },
-          async () => {
-            await userModuleService.create({
-              id: "member-user",
-              email: "member@test.com",
-              first_name: "member",
-              last_name: "user",
-            })
-          }
-        )
-      })
-
       it("should list users", async () => {
         const response = await api
           .get("/admin/users", adminHeaders)
-          .catch((err) => {
-            console.log(err)
-          })
 
         expect(response.status).toEqual(200)
 
-        const v1Response = [
-          expect.objectContaining({
-            id: "admin_user",
-            email: "admin@medusa.js",
-            created_at: expect.any(String),
-            updated_at: expect.any(String),
-            api_token: "test_token",
-            role: "admin",
-          }),
-          expect.objectContaining({
-            id: "member-user",
-            email: "member@test.com",
-            first_name: "member",
-            last_name: "user",
-            created_at: expect.any(String),
-            updated_at: expect.any(String),
-            role: "member",
-          }),
-        ]
-
         const v2Response = [
           expect.objectContaining({
-            id: "admin_user",
+            id: user.id,
             email: "admin@medusa.js",
             created_at: expect.any(String),
             updated_at: expect.any(String),
           }),
-          expect.objectContaining({
-            id: "member-user",
-            email: "member@test.com",
-            first_name: "member",
-            last_name: "user",
-            created_at: expect.any(String),
-            updated_at: expect.any(String),
-          }),
         ]
 
-        expect(response.data.users).toEqual(
+        expect(response.data.users).toEqual(v2Response)
-          expect.arrayContaining(
-            breaking(
-              () => v1Response,
-              () => v2Response
-            )
-          )
-        )
       })
 
       it("should list users that match the free text search", async () => {
-        const response = await api.get("/admin/users?q=member", adminHeaders)
+        const emptyResponse = await api.get(
+          "/admin/users?q=member",
+          adminHeaders
+        )
 
-        expect(response.status).toEqual(200)
+        expect(emptyResponse.status).toEqual(200)
+        expect(emptyResponse.data.users.length).toEqual(0)
+
+        const response = await api.get("/admin/users?q=user", adminHeaders)
 
         expect(response.data.users.length).toEqual(1)
-        expect(response.data.users).toEqual(
+        expect(response.data.users).toEqual([
-          expect.arrayContaining([
+          expect.objectContaining({
-            expect.objectContaining({
+            id: user.id,
-              id: "member-user",
+            email: "admin@medusa.js",
-              email: "member@test.com",
+            created_at: expect.any(String),
-              first_name: "member",
+            updated_at: expect.any(String),
-              last_name: "user",
+          }),
-              created_at: expect.any(String),
+        ])
-              updated_at: expect.any(String),
-              ...breaking(
-                () => ({ role: "member" }),
-                () => ({})
-              ),
-            }),
-          ])
-        )
       })
     })
 
@@ -172,64 +84,41 @@ medusaIntegrationTestRunner({
       let token
 
       beforeEach(async () => {
-        token = await breaking(
+        token = (
-          () => null,
+          await api.post("/auth/user/emailpass", {
-          async () => {
+            email: "test@test123.com",
-            const emailPassResponse = await api.post("/auth/user/emailpass", {
+            password: "test123",
-              email: "test@test123.com",
+          })
-              password: "test123",
+        ).data.token
-            })
-
-            return emailPassResponse.data.token
-          }
-        )
       })
 
+      // BREAKING: V2 users do not require a role
+      //   We should probably remove this endpoint?
       it("should create a user", async () => {
         const payload = {
           email: "test@test123.com",
-          ...breaking(
-            () => ({ role: "member", password: "test123" }),
-            () => ({})
-          ),
         }
 
         // In V2, the flow to create an authenticated user depends on the token or session of a previously created auth user
-        const headers = breaking(
+        const headers = {
-          () => adminHeaders,
+          headers: { Authorization: `Bearer ${token}` },
-          () => {
+        }
-            return {
-              headers: { Authorization: `Bearer ${token}` },
-            }
-          }
-        )
 
-        const response = await api
+        const response = await api.post("/admin/users", payload, headers)
-          .post("/admin/users", payload, headers)
-          .catch((err) => console.log(err))
 
         expect(response.status).toEqual(200)
         expect(response.data.user).toEqual(
           expect.objectContaining({
-            id: expect.stringMatching(
+            id: expect.stringMatching(/^user_*/),
-              breaking(
-                () => /^usr_*/,
-                () => /^user_*/
-              )
-            ),
             created_at: expect.any(String),
             updated_at: expect.any(String),
             email: "test@test123.com",
-            ...breaking(
-              () => ({ role: "member" }),
-              () => ({})
-            ),
           })
         )
       })
 
       // V2 only test
-      it.skip("should throw, if session/bearer auth is present for existing user", async () => {
+      it("should throw, if session/bearer auth is present for existing user", async () => {
         const emailPassResponse = await api.post("/auth/user/emailpass", {
           email: "test@test123.com",
           password: "test123",
@@ -241,24 +130,26 @@ medusaIntegrationTestRunner({
           headers: { Authorization: `Bearer ${token}` },
         })
 
-        // Create user
+        const res = await api.post(
-        const res = await api
+          "/admin/users",
-          .post(
+          {
-            "/admin/users",
+            email: "test@test123.com",
-            {
+          },
-              email: "test@test123.com",
+          headers(token)
-            },
+        )
-            headers(token)
+
-          )
+        const authenticated = await api.post("/auth/user/emailpass", {
-          .catch((err) => console.log(err))
+          email: "test@test123.com",
+          password: "test123",
+        })
 
         const payload = {
           email: "different@email.com",
         }
 
-        const { response: errorResponse } = await api
+        const errorResponse = await api
-          .post("/admin/users", payload, headers(res.data.token))
+          .post("/admin/users", payload, headers(authenticated.data.token))
-          .catch((err) => err)
+          .catch((err) => err.response)
 
         expect(errorResponse.status).toEqual(400)
         expect(errorResponse.data.message).toEqual(
@@ -268,70 +159,28 @@ medusaIntegrationTestRunner({
     })
 
     describe("POST /admin/users/:id", () => {
-      beforeEach(async () => {
-        await breaking(
-          async () => {
-            await userSeeder(dbConnection)
-          },
-          async () => {
-            await userModuleService.create([
-              {
-                id: "member-user",
-                email: "member@test.com",
-                first_name: "member",
-                last_name: "user",
-              },
-            ])
-          }
-        )
-      })
-
       it("should update a user", async () => {
-        const updateResponse = await api
+        const updateResponse = (
-          .post(
+          await api.post(
-            "/admin/users/member-user",
+            `/admin/users/${user.id}`,
-            { first_name: "karl" },
+            { first_name: "John", last_name: "Doe" },
             adminHeaders
           )
-          .catch((err) => console.log(err.response.data.message))
+        ).data.user
 
-        expect(updateResponse.status).toEqual(200)
+        expect(updateResponse).toEqual(
-        expect(updateResponse.data.user).toEqual(
           expect.objectContaining({
-            id: "member-user",
+            id: user.id,
             created_at: expect.any(String),
             updated_at: expect.any(String),
-            email: "member@test.com",
+            first_name: "John",
-            first_name: "karl",
+            last_name: "Doe",
-            last_name: "user",
-            ...breaking(
-              () => ({ role: "member" }),
-              () => ({})
-            ),
           })
         )
       })
     })
 
     describe("DELETE /admin/users", () => {
-      beforeEach(async () => {
-        await breaking(
-          async () => {
-            await userSeeder(dbConnection)
-          },
-          async () => {
-            await userModuleService.create([
-              {
-                id: "member-user",
-                email: "member@test.com",
-                first_name: "member",
-                last_name: "user",
-              },
-            ])
-          }
-        )
-      })
-
       it("Deletes a user", async () => {
         const userId = "member-user"
 
@@ -352,9 +201,9 @@ medusaIntegrationTestRunner({
       it.skip("Deletes a user and their analytics config", async () => {
         const userId = "member-user"
 
-        await simpleAnalyticsConfigFactory(dbConnection, {
+        // await simpleAnalyticsConfigFactory(dbConnection, {
-          user_id: userId,
+        //   user_id: userId,
-        })
+        // })
 
         const response = await api.delete(
           `/admin/users/${userId}`,
@@ -389,7 +238,7 @@ medusaIntegrationTestRunner({
     })
 
     // TODO: Migrate when implemented in 2.0
-    describe("POST /admin/users/reset-password + POST /admin/users/password-token", () => {
+    describe.skip("POST /admin/users/reset-password + POST /admin/users/password-token", () => {
       let user
       beforeEach(async () => {
         const response = await api

packages/medusa/src/api/admin/invites/accept/route.ts

@@ -1,11 +1,11 @@
 import { acceptInviteWorkflow } from "@medusajs/core-flows"
 import { InviteWorkflow } from "@medusajs/types"
+import { MedusaError } from "@medusajs/utils"
 import {
   AuthenticatedMedusaRequest,
   MedusaResponse,
 } from "../../../../types/routing"
 import { AdminInviteAcceptType } from "../validators"
-import { MedusaError } from "@medusajs/utils"
 
 export const POST = async (
   req: AuthenticatedMedusaRequest<AdminInviteAcceptType>,

packages/medusa/src/utils/middlewares/authenticate-middleware.ts

@@ -1,5 +1,6 @@
 import { ModuleRegistrationName } from "@medusajs/modules-sdk"
 import { ApiKeyDTO, ConfigModule, IApiKeyModuleService } from "@medusajs/types"
+import { ContainerRegistrationKeys } from "@medusajs/utils"
 import { NextFunction, RequestHandler } from "express"
 import jwt, { JwtPayload } from "jsonwebtoken"
 import {
@@ -8,7 +9,6 @@ import {
   MedusaRequest,
   MedusaResponse,
 } from "../../types/routing"
-import { ContainerRegistrationKeys } from "@medusajs/utils"
 
 const SESSION_AUTH = "session"
 const BEARER_AUTH = "bearer"