public void TestAddOrUpdateOrderLine()
{
IOC.UnitTest();
var productDiscount = DefaultFactoriesAndSharedFunctionality.CreateProductDiscountPercentage(36);
productDiscount.RangesString = new List <Range> {
new Range {
From = 1, To = 20, PriceInCents = 10000
}
}.ToRangesString();
var product = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(5000, 5, productDiscount);
var order = DefaultFactoriesAndSharedFunctionality.CreateIncompleteOrderInfo(product);
Assert.IsTrue(productDiscount.Ranges.Any());
Assert.AreEqual(10000, productDiscount.RangedDiscountValue(15));
Assert.AreEqual(100, product.DiscountPercentage);
Assert.AreEqual(0, order.OrderLineTotalInCents);
IOC.ProductService.SetupNewMock().Setup(m => m.GetById(1234, It.IsAny <ILocalization>(), It.IsAny <bool>())).Returns(new Product {
Id = 1234, UseVariantStock = true
});
var orderUpdatingService = IOC.OrderUpdatingService.Actual().Resolve();
// todo: actually make the update productinfo functionality testable..
//orderUpdatingService.AddOrUpdateOrderLine(order, 0, 1234, "update", 15, new List<int>());
}
public void Setup()
{
IOC.UnitTest();
IOC.DiscountCalculationService.Actual();
IOC.SettingsService.InclVat();
IOC.OrderDiscountService.Actual();
}
public void Setup()
{
IOC.UnitTest();
_contentServiceMock = new IOCBuilder <IContentService>().SetupNewMock(); // IOC.ContentService.SetupNewMock();
_mockContentTypeService = new IOCBuilder <IContentTypeService>().SetupNewMock(); //IOC.ContentTypeService.SetupNewMock();
var productInfo = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(995, 1);
productInfo.DocTypeAlias = "uwbsProductCustom";
productInfo.Title = "Nikes";
_orderInfo = DefaultFactoriesAndSharedFunctionality.CreateOrderInfo(productInfo);
_orderInfo.OrderNumber = "2013001";
var contentType = new ContentType(1)
{
Id = 1234
};
_mockContentTypeService.Setup(m => m.GetContentType(Order.OrderRepositoryNodeAlias)).Returns(contentType);
_contentServiceMock.Setup(m => m.GetContentOfContentType(1234)).Returns(new List <IContent> {
new Content("", 1, contentType)
});
_contentServiceMock.Setup(m => m.GetChildren(It.IsAny <int>())).Returns(new List <IContent>());
_contentServiceMock.Setup(m => m.CreateContent("2013001", It.IsAny <IContent>(), It.IsAny <string>(), It.IsAny <int>())).Returns(new Content("2013001", 1, contentType));
_contentServiceMock.Setup(m => m.CreateContent("Nikes", It.IsAny <IContent>(), It.IsAny <string>(), It.IsAny <int>())).Returns(new Content("Nikes", 1, contentType));
}
public void UpdatingAnOrderlineShouldBeReflectedInAmount()
{
IOC.UnitTest();
var orderUpdateService = IOC.OrderUpdatingService.Actual().Resolve();
var productInfo = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(1000, 1);
productInfo.Id = 5678;
productInfo.Vat = 10;
var order = DefaultFactoriesAndSharedFunctionality.CreateIncompleteOrderInfo(productInfo);
var line = order.OrderLines.Single();
Assert.AreEqual(1000, order.GetAmount(true, false, false));
Assert.AreEqual(1000, line.GetAmount(true, false, false));
Assert.AreEqual(909, order.GetAmount(false, false, false));
var basket = Basket.CreateBasketFromOrderInfo(order);
Assert.AreEqual(1000, basket.ChargedOrderAmount.ValueInCents);
orderUpdateService.AddOrUpdateOrderLine(order, 0, 5678, "update", 2, new int[0]);
Assert.AreEqual(1, order.OrderLines.Count);
Assert.AreEqual(2, productInfo.Quantity);
Assert.AreEqual(2, line.SellableUnits.Count());
Assert.AreEqual(2000, line.GetAmount(true, false, false));
Assert.AreEqual(2000, order.GetAmount(true, false, false));
basket = Basket.CreateBasketFromOrderInfo(order);
Assert.AreEqual(2000, basket.ChargedOrderAmount.ValueInCents);
}
public void BasicTests()
{
IOC.UnitTest();
IOC.SettingsService.ExclVat();
var productInfo = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(1000, 1);
productInfo.Id = 5678;
productInfo.Vat = 10;
var order = DefaultFactoriesAndSharedFunctionality.CreateIncompleteOrderInfo(productInfo);
var line = order.OrderLines.Single();
Assert.AreEqual(1000, order.GetAmount(false, false, false));
Assert.AreEqual(1000, line.GetAmount(false, false, false));
Assert.AreEqual(1100, order.GetAmount(true, false, false));
Assert.AreEqual(1100, line.GetAmount(true, false, false));
Assert.AreEqual(1100, order.ChargedAmountInCents);
Assert.AreEqual(1100, order.GrandtotalInCents);
Assert.AreEqual(1000, order.SubtotalInCents);
var basket = Basket.CreateBasketFromOrderInfo(order);
Assert.AreEqual(1100, basket.ChargedOrderAmount.ValueInCents);
}
public void Current_ShouldReturnValueFromService()
{
IOC.UnitTest();
//var service = MockConstructors.CreateMockUwebshopRequestService();
//IOC.UwebshopRequestService.Use(service);
Assert.AreEqual(UwebshopRequest.Service.Current, UwebshopRequest.Current);
}
public void Setup()
{
IOC.UnitTest();
IOC.ProductRepository.Mock(out _productRepositoryMock);
_productService = IOC.ProductService.Actual().Resolve();
_localization = StubLocalization.Default;
_productRepositoryMock.Setup(m => m.GetAll(_localization)).Returns(new List <Product>());
}
public void Setup()
{
IOC.UnitTest();
_storeUrlService = IOC.StoreUrlService.SetupNewMock();
_service = IOC.StoreFromUrlDeterminationService.Actual().Resolve();
SetUrlsWithDomain(Enumerable.Empty <string>());
SetUrlsWithoutDomain(Enumerable.Empty <string>());
}
public void Setup()
{
IOC.UnitTest();
_requestParameters = new NameValueCollection();
_basketRequestHandler = new BasketRequestHandler();
IOC.OrderUpdatingService.Mock(out _mock);
}
public void Setup()
{
IOC.UnitTest();
_discountCalculationService = IOC.DiscountCalculationService.Actual().Resolve();
_product = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(1000, 1);
_product.Tags = new [] { "schoen" };
_order = DefaultFactoriesAndSharedFunctionality.CreateIncompleteOrderInfo(_product);
}
public void ObjectsByAlias_ShouldCallCMSEntityRepository()
{
IOC.UnitTest();
IOC.CMSEntityRepository.Mock(out _cmsEntityRepository);
DomainHelper.GetObjectsByAlias <DomainHelperTests>(string.Empty);
_cmsEntityRepository.Verify(m => m.GetObjectsByAlias <DomainHelperTests>(string.Empty, It.IsAny <ILocalization>(), 0));
}
public void SetUp()
{
IOC.UnitTest();
IOC.SettingsService.InclVat();
IOC.OrderDiscountService.Actual();
//IOC.Config<IDiscountCalculator>().Actual();
//IOC.DiscountCalculator.Actual(); _discountCalculator = IOC.DiscountCalculator.Resolve();
_discountCalculationService = IOC.DiscountCalculationService.Actual().Resolve();
}
public void Setup()
{
IOC.UnitTest();
_product = new Product {
UrlName = "prod", Categories = new API.ICategory[] { new StubCategory() }
};
IOC.CategoryCatalogUrlService.SetupNewMock().Setup(m => m.GetCanonicalUrl(It.IsAny <ICategory>())).Returns("[catname]");
_productUrlService = IOC.ProductUrlService.Actual().Resolve();
}
public void TestSummedPrice()
{
IOC.UnitTest();
var basePriceMock = new Mock <IDiscountedRangedPrice>();
var price = new SummedPrice(new[] { basePriceMock.Object }, true, 19, StoreHelper.CurrentLocalization, IOC.VatCalculationStrategy.Resolve());
var a = price.Discount;
basePriceMock.VerifyGet(m => m.Discount);
}
public void Setup()
{
IOC.UnitTest();
IOC.CMSApplication.Mock(out _cmsApplicationMock);
IOC.StoreUrlService.UseType <UmbracoStorePickerStoreUrlService>();
IOC.StoreUrlRepository.Actual();
_store = new Store {
Id = StoreId
};
}
public void LoadData_ShouldCallReloadDataOnRepository()
{
IOC.UnitTest();
var mock = IOC.PaymentProviderRepository.SetupNewMock();
var paymentProvider = new PaymentProvider(1234);
IOC.PaymentProviderService.Actual().Resolve().LoadData(paymentProvider, Stubs.StubLocalization.Default);
mock.Verify(m => m.ReloadData(paymentProvider, It.IsAny <ILocalization>()));
}
public void Orderable_StockTrueVariantFalseBackorderFalseStock100_ShouldReturnTrue()
{
IOC.UnitTest();
IOC.StockService.SetupNewMock().Setup(m => m.GetStockForUwebshopEntityWithId(It.IsAny <int>(), null)).Returns(100);
var product = new Product {
UseVariantStock = false, StockStatus = true, BackorderStatus = false, VariantGroups = Enumerable.Empty <IProductVariantGroup>(), ProductVariantGroupsFactory = () => new List <IProductVariantGroup>(),
};
Assert.IsTrue(product.Orderable);
}
public void Setup()
{
IOC.UnitTest();
_wrapper = new MockHttpContextWrapper();
IOC.HttpContextWrapper.Use(_wrapper);
IOC.UwebshopConfiguration.Use(new TestUwebshopConfiguration {
PermanentRedirectOldCatalogUrls = true, LegacyCategoryUrlIdentifier = "categoryidentifier", LegacyProductUrlIdentifier = "productidentifier"
});
_urlRewritingService = IOC.UrlRewritingService.Actual().Resolve();
}
public void Percentage()
{
IOC.UnitTest();
var product = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(1000, 1);
product.DiscountPercentage = 10;
Assert.AreEqual(900, product.PriceInCents);
Assert.AreEqual(100, product.ProductDiscountInCents);
Assert.AreEqual(1000, product.RangedOriginalPrice);
}
public void PercentageProductDiscountOnProductWithVariant_ShouldGiveDiscountThatTakesVariantEffectIntoAccount()
{
IOC.UnitTest();
var discount = DefaultFactoriesAndSharedFunctionality.CreateProductDiscountPercentage(50);
var productInfo = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(1000, 1, discount);
var variant = DefaultFactoriesAndSharedFunctionality.CreateProductVariantInfo(-200);
DefaultFactoriesAndSharedFunctionality.SetVariantsOnProductInfo(productInfo, variant);
Assert.AreEqual(400, productInfo.PriceInCents);
}
public void PersistingStoreUrl()
{
IOC.UnitTest();
var store = new Store();
UwebshopRequest.Current.SetStoreUrl(store, "abc");
var actual = UwebshopRequest.Current.GetStoreUrl(store);
Assert.AreEqual("abc", actual);
}
public void OrderableTestCases_NoVariants(bool stockStatus, bool backOrderStatus, int stock, bool expected)
{
IOC.UnitTest();
IOC.StockService.SetupNewMock().Setup(m => m.GetStockForUwebshopEntityWithId(It.IsAny <int>(), null)).Returns(stock);
IOC.ProductService.Actual();
var product = new Product {
UseVariantStock = false, StockStatus = stockStatus, BackorderStatus = backOrderStatus, VariantGroups = Enumerable.Empty <IProductVariantGroup>(), ProductVariantGroupsFactory = () => new List <IProductVariantGroup>(),
};
Assert.AreEqual(expected, product.Orderable);
}
public void Setup()
{
IOC.UnitTest();
_stockServiceMock = IOC.StockService.SetupNewMock();
var productInfo = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(12990, 1);
productInfo.Id = TestProductService.ProductId1;
_order = DefaultFactoriesAndSharedFunctionality.CreateIncompleteOrderInfo(productInfo);
_order.StoreInfo.Alias = StoreHelper.GetCurrentStore().Alias;
}
public void Setup()
{
IOC.UnitTest();
IOC.VATCheckService.Mock(out _vatCheckerMock);
_incompleteOrderInfo = DefaultFactoriesAndSharedFunctionality.CreateIncompleteOrderInfo();
_incompleteOrderInfo.CustomerInfo.CountryCode = "GB";
_incompleteOrderInfo.VATCheckService = _vatCheckerMock.Object;
_incompleteOrderInfo.CustomerInfo.VATNumber = "something";
_confirmedOrderInfo = DefaultFactoriesAndSharedFunctionality.CreateOrderInfo();
_confirmedOrderInfo.VATCheckService = _vatCheckerMock.Object;
_confirmedOrderInfo.CustomerInfo.CountryCode = "GB";
}
public void BeforeDiscount_ShouldRemoveDiscountCalculation()
{
IOC.UnitTest();
var price = Price.CreateDiscountedRanged(1000, Enumerable.Empty <Range>(), true, 0, null, i => i / 2, null);
Assert.AreEqual(500, price.ValueInCents());
var beforeDiscount = price.BeforeDiscount;
Assert.AreEqual(1000, beforeDiscount.ValueInCents());
}
public void OrderInfoToDTOAndBackShouldPreserveValues()
{
IOC.UnitTest();
var originalOrderInfo = DefaultFactoriesAndSharedFunctionality.CreateOrderInfo(DefaultFactoriesAndSharedFunctionality.CreateProductInfo(995, 2));
var dto = new OrderDTO.Order(originalOrderInfo);
var convertedOrderInfo = dto.ToOrderInfo();
Assert.AreEqual(originalOrderInfo.GrandtotalInCents, convertedOrderInfo.GrandtotalInCents);
Assert.AreEqual(originalOrderInfo.SubtotalInCents, convertedOrderInfo.SubtotalInCents);
Assert.AreEqual(originalOrderInfo.ShippingProviderAmountInCents, convertedOrderInfo.ShippingProviderAmountInCents);
Assert.AreEqual(originalOrderInfo.DiscountAmountInCents, convertedOrderInfo.DiscountAmountInCents);
}
public void Setup()
{
IOC.UnitTest();
IOC.OrderService.Mock(out _orderServiceMock);
_discountCalculationService = IOC.DiscountCalculationService.Actual().Resolve();
_discountMock = MockConstructors.CreateDiscountMock();
_product1 = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(1000, 7);
_product2 = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(1000, 4);
_orderInfo = DefaultFactoriesAndSharedFunctionality.CreateOrderInfo(_product1, _product2);
_orderServiceMock.Setup(m => m.GetApplicableOrderLines(_orderInfo, It.IsAny <List <int> >())).Returns(_orderInfo.OrderLines);
}
public void PercentageIncludingVariant()
{
IOC.UnitTest();
var product = DefaultFactoriesAndSharedFunctionality.CreateProductInfo(1000, 1);
product.ProductVariants = new List <ProductVariantInfo> {
DefaultFactoriesAndSharedFunctionality.CreateProductVariantInfo(500)
};
product.DiscountAmountInCents = 100;
Assert.AreEqual(1400, product.PriceInCents);
Assert.AreEqual(100, product.ProductDiscountInCents);
Assert.AreEqual(1500, product.RangedOriginalPrice);
}
public void Setup()
{
IOC.UnitTest();
_categoryCatalogUrlService = IOC.CategoryCatalogUrlService.Actual().Resolve();
_cat1 = new MockCategory {
UrlName = "cat1"
};
_cat2 = new MockCategory {
UrlName = "cat2"
};
_cat3 = new MockCategory {
UrlName = "cat3"
};
}
public void Setup()
{
IOC.UnitTest();
_repository = (UmbracoProductRepository)IOC.ProductRepository.Actual().Resolve();
_product = new Product {
ParentId = 0
};
_propertyProvider = new TestPropertyProvider();
_localization = new StubLocalization {
CurrencyCode = "EUR", StoreAlias = "EN", Currency = new StubCurrency {
Ratio = (decimal)1.1
}
};
}
