public void Sort_Products_ShouldSortListOfProductsInAscendingOrder()
{
// Arrange
var productBuider = new ProductBuilder();
productBuider.SetConsumption(3500);
var result3500 = productBuider.Build();
productBuider.SetConsumption(4500);
var result4500 = productBuider.Build();
productBuider.SetConsumption(6000);
var result6000 = productBuider.Build();
Product [] products = new Product[] {
result3500[0],
result3500[1],
result4500[0],
result4500[1],
result6000[0],
result6000[1]
};
// Act
Array.Sort(products, new ProductComparer <Product>());
// Assert
Assert.Equal(800, products[0].AnnualCosts);
Assert.Equal(830, products[1].AnnualCosts);
Assert.Equal(950, products[2].AnnualCosts);
Assert.Equal(1050, products[3].AnnualCosts);
Assert.Equal(1380, products[4].AnnualCosts);
Assert.Equal(1400, products[5].AnnualCosts);
}
public void inserts_are_batched()
{
using (var session = SessionFactory.OpenStatelessSession())
using (var transaction = session.BeginTransaction())
{
session.SetBatchSize(2);
var builder = new ProductBuilder();
session.Insert(builder.Build());
session.Insert(builder.Build());
Logger.Info("the first batch of 2 inserts has been sent to the database now");
session.Insert(builder.Build());
session.Insert(builder.Build());
Logger.Info("the second batch of 2 inserts has been sent to the database now, without flushing the session");
transaction.Commit();
}
}
public List <Product> GetProducts(ISearchParameters parameters)
{
var searchBuilder = new ProductBuilder(parameters);
var predicate = searchBuilder.Build();
return(parameters.EmptyParameters
? _context.Products.ToList()
: _context.Products
.Where(predicate)
.ToList());
}
public void DefaultBuildedProductValues()
{
ProductBuilder builderTest = new ProductBuilder(TEST_ID, TEST_NAME);
Product expectedProduct = new Product(TEST_ID, TEST_NAME, ProductSize.Medium, new Price(0, Currency.USD), Color.RED);
Product factoryOutput = builderTest.Build();
Assert.Equal(expectedProduct.ID, factoryOutput.ID);
Assert.Equal(expectedProduct.Name, factoryOutput.Name);
Assert.Equal(expectedProduct.Size, factoryOutput.Size);
Assert.Equal(expectedProduct.Price.Value, factoryOutput.Price.Value);
Assert.Equal(expectedProduct.Price.Currency, factoryOutput.Price.Currency);
Assert.Equal(expectedProduct.Color, factoryOutput.Color);
}
public void should_create_a_product_properly()
{
var product = _productBuilder.Build();
product.Title.Should().Be(_productBuilder.ProductOptions.ProductTitle);
product.EnglishTitle.Should().Be(_productBuilder.ProductOptions.ProductEnglishTitle);
product.Overview.AtAGlance.Should().Be(_productBuilder.ProductOptions.AtAGlance);
product.Overview.Description.Should().Be(_productBuilder.ProductOptions.Description);
product.IsActive.Should().Be(_productBuilder.ProductOptions.IsActive);
product.BrandId.Should().Be(_productBuilder.ProductOptions.BrandId);
}
public void Build_Products_ShouldCreateListOfProducts(long consumption,
long expectedAnnualConstsBasic,
int expectedAnnualConstsPackaged)
{
// Arrange
var productBuider = new ProductBuilder();
productBuider.SetConsumption(consumption);
// Act
Product [] products = productBuider.Build();
// Assert
Assert.Equal(2, products.Length);
Assert.Equal(expectedAnnualConstsBasic, products[0].AnnualCosts);
Assert.Equal(expectedAnnualConstsPackaged, products[1].AnnualCosts);
}
public void Sort_Products_ShouldSortProductsInAscendingOrder(long consumption,
long expectedAnnualConstsBasic,
int expectedAnnualConstsPackaged)
{
// Arrange
var productBuider = new ProductBuilder();
productBuider.SetConsumption(consumption);
// Act
Product [] products = productBuider.Build();
Array.Sort(products, new ProductComparer <Product>());
// Assert
Assert.Equal(2, products.Length);
Assert.Equal(expectedAnnualConstsBasic, products[0].AnnualCosts);
Assert.Equal(expectedAnnualConstsPackaged, products[1].AnnualCosts);
}
public void TestProductBuilder()
{
ProductBuilder builder = new ProductBuilder();
builder.Build("Biscuits", "Tuc", -1, 2);
}
public async Task <(IEnumerable <Product>, IEnumerable <string>)> ProcessStreamAsync(Stream stream)
{
using (var reader = new StreamReader(stream, new UTF8Encoding(false, true), true))
{
const char separator = ',';
string[] header = (await reader.ReadLineAsync()).Split(separator);
int keyIndex = header.IndexOf("Key");
int articleCodeIndex = header.IndexOf("ArtikelCode");
int colourCodeIndex = header.IndexOf("ColorCode");
int descriptionIndex = header.IndexOf("Description");
int priceIndex = header.IndexOf("Price");
int discountPriceIndex = header.IndexOf("DiscountPrice");
int deliveryTimeIndex = header.IndexOf("DeliveredIn");
int groupIndex = header.IndexOf("Q1");
int sizeIndex = header.IndexOf("Size");
int colourIndex = header.IndexOf("Color");
var count = 0;
var errors = new List <string>();
var products = new List <Product>();
var productBuilder = new ProductBuilder();
return(await Task.Run(async() =>
{
while (!reader.EndOfStream)
{
count++;
string[] line = (await reader.ReadLineAsync()).Split(separator);
if (line.Length == 10)
{
try
{
var inputData = new InputData
{
Key = line[keyIndex],
ArticleCode = line[articleCodeIndex],
ColourCode = line[colourCodeIndex],
Description = line[descriptionIndex],
Price = line[priceIndex],
DiscountPrice = line[discountPriceIndex],
DeliveryTime = line[deliveryTimeIndex],
Group = line[groupIndex],
Size = line[sizeIndex],
Colour = line[colourIndex]
};
products.Add(productBuilder.Build(inputData));
}
catch (FormatException e)
{
errors.Add($"Error parsing line {count}: {e.Message}");
}
catch (IndexOutOfRangeException e)
{
throw new ProcessorException("Error processing the header of the input stream.", e);
}
}
else
{
errors.Add($"Error parsing line {count}: Insufficient number of values.");
}
}
return (products, errors);
}));
}
}