From ce40fe88f58f100e70dcc4bd1e15b2f6d711ed6a Mon Sep 17 00:00:00 2001 From: Oli Juhl <59018053+olivermrbl@users.noreply.github.com> Date: Tue, 4 Jun 2024 10:53:01 +0200 Subject: [PATCH] chore: Move admin invites + user tests to HTTP (#7596) --- .../api/__tests__/admin/invite.js | 393 ------------------ .../helpers/create-admin-user.ts | 2 + .../__tests__/invite/admin/invite.spec.ts | 181 ++++++++ .../__tests__/user/admin/user.spec.ts} | 303 ++++---------- .../src/api/admin/invites/accept/route.ts | 2 +- .../middlewares/authenticate-middleware.ts | 2 +- 6 files changed, 261 insertions(+), 622 deletions(-) delete mode 100644 integration-tests/api/__tests__/admin/invite.js create mode 100644 integration-tests/http/__tests__/invite/admin/invite.spec.ts rename integration-tests/{api/__tests__/admin/user.js => http/__tests__/user/admin/user.spec.ts} (57%) diff --git a/integration-tests/api/__tests__/admin/invite.js b/integration-tests/api/__tests__/admin/invite.js deleted file mode 100644 index 170cc0432f..0000000000 --- a/integration-tests/api/__tests__/admin/invite.js +++ /dev/null @@ -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 })]) - ) - }) - }) -}) diff --git a/integration-tests/helpers/create-admin-user.ts b/integration-tests/helpers/create-admin-user.ts index c83d642ed7..46fb0fe528 100644 --- a/integration-tests/helpers/create-admin-user.ts +++ b/integration-tests/helpers/create-admin-user.ts @@ -47,4 +47,6 @@ export const createAdminUser = async ( ) adminHeaders.headers["authorization"] = `Bearer ${token}` + + return { user } } diff --git a/integration-tests/http/__tests__/invite/admin/invite.spec.ts b/integration-tests/http/__tests__/invite/admin/invite.spec.ts new file mode 100644 index 0000000000..a7321d7bc2 --- /dev/null +++ b/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, + }) + }) + }) + }, +}) diff --git a/integration-tests/api/__tests__/admin/user.js b/integration-tests/http/__tests__/user/admin/user.spec.ts similarity index 57% rename from integration-tests/api/__tests__/admin/user.js rename to integration-tests/http/__tests__/user/admin/user.spec.ts index 4f273bebf4..0bce05ac99 100644 --- a/integration-tests/api/__tests__/admin/user.js +++ b/integration-tests/http/__tests__/user/admin/user.spec.ts @@ -1,170 +1,82 @@ -const jwt = require("jsonwebtoken") - -const { medusaIntegrationTestRunner } = require("medusa-test-utils") -const { - createAdminUser, +import { medusaIntegrationTestRunner } from "medusa-test-utils" +import { adminHeaders, -} = require("../../../helpers/create-admin-user") -const { breaking } = require("../../../helpers/breaking") -const { ModuleRegistrationName } = require("@medusajs/modules-sdk") + createAdminUser, +} from "../../../../helpers/create-admin-user" jest.setTimeout(30000) -let userSeeder = {} -let simpleAnalyticsConfigFactory = {} - medusaIntegrationTestRunner({ - // env: { MEDUSA_FF_MEDUSA_V2: true }, testSuite: ({ dbConnection, getContainer, api }) => { - let container - let userModuleService - - beforeAll(() => { - userSeeder = require("../../../helpers/user-seeder") - simpleAnalyticsConfigFactory = require("../../../factories/simple-analytics-config-factory") - }) + let user beforeEach(async () => { - container = getContainer() + const container = getContainer() + const { user: adminUser } = await createAdminUser( + dbConnection, + adminHeaders, + container + ) - userModuleService = container.resolve(ModuleRegistrationName.USER) - - await createAdminUser(dbConnection, adminHeaders, container) + user = adminUser }) 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 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 response = await api.get(`/admin/users/${user.id}`, adminHeaders) 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.objectContaining( - breaking( - () => v1Response, - () => v2Response - ) - ) - ) + expect(response.data.user).toEqual(expect.objectContaining(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.arrayContaining( - breaking( - () => v1Response, - () => v2Response - ) - ) - ) + expect(response.data.users).toEqual(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.arrayContaining([ - 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), - ...breaking( - () => ({ role: "member" }), - () => ({}) - ), - }), - ]) - ) + expect(response.data.users).toEqual([ + expect.objectContaining({ + id: user.id, + email: "admin@medusa.js", + created_at: expect.any(String), + updated_at: expect.any(String), + }), + ]) }) }) @@ -172,64 +84,41 @@ medusaIntegrationTestRunner({ let token beforeEach(async () => { - token = await breaking( - () => null, - async () => { - const emailPassResponse = await api.post("/auth/user/emailpass", { - email: "test@test123.com", - password: "test123", - }) - - return emailPassResponse.data.token - } - ) + token = ( + await api.post("/auth/user/emailpass", { + email: "test@test123.com", + password: "test123", + }) + ).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( - () => adminHeaders, - () => { - return { - headers: { Authorization: `Bearer ${token}` }, - } - } - ) + const headers = { + headers: { Authorization: `Bearer ${token}` }, + } - const response = await api - .post("/admin/users", payload, headers) - .catch((err) => console.log(err)) + const response = await api.post("/admin/users", payload, headers) expect(response.status).toEqual(200) expect(response.data.user).toEqual( expect.objectContaining({ - id: expect.stringMatching( - breaking( - () => /^usr_*/, - () => /^user_*/ - ) - ), + id: expect.stringMatching(/^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( - "/admin/users", - { - email: "test@test123.com", - }, - headers(token) - ) - .catch((err) => console.log(err)) + const res = await api.post( + "/admin/users", + { + email: "test@test123.com", + }, + headers(token) + ) + + const authenticated = await api.post("/auth/user/emailpass", { + email: "test@test123.com", + password: "test123", + }) const payload = { email: "different@email.com", } - const { response: errorResponse } = await api - .post("/admin/users", payload, headers(res.data.token)) - .catch((err) => err) + const errorResponse = await api + .post("/admin/users", payload, headers(authenticated.data.token)) + .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 - .post( - "/admin/users/member-user", - { first_name: "karl" }, + const updateResponse = ( + await api.post( + `/admin/users/${user.id}`, + { first_name: "John", last_name: "Doe" }, adminHeaders ) - .catch((err) => console.log(err.response.data.message)) + ).data.user - expect(updateResponse.status).toEqual(200) - expect(updateResponse.data.user).toEqual( + expect(updateResponse).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: "karl", - last_name: "user", - ...breaking( - () => ({ role: "member" }), - () => ({}) - ), + first_name: "John", + last_name: "Doe", }) ) }) }) 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, { - user_id: userId, - }) + // await simpleAnalyticsConfigFactory(dbConnection, { + // 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 diff --git a/packages/medusa/src/api/admin/invites/accept/route.ts b/packages/medusa/src/api/admin/invites/accept/route.ts index 30ef6bb21b..0681477197 100644 --- a/packages/medusa/src/api/admin/invites/accept/route.ts +++ b/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, diff --git a/packages/medusa/src/utils/middlewares/authenticate-middleware.ts b/packages/medusa/src/utils/middlewares/authenticate-middleware.ts index c3e54d9c39..16c9685d7d 100644 --- a/packages/medusa/src/utils/middlewares/authenticate-middleware.ts +++ b/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"