fix merge conflicts from develop

integration-tests/api/__tests__/admin/discount.js

@@ -0,0 +1,161 @@
+const { dropDatabase } = require("pg-god");
+const path = require("path");
+const { Region, DiscountRule, Discount } = require("@medusajs/medusa");
+
+const setupServer = require("../../../helpers/setup-server");
+const { useApi } = require("../../../helpers/use-api");
+const { initDb } = require("../../../helpers/use-db");
+const adminSeeder = require("../../helpers/admin-seeder");
+
+jest.setTimeout(30000);
+
+describe("/admin/discounts", () => {
+  let medusaProcess;
+  let dbConnection;
+
+  beforeAll(async () => {
+    const cwd = path.resolve(path.join(__dirname, "..", ".."));
+    dbConnection = await initDb({ cwd });
+    medusaProcess = await setupServer({ cwd });
+  });
+
+  afterAll(async () => {
+    await dbConnection.close();
+    await dropDatabase({ databaseName: "medusa-integration" });
+
+    medusaProcess.kill();
+  });
+
+  describe("POST /admin/discounts", () => {
+    beforeEach(async () => {
+      const manager = dbConnection.manager;
+      try {
+        await adminSeeder(dbConnection);
+      } catch (err) {
+        console.log(err);
+        throw err;
+      }
+    });
+
+    afterEach(async () => {
+      const manager = dbConnection.manager;
+      await manager.query(`DELETE FROM "discount"`);
+      await manager.query(`DELETE FROM "discount_rule"`);
+      await manager.query(`DELETE FROM "user"`);
+    });
+
+    it("creates a discount and updates it", async () => {
+      const api = useApi();
+
+      const response = await api
+        .post(
+          "/admin/discounts",
+          {
+            code: "HELLOWORLD",
+            rule: {
+              description: "test",
+              type: "percentage",
+              value: 10,
+              allocation: "total",
+            },
+            usage_limit: 10,
+          },
+          {
+            headers: {
+              Authorization: "Bearer test_token",
+            },
+          }
+        )
+        .catch((err) => {
+          console.log(err);
+        });
+
+      expect(response.status).toEqual(200);
+      expect(response.data.discount).toEqual(
+        expect.objectContaining({
+          code: "HELLOWORLD",
+          usage_limit: 10,
+        })
+      );
+
+      const updated = await api
+        .post(
+          `/admin/discounts/${response.data.discount.id}`,
+          {
+            usage_limit: 20,
+          },
+          {
+            headers: {
+              Authorization: "Bearer test_token",
+            },
+          }
+        )
+        .catch((err) => {
+          console.log(err);
+        });
+
+      expect(updated.status).toEqual(200);
+      expect(updated.data.discount).toEqual(
+        expect.objectContaining({
+          code: "HELLOWORLD",
+          usage_limit: 20,
+        })
+      );
+    });
+  });
+
+  describe("POST /admin/discounts/:discount_id/dynamic-codes", () => {
+    beforeEach(async () => {
+      const manager = dbConnection.manager;
+      try {
+        await adminSeeder(dbConnection);
+        await manager.insert(DiscountRule, {
+          id: "test-discount-rule",
+          description: "Dynamic rule",
+          type: "percentage",
+          value: 10,
+          allocation: "total",
+        });
+        await manager.insert(Discount, {
+          id: "test-discount",
+          code: "DYNAMIC",
+          is_dynamic: true,
+          is_disabled: false,
+          rule_id: "test-discount-rule",
+        });
+      } catch (err) {
+        console.log(err);
+        throw err;
+      }
+    });
+
+    afterEach(async () => {
+      const manager = dbConnection.manager;
+      await manager.query(`DELETE FROM "discount"`);
+      await manager.query(`DELETE FROM "discount_rule"`);
+      await manager.query(`DELETE FROM "user"`);
+    });
+
+    it("creates a dynamic discount", async () => {
+      const api = useApi();
+
+      const response = await api
+        .post(
+          "/admin/discounts/test-discount/dynamic-codes",
+          {
+            code: "HELLOWORLD",
+          },
+          {
+            headers: {
+              Authorization: "Bearer test_token",
+            },
+          }
+        )
+        .catch((err) => {
+          console.log(err);
+        });
+
+      expect(response.status).toEqual(200);
+    });
+  });
+});

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

@@ -1,11 +1,13 @@
 const { dropDatabase } = require("pg-god");
 const path = require("path");
+const { ReturnReason } = require("@medusajs/medusa");
 
 const setupServer = require("../../../helpers/setup-server");
 const { useApi } = require("../../../helpers/use-api");
 const { initDb } = 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);
@@ -98,11 +100,12 @@ describe("/admin/orders", () => {
       await manager.query(`DELETE FROM "fulfillment_item"`);
       await manager.query(`DELETE FROM "fulfillment"`);
       await manager.query(`DELETE FROM "swap"`);
-      await manager.query(`DELETE FROM "return"`);
       await manager.query(`DELETE FROM "claim_image"`);
       await manager.query(`DELETE FROM "claim_tag"`);
       await manager.query(`DELETE FROM "claim_item"`);
       await manager.query(`DELETE FROM "shipping_method"`);
+      await manager.query(`DELETE FROM "return_item"`);
+      await manager.query(`DELETE FROM "return"`);
       await manager.query(`DELETE FROM "line_item"`);
       await manager.query(`DELETE FROM "claim_order"`);
       await manager.query(`DELETE FROM "money_amount"`);
@@ -176,6 +179,72 @@ describe("/admin/orders", () => {
       );
     });
 
+    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();
 
@@ -468,6 +537,91 @@ describe("/admin/orders", () => {
     });
   });
 
+  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 manager = dbConnection.manager;
+      await manager.query(`DELETE FROM "cart"`);
+      await manager.query(`DELETE FROM "fulfillment_item"`);
+      await manager.query(`DELETE FROM "fulfillment"`);
+      await manager.query(`DELETE FROM "swap"`);
+      await manager.query(`DELETE FROM "return_item"`);
+      await manager.query(`DELETE FROM "return_reason"`);
+      await manager.query(`DELETE FROM "return"`);
+      await manager.query(`DELETE FROM "claim_image"`);
+      await manager.query(`DELETE FROM "claim_tag"`);
+      await manager.query(`DELETE FROM "claim_item"`);
+      await manager.query(`DELETE FROM "shipping_method"`);
+      await manager.query(`DELETE FROM "line_item"`);
+      await manager.query(`DELETE FROM "claim_order"`);
+      await manager.query(`DELETE FROM "money_amount"`);
+      await manager.query(`DELETE FROM "product_variant"`);
+      await manager.query(`DELETE FROM "product"`);
+      await manager.query(`DELETE FROM "shipping_option"`);
+      await manager.query(`DELETE FROM "discount"`);
+      await manager.query(`DELETE FROM "payment"`);
+      await manager.query(`DELETE FROM "order"`);
+      await manager.query(`DELETE FROM "customer"`);
+      await manager.query(
+        `UPDATE "country" SET region_id=NULL WHERE iso_2 = 'us'`
+      );
+      await manager.query(`DELETE FROM "region"`);
+      await manager.query(`DELETE FROM "user"`);
+    });
+
+    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",
+        }),
+      ]);
+    });
+  });
+
   describe("GET /admin/orders", () => {
     beforeEach(async () => {
       try {
@@ -620,4 +774,286 @@ describe("/admin/orders", () => {
       ]);
     });
   });
+
+  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 manager = dbConnection.manager;
+      await manager.query(`DELETE FROM "fulfillment_item"`);
+      await manager.query(`DELETE FROM "fulfillment"`);
+      await manager.query(`DELETE FROM "return_item"`);
+      await manager.query(`DELETE FROM "return_reason"`);
+      await manager.query(`DELETE FROM "return"`);
+      await manager.query(`DELETE FROM "claim_image"`);
+      await manager.query(`DELETE FROM "claim_tag"`);
+      await manager.query(`DELETE FROM "claim_item"`);
+      await manager.query(`DELETE FROM "shipping_method"`);
+      await manager.query(`DELETE FROM "line_item"`);
+      await manager.query(`DELETE FROM "payment"`);
+      await manager.query(`DELETE FROM "swap"`);
+      await manager.query(`DELETE FROM "cart"`);
+      await manager.query(`DELETE FROM "claim_order"`);
+      await manager.query(`DELETE FROM "money_amount"`);
+      await manager.query(`DELETE FROM "product_variant"`);
+      await manager.query(`DELETE FROM "product"`);
+      await manager.query(`DELETE FROM "shipping_option"`);
+      await manager.query(`DELETE FROM "discount"`);
+      await manager.query(`DELETE FROM "refund"`);
+      await manager.query(`DELETE FROM "order"`);
+      await manager.query(`DELETE FROM "customer"`);
+      await manager.query(
+        `UPDATE "country" SET region_id=NULL WHERE iso_2 = 'us'`
+      );
+      await manager.query(`DELETE FROM "region"`);
+      await manager.query(`DELETE FROM "user"`);
+    });
+
+    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",
+          },
+        }
+      );
+
+      expect(returnedOrderSecond.status).toEqual(200);
+      expect(returnedOrderSecond.data.order.items[1].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);
+    });
+  });
 });

integration-tests/api/__tests__/admin/product.js

@@ -42,6 +42,7 @@ describe("/admin/products", () => {
       const manager = dbConnection.manager;
       await manager.query(`DELETE FROM "product_option_value"`);
       await manager.query(`DELETE FROM "product_option"`);
+      await manager.query(`DELETE FROM "image"`);
       await manager.query(`DELETE FROM "money_amount"`);
       await manager.query(`DELETE FROM "product_variant"`);
       await manager.query(`DELETE FROM "product"`);
@@ -62,6 +63,7 @@ describe("/admin/products", () => {
         title: "Test product",
         description: "test-product-description",
         type: { value: "test-type" },
+        images: ["test-image.png", "test-image-2.png"],
         collection_id: "test-collection",
         tags: [{ value: "123" }, { value: "456" }],
         options: [{ title: "size" }, { title: "color" }],
@@ -91,6 +93,15 @@ describe("/admin/products", () => {
         expect.objectContaining({
           title: "Test product",
           handle: "test-product",
+          images: expect.arrayContaining([
+            expect.objectContaining({
+              url: "test-image.png",
+            }),
+            expect.objectContaining({
+              url: "test-image-2.png",
+            }),
+          ]),
+          thumbnail: "test-image.png",
           tags: [
             expect.objectContaining({
               value: "123",
@@ -137,13 +148,15 @@ describe("/admin/products", () => {
       );
     });
 
-    it("updates a product (update tags, delete collection, delete type)", async () => {
+    it("updates a product (update tags, delete collection, delete type, replaces images)", async () => {
       const api = useApi();
 
       const payload = {
         collection_id: null,
         type: null,
         tags: [{ value: "123" }],
+        images: ["test-image-2.png"],
+        type: { value: "test-type-2" },
       };
 
       const response = await api
@@ -160,6 +173,12 @@ describe("/admin/products", () => {
 
       expect(response.data.product).toEqual(
         expect.objectContaining({
+          images: expect.arrayContaining([
+            expect.objectContaining({
+              url: "test-image-2.png",
+            }),
+          ]),
+          thumbnail: "test-image-2.png",
           tags: [
             expect.objectContaining({
               value: "123",
@@ -167,6 +186,9 @@ describe("/admin/products", () => {
           ],
           type: null,
           collection: null,
+          type: expect.objectContaining({
+            value: "test-type-2",
+          }),
         })
       );
     });

integration-tests/api/__tests__/admin/return-reason.js

@@ -0,0 +1,170 @@
+const { dropDatabase } = require("pg-god");
+const path = require("path");
+
+const setupServer = require("../../../helpers/setup-server");
+const { useApi } = require("../../../helpers/use-api");
+const { initDb } = require("../../../helpers/use-db");
+
+const adminSeeder = require("../../helpers/admin-seeder");
+
+jest.setTimeout(30000);
+
+describe("/admin/return-reasons", () => {
+  let medusaProcess;
+  let dbConnection;
+
+  beforeAll(async () => {
+    const cwd = path.resolve(path.join(__dirname, "..", ".."));
+    dbConnection = await initDb({ cwd });
+    medusaProcess = await setupServer({ cwd });
+  });
+
+  afterAll(async () => {
+    await dbConnection.close();
+    await dropDatabase({ databaseName: "medusa-integration" });
+
+    medusaProcess.kill();
+  });
+
+  describe("POST /admin/return-reasons", () => {
+    beforeEach(async () => {
+      try {
+        await adminSeeder(dbConnection);
+      } catch (err) {
+        console.log(err);
+        throw err;
+      }
+    });
+
+    afterEach(async () => {
+      const manager = dbConnection.manager;
+      await manager.query(`DELETE FROM "return_reason"`);
+      await manager.query(`DELETE FROM "user"`);
+    });
+
+    it("creates a return_reason", async () => {
+      const api = useApi();
+
+      const payload = {
+        label: "Too Big",
+        description: "Use this if the size was too big",
+        value: "too_big",
+      };
+
+      const response = await api
+        .post("/admin/return-reasons", payload, {
+          headers: {
+            Authorization: "Bearer test_token",
+          },
+        })
+        .catch((err) => {
+          console.log(err);
+        });
+
+      expect(response.status).toEqual(200);
+
+      expect(response.data.return_reason).toEqual(
+        expect.objectContaining({
+          label: "Too Big",
+          description: "Use this if the size was too big",
+          value: "too_big",
+        })
+      );
+    });
+
+    it("update a return reason", async () => {
+      const api = useApi();
+
+      const payload = {
+        label: "Too Big Typo",
+        description: "Use this if the size was too big",
+        value: "too_big",
+      };
+
+      const response = await api
+        .post("/admin/return-reasons", payload, {
+          headers: {
+            Authorization: "Bearer test_token",
+          },
+        })
+        .catch((err) => {
+          console.log(err);
+        });
+
+      expect(response.status).toEqual(200);
+
+      expect(response.data.return_reason).toEqual(
+        expect.objectContaining({
+          label: "Too Big Typo",
+          description: "Use this if the size was too big",
+          value: "too_big",
+        })
+      );
+
+      const newResponse = await api
+        .post(
+          `/admin/return-reasons/${response.data.return_reason.id}`,
+          {
+            label: "Too Big",
+            description: "new desc",
+          },
+          {
+            headers: {
+              Authorization: "Bearer test_token",
+            },
+          }
+        )
+        .catch((err) => {
+          console.log(err);
+        });
+
+      expect(newResponse.data.return_reason).toEqual(
+        expect.objectContaining({
+          label: "Too Big",
+          description: "new desc",
+          value: "too_big",
+        })
+      );
+    });
+
+    it("list return reasons", async () => {
+      const api = useApi();
+
+      const payload = {
+        label: "Too Big Typo",
+        description: "Use this if the size was too big",
+        value: "too_big",
+      };
+
+      await api
+        .post("/admin/return-reasons", payload, {
+          headers: {
+            Authorization: "Bearer test_token",
+          },
+        })
+        .catch((err) => {
+          console.log(err);
+        });
+
+      const response = await api
+        .get("/admin/return-reasons", {
+          headers: {
+            Authorization: "Bearer test_token",
+          },
+        })
+        .catch((err) => {
+          console.log(err);
+        });
+
+      expect(response.status).toEqual(200);
+
+      console.log(response.data);
+
+      expect(response.data.return_reasons).toEqual([
+        expect.objectContaining({
+          value: "too_big",
+        }),
+      ]);
+    });
+  });
+});

integration-tests/api/__tests__/store/cart.js

@@ -14,6 +14,19 @@ describe("/store/carts", () => {
   let medusaProcess;
   let dbConnection;
 
+  const doAfterEach = async (manager) => {
+    await manager.query(`DELETE FROM "discount"`);
+    await manager.query(`DELETE FROM "discount_rule"`);
+    await manager.query(`DELETE FROM "shipping_method"`);
+    await manager.query(`DELETE FROM "shipping_option"`);
+    await manager.query(`DELETE FROM "cart"`);
+    await manager.query(`DELETE FROM "customer"`);
+    await manager.query(
+      `UPDATE "country" SET region_id=NULL WHERE iso_2 = 'us'`
+    );
+    await manager.query(`DELETE FROM "region"`);
+  };
+
   beforeAll(async () => {
     const cwd = path.resolve(path.join(__dirname, "..", ".."));
     dbConnection = await initDb({ cwd });
@@ -43,11 +56,7 @@ describe("/store/carts", () => {
 
     afterEach(async () => {
       const manager = dbConnection.manager;
-      await manager.query(`DELETE FROM "cart"`);
-      await manager.query(
-        `UPDATE "country" SET region_id=NULL WHERE iso_2 = 'us'`
-      );
-      await manager.query(`DELETE FROM "region"`);
+      await doAfterEach(manager);
     });
 
     it("creates a cart", async () => {
@@ -72,6 +81,26 @@ describe("/store/carts", () => {
       const getRes = await api.post(`/store/carts/${response.data.cart.id}`);
       expect(getRes.status).toEqual(200);
     });
+
+    it("creates a cart with context", async () => {
+      const api = useApi();
+      const response = await api.post("/store/carts", {
+        context: {
+          test_id: "test",
+        },
+      });
+      expect(response.status).toEqual(200);
+
+      const getRes = await api.post(`/store/carts/${response.data.cart.id}`);
+      expect(getRes.status).toEqual(200);
+
+      const cart = getRes.data.cart;
+      expect(cart.context).toEqual({
+        ip: "::ffff:127.0.0.1",
+        user_agent: "axios/0.21.1",
+        test_id: "test",
+      });
+    });
   });
 
   describe("POST /store/carts/:id", () => {
@@ -86,12 +115,22 @@ describe("/store/carts", () => {
 
     afterEach(async () => {
       const manager = dbConnection.manager;
-      await manager.query(`DELETE FROM "cart"`);
-      await manager.query(`DELETE FROM "customer"`);
-      await manager.query(
-        `UPDATE "country" SET region_id=NULL WHERE iso_2 = 'us'`
-      );
-      await manager.query(`DELETE FROM "region"`);
+      await doAfterEach(manager);
+    });
+
+    it("fails on apply discount if limit has been reached", async () => {
+      const api = useApi();
+
+      try {
+        await api.post("/store/carts/test-cart", {
+          discounts: [{ code: "CREATED" }],
+        });
+      } catch (error) {
+        expect(error.response.status).toEqual(400);
+        expect(error.response.data.message).toEqual(
+          "Discount has been used maximum allowed times"
+        );
+      }
     });
 
     it("updates cart customer id", async () => {
@@ -103,6 +142,73 @@ describe("/store/carts", () => {
 
       expect(response.status).toEqual(200);
     });
+
+    it("adds free shipping to cart then removes it again", async () => {
+      const api = useApi();
+
+      let cart = await api.post(
+        "/store/carts/test-cart",
+        {
+          discounts: [{ code: "FREE_SHIPPING" }, { code: "CREATED" }],
+        },
+        { withCredentials: true }
+      );
+
+      expect(cart.data.cart.shipping_total).toBe(0);
+      expect(cart.status).toEqual(200);
+
+      cart = await api.post(
+        "/store/carts/test-cart",
+        {
+          discounts: [{ code: "CREATED" }],
+        },
+        { withCredentials: true }
+      );
+
+      expect(cart.data.cart.shipping_total).toBe(1000);
+      expect(cart.status).toEqual(200);
+    });
+  });
+
+  describe("DELETE /store/carts/:id/discounts/:code", () => {
+    beforeEach(async () => {
+      try {
+        await cartSeeder(dbConnection);
+        await dbConnection.manager.query(
+          `INSERT INTO "cart_discounts" (cart_id, discount_id) VALUES ('test-cart', 'free-shipping')`
+        );
+      } catch (err) {
+        console.log(err);
+        throw err;
+      }
+    });
+
+    afterEach(async () => {
+      const manager = dbConnection.manager;
+      await doAfterEach(manager);
+    });
+
+    it("removes free shipping and updates shipping total", async () => {
+      const api = useApi();
+
+      const cartWithFreeShipping = await api.post(
+        "/store/carts/test-cart",
+        {
+          discounts: [{ code: "FREE_SHIPPING" }],
+        },
+        { withCredentials: true }
+      );
+
+      expect(cartWithFreeShipping.data.cart.shipping_total).toBe(0);
+      expect(cartWithFreeShipping.status).toEqual(200);
+
+      const response = await api.delete(
+        "/store/carts/test-cart/discounts/FREE_SHIPPING"
+      );
+
+      expect(response.data.cart.shipping_total).toBe(1000);
+      expect(response.status).toEqual(200);
+    });
   });
 
   describe("get-cart with session customer", () => {
@@ -117,12 +223,7 @@ describe("/store/carts", () => {
 
     afterEach(async () => {
       const manager = dbConnection.manager;
-      await manager.query(`DELETE FROM "cart"`);
-      await manager.query(`DELETE FROM "customer"`);
-      await manager.query(
-        `UPDATE "country" SET region_id=NULL WHERE iso_2 = 'us'`
-      );
-      await manager.query(`DELETE FROM "region"`);
+      await doAfterEach(manager);
     });
 
     it("updates empty cart.customer_id on cart retrieval", async () => {

integration-tests/api/__tests__/store/gift-cards.js

@@ -59,6 +59,7 @@ describe("/store/gift-cards", () => {
         code: "GC_TEST",
         value: 200,
         balance: 120,
+        region: expect.any(Object),
       });
     });
   });

integration-tests/api/__tests__/store/return-reason.js

@@ -0,0 +1,69 @@
+const { dropDatabase } = require("pg-god");
+const path = require("path");
+
+const { ReturnReason } = require("@medusajs/medusa");
+
+const setupServer = require("../../../helpers/setup-server");
+const { useApi } = require("../../../helpers/use-api");
+const { initDb } = require("../../../helpers/use-db");
+
+jest.setTimeout(30000);
+
+describe("/store/return-reasons", () => {
+  let medusaProcess;
+  let dbConnection;
+
+  beforeAll(async () => {
+    const cwd = path.resolve(path.join(__dirname, "..", ".."));
+    dbConnection = await initDb({ cwd });
+    medusaProcess = await setupServer({ cwd });
+  });
+
+  afterAll(async () => {
+    await dbConnection.close();
+    await dropDatabase({ databaseName: "medusa-integration" });
+
+    medusaProcess.kill();
+  });
+
+  describe("GET /store/return-reasons", () => {
+    let rrId;
+
+    beforeEach(async () => {
+      try {
+        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 manager = dbConnection.manager;
+      await manager.query(`DELETE FROM "return_reason"`);
+    });
+
+    it("list return reasons", async () => {
+      const api = useApi();
+
+      const response = await api.get("/store/return-reasons").catch((err) => {
+        console.log(err);
+      });
+
+      expect(response.status).toEqual(200);
+
+      expect(response.data.return_reasons).toEqual([
+        expect.objectContaining({
+          id: rrId,
+          value: "too_big",
+        }),
+      ]);
+    });
+  });
+});

integration-tests/api/__tests__/store/returns.js

@@ -2,6 +2,7 @@ const { dropDatabase } = require("pg-god");
 const path = require("path");
 const {
   Region,
+  ReturnReason,
   Order,
   Customer,
   ShippingProfile,
@@ -35,6 +36,8 @@ describe("/store/carts", () => {
   });
 
   describe("POST /store/returns", () => {
+    let rrId;
+
     beforeEach(async () => {
       const manager = dbConnection.manager;
       await manager.query(
@@ -110,6 +113,14 @@ describe("/store/carts", () => {
         amount: 1000,
         is_return: true,
       });
+
+      const created = dbConnection.manager.create(ReturnReason, {
+        value: "too_big",
+        label: "Too Big",
+      });
+      const result = await dbConnection.manager.save(created);
+
+      rrId = result.id;
     });
 
     afterEach(async () => {
@@ -117,6 +128,7 @@ describe("/store/carts", () => {
       await manager.query(`DELETE FROM "shipping_method"`);
       await manager.query(`DELETE FROM "shipping_option"`);
       await manager.query(`DELETE FROM "return_item"`);
+      await manager.query(`DELETE FROM "return_reason"`);
       await manager.query(`DELETE FROM "return"`);
       await manager.query(`DELETE FROM "line_item"`);
       await manager.query(`DELETE FROM "order"`);
@@ -174,5 +186,33 @@ describe("/store/carts", () => {
 
       expect(response.data.return.refund_amount).toEqual(7000);
     });
+
+    it("creates a return with reasons", async () => {
+      const api = useApi();
+
+      const response = await api
+        .post("/store/returns", {
+          order_id: "order_test",
+          items: [
+            {
+              reason_id: rrId,
+              note: "TOO small",
+              item_id: "test-item",
+              quantity: 1,
+            },
+          ],
+        })
+        .catch((err) => {
+          return err.response;
+        });
+      expect(response.status).toEqual(200);
+
+      expect(response.data.return.items).toEqual([
+        expect.objectContaining({
+          reason_id: rrId,
+          note: "TOO small",
+        }),
+      ]);
+    });
   });
 });

integration-tests/api/__tests__/store/shipping-options.js

@@ -0,0 +1,134 @@
+const { dropDatabase } = require("pg-god");
+const path = require("path");
+const { Region, ShippingProfile, ShippingOption } = require("@medusajs/medusa");
+
+const setupServer = require("../../../helpers/setup-server");
+const { useApi } = require("../../../helpers/use-api");
+const { initDb } = require("../../../helpers/use-db");
+
+jest.setTimeout(30000);
+
+describe("/store/shipping-options", () => {
+  let medusaProcess;
+  let dbConnection;
+
+  beforeAll(async () => {
+    const cwd = path.resolve(path.join(__dirname, "..", ".."));
+    dbConnection = await initDb({ cwd });
+    medusaProcess = await setupServer({ cwd });
+  });
+
+  afterAll(async () => {
+    dbConnection.close();
+    await dropDatabase({ databaseName: "medusa-integration" });
+
+    medusaProcess.kill();
+  });
+
+  describe("POST /store/shipping-options", () => {
+    beforeEach(async () => {
+      const manager = dbConnection.manager;
+      await manager.query(
+        `ALTER SEQUENCE order_display_id_seq RESTART WITH 111`
+      );
+
+      await manager.insert(Region, {
+        id: "region",
+        name: "Test Region",
+        currency_code: "usd",
+        tax_rate: 0,
+      });
+      await manager.insert(Region, {
+        id: "region2",
+        name: "Test Region 2",
+        currency_code: "usd",
+        tax_rate: 0,
+      });
+
+      const defaultProfile = await manager.findOne(ShippingProfile, {
+        type: "default",
+      });
+
+      await manager.insert(ShippingOption, {
+        id: "test-out",
+        name: "Test out",
+        profile_id: defaultProfile.id,
+        region_id: "region",
+        provider_id: "test-ful",
+        data: {},
+        price_type: "flat_rate",
+        amount: 2000,
+        is_return: false,
+      });
+
+      await manager.insert(ShippingOption, {
+        id: "test-return",
+        name: "Test ret",
+        profile_id: defaultProfile.id,
+        region_id: "region",
+        provider_id: "test-ful",
+        data: {},
+        price_type: "flat_rate",
+        amount: 1000,
+        is_return: true,
+      });
+
+      await manager.insert(ShippingOption, {
+        id: "test-region2",
+        name: "Test region 2",
+        profile_id: defaultProfile.id,
+        region_id: "region2",
+        provider_id: "test-ful",
+        data: {},
+        price_type: "flat_rate",
+        amount: 1000,
+        is_return: false,
+      });
+    });
+
+    afterEach(async () => {
+      const manager = dbConnection.manager;
+      await manager.query(`DELETE FROM "shipping_option"`);
+      await manager.query(`DELETE FROM "region"`);
+    });
+
+    it("retrieves all shipping options", async () => {
+      const api = useApi();
+
+      const response = await api.get("/store/shipping-options").catch((err) => {
+        return err.response;
+      });
+
+      expect(response.status).toEqual(200);
+      expect(response.data.shipping_options.length).toEqual(3);
+    });
+
+    it("creates a return with shipping method", async () => {
+      const api = useApi();
+
+      const response = await api
+        .get("/store/shipping-options?is_return=true")
+        .catch((err) => {
+          return err.response;
+        });
+
+      expect(response.status).toEqual(200);
+      expect(response.data.shipping_options.length).toEqual(1);
+      expect(response.data.shipping_options[0].id).toEqual("test-return");
+    });
+
+    it("creates a return with shipping method", async () => {
+      const api = useApi();
+
+      const response = await api
+        .get("/store/shipping-options?region_id=region2")
+        .catch((err) => {
+          return err.response;
+        });
+
+      expect(response.status).toEqual(200);
+      expect(response.data.shipping_options.length).toEqual(1);
+      expect(response.data.shipping_options[0].id).toEqual("test-region2");
+    });
+  });
+});