
Master test driven development in dotnet core by writing unit tests first. Apply a red, green, refactor cycle to build testable, modular software for a room booking app.
Learn how to move from dot net five to dot net six or seven, update target frameworks, and refresh NuGet packages. Discover how program.cs replaces startup in newer dot nets.
Set up a new xUnit test project in Visual Studio for the room booking app core tests, configure the project, and learn unit test basics like arrange, act, and assert.
learn to create a first unit test for a room booking request processor in asp.net core using xunit, practicing the arrange-act-assert cycle, and validating results with should or fluent assertions.
Implement the book room method to return a room booking result mirroring the request fields email, full name, and request date, and drive the test green.
Master refactoring within a test-driven cycle by relocating code into a dot core class library, updating namespaces, making members public, and applying Visual Studio productivity tips.
Flesh out the room booking app requirements by creating a GitHub kanban with notes and checkboxes, including request validation, availability checks, and booking records.
Shows test-driven development in ASP.NET Core by writing a test that throws an argument null exception when the request is null and refactoring with a shared processor setup.
Define and implement a room booking service interface to separate data access from business logic, introduce a domain room booking model, and prepare saving logic for tests.
Demonstrates a unit test that saves a room booking by invoking the processor, using a mocked room booking service via dependency injection, and asserting the save call occurs once.
Implement and refactor the room booking save flow in a test-driven ASP.NET Core setup, introducing a generic create method, base room booking, and clean inheritance to pass all tests.
Apply test-driven development in ASP.NET Core to ensure the room id is saved on a room booking by implementing and testing the first available room flow.
Explore data-driven testing in ASP.NET Core to return a booking result flag, validating success or failure via theory data and enums.
Apply test driven development by adding room booking id to the result, using data driven tests to handle null and non-null ids, and verify with assertions.
Review the completion of unit testing and code coverage for the application core, and outline upcoming work on interface implementations and database integration in a test driven development workflow.
Refactor the data access layer by reorganizing projects into domain and persistence, configure EF Core DbContext with SQL Server, and implement repositories for room and room booking data.
Develop an integration-style unit test for the room booking service using an in-memory Entity Framework Core database, seed data, and validate get available rooms for a test date.
Implement the get available rooms feature in an ASP.NET Core app using test-driven development, querying rooms and bookings to return rooms available on a given date.
Learn how to perform an integration test to save a room booking to the database using a context, asserting a single record with the correct room id and date.
Explain structuring unit tests for the room booking service and conducting integration tests with Entity Framework Core and external services like queues and email systems.
Set up an in-memory sqlite data store for a web app by configuring a sqlite in-memory connection and wiring EF Core SQLite with the db context in startup.
Create unit test scenarios for the room booking API controller, verifying valid bookings return an ok result while invalid inputs yield bad requests using mocks and dependency injection.
Implement validation for a room booking model in dotnet core and wire a post controller to return ok with a booking result or bad request. Drive test-driven development.
Configure the IoC container for the room booking service, apply migrations, and ensure the SQLite database is created, then test the API with Swagger under test driven development.
Explore how test driven development guides writing unit tests, and set up a build pipeline to protect the code base from syntax errors via GitHub actions, branching, and pull requests.
Set up a GitHub account and learn why GitHub is the go-to collaborative space for developers. Discover actions, codespaces, pull requests, and branching for automated testing and safe code collaboration.
Learn to add an existing project to Git and GitHub, use local and remote repositories, stage, commit, push changes, pull updates, and protect the master branch.
Protect your main branch in GitHub by applying branch protection rules, requiring pull requests and at least one reviewer, and enabling code review to keep deployable code.
Protect the code base with a continuous integration pipeline by using git branching and pull requests, including creating branches, submitting pull requests, code reviews, and safe merging.
Set up a GitHub Actions-based continuous integration pipeline for an ASP.NET Core project, configuring a YAML workflow with dotnet restore, build, and test steps triggered by pull requests.
Automate unit testing and pull request reviews by finalizing the continuous integration action and pipeline, ensuring tests pass and merging into main using GitHub actions and dotnet workflows.
Learn to use GitHub with branches and pull requests, protect the main branch, automate testing with actions, and maintain a pristine master while aligning test driven development with devops.
Apply test driven development fundamentals in dotnet core by separating API, core, and persistence, and use data driven tests with xUnit to ensure all layers stay green.
Test Driven Development (TDD) is a powerful approach to building reliable and robust software. This course will teach you how to apply TDD in your .NET projects. Unit Testing is a type of software testing where code is written to automate the testing of sub-sections of an entire application. This methodology gives more functional coverage and reduces the need for manual regression testing when the application's code changes. The purpose is to validate that each unit of the software code performs as expected.
Everything in this course is .NET 6 / .NET 7 compatible.
You will discover the basics of unit testing and the red-green-refactor cycle. You will also learn how to test and implement business logic in a .NET Core application using xUnit as a testing framework and Moq as a mocking library.
After this course, you will have the foundational knowledge of Test Driven Development that will help you as you move forward to test and implement new features in your C# projects. You will have the skills and knowledge to create a testable and maintainable ASP.NET Core application to architect real-world enterprise .NET Core apps.
Build A Strong Foundation in Unit Testing in .NET:
Use xUnit Test Projects.
Use Moq and Shouldly(Fluent Assertions) to write unit tests.
GitHub Projects to Track Requirements
Conduct Red, Green, Refactor Test-driven development (TDD)
Practice Test-Driven Development in actual code
Learn to write testable code
Understand how to write unit tests, then create or refactor code
Review Pitfalls to avoid and common challenges
Learn how to set up a Continuous Integration Pipeline using GitHub.
Content and Overview
To take this course, you must have some knowledge of .NET Core development and C#.
With just over 4 hours of premium content, smartly broken up to highlight related activities based on each module in the application being built; we will also look at troubleshooting and debugging errors as we go along, implementing best practices, writing efficient logic, and understanding why developers do things the way they do. Your knowledge will grow, step by step, throughout the course, and you will be challenged to be the best you can be.
We sometimes do things differently than the first time; that is not the reality of writing code. We make mistakes and point them out and fix them around them. By doing this, we develop proficiency in using debugging tools and techniques. By the time you have finished the course, you will have moved around in Visual Studio and examined logic and syntax errors so much that it will be second nature for you when working in the .NET environment. This will put your newly learned skills into practical use and impress your boss and coworkers.
The course is complete with working files hosted on GitHub, including some files to make it easier for you to replicate the demonstrated code. You will be able to work alongside the author as you work through each lecture and will receive a verifiable certificate of completion upon finishing the course.
Clicking the Take This Course button could be the best step to increase your income and marketability quickly! Also, remember that if you think the course is not worth what you spent, you have a full 30 days to get a no questions asked refund!
It's time to take action!
See you in the course!