Introduction to Unit Testing in Java

Get set up for creating unit tests in java in the Eclipse Integrated Development Environment

Create unit tests for a simple code library

Enhance your unit tests through the use of Data Driven techniques

Learn how to debug your unit tests


  • Some Java programming experience. Understand the basic of creating and assigning variables, using logic comparisons, and are able to create simple class objects.
  • Able to use the Eclipse Integrated Development Environment (free to install and use!).
  • Able to create simple methods in Java – understanding of flow control (if-else, while, for, foreach) and assignment of values to variables.


Through the use of hands-on work, you will learn how to create and work with unit tests in Java using the Eclipse integrated development environment. Get professional tips on creating, debugging, and improving your tests in a practical way.

The introduction uses a two iteration cycle to create unit tests that address the product code as it is being developed, giving you the basis for not only creating and improving your unit testing ability, but also pointing the way towards exercising these new concepts in BDD (Business/Behavior Driven Development) or TDD (Test Driven Development).

We do more than just talk about how to do this, we provide step-by-step labs detailing how to create your automation and how to improve it as we progress.

For this course, starter code projects are supplied, as well as finished projects you can adapt to fit your needs, or use for reference for further projects.

This course is designed this to help those who want to expand their capabilities in creating software test automation.

Whether you are a student, a manual tester, or are already a software test professional, this course can help you become more effective in your role.

Start your journey towards effective unit testing today!

Who this course is for:

  • Java developers new to the idea of unit testing
  • Test professionals looking to expand their abilities into creating test automation.
  • Test professionals who want to make their existing test automation more useful.

Course content

4 sections • 5 lectures • 46m total lengthExpand all sections

Introduction2 lectures • 6min

  • Introduction00:21
  • Setting Up05:25

Unit Testing, Iteration 11 lecture • 20min

  • Iteration 120:25

Unit testing, iteration 21 lecture • 16min

  • Unit Testing, Iteration 215:46

Wrapping up1 lecture • 5min

  • Dos and Don’ts for writing unit tests05:00

Introduction to Unit Testing

Course Goal: Learn the basis of unit testing and test driven development

Test Driven Development

Unit Testing with Jasmine


  • Introduction to HTML
  • Introduction to JavaScript Development
  • Intermediate JavaScript Development


Testing and debugging are places where developers spend a lot of their time. Code doesn’t always perform as expected and, with complex applications, it’s very easy to break code with minor changes. Unit tests and test-driven-development exist to help us manage expectations of our functionality and to ensure that other developers working on our code are aware when a change they made affects already existing functionality. This is very important when working on large projects with many collaborators as well as small projects with few developers.

We’ll be pre-writing tests in code that we can run whenever we make updates to our application. This will ensure that no new logic breaks old logic, and that we are certain that our programs are executing properly when given different inputs.

Course Includes:

  • 11 videos with over 90 minutes of lectures and explanations.
  • 1 external resource file.
  • 4 exercises to help you master testing concepts.

What You’ll Learn:

  • What is Unit Testing?
  • Test driven development
  • Using Assert
  • Jasmine testing framework
  • Additional Resources
  • Exercises
  • And More!

Who this course is for:

  • Anyone who wants to become familiar with unit testing and test driven development concepts
  • Intermediate JavaScript Developers
  • Advanced JavaScript Developers

Course content

7 sections • 11 lectures • 1h 25m total lengthExpand all sections

Introduction1 lecture • 1min

  • Introduction00:37

What is Unit Testing?2 lectures • 4min

  • What is Unit Testing?02:45
  • Test Driven Development01:35

Assert1 lecture • 9min

  • Example Assert Function08:31

Jasmine testing framework1 lecture • 11min

  • Introduction to Jasmine10:30

Additional Resources4 lectures • 1hr

  • Bonus Part 1: Describing Unit Testing To Students at RefactorU16:18
  • Bonus Part 2: Describing Unit Testing To Students at RefactorU11:57
  • Bonus Part 3: Describing Unit Testing To Students at RefactorU19:18
  • Bonus Part 4: Describing Unit Testing To Students at RefactorU12:43

Excercises1 lecture • 0min

  • Exercises1 page

Conclusion1 lecture • 1min

  • Course Conclusion00:40

A Python project with coding framework and unit testing

Python basics and real world coding framework – organizing code, logging, error handling, config file, unit testing


  • Basic programming skills and SQL knowledge required


Learn how to code and unit test Python applications in a real world project. Go beyond the basics by solving a practical use case step by step. This course is designed for Python beginners who want to transition for academic background to a real world developer role !

Course Project :

You will be building a Python application to read data from files and store the data into PostgreSQL database. You will be creating REST endpoints using which external users will interact with your application data. All the industry standard best practices in terms of logging, error handling, config file, code structuring will be used in the application.

Course structure :

  • Python (3.9) and PyCharm IDE installation
  • Python basics – Get started with basic Python data types including List, Tuple and Dictionary
  • Organizing code with Classes and Modules – Understand core concepts of classes and packages
  • Python logging – Implement logging using basic config and file config
  • Python error handling – Learn how to handle exceptions.
  • Python PostgreSQL database interaction – Understand how to read and write to PostgreSQL using psycopg2
  • Create REST API using Python – Learn to create APIs using Python Flask framework
  • Reading configuration from property file – Learn how to avoid hardcoding of configurable properties
  • Unit testing – Learn to test your application using unittest package
  • Unit testing – Learn to test your application using PyTest package

You will learn the above concepts by building a real world file processing application. No prior Python knowledge required.

Prerequisites :

  • Basic programming skills
  • Basic knowledge of SQL queries

Who this course is for:

  • Python beginners who are getting ready for real world developer role

Course content

8 sections • 31 lectures • 1h 55m total lengthExpand all sections

Introduction5 lectures • 7min

  • Introduction01:37
  • What is Python?01:02
  • Installing Python00:46
  • Installing PyCharm02:28
  • Creating a project in the main Python environment01:19

Python getting started3 lectures • 16min

  • Python basics09:27
  • Python dictionary04:42
  • Python List and Tuple02:20

Organizing code, logging and error handling6 lectures • 27min

  • Structuring code with classes and functions08:12
  • Initializing variables with a constructor04:37
  • Logging using basic config03:48
  • Logging using file config04:13
  • Having multiple loggers in an application03:47
  • Error handling with try and except blocks02:36

Reading configuration and database interaction5 lectures • 21min

  • Reading properties from a configuration file03:16
  • Installing PostgreSQL03:55
  • Reading from and writing to Postgres08:58
  • Organizing code further03:16
  • Handling the unique key constraint error01:50

Reading data from a JSON file and storing it in database2 lectures • 8min

  • Reading data from a JSON file02:34
  • Writing JSON file data to PostgreSQL05:39

Creating REST APIs4 lectures • 15min

  • What is REST?01:13
  • Understanding how REST will be used in the application01:01
  • Creating a REST API to fetch course list07:37
  • Creating a REST API to store course information05:24

Unit testing3 lectures • 14min

  • Python unittest package03:35
  • Data and error testing04:49
  • Unit testing with PyTest05:24

Where to go from here?3 lectures • 6min

  • Where to go from here?00:07
  • Preview – Data Engineering – Hadoop and Spark03:16
  • Preview – Machine Learning Deep Learning Model deployment introduction02:54

JUnit 5 Quick Start: Java Unit Testing

How to write and run Java Unit tests using JUnit 5

JUnit asserts and annotations

Test-driven development

How to use JUnit for bug fixes

How to use JUnit for feature requests

The import statements needed to run JUnit

Best practices and coding conventions

How to understand test output


  • Basic experience with Java (creating classes, understanding methods, etc.)
  • Beginner to JUnit


Let’s make things easy! In this quick-start course, students will learn how to write and run JUnit Java unit tests. Imports, annotations, and test output will illustrated and explained.  Best practices are discussed and demonstrated through examples and applications. By the end of the course, students will be able to conduct their own JUnit tests, successfully interpret test output, and incorporate best practices in their software development. The course is taught by a straight-A Ivy League graduate with industry experience in the subject matter.  No prior knowledge of JUnit is required. 

Who this course is for:

  • Java developers (beginner or advanced) who want to learn JUnit

Course content

3 sections • 11 lectures • 34m total lengthExpand all sections

Introduction2 lectures • 4min

  • Introduction: what JUnit is, how it works, and why it is important.04:01
  • Course requirements00:26

JUnit fundamentals8 lectures • 29min

  • Your first JUnit tests: @Test, assertEquals(), assertNotEquals()03:50
  • The assertTrue() and assertFalse() methods.03:32
  • Practice: JUnit methods04:15
  • Fielding a bug report : best-practices demonstration03:25
  • Implementing a feature request : best-practices demonstration04:45
  • @BeforeAll, @AfterAll annotations02:31
  • The assertArrayEquals() method04:15
  • Development practice: performing a bugfix02:40
  • Quiz 15 questions
  • Quiz 24 questions

Course wrap-up1 lecture • 1min

  • Course conclusion00:39

Introduction to TDD in C#

Introduction to TDD in C#


  • You should already be familiar with the basics of C#
  • You should already be familiar with the basics of unit testing


Today unit testing is the absolutely required skill which is required from any professional developer. Companies expect from developers to know how to write unit tests including all the most important topics such as mocking and test driven development (TDD in short).

This course is all about practicing TDD using C# programming language and NUnit as a unit testing framework. Along the way, we will learn the concepts related to unit testing. This course does not cover all the features of NUnit. This course is way more interesting.

Learning unit testing and TDD puts a powerful and very useful tool at your fingertips. Being familiar with unit testing and TDD you can write reliable and maintainable applications. It is very hard to lead a project which is not covered by unit tests.

Content and Overview   

This course is primarily aimed at developers who’re already familiar with the basics of unit testing and dependency injection. Some experience in C# programming is required. 

Theory is dead without practice, so starting from the second section, you’ll see tons of programming sessions where I’ll demonstrate how to implement generating of Fibonacci numbers, FizzBuzz, parsing of roman numerals, updateable spin synchronization primitives, tic-tac-toe or crosses and noughts game and game in sticks. You’ll also learn:   

  • How a regular agile development process looks like   
  • That you need to learn shortcuts to practice TDD more smoothly   
  • Three Main TDD techniques: faking, triangulation and obvious implementation   
  • Which tests to write first   
  • How to start writing a test in a TDD manner

Here is my Teaching Approach –

No fluff, no ranting, no beating the air. I respect your time. The course material is succinct, yet comprehensive. All important concepts are covered. Particularly important topics are covered in-depth. For absolute beginners, I offer my help on Skype absolutely free, if requested.

Take this course, and you will be satisfied.

Who this course is for:

  • Any developer who wants to improve professional programming skills

Course content

2 sections • 30 lectures • 3h 13m total lengthExpand all sections

Introduction to Test-Driven Development (TDD)14 lectures • 53min

  • Download Source Code00:02
  • Join Chat in Telegram00:02
  • Outline01:06
  • Why we need TDD?16:18
  • What is TDD?05:00
  • Red / Green / Refactor04:16
  • Three Laws of TDD01:42
  • Changing Requirements and the Safety Net05:23
  • F.I.R.S.T.02:48
  • Code Coverage02:19
  • Types of Tests and TDD04:04
  • Testing Frameworks and Tools05:06
  • When TDD Fails?02:46
  • Conclusion02:02

TDD in Action16 lectures • 2hr 20min

  • Outline01:46
  • Regular Agile Process in 200 Words01:59
  • VS and R# Shortcuts03:44
  • Refactoring Commands Built-In Visual Studio00:09
  • Fibonacci Numbers07:38
  • Three Main TDD Techniques04:31
  • Grabbing the Gold03:10
  • FizzBuzz11:06
  • Reading Roman Numerals12:07
  • UpdateableSpin17:50
  • Continuous Testing03:57
  • Tic-Tac-Toe (Crosses and Noughts)36:17
  • Assert First01:26
  • Demo – Sticks32:16
  • Conclusion01:38
  • BONUS00:35

Beginners Guide to Unit Testing with NUnit and C#

Write simple unit tests in C# using the NUnit framework


  • Basic Skills in C#


This course is all about writing unit tests using C# programming language and NUnit as a unit testing framework. Today unit testing is an absolutely required skill from any professional developer. Companies expect from developers to know how to write unit tests.

Learning unit testing puts a powerful and very useful tool at your fingertips. Being familiar with unit testing you can write reliable and maintainable applications. It is very hard to lead a project which is not covered by unit tests.

Content and Overview

This course is primarily aimed at beginner developers.

We start with basics of unit testing. What is a unit test? What unit testing frameworks exist? How to run and debug unit tests. After getting acquainted with the basics, we will get to the NUnit framework. Here you’ll learn how to install the framework, set the runner. Then you’ll learn the basics of assertions and arrange-act-assert triplet. Other key features of NUnit are also covered:

  • Running tests from the console
  • Setup and teardown unit tests
  • Parameterized tests
  • Grouping and ignoring

Who this course is for:

  • Anyone who wants to learn the basic of unit testing

Course content

2 sections • 34 lectures • 1h 52m total lengthExpand all sections

Getting Started16 lectures • 47min

  • About the Course00:27
  • Download Source Code and Slides00:04
  • Join .NET Community of Students00:02
  • BONUS00:35
  • Outline00:58
  • What is a Unit Test?03:11
  • Unit-Testing Frameworks03:25
  • First Unit Test08:49
  • Naming Conventions04:34
  • Running and Debugging Tests in Visual Studio05:02
  • Benefits of Unit Testing03:35
  • Who should write unit tests and When?02:51
  • Programmer’s Oath03:29
  • Exercise: Degree Converter01:29
  • Solution: Degree Converter06:54
  • Conclusion01:15

NUnit Framework18 lectures • 1hr 6min

  • Outline01:06
  • Assert. Introduction05:29
  • Assert. Demo10:27
  • Arrange-Act-Assert (AAA)01:01
  • Running a Test from the Console01:51
  • SetUp and TearDown05:09
  • SetUp and TearDown on Higher Levels02:13
  • Parameterized Tests03:40
  • Grouping and Ignoring02:14
  • Code Coverage01:42
  • Exercise: FizzBuzz01:07
  • Solution: FizzBuzz05:05
  • Exercise: Roman Numerals02:27
  • Solution: Roman Numerals09:27
  • Exercise: Stack00:59
  • Solution: Stack09:02
  • Conclusion01:24
  • BONUS-Video01:18

A Glimpse into the technology agnostic tool – Selenium

Learn about Selenium


  • Knowledge of functional testing and basic programming experience in any language. Idea of what unit testing is all about.


The beauty of selenium is, that it supports itself getting programmed on any programming language as long as its drivers are available in it.

It runs tests on any browser as long as they are w3C compliant

And it executes on any operating system.

In this talk we will understand to look at Selenium as a web browser driving tool, which it is actually. We will understand that it doesn’t matter which programming language you use, the concepts around all languages and their unittest remains the same.

Languages covered – Java, C#, Python, Ruby and JavaScript.

Browsers – Chrome and Firefox

OS for demo – Windows.

Who this course is for:

  • Anyone who wants to know about the power of the web driving tool Selenium

Course content

1 section • 5 lectures • 1h 5m total length

Introduction5 lectures • 1hr 5min

  • The Technolgy Agnostic Powerhouse Tool – Selenium15:05
  • The three pillars of Selenium15:05
  • Login Logout with Java15:05
  • Login Logout with – Python, Ruby, Csharp and JavaScript15:05
  • Conclusion04:46

Master JUnit 5 for Java developers

Understand JUnit architecture

Understand and create tests using assertions with hands on coding

Create different types of tests – repeated, conditional, nested etc…

Create TestSuites

Generate JUnit reports


  • Basic Java knowledge


This course is for Java developers who are trying to learn JUnit5 to test their code.

JUnit is probably the most widely used unit testing framework for Java developers. It is the next iteration of JUnit after Junit4 and has a number of new features added.

Knowing how to test your code automatically and enabling your code to be seamlessly tested as part of a CICD pipeline is a “must have” for any developer.

With this course you learn:

JUnit 5 architecture – You learn the basic architecture of JUnit5 and how it builds on top of the JUnit testing platform.

Lifecycle annotations – @Test, @BeforeEach, @AfterEach, @AfterAll @BeforeAll

Testing using assertions – You learn to test for equality, null, exceptions etc…

Various testing scenarios – Write test cases using @RepeatedTest, @ParameterizedTest, @ConditionalTest

Grouping tests – group various tests using @Nested and @Suite annotations.

Reporting test results using maven. With just a few additions to your maven configuration, you will be able to publish these results to a web-page and also share it with your team.

All of the coding will be done on Eclipse. However, if you are familiar with IntelliJ, that should be fine too.

The course will be completely hands on, except when it is required to explain concepts.

Who this course is for:

  • Java developers and anyone interested in building robust Java applications

Course content

8 sections • 21 lectures • 49m total lengthExpand all sections

Course Introduction1 lecture • 2min

  • Introduction01:34

JUnit5 Architecture and Environment Setup2 lectures • 4min

  • JUnit Architecture01:56
  • Environment Setup01:56

Your first JUnit test3 lectures • 7min

  • Section Introduction00:36
  • Creating test cases with a custom folder structure02:43
  • Creating test cases using Maven03:54

JUnit lifecycle and assertions7 lectures • 14min

  • JUnit Lifecycle annotations01:07
  • Assertions Introduction00:56
  • Assertions – 102:32
  • Assertions – 201:57
  • Assertions – 302:35
  • Before and After annotations04:11
  • Naming Tests01:08

Types of JUnit testing4 lectures • 15min

  • Enable and Disable Tests02:42
  • Ordering the sequence of test cases01:44
  • Repeated tests03:05
  • Parameterized tests07:19

Grouping tests2 lectures • 5min

  • Grouping tests using @Nested01:20
  • Grouping tests using @Suite03:41

Reporting test results1 lecture • 2min

  • Reporting using maven site02:22

Conclusion1 lecture • 1min

  • Thank you!00:21

Hamcrest Quick Start: Enhanced JUnit syntax and capabilities

How to use Hamcrest to make unit tests more expressive

How to use Hamcrest to increase unit testing capability

How to use Hamcrest to ease unit testing development

How to write and run custom Hamcrest matchers


  • Basic abilities with Java and Junit.
  • Basic abilities with an IDE.


JUnit is one of Java’s most popular unit testing frameworks.  Hamcrest is an additional layer that sits on top of JUnit, and it allows you to write expressive and developer-friendly unit tests.  In this course, you will learn which imports to use, how to write and run Hamcrest tests, how to use Hamcrest’s fundamental methods, and how to write your own custom Hamcrest matchers.  No prior knowledge of Hamcrest is necessary. The course is example-driven instruction and includes guided practice and quizzes to strengthen your understanding. Basic knowledge of Java programming and JUnit is required.

Who this course is for:

  • Developers looking to add Hamcrest into their unit testing
  • Students wishing to learn Hamcrest
  • Academics wishing to learn development tools used in industry
  • Software team leaders looking to evaluate Hamcrest as a development tool

Course content

5 sections • 18 lectures • 44m total lengthExpand all sections

Introduction8 lectures • 15min

  • Hamcrest source code.00:03
  • Introduction00:49
  • assertThat(), equalTo() methods02:07
  • String methods02:33
  • Number methods02:50
  • Expressive syntax01:33
  • Matcher practice 102:49
  • Matcher practice 201:58
  • Quiz 15 questions

Hamcrest In Greater Depth4 lectures • 12min

  • Array methods02:05
  • Collection methods04:23
  • Object methods, anything()03:56
  • Matcher practice 302:00
  • Quiz 26 questions

Custom Hamcrest Matchers4 lectures • 14min

  • Custom Hamcrest matcher: IsOdd03:46
  • Custom Hamcrest Matcher: Sum03:13
  • Write Your Own Custom Matcher: StartsWith03:40
  • Write Your Own Custom Matcher: AlphaNumeric03:32

Beans1 lecture • 3min

  • Methods for Java Beans02:38

Course Conclusion1 lecture • 1min

  • Course Conclusion00:35

Unit Testing en C#

Unit testing automatizado


  • Conocimientos de .Net/C#


Este curso está destinado a programadores C# con poca o ninguna experiencia en la automatización de pruebas. Presenta los conceptos básicos de pruebas unitarias. Si bien se utiliza la herramienta NUnit todos los conceptos son perfectamente aplicables a otras herramientas como MSTest y xUnit sin mayores dificultades. Más aún, los conceptos también pueden extrapolarse fácilmente a herramientas de otras tecnologías como JUnit (java), RubyTest(ruby) y SUnit(smalltalk).

El curso consta de dos horas de video, repartidas en varios videos de no más de 10 minutos cada uno. Adicionalmente a los videos el curso provee un conjunto de recursos que incluyen lecturas complementarias y ejercicios de programación con sus respectivas soluciones para que puedas comparar con tu propia solución. El curso también puede ser de gran utilidad para programadores que ya tengan experiencia haciendo pruebas automatizadas ya que además de los conceptos fundacionales de la materia, se ofrecen también varias recomendaciones surgidas de la experiencia de haber trabajado por más de 15 años en la temática.

Si bien puedes hacer el curso al ritmo que gustes, mi recomendación para un aprendizaje efectivo es que planifiques para hacerlo en una  semana, reservando 4 bloques de 1 hora en los cuales alternes videos, lecturas y ejercicios. Es fundamental que hagas los ejercicios, son pocos, pero te ayudarán a afianzar los conceptos.

Who this course is for:

  • Desarrollo de .Net/C#

Course content

3 sections • 15 lectures • 1h 57m total lengthExpand all sections

Fundamentos7 lectures • 51min

  • Fundamentos de unit testing08:06
  • Un primer test sin framework de testing08:05
  • Hacia un framework de testing06:53
  • Primeros pasos con NUnit06:49
  • Posibles resultados de un test09:28
  • NUnit, VSCode & Rider03:08
  • Test Runner & Nunit Test Adapter08:20

Convenciones de NUnit4 lectures • 35min

  • Un ejemplo más real de NUnit10:30
  • Inicialización y finalización de test en NUnit06:57
  • Test de situaciones de excepción07:47
  • Tipos de Asserts09:17

Organización de casos de prueba4 lectures • 33min

  • Generación de Casos de Prueba con NUnit08:28
  • Agrupamiento de test en NUnit07:23
  • Consideraciones de diseño de Casos de Prueba07:11
  • Cierre y Siguientes pasos09:35