Testing C# Code with NUnit and Moq for a Reliable Unit Layer

When software teams in Sydney, Melbourne, Brisbane, Perth, Adelaide and other Australian tech hubs ship C# applications to production, they rely on unit tests to protect core business logic. A solid unit layer catches regressions early, makes refactoring safer and shortens feedback loops. The combination of NUnit and Moq has become a familiar pairing for .NET developers across the country, partly because the pair works smoothly with Visual Studio, Rider and the command line tooling that local teams already use.

NUnit acts as the test framework that discovers, organises and executes test methods. Moq provides a lightweight mocking library that builds test doubles on the fly. Together they help isolate the system under test from databases, file systems, REST endpoints and other moving parts. For Australian developers operating under the Privacy Act 1988 and the Notifiable Data Breaches scheme, isolating external systems in unit tests is more than a stylistic preference; it is a practical way to keep personal information out of test fixtures.

This walkthrough targets engineers who already write C# code and want a repeatable method for verifying behaviour at the unit level. It assumes familiarity with Visual Studio or JetBrains Rider, basic object-oriented programming and a working knowledge of dependency injection. Every snippet uses C# 10 syntax and targets .NET 6 or later, although most examples compile unchanged on .NET Framework projects that many Adelaide government departments and Brisbane enterprise codebases still maintain.

The article is laid out so a developer can read it from top to bottom during a long flight between Perth and Sydney, then apply the same patterns the next morning. Each section builds on the previous one, mixing theory with runnable examples and finishing with notes on continuous integration for Australian build infrastructure.

Building a Reliable Unit Layer in Modern C# Projects

Australian .NET meetups such as DDD Melbourne, Adelaide .NET, Brisbane .NET and the various Sydney Code Camp events frequently feature talks on testing, and a recurring recommendation is the NUnit plus Moq pairing. NUnit has decades of maturity, supports parallel execution, parameterised tests and a fluent assertion API through its own Constraint model or third-party libraries such as FluentAssertions. Moq, maintained by the Moq team on GitHub, leans on dynamic proxy generation from Castle.Core to create implementation classes for interfaces and sealed classes with virtual members.

The two libraries are not formally tied together, but they complement each other because both follow a convention-over-configuration philosophy. A developer writes a test method, decorates it with an attribute such as [Test], and uses a Mock<T> object to substitute dependencies. This style matches how Australian engineering culture values pragmatic tools that do not require large amounts of boilerplate before delivering value.

Setting Up the Solution with the dotnet CLI

A clean solution layout speeds up review and onboarding, especially for distributed teams that span Melbourne, Canberra and remote regional towns. Many Australian consultancies structure their repositories with a src folder for production projects and a tests folder mirroring the same folder names. A typical project uses three projects: the application library, a unit test project targeting net8.0 and a separate integration test project that talks to real services.

To add the packages, the dotnet CLI is the most portable option. From the root of the repository:

dotnet add tests/Acme.Billing.Tests package NUnit
dotnet add tests/Acme.Billing.Tests package NUnit3TestAdapter
dotnet add tests/Acme.Billing.Tests package Moq
dotnet add tests/Acme.Billing.Tests package Microsoft.NET.Test.Sdk

The Microsoft.NET.Test.Sdk package supplies the VSTest discovery protocol so Visual Studio Test Explorer, Rider's unit test runner and the command line dotnet test all share the same execution path. Adding a Directory.Build.props file at the solution root helps standardise target frameworks and language versions across all teams, including contractors working from Perth or Darwin. Engineers in Adelaide offices often run tests inside Docker containers so the local environment matches the CI runner image, avoiding the classic "works on my machine" complaint that surfaces in many retrospectives.

Comparing NUnit, xUnit and MSTest Side by Side

Before settling on NUnit, it helps to compare the mainstream test frameworks available in the .NET world. The table below summarises the trade-offs that Australian engineering leads weigh during framework selection sessions:

For greenfield projects in Sydney and Melbourne, NUnit's Constraint model reads almost like English and pairs well with Moq's lambda expressions. For existing codebases already on MSTest, Moq still works because mocking is independent of the test framework. The deciding factor is usually the team's familiarity with assertion syntax and how easily the framework integrates with Azure DevOps pipelines hosted in Australian regions.

NUnit encourages the classic arrange-act-assert rhythm that many code reviewers expect to see in pull requests. The arrange phase sets up inputs, mocks and expected values, the act phase invokes the method under test and the assert phase checks the result. This rhythm is so familiar that Australian engineering leads often mention "the three A's" when mentoring junior developers in regional Queensland offices.

Using Moq to Isolate Dependencies

Mock objects replace real collaborators so the unit under test runs in isolation. Consider a small InvoiceService class that calculates a late fee for overdue accounts. The service depends on an IClock interface so tests can freeze time. Replacing a real DateTime.UtcNow call with a mock turns the test deterministic and protects the suite from time-of-day flakiness. Moq uses a fluent Setup chain to configure behaviour and a Verify chain to assert it.

Common Moq setup patterns seen in Australian codebases

• Setup returning a canned value from a property or method call.
• Throws simulating exception paths such as HttpRequestException or TaskCanceledException.
• Callback capturing arguments passed into a method for later inspection.
• Verify confirming a call happened exactly once, never or at least twice.

This style lets a unit test simulate a payment gateway returning a decline, an email service throwing a transient SMTP error or a repository reporting a concurrency conflict, all without hitting a real network. Banks in Sydney and Melbourne regularly mock AUSTRAC reporting endpoints so unit suites finish in seconds rather than minutes.

Verifying Behaviour Versus State

Two schools of thought compete inside Australian engineering circles: state-based testing and behaviour-based testing. State testing checks the observable output of the system under test, such as a calculated fee or a persisted entity. Behaviour testing checks that the right calls were made on collaborators in the right order. Both styles have a place.

For pure functions, state-based assertions are usually clearer. For workflow code that orchestrates external systems, behaviour checks shine. Moq supports both through its Returns, Throws and Verify APIs. The Verify method takes a Times constraint so a test can assert that an audit log was written exactly once, at least once or never.

A practical example is a NotifyCustomer method that should call an IEmailSender once with the correct subject line. The test could read:

_emailSender.Verify(s => s.Send(It.IsAny<string>(), "Payment overdue"), Times.Once);

Combining state and behaviour assertions in the same test is acceptable as long as each assertion relates to a single unit of intent. Splitting mixed concerns into separate tests keeps failures informative when a CI pipeline in an Azure region reports a red build at three in the morning.

Organising Tests with Categories and Parameters

Australian teams with large test suites adopt conventions from the broader .NET community to keep things manageable. NUnit supports several attributes that help structure tests beyond a single flat file. [Category] groups tests by feature area so a build agent can run only the smoke tests for a hot fix. [TestCase] supplies parameters so a single test method can cover many inputs. [OneTimeSetUp] and [OneTimeTearDown] handle expensive resources shared across the whole fixture.

Useful categories seen in Australian .NET projects

• Smoke covering the critical path that runs on every commit.
• Regression covering historical bug fixes.
• Performance measuring throughput under load.
• Security asserting authorisation and audit rules.

TestCase attributes help test boundary conditions. A method that validates Australian Business Numbers can use [TestCase("12345678901", ExpectedResult = true)] to confirm the checksum and [TestCase("123", ExpectedResult = false)] to reject short inputs. This style of data-driven testing is especially handy for finance teams in Sydney and Melbourne that deal with TFN, ABN and GST validation on a daily basis.

Continuous Integration and Australian Realities

Unit tests only deliver value when they run often. Australian build infrastructure spans Azure regions in Sydney and Melbourne, GitHub Actions runners hosted overseas and on-premises TeamCity servers in some banks. Pipeline configuration should run dotnet test on every pull request, publish TRX test results as build artefacts and fail the build when coverage drops below an agreed threshold.

Beyond CI, several local realities shape how unit tests are written. The Privacy Act 1988 and the Australian Privacy Principles encourage developers to avoid placing real customer data into test fixtures. Mocking identity providers, contact details and addresses is one way to comply with the Notifiable Data Breaches scheme. Australian timezone handling also matters: storing DateTime values with DateTimeKind.Utc and converting to Australian Eastern Standard Time, Australian Western Standard Time or Australian Central Standard Time only at the presentation layer avoids the famous daylight saving bug that surfaces twice a year.

Mocking time, identity and external APIs keeps unit tests fast, deterministic and compliant with local legislation. Combined with NUnit's discovery engine and a CI pipeline that runs on every push, this approach gives Australian software shops a unit layer they can trust during a long deployment window or a midnight release.