chore(tests): Try to use the api integration tests for v2 (#6588)

Few things to keep in mind:
1. You need to set MEDUSA_FF_MEDUSA_V2 to true before running the tests to run with the v2 API
2. You can use the `breaking` function to differentiate between v1 and v2 differences. This can help us identify what was breaking pretty quickly afterwards
3. You will need to run specific tests for now instead of all if you want to target v2. I think that's fine though, as we don't really need these to run on every PR until we have feature parity (and by then, all tests would be both v1 and v2 compatible)


**note: Adrien** 
- add a new way to load modules only to run their loaders comparable to the way to run the migrations only
- improve tests runner to cleanup the data properly as well as re running all loaders and core defaults

Co-authored-by: Adrien de Peretti <25098370+adrien2p@users.noreply.github.com>
This commit is contained in:
Stevche Radevski
2024-03-07 09:05:43 +01:00
committed by GitHub
parent 000eb61e33
commit 12b035cb18
76 changed files with 773 additions and 371 deletions
@@ -1,8 +0,0 @@
// Jest Snapshot v1, https://goo.gl/fbAQLP
exports[`/admin/store POST /admin/store fails to update default currency if not in store currencies 1`] = `
Object {
"message": "Store does not have currency: eur",
"type": "invalid_data",
}
`;
+221 -213
View File
@@ -1,242 +1,250 @@
const { Store } = require("@medusajs/medusa")
const path = require("path")
const {
createAdminUser,
adminHeaders,
} = require("../../../helpers/create-admin-user")
const { breaking } = require("../../../helpers/breaking")
const { ModuleRegistrationName } = require("@medusajs/modules-sdk")
const { medusaIntegrationTestRunner } = require("medusa-test-utils")
const setupServer = require("../../../environment-helpers/setup-server")
const { useApi } = require("../../../environment-helpers/use-api")
const { initDb, useDb } = require("../../../environment-helpers/use-db")
jest.setTimeout(90000)
const adminSeeder = require("../../../helpers/admin-seeder")
medusaIntegrationTestRunner({
testSuite: ({ dbConnection, getContainer, api }) => {
describe("/admin/store", () => {
let dbStore
let container
jest.setTimeout(30000)
// Note: The tests rely on the loader running and populating clean data before and after the test, so we have to do this in a beforeEach
beforeEach(async () => {
container = getContainer()
describe("/admin/store", () => {
let dbConnection
const cwd = path.resolve(path.join(__dirname, "..", ".."))
beforeAll(async () => {
dbConnection = await initDb({ cwd })
})
afterAll(async () => {
const db = useDb()
await db.shutdown()
})
describe("Store creation", () => {
let medusaProcess
beforeEach(async () => {
await adminSeeder(dbConnection)
medusaProcess = await setupServer({ cwd })
})
afterEach(async () => {
const db = useDb()
await db.teardown({ forceDelete: ["store"] })
await medusaProcess.kill()
})
it("has created store with default currency", async () => {
const api = useApi()
const response = await api.get("/admin/store", {
headers: { "x-medusa-access-token": "test_token " },
await createAdminUser(dbConnection, adminHeaders, container)
await breaking(
async () => {
const { Store } = require("@medusajs/medusa/dist/models/store")
const manager = dbConnection.manager
dbStore = await manager.findOne(Store, {
where: { name: "Medusa Store" },
})
await manager.query(
`INSERT INTO store_currencies (store_id, currency_code)
VALUES ('${dbStore.id}', 'dkk')`
)
},
async () => {
const service = container.resolve(ModuleRegistrationName.STORE)
dbStore = await service.create({
supported_currency_codes: ["usd", "dkk"],
default_currency_code: "usd",
default_sales_channel_id: "sc_12345",
})
}
)
})
expect(response.status).toEqual(200)
expect(response.data.store).toEqual(
expect.objectContaining({
id: expect.any(String),
default_sales_channel_id: expect.any(String),
default_sales_channel: expect.objectContaining({
id: expect.any(String),
}),
name: "Medusa Store",
currencies: expect.arrayContaining([
describe("Store creation", () => {
it("has created store with default currency", async () => {
const store = await breaking(
() =>
api.get("/admin/store", adminHeaders).then((r) => r.data.store),
() =>
api
.get("/admin/stores", adminHeaders)
.then((r) => r.data.stores[0])
)
expect(store).toEqual(
expect.objectContaining({
code: "usd",
}),
]),
modules: expect.any(Array),
feature_flags: expect.any(Array),
default_currency_code: "usd",
created_at: expect.any(String),
updated_at: expect.any(String),
id: expect.any(String),
name: "Medusa Store",
default_currency_code: "usd",
default_sales_channel_id: expect.any(String),
...breaking(
() => ({
default_sales_channel: expect.objectContaining({
id: expect.any(String),
}),
currencies: expect.arrayContaining([
expect.objectContaining({
code: "usd",
}),
]),
modules: expect.any(Array),
feature_flags: expect.any(Array),
}),
() => ({
supported_currency_codes: ["usd", "dkk"],
})
),
created_at: expect.any(String),
updated_at: expect.any(String),
})
)
})
)
})
})
describe("POST /admin/store", () => {
let medusaProcess
beforeEach(async () => {
await adminSeeder(dbConnection)
medusaProcess = await setupServer({ cwd })
const manager = dbConnection.manager
const store = await manager.findOne(Store, {
where: { name: "Medusa Store" },
})
await manager.query(
`INSERT INTO store_currencies (store_id, currency_code) VALUES ('${store.id}', 'dkk')`
)
})
afterEach(async () => {
const db = useDb()
await db.teardown({ forceDelete: ["store"] })
await medusaProcess.kill()
})
it("fails to update default currency if not in store currencies", async () => {
const api = useApi()
try {
await api.post(
"/admin/store",
{
default_currency_code: "eur",
},
{
headers: { "x-medusa-access-token": "test_token " },
describe("POST /admin/store", () => {
it("fails to update default currency if not in store currencies", async () => {
try {
await api.post(
breaking(
() => "/admin/store",
() => `/admin/stores/${dbStore.id}`
),
{
default_currency_code: "eur",
},
adminHeaders
)
} catch (e) {
expect(e.response.data).toEqual(
expect.objectContaining({
type: "invalid_data",
message: "Store does not have currency: eur",
})
)
expect(e.response.status).toBe(400)
}
)
} catch (e) {
expect(e.response.data).toMatchSnapshot({
type: "invalid_data",
message: "Store does not have currency: eur",
})
expect(e.response.status).toBe(400)
}
})
it("fails to remove default currency from currencies without replacing it", async () => {
const api = useApi()
try {
await api.post(
"/admin/store",
{
currencies: ["usd"],
},
{
headers: { "x-medusa-access-token": "test_token " },
it("fails to remove default currency from currencies without replacing it", async () => {
try {
await api.post(
breaking(
() => "/admin/store",
() => `/admin/stores/${dbStore.id}`
),
breaking(
() => ({
currencies: ["usd"],
}),
() => ({ supported_currency_codes: ["dkk"] })
),
adminHeaders
)
} catch (e) {
expect(e.response.data).toEqual(
expect.objectContaining({
type: "invalid_data",
message:
"You are not allowed to remove default currency from store currencies without replacing it as well",
})
)
expect(e.response.status).toBe(400)
}
)
} catch (e) {
expect(e.response.data).toMatchSnapshot({
type: "invalid_data",
message:
"You are not allowed to remove default currency from store currencies without replacing it as well",
})
expect(e.response.status).toBe(400)
}
})
it("successfully updates default currency code", async () => {
const api = useApi()
it("successfully updates default currency code", async () => {
const response = await api
.post(
breaking(
() => "/admin/store",
() => `/admin/stores/${dbStore.id}`
),
{
default_currency_code: "dkk",
},
adminHeaders
)
.catch((err) => console.log(err))
const response = await api
.post(
"/admin/store",
{
default_currency_code: "dkk",
},
{
headers: { "x-medusa-access-token": "test_token " },
}
)
.catch((err) => console.log(err))
expect(response.status).toEqual(200)
expect(response.data.store).toEqual(
expect.objectContaining({
id: expect.any(String),
name: "Medusa Store",
default_sales_channel_id: expect.any(String),
currencies: expect.arrayContaining([
expect(response.status).toEqual(200)
expect(response.data.store).toEqual(
expect.objectContaining({
code: "usd",
}),
expect.objectContaining({
code: "dkk",
}),
]),
default_currency_code: "dkk",
created_at: expect.any(String),
updated_at: expect.any(String),
id: expect.any(String),
name: "Medusa Store",
default_currency_code: "dkk",
created_at: expect.any(String),
updated_at: expect.any(String),
})
)
})
)
})
it("successfully updates default currency and store currencies", async () => {
const api = useApi()
it("successfully updates default currency and store currencies", async () => {
const response = await api.post(
breaking(
() => "/admin/store",
() => `/admin/stores/${dbStore.id}`
),
{
default_currency_code: "jpy",
...breaking(
() => ({ currencies: ["jpy", "usd"] }),
() => ({ supported_currency_codes: ["jpy", "usd"] })
),
},
adminHeaders
)
const response = await api.post(
"/admin/store",
{
default_currency_code: "jpy",
currencies: ["jpy", "usd"],
},
{
headers: { "x-medusa-access-token": "test_token " },
}
)
expect(response.status).toEqual(200)
expect(response.data.store).toEqual(
expect.objectContaining({
id: expect.any(String),
name: "Medusa Store",
default_sales_channel_id: expect.any(String),
currencies: expect.arrayContaining([
expect(response.status).toEqual(200)
expect(response.data.store).toEqual(
expect.objectContaining({
code: "jpy",
}),
expect.objectContaining({
code: "usd",
}),
]),
default_currency_code: "jpy",
created_at: expect.any(String),
updated_at: expect.any(String),
id: expect.any(String),
name: "Medusa Store",
default_sales_channel_id: expect.any(String),
...breaking(
() => ({
currencies: expect.arrayContaining([
expect.objectContaining({
code: "jpy",
}),
expect.objectContaining({
code: "usd",
}),
]),
}),
() => ({ supported_currency_codes: ["jpy", "usd"] })
),
default_currency_code: "jpy",
created_at: expect.any(String),
updated_at: expect.any(String),
})
)
})
)
})
it("successfully updates and store currencies", async () => {
const api = useApi()
it("successfully updates and store currencies", async () => {
const response = await api.post(
breaking(
() => "/admin/store",
() => `/admin/stores/${dbStore.id}`
),
breaking(
() => ({
currencies: ["jpy", "usd"],
}),
() => ({
supported_currency_codes: ["jpy", "usd"],
})
),
adminHeaders
)
const response = await api.post(
"/admin/store",
{
currencies: ["jpy", "usd"],
},
{
headers: { "x-medusa-access-token": "test_token " },
}
)
expect(response.status).toEqual(200)
expect(response.data.store).toEqual(
expect.objectContaining({
id: expect.any(String),
default_sales_channel_id: expect.any(String),
name: "Medusa Store",
currencies: expect.arrayContaining([
expect(response.status).toEqual(200)
expect(response.data.store).toEqual(
expect.objectContaining({
code: "jpy",
}),
expect.objectContaining({
code: "usd",
}),
]),
default_currency_code: "usd",
created_at: expect.any(String),
updated_at: expect.any(String),
id: expect.any(String),
default_sales_channel_id: expect.any(String),
name: "Medusa Store",
...breaking(
() => ({
currencies: expect.arrayContaining([
expect.objectContaining({
code: "jpy",
}),
expect.objectContaining({
code: "usd",
}),
]),
}),
() => ({ supported_currency_codes: ["jpy", "usd"] })
),
default_currency_code: "usd",
created_at: expect.any(String),
updated_at: expect.any(String),
})
)
})
)
})
})
})
},
})