public List<ProductCardModel> GetListOfProductsWhoWhereAlsoBought(Product product)
{
if (product == null)
return new List<ProductCardModel>();
var items = _session.CreateCriteria<Product>()
.Add(
Subqueries.PropertyIn("Id",
DetachedCriteria.For<ProductVariant>()
.SetProjection(Projections.Property("Product.Id"))
.Add(Subqueries.PropertyIn("Id",
DetachedCriteria.For<OrderLine>()
.SetProjection(Projections.Property("ProductVariant.Id"))
.Add(Subqueries.PropertyIn("Order.Id",
DetachedCriteria.For<OrderLine>()
.SetProjection(Projections.Property("Order.Id"))
.CreateCriteria("ProductVariant", JoinType.LeftOuterJoin)
.Add(Restrictions.Eq("Product.Id", product.Id))
))
))
))
.Add(Restrictions.Not(Restrictions.Eq("Id", product.Id)))
.Add(Restrictions.IsNotNull("PublishOn")).SetCacheable(true)
.SetMaxResults(4)
.List<Product>().ToList();
return items.GetCardModels();
}
public void PrepareForSyncAmazonListingService_UpdateAmazonListing_ShouldReturnAmazonListingType()
{
var mockingKernel = new MockingKernel();
MrCMSKernel.OverrideKernel(mockingKernel);
mockingKernel.Bind <ISession>().ToMethod(context => A.Fake <ISession>());
var product = new Product();
var productVariant = new ProductVariant()
{
Product = product, SKU = "S1", Barcode = ""
};
var model = new AmazonListing()
{
ProductVariant = productVariant, AmazonListingGroup = new AmazonListingGroup()
{
FulfillmentChannel = AmazonFulfillmentChannel.MFN
}
};
A.CallTo(() => _productVariantService.GetProductVariantBySKU(model.ProductVariant.SKU)).Returns(productVariant);
var results = _prepareForSyncAmazonListingService.UpdateAmazonListing(model);
results.Should().BeOfType <AmazonListing>();
}
public void ImportProductVariantsService_ImportVariants_ShouldSetProductVariantPrimaryProperties()
{
var productVariantDTO = new ProductVariantImportDataTransferObject
{
PreviousPrice = 2,
Price = 1,
SKU = "123",
Name = "Test Product Variant",
TrackingPolicy = TrackingPolicy.Track,
Weight = 0,
Barcode = "456",
Stock = 5
};
var productDTO = new ProductImportDataTransferObject
{
UrlSegment = "test-url",
ProductVariants = new List<ProductVariantImportDataTransferObject>() { productVariantDTO }
};
var product = new Product() { Name = "Test Product" };
var result = _importProductVariantsService.ImportVariants(productDTO, product);
result.First().PreviousPrice.ShouldBeEquivalentTo(2);
result.First().BasePrice.ShouldBeEquivalentTo(1);
result.First().SKU.ShouldBeEquivalentTo("123");
result.First().Name.ShouldBeEquivalentTo("Test Product Variant");
result.First().TrackingPolicy.ShouldBeEquivalentTo(TrackingPolicy.Track);
result.First().Weight.ShouldBeEquivalentTo(0);
result.First().Barcode.ShouldBeEquivalentTo("456");
result.First().StockRemaining.ShouldBeEquivalentTo(5);
}
public void ProductOptionManager_DeleteSpecificationAttribute_ShouldRemoveAllValues()
{
var attribute = new ProductSpecificationAttribute { Name = "Test" };
var option = new ProductSpecificationAttributeOption() { Name = "Test Value" };
var product = new Product();
var productSpecificationAttributes =
Enumerable.Range(1, 10)
.Select(
i =>
new ProductSpecificationValue
{
ProductSpecificationAttributeOption = option,
Product = product
})
.ToList();
option.Values = productSpecificationAttributes;
Session.Transact(session =>
{
session.Save(product);
session.Save(attribute);
productSpecificationAttributes.ForEach(value => session.Save(value));
});
_productOptionManager.DeleteSpecificationAttributeOption(option);
Session.QueryOver<ProductSpecificationValue>().RowCount().Should().Be(0);
}
public void Product_IsMultiVariant_FalseIfNoVariants()
{
var product = new Product();
var isMultiVariant = product.IsMultiVariant;
isMultiVariant.Should().BeFalse();
}
public void Product_GetSpecification_ReturnsNullWhenThereIsNoRelevantValue()
{
var product = new Product();
var specification = product.GetSpecification("Test");
specification.Should().BeNull();
}
public void Add_ShouldPersistToTheSession()
{
var product = new Product();
var productVariant = new ProductVariant {Product = product};
_service.Add(productVariant);
Session.QueryOver<ProductVariant>().RowCount().Should().Be(1);
}
public void Add_ShouldAddVariantToTheProductsVariants()
{
var product = new Product();
var productVariant = new ProductVariant {Product = product};
_service.Add(productVariant);
product.Variants.Should().Contain(productVariant);
}
public void ProductVariantController_Add_ReturnsAProductVariantWithPassedProductSet()
{
var product = new Product();
PartialViewResult add = _productVariantController.Add(product);
add.Model.Should().BeOfType<ProductVariant>();
add.Model.As<ProductVariant>().Product.Should().Be(product);
}
public void ProductVariantController_Add_CallsIntoAddViewData()
{
var product = new Product();
PartialViewResult add = _productVariantController.Add(product);
A.CallTo(
() => _productVariantAdminService.SetViewData(_productVariantController.ViewData, A<ProductVariant>._))
.MustHaveHappened();
}
public string ProcessProducts(NopCommerceDataReader dataReader,
NopImportContext nopImportContext)
{
HashSet<ProductData> productDatas = dataReader.GetProducts();
HashSet<ProductOptionValueData> optionValues = dataReader.GetProductOptionValues();
HashSet<ProductSpecificationValueData> specificationValues = dataReader.GetProductSpecificationValues();
var productContainer = _uniquePageService.GetUniquePage<ProductContainer>();
_session.Transact(session =>
{
foreach (ProductData productData in productDatas)
{
var suggestParams = new SuggestParams
{
DocumentType = typeof(Product).FullName,
PageName = productData.Name,
UseHierarchy = true
};
var product = new Product
{
Name = productData.Name,
ProductAbstract = productData.Abstract.LimitCharacters(500),
BodyContent = productData.Description,
Parent = productContainer,
UrlSegment =
string.IsNullOrWhiteSpace(productData.Url)
? _webpageUrlService.Suggest(productContainer, suggestParams)
: productData.Url,
BrandPage =
productData.BrandId.HasValue
? nopImportContext.FindNew<Brand>(productData.BrandId.Value)
: null,
Categories = productData.Categories.Select(nopImportContext.FindNew<Category>).ToList(),
Tags = new HashSet<Tag>(productData.Tags.Select(nopImportContext.FindNew<Tag>).ToList()),
PublishOn = productData.Published ? CurrentRequestData.Now.Date : (DateTime?) null
};
SetSpecificationValues(nopImportContext,
specificationValues.FindAll(data => data.ProductId == productData.Id), product);
_importProductVariants.CreateProductVariants(nopImportContext, productData.ProductVariants,
optionValues, product);
session.Save(product);
var pictureIds = productData.Pictures;
foreach (var pictureId in pictureIds)
{
var mediaFile = nopImportContext.FindNew<MediaFile>(pictureId);
if (mediaFile != null)
{
mediaFile.MediaCategory = product.Gallery;
session.Update(mediaFile);
}
}
}
});
return string.Format("{0} products processed.", productDatas.Count);
}
public void Product_IsMultiVariant_FalseIf1Variant()
{
var product = new Product();
product.Variants.Add(new ProductVariant());
var isMultiVariant = product.IsMultiVariant;
isMultiVariant.Should().BeFalse();
}
public void PrepareForSyncAmazonListingService_InitAmazonListingFromProductVariant_ShouldCallSave()
{
var item = new Currency()
{
Code = "GBP", Id = 1
};
Session.Transact(session => session.Save(item));
var mockingKernel = new MockingKernel();
MrCMSKernel.OverrideKernel(mockingKernel);
mockingKernel.Bind <ISession>().ToMethod(context => A.Fake <ISession>());
mockingKernel.Bind <EcommerceSettings>().ToMethod(context => new EcommerceSettings()
{
CurrencyId = 1
});
var product = new Product()
{
BrandPage = new Brand()
{
Name = "B"
}
};
var productVariant = new ProductVariant()
{
Product = product,
SKU = "S1",
BasePrice = 1,
StockRemaining = 2,
Name = "P",
ManufacturerPartNumber = "MPN1",
Barcode = ""
};
var amazonListingGroup = new AmazonListingGroup()
{
Id = 1,
FulfillmentChannel = AmazonFulfillmentChannel.MFN
};
var model = new AmazonListing()
{
ProductVariant = productVariant,
StandardProductId = "1P",
StandardProductIDType = StandardProductIDType.EAN,
AmazonListingGroup = amazonListingGroup
};
A.CallTo(() => _amazonListingGroupService.Get(amazonListingGroup.Id)).Returns(amazonListingGroup);
A.CallTo(() => _productVariantService.GetProductVariantBySKU(model.ProductVariant.SKU)).Returns(productVariant);
var results = _prepareForSyncAmazonListingService.InitAmazonListingFromProductVariant(model, model.ProductVariant.SKU, amazonListingGroup.Id);
A.CallTo(() => _amazonListingGroupService.Save(amazonListingGroup)).MustHaveHappened();
}
public void Product_HasVariants_TrueIfMoreThan1Variants()
{
var product = new Product();
product.Variants.Add(new ProductVariant());
product.Variants.Add(new ProductVariant());
var hasVariants = product.IsMultiVariant;
hasVariants.Should().BeTrue();
}
public IPagedList<Category> GetCategories(Product product, string query, int page = 1)
{
QueryOver<Category, Category> queryOver = QueryOver.Of<Category>();
if (!string.IsNullOrWhiteSpace(query))
queryOver = queryOver.Where(category => category.Name.IsInsensitiveLike(query, MatchMode.Anywhere));
queryOver = queryOver.Where(category => !category.Id.IsIn(product.Categories.Select(c => c.Id).ToArray()));
return _session.Paged(queryOver, page);
}
public PeopleWhoBoughtThisAlsoBoughtViewModel GetAlsoBoughtViewModel(Product product)
{
var model = new PeopleWhoBoughtThisAlsoBoughtViewModel { Title = string.Empty };
if (product != null)
{
model.Title = string.Format("People Who Bought '{0}' Also Bought", product.Name);
model.Products = _productAnalyticsService.GetListOfProductsWhoWhereAlsoBought(product);
}
model.Cart = _cart;
return model;
}
public IPagedList<Product> RelatedProductsSearch(Product product, string query, int page = 1)
{
var queryOver = QueryOver.Of<Product>();
if (!string.IsNullOrWhiteSpace(query))
queryOver = queryOver.Where(item => item.Name.IsInsensitiveLike(query, MatchMode.Anywhere));
queryOver = queryOver.Where(item => !item.Id.IsIn(product.RelatedProducts.Select(c => c.Id).ToArray()) && item.Id != product.Id);
return _session.Paged(queryOver, page);
}
public void PrepareForSyncAmazonListingService_UpdateAmazonListing_ShouldSetValues()
{
var item = new Currency() { Code = "GBP", Id=1 };
Session.Transact(session => session.Save(item));
var mockingKernel = new MockingKernel();
MrCMSKernel.OverrideKernel(mockingKernel);
mockingKernel.Bind<ISession>().ToMethod(context => A.Fake<ISession>());
mockingKernel.Bind<EcommerceSettings>().ToMethod(context => new EcommerceSettings(){CurrencyId = 1});
var product = new Product()
{
BrandPage = new Brand(){Name = "B"}
};
var productVariant = new ProductVariant()
{
Product = product,
SKU = "S1",
BasePrice = 1,
StockRemaining = 2,
Name = "P",
ManufacturerPartNumber = "MPN1",
Barcode = ""
};
var model = new AmazonListing()
{
ProductVariant = productVariant,
StandardProductId = "1P",
StandardProductIDType = StandardProductIDType.EAN,
AmazonListingGroup = new AmazonListingGroup()
{
FulfillmentChannel = AmazonFulfillmentChannel.MFN
}
};
A.CallTo(() => _productVariantService.GetProductVariantBySKU(model.ProductVariant.SKU)).Returns(productVariant);
var results = _prepareForSyncAmazonListingService.UpdateAmazonListing(model);
results.As<AmazonListing>().Condition.Should().Be(ConditionType.New);
results.As<AmazonListing>().Currency.Should().Be("GBP");
results.As<AmazonListing>().Manafacturer.Should().Be("B");
results.As<AmazonListing>().Brand.Should().Be("B");
results.As<AmazonListing>().MfrPartNumber.Should().Be("MPN1");
results.As<AmazonListing>().Price.Should().Be(1);
results.As<AmazonListing>().Quantity.Should().Be(2);
results.As<AmazonListing>().Title.Should().Be("P");
results.As<AmazonListing>().StandardProductIDType.Should().Be(_amazonSellerSettings.BarcodeIsOfType);
results.As<AmazonListing>().StandardProductId.Should().Be(model.StandardProductId);
results.As<AmazonListing>().FulfillmentChannel.Should().Be(AmazonFulfillmentChannel.MFN);
}
public IEnumerable<ProductSpecificationValue> ImportSpecifications(
ProductImportDataTransferObject dataTransferObject, Product product)
{
List<KeyValuePair<string, string>> specificationsToAdd =
dataTransferObject.Specifications.Where(
s =>
!product.SpecificationValues.Select(value => value.SpecificationName)
.Contains(s.Key, StringComparer.InvariantCultureIgnoreCase)).ToList();
List<ProductSpecificationValue> specificationsToRemove =
product.SpecificationValues.Where(
value =>
!dataTransferObject.Specifications.Keys.Contains(value.SpecificationName,
StringComparer.InvariantCultureIgnoreCase))
.ToList();
List<ProductSpecificationValue> specificationsToUpdate =
product.SpecificationValues.Where(value => !specificationsToRemove.Contains(value)).ToList();
foreach (var item in specificationsToAdd)
{
ProductSpecificationAttribute attribute =
_session.QueryOver<ProductSpecificationAttribute>()
.Where(
specificationAttribute =>
specificationAttribute.Name.IsInsensitiveLike(item.Key, MatchMode.Exact))
.Take(1)
.SingleOrDefault();
if (attribute == null)
{
attribute = new ProductSpecificationAttribute {Name = item.Key};
_session.Transact(session => session.Save(attribute));
}
SetValue(product, attribute, item.Value);
}
foreach (ProductSpecificationValue value in specificationsToRemove)
{
RemoveValue(product, value);
}
foreach (ProductSpecificationValue value in specificationsToUpdate)
{
ProductSpecificationAttribute attribute =
value.ProductSpecificationAttributeOption.ProductSpecificationAttribute;
RemoveValue(product, value);
SetValue(product, attribute, dataTransferObject.Specifications[value.SpecificationName]);
}
return dataTransferObject.Specifications.Any() ? product.SpecificationValues : null;
}
public List<SelectListItem> GetProductAttributeOptions(Product product)
{
var productAttributeOptions =
_session.QueryOver<ProductOption>()
.OrderBy(option => option.Name)
.Asc.Cacheable()
.List().ToList();
productAttributeOptions = productAttributeOptions.FindAll(option => !product.Options.Contains(option));
var options = productAttributeOptions.BuildSelectItemList(option => option.Name,
option => option.Id.ToString(),
emptyItemText: "Select an option");
options.Add(new SelectListItem { Text = "Add new", Value = "-1" });
return options;
}
public void ImportSpecificationsService_ImportSpecifications_ShouldAddANewSpecificationAttributeIfItDoesntExist()
{
var productDTO = new ProductImportDataTransferObject()
{
UrlSegment = "test-url",
Specifications = new Dictionary<string, string>()
{
{"Storage","16GB"}
}
};
var product = new Product() { Name = "Test Product" };
_importSpecificationsService.ImportSpecifications(productDTO, product);
Session.Query<ProductSpecificationAttribute>().First().Options.Should().HaveCount(1);
}
public string Parse(ProductListTemplateData template, Product item)
{
if (template == null)
return string.Empty;
string output = template.ProductTemplate;
if (string.IsNullOrWhiteSpace(output))
return string.Empty;
MediaFile image = _imageProcessor.GetImage(item.DisplayImageUrl);
output = ImageRegex.Replace(output,
_urlHelper.ToAbsolute(_fileService.GetFileLocation(image, new Size { Width = 150, Height = 150 })));
output = NameRegex.Replace(output, item.Name ?? string.Empty);
output = LinkRegex.Replace(output, item.AbsoluteUrl);
output = PriceRegex.Replace(output, GetPrice(item.DisplayPrice));
output = OldPriceRegex.Replace(output, GetPrice(item.DisplayPreviousPrice));
return output;
}
private static void SetValue(Product product, ProductSpecificationAttribute attribute, string value)
{
ProductSpecificationAttributeOption option = attribute.Options.FirstOrDefault(o => o.Name == value);
if (option == null)
{
option = new ProductSpecificationAttributeOption
{
Name = value,
ProductSpecificationAttribute = attribute
};
attribute.Options.Add(option);
}
product.SpecificationValues.Add(new ProductSpecificationValue
{
ProductSpecificationAttributeOption = option,
Product = product
});
}
public void PrepareForSyncAmazonListingService_UpdateAmazonListing_ShouldReturnAmazonListingType()
{
var mockingKernel = new MockingKernel();
MrCMSKernel.OverrideKernel(mockingKernel);
mockingKernel.Bind<ISession>().ToMethod(context => A.Fake<ISession>());
var product = new Product();
var productVariant = new ProductVariant() { Product = product, SKU = "S1", Barcode = "" };
var model = new AmazonListing() { ProductVariant = productVariant, AmazonListingGroup = new AmazonListingGroup()
{
FulfillmentChannel = AmazonFulfillmentChannel.MFN
}};
A.CallTo(() => _productVariantService.GetProductVariantBySKU(model.ProductVariant.SKU)).Returns(productVariant);
var results = _prepareForSyncAmazonListingService.UpdateAmazonListing(model);
results.Should().BeOfType<AmazonListing>();
}
public void RemoveOption(Product product, ProductOption productOption)
{
if (productOption != null && product != null)
{
product.Options.Remove(productOption);
productOption.Products.Remove(product);
_session.Transact(session =>
{
foreach (var variant in product.Variants.ToList())
{
foreach (var productOptionValue in variant.OptionValues.Where(value => value.ProductOption == productOption).ToList())
{
variant.OptionValues.Remove(productOptionValue);
session.Delete(productOptionValue);
}
}
session.Update(product);
session.Update(productOption);
});
}
}
public RelatedProductsViewModel GetRelatedProducts(Product product)
{
var model = new RelatedProductsViewModel { Title = String.Empty };
var products = new List<Product>();
if (product != null)
{
model.Title = "Related Products";
if (product.PublishedRelatedProducts.Any())
products.AddRange(product.PublishedRelatedProducts.Take(4));
else
{
if (product.Categories.Any())
products.AddRange(product.Categories.Last()
.Products.Where(x => x.Id != product.Id && x.Published).Take(4));
}
}
model.Products = products.Distinct().ToList().GetCardModels();
model.Cart = _cart;
return model;
}
public void ImportProductVariantsService_ImportVariants_ShouldSetProductVariantTaxRate()
{
var productVariantDTO = new ProductVariantImportDataTransferObject
{
SKU = "123",
TaxRate = 1
};
var productDTO = new ProductImportDataTransferObject
{
UrlSegment = "test-url",
ProductVariants = new List<ProductVariantImportDataTransferObject>() { productVariantDTO }
};
var product = new Product { Name = "Test Product" };
var taxRate = new TaxRate() { Id = 1, Name = "GLOBAL" };
A.CallTo(() => _taxRateManager.Get(productVariantDTO.TaxRate.Value)).Returns(taxRate);
var result = _importProductVariantsService.ImportVariants(productDTO, product);
result.First().TaxRate.Name.ShouldBeEquivalentTo("GLOBAL");
}
public void AddOption(Product product, ProductOption productOption)
{
if (productOption != null && product != null)
{
product.Options.Add(productOption);
productOption.Products.Add(product);
foreach (var variant in product.Variants)
{
variant.OptionValues.Add(new ProductOptionValue
{
ProductOption = productOption,
ProductVariant = variant,
Value = string.Empty,
});
}
_session.Transact(session =>
{
session.Update(product);
session.Update(productOption);
});
}
}
public void Product_GetSpecification_ReturnsValueWhenItExists()
{
var product = new Product();
product.SpecificationValues.Add(new ProductSpecificationValue
{
ProductSpecificationAttributeOption =
new ProductSpecificationAttributeOption
{
ProductSpecificationAttribute =
new ProductSpecificationAttribute
{
Name = "Test"
}
,
Name = "value"
}
});
var specification = product.GetSpecification("Test");
specification.Should().Be("value");
}
public void ImportUrlHistory(ProductImportDataTransferObject productDto, Product product)
{
List<string> urlsToAdd =
productDto.UrlHistory.Where(
s =>
!product.Urls.Select(history => history.UrlSegment)
.Contains(s, StringComparer.InvariantCultureIgnoreCase)).ToList();
//List<UrlHistory> urlsToRemove =
// product.Urls.Where(
// history =>
// !productDto.UrlHistory.Contains(history.UrlSegment, StringComparer.InvariantCultureIgnoreCase))
// .ToList();
foreach (string item in urlsToAdd)
{
UrlHistory history =
_session.Query<UrlHistory>().FirstOrDefault(urlHistory => urlHistory.UrlSegment == item);
bool isNew = history == null;
if (isNew)
{
history = new UrlHistory { UrlSegment = item, Webpage = product };
_session.Transact(session => session.Save(history));
}
else
history.Webpage = product;
if (!product.Urls.Contains(history))
product.Urls.Add(history);
_session.Transact(session => session.Update(history));
}
//foreach (UrlHistory history in urlsToRemove)
//{
// product.Urls.Remove(history);
// history.Webpage = null;
// UrlHistory closureHistory = history;
// _session.Transact(session => session.Update(closureHistory));
//}
}
public void PrepareForSyncAmazonListingService_InitAmazonListingFromProductVariant_ShouldCallSave()
{
var item = new Currency() { Code = "GBP", Id = 1 };
Session.Transact(session => session.Save(item));
var mockingKernel = new MockingKernel();
MrCMSKernel.OverrideKernel(mockingKernel);
mockingKernel.Bind<ISession>().ToMethod(context => A.Fake<ISession>());
mockingKernel.Bind<EcommerceSettings>().ToMethod(context => new EcommerceSettings() { CurrencyId = 1 });
var product = new Product()
{
BrandPage = new Brand() { Name = "B" }
};
var productVariant = new ProductVariant()
{
Product = product,
SKU = "S1",
BasePrice = 1,
StockRemaining = 2,
Name = "P",
ManufacturerPartNumber = "MPN1",
Barcode = ""
};
var amazonListingGroup = new AmazonListingGroup()
{
Id = 1,
FulfillmentChannel = AmazonFulfillmentChannel.MFN
};
var model = new AmazonListing()
{
ProductVariant = productVariant,
StandardProductId = "1P",
StandardProductIDType = StandardProductIDType.EAN,
AmazonListingGroup = amazonListingGroup
};
A.CallTo(() => _amazonListingGroupService.Get(amazonListingGroup.Id)).Returns(amazonListingGroup);
A.CallTo(() => _productVariantService.GetProductVariantBySKU(model.ProductVariant.SKU)).Returns(productVariant);
var results = _prepareForSyncAmazonListingService.InitAmazonListingFromProductVariant(model, model.ProductVariant.SKU, amazonListingGroup.Id);
A.CallTo(() => _amazonListingGroupService.Save(amazonListingGroup)).MustHaveHappened();
}
public void UpdateAttributeOptionDisplayOrder(Product product, IList<SortItem> options)
{
if (product != null && options != null && options.Count > 0)
{
_session.Transact(session =>
{
options.ForEach(item =>
{
var option = session.Get<ProductOption>(item.Id);
if (option == null)
return;
product.Options.Remove(option);
product.Options.Insert(item.Order, option);
});
session.Update(product);
});
}
}
public void PrepareForSyncAmazonListingService_UpdateAmazonListing_ShouldSetValues()
{
var item = new Currency()
{
Code = "GBP", Id = 1
};
Session.Transact(session => session.Save(item));
var mockingKernel = new MockingKernel();
MrCMSKernel.OverrideKernel(mockingKernel);
mockingKernel.Bind <ISession>().ToMethod(context => A.Fake <ISession>());
mockingKernel.Bind <EcommerceSettings>().ToMethod(context => new EcommerceSettings()
{
CurrencyId = 1
});
var product = new Product()
{
BrandPage = new Brand()
{
Name = "B"
}
};
var productVariant = new ProductVariant()
{
Product = product,
SKU = "S1",
BasePrice = 1,
StockRemaining = 2,
Name = "P",
ManufacturerPartNumber = "MPN1",
Barcode = ""
};
var model = new AmazonListing()
{
ProductVariant = productVariant,
StandardProductId = "1P",
StandardProductIDType = StandardProductIDType.EAN,
AmazonListingGroup = new AmazonListingGroup()
{
FulfillmentChannel = AmazonFulfillmentChannel.MFN
}
};
A.CallTo(() => _productVariantService.GetProductVariantBySKU(model.ProductVariant.SKU)).Returns(productVariant);
var results = _prepareForSyncAmazonListingService.UpdateAmazonListing(model);
results.As <AmazonListing>().Condition.Should().Be(ConditionType.New);
results.As <AmazonListing>().Currency.Should().Be("GBP");
results.As <AmazonListing>().Manafacturer.Should().Be("B");
results.As <AmazonListing>().Brand.Should().Be("B");
results.As <AmazonListing>().MfrPartNumber.Should().Be("MPN1");
results.As <AmazonListing>().Price.Should().Be(1);
results.As <AmazonListing>().Quantity.Should().Be(2);
results.As <AmazonListing>().Title.Should().Be("P");
results.As <AmazonListing>().StandardProductIDType.Should().Be(_amazonSellerSettings.BarcodeIsOfType);
results.As <AmazonListing>().StandardProductId.Should().Be(model.StandardProductId);
results.As <AmazonListing>().FulfillmentChannel.Should().Be(AmazonFulfillmentChannel.MFN);
}
