medusa-store/integration-tests/api/__tests__/admin/order.js

const path = require("path");
const {
  ReturnReason,
  Order,
  LineItem,
  ProductVariant,
} = require("@medusajs/medusa");

const setupServer = require("../../../helpers/setup-server");
const { useApi } = require("../../../helpers/use-api");
const { initDb, useDb } = require("../../../helpers/use-db");

const orderSeeder = require("../../helpers/order-seeder");
const swapSeeder = require("../../helpers/swap-seeder");
const adminSeeder = require("../../helpers/admin-seeder");

jest.setTimeout(30000);

describe("/admin/orders", () => {
  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/orders", () => {
    beforeEach(async () => {
      try {
        await adminSeeder(dbConnection);
        await orderSeeder(dbConnection);
      } catch (err) {
        console.log(err);
        throw err;
      }
    });

    afterEach(async () => {
      const db = useDb();
      await db.teardown();
    });

    it("gets orders", async () => {
      const api = useApi();

      const response = await api
        .get("/admin/orders", {
          headers: {
            Authorization: "Bearer test_token",
          },
        })
        .catch((err) => {
          console.log(err);
        });
      expect(response.status).toEqual(200);
    });
  });

  describe("GET /admin/orders", () => {
    beforeEach(async () => {
      try {
        await adminSeeder(dbConnection);
        await orderSeeder(dbConnection);
      } catch (err) {
        console.log(err);
        throw err;
      }

      const manager = dbConnection.manager;

      const order2 = manager.create(Order, {
        id: "test-order-not-payed",
        customer_id: "test-customer",
        email: "test@email.com",
        fulfillment_status: "not_fulfilled",
        payment_status: "awaiting",
        billing_address: {
          id: "test-billing-address",
          first_name: "lebron",
        },
        shipping_address: {
          id: "test-shipping-address",
          first_name: "lebron",
          country_code: "us",
        },
        region_id: "test-region",
        currency_code: "usd",
        tax_rate: 0,
        discounts: [
          {
            id: "test-discount",
            code: "TEST134",
            is_dynamic: false,
            rule: {
              id: "test-rule",
              description: "Test Discount",
              type: "percentage",
              value: 10,
              allocation: "total",
            },
            is_disabled: false,
            regions: [
              {
                id: "test-region",
              },
            ],
          },
        ],
        payments: [
          {
            id: "test-payment",
            amount: 10000,
            currency_code: "usd",
            amount_refunded: 0,
            provider_id: "test-pay",
            data: {},
          },
        ],
        items: [],
      });

      await manager.save(order2);

      const li2 = manager.create(LineItem, {
        id: "test-item",
        fulfilled_quantity: 0,
        returned_quantity: 0,
        title: "Line Item",
        description: "Line Item Desc",
        thumbnail: "https://test.js/1234",
        unit_price: 8000,
        quantity: 1,
        variant_id: "test-variant",
        order_id: "test-order-not-payed",
      });

      await manager.save(li2);
    });

    afterEach(async () => {
      const db = useDb();
      await db.teardown();
    });

    it("cancels an order and increments inventory_quantity", async () => {
      const api = useApi();
      const manager = dbConnection.manager;

      const initialInventoryRes = await api.get("/store/variants/test-variant");

      expect(initialInventoryRes.data.variant.inventory_quantity).toEqual(1);

      const response = await api
        .post(
          `/admin/orders/test-order-not-payed/cancel`,
          {},
          {
            headers: {
              Authorization: "Bearer test_token",
            },
          }
        )
        .catch((err) => {
          console.log(err);
        });
      expect(response.status).toEqual(200);

      const secondInventoryRes = await api.get("/store/variants/test-variant");

      expect(secondInventoryRes.data.variant.inventory_quantity).toEqual(2);
    });

    it("cancels an order but does not increment inventory_quantity of unmanaged variant", async () => {
      const api = useApi();
      const manager = dbConnection.manager;

      await manager.query(
        `UPDATE "product_variant" SET manage_inventory=false WHERE id = 'test-variant'`
      );

      const initialInventoryRes = await api.get("/store/variants/test-variant");

      expect(initialInventoryRes.data.variant.inventory_quantity).toEqual(1);

      const response = await api
        .post(
          `/admin/orders/test-order-not-payed/cancel`,
          {},
          {
            headers: {
              Authorization: "Bearer test_token",
            },
          }
        )
        .catch((err) => {
          console.log(err);
        });
      expect(response.status).toEqual(200);

      const secondInventoryRes = await api.get("/store/variants/test-variant");

      expect(secondInventoryRes.data.variant.inventory_quantity).toEqual(1);
    });
  });

  describe("POST /admin/orders/:id/claims", () => {
    beforeEach(async () => {
      try {
        await adminSeeder(dbConnection);
        await orderSeeder(dbConnection);
      } catch (err) {
        console.log(err);
        throw err;
      }
    });

    afterEach(async () => {
      const db = useDb();
      await db.teardown();
    });

    it("creates a claim", async () => {
      const api = useApi();

      const response = await api.post(
        "/admin/orders/test-order/claims",
        {
          type: "replace",
          claim_items: [
            {
              item_id: "test-item",
              quantity: 1,
              reason: "production_failure",
              tags: ["fluff"],
              images: ["https://test.image.com"],
            },
          ],
          additional_items: [
            {
              variant_id: "test-variant",
              quantity: 1,
            },
          ],
        },
        {
          headers: {
            authorization: "Bearer test_token",
          },
        }
      );
      expect(response.status).toEqual(200);

      const variant = await api.get("/admin/products", {
        headers: {
          authorization: "Bearer test_token",
        },
      });

      // find test variant and verify that its inventory quantity has changed
      const toTest = variant.data.products[0].variants.find(
        (v) => v.id === "test-variant"
      );
      expect(toTest.inventory_quantity).toEqual(0);

      expect(response.data.order.claims[0].shipping_address_id).toEqual(
        "test-shipping-address"
      );
      expect(response.data.order.claims[0].shipping_address).toEqual(
        expect.objectContaining({
          first_name: "lebron",
          country_code: "us",
        })
      );

      expect(response.data.order.claims[0].claim_items).toEqual(
        expect.arrayContaining([
          expect.objectContaining({
            item_id: "test-item",
            quantity: 1,
            reason: "production_failure",
            images: expect.arrayContaining([
              expect.objectContaining({
                url: "https://test.image.com",
              }),
            ]),
          }),
        ])
      );

      expect(response.data.order.claims[0].additional_items).toEqual(
        expect.arrayContaining([
          expect.objectContaining({
            variant_id: "test-variant",
            quantity: 1,
          }),
        ])
      );
    });

    it("creates a claim with a shipping address", async () => {
      const api = useApi();

      const response = await api.post(
        "/admin/orders/test-order/claims",
        {
          type: "replace",
          shipping_address: {
            first_name: "test",
            last_name: "testson",
            address_1: "Test",
            city: "testvill",
            postal_code: "12345",
            country_code: "us",
          },
          claim_items: [
            {
              item_id: "test-item",
              quantity: 1,
              reason: "production_failure",
              tags: ["fluff"],
              images: ["https://test.image.com"],
            },
          ],
          additional_items: [
            {
              variant_id: "test-variant",
              quantity: 1,
            },
          ],
        },
        {
          headers: {
            authorization: "Bearer test_token",
          },
        }
      );
      expect(response.status).toEqual(200);

      expect(response.data.order.claims[0].shipping_address).toEqual(
        expect.objectContaining({
          first_name: "test",
          last_name: "testson",
          address_1: "Test",
          city: "testvill",
          postal_code: "12345",
          country_code: "us",
        })
      );

      expect(response.data.order.claims[0].claim_items).toEqual(
        expect.arrayContaining([
          expect.objectContaining({
            item_id: "test-item",
            quantity: 1,
            reason: "production_failure",
            images: expect.arrayContaining([
              expect.objectContaining({
                url: "https://test.image.com",
              }),
            ]),
          }),
        ])
      );

      expect(response.data.order.claims[0].additional_items).toEqual(
        expect.arrayContaining([
          expect.objectContaining({
            variant_id: "test-variant",
            quantity: 1,
          }),
        ])
      );
    });

    it("creates a claim with return shipping", async () => {
      const api = useApi();

      const response = await api.post(
        "/admin/orders/test-order/claims",
        {
          type: "replace",
          claim_items: [
            {
              item_id: "test-item",
              quantity: 1,
              reason: "production_failure",
              tags: ["fluff"],
              images: ["https://test.image.com"],
            },
          ],
          additional_items: [
            {
              variant_id: "test-variant",
              quantity: 1,
            },
          ],
          return_shipping: { option_id: "test-return-option", price: 0 },
        },
        {
          headers: {
            authorization: "Bearer test_token",
          },
        }
      );
      expect(response.status).toEqual(200);

      expect(response.data.order.claims[0].claim_items).toEqual(
        expect.arrayContaining([
          expect.objectContaining({
            item_id: "test-item",
            quantity: 1,
            reason: "production_failure",
            images: expect.arrayContaining([
              expect.objectContaining({
                url: "https://test.image.com",
              }),
            ]),
          }),
        ])
      );

      expect(response.data.order.claims[0].additional_items).toEqual(
        expect.arrayContaining([
          expect.objectContaining({
            variant_id: "test-variant",
            quantity: 1,
          }),
        ])
      );

      expect(
        response.data.order.claims[0].return_order.shipping_method
      ).toEqual(
        expect.objectContaining({
          price: 0,
          shipping_option_id: "test-return-option",
        })
      );
    });

    it("updates a claim", async () => {
      const api = useApi();

      const response = await api.post(
        "/admin/orders/test-order/claims",
        {
          type: "replace",
          claim_items: [
            {
              item_id: "test-item",
              quantity: 1,
              reason: "production_failure",
              tags: ["fluff"],
              images: ["https://test.image.com"],
            },
          ],
          additional_items: [
            {
              variant_id: "test-variant",
              quantity: 1,
            },
          ],
        },
        {
          headers: {
            authorization: "Bearer test_token",
          },
        }
      );
      expect(response.status).toEqual(200);

      const cid = response.data.order.claims[0].id;
      const { status, data: updateData } = await api.post(
        `/admin/orders/test-order/claims/${cid}`,
        {
          shipping_methods: [
            {
              id: "test-method",
            },
          ],
        },
        {
          headers: {
            authorization: "bearer test_token",
          },
        }
      );

      expect(status).toEqual(200);
      expect(updateData.order.claims[0].shipping_methods).toEqual([
        expect.objectContaining({
          id: "test-method",
        }),
      ]);
    });

    it("updates claim items", async () => {
      const api = useApi();

      const response = await api.post(
        "/admin/orders/test-order/claims",
        {
          type: "replace",
          claim_items: [
            {
              item_id: "test-item",
              quantity: 1,
              reason: "production_failure",
              tags: ["fluff"],
              images: ["https://test.image.com"],
            },
          ],
          additional_items: [
            {
              variant_id: "test-variant",
              quantity: 1,
            },
          ],
        },
        {
          headers: {
            authorization: "Bearer test_token",
          },
        }
      );
      expect(response.status).toEqual(200);

      let claim = response.data.order.claims[0];
      const cid = claim.id;
      const { status, data: updateData } = await api.post(
        `/admin/orders/test-order/claims/${cid}`,
        {
          claim_items: claim.claim_items.map((i) => ({
            id: i.id,
            note: "Something new",
            images: [
              ...i.images.map((i) => ({ id: i.id })),
              { url: "https://new.com/image" },
            ],
            tags: [
              { value: "completely" },
              { value: "NEW" },
              { value: " tags" },
            ],
          })),
        },
        {
          headers: {
            authorization: "bearer test_token",
          },
        }
      );

      expect(status).toEqual(200);
      expect(updateData.order.claims.length).toEqual(1);

      claim = updateData.order.claims[0];

      expect(claim.claim_items.length).toEqual(1);
      expect(claim.claim_items).toEqual(
        expect.arrayContaining([
          expect.objectContaining({
            id: claim.claim_items[0].id,
            reason: "production_failure",
            note: "Something new",
            images: expect.arrayContaining([
              expect.objectContaining({
                url: "https://test.image.com",
              }),
              expect.objectContaining({
                url: "https://new.com/image",
              }),
            ]),
            // tags: expect.arrayContaining([
            //   expect.objectContaining({ value: "completely" }),
            //   expect.objectContaining({ value: "new" }),
            //   expect.objectContaining({ value: "tags" }),
            // ]),
          }),
        ])
      );
    });

    it("updates claim items - removes image", async () => {
      const api = useApi();

      const response = await api.post(
        "/admin/orders/test-order/claims",
        {
          type: "replace",
          claim_items: [
            {
              item_id: "test-item",
              quantity: 1,
              reason: "production_failure",
              tags: ["fluff"],
              images: ["https://test.image.com"],
            },
          ],
          additional_items: [
            {
              variant_id: "test-variant",
              quantity: 1,
            },
          ],
        },
        {
          headers: {
            authorization: "Bearer test_token",
          },
        }
      );
      expect(response.status).toEqual(200);

      let claim = response.data.order.claims[0];
      const cid = claim.id;
      const { status, data: updateData } = await api.post(
        `/admin/orders/test-order/claims/${cid}`,
        {
          claim_items: claim.claim_items.map((i) => ({
            id: i.id,
            note: "Something new",
            images: [],
            tags: [
              { value: "completely" },
              { value: "NEW" },
              { value: " tags" },
            ],
          })),
        },
        {
          headers: {
            authorization: "bearer test_token",
          },
        }
      );

      expect(status).toEqual(200);
      expect(updateData.order.claims.length).toEqual(1);

      claim = updateData.order.claims[0];

      expect(claim.claim_items.length).toEqual(1);
      expect(claim.claim_items).toEqual([
        expect.objectContaining({
          id: claim.claim_items[0].id,
          reason: "production_failure",
          note: "Something new",
          images: [],
          // tags: expect.arrayContaining([
          //   expect.objectContaining({ value: "completely" }),
          //   expect.objectContaining({ value: "new" }),
          //   expect.objectContaining({ value: "tags" }),
          // ]),
        }),
      ]);
    });

    it("fulfills a claim", async () => {
      const api = useApi();

      const response = await api
        .post(
          "/admin/orders/test-order/claims",
          {
            type: "replace",
            shipping_methods: [
              {
                id: "test-method",
              },
            ],
            claim_items: [
              {
                item_id: "test-item",
                quantity: 1,
                reason: "production_failure",
                tags: ["fluff"],
                images: ["https://test.image.com"],
              },
            ],
            additional_items: [
              {
                variant_id: "test-variant",
                quantity: 1,
              },
            ],
          },
          {
            headers: {
              Authorization: "Bearer test_token",
            },
          }
        )
        .catch((err) => {
          console.log(err);
        });

      const cid = response.data.order.claims[0].id;
      const fulRes = await api.post(
        `/admin/orders/test-order/claims/${cid}/fulfillments`,
        {},
        {
          headers: {
            Authorization: "Bearer test_token",
          },
        }
      );
      expect(fulRes.status).toEqual(200);
      expect(fulRes.data.order.claims).toEqual([
        expect.objectContaining({
          id: cid,
          order_id: "test-order",
          fulfillment_status: "fulfilled",
        }),
      ]);

      const fid = fulRes.data.order.claims[0].fulfillments[0].id;
      const iid = fulRes.data.order.claims[0].additional_items[0].id;
      expect(fulRes.data.order.claims[0].fulfillments).toEqual([
        expect.objectContaining({
          items: [
            {
              fulfillment_id: fid,
              item_id: iid,
              quantity: 1,
            },
          ],
        }),
      ]);
    });

    it("fails to creates a claim due to no stock on additional items", async () => {
      const api = useApi();
      try {
        await api.post(
          "/admin/orders/test-order/claims",
          {
            type: "replace",
            claim_items: [
              {
                item_id: "test-item",
                quantity: 1,
                reason: "production_failure",
                tags: ["fluff"],
                images: ["https://test.image.com"],
              },
            ],
            additional_items: [
              {
                variant_id: "test-variant",
                quantity: 2,
              },
            ],
          },
          {
            headers: {
              authorization: "Bearer test_token",
            },
          }
        );
      } catch (e) {
        expect(e.response.status).toEqual(400);
        expect(e.response.data.message).toEqual(
          "Variant with id: test-variant does not have the required inventory"
        );
      }
    });
  });

  describe("POST /admin/orders/:id/return", () => {
    let rrId;
    beforeEach(async () => {
      try {
        await adminSeeder(dbConnection);
        await orderSeeder(dbConnection);

        const created = dbConnection.manager.create(ReturnReason, {
          value: "too_big",
          label: "Too Big",
        });
        const result = await dbConnection.manager.save(created);

        rrId = result.id;
      } catch (err) {
        console.log(err);
        throw err;
      }
    });

    afterEach(async () => {
      const db = useDb();
      await db.teardown();
    });

    it("creates a return", async () => {
      const api = useApi();

      const response = await api.post(
        "/admin/orders/test-order/return",
        {
          items: [
            {
              item_id: "test-item",
              quantity: 1,
              reason_id: rrId,
              note: "TOO SMALL",
            },
          ],
        },
        {
          headers: {
            authorization: "Bearer test_token",
          },
        }
      );
      expect(response.status).toEqual(200);

      expect(response.data.order.returns[0].refund_amount).toEqual(7200);
      expect(response.data.order.returns[0].items).toEqual([
        expect.objectContaining({
          item_id: "test-item",
          quantity: 1,
          reason_id: rrId,
          note: "TOO SMALL",
        }),
      ]);
    });

    it("increases inventory_quantity when return is received", async () => {
      const api = useApi();

      const returned = await api.post(
        "/admin/orders/test-order/return",
        {
          items: [
            {
              item_id: "test-item",
              quantity: 1,
            },
          ],
          receive_now: true,
        },
        {
          headers: {
            authorization: "Bearer test_token",
          },
        }
      );

      //Find variant that should have its inventory_quantity updated
      const toTest = returned.data.order.items.find(
        (i) => i.id === "test-item"
      );

      expect(returned.status).toEqual(200);
      expect(toTest.variant.inventory_quantity).toEqual(2);
    });

    it("does not increases inventory_quantity when return is received when inventory is not managed", async () => {
      const api = useApi();
      const manager = dbConnection.manager;

      await manager.query(
        `UPDATE "product_variant" SET manage_inventory=false WHERE id = 'test-variant'`
      );

      const returned = await api.post(
        "/admin/orders/test-order/return",
        {
          items: [
            {
              item_id: "test-item",
              quantity: 1,
            },
          ],
          receive_now: true,
        },
        {
          headers: {
            authorization: "Bearer test_token",
          },
        }
      );

      //Find variant that should have its inventory_quantity updated
      const toTest = returned.data.order.items.find(
        (i) => i.id === "test-item"
      );

      expect(returned.status).toEqual(200);
      expect(toTest.variant.inventory_quantity).toEqual(1);
    });
  });

  describe("GET /admin/orders", () => {
    beforeEach(async () => {
      try {
        await adminSeeder(dbConnection);
        // Manually insert date for filtering
        const createdAt = new Date("26 January 1997 12:00 UTC");
        await orderSeeder(dbConnection, {
          created_at: createdAt.toISOString(),
        });
      } catch (err) {
        console.log(err);
        throw err;
      }
    });

    afterEach(async () => {
      const db = useDb();
      await db.teardown();
    });

    it("lists all orders", async () => {
      const api = useApi();

      const response = await api.get("/admin/orders?fields=id", {
        headers: {
          authorization: "Bearer test_token",
        },
      });

      expect(response.status).toEqual(200);
      expect(response.data.orders).toEqual([
        expect.objectContaining({
          id: "test-order",
        }),
      ]);
    });

    it("successfully lists orders with greater than", async () => {
      const api = useApi();

      const response = await api.get(
        "/admin/orders?fields=id&created_at[gt]=01-26-1990",
        {
          headers: {
            authorization: "Bearer test_token",
          },
        }
      );

      expect(response.status).toEqual(200);
      expect(response.data.orders).toEqual([
        expect.objectContaining({
          id: "test-order",
        }),
      ]);
    });

    it("successfully lists no orders with greater than", async () => {
      const api = useApi();

      const response = await api.get(
        "/admin/orders?fields=id&created_at[gt]=01-26-2000",
        {
          headers: {
            authorization: "Bearer test_token",
          },
        }
      );

      expect(response.status).toEqual(200);
      expect(response.data.orders).toEqual([]);
    });

    it("successfully lists orders with less than", async () => {
      const api = useApi();

      const response = await api.get(
        "/admin/orders?fields=id&created_at[lt]=01-26-2000",
        {
          headers: {
            authorization: "Bearer test_token",
          },
        }
      );

      expect(response.status).toEqual(200);
      expect(response.data.orders).toEqual([
        expect.objectContaining({
          id: "test-order",
        }),
      ]);
    });

    it("successfully lists no orders with less than", async () => {
      const api = useApi();

      const response = await api.get(
        "/admin/orders?fields=id&created_at[lt]=01-26-1990",
        {
          headers: {
            authorization: "Bearer test_token",
          },
        }
      );

      expect(response.status).toEqual(200);
      expect(response.data.orders).toEqual([]);
    });

    it("successfully lists orders using unix (greater than)", async () => {
      const api = useApi();

      const response = await api.get(
        "/admin/orders?fields=id&created_at[gt]=633351600",
        {
          headers: {
            authorization: "Bearer test_token",
          },
        }
      );

      expect(response.status).toEqual(200);
      expect(response.data.orders).toEqual([
        expect.objectContaining({
          id: "test-order",
        }),
      ]);
    });
  });

  describe("POST /admin/orders/:id/swaps", () => {
    beforeEach(async () => {
      try {
        await adminSeeder(dbConnection);
        await orderSeeder(dbConnection);
        await swapSeeder(dbConnection);
      } catch (err) {
        console.log(err);
        throw err;
      }
    });

    afterEach(async () => {
      const db = useDb();
      await db.teardown();
    });

    it("creates a swap", async () => {
      const api = useApi();

      const response = await api.post(
        "/admin/orders/test-order/swaps",
        {
          return_items: [
            {
              item_id: "test-item",
              quantity: 1,
            },
          ],
          additional_items: [{ variant_id: "test-variant-2", quantity: 1 }],
        },
        {
          headers: {
            authorization: "Bearer test_token",
          },
        }
      );
      expect(response.status).toEqual(200);
    });

    it("creates a swap and a return", async () => {
      const api = useApi();

      const returnedOrderFirst = await api.post(
        "/admin/orders/order-with-swap/return",
        {
          items: [
            {
              item_id: "test-item-many",
              quantity: 2,
            },
          ],
          receive_now: true,
        },
        {
          headers: {
            authorization: "Bearer test_token",
          },
        }
      );

      expect(returnedOrderFirst.status).toEqual(200);

      const returnedOrderSecond = await api.post(
        "/admin/orders/order-with-swap/return",
        {
          items: [
            {
              item_id: "test-item-many",
              quantity: 1,
            },
          ],
          receive_now: true,
        },
        {
          headers: {
            authorization: "Bearer test_token",
          },
        }
      );

      // find item to test returned quantiy for
      const toTest = returnedOrderSecond.data.order.items.find(
        (i) => i.id === "test-item-many"
      );

      expect(returnedOrderSecond.status).toEqual(200);
      expect(toTest.returned_quantity).toBe(3);
    });

    it("creates a swap and receives the items", async () => {
      const api = useApi();

      const createdSwapOrder = await api.post(
        "/admin/orders/test-order/swaps",
        {
          return_items: [
            {
              item_id: "test-item",
              quantity: 1,
            },
          ],
          additional_items: [{ variant_id: "test-variant-2", quantity: 1 }],
        },
        {
          headers: {
            authorization: "Bearer test_token",
          },
        }
      );

      expect(createdSwapOrder.status).toEqual(200);

      const swap = createdSwapOrder.data.order.swaps[0];

      const receivedSwap = await api.post(
        `/admin/returns/${swap.return_order.id}/receive`,
        {
          items: [
            {
              item_id: "test-item",
              quantity: 1,
            },
          ],
        },
        {
          headers: {
            authorization: "Bearer test_token",
          },
        }
      );

      expect(receivedSwap.status).toEqual(200);
      expect(receivedSwap.data.return.status).toBe("received");
    });

    it("creates a swap on a swap", async () => {
      const api = useApi();

      const swapOnSwap = await api.post(
        "/admin/orders/order-with-swap/swaps",
        {
          return_items: [
            {
              item_id: "test-item-swapped",
              quantity: 1,
            },
          ],
          additional_items: [{ variant_id: "test-variant", quantity: 1 }],
        },
        {
          headers: {
            authorization: "Bearer test_token",
          },
        }
      );

      expect(swapOnSwap.status).toEqual(200);
    });

    it("receives a swap on swap", async () => {
      const api = useApi();

      const received = await api.post(
        `/admin/returns/return-on-swap/receive`,
        {
          items: [
            {
              item_id: "test-item-swapped",
              quantity: 1,
            },
          ],
        },
        {
          headers: {
            authorization: "Bearer test_token",
          },
        }
      );

      expect(received.status).toEqual(200);
    });

    it("creates a return on a swap", async () => {
      const api = useApi();

      const returnOnSwap = await api.post(
        "/admin/orders/order-with-swap/return",
        {
          items: [
            {
              item_id: "test-item-swapped",
              quantity: 1,
            },
          ],
        },
        {
          headers: {
            authorization: "Bearer test_token",
          },
        }
      );

      expect(returnOnSwap.status).toEqual(200);
    });

    it("creates a return on an order", async () => {
      const api = useApi();

      const returnOnOrder = await api.post(
        "/admin/orders/test-order/return",
        {
          items: [
            {
              item_id: "test-item",
              quantity: 1,
            },
          ],
        },
        {
          headers: {
            authorization: "Bearer test_token",
          },
        }
      );

      expect(returnOnOrder.status).toEqual(200);

      const captured = await api.post(
        "/admin/orders/test-order/capture",
        {},
        {
          headers: {
            authorization: "Bearer test_token",
          },
        }
      );

      const returnId = returnOnOrder.data.order.returns[0].id;

      const received = await api.post(
        `/admin/returns/${returnId}/receive`,
        {
          items: [
            {
              item_id: "test-item",
              quantity: 1,
            },
          ],
        },
        {
          headers: {
            authorization: "Bearer test_token",
          },
        }
      );

      expect(received.status).toEqual(200);
    });
  });
});