Automated Software Testing with Python

This lecture has a link to all the Python code we'll write in this section. Use it to check your code as you write it, or to refresh your memory!

In this video we solve the previous coding exercise. Make sure to attempt the exercise yourself before watching this!

In this video we look at methods in Python, which are names for blocks of code. We can then re-use them over and over again without having to re-write the code again.

In this video we solve the previous coding exercise. Make sure to attempt the exercise yourself before watching this!

In this video we set up our Flask project so we can start writing System tests for it. We quickly go over setting up the project structure and installing required libraries.

In this video we create our Flask app and go over its different parts. A quick overview of Flask and how we'll be testing our very first endpoint!

In this video we write our first system test, testing the app from end to end—as if we were a user.

System testing is extremely powerful and useful when testing web applications, but it can be dangerous and slow if overused.

In this video we look at refactoring our System tests so that our code is nicer and easier to maintain. Throughout the rest of the course we'll be writing tests in this refactored fashion.

In this video we look at our more complex REST API with Flask, and explain how it has evolved since the last section. We add Stores and relationships between our various models with SQLAlchemy.

In this video we look at testing foreign key constraints with Python, which is extremely useful when our applications rely on relational data.

In this video we look at unit testing a more complex REST API, and how the SQLAlchemy mappers work in a Python application. Avoid some common mistakes!

In this video we finish our tests for the Store, and complete the testing of our more complex REST API with Python.

In this video we look at Postman, a great tool we can use to send requests to our API and make some checks and tests on the response.

In this video we write our first Postman test. These tests are written in JavaScript, but they are straightforward and very powerful.

In this video we look at the power of environment variables in Postman to share data across requests and responses. Setting and clearing environment variables programmatically will make our tests much more capable.

In this video we look at running a sequence of tests in Postman. This lets us define a set of requests that make up a User journey, and run the tests pretending to be the user themselves.

In this video we look at advanced PyCharm run configurations and plugins, which are going to let us run our Postman tests directly from PyCharm.

In this video we look at installing Node and Newman on OS X. We'll need this to run our tests through the console (and thus through PyCharm). Instructions are also available for Windows on a lecture attachment.

In this video we look at running multiple PyCharm run configurations one after another. Since our tests depend on our app being running, we must be able to run the app first and the tests after—in one click.

In this video we look at installing Git in both OS X and Windows. Git is extremely powerful for teamwork, error control, and keeping a history of what's changed in a project.

In this video we look at what a Git repository is, exactly. This video guides you through the different layers of a repository and what each one does.

In this video we look at a sample Git workflow that we may follow locally.

In this video we look at GitHub, one of the popular repository-hosting sites. We also look at remote repositories, which are hosted in GitHub.

In this video we look at adding our Flask REST API project to GitHub, so that we can then run our tests on the remote repository.

In this video we look at our Continuous Integration pipeline, Travis CI. It's going to look at our remote repository whenever a commit is pushed, and run our tests on the latest code available.

In this video we look at how we can add our GitHub repository to Travis so that it knows about it and can start looking at the code.

In this video we look at the Travis configuration file—we need it so Travis knows what language to run, and how to run the tests. It's really quite powerful!

In this video we look at adding our "Tests Passing" badge to the Readme of our repository. This not only gives readers some information about our project, but also some software engineering kudos by making the fact that we have tests visible.

Welcome to this section on acceptance testing! Acceptance testing is a very exciting form of testing that encourages customers to write the tests.

Using Behavior-Driven Development (BDD), we can easily model our tests after what customers say. Learn all about it in this section!

What is acceptance testing? How do we create acceptance tests? Why do we want to do acceptance tests?

In this section I provide a simple website that we'll test using acceptance testing methods and BDD. This lecture is a guide over what the website does and how it works.

In this video we write our first acceptance test step, using Gherkin and Selenium.

This video quickly walks you through getting the Chrome webdriver (remember to update your version of Chrome!), and how we can use it from Selenium.

Make sure everything works—if Selenium isn't running, your tests won't run! This video walks us through any fixes we might have to do.

In this video we finish writing our first test using Selenium, which contains navigation and checking the current page URL.

In this video we learn about the regular expression matcher in the behave library, which allows us to pass in arguments through the Gherkin steps.

In this video we write our first test to check some content of an element!

This is arguably the most important video—structuring your acceptance tests so that you and your teammates can work efficiently, by splitting them into separate locators and a page model which represents the pages in your application.

In this video we create a page in our page model to represent our blog page.

In this video we change all our hard-coded navigation into the specific pages, to make tests more readable and less interdependent.

Just a word of warning in this video! You will not have too many acceptance tests, so don't worry about making everything as efficient and generalised as possible. Often, that will result in poor readability and maintainability.

It's okay to have a small amount of duplication in the pursuit of better maintainability in the long term!

Often, acceptance tests will be slow—be it due to internet speed or JavaScript doing things. Often these tests will include waits, in order to give time for things to load. It's a very bad practice to have explicit waits (such as '5 seconds').

Instead, this video covers implicit waits: waiting for something to happen. As soon as it happens, the test moves on—not wasting any precious time.

In this video we look at how we can debug acceptance tests with PyCharm. It's simple, just as you would any other test!

In this video we look into our final complex scenario, which will have our Chrome webdriver filling in a form and checking that content is created accordingly.

Filling in forms with Selenium is really simple, especially when we've structured our page using locators and a page model. Learn how to in this video.

This video concludes this section, and the course!