Prompt file imported from uladzislauboika/FreeBelarus (.github/prompts/add-unit-test.prompt.md). Copyright stays with the author.

Unit Test Implementation Guide

Name: add-unit-test
Author: uladzislauboika

This prompt provides comprehensive examples and patterns for implementing unit tests following the FreeBelarus project guidelines.

Test Structure (AAA Pattern)

Always organize tests using the Arrange-Act-Assert pattern with clear comments:

[Fact]
public async Task MethodName_Scenario_ExpectedBehavior()
{
    // Arrange
    var mockDependency = new Mock<IDependency>();
    mockDependency.Setup(x => x.Method()).ReturnsAsync(value);
    var sut = new ServiceUnderTest(mockDependency.Object);

    // Act
    var result = await sut.MethodToTest();

    // Assert
    Assert.NotNull(result);
    Assert.Equal(expectedValue, result.Property);
}

Mocking Examples

Correct Mocking Pattern

// ✅ CORRECT: Mock external dependencies
var mockRepository = new Mock<IEventRepository>();
var mockLogger = new Mock<ILogger<EventService>>();
var sut = new EventService(mockRepository.Object, mockLogger.Object);

// Setup method return values
mockRepository
    .Setup(x => x.GetByIdAsync(It.IsAny<int>()))
    .ReturnsAsync(new Event { Id = 1, Title = "Test" });

// ❌ INCORRECT: Don't mock the SUT
var mockService = new Mock<EventService>();

Complete Test Class Template

using FreeBelarus.Core.Entities;
using FreeBelarus.Core.Services;
using FreeBelarus.Data.Repositories;
using Moq;
using Xunit;

namespace FreeBelarus.Core.Tests.Services.Impl
{
    public class EventServiceTests
    {
        private readonly Mock<IEventRepository> _mockEventRepository;
        private readonly Mock<ICategoryRepository> _mockCategoryRepository;
        private readonly EventService _sut;

        public EventServiceTests()
        {
            // Setup common mocks in constructor
            _mockEventRepository = new Mock<IEventRepository>();
            _mockCategoryRepository = new Mock<ICategoryRepository>();
            _sut = new EventService(_mockEventRepository.Object, _mockCategoryRepository.Object);
        }

        [Fact]
        public async Task GetEventByIdAsync_WhenEventExists_ReturnsEvent()
        {
            // Arrange
            var expectedEvent = CreateValidEvent(1, "Test Event");
            _mockEventRepository
                .Setup(x => x.GetByIdAsync(1))
                .ReturnsAsync(expectedEvent);

            // Act
            var result = await _sut.GetEventByIdAsync(1);

            // Assert
            Assert.NotNull(result);
            Assert.Equal(expectedEvent.Id, result.Id);
            Assert.Equal(expectedEvent.Title, result.Title);
        }

        [Fact]
        public async Task GetEventByIdAsync_WhenEventDoesNotExist_ReturnsNull()
        {
            // Arrange
            _mockEventRepository
                .Setup(x => x.GetByIdAsync(It.IsAny<int>()))
                .ReturnsAsync((Event?)null);

            // Act
            var result = await _sut.GetEventByIdAsync(999);

            // Assert
            Assert.Null(result);
        }

        [Theory]
        [InlineData(0)]
        [InlineData(-1)]
        [InlineData(-100)]
        public async Task GetEventByIdAsync_WithInvalidId_ThrowsArgumentException(int invalidId)
        {
            // Act & Assert
            await Assert.ThrowsAsync<ArgumentException>(
                () => _sut.GetEventByIdAsync(invalidId)
            );
        }

        [Fact]
        public async Task GetEventsAsync_WhenNoEvents_ReturnsEmptyCollection()
        {
            // Arrange
            _mockEventRepository
                .Setup(x => x.GetAllAsync())
                .ReturnsAsync(new List<Event>());

            // Act
            var result = await _sut.GetEventsAsync();

            // Assert
            Assert.NotNull(result);
            Assert.Empty(result);
        }

        [Fact]
        public async Task GetEventsAsync_WithCategoryFilter_ReturnsFilteredEvents()
        {
            // Arrange
            var events = new List<Event>
            {
                CreateValidEvent(1, "Event 1"),
                CreateValidEvent(2, "Event 2")
            };
            _mockEventRepository
                .Setup(x => x.GetByCategoryAsync("history"))
                .ReturnsAsync(events);

            // Act
            var result = await _sut.GetEventsAsync("history");

            // Assert
            Assert.NotNull(result);
            Assert.Equal(2, result.Count());
        }

        [Fact]
        public async Task CreateEventAsync_WithValidData_CreatesAndReturnsEvent()
        {
            // Arrange
            var newEvent = CreateValidEvent(0, "New Event");
            var createdEvent = CreateValidEvent(1, "New Event");
            _mockEventRepository
                .Setup(x => x.AddAsync(It.IsAny<Event>()))
                .ReturnsAsync(createdEvent);

            // Act
            var result = await _sut.CreateEventAsync(newEvent);

            // Assert
            Assert.NotNull(result);
            Assert.Equal(createdEvent.Id, result.Id);
            _mockEventRepository.Verify(x => x.AddAsync(It.IsAny<Event>()), Times.Once);
        }

        [Fact]
        public async Task CreateEventAsync_WithNullEvent_ThrowsArgumentNullException()
        {
            // Act & Assert
            await Assert.ThrowsAsync<ArgumentNullException>(
                () => _sut.CreateEventAsync(null!)
            );
        }

        // Helper method for creating test data
        private Event CreateValidEvent(int id, string title)
        {
            return new Event
            {
                Id = id,
                Title = title,
                Year = 2020,
                ShortDescription = "Test Description",
                DetailedDescription = "Test Detailed Description",
                WhyImportant = "Test Importance",
                HistoricalImpact = "Test Impact",
                InterestingFact = "Test Fact",
                Tags = new List<Tag>()
            };
        }
    }
}

Theory Tests for Multiple Scenarios

Use [Theory] with [InlineData] for testing multiple similar scenarios:

[Theory]
[InlineData(null)]
[InlineData("")]
[InlineData("   ")]
public async Task CreateEvent_WithInvalidTitle_ThrowsArgumentException(string title)
{
    // Arrange
    var eventData = new Event { Title = title };

    // Act & Assert
    await Assert.ThrowsAsync<ArgumentException>(
        () => _sut.CreateEventAsync(eventData)
    );
}

[Theory]
[InlineData(0, "Invalid ID: 0")]
[InlineData(-1, "Invalid ID: -1")]
[InlineData(-100, "Invalid ID: -100")]
public async Task GetEventByIdAsync_WithInvalidId_ThrowsArgumentException(int id, string scenario)
{
    // Act & Assert
    var exception = await Assert.ThrowsAsync<ArgumentException>(
        () => _sut.GetEventByIdAsync(id)
    );
    
    Assert.Contains("id", exception.Message);
}

Testing Async Methods

Always use async test methods when testing async code:

[Fact]
public async Task GetEventAsync_WhenCalled_ReturnsEvent()
{
    // Arrange
    var expectedEvent = new Event { Id = 1, Title = "Test Event" };
    _mockRepository
        .Setup(x => x.GetByIdAsync(1))
        .ReturnsAsync(expectedEvent);

    // Act
    var result = await _sut.GetEventByIdAsync(1);

    // Assert
    Assert.Equal(expectedEvent.Id, result.Id);
    Assert.Equal(expectedEvent.Title, result.Title);
}

[Fact]
public async Task GetAllEventsAsync_ReturnsAllEvents()
{
    // Arrange
    var expectedEvents = new List<Event>
    {
        new Event { Id = 1, Title = "Event 1" },
        new Event { Id = 2, Title = "Event 2" }
    };
    _mockRepository
        .Setup(x => x.GetAllAsync())
        .ReturnsAsync(expectedEvents);

    // Act
    var result = await _sut.GetAllEventsAsync();

    // Assert
    Assert.Equal(2, result.Count());
    Assert.Contains(result, e => e.Id == 1);
    Assert.Contains(result, e => e.Id == 2);
}

Verifying Method Calls

Verify that dependencies were called correctly:

[Fact]
public async Task CreateEvent_WhenCalled_CallsRepositoryAdd()
{
    // Arrange
    var newEvent = new Event { Title = "New Event" };
    var createdEvent = new Event { Id = 1, Title = "New Event" };
    _mockRepository
        .Setup(x => x.AddAsync(It.IsAny<Event>()))
        .ReturnsAsync(createdEvent);

    // Act
    await _sut.CreateEventAsync(newEvent);

    // Assert
    _mockRepository.Verify(
        x => x.AddAsync(It.Is<Event>(e => e.Title == "New Event")), 
        Times.Once
    );
}

[Fact]
public async Task UpdateEvent_WhenCalled_CallsRepositoryUpdate()
{
    // Arrange
    var existingEvent = CreateValidEvent(1, "Original Title");
    var updatedEvent = CreateValidEvent(1, "Updated Title");
    
    _mockRepository
        .Setup(x => x.GetByIdAsync(1))
        .ReturnsAsync(existingEvent);
    _mockRepository
        .Setup(x => x.UpdateAsync(It.IsAny<Event>()))
        .ReturnsAsync(updatedEvent);

    // Act
    await _sut.UpdateEventAsync(updatedEvent);

    // Assert
    _mockRepository.Verify(x => x.GetByIdAsync(1), Times.Once);
    _mockRepository.Verify(
        x => x.UpdateAsync(It.Is<Event>(e => e.Title == "Updated Title")), 
        Times.Once
    );
}

Exception Testing

Test exception scenarios explicitly:

[Fact]
public async Task GetEventById_WithNullId_ThrowsArgumentNullException()
{
    // Act & Assert
    var exception = await Assert.ThrowsAsync<ArgumentNullException>(
        () => _sut.GetEventByIdAsync(null)
    );
    
    Assert.Equal("id", exception.ParamName);
}

[Fact]
public async Task CreateEvent_WithNullEvent_ThrowsArgumentNullException()
{
    // Act & Assert
    var exception = await Assert.ThrowsAsync<ArgumentNullException>(
        () => _sut.CreateEventAsync(null!)
    );
    
    Assert.Equal("eventEntity", exception.ParamName);
}

[Fact]
public async Task CreateEvent_WhenRepositoryFails_ThrowsInvalidOperationException()
{
    // Arrange
    var newEvent = CreateValidEvent(0, "Test Event");
    _mockRepository
        .Setup(x => x.AddAsync(It.IsAny<Event>()))
        .ThrowsAsync(new InvalidOperationException("Database error"));

    // Act & Assert
    var exception = await Assert.ThrowsAsync<InvalidOperationException>(
        () => _sut.CreateEventAsync(newEvent)
    );
    
    Assert.Equal("Database error", exception.Message);
}

Test Data Builders

Create helper methods or builders for complex test data:

private Event CreateValidEvent(int id = 1, string title = "Test Event")
{
    return new Event
    {
        Id = id,
        Title = title,
        Year = 2020,
        ShortDescription = "Test Description",
        DetailedDescription = "Test Detailed Description",
        WhyImportant = "Test Importance",
        HistoricalImpact = "Test Impact",
        InterestingFact = "Test Fact",
        Tags = new List<Tag>
        {
            new Tag { Id = 1, Name = "TestTag1" },
            new Tag { Id = 2, Name = "TestTag2" }
        }
    };
}

private List<Event> CreateEventList(int count)
{
    return Enumerable.Range(1, count)
        .Select(i => CreateValidEvent(i, $"Event {i}"))
        .ToList();
}

private Category CreateValidCategory(int id = 1, string name = "Test Category")
{
    return new Category
    {
        Id = id,
        Name = name,
        Alias = name.Replace(" ", "").ToLower(),
        StartYear = 2000,
        EndYear = 2020
    };
}

Testing Collections and Filtering

[Fact]
public async Task GetEventsByCategory_WithValidCategory_ReturnsFilteredEvents()
{
    // Arrange
    var categoryEvents = CreateEventList(3);
    _mockRepository
        .Setup(x => x.GetByCategoryAsync("history"))
        .ReturnsAsync(categoryEvents);

    // Act
    var result = await _sut.GetEventsByCategoryAsync("history");

    // Assert
    Assert.NotNull(result);
    Assert.Equal(3, result.Count());
    Assert.All(result, evt => Assert.NotNull(evt.Title));
}

[Fact]
public async Task GetEventsByYear_WithValidYear_ReturnsFilteredEvents()
{
    // Arrange
    var yearEvents = new List<Event>
    {
        CreateValidEvent(1, "Event 1") { Year = 2020 },
        CreateValidEvent(2, "Event 2") { Year = 2020 }
    };
    _mockRepository
        .Setup(x => x.GetByYearAsync(2020))
        .ReturnsAsync(yearEvents);

    // Act
    var result = await _sut.GetEventsByYearAsync(2020);

    // Assert
    Assert.Equal(2, result.Count());
    Assert.All(result, evt => Assert.Equal(2020, evt.Year));
}

[Fact]
public async Task SearchEvents_WithValidKeyword_ReturnsMatchingEvents()
{
    // Arrange
    var searchResults = new List<Event>
    {
        CreateValidEvent(1, "Battle of Grunwald"),
        CreateValidEvent(2, "Battle of Orsha")
    };
    _mockRepository
        .Setup(x => x.SearchAsync("Battle"))
        .ReturnsAsync(searchResults);

    // Act
    var result = await _sut.SearchEventsAsync("Battle");

    // Assert
    Assert.Equal(2, result.Count());
    Assert.All(result, evt => Assert.Contains("Battle", evt.Title));
}

Advanced Mocking Scenarios

[Fact]
public async Task CreateEvent_WithTags_AssociatesTagsCorrectly()
{
    // Arrange
    var newEvent = CreateValidEvent(0, "New Event");
    var existingTags = new List<Tag>
    {
        new Tag { Id = 1, Name = "TestTag1" },
        new Tag { Id = 2, Name = "TestTag2" }
    };
    
    _mockEventRepository
        .Setup(x => x.AddAsync(It.IsAny<Event>()))
        .ReturnsAsync(newEvent);
    _mockTagRepository
        .Setup(x => x.GetByNamesAsync(It.IsAny<List<string>>()))
        .ReturnsAsync(existingTags);

    // Act
    var result = await _sut.CreateEventWithTagsAsync(newEvent, new[] { "TestTag1", "TestTag2" });

    // Assert
    Assert.NotNull(result);
    _mockTagRepository.Verify(
        x => x.GetByNamesAsync(It.Is<List<string>>(tags => 
            tags.Contains("TestTag1") && tags.Contains("TestTag2"))), 
        Times.Once
    );
}

[Fact]
public async Task DeleteEvent_WhenEventExists_DeletesSuccessfully()
{
    // Arrange
    var existingEvent = CreateValidEvent(1, "Event to Delete");
    _mockRepository
        .Setup(x => x.GetByIdAsync(1))
        .ReturnsAsync(existingEvent);
    _mockRepository
        .Setup(x => x.DeleteAsync(1))
        .Returns(Task.CompletedTask);

    // Act
    await _sut.DeleteEventAsync(1);

    // Assert
    _mockRepository.Verify(x => x.GetByIdAsync(1), Times.Once);
    _mockRepository.Verify(x => x.DeleteAsync(1), Times.Once);
}

[Fact]
public async Task DeleteEvent_WhenEventDoesNotExist_ThrowsNotFoundException()
{
    // Arrange
    _mockRepository
        .Setup(x => x.GetByIdAsync(999))
        .ReturnsAsync((Event?)null);

    // Act & Assert
    await Assert.ThrowsAsync<NotFoundException>(
        () => _sut.DeleteEventAsync(999)
    );
    
    _mockRepository.Verify(x => x.DeleteAsync(It.IsAny<int>()), Times.Never);
}

Integration with FluentAssertions (Optional)

If using FluentAssertions for more readable assertions:

using FluentAssertions;

[Fact]
public async Task GetEventByIdAsync_WhenEventExists_ReturnsEvent()
{
    // Arrange
    var expectedEvent = CreateValidEvent(1, "Test Event");
    _mockRepository
        .Setup(x => x.GetByIdAsync(1))
        .ReturnsAsync(expectedEvent);

    // Act
    var result = await _sut.GetEventByIdAsync(1);

    // Assert
    result.Should().NotBeNull();
    result.Id.Should().Be(expectedEvent.Id);
    result.Title.Should().Be(expectedEvent.Title);
    result.Tags.Should().HaveCount(2);
}

[Fact]
public async Task GetEventsAsync_ReturnsAllEvents()
{
    // Arrange
    var expectedEvents = CreateEventList(5);
    _mockRepository
        .Setup(x => x.GetAllAsync())
        .ReturnsAsync(expectedEvents);

    // Act
    var result = await _sut.GetEventsAsync();

    // Assert
    result.Should().NotBeNull()
          .And.HaveCount(5)
          .And.OnlyContain(e => !string.IsNullOrEmpty(e.Title));
}

Summary

When generating unit tests:

Always confirm the test project location first
Use xUnit with Moq framework
Follow AAA pattern with clear section comments
Name tests descriptively using MethodName_Scenario_ExpectedBehavior
Mock only external dependencies, never the SUT
Cover happy path, edge cases, and exception scenarios
Use Theory tests for multiple similar test cases
Verify important method calls on mocked dependencies
Create helper methods for test data generation
Keep tests readable, maintainable, and focused on single scenarios

# Unit Test Implementation Guide This prompt provides comprehensive examples and patterns for implementing unit tests following the FreeBelarus project guidelines. ## Test Structure (AAA Pattern) Always organize tests using the Arrange-Act-Assert pattern with clear comments: ```csharp [Fact] public async Task MethodName_Scenario_ExpectedBehavior() { // Arrange var mockDependency = new Mock<IDependency>(); mockDependency.Setup(x => x.Method()).ReturnsAsync(value); var sut = new ServiceUnderTest(mockDependency.Object); // Act var result = await sut.MethodToTest(); // Assert Assert.NotNull(result); Assert.Equal(expectedValue, result.Property); } ``` ## Mocking Examples ### Correct Mocking Pattern ```csharp // ✅ CORRECT: Mock external dependencies var mockRepository = new Mock<IEventRepository>(); var mockLogger = new Mock<ILogger<EventService>>(); var sut = new EventService(mockRepository.Object, mockLogger.Object); // Setup method return values mockRepository .Setup(x => x.GetByIdAsync(It.IsAny<int>())) .ReturnsAsync(new Event { Id = 1, Title = "Test" }); // ❌ INCORRECT: Don't mock the SUT var mockService = new Mock<EventService>(); ``` ## Complete Test Class Template ```csharp using FreeBelarus.Core.Entities; using FreeBelarus.Core.Services; using FreeBelarus.Data.Repositories; using Moq; using Xunit; namespace FreeBelarus.Core.Tests.Services.Impl { public class EventServiceTests { private readonly Mock<IEventRepository> _mockEventRepository; private readonly Mock<ICategoryRepository> _mockCategoryRepository; private readonly EventService _sut; public EventServiceTests() { // Setup common mocks in constructor _mockEventRepository = new Mock<IEventRepository>(); _mockCategoryRepository = new Mock<ICategoryRepository>(); _sut = new EventService(_mockEventRepository.Object, _mockCategoryRepository.Object); } [Fact] public async Task GetEventByIdAsync_WhenEventExists_ReturnsEvent() { // Arrange var expectedEvent = CreateValidEvent(1, "Test Event"); _mockEventRepository .Setup(x => x.GetByIdAsync(1)) .ReturnsAsync(expectedEvent); // Act var result = await _sut.GetEventByIdAsync(1); // Assert Assert.NotNull(result); Assert.Equal(expectedEvent.Id, result.Id); Assert.Equal(expectedEvent.Title, result.Title); } [Fact] public async Task GetEventByIdAsync_WhenEventDoesNotExist_ReturnsNull() { // Arrange _mockEventRepository .Setup(x => x.GetByIdAsync(It.IsAny<int>())) .ReturnsAsync((Event?)null); // Act var result = await _sut.GetEventByIdAsync(999); // Assert Assert.Null(result); } [Theory] [InlineData(0)] [InlineData(-1)] [InlineData(-100)] public async Task GetEventByIdAsync_WithInvalidId_ThrowsArgumentException(int invalidId) { // Act & Assert await Assert.ThrowsAsync<ArgumentException>( () => _sut.GetEventByIdAsync(invalidId) ); } [Fact] public async Task GetEventsAsync_WhenNoEvents_ReturnsEmptyCollection() { // Arrange _mockEventRepository .Setup(x => x.GetAllAsync()) .ReturnsAsync(new List<Event>()); // Act var result = await _sut.GetEventsAsync(); // Assert Assert.NotNull(result); Assert.Empty(result); } [Fact] public async Task GetEventsAsync_WithCategoryFilter_ReturnsFilteredEvents() { // Arrange var events = new List<Event> { CreateValidEvent(1, "Event 1"), CreateValidEvent(2, "Event 2") }; _mockEventRepository .Setup(x => x.GetByCategoryAsync("history")) .ReturnsAsync(events); // Act var result = await _sut.GetEventsAsync("history"); // Assert Assert.NotNull(result); Assert.Equal(2, result.Count()); } [Fact] public async Task CreateEventAsync_WithValidData_CreatesAndReturnsEvent() { // Arrange var newEvent = CreateValidEvent(0, "New Event"); var createdEvent = CreateValidEvent(1, "New Event"); _mockEventRepository .Setup(x => x.AddAsync(It.IsAny<Event>())) .ReturnsAsync(createdEvent); // Act var result = await _sut.CreateEventAsync(newEvent); // Assert Assert.NotNull(result); Assert.Equal(createdEvent.Id, result.Id); _mockEventRepository.Verify(x => x.AddAsync(It.IsAny<Event>()), Times.Once); } [Fact] public async Task CreateEventAsync_WithNullEvent_ThrowsArgumentNullException() { // Act & Assert await Assert.ThrowsAsync<ArgumentNullException>( () => _sut.CreateEventAsync(null!) ); } // Helper method for creating test data private Event CreateValidEvent(int id, string title) { return new Event { Id = id, Title = title, Year = 2020, ShortDescription = "Test Description", DetailedDescription = "Test Detailed Description", WhyImportant = "Test Importance", HistoricalImpact = "Test Impact", InterestingFact = "Test Fact", Tags = new List<Tag>() }; } } } ``` ## Theory Tests for Multiple Scenarios Use `[Theory]` with `[InlineData]` for testing multiple similar scenarios: ```csharp [Theory] [InlineData(null)] [InlineData("")] [InlineData(" ")] public async Task CreateEvent_WithInvalidTitle_ThrowsArgumentException(string title) { // Arrange var eventData = new Event { Title = title }; // Act & Assert await Assert.ThrowsAsync<ArgumentException>( () => _sut.CreateEventAsync(eventData) ); } [Theory] [InlineData(0, "Invalid ID: 0")] [InlineData(-1, "Invalid ID: -1")] [InlineData(-100, "Invalid ID: -100")] public async Task GetEventByIdAsync_WithInvalidId_ThrowsArgumentException(int id, string scenario) { // Act & Assert var exception = await Assert.ThrowsAsync<ArgumentException>( () => _sut.GetEventByIdAsync(id) ); Assert.Contains("id", exception.Message); } ``` ## Testing Async Methods Always use async test methods when testing async code: ```csharp [Fact] public async Task GetEventAsync_WhenCalled_ReturnsEvent() { // Arrange var expectedEvent = new Event { Id = 1, Title = "Test Event" }; _mockRepository .Setup(x => x.GetByIdAsync(1)) .ReturnsAsync(expectedEvent); // Act var result = await _sut.GetEventByIdAsync(1); // Assert Assert.Equal(expectedEvent.Id, result.Id); Assert.Equal(expectedEvent.Title, result.Title); } [Fact] public async Task GetAllEventsAsync_ReturnsAllEvents() { // Arrange var expectedEvents = new List<Event> { new Event { Id = 1, Title = "Event 1" }, new Event { Id = 2, Title = "Event 2" } }; _mockRepository .Setup(x => x.GetAllAsync()) .ReturnsAsync(expectedEvents); // Act var result = await _sut.GetAllEventsAsync(); // Assert Assert.Equal(2, result.Count()); Assert.Contains(result, e => e.Id == 1); Assert.Contains(result, e => e.Id == 2); } ``` ## Verifying Method Calls Verify that dependencies were called correctly: ```csharp [Fact] public async Task CreateEvent_WhenCalled_CallsRepositoryAdd() { // Arrange var newEvent = new Event { Title = "New Event" }; var createdEvent = new Event { Id = 1, Title = "New Event" }; _mockRepository .Setup(x => x.AddAsync(It.IsAny<Event>())) .ReturnsAsync(createdEvent); // Act await _sut.CreateEventAsync(newEvent); // Assert _mockRepository.Verify( x => x.AddAsync(It.Is<Event>(e => e.Title == "New Event")), Times.Once ); } [Fact] public async Task UpdateEvent_WhenCalled_CallsRepositoryUpdate() { // Arrange var existingEvent = CreateValidEvent(1, "Original Title"); var updatedEvent = CreateValidEvent(1, "Updated Title"); _mockRepository .Setup(x => x.GetByIdAsync(1)) .ReturnsAsync(existingEvent); _mockRepository .Setup(x => x.UpdateAsync(It.IsAny<Event>())) .ReturnsAsync(updatedEvent); // Act await _sut.UpdateEventAsync(updatedEvent); // Assert _mockRepository.Verify(x => x.GetByIdAsync(1), Times.Once); _mockRepository.Verify( x => x.UpdateAsync(It.Is<Event>(e => e.Title == "Updated Title")), Times.Once ); } ``` ## Exception Testing Test exception scenarios explicitly: ```csharp [Fact] public async Task GetEventById_WithNullId_ThrowsArgumentNullException() { // Act & Assert var exception = await Assert.ThrowsAsync<ArgumentNullException>( () => _sut.GetEventByIdAsync(null) ); Assert.Equal("id", exception.ParamName); } [Fact] public async Task CreateEvent_WithNullEvent_ThrowsArgumentNullException() { // Act & Assert var exception = await Assert.ThrowsAsync<ArgumentNullException>( () => _sut.CreateEventAsync(null!) ); Assert.Equal("eventEntity", exception.ParamName); } [Fact] public async Task CreateEvent_WhenRepositoryFails_ThrowsInvalidOperationException() { // Arrange var newEvent = CreateValidEvent(0, "Test Event"); _mockRepository .Setup(x => x.AddAsync(It.IsAny<Event>())) .ThrowsAsync(new InvalidOperationException("Database error")); // Act & Assert var exception = await Assert.ThrowsAsync<InvalidOperationException>( () => _sut.CreateEventAsync(newEvent) ); Assert.Equal("Database error", exception.Message); } ``` ## Test Data Builders Create helper methods or builders for complex test data: ```csharp private Event CreateValidEvent(int id = 1, string title = "Test Event") { return new Event { Id = id, Title = title, Year = 2020, ShortDescription = "Test Description", DetailedDescription = "Test Detailed Description", WhyImportant = "Test Importance", HistoricalImpact = "Test Impact", InterestingFact = "Test Fact", Tags = new List<Tag> { new Tag { Id = 1, Name = "TestTag1" }, new Tag { Id = 2, Name = "TestTag2" } } }; } private List<Event> CreateEventList(int count) { return Enumerable.Range(1, count) .Select(i => CreateValidEvent(i, $"Event {i}")) .ToList(); } private Category CreateValidCategory(int id = 1, string name = "Test Category") { return new Category { Id = id, Name = name, Alias = name.Replace(" ", "").ToLower(), StartYear = 2000, EndYear = 2020 }; } ``` ## Testing Collections and Filtering ```csharp [Fact] public async Task GetEventsByCategory_WithValidCategory_ReturnsFilteredEvents() { // Arrange var categoryEvents = CreateEventList(3); _mockRepository .Setup(x => x.GetByCategoryAsync("history")) .ReturnsAsync(categoryEvents); // Act var result = await _sut.GetEventsByCategoryAsync("history"); // Assert Assert.NotNull(result); Assert.Equal(3, result.Count()); Assert.All(result, evt => Assert.NotNull(evt.Title)); } [Fact] public async Task GetEventsByYear_WithValidYear_ReturnsFilteredEvents() { // Arrange var yearEvents = new List<Event> { CreateValidEvent(1, "Event 1") { Year = 2020 }, CreateValidEvent(2, "Event 2") { Year = 2020 } }; _mockRepository .Setup(x => x.GetByYearAsync(2020)) .ReturnsAsync(yearEvents); // Act var result = await _sut.GetEventsByYearAsync(2020); // Assert Assert.Equal(2, result.Count()); Assert.All(result, evt => Assert.Equal(2020, evt.Year)); } [Fact] public async Task SearchEvents_WithValidKeyword_ReturnsMatchingEvents() { // Arrange var searchResults = new List<Event> { CreateValidEvent(1, "Battle of Grunwald"), CreateValidEvent(2, "Battle of Orsha") }; _mockRepository .Setup(x => x.SearchAsync("Battle")) .ReturnsAsync(searchResults); // Act var result = await _sut.SearchEventsAsync("Battle"); // Assert Assert.Equal(2, result.Count()); Assert.All(result, evt => Assert.Contains("Battle", evt.Title)); } ``` ## Advanced Mocking Scenarios ```csharp [Fact] public async Task CreateEvent_WithTags_AssociatesTagsCorrectly() { // Arrange var newEvent = CreateValidEvent(0, "New Event"); var existingTags = new List<Tag> { new Tag { Id = 1, Name = "TestTag1" }, new Tag { Id = 2, Name = "TestTag2" } }; _mockEventRepository .Setup(x => x.AddAsync(It.IsAny<Event>())) .ReturnsAsync(newEvent); _mockTagRepository .Setup(x => x.GetByNamesAsync(It.IsAny<List<string>>())) .ReturnsAsync(existingTags); // Act var result = await _sut.CreateEventWithTagsAsync(newEvent, new[] { "TestTag1", "TestTag2" }); // Assert Assert.NotNull(result); _mockTagRepository.Verify( x => x.GetByNamesAsync(It.Is<List<string>>(tags => tags.Contains("TestTag1") && tags.Contains("TestTag2"))), Times.Once ); } [Fact] public async Task DeleteEvent_WhenEventExists_DeletesSuccessfully() { // Arrange var existingEvent = CreateValidEvent(1, "Event to Delete"); _mockRepository .Setup(x => x.GetByIdAsync(1)) .ReturnsAsync(existingEvent); _mockRepository .Setup(x => x.DeleteAsync(1)) .Returns(Task.CompletedTask); // Act await _sut.DeleteEventAsync(1); // Assert _mockRepository.Verify(x => x.GetByIdAsync(1), Times.Once); _mockRepository.Verify(x => x.DeleteAsync(1), Times.Once); } [Fact] public async Task DeleteEvent_WhenEventDoesNotExist_ThrowsNotFoundException() { // Arrange _mockRepository .Setup(x => x.GetByIdAsync(999)) .ReturnsAsync((Event?)null); // Act & Assert await Assert.ThrowsAsync<NotFoundException>( () => _sut.DeleteEventAsync(999) ); _mockRepository.Verify(x => x.DeleteAsync(It.IsAny<int>()), Times.Never); } ``` ## Integration with FluentAssertions (Optional) If using FluentAssertions for more readable assertions: ```csharp using FluentAssertions; [Fact] public async Task GetEventByIdAsync_WhenEventExists_ReturnsEvent() { // Arrange var expectedEvent = CreateValidEvent(1, "Test Event"); _mockRepository .Setup(x => x.GetByIdAsync(1)) .ReturnsAsync(expectedEvent); // Act var result = await _sut.GetEventByIdAsync(1); // Assert result.Should().NotBeNull(); result.Id.Should().Be(expectedEvent.Id); result.Title.Should().Be(expectedEvent.Title); result.Tags.Should().HaveCount(2); } [Fact] public async Task GetEventsAsync_ReturnsAllEvents() { // Arrange var expectedEvents = CreateEventList(5); _mockRepository .Setup(x => x.GetAllAsync()) .ReturnsAsync(expectedEvents); // Act var result = await _sut.GetEventsAsync(); // Assert result.Should().NotBeNull() .And.HaveCount(5) .And.OnlyContain(e => !string.IsNullOrEmpty(e.Title)); } ``` ## Summary When generating unit tests: 1. Always confirm the test project location first 2. Use xUnit with Moq framework 3. Follow AAA pattern with clear section comments 4. Name tests descriptively using `MethodName_Scenario_ExpectedBehavior` 5. Mock only external dependencies, never the SUT 6. Cover happy path, edge cases, and exception scenarios 7. Use Theory tests for multiple similar test cases 8. Verify important method calls on mocked dependencies 9. Create helper methods for test data generation 10. Keep tests readable, maintainable, and focused on single scenarios

{ "prompt": "# Unit Test Implementation Guide\n\nThis prompt provides comprehensive examples and patterns for implementing unit tests following the FreeBelarus project guidelines.\n\n## Test Structure (AAA Pattern)\n\nAlways organize tests using the Arrange-Act-Assert pattern with clear comments:\n\n```csharp\n[Fact]\npublic async Task MethodName_Scenario_ExpectedBehavior()\n{\n // Arrange\n var mockDependency = new Mock<IDependency>();\n mockDependency.Setup(x => x.Method()).ReturnsAsync(value);\n var sut = new ServiceUnderTest(mockDependency.Object);\n\n // Act\n var result = await sut.MethodToTest();\n\n // Assert\n Assert.NotNull(result);\n Assert.Equal(expectedValue, result.Property);\n}\n```\n\n## Mocking Examples\n\n### Correct Mocking Pattern\n```csharp\n// ✅ CORRECT: Mock external dependencies\nvar mockRepository = new Mock<IEventRepository>();\nvar mockLogger = new Mock<ILogger<EventService>>();\nvar sut = new EventService(mockRepository.Object, mockLogger.Object);\n\n// Setup method return values\nmockRepository\n .Setup(x => x.GetByIdAsync(It.IsAny<int>()))\n .ReturnsAsync(new Event { Id = 1, Title = \"Test\" });\n\n// ❌ INCORRECT: Don't mock the SUT\nvar mockService = new Mock<EventService>();\n```\n\n## Complete Test Class Template\n\n```csharp\nusing FreeBelarus.Core.Entities;\nusing FreeBelarus.Core.Services;\nusing FreeBelarus.Data.Repositories;\nusing Moq;\nusing Xunit;\n\nnamespace FreeBelarus.Core.Tests.Services.Impl\n{\n public class EventServiceTests\n {\n private readonly Mock<IEventRepository> _mockEventRepository;\n private readonly Mock<ICategoryRepository> _mockCategoryRepository;\n private readonly EventService _sut;\n\n public EventServiceTests()\n {\n // Setup common mocks in constructor\n _mockEventRepository = new Mock<IEventRepository>();\n _mockCategoryRepository = new Mock<ICategoryRepository>();\n _sut = new EventService(_mockEventRepository.Object, _mockCategoryRepository.Object);\n }\n\n [Fact]\n public async Task GetEventByIdAsync_WhenEventExists_ReturnsEvent()\n {\n // Arrange\n var expectedEvent = CreateValidEvent(1, \"Test Event\");\n _mockEventRepository\n .Setup(x => x.GetByIdAsync(1))\n .ReturnsAsync(expectedEvent);\n\n // Act\n var result = await _sut.GetEventByIdAsync(1);\n\n // Assert\n Assert.NotNull(result);\n Assert.Equal(expectedEvent.Id, result.Id);\n Assert.Equal(expectedEvent.Title, result.Title);\n }\n\n [Fact]\n public async Task GetEventByIdAsync_WhenEventDoesNotExist_ReturnsNull()\n {\n // Arrange\n _mockEventRepository\n .Setup(x => x.GetByIdAsync(It.IsAny<int>()))\n .ReturnsAsync((Event?)null);\n\n // Act\n var result = await _sut.GetEventByIdAsync(999);\n\n // Assert\n Assert.Null(result);\n }\n\n [Theory]\n [InlineData(0)]\n [InlineData(-1)]\n [InlineData(-100)]\n public async Task GetEventByIdAsync_WithInvalidId_ThrowsArgumentException(int invalidId)\n {\n // Act & Assert\n await Assert.ThrowsAsync<ArgumentException>(\n () => _sut.GetEventByIdAsync(invalidId)\n );\n }\n\n [Fact]\n public async Task GetEventsAsync_WhenNoEvents_ReturnsEmptyCollection()\n {\n // Arrange\n _mockEventRepository\n .Setup(x => x.GetAllAsync())\n .ReturnsAsync(new List<Event>());\n\n // Act\n var result = await _sut.GetEventsAsync();\n\n // Assert\n Assert.NotNull(result);\n Assert.Empty(result);\n }\n\n [Fact]\n public async Task GetEventsAsync_WithCategoryFilter_ReturnsFilteredEvents()\n {\n // Arrange\n var events = new List<Event>\n {\n CreateValidEvent(1, \"Event 1\"),\n CreateValidEvent(2, \"Event 2\")\n };\n _mockEventRepository\n .Setup(x => x.GetByCategoryAsync(\"history\"))\n .ReturnsAsync(events);\n\n // Act\n var result = await _sut.GetEventsAsync(\"history\");\n\n // Assert\n Assert.NotNull(result);\n Assert.Equal(2, result.Count());\n }\n\n [Fact]\n public async Task CreateEventAsync_WithValidData_CreatesAndReturnsEvent()\n {\n // Arrange\n var newEvent = CreateValidEvent(0, \"New Event\");\n var createdEvent = CreateValidEvent(1, \"New Event\");\n _mockEventRepository\n .Setup(x => x.AddAsync(It.IsAny<Event>()))\n .ReturnsAsync(createdEvent);\n\n // Act\n var result = await _sut.CreateEventAsync(newEvent);\n\n // Assert\n Assert.NotNull(result);\n Assert.Equal(createdEvent.Id, result.Id);\n _mockEventRepository.Verify(x => x.AddAsync(It.IsAny<Event>()), Times.Once);\n }\n\n [Fact]\n public async Task CreateEventAsync_WithNullEvent_ThrowsArgumentNullException()\n {\n // Act & Assert\n await Assert.ThrowsAsync<ArgumentNullException>(\n () => _sut.CreateEventAsync(null!)\n );\n }\n\n // Helper method for creating test data\n private Event CreateValidEvent(int id, string title)\n {\n return new Event\n {\n Id = id,\n Title = title,\n Year = 2020,\n ShortDescription = \"Test Description\",\n DetailedDescription = \"Test Detailed Description\",\n WhyImportant = \"Test Importance\",\n HistoricalImpact = \"Test Impact\",\n InterestingFact = \"Test Fact\",\n Tags = new List<Tag>()\n };\n }\n }\n}\n```\n\n## Theory Tests for Multiple Scenarios\n\nUse `[Theory]` with `[InlineData]` for testing multiple similar scenarios:\n\n```csharp\n[Theory]\n[InlineData(null)]\n[InlineData(\"\")]\n[InlineData(\" \")]\npublic async Task CreateEvent_WithInvalidTitle_ThrowsArgumentException(string title)\n{\n // Arrange\n var eventData = new Event { Title = title };\n\n // Act & Assert\n await Assert.ThrowsAsync<ArgumentException>(\n () => _sut.CreateEventAsync(eventData)\n );\n}\n\n[Theory]\n[InlineData(0, \"Invalid ID: 0\")]\n[InlineData(-1, \"Invalid ID: -1\")]\n[InlineData(-100, \"Invalid ID: -100\")]\npublic async Task GetEventByIdAsync_WithInvalidId_ThrowsArgumentException(int id, string scenario)\n{\n // Act & Assert\n var exception = await Assert.ThrowsAsync<ArgumentException>(\n () => _sut.GetEventByIdAsync(id)\n );\n \n Assert.Contains(\"id\", exception.Message);\n}\n```\n\n## Testing Async Methods\n\nAlways use async test methods when testing async code:\n\n```csharp\n[Fact]\npublic async Task GetEventAsync_WhenCalled_ReturnsEvent()\n{\n // Arrange\n var expectedEvent = new Event { Id = 1, Title = \"Test Event\" };\n _mockRepository\n .Setup(x => x.GetByIdAsync(1))\n .ReturnsAsync(expectedEvent);\n\n // Act\n var result = await _sut.GetEventByIdAsync(1);\n\n // Assert\n Assert.Equal(expectedEvent.Id, result.Id);\n Assert.Equal(expectedEvent.Title, result.Title);\n}\n\n[Fact]\npublic async Task GetAllEventsAsync_ReturnsAllEvents()\n{\n // Arrange\n var expectedEvents = new List<Event>\n {\n new Event { Id = 1, Title = \"Event 1\" },\n new Event { Id = 2, Title = \"Event 2\" }\n };\n _mockRepository\n .Setup(x => x.GetAllAsync())\n .ReturnsAsync(expectedEvents);\n\n // Act\n var result = await _sut.GetAllEventsAsync();\n\n // Assert\n Assert.Equal(2, result.Count());\n Assert.Contains(result, e => e.Id == 1);\n Assert.Contains(result, e => e.Id == 2);\n}\n```\n\n## Verifying Method Calls\n\nVerify that dependencies were called correctly:\n\n```csharp\n[Fact]\npublic async Task CreateEvent_WhenCalled_CallsRepositoryAdd()\n{\n // Arrange\n var newEvent = new Event { Title = \"New Event\" };\n var createdEvent = new Event { Id = 1, Title = \"New Event\" };\n _mockRepository\n .Setup(x => x.AddAsync(It.IsAny<Event>()))\n .ReturnsAsync(createdEvent);\n\n // Act\n await _sut.CreateEventAsync(newEvent);\n\n // Assert\n _mockRepository.Verify(\n x => x.AddAsync(It.Is<Event>(e => e.Title == \"New Event\")), \n Times.Once\n );\n}\n\n[Fact]\npublic async Task UpdateEvent_WhenCalled_CallsRepositoryUpdate()\n{\n // Arrange\n var existingEvent = CreateValidEvent(1, \"Original Title\");\n var updatedEvent = CreateValidEvent(1, \"Updated Title\");\n \n _mockRepository\n .Setup(x => x.GetByIdAsync(1))\n .ReturnsAsync(existingEvent);\n _mockRepository\n .Setup(x => x.UpdateAsync(It.IsAny<Event>()))\n .ReturnsAsync(updatedEvent);\n\n // Act\n await _sut.UpdateEventAsync(updatedEvent);\n\n // Assert\n _mockRepository.Verify(x => x.GetByIdAsync(1), Times.Once);\n _mockRepository.Verify(\n x => x.UpdateAsync(It.Is<Event>(e => e.Title == \"Updated Title\")), \n Times.Once\n );\n}\n```\n\n## Exception Testing\n\nTest exception scenarios explicitly:\n\n```csharp\n[Fact]\npublic async Task GetEventById_WithNullId_ThrowsArgumentNullException()\n{\n // Act & Assert\n var exception = await Assert.ThrowsAsync<ArgumentNullException>(\n () => _sut.GetEventByIdAsync(null)\n );\n \n Assert.Equal(\"id\", exception.ParamName);\n}\n\n[Fact]\npublic async Task CreateEvent_WithNullEvent_ThrowsArgumentNullException()\n{\n // Act & Assert\n var exception = await Assert.ThrowsAsync<ArgumentNullException>(\n () => _sut.CreateEventAsync(null!)\n );\n \n Assert.Equal(\"eventEntity\", exception.ParamName);\n}\n\n[Fact]\npublic async Task CreateEvent_WhenRepositoryFails_ThrowsInvalidOperationException()\n{\n // Arrange\n var newEvent = CreateValidEvent(0, \"Test Event\");\n _mockRepository\n .Setup(x => x.AddAsync(It.IsAny<Event>()))\n .ThrowsAsync(new InvalidOperationException(\"Database error\"));\n\n // Act & Assert\n var exception = await Assert.ThrowsAsync<InvalidOperationException>(\n () => _sut.CreateEventAsync(newEvent)\n );\n \n Assert.Equal(\"Database error\", exception.Message);\n}\n```\n\n## Test Data Builders\n\nCreate helper methods or builders for complex test data:\n\n```csharp\nprivate Event CreateValidEvent(int id = 1, string title = \"Test Event\")\n{\n return new Event\n {\n Id = id,\n Title = title,\n Year = 2020,\n ShortDescription = \"Test Description\",\n DetailedDescription = \"Test Detailed Description\",\n WhyImportant = \"Test Importance\",\n HistoricalImpact = \"Test Impact\",\n InterestingFact = \"Test Fact\",\n Tags = new List<Tag>\n {\n new Tag { Id = 1, Name = \"TestTag1\" },\n new Tag { Id = 2, Name = \"TestTag2\" }\n }\n };\n}\n\nprivate List<Event> CreateEventList(int count)\n{\n return Enumerable.Range(1, count)\n .Select(i => CreateValidEvent(i, $\"Event {i}\"))\n .ToList();\n}\n\nprivate Category CreateValidCategory(int id = 1, string name = \"Test Category\")\n{\n return new Category\n {\n Id = id,\n Name = name,\n Alias = name.Replace(\" \", \"\").ToLower(),\n StartYear = 2000,\n EndYear = 2020\n };\n}\n```\n\n## Testing Collections and Filtering\n\n```csharp\n[Fact]\npublic async Task GetEventsByCategory_WithValidCategory_ReturnsFilteredEvents()\n{\n // Arrange\n var categoryEvents = CreateEventList(3);\n _mockRepository\n .Setup(x => x.GetByCategoryAsync(\"history\"))\n .ReturnsAsync(categoryEvents);\n\n // Act\n var result = await _sut.GetEventsByCategoryAsync(\"history\");\n\n // Assert\n Assert.NotNull(result);\n Assert.Equal(3, result.Count());\n Assert.All(result, evt => Assert.NotNull(evt.Title));\n}\n\n[Fact]\npublic async Task GetEventsByYear_WithValidYear_ReturnsFilteredEvents()\n{\n // Arrange\n var yearEvents = new List<Event>\n {\n CreateValidEvent(1, \"Event 1\") { Year = 2020 },\n CreateValidEvent(2, \"Event 2\") { Year = 2020 }\n };\n _mockRepository\n .Setup(x => x.GetByYearAsync(2020))\n .ReturnsAsync(yearEvents);\n\n // Act\n var result = await _sut.GetEventsByYearAsync(2020);\n\n // Assert\n Assert.Equal(2, result.Count());\n Assert.All(result, evt => Assert.Equal(2020, evt.Year));\n}\n\n[Fact]\npublic async Task SearchEvents_WithValidKeyword_ReturnsMatchingEvents()\n{\n // Arrange\n var searchResults = new List<Event>\n {\n CreateValidEvent(1, \"Battle of Grunwald\"),\n CreateValidEvent(2, \"Battle of Orsha\")\n };\n _mockRepository\n .Setup(x => x.SearchAsync(\"Battle\"))\n .ReturnsAsync(searchResults);\n\n // Act\n var result = await _sut.SearchEventsAsync(\"Battle\");\n\n // Assert\n Assert.Equal(2, result.Count());\n Assert.All(result, evt => Assert.Contains(\"Battle\", evt.Title));\n}\n```\n\n## Advanced Mocking Scenarios\n\n```csharp\n[Fact]\npublic async Task CreateEvent_WithTags_AssociatesTagsCorrectly()\n{\n // Arrange\n var newEvent = CreateValidEvent(0, \"New Event\");\n var existingTags = new List<Tag>\n {\n new Tag { Id = 1, Name = \"TestTag1\" },\n new Tag { Id = 2, Name = \"TestTag2\" }\n };\n \n _mockEventRepository\n .Setup(x => x.AddAsync(It.IsAny<Event>()))\n .ReturnsAsync(newEvent);\n _mockTagRepository\n .Setup(x => x.GetByNamesAsync(It.IsAny<List<string>>()))\n .ReturnsAsync(existingTags);\n\n // Act\n var result = await _sut.CreateEventWithTagsAsync(newEvent, new[] { \"TestTag1\", \"TestTag2\" });\n\n // Assert\n Assert.NotNull(result);\n _mockTagRepository.Verify(\n x => x.GetByNamesAsync(It.Is<List<string>>(tags => \n tags.Contains(\"TestTag1\") && tags.Contains(\"TestTag2\"))), \n Times.Once\n );\n}\n\n[Fact]\npublic async Task DeleteEvent_WhenEventExists_DeletesSuccessfully()\n{\n // Arrange\n var existingEvent = CreateValidEvent(1, \"Event to Delete\");\n _mockRepository\n .Setup(x => x.GetByIdAsync(1))\n .ReturnsAsync(existingEvent);\n _mockRepository\n .Setup(x => x.DeleteAsync(1))\n .Returns(Task.CompletedTask);\n\n // Act\n await _sut.DeleteEventAsync(1);\n\n // Assert\n _mockRepository.Verify(x => x.GetByIdAsync(1), Times.Once);\n _mockRepository.Verify(x => x.DeleteAsync(1), Times.Once);\n}\n\n[Fact]\npublic async Task DeleteEvent_WhenEventDoesNotExist_ThrowsNotFoundException()\n{\n // Arrange\n _mockRepository\n .Setup(x => x.GetByIdAsync(999))\n .ReturnsAsync((Event?)null);\n\n // Act & Assert\n await Assert.ThrowsAsync<NotFoundException>(\n () => _sut.DeleteEventAsync(999)\n );\n \n _mockRepository.Verify(x => x.DeleteAsync(It.IsAny<int>()), Times.Never);\n}\n```\n\n## Integration with FluentAssertions (Optional)\n\nIf using FluentAssertions for more readable assertions:\n\n```csharp\nusing FluentAssertions;\n\n[Fact]\npublic async Task GetEventByIdAsync_WhenEventExists_ReturnsEvent()\n{\n // Arrange\n var expectedEvent = CreateValidEvent(1, \"Test Event\");\n _mockRepository\n .Setup(x => x.GetByIdAsync(1))\n .ReturnsAsync(expectedEvent);\n\n // Act\n var result = await _sut.GetEventByIdAsync(1);\n\n // Assert\n result.Should().NotBeNull();\n result.Id.Should().Be(expectedEvent.Id);\n result.Title.Should().Be(expectedEvent.Title);\n result.Tags.Should().HaveCount(2);\n}\n\n[Fact]\npublic async Task GetEventsAsync_ReturnsAllEvents()\n{\n // Arrange\n var expectedEvents = CreateEventList(5);\n _mockRepository\n .Setup(x => x.GetAllAsync())\n .ReturnsAsync(expectedEvents);\n\n // Act\n var result = await _sut.GetEventsAsync();\n\n // Assert\n result.Should().NotBeNull()\n .And.HaveCount(5)\n .And.OnlyContain(e => !string.IsNullOrEmpty(e.Title));\n}\n```\n\n## Summary\n\nWhen generating unit tests:\n1. Always confirm the test project location first\n2. Use xUnit with Moq framework\n3. Follow AAA pattern with clear section comments\n4. Name tests descriptively using `MethodName_Scenario_ExpectedBehavior`\n5. Mock only external dependencies, never the SUT\n6. Cover happy path, edge cases, and exception scenarios\n7. Use Theory tests for multiple similar test cases\n8. Verify important method calls on mocked dependencies\n9. Create helper methods for test data generation\n10. Keep tests readable, maintainable, and focused on single scenarios", "variables": [], "notes": "This prompt provides comprehensive examples and patterns for implementing unit tests following the FreeBelarus project guidelines.", "metadata": { "source": { "provider": "github-prompts", "repository": "https://github.com/uladzislauboika/FreeBelarus", "path": ".github/prompts/add-unit-test.prompt.md", "ref": "34371414b4b761c9eb4eacbf7cb4226c6f21f82c", "url": "https://github.com/uladzislauboika/FreeBelarus/blob/34371414b4b761c9eb4eacbf7cb4226c6f21f82c/.github/prompts/add-unit-test.prompt.md", "key": "uladzislauboika/FreeBelarus/.github/prompts/add-unit-test.prompt.md" } } }

add-unit-test

About