Skip to content

refactor: use file scoped namespaces #134

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
StuartFerguson merged 3 commits into from
Sep 19, 2025
Merged

refactor: use file scoped namespaces #134

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
cda200b
refactor: use file scoped namespaces
deepsource-autofix[bot] Sep 19, 2025
4a3a5f1
:|
StuartFerguson Sep 19, 2025
5d6a824
refactor: simplify lambda when its body has a single statement
deepsource-autofix[bot] Sep 19, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
81 changes: 40 additions & 41 deletions CallbackHandler.BusinessLogic.Tests/Mediator/MediatorTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -12,58 +12,58 @@
using System.Threading.Tasks;
using Xunit;

namespace CallbackHandler.BusinessLogic.Tests.Mediator
namespace CallbackHandler.BusinessLogic.Tests.Mediator;

using BusinessLogic.Services;
using Lamar;
using Microsoft.Extensions.DependencyInjection;

public class MediatorTests
{
using BusinessLogic.Services;
using Lamar;
using Microsoft.Extensions.DependencyInjection;
private readonly List<IBaseRequest> Requests = new List<IBaseRequest>();

public class MediatorTests
public MediatorTests()
{
private readonly List<IBaseRequest> Requests = new List<IBaseRequest>();
this.Requests.Add(TestData.RecordCallbackRequest);
}

public MediatorTests()
{
this.Requests.Add(TestData.RecordCallbackRequest);
}
[Fact]
public async Task Mediator_Send_RequestHandled()
{
Mock<IWebHostEnvironment> hostingEnvironment = new();
hostingEnvironment.Setup(he => he.EnvironmentName).Returns("Development");
hostingEnvironment.Setup(he => he.ContentRootPath).Returns("/home");
hostingEnvironment.Setup(he => he.ApplicationName).Returns("Test Application");

ServiceRegistry services = new();
Startup s = new(hostingEnvironment.Object);
Startup.Configuration = this.SetupMemoryConfiguration();

[Fact]
public async Task Mediator_Send_RequestHandled()
this.AddTestRegistrations(services, hostingEnvironment.Object);
s.ConfigureContainer(services);
Startup.Container.AssertConfigurationIsValid(AssertMode.Full);

List<String> errors = new();
IMediator mediator = Startup.Container.GetService<IMediator>();
foreach (IBaseRequest baseRequest in this.Requests)
{
Mock<IWebHostEnvironment> hostingEnvironment = new();
hostingEnvironment.Setup(he => he.EnvironmentName).Returns("Development");
hostingEnvironment.Setup(he => he.ContentRootPath).Returns("/home");
hostingEnvironment.Setup(he => he.ApplicationName).Returns("Test Application");

ServiceRegistry services = new();
Startup s = new(hostingEnvironment.Object);
Startup.Configuration = this.SetupMemoryConfiguration();

this.AddTestRegistrations(services, hostingEnvironment.Object);
s.ConfigureContainer(services);
Startup.Container.AssertConfigurationIsValid(AssertMode.Full);

List<String> errors = new();
IMediator mediator = Startup.Container.GetService<IMediator>();
foreach (IBaseRequest baseRequest in this.Requests)
try
{
try
{
await mediator.Send(baseRequest);
}
catch (Exception ex)
{
errors.Add(ex.Message);
}
await mediator.Send(baseRequest);
}

if (errors.Any())
catch (Exception ex)
{
String errorMessage = String.Join(Environment.NewLine, errors);
throw new Exception(errorMessage);
errors.Add(ex.Message);
}
}

if (errors.Any())
{
String errorMessage = String.Join(Environment.NewLine, errors);
throw new Exception(errorMessage);
}
}

private IConfigurationRoot SetupMemoryConfiguration()
{
Dictionary<String, String> configuration = new Dictionary<String, String>();
Expand Down Expand Up @@ -100,4 +100,3 @@ private void AddTestRegistrations(ServiceRegistry services,
services.OverrideServices(s => { s.AddSingleton<ICallbackDomainService, DummyCallbackDomainService>(); });
}
}
}
93 changes: 46 additions & 47 deletions CallbackHandler.BusinessLogic.Tests/RequestHandler/CallbackHandlerRequestHandlerTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,56 +1,56 @@
using SimpleResults;

namespace CallbackHandler.BusinessLogic.Tests.RequestHandler
{
using System;
using System.Threading;
using BusinessLogic.RequestHandler;
using BusinessLogic.Requests;
using BusinessLogic.Services;
using CallbackHander.Testing;
using CallbackHandlers.Models;
using CallbackMessageAggregate;
using MediatR;
using Moq;
using Services;
using Shared.DomainDrivenDesign.EventSourcing;
using Shared.EventStore.Aggregate;
using Shouldly;
using Xunit;
namespace CallbackHandler.BusinessLogic.Tests.RequestHandler;

using System;
using System.Threading;
using BusinessLogic.RequestHandler;
using BusinessLogic.Requests;
using BusinessLogic.Services;
using CallbackHander.Testing;
using CallbackHandlers.Models;
using CallbackMessageAggregate;
using MediatR;
using Moq;
using Services;
using Shared.DomainDrivenDesign.EventSourcing;
using Shared.EventStore.Aggregate;
using Shouldly;
using Xunit;

public class CallbackHandlerRequestHandlerTests
public class CallbackHandlerRequestHandlerTests
{
[Fact]
public void CallbackHandlerRequestHandlerTests_RecordCallbackRequest_IsHandled()
{
[Fact]
public void CallbackHandlerRequestHandlerTests_RecordCallbackRequest_IsHandled()
{
Mock<ICallbackDomainService> domainService = new();
domainService.Setup(a => a.RecordCallback(It.IsAny<Guid>(),
It.IsAny<String>(),
It.IsAny<MessageFormat>(),
It.IsAny<String>(),
It.IsAny<String>(),
It.IsAny<String[]>(),
It.IsAny<CancellationToken>()));
Mock<IAggregateRepository<CallbackMessageAggregate, DomainEvent>> aggregateRepository = new();
Mock<ICallbackDomainService> domainService = new();
domainService.Setup(a => a.RecordCallback(It.IsAny<Guid>(),
It.IsAny<String>(),
It.IsAny<MessageFormat>(),
It.IsAny<String>(),
It.IsAny<String>(),
It.IsAny<String[]>(),
It.IsAny<CancellationToken>()));
Mock<IAggregateRepository<CallbackMessageAggregate, DomainEvent>> aggregateRepository = new();

CallbackHandlerRequestHandler handler = new(domainService.Object, aggregateRepository.Object);
CallbackCommands.RecordCallbackRequest request = TestData.RecordCallbackRequest;
CallbackHandlerRequestHandler handler = new(domainService.Object, aggregateRepository.Object);

CallbackCommands.RecordCallbackRequest request = TestData.RecordCallbackRequest;

Should.NotThrow(async () => await handler.Handle(request, CancellationToken.None));
}
Should.NotThrow(async () => await handler.Handle(request, CancellationToken.None));
}

[Fact]
public void CallbackHandlerRequestHandlerTests_GetCallbackQuery_IsHandled()
{
Mock<ICallbackDomainService> domainService =
new();
domainService.Setup(a => a.RecordCallback(It.IsAny<Guid>(),
It.IsAny<String>(),
It.IsAny<MessageFormat>(),
It.IsAny<String>(),
It.IsAny<String>(),
It.IsAny<String[]>(),
[Fact]
public void CallbackHandlerRequestHandlerTests_GetCallbackQuery_IsHandled()
{
Mock<ICallbackDomainService> domainService =
new();
domainService.Setup(a => a.RecordCallback(It.IsAny<Guid>(),
It.IsAny<String>(),
It.IsAny<MessageFormat>(),
It.IsAny<String>(),
It.IsAny<String>(),
It.IsAny<String[]>(),
It.IsAny<CancellationToken>()));
Mock<IAggregateRepository<CallbackMessageAggregate, DomainEvent>> aggregateRepository =
new();
Expand All @@ -70,4 +70,3 @@ public void CallbackHandlerRequestHandlerTests_GetCallbackQuery_IsHandled()
});
}
}
}
68 changes: 33 additions & 35 deletions CallbackHandler.BusinessLogic.Tests/Services/CallbackDomainServiceTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,46 +1,44 @@
using System;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CallbackHandler.BusinessLogic.Tests.Services
{
using System.Threading;
using BusinessLogic.Services;
using CallbackHander.Testing;
using CallbackHandlers.Models;
using CallbackMessageAggregate;
using Moq;
using Shared.DomainDrivenDesign.EventSourcing;
using Shared.EventStore.Aggregate;
using Shouldly;
using Xunit;
namespace CallbackHandler.BusinessLogic.Tests.Services;

using System.Threading;
using BusinessLogic.Services;
using CallbackHander.Testing;
using CallbackHandlers.Models;
using CallbackMessageAggregate;
using Moq;
using Shared.DomainDrivenDesign.EventSourcing;
using Shared.EventStore.Aggregate;
using Shouldly;
using Xunit;

public class CallbackDomainServiceTests
{
private readonly ICallbackDomainService DomainService;
public class CallbackDomainServiceTests
{
private readonly ICallbackDomainService DomainService;

private readonly Mock<IAggregateRepository<CallbackMessageAggregate, DomainEvent>> AggregateRepository;
public CallbackDomainServiceTests() {
this.AggregateRepository = new Mock<IAggregateRepository<CallbackMessageAggregate, DomainEvent>>();
this.DomainService = new CallbackDomainService(this.AggregateRepository.Object);
}
private readonly Mock<IAggregateRepository<CallbackMessageAggregate, DomainEvent>> AggregateRepository;
public CallbackDomainServiceTests() {
this.AggregateRepository = new Mock<IAggregateRepository<CallbackMessageAggregate, DomainEvent>>();
this.DomainService = new CallbackDomainService(this.AggregateRepository.Object);

}

[Fact]
public async Task CallbackDomainService_RecordCallback_CallbackRecorded() {
this.AggregateRepository.Setup(a => a.GetLatestVersion(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(TestData.EmptyCallbackMessageAggregate());
[Fact]
public async Task CallbackDomainService_RecordCallback_CallbackRecorded() {

Check warning on line 32 in CallbackHandler.BusinessLogic.Tests/Services/CallbackDomainServiceTests.cs

View workflow job for this annotation

GitHub Actions / Build and Test Pull Requests 

This async method lacks 'await' operators and will run synchronously. Consider using the 'await' operator to await non-blocking API calls, or 'await Task.Run(...)' to do CPU-bound work on a background thread.
this.AggregateRepository.Setup(a => a.GetLatestVersion(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
.ReturnsAsync(TestData.EmptyCallbackMessageAggregate());

Should.NotThrow(async () => {
await this.DomainService.RecordCallback(TestData.CallbackId,
TestData.TypeString,
(MessageFormat)TestData.MessageFormat,
TestData.CallbackMessage,
TestData.Reference,
TestData.Destinations,
CancellationToken.None);
});
}
Should.NotThrow(async () => await this.DomainService.RecordCallback(TestData.CallbackId,
TestData.TypeString,
(MessageFormat)TestData.MessageFormat,
TestData.CallbackMessage,
TestData.Reference,
TestData.Destinations,
CancellationToken.None));
}
}
55 changes: 27 additions & 28 deletions CallbackHandler.CallbackMessageAggregate.Tests/CallbackMessageAggregateTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,37 +1,36 @@
using SimpleResults;

namespace CallbackHandler.CallbackMessageAggregate.Tests
{
using CallbackHander.Testing;
using CallbackHandlers.Models;
using Shouldly;
using Xunit;
namespace CallbackHandler.CallbackMessageAggregate.Tests;

public class CallbackMessageAggregateTests
{
//[Fact]
//public void CallbackMessageAggregate_CanBeCreated_IsCreated()
//{
// CallbackMessageAggregate aggregate = CallbackMessageAggregate.Create(TestData.CallbackId);
using CallbackHander.Testing;
using CallbackHandlers.Models;
using Shouldly;
using Xunit;

// aggregate.AggregateId.ShouldBe(TestData.CallbackId);
//}
public class CallbackMessageAggregateTests
{
//[Fact]
//public void CallbackMessageAggregate_CanBeCreated_IsCreated()
//{
// CallbackMessageAggregate aggregate = CallbackMessageAggregate.Create(TestData.CallbackId);

[Fact]
public void CallbackMessageAggregate_RecordCallback_CallbackIsRecorded()
{
CallbackMessageAggregate aggregate = new();
// aggregate.AggregateId.ShouldBe(TestData.CallbackId);
//}

[Fact]
public void CallbackMessageAggregate_RecordCallback_CallbackIsRecorded()
{
CallbackMessageAggregate aggregate = new();

Result result = aggregate.RecordCallback(TestData.CallbackId, TestData.TypeString, MessageFormat.JSON, TestData.CallbackMessage, TestData.Reference, TestData.Destinations,
TestData.EstateReference, TestData.MerchantReference);
result.IsSuccess.ShouldBeTrue();
Result result = aggregate.RecordCallback(TestData.CallbackId, TestData.TypeString, MessageFormat.JSON, TestData.CallbackMessage, TestData.Reference, TestData.Destinations,
TestData.EstateReference, TestData.MerchantReference);
result.IsSuccess.ShouldBeTrue();

aggregate.ShouldSatisfyAllConditions(() => aggregate.CallbackMessage.ShouldBe(TestData.CallbackMessage),
() => aggregate.TypeString.ShouldBe(TestData.TypeString),
() => aggregate.MessageFormat.ShouldBe(MessageFormat.JSON),
() => aggregate.Reference.ShouldBe(TestData.Reference),
() => aggregate.GetDestinations().ShouldNotBeEmpty(),
() => aggregate.GetDestinations().Length.ShouldBe(TestData.Destinations.Length));
}
aggregate.ShouldSatisfyAllConditions(() => aggregate.CallbackMessage.ShouldBe(TestData.CallbackMessage),
() => aggregate.TypeString.ShouldBe(TestData.TypeString),
() => aggregate.MessageFormat.ShouldBe(MessageFormat.JSON),
() => aggregate.Reference.ShouldBe(TestData.Reference),
() => aggregate.GetDestinations().ShouldNotBeEmpty(),
() => aggregate.GetDestinations().Length.ShouldBe(TestData.Destinations.Length));
}
}
Loading
Loading