public void ThrowArgumentNullException_WhenCompaniesIsNull()
{
//Arrange
var dbContextMock = new Mock <ISportscardSystemDbContext>();
var mapperMock = new Mock <IMapper>();
var data = new List <Company>
{
new Company {
Name = "Company1"
},
new Company {
Name = "Company2"
},
new Company {
Name = "Company3"
},
};
var mockSet = new Mock <DbSet <Company> >();
mockSet.SetupData(data);
Mapper.Reset();
AutomapperConfiguration.Initialize();
dbContextMock
.Setup(x => x.Companies)
.Returns((IDbSet <Company>)null);
var companyService = new CompanyService(dbContextMock.Object, mapperMock.Object);
//Act && Assert
Assert.ThrowsException <ArgumentNullException>(() => companyService.GetAllCompanies());
}
public void ReturnCorrectData_WhenInvoked()
{
// Arrange
Mapper.Reset();
AutomapperConfiguration.Initialize();
var mockContext = new Mock <IOnlineStoreContext>();
var products = new List <Product> {
new Product {
Name = "Testproduct", Quantity = 5, Category = new Category {
Name = "Patki"
}
}
};
var fakemapper = new Mock <IMapper>();
var fakeCategoryService = new Mock <ICategoryService>();
var mockSet = new Mock <DbSet <Product> >();
mockSet.SetupData(products);
mockContext.Setup(s => s.Products).Returns(mockSet.Object);
var service = new Logic.Services.ProductService(mockContext.Object, fakemapper.Object, fakeCategoryService.Object);
// Act
var productsGot = service.GetAllProducts();
//Assert
Assert.AreEqual(products.Count, productsGot.Count());
}
public void ReturnCorrectData_WhenInvoked()
{
// Arrange
Mapper.Reset();
AutomapperConfiguration.Initialize();
var mockContext = new Mock <IOnlineStoreContext>();
var stubDateTimeProvider = new MockDateTimeProvider();
var orders = new List <Order> {
new Order {
Comment = "Patka", CourierId = 1, OrderedOn = stubDateTimeProvider.Now, UserId = 1, User = new User()
{
Username = "******"
}
}
};
var mockSet = new Mock <DbSet <Order> >();
mockSet.SetupData(orders);
mockContext.Setup(s => s.Orders).Returns(mockSet.Object);
var service = new Logic.Services.OrderService(mockContext.Object);
// Act
var ordersGot = service.GetAllOrders();
//Assert
Assert.AreEqual(orders.Count, ordersGot.Count());
}
public void AssemblyInitialization()
{
AutomapperConfiguration.Initialize();
var jurisdiction = new Jurisdiction("ori", "agencyCode");
AgencyDetails = new AgencyDerived(jurisdiction, "name");
}
public void ReturnInstanceOfTypeIEnumerableProductModel_WhenInvoked()
{
// Arrange
Mapper.Reset();
AutomapperConfiguration.Initialize();
var mockContext = new Mock <IOnlineStoreContext>();
var productsMock = new List <Product> {
new Product {
Name = "Testproduct", Quantity = 5, Category = new Category()
{
Name = "Patki"
}
}
}.GetQueryableMockDbSet();
var fakemapper = new Mock <IMapper>();
var fakeCategoryService = new Mock <ICategoryService>();
mockContext.Setup(s => s.Products).Returns(productsMock.Object);
var service = new Logic.Services.ProductService(mockContext.Object, fakemapper.Object, fakeCategoryService.Object);
// Act
var products = service.GetProductsByCategoryName("Patki");
//Assert
Assert.IsInstanceOfType(products, typeof(IEnumerable <ProductModel>));
}
public void ThrowArgumentNullException_WhenSportscardsIsNull()
{
//Arrange
var dbContextMock = new Mock <ISportscardSystemDbContext>();
var mapperMock = new Mock <IMapper>();
var data = new List <Sportscard>
{
new Sportscard {
CreatedOn = DateTime.Today.AddDays(-1)
}
};
var mockSet = new Mock <DbSet <Sportscard> >();
mockSet.SetupData(data);
Mapper.Reset();
AutomapperConfiguration.Initialize();
dbContextMock
.Setup(x => x.Sportscards)
.Returns((IDbSet <Sportscard>)null);
var sportscardDto = new SportscardDto()
{
CompanyId = Guid.NewGuid()
};
var sportscardService = new SportscardService(dbContextMock.Object, mapperMock.Object);
//Act && Assert
Assert.ThrowsException <ArgumentNullException>(() => sportscardService.GetAllSportscards());
}
public void ThrowArgumentNullException_WhenSportshallsIsNull()
{
//Arrange
var dbContextMock = new Mock <ISportscardSystemDbContext>();
var mapperMock = new Mock <IMapper>();
var data = new List <Sportshall>
{
new Sportshall {
Name = "Sportshall1"
},
new Sportshall {
Name = "Sportshall2"
},
new Sportshall {
Name = "Sportshall3"
}
};
var mockSet = new Mock <DbSet <Sportshall> >();
mockSet.SetupData(data);
Mapper.Reset();
AutomapperConfiguration.Initialize();
dbContextMock
.Setup(x => x.Sportshalls)
.Returns((IDbSet <Sportshall>)null);
var sportService = new SportshallService(dbContextMock.Object, mapperMock.Object);
//Act && Assert
Assert.ThrowsException <ArgumentNullException>(() => sportService.GetAllSportshalls());
}
public void ReturnCorrectAmountOfProducts_WhenInvoked()
{
// Arrange
Mapper.Reset();
AutomapperConfiguration.Initialize();
var mockContext = new Mock <IOnlineStoreContext>();
var productsMock = new List <Product> {
new Product {
Name = "Testproduct", Quantity = 5, Category = new Category()
{
Name = "Patki"
}
}
}.GetQueryableMockDbSet();
var fakemapper = new Mock <IMapper>();
var fakeCategoryService = new Mock <ICategoryService>();
mockContext.Setup(s => s.Products).Returns(productsMock.Object);
var service = new Logic.Services.ProductService(mockContext.Object, fakemapper.Object, fakeCategoryService.Object);
// Act
var products = service.GetProductsByCategoryName("Patki");
//Assert
Assert.AreEqual(1, products.Count());
}
public void ThrowArgumentException_WhenProductExists()
{
//Arrange
Mapper.Reset();
AutomapperConfiguration.Initialize();
var mockContext = new Mock <IOnlineStoreContext>();
var products = new List <Product> {
new Product {
Name = "Testproduct", Quantity = 5, Category = new Category {
Name = "Patki"
}
}
};
var fakemapper = new Mock <IMapper>();
var fakeCategoryService = new Mock <ICategoryService>();
var mockSet = new Mock <DbSet <Product> >();
mockSet.SetupData(products);
mockContext.Setup(s => s.Products).Returns(mockSet.Object);
var service = new Logic.Services.ProductService(mockContext.Object, fakemapper.Object, fakeCategoryService.Object);
//Act
var productToAdd = new ProductImportModel {
Name = "Testproduct"
};
//Assert
Assert.ThrowsException <ArgumentException>(() => service.AddProduct(productToAdd));
}
public void ThrowArgumentNullException_WhenSportshallsIsNull()
{
//Arrange
var dbContextMock = new Mock <ISportscardSystemDbContext>();
var mapperMock = new Mock <IMapper>();
var data = new List <Visit>
{
new Visit {
CreatedOn = DateTime.Today.AddDays(-1)
}
};
var mockSet = new Mock <DbSet <Visit> >();
mockSet.SetupData(data);
Mapper.Reset();
AutomapperConfiguration.Initialize();
dbContextMock
.Setup(x => x.Visits)
.Returns((IDbSet <Visit>)null);
var visitService = new VisitService(dbContextMock.Object, mapperMock.Object);
//Act && Assert
Assert.ThrowsException <ArgumentNullException>(() => visitService.GetAllVisits());
}
public void ThrowArgumentNullException_WhenClientsIsNull()
{
//Arrange
var dbContextMock = new Mock <ISportscardSystemDbContext>();
var mapperMock = new Mock <IMapper>();
var data = new List <Client>
{
new Client {
FirstName = "Stamat", LastName = "Stamateev", Age = 26
},
new Client {
FirstName = "Stamat", LastName = "Stamatev", Age = 27
},
new Client {
FirstName = "Stamat", LastName = "Stamatav", Age = 28
}
};
var mockSet = new Mock <DbSet <Client> >();
mockSet.SetupData(data);
Mapper.Reset();
AutomapperConfiguration.Initialize();
dbContextMock
.Setup(x => x.Clients)
.Returns((IDbSet <Client>)null);
var clientService = new ClientService(dbContextMock.Object, mapperMock.Object);
//Act && Assert
Assert.ThrowsException <ArgumentNullException>(() => clientService.GetAllClients());
}
public void InvokeAddMethod_WhenModelsAreValid()
{
//Arrange
Mapper.Reset();
AutomapperConfiguration.Initialize();
var productToImport = new ProductImportModel
{
Category = "TestCategory",
Name = "TestProduct 2",
PurchasePrice = 50m,
Quantity = 5,
Supplier = "TestSupplier"
};
var productToImport2 = new ProductImportModel
{
Category = "TestCategory",
Name = "TestProduct 5",
PurchasePrice = 50m,
Quantity = 5,
Supplier = "TestSupplier"
};
var productsToImport = new List <ProductImportModel> {
productToImport, productToImport2
};
var mockContext = new Mock <IOnlineStoreContext>();
var productsMock = new List <Product> ().GetQueryableMockDbSet();
var categoriesMock = new List <Category> {
new Category {
Name = "TestCategory"
}
}.GetQueryableMockDbSet();
var suppliersMock = new List <Supplier> {
new Supplier {
Name = "TestSupplier"
}
}.GetQueryableMockDbSet();
var fakemapper = new Mock <IMapper>();
fakemapper.SetupSequence(x => x.Map <IProductImportModel, Product>(It.IsAny <IProductImportModel>())).Returns(new Product {
Name = productToImport.Name, PurchasePrice = productToImport.PurchasePrice, SellingPrice = productToImport.PurchasePrice * 1.5m, Quantity = productToImport.Quantity
}).Returns(new Product {
Name = productToImport2.Name, PurchasePrice = productToImport2.PurchasePrice, SellingPrice = productToImport2.PurchasePrice * 1.5m, Quantity = productToImport2.Quantity
});
var fakeCategoryService = new Mock <ICategoryService>();
mockContext.Setup(s => s.Categories).Returns(categoriesMock.Object);
mockContext.Setup(s => s.Suppliers).Returns(suppliersMock.Object);
mockContext.Setup(s => s.Products).Returns(productsMock.Object);
var service = new Logic.Services.ProductService(mockContext.Object, fakemapper.Object, fakeCategoryService.Object);
//Act
service.AddProductRange(productsToImport);
//Assert
productsMock.Verify(v => v.Add(It.IsAny <Product>()), Times.Exactly(2));
}
protected void Application_Start()
{
AutomapperConfiguration.Initialize();
AutofacConfig.ConfigureContainer();
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc()
.AddJsonOptions(x => x.SerializerSettings.Formatting = Formatting.Indented)
.AddJsonOptions(options =>
{
options.SerializerSettings.DateFormatString = Configuration["DateTimeFormat:DefaultFormat"];
});
services.Configure <JwtSettings>(Configuration.GetSection("Jwt"));
services.Configure <ExternalApiSettings>(Configuration.GetSection("ExternalApi"));
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new Info {
Title = "Weather App API", Version = "v1"
});
});
services.AddScoped <IExternalApiWeatherHandler, ExternalApiWeatherHandler>();
services.AddScoped <IUserService, UserService>();
services.AddScoped <IUserRepository, UserRepository>();
services.AddScoped <ITokenService, TokenService>();
services.AddScoped <IWeatherMeasureService, WeatherMeasureService>();
services.AddScoped <IWeatherMeasureRepository, WeatherMeasureRepository>();
services.AddScoped <ICityService, CityService>();
services.AddScoped <ICityRepository, CityRepository>();
services.AddSingleton(AutomapperConfiguration.Initialize());
services.AddDbContext <WeatherDBContext>(options => options.UseSqlServer(Configuration["ConnectionStrings:DefaultConnection"]));
// In production, the React files will be served from this directory
services.AddSpaStaticFiles(configuration =>
{
configuration.RootPath = "ClientApp/build";
});
string securityKey = Configuration["Jwt:Key"];
var symmetricSecurityKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(securityKey));
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
.AddJwtBearer(options =>
{
options.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuer = true,
ValidateAudience = false,
ValidateIssuerSigningKey = true,
ValidIssuer = Configuration["Jwt:Issuer"],
IssuerSigningKey = symmetricSecurityKey
};
});
}
public void ClasslevelSetUp()
{
AutomapperConfiguration.Initialize();
_factory = new MockRepository(MockBehavior.Loose);
_classicRmsMasterIndicesRepository = _factory.Create <IClassicRMSMasterIndicesRepository>();
_summariesUnitOfWork = _factory.Create <ISummariesUnitOfWork>();
_reportsUnitOfWork = _factory.Create <IReportsUnitOfWork>();
_classicRmsMasterIndicesRepository.Setup(mock => mock.FindMasterProperty(It.IsAny <int>())).Returns(new ClassicMasterProperty());
_masterIndexSearchService = new MasterIndexSearchService(_classicRmsMasterIndicesRepository.Object, _summariesUnitOfWork.Object, _reportsUnitOfWork.Object, Mock.Of <ILog>(), Mock.Of <IServiceAuthorizationPolicy>(), Mock.Of <IServiceIdentityProvider>());
}
static void Main()
{
AutomapperConfiguration.Initialize();
var builder = new ContainerBuilder();
builder.RegisterModule(new AutofacConfiguration());
var container = builder.Build();
var engine = container.Resolve <IEngine>();
engine.Run();
}
public void InvokeCategoryServiceCreate_WhenCategoryNotAvailable()
{
//Arrange
Mapper.Reset();
AutomapperConfiguration.Initialize();
var productToImport = new ProductImportModel
{
Category = "Patkiii",
Name = "TestProduct",
PurchasePrice = 50m,
Quantity = 5,
Supplier = "TestSupplier"
};
var productsToImport = new List <ProductImportModel> {
productToImport
};
var mockContext = new Mock <IOnlineStoreContext>();
var productsMock = new List <Product>().GetQueryableMockDbSet();
var categoriesMock = new List <Category> {
new Category {
Name = "TestCategory"
}
}.GetQueryableMockDbSet();
var categoriesAddedMock = new List <Category> {
new Category {
Name = "Patkiii"
}
}.GetQueryableMockDbSet();
var suppliersMock = new List <Supplier> {
new Supplier {
Name = "TestSupplier"
}
}.GetQueryableMockDbSet();
var fakemapper = new Mock <IMapper>();
fakemapper.Setup(x => x.Map <IProductImportModel, Product>(It.IsAny <IProductImportModel>())).Returns(new Product {
Name = productToImport.Name, PurchasePrice = productToImport.PurchasePrice, SellingPrice = productToImport.PurchasePrice * 1.5m, Quantity = productToImport.Quantity
});
var fakeCategoryService = new Mock <ICategoryService>();
mockContext.SetupSequence(s => s.Categories).Returns(categoriesMock.Object).Returns(categoriesAddedMock.Object);
mockContext.Setup(s => s.Suppliers).Returns(suppliersMock.Object);
mockContext.Setup(s => s.Products).Returns(productsMock.Object);
var service = new Logic.Services.ProductService(mockContext.Object, fakemapper.Object, fakeCategoryService.Object);
//Act
service.AddProductRange(productsToImport);
//Assert
fakeCategoryService.Verify(v => v.Create(It.IsAny <string>()), Times.Once);
}
public void InvokeRemoveMethod_WhenProductIsFound()
{
//Arrange
Mapper.Reset();
AutomapperConfiguration.Initialize();
var productToAdd = new ProductImportModel
{
Name = "Testproduct2",
Supplier = "TestSupplier",
Category = "TestCategory",
PurchasePrice = 5.50m,
Quantity = 5
};
var mockContext = new Mock <IOnlineStoreContext>();
var productsMock = new List <Product> {
new Product {
Name = "Testproduct", Quantity = 5, Category = new Category {
Name = "Patki"
}
}
}.GetQueryableMockDbSet();
var categoriesMock = new List <Category> {
new Category {
Name = "TestCategory"
}
}.GetQueryableMockDbSet();
var suppliersMock = new List <Supplier> {
new Supplier {
Name = "TestSupplier"
}
}.GetQueryableMockDbSet();
var fakemapper = new Mock <IMapper>();
fakemapper.Setup(x => x.Map <Product>(It.IsAny <IProductImportModel>())).Returns(new Product {
Name = productToAdd.Name, PurchasePrice = productToAdd.PurchasePrice, SellingPrice = productToAdd.PurchasePrice * 1.5m
});
var fakeCategoryService = new Mock <ICategoryService>();
mockContext.Setup(s => s.Categories).Returns(categoriesMock.Object);
mockContext.Setup(s => s.Suppliers).Returns(suppliersMock.Object);
mockContext.Setup(s => s.Products).Returns(productsMock.Object);
var service = new Logic.Services.ProductService(mockContext.Object, fakemapper.Object, fakeCategoryService.Object);
//Act
service.RemoveProductByName("Testproduct");
//Assert
productsMock.Verify(v => v.Remove(It.IsNotNull <Product>()), Times.Once);
}
public void ClassLevelSetup()
{
AutomapperConfiguration.Initialize();
_administrationUnitOfWork = new Mock <IAdministrationUnitOfWork>();
Assert.IsInstanceOf(typeof(IAdministrationUnitOfWork), _administrationUnitOfWork.Object);
_identityProvider = new Mock <IServiceIdentityProvider>();
_authorizationPolicy = new Mock <IServiceAuthorizationPolicy>();
_dependencyContainer = new Mock <IDependencyContainer>();
Assert.IsInstanceOf(typeof(IDependencyContainer), _dependencyContainer.Object);
_userQueryService = new UserQueryService(_administrationUnitOfWork.Object, Mock.Of <ILog>(), _authorizationPolicy.Object, _identityProvider.Object);
Assert.IsInstanceOf(typeof(UserQueryService), _userQueryService);
SetUpUser();
SetAgencyPermissions();
}
private void RegisterContainer()
{
if (!AutomapperConfiguration.ShouldInitialize)
{
AutomapperConfiguration.Initialize();
}
var builder = new ContainerBuilder();
builder.RegisterAssemblyModules(Assembly.GetExecutingAssembly());
var container = builder.Build();
this.MainController = container.Resolve <IMainController>();
this.UserContext = container.Resolve <UserContext>();
}
public void ReturnInstanceOfTypeIEnumerableIOrderProduct_WhenInvoked()
{
// Arrange
Mapper.Reset();
AutomapperConfiguration.Initialize();
var mockContext = new Mock <IOnlineStoreContext>();
var usersMock = new List <User> {
new User {
Username = "******"
}
}.GetQueryableMockDbSet();
var couriersMock = new List <Courier> {
new Courier {
FirstName = "Peshko", LastName = "Peshkov"
}
}.GetQueryableMockDbSet();
var ordersMock = new List <Order> {
new Order()
}.GetQueryableMockDbSet();
var productsMock = new List <Product> {
new Product {
Name = "Testproduct", Quantity = 5
}
}.GetQueryableMockDbSet();
var orderProductsMock = new List <OrderProduct> {
new OrderProduct()
}.GetQueryableMockDbSet();
IDictionary <string, int> productsCounts = new Dictionary <string, int>();
productsCounts.Add("Testproduct", 2);
mockContext.Setup(x => x.Users).Returns(usersMock.Object);
mockContext.Setup(x => x.Couriers).Returns(couriersMock.Object);
mockContext.Setup(s => s.Orders).Returns(ordersMock.Object);
mockContext.Setup(s => s.Products).Returns(productsMock.Object);
mockContext.Setup(s => s.OrderProducts).Returns(orderProductsMock.Object);
var service = new Logic.Services.OrderService(mockContext.Object);
// Act
var orders = service.GetAllOrders();
//Assert
Assert.IsInstanceOfType(orders, typeof(IEnumerable <IOrderModel>));
}
public void ThrowArgumentException_WhenSupplierNotFound()
{
//Arrange
Mapper.Reset();
AutomapperConfiguration.Initialize();
var productToImport = new ProductImportModel
{
Category = "TestCategory",
Name = "TestProduct",
PurchasePrice = 50m,
Quantity = 5,
Supplier = "Pesho"
};
var productsToImport = new List <ProductImportModel> {
productToImport
};
var mockContext = new Mock <IOnlineStoreContext>();
var productsMock = new List <Product>().GetQueryableMockDbSet();
var categoriesMock = new List <Category> {
new Category {
Name = "TestCategory"
}
}.GetQueryableMockDbSet();
var suppliersMock = new List <Supplier> {
new Supplier {
Name = "TestSupplier"
}
}.GetQueryableMockDbSet();
var fakemapper = new Mock <IMapper>();
fakemapper.Setup(x => x.Map <IProductImportModel, Product>(It.IsAny <IProductImportModel>())).Returns(new Product {
Name = productToImport.Name, PurchasePrice = productToImport.PurchasePrice, SellingPrice = productToImport.PurchasePrice * 1.5m, Quantity = productToImport.Quantity
});
var fakeCategoryService = new Mock <ICategoryService>();
mockContext.Setup(s => s.Categories).Returns(categoriesMock.Object);
mockContext.Setup(s => s.Suppliers).Returns(suppliersMock.Object);
mockContext.Setup(s => s.Products).Returns(productsMock.Object);
var service = new Logic.Services.ProductService(mockContext.Object, fakemapper.Object, fakeCategoryService.Object);
//Act && Assert
Assert.ThrowsException <ArgumentException>(() => service.AddProductRange(productsToImport));
}
public void ThrowArgumentException_WhenCategoryNotFound()
{
//Arrange
Mapper.Reset();
AutomapperConfiguration.Initialize();
var mockContext = new Mock <IOnlineStoreContext>();
var products = new List <Product> {
new Product {
Name = "Testproduct", Quantity = 5, Category = new Category {
Name = "Patki"
}
}
};
var categoriesMock = new List <Category> {
new Category {
Name = "TestCategory"
}
}.GetQueryableMockDbSet();
var suppliersMock = new List <Supplier> {
new Supplier {
Name = "TestSupplier"
}
}.GetQueryableMockDbSet();
var fakemapper = new Mock <IMapper>();
var fakeCategoryService = new Mock <ICategoryService>();
var mockSet = new Mock <DbSet <Product> >();
mockSet.SetupData(products);
mockContext.Setup(s => s.Products).Returns(mockSet.Object);
mockContext.Setup(s => s.Categories).Returns(categoriesMock.Object);
mockContext.Setup(s => s.Suppliers).Returns(suppliersMock.Object);
var service = new Logic.Services.ProductService(mockContext.Object, fakemapper.Object, fakeCategoryService.Object);
//Act
var productToAdd = new ProductImportModel {
Name = "Testproduct2", Category = "Gubi"
};
//Assert
Assert.ThrowsException <ArgumentException>(() => service.AddProduct(productToAdd));
}
public override void Load()
{
Bind <ISampleService>().To <SampleService>();
Bind <IUserService>().To <UserService>();
Bind <IUserProfileService>().To <UserProfileService>();
Bind <IvUserProfileService>().To <VUserProfileService>();
Bind <IDirectionService>().To <DirectionService>();
Bind <IUserProgressService>().To <UserProgressService>();
Bind <ITaskTrackService>().To <TaskTrackService>();
Bind <ITaskService>().To <TaskService>();
Bind <IvUserTaskService>().To <VUserTaskService>();
Bind <ISender>().To <Sender>()
.InSingletonScope()
.WithConstructorArgument("apiKey", ConfigurationManager.AppSettings["apiKey"])
.WithConstructorArgument("email", ConfigurationManager.AppSettings["email"]);
Bind <IMapper>()
.ToMethod(c => AutomapperConfiguration.Initialize()
.CreateMapper())
.InSingletonScope();
Bind <DefaultFilterProviders>().ToConstant(new DefaultFilterProviders(GlobalConfiguration.Configuration.Services.GetFilterProviders()));
}
public void ReturnAllCategoriesCorrect()
{
var stubDBContext = new Mock <IOnlineStoreContext>();
var stubMapper = new Mock <IMapper>();
var fakeCategoryService = new CategoryService(stubDBContext.Object, stubMapper.Object);
var data = new List <Category>
{
new Category
{
Id = 1,
Name = "test",
Products = new Collection <Product>()
},
new Category
{
Id = 1,
Name = "test",
Products = new Collection <Product>()
},
new Category
{
Id = 1,
Name = "test",
Products = new Collection <Product>()
}
};
var stubDbSet = new Mock <DbSet <Category> >();
stubDbSet.SetupData(data);
stubDBContext.Setup(x => x.Categories).Returns(stubDbSet.Object);
Mapper.Reset();
AutomapperConfiguration.Initialize();
//Act
var foundCategories = fakeCategoryService.GetAllCategories();
//Assert
Assert.AreEqual(data.Count, foundCategories.Count());
}
public void ReturnIEnumerableOfSportshallsDto_WhenCollectionIsNotNull()
{
//Arrange
var dbContextMock = new Mock <ISportscardSystemDbContext>();
var mapperMock = new Mock <IMapper>();
var data = new List <Sportshall>
{
new Sportshall {
Name = "Sportshall1"
},
new Sportshall {
Name = "Sportshall2"
},
new Sportshall {
Name = "Sportshall3"
}
};
var mockSet = new Mock <DbSet <Sportshall> >();
mockSet.SetupData(data);
Mapper.Reset();
AutomapperConfiguration.Initialize();
dbContextMock
.Setup(x => x.Sportshalls)
.Returns(mockSet.Object);
var sportshallService = new SportshallService(dbContextMock.Object, mapperMock.Object);
//Act
var sportshalls = sportshallService.GetAllSportshalls();
//Assert
Assert.AreEqual(data.Count, sportshalls.Count());
Assert.IsNotNull(sportshalls);
Assert.IsInstanceOfType(sportshalls, typeof(IEnumerable <ISportshallDto>));
}
public void ReturnIEnumerableOfClientsDto_WhenCollectionIsNotNull()
{
//Arrange
var dbContextMock = new Mock <ISportscardSystemDbContext>();
var mapperMock = new Mock <IMapper>();
var data = new List <Client>
{
new Client {
FirstName = "Stamat", LastName = "Stamateev", Age = 26
},
new Client {
FirstName = "Stamat", LastName = "Stamatev", Age = 27
},
new Client {
FirstName = "Stamat", LastName = "Stamatav", Age = 28
}
};
var mockSet = new Mock <DbSet <Client> >();
mockSet.SetupData(data);
Mapper.Reset();
AutomapperConfiguration.Initialize();
dbContextMock
.Setup(x => x.Clients)
.Returns(mockSet.Object);
var clientService = new ClientService(dbContextMock.Object, mapperMock.Object);
//Act
var clients = clientService.GetAllClients();
//Assert
Assert.AreEqual(data.Count, clients.Count());
Assert.IsNotNull(clients);
Assert.IsInstanceOfType(clients, typeof(IEnumerable <IClientDto>));
}
public void ThrowArgumentException_WhenProductNotFound()
{
//Arrange
Mapper.Reset();
AutomapperConfiguration.Initialize();
var mockContext = new Mock <IOnlineStoreContext>();
var productsMock = new List <Product> {
new Product {
Name = "Testproduct", Quantity = 5, Category = new Category {
Name = "Patki"
}
}
}.GetQueryableMockDbSet();
var fakemapper = new Mock <IMapper>();
var fakeCategoryService = new Mock <ICategoryService>();
mockContext.Setup(s => s.Products).Returns(productsMock.Object);
var service = new Logic.Services.ProductService(mockContext.Object, fakemapper.Object, fakeCategoryService.Object);
//Act && Assert
Assert.ThrowsException <ArgumentException>(() => service.RemoveProductByName("Patka"));
}
public void ReturnInstanceOfTypeIProductModel_WhenProductExists()
{
//Arrange
Mapper.Reset();
AutomapperConfiguration.Initialize();
var mockContext = new Mock <IOnlineStoreContext>();
var productToAdd = new Product
{
Name = "Testproduct",
Quantity = 5,
Category = new Category {
Name = "Patki"
},
Supplier = new Supplier()
{
Name = "Pesho"
},
PurchasePrice = 50m,
SellingPrice = 75m
};
var productsMock = new List <Product> {
productToAdd
}.GetQueryableMockDbSet();
var fakemapper = new Mock <IMapper>();
fakemapper.Setup(x => x.Map <IProductModel>(It.IsAny <Product>())).Returns(new ProductModel {
Name = productToAdd.Name, PurchasePrice = productToAdd.PurchasePrice, SellingPrice = productToAdd.PurchasePrice * 1.5m, Quantity = productToAdd.Quantity, CategoryName = productToAdd.Category.Name
});
var fakeCategoryService = new Mock <ICategoryService>();
mockContext.Setup(s => s.Products).Returns(productsMock.Object);
var service = new Logic.Services.ProductService(mockContext.Object, fakemapper.Object, fakeCategoryService.Object);
//Act
var productFound = service.FindProductByName("Testproduct");
// Assert
Assert.IsInstanceOfType(productFound, typeof(IProductModel));
}
public void ReturnIEnumerableOfCompaniesDto_WhenCollectionIsNotNull()
{
//Arrange
var dbContextMock = new Mock <ISportscardSystemDbContext>();
var mapperMock = new Mock <IMapper>();
var data = new List <Company>
{
new Company {
Name = "Company1"
},
new Company {
Name = "Company2"
},
new Company {
Name = "Company3"
},
};
var mockSet = new Mock <DbSet <Company> >();
mockSet.SetupData(data);
Mapper.Reset();
AutomapperConfiguration.Initialize();
dbContextMock
.Setup(x => x.Companies)
.Returns(mockSet.Object);
var companyService = new CompanyService(dbContextMock.Object, mapperMock.Object);
//Act
var companies = companyService.GetAllCompanies();
//Assert
Assert.AreEqual(data.Count, companies.Count());
Assert.IsNotNull(companies);
Assert.IsInstanceOfType(companies, typeof(IEnumerable <ICompanyDto>));
}
