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/admin/create-customer-addresses.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,142 +10,127 @@ const adminHeaders = {
   headers: { "x-medusa-access-token": "test_token" },
 }
 
-describe("POST /admin/customers/:id/addresses", () => {
-  let dbConnection
-  let appContainer
-  let shutdownServer
-  let customerModuleService: ICustomerModuleService
+medusaIntegrationTestRunner({
+  env,
+  testSuite: ({ dbConnection, getContainer, api }) => {
+    describe("POST /admin/customers/:id/addresses", () => {
+      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 create a customer address", async () => {
-    // Create a customer
-    const customer = await customerModuleService.create({
-      first_name: "John",
-      last_name: "Doe",
-    })
-
-    const api = useApi() as any
-    const response = await api.post(
-      `/admin/customers/${customer.id}/addresses`,
-      {
-        first_name: "John",
-        last_name: "Doe",
-        address_1: "Test street 1",
-      },
-      adminHeaders
-    )
-
-    expect(response.status).toEqual(200)
-    expect(response.data.address).toEqual(
-      expect.objectContaining({
-        id: expect.any(String),
-        first_name: "John",
-        last_name: "Doe",
-        address_1: "Test street 1",
+      beforeAll(async () => {
+        appContainer = getContainer()
+        customerModuleService = appContainer.resolve(
+          ModuleRegistrationName.CUSTOMER
+        )
       })
-    )
 
-    const customerWithAddresses = await customerModuleService.retrieve(
-      customer.id,
-      { relations: ["addresses"] }
-    )
-
-    expect(customerWithAddresses.addresses?.length).toEqual(1)
-  })
-
-  it("sets new shipping address as default and unsets the old one", async () => {
-    const customer = await customerModuleService.create({
-      first_name: "John",
-      last_name: "Doe",
-      addresses: [
-        {
+      beforeEach(async () => {
+        await createAdminUser(dbConnection, adminHeaders, appContainer)
+      })
+      it("should create a customer address", async () => {
+        // Create a customer
+        const customer = await customerModuleService.create({
           first_name: "John",
           last_name: "Doe",
-          address_1: "Test street 1",
+        })
+
+        const response = await api.post(
+          `/admin/customers/${customer.id}/addresses`,
+          {
+            first_name: "John",
+            last_name: "Doe",
+            address_1: "Test street 1",
+          },
+          adminHeaders
+        )
+
+        expect(response.status).toEqual(200)
+        expect(response.data.address).toEqual(
+          expect.objectContaining({
+            id: expect.any(String),
+            first_name: "John",
+            last_name: "Doe",
+            address_1: "Test street 1",
+          })
+        )
+
+        const customerWithAddresses = await customerModuleService.retrieve(
+          customer.id,
+          { relations: ["addresses"] }
+        )
+
+        expect(customerWithAddresses.addresses?.length).toEqual(1)
+      })
+
+      it("sets new shipping address as default and unsets the old one", async () => {
+        const customer = await customerModuleService.create({
+          first_name: "John",
+          last_name: "Doe",
+          addresses: [
+            {
+              first_name: "John",
+              last_name: "Doe",
+              address_1: "Test street 1",
+              is_default_shipping: true,
+            },
+          ],
+        })
+
+        const response = await api.post(
+          `/admin/customers/${customer.id}/addresses`,
+          {
+            first_name: "John",
+            last_name: "Doe",
+            address_1: "Test street 2",
+            is_default_shipping: true,
+          },
+          adminHeaders
+        )
+
+        expect(response.status).toEqual(200)
+
+        const [address] = await customerModuleService.listAddresses({
+          customer_id: customer.id,
           is_default_shipping: true,
-        },
-      ],
-    })
+        })
 
-    const api = useApi() as any
-    const response = await api.post(
-      `/admin/customers/${customer.id}/addresses`,
-      {
-        first_name: "John",
-        last_name: "Doe",
-        address_1: "Test street 2",
-        is_default_shipping: true,
-      },
-      adminHeaders
-    )
+        expect(address.address_1).toEqual("Test street 2")
+      })
 
-    expect(response.status).toEqual(200)
-
-    const [address] = await customerModuleService.listAddresses({
-      customer_id: customer.id,
-      is_default_shipping: true,
-    })
-
-    expect(address.address_1).toEqual("Test street 2")
-  })
-
-  it("sets new billing address as default and unsets the old one", async () => {
-    const customer = await customerModuleService.create({
-      first_name: "John",
-      last_name: "Doe",
-      addresses: [
-        {
+      it("sets new billing address as default and unsets the old one", async () => {
+        const customer = await customerModuleService.create({
           first_name: "John",
           last_name: "Doe",
-          address_1: "Test street 1",
+          addresses: [
+            {
+              first_name: "John",
+              last_name: "Doe",
+              address_1: "Test street 1",
+              is_default_billing: true,
+            },
+          ],
+        })
+
+        const response = await api.post(
+          `/admin/customers/${customer.id}/addresses`,
+          {
+            first_name: "John",
+            last_name: "Doe",
+            address_1: "Test street 2",
+            is_default_billing: true,
+          },
+          adminHeaders
+        )
+
+        expect(response.status).toEqual(200)
+
+        const [address] = await customerModuleService.listAddresses({
+          customer_id: customer.id,
           is_default_billing: true,
-        },
-      ],
+        })
+
+        expect(address.address_1).toEqual("Test street 2")
+      })
     })
-
-    const api = useApi() as any
-    const response = await api.post(
-      `/admin/customers/${customer.id}/addresses`,
-      {
-        first_name: "John",
-        last_name: "Doe",
-        address_1: "Test street 2",
-        is_default_billing: true,
-      },
-      adminHeaders
-    )
-
-    expect(response.status).toEqual(200)
-
-    const [address] = await customerModuleService.listAddresses({
-      customer_id: customer.id,
-      is_default_billing: true,
-    })
-
-    expect(address.address_1).toEqual("Test street 2")
-  })
+  },
 })

integration-tests/modules/__tests__/customer/admin/create-customer.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,56 +10,44 @@ const adminHeaders = {
   headers: { "x-medusa-access-token": "test_token" },
 }
 
-describe("POST /admin/customers", () => {
-  let dbConnection
-  let appContainer
-  let shutdownServer
-  let customerModuleService: ICustomerModuleService
+medusaIntegrationTestRunner({
+  env,
+  testSuite: ({ dbConnection, getContainer, api }) => {
+    describe("POST /admin/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
-    )
-  })
-
-  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 create a customer", async () => {
-    const api = useApi() as any
-    const response = await api.post(
-      `/admin/customers`,
-      {
-        first_name: "John",
-        last_name: "Doe",
-      },
-      adminHeaders
-    )
-
-    expect(response.status).toEqual(200)
-    expect(response.data.customer).toEqual(
-      expect.objectContaining({
-        id: expect.any(String),
-        first_name: "John",
-        last_name: "Doe",
-        created_by: "admin_user",
+      beforeAll(async () => {
+        appContainer = getContainer()
+        customerModuleService = appContainer.resolve(
+          ModuleRegistrationName.CUSTOMER
+        )
       })
-    )
-  })
+
+      beforeEach(async () => {
+        await createAdminUser(dbConnection, adminHeaders, appContainer)
+      })
+
+      it("should create a customer", async () => {
+        const response = await api.post(
+          `/admin/customers`,
+          {
+            first_name: "John",
+            last_name: "Doe",
+          },
+          adminHeaders
+        )
+
+        expect(response.status).toEqual(200)
+        expect(response.data.customer).toEqual(
+          expect.objectContaining({
+            id: expect.any(String),
+            first_name: "John",
+            last_name: "Doe",
+            created_by: "admin_user",
+          })
+        )
+      })
+    })
+  },
 })

integration-tests/modules/__tests__/customer/admin/delete-customer-address.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,62 +10,53 @@ const adminHeaders = {
   headers: { "x-medusa-access-token": "test_token" },
 }
 
-describe("DELETE /admin/customers/:id/addresses/:address_id", () => {
-  let dbConnection
-  let appContainer
-  let shutdownServer
-  let customerModuleService: ICustomerModuleService
+medusaIntegrationTestRunner({
+  env,
+  testSuite: ({ dbConnection, getContainer, api }) => {
+    describe("DELETE /admin/customers/:id/addresses/:address_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 update a customer address", async () => {
+        const customer = await customerModuleService.create({
+          first_name: "John",
+          last_name: "Doe",
+        })
 
-  afterEach(async () => {
-    const db = useDb()
-    await db.teardown()
-  })
+        const address = await customerModuleService.addAddresses({
+          customer_id: customer.id,
+          first_name: "John",
+          last_name: "Doe",
+          address_1: "Test street 1",
+        })
 
-  it("should update a customer address", async () => {
-    const customer = await customerModuleService.create({
-      first_name: "John",
-      last_name: "Doe",
+        const response = await api.delete(
+          `/admin/customers/${customer.id}/addresses/${address.id}`,
+          adminHeaders
+        )
+
+        expect(response.status).toEqual(200)
+
+        const updatedCustomer = await customerModuleService.retrieve(
+          customer.id,
+          {
+            relations: ["addresses"],
+          }
+        )
+
+        expect(updatedCustomer.addresses?.length).toEqual(0)
+      })
     })
-
-    const address = await customerModuleService.addAddresses({
-      customer_id: customer.id,
-      first_name: "John",
-      last_name: "Doe",
-      address_1: "Test street 1",
-    })
-
-    const api = useApi() as any
-    const response = await api.delete(
-      `/admin/customers/${customer.id}/addresses/${address.id}`,
-      adminHeaders
-    )
-
-    expect(response.status).toEqual(200)
-
-    const updatedCustomer = await customerModuleService.retrieve(customer.id, {
-      relations: ["addresses"],
-    })
-
-    expect(updatedCustomer.addresses?.length).toEqual(0)
-  })
+  },
 })

integration-tests/modules/__tests__/customer/admin/delete-customer.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,45 @@ const adminHeaders = {
   headers: { "x-medusa-access-token": "test_token" },
 }
 
-describe("DELETE /admin/customers/:id", () => {
-  let dbConnection
-  let appContainer
-  let shutdownServer
-  let customerModuleService: ICustomerModuleService
+medusaIntegrationTestRunner({
+  env,
+  testSuite: ({ dbConnection, getContainer, api }) => {
+    describe("DELETE /admin/customers/: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 customer", async () => {
+        const customer = await customerModuleService.create({
+          first_name: "John",
+          last_name: "Doe",
+        })
 
-  afterEach(async () => {
-    const db = useDb()
-    await db.teardown()
-  })
+        const response = await api.delete(
+          `/admin/customers/${customer.id}`,
+          adminHeaders
+        )
 
-  it("should delete a customer", async () => {
-    const customer = await customerModuleService.create({
-      first_name: "John",
-      last_name: "Doe",
+        expect(response.status).toEqual(200)
+
+        const deletedCustomer = await customerModuleService.retrieve(
+          customer.id,
+          {
+            withDeleted: true,
+          }
+        )
+        expect(deletedCustomer.deleted_at).toBeTruthy()
+      })
     })
-
-    const api = useApi() as any
-    const response = await api.delete(
-      `/admin/customers/${customer.id}`,
-      adminHeaders
-    )
-
-    expect(response.status).toEqual(200)
-
-    const deletedCustomer = await customerModuleService.retrieve(customer.id, {
-      withDeleted: true,
-    })
-    expect(deletedCustomer.deleted_at).toBeTruthy()
-  })
+  },
 })

integration-tests/modules/__tests__/customer/admin/list-customer-addresses.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,100 +10,88 @@ const adminHeaders = {
   headers: { "x-medusa-access-token": "test_token" },
 }
 
-describe("GET /admin/customers/:id/addresses", () => {
-  let dbConnection
-  let appContainer
-  let shutdownServer
-  let customerModuleService: ICustomerModuleService
+medusaIntegrationTestRunner({
+  env,
+  testSuite: ({ dbConnection, getContainer, api }) => {
+    describe("GET /admin/customers/:id/addresses", () => {
+      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)
-  })
-
-  afterEach(async () => {
-    const db = useDb()
-    await db.teardown()
-  })
-
-  it("should get all customer addresses and its count", async () => {
-    const [customer] = await customerModuleService.create([
-      {
-        first_name: "Test",
-        last_name: "Test",
-        email: "test@me.com",
-        addresses: [
+      it("should get all customer addresses and its count", async () => {
+        const [customer] = await customerModuleService.create([
           {
             first_name: "Test",
             last_name: "Test",
-            address_1: "Test street 1",
+            email: "test@me.com",
+            addresses: [
+              {
+                first_name: "Test",
+                last_name: "Test",
+                address_1: "Test street 1",
+              },
+              {
+                first_name: "Test",
+                last_name: "Test",
+                address_1: "Test street 2",
+              },
+              {
+                first_name: "Test",
+                last_name: "Test",
+                address_1: "Test street 3",
+              },
+            ],
           },
           {
-            first_name: "Test",
-            last_name: "Test",
-            address_1: "Test street 2",
+            first_name: "Test Test",
+            last_name: "Test Test",
+            addresses: [
+              {
+                first_name: "Test TEST",
+                last_name: "Test TEST",
+                address_1: "NOT street 1",
+              },
+            ],
           },
-          {
-            first_name: "Test",
-            last_name: "Test",
-            address_1: "Test street 3",
-          },
-        ],
-      },
-      {
-        first_name: "Test Test",
-        last_name: "Test Test",
-        addresses: [
-          {
-            first_name: "Test TEST",
-            last_name: "Test TEST",
-            address_1: "NOT street 1",
-          },
-        ],
-      },
-    ])
+        ])
 
-    const api = useApi() as any
-    const response = await api.get(
-      `/admin/customers/${customer.id}/addresses`,
-      adminHeaders
-    )
+        const response = await api.get(
+          `/admin/customers/${customer.id}/addresses`,
+          adminHeaders
+        )
 
-    expect(response.status).toEqual(200)
-    expect(response.data.count).toEqual(3)
-    expect(response.data.addresses).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({
-          id: expect.any(String),
-          customer_id: customer.id,
-          address_1: "Test street 1",
-        }),
-        expect.objectContaining({
-          id: expect.any(String),
-          customer_id: customer.id,
-          address_1: "Test street 2",
-        }),
-        expect.objectContaining({
-          id: expect.any(String),
-          customer_id: customer.id,
-          address_1: "Test street 3",
-        }),
-      ])
-    )
-  })
+        expect(response.status).toEqual(200)
+        expect(response.data.count).toEqual(3)
+        expect(response.data.addresses).toEqual(
+          expect.arrayContaining([
+            expect.objectContaining({
+              id: expect.any(String),
+              customer_id: customer.id,
+              address_1: "Test street 1",
+            }),
+            expect.objectContaining({
+              id: expect.any(String),
+              customer_id: customer.id,
+              address_1: "Test street 2",
+            }),
+            expect.objectContaining({
+              id: expect.any(String),
+              customer_id: customer.id,
+              address_1: "Test street 3",
+            }),
+          ])
+        )
+      })
+    })
+  },
 })

integration-tests/modules/__tests__/customer/admin/list-customers.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,108 +10,96 @@ const adminHeaders = {
   headers: { "x-medusa-access-token": "test_token" },
 }
 
-describe("GET /admin/customers", () => {
-  let dbConnection
-  let appContainer
-  let shutdownServer
-  let customerModuleService: ICustomerModuleService
+medusaIntegrationTestRunner({
+  env,
+  testSuite: ({ dbConnection, getContainer, api }) => {
+    describe("GET /admin/customers", () => {
+      let appContainer
+      let shutdownServer
+      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 get all customers and its count", async () => {
-    await customerModuleService.create([
-      {
-        first_name: "Test",
-        last_name: "Test",
-        email: "test@me.com",
-      },
-    ])
-
-    const api = useApi() as any
-    const response = await api.get(`/admin/customers`, adminHeaders)
-
-    expect(response.status).toEqual(200)
-    expect(response.data.count).toEqual(1)
-    expect(response.data.customers).toEqual([
-      expect.objectContaining({
-        id: expect.any(String),
-        first_name: "Test",
-        last_name: "Test",
-        email: "test@me.com",
-      }),
-    ])
-  })
-
-  it("should filter customers by last name", async () => {
-    await customerModuleService.create([
-      {
-        first_name: "Jane",
-        last_name: "Doe",
-        email: "jane@me.com",
-      },
-      {
-        first_name: "John",
-        last_name: "Doe",
-        email: "john@me.com",
-      },
-      {
-        first_name: "LeBron",
-        last_name: "James",
-        email: "lebron@me.com",
-      },
-      {
-        first_name: "John",
-        last_name: "Silver",
-        email: "johns@me.com",
-      },
-    ])
-
-    const api = useApi() as any
-    const response = await api.get(
-      `/admin/customers?last_name=Doe`,
-      adminHeaders
-    )
-
-    expect(response.status).toEqual(200)
-    expect(response.data.count).toEqual(2)
-    expect(response.data.customers).toContainEqual(
-      expect.objectContaining({
-        id: expect.any(String),
-        first_name: "Jane",
-        last_name: "Doe",
-        email: "jane@me.com",
+      beforeAll(async () => {
+        appContainer = getContainer()
+        customerModuleService = appContainer.resolve(
+          ModuleRegistrationName.CUSTOMER
+        )
       })
-    )
-    expect(response.data.customers).toContainEqual(
-      expect.objectContaining({
-        id: expect.any(String),
-        first_name: "John",
-        last_name: "Doe",
-        email: "john@me.com",
+
+      beforeEach(async () => {
+        await createAdminUser(dbConnection, adminHeaders, appContainer)
       })
-    )
-  })
+
+      it("should get all customers and its count", async () => {
+        await customerModuleService.create([
+          {
+            first_name: "Test",
+            last_name: "Test",
+            email: "test@me.com",
+          },
+        ])
+
+        const response = await api.get(`/admin/customers`, adminHeaders)
+
+        expect(response.status).toEqual(200)
+        expect(response.data.count).toEqual(1)
+        expect(response.data.customers).toEqual([
+          expect.objectContaining({
+            id: expect.any(String),
+            first_name: "Test",
+            last_name: "Test",
+            email: "test@me.com",
+          }),
+        ])
+      })
+
+      it("should filter customers by last name", async () => {
+        await customerModuleService.create([
+          {
+            first_name: "Jane",
+            last_name: "Doe",
+            email: "jane@me.com",
+          },
+          {
+            first_name: "John",
+            last_name: "Doe",
+            email: "john@me.com",
+          },
+          {
+            first_name: "LeBron",
+            last_name: "James",
+            email: "lebron@me.com",
+          },
+          {
+            first_name: "John",
+            last_name: "Silver",
+            email: "johns@me.com",
+          },
+        ])
+
+        const response = await api.get(
+          `/admin/customers?last_name=Doe`,
+          adminHeaders
+        )
+
+        expect(response.status).toEqual(200)
+        expect(response.data.count).toEqual(2)
+        expect(response.data.customers).toContainEqual(
+          expect.objectContaining({
+            id: expect.any(String),
+            first_name: "Jane",
+            last_name: "Doe",
+            email: "jane@me.com",
+          })
+        )
+        expect(response.data.customers).toContainEqual(
+          expect.objectContaining({
+            id: expect.any(String),
+            first_name: "John",
+            last_name: "Doe",
+            email: "john@me.com",
+          })
+        )
+      })
+    })
+  },
 })

integration-tests/modules/__tests__/customer/admin/update-customer-address.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,151 +10,137 @@ const adminHeaders = {
   headers: { "x-medusa-access-token": "test_token" },
 }
 
-describe("POST /admin/customers/:id/addresses/:address_id", () => {
-  let dbConnection
-  let appContainer
-  let shutdownServer
-  let customerModuleService: ICustomerModuleService
+medusaIntegrationTestRunner({
+  env,
+  testSuite: ({ dbConnection, getContainer, api }) => {
+    describe("POST /admin/customers/:id/addresses/:address_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 address", async () => {
-    const customer = await customerModuleService.create({
-      first_name: "John",
-      last_name: "Doe",
-    })
-
-    const address = await customerModuleService.addAddresses({
-      customer_id: customer.id,
-      first_name: "John",
-      last_name: "Doe",
-      address_1: "Test street 1",
-    })
-
-    const api = useApi() as any
-    const response = await api.post(
-      `/admin/customers/${customer.id}/addresses/${address.id}`,
-      {
-        first_name: "Jane",
-      },
-      adminHeaders
-    )
-
-    expect(response.status).toEqual(200)
-    expect(response.data.address).toEqual(
-      expect.objectContaining({
-        id: expect.any(String),
-        first_name: "Jane",
-        last_name: "Doe",
+      beforeAll(async () => {
+        appContainer = getContainer()
+        customerModuleService = appContainer.resolve(
+          ModuleRegistrationName.CUSTOMER
+        )
       })
-    )
-  })
 
-  it("updates a new address to be default and unsets old one", async () => {
-    const customer = await customerModuleService.create({
-      first_name: "John",
-      last_name: "Doe",
+      beforeEach(async () => {
+        await createAdminUser(dbConnection, adminHeaders, appContainer)
+      })
+
+      it("should update a customer address", async () => {
+        const customer = await customerModuleService.create({
+          first_name: "John",
+          last_name: "Doe",
+        })
+
+        const address = await customerModuleService.addAddresses({
+          customer_id: customer.id,
+          first_name: "John",
+          last_name: "Doe",
+          address_1: "Test street 1",
+        })
+
+        const response = await api.post(
+          `/admin/customers/${customer.id}/addresses/${address.id}`,
+          {
+            first_name: "Jane",
+          },
+          adminHeaders
+        )
+
+        expect(response.status).toEqual(200)
+        expect(response.data.address).toEqual(
+          expect.objectContaining({
+            id: expect.any(String),
+            first_name: "Jane",
+            last_name: "Doe",
+          })
+        )
+      })
+
+      it("updates a new address to be default and unsets old one", async () => {
+        const customer = await customerModuleService.create({
+          first_name: "John",
+          last_name: "Doe",
+        })
+        const [, address] = await customerModuleService.addAddresses([
+          {
+            customer_id: customer.id,
+            first_name: "John",
+            last_name: "Doe",
+            address_1: "Test street 1",
+            is_default_shipping: true,
+          },
+          {
+            customer_id: customer.id,
+            first_name: "John",
+            last_name: "Doe",
+            address_1: "Test street 2",
+          },
+        ])
+
+        const response = await api.post(
+          `/admin/customers/${customer.id}/addresses/${address.id}`,
+          {
+            first_name: "jane",
+            is_default_shipping: true,
+          },
+          adminHeaders
+        )
+
+        expect(response.status).toEqual(200)
+
+        const [defaultAddress] = await customerModuleService.listAddresses({
+          customer_id: customer.id,
+          is_default_shipping: true,
+        })
+
+        expect(defaultAddress.first_name).toEqual("jane")
+        expect(defaultAddress.address_1).toEqual("Test street 2")
+      })
+
+      // do the same as above but for billing address
+      it("updates a new address to be default and unsets old one", async () => {
+        const customer = await customerModuleService.create({
+          first_name: "John",
+          last_name: "Doe",
+        })
+        const [, address] = await customerModuleService.addAddresses([
+          {
+            customer_id: customer.id,
+            first_name: "John",
+            last_name: "Doe",
+            address_1: "Test street 1",
+            is_default_billing: true,
+          },
+          {
+            customer_id: customer.id,
+            first_name: "John",
+            last_name: "Doe",
+            address_1: "Test street 2",
+          },
+        ])
+
+        const response = await api.post(
+          `/admin/customers/${customer.id}/addresses/${address.id}`,
+          {
+            first_name: "jane",
+            is_default_billing: true,
+          },
+          adminHeaders
+        )
+
+        expect(response.status).toEqual(200)
+
+        const [defaultAddress] = await customerModuleService.listAddresses({
+          customer_id: customer.id,
+          is_default_billing: true,
+        })
+
+        expect(defaultAddress.first_name).toEqual("jane")
+        expect(defaultAddress.address_1).toEqual("Test street 2")
+      })
     })
-    const [, address] = await customerModuleService.addAddresses([
-      {
-        customer_id: customer.id,
-        first_name: "John",
-        last_name: "Doe",
-        address_1: "Test street 1",
-        is_default_shipping: true,
-      },
-      {
-        customer_id: customer.id,
-        first_name: "John",
-        last_name: "Doe",
-        address_1: "Test street 2",
-      },
-    ])
-
-    const api = useApi() as any
-    const response = await api.post(
-      `/admin/customers/${customer.id}/addresses/${address.id}`,
-      {
-        first_name: "jane",
-        is_default_shipping: true,
-      },
-      adminHeaders
-    )
-
-    expect(response.status).toEqual(200)
-
-    const [defaultAddress] = await customerModuleService.listAddresses({
-      customer_id: customer.id,
-      is_default_shipping: true,
-    })
-
-    expect(defaultAddress.first_name).toEqual("jane")
-    expect(defaultAddress.address_1).toEqual("Test street 2")
-  })
-
-  // do the same as above but for billing address
-  it("updates a new address to be default and unsets old one", async () => {
-    const customer = await customerModuleService.create({
-      first_name: "John",
-      last_name: "Doe",
-    })
-    const [, address] = await customerModuleService.addAddresses([
-      {
-        customer_id: customer.id,
-        first_name: "John",
-        last_name: "Doe",
-        address_1: "Test street 1",
-        is_default_billing: true,
-      },
-      {
-        customer_id: customer.id,
-        first_name: "John",
-        last_name: "Doe",
-        address_1: "Test street 2",
-      },
-    ])
-
-    const api = useApi() as any
-    const response = await api.post(
-      `/admin/customers/${customer.id}/addresses/${address.id}`,
-      {
-        first_name: "jane",
-        is_default_billing: true,
-      },
-      adminHeaders
-    )
-
-    expect(response.status).toEqual(200)
-
-    const [defaultAddress] = await customerModuleService.listAddresses({
-      customer_id: customer.id,
-      is_default_billing: true,
-    })
-
-    expect(defaultAddress.first_name).toEqual("jane")
-    expect(defaultAddress.address_1).toEqual("Test street 2")
-  })
+  },
 })

integration-tests/modules/__tests__/customer/admin/update-customer.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,59 +10,47 @@ const adminHeaders = {
   headers: { "x-medusa-access-token": "test_token" },
 }
 
-describe("POST /admin/customers/:id", () => {
-  let dbConnection
-  let appContainer
-  let shutdownServer
-  let customerModuleService: ICustomerModuleService
+medusaIntegrationTestRunner({
+  env,
+  testSuite: ({ dbConnection, getContainer, api }) => {
+    describe("POST /admin/customers/: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", async () => {
-    const customer = await customerModuleService.create({
-      first_name: "John",
-      last_name: "Doe",
-    })
-
-    const api = useApi() as any
-    const response = await api.post(
-      `/admin/customers/${customer.id}`,
-      {
-        first_name: "Jane",
-      },
-      adminHeaders
-    )
-
-    expect(response.status).toEqual(200)
-    expect(response.data.customer).toEqual(
-      expect.objectContaining({
-        id: expect.any(String),
-        first_name: "Jane",
-        last_name: "Doe",
+      beforeAll(async () => {
+        appContainer = getContainer()
+        customerModuleService = appContainer.resolve(
+          ModuleRegistrationName.CUSTOMER
+        )
       })
-    )
-  })
+
+      beforeEach(async () => {
+        await createAdminUser(dbConnection, adminHeaders, appContainer)
+      })
+
+      it("should update a customer", async () => {
+        const customer = await customerModuleService.create({
+          first_name: "John",
+          last_name: "Doe",
+        })
+
+        const response = await api.post(
+          `/admin/customers/${customer.id}`,
+          {
+            first_name: "Jane",
+          },
+          adminHeaders
+        )
+
+        expect(response.status).toEqual(200)
+        expect(response.data.customer).toEqual(
+          expect.objectContaining({
+            id: expect.any(String),
+            first_name: "Jane",
+            last_name: "Doe",
+          })
+        )
+      })
+    })
+  },
 })