
## Day One

1. End-to-end testing best practices
   1. Mocking APIs
   2. Writing SIFERS
   3. Focusing on the happy path
   4. Quantity vs quality and the testing pyramid
2. Getting Started with Cypress
   1. Installing Cypress
   2. Launching the test runner
   3. Using `cy.visit()`
   4. Writing your first test
3. Finding Elements
   1. It's just jQuery (but better)
   2. Use `get()` to find elements
   3. Use `contains()` to find by text
   4. Chaining commands
   5. Best practices
4. Interactions
   1. Use `type()` to type into an input
   2. Use `click()` to click an element
   3. Use `clear()` to clear an input
   4. Using `check()` and `uncheck()` with checkboxes
   5. Use `select()` to select an option
5. Assertions
   1. Default assertions
   2. Chai-based assertions using `should()`
   3. Chaining implicit assertions using `and()`
   4. Explicit assertions
6. Subjects and Promises
   1. Commands yield a subject
   2. Use of `.then()` for asynchronous code
7. Timeouts
   1. Timeouts for default assertions
   2. Modifying timeouts
   3. Using `cy.wait()`
8. Variables and Aliases
   1. Asserting mutable values
   2. Create alias using `as()` command
   3. Access alias via `this` scope
   4. Access alias via `get(@)`
9. Fixtures
   1. Creating a fixture with `cy.fixture()`
   2. Using fixtures to bootstrap data
10. Capstone Test

## Prereqs

Attendees should be familiar with the following technologies:

- JavaScript


Cypress provides mechanisms for you to write more efficient and maintainable tests. You'll know how to create and access aliases in your tests.

Use variables and aliases for efficiency

It's important that most of our tests do not rely on external sources. This would create a dependency for the success of our tests and place a burden on the execution of our tests. You'll learn how to create fixtures to separate the concerns of displaying data and fetching data when testing your application.

Setting up Fixtures

Testing applications requires an understanding of the tools and strategies, and the effectiveness of each. You'll know what to test, and where to put your testing efforts, before writing your first test.

Know the best practices for testing applications

You'll be able to write a full suite of tests for an application to give you hands-on real-world experience using Cypress.

Write a full suite of tests

The setup required for tests starts simple and small, but grows in complexity over time, leading to code that is difficult to understand and maintain. Using the Simple Injectable Functions Explicitly Returning State (SIFERS) pattern reduces the mental overhead of determining the correct state and environment for a test to run within, reduces leaks between tests, and removes the need for before blocks in your tests.

Using the SIFERS pattern

You'll be able to install and configure Cypress to get started on writing your firsts end-to-end tests.

Start writing tests with Cyress

During the arrangement of your tests you'll need to query and get access to elements in the DOM. You'll know the best practices for ensuring the maintainability of finding elements and using chaining commands.

Use best practices for querying elements in the DOM

The goal of end-to-end tests is to validate your application works as expected as if a user was using the application themselves. You'll have the skills to mimic user interactions with elements to have confidence when shipping your application.

User-like interactions

Writing good end-to-end tests requires an understanding of assertions. You'll know how Cypress performs default asserts, how to use chai-based assertions, chain assertions, and perform explicit assertions.

Effective and explicit assertions

It's important to know that all commands in Cypress yield a subject, and it's equally important to understand what a subject is, and how you can leverage subjects when writing tests.

Expert Led Cypress Workshops

Cypress In One Day

Get Expert Led Training For Your Team