Learn Cypress, Sequelize and Tmux

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

Learn to manage your terminal sessions and work more effectively from the command line using tmux. If you use the command line at all, tmux can make your life easier.

tmux bills itself as a terminal multiplexer. It allows you to wrangle multiple terminal sessions from one window. Instead of keeping track of many terminal windows yourself, you can use tmux to create, organize, and navigate between them. Even more importantly, tmux lets you detach from and re-attach sessions, so that you can leave your terminal sessions running in the background and resume them later. This is especially useful if you're working on a remote server: you can set up a persistent session that will continue running when you close your laptop. You can even share a tmux session to facilitate pair programming.

It lets you switch easily between several programs in one terminal, detach them (they keep running in the background) and reattach them to a different terminal.

tmux

Wrangle your terminal with tmux

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

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

Our database seeder needs to be extended to work in production. It should reset between tests, auto-increment ID sequences, and allow us to set defaults on our seeds to keep our tests easy to maintain.

Let's extend the example from the previous lesson to get to a production ready seeding abstraction. 

Productionize Your Database Seeder in 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

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. 

Extend Cypress with Plugins

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

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

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

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

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.

Topics

Instructors

Content Type

Free or Pro