Automation Testing Javascript Webdriverio Selenium More

Gitbash Setup for Windows Preview 02:22

Git Bash for Windows is a package that is comprised of two parts: git which is a version control system (VCS) which tracks the file changes, commonly used for programming in a team setting. bash is a Linux-based command line (which has been ported over to Windows).

In this lecture, I teach you how to download and setup GitBash for which we will use extensively during this course.

iTerm2 Setup for Mac Preview 00:51

iTerm2 is a replacement for Terminal and the successor to iTerm. It works on Macs with macOS 10.10 or newer. iTerm2 brings the terminal into the modern age with features you never knew you always wanted. It’s features rich and provides several additional features above the standard terminal which will make it easier to run our tests.

In this lecture, I show how Mac users can download and install iTerm2 and how to set the tool up successfully.

WebdriverIO API Preview 01:40

The Webdriver IO API page contains reference materials for all implemented selenium bindings and commands. WebdriverIO has all JSONWire protocol commands implemented and also supports special bindings for Appium.

IMPORTANT: WebdriverIO v4 & NodeJS Preview 00:28

NodeJS npm Package JSON Setup Preview 08:14

NodeJS is a JavaScript runtime environment which includes everything you need to execute a program written in JavaScript. It’s built on Chrome’s V8 JavaScript engine. Node.js’ package ecosystem, npm, is the largest ecosystem of open source libraries in the world.     

IMPORTANT - note about the following two lectures - Please Read Preview 00:23

WebdriverIO released a version update (to v.5) on the 17th December 2018. I will add a new section to explain the changes made very soon, but in the meantime please ensure to read this lecture note otherwise you will come across an error.

Handling Dependencies Preview 10:52

npm is a package manager for Javascript and it the worlds largest software registry. The registry consists of code that can be reused in your project (rather than having to rewrite it yourself!). In this lecture, I show you how to handle package dependencies.

Selenium Standalone Setup Preview 08:56

Selenium Standalone is a node based CLI library for launching Selenium with WebDrivers support. Basically, it’s a way for us to use Selenium which is needed to run our automation tests. As explained in the NodeJS/ NPM lecture, we can instruct our project to use dependencies and in this case we are calling the selenium-standalone library.

Selenium Standalone acts as a middle layer between our automation framework and our browsers. It passes on test messages to the relevant browser that will then run our test against the application that’s in scope.

Sublime Text IDE Setup Preview 01:32

Sublime Text is a proprietary cross-platform source code editor with a Python application programming interface (API). It natively supports many programming languages and markup languages, and functions can be added by users with plugins, typically community-built and maintained under free-software licenses.

Setup & Resources - Quiz

Creating Our First Automation Test Preview 07:15

In this lecture we use one of the available demonstration tests found on the webdriver.io homepage to create our first test.

Creating Our Second Automation Test Preview 09:01

In this lecture, we look at creating and executing a second test that uses the contact us form on webdriveruniversity.com. Contact forms on websites can be quite tricky because there is usually validation in place before it can be submitted (e.g. you need to fill in the mandatory fields before you can submit the request). We can formulate tests to ensure we test all scenarios but, in this case, we want to keep things simple to demonstrate how little code is needed to direct our tests to the contact us form.

Creating Our First Tests - Quiz

Wdio - Creation & Review Preview 06:41

The main purpose of WebdriverIO is end-to-end testing on a big scale. Webdriverio provides a test runner (wdio) that helps you to build a reliable test suite that is easy to read and maintain. The test runner takes care of many problems you are usually facing when working with plain automation libraries. For one, it organizes your test runs and splits up test specs, so your tests can be executed with maximum concurrency. It also handles session management and provides a lot of features that help you to debug problems and find errors in your tests.

Wdio - Triggering Tests Preview 04:32

In this lecture, we look at triggering tests using the wdio file.

Wdio - Contact Us & Login Portal Test Preview 02:06

In this lecture, I start showing you how we can use the wdio file to trigger our ‘contactUsTest’ and ‘loginPortalTest’ tests.

Wdio - Executing Our New & Improved Tests Preview 02:34

In this lecture, we continue to work towards getting out wdiofile to execute our ‘contactUsTest’ and ‘loginPortalTest’ tests and actually execute to test with an example.

Wdio - Reviewing the Wdio File Preview 02:30

In this lecture, we take a more detailed look at the WDIO file and review some of the key sections of code.

Wdio - Quiz

Mocha - Introduction Preview 04:02

In this lecture, I introduce you to Mocha. Here I explain its purpose, why we should use it and the benefits.

Mocha - Structuring & Combining Tests Part 1 Preview 07:21

In this lecture we’ll start using Mocha to form our test cases. We are going to combine our two existing tests into one .js file and then use Mocha to construct our tests.

Mocha - Structuring & Combining Tests Part 2 Preview 03:44

In this lecture we continue with the changes being explained in Part 1.

Mocha - Reviewing & Executing our New & Improved Tests Preview 03:05

In this lecture we review our changes from part 1 and 2 and execute our new and improved tests.

Mocha - Quiz

Simplifying Tests and Sync Mode Preview 05:01

In this lecture, we take a look at Sync mode and the difference between Synchronous and asynchronous requests.

Configuring Our Tests to Use Sync Mode Preview 05:08

In this lecture, we look at changing our wdio.conf file to show you how we can run our tests asynchronously, if needed.

Selenium Standalone & NPM Scripts Preview 04:34

In this lecture we looked at the Selenium Standalone Service where I show you how we could use npm scripts to enhance our framework.

Selenium Standalone & NPM Scripts - Quiz

Base URL Setup Preview 05:16

In this module, we look at setting a base URL and handling multiple environments/ websites at runtime.

Handling Multiple Environments During Runtime Preview 04:56

In this lecture, we looked at handling multiple environments during runtime. This is a common scenario, as most companies will use multiple environments to perform different tests in the real world.

For example, a company may have a website to perform sprint related work. They may have another website to perform regression testing. In this lecture, we look at adding an IF statement in our WDIO file to handle this situation.

Environments & Base URL - Quiz

Logging During Runtime Preview 02:24

In this lecture we looked at logging additional information when running our tests. This will greatly help when debugging our code.  

Logging - Quiz

Implementing Node Assertions Preview 06:40

The assert module provides a way of testing expressions. For example, if the expression evaluates to 0, or false, an assertion failure is being caused, and the program is terminated. Think of assertions as a condition (e.g. we expect result A to be returned and if result A does not return then the test should fail).

Node Assertions - Quiz

Chai - Advanced Assertions & Code Example - Part 1 Preview 08:13

In this lecture we start adding advanced assertions into our tests using Chai. This module is broken down into sections and we keep improving our tests as we advance.

Chai - Advanced Assertions & Code Example - Part 2 Preview 03:25

In this lecture we continue on from the previous lecture and execute the newly created test (chai.js).

Chai - Adding Assertions to our Tests Preview 05:37

In this lecture we start adding Chai Assertions to our webdriverUniversityTests.js file by adding Chai assertions using the knowledge we have picked up from the previous two lectures.

Chai - Centralizing Assertions Using our wdio File Preview 03:32

In this lecture we look at refactoring and centralizing our assertions using the wdio file.   

Chai - Quiz

Pause Command Part 1 Preview 06:47

The Pause command pauses execution for a specific amount of time. It is recommended to not use this command to wait for an element to show up. In order to avoid flaky test results, it is better to use commands like waitforExist or other waitFor commands (we cover this in a later module).

Pause Command Part 2 Preview 04:47

This lecture continues from the previous lecture. Here we recap on what we have done in Part 1 and attempt to execute the test to see the results.

Debug Mode Preview 07:09

In this lecture, we take a look at debug mode. Debug mode allows you to debug any issues that you may have during runtime.

Creating Selectors using Ranorex Preview 07:15

In this lecture, we take a look at creating selectors. Selectors are used to be able to select elements on a website. An example would be to select a particular button on a webpage. We need to instruct our tests to use the button and we do this by referring to the locator associated to the button.

There is a great Chrome addon that makes creating selectors so much easier. It’s called Ranorex Selocity and it can be used to automatically generate selectors.

Pause, Debug Mode & Selectors - Quiz

Targeting Specific Tests Preview 02:44

In this lecture, we looked at how we could target specific tests. The Mocha documentation provides examples of how we can run only the specified suite or test-case of our choosing. This is useful because currently when we run a test, it tests all cases within the test file. This is different from when we select which test file to use (as shown previously) as we are now focusing on a more granular level where we now choose the specific test to run within a single file when multiple tests exist.

Skipping Specific Tests Preview 01:15

In this lecture, we looked at how to skip specific tests. This is similar to the previous lecture but sometimes skipping a specific test is the better option when we have a number of tests we do want to run and only want to skip one (or a few) tests.

Targeting & Skipping Specific Tests - Quiz

getCssProperty Command Preview 07:43

In this module we took a look as CSS extraction. CSS extraction is when we return CSS information of an element from a HTML page. An example of this is to find out the styling associated to a H1 element for example.

Mocha Hooks Part 1 Preview 07:52

In this lecture, you are introduced to Mocha Hooks. The Mocha documentation provides us with some useful information and demonstrates how we can use them to set preconditions and clean up our tests after they’ve run.

Mocha Hooks Part 2 Preview 08:26

In this lecture we continue on from Part 1 and delve further into creating tests using Mocha hooks. We’ve now already created the initial test skeleton and have included locators into our first test so that we can locate the fields of interest from the contact us form.

Mocha Hooks - Quiz

Tabs Part 1 Preview 06:03

In this lecture we look at how we can handle multiple browser tabs using the webdriverio API. The specific command we are interested in is the switchTab command.

Tabs Part 2 Preview 08:50

In this lecture we continued on from Part 1 but this time we added a couple of assertions to ensure the correct tab was in focus during out tests. So, for example, in our first “it” test we want to check to see if the contact us page opens in a new browser window. We can add an assertion into the test to check the URL of the newly opened page and can go a step further by checking the webpage title.

Handling Browser Windows Tabs - Quiz

isExisting Part 1 Preview 07:29

In this lecture we take a look at the isExisting function in detail. This function checks to see if at least one element is existing using a selector we provide. For example, we may want to check to see if a h1 heading exists on the webpage and our test will return either true or false.

isExisting Part 2 Preview 08:01

In this lecture we continue building the isExistingTest.js file. We currently have the skeleton test defined and have placed locators in each of the “it” test blocks. We now need to use the locators to test for expected values.

isVisible Preview 07:25

In this lecture we take a look at the isVisible function. This function will return true if the selected DOM-element is visible for the locator that we provide.

hasFocus Part 1 Preview 07:51

In this lecture we take a look at the hasFocus function. This function allows us to test whether an element has focus (e.g. we have instructed our test to select a checkbox option and we want to prove the checkbox element is now in focus of the browser).

hasFocus Part 2 Preview 04:18

In this lecture we continue from Part 1 and continue adding to our test

isEnabled Part 1 Preview 08:36

In this lecture we take a look at the isEnabled function. This function allows us to test whether an element is enabled and will return a true or false value. A typical example of when we would use this function is when we test web forms. Sometimes a form field will be disabled (e.g. a second email input field) until the first email input field has been entered.

isEnabled Part 2 Preview 07:43

In this lecture we continue developing our test (from Part 1) and will now add assertions into our “it” blocks.

isSelected Part 1 Preview 06:49

In this lecture take a look at the isSelected function which can be used to determine if a radio button option has been selected or not. It will return a true or false value.

isSelected Part 2 Preview 04:59

In this lecture we continue to build our isSelected test from Part 1.

isVisibleWithinViewport Part 1 Preview 06:32

In this lecture we take a look at the isVisibleWithinViewpoint function, which will return true if the selected DOM-element is found by given selector and is visible within the viewport.

isVisibleWithinViewport Part 2 Preview 07:31

In this lecture we continue to build our isVisibleWithinViewpoint test from Part 1.

getText, isVisible, isExisting Part 1 Preview 06:21

In this lecture we go back to our contactUsTest.js test and look to enhance the current file by introducing getText, isVisible and isExisting functions.

getText, isVisible, isExisting Part 2 Preview 10:04

In this lecture we continue improving our contactUsTest.js file and will now use the locators to build methods round them to validate the output. We are now going to test to see if a successful form submission has taken place.

getText, isVisible, isExisting Part 3 Preview 05:45

In this lecture we now review our code from the changes made in the last two lectures and attempt to execute our test.

waitForText Part 1 Preview 06:34

In this lecture we take a look at the waitForText function. We can use this function to wait for an element (when given a CSS selector) for a given amount of time in milliseconds to have text or content.  

waitForText Part 2 Preview 07:08

In this lecture we continue building our waitForText test from Part1.

waitForExist, waitForVisible Part 1 Preview 05:39

In this lecture we take a look at the waitforExist and waitForVisible functions from the webdriverio documentation.

waitForExist can be used to wait for an element (using a locator) for a provided amount of time in milliseconds for the element to be present within the DOM. The value returned will be true if the found. There is also a reverse flag that can be used that will instead return true if the element does not exist.

waitForVisible can be used to wait for an element (using a selector) for an amount of time in milliseconds for an element to be visible on the page. The value returned will be true. There is also a reverse flag that can be used return true if the element does not become visible in the given amount of time.

waitForExist, waitForVisible Part 2 Preview 04:01

In this lecture we continue from the last lecture and further develop the waitForExist and waitForVisible test file.

waitUntil Preview 08:46

In this lecture we look at the waitUntil command. The waitUntil command allows you to wait on something. It expects a condition and waits until that condition is fulfilled with a truthy value.

waitForValue Preview 05:08

In this lecture we look at the waitForValue command. WaitForValue waits for an element (using a locator) to have a value within the amount of time set in milliseconds.

Using External Data (Sync Data Mode) - Part 1 Preview 07:11

In this lecture we take a look at Sync-Request which is a npm package than can be used to GET data from a given URL to retrieve data that we can then pull into our tests, rather than having to define specific values (such as [email protected]).

Using External Data (Sync Data Mode) - Part 2 Preview 04:36

In this lecture we continue on from Part 1 and finish making changes to our test file to use data from a JSON file. So far, we have installed the sync-request package, have referenced the package in our test file and have created two variables that link to the JSON file URL and have set the format of the data retrieved.

Custom Commands (addCommand) - Part 1 Preview 05:30

If you want to extend the browser instance with your own set of commands, there is a method called addCommand available from the browser object.

Custom Commands (addCommand) - Part 2 Preview 06:43

In this lecture, we continue on from Part 1 and start making use of the new custom command that we’ve now created. At the moment, our test still references locators in each of the “it” blocks. We need to update this so that we now call the custom command.

Injecting JavaScript Code (Execute Command) - Part 1 Preview 08:00

In this lecture, we look at interacting with a video on a webpage. The video player has a play button that transitions to a pause when pressed. We are going to use Javascript to interact with the video player by writing Javascript code within our test file by using the execute command.

Injecting JavaScript Code (Execute Command) - Part 2 Preview 09:14

In this lecture, we continue from Part 1 and continue to develop our test to use Javascript code injection within our test.

Injecting JavaScript Code (Execute Command) - Part 3 Preview 02:24

In this lecture, we make a small change to slow down our test so that we can see the output that’s logged to the console when the first “it” test block runs.

Page Object Model (POM) - Intro Preview 02:09

In this lecture, we cover what we are going to do in phase one, two and three. This lecture provides an overview of each phase and highlights some of the key improvements that we will cover.

Page Object Model (POM) - Phase 1 - Part 1 Preview 09:32

In this lecture, we start phase one and look at centralizing our selectors and improving our existing commands.

Page Object Model (POM) - Phase 1 - Part 2 Preview 09:34

In this lecture, we continue improving our contactUsTest.js file from the work we have completed from Part 1.

Page Object Model (POM) - Phase 1 - Part 3 Preview 09:37

In this lecture, we continue improving our contactUsTest.js file from the work we have completed from Part 2.

Page Object Model (POM) - Phase 1 - Part 4 Preview 07:20

In this lecture, we continue improving our contactUsTest.js file from the work we have completed from Part 3.

Page Object Model (POM) - Phase 1 - Part 5 Preview 05:53

In this lecture, we check to see if one of our assertions work correctly. We do this by amending the code to give an unexpected value for one of the “it” tests. This is to show you what happens when a value is returned that we were not expecting.

Page Object Model (POM) - Phase 2 - Part 1 Preview 01:14

In this lecture, we move onto phase 2.  In this phase, look at creating separate POM classes, link tests with the POM classes and directly call POM commands in our tests.

Page Object Model (POM) - Phase 2 - Part 2 Preview 08:26

In this lecture, we start making changes to our code. We will again be using the contactUsTest.js file to make further changes.

Page Object Model (POM) - Phase 2 - Part 3 Preview 07:23

In this lecture, we continue from the last lecture and continue to improve our contactUsTest.js file by using the newly created ContactUs_Page.js class file.

Page Object Model (POM) - Phase 2 - Part 4 Preview 07:24

In this lecture, we continue from the last lecture and continue to improve our contactUsTest.js file by amending the functions to use the ContactUs_Page.js file.

Page Object Model (POM) - Phase 2 - Part 5 Preview 08:00

In this lecture, we continue from the last lecture and make a few minor adjustments to our WDIO file and our contactUsTest.js file. We also go through our code to ensure it’s correct before attempting to run a test.

Page Object Model (POM) - Phase 2 - Part 6 Preview 05:02

In this lecture, we review the changes that we have made throughout phase 2.     

Page Object Model (POM) - Phase 3 - Part 1 Preview 00:43

In this lecture, we start Phase 3 and look at centralizing all sectors and commands inside the POM class (further abstraction). We also look at simplifying our tests even further.

Page Object Model (POM) - Phase 3 - Part 2 Preview 05:07

In this lecture, we begin amending our contactUsTest.js file and our ContactUs_Page.js file by introducing further abstraction.

Page Object Model (POM) - Phase 3 - Part 3 Preview 06:15

In this lecture, we make a further improvement to our ContactUs_Page.js file by creating a new method that handles a test scenario.

Page Object Model (POM) - Phase 3 - Part 4 Preview 04:46

In this lecture, we make a further improvement to our ContactUs_Page.js by removing the individual function keywords to each of the former functions listed within the ContactUs_Page.js page. We then make changes to our contactUsTest.js file by referencing the ContactUs_Page variable in each of the “it” code blocks.

Page Object Model (POM) - Phase 3 - Part 5 Preview 06:36

In this lecture, we review our code from phase 3 and look to see if we need to make any more changes before finalising our code.

Page Object Model (POM) - Phase 3 - Part 6 Preview 04:03

In this lecture, we go over the changes we have made during Phase 3. We recap on the key improvements that we have made to our code.

Advanced Reporting - Intro Preview 02:17

In this lecture, I introduce you to advance reporting and explain the different types of reports we can use in our tests.

Advanced Reporting - Junit Reports Preview 05:08

In this lecture we start looking at Junit reports.

Advanced Reporting - JSON Reports Preview 05:54

In this lecture we start looking at JSON reports.

Advanced Reporting - Allure Reports Preview 09:05

In this lecture we start looking at Allure reports.

Advanced Reporting - Allure Reports - Attaching Images - Part 1 Preview 08:15

In this lecture we start looking at adding exception images to our reports.     

Advanced Reporting - Allure Reports - Attaching Images - Part 2 Preview 05:26

I decided to create this lecture just to explain the wdio report configuration and to go through some additional options that we have available.

Free Up Space - Deleting Files and Folders Preview 04:37

In this lecture we will be making further modifications to the wdio file, to delete specific files and folders prior to test execution, in turn freeing up disk (Hard drive) space.

Jenkins Introduction and Explanation Preview 02:02

It’s fairly simple to setup Jenkins by using a .war file (WAR file (Web Application Resource or Web application Archive) is a file used to distribute a collection of JAR-files) making the deployment of Jenkins simple!

Jenkins Installation And Setup Preview 07:06

Jenkins Installing Plugins And Setting Up NodeJS Preview 07:47

Jenkins enables the test automation engineer to download and install many available (Free) plugins to enhance their instance of Jenkins. We will inspect the Jenkins Plugin Marketplace and in turn select and install specific plugins required to get our tests up and running within Jenkins.

Trigger our Tests using Jenkins Preview 10:12

In this lecture we will take a look at how we can trigger specific tests to run within Jenkins, setup a base URL and also take a look at other settings.

Jenkins Adding Parameters Preview 13:45

As you have previously seen, we can add parameters within Jenkins to alter specific properties of our automation framework; in this lecture we will be adding another parameter which will enable the user to target and execute the desired test of their choice.

Jenkins Adding Additional Logging Information Preview 04:04

In this lecture, we look at how can add additional logging data within Jenkins.

Jenkins Execute Our Tests when Ever We Want Preview 04:59

In this lecture we will learn how we can automatically trigger jobs / builds within Jenkins using the schedule jobs functionality; for example automatically triggering jobs during specific times of given days.

Generating Allure Reports within Jenkins - Part 1 Preview 08:05

In this lecture, we begin to look at how we can generate Allure reports within Jenkins.

Generating Allure Reports within Jenkins - Part 2 Preview 09:42

In this lecture, we continue to look at how we can generate Allure reports within Jenkins and carry on from Part 1.

Generating Allure Reports within Jenkins - Part 3 Preview 10:40

In this lecture, we continue to look at how we can generate Allure reports within Jenkins and carry on from Part 2.

Generating Allure Reports within Jenkins - Part 4 Preview 08:40

In this lecture, we continue to look at how we can generate Allure reports within Jenkins and carry on from Part 3.

Generating Allure Reports within Jenkins - Part 5 Preview 03:18

In this lecture, we continue to look at how we can generate Allure reports within Jenkins and carry on from Part 4.

Webdriver IO v5 - Introduction Preview 02:53

Preparing our Project for Webdriver IO v5 Preview 01:47

Webdriver IO v5 - Instructions Preview 00:59

Downloading Webdriver IO v5 Packages Preview 04:16

Installing New WDIO CLI Preview 01:24

Creating New WDIO CLI File Preview 03:26

Configuring New WDIO CLI File Preview 07:53

Updating our Dependencies Preview 06:10

Downloading Additional Dependencies Preview 02:16

Potential Problem with the .Dot Reporter Preview 01:43

Preparing the Foundations of our Framework Preview 04:23

Modifying our Test to use Async Await Preview 03:53

Customising our Page Object Model Commands Preview 10:01

Custom Commands - waitForDisplayed Preview 07:27

Adding Assertions Directly Inside our Tests Preview 05:08

Triggering our New Webdriver IO v5 Tests Preview 03:48

Incorporating Try Catch Blocks to our Assertions Preview 06:21

Final Project Code Preview 00:04

Intro Preview 00:07

Installing and setting up Visual Studio Code Preview 01:49

Setting up Code Runner Extension Preview 03:50

Altering Color Themes Preview 01:26

Installing latest version of NodeJS Preview 03:53

Package.json Setup Preview 03:08

Downloading Latest WebdriverIO v5 Packages Preview 03:37

Prettier Setup (Enhanced Code Formatter) Preview 04:37

Wdio File Setup Preview 04:08

Babel Setup Preview 05:33

Selenium Server Overview Preview 05:17

Creating Our First Test - Part 1/2 Preview 08:52

Creating Our First Test - Part 2/2 Preview 07:02

Altering Selenium Server Port Number Preview 05:04

ChromeDriver Setup Preview 04:40

Creating Advanced Selectors - Part 1/2 Preview 09:16

Creating Advanced Selectors - Part 2/2 Preview 09:11

Switching Browser Tabs Preview 07:53

Closing Browser Tabs Preview 03:35

Applying Chai Assertions To Our Tests Preview 10:48

Creating Custom Commands Using: addCommand Preview 07:02

waitForExist Preview 06:26

waitForDisplayed Preview 06:17

waitForEnabled Preview 06:36

pause Preview 03:30

execute Command Preview 06:19

Handling Inputs - Part 1/2 Preview 09:16

Handling Inputs - Part 2/2 Preview 04:09

isExisting, isSelected, isDisplayed Preview 10:41

Handling IFrame's The Correct Way! Preview 09:50

Challenge Overview Preview 01:48

Challenge Solution - Part 1/3 Preview 07:38

Challenge Solution - Part 2/3 Preview 09:05

Challenge Solution - Part 3/3 Preview 08:34

Config File Creation & Linking To Tests Preview 07:45

Interlinking Config File With Wdio File Preview 05:47

waitAndClick Preview 06:03

waitAndSendkeys Preview 04:22

Custom Commands & Test Integration Preview 08:44

Random Email Generator - [Custom Command Creation] Preview 06:13

Random String Generator - [Custom Command Creation] Preview 07:15

Base Page Creation Preview 06:51

Sub Page Creation - Part 1/2 Preview 05:24

Sub Page Creation - Part 2/2 Preview 08:00

Page Object Pattern & Test Connection - Part 1/3 Preview 07:52

Page Object Pattern & Test Connection - Part 2/3 Preview 07:28

Page Object Pattern & Test Connection - Part 3/3 Preview 04:30

Making Improvements To The Existing Framework - Part 1/2 Preview 09:51

Making Improvements To The Existing Framework - Part 2/2 Preview 03:31

Organizing Test Suite's - Part 1/2 Preview 07:20

Organizing Test Suite's - Part 2/2 Preview 05:54

Retry Flaky Tests Preview 05:34