Chore/integration tests modules utils (#6581)

new wrapper for medusa integration tests.
for now it is only applied to the modules directory, but it could be used in the api integration tests or any other integrations that requires a db and a server up and running. 

It is not perfect, but I wanted to have something working and centralised before improving it, also avoiding too many conflicts with other prs

integration-tests/modules/__tests__/customer-group/admin/batch-add-customers.ts

@@ -1,13 +1,7 @@
-import { initDb, useDb } from "../../../../environment-helpers/use-db"
-
 import { ICustomerModuleService } from "@medusajs/types"
 import { ModuleRegistrationName } from "@medusajs/modules-sdk"
-import adminSeeder from "../../../../helpers/admin-seeder"
 import { createAdminUser } from "../../../helpers/create-admin-user"
-import { getContainer } from "../../../../environment-helpers/use-container"
-import path from "path"
-import { startBootstrapApp } from "../../../../environment-helpers/bootstrap-app"
-import { useApi } from "../../../../environment-helpers/use-api"
+import { medusaIntegrationTestRunner } from "medusa-test-utils"
 
 jest.setTimeout(50000)
 
@@ -16,74 +10,61 @@ const adminHeaders = {
   headers: { "x-medusa-access-token": "test_token" },
 }
 
-describe("POST /admin/customer-groups/:id/customers/batch", () => {
-  let dbConnection
-  let appContainer
-  let shutdownServer
-  let customerModuleService: ICustomerModuleService
+medusaIntegrationTestRunner({
+  env,
+  testSuite: ({ dbConnection, getContainer, api }) => {
+    describe("POST /admin/customer-groups/:id/customers/batch", () => {
+      let appContainer
+      let customerModuleService: ICustomerModuleService
 
-  beforeAll(async () => {
-    const cwd = path.resolve(path.join(__dirname, "..", "..", ".."))
-    dbConnection = await initDb({ cwd, env } as any)
-    shutdownServer = await startBootstrapApp({ cwd, env })
-    appContainer = getContainer()
-    customerModuleService = appContainer.resolve(
-      ModuleRegistrationName.CUSTOMER
-    )
-  })
+      beforeAll(async () => {
+        appContainer = getContainer()
+        customerModuleService = appContainer.resolve(
+          ModuleRegistrationName.CUSTOMER
+        )
+      })
 
-  afterAll(async () => {
-    const db = useDb()
-    await db.shutdown()
-    await shutdownServer()
-  })
+      beforeEach(async () => {
+        await createAdminUser(dbConnection, adminHeaders, appContainer)
+      })
 
-  beforeEach(async () => {
-    await createAdminUser(dbConnection, adminHeaders)
-  })
+      it("should batch add customers to a group", async () => {
+        const group = await customerModuleService.createCustomerGroup({
+          name: "VIP",
+        })
+        const customers = await customerModuleService.create([
+          {
+            first_name: "Test",
+            last_name: "Test",
+          },
+          {
+            first_name: "Test2",
+            last_name: "Test2",
+          },
+          {
+            first_name: "Test3",
+            last_name: "Test3",
+          },
+        ])
 
-  afterEach(async () => {
-    const db = useDb()
-    await db.teardown()
-  })
+        const response = await api.post(
+          `/admin/customer-groups/${group.id}/customers/batch`,
+          {
+            customer_ids: customers.map((c) => ({ id: c.id })),
+          },
+          adminHeaders
+        )
 
-  it("should batch add customers to a group", async () => {
-    const api = useApi() as any
+        expect(response.status).toEqual(200)
 
-    const group = await customerModuleService.createCustomerGroup({
-      name: "VIP",
+        const updatedGroup = await customerModuleService.retrieveCustomerGroup(
+          group.id,
+          {
+            relations: ["customers"],
+          }
+        )
+        expect(updatedGroup.customers?.length).toEqual(3)
+      })
     })
-    const customers = await customerModuleService.create([
-      {
-        first_name: "Test",
-        last_name: "Test",
-      },
-      {
-        first_name: "Test2",
-        last_name: "Test2",
-      },
-      {
-        first_name: "Test3",
-        last_name: "Test3",
-      },
-    ])
-
-    const response = await api.post(
-      `/admin/customer-groups/${group.id}/customers/batch`,
-      {
-        customer_ids: customers.map((c) => ({ id: c.id })),
-      },
-      adminHeaders
-    )
-
-    expect(response.status).toEqual(200)
-
-    const updatedGroup = await customerModuleService.retrieveCustomerGroup(
-      group.id,
-      {
-        relations: ["customers"],
-      }
-    )
-    expect(updatedGroup.customers?.length).toEqual(3)
-  })
+  },
 })

integration-tests/modules/__tests__/customer-group/admin/batch-remove-customers.ts

@@ -1,13 +1,7 @@
-import { initDb, useDb } from "../../../../environment-helpers/use-db"
-
 import { ICustomerModuleService } from "@medusajs/types"
 import { ModuleRegistrationName } from "@medusajs/modules-sdk"
-import adminSeeder from "../../../../helpers/admin-seeder"
 import { createAdminUser } from "../../../helpers/create-admin-user"
-import { getContainer } from "../../../../environment-helpers/use-container"
-import path from "path"
-import { startBootstrapApp } from "../../../../environment-helpers/bootstrap-app"
-import { useApi } from "../../../../environment-helpers/use-api"
+import { medusaIntegrationTestRunner } from "medusa-test-utils"
 
 jest.setTimeout(50000)
 
@@ -16,78 +10,68 @@ const adminHeaders = {
   headers: { "x-medusa-access-token": "test_token" },
 }
 
-describe("DELETE /admin/customer-groups/:id/customers/remove", () => {
-  let dbConnection
-  let appContainer
-  let shutdownServer
-  let customerModuleService: ICustomerModuleService
+medusaIntegrationTestRunner({
+  env,
+  testSuite: ({ dbConnection, getContainer, api }) => {
+    describe("DELETE /admin/customer-groups/:id/customers/remove", () => {
+      let appContainer
+      let customerModuleService: ICustomerModuleService
 
-  beforeAll(async () => {
-    const cwd = path.resolve(path.join(__dirname, "..", "..", ".."))
-    dbConnection = await initDb({ cwd, env } as any)
-    shutdownServer = await startBootstrapApp({ cwd, env })
-    appContainer = getContainer()
-    customerModuleService = appContainer.resolve(
-      ModuleRegistrationName.CUSTOMER
-    )
-  })
+      beforeAll(async () => {
+        appContainer = getContainer()
+        customerModuleService = appContainer.resolve(
+          ModuleRegistrationName.CUSTOMER
+        )
+      })
 
-  afterAll(async () => {
-    const db = useDb()
-    await db.shutdown()
-    await shutdownServer()
-  })
+      beforeEach(async () => {
+        await createAdminUser(dbConnection, adminHeaders, appContainer)
+      })
 
-  beforeEach(async () => {
-    await createAdminUser(dbConnection, adminHeaders)
-  })
+      it("should batch delete customers from a group", async () => {
+        const group = await customerModuleService.createCustomerGroup({
+          name: "VIP",
+        })
+        const customers = await customerModuleService.create([
+          {
+            first_name: "Test",
+            last_name: "Test",
+          },
+          {
+            first_name: "Test2",
+            last_name: "Test2",
+          },
+          {
+            first_name: "Test3",
+            last_name: "Test3",
+          },
+        ])
 
-  afterEach(async () => {
-    const db = useDb()
-    await db.teardown()
-  })
+        await customerModuleService.addCustomerToGroup(
+          customers.map((c) => ({
+            customer_id: c.id,
+            customer_group_id: group.id,
+          }))
+        )
 
-  it("should batch delete customers from a group", async () => {
-    const api = useApi() as any
+        const response = await api.post(
+          `/admin/customer-groups/${group.id}/customers/remove`,
+          {
+            customer_ids: customers.map((c) => ({ id: c.id })),
+          },
+          adminHeaders
+        )
 
-    const group = await customerModuleService.createCustomerGroup({
-      name: "VIP",
+        expect(response.status).toEqual(200)
+
+        const updatedGroup = await customerModuleService.retrieveCustomerGroup(
+          group.id,
+          {
+            relations: ["customers"],
+          }
+        )
+        expect(updatedGroup.customers?.length).toEqual(0)
+      })
     })
-    const customers = await customerModuleService.create([
-      {
-        first_name: "Test",
-        last_name: "Test",
-      },
-      {
-        first_name: "Test2",
-        last_name: "Test2",
-      },
-      {
-        first_name: "Test3",
-        last_name: "Test3",
-      },
-    ])
-
-    await customerModuleService.addCustomerToGroup(
-      customers.map((c) => ({ customer_id: c.id, customer_group_id: group.id }))
-    )
-
-    const response = await api.post(
-      `/admin/customer-groups/${group.id}/customers/remove`,
-      {
-        customer_ids: customers.map((c) => ({ id: c.id })),
-      },
-      adminHeaders
-    )
-
-    expect(response.status).toEqual(200)
-
-    const updatedGroup = await customerModuleService.retrieveCustomerGroup(
-      group.id,
-      {
-        relations: ["customers"],
-      }
-    )
-    expect(updatedGroup.customers?.length).toEqual(0)
-  })
+  },
 })

integration-tests/modules/__tests__/customer-group/admin/create-customer-group.ts

@@ -1,13 +1,7 @@
-import { initDb, useDb } from "../../../../environment-helpers/use-db"
-
 import { ICustomerModuleService } from "@medusajs/types"
 import { ModuleRegistrationName } from "@medusajs/modules-sdk"
-import adminSeeder from "../../../../helpers/admin-seeder"
 import { createAdminUser } from "../../../helpers/create-admin-user"
-import { getContainer } from "../../../../environment-helpers/use-container"
-import path from "path"
-import { startBootstrapApp } from "../../../../environment-helpers/bootstrap-app"
-import { useApi } from "../../../../environment-helpers/use-api"
+import { medusaIntegrationTestRunner } from "medusa-test-utils"
 
 jest.setTimeout(50000)
 
@@ -16,55 +10,43 @@ const adminHeaders = {
   headers: { "x-medusa-access-token": "test_token" },
 }
 
-describe("POST /admin/customer-groups", () => {
-  let dbConnection
-  let appContainer
-  let shutdownServer
-  let customerModuleService: ICustomerModuleService
+medusaIntegrationTestRunner({
+  env,
+  testSuite: ({ dbConnection, getContainer, api }) => {
+    describe("POST /admin/customer-groups", () => {
+      let appContainer
+      let customerModuleService: ICustomerModuleService
 
-  beforeAll(async () => {
-    const cwd = path.resolve(path.join(__dirname, "..", "..", ".."))
-    dbConnection = await initDb({ cwd, env } as any)
-    shutdownServer = await startBootstrapApp({ cwd, env })
-    appContainer = getContainer()
-    customerModuleService = appContainer.resolve(
-      ModuleRegistrationName.CUSTOMER
-    )
-  })
-
-  afterAll(async () => {
-    const db = useDb()
-    await db.shutdown()
-    await shutdownServer()
-  })
-
-  beforeEach(async () => {
-    await createAdminUser(dbConnection, adminHeaders)
-    // await adminSeeder(dbConnection)
-  })
-
-  afterEach(async () => {
-    const db = useDb()
-    await db.teardown()
-  })
-
-  it("should create a customer group", async () => {
-    const api = useApi() as any
-    const response = await api.post(
-      `/admin/customer-groups`,
-      {
-        name: "VIP",
-      },
-      adminHeaders
-    )
-
-    expect(response.status).toEqual(200)
-    expect(response.data.customer_group).toEqual(
-      expect.objectContaining({
-        id: expect.any(String),
-        name: "VIP",
-        created_by: "admin_user",
+      beforeAll(async () => {
+        appContainer = getContainer()
+        customerModuleService = appContainer.resolve(
+          ModuleRegistrationName.CUSTOMER
+        )
       })
-    )
-  })
+
+      beforeEach(async () => {
+        await createAdminUser(dbConnection, adminHeaders, appContainer)
+        // await adminSeeder(dbConnection)
+      })
+
+      it("should create a customer group", async () => {
+        const response = await api.post(
+          `/admin/customer-groups`,
+          {
+            name: "VIP",
+          },
+          adminHeaders
+        )
+
+        expect(response.status).toEqual(200)
+        expect(response.data.customer_group).toEqual(
+          expect.objectContaining({
+            id: expect.any(String),
+            name: "VIP",
+            created_by: "admin_user",
+          })
+        )
+      })
+    })
+  },
 })

integration-tests/modules/__tests__/customer-group/admin/delete-customer-group.ts

@@ -1,13 +1,7 @@
-import { initDb, useDb } from "../../../../environment-helpers/use-db"
-
 import { ICustomerModuleService } from "@medusajs/types"
 import { ModuleRegistrationName } from "@medusajs/modules-sdk"
-import adminSeeder from "../../../../helpers/admin-seeder"
 import { createAdminUser } from "../../../helpers/create-admin-user"
-import { getContainer } from "../../../../environment-helpers/use-container"
-import path from "path"
-import { startBootstrapApp } from "../../../../environment-helpers/bootstrap-app"
-import { useApi } from "../../../../environment-helpers/use-api"
+import { medusaIntegrationTestRunner } from "medusa-test-utils"
 
 jest.setTimeout(50000)
 
@@ -16,54 +10,42 @@ const adminHeaders = {
   headers: { "x-medusa-access-token": "test_token" },
 }
 
-describe("DELETE /admin/customer-groups/:id", () => {
-  let dbConnection
-  let appContainer
-  let shutdownServer
-  let customerModuleService: ICustomerModuleService
+medusaIntegrationTestRunner({
+  env,
+  testSuite: ({ dbConnection, getContainer, api }) => {
+    describe("DELETE /admin/customer-groups/:id", () => {
+      let appContainer
+      let customerModuleService: ICustomerModuleService
 
-  beforeAll(async () => {
-    const cwd = path.resolve(path.join(__dirname, "..", "..", ".."))
-    dbConnection = await initDb({ cwd, env } as any)
-    shutdownServer = await startBootstrapApp({ cwd, env })
-    appContainer = getContainer()
-    customerModuleService = appContainer.resolve(
-      ModuleRegistrationName.CUSTOMER
-    )
-  })
+      beforeAll(async () => {
+        appContainer = getContainer()
+        customerModuleService = appContainer.resolve(
+          ModuleRegistrationName.CUSTOMER
+        )
+      })
 
-  afterAll(async () => {
-    const db = useDb()
-    await db.shutdown()
-    await shutdownServer()
-  })
+      beforeEach(async () => {
+        await createAdminUser(dbConnection, adminHeaders, appContainer)
+      })
 
-  beforeEach(async () => {
-    await createAdminUser(dbConnection, adminHeaders)
-  })
+      it("should delete a group", async () => {
+        const group = await customerModuleService.createCustomerGroup({
+          name: "VIP",
+        })
 
-  afterEach(async () => {
-    const db = useDb()
-    await db.teardown()
-  })
+        const response = await api.delete(
+          `/admin/customer-groups/${group.id}`,
+          adminHeaders
+        )
 
-  it("should delete a group", async () => {
-    const group = await customerModuleService.createCustomerGroup({
-      name: "VIP",
+        expect(response.status).toEqual(200)
+
+        const deletedCustomer =
+          await customerModuleService.retrieveCustomerGroup(group.id, {
+            withDeleted: true,
+          })
+        expect(deletedCustomer.deleted_at).toBeTruthy()
+      })
     })
-
-    const api = useApi() as any
-    const response = await api.delete(
-      `/admin/customer-groups/${group.id}`,
-      adminHeaders
-    )
-
-    expect(response.status).toEqual(200)
-
-    const deletedCustomer = await customerModuleService.retrieveCustomerGroup(
-      group.id,
-      { withDeleted: true }
-    )
-    expect(deletedCustomer.deleted_at).toBeTruthy()
-  })
+  },
 })

integration-tests/modules/__tests__/customer-group/admin/list-customer-group-customers.ts

@@ -1,13 +1,7 @@
-import { initDb, useDb } from "../../../../environment-helpers/use-db"
-
 import { ICustomerModuleService } from "@medusajs/types"
 import { ModuleRegistrationName } from "@medusajs/modules-sdk"
-import adminSeeder from "../../../../helpers/admin-seeder"
 import { createAdminUser } from "../../../helpers/create-admin-user"
-import { getContainer } from "../../../../environment-helpers/use-container"
-import path from "path"
-import { startBootstrapApp } from "../../../../environment-helpers/bootstrap-app"
-import { useApi } from "../../../../environment-helpers/use-api"
+import { medusaIntegrationTestRunner } from "medusa-test-utils"
 
 jest.setTimeout(50000)
 
@@ -16,77 +10,67 @@ const adminHeaders = {
   headers: { "x-medusa-access-token": "test_token" },
 }
 
-describe("GET /admin/customer-groups/:id/customers", () => {
-  let dbConnection
-  let appContainer
-  let shutdownServer
-  let customerModuleService: ICustomerModuleService
+medusaIntegrationTestRunner({
+  env,
+  testSuite: ({ dbConnection, getContainer, api }) => {
+    describe("GET /admin/customer-groups/:id/customers", () => {
+      let appContainer
+      let customerModuleService: ICustomerModuleService
 
-  beforeAll(async () => {
-    const cwd = path.resolve(path.join(__dirname, "..", "..", ".."))
-    dbConnection = await initDb({ cwd, env } as any)
-    shutdownServer = await startBootstrapApp({ cwd, env })
-    appContainer = getContainer()
-    customerModuleService = appContainer.resolve(
-      ModuleRegistrationName.CUSTOMER
-    )
-  })
+      beforeAll(async () => {
+        appContainer = getContainer()
+        customerModuleService = appContainer.resolve(
+          ModuleRegistrationName.CUSTOMER
+        )
+      })
 
-  afterAll(async () => {
-    const db = useDb()
-    await db.shutdown()
-    await shutdownServer()
-  })
+      beforeEach(async () => {
+        await createAdminUser(dbConnection, adminHeaders, appContainer)
+      })
 
-  beforeEach(async () => {
-    await createAdminUser(dbConnection, adminHeaders)
-  })
+      it("should get all customer groups and its count", async () => {
+        const group = await customerModuleService.createCustomerGroup({
+          name: "Test",
+        })
 
-  afterEach(async () => {
-    const db = useDb()
-    await db.teardown()
-  })
+        const customers = await customerModuleService.create([
+          {
+            first_name: "Test",
+            last_name: "Test",
+          },
+          {
+            first_name: "Test2",
+            last_name: "Test2",
+          },
+        ])
 
-  it("should get all customer groups and its count", async () => {
-    const group = await customerModuleService.createCustomerGroup({
-      name: "Test",
+        // add to group
+
+        await customerModuleService.addCustomerToGroup(
+          customers.map((c) => ({
+            customer_id: c.id,
+            customer_group_id: group.id,
+          }))
+        )
+
+        const response = await api.get(
+          `/admin/customer-groups/${group.id}/customers`,
+          adminHeaders
+        )
+
+        expect(response.status).toEqual(200)
+        expect(response.data.count).toEqual(2)
+        expect(response.data.customers).toEqual(
+          expect.arrayContaining([
+            expect.objectContaining({
+              id: customers[0].id,
+            }),
+            expect.objectContaining({
+              id: customers[1].id,
+            }),
+          ])
+        )
+      })
     })
-
-    const customers = await customerModuleService.create([
-      {
-        first_name: "Test",
-        last_name: "Test",
-      },
-      {
-        first_name: "Test2",
-        last_name: "Test2",
-      },
-    ])
-
-    // add to group
-
-    await customerModuleService.addCustomerToGroup(
-      customers.map((c) => ({ customer_id: c.id, customer_group_id: group.id }))
-    )
-
-    const api = useApi() as any
-
-    const response = await api.get(
-      `/admin/customer-groups/${group.id}/customers`,
-      adminHeaders
-    )
-
-    expect(response.status).toEqual(200)
-    expect(response.data.count).toEqual(2)
-    expect(response.data.customers).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({
-          id: customers[0].id,
-        }),
-        expect.objectContaining({
-          id: customers[1].id,
-        }),
-      ])
-    )
-  })
+  },
 })

integration-tests/modules/__tests__/customer-group/admin/list-customer-groups.spec.ts

@@ -1,13 +1,7 @@
-import { initDb, useDb } from "../../../../environment-helpers/use-db"
-
 import { ICustomerModuleService } from "@medusajs/types"
 import { ModuleRegistrationName } from "@medusajs/modules-sdk"
-import adminSeeder from "../../../../helpers/admin-seeder"
 import { createAdminUser } from "../../../helpers/create-admin-user"
-import { getContainer } from "../../../../environment-helpers/use-container"
-import path from "path"
-import { startBootstrapApp } from "../../../../environment-helpers/bootstrap-app"
-import { useApi } from "../../../../environment-helpers/use-api"
+import { medusaIntegrationTestRunner } from "medusa-test-utils"
 
 jest.setTimeout(50000)
 
@@ -16,52 +10,40 @@ const adminHeaders = {
   headers: { "x-medusa-access-token": "test_token" },
 }
 
-describe("GET /admin/customer-groups", () => {
-  let dbConnection
-  let appContainer
-  let shutdownServer
-  let customerModuleService: ICustomerModuleService
+medusaIntegrationTestRunner({
+  env,
+  testSuite: ({ dbConnection, getContainer, api }) => {
+    describe("GET /admin/customer-groups", () => {
+      let appContainer
+      let customerModuleService: ICustomerModuleService
 
-  beforeAll(async () => {
-    const cwd = path.resolve(path.join(__dirname, "..", "..", ".."))
-    dbConnection = await initDb({ cwd, env } as any)
-    shutdownServer = await startBootstrapApp({ cwd, env })
-    appContainer = getContainer()
-    customerModuleService = appContainer.resolve(
-      ModuleRegistrationName.CUSTOMER
-    )
-  })
+      beforeAll(async () => {
+        appContainer = getContainer()
+        customerModuleService = appContainer.resolve(
+          ModuleRegistrationName.CUSTOMER
+        )
+      })
 
-  afterAll(async () => {
-    const db = useDb()
-    await db.shutdown()
-    await shutdownServer()
-  })
+      beforeEach(async () => {
+        await createAdminUser(dbConnection, adminHeaders, appContainer)
+      })
 
-  beforeEach(async () => {
-    await createAdminUser(dbConnection, adminHeaders)
-  })
+      it("should get all customer groups and its count", async () => {
+        await customerModuleService.createCustomerGroup({
+          name: "Test",
+        })
 
-  afterEach(async () => {
-    const db = useDb()
-    await db.teardown()
-  })
+        const response = await api.get(`/admin/customer-groups`, adminHeaders)
 
-  it("should get all customer groups and its count", async () => {
-    await customerModuleService.createCustomerGroup({
-      name: "Test",
+        expect(response.status).toEqual(200)
+        expect(response.data.count).toEqual(1)
+        expect(response.data.customer_groups).toEqual([
+          expect.objectContaining({
+            id: expect.any(String),
+            name: "Test",
+          }),
+        ])
+      })
     })
-
-    const api = useApi() as any
-    const response = await api.get(`/admin/customer-groups`, adminHeaders)
-
-    expect(response.status).toEqual(200)
-    expect(response.data.count).toEqual(1)
-    expect(response.data.customer_groups).toEqual([
-      expect.objectContaining({
-        id: expect.any(String),
-        name: "Test",
-      }),
-    ])
-  })
+  },
 })

integration-tests/modules/__tests__/customer-group/admin/retrieve-customer-group.ts

@@ -1,13 +1,7 @@
-import { initDb, useDb } from "../../../../environment-helpers/use-db"
-
 import { ICustomerModuleService } from "@medusajs/types"
 import { ModuleRegistrationName } from "@medusajs/modules-sdk"
-import adminSeeder from "../../../../helpers/admin-seeder"
 import { createAdminUser } from "../../../helpers/create-admin-user"
-import { getContainer } from "../../../../environment-helpers/use-container"
-import path from "path"
-import { startBootstrapApp } from "../../../../environment-helpers/bootstrap-app"
-import { useApi } from "../../../../environment-helpers/use-api"
+import { medusaIntegrationTestRunner } from "medusa-test-utils"
 
 jest.setTimeout(50000)
 
@@ -16,54 +10,42 @@ const adminHeaders = {
   headers: { "x-medusa-access-token": "test_token" },
 }
 
-describe("GET /admin/customer-groups/:id", () => {
-  let dbConnection
-  let appContainer
-  let shutdownServer
-  let customerModuleService: ICustomerModuleService
+medusaIntegrationTestRunner({
+  env,
+  testSuite: ({ dbConnection, getContainer, api }) => {
+    describe("GET /admin/customer-groups/:id", () => {
+      let appContainer
+      let customerModuleService: ICustomerModuleService
 
-  beforeAll(async () => {
-    const cwd = path.resolve(path.join(__dirname, "..", "..", ".."))
-    dbConnection = await initDb({ cwd, env } as any)
-    shutdownServer = await startBootstrapApp({ cwd, env })
-    appContainer = getContainer()
-    customerModuleService = appContainer.resolve(
-      ModuleRegistrationName.CUSTOMER
-    )
-  })
-
-  afterAll(async () => {
-    const db = useDb()
-    await db.shutdown()
-    await shutdownServer()
-  })
-
-  beforeEach(async () => {
-    await createAdminUser(dbConnection, adminHeaders)
-  })
-
-  afterEach(async () => {
-    const db = useDb()
-    await db.teardown()
-  })
-
-  it("should retrieve customer group", async () => {
-    const group = await customerModuleService.createCustomerGroup({
-      name: "Test",
-    })
-
-    const api = useApi() as any
-    const response = await api.get(
-      `/admin/customer-groups/${group.id}`,
-      adminHeaders
-    )
-
-    expect(response.status).toEqual(200)
-    expect(response.data.customer_group).toEqual(
-      expect.objectContaining({
-        id: expect.any(String),
-        name: "Test",
+      beforeAll(async () => {
+        appContainer = getContainer()
+        customerModuleService = appContainer.resolve(
+          ModuleRegistrationName.CUSTOMER
+        )
       })
-    )
-  })
+
+      beforeEach(async () => {
+        await createAdminUser(dbConnection, adminHeaders, appContainer)
+      })
+
+      it("should retrieve customer group", async () => {
+        const group = await customerModuleService.createCustomerGroup({
+          name: "Test",
+        })
+
+        const response = await api.get(
+          `/admin/customer-groups/${group.id}`,
+          adminHeaders
+        )
+
+        expect(response.status).toEqual(200)
+        expect(response.data.customer_group).toEqual(
+          expect.objectContaining({
+            id: expect.any(String),
+            name: "Test",
+          })
+        )
+      })
+    })
+  },
 })

integration-tests/modules/__tests__/customer-group/admin/update-customer-group.ts

@@ -1,13 +1,7 @@
-import { initDb, useDb } from "../../../../environment-helpers/use-db"
-
 import { ICustomerModuleService } from "@medusajs/types"
 import { ModuleRegistrationName } from "@medusajs/modules-sdk"
-import adminSeeder from "../../../../helpers/admin-seeder"
 import { createAdminUser } from "../../../helpers/create-admin-user"
-import { getContainer } from "../../../../environment-helpers/use-container"
-import path from "path"
-import { startBootstrapApp } from "../../../../environment-helpers/bootstrap-app"
-import { useApi } from "../../../../environment-helpers/use-api"
+import { medusaIntegrationTestRunner } from "medusa-test-utils"
 
 jest.setTimeout(50000)
 
@@ -16,57 +10,45 @@ const adminHeaders = {
   headers: { "x-medusa-access-token": "test_token" },
 }
 
-describe("POST /admin/customer-groups/:id", () => {
-  let dbConnection
-  let appContainer
-  let shutdownServer
-  let customerModuleService: ICustomerModuleService
+medusaIntegrationTestRunner({
+  env,
+  testSuite: ({ dbConnection, getContainer, api }) => {
+    describe("POST /admin/customer-groups/:id", () => {
+      let appContainer
+      let customerModuleService: ICustomerModuleService
 
-  beforeAll(async () => {
-    const cwd = path.resolve(path.join(__dirname, "..", "..", ".."))
-    dbConnection = await initDb({ cwd, env } as any)
-    shutdownServer = await startBootstrapApp({ cwd, env })
-    appContainer = getContainer()
-    customerModuleService = appContainer.resolve(
-      ModuleRegistrationName.CUSTOMER
-    )
-  })
-
-  afterAll(async () => {
-    const db = useDb()
-    await db.shutdown()
-    await shutdownServer()
-  })
-
-  beforeEach(async () => {
-    await createAdminUser(dbConnection, adminHeaders)
-  })
-
-  afterEach(async () => {
-    const db = useDb()
-    await db.teardown()
-  })
-
-  it("should update a customer group", async () => {
-    const customer = await customerModuleService.createCustomerGroup({
-      name: "VIP",
-    })
-
-    const api = useApi() as any
-    const response = await api.post(
-      `/admin/customer-groups/${customer.id}`,
-      {
-        name: "regular",
-      },
-      adminHeaders
-    )
-
-    expect(response.status).toEqual(200)
-    expect(response.data.customer_group).toEqual(
-      expect.objectContaining({
-        id: expect.any(String),
-        name: "regular",
+      beforeAll(async () => {
+        appContainer = getContainer()
+        customerModuleService = appContainer.resolve(
+          ModuleRegistrationName.CUSTOMER
+        )
       })
-    )
-  })
+
+      beforeEach(async () => {
+        await createAdminUser(dbConnection, adminHeaders, appContainer)
+      })
+
+      it("should update a customer group", async () => {
+        const customer = await customerModuleService.createCustomerGroup({
+          name: "VIP",
+        })
+
+        const response = await api.post(
+          `/admin/customer-groups/${customer.id}`,
+          {
+            name: "regular",
+          },
+          adminHeaders
+        )
+
+        expect(response.status).toEqual(200)
+        expect(response.data.customer_group).toEqual(
+          expect.objectContaining({
+            id: expect.any(String),
+            name: "regular",
+          })
+        )
+      })
+    })
+  },
 })