public async Task Return_Ok_When_ProductsFound()
{
var expectedProduct = new GetProductsResponse(1, "product1", 10);
_getProductsHandler
.Setup(g => g.GetAll())
.ReturnsAsync(new List <GetProductsResponse> {
expectedProduct
});
var response = await _productsController.GetAll();
Assert.Multiple(() =>
{
var result = (OkObjectResult)response;
var content = result.Value as List <GetProductsResponse>;
Assert.IsNotNull(content);
Assert.AreEqual((int)HttpStatusCode.OK, result.StatusCode);
var responseProduct = content.FirstOrDefault();
Assert.IsNotNull(responseProduct);
Assert.AreEqual(expectedProduct.Id, responseProduct.Id);
Assert.AreEqual(expectedProduct.Description, responseProduct.Description);
Assert.AreEqual(expectedProduct.CookTime, responseProduct.CookTime);
});
}
public GetProductsResponse GetProducts()
{
GetProductsResponse response = new GetProductsResponse();
//response.Product =
throw new NotImplementedException();
}
/// <summary>
/// Unmarshaller the response from the service to the response class.
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context)
{
GetProductsResponse response = new GetProductsResponse();
context.Read();
int targetDepth = context.CurrentDepth;
while (context.ReadAtDepth(targetDepth))
{
if (context.TestExpression("FormatVersion", targetDepth))
{
var unmarshaller = StringUnmarshaller.Instance;
response.FormatVersion = unmarshaller.Unmarshall(context);
continue;
}
if (context.TestExpression("NextToken", targetDepth))
{
var unmarshaller = StringUnmarshaller.Instance;
response.NextToken = unmarshaller.Unmarshall(context);
continue;
}
if (context.TestExpression("PriceList", targetDepth))
{
var unmarshaller = new ListUnmarshaller <string, StringUnmarshaller>(StringUnmarshaller.Instance);
response.PriceList = unmarshaller.Unmarshall(context);
continue;
}
}
return(response);
}
public async Task Handle_If_Request_Is_Null_Should_Return_Unsuccesful_Response()
{
GetProductsResponse useCaseResponse = null;
// Mock dependencies
var mockGetExtensions = new Mock <IGetPagedListFromRepository <Product> >();
var mockResponsesMessagesSettings = new Mock <IOptions <Dto.ResponsesSettings> >();
var mockOutput = new Mock <UseCases.IOutputPort <GetProductsResponse> >();
// Setup
mockResponsesMessagesSettings
.Setup(x => x.Value)
.Returns(TestsConfigurationHelper.ResponsesSettings);
mockOutput
.Setup(x => x.Handle(It.IsAny <GetProductsResponse>()))
.Callback((GetProductsResponse response) =>
{
useCaseResponse = response;
});
// Arrange
var useCase = new GetProductsUseCase(
mockGetExtensions.Object,
mockResponsesMessagesSettings.Object);
GetProductsRequest request = null;
// Act
var result = await useCase.Handle(request, mockOutput.Object);
// Assert
Assert.False(result);
Assert.Contains(useCaseResponse.Errores, x => x.Codigo == nameof(TestsConfigurationHelper.ResponsesSettings.RequestMissingErrorMessage));
}
// Added By zafari
public GetProductsResponse GetProducts(AjaxGetRequest request)
{
GetProductsResponse response = new GetProductsResponse();
try
{
int index = (request.PageNumber - 1) * request.PageSize;
int count = request.PageSize;
Infrastructure.Domain.Response <Product> productsResponse = _productRepository
.FindAll(index, count);
IEnumerable <ProductView> products = productsResponse.data
.ConvertToProductViews();
response.ProductViews = products;
response.Count = productsResponse.totalCount;
}
catch (Exception ex)
{
throw;
}
return(response);
}
public GetProductsResponse GetProducts()
{
GetProductsResponse response = new GetProductsResponse();
try
{
List <Material> materials = (List <Material>)_materialRepo.GetMaterials();
if (materials.Count == 0)
{
response.Success = false;
response.Message = "Error: failed to load products. Please contact IT.";
}
else
{
response.Success = true;
response.Materials = materials;
}
}
catch
{
response.Success = false;
response.Message = "Error: failed to load products. Please contact IT.";
}
return(response);
}
public void TestGetProducts()
{
int productId = 1;
GetProductsResponse response = new GetProductsResponse();
response.Products.Add(new ProductDTO()
{
Id = productId
});
Expect.Once.On(service).Method("GetProductsByCriteria").Will(Return.Value(response));
IList <ProductDTO> products = serviceFacade.GetProductsByCategory("FakeCategory");
Assert.AreEqual(1, products.Count);
Assert.AreEqual(products.First().Id, productId);
Expect.Once.On(service).Method("GetProductsByCriteria").Will(Return.Value(response));
products = serviceFacade.GetProductsByName("FAkeName");
Assert.AreEqual(1, products.Count);
Assert.AreEqual(products.First().Id, productId);
Expect.Once.On(service).Method("GetProductsByCriteria").Will(Return.Value(response));
products = serviceFacade.GetAllProducts();
Assert.AreEqual(1, products.Count);
Assert.AreEqual(products.First().Id, productId);
}
public override void Invoke(AWSCredentials creds, RegionEndpoint region, int maxItems)
{
AmazonPricingConfig config = new AmazonPricingConfig();
config.RegionEndpoint = region;
ConfigureClient(config);
AmazonPricingClient client = new AmazonPricingClient(creds, config);
GetProductsResponse resp = new GetProductsResponse();
do
{
GetProductsRequest req = new GetProductsRequest
{
NextToken = resp.NextToken
,
MaxResults = maxItems
};
resp = client.GetProducts(req);
CheckError(resp.HttpStatusCode, "200");
foreach (var obj in resp.FormatVersion)
{
AddObject(obj);
}
foreach (var obj in resp.PriceList)
{
AddObject(obj);
}
}while (!string.IsNullOrEmpty(resp.NextToken));
}
public void GetProductsNoProducts()
{
m_Utils.CreateAndSetNewContext();
m_Utils.ActivateContext(0);
GetProductsResponse getProductsResp = m_Utils.GetProducts(0);
Assert.AreEqual(0, getProductsResp.Products.Count);
}
public Task <GetProductsResponse> GetProductsAsync(GetProductsRequest request)
{
var response = new GetProductsResponse
{
Products = _products
};
return(Task.FromResult(response));
}
// Set the workflow status.
public void setWorkFlowStatus(ErrorIndexType indexType, bool resetService)
{
// Add a context.
CreateNewStackHashContextResponse resp = m_Utils.CreateNewContext(indexType);
String testPath = "c:\\stackhashunittests\\testindex\\";
resp.Settings.ErrorIndexSettings.Folder = testPath;
resp.Settings.ErrorIndexSettings.Name = "TestIndex";
m_Utils.SetContextSettings(resp.Settings);
m_Utils.DeleteIndex(0); // Make sure it is empty.
m_Utils.ActivateContext(0);
// Create a test index with one cab file.
StackHashTestIndexData testIndexData = new StackHashTestIndexData();
testIndexData.NumberOfProducts = 1;
testIndexData.NumberOfFiles = 1;
testIndexData.NumberOfEvents = 1;
testIndexData.NumberOfEventInfos = 0;
testIndexData.NumberOfCabs = 0;
m_Utils.CreateTestIndex(0, testIndexData);
GetProductsResponse getProductsResp = m_Utils.GetProducts(0);
Assert.AreEqual(1, getProductsResp.Products.Count());
GetFilesResponse allFiles = m_Utils.GetFiles(0, getProductsResp.Products[0].Product);
Assert.AreEqual(1, allFiles.Files.Count());
GetProductEventPackageResponse allEvents = m_Utils.GetProductEventPackages(0, getProductsResp.Products[0].Product);
Assert.AreEqual(1, allEvents.EventPackages.Count());
// Set the workflow status
int workFlowStatus = 10;
m_Utils.SetWorkFlowStatus(0, getProductsResp.Products[0].Product, allFiles.Files[0], allEvents.EventPackages[0].EventData, workFlowStatus);
if (resetService)
{
m_Utils.RestartService();
}
allEvents = m_Utils.GetProductEventPackages(0, getProductsResp.Products[0].Product);
Assert.AreEqual(1, allEvents.EventPackages.Count());
Assert.AreEqual(workFlowStatus, allEvents.EventPackages[0].EventData.WorkFlowStatus);
Assert.AreEqual("Resolved - Responded", allEvents.EventPackages[0].EventData.WorkFlowStatusName);
m_Utils.DeactivateContext(0);
m_Utils.DeleteIndex(0);
}
public GetProductsResponse GetProductsByCriteria(GetProductsRequest request)
{
GetProductsResponse response = new GetProductsResponse();
ProductBusinessComponent bc = DependencyInjectionHelper.GetProductBusinessComponent();
IQueryable <Product> products = bc.GetProductsByCriteria(request.SearchType, request.Category, request.ProductName);
response.Products = ProductAdapter.ProductsToDtos(products);
return(response);
}
public async Task <GetProductsResponse> GetSummary()
{
var response = new GetProductsResponse();
var countInInventory = await _context.Products.CountAsync(p => p.InInventory);
var countOutOfInventory = await _context.Products.CountAsync(p => !p.InInventory);
response.NumberOfProductsInInventory = countInInventory;
response.NumberOfProductsOutOfStock = countOutOfInventory;
response.NumberOfProductsAddedToday = new Random().Next(12, 300);
return(response);
}
public override Task <GetProductsResponse> GetProducts(GetProductsRequest request, ServerCallContext context)
{
var products = _productService.Get().Select(x => new ProductMessage
{
Id = x.Id.ToString(),
Code = x.Code,
Name = x.Name,
Description = x.Description
});
var rp = new GetProductsResponse();
rp.Products.AddRange(products);
return(Task.FromResult(rp));
}
public GetProductsResponse GetProductByCriteria(GetProductsRequest request)
{
if (!HttpContext.Current.User.Identity.IsAuthenticated)
{
throw new FaultException <NotAuthenticatedFault>(new NotAuthenticatedFault());
}
GetProductsResponse response = new GetProductsResponse();
ProductBusinessComponent bc = DependencyInjectionHelper.GetProductBusinessComponent();
IQueryable <Product> products = bc.GetProductsByCriteria(request.SearchType, request.Category, request.ProductName);
response.Products = ProductAdapter.ProductsToDtos(products);
return(response);
}
public async Task <ActionResult> GetProducts([FromQuery] string category = null)
{
if (category == null)
{
GetProductsResponse response = await _productsService.GetSummary();
return(Ok(response));
}
else
{
GetProductListSummary response = await _productsService.GetSummaryList(category);
return(Ok(response));
}
}
public async Task <GetProductsResponse> ObsoleteGetAllAsync([FromQuery] ObsoleteGetProductsRequest request, int skip = default, int take = 20)
{
// if take == 0 return all rows
var result = take == default
? await _productsService.GetAllAsync(request?.MdsCodes, request?.ProductIds, request?.IsStarted)
: await _productsService.GetByPageAsync(request?.MdsCodes, request?.ProductIds, request?.IsStarted, isDiscontinued : null, skip : skip, take : take);
var response = new GetProductsResponse
{
Products = result.Value
.Select(p => _convertService.Convert <Product, ProductContract>(p))
.ToList()
};
return(response);
}
private static Material GetProduct(Manager manager)
{
bool validProduct = false;
Material product = null;
while (!validProduct)
{
Console.Clear();
ConsoleIO.TitleHeader("Add an Order");
Console.WriteLine("(Step 4 of 5)\n");
GetProductsResponse getProductResponse = manager.GetProducts();
if (getProductResponse.Success)
{
ConsoleIO.PrintProducts(getProductResponse.Materials);
}
else
{
Console.WriteLine(getProductResponse.Message);
Console.Write("Press any key to continue...");
Console.ReadKey();
}
string userProductInput = ConsoleIO.GetProductFromUser();
CheckProductResponse checkProdResponse = manager.CheckForRequestedProduct(userProductInput);
if (checkProdResponse.Success == true)
{
validProduct = true;
product = checkProdResponse.Product;
}
else
{
Console.Clear();
Console.WriteLine(checkProdResponse.Message);
Console.Write("Press any key to retry...");
Console.ReadKey();
}
if (validProduct)
{
validProduct = ConsoleIO.ConsoleKeyConfirmationSwitch($"Entered product is ({userProductInput}).", false);
}
}
return(product);
}
public GetProductsResponse GetProducts(GetProductsRequest request)
{
var response = new GetProductsResponse();
try
{
response.Products = ModelTranslator.Translate(BLL.Product.GetProductList());
response.Success = true;
}
catch (Exception ex)
{
response.Success = false;
response.ErrorMessage = ex.ToString();
}
return(response);
}
public GetProductsResponse GetProducts()
{
GetProductsResponse response = new GetProductsResponse();
try
{
IEnumerable <ProductView> products = _productRepository.FindAll()
.ConvertToProductViews();
response.ProductViews = products;
}
catch (Exception ex)
{
throw;
}
return(response);
}
/// <summary>
/// Gets the product data associated with a particular context.
/// </summary>
/// <returns>Response result code.</returns>
public GetProductsResponse GetProducts(GetProductsRequest requestData)
{
if (requestData == null)
{
throw new ArgumentNullException("requestData");
}
GetProductsResponse resp = new GetProductsResponse();
StackHashProductInfoCollection products =
StaticObjects.TheStaticObjects.TheController.GetProducts(requestData.ContextId);
resp.Products = products;
resp.ResultData = new StackHashServiceResultData(
StackHashServiceResult.Success, s_OperationSuccessful, null);
return(resp);
}
// Get the
public void getCabPackage(ErrorIndexType indexType)
{
// Add a context.
CreateNewStackHashContextResponse resp = m_Utils.CreateNewContext(indexType);
String testPath = "c:\\stackhashunittests\\testindex\\";
resp.Settings.ErrorIndexSettings.Folder = testPath;
resp.Settings.ErrorIndexSettings.Name = "TestIndex";
m_Utils.SetContextSettings(resp.Settings);
m_Utils.DeleteIndex(0); // Make sure it is empty.
m_Utils.ActivateContext(0);
// Create a test index with one cab file.
StackHashTestIndexData testIndexData = new StackHashTestIndexData();
testIndexData.NumberOfProducts = 1;
testIndexData.NumberOfFiles = 1;
testIndexData.NumberOfEvents = 1;
testIndexData.NumberOfEventInfos = 0;
testIndexData.NumberOfCabs = 1;
m_Utils.CreateTestIndex(0, testIndexData);
GetProductsResponse getProductsResp = m_Utils.GetProducts(0);
Assert.AreEqual(1, getProductsResp.Products.Count());
GetFilesResponse allFiles = m_Utils.GetFiles(0, getProductsResp.Products[0].Product);
Assert.AreEqual(1, allFiles.Files.Count());
GetProductEventPackageResponse allEvents = m_Utils.GetProductEventPackages(0, getProductsResp.Products[0].Product);
Assert.AreEqual(1, allEvents.EventPackages.Count());
Assert.AreEqual(1, allEvents.EventPackages[0].Cabs.Count);
// Get the Cab package.
GetCabPackageResponse cabPackageResp = m_Utils.GetCabPackage(0, getProductsResp.Products[0].Product, allFiles.Files[0], allEvents.EventPackages[0].EventData,
allEvents.EventPackages[0].Cabs[0].Cab);
Assert.AreEqual("c:\\stackhashunittests\\testindex\\TestIndex\\00\\00\\00\\00\\CAB_0000000001\\1-Crash 32bit-0.cab", cabPackageResp.CabPackage.FullPath);
}
public GetProductsResponse GetProducts()
{
var productRes = new GetProductsResponse();
using (context)
{
try
{
productRes.Products = context.Products.ToList();
productRes.Success = true;
}
catch (Exception ex)
{
productRes.Success = false;
productRes.ErrorMessage = $"An error has occured {ex.Message} {ex.InnerException}";
}
return(productRes);
}
}
public virtual async Task <GetProductsResponse> GetProducts(GetProductsRequest request, CancellationToken cancellationToken = default(CancellationToken))
{
var response = new GetProductsResponse();
try
{
var serviceResult = await _options.GetProducts.WithHeader("Cache-Control", "no-cache")
.SetQueryParams(request)
.GetAsync(cancellationToken);
response = JsonConvert.DeserializeObject <GetProductsResponse>(serviceResult.Content.ReadAsStringAsync().Result);
}
catch (Exception ex)
{
throw ex;
}
return(response);
}
public async Task <ActionResult> GetProduction()
{
//var response = new GetProductsResponse(
// new List<GetProductResponseItem>
// {
// new GetProductResponseItem(1, "eggs", 2.39M),
// new GetProductResponseItem(1, "bread", 2.39M),
// new GetProductResponseItem(1, "beer", 7.39M)
// }
// );
var items = await _context.Products
.Select(product => new GetProductResponseItem(product.Id, product.Name, product.Price))
.ToListAsync();
GetProductSummary summary = _summarizer.GetSummaryFor(items);
var response = new GetProductsResponse(items, summary);
return(Ok(response));
}
private IList <ProductDTO> getProducts(ProductSearchType searchType, string name, string category)
{
try
{
GetProductsRequest request = new GetProductsRequest();
request.SearchType = searchType;
request.ProductName = name;
request.Category = category;
GetProductsResponse response = Service.GetProductsByCriteria(request);
return(response.Products);
}
catch (Exception ex)
{
if (ExceptionPolicy.HandleException(ex, "PL Policy"))
{
throw;
}
return(new List <ProductDTO>());
}
}
public async Task <GetProductsResponse> GetProductsAsync(GetProductRequest request)
{
var response = new GetProductsResponse {
Code = 200
};
try
{
var result = await this.gateway.GetProductsAsync(request.Product.AsEntity());
response.Products = result.AsResponseList();
}
catch (Exception ex)
{
this.logger.LogError(ex.Message);
response.Code = 500;
}
return(response);
}
public async Task <GetProductsResponse> GetAllAsync([FromBody] GetProductsRequest request)
{
var result = request.Take == default
? await _productsService.GetAllAsync(request.MdsCodes, request.ProductIds, request.IsStarted)
: await _productsService.GetByPageAsync(request.MdsCodes,
request.ProductIds,
request.IsStarted,
request.IsDiscontinued,
request.Skip,
request.Take);
var response = new GetProductsResponse
{
Products = result.Value
.Select(p => _convertService.Convert <Product, ProductContract>(p))
.ToList()
};
return(response);
}
public async Task Handle_If_FilterTerm_Is_Provided_Should_Return_Successful_Response_With_Filtered_Products()
{
GetProductsResponse useCaseResponse = null;
var allProducts = TestModelFactory.GetProductSample();
var filterTerm = "brand";
// Mock dependencies
var mockGetProducts = new Mock <IGetPagedListFromRepository <Product> >();
var mockResponsesMessagesSettings = new Mock <IOptions <Dto.ResponsesSettings> >();
var mockOutput = new Mock <UseCases.IOutputPort <GetProductsResponse> >();
// Setup
mockResponsesMessagesSettings
.Setup(x => x.Value)
.Returns(TestsConfigurationHelper.ResponsesSettings);
mockOutput
.Setup(x => x.Handle(It.IsAny <GetProductsResponse>()))
.Callback((GetProductsResponse response) =>
{
useCaseResponse = response;
});
mockGetProducts
.Setup(x => x.GetProducts(It.IsAny <PageParameters>(), It.IsAny <string>()))
.ReturnsAsync(new BaseGatewayResponse <PagedList <Product> >(allProducts));
// Arrange
var useCase = new GetProductsUseCase(
mockGetProducts.Object,
mockResponsesMessagesSettings.Object);
var request = new GetProductsRequest(new PageParameters(), filterTerm);
// Act
var result = await useCase.Handle(request, mockOutput.Object);
// Assert
Assert.True(result);
Assert.Equal(useCaseResponse.Products.Count(), allProducts.Count());
}
public async Task Handle_If_Filter_Term_Is_Invalid_Should_Return_Unsuccessful_Response()
{
GetProductsResponse useCaseResponse = null;
var allProducts = TestModelFactory.GetProductSample();
// Mock dependencies
var mockGetProducts = new Mock <IGetPagedListFromRepository <Product> >();
var mockResponsesMessagesSettings = new Mock <IOptions <Dto.ResponsesSettings> >();
var mockOutput = new Mock <UseCases.IOutputPort <GetProductsResponse> >();
// Setup
mockResponsesMessagesSettings
.Setup(x => x.Value)
.Returns(TestsConfigurationHelper.ResponsesSettings);
mockOutput
.Setup(x => x.Handle(It.IsAny <GetProductsResponse>()))
.Callback((GetProductsResponse response) =>
{
useCaseResponse = response;
});
mockGetProducts
.Setup(x => x.GetProducts(It.IsAny <PageParameters>(), It.IsAny <string>()))
.ReturnsAsync(new BaseGatewayResponse <PagedList <Product> >(allProducts));
// Arrange
var useCase = new GetProductsUseCase(
mockGetProducts.Object,
mockResponsesMessagesSettings.Object);
var request = new GetProductsRequest(new PageParameters(), "&ASDG%&/");
// Act
var result = await useCase.Handle(request, mockOutput.Object);
// Assert
Assert.False(result);
Assert.Contains(useCaseResponse.Errores, x => x.Codigo == nameof(TestsConfigurationHelper.ResponsesSettings.InvalidParamErrorMessage));
}
