level_0
int64 0
10k
| index
int64 0
0
| repo_id
stringlengths 22
152
| file_path
stringlengths 41
203
| content
stringlengths 11
11.5M
|
|---|---|---|---|---|
3,757 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin/order-edits/mutations.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import {
useAdminCancelOrderEdit,
useAdminConfirmOrderEdit,
useAdminCreateOrderEdit,
useAdminDeleteOrderEdit,
useAdminDeleteOrderEditItemChange,
useAdminOrderEditAddLineItem,
useAdminOrderEditDeleteLineItem,
useAdminOrderEditUpdateLineItem,
useAdminRequestOrderEditConfirmation,
useAdminUpdateOrderEdit,
} from "../../../../src/"
import { createWrapper } from "../../../utils"
describe("useAdminOrderEditUpdateLineItem hook", () => {
test("Update line item of an order edit and create or update an item change", async () => {
const id = "oe_1"
const itemId = "item_1"
const { result, waitFor } = renderHook(
() => useAdminOrderEditUpdateLineItem(id, itemId),
{
wrapper: createWrapper(),
}
)
result.current.mutate({ quantity: 3 })
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.order_edit).toEqual(
expect.objectContaining({
...fixtures.get("order_edit"),
changes: expect.arrayContaining([
expect.objectContaining({
quantity: 3,
}),
]),
})
)
})
})
describe("useAdminDeleteOrderEditItemChange hook", () => {
test("Deletes an order edit item change", async () => {
const id = "oe_1"
const itemChangeId = "oeic_1"
const { result, waitFor } = renderHook(
() => useAdminDeleteOrderEditItemChange(id, itemChangeId),
{
wrapper: createWrapper(),
}
)
result.current.mutate()
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data).toEqual(
expect.objectContaining({
id: itemChangeId,
object: "item_change",
deleted: true,
})
)
})
})
describe("useAdminDeleteOrderEdit hook", () => {
test("Deletes an order edit", async () => {
const id = "oe_1"
const { result, waitFor } = renderHook(() => useAdminDeleteOrderEdit(id), {
wrapper: createWrapper(),
})
result.current.mutate()
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data).toEqual(
expect.objectContaining({
id,
object: "order_edit",
deleted: true,
})
)
})
})
describe("useAdminUpdateOrderEdit hook", () => {
test("updates an order edit and returns it", async () => {
const orderEdit = {
internal_note: "changed note",
}
const { result, waitFor } = renderHook(
() => useAdminUpdateOrderEdit(fixtures.get("order_edit").id),
{
wrapper: createWrapper(),
}
)
result.current.mutate(orderEdit)
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.order_edit).toEqual(
expect.objectContaining({
...fixtures.get("order_edit"),
...orderEdit,
})
)
})
})
describe("useAdminCreateOrderEdit hook", () => {
test("Created an order edit", async () => {
const { result, waitFor } = renderHook(() => useAdminCreateOrderEdit(), {
wrapper: createWrapper(),
})
const payload = {
order_id: "ord_1",
internal_note: "This is an internal note",
}
result.current.mutate(payload)
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data).toEqual(
expect.objectContaining({
order_edit: {
...fixtures.get("order_edit"),
...payload,
},
})
)
})
})
describe("useAdminRequestOrderEditConfirmation hook", () => {
test("Requests an order edit", async () => {
const { result, waitFor } = renderHook(
() => useAdminRequestOrderEditConfirmation(fixtures.get("order_edit").id),
{
wrapper: createWrapper(),
}
)
result.current.mutate()
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data?.order_edit).toEqual(
expect.objectContaining({
...fixtures.get("order_edit"),
requested_at: expect.any(String),
status: "requested",
})
)
})
})
describe("useAdminOrderEditAddLineItem hook", () => {
test("Created an order edit line item", async () => {
const { result, waitFor } = renderHook(
() => useAdminOrderEditAddLineItem(fixtures.get("order_edit").id),
{
wrapper: createWrapper(),
}
)
const payload = {
variant_id: "var_1",
quantity: 2,
}
result.current.mutate(payload)
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data).toEqual(
expect.objectContaining({
order_edit: {
...fixtures.get("order_edit"),
...payload,
},
})
)
})
})
describe("useAdminCancelOrderEdit hook", () => {
test("cancel an order edit", async () => {
const { result, waitFor } = renderHook(
() => useAdminCancelOrderEdit(fixtures.get("order_edit").id),
{
wrapper: createWrapper(),
}
)
result.current.mutate()
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data).toEqual(
expect.objectContaining({
order_edit: {
...fixtures.get("order_edit"),
canceled_at: expect.any(String),
status: "canceled",
},
})
)
})
})
describe("useAdminConfirmOrderEdit hook", () => {
test("confirm an order edit", async () => {
const { result, waitFor } = renderHook(
() => useAdminConfirmOrderEdit(fixtures.get("order_edit").id),
{
wrapper: createWrapper(),
}
)
result.current.mutate()
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data).toEqual(
expect.objectContaining({
order_edit: {
...fixtures.get("order_edit"),
confirmed_at: expect.any(String),
status: "confirmed",
},
})
)
})
})
describe("useAdminOrderEditDeleteLineItem hook", () => {
test("Remove line item of an order edit and create an item change", async () => {
const id = "oe_1"
const itemId = "item_1"
const { result, waitFor } = renderHook(
() => useAdminOrderEditDeleteLineItem(id, itemId),
{
wrapper: createWrapper(),
}
)
result.current.mutate()
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.order_edit).toEqual(
expect.objectContaining({
...fixtures.get("order_edit"),
changes: expect.arrayContaining([
expect.objectContaining({
type: "item_remove",
}),
]),
})
)
})
})
|
3,758 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin/order-edits/queries.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import { useAdminOrderEdit, useAdminOrderEdits } from "../../../../src"
import { createWrapper } from "../../../utils"
describe("useAdminOrderEdit hook", () => {
test("returns an order edit", async () => {
const order_edit = fixtures.get("order_edit")
const { result, waitFor } = renderHook(
() => useAdminOrderEdit(order_edit.id),
{
wrapper: createWrapper(),
}
)
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.order_edit).toEqual(order_edit)
})
})
describe("useAdminOrderEdits hook", () => {
test("returns an order edit", async () => {
const order_edit = fixtures.get("order_edit")
const { result, waitFor } = renderHook(() => useAdminOrderEdits(), {
wrapper: createWrapper(),
})
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.order_edits).toEqual(
expect.arrayContaining([order_edit])
)
})
})
|
3,759 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin/orders/mutations.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import {
useAdminAddShippingMethod,
useAdminArchiveOrder,
useAdminCancelFulfillment,
useAdminCancelOrder,
useAdminCapturePayment,
useAdminCompleteOrder,
useAdminCreateFulfillment,
useAdminCreateShipment,
useAdminRefundPayment,
useAdminUpdateOrder,
} from "../../../../src/"
import { createWrapper } from "../../../utils"
describe("useAdminUpdateOrder hook", () => {
test("updates a order and returns it", async () => {
const order = {
email: "[email protected]",
}
const { result, waitFor } = renderHook(
() => useAdminUpdateOrder(fixtures.get("order").id),
{
wrapper: createWrapper(),
}
)
result.current.mutate(order)
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.order).toEqual(
expect.objectContaining({
...fixtures.get("order"),
...order,
})
)
})
})
describe("useAdminCancelOrder hook", () => {
test("cancels an order", async () => {
const id = fixtures.get("order").id
const { result, waitFor } = renderHook(() => useAdminCancelOrder(id), {
wrapper: createWrapper(),
})
result.current.mutate()
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.order).toEqual(fixtures.get("order"))
})
})
describe("useAdminArchiveOrder hook", () => {
test("archives an order", async () => {
const id = fixtures.get("order").id
const { result, waitFor } = renderHook(() => useAdminArchiveOrder(id), {
wrapper: createWrapper(),
})
result.current.mutate()
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.order).toEqual(fixtures.get("order"))
})
})
describe("useAdminCompleteOrder hook", () => {
test("completes an order", async () => {
const id = fixtures.get("order").id
const { result, waitFor } = renderHook(() => useAdminCompleteOrder(id), {
wrapper: createWrapper(),
})
result.current.mutate()
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.order).toEqual(fixtures.get("order"))
})
})
describe("useAdminCapturePayment hook", () => {
test("captures an order's payment", async () => {
const id = fixtures.get("order").id
const { result, waitFor } = renderHook(() => useAdminCapturePayment(id), {
wrapper: createWrapper(),
})
result.current.mutate()
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.order).toEqual(fixtures.get("order"))
})
})
describe("useAdminRefundPayment hook", () => {
test("captures an order's payment", async () => {
const id = fixtures.get("order").id
const payload = {
amount: 100,
reason: "wrong item",
}
const { result, waitFor } = renderHook(() => useAdminRefundPayment(id), {
wrapper: createWrapper(),
})
result.current.mutate(payload)
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.order).toEqual(fixtures.get("order"))
})
})
describe("useAdminCreateShipment hook", () => {
test("creates a shipment for an order", async () => {
const id = fixtures.get("order").id
const payload = {
fulfillment_id: "test-ful",
tracking_numbers: [],
}
const { result, waitFor } = renderHook(() => useAdminCreateShipment(id), {
wrapper: createWrapper(),
})
result.current.mutate(payload)
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.order).toEqual(fixtures.get("order"))
})
})
describe("useAdminAddShippingMethod hook", () => {
test("adds a shipping method to an order", async () => {
const id = fixtures.get("order").id
const payload = {
price: 1000,
option_id: "test-so",
}
const { result, waitFor } = renderHook(
() => useAdminAddShippingMethod(id),
{
wrapper: createWrapper(),
}
)
result.current.mutate(payload)
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.order).toEqual(fixtures.get("order"))
})
})
describe("useAdminCreateFulfillment hook", () => {
test("creates a fulfillment for an order", async () => {
const id = fixtures.get("order").id
const fulfillment = {
items: [
{
item_id: "test-item",
quantity: 2,
},
],
}
const { result, waitFor } = renderHook(
() => useAdminCreateFulfillment(id),
{
wrapper: createWrapper(),
}
)
result.current.mutate(fulfillment)
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.order).toEqual(fixtures.get("order"))
})
})
describe("useAdminCancelFulfillment hook", () => {
test("cancels a fulfillment for an order", async () => {
const id = fixtures.get("order").id
const fulfillmentId = "test-ful"
const { result, waitFor } = renderHook(
() => useAdminCancelFulfillment(id),
{
wrapper: createWrapper(),
}
)
result.current.mutate(fulfillmentId)
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.order).toEqual(fixtures.get("order"))
})
})
|
3,760 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin/orders/queries.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import { useAdminOrder, useAdminOrders } from "../../../../src"
import { createWrapper } from "../../../utils"
describe("useAdminOrders hook", () => {
test("returns a list of orders", async () => {
const orders = fixtures.list("order")
const { result, waitFor } = renderHook(() => useAdminOrders(), {
wrapper: createWrapper(),
})
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.orders).toEqual(orders)
})
})
describe("useAdminOrder hook", () => {
test("returns a order", async () => {
const order = fixtures.get("order")
const { result, waitFor } = renderHook(() => useAdminOrder(order.id), {
wrapper: createWrapper(),
})
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.order).toEqual(order)
})
})
|
3,761 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin/payment-collections/mutations.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import {
useAdminDeletePaymentCollection,
useAdminMarkPaymentCollectionAsAuthorized,
useAdminUpdatePaymentCollection,
} from "../../../../src"
import { createWrapper } from "../../../utils"
describe("useAdminDeletePaymentCollection hook", () => {
test("Delete a payment collection", async () => {
const { result, waitFor } = renderHook(
() => useAdminDeletePaymentCollection("payment_collection_id"),
{
wrapper: createWrapper(),
}
)
result.current.mutate()
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data).toEqual(
expect.objectContaining({
id: "payment_collection_id",
deleted: true,
})
)
})
})
describe("useAdminUpdatePaymentCollection hook", () => {
test("Update a Payment Collection", async () => {
const { result, waitFor } = renderHook(
() => useAdminUpdatePaymentCollection("payment_collection_id"),
{
wrapper: createWrapper(),
}
)
result.current.mutate({
description: "new description",
metadata: { demo: "obj" },
})
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.payment_collection).toEqual(
expect.objectContaining({
id: "payment_collection_id",
description: "new description",
metadata: { demo: "obj" },
})
)
})
})
describe("useAdminMarkPaymentCollectionAsAuthorized hook", () => {
test("Mark a Payment Collection as Authorized", async () => {
const { result, waitFor } = renderHook(
() => useAdminMarkPaymentCollectionAsAuthorized("payment_collection_id"),
{
wrapper: createWrapper(),
}
)
result.current.mutate()
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.payment_collection).toEqual(
expect.objectContaining({
id: "payment_collection_id",
status: "authorized",
})
)
})
})
|
3,762 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin/payment-collections/queries.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import { useAdminPaymentCollection } from "../../../../src/hooks/admin/payment-collections"
import { createWrapper } from "../../../utils"
describe("useAdminPaymentCollection hook", () => {
test("returns a payment collection", async () => {
const payment_collection = fixtures.get("payment_collection")
const { result, waitFor } = renderHook(
() => useAdminPaymentCollection(payment_collection.id),
{
wrapper: createWrapper(),
}
)
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.payment_collection).toEqual(payment_collection)
})
})
|
3,763 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin/payments/mutations.test.ts | import { RefundReason } from "@medusajs/medusa"
import { renderHook } from "@testing-library/react-hooks/dom"
import {
useAdminPaymentsCapturePayment,
useAdminPaymentsRefundPayment,
} from "../../../../src"
import { createWrapper } from "../../../utils"
describe("useAdminPaymentsCapturePayment hook", () => {
test("Capture a payment", async () => {
const { result, waitFor } = renderHook(
() => useAdminPaymentsCapturePayment("payment_id"),
{
wrapper: createWrapper(),
}
)
result.current.mutate()
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.payment).toEqual(
expect.objectContaining({
amount_captured: 900,
})
)
})
})
describe("useAdminPaymentsRefundPayment hook", () => {
test("Update a Payment Collection", async () => {
const { result, waitFor } = renderHook(
() => useAdminPaymentsRefundPayment("payment_id"),
{
wrapper: createWrapper(),
}
)
result.current.mutate({
amount: 500,
reason: RefundReason.DISCOUNT,
note: "note to refund",
})
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.refund).toEqual(
expect.objectContaining({
payment_id: "payment_id",
amount: 500,
reason: RefundReason.DISCOUNT,
note: "note to refund",
})
)
})
})
|
3,764 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin/payments/queries.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import { useAdminPayment } from "../../../../src/hooks/admin/payments"
import { createWrapper } from "../../../utils"
describe("useAdminPayment hook", () => {
test("returns a payment collection", async () => {
const payment = fixtures.get("payment")
const { result, waitFor } = renderHook(() => useAdminPayment(payment.id), {
wrapper: createWrapper(),
})
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.payment).toEqual(payment)
})
})
|
3,765 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin/price-lists/mutations.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import {
useAdminCreatePriceList,
useAdminCreatePriceListPrices,
useAdminDeletePriceList,
useAdminDeletePriceListPrices,
useAdminDeletePriceListProductPrices,
useAdminDeletePriceListVariantPrices,
useAdminUpdatePriceList,
} from "../../../../src"
import { createWrapper } from "../../../utils"
import { PriceListType } from "@medusajs/medusa/dist/types/price-list"
describe("useAdminCreatePriceList hook", () => {
test("creates a price list and returns it", async () => {
const priceList = {
name: "talked to customer",
type: PriceListType.SALE,
description: "test",
prices: [],
}
const { result, waitFor } = renderHook(() => useAdminCreatePriceList(), {
wrapper: createWrapper(),
})
result.current.mutate(priceList)
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.price_list).toEqual(
expect.objectContaining({
...fixtures.get("price_list"),
...priceList,
})
)
})
})
describe("useAdminUpdatePriceList hook", () => {
test("updates a price list and returns it", async () => {
const priceList = {
name: "talked to customer",
type: PriceListType.SALE,
prices: [],
customer_groups: [],
}
const { result, waitFor } = renderHook(
() => useAdminUpdatePriceList(fixtures.get("price_list").id),
{
wrapper: createWrapper(),
}
)
result.current.mutate(priceList)
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.price_list).toEqual(
expect.objectContaining({
...fixtures.get("price_list"),
...priceList,
})
)
})
})
describe("useAdminDeletePriceList hook", () => {
test("deletes a price list", async () => {
const { result, waitFor } = renderHook(
() => useAdminDeletePriceList(fixtures.get("price_list").id),
{
wrapper: createWrapper(),
}
)
result.current.mutate()
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data).toEqual(
expect.objectContaining({
id: fixtures.get("price_list").id,
deleted: true,
})
)
})
})
describe("useAdminDeletePriceListBatch hook", () => {
test("deletes a money amounts from price list", async () => {
const { result, waitFor } = renderHook(
() => useAdminDeletePriceListPrices(fixtures.get("price_list").id),
{
wrapper: createWrapper(),
}
)
result.current.mutate({ price_ids: [fixtures.get("money_amount").id] })
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data).toEqual(
expect.objectContaining({
ids: [fixtures.get("money_amount").id],
deleted: true,
})
)
})
})
describe("useAdminDeletePriceList hook", () => {
test("Adds prices to price list", async () => {
const { result, waitFor } = renderHook(
() => useAdminCreatePriceListPrices(fixtures.get("price_list").id),
{
wrapper: createWrapper(),
}
)
result.current.mutate({ prices: [] })
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data).toEqual(
expect.objectContaining({
price_list: {
...fixtures.get("price_list"),
},
})
)
})
})
describe("useAdminDeletePriceListProductPrices hook", () => {
test("should delete prices from a price list for all the variants related to the specified product", async () => {
const { result, waitFor } = renderHook(
() =>
useAdminDeletePriceListProductPrices(
fixtures.get("price_list").id,
fixtures.get("product").id
),
{
wrapper: createWrapper(),
}
)
result.current.mutate()
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data).toEqual(
expect.objectContaining({
ids: [],
object: "money-amount",
deleted: true,
})
)
})
})
describe("useAdminDeletePriceListVariantPrices hook", () => {
test("should delete prices from a price list for the specified variant", async () => {
const { result, waitFor } = renderHook(
() =>
useAdminDeletePriceListVariantPrices(
fixtures.get("price_list").id,
fixtures.get("product_variant").id
),
{
wrapper: createWrapper(),
}
)
result.current.mutate()
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data).toEqual(
expect.objectContaining({
ids: [],
object: "money-amount",
deleted: true,
})
)
})
})
|
3,766 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin/price-lists/queries.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import { useAdminPriceList, useAdminPriceLists } from "../../../../src"
import { createWrapper } from "../../../utils"
describe("useAdminPriceLists hook", () => {
test("returns a list of price lists", async () => {
const priceLists = fixtures.list("price_list")
const { result, waitFor } = renderHook(() => useAdminPriceLists(), {
wrapper: createWrapper(),
})
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.price_lists).toEqual(priceLists)
})
})
describe("useAdminPriceList hook", () => {
test("returns a price list", async () => {
const priceList = fixtures.get("price_list")
const { result, waitFor } = renderHook(
() => useAdminPriceList(priceList.id),
{
wrapper: createWrapper(),
}
)
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.price_list).toEqual(priceList)
})
})
|
3,767 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin/product-categories/mutations.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import {
useAdminAddProductsToCategory,
useAdminCreateProductCategory,
useAdminDeleteProductCategory,
useAdminDeleteProductsFromCategory,
useAdminUpdateProductCategory,
} from "../../../../src"
import { createWrapper } from "../../../utils"
describe("useAdminCreateProductCategory hook", () => {
test("creates a product category", async () => {
const category = {
name: "Jeans category",
}
const { result, waitFor } = renderHook(
() => useAdminCreateProductCategory(),
{
wrapper: createWrapper(),
}
)
result.current.mutate(category)
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.product_category).toEqual(
expect.objectContaining({
...fixtures.get("product_category"),
...category,
})
)
})
})
describe("useAdminUpdateProductCategory hook", () => {
test("updates a product category", async () => {
const category = {
name: "Updated name",
}
const categoryId = fixtures.get("product_category").id
const { result, waitFor } = renderHook(
() => useAdminUpdateProductCategory(categoryId),
{
wrapper: createWrapper(),
}
)
result.current.mutate(category)
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.product_category).toEqual({
...fixtures.get("product_category"),
...category,
})
})
})
describe("useAdminDeleteProductCategory hook", () => {
test("deletes a product category", async () => {
const id = fixtures.get("product_category").id
const { result, waitFor } = renderHook(
() => useAdminDeleteProductCategory(id),
{ wrapper: createWrapper() }
)
result.current.mutate()
await waitFor(() => result.current.isSuccess)
expect(result.current.data).toEqual(
expect.objectContaining({
id,
object: "product-category",
deleted: true,
})
)
})
})
describe("useAdminAddProductsToCategory hook", () => {
test("add products to a product category", async () => {
const id = fixtures.get("product_category").id
const productId = fixtures.get("product").id
const { result, waitFor } = renderHook(
() => useAdminAddProductsToCategory(id),
{ wrapper: createWrapper() }
)
result.current.mutate({ product_ids: [{ id: productId }] })
await waitFor(() => result.current.isSuccess)
expect(result.current.data).toEqual(
expect.objectContaining({
product_category: fixtures.get("product_category"),
})
)
})
})
describe("useAdminDeleteProductsFromCategory hook", () => {
test("remove products from a product category", async () => {
const id = fixtures.get("product_category").id
const productId = fixtures.get("product").id
const { result, waitFor } = renderHook(
() => useAdminDeleteProductsFromCategory(id),
{ wrapper: createWrapper() }
)
result.current.mutate({ product_ids: [{ id: productId }] })
await waitFor(() => result.current.isSuccess)
expect(result.current.data).toEqual(
expect.objectContaining({
product_category: fixtures.get("product_category"),
})
)
})
})
|
3,768 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin/product-categories/queries.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import {
useAdminProductCategories,
useAdminProductCategory,
} from "../../../../src"
import { createWrapper } from "../../../utils"
describe("useAdminProductCategories hook", () => {
test("returns a list of categories", async () => {
const categories = fixtures.list("product_category")
const { result, waitFor } = renderHook(() => useAdminProductCategories(), {
wrapper: createWrapper(),
})
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.product_categories).toEqual(categories)
})
})
describe("useAdminProductCategory hook", () => {
test("returns a category", async () => {
const category = fixtures.get("product_category")
const { result, waitFor } = renderHook(
() => useAdminProductCategory(category.id),
{
wrapper: createWrapper(),
}
)
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.product_category).toEqual(category)
})
})
|
3,769 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin/products/mutations.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import {
useAdminCreateProduct,
useAdminCreateProductOption,
useAdminDeleteProduct,
useAdminDeleteProductOption,
useAdminUpdateProduct,
useAdminUpdateProductOption,
} from "../../../../src/"
import { createWrapper } from "../../../utils"
describe("useAdminCreateProduct hook", () => {
test("creates a product and returns it", async () => {
const product = {
title: "test-product",
is_giftcard: false,
discountable: false,
}
const { result, waitFor } = renderHook(() => useAdminCreateProduct(), {
wrapper: createWrapper(),
})
result.current.mutate(product)
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.product).toEqual(
expect.objectContaining({
...fixtures.get("product"),
...product,
})
)
})
})
describe("useAdminUpdateProduct hook", () => {
test("updates a product and returns it", async () => {
const id = fixtures.get("product").id
const product = {
title: "test-product-1",
images: [],
}
const { result, waitFor } = renderHook(() => useAdminUpdateProduct(id), {
wrapper: createWrapper(),
})
result.current.mutate(product)
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.product).toEqual(
expect.objectContaining({
...fixtures.get("product"),
...product,
})
)
})
})
describe("useAdminDeleteProduct hook", () => {
test("deletes a product", async () => {
const id = fixtures.get("product").id
const { result, waitFor } = renderHook(() => useAdminDeleteProduct(id), {
wrapper: createWrapper(),
})
result.current.mutate()
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data).toEqual(
expect.objectContaining({
id,
deleted: true,
})
)
})
})
describe("useAdminCreateProductOption hook", () => {
test("creates a product option", async () => {
const productId = fixtures.get("product").id
const { result, waitFor } = renderHook(
() => useAdminCreateProductOption(productId),
{
wrapper: createWrapper(),
}
)
result.current.mutate({
title: "color",
})
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.product).toEqual(fixtures.get("product"))
})
})
describe("useAdminUpdateProductOption hook", () => {
test("updates a product option", async () => {
const productId = fixtures.get("product").id
const { result, waitFor } = renderHook(
() => useAdminUpdateProductOption(productId),
{
wrapper: createWrapper(),
}
)
result.current.mutate({
title: "size",
option_id: "test-option",
})
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.product).toEqual(fixtures.get("product"))
})
})
describe("useAdminDeleteProductOption hook", () => {
test("deletes a product option", async () => {
const productId = fixtures.get("product").id
const { result, waitFor } = renderHook(
() => useAdminDeleteProductOption(productId),
{
wrapper: createWrapper(),
}
)
result.current.mutate("test-option")
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data).toEqual(
expect.objectContaining({
option_id: "test-option",
deleted: true,
})
)
})
})
|
3,770 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin/products/queries.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import {
useAdminProduct,
useAdminProducts,
useAdminProductTagUsage,
} from "../../../../src"
import { createWrapper } from "../../../utils"
describe("useAdminProducts hook", () => {
test("returns a list of products", async () => {
const products = fixtures.list("product")
const { result, waitFor } = renderHook(() => useAdminProducts(), {
wrapper: createWrapper(),
})
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.products).toEqual(products)
})
})
describe("useAdminProductTagUsage hook", () => {
test("returns a list of product tags", async () => {
const tags = fixtures.list("product_tag")
const { result, waitFor } = renderHook(() => useAdminProductTagUsage(), {
wrapper: createWrapper(),
})
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.tags).toEqual(tags)
})
})
describe("useAdminProduct hook", () => {
test("returns a product", async () => {
const product = fixtures.get("product")
const { result, waitFor } = renderHook(() => useAdminProduct(product.id), {
wrapper: createWrapper(),
})
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.product).toEqual(product)
})
})
|
3,771 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin/publishable-api-keys/mutations.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import {
useAdminAddPublishableKeySalesChannelsBatch,
useAdminCreatePublishableApiKey,
useAdminDeletePublishableApiKey,
useAdminRemovePublishableKeySalesChannelsBatch,
useAdminRevokePublishableApiKey,
useAdminUpdatePublishableApiKey,
} from "../../../../src"
import { createWrapper } from "../../../utils"
describe("useAdminCreatePublishableApiKey hook", () => {
test("Created a publishable api key", async () => {
const { result, waitFor } = renderHook(
() => useAdminCreatePublishableApiKey(),
{
wrapper: createWrapper(),
}
)
result.current.mutate({ title: "Mandatory title" })
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data).toEqual(
expect.objectContaining({
publishable_api_key: {
title: "Mandatory title",
...fixtures.get("publishable_api_key"),
},
})
)
})
})
describe("useAdminUpdatePublishableApiKey hook", () => {
test("updates an publishable key and returns it", async () => {
const pubKey = {
title: "changed title",
}
const { result, waitFor } = renderHook(
() =>
useAdminUpdatePublishableApiKey(fixtures.get("publishable_api_key").id),
{
wrapper: createWrapper(),
}
)
result.current.mutate(pubKey)
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.publishable_api_key).toEqual(
expect.objectContaining({
...fixtures.get("publishable_api_key"),
...pubKey,
})
)
})
})
describe("useAdminRevokePublishableApiKey hook", () => {
test("Revoke a publishable api key", async () => {
const id = "pubkey_1234"
const { result, waitFor } = renderHook(
() => useAdminRevokePublishableApiKey(id),
{
wrapper: createWrapper(),
}
)
result.current.mutate()
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data).toEqual(
expect.objectContaining({
publishable_api_key: {
...fixtures.get("publishable_api_key"),
revoked_at: "2022-11-10 11:17:46.666Z",
revoked_by: "admin_user",
id,
},
})
)
})
})
describe("useAdminDeletePublishableApiKey hook", () => {
test("Deletes a publishable api key", async () => {
const id = "pubkey_1234"
const { result, waitFor } = renderHook(
() => useAdminDeletePublishableApiKey(id),
{
wrapper: createWrapper(),
}
)
result.current.mutate()
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data).toEqual(
expect.objectContaining({
id,
object: "publishable_api_key",
deleted: true,
})
)
})
})
describe("useAdminAddPublishableKeySalesChannelsBatch hook", () => {
test("Adds a SC to the publishable api key scope", async () => {
const id = "pubkey_1234"
const { result, waitFor } = renderHook(
() => useAdminAddPublishableKeySalesChannelsBatch(id),
{
wrapper: createWrapper(),
}
)
result.current.mutate({
sales_channel_ids: [{ id: "rand_id" }],
})
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.publishable_api_key).toEqual(
expect.objectContaining({
...fixtures.get("publishable_api_key"),
})
)
})
})
describe("useAdminRemovePublishableKeySalesChannelsBatch hook", () => {
test("Deletes a SC from the publishable api key scope", async () => {
const id = "pubkey_1234"
const { result, waitFor } = renderHook(
() => useAdminRemovePublishableKeySalesChannelsBatch(id),
{
wrapper: createWrapper(),
}
)
result.current.mutate({
sales_channel_ids: [{ id: "rand_id" }],
})
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.publishable_api_key).toEqual(
expect.objectContaining({
...fixtures.get("publishable_api_key"),
})
)
})
})
|
3,772 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin/publishable-api-keys/queries.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import {
useAdminPublishableApiKey,
useAdminPublishableApiKeys,
useAdminPublishableApiKeySalesChannels,
} from "../../../../src"
import { createWrapper } from "../../../utils"
describe("useAdminPublishableApiKey hook", () => {
test("returns an publishable api key", async () => {
const publishable_api_key = fixtures.get("publishable_api_key")
const { result, waitFor } = renderHook(
() => useAdminPublishableApiKey(publishable_api_key.id),
{
wrapper: createWrapper(),
}
)
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.publishable_api_key).toEqual(publishable_api_key)
})
})
describe("useAdminPublishableApiKeys hook", () => {
test("returns a list of publishable api keys", async () => {
const publishable_api_key = fixtures.get("publishable_api_key")
const { result, waitFor } = renderHook(() => useAdminPublishableApiKeys(), {
wrapper: createWrapper(),
})
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.publishable_api_keys).toEqual(
expect.arrayContaining([publishable_api_key])
)
})
})
describe("useAdminPublishableApiKeySalesChannels hook", () => {
test("returns a list of sales channels of a publishable api key", async () => {
const publishable_api_key = fixtures.get("publishable_api_key")
const { result, waitFor } = renderHook(
() => useAdminPublishableApiKeySalesChannels(publishable_api_key.id),
{
wrapper: createWrapper(),
}
)
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.sales_channels).toEqual(
fixtures.get("sales_channels")
)
})
})
|
3,773 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin/regions/mutations.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import {
useAdminCreateRegion,
useAdminDeleteRegion,
useAdminRegionAddFulfillmentProvider,
useAdminRegionAddPaymentProvider,
useAdminRegionDeleteFulfillmentProvider,
useAdminRegionDeletePaymentProvider,
useAdminUpdateRegion,
} from "../../../../src/"
import { createWrapper } from "../../../utils"
describe("useAdminCreateRegion hook", () => {
test("creates a region and returns it", async () => {
const region = {
name: "test region",
currency_code: "eur",
tax_rate: 10,
payment_providers: [],
fulfillment_providers: [],
countries: [],
}
const { result, waitFor } = renderHook(() => useAdminCreateRegion(), {
wrapper: createWrapper(),
})
result.current.mutate(region)
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.region).toEqual(
expect.objectContaining({
...fixtures.get("region"),
...region,
})
)
})
})
describe("useAdminUpdateRegion hook", () => {
test("updates a region and returns it", async () => {
const region = {
name: "Africa",
}
const id = fixtures.get("region").id
const { result, waitFor } = renderHook(() => useAdminUpdateRegion(id), {
wrapper: createWrapper(),
})
result.current.mutate(region)
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.region).toEqual(
expect.objectContaining({
...fixtures.get("region"),
...region,
})
)
})
})
describe("useAdminDeleteRegion hook", () => {
test("deletes a region", async () => {
const id = fixtures.get("region").id
const { result, waitFor } = renderHook(() => useAdminDeleteRegion(id), {
wrapper: createWrapper(),
})
result.current.mutate()
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data).toEqual(
expect.objectContaining({
id,
deleted: true,
})
)
})
})
describe("useAdminRegionAddFulfillmentProvider hook", () => {
test("adds a fulfillment provider to a region", async () => {
const payload = {
provider_id: "test-ful",
}
const id = fixtures.get("region").id
const { result, waitFor } = renderHook(
() => useAdminRegionAddFulfillmentProvider(id),
{
wrapper: createWrapper(),
}
)
result.current.mutate(payload)
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.region).toEqual(fixtures.get("region"))
})
})
describe("useAdminRegionDeleteFulfillmentProvider hook", () => {
test("deletes a region's fulfillment provider", async () => {
const id = fixtures.get("region").id
const { result, waitFor } = renderHook(
() => useAdminRegionDeleteFulfillmentProvider(id),
{
wrapper: createWrapper(),
}
)
result.current.mutate("test-ful")
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.region).toEqual(fixtures.get("region"))
})
})
describe("useAdminRegionAddPaymentProvider hook", () => {
test("adds a payment provider to a region", async () => {
const payload = {
provider_id: "test-pay",
}
const id = fixtures.get("region").id
const { result, waitFor } = renderHook(
() => useAdminRegionAddPaymentProvider(id),
{
wrapper: createWrapper(),
}
)
result.current.mutate(payload)
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.region).toEqual(fixtures.get("region"))
})
})
describe("useAdminRegionDeletePaymentProvider hook", () => {
test("deletes a region's payment provider", async () => {
const id = fixtures.get("region").id
const { result, waitFor } = renderHook(
() => useAdminRegionDeletePaymentProvider(id),
{
wrapper: createWrapper(),
}
)
result.current.mutate("test-pay")
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.region).toEqual(fixtures.get("region"))
})
})
|
3,774 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin/regions/queries.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import {
useAdminRegion,
useAdminRegionFulfillmentOptions,
useAdminRegions,
} from "../../../../src"
import { createWrapper } from "../../../utils"
describe("useAdminRegions hook", () => {
test("returns a list of regions", async () => {
const regions = fixtures.list("region")
const { result, waitFor } = renderHook(() => useAdminRegions(), {
wrapper: createWrapper(),
})
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.regions).toEqual(regions)
})
})
describe("useAdminRegion hook", () => {
test("returns a region", async () => {
const region = fixtures.get("region")
const { result, waitFor } = renderHook(() => useAdminRegion(region.id), {
wrapper: createWrapper(),
})
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.region).toEqual(region)
})
})
describe("useAdminRegionFulfillmentOptions hook", () => {
test("returns a region's fulfillment options", async () => {
const region = fixtures.get("region")
const options = fixtures.get("fulfillment_option")
const { result, waitFor } = renderHook(
() => useAdminRegionFulfillmentOptions(region.id),
{
wrapper: createWrapper(),
}
)
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.fulfillment_options).toEqual(options)
})
})
|
3,775 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin/reservations/mutations.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import {
useAdminCreateReservation,
useAdminDeleteReservation,
useAdminUpdateReservation,
} from "../../../../src/"
import { createWrapper } from "../../../utils"
describe("useAdminCreateShippingProfile hook", () => {
test("creates a shipping profile and returns it", async () => {
const reservationPayload = {
location_id: "loc_1",
inventory_item_id: "inv_1",
quantity: 2,
}
const { result, waitFor } = renderHook(() => useAdminCreateReservation(), {
wrapper: createWrapper(),
})
result.current.mutate(reservationPayload)
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.reservation).toEqual(
expect.objectContaining({
...fixtures.get("reservation"),
...reservationPayload,
})
)
})
})
describe("useAdminUpdateShippingProfile hook", () => {
test("updates a shipping profile and returns it", async () => {
const reservationPayload = {
quantity: 3,
}
const { result, waitFor } = renderHook(
() => useAdminUpdateReservation(fixtures.get("reservation").id),
{
wrapper: createWrapper(),
}
)
result.current.mutate(reservationPayload)
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.reservation).toEqual(
expect.objectContaining({
...fixtures.get("reservation"),
quantity: 3,
})
)
})
})
describe("useAdminDeleteShippingProfile hook", () => {
test("deletes a shipping profile", async () => {
const { result, waitFor } = renderHook(
() => useAdminDeleteReservation(fixtures.get("reservation").id),
{
wrapper: createWrapper(),
}
)
result.current.mutate()
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data).toEqual(
expect.objectContaining({
id: fixtures.get("reservation").id,
object: "reservation",
deleted: true,
})
)
})
})
|
3,776 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin/reservations/queries.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import { useAdminReservation, useAdminReservations } from "../../../../src"
import { createWrapper } from "../../../utils"
describe("useAdminShippingProfiles hook", () => {
test("returns a list of shipping profiles", async () => {
const reservations = fixtures.list("reservation")
const { result, waitFor } = renderHook(() => useAdminReservations(), {
wrapper: createWrapper(),
})
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.reservations).toEqual(reservations)
})
})
describe("useAdminShippingProfile hook", () => {
test("returns a shipping profile", async () => {
const reservation = fixtures.get("reservation")
const { result, waitFor } = renderHook(
() => useAdminReservation(reservation.id),
{
wrapper: createWrapper(),
}
)
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.reservation).toEqual(reservation)
})
})
|
3,777 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin/return-reasons/mutations.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import {
useAdminCreateReturnReason,
useAdminDeleteReturnReason,
useAdminUpdateReturnReason,
} from "../../../../src/"
import { createWrapper } from "../../../utils"
describe("useAdminCreateReturnReason hook", () => {
test("creates a return reason and returns it", async () => {
const rr = {
value: "too_big",
label: "Too big",
description: "Shirt is too big in length",
}
const { result, waitFor } = renderHook(() => useAdminCreateReturnReason(), {
wrapper: createWrapper(),
})
result.current.mutate(rr)
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.return_reason).toEqual(
expect.objectContaining({
...fixtures.get("return_reason"),
...rr,
})
)
})
})
describe("useAdminUpdateReturnReason hook", () => {
test("updates a return reason and returns it", async () => {
const rr = {
value: "too_small",
label: "Too small",
}
const { result, waitFor } = renderHook(
() => useAdminUpdateReturnReason(fixtures.get("return_reason").id),
{
wrapper: createWrapper(),
}
)
result.current.mutate(rr)
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.return_reason).toEqual(
expect.objectContaining({
...fixtures.get("return_reason"),
...rr,
})
)
})
})
describe("useAdminDeleteReturnReason hook", () => {
test("deletes a return reason", async () => {
const { result, waitFor } = renderHook(
() => useAdminDeleteReturnReason(fixtures.get("return_reason").id),
{
wrapper: createWrapper(),
}
)
result.current.mutate()
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data).toEqual(
expect.objectContaining({
id: fixtures.get("return_reason").id,
deleted: true,
})
)
})
})
|
3,778 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin/return-reasons/queries.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import { useAdminReturnReason, useAdminReturnReasons } from "../../../../src"
import { createWrapper } from "../../../utils"
describe("useAdminReturnReasons hook", () => {
test("returns a list of return reasons", async () => {
const returnReasons = fixtures.list("return_reason")
const { result, waitFor } = renderHook(() => useAdminReturnReasons(), {
wrapper: createWrapper(),
})
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.return_reasons).toEqual(returnReasons)
})
})
describe("useAdminReturnReason hook", () => {
test("returns a return reason", async () => {
const returnReason = fixtures.get("return_reason")
const { result, waitFor } = renderHook(
() => useAdminReturnReason(returnReason.id),
{
wrapper: createWrapper(),
}
)
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.return_reason).toEqual(returnReason)
})
})
|
3,779 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin/returns/mutations.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import { useAdminCancelReturn, useAdminReceiveReturn } from "../../../../src/"
import { createWrapper } from "../../../utils"
describe("useAdminCancel hook", () => {
test("cancels a return", async () => {
const { result, waitFor } = renderHook(
() => useAdminCancelReturn("test-return"),
{
wrapper: createWrapper(),
}
)
result.current.mutate()
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.order).toEqual(fixtures.get("order"))
})
})
describe("useAdminReceiveReturn hook", () => {
test("marks a return as received", async () => {
const payload = {
items: [
{
item_id: "test_id",
quantity: 1,
},
],
}
const { result, waitFor } = renderHook(
() => useAdminReceiveReturn("test-return"),
{
wrapper: createWrapper(),
}
)
result.current.mutate({ ...payload })
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.return).toEqual(fixtures.get("return"))
})
})
|
3,780 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin/returns/queries.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import { useAdminReturns } from "../../../../src"
import { createWrapper } from "../../../utils"
describe("useAdminReturns hook", () => {
test("returns a list of returns", async () => {
const returns = fixtures.list("return")
const { result, waitFor } = renderHook(() => useAdminReturns(), {
wrapper: createWrapper(),
})
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.returns).toEqual(returns)
})
})
|
3,781 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin/sales-channels/mutations.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import {
useAdminAddProductsToSalesChannel,
useAdminCreateSalesChannel,
useAdminDeleteProductsFromSalesChannel,
useAdminDeleteSalesChannel,
useAdminUpdateSalesChannel,
} from "../../../../src"
import { createWrapper } from "../../../utils"
describe("useAdminCreateSalesChannel hook", () => {
test("returns a sales channel", async () => {
const salesChannel = {
name: "sales channel 1 name",
description: "sales channel 1 description",
}
const { result, waitFor } = renderHook(() => useAdminCreateSalesChannel(), {
wrapper: createWrapper(),
})
result.current.mutate(salesChannel)
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.sales_channel).toEqual(
expect.objectContaining({
...fixtures.get("sales_channel"),
...salesChannel,
})
)
})
})
describe("useAdminUpdateSalesChannel hook", () => {
test("updates a sales channel", async () => {
const salesChannel = {
name: "medusa sales channel",
description: "main sales channel for medusa",
is_disabled: true,
}
const salesChannelId = fixtures.get("sales_channel").id
const { result, waitFor } = renderHook(
() => useAdminUpdateSalesChannel(salesChannelId),
{
wrapper: createWrapper(),
}
)
result.current.mutate(salesChannel)
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.sales_channel).toEqual({
...fixtures.get("sales_channel"),
...salesChannel,
})
})
})
describe("useAdminDeleteSalesChannel hook", () => {
test("deletes a sales channel", async () => {
const id = fixtures.get("sales_channel").id
const { result, waitFor } = renderHook(
() => useAdminDeleteSalesChannel(id),
{ wrapper: createWrapper() }
)
result.current.mutate()
await waitFor(() => result.current.isSuccess)
expect(result.current.data).toEqual(
expect.objectContaining({
id,
object: "sales-channel",
deleted: true,
})
)
})
})
describe("useAdminDeleteProductsFromSalesChannel hook", () => {
test("remove products from a sales channel", async () => {
const id = fixtures.get("sales_channel").id
const productId = fixtures.get("product").id
const { result, waitFor } = renderHook(
() => useAdminDeleteProductsFromSalesChannel(id),
{ wrapper: createWrapper() }
)
result.current.mutate({ product_ids: [{ id: productId }] })
await waitFor(() => result.current.isSuccess)
expect(result.current.data).toEqual(
expect.objectContaining({
sales_channel: fixtures.get("sales_channel"),
})
)
})
})
describe("useAdminAddProductsToSalesChannel hook", () => {
test("add products to a sales channel", async () => {
const id = fixtures.get("sales_channel").id
const productId = fixtures.get("product").id
const { result, waitFor } = renderHook(
() => useAdminAddProductsToSalesChannel(id),
{ wrapper: createWrapper() }
)
result.current.mutate({ product_ids: [{ id: productId }] })
await waitFor(() => result.current.isSuccess)
expect(result.current.data).toEqual(
expect.objectContaining({
sales_channel: fixtures.get("sales_channel"),
})
)
})
})
|
3,782 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin/sales-channels/queries.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import { useAdminSalesChannel, useAdminSalesChannels } from "../../../../src"
import { createWrapper } from "../../../utils"
describe("useAdminSalesChannel hook", () => {
test("returns a sales channel", async () => {
const salesChannel = fixtures.get("sales_channel")
const { result, waitFor } = renderHook(
() => useAdminSalesChannel(salesChannel.id),
{
wrapper: createWrapper(),
}
)
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.sales_channel).toEqual(salesChannel)
})
})
describe("useAdminSalesChannels hook", () => {
test("returns a list of sales channels", async () => {
const salesChannels = fixtures.get("sales_channels")
const { result, waitFor } = renderHook(() => useAdminSalesChannels(), {
wrapper: createWrapper(),
})
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.sales_channels).toEqual(salesChannels)
})
})
|
3,783 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin/shipping-options/mutations.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import {
useAdminCreateShippingOption,
useAdminDeleteShippingOption,
useAdminUpdateShippingOption,
} from "../../../../src/"
import { createWrapper } from "../../../utils"
describe("useAdminCreateShippingOption hook", () => {
test("creates a shipping option and returns it", async () => {
const so = {
name: "test-so",
region_id: "test-region",
provider_id: "test-provider",
data: {},
price_type: "flat",
}
const { result, waitFor } = renderHook(
() => useAdminCreateShippingOption(),
{
wrapper: createWrapper(),
}
)
result.current.mutate(so)
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.shipping_option).toEqual(
expect.objectContaining({
...fixtures.get("shipping_option"),
...so,
})
)
})
})
describe("useAdminUpdateShippingOption hook", () => {
test("updates a shipping option and returns it", async () => {
const so = {
name: "test-so",
requirements: [
{
id: "test-so-req",
type: "thing",
amount: 500,
},
],
}
const { result, waitFor } = renderHook(
() => useAdminUpdateShippingOption(fixtures.get("shipping_option").id),
{
wrapper: createWrapper(),
}
)
result.current.mutate(so)
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.shipping_option).toEqual(
expect.objectContaining({
...fixtures.get("shipping_option"),
...so,
})
)
})
})
describe("useAdminDeleteShippingOption hook", () => {
test("deletes a shipping option", async () => {
const { result, waitFor } = renderHook(
() => useAdminDeleteShippingOption(fixtures.get("shipping_option").id),
{
wrapper: createWrapper(),
}
)
result.current.mutate()
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data).toEqual(
expect.objectContaining({
id: fixtures.get("shipping_option").id,
deleted: true,
})
)
})
})
|
3,784 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin/shipping-options/queries.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import {
useAdminShippingOption,
useAdminShippingOptions,
} from "../../../../src"
import { createWrapper } from "../../../utils"
describe("useAdminShippingOptions hook", () => {
test("returns a list of shipping options", async () => {
const shippingOptions = fixtures.list("shipping_option")
const { result, waitFor } = renderHook(() => useAdminShippingOptions(), {
wrapper: createWrapper(),
})
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.shipping_options).toEqual(shippingOptions)
})
})
describe("useAdminShippingOption hook", () => {
test("returns a shipping option", async () => {
const shippingOption = fixtures.get("shipping_option")
const { result, waitFor } = renderHook(
() => useAdminShippingOption(shippingOption.id),
{
wrapper: createWrapper(),
}
)
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.shipping_option).toEqual(shippingOption)
})
})
|
3,785 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin/shipping-profiles/mutations.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import {
useAdminCreateShippingProfile,
useAdminDeleteShippingProfile,
useAdminUpdateShippingProfile,
} from "../../../../src/"
import { createWrapper } from "../../../utils"
describe("useAdminCreateShippingProfile hook", () => {
test("creates a shipping profile and returns it", async () => {
const sp = {
name: "test-sp",
}
const { result, waitFor } = renderHook(
() => useAdminCreateShippingProfile(),
{
wrapper: createWrapper(),
}
)
result.current.mutate(sp)
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.shipping_profile).toEqual(
expect.objectContaining({
...fixtures.get("shipping_profile"),
...sp,
})
)
})
})
describe("useAdminUpdateShippingProfile hook", () => {
test("updates a shipping profile and returns it", async () => {
const sp = {
name: "test-sp",
}
const { result, waitFor } = renderHook(
() => useAdminUpdateShippingProfile(fixtures.get("shipping_profile").id),
{
wrapper: createWrapper(),
}
)
result.current.mutate(sp)
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.shipping_profile).toEqual(
expect.objectContaining({
...fixtures.get("shipping_profile"),
...sp,
})
)
})
})
describe("useAdminDeleteShippingProfile hook", () => {
test("deletes a shipping profile", async () => {
const { result, waitFor } = renderHook(
() => useAdminDeleteShippingProfile(fixtures.get("shipping_profile").id),
{
wrapper: createWrapper(),
}
)
result.current.mutate()
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data).toEqual(
expect.objectContaining({
id: fixtures.get("shipping_profile").id,
deleted: true,
})
)
})
})
|
3,786 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin/shipping-profiles/queries.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import {
useAdminShippingProfile,
useAdminShippingProfiles,
} from "../../../../src"
import { createWrapper } from "../../../utils"
describe("useAdminShippingProfiles hook", () => {
test("returns a list of shipping profiles", async () => {
const shippingProfiles = fixtures.list("shipping_profile")
const { result, waitFor } = renderHook(() => useAdminShippingProfiles(), {
wrapper: createWrapper(),
})
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.shipping_profiles).toEqual(shippingProfiles)
})
})
describe("useAdminShippingProfile hook", () => {
test("returns a shipping profile", async () => {
const shippingProfile = fixtures.get("shipping_profile")
const { result, waitFor } = renderHook(
() => useAdminShippingProfile(shippingProfile.id),
{
wrapper: createWrapper(),
}
)
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.shipping_profile).toEqual(shippingProfile)
})
})
|
3,787 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin/stock-location/mutations.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import {
useAdminCreateStockLocation,
useAdminDeleteStockLocation,
useAdminUpdateStockLocation,
} from "../../../../src"
import { createWrapper } from "../../../utils"
describe("useAdminUpdateStockLocation hook", () => {
test("updates a stock location", async () => {
const payload = {
name: "updated name",
}
const { result, waitFor } = renderHook(
() => useAdminUpdateStockLocation("stock-location-id"),
{
wrapper: createWrapper(),
}
)
result.current.mutate(payload)
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.stock_location).toEqual(
expect.objectContaining({
id: "stock-location-id",
name: "updated name",
})
)
})
})
describe("useAdminCreateStockLocation hook", () => {
test("creates a stock location", async () => {
const locationFixture = fixtures.get("stock_location")
const payload = {
name: "updated name",
}
const { result, waitFor } = renderHook(
() => useAdminCreateStockLocation(),
{
wrapper: createWrapper(),
}
)
result.current.mutate(payload)
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.stock_location).toEqual(
expect.objectContaining({
...locationFixture,
...payload,
})
)
})
})
describe("useAdminDeleteStockLocation hook", () => {
test("deletes a stock location", async () => {
const { result, waitFor } = renderHook(
() => useAdminDeleteStockLocation("stock-location-id"),
{
wrapper: createWrapper(),
}
)
result.current.mutate()
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data).toEqual(
expect.objectContaining({
id: "stock-location-id",
object: "stock_location",
deleted: true,
})
)
})
})
|
3,788 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin/stock-location/queries.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import { useAdminStockLocation, useAdminStockLocations } from "../../../../src"
import { createWrapper } from "../../../utils"
describe("useAdminUpdateStockLocation hook", () => {
test("gets a stock location", async () => {
const stockLocation = fixtures.get("stock_location")
const { result, waitFor } = renderHook(
() => useAdminStockLocation("stock-location-id"),
{
wrapper: createWrapper(),
}
)
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.stock_location).toEqual(
expect.objectContaining({
...stockLocation,
id: "stock-location-id",
})
)
})
})
describe("useAdminUpdateStockLocations hook", () => {
test("lists stock locations", async () => {
const stockLocation = fixtures.list("stock_location")
const { result, waitFor } = renderHook(() => useAdminStockLocations(), {
wrapper: createWrapper(),
})
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.stock_locations).toEqual(stockLocation)
})
})
|
3,789 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin/store/mutations.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import {
useAdminAddStoreCurrency,
useAdminDeleteStoreCurrency,
useAdminUpdateStore,
} from "../../../../src"
import { createWrapper } from "../../../utils"
describe("useAdminUpdateStore hook", () => {
test("updates a store", async () => {
const store = {
name: "medusa-store",
swap_link_template: "template",
payment_link_template: "payment",
}
const { result, waitFor } = renderHook(() => useAdminUpdateStore(), {
wrapper: createWrapper(),
})
result.current.mutate(store)
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.store).toEqual({
...fixtures.get("store"),
...store,
})
})
})
describe("useAdminAddStoreCurrency hook", () => {
test("adds a currency to the store", async () => {
const { result, waitFor } = renderHook(() => useAdminAddStoreCurrency(), {
wrapper: createWrapper(),
})
result.current.mutate("eur")
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.store).toEqual(fixtures.get("store"))
})
})
describe("useAdminDeleteStoreCurrency hook", () => {
test("deletes a currency from the store", async () => {
const { result, waitFor } = renderHook(
() => useAdminDeleteStoreCurrency(),
{
wrapper: createWrapper(),
}
)
result.current.mutate("eur")
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.store).toEqual(fixtures.get("store"))
})
})
|
3,790 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin/store/queries.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import { useAdminStore, useAdminStorePaymentProviders } from "../../../../src"
import { createWrapper } from "../../../utils"
describe("useAdminStore hook", () => {
test("returns the store", async () => {
const store = fixtures.get("store")
const { result, waitFor } = renderHook(() => useAdminStore(), {
wrapper: createWrapper(),
})
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.store).toEqual(store)
})
})
describe("useAdminListPaymentProviders hook", () => {
test("returns a list of the store's payment providers", async () => {
const store = fixtures.get("store")
const { result, waitFor } = renderHook(
() => useAdminStorePaymentProviders(),
{
wrapper: createWrapper(),
}
)
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.payment_providers).toEqual(store.payment_providers)
})
})
|
3,791 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin/swaps/mutations.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import {
useAdminCancelSwap,
useAdminCancelSwapFulfillment,
useAdminCreateSwap,
useAdminCreateSwapShipment,
useAdminFulfillSwap,
useAdminProcessSwapPayment,
} from "../../../../src/"
import { createWrapper } from "../../../utils"
describe("useAdminCreateSwap hook", () => {
test("creates a swap and returns the order", async () => {
const orderId = fixtures.get("order").id
const swap = {
return_items: [
{
item_id: "test-item",
quantity: 1,
},
],
additional_items: [
{
variant_id: "another-item",
quantity: 1,
},
],
}
const { result, waitFor } = renderHook(() => useAdminCreateSwap(orderId), {
wrapper: createWrapper(),
})
result.current.mutate(swap)
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.order).toEqual(fixtures.get("order"))
})
})
describe("useAdminFulfillSwap hook", () => {
test("receives a swap", async () => {
const orderId = fixtures.get("order").id
const swapId = "test-swap"
const payload = {
no_notification: false,
}
const { result, waitFor } = renderHook(() => useAdminFulfillSwap(orderId), {
wrapper: createWrapper(),
})
result.current.mutate({ swap_id: swapId, ...payload })
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.order).toEqual(fixtures.get("order"))
})
})
describe("useAdminCreateSwapShipment hook", () => {
test("creates a swap shipment", async () => {
const orderId = fixtures.get("order").id
const swapId = "test-swap"
const payload = {
fulfillment_id: "test-ful",
tracking_numbers: [],
}
const { result, waitFor } = renderHook(
() => useAdminCreateSwapShipment(orderId),
{
wrapper: createWrapper(),
}
)
result.current.mutate({ swap_id: swapId, ...payload })
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.order).toEqual(fixtures.get("order"))
})
})
describe("useAdminProcessSwapPayment hook", () => {
test("process a swap's payment", async () => {
const orderId = fixtures.get("order").id
const swapId = "test-swap"
const { result, waitFor } = renderHook(
() => useAdminProcessSwapPayment(orderId),
{
wrapper: createWrapper(),
}
)
result.current.mutate(swapId)
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.order).toEqual(fixtures.get("order"))
})
})
describe("useAdminCancelSwap hook", () => {
test("cancels a swap", async () => {
const orderId = fixtures.get("order").id
const swapId = "test-swap"
const { result, waitFor } = renderHook(() => useAdminCancelSwap(orderId), {
wrapper: createWrapper(),
})
result.current.mutate(swapId)
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.order).toEqual(fixtures.get("order"))
})
})
describe("useAdminCancelSwapFulfillment hook", () => {
test("cancels a swap", async () => {
const orderId = fixtures.get("order").id
const swapId = "test-swap"
const fulfillmentId = "test-ful"
const { result, waitFor } = renderHook(
() => useAdminCancelSwapFulfillment(orderId),
{
wrapper: createWrapper(),
}
)
result.current.mutate({ swap_id: swapId, fulfillment_id: fulfillmentId })
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.order).toEqual(fixtures.get("order"))
})
})
|
3,792 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin/swaps/queries.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import { useAdminSwap, useAdminSwaps } from "../../../../src"
import { createWrapper } from "../../../utils"
describe("useAdminSwaps hook", () => {
test("returns a list of swaps", async () => {
const swaps = fixtures.list("swap")
const { result, waitFor } = renderHook(() => useAdminSwaps(), {
wrapper: createWrapper(),
})
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.swaps).toEqual(swaps)
})
})
describe("useAdminSwap hook", () => {
test("returns a swap", async () => {
const swap = fixtures.get("swap")
const { result, waitFor } = renderHook(() => useAdminSwap(swap.id), {
wrapper: createWrapper(),
})
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.swap).toEqual(swap)
})
})
|
3,793 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin/uploads/mutations.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import {
useAdminCreatePresignedDownloadUrl,
useAdminDeleteFile,
} from "../../../../src"
import { createWrapper } from "../../../utils"
describe("useAdminDeleteFile hook", () => {
test("Removes file with key and returns delete result", async () => {
const file_key = "test"
const { result, waitFor } = renderHook(() => useAdminDeleteFile(), {
wrapper: createWrapper(),
})
result.current.mutate({ file_key })
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data).toEqual(
expect.objectContaining({ id: file_key, object: "file", deleted: true })
)
})
})
describe("useAdminCreatePresignedDownloadUrl hook", () => {
test("", async () => {
const file_key = "test"
const { result, waitFor } = renderHook(
() => useAdminCreatePresignedDownloadUrl(),
{
wrapper: createWrapper(),
}
)
result.current.mutate({ file_key })
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.download_url).toEqual(fixtures.get("upload").url)
})
})
|
3,794 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin/users/mutations.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import {
useAdminCreateUser,
useAdminDeleteUser,
useAdminResetPassword,
useAdminSendResetPasswordToken,
useAdminUpdateUser,
} from "../../../../src/"
import { createWrapper } from "../../../utils"
describe("useAdminCreateUser hook", () => {
test("creates a user and returns it", async () => {
const user = {
email: "[email protected]",
first_name: "Lebron",
last_name: "James",
role: "admin" as const,
password: "test-password",
}
const { result, waitFor } = renderHook(() => useAdminCreateUser(), {
wrapper: createWrapper(),
})
result.current.mutate(user)
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.user).toEqual(
expect.objectContaining({
...fixtures.get("user"),
...user,
})
)
})
})
describe("useAdminUpdateUser hook", () => {
test("updates a user and returns it", async () => {
const id = fixtures.get("user").id
const user = {
first_name: "Zack",
last_name: "Medusa",
}
const { result, waitFor } = renderHook(() => useAdminUpdateUser(id), {
wrapper: createWrapper(),
})
result.current.mutate(user)
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.user).toEqual(
expect.objectContaining({
...fixtures.get("user"),
...user,
})
)
})
})
describe("useAdminDeleteUser hook", () => {
test("deletes a user", async () => {
const id = fixtures.get("user").id
const { result, waitFor } = renderHook(() => useAdminDeleteUser(id), {
wrapper: createWrapper(),
})
result.current.mutate()
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data).toEqual(
expect.objectContaining({
id,
deleted: true,
})
)
})
})
describe("useAdminSendResetPasswordToken hook", () => {
test("sends a token to reset the password", async () => {
const payload = {
email: "[email protected]",
}
const { result, waitFor } = renderHook(
() => useAdminSendResetPasswordToken(),
{
wrapper: createWrapper(),
}
)
result.current.mutate(payload)
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
})
})
describe("useAdminResetPassword hook", () => {
test("reset the password", async () => {
const payload = {
token: "test-token",
password: "new-password",
}
const { result, waitFor } = renderHook(() => useAdminResetPassword(), {
wrapper: createWrapper(),
})
result.current.mutate(payload)
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.user).toEqual(
expect.objectContaining(fixtures.get("user"))
)
})
})
|
3,795 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin/users/queries.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import { useAdminUser, useAdminUsers } from "../../../../src"
import { createWrapper } from "../../../utils"
describe("useAdminUsers hook", () => {
test("returns a list of users", async () => {
const users = fixtures.list("user")
const { result, waitFor } = renderHook(() => useAdminUsers(), {
wrapper: createWrapper(),
})
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.users).toEqual(users)
})
})
describe("useAdminUser hook", () => {
test("returns a user", async () => {
const user = fixtures.get("user")
const { result, waitFor } = renderHook(() => useAdminUser(user.id), {
wrapper: createWrapper(),
})
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.user).toEqual(user)
})
})
|
3,796 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin/variants/mutations.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import {
useAdminCreateVariant,
useAdminDeleteVariant,
useAdminUpdateVariant,
} from "../../../../src/"
import { createWrapper } from "../../../utils"
describe("useAdminCreateVariant hook", () => {
test("creates a variant and returns it", async () => {
const variant = {
title: "Test variant",
inventory_quantity: 10,
prices: [
{
amount: 1000,
},
],
options: [],
}
const { result, waitFor } = renderHook(
() => useAdminCreateVariant("test-product"),
{
wrapper: createWrapper(),
}
)
result.current.mutate(variant)
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.product).toEqual(fixtures.get("product"))
})
})
describe("useAdminUpdateVariant hook", () => {
test("updates a variant and returns it", async () => {
const variant = {
title: "Example variant",
inventory_quantity: 5,
prices: [],
options: [],
}
const { result, waitFor } = renderHook(
() => useAdminUpdateVariant("test-product"),
{
wrapper: createWrapper(),
}
)
result.current.mutate({
...variant,
variant_id: "test-variant",
})
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.product).toEqual(fixtures.get("product"))
})
})
describe("useAdminDeleteVariant hook", () => {
test("deletes a variant", async () => {
const { result, waitFor } = renderHook(
() => useAdminDeleteVariant("test-product"),
{
wrapper: createWrapper(),
}
)
result.current.mutate("test-variant")
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data).toEqual(
expect.objectContaining({
variant_id: "test-variant",
deleted: true,
})
)
})
})
|
3,797 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/admin/variants/queries.test.ts | import { useAdminVariant, useAdminVariants, useAdminVariantsInventory } from "../../../../src"
import { createWrapper } from "../../../utils"
import { fixtures } from "../../../../mocks/data"
import { renderHook } from "@testing-library/react-hooks"
describe("useAdminVariants hook", () => {
test("returns a list of variants", async () => {
const variants = fixtures.list("product_variant")
const { result, waitFor } = renderHook(() => useAdminVariants(), {
wrapper: createWrapper(),
})
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.variants).toEqual(variants)
})
})
describe("useAdminVariant hook", () => {
test("returns a variant", async () => {
const variant = fixtures.get("product_variant")
const { result, waitFor } = renderHook(() => useAdminVariant(variant.id), {
wrapper: createWrapper(),
})
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.variant).toEqual(variant)
})
})
describe("useAdminVariants hook", () => {
test("returns a variant with saleschannel locations", async () => {
const variant = fixtures.get("product_variant")
const { result, waitFor } = renderHook(
() => useAdminVariantsInventory(variant.id),
{
wrapper: createWrapper(),
}
)
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.variant).toEqual({
...variant,
sales_channel_availability: [
{
channel_name: "default channel",
channel_id: "1",
available_quantity: 10,
},
],
})
})
})
|
3,798 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/store | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/store/carts/mutations.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import {
useAddShippingMethodToCart,
useCompleteCart,
useCreateCart,
useCreatePaymentSession,
useDeletePaymentSession,
useRefreshPaymentSession,
useSetPaymentSession,
useUpdateCart,
useUpdatePaymentSession,
} from "../../../../src"
import { createWrapper } from "../../../utils"
describe("useCreateCart hook", () => {
test("creates a cart", async () => {
const { result, waitFor } = renderHook(() => useCreateCart(), {
wrapper: createWrapper(),
})
result.current.mutate({})
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.cart).toEqual(fixtures.get("cart"))
})
})
describe("useUpdateCart hook", () => {
test("updates a cart", async () => {
const { result, waitFor } = renderHook(() => useUpdateCart("some-cart"), {
wrapper: createWrapper(),
})
result.current.mutate({
email: "[email protected]",
})
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.cart).toEqual({
...fixtures.get("cart"),
id: "some-cart",
email: "[email protected]",
})
})
})
describe("useCompleteCart hook", () => {
test("completes a cart", async () => {
const { result, waitFor } = renderHook(() => useCompleteCart("test-cart"), {
wrapper: createWrapper(),
})
result.current.mutate()
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.type).toEqual("order")
expect(result.current.data.data).toEqual(fixtures.get("order"))
})
})
describe("useCreatePaymentSession hook", () => {
test("creates a payment session", async () => {
const { result, waitFor } = renderHook(
() => useCreatePaymentSession("test-cart"),
{
wrapper: createWrapper(),
}
)
result.current.mutate()
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.cart).toEqual({
...fixtures.get("cart"),
id: "test-cart",
})
})
})
describe("useUpdatePaymentSession hook", () => {
test("updates a payment session", async () => {
const { result, waitFor } = renderHook(
() => useUpdatePaymentSession("test-cart"),
{
wrapper: createWrapper(),
}
)
result.current.mutate({
data: {},
provider_id: "stripe",
})
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.cart).toEqual({
...fixtures.get("cart"),
id: "test-cart",
})
})
})
describe("useRefreshPaymentSession hook", () => {
test("refreshes a payment session", async () => {
const { result, waitFor } = renderHook(
() => useRefreshPaymentSession("test-cart"),
{
wrapper: createWrapper(),
}
)
result.current.mutate({
provider_id: "stripe",
})
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.cart).toEqual({
...fixtures.get("cart"),
id: "test-cart",
})
})
})
describe("useSetPaymentSession hook", () => {
test("sets a payment session", async () => {
const { result, waitFor } = renderHook(
() => useSetPaymentSession("test-cart"),
{
wrapper: createWrapper(),
}
)
result.current.mutate({
provider_id: "stripe",
})
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.cart).toEqual({
...fixtures.get("cart"),
id: "test-cart",
})
})
})
describe("useDeletePaymentSession hook", () => {
test("deletes a payment session", async () => {
const { result, waitFor } = renderHook(
() => useDeletePaymentSession("test-cart"),
{
wrapper: createWrapper(),
}
)
result.current.mutate({
provider_id: "stripe",
})
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.cart).toEqual({
...fixtures.get("cart"),
id: "test-cart",
})
})
})
describe("useAddShippingMethodToCart hook", () => {
test("adds a shipping method to a cart", async () => {
const { result, waitFor } = renderHook(
() => useAddShippingMethodToCart("test-cart"),
{
wrapper: createWrapper(),
}
)
result.current.mutate({
option_id: "test-option",
})
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.cart).toEqual({
...fixtures.get("cart"),
id: "test-cart",
})
})
})
|
3,799 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/store | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/store/carts/queries.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import { useGetCart } from "../../../../src/"
import { createWrapper } from "../../../utils"
describe("useGetCart hook", () => {
test("returns a cart", async () => {
const cart = fixtures.get("cart")
const { result, waitFor } = renderHook(() => useGetCart(cart.id), {
wrapper: createWrapper(),
})
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.cart).toEqual(cart)
})
})
|
3,800 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/store | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/store/collections/queries.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import { useCollection, useCollections } from "../../../../src/"
import { createWrapper } from "../../../utils"
describe("useCollections hook", () => {
test("returns a list of collections", async () => {
const collections = fixtures.list("product_collection")
const { result, waitFor } = renderHook(() => useCollections(), {
wrapper: createWrapper(),
})
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.collections).toEqual(collections)
})
})
describe("useCollection hook", () => {
test("returns a collection", async () => {
const collection = fixtures.get("product_collection")
const { result, waitFor } = renderHook(() => useCollection(collection.id), {
wrapper: createWrapper(),
})
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.collection).toEqual(collection)
})
})
|
3,801 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/store | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/store/customers/mutations.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import { useCreateCustomer, useUpdateMe } from "../../../../src/"
import { createWrapper } from "../../../utils"
describe("useCreateCustomer hook", () => {
test("creates a new customer", async () => {
const customer = {
first_name: "john",
last_name: "wick",
email: "[email protected]",
password: "supersecret",
phone: "111111",
}
const { result, waitFor } = renderHook(() => useCreateCustomer(), {
wrapper: createWrapper(),
})
result.current.mutate(customer)
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.customer).toEqual({
...fixtures.get("customer"),
...customer,
})
})
})
describe("useUpdateMe hook", () => {
test("updates current customer", async () => {
const customer = {
first_name: "lebron",
last_name: "james",
email: "[email protected]",
password: "supersecret",
phone: "111111",
}
const { result, waitFor } = renderHook(() => useUpdateMe(), {
wrapper: createWrapper(),
})
result.current.mutate({
id: "cus_test",
...customer,
})
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.customer).toEqual({
...fixtures.get("customer"),
...customer,
})
})
})
|
3,802 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/store | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/store/customers/queries.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { rest } from "msw"
import { fixtures } from "../../../../mocks/data"
import { server } from "../../../../mocks/server"
import { useCustomerOrders, useMeCustomer } from "../../../../src/"
import { createWrapper } from "../../../utils"
describe("useMeCustomer hook", () => {
test("returns customer", async () => {
const customer = fixtures.get("customer")
const { result, waitFor } = renderHook(() => useMeCustomer(), {
wrapper: createWrapper(),
})
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.customer).toEqual(customer)
})
})
describe("useCustomerOrders hook", () => {
test("returns customer's orders", async () => {
const orders = fixtures.list("order", 5)
const { result, waitFor } = renderHook(() => useCustomerOrders(), {
wrapper: createWrapper(),
})
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.orders).toEqual(orders)
expect(result.current.limit).toEqual(5)
expect(result.current.offset).toEqual(0)
})
test("propagates query params and returns customer's orders", async () => {
const orders = fixtures.list("order")
server.use(
rest.get("/store/customers/me/orders", (req, res, ctx) => {
const limit = req.url.searchParams.get("limit")
const offset = req.url.searchParams.get("offset")
const expand = req.url.searchParams.get("expand")
const fields = req.url.searchParams.get("fields")
expect({
limit,
offset,
expand,
fields,
}).toEqual({
limit: "2",
offset: "5",
expand: "relation_1,relation_2",
fields: "field_1,field_2",
})
return res(
ctx.status(200),
ctx.json({
orders,
limit: 2,
offset: 5,
})
)
})
)
const { result, waitFor } = renderHook(
() =>
useCustomerOrders({
limit: 2,
offset: 5,
expand: "relation_1,relation_2",
fields: "field_1,field_2",
}),
{
wrapper: createWrapper(),
}
)
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.orders).toEqual(orders)
expect(result.current.limit).toEqual(2)
expect(result.current.offset).toEqual(5)
})
})
|
3,803 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/store | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/store/gift_cards/queries.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import { useGiftCard } from "../../../../src/"
import { createWrapper } from "../../../utils"
describe("useGiftCard hook", () => {
test("returns a gift card", async () => {
const giftCard = fixtures.get("gift_card")
const { result, waitFor } = renderHook(() => useGiftCard(giftCard.id), {
wrapper: createWrapper(),
})
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.gift_card).toEqual(giftCard)
})
})
|
3,804 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/store | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/store/line-items/mutations.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import {
useCreateLineItem,
useDeleteLineItem,
useUpdateLineItem,
} from "../../../../src/"
import { createWrapper } from "../../../utils"
describe("useCreateLineItem hook", () => {
test("creates a line item", async () => {
const lineItem = {
variant_id: "test-variant",
quantity: 1,
}
const { result, waitFor } = renderHook(
() => useCreateLineItem("test-cart"),
{
wrapper: createWrapper(),
}
)
result.current.mutate(lineItem)
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.cart.items).toEqual(
expect.arrayContaining([
expect.objectContaining({
...lineItem,
}),
])
)
})
})
describe("useUpdateLineItem hook", () => {
test("updates a line item", async () => {
const lineItem = {
lineId: "some-item-id",
quantity: 3,
}
const { result, waitFor } = renderHook(
() => useUpdateLineItem("test-cart"),
{
wrapper: createWrapper(),
}
)
result.current.mutate(lineItem)
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.cart.items).toEqual(
expect.arrayContaining([
expect.objectContaining({
id: lineItem.lineId,
quantity: lineItem.quantity,
}),
])
)
})
})
describe("useDeleteLineItem hook", () => {
test("deletes a line item", async () => {
const lineItem = {
lineId: "some-item-id",
}
const { result, waitFor } = renderHook(
() => useDeleteLineItem("test-cart"),
{
wrapper: createWrapper(),
}
)
result.current.mutate(lineItem)
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.cart).toEqual(fixtures.get("cart"))
})
})
|
3,805 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/store | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/store/order-edits/mutations.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { useCompleteOrderEdit, useDeclineOrderEdit } from "../../../../src/"
import { createWrapper } from "../../../utils"
describe("useDeclineOrderEdit hook", () => {
test("decline an order edit", async () => {
const declineBody = {
declined_reason: "Wrong color",
}
const { result, waitFor } = renderHook(
() => useDeclineOrderEdit("store_order_edit"),
{
wrapper: createWrapper(),
}
)
result.current.mutate(declineBody)
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.order_edit).toEqual(
expect.objectContaining({
status: "declined",
...declineBody,
})
)
})
})
describe("useCompleteOrderEdit hook", () => {
test("complete an order edit", async () => {
const { result, waitFor } = renderHook(
() => useCompleteOrderEdit("store_order_edit"),
{
wrapper: createWrapper(),
}
)
result.current.mutate()
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.order_edit).toEqual(
expect.objectContaining({
status: "confirmed",
})
)
})
})
|
3,806 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/store | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/store/order-edits/queries.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import { useOrderEdit } from "../../../../src/hooks/store/order-edits"
import { createWrapper } from "../../../utils"
describe("useOrderEdit hook", () => {
test("returns an order", async () => {
const store_order_edit = fixtures.get("store_order_edit")
const { result, waitFor } = renderHook(
() => useOrderEdit(store_order_edit.id),
{
wrapper: createWrapper(),
}
)
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.order_edit).toEqual(store_order_edit)
})
})
|
3,807 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/store | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/store/orders/mutations.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { useGrantOrderAccess, useRequestOrderAccess } from "../../../../src/"
import { createWrapper } from "../../../utils"
describe("useGrantOrderAccess hook", () => {
test("Grant access to token", async () => {
const { result, waitFor } = renderHook(() => useGrantOrderAccess(), {
wrapper: createWrapper(),
})
result.current.mutate({ token: "store_order_edit" })
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
})
})
describe("useRequestOrderAccess hook", () => {
test("Requests access to ids", async () => {
const { result, waitFor } = renderHook(() => useRequestOrderAccess(), {
wrapper: createWrapper(),
})
result.current.mutate({ order_ids: [""] })
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
})
})
|
3,808 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/store | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/store/orders/queries.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { rest } from "msw"
import { fixtures } from "../../../../mocks/data"
import { server } from "../../../../mocks/server"
import { useCartOrder, useOrder } from "../../../../src/"
import { useOrders } from "../../../../src/hooks"
import { createWrapper } from "../../../utils"
describe("useOrder hook", () => {
test("returns an order", async () => {
const order = fixtures.get("order")
const { result, waitFor } = renderHook(() => useOrder(order.id), {
wrapper: createWrapper(),
})
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.order).toEqual(order)
})
})
describe("useCartOrder hook", () => {
test("returns a cart order", async () => {
const order = fixtures.get("order")
const { result, waitFor } = renderHook(() => useCartOrder("test_cart"), {
wrapper: createWrapper(),
})
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.order).toEqual(order)
})
})
describe("useOrders hook", () => {
test("propagates the query params and returns an order", async () => {
const order = fixtures.get("order")
const displayId = 400,
emailParam = "[email protected]"
server.use(
rest.get("/store/orders", (req, res, ctx) => {
const display_id = req.url.searchParams.get("display_id")
const email = req.url.searchParams.get("email")
expect({
display_id,
email,
}).toEqual({
email: emailParam,
display_id: displayId.toString(),
})
return res(
ctx.status(200),
ctx.json({
order,
})
)
})
)
const { result, waitFor } = renderHook(
() =>
useOrders({
display_id: displayId,
email: emailParam,
}),
{
wrapper: createWrapper(),
}
)
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.order).toEqual(order)
})
})
|
3,809 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/store | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/store/payment-collections/mutations.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import {
useAuthorizePaymentSession,
useAuthorizePaymentSessionsBatch,
useManageMultiplePaymentSessions,
useManagePaymentSession,
usePaymentCollectionRefreshPaymentSession,
} from "../../../../src"
import { createWrapper } from "../../../utils"
describe("useManageMultiplePaymentSessions hook", () => {
test("Manage multiple payment sessions of a payment collection", async () => {
const { result, waitFor } = renderHook(
() => useManageMultiplePaymentSessions("payment_collection_id"),
{
wrapper: createWrapper(),
}
)
result.current.mutate({
sessions: {
provider_id: "manual",
amount: 900,
},
})
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data?.payment_collection).toEqual(
expect.objectContaining({
id: "payment_collection_id",
amount: 900,
})
)
})
})
describe("useManagePaymentSession hook", () => {
test("Manage payment session of a payment collection", async () => {
const { result, waitFor } = renderHook(
() => useManagePaymentSession("payment_collection_id"),
{
wrapper: createWrapper(),
}
)
result.current.mutate({
provider_id: "manual",
})
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data?.payment_collection).toEqual(
expect.objectContaining({
id: "payment_collection_id",
amount: 900,
})
)
})
})
describe("useAuthorizePaymentSession hook", () => {
test("Authorize a payment session of a Payment Collection", async () => {
const { result, waitFor } = renderHook(
() => useAuthorizePaymentSession("payment_collection_id"),
{
wrapper: createWrapper(),
}
)
result.current.mutate("123")
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.payment_session).toEqual(
expect.objectContaining({
id: "123",
amount: 900,
})
)
})
})
describe("authorizePaymentSessionsBatch hook", () => {
test("Authorize all payment sessions of a Payment Collection", async () => {
const { result, waitFor } = renderHook(
() => useAuthorizePaymentSessionsBatch("payment_collection_id"),
{
wrapper: createWrapper(),
}
)
result.current.mutate({
session_ids: ["abc"],
})
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(207)
expect(result.current.data.payment_collection).toEqual(
expect.objectContaining({
id: "payment_collection_id",
payment_sessions: expect.arrayContaining([
expect.objectContaining({
amount: 900,
}),
]),
})
)
})
})
describe("usePaymentCollectionRefreshPaymentSession hook", () => {
test("Refresh a payment sessions of a Payment Collection", async () => {
const { result, waitFor } = renderHook(
() => usePaymentCollectionRefreshPaymentSession("payment_collection_id"),
{
wrapper: createWrapper(),
}
)
result.current.mutate("session_id")
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.payment_session).toEqual(
expect.objectContaining({
id: "new_session_id",
amount: 900,
})
)
})
})
|
3,810 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/store | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/store/payment-collections/queries.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import { usePaymentCollection } from "../../../../src/hooks/store/payment-collections"
import { createWrapper } from "../../../utils"
describe("usePaymentCollection hook", () => {
test("returns a payment collection", async () => {
const payment_collection = fixtures.get("payment_collection")
const { result, waitFor } = renderHook(
() => usePaymentCollection(payment_collection.id),
{
wrapper: createWrapper(),
}
)
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.payment_collection).toEqual(payment_collection)
})
})
|
3,811 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/store | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/store/product-tags/queries.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data/index"
import { useProductTags } from "../../../../src"
import { createWrapper } from "../../../utils"
describe("useProductTags hook", () => {
test("gets a list of products", async () => {
const { result, waitFor } = renderHook(() => useProductTags(), {
wrapper: createWrapper(),
})
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.product_tags).toEqual(
fixtures.list("product_tag", 10)
)
})
})
|
3,812 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/store | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/store/products/queries.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data/index"
import { useProduct, useProducts } from "../../../../src"
import { createWrapper } from "../../../utils"
describe("useProducts hook", () => {
test("gets a list of products", async () => {
const { result, waitFor } = renderHook(() => useProducts(), {
wrapper: createWrapper(),
})
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.products).toEqual(fixtures.list("product"))
})
test("gets a list of products based on limit and offset", async () => {
const { result, waitFor } = renderHook(
() =>
useProducts({
limit: 2,
offset: 5,
}),
{
wrapper: createWrapper(),
}
)
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.products).toEqual(fixtures.list("product"))
expect(result.current.limit).toEqual(2)
expect(result.current.offset).toEqual(5)
})
})
describe("useProducts hook", () => {
test("success", async () => {
const { result, waitFor } = renderHook(
() => useProduct("prod_01F0YESHQ27Y31CAMD0NV6W9YP"),
{
wrapper: createWrapper(),
}
)
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.product).toEqual(fixtures.get("product"))
})
})
|
3,813 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/store | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/store/regions/queries.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import { useRegion, useRegions } from "../../../../src/"
import { createWrapper } from "../../../utils"
describe("useRegions hook", () => {
test("success", async () => {
const regions = fixtures.list("region")
const { result, waitFor } = renderHook(() => useRegions(), {
wrapper: createWrapper(),
})
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.regions).toEqual(regions)
})
})
describe("useRegion hook", () => {
test("success", async () => {
const region = fixtures.get("region")
const { result, waitFor } = renderHook(() => useRegion(region.id), {
wrapper: createWrapper(),
})
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.region).toEqual(region)
})
})
|
3,814 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/store | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/store/return-reasons/queries.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import { useReturnReason, useReturnReasons } from "../../../../src/"
import { createWrapper } from "../../../utils"
describe("useReturnReasons hook", () => {
test("returns a list of return reasons", async () => {
const return_reasons = fixtures.list("return_reason")
const { result, waitFor } = renderHook(() => useReturnReasons(), {
wrapper: createWrapper(),
})
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.return_reasons).toEqual(return_reasons)
})
})
describe("useReturnReason hook", () => {
test("returns a return reason", async () => {
const return_reason = fixtures.get("return_reason")
const { result, waitFor } = renderHook(
() => useReturnReason(return_reason.id),
{
wrapper: createWrapper(),
}
)
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.return_reason).toEqual(return_reason)
})
})
|
3,815 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/store | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/store/returns/mutations.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import { useCreateReturn } from "../../../../src"
import { createWrapper } from "../../../utils"
describe("useCreateReturn hook", () => {
test("creates a return", async () => {
const ret = {
order_id: "order_38",
items: [
{
item_id: "test-item",
quantity: 1,
},
],
}
const { result, waitFor } = renderHook(() => useCreateReturn(), {
wrapper: createWrapper(),
})
result.current.mutate(ret)
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.return).toEqual(
expect.objectContaining({
...fixtures.get("return"),
order_id: ret.order_id,
})
)
})
})
|
3,816 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/store | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/store/shipping-options/queries.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { rest } from "msw"
import { fixtures } from "../../../../mocks/data"
import { server } from "../../../../mocks/server"
import { useCartShippingOptions, useShippingOptions } from "../../../../src/"
import { createWrapper } from "../../../utils"
describe("useShippingOptions hook", () => {
test("returns a list of shipping options", async () => {
const shippingOptions = fixtures.list("shipping_option", 5)
const { result, waitFor } = renderHook(() => useShippingOptions(), {
wrapper: createWrapper(),
})
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.shipping_options).toEqual(shippingOptions)
})
test("when shipping options params are provided, then they should be sent as query params", async () => {
const shippingOptions = fixtures.list("shipping_option")
server.use(
rest.get("/store/shipping-options/", (req, res, ctx) => {
const product_ids = req.url.searchParams.get("product_ids")
const is_return = req.url.searchParams.get("is_return")
const region_id = req.url.searchParams.get("region_id")
expect({
product_ids,
is_return,
region_id,
}).toEqual({
product_ids: "1,2,3",
is_return: "false",
region_id: "test-region",
})
return res(
ctx.status(200),
ctx.json({
shipping_options: fixtures.list("shipping_option"),
})
)
})
)
const { result, waitFor } = renderHook(
() =>
useShippingOptions({
product_ids: "1,2,3",
is_return: "false",
region_id: "test-region",
}),
{
wrapper: createWrapper(),
}
)
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.shipping_options).toEqual(shippingOptions)
})
})
describe("useCartShippingOptions hook", () => {
test("success", async () => {
const cartShippingOptions = fixtures.list("shipping_option")
const { result, waitFor } = renderHook(
() => useCartShippingOptions("cart_test"),
{
wrapper: createWrapper(),
}
)
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.shipping_options).toEqual(cartShippingOptions)
})
})
|
3,817 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/store | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/store/swaps/mutations.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import { useCreateSwap } from "../../../../src/"
import { createWrapper } from "../../../utils"
describe("useCreateSwap hook", () => {
test("creates a return", async () => {
const swap = {
order_id: "order_test",
additional_items: [
{
variant_id: "new-item",
quantity: 1,
},
],
return_items: [
{
item_id: "return-item",
quantity: 1,
},
],
}
const { result, waitFor } = renderHook(() => useCreateSwap(), {
wrapper: createWrapper(),
})
result.current.mutate(swap)
await waitFor(() => result.current.isSuccess)
expect(result.current.data.response.status).toEqual(200)
expect(result.current.data.swap).toEqual(
expect.objectContaining({
...fixtures.get("swap"),
order_id: swap.order_id,
})
)
})
})
|
3,818 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/store | petrpan-code/medusajs/medusa/packages/medusa-react/test/hooks/store/swaps/queries.test.ts | import { renderHook } from "@testing-library/react-hooks/dom"
import { fixtures } from "../../../../mocks/data"
import { useCartSwap } from "../../../../src/"
import { createWrapper } from "../../../utils"
describe("useCartSwap hook", () => {
test("returns a swap", async () => {
const swap = fixtures.get("swap")
const { result, waitFor } = renderHook(() => useCartSwap("cart_test"), {
wrapper: createWrapper(),
})
await waitFor(() => result.current.isSuccess)
expect(result.current.response.status).toEqual(200)
expect(result.current.swap).toEqual(swap)
})
})
|
3,819 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test | petrpan-code/medusajs/medusa/packages/medusa-react/test/session-cart-context/session-cart.test.ts | import { generateCartState } from "../../src/contexts/session-cart"
import { ProductVariant } from "@medusajs/medusa"
import { useSessionCart } from "../../src"
import { act, renderHook } from "@testing-library/react-hooks"
import { fixtures } from "../../mocks/data"
import { createSessionCartWrapper } from "../utils"
const initialSessionCartState = {
region: fixtures.get("region"),
totalItems: 0,
total: 0,
items: [],
}
describe("useSessionCart hook", () => {
describe("sets a region", () => {
test("success", async () => {
const { result } = renderHook(() => useSessionCart(), {
wrapper: createSessionCartWrapper(),
})
const { setRegion } = result.current
act(() => {
setRegion(fixtures.get("region"))
})
const { region, total, totalItems } = result.current
expect(region).toEqual(fixtures.get("region"))
expect(total).toEqual(0)
expect(totalItems).toEqual(0)
})
})
describe("item operations", () => {
test("addItem", () => {
const { result } = renderHook(() => useSessionCart(), {
wrapper: createSessionCartWrapper(),
initialProps: {
initialState: initialSessionCartState,
},
})
const { addItem } = result.current
const variant = fixtures.get("product_variant")
act(() => {
addItem({
variant: (variant as unknown) as ProductVariant,
quantity: 1,
})
})
const { items, totalItems, total } = result.current
expect(totalItems).toBe(1)
expect(total).toBe(1000)
expect(items).toEqual([
{
variant: expect.objectContaining(variant),
quantity: 1,
total: 1000,
},
])
})
test("updateItem", () => {
const variant = fixtures.get("product_variant")
const { result } = renderHook(() => useSessionCart(), {
wrapper: createSessionCartWrapper(),
initialProps: {
initialState: generateCartState(initialSessionCartState, [
{
variant: (variant as unknown) as ProductVariant,
quantity: 1,
},
{
variant: ({
...variant,
id: "test-variant",
} as unknown) as ProductVariant,
quantity: 1,
},
]),
},
})
const { updateItem } = result.current
act(() => {
updateItem(variant.id, {
quantity: 4,
})
})
const { items, totalItems, total } = result.current
expect(totalItems).toBe(5)
expect(total).toBe(5 * 1000)
expect(items).toEqual([
{
variant: expect.objectContaining(variant),
quantity: 4,
total: 1000,
},
{
variant: {
...variant,
id: "test-variant",
},
quantity: 1,
total: 1000,
},
])
})
test("removeItem", () => {
const variant = fixtures.get("product_variant")
const { result } = renderHook(() => useSessionCart(), {
wrapper: createSessionCartWrapper(),
initialProps: {
initialState: generateCartState(initialSessionCartState, [
{
variant: (variant as unknown) as ProductVariant,
quantity: 3,
},
{
variant: ({
...variant,
id: "test-variant",
} as unknown) as ProductVariant,
quantity: 1,
},
]),
},
})
const { removeItem } = result.current
act(() => {
removeItem(variant.id)
})
const { items, totalItems, total } = result.current
expect(totalItems).toBe(1)
expect(total).toBe(1000)
expect(items).toEqual([
{
variant: {
...variant,
id: "test-variant",
},
quantity: 1,
total: 1000,
},
])
})
test("incrementItemQuantity", () => {
const variant = fixtures.get("product_variant")
const { result } = renderHook(() => useSessionCart(), {
wrapper: createSessionCartWrapper(),
initialProps: {
initialState: generateCartState(initialSessionCartState, [
{
variant: (variant as unknown) as ProductVariant,
quantity: 2,
},
]),
},
})
const { incrementItemQuantity } = result.current
act(() => {
incrementItemQuantity(variant.id)
})
const { items, totalItems, total } = result.current
expect(totalItems).toBe(3)
expect(total).toBe(3 * 1000)
expect(items).toEqual([
{
variant,
quantity: 3,
total: 1000,
},
])
})
test("decrementItemQuantity", () => {
const variant = fixtures.get("product_variant")
const { result } = renderHook(() => useSessionCart(), {
wrapper: createSessionCartWrapper(),
initialProps: {
initialState: generateCartState(initialSessionCartState, [
{
variant: (variant as unknown) as ProductVariant,
quantity: 4,
},
]),
},
})
const { decrementItemQuantity } = result.current
act(() => {
decrementItemQuantity(variant.id)
})
const { items, totalItems, total } = result.current
expect(totalItems).toBe(3)
expect(total).toBe(3 * 1000)
expect(items).toEqual([
{
variant,
quantity: 3,
total: 1000,
},
])
})
test("setItems", () => {
const variant = fixtures.get("product_variant")
const { result } = renderHook(() => useSessionCart(), {
wrapper: createSessionCartWrapper(),
initialProps: {
initialState: generateCartState(initialSessionCartState, [
{
variant: (variant as unknown) as ProductVariant,
quantity: 4,
},
]),
},
})
const { setItems } = result.current
act(() => {
setItems([
{
variant: ({
...variant,
id: "test-variant",
} as unknown) as ProductVariant,
quantity: 1,
},
])
})
const { items, totalItems, total } = result.current
expect(totalItems).toBe(1)
expect(total).toBe(1000)
expect(items).toEqual([
{
variant: expect.objectContaining({
id: "test-variant",
}),
quantity: 1,
total: 1000,
},
])
})
test("getItem", () => {
const variant = fixtures.get("product_variant")
const { result } = renderHook(() => useSessionCart(), {
wrapper: createSessionCartWrapper(),
initialProps: {
initialState: generateCartState(initialSessionCartState, [
{
variant: (variant as unknown) as ProductVariant,
quantity: 1,
},
]),
},
})
const { getItem } = result.current
let item
act(() => {
item = getItem(variant.id)
})
expect(item).toEqual({
variant,
quantity: 1,
total: 1000,
})
})
test("clearItems", () => {
const variant = fixtures.get("product_variant")
const { result } = renderHook(() => useSessionCart(), {
wrapper: createSessionCartWrapper(),
initialProps: {
initialState: generateCartState(initialSessionCartState, [
{
variant: (variant as unknown) as ProductVariant,
quantity: 4,
},
]),
},
})
const { clearItems } = result.current
act(() => {
clearItems()
})
const { items, totalItems, total } = result.current
expect(totalItems).toBe(0)
expect(total).toBe(0)
expect(items).toEqual([])
})
})
})
|
3,820 | 0 | petrpan-code/medusajs/medusa/packages/medusa-react/test | petrpan-code/medusajs/medusa/packages/medusa-react/test/utils/utils.test.ts | import { RegionInfo, ProductVariantInfo } from "./../../src/types"
import { fixtures } from "./../../mocks/data/"
import {
computeVariantPrice,
getVariantPrice,
computeAmount,
formatAmount,
formatVariantPrice,
} from "./../../src/"
describe("getVariantPrice", () => {
test("finds the variant price and returns its amount", () => {
const variant = fixtures.get("product_variant")
const region = fixtures.get("region")
const amount = getVariantPrice(
(variant as unknown) as ProductVariantInfo,
region
)
expect(amount).toEqual(1000)
})
test("when no region is provided, then it should return 0", () => {
const variant = fixtures.get("product_variant")
const amount = getVariantPrice(
(variant as unknown) as ProductVariantInfo,
{} as RegionInfo
)
expect(amount).toEqual(0)
})
test("when no product variant is provided, then it should return 0", () => {
const region = fixtures.get("region")
const amount = getVariantPrice({} as ProductVariantInfo, region)
expect(amount).toEqual(0)
})
test("when no product variant and region are provided, then it should return 0", () => {
const amount = getVariantPrice({} as ProductVariantInfo, {} as RegionInfo)
expect(amount).toEqual(0)
})
})
describe("computeAmount", () => {
test("given an amount and a region, it should return a decimal amount not including taxes", () => {
const region = fixtures.get("region")
const amount = computeAmount({ amount: 3000, region, includeTaxes: false })
expect(amount).toEqual(30)
})
test("given an amount and a region, it should return a decimal amount including taxes", () => {
const region = fixtures.get("region")
const amount = computeAmount({
amount: 3000,
region: {
...region,
tax_rate: 10,
},
})
expect(amount).toEqual(33)
})
test("when no region is provided, then it should return the decimal amount", () => {
const region = fixtures.get("region")
const amount = computeAmount({ amount: 2000, region })
expect(amount).toEqual(20)
})
})
describe("computeVariantPrice", () => {
test("finds the variant price and returns a decimal amount not including taxes", () => {
const variant = fixtures.get("product_variant")
const region = fixtures.get("region")
const price = computeVariantPrice({
variant: (variant as unknown) as ProductVariantInfo,
region,
})
expect(price).toEqual(10)
})
test("finds the variant price and returns a decimal amount including taxes", () => {
const variant = fixtures.get("product_variant")
const region = fixtures.get("region")
const price = computeVariantPrice({
variant: (variant as unknown) as ProductVariantInfo,
region: {
...region,
tax_rate: 15,
},
includeTaxes: true,
})
expect(price).toEqual(11.5)
})
})
describe("formatVariantPrice", () => {
test("given a variant and region, should return a decimal localized amount including taxes and the region's currency code", () => {
const region = fixtures.get("region")
const variant = fixtures.get("product_variant")
const price = formatVariantPrice({
variant: (variant as unknown) as ProductVariantInfo,
region: {
...region,
tax_rate: 15,
},
})
expect(price).toEqual("$11.50")
})
test("given a variant, region, and a custom locale, should return a decimal localized amount including taxes and the region's currency code", () => {
const region = fixtures.get("region")
const variant = fixtures.get("product_variant")
const price = formatVariantPrice({
variant: (variant as unknown) as ProductVariantInfo,
region: {
...region,
tax_rate: 15,
},
locale: "fr-FR",
})
expect(price.replace(/\s/, " ")).toEqual("11,50 $US")
})
})
describe("formatAmount", () => {
test("given an amount and region, should return a decimal localized amount including taxes and the region's currency code", () => {
const region = fixtures.get("region")
const price = formatAmount({
amount: 3000,
region: {
...region,
tax_rate: 15,
},
})
expect(price).toEqual("$34.50")
})
test("given an amount and no region, should return a decimal localized amount", () => {
const price = formatAmount({ amount: 3000, region: {} as RegionInfo })
expect(price).toEqual("30")
})
})
|
5,156 | 0 | petrpan-code/medusajs/medusa/packages/oas/medusa-oas-cli/src | petrpan-code/medusajs/medusa/packages/oas/medusa-oas-cli/src/__tests__/command-docs.test.ts | import { exists, getTmpDirectory } from "../utils/fs-utils"
import { writeJson } from "../utils/json-utils"
import { OpenAPIObject } from "openapi3-ts"
import path from "path"
import { v4 as uid } from "uuid"
import { readYaml, writeYaml } from "../utils/yaml-utils"
import { mkdir, readdir } from "fs/promises"
import {
formatHintRecommendation,
getCircularPatchRecommendation,
getCircularReferences,
} from "../utils/circular-patch-utils"
import execa from "execa"
const basePath = path.resolve(__dirname, `../../../`)
export const runCLI = async (command: string, options: string[] = []) => {
const params = ["run", "medusa-oas", command, ...options]
try {
const { all: logs } = await execa("yarn", params, {
cwd: basePath,
all: true,
})
} catch (err) {
throw new Error(err.message + err.all)
}
}
export const getBaseOpenApi = (): OpenAPIObject => {
return {
openapi: "3.0.0",
info: {
title: "Test",
version: "1.0.0",
},
paths: {},
components: {},
}
}
describe("command docs", () => {
let tmpDir: string
let openApi: OpenAPIObject
beforeAll(async () => {
tmpDir = await getTmpDirectory()
})
beforeEach(async () => {
openApi = getBaseOpenApi()
})
describe("basic usage", () => {
let srcFile: string
beforeAll(async () => {
openApi = getBaseOpenApi()
openApi.components = {
schemas: {
Order: {
type: "object",
},
},
}
const outDir = path.resolve(tmpDir, uid())
await mkdir(outDir, { recursive: true })
srcFile = path.resolve(outDir, "store.oas.json")
await writeJson(srcFile, openApi)
})
it("should generate docs", async () => {
const outDir = path.resolve(tmpDir, uid())
await runCLI("docs", ["--src-file", srcFile, "--out-dir", outDir])
const generatedFilePath = path.resolve(outDir, "openapi.yaml")
const oas = (await readYaml(generatedFilePath)) as OpenAPIObject
const files = await readdir(outDir)
expect(oas.components?.schemas?.Order).toBeDefined()
expect(files.length).toBe(1)
})
it("should clean output directory", async () => {
const outDir = path.resolve(tmpDir, uid())
await mkdir(outDir, { recursive: true })
await writeJson(path.resolve(outDir, "test.json"), { foo: "bar" })
await runCLI("docs", [
"--src-file",
srcFile,
"--out-dir",
outDir,
"--clean",
])
const files = await readdir(outDir)
expect(files.includes("test.json")).toBeFalsy()
expect(files.length).toBe(1)
})
it("should not output any files", async () => {
const outDir = path.resolve(tmpDir, uid())
await runCLI("docs", [
"--src-file",
srcFile,
"--out-dir",
outDir,
"--dry-run",
])
const outDirExists = await exists(outDir)
expect(outDirExists).toBeFalsy()
})
it("should split output into multiple files and directories", async () => {
const outDir = path.resolve(tmpDir, uid())
/**
* For split to output files, we need to not be in test mode
* See https://github.com/Redocly/redocly-cli/blob/v1.0.0-beta.125/packages/cli/src/utils.ts#L206-L215
*/
const previousEnv = process.env.NODE_ENV
process.env.NODE_ENV = "development"
await runCLI("docs", [
"--src-file",
srcFile,
"--out-dir",
outDir,
"--split",
"--clean",
])
process.env.NODE_ENV = previousEnv
const oasFileExists = await exists(path.resolve(outDir, "openapi.yaml"))
const outFileExists = await exists(
path.resolve(outDir, "components/schemas/Order.yaml")
)
expect(oasFileExists).toBeTruthy()
expect(outFileExists).toBeTruthy()
})
it("should generate static HTML docs", async () => {
const outDir = path.resolve(tmpDir, uid())
await runCLI("docs", [
"--src-file",
srcFile,
"--out-dir",
outDir,
"--html",
])
const generatedFilePath = path.resolve(outDir, "index.html")
const htmlFileExists = await exists(generatedFilePath)
expect(htmlFileExists).toBeTruthy()
})
})
describe("--config", () => {
let srcFile: string
let configFile: string
let configYamlFile: string
beforeAll(async () => {
openApi = getBaseOpenApi()
openApi.components = {
schemas: {
Customer: {
type: "object",
properties: {
address: {
$ref: "#/components/schemas/Address",
},
},
},
TestOrder: {
type: "object",
properties: {
address: {
$ref: "#/components/schemas/Address",
},
},
},
Address: {
type: "object",
properties: {
/**
* We expect this circular reference to already be handled by
* our CLI's default redocly-config.yaml
*/
customer: {
$ref: "#/components/schemas/Customer",
},
/**
* We expect this circular reference to not be handled.
*/
test_order: {
$ref: "#/components/schemas/TestOrder",
},
},
},
},
}
const config = {
decorators: {
"medusa/circular-patch": {
schemas: {
Address: ["TestOrder"],
},
},
},
}
const outDir = path.resolve(tmpDir, uid())
await mkdir(outDir, { recursive: true })
srcFile = path.resolve(outDir, "store.oas.json")
await writeJson(srcFile, openApi)
configFile = path.resolve(outDir, "redocly-config.json")
await writeJson(configFile, config)
configYamlFile = path.resolve(outDir, "redocly-config.yaml")
await writeYaml(configYamlFile, config)
})
it("should fail with unhandled circular reference", async () => {
const outDir = path.resolve(tmpDir, uid())
await expect(
runCLI("docs", [
"--src-file",
srcFile,
"--out-dir",
outDir,
"--dry-run",
])
).rejects.toThrow("Unhandled circular references")
})
it("should succeed with patched circular reference", async () => {
const outDir = path.resolve(tmpDir, uid())
await expect(
runCLI("docs", [
"--src-file",
srcFile,
"--out-dir",
outDir,
"--config",
configFile,
"--dry-run",
])
).resolves.not.toThrow()
})
it("should succeed when config is of type yaml", async () => {
const outDir = path.resolve(tmpDir, uid())
await expect(
runCLI("docs", [
"--src-file",
srcFile,
"--out-dir",
outDir,
"--config",
configYamlFile,
"--dry-run",
])
).resolves.not.toThrow()
})
it("should fail when config is not a file", async () => {
const outDir = path.resolve(tmpDir, uid())
await expect(
runCLI("docs", [
"--src-file",
srcFile,
"--out-dir",
outDir,
"--dry-run",
"--config",
outDir,
])
).rejects.toThrow("--config must be a file")
})
it("should fail when config is not of supported file type", async () => {
const outDir = path.resolve(tmpDir, uid())
await mkdir(outDir, { recursive: true })
const tmpFile = path.resolve(outDir, "tmp.txt")
await writeJson(tmpFile, { foo: "bar" })
await expect(
runCLI("docs", [
"--src-file",
srcFile,
"--out-dir",
outDir,
"--dry-run",
"--config",
tmpFile,
])
).rejects.toThrow("--config file must be of type .json or .yaml")
})
})
describe("circular references", () => {
let srcFile: string
beforeAll(async () => {
openApi = getBaseOpenApi()
openApi.components = {
schemas: {
Customer: {
type: "object",
properties: {
address: {
$ref: "#/components/schemas/Address",
},
},
},
TestOrder: {
type: "object",
properties: {
address: {
$ref: "#/components/schemas/Address",
},
},
},
Address: {
type: "object",
properties: {
customer: {
$ref: "#/components/schemas/Customer",
},
test_order: {
$ref: "#/components/schemas/TestOrder",
},
},
},
},
}
const outDir = path.resolve(tmpDir, uid())
await mkdir(outDir, { recursive: true })
srcFile = path.resolve(outDir, "store.oas.json")
await writeJson(srcFile, openApi)
})
it("should find circular references", async () => {
const { circularRefs, oas } = await getCircularReferences(srcFile)
expect(circularRefs.length).toBe(2)
expect(circularRefs).toEqual(
expect.arrayContaining([
"#/components/schemas/Address/properties/customer",
"#/components/schemas/TestOrder/properties/address",
])
)
})
it("should recommend which schemas to patch to resolve circular references", async () => {
/**
* The recommendation is heavily influenced but the dereference operation
* from @readme/json-schema-ref-parser. It's not an exact science and the
* results may vary between versions.
*/
const { circularRefs, oas } = await getCircularReferences(srcFile)
const recommendation = getCircularPatchRecommendation(circularRefs, oas)
expect(recommendation).toEqual(
expect.objectContaining({
Address: expect.arrayContaining(["Customer"]),
TestOrder: expect.arrayContaining(["Address"]),
})
)
})
it("should format hint", async () => {
const { circularRefs, oas } = await getCircularReferences(srcFile)
const recommendation = getCircularPatchRecommendation(circularRefs, oas)
const hint = formatHintRecommendation(recommendation)
expect(hint).toEqual(
expect.stringContaining(`decorators:
medusa/circular-patch:
schemas:
Address:
- Customer
TestOrder:
- Address
`)
)
})
})
})
|
5,157 | 0 | petrpan-code/medusajs/medusa/packages/oas/medusa-oas-cli/src | petrpan-code/medusajs/medusa/packages/oas/medusa-oas-cli/src/__tests__/command-oas.test.ts | import fs from "fs/promises"
import { OpenAPIObject, SchemaObject } from "openapi3-ts"
import { OperationObject } from "openapi3-ts/src/model/OpenApi"
import path from "path"
import { v4 as uid } from "uuid"
import { getTmpDirectory } from "../utils/fs-utils"
import { readYaml } from "../utils/yaml-utils"
import { readJson } from "../utils/json-utils"
import execa from "execa"
const medusaPackagePath = path.dirname(
require.resolve("@medusajs/medusa/package.json")
)
const basePath = path.resolve(__dirname, `../../`)
export const runCLI = async (command: string, options: string[] = []) => {
const params = ["run", "medusa-oas", command, ...options]
try {
const { all: logs } = await execa("yarn", params, {
cwd: basePath,
all: true,
})
} catch (err) {
throw new Error(err.message + err.all)
}
}
const listOperations = (oas: OpenAPIObject): OperationObject[] => {
const operations: OperationObject[] = []
for (const url in oas.paths) {
if (oas.paths.hasOwnProperty(url)) {
const path = oas.paths[url]
for (const method in path) {
if (path.hasOwnProperty(method)) {
switch (method) {
case "get":
case "put":
case "post":
case "delete":
case "options":
case "head":
case "patch":
operations.push(path[method])
break
}
}
}
}
}
return operations
}
describe("command oas", () => {
let tmpDir: string
beforeAll(async () => {
tmpDir = await getTmpDirectory()
})
describe("--type admin", () => {
let oas: OpenAPIObject
/**
* In a CI context, beforeAll might exceed the configured jest timeout.
* Until we upgrade our jest version, the timeout error will be swallowed
* and the test will fail in unexpected ways.
*/
beforeAll(async () => {
const outDir = path.resolve(tmpDir, uid())
await runCLI("oas", ["--type", "admin", "--out-dir", outDir])
const generatedFilePath = path.resolve(outDir, "admin.oas.json")
oas = (await readJson(generatedFilePath)) as OpenAPIObject
})
it("generates oas with admin routes only", async () => {
const routes = Object.keys(oas.paths)
expect(routes.includes("/admin/products")).toBeTruthy()
expect(routes.includes("/store/products")).toBeFalsy()
})
it("generates oas using admin.oas.base.yaml", async () => {
const yamlFilePath = path.resolve(
medusaPackagePath,
"oas",
"admin.oas.base.yaml"
)
const oasBase = (await readYaml(yamlFilePath)) as OpenAPIObject
expect(oas.info.title).toEqual(oasBase.info.title)
})
})
describe("--type store", () => {
let oas: OpenAPIObject
beforeAll(async () => {
const outDir = path.resolve(tmpDir, uid())
await runCLI("oas", ["--type", "store", "--out-dir", outDir])
const generatedFilePath = path.resolve(outDir, "store.oas.json")
oas = (await readJson(generatedFilePath)) as OpenAPIObject
})
it("generates oas with store routes only", async () => {
const routes = Object.keys(oas.paths)
expect(routes.includes("/admin/products")).toBeFalsy()
expect(routes.includes("/store/products")).toBeTruthy()
})
it("generates oas using store.oas.base.yaml", async () => {
const yamlFilePath = path.resolve(
medusaPackagePath,
"oas",
"store.oas.base.yaml"
)
const oasBase = (await readYaml(yamlFilePath)) as OpenAPIObject
expect(oas.info.title).toEqual(oasBase.info.title)
})
})
describe("--type combined", () => {
let oas: OpenAPIObject
beforeAll(async () => {
const outDir = path.resolve(tmpDir, uid())
await runCLI("oas", ["--type", "combined", "--out-dir", outDir])
const generatedFilePath = path.resolve(outDir, "combined.oas.json")
oas = (await readJson(generatedFilePath)) as OpenAPIObject
})
it("generates oas with admin and store routes", async () => {
const routes = Object.keys(oas.paths)
expect(routes.includes("/admin/products")).toBeTruthy()
expect(routes.includes("/store/products")).toBeTruthy()
})
it("generates oas using default.oas.base.yaml", async () => {
const yamlFilePath = path.resolve(
basePath,
"oas",
"default.oas.base.yaml"
)
const oasBase = (await readYaml(yamlFilePath)) as OpenAPIObject
expect(oas.info.title).toEqual(oasBase.info.title)
})
it("prefixes tags with api type", async () => {
const found = (oas.tags ?? []).filter((tag) => {
return !(tag.name.startsWith("Admin") || tag.name.startsWith("Store"))
})
expect(found).toEqual([])
})
it("prefixes route's tags with api type", async () => {
const tags: string[] = listOperations(oas)
.map((operation) => {
return operation.tags ?? []
})
.flat()
const found = tags.filter((tag) => {
return !(tag.startsWith("Admin") || tag.startsWith("Store"))
})
expect(found).toEqual([])
})
it("prefixes route's operationId with api type", async () => {
const operationIds: string[] = listOperations(oas)
.map((operation) => operation.operationId)
.filter((operationId): operationId is string => !!operationId)
const found = operationIds.filter((tag) => {
return !(tag.startsWith("Admin") || tag.startsWith("Store"))
})
expect(found).toEqual([])
})
it("combines components.schemas from admin and store", async () => {
const schemas = Object.keys(oas.components?.schemas ?? {})
expect(schemas.includes("AdminProductsListRes")).toBeTruthy()
expect(schemas.includes("StoreProductsListRes")).toBeTruthy()
})
})
/**
* to optimize test suite time, we only test --paths with the store api
*/
describe("--paths", () => {
let oas: OpenAPIObject
beforeAll(async () => {
const fileContent = `
/** @oas [get] /foobar/tests
* operationId: GetFoobarTests
*/
/** @oas [get] /store/regions
* operationId: OverwrittenOperation
*/
/**
* @schema FoobarTestSchema
* type: object
* properties:
* foo:
* type: string
*/
/**
* @schema StoreRegionsListRes
* type: object
* properties:
* foo:
* type: string
*/
`
const additionalPath = path.resolve(tmpDir, uid())
const filePath = path.resolve(additionalPath, "foobar.ts")
await fs.mkdir(additionalPath, { recursive: true })
await fs.writeFile(filePath, fileContent, "utf8")
const outDir = path.resolve(tmpDir, uid())
await runCLI("oas", [
"--type",
"store",
"--out-dir",
outDir,
"--paths",
additionalPath,
])
const generatedFilePath = path.resolve(outDir, "store.oas.json")
oas = (await readJson(generatedFilePath)) as OpenAPIObject
})
it("should add new path to existing paths", async () => {
const routes = Object.keys(oas.paths)
expect(routes.includes("/store/products")).toBeTruthy()
expect(routes.includes("/foobar/tests")).toBeTruthy()
})
it("should overwrite existing path", async () => {
expect(oas.paths["/store/regions"]["get"].operationId).toBe(
"OverwrittenOperation"
)
})
it("should add new schema to existing schemas", async () => {
const schemas = Object.keys(oas.components?.schemas ?? {})
expect(schemas.includes("StoreProductsListRes")).toBeTruthy()
expect(schemas.includes("FoobarTestSchema")).toBeTruthy()
})
it("should overwrite existing schema", async () => {
const schema = oas.components?.schemas?.StoreRegionsListRes as
| SchemaObject
| undefined
expect(schema?.properties?.foo).toBeDefined()
})
})
/**
* to optimize test suite time, we only test --base with the store api
*/
describe("--base", () => {
let oas: OpenAPIObject
beforeAll(async () => {
const fileContent = `
openapi: 3.1.0
info:
version: 1.0.1
title: Custom API
servers:
- url: https://foobar.com
security:
- api_key: []
externalDocs:
url: https://docs.com
webhooks:
"foo-hook":
get:
responses:
"200":
description: OK
tags:
- name: Products
description: Overwritten tag
- name: FoobarTag
description: Foobar tag description
paths:
"/foobar/tests":
get:
operationId: GetFoobarTests
responses:
"200":
description: OK
"/store/regions":
get:
operationId: OverwrittenOperation
responses:
"200":
description: OK
components:
schemas:
FoobarTestSchema:
type: object
properties:
foo:
type: string
StoreRegionsListRes:
type: object
properties:
foo:
type: string
callbacks:
fooCallback:
get:
description: foo callback
examples:
fooExample:
description: foo example
headers:
fooHeader:
description: foo header
links:
fooLink:
description: foo link
operationRef: GetFoobarTests
parameters:
fooParameter:
description: foo parameter
name: foobar
in: path
required: true
schema:
type: string
requestBodies:
fooRequestBody:
description: foo requestBody
content:
"application/octet-stream": { }
responses:
fooResponse:
description: foo response
securitySchemes:
fooSecurity:
description: foo security
type: apiKey
name: foo-api-key
in: header
`
const targetDir = path.resolve(tmpDir, uid())
const filePath = path.resolve(targetDir, "custom.oas.base.yaml")
await fs.mkdir(targetDir, { recursive: true })
await fs.writeFile(filePath, fileContent, "utf8")
const outDir = path.resolve(tmpDir, uid())
await runCLI("oas", [
"--type",
"store",
"--out-dir",
outDir,
"--base",
filePath,
])
const generatedFilePath = path.resolve(outDir, "store.oas.json")
oas = (await readJson(generatedFilePath)) as OpenAPIObject
})
it("should add new path to existing paths", async () => {
const routes = Object.keys(oas.paths)
expect(routes.includes("/store/products")).toBeTruthy()
expect(routes.includes("/foobar/tests")).toBeTruthy()
})
it("should overwrite existing path", async () => {
expect(oas.paths["/store/regions"]["get"].operationId).toBe(
"OverwrittenOperation"
)
})
it("should add new schema to existing schemas", async () => {
const schemas = Object.keys(oas.components?.schemas ?? {})
expect(schemas.includes("StoreProductsListRes")).toBeTruthy()
expect(schemas.includes("FoobarTestSchema")).toBeTruthy()
})
it("should overwrite existing schema", async () => {
const schema = oas.components?.schemas?.StoreRegionsListRes as
| SchemaObject
| undefined
expect(schema?.properties?.foo).toBeDefined()
})
it("should replace base properties", async () => {
expect(oas.openapi).toBe("3.1.0")
expect(oas.info).toEqual({ version: "1.0.1", title: "Custom API" })
expect(oas.servers).toEqual([{ url: "https://foobar.com" }])
expect(oas.security).toEqual([{ api_key: [] }])
expect(oas.externalDocs).toEqual({ url: "https://docs.com" })
expect(oas.webhooks).toEqual({
"foo-hook": { get: { responses: { "200": { description: "OK" } } } },
})
})
it("should add new tag", async () => {
expect(oas.tags).toEqual(
expect.arrayContaining([
expect.objectContaining({
name: "FoobarTag",
}),
])
)
})
it("should overwrite existing tag", async () => {
expect(oas.tags).toEqual(
expect.arrayContaining([
expect.objectContaining({
name: "Products",
description: "Overwritten tag",
}),
])
)
})
it("should add new components", async () => {
const components = oas.components ?? {}
expect(
Object.keys(components.callbacks ?? {}).includes("fooCallback")
).toBeTruthy()
expect(
Object.keys(components.examples ?? {}).includes("fooExample")
).toBeTruthy()
expect(
Object.keys(components.headers ?? {}).includes("fooHeader")
).toBeTruthy()
expect(
Object.keys(components.links ?? {}).includes("fooLink")
).toBeTruthy()
expect(
Object.keys(components.parameters ?? {}).includes("fooParameter")
).toBeTruthy()
expect(
Object.keys(components.requestBodies ?? {}).includes("fooRequestBody")
).toBeTruthy()
expect(
Object.keys(components.responses ?? {}).includes("fooResponse")
).toBeTruthy()
expect(
Object.keys(components.securitySchemes ?? {}).includes("fooSecurity")
).toBeTruthy()
})
})
})
|
5,260 | 0 | petrpan-code/medusajs/medusa/packages/oas/openapi-typescript-codegen/src/openApi/v3/parser | petrpan-code/medusajs/medusa/packages/oas/openapi-typescript-codegen/src/openApi/v3/parser/__tests__/getModel.test.ts | import { getModel } from "../getModel"
import { OpenApi } from "../../interfaces/OpenApi"
import { Model } from "../../../../client/interfaces/Model"
import { OpenApiSchema } from "../../interfaces/OpenApiSchema"
describe("getModel", () => {
let openApi: OpenApi
beforeEach(async () => {
openApi = {
openapi: "3.0.0",
info: {
title: "Test",
version: "1.0.0",
},
paths: {},
components: {},
}
})
it("should set model spec with definition", () => {
const modelName = "OrderRes"
const definition: OpenApiSchema = {
type: "object",
properties: {
id: {
type: "string",
},
},
}
const model: Model = getModel(openApi, definition, true, modelName)
expect(model.spec).toEqual(definition)
})
it("should set property spec with definition", () => {
const modelName = "OrderRes"
const definition: OpenApiSchema = {
type: "object",
properties: {
order: {
type: "object",
properties: {
id: {
type: "string",
},
},
},
},
}
const model: Model = getModel(openApi, definition, true, modelName)
expect(model.properties[0].spec).toEqual(definition.properties!.order)
})
})
|
5,261 | 0 | petrpan-code/medusajs/medusa/packages/oas/openapi-typescript-codegen/src/openApi/v3/parser | petrpan-code/medusajs/medusa/packages/oas/openapi-typescript-codegen/src/openApi/v3/parser/__tests__/getModels.test.ts | import { getModels } from "../getModels"
import { OpenApi } from "../../interfaces/OpenApi"
describe("getModels", () => {
let openApi: OpenApi
beforeEach(async () => {
openApi = {
openapi: "3.0.0",
info: {
title: "Test",
version: "1.0.0",
},
paths: {},
components: {},
}
})
it("should return an empty array if no models are found", () => {
const models = getModels(openApi)
expect(models).toEqual([])
})
it("should return an array of models", () => {
openApi.components = {
schemas: {
OrderRes: {
type: "object",
properties: {
id: {
type: "string",
},
},
},
},
}
const models = getModels(openApi)
expect(models).toEqual(
expect.arrayContaining([
expect.objectContaining({
name: "OrderRes",
properties: expect.arrayContaining([
expect.objectContaining({
name: "id",
type: "string",
}),
]),
}),
])
)
})
it("should return an array of models with expanded relations", () => {
openApi.components = {
schemas: {
OrderRes: {
type: "object",
"x-expanded-relations": {
field: "order",
relations: ["region", "region.country"],
},
properties: {
order: {
$ref: "#/components/schemas/Order",
},
},
},
Order: {
type: "object",
properties: {
region: {
$ref: "#/components/schemas/Region",
},
},
},
Region: {
type: "object",
properties: {
country: {
$ref: "#/components/schemas/Country",
},
},
},
Country: {
type: "object",
},
},
}
const models = getModels(openApi)
expect(models).toEqual(
expect.arrayContaining([
expect.objectContaining({
name: "OrderRes",
properties: expect.arrayContaining([
expect.objectContaining({
name: "order",
base: "Order",
nestedRelations: expect.arrayContaining([
expect.objectContaining({
base: "Order",
field: "order",
nestedRelations: expect.arrayContaining([
expect.objectContaining({
field: "region",
base: "Region",
nestedRelations: expect.arrayContaining([
expect.objectContaining({
base: "Country",
field: "country",
nestedRelations: [],
}),
]),
}),
]),
}),
]),
}),
]),
}),
])
)
})
it("should convert query parameters into a schema when x-codegen.queryParams is declared", () => {
openApi.paths = {
"/": {
get: {
operationId: "GetOrder",
"x-codegen": {
queryParams: "GetOrderQueryParams",
},
parameters: [
{
description: "Limit the number of results",
in: "query",
name: "limit",
schema: {
type: "integer",
},
required: true,
deprecated: true,
},
],
responses: {
"200": {
description: "OK",
},
},
},
},
}
const models = getModels(openApi)
expect(models).toEqual(
expect.arrayContaining([
expect.objectContaining({
name: "GetOrderQueryParams",
properties: expect.arrayContaining([
expect.objectContaining({
description: "Limit the number of results",
name: "limit",
type: "number",
isRequired: true,
deprecated: true,
}),
]),
}),
])
)
})
})
|
5,262 | 0 | petrpan-code/medusajs/medusa/packages/oas/openapi-typescript-codegen/src/openApi/v3/parser | petrpan-code/medusajs/medusa/packages/oas/openapi-typescript-codegen/src/openApi/v3/parser/__tests__/getModelsExpandedRelations.test.ts | import { Model } from "../../../../client/interfaces/Model"
import { handleExpandedRelations } from "../getModelsExpandedRelations"
import { getModel } from "../getModel"
import { OpenApi } from "../../interfaces/OpenApi"
import { OpenApiSchema } from "../../interfaces/OpenApiSchema"
import { getType } from "../getType"
function getModelsTest(openApi: OpenApi): Model[] {
const models: Model[] = []
if (openApi.components) {
for (const definitionName in openApi.components.schemas) {
if (openApi.components.schemas.hasOwnProperty(definitionName)) {
const definition = openApi.components.schemas[definitionName]
const definitionType = getType(definitionName)
const model = getModel(openApi, definition, true, definitionType.base)
models.push(model)
}
}
}
return models
}
describe("getModelsExpandedRelations", () => {
let openApi: OpenApi
beforeEach(async () => {
openApi = {
openapi: "3.0.0",
info: {
title: "Test",
version: "1.0.0",
},
paths: {},
components: {
schemas: {
Order: {
type: "object",
properties: {
region: {
$ref: "#/components/schemas/Region",
},
total: {
type: "number",
},
},
},
Region: {
type: "object",
properties: {
country: {
$ref: "#/components/schemas/Country",
},
},
},
Country: {
type: "object",
},
Customer: {
type: "object",
properties: {
orders: {
type: "array",
items: {
$ref: "#/components/schemas/Order",
},
},
},
},
},
},
}
})
describe("basic use cases", () => {
it("should find nested relation - model", () => {
const modelName: string = "OrderRes"
const definition: OpenApiSchema = {
type: "object",
"x-expanded-relations": {
field: "order",
relations: ["region"],
},
properties: {
order: {
$ref: "#/components/schemas/Order",
},
},
}
const model: Model = getModel(openApi, definition, true, modelName)
const models: Model[] = [...getModelsTest(openApi), model]
handleExpandedRelations(model, models)
expect(model.properties[0].nestedRelations).toEqual(
expect.arrayContaining([
expect.objectContaining({
field: "order",
base: "Order",
isArray: false,
nestedRelations: expect.arrayContaining([
expect.objectContaining({
field: "region",
base: "Region",
isArray: false,
nestedRelations: [],
}),
]),
}),
])
)
})
it("should find nested relation - shallow", () => {
const modelName: string = "OrderRes"
const definition: OpenApiSchema = {
type: "object",
"x-expanded-relations": {
field: "order",
relations: ["total"],
},
properties: {
order: {
$ref: "#/components/schemas/Order",
},
},
}
const model: Model = getModel(openApi, definition, true, modelName)
const models: Model[] = [...getModelsTest(openApi), model]
handleExpandedRelations(model, models)
expect(model.properties[0].nestedRelations).toEqual(
expect.arrayContaining([
expect.objectContaining({
field: "order",
base: "Order",
isArray: false,
nestedRelations: expect.arrayContaining([
expect.objectContaining({
field: "total",
nestedRelations: [],
}),
]),
}),
])
)
})
it("should find nested relation - array", () => {
const modelName: string = "CustomerRes"
const definition: OpenApiSchema = {
type: "object",
"x-expanded-relations": {
field: "customer",
relations: ["orders"],
},
properties: {
customer: {
$ref: "#/components/schemas/Customer",
},
},
}
const model: Model = getModel(openApi, definition, true, modelName)
const models: Model[] = [...getModelsTest(openApi), model]
handleExpandedRelations(model, models)
expect(model.properties[0].nestedRelations).toEqual(
expect.arrayContaining([
expect.objectContaining({
field: "customer",
base: "Customer",
isArray: false,
nestedRelations: expect.arrayContaining([
expect.objectContaining({
field: "orders",
base: "Order",
isArray: true,
nestedRelations: [],
}),
]),
}),
])
)
})
})
describe("misc usage", () => {
it.each([["allOf"], ["anyOf"], ["oneOf"]])(
"should findPropInCombination - %s",
(combination) => {
openApi.components!.schemas!.ExpandedOrder = {
[combination]: [{ $ref: "#/components/schemas/Order" }],
}
const modelName: string = "OrderRes"
const definition: OpenApiSchema = {
type: "object",
"x-expanded-relations": {
field: "order",
relations: ["region"],
},
properties: {
order: {
$ref: "#/components/schemas/ExpandedOrder",
},
},
}
const model: Model = getModel(openApi, definition, true, modelName)
const models: Model[] = [...getModelsTest(openApi), model]
handleExpandedRelations(model, models)
expect(model.properties[0].nestedRelations).toEqual(
expect.arrayContaining([
expect.objectContaining({
nestedRelations: expect.arrayContaining([
expect.objectContaining({
field: "region",
}),
]),
}),
])
)
}
)
it.each([["relations"], ["totals"], ["implicit"], ["eager"]])(
"should find nested relation with relation type - %s",
(relationType) => {
const modelName: string = "OrderRes"
const definition: OpenApiSchema = {
type: "object",
"x-expanded-relations": {
field: "order",
[relationType]: ["region"],
},
properties: {
order: {
$ref: "#/components/schemas/Order",
},
},
}
const model: Model = getModel(openApi, definition, true, modelName)
const models: Model[] = [...getModelsTest(openApi), model]
handleExpandedRelations(model, models)
expect(model.properties[0].nestedRelations).toEqual(
expect.arrayContaining([
expect.objectContaining({
nestedRelations: expect.arrayContaining([
expect.objectContaining({
field: "region",
}),
]),
}),
])
)
}
)
it("should set field hasDepth - true", () => {
const modelName: string = "OrderRes"
const definition: OpenApiSchema = {
type: "object",
"x-expanded-relations": {
field: "order",
relations: ["region.country"],
},
properties: {
order: {
$ref: "#/components/schemas/Order",
},
},
}
const model: Model = getModel(openApi, definition, true, modelName)
const models: Model[] = [...getModelsTest(openApi), model]
handleExpandedRelations(model, models)
expect(model.properties[0].nestedRelations).toEqual(
expect.arrayContaining([
expect.objectContaining({
hasDepth: true,
nestedRelations: expect.arrayContaining([
expect.objectContaining({
field: "region",
nestedRelations: expect.arrayContaining([
expect.objectContaining({
field: "country",
}),
]),
}),
]),
}),
])
)
})
it("should set relation hasDepth - true", () => {
const modelName: string = "CustomerRes"
const definition: OpenApiSchema = {
type: "object",
"x-expanded-relations": {
field: "customer",
relations: ["orders.region.country"],
},
properties: {
customer: {
$ref: "#/components/schemas/Customer",
},
},
}
const model: Model = getModel(openApi, definition, true, modelName)
const models: Model[] = [...getModelsTest(openApi), model]
handleExpandedRelations(model, models)
expect(model.properties[0].nestedRelations).toEqual(
expect.arrayContaining([
expect.objectContaining({
hasDepth: true,
nestedRelations: expect.arrayContaining([
expect.objectContaining({
field: "orders",
hasDepth: true,
nestedRelations: expect.arrayContaining([
expect.objectContaining({
field: "region",
nestedRelations: expect.arrayContaining([
expect.objectContaining({
field: "country",
nestedRelations: [],
}),
]),
}),
]),
}),
]),
}),
])
)
})
it("should add models with relation to root model imports, only once", () => {
const modelName: string = "OrderRes"
const definition: OpenApiSchema = {
type: "object",
"x-expanded-relations": {
field: "order",
relations: ["region", "region.country"],
},
properties: {
order: {
$ref: "#/components/schemas/Order",
},
},
}
const model: Model = getModel(openApi, definition, true, modelName)
const models: Model[] = [...getModelsTest(openApi), model]
handleExpandedRelations(model, models)
expect(model.imports).toEqual(expect.arrayContaining(["Order", "Region"]))
})
})
describe("errors", () => {
it("should throw if field is not found", () => {
const modelName: string = "OrderRes"
const definition: OpenApiSchema = {
type: "object",
"x-expanded-relations": {
field: "nope",
},
properties: {
order: {
$ref: "#/components/schemas/Order",
},
},
}
const model: Model = getModel(openApi, definition, true, modelName)
const models: Model[] = [...getModelsTest(openApi), model]
expect(() => handleExpandedRelations(model, models)).toThrow(
"x-expanded-relations - field not found"
)
})
it("should throw if relation is not found", () => {
const modelName: string = "OrderRes"
const definition: OpenApiSchema = {
type: "object",
"x-expanded-relations": {
field: "order",
relations: ["nope"],
},
properties: {
order: {
$ref: "#/components/schemas/Order",
},
},
}
const model: Model = getModel(openApi, definition, true, modelName)
const models: Model[] = [...getModelsTest(openApi), model]
expect(() => handleExpandedRelations(model, models)).toThrow(
"x-expanded-relations - relation not found"
)
})
it.each([["allOf"], ["anyOf"], ["oneOf"]])(
"should throw if field exports as a combination - %s",
(combination) => {
const modelName: string = "OrderRes"
const definition: OpenApiSchema = {
type: "object",
"x-expanded-relations": {
field: "order",
relations: ["region"],
},
properties: {
order: {
[combination]: [{ $ref: "#/components/schemas/Order" }],
},
},
}
const model: Model = getModel(openApi, definition, true, modelName)
const models: Model[] = [...getModelsTest(openApi), model]
expect(() => handleExpandedRelations(model, models)).toThrow(
"x-expanded-relations - unsupported - field referencing multiple models"
)
}
)
})
})
|
5,263 | 0 | petrpan-code/medusajs/medusa/packages/oas/openapi-typescript-codegen/src/openApi/v3/parser | petrpan-code/medusajs/medusa/packages/oas/openapi-typescript-codegen/src/openApi/v3/parser/__tests__/getOperation.test.ts | import { OpenApi } from "../../interfaces/OpenApi"
import { OpenApiOperation } from "../../interfaces/OpenApiOperation"
import { getOperation } from "../getOperation"
import { getOperationParameters } from "../getOperationParameters"
describe("getOperation", () => {
let openApi: OpenApi
beforeEach(async () => {
openApi = {
openapi: "3.0.0",
info: {
title: "Test",
version: "1.0.0",
},
paths: {},
components: {},
}
})
it("should parse x-codegen", () => {
const op: OpenApiOperation = {
"x-codegen": {
method: "list",
},
responses: {
"200": {
description: "OK",
},
},
}
const pathParams = getOperationParameters(openApi, [])
const operation = getOperation(
openApi,
"/orders",
"get",
"Orders",
op,
pathParams
)
expect(operation).toEqual(
expect.objectContaining({
codegen: { method: "list" },
})
)
})
it("should add x-codegen.queryParams to imports", () => {
const op: OpenApiOperation = {
"x-codegen": {
queryParams: "OrdersQueryParams",
},
responses: {
"200": {
description: "OK",
},
},
}
const pathParams = getOperationParameters(openApi, [])
const operation = getOperation(
openApi,
"/orders",
"get",
"Orders",
op,
pathParams
)
expect(operation.imports).toEqual(
expect.arrayContaining(["OrdersQueryParams"])
)
})
})
|
5,264 | 0 | petrpan-code/medusajs/medusa/packages/oas/openapi-typescript-codegen/src/openApi/v3/parser | petrpan-code/medusajs/medusa/packages/oas/openapi-typescript-codegen/src/openApi/v3/parser/__tests__/getOperationParameter.test.ts | import { OpenApi } from "../../interfaces/OpenApi"
import { getOperationParameter } from "../getOperationParameter"
import { OpenApiParameter } from "../../interfaces/OpenApiParameter"
describe("getOperation", () => {
let openApi: OpenApi
beforeEach(async () => {
openApi = {
openapi: "3.0.0",
info: {
title: "Test",
version: "1.0.0",
},
paths: {},
components: {},
}
})
it("should set spec with definition", () => {
const parameter: OpenApiParameter = {
name: "id",
in: "path",
}
const operationParameter = getOperationParameter(openApi, parameter)
expect(operationParameter.spec).toEqual(parameter)
})
})
|
5,265 | 0 | petrpan-code/medusajs/medusa/packages/oas/openapi-typescript-codegen/src/openApi/v3/parser | petrpan-code/medusajs/medusa/packages/oas/openapi-typescript-codegen/src/openApi/v3/parser/__tests__/getOperationRequestBody.test.ts | import { OpenApi } from "../../interfaces/OpenApi"
import { getOperationRequestBody } from "../getOperationRequestBody"
import { OpenApiRequestBody } from "../../interfaces/OpenApiRequestBody"
describe("getOperation", () => {
let openApi: OpenApi
beforeEach(async () => {
openApi = {
openapi: "3.0.0",
info: {
title: "Test",
version: "1.0.0",
},
paths: {},
components: {},
}
})
it("should set spec with definition", () => {
const body: OpenApiRequestBody = {
content: {
"application/json": {
schema: {
type: "object",
properties: {
id: {
type: "string",
},
},
},
},
},
}
const operationRequestBody = getOperationRequestBody(openApi, body)
expect(operationRequestBody.spec).toEqual(body)
})
})
|
5,266 | 0 | petrpan-code/medusajs/medusa/packages/oas/openapi-typescript-codegen/src/openApi/v3/parser | petrpan-code/medusajs/medusa/packages/oas/openapi-typescript-codegen/src/openApi/v3/parser/__tests__/getOperationResponse.test.ts | import { OpenApi } from "../../interfaces/OpenApi"
import { getOperationResponse } from "../getOperationResponse"
import { OpenApiResponse } from "../../interfaces/OpenApiResponse"
describe("getOperation", () => {
let openApi: OpenApi
beforeEach(async () => {
openApi = {
openapi: "3.0.0",
info: {
title: "Test",
version: "1.0.0",
},
paths: {},
components: {},
}
})
it("should set spec with definition", () => {
const response: OpenApiResponse = {
description: "OK",
}
const operationResponse = getOperationResponse(openApi, response, 200)
expect(operationResponse.spec).toEqual(response)
})
})
|
60 | 0 | petrpan-code/vercel/hyper/test | petrpan-code/vercel/hyper/test/unit/cli-api.test.ts | /* eslint-disable eslint-comments/disable-enable-pair */
/* eslint-disable @typescript-eslint/no-unsafe-return */
/* eslint-disable @typescript-eslint/no-unsafe-call */
import test from 'ava';
// eslint-disable-next-line @typescript-eslint/no-var-requires
const proxyquire = require('proxyquire').noCallThru();
test('existsOnNpm() builds the url for non-scoped packages', (t) => {
let getUrl: string;
const {existsOnNpm} = proxyquire('../../cli/api', {
got: {
get(url: string) {
getUrl = url;
return Promise.resolve({
body: {
versions: []
}
});
}
},
'registry-url': () => 'https://registry.npmjs.org/'
});
return existsOnNpm('pkg').then(() => {
t.is(getUrl, 'https://registry.npmjs.org/pkg');
});
});
test('existsOnNpm() builds the url for scoped packages', (t) => {
let getUrl: string;
const {existsOnNpm} = proxyquire('../../cli/api', {
got: {
get(url: string) {
getUrl = url;
return Promise.resolve({
body: {
versions: []
}
});
}
},
'registry-url': () => 'https://registry.npmjs.org/'
});
return existsOnNpm('@scope/pkg').then(() => {
t.is(getUrl, 'https://registry.npmjs.org/@scope%2fpkg');
});
});
|
61 | 0 | petrpan-code/vercel/hyper/test | petrpan-code/vercel/hyper/test/unit/to-electron-background-color.test.ts | import test from 'ava';
import toElectronBackgroundColor from '../../app/utils/to-electron-background-color';
import {isHexColor} from '../testUtils/is-hex-color';
test('toElectronBackgroundColor', (t) => {
t.false(false);
});
test(`returns a color that's in hex`, (t) => {
const hexColor = '#BADA55';
const rgbColor = 'rgb(0,0,0)';
const rgbaColor = 'rgb(0,0,0, 55)';
const hslColor = 'hsl(15, 100%, 50%)';
const hslaColor = 'hsl(15, 100%, 50%, 1)';
const colorKeyword = 'pink';
t.true(isHexColor(toElectronBackgroundColor(hexColor)));
t.true(isHexColor(toElectronBackgroundColor(rgbColor)));
t.true(isHexColor(toElectronBackgroundColor(rgbaColor)));
t.true(isHexColor(toElectronBackgroundColor(hslColor)));
t.true(isHexColor(toElectronBackgroundColor(hslaColor)));
t.true(isHexColor(toElectronBackgroundColor(colorKeyword)));
});
|
62 | 0 | petrpan-code/vercel/hyper/test | petrpan-code/vercel/hyper/test/unit/window-utils.test.ts | // eslint-disable-next-line eslint-comments/disable-enable-pair
/* eslint-disable @typescript-eslint/no-unsafe-call */
import test from 'ava';
// eslint-disable-next-line @typescript-eslint/no-var-requires
const proxyquire = require('proxyquire').noCallThru();
test('positionIsValid() returns true when window is on only screen', (t) => {
const position = [50, 50];
const windowUtils = proxyquire('../../app/utils/window-utils', {
electron: {
screen: {
getAllDisplays: () => {
return [
{
workArea: {
x: 0,
y: 0,
width: 500,
height: 500
}
}
];
}
}
}
});
const result = windowUtils.positionIsValid(position);
t.true(result);
});
test('positionIsValid() returns true when window is on second screen', (t) => {
const position = [750, 50];
const windowUtils = proxyquire('../../app/utils/window-utils', {
electron: {
screen: {
getAllDisplays: () => {
return [
{
workArea: {
x: 0,
y: 0,
width: 500,
height: 500
}
},
{
workArea: {
x: 500,
y: 0,
width: 500,
height: 500
}
}
];
}
}
}
});
const result = windowUtils.positionIsValid(position);
t.true(result);
});
test('positionIsValid() returns false when position isnt valid', (t) => {
const primaryDisplay = {
workArea: {
x: 0,
y: 0,
width: 500,
height: 500
}
};
const position = [600, 50];
const windowUtils = proxyquire('../../app/utils/window-utils', {
electron: {
screen: {
getAllDisplays: () => {
return [primaryDisplay];
},
getPrimaryDisplay: () => primaryDisplay
}
}
});
const result = windowUtils.positionIsValid(position);
t.false(result);
});
|
156 | 0 | petrpan-code/vercel/swr/e2e | petrpan-code/vercel/swr/e2e/test/initial-render.test.ts | /* eslint-disable testing-library/prefer-screen-queries */
import { test, expect } from '@playwright/test'
test.describe('rendering', () => {
test('suspense with preload', async ({ page }) => {
await page.goto('./suspense-after-preload', { waitUntil: 'commit' })
await page.getByRole('button', { name: 'preload' }).click()
await expect(page.getByText('suspense-after-preload')).toBeVisible()
})
test('should be able to retry in suspense with react 18.3', async ({
page
}) => {
await page.goto('./suspense-retry-18-3', { waitUntil: 'commit' })
await expect(page.getByText('Something went wrong')).toBeVisible()
await page.getByRole('button', { name: 'retry' }).click()
await expect(page.getByText('data: SWR suspense retry works')).toBeVisible()
})
test('should be able to retry in suspense with react 18.2', async ({
page
}) => {
await page.goto('./suspense-retry-18-2', { waitUntil: 'commit' })
await expect(page.getByText('Something went wrong')).toBeVisible()
await page.getByRole('button', { name: 'retry' }).click()
await expect(page.getByText('data: SWR suspense retry works')).toBeVisible()
})
test('should be able to retry in suspense with mutate', async ({ page }) => {
await page.goto('./suspense-retry-mutate', { waitUntil: 'commit' })
await expect(page.getByText('Something went wrong')).toBeVisible()
await page.getByRole('button', { name: 'retry' }).click()
await expect(page.getByText('data: SWR suspense retry works')).toBeVisible()
})
test('should be able to use `unstable_serialize` in server component', async ({
page
}) => {
await page.goto('./react-server-entry', { waitUntil: 'commit' })
await expect(page.getByText('unstable_serialize: useSWR')).toBeVisible()
await expect(
page.getByText('infinite_unstable_serialize: $inf$useSWRInfinite')
).toBeVisible()
})
})
|
157 | 0 | petrpan-code/vercel/swr/e2e | petrpan-code/vercel/swr/e2e/test/mutate-server-action.test.ts | /* eslint-disable testing-library/prefer-screen-queries */
import { test, expect } from '@playwright/test'
test('mutate-server-action', async ({ page }) => {
await page.goto('./mutate-server-action')
await page.getByRole('button', { name: 'mutate' }).click()
await expect(page.getByText('isMutating: true')).toBeVisible()
await expect(page.getByText('data: ')).toBeVisible()
await page.waitForTimeout(500)
await expect(page.getByText('isMutating: false')).toBeVisible()
await expect(page.getByText('data: 10086')).toBeVisible()
})
|
158 | 0 | petrpan-code/vercel/swr/e2e | petrpan-code/vercel/swr/e2e/test/stream-ssr.test.ts | /* eslint-disable testing-library/prefer-screen-queries */
import { test, expect } from '@playwright/test'
test.describe('Stream SSR', () => {
test('Basic SSR', async ({ page }) => {
const log: any[] = []
await page.exposeFunction('consoleError', (msg: any) => log.push(msg))
await page.addInitScript(`
const onError = window.onerror
window.onerror = (...args) => {
consoleError(...args)
onError(...args)
}
`)
await page.goto('./basic-ssr', { waitUntil: 'commit' })
await expect(page.getByText('result:undefined')).toBeVisible()
await expect(page.getByText('result:SSR Works')).toBeVisible()
await expect(page.getByText('history:[null,"SSR Works"]')).toBeVisible()
expect(log).toHaveLength(0)
})
test('Partially Hydrate', async ({ page }) => {
const log: any[] = []
await page.exposeFunction('consoleError', (msg: any) => log.push(msg))
await page.addInitScript(`
const onError = window.onerror
window.onerror = (...args) => {
consoleError(...args)
onError(...args)
}
`)
await page.goto('./partially-hydrate', { waitUntil: 'commit' })
await expect(page.getByText('first data:undefined')).toBeVisible()
await expect(
page.getByText('second data (delayed hydration):undefined')
).toBeVisible()
await expect(page.getByText('first data:SSR Works')).toBeVisible()
await expect(
page.getByText('second data (delayed hydration):SSR Works')
).toBeVisible()
await expect(
page.getByText('first history:[null,"SSR Works"]')
).toBeVisible()
await expect(
page.getByText('second history:[null,"SSR Works"]')
).toBeVisible()
expect(log).toHaveLength(0)
})
})
|
302 | 0 | petrpan-code/vercel/swr | petrpan-code/vercel/swr/test/tsconfig.json | {
"extends": "../tsconfig.json",
"compilerOptions": {
"strict": false,
"jsx": "react-jsx"
},
"include": [".", "./jest-setup.ts"],
"exclude": ["./type"]
}
|
303 | 0 | petrpan-code/vercel/swr | petrpan-code/vercel/swr/test/use-swr-cache.test.tsx | import { act, fireEvent, screen } from '@testing-library/react'
import { useState, StrictMode } from 'react'
import useSWR, { useSWRConfig, SWRConfig, mutate as globalMutate } from 'swr'
import {
sleep,
createKey,
createResponse,
nextTick,
focusOn,
renderWithConfig,
renderWithGlobalCache
} from './utils'
describe('useSWR - cache provider', () => {
let provider
beforeEach(() => {
provider = new Map()
})
it('should be able to update the cache', async () => {
const fetcher = _key => 'res:' + _key
const keys = [createKey(), createKey()]
function Page() {
const [index, setIndex] = useState(0)
const { data } = useSWR(keys[index], fetcher)
return <div onClick={() => setIndex(1)}>{data}</div>
}
renderWithConfig(<Page />, { provider: () => provider })
await screen.findByText(fetcher(keys[0]))
expect(provider.get(keys[1])?.data).toBe(undefined)
fireEvent.click(screen.getByText(fetcher(keys[0])))
await act(() => sleep(10))
expect(provider.get(keys[0])?.data).toBe(fetcher(keys[0]))
expect(provider.get(keys[1])?.data).toBe(fetcher(keys[1]))
})
it('should be able to read from the initial cache with updates', async () => {
const key = createKey()
const renderedValues = []
const fetcher = () => createResponse('updated value', { delay: 10 })
function Page() {
const { data } = useSWR(key, fetcher)
renderedValues.push(data)
return <div>{data}</div>
}
renderWithConfig(<Page />, {
provider: () => new Map([[key, { data: 'cached value' }]])
})
screen.getByText('cached value')
await screen.findByText('updated value')
expect(renderedValues.length).toBe(2)
})
it('should correctly mutate the cached value', async () => {
const key = createKey()
let mutate
function Page() {
const { mutate: mutateWithCache } = useSWRConfig()
mutate = mutateWithCache
const { data } = useSWR(key, null)
return <div>{data}</div>
}
renderWithConfig(<Page />, {
provider: () => new Map([[key, { data: 'cached value' }]])
})
screen.getByText('cached value')
await act(() => mutate(key, 'mutated value', false))
await screen.findByText('mutated value')
})
it('should support multi-level cache', async () => {
const key = createKey()
// Nested components with the same cache key can get different values.
function Foo() {
const { data } = useSWR(key, null)
return <>{data}</>
}
function Page() {
const { data } = useSWR(key, null)
return (
<div>
{data}:
<SWRConfig
value={{ provider: () => new Map([[key, { data: '2' }]]) }}
>
<Foo />
</SWRConfig>
</div>
)
}
renderWithConfig(<Page />, {
provider: () => new Map([[key, { data: '1' }]])
})
screen.getByText('1:2')
})
it('should support isolated cache', async () => {
const key = createKey()
// Nested components with the same cache key can get different values.
function Foo() {
const { data } = useSWR(key, null)
return <>{data}</>
}
function Page() {
return (
<div>
<SWRConfig
value={{ provider: () => new Map([[key, { data: '1' }]]) }}
>
<Foo />
</SWRConfig>
:
<SWRConfig
value={{ provider: () => new Map([[key, { data: '2' }]]) }}
>
<Foo />
</SWRConfig>
</div>
)
}
renderWithConfig(<Page />)
screen.getByText('1:2')
})
it('should respect provider options', async () => {
const key = createKey()
const focusFn = jest.fn()
const unsubscribeFocusFn = jest.fn()
const unsubscribeReconnectFn = jest.fn()
let value = 1
function Page() {
const { data } = useSWR(key, () => value++, {
dedupingInterval: 0
})
return <>{String(data)}</>
}
const { unmount } = renderWithConfig(<Page />, {
provider: () => new Map([[key, { data: 0 }]]),
initFocus() {
focusFn()
return unsubscribeFocusFn
},
initReconnect() {
/* do nothing */
return unsubscribeReconnectFn
}
})
screen.getByText('0')
// mount
await screen.findByText('1')
await nextTick()
// try to trigger revalidation, but shouldn't work
await focusOn(window)
// revalidateOnFocus won't work
screen.getByText('1')
unmount()
expect(focusFn).toBeCalled()
expect(unsubscribeFocusFn).toBeCalledTimes(1)
expect(unsubscribeReconnectFn).toBeCalledTimes(1)
})
it('should work with revalidateOnFocus', async () => {
const key = createKey()
let value = 0
function Page() {
const { data } = useSWR(key, () => value++, {
dedupingInterval: 0
})
return <>{String(data)}</>
}
renderWithConfig(<Page />, { provider: () => provider })
screen.getByText('undefined')
await screen.findByText('0')
await nextTick()
await focusOn(window)
await nextTick()
screen.getByText('1')
})
it('should support fallback values with custom provider', async () => {
const key = createKey()
function Page() {
const { data, isLoading } = useSWR(key, async () => {
await sleep(10)
return 'data'
})
return (
<>
{String(data)},{String(isLoading)}
</>
)
}
renderWithConfig(<Page />, {
provider: () => provider,
fallback: { [key]: 'fallback' }
})
screen.getByText('fallback,true') // no `undefined`, directly fallback
await screen.findByText('data,false')
})
it('should not return the fallback if cached', async () => {
const key = createKey()
function Page() {
const { data } = useSWR(key, async () => {
await sleep(10)
return 'data'
})
return <>{String(data)}</>
}
renderWithConfig(<Page />, {
provider: () => new Map([[key, { data: 'cache' }]]),
fallback: { [key]: 'fallback' }
})
screen.getByText('cache') // no `undefined`, directly from the cache
await screen.findByText('data')
})
it('should be able to extend the parent cache', async () => {
let parentCache
const key = createKey()
function Page() {
const { data } = useSWR(key, async () => {
await sleep(10)
return 'data'
})
return <>{String(data)}</>
}
renderWithConfig(<Page />, {
provider: parentCache_ => {
parentCache = parentCache_
return {
keys: () => parentCache.keys(),
set: (k, v) => parentCache_.set(k, v),
get: k => {
// We append `-extended` to the value returned by the parent cache.
const v = parentCache_.get(k)
if (v && typeof v.data !== 'undefined') {
return { ...v, data: v.data + '-extended' }
}
return v
},
delete: k => parentCache_.delete(k)
}
}
})
expect(parentCache).toBe(SWRConfig.defaultValue.cache)
screen.getByText('undefined')
await screen.findByText('data-extended')
})
it('should return the cache instance from the useSWRConfig', async () => {
let cache
function Page() {
cache = useSWRConfig().cache
return null
}
renderWithConfig(<Page />, { provider: () => provider })
expect(provider).toBe(cache)
})
it('should retain the correct cache hierarchy', async () => {
const key = createKey()
const fetcher = async () => {
await sleep(10)
return 'data'
}
function Foo() {
const { data } = useSWR(key, fetcher)
return <>{String(data)}</>
}
function Bar() {
const { data } = useSWR(key, fetcher)
return <>{String(data)}</>
}
function Page() {
const { data } = useSWR(key, fetcher)
return (
<div>
{String(data)},
<SWRConfig value={{ fallback: { [key]: 'fallback' } }}>
<Foo />
</SWRConfig>
,
<Bar />
</div>
)
}
renderWithConfig(<Page />)
screen.getByText('undefined,fallback,undefined')
await screen.findByText('data,data,data')
})
it('should not recreate the cache if rerendering', async () => {
const createCacheProvider = jest.fn()
let rerender
function Page() {
rerender = useState({})[1]
return (
<SWRConfig
value={{
provider: () => {
createCacheProvider()
return provider
}
}}
/>
)
}
renderWithConfig(<Page />)
expect(createCacheProvider).toBeCalledTimes(1)
act(() => rerender({}))
expect(createCacheProvider).toBeCalledTimes(1)
})
})
describe('useSWR - global cache', () => {
it('should return the global cache and mutate by default', async () => {
let localCache, localMutate
function Page() {
const { cache, mutate } = useSWRConfig()
localCache = cache
localMutate = mutate
return null
}
renderWithGlobalCache(<Page />)
expect(localCache).toBe(SWRConfig.defaultValue.cache)
expect(localMutate).toBe(globalMutate)
})
it('should be able to update the cache', async () => {
const fetcher = _key => 'res:' + _key
const keys = [createKey(), createKey()]
let cache
function Page() {
const [index, setIndex] = useState(0)
cache = useSWRConfig().cache
const { data } = useSWR(keys[index], fetcher)
return <div onClick={() => setIndex(1)}>{data}</div>
}
renderWithGlobalCache(<Page />)
await screen.findByText(fetcher(keys[0]))
expect(cache.get(keys[1])?.data).toBe(undefined)
fireEvent.click(screen.getByText(fetcher(keys[0])))
await act(() => sleep(10))
expect(cache.get(keys[0])?.data).toBe(fetcher(keys[0]))
expect(cache.get(keys[1])?.data).toBe(fetcher(keys[1]))
})
it('should correctly mutate the cached value', async () => {
const key = createKey()
let mutate
function Page() {
const { mutate: mutateWithCache } = useSWRConfig()
mutate = mutateWithCache
const { data } = useSWR(key, null)
return <div>data:{data}</div>
}
renderWithGlobalCache(<Page />)
screen.getByText('data:')
await act(() => mutate(key, 'mutated value', false))
await screen.findByText('data:mutated value')
})
it('should work with revalidateOnFocus', async () => {
const key = createKey()
let value = 0
function Page() {
const { data } = useSWR(key, () => value++, {
dedupingInterval: 0
})
return <>{String(data)}</>
}
renderWithGlobalCache(<Page />)
screen.getByText('undefined')
await screen.findByText('0')
await nextTick()
await focusOn(window)
await nextTick()
screen.getByText('1')
})
it('should support fallback values', async () => {
const key = createKey()
function Page() {
const { data } = useSWR(key, async () => {
await sleep(10)
return 'data'
})
return <>{String(data)}</>
}
renderWithGlobalCache(<Page />, { fallback: { [key]: 'fallback' } })
screen.getByText('fallback') // no `undefined`, directly fallback
await screen.findByText('data')
})
it('should reusing the same cache instance after unmounting SWRConfig', async () => {
let focusEventRegistered = false
const cacheSingleton = new Map([['key', { data: 'value' }]])
function Page() {
return (
<SWRConfig
value={{
provider: () => cacheSingleton,
initFocus: () => {
focusEventRegistered = true
return () => (focusEventRegistered = false)
}
}}
>
<Comp />
</SWRConfig>
)
}
function Comp() {
const { cache } = useSWRConfig()
return <>{String(cache.get('key')?.data)}</>
}
function Wrapper() {
const [mount, setMountPage] = useState(true)
return (
<>
<button onClick={() => setMountPage(!mount)}>toggle</button>
{mount ? <Page /> : null}
</>
)
}
renderWithGlobalCache(<Wrapper />)
await screen.findByText('value')
fireEvent.click(screen.getByText('toggle'))
fireEvent.click(screen.getByText('toggle'))
await screen.findByText('value')
expect(focusEventRegistered).toEqual(true)
})
it('should correctly return the cache instance under strict mode', async () => {
function Page() {
// Intentionally do this.
const [cache] = useState(new Map([['key', { data: 'value' }]]))
return (
<SWRConfig value={{ provider: () => cache }}>
<Comp />
</SWRConfig>
)
}
function Comp() {
const { cache } = useSWRConfig()
return <>{String(cache.get('key')?.data)}</>
}
renderWithGlobalCache(
<StrictMode>
<Page />
</StrictMode>
)
await screen.findByText('value')
})
})
|
304 | 0 | petrpan-code/vercel/swr | petrpan-code/vercel/swr/test/use-swr-concurrent-rendering.test.tsx | import { screen, fireEvent, act } from '@testing-library/react'
import {
createKey,
createResponse,
sleep,
executeWithoutBatching,
renderWithConfig
} from './utils'
import React from 'react'
import useSWR from 'swr'
describe('useSWR - concurrent rendering', () => {
it('should fetch data in concurrent rendering', async () => {
const key = createKey()
function Page() {
const { data } = useSWR(key, () => createResponse('0', { delay: 50 }), {
dedupingInterval: 0
})
return <div>data:{data}</div>
}
renderWithConfig(<Page />)
screen.getByText('data:')
await act(() => sleep(100))
screen.getByText('data:0')
})
it('should pause when changing the key inside a transition', async () => {
const initialKey = createKey()
const newKey = createKey()
const fetcher = (k: string) => createResponse(k, { delay: 100 })
// eslint-disable-next-line react/prop-types
function Component({ swrKey }) {
const { data } = useSWR(swrKey, fetcher, {
dedupingInterval: 0,
suspense: true
})
return <>data:{data}</>
}
function Page() {
const [isPending, startTransition] = React.useTransition()
const [key, setKey] = React.useState(initialKey)
return (
<div onClick={() => startTransition(() => setKey(newKey))}>
isPending:{isPending ? 1 : 0},
<React.Suspense fallback="loading">
<Component swrKey={key} />
</React.Suspense>
</div>
)
}
renderWithConfig(<Page />)
screen.getByText('isPending:0,loading')
await act(() => sleep(120))
screen.getByText(`isPending:0,data:${initialKey}`)
fireEvent.click(screen.getByText(`isPending:0,data:${initialKey}`))
await act(() => sleep(10))
// Pending state
screen.getByText(`isPending:1,data:${initialKey}`)
// Transition end
await act(() => sleep(120))
screen.getByText(`isPending:0,data:${newKey}`)
})
// https://codesandbox.io/s/concurrent-swr-case-ii-lr6x4u
it.skip('should do state updates in transitions', async () => {
const key1 = createKey()
const key2 = createKey()
const log = []
function Counter() {
const [count, setCount] = React.useState(0)
React.useEffect(() => {
const interval = setInterval(() => {
setCount(x => x + 1)
}, 20)
return () => clearInterval(interval)
}, [])
log.push(count)
return <>{count}</>
}
function Body() {
useSWR(key2, () => createResponse(true, { delay: 1000 }), {
revalidateOnFocus: false,
revalidateOnReconnect: false,
dedupingInterval: 0,
suspense: true
})
return null
}
function Page() {
const { data } = useSWR(key1, () => createResponse(true, { delay: 50 }), {
revalidateOnFocus: false,
revalidateOnReconnect: false,
dedupingInterval: 0
})
return (
<>
<Counter />
{data ? <Body /> : null}
</>
)
}
await executeWithoutBatching(async () => {
renderWithConfig(<Page />)
await sleep(500)
})
})
})
|
305 | 0 | petrpan-code/vercel/swr | petrpan-code/vercel/swr/test/use-swr-config-callbacks.test.tsx | import { act, screen, fireEvent } from '@testing-library/react'
import useSWR from 'swr'
import { sleep, createResponse, renderWithConfig, createKey } from './utils'
describe('useSWR - config callbacks', () => {
it('should trigger the onSuccess event with the latest version of the onSuccess callback', async () => {
let state = null
let count = 0
const key = createKey()
function Page(props: { text: string }) {
const { data, mutate } = useSWR(key, () => createResponse(count++), {
onSuccess: () => (state = props.text)
})
return (
<div onClick={() => mutate()}>
hello, {data}, {props.text}
</div>
)
}
const { rerender } = renderWithConfig(<Page text={'a'} />)
// the onSuccess callback does not trigger yet, the state is still null.
screen.getByText('hello, , a')
expect(state).toEqual(null)
await screen.findByText('hello, 0, a')
expect(state).toEqual('a')
// props changed, but the onSuccess callback does not trigger yet, `state` is same as before
rerender(<Page text={'b'} />)
screen.getByText('hello, 0, b')
expect(state).toEqual('a')
// trigger revalidation, this would re-trigger the onSuccess callback
fireEvent.click(screen.getByText(/hello/))
await screen.findByText('hello, 1, b')
// the onSuccess callback should capture the latest `props.text`
expect(state).toEqual('b')
})
it('should trigger the onError event with the latest version of the onError callback', async () => {
let state = null
let count = 0
const key = createKey()
function Page(props: { text: string }) {
const { data, mutate, error } = useSWR(
key,
() => createResponse(new Error(`Error: ${count++}`)),
{ onError: () => (state = props.text) }
)
if (error)
return (
<div title={props.text} onClick={() => mutate()}>
{error.message}
</div>
)
return (
<div onClick={() => mutate()}>
<>
hello, {data}, {props.text}
</>
</div>
)
}
const { rerender } = renderWithConfig(<Page text="a" />)
screen.getByText('hello, , a')
expect(state).toEqual(null)
await screen.findByText('Error: 0')
expect(state).toEqual('a')
// props changed, but the onError callback does not trigger yet.
rerender(<Page text="b" />)
screen.getByText('Error: 0')
screen.getByTitle('b')
expect(state).toEqual('a')
fireEvent.click(screen.getByTitle('b'))
await screen.findByText('Error: 1')
screen.getByTitle('b')
expect(state).toEqual('b')
})
it('should trigger the onErrorRetry event with the latest version of the onErrorRetry callback', async () => {
let state = null
let count = 0
const key = createKey()
function Page(props: { text: string }) {
const { data, error } = useSWR(
key,
() => createResponse(new Error(`Error: ${count++}`)),
{
onErrorRetry: (_, __, ___, revalidate, revalidateOpts) => {
state = props.text
revalidate(revalidateOpts)
}
}
)
if (error) return <div title={props.text}>{error.message}</div>
return (
<div>
<>
hello, {data}, {props.text}
</>
</div>
)
}
const { rerender } = renderWithConfig(<Page text="a" />)
screen.getByText('hello, , a')
expect(state).toEqual(null)
await screen.findByText('Error: 0')
screen.getByTitle('a')
expect(state).toEqual('a')
// since the onErrorRetry schedule a timer to trigger revalidation, and update props.text now
rerender(<Page text="b" />)
// not revalidated yet.
screen.getByText('Error: 0')
screen.getByTitle('b')
expect(state).toEqual('a')
// revalidate
await screen.findByText('Error: 1')
screen.getByTitle('b')
expect(state).toEqual('b')
})
it('should trigger the onLoadingSlow and onSuccess event with the lastest version of the callbacks', async () => {
const LOADING_TIMEOUT = 100
let state = null
let count = 0
const key = createKey()
function Page(props: { text: string }) {
const { data } = useSWR(
key,
() => createResponse(count++, { delay: LOADING_TIMEOUT * 2 }),
{
onLoadingSlow: () => {
state = props.text
},
onSuccess: () => {
state = props.text
},
loadingTimeout: LOADING_TIMEOUT
}
)
return (
<div>
hello, {data}, {props.text}
</div>
)
}
const { rerender } = renderWithConfig(<Page text="a" />)
screen.getByText('hello, , a')
expect(state).toEqual(null)
// should trigger a loading slow event
await act(() => sleep(LOADING_TIMEOUT * 1.5))
screen.getByText('hello, , a')
expect(state).toEqual('a')
// onSuccess callback should be called with the latest prop value
rerender(<Page text="b" />)
await screen.findByText('hello, 0, b')
expect(state).toEqual('b')
})
it('should trigger the onDiscarded callback when having a race condition with mutate', async () => {
const key = createKey()
const discardedEvents = []
function Page() {
const { mutate } = useSWR(
key,
() => createResponse('foo', { delay: 50 }),
{
onDiscarded: k => {
discardedEvents.push(k)
}
}
)
return <div onClick={() => mutate('bar')}>mutate</div>
}
renderWithConfig(<Page />)
screen.getByText('mutate')
await act(() => sleep(10))
fireEvent.click(screen.getByText('mutate'))
await act(() => sleep(80))
// Should have one event recorded.
expect(discardedEvents).toEqual([key])
})
it('should not trigger the onSuccess callback when discarded', async () => {
const key = createKey()
const discardedEvents = []
const successEvents = []
function Page() {
const { mutate } = useSWR(
key,
() => createResponse('foo', { delay: 50 }),
{
onDiscarded: k => {
discardedEvents.push(k)
},
onSuccess: d => {
successEvents.push(d)
}
}
)
return <div onClick={() => mutate('bar', false)}>mutate</div>
}
renderWithConfig(<Page />)
screen.getByText('mutate')
await act(() => sleep(10))
fireEvent.click(screen.getByText('mutate'))
await act(() => sleep(80))
// Should have one event recorded.
expect(discardedEvents).toEqual([key])
expect(successEvents).toEqual([])
})
})
|
306 | 0 | petrpan-code/vercel/swr | petrpan-code/vercel/swr/test/use-swr-config.test.tsx | import { act, screen, fireEvent } from '@testing-library/react'
import { useEffect, useState } from 'react'
import type { Middleware } from 'swr'
import useSWR, { SWRConfig, useSWRConfig } from 'swr'
import { renderWithConfig, createKey, renderWithGlobalCache } from './utils'
describe('useSWR - configs', () => {
it('should read the config fallback from the context', async () => {
let value = 0
const INTERVAL = 100
const fetcher = () => value++
const key = createKey()
function Page() {
const { data } = useSWR(key)
return <div>data: {data}</div>
}
renderWithConfig(<Page />, {
fetcher,
refreshInterval: INTERVAL,
dedupingInterval: 0
})
// hydration
screen.getByText('data:')
// mount
await screen.findByText('data: 0')
// wait for the refresh interval
await screen.findByText('data: 1')
})
it('should stop revalidations when config.isPaused returns true', async () => {
const key = createKey()
let value = 0
const fetcher = () => {
if (value === 2) throw new Error()
return value++
}
let mutate
function Page() {
const [paused, setPaused] = useState(false)
const {
data,
error,
mutate: _mutate
} = useSWR(key, fetcher, {
revalidateOnMount: true,
refreshInterval: 1,
isPaused() {
return paused
}
})
mutate = _mutate
useEffect(() => {
// revalidate on the mount and turn to idle
setPaused(true)
}, [])
return (
<div onClick={() => setPaused(!paused)}>
{error ? error : `data: ${data}`}
</div>
)
}
renderWithConfig(<Page />)
await screen.findByText('data: 0')
// should not be revalidated
await act(() => mutate())
screen.getByText('data: 0')
await act(() => mutate())
screen.getByText('data: 0')
// enable isPaused
fireEvent.click(screen.getByText('data: 0'))
// should be revalidated
await act(() => mutate())
screen.getByText('data: 1')
// disable isPaused
fireEvent.click(screen.getByText('data: 1'))
// should not be revalidated
await act(() => mutate())
screen.getByText('data: 1')
await act(() => mutate())
screen.getByText('data: 1')
})
it('should expose default config as static property on SWRConfig', () => {
expect(SWRConfig.defaultValue).toBeDefined()
})
it('should expose the default config from useSWRConfig', () => {
let config
function Page() {
config = useSWRConfig()
return null
}
renderWithGlobalCache(<Page />)
expect(SWRConfig.defaultValue).toEqual(config)
})
it('should expose the correctly extended config from useSWRConfig', () => {
let config
function Page() {
config = useSWRConfig()
return null
}
const middleware1: Middleware = useSWRNext => (k, f, c) =>
useSWRNext(k, f, c)
const middleware2: Middleware = useSWRNext => (k, f, c) =>
useSWRNext(k, f, c)
renderWithConfig(
<SWRConfig
value={{
dedupingInterval: 1,
refreshInterval: 1,
fallback: { a: 1, b: 1 },
use: [middleware1]
}}
>
<SWRConfig
value={{
dedupingInterval: 2,
fallback: { a: 2, c: 2 },
use: [middleware2]
}}
>
<Page />
</SWRConfig>
</SWRConfig>
)
expect(config.dedupingInterval).toEqual(2)
expect(config.refreshInterval).toEqual(1)
expect(config.fallback).toEqual({ a: 2, b: 1, c: 2 })
expect(config.use).toEqual([middleware1, middleware2])
})
it('should ignore parent config when value is functional', async () => {
let config
function Page() {
config = useSWRConfig()
return null
}
const middleware1: Middleware = useSWRNext => (k, f, c) =>
useSWRNext(k, f, c)
const middleware2: Middleware = useSWRNext => (k, f, c) =>
useSWRNext(k, f, c)
renderWithConfig(
<SWRConfig
value={{
dedupingInterval: 1,
refreshInterval: 1,
fallback: { a: 1, b: 1 },
use: [middleware1]
}}
>
<SWRConfig
value={parentConfig => ({
dedupingInterval: 2 + parentConfig.dedupingInterval,
fallback: { a: 2, c: 2 },
use: [middleware2]
})}
>
<Page />
</SWRConfig>
</SWRConfig>
)
expect(config.dedupingInterval).toEqual(3)
expect(config.refreshInterval).toEqual(undefined)
expect(config.fallback).toEqual({ a: 2, c: 2 })
expect(config.use).toEqual([middleware2])
})
})
|
307 | 0 | petrpan-code/vercel/swr | petrpan-code/vercel/swr/test/use-swr-context-config.test.tsx | import { act, screen } from '@testing-library/react'
import useSWR, { mutate } from 'swr'
import { createKey, createResponse, renderWithGlobalCache } from './utils'
describe('useSWR - context configs', () => {
it('mutate before mount should not block rerender', async () => {
const prefetch = () => createResponse('prefetch-data')
const fetcher = () => createResponse('data')
const key = createKey()
await act(async () => {
await mutate(key, prefetch)
})
function Page() {
const { data } = useSWR(key, fetcher)
return <div>{data}</div>
}
renderWithGlobalCache(<Page />)
// render with the prefetched data
screen.getByText('prefetch-data')
// render the fetched data
await screen.findByText('data')
})
})
|
308 | 0 | petrpan-code/vercel/swr | petrpan-code/vercel/swr/test/use-swr-devtools.test.tsx | import { screen } from '@testing-library/react'
import React from 'react'
describe('useSWR - devtools', () => {
let useSWR, createKey, createResponse, renderWithConfig
beforeEach(() => {
const middleware =
useSWRNext =>
(...args) => {
const result = useSWRNext(...args)
return { ...result, data: 'middleware' }
}
// @ts-expect-error
window.__SWR_DEVTOOLS_USE__ = [middleware]
;({ createKey, createResponse, renderWithConfig } = require('./utils'))
useSWR = require('swr').default
})
it('window.__SWR_DEVTOOLS_USE__ should be set as middleware', async () => {
const key = createKey()
function Page() {
const { data } = useSWR(key, () => createResponse('ok'))
return <div>data: {data}</div>
}
renderWithConfig(<Page />)
await screen.findByText('data: middleware')
})
it('window.__SWR_DEVTOOLS_REACT__ should be the same reference with React', () => {
// @ts-expect-error
expect(window.__SWR_DEVTOOLS_REACT__).toBe(React)
})
})
|
309 | 0 | petrpan-code/vercel/swr | petrpan-code/vercel/swr/test/use-swr-error.test.tsx | import { act, fireEvent, screen } from '@testing-library/react'
import { useEffect, useState } from 'react'
import useSWR from 'swr'
import {
sleep,
createResponse,
createKey,
renderWithConfig,
mockVisibilityHidden
} from './utils'
describe('useSWR - error', () => {
it('should handle errors', async () => {
const key = createKey()
function Page() {
const { data, error } = useSWR(key, () =>
createResponse(new Error('error!'))
)
if (error) return <div>{error.message}</div>
return (
<div>
<>hello, {data}</>
</div>
)
}
renderWithConfig(<Page />)
screen.getByText('hello,')
// mount
await screen.findByText('error!')
})
it('should trigger the onError event', async () => {
const key = createKey()
let erroredSWR = null
function Page() {
const { data, error } = useSWR(
key,
() => createResponse(new Error('error!')),
{ onError: (_, errorKey) => (erroredSWR = errorKey) }
)
if (error) return <div>{error.message}</div>
return (
<div>
<>hello, {data}</>
</div>
)
}
renderWithConfig(<Page />)
screen.getByText('hello,')
// mount
await screen.findByText('error!')
expect(erroredSWR).toEqual(key)
})
it('should trigger error retry', async () => {
const key = createKey()
let count = 0
function Page() {
const { data, error } = useSWR(
key,
() => createResponse(new Error('error: ' + count++), { delay: 100 }),
{
onErrorRetry: (_, __, ___, revalidate, revalidateOpts) => {
setTimeout(() => revalidate(revalidateOpts), 50)
},
dedupingInterval: 0
}
)
if (error) return <div>{error.message}</div>
return (
<div>
<>hello, {data}</>
</div>
)
}
renderWithConfig(<Page />)
screen.getByText('hello,')
// mount
await screen.findByText('error: 0')
await act(() => sleep(200)) // retry
screen.getByText('error: 1')
await act(() => sleep(200)) // retry
screen.getByText('error: 2')
})
it('should stop retrying when document is not visible', async () => {
const key = createKey()
let count = 0
function Page() {
const { data, error } = useSWR(
key,
() => createResponse(new Error('error: ' + count++), { delay: 100 }),
{
onErrorRetry: (_, __, ___, revalidate, revalidateOpts) => {
revalidate(revalidateOpts)
},
dedupingInterval: 0
}
)
if (error) return <div>{error.message}</div>
return (
<div>
<>hello, {data}</>
</div>
)
}
renderWithConfig(<Page />)
screen.getByText('hello,')
// mount
await screen.findByText('error: 0')
// errored, retrying
await act(() => sleep(50))
const resetVisibility = mockVisibilityHidden()
await act(() => sleep(100))
screen.getByText('error: 1')
await act(() => sleep(100)) // stopped due to invisible
screen.getByText('error: 1')
resetVisibility()
})
it('should not retry when shouldRetryOnError is disabled', async () => {
const key = createKey()
let count = 0
function Page() {
const { data, error } = useSWR(
key,
() => createResponse(new Error('error: ' + count++), { delay: 100 }),
{
onErrorRetry: (_, __, ___, revalidate, revalidateOpts) => {
revalidate(revalidateOpts)
},
dedupingInterval: 0,
shouldRetryOnError: false
}
)
if (error) return <div>{error.message}</div>
return (
<div>
<>hello, {data}</>
</div>
)
}
renderWithConfig(<Page />)
screen.getByText('hello,')
// mount
await screen.findByText('error: 0')
await act(() => sleep(150))
screen.getByText('error: 0')
})
it('should not retry when shouldRetryOnError function returns false', async () => {
const key = createKey()
let count = 0
function Page() {
const { data, error } = useSWR(
key,
() => createResponse(new Error('error: ' + count++), { delay: 100 }),
{
onErrorRetry: (_, __, ___, revalidate, revalidateOpts) => {
revalidate(revalidateOpts)
},
dedupingInterval: 0,
shouldRetryOnError: () => false
}
)
if (error) return <div>{error.message}</div>
return (
<div>
<>hello, {data}</>
</div>
)
}
renderWithConfig(<Page />)
screen.getByText('hello,')
// mount
await screen.findByText('error: 0')
await act(() => sleep(150))
screen.getByText('error: 0')
})
it('should retry when shouldRetryOnError function returns true', async () => {
const key = createKey()
let count = 0
function Page() {
const { data, error } = useSWR(
key,
() => createResponse(new Error('error: ' + count++), { delay: 100 }),
{
onErrorRetry: (_, __, ___, revalidate, revalidateOpts) => {
revalidate(revalidateOpts)
},
dedupingInterval: 0,
shouldRetryOnError: () => true
}
)
if (error) return <div>{error.message}</div>
return (
<div>
<>hello, {data}</>
</div>
)
}
renderWithConfig(<Page />)
screen.getByText('hello,')
// mount
await screen.findByText('error: 0')
await act(() => sleep(150))
screen.getByText('error: 1')
})
it('should trigger the onLoadingSlow and onSuccess event', async () => {
const key = createKey()
let loadingSlow = null,
success = null
function Page() {
const { data } = useSWR(
key,
() => createResponse('SWR', { delay: 200 }),
{
onLoadingSlow: loadingKey => (loadingSlow = loadingKey),
onSuccess: (_, successKey) => (success = successKey),
loadingTimeout: 100
}
)
return <div>hello, {data}</div>
}
renderWithConfig(<Page />)
screen.getByText('hello,')
expect(loadingSlow).toEqual(null)
await act(() => sleep(150)) // trigger onLoadingSlow event
expect(loadingSlow).toEqual(key)
expect(success).toEqual(null)
await act(() => sleep(150)) // finish the request
expect(success).toEqual(key)
screen.getByText('hello, SWR')
})
it('should trigger limited error retries if errorRetryCount exists', async () => {
const key = createKey()
let count = 0
function Page() {
const { data, error } = useSWR(
key,
() => createResponse(new Error('error: ' + count++)),
{
errorRetryCount: 1,
errorRetryInterval: 50,
dedupingInterval: 0
}
)
if (error) return <div>{error.message}</div>
return (
<div>
<>hello, {data}</>
</div>
)
}
renderWithConfig(<Page />)
screen.getByText('hello,')
// mount
await screen.findByText('error: 0')
await screen.findByText('error: 1') // retry
await act(() => sleep(200)) // a retry request won't happen because retryCount is over
screen.getByText('error: 1')
})
it.skip('should not trigger the onLoadingSlow and onSuccess event after component unmount', async () => {
const key = createKey()
let loadingSlow = null,
success = null
function Page() {
const { data } = useSWR(key, () => createResponse('SWR'), {
onLoadingSlow: loadingKey => {
loadingSlow = loadingKey
},
onSuccess: (_, successKey) => {
success = successKey
},
loadingTimeout: 100
})
return <div>hello, {data}</div>
}
function App() {
const [on, toggle] = useState(true)
return (
<div id="app" onClick={() => toggle(s => !s)}>
{on && <Page />}
</div>
)
}
renderWithConfig(<App />)
screen.getByText('hello,')
expect(loadingSlow).toEqual(null)
expect(success).toEqual(null)
fireEvent.click(screen.getByText('hello,'))
await act(() => sleep(200))
expect(success).toEqual(null)
expect(loadingSlow).toEqual(null)
})
it.skip('should not trigger the onError and onErrorRetry event after component unmount', async () => {
const key = createKey()
let retry = null,
failed = null
function Page() {
const { data } = useSWR(key, () => createResponse(new Error('error!')), {
onError: (_, errorKey) => {
failed = errorKey
},
onErrorRetry: (_, errorKey) => {
retry = errorKey
},
dedupingInterval: 0
})
return (
<div>
<>hello, {data}</>
</div>
)
}
function App() {
const [on, toggle] = useState(true)
return (
<div id="app" onClick={() => toggle(s => !s)}>
{on && <Page />}
</div>
)
}
renderWithConfig(<App />)
screen.getByText('hello,')
expect(retry).toEqual(null)
expect(failed).toEqual(null)
fireEvent.click(screen.getByText('hello,'))
await act(() => sleep(200))
expect(retry).toEqual(null)
expect(failed).toEqual(null)
})
it('should not trigger error retries if errorRetryCount is set to 0', async () => {
const key = createKey()
let count = 0
function Page() {
const { data, error } = useSWR(
key,
() => createResponse(new Error('error: ' + count++)),
{
errorRetryCount: 0,
errorRetryInterval: 50,
dedupingInterval: 0
}
)
if (error) return <div>{error.message}</div>
return (
<div>
<>hello, {data}</>
</div>
)
}
renderWithConfig(<Page />)
screen.getByText('hello,')
// mount
await screen.findByText('error: 0')
await act(() => sleep(210)) // retry is never happen
screen.getByText('error: 0')
})
it('should not clear error during revalidating until fetcher is finished successfully', async () => {
const errors = []
const key = createKey()
let mutate
function Page() {
const { error, mutate: _mutate } = useSWR(
key,
() => createResponse(new Error('error')),
{
errorRetryCount: 0,
errorRetryInterval: 0,
dedupingInterval: 0
}
)
mutate = _mutate
useEffect(() => {
errors.push(error ? error.message : null)
}, [error])
return <div>hello, {error ? error.message : null}</div>
}
renderWithConfig(<Page />)
// mount
await screen.findByText('hello, error')
await act(() => mutate())
// initial -> first error -> mutate -> receive another error
// the error won't be cleared during revalidation
expect(errors).toEqual([null, 'error', 'error'])
})
it('should reset isValidating when an error occured synchronously', async () => {
const key = createKey()
function Page() {
const { error, isValidating } = useSWR(key, () => {
throw new Error('error!')
})
if (error)
return (
<div>
{error.message},{isValidating.toString()}
</div>
)
return <div>hello,{isValidating.toString()}</div>
}
renderWithConfig(<Page />)
screen.getByText('error!,false')
})
it('should reset isValidating when an error occured asynchronously', async () => {
const key = createKey()
function Page() {
const { error, isValidating } = useSWR(key, () =>
createResponse(new Error('error!'))
)
if (error)
return (
<div>
{error.message},{isValidating.toString()}
</div>
)
return <div>hello,{isValidating.toString()}</div>
}
renderWithConfig(<Page />)
screen.getByText('hello,true')
await screen.findByText('error!,false')
})
it('should dedupe onError events', async () => {
const key = createKey()
const errorEvents = []
function Foo() {
useSWR(key, () => createResponse(new Error('error!'), { delay: 20 }), {
onError: e => errorEvents.push(e)
})
return null
}
function Page() {
return (
<>
<Foo />
<Foo />
</>
)
}
renderWithConfig(<Page />)
await act(() => sleep(30))
// Since there's only 1 request fired, only 1 error event should be reported.
expect(errorEvents.length).toBe(1)
})
it('should not trigger revalidation when a key is already active and has error - isLoading', async () => {
const key = createKey()
const useData = () => {
return useSWR<any, any>(key, () =>
createResponse(new Error('error!'), { delay: 200 })
)
}
const Page = () => {
useData()
return null
}
const App = () => {
const { error, isLoading } = useData()
if (isLoading) return <span>loading</span>
return (
<div>
{error ? error.message : ''},{isLoading.toString()}
<Page />
</div>
)
}
renderWithConfig(<App />)
screen.getByText('loading')
await screen.findByText('error!,false')
})
it('should not trigger revalidation when a key is already active and has error - isValidating', async () => {
const key = createKey()
const useData = () => {
return useSWR<any, any>(key, () =>
createResponse(new Error('error!'), { delay: 200 })
)
}
const Page = () => {
useData()
return null
}
const App = () => {
const { error, isValidating } = useData()
if (isValidating) return <span>validating</span>
return (
<div>
{error ? error.message : ''},{isValidating.toString()}
<Page />
</div>
)
}
renderWithConfig(<App />)
screen.getByText('validating')
await screen.findByText('error!,false')
})
it('should trigger revalidation when first hook is unmount', async () => {
const key = createKey()
const fn = jest.fn()
const useData = () => {
return useSWR<any, any>(
key,
() => createResponse(new Error('error!'), { delay: 200 }),
{
onErrorRetry: (_, __, ___, revalidate, opts) => {
setTimeout(() => {
fn()
revalidate(opts)
}, 100)
},
dedupingInterval: 1
}
)
}
const First = () => {
useData()
const [state, setState] = useState(true)
return (
<>
<button onClick={() => setState(!state)}>toggle</button>
{state ? <Second></Second> : null}
</>
)
}
const Second = () => {
useData()
return null
}
const App = () => {
return (
<div>
<First></First>
<Second />
</div>
)
}
renderWithConfig(<App />)
await act(() => sleep(320))
expect(fn).toBeCalledTimes(1)
fireEvent.click(screen.getByText('toggle'))
await act(() => sleep(320))
expect(fn).toBeCalledTimes(2)
await act(() => sleep(320))
expect(fn).toBeCalledTimes(3)
})
})
|
310 | 0 | petrpan-code/vercel/swr | petrpan-code/vercel/swr/test/use-swr-fetcher.test.tsx | import { act, fireEvent, screen } from '@testing-library/react'
import { Suspense, useState } from 'react'
import useSWR from 'swr'
import { createKey, renderWithConfig, nextTick } from './utils'
describe('useSWR - fetcher', () => {
// https://github.com/vercel/swr/issues/1131
it('should use the latest fetcher reference', async () => {
const key = createKey()
let fetcher = () => 'foo'
let mutate
let rerender
function Page() {
const { data, mutate: boundMutate } = useSWR(key, fetcher)
rerender = useState({})[1]
mutate = boundMutate
return <div>data:{data}</div>
}
renderWithConfig(<Page />)
await nextTick()
screen.getByText('data:foo')
// Change the fetcher and make sure the ref is updated.
fetcher = () => 'bar'
act(() => rerender({}))
// Revalidate.
await act(() => mutate())
// Should fetch with the new fetcher.
await screen.findByText('data:bar')
})
it('should use the latest fetcher reference when the key has been changed', async () => {
const key = createKey()
let fetcher = () => 'foo'
function Page() {
const [prefix, setPrefix] = useState('a')
const { data } = useSWR(prefix + key, fetcher)
return (
<div>
<p>data:{data}</p>
<button
onClick={() => {
setPrefix('b')
}}
>
mutate
</button>
</div>
)
}
renderWithConfig(<Page />)
await screen.findByText('data:foo')
// Change the fetcher and make sure the ref is updated.
fetcher = () => 'bar'
fireEvent.click(screen.getByText('mutate'))
// Should fetch with the new fetcher.
await screen.findByText('data:bar')
})
it('should use the latest fetcher reference with the suspense mode when the key has been changed', async () => {
const key = createKey()
let fetcher = () => 'foo'
function Page() {
const [prefix, setPrefix] = useState('a')
const { data } = useSWR(prefix + key, fetcher, { suspense: true })
return (
<div>
<p>data:{data}</p>
<button
onClick={() => {
setPrefix('b')
}}
>
mutate
</button>
</div>
)
}
renderWithConfig(
<Suspense fallback="loading">
<Page />
</Suspense>
)
await screen.findByText('data:foo')
// Change the fetcher and make sure the ref is updated.
fetcher = () => 'bar'
fireEvent.click(screen.getByText('mutate'))
// Should fetch with the new fetcher.
await screen.findByText('data:bar')
})
it('should be able to pass falsy values to the fetcher', () => {
const key = createKey()
function Page({ fetcher }) {
const { data } = useSWR(key, fetcher)
return (
<div>
<p>data:{data}</p>
</div>
)
}
const { rerender } = renderWithConfig(<Page fetcher={null} />)
screen.getByText('data:')
rerender(<Page fetcher={undefined} />)
screen.getByText('data:')
rerender(<Page fetcher={false} />)
screen.getByText('data:')
})
})
|
311 | 0 | petrpan-code/vercel/swr | petrpan-code/vercel/swr/test/use-swr-focus.test.tsx | import { act, fireEvent, screen } from '@testing-library/react'
import { useState } from 'react'
import useSWR from 'swr'
import {
sleep,
nextTick as waitForNextTick,
focusOn,
renderWithConfig,
createKey
} from './utils'
const focusWindow = () => focusOn(window)
describe('useSWR - focus', () => {
it('should revalidate on focus by default', async () => {
let value = 0
const key = createKey()
function Page() {
const { data } = useSWR(key, () => value++, {
dedupingInterval: 0
})
return <div>data: {data}</div>
}
renderWithConfig(<Page />)
// hydration
screen.getByText('data:')
// mount
await screen.findByText('data: 0')
await waitForNextTick()
// trigger revalidation
await focusWindow()
await screen.findByText('data: 1')
})
it("shouldn't revalidate on focus when revalidateOnFocus is false", async () => {
let value = 0
const key = createKey()
function Page() {
const { data } = useSWR(key, () => value++, {
dedupingInterval: 0,
revalidateOnFocus: false
})
return <div>data: {data}</div>
}
renderWithConfig(<Page />)
// hydration
screen.getByText('data:')
// mount
await screen.findByText('data: 0')
await waitForNextTick()
// trigger revalidation
await focusWindow()
// should not be revalidated
screen.getByText('data: 0')
})
it('revalidateOnFocus should be stateful', async () => {
let value = 0
const key = createKey()
function Page() {
const [revalidateOnFocus, toggle] = useState(false)
const { data } = useSWR(key, () => value++, {
dedupingInterval: 0,
revalidateOnFocus,
focusThrottleInterval: 0
})
return <div onClick={() => toggle(s => !s)}>data: {data}</div>
}
renderWithConfig(<Page />)
// hydration
screen.getByText('data:')
// mount
await screen.findByText('data: 0')
await waitForNextTick()
// trigger revalidation
await focusWindow()
// data should not change
screen.getByText('data: 0')
// change revalidateOnFocus to true
fireEvent.click(screen.getByText('data: 0'))
// trigger revalidation
await focusWindow()
// data should update
await screen.findByText('data: 1')
await waitForNextTick()
// trigger revalidation
await focusWindow()
// data should update
await screen.findByText('data: 2')
await waitForNextTick()
// change revalidateOnFocus to false
fireEvent.click(screen.getByText('data: 2'))
// trigger revalidation
await focusWindow()
// data should not change
screen.getByText('data: 2')
})
it('focusThrottleInterval should work', async () => {
let value = 0
const key = createKey()
function Page() {
const { data } = useSWR(key, () => value++, {
dedupingInterval: 0,
revalidateOnFocus: true,
focusThrottleInterval: 50
})
return <div>data: {data}</div>
}
renderWithConfig(<Page />)
// hydration
screen.getByText('data:')
// mount
await screen.findByText('data: 0')
await waitForNextTick()
// trigger revalidation
await focusWindow()
// still in throttling interval
await act(() => sleep(20))
// should be throttled
await focusWindow()
await screen.findByText('data: 1')
// wait for focusThrottleInterval
await act(() => sleep(100))
// trigger revalidation again
await focusWindow()
await screen.findByText('data: 2')
})
it('focusThrottleInterval should be stateful', async () => {
let value = 0
const key = createKey()
function Page() {
const [focusThrottleInterval, setInterval] = useState(50)
const { data } = useSWR(key, () => value++, {
dedupingInterval: 0,
revalidateOnFocus: true,
focusThrottleInterval
})
return <div onClick={() => setInterval(s => s + 100)}>data: {data}</div>
}
renderWithConfig(<Page />)
// hydration
screen.getByText('data:')
// mount
await screen.findByText('data: 0')
await waitForNextTick()
// trigger revalidation
await focusWindow()
// wait for throttle interval
await act(() => sleep(100))
// trigger revalidation
await focusWindow()
await screen.findByText('data: 2')
await waitForNextTick()
// increase focusThrottleInterval
fireEvent.click(screen.getByText('data: 2'))
// wait for throttle interval
await act(() => sleep(100))
// trigger revalidation
await focusWindow()
// wait for throttle interval
await act(() => sleep(100))
// should be throttled
await focusWindow()
await screen.findByText('data: 3')
// wait for throttle interval
await act(() => sleep(150))
// trigger revalidation
await focusWindow()
// wait for throttle intervals
await act(() => sleep(150))
await screen.findByText('data: 4')
})
it('should revalidate on focus even with custom cache', async () => {
let value = 0
const key = createKey()
function Page() {
const { data } = useSWR(key, () => value++, {
revalidateOnFocus: true,
dedupingInterval: 0
})
return <div>data: {data}</div>
}
renderWithConfig(<Page />)
screen.getByText('data:')
await screen.findByText('data: 0')
await waitForNextTick()
await focusWindow()
await screen.findByText('data: 1')
})
it('should not revalidate on focus when key changes in the same tick', async () => {
const fetchLogs = []
function Page() {
const [key, setKey] = useState(() => createKey())
useSWR(key, k => fetchLogs.push(k), {
revalidateOnFocus: true,
dedupingInterval: 0
})
return <div onClick={() => setKey(createKey())}>change key</div>
}
renderWithConfig(<Page />)
await waitForNextTick()
fireEvent.focus(window)
fireEvent.click(screen.getByText('change key'))
await waitForNextTick()
// Only fetched twice with the initial and the new keys.
expect(fetchLogs.length).toBe(2)
expect(fetchLogs[0]).not.toEqual(fetchLogs[1])
})
})
|
312 | 0 | petrpan-code/vercel/swr | petrpan-code/vercel/swr/test/use-swr-immutable.test.tsx | import { screen, act, fireEvent } from '@testing-library/react'
import { useState } from 'react'
import useSWR from 'swr'
import useSWRImmutable from 'swr/immutable'
import {
sleep,
createKey,
nextTick as waitForNextTick,
focusOn,
renderWithConfig
} from './utils'
const focusWindow = () => focusOn(window)
describe('useSWR - immutable', () => {
it('should revalidate on mount', async () => {
let value = 0
const key = createKey()
const useData = () =>
useSWR(key, () => value++, {
dedupingInterval: 0
})
function Component() {
useData()
return null
}
function Page() {
const [showComponent, setShowComponent] = useState(false)
const { data } = useData()
return (
<div>
<button onClick={() => setShowComponent(true)}>
mount component
</button>
<p>data: {data}</p>
{showComponent ? <Component /> : null}
</div>
)
}
renderWithConfig(<Page />)
// hydration
screen.getByText('mount component')
screen.getByText('data:')
// ready
await screen.findByText('data: 0')
// mount <Component/> by clicking the button
fireEvent.click(screen.getByText('mount component'))
// wait for rerender
await screen.findByText('data: 1')
})
it('should not revalidate on mount when `revalidateIfStale` is enabled', async () => {
let value = 0
const key = createKey()
const useData = () =>
useSWR(key, () => value++, {
dedupingInterval: 0,
revalidateIfStale: false
})
function Component() {
useData()
return null
}
function Page() {
const [showComponent, setShowComponent] = useState(false)
const { data } = useData()
return (
<div>
<button onClick={() => setShowComponent(true)}>
mount component
</button>
<p>data: {data}</p>
{showComponent ? <Component /> : null}
</div>
)
}
renderWithConfig(<Page />)
// hydration
screen.getByText('mount component')
screen.getByText('data:')
// ready
await screen.findByText('data: 0')
// mount <Component/> by clicking the button
fireEvent.click(screen.getByText('mount component'))
// wait for rerender
await act(() => sleep(50))
await screen.findByText('data: 0')
})
it('should not revalidate with the immutable hook', async () => {
let value = 0
const key = createKey()
const useData = () =>
useSWRImmutable(key, () => value++, { dedupingInterval: 0 })
function Component() {
useData()
return null
}
function Page() {
const [showComponent, setShowComponent] = useState(false)
const { data } = useData()
return (
<div>
<button onClick={() => setShowComponent(true)}>
mount component
</button>
<p>data: {data}</p>
{showComponent ? <Component /> : null}
</div>
)
}
renderWithConfig(<Page />)
// hydration
screen.getByText('mount component')
screen.getByText('data:')
// ready
await screen.findByText('data: 0')
// mount <Component/> by clicking the button
fireEvent.click(screen.getByText('mount component'))
// trigger window focus
await waitForNextTick()
await focusWindow()
// wait for rerender
await act(() => sleep(50))
await screen.findByText('data: 0')
})
it('should not revalidate with revalidateIfStale disabled when key changes', async () => {
const fetcher = jest.fn(v => v)
const key = createKey()
const useData = (id: string) =>
useSWR(key + id, fetcher, {
dedupingInterval: 0,
revalidateIfStale: false
})
function Page() {
const [id, setId] = useState('0')
const { data } = useData(id)
return (
<button onClick={() => setId(id === '0' ? '1' : '0')}>
data: {data}
</button>
)
}
renderWithConfig(<Page />)
// Ready
await screen.findByText(`data: ${key}0`)
// Toggle the key by clicking the button
fireEvent.click(screen.getByText(`data: ${key}0`))
await screen.findByText(`data: ${key}1`)
await waitForNextTick()
// Toggle the key again by clicking the button
fireEvent.click(screen.getByText(`data: ${key}1`))
await screen.findByText(`data: ${key}0`)
await waitForNextTick()
// Toggle the key by clicking the button
fireEvent.click(screen.getByText(`data: ${key}0`))
await screen.findByText(`data: ${key}1`)
await sleep(20)
// `fetcher` should only be called twice, with each key.
expect(fetcher).toBeCalledTimes(2)
expect(fetcher).nthCalledWith(1, key + '0')
expect(fetcher).nthCalledWith(2, key + '1')
})
})
|
313 | 0 | petrpan-code/vercel/swr | petrpan-code/vercel/swr/test/use-swr-infinite-preload.test.tsx | import { act, fireEvent, screen } from '@testing-library/react'
import { Suspense, useEffect, useState, Profiler } from 'react'
import { preload } from 'swr'
import useSWRInfinite from 'swr/infinite'
import { createKey, createResponse, renderWithConfig, sleep } from './utils'
describe('useSWRInfinite - preload', () => {
const getKeyFunction = (key: string) => (index: number) =>
`page-${index}-${key}`
it('preloading useSWRInfinite should produce the same result', async () => {
const key = createKey()
const getKey = getKeyFunction(key)
const fetcher = jest.fn(() => createResponse('foo'))
function Page() {
const { data } = useSWRInfinite(getKey, fetcher)
return <div>data:{Array.isArray(data) ? 'true' : 'false'}</div>
}
preload(getKey(0), fetcher)
renderWithConfig(<Page />)
await screen.findByText('data:true')
})
it('preload the fetcher function', async () => {
const key = createKey()
const getKey = getKeyFunction(key)
const fetcher = jest.fn(() => createResponse('foo'))
function Page() {
const { data } = useSWRInfinite(getKey, fetcher)
return <div>data:{data}</div>
}
preload(getKey(0), fetcher)
expect(fetcher).toBeCalledTimes(1)
renderWithConfig(<Page />)
await screen.findByText('data:foo')
expect(fetcher).toBeCalledTimes(1)
})
it('should avoid preloading the resource multiple times', async () => {
const key = createKey()
const getKey = getKeyFunction(key)
const fetcher = jest.fn(() => createResponse('foo'))
function Page() {
const { data } = useSWRInfinite(getKey, fetcher)
return <div>data:{data}</div>
}
preload(getKey(0), fetcher)
preload(getKey(0), fetcher)
preload(getKey(0), fetcher)
expect(fetcher).toBeCalledTimes(1)
renderWithConfig(<Page />)
await screen.findByText('data:foo')
expect(fetcher).toBeCalledTimes(1)
})
it('should be able to prealod resources in effects', async () => {
const key = createKey()
const getKey = getKeyFunction(key)
const fetcher = jest.fn(() => createResponse('foo'))
function Comp() {
const { data } = useSWRInfinite(getKey, fetcher)
return <div>data:{data}</div>
}
function Page() {
const [show, setShow] = useState(false)
useEffect(() => {
preload(getKey(0), fetcher)
}, [])
return show ? (
<Comp />
) : (
<button onClick={() => setShow(true)}>click</button>
)
}
renderWithConfig(<Page />)
expect(fetcher).toBeCalledTimes(1)
fireEvent.click(screen.getByText('click'))
await screen.findByText('data:foo')
expect(fetcher).toBeCalledTimes(1)
})
it('preload the fetcher function with the suspense mode', async () => {
const key = createKey()
const getKey = getKeyFunction(key)
const fetcher = jest.fn(() => createResponse('foo'))
const onRender = jest.fn()
function Page() {
const { data } = useSWRInfinite(getKey, fetcher, { suspense: true })
return <div>data:{data}</div>
}
preload(getKey(0), fetcher)
expect(fetcher).toBeCalledTimes(1)
renderWithConfig(
<Suspense
fallback={
<Profiler id={key} onRender={onRender}>
loading
</Profiler>
}
>
<Page />
</Suspense>
)
await screen.findByText('data:foo')
expect(onRender).toBeCalledTimes(1)
expect(fetcher).toBeCalledTimes(1)
})
it('avoid suspense waterfall by prefetching the resources', async () => {
const key1 = createKey()
const getKey1 = getKeyFunction(key1)
const key2 = createKey()
const getKey2 = getKeyFunction(key2)
const response1 = createResponse('foo', { delay: 50 })
const response2 = createResponse('bar', { delay: 50 })
const fetcher1 = () => response1
const fetcher2 = () => response2
function Page() {
const { data: data1 } = useSWRInfinite(getKey1, fetcher1, {
suspense: true
})
const { data: data2 } = useSWRInfinite(getKey2, fetcher2, {
suspense: true
})
return (
<div>
data:{data1}:{data2}
</div>
)
}
preload(getKey1(0), fetcher1)
preload(getKey1(0), fetcher2)
renderWithConfig(
<Suspense fallback="loading">
<Page />
</Suspense>
)
screen.getByText('loading')
// Should avoid waterfall(50ms + 50ms)
await act(() => sleep(80))
screen.getByText('data:foo:bar')
})
it('reset the preload result when the preload function gets an error', async () => {
const key = createKey()
const getKey = getKeyFunction(key)
let count = 0
const fetcher = () => {
++count
const res = count === 1 ? new Error('err') : 'foo'
return createResponse(res)
}
let mutate
function Page() {
const { data, error, ...swr } = useSWRInfinite<any>(getKey, fetcher)
mutate = swr.mutate
if (error) {
return <div>error:{error.message}</div>
}
return <div>data:{data}</div>
}
try {
// error
await preload(getKey(0), fetcher)
} catch (e) {
// noop
}
renderWithConfig(<Page />)
screen.getByText('data:')
// use the preloaded result
await screen.findByText('error:err')
expect(count).toBe(1)
// revalidate
await act(() => mutate(getKey(0)))
// should not use the preload data
await screen.findByText('data:foo')
})
it('dedupe requests during preloading', async () => {
const key = createKey()
const getKey = getKeyFunction(key)
const fetcher = jest.fn(() =>
createResponse('foo', {
delay: 50
})
)
const onRender = jest.fn()
function Page() {
const { data } = useSWRInfinite(getKey, fetcher, { dedupingInterval: 0 })
return (
<Profiler id={key} onRender={onRender}>
data:{data}
</Profiler>
)
}
preload(getKey(0), fetcher)
expect(fetcher).toBeCalledTimes(1)
const { rerender } = renderWithConfig(<Page />)
expect(onRender).toBeCalledTimes(1)
// rerender when the preloading is in-flight, and the deduping interval is over
await act(() => sleep(10))
rerender(<Page />)
expect(onRender).toBeCalledTimes(2)
await screen.findByText('data:foo')
expect(fetcher).toBeCalledTimes(1)
expect(onRender).toBeCalledTimes(3)
})
it('should pass serialize key to fetcher', async () => {
const key = createKey()
const getKey = getKeyFunction(key)
let calledWith: string
const fetcher = (args: string) => {
calledWith = args
}
preload(() => getKey(0), fetcher)
expect(calledWith).toBe(getKey(0))
})
it('should not break parallel option', async () => {
// mock api
const pageData = ['apple', 'banana', 'pineapple']
const key = createKey()
const fetcher = ([_, index]) =>
createResponse(`${pageData[index]}, `, { delay: index === 0 ? 50 : 200 })
function Page() {
const { data } = useSWRInfinite(index => [key, index], fetcher, {
initialSize: 3,
parallel: true
})
return <div>data:{data}</div>
}
preload([key, 0], fetcher)
renderWithConfig(<Page />)
screen.getByText('data:')
// If SWR sends parallel requests, it should only take 200ms
await act(() => sleep(200))
screen.getByText('data:apple, banana, pineapple,')
})
it('should be able to preload multiple page', async () => {
// mock api
const pageData = ['apple', 'banana', 'pineapple']
const key = createKey()
const fetcher = ([_, index]) =>
createResponse(`${pageData[index]}, `, { delay: 50 })
function Page() {
const { data } = useSWRInfinite(index => [key, index], fetcher, {
initialSize: 3,
parallel: true
})
return <div>data:{data}</div>
}
preload([key, 0], fetcher)
preload([key, 1], fetcher)
preload([key, 2], fetcher)
renderWithConfig(<Page />)
screen.getByText('data:')
await act(() => sleep(50))
screen.getByText('data:apple, banana, pineapple,')
})
})
|
314 | 0 | petrpan-code/vercel/swr | petrpan-code/vercel/swr/test/use-swr-infinite.test.tsx | import { Suspense, useEffect, useState } from 'react'
import { fireEvent, act, screen } from '@testing-library/react'
import useSWR, { mutate as globalMutate, useSWRConfig, SWRConfig } from 'swr'
import useSWRInfinite, { unstable_serialize } from 'swr/infinite'
import {
sleep,
createKey,
createResponse,
nextTick,
renderWithConfig,
renderWithGlobalCache,
executeWithoutBatching
} from './utils'
describe('useSWRInfinite', () => {
it('should render the first page component', async () => {
const key = createKey()
function Page() {
const { data, error, isValidating } = useSWRInfinite(
index => `page-${index}-${key}`,
infiniteKey => createResponse(infiniteKey)
)
return (
<div>
<div>data:{data}</div>
<div>isArray:{Array.isArray(data) ? 'true' : 'false'}</div>
<div>error:{error}</div>
<div>isValidating:{isValidating.toString()}</div>
</div>
)
}
renderWithConfig(<Page />)
screen.getByText('data:')
await screen.findByText(`data:page-0-${key}`)
await screen.findByText(`isArray:true`)
await screen.findByText(`error:`)
await screen.findByText(`isValidating:false`)
})
it('should not render anything if getKey throw error and call mutate wont cause error', async () => {
function Page() {
const { data, error, isValidating, mutate } = useSWRInfinite(
() => {
throw new Error('error')
},
infiniteKey => createResponse(infiniteKey)
)
return (
<div>
<div onClick={() => mutate()}>data:{data}</div>
<div>error:{error}</div>
<div>isValidating:{isValidating.toString()}</div>
</div>
)
}
renderWithConfig(<Page />)
screen.getByText('data:')
await screen.findByText(`data:`)
await screen.findByText(`error:`)
await screen.findByText(`isValidating:false`)
fireEvent.click(screen.getByText('data:'))
await screen.findByText(`data:`)
await screen.findByText(`error:`)
await screen.findByText(`isValidating:false`)
})
it('should render the multiple pages', async () => {
const key = createKey()
function Page() {
const { data, size, setSize } = useSWRInfinite(
index => [key, index],
([_, index]) => createResponse(`page ${index}, `)
)
useEffect(() => {
// load next page if the current one is ready
if (size <= 2) setSize(size + 1)
// The setSize function is guaranteed to be referential equal
// eslint-disable-next-line react-hooks/exhaustive-deps
}, [size])
return <div>data:{data}</div>
}
renderWithConfig(<Page />)
screen.getByText('data:')
await screen.findByText('data:page 0, page 1, page 2,')
})
it('should support mutate and initialSize', async () => {
// mock api
const pageData = ['apple', 'banana', 'pineapple']
const key = createKey()
function Page() {
const { data, mutate: boundMutate } = useSWRInfinite(
index => [key, index],
([_, index]) => createResponse(`${pageData[index]}, `),
{
initialSize: 3
}
)
return (
<div
onClick={() => {
// reload the entire list
boundMutate()
}}
>
data:{data}
</div>
)
}
renderWithConfig(<Page />)
screen.getByText('data:')
await screen.findByText('data:apple, banana, pineapple,')
// change the source data to 'watermelon'
pageData[1] = 'watermelon'
// revalidate
fireEvent.click(screen.getByText('data:apple, banana, pineapple,'))
await screen.findByText('data:apple, watermelon, pineapple,')
})
it('should support api cursor', async () => {
// an API that supports the `?offset=` param
async function mockAPIFetcher(url) {
const parse = url.match(/\?offset=(\d+)/)
const offset = parse ? +parse[1] + 1 : 0
const response =
offset <= 3
? [
{
data: 'foo',
id: offset
},
{
data: 'bar',
id: offset + 1
}
]
: []
return createResponse(response)
}
const key = createKey()
function Page() {
const { data } = useSWRInfinite(
(index, previousPageData) => {
// first page
if (index === 0) return `/api/${key}`
// hit the end
if (!previousPageData.length) {
return null
}
// fetch with offset
return `/api/${key}?offset=${
previousPageData[previousPageData.length - 1].id
}`
},
mockAPIFetcher,
{
initialSize: 5
}
)
if (!data) return <div>loading</div>
const hitEnd = data[data.length - 1].length === 0
return (
<div>
{data.map(page => {
return page.map(item => {
return (
<span key={item.id}>
{item.id}: {item.data},{' '}
</span>
)
})
})}
{hitEnd ? 'end.' : ''}
</div>
)
}
renderWithConfig(<Page />)
screen.getByText('loading')
await screen.findByText('0: foo,')
await screen.findByText('1: bar,')
await screen.findByText('2: foo,')
await screen.findByText('3: bar,')
await screen.findByText('end.')
})
it('should skip fetching existing pages when loading more', async () => {
let requests = 0
const key = createKey()
function Page() {
const { data, size, setSize } = useSWRInfinite(
index => [key, index],
([_, index]) => {
requests++
return createResponse(`page ${index}, `)
}
)
return (
<div
onClick={() => {
// load next page
setSize(size + 1)
}}
>
data:{data}
</div>
)
}
renderWithConfig(<Page />)
screen.getByText('data:')
await screen.findByText('data:page 0,') // mounted
expect(requests).toEqual(1)
// load next page
fireEvent.click(screen.getByText('data:page 0,'))
await screen.findByText('data:page 0, page 1,') // mounted
expect(requests).toEqual(3) // revalidate page 0, load page 1
// load next page
fireEvent.click(screen.getByText('data:page 0, page 1,'))
await screen.findByText('data:page 0, page 1, page 2,') // mounted
expect(requests).toEqual(5) // revalidate page 0, load page 2
// load next page
fireEvent.click(screen.getByText('data:page 0, page 1, page 2,'))
await screen.findByText('data:page 0, page 1, page 2, page 3,') // mounted
expect(requests).toEqual(7) // revalidate page 0, load page 3
})
it('should not revalidate page 0 when revalidateFirstPage is false', async () => {
let requests = 0
const key = createKey()
function Page() {
const { data, size, setSize } = useSWRInfinite(
index => [key, index],
([_, index]) => {
requests++
return createResponse(`page ${index}, `)
},
{
revalidateFirstPage: false
}
)
return (
<div
onClick={() => {
// load next page
setSize(size + 1)
}}
>
data:{data}
</div>
)
}
renderWithConfig(<Page />)
screen.getByText('data:')
await screen.findByText('data:page 0,') // mounted
expect(requests).toEqual(1)
// load next page
fireEvent.click(screen.getByText('data:page 0,'))
await screen.findByText('data:page 0, page 1,') // mounted
expect(requests).toEqual(2) // load page 1
// load next page
fireEvent.click(screen.getByText('data:page 0, page 1,'))
await screen.findByText('data:page 0, page 1, page 2,') // mounted
expect(requests).toEqual(3) // load page 2
// load next page
fireEvent.click(screen.getByText('data:page 0, page 1, page 2,'))
await screen.findByText('data:page 0, page 1, page 2, page 3,') // mounted
expect(requests).toEqual(4) // load page 3
})
it('should cache page count', async () => {
let toggle
const key = createKey()
function Page() {
const { data, size, setSize } = useSWRInfinite(
index => [key, index],
([_, index]) => createResponse(`page ${index}, `)
)
return (
<div
onClick={() => {
// load next page
setSize(size + 1)
}}
>
data:{data}
</div>
)
}
function App() {
const [showList, setShowList] = useState(true)
toggle = setShowList
return showList ? <Page /> : <div>yo</div>
}
renderWithConfig(<App />)
screen.getByText('data:')
await screen.findByText('data:page 0,')
// load next page
fireEvent.click(screen.getByText('data:page 0,'))
await screen.findByText('data:page 0, page 1,')
// switch to another component
act(() => toggle(v => !v))
screen.getByText('yo')
// switch back and it should still have 2 pages cached
act(() => toggle(v => !v))
screen.getByText('data:page 0, page 1,')
await act(() => sleep(100))
screen.getByText('data:page 0, page 1,')
})
it('should reset page size when key changes', async () => {
const key = createKey()
function Page() {
const [t, setT] = useState(false)
const {
data,
size: pageSize,
setSize
} = useSWRInfinite(
index => [key, index, t ? 'A' : 'B'],
([_, index]) =>
createResponse(`page ${index}, `, {
delay: 20
}),
{
dedupingInterval: 0
}
)
return (
<>
<button onClick={() => setT(v => !v)}>change key</button>
<button onClick={() => setSize(size => size + 1)}>load next</button>
<div>size: {pageSize}</div>
<div>
key:{t ? 'A' : 'B'} data:{data}
</div>
</>
)
}
renderWithConfig(<Page />)
screen.getByText('key:B data:')
await screen.findByText('key:B data:page 0,')
// load next page
fireEvent.click(screen.getByText('load next'))
await screen.findByText('key:B data:page 0, page 1,')
// switch key, it should have only 1 page
fireEvent.click(screen.getByText('change key'))
await screen.findByText('key:A data:page 0,')
// switch key back, it should have 2 pages
fireEvent.click(screen.getByText('change key'))
await act(() => sleep(40))
await screen.findByText('key:B data:page 0, page 1,')
})
it('should persist page size when key changes', async () => {
let toggle
const key = createKey()
function Page() {
const [t, setT] = useState(false)
const { data, size, setSize } = useSWRInfinite(
index => [key, index, t ? 'A' : 'B'],
async ([_, index]) => createResponse(`page ${index}, `),
{
persistSize: true
}
)
toggle = setT
return (
<div
onClick={() => {
// load next page
setSize(size + 1)
}}
>
data:{data}
</div>
)
}
renderWithConfig(<Page />)
screen.getByText('data:')
await screen.findByText('data:page 0,')
// load next page
fireEvent.click(screen.getByText('data:page 0,'))
await screen.findByText('data:page 0, page 1,')
// switch key, it should still have 2 pages
act(() => toggle(v => !v))
await screen.findByText('data:page 0, page 1,')
})
it('should persist page size when remount', async () => {
let toggle
const key = createKey()
function Comp() {
const { data, size, setSize } = useSWRInfinite(
index => [key, index],
([_, index]) => createResponse(`page ${index}, `)
)
return (
<div
onClick={() => {
// load next page
setSize(size + 1)
}}
>
data:{data}
</div>
)
}
function Page() {
const [show, setShow] = useState(true)
toggle = setShow
return show ? <Comp /> : <div>hide</div>
}
renderWithConfig(<Page />)
screen.getByText('data:')
await screen.findByText('data:page 0,')
// load next page
fireEvent.click(screen.getByText('data:page 0,'))
await screen.findByText('data:page 0, page 1,')
// pages should be unmounted now
act(() => toggle(v => !v))
await screen.findByText('hide')
// remount, it should still have 2 pages
act(() => toggle(v => !v))
await screen.findByText('data:page 0, page 1,')
})
it('should keep `mutate` referential equal', async () => {
const setters = []
const key = createKey()
function Comp() {
const { data, size, setSize } = useSWRInfinite(
index => [key, index],
([_, index]) => createResponse(`page ${index}, `)
)
setters.push(setSize)
return (
<div
onClick={() => {
// load next page
setSize(size + 1)
}}
>
data:{data}
</div>
)
}
renderWithConfig(<Comp />)
screen.getByText('data:')
await screen.findByText('data:page 0,')
// load next page
fireEvent.click(screen.getByText('data:page 0,'))
await screen.findByText('data:page 0, page 1,')
// check all `setSize`s are referential equal.
for (const setSize of setters) {
expect(setSize).toEqual(setters[0])
}
})
it('should share initial cache from `useSWR`', async () => {
const cachedData = new Date().toISOString()
const key = createKey()
globalMutate(`shared-cache-${key}-0`, cachedData)
function Page() {
const { data } = useSWRInfinite<string, string>(
index => `shared-cache-${key}-${index}`,
() => createResponse(cachedData)
)
return <div>data:{data}</div>
}
renderWithGlobalCache(<Page />)
screen.getByText('data:')
// after a rerender, we should already have the cached data rendered
await screen.findByText(`data:${cachedData}`)
})
it('should not break refreshInterval', async () => {
let value = 0
const key = createKey()
function Page() {
const { data } = useSWRInfinite(
index => `interval-${key}-${index}`,
() => value++,
{
dedupingInterval: 0,
refreshInterval: 100
}
)
return <div>data:{data}</div>
}
renderWithConfig(<Page />)
screen.getByText('data:')
// after 300ms the rendered result should be 3
await executeWithoutBatching(() => sleep(350))
screen.getByText('data:3')
})
it('should re-use fallbackData', async () => {
const dummyResponses = {
'/api?page=1': ['page-1-1', 'page-1-2'],
'/api?page=2': ['page-2-1', 'page-2-2']
}
const requests = []
const key = createKey()
function Page() {
const { data, size, setSize } = useSWRInfinite(
index => {
return [key, `/api?page=${index + 1}`]
},
([_, index]) => {
requests.push(index)
return createResponse<string[]>(dummyResponses[index])
},
{
fallbackData: [dummyResponses[`/api?page=1`]]
}
)
return (
<div
onClick={() => {
// load next page
setSize(size + 1)
}}
>
data:{(data ? [].concat(...data) : []).join(', ')}
</div>
)
}
renderWithConfig(<Page />)
// render with the fallbackData
screen.getByText('data:page-1-1, page-1-2')
expect(requests).toEqual([]) // should use the initial data
fireEvent.click(screen.getByText('data:page-1-1, page-1-2'))
// Should this reuse the cached data for `page=1`?
await screen.findByText('data:page-1-1, page-1-2, page-2-1, page-2-2')
expect(requests).toEqual(['/api?page=1', '/api?page=2'])
})
it('should share data between multiple hooks have the same key', async () => {
const key = createKey()
const dummyResponses = {
'/api?page=1': ['page-1-1', 'page-1-2'],
'/api?page=2': ['page-2-1', 'page-2-2']
}
const useCustomSWRInfinite = () => {
const { data, setSize, size } = useSWRInfinite(
index => [key, `/api?page=${index + 1}`],
([_, index]) => createResponse<string[]>(dummyResponses[index])
)
return {
data: data ? [].concat(...data) : [],
setSize,
size
}
}
const Component = (props: { label: string }) => {
const { data, size, setSize } = useCustomSWRInfinite()
return (
<>
<ul>
{data.map(value => (
<li key={value}>
{props.label}:{value}
</li>
))}
</ul>
<button onClick={() => setSize(size + 1)}>{props.label}:click</button>
</>
)
}
function Page() {
return (
<div>
<Component label="A" />
<Component label="B" />
</div>
)
}
renderWithConfig(<Page />)
// render responses for page=1
await screen.findByText('A:page-1-2')
await screen.findByText('B:page-1-2')
fireEvent.click(screen.getByText('A:click'))
// render responses for page=2
await screen.findByText('A:page-2-2')
await screen.findByText('B:page-2-2')
})
it('should support null as getKey', async () => {
function Page() {
const { data, setSize } = useSWRInfinite(null, () => 'data')
return (
<div
onClick={() => {
// load next page
setSize(size => size + 1)
}}
>
data:{data || ''}
</div>
)
}
renderWithConfig(<Page />)
screen.getByText('data:')
await screen.findByText('data:')
// load next page
fireEvent.click(screen.getByText('data:'))
await screen.findByText('data:')
})
it('should support getKey to return null', async () => {
function Page() {
const { data, setSize } = useSWRInfinite(
() => null,
() => 'data'
)
return (
<div
onClick={() => {
// load next page
setSize(size => size + 1)
}}
>
data:{data || ''}
</div>
)
}
renderWithConfig(<Page />)
screen.getByText('data:')
await screen.findByText('data:')
// load next page
fireEvent.click(screen.getByText('data:'))
await screen.findByText('data:')
})
it('should mutate a cache with `unstable_serialize`', async () => {
let count = 0
const key = createKey()
let mutate
function Page() {
mutate = useSWRConfig().mutate
const { data } = useSWRInfinite(
index => `page-test-${key}-${index}`,
infiniteKey => createResponse(`${infiniteKey}:${++count}`)
)
return <div>data:{data}</div>
}
renderWithConfig(<Page />)
screen.getByText('data:')
await screen.findByText(`data:page-test-${key}-0:1`)
await act(() =>
mutate(unstable_serialize(index => `page-test-${key}-${index}`))
)
await screen.findByText(`data:page-test-${key}-0:2`)
await act(() =>
mutate(
unstable_serialize(index => `page-test-${key}-${index}`),
'local-mutation',
false
)
)
await screen.findByText('data:local-mutation')
})
it('should mutate a cache with `unstable_serialize` based on a current data', async () => {
const key = createKey()
const getKey: (index: number) => [string, number] = (index: number) => [
key,
index
]
let mutate
function Comp() {
mutate = useSWRConfig().mutate
const { data, size, setSize } = useSWRInfinite(getKey, ([_, index]) =>
createResponse(`page ${index}, `)
)
useEffect(() => {
setSize(size + 1)
// eslint-disable-next-line react-hooks/exhaustive-deps
}, [])
return <div>data:{data}</div>
}
renderWithConfig(<Comp />)
screen.getByText('data:')
await screen.findByText('data:page 0, page 1,')
await act(() =>
mutate(
unstable_serialize(getKey),
data => data.map(value => `(edited)${value}`),
false
)
)
await screen.findByText('data:(edited)page 0, (edited)page 1,')
})
it('should be able to use `unstable_serialize` with a custom cache', async () => {
const key = createKey()
let mutateCustomCache
function Page() {
mutateCustomCache = useSWRConfig().mutate
const { data } = useSWRInfinite(
() => key,
() => createResponse('response data')
)
return <div>data:{data}</div>
}
function App() {
return (
<SWRConfig
value={{
provider: () => new Map([[key, { data: 'initial-cache' }]])
}}
>
<Page />
</SWRConfig>
)
}
renderWithConfig(<App />)
screen.getByText('data:')
await screen.findByText('data:initial-cache')
await act(() => mutateCustomCache(unstable_serialize(() => key)))
await screen.findByText('data:response data')
await act(() =>
mutateCustomCache(
unstable_serialize(() => key),
'local-mutation',
false
)
)
await screen.findByText('data:local-mutation')
})
it('should correctly set size when key is null', async () => {
const loggedValues = []
function Page() {
const { size, setSize } = useSWRInfinite(
() => null,
() => ''
)
loggedValues.push(size)
return <button onClick={() => setSize(1)}>set size</button>
}
renderWithConfig(<Page />)
await screen.findByText('set size')
fireEvent.click(screen.getByText('set size'))
await nextTick()
expect(loggedValues).toEqual([1])
})
it('setSize should only accept number', async () => {
const key = createKey()
function Comp() {
const { data, size, setSize } = useSWRInfinite(
index => [key, index],
([_, index]) => createResponse(`page ${index}`)
)
return (
<>
<div
onClick={() => {
// load next page
// @ts-expect-error
setSize('2')
}}
>
data:{data}
</div>
<div>size:{size}</div>
</>
)
}
renderWithConfig(<Comp></Comp>)
await screen.findByText('data:page 0')
await screen.findByText('size:1')
fireEvent.click(screen.getByText('data:page 0'))
await screen.findByText('data:page 0')
await screen.findByText('size:1')
})
it('should correctly set size when setSize receives a callback', async () => {
const key = createKey()
function Page() {
const { data, size, setSize } = useSWRInfinite(
index => `${key}-${index}`,
k => createResponse(`page-${k}`)
)
return (
<div>
<p>data: {(data || []).join()}</p>
<p>size: {size}</p>
<button onClick={() => setSize(sz => sz + 1)}>set size</button>
</div>
)
}
const getDataBySize = size =>
Array<string>(size)
.fill('')
.map((_, index) => `page-${key}-${index}`)
.join()
renderWithConfig(<Page />)
await screen.findByText('set size')
const btn = screen.getByText('set size')
fireEvent.click(btn)
await nextTick()
await screen.findByText(`data: ${getDataBySize(2)}`)
await screen.findByText('size: 2')
fireEvent.click(btn)
await nextTick()
await screen.findByText(`data: ${getDataBySize(3)}`)
await screen.findByText('size: 3')
})
it('setSize should return a promise', async () => {
let _setSize
function Comp() {
const { setSize } = useSWRInfinite(
() => null,
() => createResponse('')
)
_setSize = setSize
return null
}
renderWithConfig(<Comp />)
expect(_setSize()).toBeInstanceOf(Promise)
})
// https://github.com/vercel/swr/issues/908
it('should revalidate first page after mutating', async () => {
const key = createKey()
let v = 'old'
function Page() {
const { data, mutate: boundMutate } = useSWRInfinite(
i => [key, i],
() => createResponse(v)
)
return (
<div>
<button
onClick={() => {
v = 'new'
boundMutate([v])
}}
>
mutate
</button>
<p>data:{data}</p>
</div>
)
}
renderWithConfig(<Page />)
await screen.findByText('data:old')
fireEvent.click(screen.getByText('mutate'))
await screen.findByText('data:new')
})
it('should reuse cached value for new pages', async () => {
const key = createKey()
function Page() {
const { data, setSize } = useSWRInfinite(
index => key + '-' + index,
() => createResponse('response value')
)
return (
<div onClick={() => setSize(2)}>data:{data ? data.join(',') : ''}</div>
)
}
renderWithConfig(<Page />, {
provider: () => new Map([[key + '-1', { data: 'cached value' }]])
})
screen.getByText('data:')
await screen.findByText('data:response value')
fireEvent.click(screen.getByText('data:response value'))
await screen.findByText('data:response value,cached value')
})
it('should return cached value ASAP when updating size and revalidate in the background', async () => {
const key = createKey()
const getData = jest.fn(v => v)
function Page() {
const { data, setSize } = useSWRInfinite(
index => key + '-' + index,
() => sleep(30).then(() => getData('response value'))
)
return (
<div onClick={() => setSize(2)}>data:{data ? data.join(',') : ''}</div>
)
}
renderWithConfig(<Page />, {
provider: () => new Map([[key + '-1', { data: 'cached value' }]])
})
screen.getByText('data:')
await screen.findByText('data:response value')
expect(getData).toHaveBeenCalledTimes(1)
fireEvent.click(screen.getByText('data:response value'))
// Returned directly from the cache without blocking
await screen.findByText('data:response value,cached value')
expect(getData).toHaveBeenCalledTimes(1)
// Revalidate
await act(() => sleep(30))
expect(getData).toHaveBeenCalledTimes(2)
})
it('should block on fetching new uncached pages when updating size', async () => {
const key = createKey()
const getData = jest.fn(v => v)
function Page() {
const { data, setSize } = useSWRInfinite(
index => key + '-' + index,
() => sleep(30).then(() => getData('response value'))
)
return (
<div onClick={() => setSize(2)}>data:{data ? data.join(',') : ''}</div>
)
}
renderWithConfig(<Page />)
screen.getByText('data:')
await screen.findByText('data:response value')
expect(getData).toHaveBeenCalledTimes(1)
fireEvent.click(screen.getByText('data:response value'))
// Fetch a new page and revalidate the first page.
await screen.findByText('data:response value,response value')
expect(getData).toHaveBeenCalledTimes(3)
})
it('should return fallbackData if cache is empty', async () => {
const key = createKey()
function Page() {
const { data, setSize } = useSWRInfinite(
index => key + '-' + index,
() => sleep(30).then(() => 'response value'),
{ fallbackData: ['fallback-1', 'fallback-2'] }
)
return (
<div onClick={() => setSize(2)}>data:{data ? data.join(',') : ''}</div>
)
}
renderWithConfig(<Page />)
screen.getByText('data:fallback-1,fallback-2')
// Update size, it should still render the fallback
fireEvent.click(screen.getByText('data:fallback-1,fallback-2'))
await nextTick()
screen.getByText('data:fallback-1,fallback-2')
})
it('should revalidate the resource with bound mutate when no argument is passed', async () => {
let t = 0
const key = createKey()
const fetcher = jest.fn(async () =>
createResponse(`foo-${t++}`, { delay: 10 })
)
const logger = []
function Page() {
const { data, mutate } = useSWRInfinite(() => key, fetcher, {
dedupingInterval: 0
})
logger.push(data)
return (
<>
<div>data: {String(data)}</div>
<button onClick={() => mutate()}>mutate</button>
</>
)
}
renderWithConfig(<Page />)
await screen.findByText('data: foo-0')
fireEvent.click(screen.getByText('mutate'))
await screen.findByText('data: foo-1')
expect(fetcher).toBeCalledTimes(2)
expect(logger).toEqual([undefined, ['foo-0'], ['foo-1']])
})
it('should pass the correct cursor information in `getKey`', async () => {
const key = createKey()
const fetcher = jest.fn(index => createResponse('data-' + index))
const logger = []
function Page() {
const { data } = useSWRInfinite(
(index, previousPageData) => {
logger.push(key + ':' + index + ':' + previousPageData)
return '' + index
},
fetcher,
{
dedupingInterval: 0,
initialSize: 5
}
)
return (
<>
<div>{data ? data.length : 0}</div>
</>
)
}
renderWithConfig(<Page />)
await screen.findByText('5')
expect(
logger.every(log => {
const [k, index, previousData] = log.split(':')
return (
k === key &&
((index === '0' && previousData === 'null') ||
previousData === 'data-' + (index - 1))
)
})
).toBeTruthy()
})
// https://github.com/vercel/swr/issues/1776
it('should update the getKey reference with the suspense mode', async () => {
const keyA = 'keyA' + createKey()
const keyB = 'keyB' + createKey()
const apiData = {
[keyA]: ['A1', 'A2', 'A3'],
[keyB]: ['B1', 'B2', 'B3']
}
function Page() {
const [status, setStatus] = useState('a')
const { data, setSize } = useSWRInfinite(
() => (status === 'a' ? keyA : keyB),
key => createResponse(apiData[key]),
{ suspense: true }
)
return (
<>
<div>data: {String(data)}</div>
<button
onClick={() => {
setStatus('b')
setSize(1)
}}
>
mutate
</button>
</>
)
}
renderWithConfig(
<Suspense fallback="loading">
<Page />
</Suspense>
)
await screen.findByText('data: A1,A2,A3')
fireEvent.click(screen.getByText('mutate'))
await screen.findByText('data: B1,B2,B3')
})
it('should revalidate the resource with bound mutate when arguments are passed', async () => {
const key = createKey()
let counter = 0
function Content() {
const { data } = useSWRInfinite(
() => key,
() => createResponse(++counter),
{
revalidateOnMount: true,
revalidateFirstPage: false,
dedupingInterval: 0
}
)
return <div>data: {String(data)}</div>
}
function Page() {
const [contentKey, setContentKey] = useState('a')
return (
<>
<Content key={contentKey} />
<button
onClick={() => {
setContentKey('b')
}}
>
mutate
</button>
</>
)
}
renderWithConfig(<Page />)
await screen.findByText('data: 1')
fireEvent.click(screen.getByText('mutate'))
await screen.findByText('data: 2')
})
// https://github.com/vercel/swr/issues/1899
it('should revalidate the resource with bound mutate when options is of Object type ', async () => {
let t = 0
const key = createKey()
const fetcher = jest.fn(async () =>
createResponse(`foo-${t++}`, { delay: 10 })
)
const logger = []
function Page() {
const { data, mutate } = useSWRInfinite(() => key, fetcher, {
dedupingInterval: 0
})
logger.push(data)
return (
<>
<div>data: {String(data)}</div>
<button onClick={() => mutate(data, { revalidate: true })}>
mutate
</button>
</>
)
}
renderWithConfig(<Page />)
await screen.findByText('data: foo-0')
fireEvent.click(screen.getByText('mutate'))
await screen.findByText('data: foo-1')
expect(fetcher).toBeCalledTimes(2)
expect(logger).toEqual([undefined, ['foo-0'], ['foo-1']])
})
// https://github.com/vercel/swr/issues/1899
it('should not revalidate the resource with bound mutate when options is of Object type', async () => {
let t = 0
const key = createKey()
const fetcher = jest.fn(async () =>
createResponse(`foo-${t++}`, { delay: 10 })
)
const logger = []
function Page() {
const { data, mutate } = useSWRInfinite(() => key, fetcher, {
dedupingInterval: 0
})
logger.push(data)
return (
<>
<div>data: {String(data)}</div>
<button onClick={() => mutate(data, { revalidate: false })}>
mutate
</button>
</>
)
}
renderWithConfig(<Page />)
await screen.findByText('data: foo-0')
fireEvent.click(screen.getByText('mutate'))
expect(fetcher).toBeCalledTimes(1)
expect(logger).toEqual([undefined, ['foo-0']])
})
it('should be able to use the optimisticData option', async () => {
let t = 0
const key = createKey()
const fetcher = async () => createResponse(`foo-${t++}`)
const updater = async () => createResponse(['updated'])
function Page() {
const { data, mutate } = useSWRInfinite(() => key, fetcher, {
dedupingInterval: 0
})
return (
<>
<div>data: {String(data)}</div>
<button
onClick={() => {
mutate(updater, { optimisticData: ['optimistic'] })
}}
>
mutate
</button>
</>
)
}
renderWithConfig(<Page />)
await screen.findByText('data: foo-0')
fireEvent.click(screen.getByText('mutate'))
await screen.findByText('data: optimistic')
await screen.findByText('data: updated')
await screen.findByText('data: foo-1')
})
it('should be able to use the functional optimisticData option', async () => {
let t = 0
const key = createKey()
const fetcher = async () => createResponse(`foo-${t++}`)
const updater = async () => createResponse(['updated'])
function Page() {
const { data, mutate } = useSWRInfinite(() => key, fetcher, {
dedupingInterval: 0
})
return (
<>
<div>data: {String(data)}</div>
<button
onClick={() => {
mutate(updater, {
optimisticData: current => [...current, 'optimistic']
})
}}
>
mutate
</button>
</>
)
}
renderWithConfig(<Page />)
await screen.findByText('data: foo-0')
fireEvent.click(screen.getByText('mutate'))
await screen.findByText('data: foo-0,optimistic')
await screen.findByText('data: updated')
await screen.findByText('data: foo-1')
})
it('should be able to use the functional populateCache option', async () => {
let t = 0
const key = createKey()
const fetcher = async () => createResponse(`foo-${t++}`)
const updater = async () => createResponse(['updated'])
function Page() {
const { data, mutate } = useSWRInfinite(() => key, fetcher, {
dedupingInterval: 0
})
return (
<>
<div>data: {String(data)}</div>
<button
onClick={() => {
mutate(updater, {
populateCache: (result: string[], currentData: string[]) => {
return [...currentData, ...result]
},
revalidate: false
})
}}
>
mutate
</button>
</>
)
}
renderWithConfig(<Page />)
await screen.findByText('data: foo-0')
fireEvent.click(screen.getByText('mutate'))
await screen.findByText('data: foo-0,updated')
})
it('should be able to turn off the populateCache option', async () => {
let t = 0
const key = createKey()
const fetcher = async () => createResponse(`foo-${t++}`)
const updater = async () => createResponse(['updated'])
function Page() {
const { data, mutate } = useSWRInfinite(() => key, fetcher, {
dedupingInterval: 0
})
return (
<>
<div>data: {String(data)}</div>
<button
onClick={() => {
mutate(updater, {
populateCache: false,
revalidate: false
})
}}
>
mutate
</button>
</>
)
}
renderWithConfig(<Page />)
await screen.findByText('data: foo-0')
fireEvent.click(screen.getByText('mutate'))
sleep(50)
await screen.findByText('data: foo-0')
})
it('should be able to use the functional optimisticData option with multiple pages', async () => {
const apiData = {
0: ['A1', 'A2', 'A3'],
1: ['B1', 'B2', 'B3']
}
const key = createKey()
const fetcher = async ([_key, pageKey]) => createResponse(apiData[pageKey])
const updater = async () => createResponse(['updated'])
function Page() {
const { data, mutate } = useSWRInfinite(
(pageIndex: number) => [key, pageIndex],
fetcher,
{
initialSize: 2,
dedupingInterval: 0
}
)
return (
<>
<div>data: {String(data)}</div>
<button
onClick={() => {
mutate(updater, {
optimisticData: current => [current[0], [...current[1], 'B4']],
populateCache: (result: string[], currentData: string[]) => {
return [currentData[0], [...currentData[1], ...result]]
},
revalidate: false
})
}}
>
mutate
</button>
</>
)
}
renderWithConfig(<Page />)
await screen.findByText('data: A1,A2,A3,B1,B2,B3')
fireEvent.click(screen.getByText('mutate'))
await screen.findByText('data: A1,A2,A3,B1,B2,B3,B4')
await screen.findByText('data: A1,A2,A3,B1,B2,B3,updated')
})
it('should be able to use the rollbackOnError option', async () => {
let t = 0
const key = createKey()
const fetcher = async () => createResponse(`foo-${t++}`)
const updater = async () =>
createResponse(new Error('error')) as any as Promise<string[]>
function Page() {
const { data, mutate } = useSWRInfinite(() => key, fetcher, {
dedupingInterval: 0
})
return (
<>
<div>data: {String(data)}</div>
<button
onClick={async () => {
try {
await mutate(updater, {
optimisticData: ['optimistic'],
rollbackOnError: true,
revalidate: false
})
} catch (e) {
// noop
}
}}
>
mutate
</button>
</>
)
}
renderWithConfig(<Page />)
await screen.findByText('data: foo-0')
fireEvent.click(screen.getByText('mutate'))
await screen.findByText('data: optimistic')
await screen.findByText('data: foo-0')
})
it('should be able to disable the rollbackOnError option', async () => {
let t = 0
const key = createKey()
const fetcher = async () => createResponse(`foo-${t++}`)
const updater = async () =>
createResponse(new Error('error')) as any as Promise<string[]>
function Page() {
const { data, mutate } = useSWRInfinite(() => key, fetcher, {
dedupingInterval: 0
})
return (
<>
<div>data: {String(data)}</div>
<button
onClick={async () => {
try {
await mutate(updater, {
optimisticData: ['optimistic'],
rollbackOnError: false,
revalidate: false
})
} catch (e) {
// noop
}
}}
>
mutate
</button>
</>
)
}
renderWithConfig(<Page />)
await screen.findByText('data: foo-0')
fireEvent.click(screen.getByText('mutate'))
await screen.findByText('data: optimistic')
await sleep(50)
await screen.findByText('data: optimistic')
})
it('should be able to use the throwOnError option', async () => {
let t = 0
const key = createKey()
const fetcher = async () => createResponse(`foo-${t++}`)
const updater = async () =>
createResponse(new Error('mutation error')) as any as Promise<string[]>
function Page() {
const [error, setError] = useState(null)
const { data, mutate } = useSWRInfinite(() => key, fetcher, {
dedupingInterval: 0
})
return (
<>
<div>data: {String(data)}</div>
<div>error: {error}</div>
<button
onClick={async () => {
try {
await mutate(updater, { throwOnError: true, revalidate: false })
} catch (e) {
setError(e.message)
}
}}
>
mutate
</button>
</>
)
}
renderWithConfig(<Page />)
await screen.findByText('data: foo-0')
fireEvent.click(screen.getByText('mutate'))
await screen.findByText('error: mutation error')
})
it('should be able to disable the throwOnError option', async () => {
let t = 0
const key = createKey()
const fetcher = async () => createResponse(`foo-${t++}`)
const updater = async () =>
createResponse(new Error('mutation error')) as any as Promise<string[]>
function Page() {
const [error, setError] = useState(null)
const { data, mutate } = useSWRInfinite(() => key, fetcher, {
dedupingInterval: 0
})
return (
<>
<div>data: {String(data)}</div>
<div>error: {error}</div>
<button
onClick={async () => {
try {
await mutate(updater, {
throwOnError: false,
revalidate: false
})
} catch (e) {
setError(e.message)
}
}}
>
mutate
</button>
</>
)
}
renderWithConfig(<Page />)
await screen.findByText('data: foo-0')
fireEvent.click(screen.getByText('mutate'))
await sleep(50)
await screen.findByText('error:')
})
it('should share data with useSWR', async () => {
const key = createKey()
const SWR = () => {
const { data } = useSWR(`${key}-${2}`)
return <div>swr: {data}</div>
}
const Page = () => {
const { data, setSize, size } = useSWRInfinite(
index => `${key}-${index + 1}`,
infiniteKey => createResponse(`${infiniteKey},`, { delay: 100 })
)
return (
<>
<div onClick={() => setSize(i => i + 1)}>data: {data}</div>
<div onClick={() => setSize(i => i + 1)}>size: {size}</div>
<SWR></SWR>
</>
)
}
renderWithConfig(<Page />)
await screen.findByText(`data: ${key}-1,`)
await screen.findByText(`swr:`)
fireEvent.click(screen.getByText('size: 1'))
await screen.findByText(`data: ${key}-1,${key}-2,`)
await screen.findByText(`size: 2`)
await screen.findByText(`swr: ${key}-2,`)
})
it('should support the parallel option', async () => {
// mock api
const pageData = ['apple', 'banana', 'pineapple']
const key = createKey()
function Page() {
const { data } = useSWRInfinite(
index => [key, index],
([_, index]) => createResponse(`${pageData[index]}, `, { delay: 50 }),
{
initialSize: 3,
parallel: true
}
)
return <div>data:{data}</div>
}
renderWithConfig(<Page />)
screen.getByText('data:')
// If SWR sends requests sequentially, it takes 150ms at least
await act(() => sleep(100))
screen.getByText('data:apple, banana, pineapple,')
})
it('should return the first error happened in parallel requests', async () => {
// mock api
const pageData = [
{ data: new Error('apple'), delay: 50 },
{ data: new Error('banana'), delay: 30 },
{ data: 'pineapple', delay: 10 }
]
const key = createKey()
function Page() {
const { data, error } = useSWRInfinite(
index => [key, index],
([_, index]) =>
createResponse<string>(pageData[index].data as string, {
delay: pageData[index].delay
}),
{
initialSize: 3,
parallel: true
}
)
if (error) {
return <div>error:{error.message}</div>
}
return <div>data:{data}</div>
}
renderWithConfig(<Page />)
screen.getByText('data:')
await act(() => sleep(50))
screen.getByText('error:banana')
})
it('should send request sequentially when the parallel option is disabled', async () => {
// mock api
const pageData = ['apple', 'banana', 'pineapple']
const key = createKey()
function Page() {
const { data } = useSWRInfinite(
index => [key, index],
([_, index]) => createResponse(`${pageData[index]}, `, { delay: 50 }),
{
initialSize: 3,
parallel: false
}
)
return <div>data:{data}</div>
}
renderWithConfig(<Page />)
screen.getByText('data:')
// If SWR sends requests sequentially, it takes 150ms at least
await act(() => sleep(100))
screen.getByText('data:')
await act(() => sleep(200))
screen.getByText('data:apple, banana, pineapple,')
})
it('should be the parallel option false by default', async () => {
// mock api
const pageData = ['apple', 'banana', 'pineapple']
const key = createKey()
function Page() {
const { data } = useSWRInfinite(
index => [key, index],
([_, index]) => createResponse(`${pageData[index]}, `, { delay: 50 }),
{
initialSize: 3
}
)
return <div>data:{data}</div>
}
renderWithConfig(<Page />)
screen.getByText('data:')
// If SWR sends requests sequentially, it takes 150ms at least
await act(() => sleep(100))
screen.getByText('data:')
await act(() => sleep(200))
screen.getByText('data:apple, banana, pineapple,')
})
it('should make previousPageData null when the parallel option is enabled', async () => {
// mock api
const pageData = ['apple', 'banana', 'pineapple']
const previousPageDataLogs = []
const key = createKey()
function Page() {
const { data } = useSWRInfinite(
(index, previousPageData) => {
previousPageDataLogs.push(previousPageData)
return [key, index]
},
([_, index]) => createResponse(`${pageData[index]}, `, { delay: 50 }),
{
initialSize: 3,
parallel: true
}
)
return <div>data:{data}</div>
}
renderWithConfig(<Page />)
screen.getByText('data:')
// If SWR sends requests sequentially, it takes 150ms at least
await act(() => sleep(100))
screen.getByText('data:apple, banana, pineapple,')
expect(previousPageDataLogs.every(d => d === null)).toBeTruthy()
})
})
|
315 | 0 | petrpan-code/vercel/swr | petrpan-code/vercel/swr/test/use-swr-integration.test.tsx | import { act, screen, fireEvent } from '@testing-library/react'
import React, { useState, useEffect, Profiler } from 'react'
import useSWR from 'swr'
import {
createResponse,
sleep,
nextTick as waitForNextTick,
renderWithConfig,
createKey,
renderWithGlobalCache
} from './utils'
describe('useSWR', () => {
const sharedKey = createKey()
it('should return `undefined` on hydration then return data', async () => {
function Page() {
const { data } = useSWR(sharedKey, () => 'SWR')
return <div>hello, {data}</div>
}
renderWithGlobalCache(<Page />)
// hydration
screen.getByText('hello,')
// mounted
await screen.findByText('hello, SWR')
})
it('should allow functions as key and reuse the cache', async () => {
function Page() {
const { data } = useSWR(
() => sharedKey,
() => 'SWR'
)
return <div>hello, {data}</div>
}
renderWithGlobalCache(<Page />)
screen.getByText('hello, SWR')
})
it('should allow async fetcher functions', async () => {
const fetcher = jest.fn(() => createResponse('SWR'))
const key = createKey()
function Page() {
const { data } = useSWR(key, fetcher)
return <div>hello, {data}</div>
}
renderWithConfig(<Page />)
// hydration
screen.getByText('hello,')
await screen.findByText('hello, SWR')
expect(fetcher).toBeCalledTimes(1)
})
it('should not call fetch function when revalidateOnMount is false', async () => {
const fetch = jest.fn(() => 'SWR')
const key = createKey()
function Page() {
const { data } = useSWR(key, fetch, {
revalidateOnMount: false
})
return <div>hello, {data}</div>
}
renderWithConfig(<Page />)
await screen.findByText('hello,')
expect(fetch).not.toHaveBeenCalled()
})
it('should call fetch function when revalidateOnMount is false and key has been changed', async () => {
const fetch = jest.fn(() => 'SWR')
function Page() {
const [key, setKey] = useState(createKey())
const { data } = useSWR(key, fetch, {
revalidateOnMount: false
})
return <div onClick={() => setKey(createKey)}>hello,{data}</div>
}
renderWithConfig(<Page />)
await screen.findByText('hello,')
expect(fetch).not.toHaveBeenCalled()
// the key has been changed
fireEvent.click(screen.getByText('hello,'))
await screen.findByText('hello,SWR')
})
it('should call fetch function when revalidateOnMount is true even if fallbackData is set', async () => {
const fetch = jest.fn(() => 'SWR')
const key = createKey()
function Page() {
const { data } = useSWR(key, fetch, {
revalidateOnMount: true,
fallbackData: 'gab'
})
return <div>hello, {data}</div>
}
renderWithConfig(<Page />)
screen.getByText('hello, gab')
await screen.findByText('hello, SWR')
expect(fetch).toHaveBeenCalled()
})
it('initial loading state should be false when revalidation is disabled with fallbackData', async () => {
const fetch = jest.fn(() => 'SWR')
const key = createKey()
function Page() {
const { data, isLoading, isValidating } = useSWR(key, fetch, {
revalidateIfStale: false,
revalidateOnFocus: false,
revalidateOnReconnect: false,
fallbackData: 'Fallback'
})
return (
<div>
{data}, {isLoading.toString()} , {isValidating.toString()}
</div>
)
}
renderWithConfig(<Page />)
screen.getByText('Fallback, false , false')
expect(fetch).not.toHaveBeenCalled()
})
it('should dedupe requests by default', async () => {
const fetcher = jest.fn(() => createResponse('SWR'))
const key = createKey()
function Page() {
const { data: v1 } = useSWR(key, fetcher)
const { data: v2 } = useSWR(key, fetcher)
return (
<div>
{v1}, {v2}
</div>
)
}
renderWithConfig(<Page />)
screen.getByText(',')
await screen.findByText('SWR, SWR')
expect(fetcher).toBeCalledTimes(1)
})
it('should trigger the onSuccess event', async () => {
let SWRData = null
const key = createKey()
function Page() {
const { data } = useSWR(key, () => createResponse('SWR'), {
onSuccess: _data => (SWRData = _data)
})
return <div>hello, {data}</div>
}
renderWithConfig(<Page />)
screen.getByText('hello,')
await screen.findByText('hello, SWR')
expect(SWRData).toEqual('SWR')
})
it('should broadcast data', async () => {
let cnt = 0
const key = createKey()
function Block() {
const { data } = useSWR(key, () => cnt++, {
refreshInterval: 100,
// need to turn of deduping otherwise
// refreshing will be ignored
dedupingInterval: 10
})
return <>{data}</>
}
function Page() {
return (
<>
<Block /> <Block /> <Block />
</>
)
}
renderWithConfig(<Page />)
await act(() => sleep(50))
screen.getByText('0 0 0')
await act(() => sleep(100))
screen.getByText('1 1 1')
await act(() => sleep(100))
screen.getByText('2 2 2')
})
it('should broadcast error', async () => {
let cnt = 0
const key = createKey()
function Block() {
const { data, error } = useSWR(
key,
() => {
if (cnt === 2) throw new Error('err')
return cnt++
},
{
refreshInterval: 100,
// need to turn of deduping otherwise
// refreshing will be ignored
dedupingInterval: 10
}
)
if (error) return error.message
return <>{data}</>
}
function Page() {
return (
<>
<Block /> <Block /> <Block />
</>
)
}
renderWithConfig(<Page />)
await act(() => sleep(50))
screen.getByText('0 0 0')
await act(() => sleep(100))
screen.getByText('1 1 1')
await act(() => sleep(100))
screen.getByText('err err err')
})
it('should broadcast isValidating', async () => {
const key = createKey()
function useBroadcast3() {
const { isValidating, mutate } = useSWR(key, () => sleep(100), {
// need to turn of deduping otherwise
// revalidating will be ignored
dedupingInterval: 10
})
return { isValidating, mutate }
}
function Initiator() {
const { isValidating, mutate } = useBroadcast3()
useEffect(() => {
const timeout = setTimeout(() => {
mutate()
}, 200)
return () => clearTimeout(timeout)
// the revalidate function is always the same reference because the key of the useSWR is static (broadcast-3)
// eslint-disable-next-line react-hooks/exhaustive-deps
}, [])
return <>{isValidating ? 'true' : 'false'}</>
}
function Consumer() {
const { isValidating } = useBroadcast3()
return <>{isValidating ? 'true' : 'false'}</>
}
function Page() {
return (
<>
<Initiator /> <Consumer /> <Consumer />
</>
)
}
renderWithConfig(<Page />)
screen.getByText('true true true')
await act(() => sleep(150))
screen.getByText('false false false')
await act(() => sleep(100))
screen.getByText('true true true')
await act(() => sleep(100))
screen.getByText('false false false')
})
it('should accept object args', async () => {
const obj = { v: 'hello' }
const arr = ['world']
const key1 = createKey()
const key2 = createKey()
function Page() {
const { data: v1 } = useSWR(
[key1, obj, arr],
([a, b, c]) => a + b.v + c[0]
)
// reuse the cache
const { data: v2 } = useSWR([key1, obj, arr], () => 'not called!')
// different object
const { data: v3 } = useSWR(
[key2, obj, 'world'],
([a, b, c]) => a + b.v + c
)
return (
<div>
{v1}, {v2}, {v3}
</div>
)
}
renderWithConfig(<Page />)
await screen.findByText(
`${key1}helloworld, ${key1}helloworld, ${key2}helloworld`
)
})
it('should accept function returning args', async () => {
const obj = { v: 'hello' }
const arr = ['world']
const key = createKey()
function Page() {
const { data } = useSWR(
() => [key, obj, arr],
([a, b, c]) => a + b.v + c[0]
)
return <div>{data}</div>
}
renderWithConfig(<Page />)
await screen.findByText(`${key}helloworld`)
})
it('should accept initial data', async () => {
const fetcher = jest.fn(() => 'SWR')
const key = createKey()
function Page() {
const { data } = useSWR(key, fetcher, {
fallbackData: 'Initial'
})
return <div>hello, {data}</div>
}
renderWithConfig(<Page />)
await screen.findByText('hello, Initial')
expect(fetcher).not.toBeCalled()
})
it('should revalidate even if fallbackData is provided', async () => {
const fetcher = key => createResponse(key, { delay: 50 })
const initialKey = createKey()
const updatedKey = createKey()
function Page() {
const [key, setKey] = useState(initialKey)
const { data } = useSWR(key, fetcher, {
fallbackData: 'Initial'
})
return (
<div onClick={() => setKey(updatedKey)}>
{data ? `hello, ${data}` : 'loading'}
</div>
)
}
renderWithConfig(<Page />)
// render with the initial data
await screen.findByText('hello, Initial')
await waitForNextTick()
fireEvent.focus(window)
await screen.findByText(`hello, ${initialKey}`)
// change the key
await waitForNextTick()
fireEvent.click(screen.getByText(`hello, ${initialKey}`))
// a request is still in flight
await act(() => sleep(10))
// while validating, SWR returns the fallbackData
// https://github.com/vercel/swr/pull/961/files#r588928241
screen.getByText('hello, Initial')
// render with data the fetcher returns
await screen.findByText(`hello, ${updatedKey}`)
})
it('should set config as second parameter', async () => {
const fetcher = jest.fn(() => 'SWR')
const key = createKey()
function Page() {
const { data } = useSWR(key, {
fetcher
})
return <div>hello, {data}</div>
}
renderWithConfig(<Page />)
screen.getByText('hello,')
expect(fetcher).toBeCalled()
await screen.findByText('hello, SWR')
})
it('should revalidate on mount after dedupingInterval', async () => {
const key = createKey()
let cnt = 0
function Foo() {
const { data } = useSWR(key, () => 'data: ' + cnt++, {
dedupingInterval: 0
})
return <>{data}</>
}
function Page() {
const [showFoo, setShowFoo] = React.useState(true)
return (
<>
{showFoo ? <Foo /> : null}
<button onClick={() => setShowFoo(!showFoo)}>toggle</button>
</>
)
}
renderWithConfig(<Page />)
await waitForNextTick()
screen.getByText('data: 0')
fireEvent.click(screen.getByText('toggle'))
await waitForNextTick()
fireEvent.click(screen.getByText('toggle'))
await act(() => sleep(20))
screen.getByText('data: 1')
})
it('Nested SWR hook should only do loading once', async () => {
const key = createKey()
let count = 0
const ChildComponent = () => {
const { data } = useSWR(key, _ => createResponse(_, { delay: 100 }))
return <div id="child">{data}</div>
}
const NestedRender = () => {
const { data, isValidating } = useSWR(key, _ =>
createResponse(_, { delay: 50 })
)
if (isValidating) {
return <div>loading</div>
}
return (
<div>
<div id="parent">{data}</div>
<ChildComponent />
</div>
)
}
const Page = () => (
<Profiler
id={key}
onRender={() => {
count += 1
}}
>
<NestedRender />
</Profiler>
)
renderWithConfig(<Page />)
await screen.findByText(`loading`)
await screen.findAllByText(key)
await act(() => sleep(150))
expect(count).toBe(2)
})
// Test for https://swr.vercel.app/docs/advanced/performance#dependency-collection
it('should render four times in the worst case', async () => {
let isFirstFetch = true
const fetcher = async () => {
if (isFirstFetch) {
isFirstFetch = false
throw new Error('error')
}
return 'value'
}
const key = createKey()
const logs = []
function Page() {
const { data, error, isLoading, isValidating } = useSWR(key, fetcher, {
errorRetryInterval: 10
})
logs.push({
data,
error,
isLoading,
isValidating
})
if (isLoading) return <p>loading</p>
return <p>data:{data}</p>
}
renderWithConfig(<Page />)
await screen.findByText('data:value')
expect(logs).toMatchInlineSnapshot(`
[
{
"data": undefined,
"error": undefined,
"isLoading": true,
"isValidating": true,
},
{
"data": undefined,
"error": [Error: error],
"isLoading": false,
"isValidating": false,
},
{
"data": undefined,
"error": [Error: error],
"isLoading": true,
"isValidating": true,
},
{
"data": "value",
"error": undefined,
"isLoading": false,
"isValidating": false,
},
]
`)
})
// Test for https://swr.vercel.app/docs/advanced/performance#dependency-collection
it('should render only two times in the best case', async () => {
let isFirstFetch = true
const fetcher = async () => {
if (isFirstFetch) {
isFirstFetch = false
throw new Error('error')
}
return 'value'
}
const key = createKey()
const logs = []
function Page() {
const { data } = useSWR(key, fetcher, {
errorRetryInterval: 10
})
logs.push({ data })
if (!data) return <p>loading</p>
return <p>data:{data}</p>
}
renderWithConfig(<Page />)
await screen.findByText('data:value')
expect(logs).toMatchInlineSnapshot(`
[
{
"data": undefined,
},
{
"data": "value",
},
]
`)
})
// Test for https://github.com/vercel/swr/issues/2446
it('should return latest data synchronously after accessing getter', async () => {
const fetcher = async () => {
await sleep(10)
return 'value'
}
const key = createKey()
const logs = []
function Page() {
const swr = useSWR(key, fetcher)
const [show, setShow] = useState(false)
useEffect(() => {
setTimeout(() => {
setShow(true)
}, 100)
}, [])
if (!show) return null
logs.push(swr.data)
return <p>data:{swr.data}</p>
}
renderWithConfig(<Page />)
await screen.findByText('data:value')
expect(logs).toMatchInlineSnapshot(`
[
"value",
]
`)
})
})
|
316 | 0 | petrpan-code/vercel/swr | petrpan-code/vercel/swr/test/use-swr-key.test.tsx | import { act, fireEvent, screen } from '@testing-library/react'
import React, { useState, useEffect } from 'react'
import useSWR from 'swr'
import { createKey, createResponse, renderWithConfig, sleep } from './utils'
describe('useSWR - key', () => {
it('should respect requests after key has changed', async () => {
let rerender
const baseKey = createKey()
function Page() {
const [mounted, setMounted] = useState(0)
const key = `${baseKey}-${mounted ? 'short' : 'long'}`
const { data } = useSWR(key, () => {
if (mounted) {
return createResponse('short request', { delay: 50 })
}
return createResponse('long request', { delay: 100 })
})
useEffect(() => setMounted(1), [])
rerender = setMounted
return <div>data:{data}</div>
}
renderWithConfig(<Page />)
screen.getByText('data:')
await screen.findByText('data:short request')
await act(() => sleep(100)) // wait 100ms until "long request" finishes
screen.getByText('data:short request') // should be "short request" still
// manually trigger a re-render from outside
// this triggers a re-render and a read access to `swr.data`
// but the result should still be "short request"
act(() => rerender(x => x + 1))
screen.getByText('data:short request')
})
it('should render undefined after key has changed', async () => {
const baseKey = createKey()
function Page() {
const [mounted, setMounted] = useState(false)
const key = `${baseKey}-${mounted ? '1' : '0'}`
const { data } = useSWR(key, k => createResponse(k, { delay: 100 }))
useEffect(() => {
setTimeout(() => setMounted(true), 200)
}, [])
return <div>data:{data}</div>
}
// time data key
// -> 0 undefined, '0'
// -> 100 0, '0'
// -> 200 undefined, '1' <- this state is required; we can't show 0 here
// -> 300 1, '1'
renderWithConfig(<Page />)
screen.getByText('data:') // undefined, time=0
await act(() => sleep(150))
screen.getByText(`data:${baseKey}-0`) // 0, time=150
await act(() => sleep(100))
screen.getByText('data:') // undefined, time=250
await act(() => sleep(100))
screen.getByText(`data:${baseKey}-1`) // 1, time=350
})
it('should return undefined after key change when fetcher is synchronized', async () => {
const samples = {
'1': 'a',
'2': 'b',
'3': 'c'
}
const baseKey = createKey()
function Page() {
const [sampleKey, setKey] = React.useState(1)
const { data } = useSWR(
`${baseKey}-${sampleKey}`,
key => samples[key.replace(`${baseKey}-`, '')]
)
return (
<div
onClick={() => {
setKey(sampleKey + 1)
}}
>
hello, {sampleKey}:{data}
</div>
)
}
renderWithConfig(<Page />)
screen.getByText('hello, 1:')
await screen.findByText('hello, 1:a')
fireEvent.click(screen.getByText('hello, 1:a'))
// first, rerender on key change
screen.getByText('hello, 2:')
await screen.findByText('hello, 2:b')
})
it('should revalidate if a function key changes identity', async () => {
const closureFunctions: { [key: string]: () => string } = {}
const baseKey = createKey()
const closureFactory = id => {
if (closureFunctions[id]) return closureFunctions[id]
closureFunctions[id] = () => `${baseKey}-${id}`
return closureFunctions[id]
}
let updateId
const fetcher = (key: string) => Promise.resolve(key)
function Page() {
const [id, setId] = React.useState('first')
updateId = setId
const fnWithClosure = closureFactory(id)
const { data } = useSWR(fnWithClosure, fetcher)
return <div>{data}</div>
}
renderWithConfig(<Page />)
await screen.findByText(`${baseKey}-first`)
act(() => updateId('first'))
await screen.findByText(`${baseKey}-first`)
act(() => updateId('second'))
await screen.findByText(`${baseKey}-second`)
})
it('should not fetch if the function key throws an error', async () => {
let value = 0
const fetcher = jest.fn(() => value++)
const key = () => {
throw new Error('error')
}
function Page() {
const { data } = useSWR(key, fetcher)
return <div>{`key-${data}`}</div>
}
renderWithConfig(<Page />)
await screen.findByText(`key-undefined`)
expect(fetcher).toBeCalledTimes(0)
})
it('should cleanup state when key turns to empty', async () => {
const key = createKey()
function Page() {
const [cnt, setCnt] = useState(1)
const { isValidating } = useSWR(cnt === -1 ? '' : `${key}-${cnt}`, () =>
createResponse('', { delay: 100 })
)
return (
<div onClick={() => setCnt(cnt == 2 ? -1 : cnt + 1)}>
{isValidating ? 'true' : 'false'}
</div>
)
}
renderWithConfig(<Page />)
screen.getByText('true')
fireEvent.click(screen.getByText('true'))
await act(() => sleep(10))
screen.getByText('true')
fireEvent.click(screen.getByText('true'))
await act(() => sleep(10))
screen.getByText('false')
})
it('should keep data in sync when key updates', async () => {
const fetcher = () => createResponse('test', { delay: 100 })
const values = []
const updatedKey = createKey()
function Page() {
const [key, setKey] = useState(null)
const { data: v1 } = useSWR(key, fetcher)
const { data: v2 } = useSWR(key, fetcher)
values.push([v1, v2])
return <button onClick={() => setKey(updatedKey)}>update key</button>
}
renderWithConfig(<Page />)
screen.getByText('update key')
fireEvent.click(screen.getByText('update key'))
await act(() => sleep(120))
// All values should be equal because they're sharing the same key
expect(values.some(([a, b]) => a !== b)).toBeFalsy()
})
it('should support object as the key and deep compare', async () => {
const fetcher = jest.fn(() => 'data')
function Page() {
const { data: v1 } = useSWR({ foo: { bar: 1 } }, fetcher)
const { data: v2 } = useSWR({ foo: { bar: 1 } }, fetcher)
return (
<div>
{v1},{v2}
</div>
)
}
renderWithConfig(<Page />)
await screen.findByText('data,data')
// Only 1 request since the keys are the same.
expect(fetcher).toBeCalledTimes(1)
})
})
|
317 | 0 | petrpan-code/vercel/swr | petrpan-code/vercel/swr/test/use-swr-laggy.test.tsx | import { screen, act, fireEvent } from '@testing-library/react'
import { useState } from 'react'
import useSWR from 'swr'
import useSWRInfinite from 'swr/infinite'
import { createKey, createResponse, renderWithConfig, sleep } from './utils'
describe('useSWR - keep previous data', () => {
it('should keep previous data when key changes when `keepPreviousData` is enabled', async () => {
const loggedData = []
const fetcher = k => createResponse(k, { delay: 50 })
function App() {
const [key, setKey] = useState(createKey())
const { data: laggedData } = useSWR(key, fetcher, {
keepPreviousData: true
})
loggedData.push([key, laggedData])
return <button onClick={() => setKey(createKey())}>change key</button>
}
renderWithConfig(<App />)
await act(() => sleep(100))
fireEvent.click(screen.getByText('change key'))
await act(() => sleep(100))
const key1 = loggedData[0][0]
const key2 = loggedData[2][0]
expect(loggedData).toEqual([
[key1, undefined],
[key1, key1],
[key2, key1],
[key2, key2]
])
})
it('should keep previous data when sharing the cache', async () => {
const loggedData = []
const fetcher = k => createResponse(k, { delay: 50 })
function App() {
const [key, setKey] = useState(createKey())
const { data } = useSWR(key, fetcher)
const { data: laggedData } = useSWR(key, fetcher, {
keepPreviousData: true
})
loggedData.push([key, data, laggedData])
return <button onClick={() => setKey(createKey())}>change key</button>
}
renderWithConfig(<App />)
await act(() => sleep(100))
fireEvent.click(screen.getByText('change key'))
await act(() => sleep(100))
const key1 = loggedData[0][0]
const key2 = loggedData[2][0]
expect(loggedData).toEqual([
[key1, undefined, undefined],
[key1, key1, key1],
[key2, undefined, key1],
[key2, key2, key2]
])
})
it('should keep previous data even if there is fallback data', async () => {
const loggedData = []
const fetcher = k => createResponse(k, { delay: 50 })
function App() {
const [key, setKey] = useState(createKey())
const { data } = useSWR(key, fetcher, {
fallbackData: 'fallback'
})
const { data: laggedData } = useSWR(key, fetcher, {
keepPreviousData: true,
fallbackData: 'fallback'
})
loggedData.push([key, data, laggedData])
return <button onClick={() => setKey(createKey())}>change key</button>
}
renderWithConfig(<App />)
await act(() => sleep(100))
fireEvent.click(screen.getByText('change key'))
await act(() => sleep(100))
const key1 = loggedData[0][0]
const key2 = loggedData[2][0]
expect(loggedData).toEqual([
[key1, 'fallback', 'fallback'],
[key1, key1, key1],
[key2, 'fallback', key1],
[key2, key2, key2]
])
})
it('should always return the latest data', async () => {
const loggedData = []
const fetcher = k => createResponse(k, { delay: 50 })
function App() {
const [key, setKey] = useState(createKey())
const { data: laggedData, mutate } = useSWR(key, fetcher, {
keepPreviousData: true
})
loggedData.push([key, laggedData])
return (
<>
<button onClick={() => setKey(createKey())}>change key</button>
<button onClick={() => mutate('mutate')}>mutate</button>
</>
)
}
renderWithConfig(<App />)
await act(() => sleep(100))
fireEvent.click(screen.getByText('change key'))
await act(() => sleep(100))
fireEvent.click(screen.getByText('mutate'))
await act(() => sleep(100))
const key1 = loggedData[0][0]
const key2 = loggedData[2][0]
expect(loggedData).toEqual([
[key1, undefined],
[key1, key1],
[key2, key1],
[key2, key2],
[key2, 'mutate'],
[key2, key2]
])
})
it('should keep previous data for the useSWRInfinite hook', async () => {
const loggedData = []
const fetcher = k => createResponse(k, { delay: 50 })
function App() {
const [key, setKey] = useState(createKey())
const { data } = useSWRInfinite(() => key, fetcher, {
keepPreviousData: true
})
loggedData.push([key, data])
return <button onClick={() => setKey(createKey())}>change key</button>
}
renderWithConfig(<App />)
await act(() => sleep(100))
fireEvent.click(screen.getByText('change key'))
await act(() => sleep(100))
const key1 = loggedData[0][0]
const key2 = loggedData[2][0]
expect(loggedData).toEqual([
[key1, undefined],
[key1, [key1]],
[key2, [key1]],
[key2, [key2]]
])
})
it('should support changing the `keepPreviousData` option', async () => {
const loggedData = []
const fetcher = k => createResponse(k, { delay: 50 })
let keepPreviousData = false
function App() {
const [key, setKey] = useState(createKey())
const { data: laggedData } = useSWR(key, fetcher, {
keepPreviousData
})
loggedData.push([key, laggedData])
return <button onClick={() => setKey(createKey())}>change key</button>
}
renderWithConfig(<App />)
await act(() => sleep(100))
fireEvent.click(screen.getByText('change key'))
await act(() => sleep(100))
keepPreviousData = true
fireEvent.click(screen.getByText('change key'))
await act(() => sleep(100))
const key1 = loggedData[0][0]
const key2 = loggedData[2][0]
const key3 = loggedData[4][0]
expect(loggedData).toEqual([
[key1, undefined],
[key1, key1],
[key2, undefined],
[key2, key2],
[key3, key2],
[key3, key3]
])
})
// https://github.com/vercel/swr/issues/2128
it('should re-render when returned data and fallbackData is the same and keepPreviousData is enabled', async () => {
const fallbackData = 'initial'
const fetcher = k => createResponse(k, { delay: 50 })
const keys = ['initial', 'updated']
function App() {
const [count, setCount] = useState(0)
const { data } = useSWR(keys[count % 2 === 0 ? 0 : 1], fetcher, {
fallbackData,
keepPreviousData: true,
revalidateOnMount: false,
revalidateOnFocus: false
})
return (
<>
<button onClick={() => setCount(c => c + 1)}>change key</button>
<div>{data}</div>
</>
)
}
renderWithConfig(<App />)
// fallbackData
screen.getByText('initial')
fireEvent.click(screen.getByText('change key'))
await act(() => sleep(10))
// previous data
screen.getByText('initial')
await act(() => sleep(100))
screen.getByText('updated')
fireEvent.click(screen.getByText('change key'))
await act(() => sleep(10))
// previous data
screen.getByText('updated')
await act(() => sleep(100))
screen.getByText('initial')
})
it('should work keepPreviousData without changing th key', async () => {
const key = createKey()
let counter = 0
const fetcher = () => createResponse(++counter, { delay: 50 })
function App() {
const { data, mutate } = useSWR(key, fetcher)
const { data: laggedData } = useSWR(key, fetcher, {
keepPreviousData: true
})
return (
<>
<button onClick={() => mutate(undefined)}>mutate</button>
<div>
data:{data},laggy:{laggedData}
</div>
</>
)
}
renderWithConfig(<App />)
screen.getByText('data:,laggy:')
await act(() => sleep(100))
screen.getByText('data:1,laggy:1')
fireEvent.click(screen.getByText('mutate'))
// previous data
screen.getByText('data:,laggy:1')
await act(() => sleep(100))
screen.getByText('data:2,laggy:2')
})
})
|
318 | 0 | petrpan-code/vercel/swr | petrpan-code/vercel/swr/test/use-swr-loading.test.tsx | import { act, screen, fireEvent } from '@testing-library/react'
import React, { useEffect } from 'react'
import useSWR from 'swr'
import {
createResponse,
createKey,
sleep,
renderWithConfig,
nextTick,
executeWithoutBatching
} from './utils'
describe('useSWR - loading', () => {
it('should return validating state', async () => {
let renderCount = 0
const key = createKey()
function Page() {
const { data, isValidating } = useSWR(key, () => createResponse('data'))
renderCount++
return (
<div>
hello, {data}, {isValidating ? 'validating' : 'ready'}
</div>
)
}
renderWithConfig(<Page />)
screen.getByText('hello, , validating')
await screen.findByText('hello, data, ready')
// data isValidating
// -> undefined, true
// -> data, false
expect(renderCount).toEqual(2)
})
it('should return loading state', async () => {
let renderCount = 0
const key = createKey()
function Page() {
const { data, isLoading } = useSWR(key, () => createResponse('data'))
renderCount++
return (
<div>
hello, {data}, {isLoading ? 'loading' : 'ready'}
</div>
)
}
renderWithConfig(<Page />)
screen.getByText('hello, , loading')
await screen.findByText('hello, data, ready')
// data isLoading
// -> undefined, true
// -> data, false
expect(renderCount).toEqual(2)
})
it('should avoid extra rerenders', async () => {
let renderCount = 0
const key = createKey()
function Page() {
// we never access `isValidating`, so it will not trigger rerendering
const { data } = useSWR(key, () => createResponse('data'))
renderCount++
return <div>hello, {data}</div>
}
renderWithConfig(<Page />)
await screen.findByText('hello, data')
// data
// -> undefined
// -> data
expect(renderCount).toEqual(2)
})
it('should avoid extra rerenders while fetching', async () => {
let renderCount = 0,
dataLoaded = false
const key = createKey()
function Page() {
// we never access anything
useSWR(key, async () => {
const res = await createResponse('data')
dataLoaded = true
return res
})
renderCount++
return <div>hello</div>
}
renderWithConfig(<Page />)
screen.getByText('hello')
await executeWithoutBatching(() => sleep(100)) // wait
// it doesn't re-render, but fetch was triggered
expect(renderCount).toEqual(1)
expect(dataLoaded).toEqual(true)
})
it('should avoid extra rerenders when the fallback is the same as cache', async () => {
let renderCount = 0,
initialDataLoaded = false,
mutationDataLoaded = false
const key = createKey()
function Page() {
const { data, mutate } = useSWR(
key,
async () => {
const res = await createResponse({ greeting: 'hello' })
initialDataLoaded = true
return res
},
{ fallbackData: { greeting: 'hello' } }
)
useEffect(() => {
const timeout = setTimeout(
() =>
mutate(async () => {
const res = await createResponse({ greeting: 'hello' })
mutationDataLoaded = true
return res
}),
200
)
return () => clearTimeout(timeout)
}, [mutate])
renderCount++
return <div>{data?.greeting}</div>
}
renderWithConfig(<Page />)
screen.getByText('hello')
await act(() => sleep(1000)) // wait
// it doesn't re-render, but fetch was triggered
expect(initialDataLoaded).toEqual(true)
expect(mutationDataLoaded).toEqual(true)
expect(renderCount).toEqual(1)
})
it('should return enumerable object', async () => {
// If the returned object is enumerable, we can use the spread operator
// to deconstruct all the keys.
function Page() {
const swr = useSWR(createKey())
return (
<div>
{Object.keys({ ...swr })
.sort()
.join(',')}
</div>
)
}
renderWithConfig(<Page />)
screen.getByText('data,error,isLoading,isValidating,mutate')
})
it('should sync validating states', async () => {
const key = createKey()
const fetcher = jest.fn()
function Foo() {
const { isValidating } = useSWR(key, async () => {
fetcher()
return 'foo'
})
return isValidating ? <>validating</> : <>stopped</>
}
function Page() {
return (
<>
<Foo />,<Foo />
</>
)
}
renderWithConfig(<Page />)
screen.getByText('validating,validating')
await nextTick()
screen.getByText('stopped,stopped')
expect(fetcher).toBeCalledTimes(1)
})
it('should sync all validating states if errored', async () => {
const key = createKey()
function Foo() {
const { isValidating } = useSWR(key, async () => {
throw new Error(key)
})
return isValidating ? <>validating</> : <>stopped</>
}
function Page() {
return (
<>
<Foo />,<Foo />
</>
)
}
renderWithConfig(<Page />)
screen.getByText('validating,validating')
await nextTick()
screen.getByText('stopped,stopped')
})
it('should sync all validating states if errored but paused', async () => {
const key = createKey()
let paused = false
function Foo() {
const { isValidating } = useSWR(key, {
isPaused: () => paused,
fetcher: async () => {
await sleep(50)
throw new Error(key)
},
dedupingInterval: 0,
errorRetryInterval: 50
})
return isValidating ? <>validating</> : <>stopped</>
}
function Page() {
const [mountSecondRequest, setMountSecondRequest] = React.useState(false)
return (
<>
<Foo />,{mountSecondRequest ? <Foo /> : null}
<br />
<button onClick={() => setMountSecondRequest(true)}>start</button>
</>
)
}
renderWithConfig(<Page />)
screen.getByText('validating,')
await executeWithoutBatching(() => sleep(70))
screen.getByText('stopped,')
fireEvent.click(screen.getByText('start'))
await screen.findByText('validating,validating')
// Pause before it resolves
paused = true
await executeWithoutBatching(() => sleep(50))
// They should both stop
screen.getByText('stopped,stopped')
})
it('should not trigger loading state when revalidating', async () => {
const key = createKey()
let renderCount = 0
function Page() {
const { isLoading, isValidating, mutate } = useSWR(key, () =>
createResponse('data', { delay: 10 })
)
renderCount++
return (
<div>
<div>
{isLoading ? 'loading' : 'ready'},
{isValidating ? 'validating' : 'ready'}
</div>
<button onClick={() => mutate()}>revalidate</button>
</div>
)
}
renderWithConfig(<Page />)
screen.getByText('loading,validating')
await screen.findByText('ready,ready')
fireEvent.click(screen.getByText('revalidate'))
screen.getByText('ready,validating')
await screen.findByText('ready,ready')
// isValidating: true -> false -> true -> false
expect(renderCount).toBe(4)
})
it('should trigger loading state when changing the key', async () => {
function Page() {
const [key, setKey] = React.useState(createKey)
const { isLoading, isValidating } = useSWR(key, () =>
createResponse('data', { delay: 10 })
)
return (
<div>
<div>
{isLoading ? 'loading' : 'ready'},
{isValidating ? 'validating' : 'ready'}
</div>
<button onClick={() => setKey(createKey())}>update key</button>
</div>
)
}
renderWithConfig(<Page />)
screen.getByText('loading,validating')
await screen.findByText('ready,ready')
fireEvent.click(screen.getByText('update key'))
screen.getByText('loading,validating')
await screen.findByText('ready,ready')
})
it('isLoading and isValidating should always respect cache value', async () => {
const key = createKey()
const Page = () => {
const { data } = useSWR(key, () =>
createResponse('result', { delay: 10 })
)
const { data: response } = useSWR(data, () =>
createResponse('data', { delay: 10 })
)
// eslint-disable-next-line react/display-name
const Component = ((_: any) => () => {
const {
data: result,
isLoading,
isValidating
// eslint-disable-next-line react-hooks/rules-of-hooks
} = useSWR(key, () => createResponse('result', { delay: 10 }))
return (
<div>{`result is ${
result ? result : 'null'
},${isLoading},${isValidating}`}</div>
)
})(response)
return <Component></Component>
}
renderWithConfig(<Page />)
screen.getByText('result is null,true,true')
await screen.findByText('result is result,false,false')
})
it('isLoading should be false when key is null', () => {
function Page() {
const { isLoading } = useSWR(null, () => 'data')
return <div>isLoading:{String(isLoading)}</div>
}
renderWithConfig(<Page />)
screen.getByText('isLoading:false')
})
it('isLoading should be false when the key function throws an error', () => {
function Page() {
const { isLoading } = useSWR(
() => {
throw new Error('error')
},
() => 'data'
)
return <div>isLoading:{String(isLoading)}</div>
}
renderWithConfig(<Page />)
screen.getByText('isLoading:false')
})
})
|
319 | 0 | petrpan-code/vercel/swr | petrpan-code/vercel/swr/test/use-swr-local-mutation.test.tsx | import { act, screen, fireEvent } from '@testing-library/react'
import { useEffect, useState } from 'react'
import useSWR, { mutate as globalMutate, useSWRConfig } from 'swr'
import useSWRInfinite from 'swr/infinite'
import { serialize } from 'swr/_internal'
import {
createResponse,
sleep,
nextTick,
createKey,
renderWithConfig,
renderWithGlobalCache,
executeWithoutBatching
} from './utils'
describe('useSWR - local mutation', () => {
it('should trigger revalidation programmatically', async () => {
let value = 0,
mutate
const key = createKey()
function Page() {
mutate = useSWRConfig().mutate
const { data } = useSWR(key, () => value++, {
dedupingInterval: 0
})
return <div>data: {data}</div>
}
renderWithConfig(<Page />)
// hydration
screen.getByText('data:')
// mount
await screen.findByText('data: 0')
act(() => {
// mutate and revalidate
mutate(key)
})
await screen.findByText('data: 1')
})
it('should share local state when no fetcher is specified', async () => {
const baseKey = createKey()
const useSharedState = (key, fallbackData) => {
const { data: state, mutate: setState } = useSWR(`${baseKey}--${key}`, {
fallbackData
})
return [state, setState]
}
function Page() {
const [name, setName] = useSharedState('name', 'huozhi')
const [job, setJob] = useSharedState('job', 'gardener')
return (
<span
onClick={() => {
setName('@huozhi')
setJob('chef')
}}
>
{`${name}:${job}`}
</span>
)
}
renderWithConfig(<Page />)
const root = screen.getByText('huozhi:gardener')
fireEvent.click(root)
await screen.findByText('@huozhi:chef')
})
it('should trigger revalidation programmatically within a dedupingInterval', async () => {
let value = 0,
mutate
const key = createKey()
function Page() {
mutate = useSWRConfig().mutate
const { data } = useSWR(key, () => value++, {
dedupingInterval: 2000
})
return <div>data: {data}</div>
}
renderWithConfig(<Page />)
// hydration
screen.getByText('data:')
// mount
await screen.findByText('data: 0')
act(() => {
// trigger revalidation
mutate(key)
})
await screen.findByText('data: 1')
})
it('should mutate the cache and revalidate', async () => {
let value = 0,
mutate
const key = createKey()
function Page() {
mutate = useSWRConfig().mutate
const { data } = useSWR(key, () => value++, {
dedupingInterval: 0
})
return <div>data: {data}</div>
}
renderWithConfig(<Page />)
// hydration
screen.getByText('data:')
// mount
await screen.findByText('data: 0')
act(() => {
// mutate and revalidate
mutate(key, 'mutate')
})
await screen.findByText('data: 1')
})
it('should dedupe extra requests after mutation', async () => {
let value = 0,
mutate
const key = createKey()
function Page() {
mutate = useSWRConfig().mutate
const { data } = useSWR(key, () => value++, {
dedupingInterval: 2000
})
useSWR(key, () => value++, {
dedupingInterval: 2000
})
return <div>data: {data}</div>
}
renderWithConfig(<Page />)
// hydration
screen.getByText('data:')
// mount
await screen.findByText('data: 0')
act(() => {
// mutate and revalidate
mutate(key)
})
await screen.findByText('data: 1')
})
it('should mutate the cache and revalidate in async', async () => {
let mutate
const key = createKey()
function Page() {
mutate = useSWRConfig().mutate
const { data } = useSWR(key, () => createResponse('truth'), {
dedupingInterval: 0
})
return <div>data: {data}</div>
}
renderWithConfig(<Page />)
// hydration
screen.getByText('data:')
// mount
await screen.findByText('data: truth')
act(() => {
// mutate and revalidate
mutate(key, 'local')
})
await screen.findByText('data: local')
// recovers
await screen.findByText('data: truth')
})
it('should support async mutation with promise', async () => {
let mutate
const key = createKey()
function Page() {
mutate = useSWRConfig().mutate
const { data } = useSWR(key, () => 0, {
dedupingInterval: 0
})
return <div>data: {data}</div>
}
renderWithConfig(<Page />)
// hydration
screen.getByText('data:')
// mount
await screen.findByText('data: 0')
await nextTick()
await act(() => {
// mutate and revalidate
return mutate(key, createResponse(999), false)
})
await screen.findByText('data: 999')
})
it('should support async mutation with async function', async () => {
let mutate
const key = createKey()
function Page() {
mutate = useSWRConfig().mutate
const { data } = useSWR(key, () => 0, {
dedupingInterval: 0
})
return <div>data: {data}</div>
}
renderWithConfig(<Page />)
// hydration
screen.getByText('data:')
// mount
await screen.findByText('data: 0')
await nextTick()
await act(() => {
// mutate and revalidate
return mutate(key, async () => createResponse(999), false)
})
await screen.findByText('data: 999')
})
it('should trigger on mutation without data', async () => {
let value = 0,
mutate
const key = createKey()
function Page() {
mutate = useSWRConfig().mutate
const { data } = useSWR(key, () => value++, {
dedupingInterval: 0
})
return <div>data: {data}</div>
}
renderWithConfig(<Page />)
// hydration
screen.getByText('data:')
// mount
await screen.findByText('data: 0')
act(() => {
// trigger revalidation
mutate(key)
})
await screen.findByText('data: 1')
})
it('should call function as data passing current cached value', async () => {
let mutate
const key = createKey()
function Page() {
mutate = useSWRConfig().mutate
const { data } = useSWR(key, null)
return <div>data: {data}</div>
}
// Prefill the cache with data
renderWithConfig(<Page />, {
provider: () => new Map([[key, { data: 'cached data' }]])
})
const callback = jest.fn()
await act(() => mutate(key, callback))
expect(callback).toHaveBeenCalledWith('cached data')
})
it('should call function with undefined if key not cached', async () => {
let cache, mutate
function App() {
const { cache: cache_, mutate: mutate_ } = useSWRConfig()
cache = cache_
mutate = mutate_
return null
}
renderWithConfig(<App />)
const increment = jest.fn(currentValue =>
currentValue == null ? undefined : currentValue + 1
)
const key = createKey()
await mutate(key, increment, false)
expect(increment).toHaveBeenCalledTimes(1)
expect(increment).toHaveBeenLastCalledWith(undefined)
expect(increment).toHaveLastReturnedWith(undefined)
cache.set(key, { ...cache.get(key), data: 42 })
await mutate(key, increment, false)
expect(increment).toHaveBeenCalledTimes(2)
expect(increment).toHaveBeenLastCalledWith(42)
expect(increment).toHaveLastReturnedWith(43)
})
it('should return results of the mutation', async () => {
const key = createKey()
// returns the data if the promise resolved
expect(globalMutate(key, Promise.resolve('data'))).resolves.toBe('data')
// throw the error if the promise rejected
expect(
globalMutate(key, Promise.reject(new Error('error')))
).rejects.toBeInstanceOf(Error)
})
it('globalMutate should return undefined if the key is serialized to "" ', async () => {
// returns the data if the promise resolved
expect(globalMutate(null, Promise.resolve('data'))).resolves.toBe(undefined)
// throw the error if the promise rejected
const e = new Error('error')
expect(
globalMutate(() => {
throw e
}, Promise.resolve('data'))
).rejects.toEqual(e)
})
it('should get bound mutate from useSWR', async () => {
const key = createKey()
function Page() {
// eslint-disable-next-line no-shadow
const { data, mutate: boundMutate } = useSWR(key, () => 'fetched')
return (
<div onClick={() => boundMutate('mutated', false)}>data: {data}</div>
)
}
renderWithConfig(<Page />)
// hydration
screen.getByText('data:')
// mount
await screen.findByText('data: fetched')
// call bound mutate
fireEvent.click(screen.getByText('data: fetched'))
// expect a new updated value (after a tick)
await screen.findByText('data: mutated')
})
it('should ignore in flight requests when mutating', async () => {
const key = createKey()
// set it to 1
act(() => {
globalMutate(key, 1)
})
function Section() {
const { data } = useSWR(key, () => createResponse(2, { delay: 150 }))
return <div>{data}</div>
}
renderWithGlobalCache(<Section />)
screen.getByText('1') // directly from cache
await act(() => sleep(100)) // still suspending
act(() => {
globalMutate(key, 3)
}) // set it to 3. this will drop the ongoing request
await screen.findByText('3')
await act(() => sleep(100))
screen.getByText('3')
})
it('should ignore in flight mutations when calling another async mutate', async () => {
let value = 'off',
mutate
const key = createKey()
function Page() {
mutate = useSWRConfig().mutate
const { data } = useSWR(key, () => createResponse(value, { delay: 100 }))
return <div>{data}</div>
}
renderWithConfig(<Page />)
await screen.findByText('off') // Initial state
act(() => {
mutate(key, 'on', false)
})
// Validate local state is now "on"
await screen.findByText('on')
// Simulate toggling "on"
await act(async () => {
expect(
mutate(
key,
() => {
value = 'on'
return createResponse('on', { delay: 100 })
},
false
)
).resolves.toBe('on')
})
act(() => {
mutate(key, 'off', false)
})
// Validate local state is now "off"
await screen.findByText('off')
// Simulate toggling "off"
await act(async () => {
expect(
mutate(
key,
() => {
value = 'off'
return createResponse('off', { delay: 100 })
},
false
)
).resolves.toBe('off')
})
// Wait for toggling "on" promise to resolve, but the "on" mutation is canceled
await act(() => sleep(50))
screen.getByText('off')
// Wait for toggling "off" promise to resolve
await act(() => sleep(100))
screen.getByText('off')
})
it('null is stringified when found inside an array', async () => {
let value = 0,
mutate
function Page() {
mutate = useSWRConfig().mutate
const { data } = useSWR([null], () => value++, {
dedupingInterval: 0
})
return <div>data: {data}</div>
}
renderWithConfig(<Page />)
// hydration
screen.getByText('data:')
// mount
await screen.findByText('data: 0')
act(() => {
// trigger revalidation
mutate([null])
})
await screen.findByText('data: 1')
})
it('should return promise from mutate without data', async () => {
let value = 0,
mutate
const key = createKey()
function Page() {
mutate = useSWRConfig().mutate
const { data } = useSWR(key, () => value++, {
dedupingInterval: 0
})
return <div>data: {data}</div>
}
renderWithConfig(<Page />)
screen.getByText('data:')
// mount
await screen.findByText('data: 0')
let promise
await act(() => {
promise = mutate(key)
return promise
})
expect(promise).toBeInstanceOf(Promise) // mutate returns a promise
expect(promise).resolves.toBe(1) // the return value should be the new cache
screen.getByText('data: 1')
})
it('should not update error in global cache when mutate failed with error', async () => {
const value = 0
const key = createKey()
const message = 'mutate-error'
let cache, mutate
function Page() {
const { cache: cache_, mutate: mutate_ } = useSWRConfig()
cache = cache_
mutate = mutate_
const { data, error } = useSWR(key, () => value)
return <div>{error ? error.message : `data: ${data}`}</div>
}
renderWithConfig(<Page />)
// Mount
await screen.findByText('data: 0')
await act(async () => {
// mutate error will be thrown, add try catch to avoid crashing
try {
await mutate(
key,
() => {
throw new Error(message)
},
false
)
} catch (e) {
// do nothing
}
})
screen.getByText('data: 0')
const [keyInfo] = serialize(key)
const cacheError = cache.get(keyInfo)?.error
expect(cacheError).toBeUndefined()
})
it('should update error in global cache when mutate succeeded', async () => {
const key = createKey()
let mutate
function Page() {
const {
data,
error,
mutate: mutate_
} = useSWR<string>(key, async () => {
throw new Error('error')
})
mutate = mutate_
return <div>{error ? error.message : `data: ${data}`}</div>
}
renderWithConfig(<Page />)
// Mount
await screen.findByText('error')
mutate(v => v, { revalidate: false })
await screen.findByText('data: undefined')
})
it('should keep the `mutate` function referential equal', async () => {
const refs = []
let mutate
const updatedKey = createKey()
function Section() {
mutate = useSWRConfig().mutate
const [key, setKey] = useState(null)
const { data, mutate: boundMutate } = useSWR(key, () => createResponse(1))
useEffect(() => {
const timeout = setTimeout(() => setKey(updatedKey), 50)
return () => clearTimeout(timeout)
}, [])
refs.push(boundMutate)
return <div>{data}</div>
}
renderWithConfig(<Section />)
await act(() => sleep(100))
act(() => {
mutate(updatedKey, 2)
})
await act(() => sleep(50))
// check all `setSize`s are referential equal.
for (const ref of refs) {
expect(ref).toEqual(refs[0])
}
})
// https://github.com/vercel/swr/pull/1003
it.skip('should not dedupe synchronous mutations', async () => {
const mutationRecivedValues = []
const renderRecivedValues = []
const key = createKey()
function Component() {
const { data, mutate: boundMutate } = useSWR(key, () => 0)
useEffect(() => {
setTimeout(() => {
// let's mutate twice, synchronously
boundMutate(v => {
mutationRecivedValues.push(v) // should be 0
return 1
}, false)
boundMutate(v => {
mutationRecivedValues.push(v) // should be 1
return 2
}, false)
}, 1)
// the mutate function is guaranteed to be the same reference
// eslint-disable-next-line react-hooks/exhaustive-deps
}, [])
renderRecivedValues.push(data) // should be 0 -> 2, never render 1 in between
return null
}
renderWithConfig(<Component />)
await executeWithoutBatching(() => sleep(50))
expect(mutationRecivedValues).toEqual([0, 1])
expect(renderRecivedValues).toEqual([undefined, 0, 1, 2])
})
it('async mutation case 1 (startAt <= MUTATION_TS[key])', async () => {
let result = 0
const key = createKey()
const fetcher = jest.fn(createResponse)
function Component() {
const { data, mutate: boundMutate } = useSWR(
key,
() =>
fetcher(0, {
delay: 300
}),
{
dedupingInterval: 200
}
)
return (
<div
onClick={() => {
boundMutate(async () => {
result += 1
return createResponse(result, {
delay: 100
})
}, false)
}}
>
{data !== undefined ? `data: ${data.toString()}` : 'loading'}
</div>
)
}
renderWithConfig(<Component />)
screen.getByText('loading')
await act(() => sleep(50))
fireEvent.click(screen.getByText('loading'))
await act(() => sleep(100))
// mutate success
await screen.findByText('data: 1')
await act(() => sleep(150))
// fetcher result should be ignored
expect(fetcher).toBeCalledTimes(1)
await screen.findByText('data: 1')
})
it('async mutation case 2 (startAt <= MUTATION_END_TS[key])', async () => {
let result = 0,
mutate
const fetcher = jest.fn(createResponse)
const updatedKey = createKey()
function Component() {
const [key, setKey] = useState(null)
mutate = useSWRConfig().mutate
const { data } = useSWR(
key,
() =>
fetcher(0, {
delay: 400
}),
{
dedupingInterval: 200
}
)
useEffect(() => {
mutate(
updatedKey,
async () => {
result += 1
return createResponse(result, {
delay: 200
})
},
false
)
setKey(updatedKey)
}, [])
return (
<div>{data !== undefined ? `data: ${data.toString()}` : 'loading'}</div>
)
}
renderWithConfig(<Component />)
screen.getByText('loading')
// mutate success
await act(() => sleep(200))
fireEvent.click(screen.getByText('data: 1'))
// fetcher result should be ignored
await act(() => sleep(200))
expect(fetcher).toBeCalledTimes(1)
await screen.findByText('data: 1')
})
it('async mutation case 3 (MUTATION_END_TS[key] === 0)', async () => {
let result = 0,
mutate
const fetcher = jest.fn(createResponse)
const updatedKey = createKey()
function Component() {
const [key, setKey] = useState(null)
mutate = useSWRConfig().mutate
const { data } = useSWR(
key,
() =>
fetcher(0, {
delay: 100
}),
{
dedupingInterval: 200
}
)
useEffect(() => {
setKey(updatedKey)
mutate(
updatedKey,
async () => {
result += 1
return createResponse(result, { delay: 200 })
},
false
)
}, [])
return (
<div>{data !== undefined ? `data: ${data.toString()}` : 'loading'}</div>
)
}
renderWithConfig(<Component />)
screen.getByText('loading')
// fetcher result should be ignored
await act(() => sleep(100))
expect(fetcher).toBeCalledTimes(1)
screen.getByText('loading')
// mutate success
await act(() => sleep(100))
await screen.findByText('data: 1')
})
it('isValidating should be false when no fetcher is provided', async () => {
const key = createKey()
function Page() {
const { isValidating } = useSWR(key)
return <p>{isValidating.toString()}</p>
}
renderWithConfig(<Page />)
screen.getByText('false')
})
it('bound mutate should always use the latest key', async () => {
const key = createKey()
const fetcher = jest.fn(() => 'data')
function Page() {
const [ready, setReady] = useState(false)
const { mutate: boundMutate } = useSWR(ready ? key : null, fetcher)
return (
<div>
<button onClick={() => setReady(true)}>set ready</button>
<button onClick={() => boundMutate()}>mutate</button>
</div>
)
}
renderWithConfig(<Page />)
screen.getByText('set ready')
expect(fetcher).toBeCalledTimes(0)
// it should trigger the fetch
fireEvent.click(screen.getByText('set ready'))
await act(() => sleep(10))
expect(fetcher).toBeCalledTimes(1)
// it should trigger the fetch again
fireEvent.click(screen.getByText('mutate'))
await act(() => sleep(10))
expect(fetcher).toBeCalledTimes(2)
})
it('should reset isValidating after mutate', async () => {
const key = createKey()
function Data() {
const { data, isValidating } = useSWR(key, () =>
createResponse('data', { delay: 30 })
)
const { cache } = useSWRConfig()
const [keyInfo] = serialize(key)
const cacheIsValidating = cache.get(keyInfo)?.isValidating
return (
<>
<p>data:{data}</p>
<p>isValidating:{isValidating.toString()}</p>
<p>cache:validating:{cacheIsValidating.toString()}</p>
</>
)
}
function Page() {
const { mutate: boundMutate } = useSWR(key, () =>
createResponse('data', { delay: 30 })
)
const [visible, setVisible] = useState(false)
return (
<div>
<button onClick={() => boundMutate(() => 'data', false)}>
preload
</button>
<button onClick={() => setVisible(true)}>show</button>
{visible && <Data />}
</div>
)
}
renderWithConfig(<Page />)
fireEvent.click(screen.getByText('preload'))
await act(() => sleep(20))
fireEvent.click(screen.getByText('show'))
screen.getByText('data:data')
screen.getByText('isValidating:true')
await act(() => sleep(20))
screen.getByText('data:data')
screen.getByText('isValidating:false')
})
it('should be able to mutate data to undefined', async () => {
const key = createKey()
function Page() {
const { data, mutate } = useSWR(key, () => 'foo')
return (
<>
<div>data: {String(data)}</div>
<button onClick={() => mutate(undefined, false)}>mutate</button>
</>
)
}
renderWithConfig(<Page />)
await screen.findByText('data: foo')
fireEvent.click(screen.getByText('mutate'))
await screen.findByText('data: undefined')
})
it('should be able to mutate data to undefined asynchronously', async () => {
const key = createKey()
function Page() {
const { data, mutate } = useSWR(key, () => 'foo')
return (
<>
<div>data: {String(data)}</div>
<button
onClick={() =>
mutate(
() => new Promise(res => setTimeout(() => res(undefined), 10)),
false
)
}
>
mutate
</button>
</>
)
}
renderWithConfig(<Page />)
await screen.findByText('data: foo')
fireEvent.click(screen.getByText('mutate'))
await screen.findByText('data: undefined')
})
// https://github.com/vercel/swr/issues/482
it('should be able to deduplicate multiple mutate calls', async () => {
const key = createKey()
const loggedData = []
function Page() {
const { data, mutate } = useSWR(key, () => 'foo')
useEffect(() => {
async function startMutation() {
await sleep(10)
mutate('sync1', false)
mutate(createResponse('async1', { delay: 50 }), false)
await sleep(10)
mutate('sync2', false)
mutate(createResponse('async2', { delay: 50 }), false)
await sleep(10)
mutate('sync3', false)
mutate(createResponse('async3', { delay: 50 }), false)
}
startMutation()
}, [mutate])
loggedData.push(data)
return null
}
renderWithConfig(<Page />)
await executeWithoutBatching(() => sleep(200))
// Only "async3" is left and others were deduped.
expect(loggedData).toEqual([
undefined,
'foo',
'sync1',
'sync2',
'sync3',
'async3'
])
})
it('should ignore in flight mutation error when calling another async mutate', async () => {
const key = createKey()
const errorMutate = () =>
new Promise<string>((_, reject) => {
setTimeout(() => reject('error'), 200)
})
const successMutate = () =>
new Promise<string>(resolve => {
setTimeout(() => resolve('success'), 100)
})
function Page() {
const { data, mutate: boundMutate } = useSWR(key, () =>
createResponse('data', { delay: 100 })
)
return (
<div>
<div>{data}</div>
<button
onClick={() => {
boundMutate(successMutate, false)
}}
>
success-mutate
</button>
<button
onClick={() => {
boundMutate(errorMutate, false).catch(() => {})
}}
>
error-mutate
</button>
</div>
)
}
renderWithConfig(<Page />)
await screen.findByText('data')
fireEvent.click(screen.getByText('error-mutate'))
await sleep(50)
fireEvent.click(screen.getByText('success-mutate'))
await screen.findByText('success')
await sleep(300)
await screen.findByText('success')
})
it('should not update the cache when `populateCache` is disabled', async () => {
const key = createKey()
function Page() {
const { data, mutate } = useSWR(key, () => 'foo')
return (
<>
<div>data: {String(data)}</div>
<button
onClick={() =>
mutate('bar', {
revalidate: false,
populateCache: false
})
}
>
mutate
</button>
</>
)
}
renderWithConfig(<Page />)
await screen.findByText('data: foo')
fireEvent.click(screen.getByText('mutate'))
await sleep(30)
await screen.findByText('data: foo')
})
it('should support optimistic updates via `optimisticData`', async () => {
const key = createKey()
const renderedData = []
let mutate
function Page() {
const { data, mutate: boundMutate } = useSWR(key, () =>
createResponse('foo', { delay: 20 })
)
mutate = boundMutate
renderedData.push(data)
return <div>data: {String(data)}</div>
}
renderWithConfig(<Page />)
await screen.findByText('data: foo')
await executeWithoutBatching(() =>
mutate(createResponse('baz', { delay: 20 }), {
optimisticData: 'bar'
})
)
await sleep(30)
expect(renderedData).toEqual([undefined, 'foo', 'bar', 'baz', 'foo'])
})
it('should support optimistic updates via function `optimisticData`', async () => {
const key = createKey()
const renderedData = []
let mutate
function Page() {
const { data, mutate: boundMutate } = useSWR(key, () =>
createResponse('foo', { delay: 20 })
)
mutate = boundMutate
renderedData.push(data)
return <div>data: {String(data)}</div>
}
renderWithConfig(<Page />)
await screen.findByText('data: foo')
await executeWithoutBatching(() =>
mutate(createResponse('baz', { delay: 20 }), {
optimisticData: data => 'function_' + data
})
)
await sleep(30)
expect(renderedData).toEqual([
undefined,
'foo',
'function_foo',
'baz',
'foo'
])
})
it('should be able use mutate to manipulate data via function `optimisticData`', async () => {
const key = createKey()
const renderedData = []
function useOptimisticDataMutate(_key, data, fallback) {
const { mutate } = useSWRConfig()
return () => {
return mutate(_key, createResponse(data, { delay: 20 }), {
optimisticData() {
return fallback
}
})
}
}
function Page() {
const mutateWithOptData = useOptimisticDataMutate(key, 'final', 'loading')
const { data } = useSWR(key)
renderedData.push(data)
return (
<div>
<button onClick={() => mutateWithOptData()}>mutate</button>
<div>data: {String(data)}</div>
</div>
)
}
renderWithConfig(<Page />)
fireEvent.click(screen.getByText('mutate'))
await act(() => sleep(30))
expect(renderedData).toEqual([undefined, 'loading', 'final'])
})
it('should be able to use functional optimistic data config and use second param `displayedData` to keep UI consistent in slow networks', async () => {
const key1 = createKey()
const key2 = createKey()
let data1 = 0
let data2 = 0
function useOptimisticData1Mutate() {
const { mutate } = useSWRConfig()
return () => {
return mutate(key1, () => createResponse(data1++, { delay: 1000 }), {
optimisticData(currentData) {
return currentData + 1 // optimistic update current data
}
})
}
}
function useOptimisticData2Mutate() {
const { mutate } = useSWRConfig()
return () => {
return mutate(key2, () => createResponse(data2++, { delay: 1000 }), {
optimisticData(_, displayedData) {
return displayedData + 1 // optimistic update displayed data
}
})
}
}
function Page() {
const mutateWithOptimisticallyUpdatedCurrentData =
useOptimisticData1Mutate()
const mutateWithOptimisticallyUpdatedDisplayedData =
useOptimisticData2Mutate()
const { data: renderedData1 } = useSWR<number>(key1, () =>
createResponse(data1, { delay: 1000 })
)
const { data: renderedData2 } = useSWR<number>(key2, () =>
createResponse(data2, { delay: 1000 })
)
return (
<div>
<button onClick={mutateWithOptimisticallyUpdatedCurrentData}>
incrementCurrent
</button>
<button onClick={mutateWithOptimisticallyUpdatedDisplayedData}>
incrementDisplayed
</button>
<div>
data: <span data-testid="data1">{renderedData1}</span>
</div>
<div>
data: <span data-testid="data2">{renderedData2}</span>
</div>
</div>
)
}
renderWithConfig(<Page />)
await act(() => sleep(1000)) // Wait for initial data to load
fireEvent.click(screen.getByText('incrementCurrent'))
fireEvent.click(screen.getByText('incrementDisplayed'))
fireEvent.click(screen.getByText('incrementCurrent'))
fireEvent.click(screen.getByText('incrementDisplayed'))
const renderedData1 = parseInt(
(await screen.findByTestId('data1')).innerHTML,
10
)
const renderedData2 = Number((await screen.findByTestId('data2')).innerHTML)
await act(() => sleep(2000)) // Wait for revalidation roundtrip
const renderedRevalidatedData1 = Number(
(await screen.findByTestId('data1')).innerHTML
)
const renderedRevalidatedData2 = Number(
(await screen.findByTestId('data2')).innerHTML
)
expect(data1).toEqual(2)
expect(renderedData1).toEqual(1)
expect(renderedRevalidatedData1).toEqual(2)
expect(data2).toEqual(2)
expect(renderedData2).toEqual(2)
expect(renderedRevalidatedData2).toEqual(2)
})
it('should prevent race conditions with optimistic UI', async () => {
const key = createKey()
const renderedData = []
let mutate
function Page() {
const { data, mutate: boundMutate } = useSWR(key, () => Math.random(), {
refreshInterval: 10,
dedupingInterval: 0
})
mutate = boundMutate
renderedData.push(data)
return <div>data: {String(data)}</div>
}
renderWithConfig(<Page />)
await act(() => sleep(20))
await executeWithoutBatching(() =>
mutate(createResponse('end', { delay: 50 }), {
optimisticData: 'start'
})
)
await act(() => sleep(20))
// There can never be any changes during a mutation — it should be atomic.
expect(renderedData.indexOf('end') - renderedData.indexOf('start')).toEqual(
1
)
})
it('should rollback optimistic updates when mutation fails', async () => {
const key = createKey()
const renderedData = []
let mutate
let cnt = 0
function Page() {
const { data, mutate: boundMutate } = useSWR(key, () =>
createResponse(cnt++, { delay: 20 })
)
mutate = boundMutate
if (
!renderedData.length ||
renderedData[renderedData.length - 1] !== data
) {
renderedData.push(data)
}
return <div>data: {String(data)}</div>
}
renderWithConfig(<Page />)
await screen.findByText('data: 0')
try {
await executeWithoutBatching(() =>
mutate(createResponse(new Error('baz'), { delay: 20 }), {
optimisticData: 'bar'
})
)
} catch (e) {
expect(e.message).toEqual('baz')
}
await sleep(30)
expect(renderedData).toEqual([undefined, 0, 'bar', 0, 1])
})
it('should not revert to optimistic data when rolling back', async () => {
const key = createKey()
const renderedData = []
let mutate
let previousValue
let previousValue2
function Page() {
const { data, mutate: boundMutate } = useSWR(key, () =>
createResponse(0, { delay: 20 })
)
mutate = boundMutate
if (
!renderedData.length ||
renderedData[renderedData.length - 1] !== data
) {
renderedData.push(data)
}
return <div>data: {String(data)}</div>
}
renderWithConfig(<Page />)
await screen.findByText('data: 0')
await executeWithoutBatching(async () => {
const p1 = mutate(createResponse(new Error(), { delay: 20 }), {
optimisticData: 1
})
await sleep(10)
const p2 = mutate(
v => {
previousValue = v
return createResponse(new Error(), { delay: 20 })
},
{
optimisticData: v => {
previousValue2 = v
return 2
}
}
)
return Promise.all([p1, p2])
}).catch(_e => {})
await sleep(30)
// It should revert to `0` instead of `1` at the end.
expect(renderedData).toEqual([undefined, 0, 1, 2, 0])
// It should receive the original displayed data instead of the currently displayed data.
expect(previousValue).toBe(0)
expect(previousValue2).toBe(0)
})
it('should rollback to the original value after multiple mutations', async () => {
const key = createKey()
const renderedData = []
let mutate
let serverData = 'foo'
function Page() {
const { data, mutate: boundMutate } = useSWR(key, () =>
createResponse(serverData, { delay: 20 })
)
mutate = boundMutate
if (
!renderedData.length ||
renderedData[renderedData.length - 1] !== data
) {
renderedData.push(data)
}
return <div>data: {String(data)}</div>
}
// data == "foo"
renderWithConfig(<Page />)
await screen.findByText('data: foo')
// data == "bar"
await executeWithoutBatching(async () => {
await mutate(
createResponse('bar', { delay: 20 }).then(r => (serverData = r)),
{
optimisticData: 'bar',
populateCache: false
}
)
})
await sleep(30)
try {
// data == "baz", then reverted back to "bar"
await executeWithoutBatching(() =>
mutate(createResponse(new Error(), { delay: 20 }), {
optimisticData: 'baz',
revalidate: false
})
)
} catch (_) {
// Ignore
}
await sleep(30)
expect(renderedData).toEqual([undefined, 'foo', 'bar', 'baz', 'bar'])
})
it('should rollback to the original value after multiple mutations (2)', async () => {
const key = createKey()
const renderedData = []
let mutate
let serverData = 'foo'
function Page() {
const { data, mutate: boundMutate } = useSWR(key, () =>
createResponse(serverData, { delay: 20 })
)
mutate = boundMutate
if (
!renderedData.length ||
renderedData[renderedData.length - 1] !== data
) {
renderedData.push(data)
}
return <div>data: {String(data)}</div>
}
// data == "foo"
renderWithConfig(<Page />)
await screen.findByText('data: foo')
// Here m1 and m2 overlap and m1 will be discarded.
await executeWithoutBatching(async () => {
const m1 = mutate(
createResponse('bar', { delay: 30 }).then(r => (serverData = r)),
{
optimisticData: 'bar',
populateCache: false
}
)
await sleep(10)
const m2 = mutate(
createResponse('baz', { delay: 30 }).then(r => (serverData = r))
)
await m1
await m2
})
try {
// data == "qux", then reverted back to "baz"
await executeWithoutBatching(() =>
mutate(createResponse(new Error(), { delay: 20 }), {
optimisticData: 'qux',
revalidate: false
})
)
} catch (_) {
// Ignore
}
// data: "foo" -> "bar" -> "baz" -> "qux" -> "baz"
// ^ optimistic ^ error
await sleep(30)
expect(renderedData).toEqual([undefined, 'foo', 'bar', 'baz', 'qux', 'baz'])
})
it('should not rollback optimistic updates if `rollbackOnError` is disabled', async () => {
const key = createKey()
const renderedData = []
let mutate
let cnt = 0
function Page() {
const { data, mutate: boundMutate } = useSWR(key, () =>
createResponse(cnt++, { delay: 20 })
)
mutate = boundMutate
if (
!renderedData.length ||
renderedData[renderedData.length - 1] !== data
) {
renderedData.push(data)
}
return <div>data: {String(data)}</div>
}
renderWithConfig(<Page />)
await screen.findByText('data: 0')
try {
await executeWithoutBatching(() =>
mutate(createResponse(new Error('baz-1'), { delay: 20 }), {
optimisticData: 'bar-1',
rollbackOnError: false
})
)
} catch (e) {
expect(e.message).toEqual('baz-1')
}
await sleep(30)
expect(renderedData).toEqual([undefined, 0, 'bar-1', 1])
let rollbackErrorMessage
try {
await executeWithoutBatching(() =>
mutate(createResponse(new Error('baz-2'), { delay: 20 }), {
optimisticData: 'bar-2',
rollbackOnError: error => {
rollbackErrorMessage = error.message
return false
}
})
)
} catch (e) {
expect(e.message).toEqual('baz-2')
}
await sleep(30)
expect(renderedData).toEqual([undefined, 0, 'bar-1', 1, 'bar-2', 2])
expect(rollbackErrorMessage).toEqual('baz-2')
})
it('should support transforming the result with `populateCache` before writing back', async () => {
const key = createKey()
function Page() {
const { data, mutate } = useSWR(key, () => 'foo')
return (
<>
<div>data: {String(data)}</div>
<button
onClick={() =>
mutate('bar', {
revalidate: false,
populateCache: v => '!' + v
})
}
>
mutate
</button>
</>
)
}
renderWithConfig(<Page />)
await screen.findByText('data: foo')
fireEvent.click(screen.getByText('mutate'))
await sleep(30)
await screen.findByText('data: !bar')
})
it('should support transforming the result with `populateCache` for async data with optimistic data', async () => {
const key = createKey()
const renderedData = []
let mutatePage
function Page() {
const { data, mutate } = useSWR(key, () => 'foo')
mutatePage = () =>
mutate(new Promise(res => setTimeout(() => res('baz'), 20)), {
optimisticData: () => 'bar',
revalidate: false,
populateCache: v => '!' + v
})
renderedData.push(data)
return null
}
renderWithConfig(<Page />)
await act(() => sleep(10))
await executeWithoutBatching(() => mutatePage())
await sleep(30)
expect(renderedData).toEqual([undefined, 'foo', 'bar', '!baz'])
})
it('should pass the original data snapshot to `populateCache` as the second parameter', async () => {
const key = createKey()
const renderedData = []
let serverData = ['Apple', 'Banana']
let appendData
const sendRequest = (newItem: string) => {
return new Promise<string>(res =>
setTimeout(() => {
// The server capitalizes the new item.
const modifiedData =
newItem.charAt(0).toUpperCase() + newItem.slice(1)
serverData = [...serverData, modifiedData]
res(modifiedData)
}, 20)
)
}
function Page() {
const { mutate } = useSWRConfig()
const { data } = useSWR(key, () => serverData)
appendData = () => {
return mutate<string[], string>(key, sendRequest('cherry'), {
optimisticData: [...data, 'cherry (optimistic)'],
populateCache: (result, currentData) => [
...currentData,
result + ' (res)'
],
revalidate: true
})
}
renderedData.push(data)
return null
}
renderWithConfig(<Page />)
await executeWithoutBatching(async () => {
await sleep(10)
await appendData()
await sleep(30)
})
expect(renderedData).toEqual([
undefined, // fetching
['Apple', 'Banana'], // initial data
['Apple', 'Banana', 'cherry (optimistic)'], // optimistic data
['Apple', 'Banana', 'Cherry (res)'], // appended server response
['Apple', 'Banana', 'Cherry'] // revalidated data
])
})
it('should support key filter as first argument', async () => {
const key = createKey()
const mutationAllResults = []
const mutationOneResults = []
function Page() {
const { data: data1 } = useSWR(key + 'first', v => v)
const { data: data2 } = useSWR(key + 'second', v => v)
const { mutate } = useSWRConfig()
return (
<div>
<span
data-testid="mutator-filter-all"
onClick={async () => {
const res = await mutate(
k => typeof k === 'string' && k.startsWith(key),
data => {
return 'value-' + data.replace(key, '')
},
false
)
mutationAllResults.push(...res)
}}
/>
<span
data-testid="mutator-filter-one"
onClick={async () => {
const res = await mutate(
k => typeof k === 'string' && k.includes('first'),
() => 'value-first-g0',
false
)
mutationOneResults.push(...res)
}}
/>
<p>first:{data1}</p>
<p>second:{data2}</p>
</div>
)
}
renderWithConfig(<Page />)
screen.getByText('first:')
screen.getByText('second:')
await nextTick()
// filter and mutate `first` and `second`
fireEvent.click(screen.getByTestId('mutator-filter-all'))
await nextTick()
await screen.findByText('first:value-first')
await screen.findByText('second:value-second')
expect(mutationAllResults).toEqual(['value-first', 'value-second'])
// only filter and mutate `first`
fireEvent.click(screen.getByTestId('mutator-filter-one'))
await nextTick()
await screen.findByText('first:value-first-g0')
await screen.findByText('second:value-second')
expect(mutationOneResults).toEqual(['value-first-g0'])
})
it('should remove all key value pairs when clear cache through key filter', async () => {
const key = createKey()
const mutationOneResults = []
function Page() {
const { data: data1 } = useSWR(key + 'first')
const { data: data2 } = useSWR(key + 'second')
const { mutate } = useSWRConfig()
return (
<div>
<span
data-testid="mutator-filter-all"
onClick={async () => {
const promises = ['first', 'second'].map(async name => {
await mutate(key + name, `value-${name}`, false)
})
await Promise.all(promises)
}}
/>
<span
data-testid="clear-all"
onClick={async () => {
const res = await mutate(() => true, undefined, false)
mutationOneResults.push(...res)
}}
/>
<p>first:{data1}</p>
<p>second:{data2}</p>
</div>
)
}
renderWithConfig(<Page />)
// add and mutate `first` and `second`
fireEvent.click(screen.getByTestId('mutator-filter-all'))
await nextTick()
await screen.findByText('first:value-first')
await screen.findByText('second:value-second')
// reset all keys to undefined
fireEvent.click(screen.getByTestId('clear-all'))
await nextTick()
await screen.findByText('first:')
await screen.findByText('second:')
expect(mutationOneResults).toEqual([undefined])
})
it('should pass the original key to the key filter', async () => {
const key = createKey()
const keys = []
function Page() {
useSWR([key, 'first'])
useSWR([key, 'second'])
useSWR(key)
const { mutate } = useSWRConfig()
return (
<span
data-testid="mutator-filter-all"
onClick={() => {
mutate(
k => {
keys.push(k)
return false
},
undefined,
false
)
}}
/>
)
}
renderWithConfig(<Page />)
// add and mutate `first` and `second`
fireEvent.click(screen.getByTestId('mutator-filter-all'))
await nextTick()
expect(keys).toEqual([[key, 'first'], [key, 'second'], key])
})
it('should skip speicla useSWRInfinite keys', async () => {
const key = createKey()
const keys = []
function Page() {
useSWR([key, 'first'])
useSWR([key, 'second'])
useSWR(key)
useSWRInfinite(
i => [key, 'inf', i],
k => k,
{ initialSize: 2 }
)
const { mutate } = useSWRConfig()
return (
<span
data-testid="mutator-filter-all"
onClick={() => {
mutate(
k => {
keys.push(k)
return false
},
undefined,
false
)
}}
/>
)
}
renderWithConfig(<Page />)
await nextTick()
// add and mutate `first` and `second`
fireEvent.click(screen.getByTestId('mutator-filter-all'))
expect(keys).toEqual([
[key, 'first'],
[key, 'second'],
key,
[key, 'inf', 0],
[key, 'inf', 1]
])
})
})
|
320 | 0 | petrpan-code/vercel/swr | petrpan-code/vercel/swr/test/use-swr-middlewares.test.tsx | import { act, screen } from '@testing-library/react'
import { useState, useEffect, useRef } from 'react'
import type { Middleware } from 'swr'
import useSWR, { SWRConfig } from 'swr'
import { withMiddleware } from 'swr/_internal'
import {
createResponse,
sleep,
createKey,
nextTick,
renderWithConfig
} from './utils'
describe('useSWR - middleware', () => {
it('should use middleware', async () => {
const key = createKey()
const mockConsoleLog = jest.fn(s => s)
const loggerMiddleware: Middleware = useSWRNext => (k, fn, config) => {
mockConsoleLog(k)
return useSWRNext(k, fn, config)
}
function Page() {
const { data } = useSWR(key, () => createResponse('data'), {
use: [loggerMiddleware]
})
return <div>hello, {data}</div>
}
renderWithConfig(<Page />)
screen.getByText('hello,')
await screen.findByText('hello, data')
expect(mockConsoleLog.mock.calls[0][0]).toBe(key)
// Initial render and data ready.
expect(mockConsoleLog.mock.calls.length).toBe(2)
})
it('should pass original keys to middleware', async () => {
const key = createKey()
const mockConsoleLog = jest.fn(s => s)
const loggerMiddleware: Middleware = useSWRNext => (k, fn, config) => {
mockConsoleLog(k)
return useSWRNext(k, fn, config)
}
function Page() {
const { data } = useSWR([key, 1, 2, 3], () => createResponse('data'), {
use: [loggerMiddleware]
})
return <div>hello, {data}</div>
}
renderWithConfig(<Page />)
screen.getByText('hello,')
await screen.findByText('hello, data')
expect(mockConsoleLog.mock.calls[0][0]).toEqual([key, 1, 2, 3])
// Initial render and data ready.
expect(mockConsoleLog.mock.calls.length).toBe(2)
})
it('should pass null fetcher to middleware', () => {
const key = createKey()
const mockConsoleLog = jest.fn(s => s)
const loggerMiddleware: Middleware = useSWRNext => (k, fn, config) => {
mockConsoleLog(fn)
return useSWRNext(k, fn, config)
}
function Page() {
const { data } = useSWR(key, null, {
use: [loggerMiddleware]
})
return <div>hello, {data}</div>
}
renderWithConfig(<Page />)
screen.getByText('hello,')
expect(mockConsoleLog.mock.calls[0][0]).toEqual(null)
})
it('should support `use` option in context', async () => {
const key = createKey()
const mockConsoleLog = jest.fn(s => s)
const loggerMiddleware: Middleware = useSWRNext => (k, fn, config) => {
mockConsoleLog(k)
return useSWRNext(k, fn, config)
}
function Page() {
const { data } = useSWR(key, () => createResponse('data'))
return <div>hello, {data}</div>
}
renderWithConfig(<Page />, { use: [loggerMiddleware] })
screen.getByText('hello,')
await screen.findByText('hello, data')
expect(mockConsoleLog.mock.calls[0][0]).toBe(key)
expect(mockConsoleLog.mock.calls.length).toBe(2)
})
it('should support extending middleware via context and per-hook config', async () => {
const key = createKey()
const mockConsoleLog = jest.fn((_, s) => s)
const createLoggerMiddleware =
(id: number): Middleware =>
useSWRNext =>
(k, fn, config) => {
mockConsoleLog(id, k)
return useSWRNext(k, fn, config)
}
function Page() {
const { data } = useSWR(key, () => createResponse('data'), {
use: [createLoggerMiddleware(0)]
})
return <div>hello, {data}</div>
}
renderWithConfig(
<SWRConfig value={{ use: [createLoggerMiddleware(2)] }}>
<SWRConfig value={{ use: [createLoggerMiddleware(1)] }}>
<Page />
</SWRConfig>
</SWRConfig>
)
screen.getByText('hello,')
await screen.findByText('hello, data')
expect(mockConsoleLog.mock.calls.map(call => call[0])).toEqual([
2, 1, 0, 2, 1, 0
])
})
it('should use the correct middleware order in `withMiddleware`', async () => {
const key = createKey()
const mockConsoleLog = jest.fn((_, s) => s)
const createLoggerMiddleware =
(id: number): Middleware =>
useSWRNext =>
(k, fn, config) => {
mockConsoleLog(id + '-enter', k)
const swr = useSWRNext(k, fn, config)
mockConsoleLog(id + '-exit', k)
return swr
}
const customSWRHook = withMiddleware(useSWR, useSWRNext => (...args) => {
mockConsoleLog('0-enter', args[0])
const swr = useSWRNext(...args)
mockConsoleLog('0-exit', args[0])
return swr
})
function Page() {
const { data } = customSWRHook(key, () => createResponse('data'), {
use: [createLoggerMiddleware(1)]
})
return <div>hello, {data}</div>
}
renderWithConfig(<Page />, { use: [createLoggerMiddleware(2)] })
screen.getByText('hello,')
await screen.findByText('hello, data')
expect(mockConsoleLog.mock.calls.map(call => call[0])).toEqual([
'2-enter',
'1-enter',
'0-enter',
'0-exit',
'1-exit',
'2-exit',
'2-enter',
'1-enter',
'0-enter',
'0-exit',
'1-exit',
'2-exit'
])
})
it('should support react hooks inside middleware', async () => {
const key = createKey()
const lazyMiddleware: Middleware = useSWRNext => (k, fn, config) => {
const dataRef = useRef(undefined)
const res = useSWRNext(k, fn, config)
if (res.data) {
dataRef.current = res.data
return res
} else {
return { ...res, data: dataRef.current }
}
}
function Page() {
const [mounted, setMounted] = useState(false)
const { data } = useSWR(`${key}-${mounted ? '1' : '0'}`, k =>
createResponse(k, { delay: 100 })
)
useEffect(() => {
setTimeout(() => setMounted(true), 200)
}, [])
return <div>data:{data}</div>
}
renderWithConfig(<Page />, { use: [lazyMiddleware] })
screen.getByText('data:') // undefined, time=0
await act(() => sleep(150))
screen.getByText(`data:${key}-0`) // 0, time=150
await act(() => sleep(100))
screen.getByText(`data:${key}-0`) // still holding the previous value, even if the key has changed
await act(() => sleep(100))
screen.getByText(`data:${key}-1`) // 1, time=350
})
it('should pass modified keys to the next middleware and useSWR', async () => {
const key = createKey()
const createDecoratingKeyMiddleware =
(c: string): Middleware =>
useSWRNext =>
(k, fn, config) => {
return useSWRNext(`${c}${k}${c}`, fn, config)
}
function Page() {
const { data } = useSWR(key, k => createResponse(k), {
use: [
createDecoratingKeyMiddleware('!'),
createDecoratingKeyMiddleware('#')
]
})
return <div>hello, {data}</div>
}
renderWithConfig(<Page />)
screen.getByText('hello,')
await screen.findByText(`hello, #!${key}!#`)
})
it('should send the non-serialized key to the middleware', async () => {
const key = createKey()
const logger = jest.fn()
const m: Middleware = useSWRNext => (k, fn, config) => {
logger(Array.isArray(k))
return useSWRNext(JSON.stringify(k), _k => fn(...JSON.parse(_k)), config)
}
function Page() {
const { data } = useSWR(
[key, { hello: 'world' }],
(_, o) => {
return o.hello
},
{
use: [m]
}
)
return <div>hello, {data || ''}</div>
}
renderWithConfig(<Page />)
screen.getByText('hello,')
await nextTick()
expect(logger).toBeCalledWith(true)
screen.getByText('hello, world')
})
})
|
321 | 0 | petrpan-code/vercel/swr | petrpan-code/vercel/swr/test/use-swr-node-env.test.tsx | /**
* @jest-environment node
*/
// Do not lint the return value destruction for `renderToString`
/* eslint-disable testing-library/render-result-naming-convention */
import { renderToString } from 'react-dom/server'
import useSWR from 'swr'
import useSWRImmutable from 'swr/immutable'
import { IS_SERVER } from 'swr/_internal'
import { createKey } from './utils'
describe('useSWR', () => {
it('env IS_SERVER is true in node env', () => {
expect(IS_SERVER).toBe(true)
})
it('should render fallback if provided on server side', async () => {
const key = createKey()
const useData = () => useSWR(key, k => k, { fallbackData: 'fallback' })
function Page() {
const { data } = useData()
return <p>{data}</p>
}
const html = renderToString(<Page />)
expect(html).toContain('fallback')
})
it('should not revalidate useSWRImmutable on server side', async () => {
const key = createKey()
const useData = () => useSWRImmutable(key, k => k)
function Page() {
const { data } = useData()
return <p>{data || 'empty'}</p>
}
const html = renderToString(<Page />)
expect(html).toContain('empty')
})
})
|
322 | 0 | petrpan-code/vercel/swr | petrpan-code/vercel/swr/test/use-swr-offline.test.tsx | import { act, screen } from '@testing-library/react'
import useSWR from 'swr'
import {
nextTick as waitForNextTick,
focusOn,
createKey,
renderWithConfig
} from './utils'
const focusWindow = () => focusOn(window)
const dispatchWindowEvent = event =>
act(async () => {
window.dispatchEvent(new Event(event))
})
describe('useSWR - offline', () => {
it('should not revalidate when offline', async () => {
let value = 0
const key = createKey()
function Page() {
const { data } = useSWR(key, () => value++, {
dedupingInterval: 0
})
return <div>data: {data}</div>
}
renderWithConfig(<Page />)
// hydration
screen.getByText('data:')
// mount
await screen.findByText('data: 0')
// simulate offline
await waitForNextTick()
await dispatchWindowEvent('offline')
// trigger focus revalidation
await focusWindow()
// should not be revalidated
screen.getByText('data: 0')
})
it('should revalidate immediately when becoming online', async () => {
let value = 0
const key = createKey()
function Page() {
const { data } = useSWR(key, () => value++, {
dedupingInterval: 0
})
return <div>data: {data}</div>
}
renderWithConfig(<Page />)
// hydration
screen.getByText('data:')
// mount
await screen.findByText('data: 0')
// simulate online
await waitForNextTick()
await dispatchWindowEvent('online')
// should be revalidated
await screen.findByText('data: 1')
})
})
|
Subsets and Splits