public void SetUp()
{
// you have to be an administrator to access the product controller
Thread.CurrentPrincipal = new GenericPrincipal(new GenericIdentity("admin"), new[] { "Administrator" });
categoryRepository = MockRepositoryBuilder.CreateCategoryRepository();
productRepository = MockRepositoryBuilder.CreateProductRepository();
productOrderableService = MockRepository.GenerateStub<IOrderableService<ProductCategory>>();
MockRepository.GenerateStub<IOrderableService<ProductImage>>();
userService = MockRepository.GenerateStub<IUserService>();
productBuilder = MockRepository.GenerateStub<IProductBuilder>();
productController = new ProductController(
productRepository,
categoryRepository,
productOrderableService,
userService,
MockRepository.GenerateStub<IUnitOfWorkManager>(),
productBuilder);
userService.Stub(c => c.CurrentUser).Return(new User { Role = Role.Administrator });
}
public UtilityService(
IRepository <Testimonial> testimonialRepository,
IRepository <CustomDictionary> customDictionaryRepository,
IRepository <StockNotification> stockNotificationRepository,
IRepository <Product> productRepository,
IRepository <ProductPrice> productPriceRepository,
IIPToCountry ipToCountry,
ILogBuilder logBuilder,
ISettingService settings,
IEmailManager emailManager,
ICacheNotifier cacheNotifier,
IEnumerable <Lazy <ICacheManager, ICacheManagerMetadata> > cacheManagers,
ISitemapGenerator sitemapGenerator,
ICurrencyService currencyService,
IGenericAttributeService genericAttributeService,
IProductBuilder productBuilder,
CacheSettings cacheSettings)
{
_testimonialRepository = testimonialRepository;
_customDictionaryRepository = customDictionaryRepository;
_stockNotificationRepository = stockNotificationRepository;
_productRepository = productRepository;
_productPriceRepository = productPriceRepository;
_ipToCountry = ipToCountry;
_settings = settings;
_emailManager = emailManager;
_cacheNotifier = cacheNotifier;
_cacheManagers = cacheManagers;
_sitemapGenerator = sitemapGenerator;
_currencyService = currencyService;
_genericAttributeService = genericAttributeService;
_productBuilder = productBuilder;
_cacheSettings = cacheSettings;
_logger = logBuilder.CreateLogger(GetType().FullName);
}
public ProductsController(IProductBuilder productBuilder,
IComparer <Product> productComparer,
IMapper mapper)
{
_productBuilder = productBuilder;
_productComparer = productComparer;
_mapper = mapper;
}
public void Initialize(IProductEditorView view, IProductBuilder productBuilder)
{
view.SaveProduct += delegate
{
var product = productBuilder.Create(view.ProductId, view.ProductDescription);
product.Save();
}
}
public StormProductManager(IStormConnectionManager connectionManager, IProductBuilder <StormProductItem, StormProduct> productBuilder, IBuyableExtension buyableExtension, IConfiguration configuration)
{
_productBuilder = productBuilder;
_buyableExtension = buyableExtension;
_connectionManager = connectionManager;
_configuration = configuration;
PageSize = Convert.ToInt32(_configuration["Storm:DefaultPageSize"]);
}
public CartService(
IDbContext dbContext,
IRepository <Account> accountRepository,
IRepository <CartItem> cartItemRepository,
IRepository <Currency> currencyRepository,
IRepository <Country> countryRepository,
IRepository <ProductMedia> productMediaRepository,
IRepository <ShippingOption> shippingOptionRepository,
IRepository <OfferRule> offerRuleRepository,
IRepository <CartPharmOrder> cartPharmOrderRepository,
IRepository <CartPharmItem> cartPharmItemRepository,
IRepository <TaxCategory> taxCategoryRepository,
IOrderCalculator orderCalculator,
IOfferService offerService,
ICurrencyService currencyService,
IGenericAttributeService genericAttributeService,
IShippingService shippingService,
IAccountService accountService,
ICartValidator cartValidator,
ICacheManager cacheManager,
ILogBuilder logBuilder,
IProductBuilder productBuilder,
ICartItemBuilder cartItemBuilder,
ShoppingCartSettings shoppingCartSettings,
TaxSettings taxSettings,
MediaSettings mediaSettings,
ShippingSettings shippingSettings)
{
_dbContext = dbContext;
_accountRepository = accountRepository;
_cartItemRepository = cartItemRepository;
_currencyRepository = currencyRepository;
_countryRepository = countryRepository;
_productMediaRepository = productMediaRepository;
_shippingOptionRepository = shippingOptionRepository;
_offerRuleRepository = offerRuleRepository;
_cartPharmOrderRepository = cartPharmOrderRepository;
_cartPharmItemRepository = cartPharmItemRepository;
_taxCategoryRepository = taxCategoryRepository;
_orderCalculator = orderCalculator;
_offerService = offerService;
_currencyService = currencyService;
_genericAttributeService = genericAttributeService;
_shippingService = shippingService;
_accountService = accountService;
_cartValidator = cartValidator;
_cacheManager = cacheManager;
_productBuilder = productBuilder;
_cartItemBuilder = cartItemBuilder;
_shoppingCartSettings = shoppingCartSettings;
_taxSettings = taxSettings;
_mediaSettings = mediaSettings;
_shippingSettings = shippingSettings;
_logger = logBuilder.CreateLogger(GetType().FullName);
}
public Product Build(IProductBuilder builder)
{
builder.BuildAttribute1();
builder.BuildAttribute2();
builder.BuildAttribute3();
builder.BuildAttribute4();
builder.BuildAttribute5();
builder.BuildAttribute6();
return(builder.Build());
}
public ProductController(
IRepository <Product> productRepository,
IRepository <Category> categoryRepository,
IOrderableService <Product> productOrderableService,
IUserService userService,
IUnitOfWorkManager uow,
IProductBuilder productBuilder)
{
this.productRepository = productRepository;
this.uow = uow;
this.userService = userService;
this.categoryRepository = categoryRepository;
this.productOrderableService = productOrderableService;
this.productBuilder = productBuilder;
}
public ProductController(
IRepository<Product> productRepository,
IRepository<Category> categoryRepository,
IOrderableService<Product> productOrderableService,
IUserService userService,
IUnitOfWorkManager uow,
IProductBuilder productBuilder)
{
this.productRepository = productRepository;
this.uow = uow;
this.userService = userService;
this.categoryRepository = categoryRepository;
this.productOrderableService = productOrderableService;
this.productBuilder = productBuilder;
}
public CatalogService(
ISiteContext siteContext,
ICatalogMapper catalogMapper,
ISearchService searchService,
IProductBuilder <Item> productBuilder)
{
Assert.ArgumentNotNull(siteContext, nameof(siteContext));
Assert.ArgumentNotNull(catalogMapper, nameof(catalogMapper));
Assert.ArgumentNotNull(searchService, nameof(searchService));
Assert.ArgumentNotNull(productBuilder, nameof(productBuilder));
this.siteContext = siteContext;
this.catalogMapper = catalogMapper;
this.searchService = searchService;
this.productBuilder = productBuilder;
}
public SearchServiceTests()
{
this.fixture = new Fixture().Customize(new AutoDbCustomization());
this.searchMapper = Substitute.For <ISearchMapper>();
this.searchResponseProvider = Substitute.For <ISearchResponseProvider>();
this.productBuilder = Substitute.For <IProductBuilder <Item> >();
this.searchResultProvider = Substitute.For <ISearchResultProvider>();
this.queryBuilder = Substitute.For <ISearchQueryBuilder>();
this.searchService = new SearchService(
this.searchMapper,
this.searchResponseProvider,
this.productBuilder,
this.searchResultProvider,
this.queryBuilder);
}
public SearchService(
ISearchMapper searchMapper,
ISearchResponseProvider searchResponseProvider,
IProductBuilder <Item> productBuilder,
ISearchResultProvider searchResultProvider,
ISearchQueryBuilder queryBuilder)
{
Assert.ArgumentNotNull(searchMapper, nameof(searchMapper));
Assert.ArgumentNotNull(searchResponseProvider, nameof(searchResponseProvider));
Assert.ArgumentNotNull(searchResponseProvider, nameof(searchResponseProvider));
Assert.ArgumentNotNull(productBuilder, nameof(productBuilder));
Assert.ArgumentNotNull(queryBuilder, nameof(queryBuilder));
this.searchMapper = searchMapper;
this.searchResponseProvider = searchResponseProvider;
this.searchResultProvider = searchResultProvider;
this.productBuilder = productBuilder;
this.queryBuilder = queryBuilder;
}
public CartUtility(
ILogBuilder logBuilder,
ICartValidator cartValidator,
IProductBuilder productBuilder,
IRepository <Order> orderRepository,
IRepository <Country> countryRepository,
IRepository <CartItem> cartItemRepository,
IRepository <OfferType> offerTypeRepository,
AttributeUtility attributeUtility,
MediaSettings mediaSettings)
{
_logger = logBuilder.CreateLogger(typeof(CartUtility).FullName);
_mediaSettings = mediaSettings;
_cartValidator = cartValidator;
_attributeUtility = attributeUtility;
_productBuilder = productBuilder;
_orderRepository = orderRepository;
_countryRepository = countryRepository;
_cartItemRepository = cartItemRepository;
_offerTypeRepository = offerTypeRepository;
}
public ProductBuilderDirector()
{
_productBuilder = new ProductBuilder();
}
public ProductCreator(IProductBuilder builder)
{
objectBuilder = builder;
}
public EligibilityOrderDirector(IProductBuilder builder)
{
_builder = builder;
}
/// <summary> ANOTHER WAY TO CREATE SINGELTON WITHOUT LOCK
// public sealed class Singleton
// {
// private static readonly Singleton instance = new Singleton();
// Explicit static constructor to tell C# compiler
// not to mark type as beforefieldinit
// static Singleton()
// {
// }
// private Singleton()
// {
// }
// public static Singleton Instance
// {
// get
// {
// return instance;
// }
// }
// }
/// </summary>
public Product Build(IProductBuilder builder)
{
builder.setName("bla");
builder.setNumber(10);
return(builder.GetProduct());
}
public void Construct(IProductBuilder builder)
{
builder.BuildPart();
}
