public async Task GivenTheFollowingClientsExist(Table table)
{
foreach (TableRow tableRow in table.Rows)
{
String clientId = SpecflowTableHelper.GetStringRowValue(tableRow, "ClientId");
String clientName = SpecflowTableHelper.GetStringRowValue(tableRow, "ClientName");
String secret = SpecflowTableHelper.GetStringRowValue(tableRow, "Secret");
String allowedScopes = SpecflowTableHelper.GetStringRowValue(tableRow, "AllowedScopes");
String allowedGrantTypes = SpecflowTableHelper.GetStringRowValue(tableRow, "AllowedGrantTypes");
List <String> splitAllowedScopes = allowedScopes.Split(",").ToList();
List <String> splitAllowedGrantTypes = allowedGrantTypes.Split(",").ToList();
CreateClientRequest createClientRequest = new CreateClientRequest
{
Secret = secret,
AllowedGrantTypes = new List <String>(),
AllowedScopes = new List <String>(),
ClientDescription = String.Empty,
ClientId = clientId,
ClientName = clientName
};
splitAllowedScopes.ForEach(a => { createClientRequest.AllowedScopes.Add(a.Trim()); });
splitAllowedGrantTypes.ForEach(a => { createClientRequest.AllowedGrantTypes.Add(a.Trim()); });
CreateClientResponse createClientResponse = await this.TestingContext.DockerHelper.SecurityServiceClient
.CreateClient(createClientRequest, CancellationToken.None).ConfigureAwait(false);
createClientResponse.ClientId.ShouldBe(clientId);
this.TestingContext.AddClientDetails(clientId, secret, allowedGrantTypes);
}
}
static void ExecuteSoap()
{
var client = new SoapServiceClient("NeliburSoapService");
var createRequest = new CreateClientRequest
{
Email = "*****@*****.**"
};
ClientResponse response = client.Post <ClientResponse>(createRequest);
var updateRequest = new UpdateClientRequest
{
Email = "*****@*****.**",
Id = response.Id
};
response = client.Put <ClientResponse>(updateRequest);
var getClientRequest = new GetClientRequest
{
Id = response.Id
};
response = client.Get <ClientResponse>(getClientRequest);
var deleteRequest = new DeleteClientRequest
{
Id = response.Id
};
client.Delete(deleteRequest);
}
public async Task <CreateClientResponse> Execute(CreateClientRequest request)
{
try
{
if (request != null)
{
var result = _clientRepository.Exist(request.ClientDto).Result;
if (result != null)
{
throw new Exception($"Cpf/Cnpj or Email already exist: {JsonConvert.SerializeObject(result)}");
}
if (await _clientRepository.Create(request.ClientDto))
{
return new CreateClientResponse {
Created = true
}
}
;
throw new Exception(message: $"It was not possible to create client: {JsonConvert.SerializeObject(request)}");
}
return(new CreateClientResponse {
Created = false
});
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
/// <summary>
/// Creates the client.
/// </summary>
/// <param name="createClientRequest">The create client request.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns></returns>
public async Task <CreateClientResponse> CreateClient(CreateClientRequest createClientRequest,
CancellationToken cancellationToken)
{
CreateClientResponse response = null;
String requestUri = this.BuildRequestUrl("/api/clients");
try
{
String requestSerialised = JsonConvert.SerializeObject(createClientRequest);
StringContent httpContent = new StringContent(requestSerialised, Encoding.UTF8, "application/json");
// Add the access token to the client headers
//this.HttpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
// Make the Http Call here
HttpResponseMessage httpResponse = await this.HttpClient.PostAsync(requestUri, httpContent, cancellationToken);
// Process the response
String content = await this.HandleResponse(httpResponse, cancellationToken);
// call was successful so now deserialise the body to the response object
response = JsonConvert.DeserializeObject <CreateClientResponse>(content);
}
catch (Exception ex)
{
// An exception has occurred, add some additional information to the message
Exception exception = new Exception($"Error creating client {createClientRequest.ClientId}.", ex);
throw exception;
}
return(response);
}
public CreateClientResponse CreateClient(CreateClientRequest clientRequest)
{
CreateClientResponse rtn = new CreateClientResponse();
_client = new RestClient($"{_settings.Url}{XeroUrl.Contacts}");
_client.Timeout = -1;
var request = new RestRequest(Method.POST);
request.AddHeader("xero-tenant-id", _settings.TenandId);
request.AddHeader("Authorization", "Bearer " + _settings.AccessToken);
request.AddHeader("Accept", "application/json");
request.AddHeader("Content-Type", "application/json");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json,application/json", JsonConvert.SerializeObject(clientRequest), ParameterType.RequestBody);
var response = _client.Execute <XeroCreateContactResponse>(request);
rtn.HttpStatusCode = response.StatusCode;
if (rtn.HttpStatusCode == System.Net.HttpStatusCode.OK)
{
rtn.HttpStatusCode = System.Net.HttpStatusCode.Created;
}
rtn.Status = response.StatusCode == System.Net.HttpStatusCode.Created ? PSC.Common.Enums.ResponseStatus.Success : PSC.Common.Enums.ResponseStatus.Failed;
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
rtn.Contacts = response.Data.Contacts;
}
else
{
rtn.Message = response.Content;
}
return(rtn);
}
private async Task <CreateClientResponse> CreateClient(CreateClientRequest createClientRequest,
CancellationToken cancellationToken)
{
CreateClientResponse createClientResponse = await this.TestingContext.DockerHelper.SecurityServiceClient.CreateClient(createClientRequest, cancellationToken).ConfigureAwait(false);
return(createClientResponse);
}
public async Task CreateClient(Boolean mediatorResult)
{
Random random = new Random();
Guid id = random.NextGuid();
var request = new CreateClientRequest
{
};
var mediatorMock = new Mock <IMediator>(MockBehavior.Strict);
mediatorMock.Setup(x => x.Send(It.Is <CreateClientCommand>(y =>
y.Request == request), It.IsAny <CancellationToken>())).ReturnsAsync(mediatorResult == false ? new Guid?() : id).Verifiable();
var controller = new ClientController(
mediatorMock.Object,
Mock.Of <IClientRepository>(MockBehavior.Strict),
Mock.Of <ILogger <ClientController> >()
);
var actionResult = await controller.CreateClient(request);
if (mediatorResult == true)
{
var actual = actionResult.EnsureOkObjectResult <Guid>(true);
Assert.Equal(id, actual);
}
else
{
actionResult.EnsureBadRequestObjectResult("unable to complete service operation");
}
mediatorMock.Verify();
}
public override Task <CreateClientReply> CreateClient(CreateClientRequest request, ServerCallContext context)
{
return(Task.FromResult(new CreateClientReply
{
Status = $"{request.Name} was successfully cretead"
}));
}
static void ExecuteJson()
{
var client = new JsonServiceClient("http://*****:*****@email.com"
};
ClientResponse response = client.Post <ClientResponse>(createRequest);
var updateRequest = new UpdateClientRequest
{
Email = "*****@*****.**",
Id = response.Id
};
response = client.Put <ClientResponse>(updateRequest);
var getClientRequest = new GetClientRequest
{
Id = response.Id
};
response = client.Get <ClientResponse>(getClientRequest);
var deleteRequest = new DeleteClientRequest
{
Id = response.Id
};
client.Delete(deleteRequest);
}
private async Task SaveClick()
{
if (ToSave.ClientId == 0)
{
var toCreate = new CreateClientRequest()
{
FullName = ToSave.FullName,
EmailAddress = ToSave.EmailAddress,
Salutation = ToSave.Salutation,
PreferredDoctorId = ToSave.PreferredDoctorId,
PreferredName = ToSave.PreferredName,
};
await ClientService.CreateAsync(toCreate);
}
else
{
var toUpdate = new UpdateClientRequest()
{
ClientId = ToSave.ClientId,
FullName = ToSave.FullName,
EmailAddress = ToSave.EmailAddress,
Salutation = ToSave.Salutation,
PreferredDoctorId = ToSave.PreferredDoctorId,
PreferredName = ToSave.PreferredName,
};
await ClientService.EditAsync(toUpdate);
}
CancelClick();
await ReloadData();
}
public async Task GivenICreateTheFollowingClients(Table table)
{
foreach (TableRow tableRow in table.Rows)
{
// Get the scopes
String scopes = SpecflowTableHelper.GetStringRowValue(tableRow, "Scopes");
// Get the grant types
String grantTypes = SpecflowTableHelper.GetStringRowValue(tableRow, "GrantTypes");
// Get the redirect uris
String redirectUris = SpecflowTableHelper.GetStringRowValue(tableRow, "RedirectUris");
// Get the post logout redirect uris
String postLogoutRedirectUris = SpecflowTableHelper.GetStringRowValue(tableRow, "PostLogoutRedirectUris");
CreateClientRequest createClientRequest = new CreateClientRequest
{
ClientId = SpecflowTableHelper.GetStringRowValue(tableRow, "ClientId"),
Secret = SpecflowTableHelper.GetStringRowValue(tableRow, "Secret"),
ClientName = SpecflowTableHelper.GetStringRowValue(tableRow, "Name"),
AllowedScopes = string.IsNullOrEmpty(scopes) ? null : scopes.Split(",").ToList(),
AllowedGrantTypes = string.IsNullOrEmpty(grantTypes) ? null : grantTypes.Split(",").ToList(),
ClientRedirectUris = string.IsNullOrEmpty(redirectUris) ? null : redirectUris.Split(",").ToList(),
ClientPostLogoutRedirectUris = string.IsNullOrEmpty(postLogoutRedirectUris) ? null : postLogoutRedirectUris.Split(",").ToList(),
ClientDescription = SpecflowTableHelper.GetStringRowValue(tableRow, "Description"),
RequireConsent = SpecflowTableHelper.GetBooleanValue(tableRow, "RequireConsent")
};
CreateClientResponse createClientResponse = await this.CreateClient(createClientRequest, CancellationToken.None).ConfigureAwait(false);
createClientResponse.ShouldNotBeNull();
createClientResponse.ClientId.ShouldNotBeNullOrEmpty();
this.TestingContext.Clients.Add(createClientResponse.ClientId);
}
}
public async Task <IActionResult> Create([FromBody] CreateClientRequest request)
{
var clientId = (request.UserId + "client_id_" + request.ApplicationName).Sha256();
int i = 0;
Console.WriteLine("clientId = " + clientId);
while (true)
{
Console.WriteLine("IndexOf + = " + (clientId.IndexOf('+') >= 0).ToString());
if (clientId.IndexOf('+') >= 0)
{
clientId = (request.UserId + "client_id_" + request.ApplicationName + "_" + i).Sha256();
Console.WriteLine("clientId = " + clientId);
i++;
}
else
{
break;
}
}
var clientSecret = ("client_secret_" + request.ApplicationName).Sha256();
request.RedirectUris.Add("http://localhost:7030/Auth/AuthorizationGrantCode");
IdentityServer4.Models.Client client = new IdentityServer4.Models.Client
{
ClientName = request.ApplicationName,
ClientId = clientId,
ClientSecrets =
{
new IdentityServer4.Models.Secret(clientSecret.Sha256())
},
AllowedGrantTypes = { GrantType.AuthorizationCode, GrantType.ClientCredentials },
RedirectUris = request.RedirectUris,
AllowedScopes = request.Scopes,
RequireConsent = true,
AlwaysSendClientClaims = true
};
var entry = await _configurationDbContext.Clients.AddAsync(client.ToEntity());
if (await _configurationDbContext.SaveChangesAsync() > 0)
{
List <string> scopes = new List <string>();
foreach (var item in entry.Entity.AllowedScopes)
{
scopes.Add(item.Scope);
}
var response = new CreateClientResponse
{
ClientId = entry.Entity.ClientId,
ClientSecret = clientSecret,
RedirectUris = entry.Entity.RedirectUris.Select(x => x.RedirectUri).ToList(),
ApplicationName = request.ApplicationName,
Scopes = entry.Entity.AllowedScopes.Select(x => x.Scope).Join(",")
};
return(await Task.FromResult(Ok(response)));
}
return(BadRequest());
}
public override Task <CreateClientResponse> CreateClient(CreateClientRequest request, ServerCallContext context)
{
bool success = RequestsDispatcher.CreateClientProcess(GetClientArguments(request));
if (!success)
{
throw new RpcException(new Status(StatusCode.Internal, "Couldn't create client process."));
}
return(Task.FromResult(new CreateClientResponse()));
}
public IActionResult CreateClient([FromServices] IClientDal _dbService, CreateClientRequest client)
{
var response = _dbService.CreateClient(client);
if (response != null)
{
return(StatusCode(201, response));
}
return(StatusCode(400, "error"));
}
public IActionResult CreateClient([FromBody] CreateClientRequest data)
{
var isCreate = _userService.CreateClient(data);
if (!isCreate)
{
return(BadRequest("UserName invalid"));
}
return(Ok());
}
public async Task Handle(Boolean repoResult)
{
Random random = new Random();
Guid clientSystemId = random.NextGuid();
var request = new CreateClientRequest
{
ClientId = random.GetAlphanumericString(),
AllowedCorsOrigins = new[] { "https://myapp.com" },
AllowedScopes = new[] { "test", "testus" },
DisplayName = random.GetAlphanumericString(),
FrontChannelLogoutUri = "http://mylogout.com/logout",
Password = "******",
PostLogoutRedirectUris = new[] { "https://myapp2.com/logout-callback" },
RedirectUris = new[] { "https://myapp2.com/login-callback" },
RequirePkce = true,
};
BeerClient clientCreated = null;
var repoMock = new Mock <IClientRepository>(MockBehavior.Strict);
repoMock.Setup(x => x.CheckIfClientIdExists(request.ClientId)).ReturnsAsync(false).Verifiable();
repoMock.Setup(x => x.AddClient(It.Is <BeerClient>(y =>
y.DisplayName == request.DisplayName
))).ReturnsAsync(repoResult).Callback <BeerClient>(x => { clientCreated = x; x.Id = clientSystemId; }).Verifiable();
var handler = new CreateClientCommandHandler(repoMock.Object,
Mock.Of <ILogger <CreateClientCommandHandler> >());
Guid?result = await handler.Handle(new CreateClientCommand(request), CancellationToken.None);
if (repoResult == true)
{
Assert.True(result.HasValue);
Assert.Equal(clientSystemId, result.Value);
}
else
{
Assert.False(result.HasValue);
}
Assert.Equal(request.ClientId, clientCreated.ClientId);
Assert.Equal(request.AllowedCorsOrigins, clientCreated.AllowedCorsOrigins);
Assert.Equal(request.AllowedScopes, clientCreated.AllowedScopes);
Assert.Equal(request.DisplayName, clientCreated.DisplayName);
Assert.Equal(request.FrontChannelLogoutUri, clientCreated.FrontChannelLogoutUri);
Assert.Equal("mypassword".Sha256(), clientCreated.HashedPassword);
Assert.Equal(request.PostLogoutRedirectUris, clientCreated.PostLogoutRedirectUris);
Assert.Equal(request.RedirectUris, clientCreated.RedirectUris);
Assert.True(clientCreated.RequirePkce);
repoMock.Verify();
}
public CreateClientArguments GetClientArguments(CreateClientRequest request)
{
return(new CreateClientArguments {
Username = request.Username,
Host = request.Host,
Port = request.Port,
Script = request.Script,
NameServersUrls = request.NamingServersUrls.ToList(),
Version = request.Version
});
}
private static void Main()
{
AppDomain.CurrentDomain.UnhandledException += UnhandledExceptionHandler;
// PerformanceTest();
var client = new JsonServiceClient(Settings.Default.ServiceAddress);
var createRequest = new CreateClientRequest
{
Email = "*****@*****.**"
};
var response = client.Post <ClientResponse>(createRequest);
Console.WriteLine("POST Response: {0}\n", response);
var updateRequest = new UpdateClientRequest
{
Email = "*****@*****.**",
Id = response.Id
};
response = client.Put <ClientResponse>(updateRequest);
Console.WriteLine("PUT Response: {0}\n", response);
var getClientRequest = new GetClientRequest
{
Id = response.Id,
Date = DateTime.Now.Date
};
response = client.Get <ClientResponse>(getClientRequest);
Console.WriteLine("GET Response: {0}\n", response);
var deleteRequest = new DeleteClientRequest
{
Id = response.Id
};
client.Delete(deleteRequest);
var certificate = new MemoryStream(File.ReadAllBytes("Certificate.cer"));
var uploadRequest = new UploadRequest
{
FileContents = certificate.ToArray(),
OriginalFileName = "MyFileName.cert",
UploaderId = Guid.NewGuid().ToString()
};
client.Post(uploadRequest);
Console.ReadKey();
}
public async Task <CreateEntityResponse> Create(CreateClientRequest client)
{
var newClient = new Client
{
Name = client.Name,
Description = client.Description,
EmployerId = client.EmployerId
};
var result = await _clientsRepo.Create(newClient);
return(result);
}
public override async Task <ClientModel> CreateClient(CreateClientRequest request, ServerCallContext context)
{
Tourist client = _mapper.Map <Tourist>(request.Client);
client.Id = default;
_touristRepository.Add(client);
await _touristRepository.SaveChangesAsync();
var clientModel = request.Client;
return(clientModel);
}
/// <summary>
/// Clients / Create Client
/// </summary>
public async Task <CreateClientResponse> CreateClientAsync(CreateClientRequest request)
{
if (request == null)
{
throw new ArgumentNullException("Value cannot be null.", nameof(request));
}
if (string.IsNullOrEmpty(request.Name))
{
throw new ArgumentException("Value cannot be null or empty.", nameof(request.Name));
}
return(await ExecuteAsync <CreateClientResponse>(CreateRequest <CreateClientRequest>(CLIENTS_PATH, request)).ConfigureAwait(false));
}
public async Task <IActionResult> CreateClient([FromBody] CreateClientRequest request)
{
Guid?systemid = await _mediator.Send(new CreateClientCommand(request));
if (systemid.HasValue == true)
{
return(base.Ok(systemid.Value));
}
else
{
return(BadRequest("unable to complete service operation"));
}
}
private async void CreateNewClient()
{
CreateClientRequest createClientRequest = new CreateClientRequest
{
FirstName = tbIme.Text,
LastName = tbPrezime.Text,
Email = tbEmail.Text,
Password = tbPassword.Text,
Address = tbAdresa.Text,
PhoneNumber = tbTelefon.Text
};
await _apiService.Create <Client>(createClientRequest);
}
public bool CreateClient(CreateClientRequest clientRequest)
{
var client = _clientRepository.GetByUserName(clientRequest.UserName);
if (client != null)
{
return(false);
}
_clientRepository.Add(_mapper.Map <ClientEntity>(clientRequest));
Console.WriteLine($"New User Create! Name: { clientRequest.UserName }, Email: { clientRequest.EmailAddress }, Password: { clientRequest.Password }.");
return(true);
}
public Models.Clients.Client Create(CreateClientRequest createClientRequest)
{
Database.AppUser appUser = _mapper.Map <Database.AppUser>(createClientRequest);
appUser.HashedPassword = HashUtil.ComputeSha256Hash(createClientRequest.Password);
appUser.CreatedAt = DateTime.UtcNow;
appUser.Status = Database.UserStatus.INACTIVE;
// add client specific data
Database.Client client = new Database.Client();
appUser.Client = client;
_context.AppUsers.Add(appUser);
_context.SaveChanges();
return(_mapper.Map <Models.Clients.Client>(appUser));
}
private static void PerformanceTest()
{
var client = new JsonServiceClient(Settings.Default.ServiceAddress);
var createRequest = new CreateClientRequest
{
Email = "*****@*****.**"
};
Stopwatch stopwatch = Stopwatch.StartNew();
1000.Times()
.Iter(x => client.Post <ClientResponse>(createRequest));
Console.WriteLine("Total: {0} ms", stopwatch.Elapsed.TotalMilliseconds);
}
// POST api/values
public CreateClientResponse Post(CreateClientRequest model)
{
if (model != null)
{
return(new CreateClientResponse
{
Token = "SuperSecretData",
Status = ResponseStatus.Success
});
}
return(new CreateClientResponse
{
Status = ResponseStatus.Failed
});
}
public void CreateClient_ServiceReturnTask_ReturnOk()
{
ClientService.Invocations.Clear();
var name = "Ivan Ivanov";
var email = "*****@*****.**";
var password = "******";
var clientId = Guid.NewGuid();
var requestedName = string.Empty;
var requestedEmail = string.Empty;
var requestedPassword = string.Empty;
var taskId = Guid.NewGuid();
var request = new CreateClientRequest {
Name = name, Email = email, Password = password
};
ClientService.Setup(x => x.CreateClient(It.IsAny <Client>()))
.Callback <Client>((clientParam) =>
{
requestedName = clientParam.Name;
requestedEmail = clientParam.Email;
requestedPassword = clientParam.Password;
})
.Returns(new BusinessLogic.Models.CreateClientResult {
TaskId = taskId
});
var controller = new ClientsController(ClientService.Object)
{
ControllerContext = new ControllerContext {
HttpContext = new DefaultHttpContext()
}
};
var actionResult = controller.Post(request);
var result = actionResult as OkObjectResult;
var createResult = result.Value as TimeOutResult;
ClientService.Verify(x => x.CreateClient(It.IsAny <Client>()), Times.Once);
Assert.AreEqual(requestedName, name);
Assert.AreEqual(requestedEmail, email);
Assert.AreEqual(requestedPassword, password);
Assert.AreEqual(createResult.TaskId, taskId);
Assert.AreEqual(result.StatusCode, 200);
}
public async Task GivenTheFollowingClientsExist(Table table)
{
foreach (TableRow tableRow in table.Rows)
{
String clientId = SpecflowTableHelper.GetStringRowValue(tableRow, "ClientId");
String clientName = SpecflowTableHelper.GetStringRowValue(tableRow, "ClientName");
String secret = SpecflowTableHelper.GetStringRowValue(tableRow, "Secret");
String allowedScopes = SpecflowTableHelper.GetStringRowValue(tableRow, "AllowedScopes");
String allowedGrantTypes = SpecflowTableHelper.GetStringRowValue(tableRow, "AllowedGrantTypes");
List <String> splitAllowedScopes = allowedScopes.Split(',').ToList();
List <String> splitAllowedGrantTypes = allowedGrantTypes.Split(',').ToList();
CreateClientRequest createClientRequest = new CreateClientRequest
{
Secret = secret,
AllowedGrantTypes = new List <String>(),
AllowedScopes = new List <String>(),
ClientDescription = String.Empty,
ClientId = clientId,
ClientName = clientName
};
splitAllowedScopes.ForEach(a => { createClientRequest.AllowedScopes.Add(a.Trim()); });
splitAllowedGrantTypes.ForEach(a => { createClientRequest.AllowedGrantTypes.Add(a.Trim()); });
CreateClientResponse createClientResponse = await this.TestingContext.DockerHelper.SecurityServiceClient
.CreateClient(createClientRequest, CancellationToken.None).ConfigureAwait(false);
createClientResponse.ClientId.ShouldBe(clientId);
this.TestingContext.AddClientDetails(clientId, secret, allowedGrantTypes);
}
var merchantClient = this.TestingContext.GetClientDetails("merchantClient");
// TODO: Handle local test running
String securityService = this.TestingContext.DockerHelper.SecurityServiceBaseAddress;
String transactionProcessorAcl = this.TestingContext.DockerHelper.TransactionProcessorACLBaseAddress;
Console.WriteLine($"securityService [{securityService}]");
Console.WriteLine($"transactionProcessorAcl [{transactionProcessorAcl}]");
AppManager.SetConfiguration(merchantClient.ClientId, merchantClient.ClientSecret,
securityService, transactionProcessorAcl);
}
public void CreateClient_ServiceReturnException_ReturnInternalServiceError()
{
ClientService.Invocations.Clear();
var name = "Ivan Ivanov";
var email = "*****@*****.**";
var password = "******";
var requestedName = string.Empty;
var requestedEmail = string.Empty;
var requestedPassword = string.Empty;
var exceptionMessage = "some exception message";
var request = new CreateClientRequest {
Name = name, Email = email, Password = password
};
ClientService.Setup(x => x.CreateClient(It.IsAny <Client>()))
.Callback <Client>((clientParam) =>
{
requestedName = clientParam.Name;
requestedEmail = clientParam.Email;
requestedPassword = clientParam.Password;
})
.Throws(new Exception(exceptionMessage));
var controller = new ClientsController(ClientService.Object)
{
ControllerContext = new ControllerContext {
HttpContext = new DefaultHttpContext()
}
};
var actionResult = controller.Post(request);
var result = actionResult as OkObjectResult;
var result1 = actionResult as ObjectResult;
ClientService.Verify(x => x.CreateClient(It.IsAny <Client>()), Times.Once);
Assert.AreEqual(requestedName, name);
Assert.AreEqual(requestedEmail, email);
Assert.AreEqual(requestedPassword, password);
Assert.IsTrue(result == null);
Assert.IsTrue(result1 != null);
Assert.AreEqual(result1.StatusCode, 500);
Assert.AreEqual(result1.Value, exceptionMessage);
}
