Integration testing

The flow of operations

The flow for running said tests goes as follows:

1. Start the container and create the database
2. Migrate the schema
3. Run the tests
4. Destroy the container

Each test suite will seed the database before all the test are run. After all the tests in the suite have finished, the data from all the tables will be dropped and the connection terminated.

The function to test

The ecommerce application you are testing has a function which creates an order. This function does the following:

• Accepts input about the customer making the order
• Accepts input about the product being ordered
• Checks if the customer has an existing account
• Checks if the product is in stock
• Returns an "Out of stock" message if the product doesn't exist
• Creates an account if the customer doesn't exist in the database
• Create the order

An example of how such a function might look can be seen below:

create-order.ts
1import prisma from '../client'
2
3export interface Customer {
4  id?: number
5  name?: string
6  email: string
7  address?: string
8}
9
10export interface OrderInput {
11  customer: Customer
12  productId: number
13  quantity: number
14}
15
16/**
17 * Creates an order with customer.
18 * @param input The order parameters
19 */
20export async function createOrder(input: OrderInput) {
21  const { productId, quantity, customer } = input
22  const { name, email, address } = customer
23
24  // Get the product
25  const product = await prisma.product.findUnique({
26    where: {
27      id: productId,
28    },
29  })
30
31  // If the product is null its out of stock, return error.
32  if (!product) return new Error('Out of stock')
33
34  // If the customer is new then create the record, otherwise connect via their unique email
35  await prisma.customerOrder.create({
36    data: {
37      customer: {
38        connectOrCreate: {
39          create: {
40            name,
41            email,
42            address,
43          },
44          where: {
45            email,
46          },
47        },
48      },
49      orderDetails: {
50        create: {
51          total: product.price,
52          quantity,
53          products: {
54            connect: {
55              id: product.id,
56            },
57          },
58        },
59      },
60    },
61  })
62}

The test suite

The following tests will check if the createOrder function works as it should do. They will test:

• Creating a new order with a new customer
• Creating an order with an existing customer
• Show an "Out of stock" error message if a product doesn't exist

Before the test suite is run the database is seeded with data. After the test suite has finished a deleteMany is used to clear the database of its data.

__tests__/create-order.ts
1import prisma from '../src/client'
2import { createOrder, Customer, OrderInput } from '../src/functions/index'
3
4beforeAll(async () => {
5  // create product categories
6  await prisma.category.createMany({
7    data: [{ name: 'Wand' }, { name: 'Broomstick' }],
8  })
9
10  console.log('✨ 2 categories successfully created!')
11
12  // create products
13  await prisma.product.createMany({
14    data: [
15      {
16        name: 'Holly, 11", phoenix feather',
17        description: 'Harry Potters wand',
18        price: 100,
19        sku: 1,
20        categoryId: 1,
21      },
22      {
23        name: 'Nimbus 2000',
24        description: 'Harry Potters broom',
25        price: 500,
26        sku: 2,
27        categoryId: 2,
28      },
29    ],
30  })
31
32  console.log('✨ 2 products successfully created!')
33
34  // create the customer
35  await prisma.customer.create({
36    data: {
37      name: 'Harry Potter',
38      email: 'harry@hogwarts.io',
39      address: '4 Privet Drive',
40    },
41  })
42
43  console.log('✨ 1 customer successfully created!')
44})
45
46afterAll(async () => {
47  const deleteOrderDetails = prisma.orderDetails.deleteMany()
48  const deleteProduct = prisma.product.deleteMany()
49  const deleteCategory = prisma.category.deleteMany()
50  const deleteCustomerOrder = prisma.customerOrder.deleteMany()
51  const deleteCustomer = prisma.customer.deleteMany()
52
53  await prisma.$transaction([
54    deleteOrderDetails,
55    deleteProduct,
56    deleteCategory,
57    deleteCustomerOrder,
58    deleteCustomer,
59  ])
60
61  await prisma.$disconnect()
62})
63
64it('should create 1 new customer with 1 order', async () => {
65  // The new customers details
66  const customer: Customer = {
67    id: 2,
68    name: 'Hermione Granger',
69    email: 'hermione@hogwarts.io',
70    address: '2 Hampstead Heath',
71  }
72  // The new orders details
73  const order: OrderInput = {
74    customer,
75    productId: 1,
76    quantity: 1,
77  }
78
79  // Create the order and customer
80  await createOrder(order)
81
82  // Check if the new customer was created by filtering on unique email field
83  const newCustomer = await prisma.customer.findUnique({
84    where: {
85      email: customer.email,
86    },
87  })
88
89  // Check if the new order was created by filtering on unique email field of the customer
90  const newOrder = await prisma.customerOrder.findFirst({
91    where: {
92      customer: {
93        email: customer.email,
94      },
95    },
96  })
97
98  // Expect the new customer to have been created and match the input
99  expect(newCustomer).toEqual(customer)
100  // Expect the new order to have been created and contain the new customer
101  expect(newOrder).toHaveProperty('customerId', 2)
102})
103
104it('should create 1 order with an existing customer', async () => {
105  // The existing customers email
106  const customer: Customer = {
107    email: 'harry@hogwarts.io',
108  }
109  // The new orders details
110  const order: OrderInput = {
111    customer,
112    productId: 1,
113    quantity: 1,
114  }
115
116  // Create the order and connect the existing customer
117  await createOrder(order)
118
119  // Check if the new order was created by filtering on unique email field of the customer
120  const newOrder = await prisma.customerOrder.findFirst({
121    where: {
122      customer: {
123        email: customer.email,
124      },
125    },
126  })
127
128  // Expect the new order to have been created and contain the existing customer with an id of 1 (Harry Potter from the seed script)
129  expect(newOrder).toHaveProperty('customerId', 1)
130})
131
132it("should show 'Out of stock' message if productId doesn't exit", async () => {
133  // The existing customers email
134  const customer: Customer = {
135    email: 'harry@hogwarts.io',
136  }
137  // The new orders details
138  const order: OrderInput = {
139    customer,
140    productId: 3,
141    quantity: 1,
142  }
143
144  // The productId supplied doesn't exit so the function should return an "Out of stock" message
145  await expect(createOrder(order)).resolves.toEqual(new Error('Out of stock'))
146})