merge develop

integration-tests/api/__tests__/admin/__snapshots__/auth.js.snap

@@ -0,0 +1,15 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`/admin/auth creates admin session correctly 1`] = `
+Object {
+  "api_token": "test_token",
+  "created_at": Any<String>,
+  "deleted_at": null,
+  "email": "admin@medusa.js",
+  "first_name": null,
+  "id": "admin_user",
+  "last_name": null,
+  "metadata": null,
+  "updated_at": Any<String>,
+}
+`;

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

@@ -380,5 +380,198 @@ Array [
     "weight": null,
     "width": null,
   },
+  Object {
+    "collection": Any<Object>,
+    "collection_id": "test-collection1",
+    "created_at": Any<String>,
+    "deleted_at": null,
+    "description": "test-product-description",
+    "discountable": true,
+    "handle": "test-product_filtering_3",
+    "height": null,
+    "hs_code": null,
+    "id": StringMatching /\\^test-\\*/,
+    "images": Array [],
+    "is_giftcard": false,
+    "length": null,
+    "material": null,
+    "metadata": null,
+    "mid_code": null,
+    "options": Any<Array>,
+    "origin_country": null,
+    "profile_id": StringMatching /\\^sp_\\*/,
+    "status": "draft",
+    "subtitle": null,
+    "tags": Any<Array>,
+    "thumbnail": null,
+    "title": "Test product filtering 3",
+    "type": Any<Object>,
+    "type_id": "test-type",
+    "updated_at": Any<String>,
+    "variants": Any<Array>,
+    "weight": null,
+    "width": null,
+  },
+  Object {
+    "collection": Any<Object>,
+    "collection_id": "test-collection1",
+    "created_at": Any<String>,
+    "deleted_at": null,
+    "description": "test-product-description",
+    "discountable": true,
+    "handle": "test-product_filtering_1",
+    "height": null,
+    "hs_code": null,
+    "id": StringMatching /\\^test-\\*/,
+    "images": Array [],
+    "is_giftcard": false,
+    "length": null,
+    "material": null,
+    "metadata": null,
+    "mid_code": null,
+    "options": Any<Array>,
+    "origin_country": null,
+    "profile_id": StringMatching /\\^sp_\\*/,
+    "status": "proposed",
+    "subtitle": null,
+    "tags": Any<Array>,
+    "thumbnail": null,
+    "title": "Test product filtering 1",
+    "type": Any<Object>,
+    "type_id": "test-type",
+    "updated_at": Any<String>,
+    "variants": Any<Array>,
+    "weight": null,
+    "width": null,
+  },
+  Object {
+    "collection": Any<Object>,
+    "collection_id": "test-collection2",
+    "created_at": Any<String>,
+    "deleted_at": null,
+    "description": "test-product-description",
+    "discountable": true,
+    "handle": "test-product_filtering_2",
+    "height": null,
+    "hs_code": null,
+    "id": StringMatching /\\^test-\\*/,
+    "images": Array [],
+    "is_giftcard": false,
+    "length": null,
+    "material": null,
+    "metadata": null,
+    "mid_code": null,
+    "options": Any<Array>,
+    "origin_country": null,
+    "profile_id": StringMatching /\\^sp_\\*/,
+    "status": "published",
+    "subtitle": null,
+    "tags": Any<Array>,
+    "thumbnail": null,
+    "title": "Test product filtering 2",
+    "type": Any<Object>,
+    "type_id": "test-type",
+    "updated_at": Any<String>,
+    "variants": Any<Array>,
+    "weight": null,
+    "width": null,
+  },
+]
+`;
+
+exports[`/admin/products GET /admin/products returns a list of products with giftcard in list 1`] = `
+Array [
+  Object {
+    "collection": null,
+    "collection_id": null,
+    "created_at": Any<String>,
+    "deleted_at": null,
+    "description": "test-giftcard-description",
+    "discountable": false,
+    "handle": "test-giftcard",
+    "height": null,
+    "hs_code": null,
+    "id": StringMatching /\\^prod_\\*/,
+    "images": Array [],
+    "is_giftcard": true,
+    "length": null,
+    "material": null,
+    "metadata": null,
+    "mid_code": null,
+    "options": Array [
+      Object {
+        "created_at": Any<String>,
+        "deleted_at": null,
+        "id": StringMatching /\\^opt_\\*/,
+        "metadata": null,
+        "product_id": StringMatching /\\^prod_\\*/,
+        "title": "Denominations",
+        "updated_at": Any<String>,
+      },
+    ],
+    "origin_country": null,
+    "profile_id": StringMatching /\\^sp_\\*/,
+    "status": "draft",
+    "subtitle": null,
+    "tags": Array [],
+    "thumbnail": null,
+    "title": "Test Giftcard",
+    "type": null,
+    "type_id": null,
+    "updated_at": Any<String>,
+    "variants": Array [
+      Object {
+        "allow_backorder": false,
+        "barcode": null,
+        "created_at": Any<String>,
+        "deleted_at": null,
+        "ean": null,
+        "height": null,
+        "hs_code": null,
+        "id": StringMatching /\\^variant_\\*/,
+        "inventory_quantity": 0,
+        "length": null,
+        "manage_inventory": true,
+        "material": null,
+        "metadata": null,
+        "mid_code": null,
+        "options": Array [
+          Object {
+            "created_at": Any<String>,
+            "deleted_at": null,
+            "id": StringMatching /\\^opt_\\*/,
+            "metadata": null,
+            "option_id": StringMatching /\\^opt_\\*/,
+            "updated_at": Any<String>,
+            "value": "100",
+            "variant_id": StringMatching /\\^variant_\\*/,
+          },
+        ],
+        "origin_country": null,
+        "prices": Array [
+          Object {
+            "amount": 100,
+            "created_at": Any<String>,
+            "currency_code": "usd",
+            "deleted_at": null,
+            "id": Any<String>,
+            "region_id": null,
+            "sale_amount": null,
+            "updated_at": Any<String>,
+            "variant_id": StringMatching /\\^variant_\\*/,
+          },
+        ],
+        "product_id": StringMatching /\\^prod_\\*/,
+        "sku": null,
+        "title": "Test variant",
+        "upc": null,
+        "updated_at": Any<String>,
+        "weight": null,
+        "width": null,
+      },
+    ],
+    "weight": null,
+    "width": null,
+  },
 ]
 `;

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

@@ -0,0 +1,54 @@
+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, useDb } = require("../../../helpers/use-db")
+const adminSeeder = require("../../helpers/admin-seeder")
+const { exportAllDeclaration } = require("@babel/types")
+
+jest.setTimeout(30000)
+
+describe("/admin/auth", () => {
+  let medusaProcess
+  let dbConnection
+
+  beforeAll(async () => {
+    const cwd = path.resolve(path.join(__dirname, "..", ".."))
+    dbConnection = await initDb({ cwd })
+    medusaProcess = await setupServer({ cwd })
+
+    try {
+      await adminSeeder(dbConnection)
+    } catch (e) {
+      throw e
+    }
+  })
+
+  afterAll(async () => {
+    const db = useDb()
+    await db.shutdown()
+    medusaProcess.kill()
+  })
+
+  it("creates admin session correctly", async () => {
+    const api = useApi()
+
+    const response = await api
+      .post("/admin/auth", {
+        email: "admin@medusa.js",
+        password: "secret_password",
+      })
+      .catch((err) => {
+        console.log(err)
+      })
+
+    expect(response.status).toEqual(200)
+    expect(response.data.user.password_hash).toEqual(undefined)
+    expect(response.data.user).toMatchSnapshot({
+      email: "admin@medusa.js",
+      created_at: expect.any(String),
+      updated_at: expect.any(String),
+    })
+  })
+})

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

@@ -158,6 +158,193 @@ describe("/admin/discounts", () => {
         })
       )
     })
+
+    it("creates a discount with start and end dates", 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,
+            starts_at: new Date("09/15/2021 11:50"),
+            ends_at: new Date("09/15/2021 17:50"),
+          },
+          {
+            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,
+          starts_at: expect.any(String),
+          ends_at: expect.any(String),
+        })
+      )
+
+      expect(new Date(response.data.discount.starts_at)).toEqual(
+        new Date("09/15/2021 11:50")
+      )
+
+      expect(new Date(response.data.discount.ends_at)).toEqual(
+        new Date("09/15/2021 17:50")
+      )
+
+      const updated = await api
+        .post(
+          `/admin/discounts/${response.data.discount.id}`,
+          {
+            usage_limit: 20,
+            starts_at: new Date("09/14/2021 11:50"),
+            ends_at: new Date("09/17/2021 17:50"),
+          },
+          {
+            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,
+          starts_at: expect.any(String),
+          ends_at: expect.any(String),
+        })
+      )
+
+      expect(new Date(updated.data.discount.starts_at)).toEqual(
+        new Date("09/14/2021 11:50")
+      )
+
+      expect(new Date(updated.data.discount.ends_at)).toEqual(
+        new Date("09/17/2021 17:50")
+      )
+    })
+
+    it("fails to update end date to a date before start date", async () => {
+      expect.assertions(6)
+
+      const api = useApi()
+
+      const response = await api
+        .post(
+          "/admin/discounts",
+          {
+            code: "HELLOWORLD",
+            rule: {
+              description: "test",
+              type: "percentage",
+              value: 10,
+              allocation: "total",
+            },
+            usage_limit: 10,
+            starts_at: new Date("09/15/2021 11:50"),
+            ends_at: new Date("09/15/2021 17:50"),
+          },
+          {
+            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,
+          starts_at: expect.any(String),
+          ends_at: expect.any(String),
+        })
+      )
+
+      expect(new Date(response.data.discount.starts_at)).toEqual(
+        new Date("09/15/2021 11:50")
+      )
+
+      expect(new Date(response.data.discount.ends_at)).toEqual(
+        new Date("09/15/2021 17:50")
+      )
+
+      await api
+        .post(
+          `/admin/discounts/${response.data.discount.id}`,
+          {
+            usage_limit: 20,
+            ends_at: new Date("09/11/2021 17:50"),
+          },
+          {
+            headers: {
+              Authorization: "Bearer test_token",
+            },
+          }
+        )
+        .catch((err) => {
+          expect(err.response.status).toEqual(400)
+          expect(err.response.data.message).toEqual(
+            `"ends_at" must be greater than "starts_at"`
+          )
+        })
+    })
+
+    it("fails to create discount with end date before start date", async () => {
+      expect.assertions(2)
+      const api = useApi()
+
+      const response = await api
+        .post(
+          "/admin/discounts",
+          {
+            code: "HELLOWORLD",
+            rule: {
+              description: "test",
+              type: "percentage",
+              value: 10,
+              allocation: "total",
+            },
+            usage_limit: 10,
+            starts_at: new Date("09/15/2021 11:50"),
+            ends_at: new Date("09/14/2021 17:50"),
+          },
+          {
+            headers: {
+              Authorization: "Bearer test_token",
+            },
+          }
+        )
+        .catch((err) => {
+          expect(err.response.status).toEqual(400)
+          expect(err.response.data.message).toEqual([
+            expect.objectContaining({
+              message: `"ends_at" must be greater than "ref:starts_at"`,
+            }),
+          ])
+        })
+    })
   })
 
   describe("testing for soft-deletion + uniqueness on discount codes", () => {
@@ -286,6 +473,21 @@ describe("/admin/discounts", () => {
           is_dynamic: true,
           is_disabled: false,
           rule_id: "test-discount-rule",
+          valid_duration: "P2Y",
+        })
+        await manager.insert(DiscountRule, {
+          id: "test-discount-rule1",
+          description: "Dynamic rule",
+          type: "percentage",
+          value: 10,
+          allocation: "total",
+        })
+        await manager.insert(Discount, {
+          id: "test-discount1",
+          code: "DYNAMICCode",
+          is_dynamic: true,
+          is_disabled: false,
+          rule_id: "test-discount-rule1",
         })
       } catch (err) {
         console.log(err)
@@ -298,7 +500,7 @@ describe("/admin/discounts", () => {
       await db.teardown()
     })
 
-    it("creates a dynamic discount", async () => {
+    it("creates a dynamic discount with ends_at", async () => {
       const api = useApi()
 
       const response = await api
@@ -318,6 +520,40 @@ describe("/admin/discounts", () => {
         })
 
       expect(response.status).toEqual(200)
+      expect(response.data.discount).toEqual(
+        expect.objectContaining({
+          code: "HELLOWORLD",
+          ends_at: expect.any(String),
+        })
+      )
+    })
+
+    it("creates a dynamic discount without ends_at", async () => {
+      const api = useApi()
+
+      const response = await api
+        .post(
+          "/admin/discounts/test-discount1/dynamic-codes",
+          {
+            code: "HELLOWORLD",
+          },
+          {
+            headers: {
+              Authorization: "Bearer test_token",
+            },
+          }
+        )
+        .catch((err) => {
+          // console.log(err)
+        })
+
+      expect(response.status).toEqual(200)
+      expect(response.data.discount).toEqual(
+        expect.objectContaining({
+          code: "HELLOWORLD",
+          ends_at: null,
+        })
+      )
     })
   })
 })

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

@@ -4,6 +4,7 @@ const {
   Order,
   LineItem,
   ProductVariant,
+  CustomShippingOption,
 } = require("@medusajs/medusa")
 
 const setupServer = require("../../../helpers/setup-server")
@@ -79,7 +80,6 @@ describe("/admin/orders", () => {
         await adminSeeder(dbConnection)
         await orderSeeder(dbConnection)
         await swapSeeder(dbConnection)
-        await claimSeeder(dbConnection)
       } catch (err) {
         console.log(err)
         throw err
@@ -222,6 +222,48 @@ describe("/admin/orders", () => {
     })
   })
 
+  describe("POST /admin/orders/:id/swaps", () => {
+    beforeEach(async () => {
+      try {
+        await adminSeeder(dbConnection)
+        await orderSeeder(dbConnection)
+        await claimSeeder(dbConnection)
+      } catch (err) {
+        console.log(err)
+        throw err
+      }
+    })
+
+    afterEach(async () => {
+      const db = useDb()
+      await db.teardown()
+    })
+
+    it("creates a swap on a claim", async () => {
+      const api = useApi()
+
+      const swapOnSwap = await api.post(
+        "/admin/orders/order-with-claim/swaps",
+        {
+          return_items: [
+            {
+              item_id: "test-item-co-2",
+              quantity: 1,
+            },
+          ],
+          additional_items: [{ variant_id: "test-variant", quantity: 1 }],
+        },
+        {
+          headers: {
+            authorization: "Bearer test_token",
+          },
+        }
+      )
+
+      expect(swapOnSwap.status).toEqual(200)
+    })
+  })
+
   describe("POST /admin/orders/:id/claims", () => {
     beforeEach(async () => {
       try {
@@ -317,6 +359,43 @@ describe("/admin/orders", () => {
       )
     })
 
+    it("creates a claim on a claim", async () => {
+      const api = useApi()
+
+      const claimOnClaim = await api
+        .post(
+          "/admin/orders/order-with-claim/claims",
+          {
+            type: "replace",
+            claim_items: [
+              {
+                item_id: "test-item-co-2",
+                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)
+        })
+
+      expect(claimOnClaim.status).toEqual(200)
+    })
+
     it("creates a claim with a shipping address", async () => {
       const api = useApi()
 
@@ -840,6 +919,61 @@ describe("/admin/orders", () => {
     })
   })
 
+  describe("POST /admin/orders/:id/claims", () => {
+    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 claim on a swap", async () => {
+      const api = useApi()
+
+      const claimOnClaim = await api
+        .post(
+          "/admin/orders/order-with-swap/claims",
+          {
+            type: "replace",
+            claim_items: [
+              {
+                item_id: "return-item-1",
+                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)
+        })
+
+      expect(claimOnClaim.status).toEqual(200)
+    })
+  })
+
   describe("POST /admin/orders/:id/return", () => {
     let rrId
     beforeEach(async () => {
@@ -1276,6 +1410,47 @@ describe("/admin/orders", () => {
       expect(response.status).toEqual(200)
     })
 
+    it("creates a swap with custom shipping options", 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 }],
+          custom_shipping_options: [{ option_id: "test-option", price: 0 }],
+        },
+        {
+          headers: {
+            authorization: "Bearer test_token",
+          },
+        }
+      )
+
+      const swap = response.data.order.swaps[0]
+
+      const manager = dbConnection.manager
+      const customOptions = await manager.find(CustomShippingOption, {
+        shipping_option_id: "test-option",
+      })
+
+      expect(response.status).toEqual(200)
+      expect(customOptions).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            shipping_option_id: "test-option",
+            price: 0,
+            cart_id: swap.cart_id,
+          }),
+        ])
+      )
+    })
+
     it("creates a swap and a return", async () => {
       const api = useApi()
 

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

@@ -46,7 +46,35 @@ describe("/admin/products", () => {
       const api = useApi()
 
       const res = await api
-        .get("/admin/products?status%5B%5D=null", {
+        .get("/admin/products", {
+          headers: {
+            Authorization: "Bearer test_token",
+          },
+        })
+        .catch((err) => {
+          console.log(err)
+        })
+
+      expect(res.status).toEqual(200)
+      expect(res.data.products).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            id: "test-product",
+            status: "draft",
+          }),
+          expect.objectContaining({
+            id: "test-product1",
+            status: "draft",
+          }),
+        ])
+      )
+    })
+
+    it("returns a list of all products when no query is provided", async () => {
+      const api = useApi()
+
+      const res = await api
+        .get("/admin/products?q=", {
           headers: {
             Authorization: "Bearer test_token",
           },
@@ -89,7 +117,7 @@ describe("/admin/products", () => {
         })
 
       const response = await api
-        .get("/admin/products?status%5B%5D=proposed", {
+        .get("/admin/products?status[]=proposed", {
           headers: {
             Authorization: "Bearer test_token",
           },
@@ -109,6 +137,258 @@ describe("/admin/products", () => {
       )
     })
 
+    it("returns a list of products where status is proposed or published", async () => {
+      const api = useApi()
+
+      const notExpected = [
+        expect.objectContaining({ status: "draft" }),
+        expect.objectContaining({ status: "rejected" }),
+      ]
+
+      const response = await api
+        .get("/admin/products?status[]=published,proposed", {
+          headers: {
+            Authorization: "Bearer test_token",
+          },
+        })
+        .catch((err) => {
+          console.log(err)
+        })
+
+      expect(response.status).toEqual(200)
+      expect(response.data.products).toEqual([
+        expect.objectContaining({
+          id: "test-product_filtering_1",
+          status: "proposed",
+        }),
+        expect.objectContaining({
+          id: "test-product_filtering_2",
+          status: "published",
+        }),
+      ])
+
+      for (const notExpect of notExpected) {
+        expect(response.data.products).toEqual(
+          expect.not.arrayContaining([notExpect])
+        )
+      }
+    })
+
+    it("returns a list of products in collection", async () => {
+      const api = useApi()
+
+      const notExpected = [
+        expect.objectContaining({ collection_id: "test-collection" }),
+        expect.objectContaining({ collection_id: "test-collection2" }),
+      ]
+
+      const response = await api
+        .get("/admin/products?collection_id[]=test-collection1", {
+          headers: {
+            Authorization: "Bearer test_token",
+          },
+        })
+        .catch((err) => {
+          console.log(err)
+        })
+
+      expect(response.status).toEqual(200)
+      expect(response.data.products).toEqual([
+        expect.objectContaining({
+          id: "test-product_filtering_1",
+          collection_id: "test-collection1",
+        }),
+        expect.objectContaining({
+          id: "test-product_filtering_3",
+          collection_id: "test-collection1",
+        }),
+      ])
+
+      for (const notExpect of notExpected) {
+        expect(response.data.products).toEqual(
+          expect.not.arrayContaining([notExpect])
+        )
+      }
+    })
+
+    it("returns a list of products with tags", async () => {
+      const api = useApi()
+
+      const notExpected = [
+        expect.objectContaining({ id: "tag1" }),
+        expect.objectContaining({ id: "tag2" }),
+        expect.objectContaining({ id: "tag4" }),
+      ]
+
+      const response = await api
+        .get("/admin/products?tags[]=tag3", {
+          headers: {
+            Authorization: "Bearer test_token",
+          },
+        })
+        .catch((err) => {
+          console.log(err)
+        })
+
+      expect(response.status).toEqual(200)
+      expect(response.data.products).toEqual([
+        expect.objectContaining({
+          id: "test-product_filtering_1",
+          tags: [expect.objectContaining({ id: "tag3" })],
+        }),
+        expect.objectContaining({
+          id: "test-product_filtering_2",
+          tags: [expect.objectContaining({ id: "tag3" })],
+        }),
+      ])
+      for (const product of response.data.products) {
+        for (const notExpect of notExpected) {
+          expect(product.tags).toEqual(expect.not.arrayContaining([notExpect]))
+        }
+      }
+    })
+
+    it("returns a list of products with tags in a collection", async () => {
+      const api = useApi()
+
+      const notExpectedTags = [
+        expect.objectContaining({ id: "tag1" }),
+        expect.objectContaining({ id: "tag2" }),
+        expect.objectContaining({ id: "tag3" }),
+      ]
+
+      const notExpectedCollections = [
+        expect.objectContaining({ collection_id: "test-collection" }),
+        expect.objectContaining({ collection_id: "test-collection2" }),
+      ]
+
+      const response = await api
+        .get("/admin/products?collection_id[]=test-collection1&tags[]=tag4", {
+          headers: {
+            Authorization: "Bearer test_token",
+          },
+        })
+        .catch((err) => {
+          console.log(err)
+        })
+
+      expect(response.status).toEqual(200)
+      expect(response.data.products).toEqual([
+        expect.objectContaining({
+          id: "test-product_filtering_3",
+          collection_id: "test-collection1",
+          tags: [expect.objectContaining({ id: "tag4" })],
+        }),
+      ])
+
+      for (const notExpect of notExpectedCollections) {
+        expect(response.data.products).toEqual(
+          expect.not.arrayContaining([notExpect])
+        )
+      }
+
+      for (const product of response.data.products) {
+        for (const notExpect of notExpectedTags) {
+          expect(product.tags).toEqual(expect.not.arrayContaining([notExpect]))
+        }
+      }
+    })
+
+    it("returns a list of products with giftcard in list", async () => {
+      const api = useApi()
+
+      const payload = {
+        title: "Test Giftcard",
+        is_giftcard: true,
+        description: "test-giftcard-description",
+        options: [{ title: "Denominations" }],
+        variants: [
+          {
+            title: "Test variant",
+            prices: [{ currency_code: "usd", amount: 100 }],
+            options: [{ value: "100" }],
+          },
+        ],
+      }
+
+      await api
+        .post("/admin/products", payload, {
+          headers: {
+            Authorization: "Bearer test_token",
+          },
+        })
+        .catch((err) => {
+          console.log(err)
+        })
+
+      const response = await api
+        .get("/admin/products?is_giftcard=true", {
+          headers: {
+            Authorization: "Bearer test_token",
+          },
+        })
+        .catch((err) => {
+          console.log(err)
+        })
+
+      expect(response.data.products).toEqual(
+        expect.not.arrayContaining([
+          expect.objectContaining({ is_giftcard: false }),
+        ])
+      )
+
+      expect(response.status).toEqual(200)
+      expect(response.data.products).toMatchSnapshot([
+        {
+          title: "Test Giftcard",
+          id: expect.stringMatching(/^prod_*/),
+          is_giftcard: true,
+          description: "test-giftcard-description",
+          profile_id: expect.stringMatching(/^sp_*/),
+          options: [
+            {
+              title: "Denominations",
+              id: expect.stringMatching(/^opt_*/),
+              product_id: expect.stringMatching(/^prod_*/),
+              created_at: expect.any(String),
+              updated_at: expect.any(String),
+            },
+          ],
+
+          variants: [
+            {
+              title: "Test variant",
+              id: expect.stringMatching(/^variant_*/),
+              product_id: expect.stringMatching(/^prod_*/),
+              created_at: expect.any(String),
+              updated_at: expect.any(String),
+              prices: [
+                {
+                  id: expect.any(String),
+                  currency_code: "usd",
+                  amount: 100,
+                  variant_id: expect.stringMatching(/^variant_*/),
+                  created_at: expect.any(String),
+                  updated_at: expect.any(String),
+                },
+              ],
+              options: [
+                {
+                  id: expect.stringMatching(/^opt_*/),
+                  option_id: expect.stringMatching(/^opt_*/),
+                  created_at: expect.any(String),
+                  variant_id: expect.stringMatching(/^variant_*/),
+                  updated_at: expect.any(String),
+                },
+              ],
+            },
+          ],
+          created_at: expect.any(String),
+          updated_at: expect.any(String),
+        },
+      ])
+    })
+
     it("returns a list of products with child entities", async () => {
       const api = useApi()
 
@@ -306,6 +586,42 @@ describe("/admin/products", () => {
           created_at: expect.any(String),
           updated_at: expect.any(String),
         },
+        {
+          id: expect.stringMatching(/^test-*/),
+          profile_id: expect.stringMatching(/^sp_*/),
+          created_at: expect.any(String),
+          type: expect.any(Object),
+          collection: expect.any(Object),
+          options: expect.any(Array),
+          tags: expect.any(Array),
+          variants: expect.any(Array),
+          created_at: expect.any(String),
+          updated_at: expect.any(String),
+        },
+        {
+          id: expect.stringMatching(/^test-*/),
+          profile_id: expect.stringMatching(/^sp_*/),
+          created_at: expect.any(String),
+          type: expect.any(Object),
+          collection: expect.any(Object),
+          options: expect.any(Array),
+          tags: expect.any(Array),
+          variants: expect.any(Array),
+          created_at: expect.any(String),
+          updated_at: expect.any(String),
+        },
+        {
+          id: expect.stringMatching(/^test-*/),
+          profile_id: expect.stringMatching(/^sp_*/),
+          created_at: expect.any(String),
+          type: expect.any(Object),
+          collection: expect.any(Object),
+          options: expect.any(Array),
+          tags: expect.any(Array),
+          variants: expect.any(Array),
+          created_at: expect.any(String),
+          updated_at: expect.any(String),
+        },
       ])
     })
   })
@@ -592,6 +908,28 @@ describe("/admin/products", () => {
       )
     })
 
+    it("updates product (removes images when empty array included)", async () => {
+      const api = useApi()
+
+      const payload = {
+        images: [],
+      }
+
+      const response = await api
+        .post("/admin/products/test-product", payload, {
+          headers: {
+            Authorization: "Bearer test_token",
+          },
+        })
+        .catch((err) => {
+          console.log(err)
+        })
+
+      expect(response.status).toEqual(200)
+
+      expect(response.data.product.images.length).toEqual(0)
+    })
+
     it("fails to update product with invalid status", async () => {
       const api = useApi()
 
@@ -696,6 +1034,7 @@ describe("/admin/products", () => {
       )
     })
   })
+
   describe("testing for soft-deletion + uniqueness on handles, collection and variant properties", () => {
     beforeEach(async () => {
       try {