Learn Canvas, Chai and Cypress

Imagine the following.

You join a new project and after getting access to the repo you notice that there's no tests.

You decide to ask the team whether they are in different repo or something and unfortunately the answer is:

>We don't have any tests, we didn't have the time.

😐

In this collection we're going to learn how to add e2e tests with cypress.io to an existing React app in order to do two things:

- 🌟 Ensure that our app currently works as intended
- 🌟 Allow us to add features to it with a technique called "Cypress Driven Development" 

In less than 20 minutes we're going to go through:

- ⚡️Adding cypress.io setup to an existing project
- ⚡️Testing search functionality with `data-cy` properties
- ⚡️Using "Cypress Driven Development" to add a new feature to an app
- ⚡️Use Cypress UI to debug an API response
- ⚡️How to use `cy.only` and `cy.skip` in order for us to build our e2e test suite faster

and much more!

Fast, easy and reliable testing for anything that runs in a browser.

cypress

Add e2e tests with cypress to a React application

One of the most important — but most ignored — practices for web developers is performing end-to-end testing on applications before they go live into production. You know: making sure they work like they’re supposed to. But testing can be tedious, and definitely not fun.

In this course, Brett Cassette will show you how you can test all layers of your application stack, simultaneously, with Cypress. When you use Cypress, it’s like having a robot that uses your app the way a real user would. Cypress reports if things work the way you designed them to — and if they don’t — every step of the way. And it’s fun.

After completing this course, you’ll be ready to apply the same E2E testing principles to your own applications. Stop leaning on your QA department (if it exists) to stress-test your application, and ship your app knowing it’s ready. 


Test Production Ready Apps with Cypress

The tools available for unit testing have come a long way. While testing may never be “easy”, the available tools have certainly moved testing closer to the simple end of the spectrum. Full end to end testing hasn’t quite kept the same pace and as a result many applications are testing manually and often by users in production. Cypress provides a testing environment that makes end-to-end testing fast and reliable with a simple API that makes creating automated unit tests for your web applications a no-brainer.


End to End testing with Cypress

A <canvas> element provides scripts with a resolution-dependent bitmap canvas, which can be used for rendering graphs, game graphics, or other visual images on the fly.

canvas

The `canvas` element exposes a 2d context which allows you to draw lines using the `moveTo`, `lineTo`, and `stroke` api. You can combine this with Mouse events to make a simple drawing app.

Draw with Your Mouse on an HTML Canvas

Using cy.server, cy.route, and cy.wait, we can intercept requests to our real backend, and return known mock responses.

The pros of using this approach:
- It's much faster than interacting with the real backend
- Doesn't need to seed data to the backend
- Easy control of requests and responses
- Can mock network delay and failure

Cons:
- No guarantee the stubs match the real backend responses
- Not full end-to-end testing

Recommended Homework:
- Mock the route to create a new todo, and reply with a 200
- Mock the route to edit an existing todo, and reply with a 200

Mock Your Backend with Cypress

Learn how to setup your [Cypress development environment](https://docs.cypress.io/guides/tooling/intelligent-code-completion.html#Reference-type-declarations-via-tsconfig) with Intellisense, custom Cypress configuration in cypress.json, and [get settings autocompletion in VSCode](https://docs.cypress.io/guides/tooling/intelligent-code-completion.html#Set-up-in-your-Dev-Environment-1).  

Recommended Homework:
- Setup your Cypress dev environment

Setup Your Cypress Dev Environment

Which selectors your choose for your tests matter, a lot. In this lesson, we'll see the recommended Cypress best practices for selectors, and why we should prefer the data-cy attribute.

Recommended Homework:
- Finish the example using cy.contains, and remove the false positives to get a richer sense of why data-cy is a better choice for our selector

Use the Most Robust Selector for Cypress Tests

So you have a production application, and it doesn't use Cypress yet.

In this course, you'll learn how to add Cypress to your existing npm application, and run it for the first time.

Recommended Homework: 
- Look through the tests Cypress spins up for you and learn how typical Cypress tests are setup

Install Cypress in a Production Application

If we want to do full end-to-end testing, then we need to seed our database into a reliable state at the start of every test. In this lesson, we'll learn how to build a Cypress plugin that updates the data in our database.

Seed Your Database in Cypress

Cypress allows full-stack end-to-end testing. You can test the UI, the frontend stores, the XHR requests, and the database, and interact with every layer in the same test.

But Cypress doesn't do all this out of the box. This course will introduce you to the techniques and abstractions used to handle full-stack testing. 

Course Introduction: Test Production Ready Apps with Cypress

Cypress can do more than end-to-end testing. It can fully drive remote applications, including ones you don't own, much more reliably than Selenium.

In this example, we'll use Cypress to build a web scraper to mine data from applications we don't own. This data could be used to power other applications, filtered for data relevant to your use cases, sent to your calendar, or any number of uses. 

Since Cypress is easy to automate, it's easy to integrate with cron or a job framework to run a scraper in an automated fashion.

Create a Web Scraper with Cypress

We can reuse our stubbed responses between tests by using Cypress fixtures. In this lesson, learn how to share data between tests.

Reuse Data with Cypress Fixtures

Learn how to target the elements on your UI, interact with them, and make assertions on their state.

Recommended Homework:
- Write a test that creates a new todo and asserts that the todo is present on the DOM
- Write a test that finishes a todo, and asserts that the todo shows as completed

Write Your First Cypress Integration Test

The Cypress programming model is similar to async and await. When you write Cypress commands, they will be enqueued to be run at a later time, but they will run in the same order as you write them. 

Recommended Homework:
- Verify that Cypress commands run in the order you write them, and not based on when they asynchronously finish. Recommended solutions include using timeouts, and/or synchronously available values as with cy.wrap


Debug and Log with Cypress

Cypress doesn't provide out-of-the-box ability to make assertions on our frontend stores, so let's expose the store to the tests, and assert on it. We'll use our knowledge of Cypress's asynchronous programming style to access properties and functions on the store using cy.its and cy.invoke.

Recommended Homework:
- Consider why it's valuable to test against your frontend store when you can test against the UI

Assert on Your Redux Store with Cypress

Do you need to reuse complex Cypress calls often (like when accessing the store)? 

You can turn them into custom Cypress commands, and even customize their output in the time-traveling debugger, so it's easy to see a snapshot at the point your command ran!

 Recommended Homework:
- Review the Best Practices for Custom Commands - https://docs.cypress.io/api/cypress-api/custom-commands.html#Best-Practices

Create Custom Cypress Commands

External libraries tend to be synchronous, so how do we integrate other powerful tools into the Cypress framework? This lesson walks us through merging in the Lodash library to Cypress to allow us to slice and dice data to more accurately assert on just the pieces of data we care about.

Wrap External Libraries with Cypress

How do you test complex interactions like network timeouts and retries? With Cypress, you can cover your bases, and assert that your application behaves reliably under unreliable conditions. 

Recommended Homework:
- Are multiple cy.route calls the only way to mock multiple requests in Cypress? The response key of cy.route can accept a function -- will that let us change the response based on request attempt?

Mock Network Retries with Cypress

Requests that aren't stubbed will hit our real backend. To ensure we've stubbed all our routes, we can use the force404 method to send 404s from any unstubbed routes.

Find Unstubbed Cypress Requests with Force 404

Let's put all the pieces of the puzzle together. We'll assert on our database, XHR requests, frontend store, and UI in order to pinpoint the locations where our contract breaks down, and highlight our data lifecycle for our teammates. 

Full End-To-End Testing in Cypress

Cypress can not only interact with our frontend code, it can also trigger events in our backend, allowing us to seed our database, assert on database snapshot, or trigger jobs like email campaigns to run.

To get familiar with this mechanism, let's build a "hello world" Cypress Plugin. 

Topics

Instructors

Content Type

Free or Pro