MINOR CODE RUB: Code Cleanup

GitFyle.Core.Api.Tests.Acceptance/Apis/Repositories/RepositoriesApiTests.Logic.cs

@@ -70,7 +70,7 @@ public async Task ShouldGetAllRepositoriesAsync()
             // then
             foreach (Repository expectedRepository in expectedRepositories)
             {
-                Repository actualRepository = 
+                Repository actualRepository =
                     actualRepositories.Single(repository => repository.Id == expectedRepository.Id);
 
                 actualRepository.Should().BeEquivalentTo(expectedRepository);

GitFyle.Core.Api.Tests.Acceptance/Apis/Repositories/RepositoriesApiTests.cs

@@ -6,7 +6,6 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
-using FluentAssertions;
 using GitFyle.Core.Api.Tests.Acceptance.Brokers;
 using GitFyle.Core.Api.Tests.Acceptance.Models.Repositories;
 using GitFyle.Core.Api.Tests.Acceptance.Models.Sources;
@@ -60,7 +59,7 @@ private async ValueTask<Repository> PostRandomRepository(Guid sourceId)
 
             return randomRepository;
         }
-        
+
         private static Repository CreateRandomRepository(Guid sourceId) =>
             CreateRepositoryFiller(sourceId).Create();
 

GitFyle.Core.Api.Tests.Unit/Controllers/ContributionTypes/ContributionTypesControllerTests.Exceptions.Delete.cs

@@ -3,7 +3,6 @@
 // ----------------------------------------------------------------------------------
 
 using System;
-using System.ComponentModel.DataAnnotations;
 using System.Threading.Tasks;
 using GitFyle.Core.Api.Models.Foundations.ContributionTypes;
 using GitFyle.Core.Api.Models.Foundations.ContributionTypes.Exceptions;

GitFyle.Core.Api.Tests.Unit/Controllers/ContributionTypes/ContributionTypesControllerTests.Exceptions.Post.cs

@@ -104,7 +104,7 @@ public async Task ShouldReturnConflictOnPostIfAlreadyExistsContributionTypeExcep
             ConflictObjectResult expectedConflictObjectResult =
                 Conflict(alreadyExistsContributionTypeException);
 
-            var expectedActionResult = 
+            var expectedActionResult =
                 new ActionResult<ContributionType>(expectedConflictObjectResult);
 
             this.contributionTypeServiceMock.Setup(service =>
@@ -145,8 +145,8 @@ public async Task ShouldReturnFailedDependencyOnPostIfReferenceExceptionOccursAs
                     innerException: invalidReferenceContributionTypeException,
                     data: invalidReferenceContributionTypeException.Data);
 
-            FailedDependencyObjectResult expectedFailedDependencyObjectResult = 
-                    FailedDependency(invalidReferenceContributionTypeException);
+            FailedDependencyObjectResult expectedFailedDependencyObjectResult =
+                FailedDependency(invalidReferenceContributionTypeException);
 
             var expectedActionResult =
                 new ActionResult<ContributionType>(expectedFailedDependencyObjectResult);
@@ -156,7 +156,7 @@ public async Task ShouldReturnFailedDependencyOnPostIfReferenceExceptionOccursAs
                     .ThrowsAsync(contributionTypeDependencyValidationException);
 
             // when
-            ActionResult<ContributionType> actualActionResult = 
+            ActionResult<ContributionType> actualActionResult =
                 await this.contributionTypesController.PostContributionTypeAsync(someContributionType);
 
             // then

GitFyle.Core.Api.Tests.Unit/Controllers/ContributionTypes/ContributionTypesControllerTests.Exceptions.Put.cs

@@ -56,18 +56,18 @@ public async Task ShouldReturnInternalServerErrorOnPutIfServerExceptionOccurredA
             // given
             ContributionType someContributionType = CreateRandomContributionType();
 
-            InternalServerErrorObjectResult expectedInternalServerErrorObjectResult = 
+            InternalServerErrorObjectResult expectedInternalServerErrorObjectResult =
                 InternalServerError(serverException);
 
-            var expectedActionResult = 
+            var expectedActionResult =
                 new ActionResult<ContributionType>(expectedInternalServerErrorObjectResult);
 
             this.contributionTypeServiceMock.Setup(service =>
                 service.ModifyContributionTypeAsync(It.IsAny<ContributionType>()))
                     .ThrowsAsync(serverException);
 
             // when
-            ActionResult<ContributionType> actualActionResult = 
+            ActionResult<ContributionType> actualActionResult =
                 await this.contributionTypesController.PutContributionTypeAsync(someContributionType);
 
             // then
@@ -186,19 +186,19 @@ public async Task ShouldReturnFailedDependencyOnPutIfReferenceExceptionOccursAsy
                     innerException: invalidReferenceContributionTypeException,
                     data: someDictionaryData);
 
-            FailedDependencyObjectResult expectedFailedDependencyObjectResult = 
+            FailedDependencyObjectResult expectedFailedDependencyObjectResult =
                 FailedDependency(invalidReferenceContributionTypeException);
 
             var expectedActionResult =
                 new ActionResult<ContributionType>(expectedFailedDependencyObjectResult);
 
-            this.contributionTypeServiceMock.Setup(service => 
+            this.contributionTypeServiceMock.Setup(service =>
                 service.ModifyContributionTypeAsync(It.IsAny<ContributionType>()))
                     .ThrowsAsync(contributionTypeDependencyValidationException);
 
             // when
-            ActionResult<ContributionType> actualActionResult = 
-                    await this.contributionTypesController.PutContributionTypeAsync(someContributionType);
+            ActionResult<ContributionType> actualActionResult =
+                await this.contributionTypesController.PutContributionTypeAsync(someContributionType);
 
             // then
             actualActionResult.ShouldBeEquivalentTo(expectedActionResult);

GitFyle.Core.Api.Tests.Unit/Controllers/Contributions/ContributionsControllerTests.Exceptions.Delete.cs

@@ -24,11 +24,11 @@ public async Task ShouldReturnBadRequestOnDeleteIfValidationExceptionOccursAsync
             // given
             Guid someContributionId = Guid.NewGuid();
 
-            BadRequestObjectResult expectedInternalServerErrorObjectResult  = 
+            BadRequestObjectResult expectedInternalServerErrorObjectResult =
                 BadRequest(validationException.InnerException);
 
-            var expectedActionResult = 
-                new ActionResult<Contribution>(expectedInternalServerErrorObjectResult );
+            var expectedActionResult =
+                new ActionResult<Contribution>(expectedInternalServerErrorObjectResult);
 
             this.contributionServiceMock.Setup(service =>
                 service.RemoveContributionByIdAsync(It.IsAny<Guid>()))
@@ -57,23 +57,23 @@ public async Task ShouldReturnFailedDependencyOnDeleteIfReferenceExceptionOccurs
             var someInnerException = new Exception();
             string someMessage = GetRandomString();
 
-            var invalidReferenceContributionException = 
+            var invalidReferenceContributionException =
                 new InvalidReferenceContributionException(
                     message: someMessage,
                     innerException: someInnerException,
                     data: someInnerException.Data);
 
-            var contributionDependencyValidationException = 
+            var contributionDependencyValidationException =
                 new ContributionDependencyValidationException(
                     message: someMessage,
                     innerException: invalidReferenceContributionException,
                     data: invalidReferenceContributionException.Data);
 
-            FailedDependencyObjectResult expectedLockedObjectResult  = 
+            FailedDependencyObjectResult expectedLockedObjectResult =
                 FailedDependency(invalidReferenceContributionException);
 
-            var expectedActionResult = 
-                new ActionResult<Contribution>(expectedLockedObjectResult );
+            var expectedActionResult =
+                new ActionResult<Contribution>(expectedLockedObjectResult);
 
 
             this.contributionServiceMock.Setup(service =>
@@ -102,10 +102,10 @@ public async Task ShouldReturnInternalServerErrorOnDeleteIfServerErrorOccurredAs
             // given
             Guid someContributionId = Guid.NewGuid();
 
-            InternalServerErrorObjectResult expectedInternalServerErrorObjectResult  = 
+            InternalServerErrorObjectResult expectedInternalServerErrorObjectResult =
                 InternalServerError(serverException);
 
-            var expectedActionResult = 
+            var expectedActionResult =
                 new ActionResult<Contribution>(expectedInternalServerErrorObjectResult);
 
             this.contributionServiceMock.Setup(service =>
@@ -175,13 +175,13 @@ public async Task ShouldReturnLockedOnDeleteIfLockedContributionExceptionOccursA
             string someMessage = GetRandomString();
             var someDictionaryData = GetRandomDictionaryData();
 
-            var lockedContributionException = 
+            var lockedContributionException =
                 new LockedContributionException(
                     message: someMessage,
                     innerException: someInnerException,
                     data: someInnerException.Data);
 
-            var contributionDependencyValidationException = 
+            var contributionDependencyValidationException =
                 new ContributionDependencyValidationException(
                     message: someMessage,
                     innerException: lockedContributionException,
@@ -191,7 +191,7 @@ public async Task ShouldReturnLockedOnDeleteIfLockedContributionExceptionOccursA
                 Locked(lockedContributionException);
 
             var expectedActionResult =
-                new ActionResult<Contribution>(expectedLockedObjectResult  );
+                new ActionResult<Contribution>(expectedLockedObjectResult);
 
             this.contributionServiceMock.Setup(service =>
                 service.RemoveContributionByIdAsync(It.IsAny<Guid>()))

GitFyle.Core.Api.Tests.Unit/Controllers/Contributions/ContributionsControllerTests.Exceptions.Post.cs

@@ -56,7 +56,7 @@ public async Task ShouldReturnFailedDependencyOnPostIfReferenceExceptionOccursAs
             var someInnerException = new Exception();
             string someMessage = GetRandomString();
 
-            var invalidReferenceContributionException = 
+            var invalidReferenceContributionException =
                 new InvalidReferenceContributionException(
                     message: someMessage,
                     innerException: someInnerException,
@@ -68,7 +68,7 @@ public async Task ShouldReturnFailedDependencyOnPostIfReferenceExceptionOccursAs
                     innerException: invalidReferenceContributionException,
                     data: invalidReferenceContributionException.Data);
 
-            FailedDependencyObjectResult expectedConflictObjectResult = 
+            FailedDependencyObjectResult expectedConflictObjectResult =
                 FailedDependency(invalidReferenceContributionException);
 
             var expectedActionResult = new ActionResult<Contribution>(expectedConflictObjectResult);
@@ -78,8 +78,8 @@ public async Task ShouldReturnFailedDependencyOnPostIfReferenceExceptionOccursAs
                     .ThrowsAsync(contributionDependencyValidationException);
 
             // when
-            ActionResult<Contribution> actualActionResult = 
-                    await this.contributionsController.PostContributionAsync(someContribution);
+            ActionResult<Contribution> actualActionResult =
+                await this.contributionsController.PostContributionAsync(someContribution);
 
             // then
             actualActionResult.ShouldBeEquivalentTo(expectedActionResult);
@@ -90,7 +90,7 @@ public async Task ShouldReturnFailedDependencyOnPostIfReferenceExceptionOccursAs
 
             this.contributionServiceMock.VerifyNoOtherCalls();
         }
-    
+
         [Theory]
         [MemberData(nameof(ServerExceptions))]
         public async Task ShouldReturnInternalServerErrorOnPostIfServerExceptionOccurredAsync(
@@ -144,18 +144,18 @@ public async Task ShouldReturnConflictOnPostIfAlreadyExistsContributionException
                     innerException: alreadyExistsContributionException,
                     data: someDictionaryData);
 
-            ConflictObjectResult expectedConflictObjectResult = 
+            ConflictObjectResult expectedConflictObjectResult =
                 Conflict(alreadyExistsContributionException);
 
-            var expectedActionResult = 
+            var expectedActionResult =
                 new ActionResult<Contribution>(expectedConflictObjectResult);
 
             this.contributionServiceMock.Setup(service =>
                 service.AddContributionAsync(It.IsAny<Contribution>()))
                     .ThrowsAsync(contributionDependencyValidationException);
 
             // when
-            ActionResult<Contribution> actualActionResult = 
+            ActionResult<Contribution> actualActionResult =
                 await this.contributionsController.PostContributionAsync(someContribution);
 
             // then

GitFyle.Core.Api.Tests.Unit/Controllers/Contributions/ContributionsControllerTests.Exceptions.Put.cs

@@ -6,8 +6,6 @@
 using System.Threading.Tasks;
 using GitFyle.Core.Api.Models.Foundations.Contributions;
 using GitFyle.Core.Api.Models.Foundations.Contributions.Exceptions;
-using GitFyle.Core.Api.Models.Foundations.ContributionTypes.Exceptions;
-using GitFyle.Core.Api.Models.Foundations.ContributionTypes;
 using Microsoft.AspNetCore.Mvc;
 using Moq;
 using RESTFulSense.Clients.Extensions;

GitFyle.Core.Api.Tests.Unit/Controllers/Contributions/ContributionsControllerTests.Logic.GetById.cs

@@ -34,8 +34,8 @@ public async Task ShouldReturnOkWithRecordOnGetByIdAsync()
                     .ReturnsAsync(storageContribution);
 
             // when
-            ActionResult<Contribution> actualActionResult = 
-                    await contributionsController.GetContributionByIdAsync(inputId);
+            ActionResult<Contribution> actualActionResult =
+                await contributionsController.GetContributionByIdAsync(inputId);
 
             // then
             actualActionResult.ShouldBeEquivalentTo(expectedActionResult);

GitFyle.Core.Api.Tests.Unit/Services/Foundations/ContributionTypes/ContributionTypeServiceTests.Exceptions.Modify.cs

@@ -83,16 +83,16 @@ public async Task ShouldThrowValidationExceptionOnModifyIfReferenceErrorOccursAn
                 new ForeignKeyConstraintConflictException(message: exceptionMessage);
 
             var invalidContributionTypeReferenceException =
-                    new InvalidReferenceContributionTypeException(
-                        message: "Invalid contributionType reference error occurred.", 
-                        innerException: foreignKeyConstraintConflictException,
-                        data: foreignKeyConstraintConflictException.Data);
+                new InvalidReferenceContributionTypeException(
+                    message: "Invalid contributionType reference error occurred.",
+                    innerException: foreignKeyConstraintConflictException,
+                    data: foreignKeyConstraintConflictException.Data);
 
-            var expectedContributionTypeDependencyValidationException = 
-                    new ContributionTypeDependencyValidationException(
-                        message: "ContributionType dependency validation error occurred, fix errors and try again.", 
-                        innerException: invalidContributionTypeReferenceException,
-                        data: invalidContributionTypeReferenceException.Data);
+            var expectedContributionTypeDependencyValidationException =
+                new ContributionTypeDependencyValidationException(
+                    message: "ContributionType dependency validation error occurred, fix errors and try again.",
+                    innerException: invalidContributionTypeReferenceException,
+                    data: invalidContributionTypeReferenceException.Data);
 
             this.dateTimeBrokerMock.Setup(broker =>
                 broker.GetCurrentDateTimeOffsetAsync())
@@ -205,13 +205,13 @@ private async Task ShouldThrowDependencyValidationExceptionOnModifyIfDbUpdateCon
             var dbUpdateConcurrencyException =
                 new DbUpdateConcurrencyException();
 
-            var lockedContributionTypeException = 
+            var lockedContributionTypeException =
                 new LockedContributionTypeException(
                     message: "Locked contributionType record error occurred, please try again.",
                     innerException: dbUpdateConcurrencyException,
                     data: dbUpdateConcurrencyException.Data);
 
-            var expectedContributionTypeDependencyValidationException = 
+            var expectedContributionTypeDependencyValidationException =
                 new ContributionTypeDependencyValidationException(
                     message: "ContributionType dependency validation error occurred, fix errors and try again.",
                     innerException: lockedContributionTypeException,

GitFyle.Core.Api/Controllers/ContributionTypesController.cs

@@ -38,13 +38,13 @@ public async ValueTask<ActionResult<ContributionType>> PostContributionTypeAsync
                 return BadRequest(contributionTypeValidationException.InnerException);
             }
             catch (ContributionTypeDependencyValidationException contributionTypeDependencyValidationException)
-                when (contributionTypeDependencyValidationException.InnerException 
+                when (contributionTypeDependencyValidationException.InnerException
                     is AlreadyExistsContributionTypeException)
             {
                 return Conflict(contributionTypeDependencyValidationException.InnerException);
             }
             catch (ContributionTypeDependencyValidationException contributionTypeDependencyValidationException)
-                 when (contributionTypeDependencyValidationException.InnerException 
+                 when (contributionTypeDependencyValidationException.InnerException
                     is InvalidReferenceContributionTypeException)
             {
                 return FailedDependency(contributionTypeDependencyValidationException.InnerException);
@@ -137,14 +137,14 @@ public async ValueTask<ActionResult<ContributionType>> PutContributionTypeAsync(
                 return BadRequest(contributionTypeValidationException.InnerException);
             }
             catch (ContributionTypeDependencyValidationException contributionTypeDependencyValidationException)
-                when (contributionTypeDependencyValidationException.InnerException is 
+                when (contributionTypeDependencyValidationException.InnerException is
                     AlreadyExistsContributionTypeException)
             {
                 return Conflict(contributionTypeDependencyValidationException.InnerException);
             }
             catch (ContributionTypeDependencyValidationException contributionTypeDependencyValidationException)
-              when (contributionTypeDependencyValidationException.InnerException is 
-                InvalidReferenceContributionTypeException)
+                when (contributionTypeDependencyValidationException.InnerException is
+                    InvalidReferenceContributionTypeException)
             {
                 return FailedDependency(contributionTypeDependencyValidationException.InnerException);
             }
@@ -183,7 +183,7 @@ public async ValueTask<ActionResult<ContributionType>> DeleteContributionTypeByI
                 return BadRequest(contributionTypeValidationException.InnerException);
             }
             catch (ContributionTypeDependencyValidationException contributionTypeDependencyValidationException)
-                when (contributionTypeDependencyValidationException.InnerException 
+                when (contributionTypeDependencyValidationException.InnerException
                     is InvalidReferenceContributionTypeException)
             {
                 return FailedDependency(contributionTypeDependencyValidationException.InnerException);