public async Task GetAll_ReturnOk()
{
var customersResponse = new CustomersResponse()
{
Customers = new List <CustomerDto>()
{
new CustomerDto()
{
Id = 1,
Name = "ООО Рога и Копыта"
},
new CustomerDto()
{
Id = 2,
Name = "АО Пивной дворик"
}
}
};
_mockMediator.Setup(mediator => mediator.Send(It.IsAny <GetAllCustomersQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(customersResponse);
var result = await _controller.GetAll();
var resultValue = ((OkObjectResult)result).Value as CustomersResponse;
_mockMediator.Verify(mediator => mediator.Send(It.IsAny <GetAllCustomersQuery>(), It.IsAny <CancellationToken>()), Times.Once);
Assert.Equal(2, resultValue.Customers.Count);
Assert.Equal(1, resultValue.Customers[0].Id);
Assert.Equal("ООО Рога и Копыта", resultValue.Customers[0].Name);
Assert.IsAssignableFrom <IActionResult>(result);
}
private async void ExecuteCustomer()
{
try
{
CustomersResponse customers = await _customerAPI.GetCustomers();
}
catch (Exception ex)
{
new LogJobErrorModel
{
Message = ex.Message,
Area = "Execute Customer",
Date = DateTime.Now,
TypeException = ex.GetType().Name,
StackTrace = ex.StackTrace
};
}
finally
{
new LogJobModel {
Message = "Job Finished", Area = "Execute Customer", Date = DateTime.Now
};
}
}
public static Customer ToCustomer(this CustomersResponse customer)
{
return(new Customer
{
Address = customer.Address,
FirstName = customer.FirstName,
LastName = customer.LastName,
Phone = customer.Phone,
Id = Guid.Parse(customer.Id)
});
}
public override async Task <CustomersResponse> GetCustomersClientStream(IAsyncStreamReader <CustomerRequest> requestStream, ServerCallContext context)
{
CustomersResponse customersResponse = new CustomersResponse();
await foreach (var customerRequest in requestStream.ReadAllAsync())
{
customersResponse.Customer.Add(customerList.FirstOrDefault(customer => customer.Id == customerRequest.CustomerId));
await Task.Delay(TimeSpan.FromSeconds(5));
}
return(customersResponse);
}
public void GetAllCustomersTest()
{
CustomersResponse actualResponse = customer.GetAll();
string expectedResponse = TestHelper.GetJson(TestResource.ExpectedResponse + "AllCustomers.json");
TestHelper.CompareProperties(expectedResponse, actualResponse.JsonResponse());
CustomersResponse expectedObj = JsonConvert.DeserializeObject<CustomersResponse>(expectedResponse);
CustomersResponse actualObj = JsonConvert.DeserializeObject<CustomersResponse>(actualResponse.JsonResponse());
TestHelper.PropertyValuesAreEquals(actualObj, expectedObj);
}
public async Task <IActionResult> ListAsync()
{
CustomersResponse result = await Task.Run(() => _customerService.List());
if (!result.Success)
{
return(BadRequest(result));
}
else
{
return(Ok(result));
}
}
public async Task <IActionResult> LoadCustomers(
[FromQuery] string loginSort,
[FromQuery] string nameSort,
[FromQuery] string emailSort,
[FromQuery] string phoneSort,
[FromQuery] string s,
[FromQuery] int page)
{
if (page <= 0)
{
logger.LogError($"Page is less or equal to zero: {page}");
}
try
{
var sortConditions = GetSortConditions(loginSort, nameSort, emailSort, phoneSort);
var skip = (page - 1) * customersPerPage;
var customers = await customerService
.GetCustomersDtoAsync(sortConditions.Item1, sortConditions.Item2, s, skip, customersPerPage)
.ConfigureAwait(false);
var totalCustomers = await customerService
.CustomersCountTotalAsync()
.ConfigureAwait(false);
var totalFilteredCustomers = totalCustomers;
if (!string.IsNullOrEmpty(s))
{
totalFilteredCustomers = await customerService
.CustomersCountAsync(s)
.ConfigureAwait(false);
}
var response = new CustomersResponse
{
Customers = customers,
TotalCustomers = totalCustomers,
Page = page,
TotalPages = (int)Math.Ceiling((double)totalFilteredCustomers / customersPerPage),
};
return(Ok(response));
}
catch (Exception ex)
{
logger.LogError($"Load customers error: {ex.Message}");
return(BadRequest(ex.Message));
}
}
public void List_All_Customers_Name_of_2nd_Customer()
{
//arrange
ICustomerService customerService = MockDataWithTwoCustomers();
CustomersController customersctrl = new CustomersController(customerService);
//act
var result = customersctrl.ListAsync();
//assert
var response = result.Result as OkObjectResult;
CustomersResponse customersResponse = response.Value as CustomersResponse;
Assert.True(customersResponse.Success);
Assert.Equal(2, customersResponse.Resource.customers.Count);
Assert.Equal("Ajit", customersResponse.Resource.customers[0].name);
}
public async Task <CustomersResponse> GetCustomerListAsync(PaginationFilter validFilter)
{
CustomersResponse response = new CustomersResponse
{
Total = GetCustomersCount()
};
if (response.Total > 0)
{
response.Customers = await _context.Customers.ProjectTo <CustomerModel>(_mapperConfiguration)
.Skip((validFilter.Page - 1) * validFilter.Size)
.Take(validFilter.Size)
.ToListAsync();
}
return(response);
}
public void GetAllCustomers()
{
restClient.Setup(x => x.Execute(It.IsAny <string>(), It.IsAny <RequestOptions>(), It.IsAny <Hashtable>()))
.Returns(new RestResponse()
{
StatusCode = HttpStatusCode.OK,
Content = TestHelper.GetJson(TestResource.MocksPath + "CustomersList.json")
});
customer.ExecuteObj = restClient.Object;
var customers = customer.GetAll();
Fixture fixture = new Fixture();
CustomersResponse sut = fixture.Create <CustomersResponse>();
TestHelper.PropertiesAreEqual(sut, customers.JsonResponse());
}
static async Task Main(string[] args)
{
//Güvenilir olmayan/geçersiz sertifikayla gRPC hizmetini çağırma
HttpClientHandler httpHandler = new HttpClientHandler();
httpHandler.ServerCertificateCustomValidationCallback =
HttpClientHandler.DangerousAcceptAnyServerCertificateValidator;
//Güvenilir olmayan/geçersiz sertifikayla gRPC hizmetini çağırma
GrpcChannel channel = GrpcChannel.ForAddress("https://localhost:5001",
new GrpcChannelOptions {
HttpHandler = httpHandler
});
CustomerClient client = new CustomerClient(channel);
#region Unary
CustomerRequest request = new CustomerRequest {
CustomerId = 1
};
var callUnary = await client.GetCustomerUnaryAsync(request);
Console.WriteLine($"{callUnary.Name} ,{callUnary.Email},{callUnary.Adress},{callUnary.Age}");
#endregion
#region Server Streaming
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
using (var callServerStream = client.GetCustomerServerStream(new Empty()))
{
while (await callServerStream.ResponseStream.MoveNext(cancellationTokenSource.Token))
{
//herhangi bir yerde iptal tokene gönderebiliriz
//cancellationTokenSource.Cancel();
CustomerResponse currentCustomer = callServerStream.ResponseStream.Current;
Console.WriteLine($"{currentCustomer.Name} ,{currentCustomer.Email},{currentCustomer.Adress},{currentCustomer.Age}");
}
}
#endregion
#region Client Streaming
using (var callClientStream = client.GetCustomersClientStream())
{
for (int i = 1; i <= 3; i++)
{
await callClientStream.RequestStream.WriteAsync(new CustomerRequest { CustomerId = i });
}
await callClientStream.RequestStream.CompleteAsync();// steam'i bitirdik
CustomersResponse response = await callClientStream;
foreach (var customer in response.Customer)
{
Console.WriteLine($"{customer.Name} ,{customer.Email},{customer.Adress},{customer.Age}");
}
}
#endregion
#region Bi-Directional Streaming
CancellationTokenSource cancellationTokenSource2 = new CancellationTokenSource();
using (var callBiDirectionalStream = client.GetCustomersBiDirectionalStream())
{
Console.WriteLine("Başla");
var readTask = Task.Run(async() =>
{
while (await callBiDirectionalStream.ResponseStream.MoveNext(cancellationTokenSource.Token))
{
Console.WriteLine(callBiDirectionalStream.ResponseStream.Current);
}
});
for (int i = 1; i <= 3; i++)
{
await callBiDirectionalStream.RequestStream.WriteAsync(new CustomerRequest { CustomerId = i });
await Task.Delay(TimeSpan.FromSeconds(2));
}
await callBiDirectionalStream.RequestStream.CompleteAsync();
await readTask;
Console.WriteLine("Bitir");
}
#endregion
Console.ReadLine();
}
Func <AccountsResponse, CustomersResponse> GetResponse(IEnumerable <Customer> customers) => response => CustomersResponse.Create(Map(customers, response.Accounts));
