Reduce EstateDomainService.CreateEstateUser complexity by extracting user creation helpers

TransactionProcessor.BusinessLogic.Tests/Services/EstateDomainServiceTests.cs

@@ -89,6 +89,43 @@ public async Task EstateDomainService_CreateEstateUser_EstateUserIsCreated() {
             result.IsSuccess.ShouldBeTrue();
         }
 
+        [Fact]
+        public async Task EstateDomainService_CreateEstateUser_EstateRoleOverrideIsUsedInCreateUserRequest() {
+            String originalEstateRoleName = Environment.GetEnvironmentVariable("EstateRoleName");
+            CreateUserRequest capturedRequest = null;
+
+            try {
+                Environment.SetEnvironmentVariable("EstateRoleName", "CustomEstateRole");
+
+                this.AggregateService.Setup(m => m.GetLatest<EstateAggregate>(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
+                    .ReturnsAsync(Result.Success(TestData.Aggregates.CreatedEstateAggregate()));
+                this.AggregateService.Setup(m => m.Save(It.IsAny<EstateAggregate>(), It.IsAny<CancellationToken>()))
+                    .ReturnsAsync(SimpleResults.Result.Success());
+
+                this.SecurityServiceClient
+                    .Setup(s => s.CreateUser(It.IsAny<CreateUserRequest>(), It.IsAny<CancellationToken>()))
+                    .Callback<CreateUserRequest, CancellationToken>((request, _) => capturedRequest = request)
+                    .ReturnsAsync(Result.Success);
+                this.SecurityServiceClient
+                    .Setup(s => s.GetUsers(It.IsAny<String>(), It.IsAny<CancellationToken>()))
+                    .ReturnsAsync(Result.Success(new List<UserDetails>() {
+                        new UserDetails {
+                            UserId = Guid.Parse("FA077CE3-B915-4048-88E3-9B500699317F")
+                        }
+                    }));
+
+                Result result = await this.DomainService.CreateEstateUser(TestData.Commands.CreateEstateUserCommand, CancellationToken.None);
+
+                result.IsSuccess.ShouldBeTrue();
+                capturedRequest.ShouldNotBeNull();
+                capturedRequest.Roles.ShouldContain("CustomEstateRole");
+                capturedRequest.Claims["estateId"].ShouldBe(TestData.EstateId.ToString());
+            }
+            finally {
+                Environment.SetEnvironmentVariable("EstateRoleName", originalEstateRoleName);
+            }
+        }
+
         [Fact]
         public async Task EstateDomainService_CreateEstateUser_UserCreateFailed_ResultIsFailed()
         {

TransactionProcessor.BusinessLogic/Services/EstateDomainService.cs

@@ -111,42 +111,19 @@ public async Task<Result> CreateEstateUser(EstateCommands.CreateEstateUserComman
         {
             try
             {
-                CreateUserRequest createUserRequest = new CreateUserRequest
-                {
-                    EmailAddress = command.RequestDto.EmailAddress,
-                    FamilyName = command.RequestDto.FamilyName,
-                    GivenName = command.RequestDto.GivenName,
-                    MiddleName = command.RequestDto.MiddleName,
-                    Password = command.RequestDto.Password,
-                    PhoneNumber = "123456", // Is this really needed :|
-                    Roles = new List<String>(),
-                    Claims = new Dictionary<String, String>()
-                };
-
-                // Check if role has been overridden
-                String estateRoleName = Environment.GetEnvironmentVariable("EstateRoleName");
-                createUserRequest.Roles.Add(String.IsNullOrEmpty(estateRoleName) ? "Estate" : estateRoleName);
-                createUserRequest.Claims.Add("estateId", command.EstateId.ToString());
-
-                Result createUserResult = await this.SecurityServiceClient.CreateUser(createUserRequest, cancellationToken);
-                if (createUserResult.IsFailed)
-                    return ResultHelpers.CreateFailure(createUserResult);
-
-                Result<List<UserDetails>> userDetailsResult = await this.SecurityServiceClient.GetUsers(createUserRequest.EmailAddress, cancellationToken);
-                if (userDetailsResult.IsFailed)
-                    return ResultHelpers.CreateFailure(userDetailsResult);
-
-                UserDetails user = userDetailsResult.Data.SingleOrDefault();
-                if (user == null)
-                    return Result.Failure($"Unable to get user details for username {createUserRequest.EmailAddress}");
+                CreateUserRequest createUserRequest = this.BuildEstateUserRequest(command);
+
+                Result<UserDetails> getUserResult = await this.CreateEstateSecurityUser(createUserRequest, cancellationToken);
+                if (getUserResult.IsFailed)
+                    return ResultHelpers.CreateFailure(getUserResult);
 
                 Result<EstateAggregate> estateResult = await DomainServiceHelper.GetAggregateOrFailure(ct => this.AggregateService.GetLatest<EstateAggregate>(command.EstateId, ct), command.EstateId, cancellationToken);
                 if (estateResult.IsFailed)
                     return ResultHelpers.CreateFailure(estateResult);
 
                 EstateAggregate estateAggregate = estateResult.Data;
 
-                Result stateResult = estateAggregate.AddSecurityUser(user.UserId, command.RequestDto.EmailAddress);
+                Result stateResult = estateAggregate.AddSecurityUser(getUserResult.Data.UserId, command.RequestDto.EmailAddress);
                 if (stateResult.IsFailed)
                     return ResultHelpers.CreateFailure(stateResult);
 
@@ -162,6 +139,43 @@ public async Task<Result> CreateEstateUser(EstateCommands.CreateEstateUserComman
             }
         }
 
+        private CreateUserRequest BuildEstateUserRequest(EstateCommands.CreateEstateUserCommand command) {
+            CreateUserRequest createUserRequest = new CreateUserRequest
+            {
+                EmailAddress = command.RequestDto.EmailAddress,
+                FamilyName = command.RequestDto.FamilyName,
+                GivenName = command.RequestDto.GivenName,
+                MiddleName = command.RequestDto.MiddleName,
+                Password = command.RequestDto.Password,
+                PhoneNumber = "123456", // Is this really needed :|
+                Roles = new List<String>(),
+                Claims = new Dictionary<String, String>()
+            };
+
+            String estateRoleName = Environment.GetEnvironmentVariable("EstateRoleName");
+            createUserRequest.Roles.Add(String.IsNullOrEmpty(estateRoleName) ? "Estate" : estateRoleName);
+            createUserRequest.Claims.Add("estateId", command.EstateId.ToString());
+
+            return createUserRequest;
+        }
+
+        private async Task<Result<UserDetails>> CreateEstateSecurityUser(CreateUserRequest createUserRequest,
+                                                                         CancellationToken cancellationToken) {
+            Result createUserResult = await this.SecurityServiceClient.CreateUser(createUserRequest, cancellationToken);
+            if (createUserResult.IsFailed)
+                return ResultHelpers.CreateFailure(createUserResult);
+
+            Result<List<UserDetails>> userDetailsResult = await this.SecurityServiceClient.GetUsers(createUserRequest.EmailAddress, cancellationToken);
+            if (userDetailsResult.IsFailed)
+                return ResultHelpers.CreateFailure(userDetailsResult);
+
+            UserDetails user = userDetailsResult.Data.SingleOrDefault();
+            if (user == null)
+                return Result.Failure($"Unable to get user details for username {createUserRequest.EmailAddress}");
+
+            return Result.Success(user);
+        }
+
         public async Task<Result> RemoveOperatorFromEstate(EstateCommands.RemoveOperatorFromEstateCommand command, CancellationToken cancellationToken)
         {
             try