Skip to content

refactor: drop explicit types on new expressions #361

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
merged 3 commits into from
Sep 19, 2025
Merged

refactor: drop explicit types on new expressions #361

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
f518b42
refactor: drop explicit types on new expressions
deepsource-autofix[bot] Sep 19, 2025
514b329
fixes to autofix
StuartFerguson Sep 19, 2025
0b32713
refactor: remove unused variable declarations
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
6 changes: 3 additions & 3 deletions Shared.EventStore.Tests/AggregateExtensionsTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -15,7 +15,7 @@ public class AggregateExtensionsTests{
public void AggregateExtensions_Apply_EventIsApplied()
{
TestAggregate t = TestAggregate.Create(TestData.AggregateId);
AggregateNameSetEvent aggregateNameSetEvent = new AggregateNameSetEvent(TestData.AggregateId, TestData.EventId, "Test");
AggregateNameSetEvent aggregateNameSetEvent = new(TestData.AggregateId, TestData.EventId, "Test");
t.Apply(aggregateNameSetEvent);
t.AggregateName.ShouldBe("Test");
}
Expand All @@ -24,7 +24,7 @@ public void AggregateExtensions_Apply_EventIsApplied()
public void AggregateExtensions_Apply_DuplicateEvent_EventIsSilentlyHandled()
{
TestAggregate t = TestAggregate.Create(TestData.AggregateId);
AggregateNameSetEvent aggregateNameSetEvent = new AggregateNameSetEvent(TestData.AggregateId, TestData.EventId, "Test");
AggregateNameSetEvent aggregateNameSetEvent = new(TestData.AggregateId, TestData.EventId, "Test");
t.Apply(aggregateNameSetEvent);
t.AggregateName.ShouldBe("Test");
t.Apply(aggregateNameSetEvent);
Expand All @@ -34,7 +34,7 @@ public void AggregateExtensions_Apply_DuplicateEvent_EventIsSilentlyHandled()
public void AggregateExtensions_GetHistoricalEvents_EventsReturned()
{
TestAggregate t = TestAggregate.Create(TestData.AggregateId);
AggregateNameSetEvent aggregateNameSetEvent = new AggregateNameSetEvent(TestData.AggregateId, TestData.EventId, "Test");
AggregateNameSetEvent aggregateNameSetEvent = new(TestData.AggregateId, TestData.EventId, "Test");
t.Apply(aggregateNameSetEvent);
t.AggregateName.ShouldBe("Test");
IList<IDomainEvent> events = t.GetHistoricalEvents();
Expand Down
4 changes: 2 additions & 2 deletions Shared.EventStore.Tests/AggregateRepositoryManagerTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -13,9 +13,9 @@ namespace Shared.EventStore.Tests;
public class AggregateRepositoryManagerTests{
[Fact]
public void AggregateRepositoryManager_GetAggregateRepository_AggregateRepositoryReturned(){
Mock<IEventStoreContextManager> eventStoreContextManager = new Mock<IEventStoreContextManager>();
Mock<IEventStoreContextManager> eventStoreContextManager = new();
IDomainEventFactory<IDomainEvent> factory = new DomainEventFactory();
AggregateRepositoryManager aggregateRepositoryManager = new AggregateRepositoryManager(eventStoreContextManager.Object, factory);
AggregateRepositoryManager aggregateRepositoryManager = new(eventStoreContextManager.Object, factory);
IAggregateRepository<TestAggregate, DomainEvent> r = aggregateRepositoryManager.GetAggregateRepository<TestAggregate, DomainEvent>(Guid.NewGuid());
r.ShouldNotBeNull();

Expand Down
61 changes: 31 additions & 30 deletions Shared.EventStore.Tests/AggregateRepositoryTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -18,13 +18,13 @@ namespace Shared.EventStore.Tests;
public class AggregateRepositoryTests{
[Fact]
public async Task AggregateRepository_GetLatestVersion_AggregateReturned(){
Mock<IEventStoreContext> context = new Mock<IEventStoreContext>();
Mock<IEventStoreContext> context = new();
IDomainEventFactory<IDomainEvent> factory = new DomainEventFactory();
AggregateRepository<TestAggregate, DomainEvent> testAggregateRepository = new AggregateRepository<TestAggregate, DomainEvent>(context.Object,factory);
AggregateRepository<TestAggregate, DomainEvent> testAggregateRepository = new(context.Object,factory);

AggregateNameSetEvent aggregateNameSetEvent = new AggregateNameSetEvent(TestData.AggregateId, TestData.EventId, "Test");
AggregateNameSetEvent aggregateNameSetEvent = new(TestData.AggregateId, TestData.EventId, "Test");
EventRecord r = TestData.CreateEventRecord<AggregateNameSetEvent>(aggregateNameSetEvent, "TestAggregate");
List<ResolvedEvent> e = new List<ResolvedEvent>{
List<ResolvedEvent> e = new(){
new ResolvedEvent(r, null, null)
};
context.Setup(c => c.ReadEvents(It.IsAny<String>(), It.IsAny<Int64>(), It.IsAny<CancellationToken>())).ReturnsAsync(e);
Expand All @@ -49,15 +49,16 @@ public async Task AggregateRepository_GetLatestVersion_NotFound_AggregateReturne
[Fact]
public async Task AggregateRepository_GetLatestVersion_ErrorApplyingEvents_ErrorThrown()
{
Mock<IEventStoreContext> context = new Mock<IEventStoreContext>();
Mock<IEventStoreContext> context = new();
IDomainEventFactory<IDomainEvent> factory = new DomainEventFactory();
AggregateRepository<TestAggregate, DomainEvent> testAggregateRepository = new AggregateRepository<TestAggregate, DomainEvent>(context.Object, factory);
AggregateNameSetEvent aggregateNameSetEvent = new AggregateNameSetEvent(TestData.AggregateId, TestData.EventId, "Error");
AggregateRepository<TestAggregate, DomainEvent> testAggregateRepository = new(context.Object, factory);
AggregateNameSetEvent aggregateNameSetEvent = new(TestData.AggregateId, TestData.EventId, "Error");
EventRecord r = TestData.CreateEventRecord<AggregateNameSetEvent>(aggregateNameSetEvent, "TestAggregate");

List<ResolvedEvent> e = new List<ResolvedEvent>{
new ResolvedEvent(r, null, null)
};
List<ResolvedEvent> e = new()
{
new ResolvedEvent(r, null, null)
};
context.Setup(c => c.ReadEvents(It.IsAny<String>(), It.IsAny<Int64>(), It.IsAny<CancellationToken>())).ReturnsAsync(e);
Result<TestAggregate> result = await testAggregateRepository.GetLatestVersion(TestData.AggregateId, CancellationToken.None);
result.IsFailed.ShouldBeTrue();
Expand All @@ -81,14 +82,14 @@ public async Task AggregateRepository_GetLatestVersion_NoEvents_AggregateReturne
[Fact]
public async Task AggregateRepository_GetLatestVersionFromLastEvent_AggregateReturned()
{
Mock<IEventStoreContext> context = new Mock<IEventStoreContext>();
Mock<IEventStoreContext> context = new();
IDomainEventFactory<IDomainEvent> factory = new DomainEventFactory();

AggregateRepository<TestAggregate, DomainEvent> testAggregateRepository = new AggregateRepository<TestAggregate, DomainEvent>(context.Object, factory);
AggregateRepository<TestAggregate, DomainEvent> testAggregateRepository = new(context.Object, factory);

AggregateNameSetEvent aggregateNameSetEvent = new AggregateNameSetEvent(TestData.AggregateId, TestData.EventId, "Test");
AggregateNameSetEvent aggregateNameSetEvent = new(TestData.AggregateId, TestData.EventId, "Test");
EventRecord r = TestData.CreateEventRecord<AggregateNameSetEvent>(aggregateNameSetEvent, "TestAggregate");
List<ResolvedEvent> e = new List<ResolvedEvent>{
List<ResolvedEvent> e = new(){
new ResolvedEvent(r, null, null)
};
context.Setup(c => c.GetEventsBackward(It.IsAny<String>(), It.IsAny<Int32>(), It.IsAny<CancellationToken>())).ReturnsAsync(e);
Expand All @@ -100,17 +101,17 @@ public async Task AggregateRepository_GetLatestVersionFromLastEvent_AggregateRet
[Fact]
public async Task AggregateRepository_SaveChanges_NoChangesMade_ChangesAreSaved()
{
Mock<IEventStoreContext> context = new Mock<IEventStoreContext>();
Mock<IEventStoreContext> context = new();
IDomainEventFactory<IDomainEvent> factory = new DomainEventFactory();

AggregateNameSetEvent aggregateNameSetEvent = new AggregateNameSetEvent(TestData.AggregateId, TestData.EventId, "Test");
AggregateNameSetEvent aggregateNameSetEvent = new(TestData.AggregateId, TestData.EventId, "Test");
EventRecord r = TestData.CreateEventRecord<AggregateNameSetEvent>(aggregateNameSetEvent, "TestAggregate");
List<ResolvedEvent> e = new List<ResolvedEvent>{
List<ResolvedEvent> e = new(){
new ResolvedEvent(r, null, null)
};
context.Setup(c => c.GetEventsBackward(It.IsAny<String>(), It.IsAny<Int32>(), It.IsAny<CancellationToken>())).ReturnsAsync(e);

AggregateRepository<TestAggregate, DomainEvent> testAggregateRepository = new AggregateRepository<TestAggregate, DomainEvent>(context.Object, factory);
AggregateRepository<TestAggregate, DomainEvent> testAggregateRepository = new(context.Object, factory);
Result<TestAggregate> testAggregate = await testAggregateRepository.GetLatestVersionFromLastEvent(TestData.AggregateId, CancellationToken.None);

Result result = await testAggregateRepository.SaveChanges(testAggregate.Data, CancellationToken.None);
Expand All @@ -120,18 +121,18 @@ public async Task AggregateRepository_SaveChanges_NoChangesMade_ChangesAreSaved(
[Fact]
public async Task AggregateRepository_SaveChanges_ErrorsOnInsert_FailedResult()
{
Mock<IEventStoreContext> context = new Mock<IEventStoreContext>();
Mock<IEventStoreContext> context = new();
IDomainEventFactory<IDomainEvent> factory = new DomainEventFactory();

AggregateNameSetEvent aggregateNameSetEvent = new AggregateNameSetEvent(TestData.AggregateId, TestData.EventId, "Test");
AggregateNameSetEvent aggregateNameSetEvent = new(TestData.AggregateId, TestData.EventId, "Test");
EventRecord r = TestData.CreateEventRecord<AggregateNameSetEvent>(aggregateNameSetEvent, "TestAggregate");
List<ResolvedEvent> e = new List<ResolvedEvent>{
List<ResolvedEvent> e = new() {
new ResolvedEvent(r, null, null)
};
context.Setup(c => c.GetEventsBackward(It.IsAny<String>(), It.IsAny<Int32>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success(e));
context.Setup(c => c.InsertEvents(It.IsAny<String>(), It.IsAny<long>(), It.IsAny<List<EventData>>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure("error"));

AggregateRepository<TestAggregate, DomainEvent> testAggregateRepository = new AggregateRepository<TestAggregate, DomainEvent>(context.Object, factory);
AggregateRepository<TestAggregate, DomainEvent> testAggregateRepository = new(context.Object, factory);
Result<TestAggregate> testAggregate = await testAggregateRepository.GetLatestVersionFromLastEvent(TestData.AggregateId, CancellationToken.None);
testAggregate.Data.SetAggregateName("New name", Guid.NewGuid());
Result result = await testAggregateRepository.SaveChanges(testAggregate.Data, CancellationToken.None);
Expand All @@ -141,14 +142,14 @@ public async Task AggregateRepository_SaveChanges_ErrorsOnInsert_FailedResult()
[Fact]
public async Task AggregateRepository_GetLatestVersionFromLastEvent_GetEventsFailed_FailedResult()
{
Mock<IEventStoreContext> context = new Mock<IEventStoreContext>();
Mock<IEventStoreContext> context = new();
IDomainEventFactory<IDomainEvent> factory = new DomainEventFactory();

AggregateRepository<TestAggregate, DomainEvent> testAggregateRepository = new AggregateRepository<TestAggregate, DomainEvent>(context.Object, factory);
AggregateRepository<TestAggregate, DomainEvent> testAggregateRepository = new(context.Object, factory);

AggregateNameSetEvent aggregateNameSetEvent = new AggregateNameSetEvent(TestData.AggregateId, TestData.EventId, "Test");
AggregateNameSetEvent aggregateNameSetEvent = new(TestData.AggregateId, TestData.EventId, "Test");
EventRecord r = TestData.CreateEventRecord<AggregateNameSetEvent>(aggregateNameSetEvent, "TestAggregate");
List<ResolvedEvent> e = new List<ResolvedEvent>{
List<ResolvedEvent> e = new(){
new ResolvedEvent(r, null, null)
};
context.Setup(c => c.GetEventsBackward(It.IsAny<String>(), It.IsAny<Int32>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Failure("error"));
Expand All @@ -160,18 +161,18 @@ public async Task AggregateRepository_GetLatestVersionFromLastEvent_GetEventsFai
[Fact]
public async Task AggregateRepository_SaveChanges_ChangesMade_ChangesAreSaved()
{
Mock<IEventStoreContext> context = new Mock<IEventStoreContext>();
Mock<IEventStoreContext> context = new();
context.Setup(c => c.InsertEvents(It.IsAny<String>(), It.IsAny<long>(), It.IsAny<List<EventData>>(), It.IsAny<CancellationToken>())).ReturnsAsync(Result.Success);
IDomainEventFactory<IDomainEvent> factory = new DomainEventFactory();

AggregateNameSetEvent aggregateNameSetEvent = new AggregateNameSetEvent(TestData.AggregateId, TestData.EventId, "Test");
AggregateNameSetEvent aggregateNameSetEvent = new(TestData.AggregateId, TestData.EventId, "Test");
EventRecord r = TestData.CreateEventRecord<AggregateNameSetEvent>(aggregateNameSetEvent, "TestAggregate");
List<ResolvedEvent> e = new List<ResolvedEvent>{
List<ResolvedEvent> e = new() {
new ResolvedEvent(r, null, null)
};
context.Setup(c => c.GetEventsBackward(It.IsAny<String>(), It.IsAny<Int32>(), It.IsAny<CancellationToken>())).ReturnsAsync(e);

AggregateRepository<TestAggregate, DomainEvent> testAggregateRepository = new AggregateRepository<TestAggregate, DomainEvent>(context.Object, factory);
AggregateRepository<TestAggregate, DomainEvent> testAggregateRepository = new(context.Object, factory);
Result<TestAggregate> testAggregaterResult = await testAggregateRepository.GetLatestVersionFromLastEvent(TestData.AggregateId, CancellationToken.None);
var testAggregate = testAggregaterResult.Data;
testAggregate.SetAggregateName("New name", Guid.NewGuid());
Expand Down
Loading
Loading