public async Task Create_WithInvalidModel_ShouldNotAddToDatabase() { // Arrange var options = new DbContextOptionsBuilder <EventuresDbContext>() .UseInMemoryDatabase(Guid.NewGuid().ToString()) .Options; var context = new EventuresDbContext(options); var eventsService = new EventsService(context); var model = new EventuresEventServiceModel { Name = "Test Event", Place = "Test Place", StartDate = DateTime.UtcNow, EndDate = DateTime.UtcNow, TotalTickets = -1, PricePerTicket = 1 }; // Act await eventsService.CreateAsync(model); // Assert var count = await context.Events.CountAsync(); Assert.Equal(0, count); }
public void GetTotalTicketsByEventShouldReturnsCorrectTotalTicketsUsingDbContext() { var options = new DbContextOptionsBuilder <EventuresDbContext>() .UseInMemoryDatabase("Eventures_Database_4") .Options; var context = new EventuresDbContext(options); var service = new EventService(context); var eventInDb = new Event { Name = "Event", Place = "Sofia", Start = DateTime.UtcNow, End = DateTime.UtcNow, TotalTickets = 100, PricePerTicket = 25.5M }; context.Events.Add(eventInDb); context.SaveChanges(); var totalTickets = service.GetTotalTicketsByEvent(1); Assert.Equal(100, totalTickets); }
public async Task GetAllOrderedByStart_ShouldReturnOrderedByStartList() { var context = new EventuresDbContext(this.Options); var events = new List <Event> { new Event { Start = DateTime.UtcNow.AddDays(1) }, new Event { Start = DateTime.UtcNow.AddDays(3) }, new Event { Start = DateTime.UtcNow.AddDays(2) }, }; await context.Events.AddRangeAsync(events); await context.SaveChangesAsync(); var eventsService = new EventsService(context); var serviceResult = eventsService.GetAllOrderedByStart(); var expected = events.OrderBy(e => e.Start); Assert.Equal(expected, serviceResult); }
private static void SeedEvents(EventuresDbContext db) { if (db.Events.Count() > 0) { return; } var newEvent = new Eventures.Models.Event(999) { Name = "Mile Kitich", Place = "Враца", PricePerTicket = 19, Start = DateTime.UtcNow.AddDays(14), End = DateTime.UtcNow.AddDays(14).AddHours(6) }; db.Events.Add(newEvent); db.SaveChanges(); newEvent = new Eventures.Models.Event(45999) { Name = "Jon Bon Jovi", Place = "София", PricePerTicket = 99, Start = DateTime.UtcNow.AddDays(21), End = DateTime.UtcNow.AddDays(21).AddHours(6) }; db.Events.Add(newEvent); db.SaveChanges(); }
public void Configure(IApplicationBuilder app, IHostingEnvironment env, EventuresDbContext dbContext, RoleManager <IdentityRole> roleManager) { if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); app.UseDatabaseErrorPage(); } else { app.UseExceptionHandler("/Home/Error"); app.UseHsts(); } app.UseHttpsRedirection(); app.UseStaticFiles(); app.UseCookiePolicy(); app.UseAuthentication(); app.UseDatabaseSeeder(); app.UseMvc(routes => { routes.MapRoute( name: "areaRoute", template: "{area:exists}/{controller=Home}/{action=Index}/{id?}"); routes.MapRoute( name: "default", template: "{controller=Home}/{action=Index}/{id?}"); }); }
public void GetEventById_ShouldReturnSingleEventWithTheGivenId() { var context = new EventuresDbContext(this.Options); var events = new List <Event> { new Event { Id = "1", Name = "Event1" }, new Event { Id = "2", Name = "Event2" }, new Event { Id = "3", Name = "Event3" }, }; context.Events.AddRange(events); context.SaveChanges(); var service = new EventsService(context); var resultEvent = service.GetEventById("1"); Assert.Equal(events[0], resultEvent); Assert.Equal(events[0].Name, resultEvent.Name); }
public DbLoggerProvider( Func <string, LogLevel, bool> filter, EventuresDbContext dbContext) { this.filter = filter; this.dbContext = dbContext; }
public async Task Create_WithNonExistentEvent_ShouldNotChangeAnything() { // Arrange var context = new EventuresDbContext(new DbContextOptionsBuilder <EventuresDbContext>() .UseInMemoryDatabase(Guid.NewGuid().ToString()) .Options); var ordersService = new OrdersService(context); var user = new EventuresUser { UserName = "******" }; await context.Users.AddAsync(user); await context.SaveChangesAsync(); var model = new OrderServiceModel { EventId = Guid.NewGuid().ToString(), TicketsCount = 2 }; // Act var result = await ordersService.Create(model, user.UserName); // Assert Assert.False(result); var count = await context.Orders.CountAsync(); Assert.Equal(0, count); }
public async Task InvokeAsync( HttpContext context, EventuresDbContext dbContext, RoleManager <IdentityRole> roleManager, UserManager <User> userManager) { if (await roleManager.RoleExistsAsync("User") == false) { await roleManager.CreateAsync(new IdentityRole("User")); } if (await roleManager.RoleExistsAsync("Admin") == false) { await roleManager.CreateAsync(new IdentityRole("Admin")); } if (!dbContext.Users.Any(x => x.UserName == "Admin")) { var user = new User { UserName = "******", Email = "*****@*****.**", FirstName = "Secret", LastName = "Secret", }; var result = await userManager.CreateAsync(user, "Admin"); await userManager.AddToRoleAsync(user, "Admin"); } await next(context); }
public void GetEventByIdReturnsCorrectEvent() { var options = new DbContextOptionsBuilder <EventuresDbContext>() .UseInMemoryDatabase(databaseName: "Get_Event_by_Id_Db") .Options; var db = new EventuresDbContext(options); var @event = new Event { Name = "FootballGame", PricePerTicket = 10.25m, Place = "Somewhere", TotalTickets = 15000, Start = new DateTime(2018, 12, 23, 19, 30, 0), End = new DateTime(2018, 12, 23, 21, 0, 0), Id = "123" }; db.Events.AddRange(this.TestEvents().AsQueryable()); db.Events.Add(@event); db.SaveChanges(); Assert.True(db.Events.Count() == 4); var eventService = new EventService(db); var dbEvent = eventService.GetEventById("123"); Assert.True(dbEvent.Name == "FootballGame"); }
public EventService(EventuresDbContext context, ILogger <EventService> logger, IMapper mapper) { this.logger = logger; Context = context; Mapper = mapper; }
public EventServiceTests() { this.options = new DbContextOptionsBuilder <EventuresDbContext>() .UseInMemoryDatabase(Guid.NewGuid().ToString()) .Options; this.dbContext = new EventuresDbContext(options); this.events = new EventService(dbContext); }
public async Task InvokeAsync(HttpContext httpContext, EventuresDbContext dbContext, RoleManager <IdentityRole> roleManager, UserManager <EventuresUser> userManager) { this.roleManager = roleManager; this.userManager = userManager; this.SeedRoles(roleManager, userManager); await this.next(httpContext); }
public static ILoggerFactory AddContext( this ILoggerFactory factory, EventuresDbContext dbContext, Func <string, LogLevel, bool> filter = null) { factory.AddProvider(new DbLoggerProvider(filter, dbContext)); return(factory); }
public DbLogger( string categoryName, Func <string, LogLevel, bool> filter, EventuresDbContext dbContext) { this.categoryName = categoryName; this.filter = filter; this.context = dbContext; }
public UsersController( SignInManager <User> signInManager, UserManager <User> userManager, RoleManager <IdentityRole> roleManager, EventuresDbContext dbContext, IMapper mapper) { this._signInManager = signInManager; this._userManager = userManager; this._roleManager = roleManager; this._dbContext = dbContext; this._mapper = mapper; }
public UsersController( SignInManager <EventuresUser> signInManager, UserManager <EventuresUser> userManager, RoleManager <IdentityRole> roleManager, EventuresDbContext dbContext, IMapper mapper) { this.signInManager = signInManager; this.userManager = userManager; this.roleManager = roleManager; this.db = dbContext; this.mapper = mapper; }
public async Task CreateMethod_ShouldAddEventToContext() { var context = new EventuresDbContext(this.Options); var eventsService = new EventsService(context); await eventsService.CreateAsync("Name", "Place", 10.00m, 100, DateTime.UtcNow, DateTime.UtcNow.AddDays(3)); Assert.Equal(1, context.Events.Count()); }
private async Task SeedRoles(EventuresDbContext dbContext, RoleManager <IdentityRole> roleManager) { if (!dbContext.Roles.Any()) { await roleManager.CreateAsync(new IdentityRole("ADMIN")); await roleManager.CreateAsync(new IdentityRole("USER")); } }
public static ILoggerFactory AddContext( this ILoggerFactory factory, LogLevel minLevel, EventuresDbContext dbContext) { return(AddContext( factory, dbContext, (_, logLevel) => logLevel >= minLevel)); }
public async Task CreateMethod_ShouldAddOrderToDbContext() { var context = new EventuresDbContext(this.Options); var ordersService = new OrdersService(context); await ordersService.CreateAsync(new Event(), 10, new User()); Assert.Equal(1, context.Orders.Count()); }
public EventServiceTests() { ServiceCollection services = new ServiceCollection(); services.AddDbContext <EventuresDbContext>(options => options.UseInMemoryDatabase("EventuresTestDB")); _provider = services.BuildServiceProvider(); _db = _provider.GetService <EventuresDbContext>(); _service = new EventService(_provider.GetService <EventuresDbContext>(), null); }
public EventureEventsServiceTests() { var services = new ServiceCollection(); services.AddDbContext <EventuresDbContext>(opt => opt.UseInMemoryDatabase(Guid.NewGuid().ToString())); services.AddScoped <IEventuresEventsService, EventuresEventsService>(); this.provider = services.BuildServiceProvider(); this.context = provider.GetService <EventuresDbContext>(); this.service = provider.GetService <IEventuresEventsService>(); }
public async Task InvokeAsync( HttpContext httpContext, EventuresDbContext dbContext, RoleManager <IdentityRole> roleManager, UserManager <User> userManager) { await this.SeedRoles(dbContext, roleManager); await this.SeedFirstUser(dbContext, userManager); await this.next(httpContext); }
public void Seed(EventuresDbContext context) { if (!context.Roles.Any()) { context.Roles.Add(new UserRole { Name = "Admin", NormalizedName = "ADMIN" }); context.Roles.Add(new UserRole { Name = "User", NormalizedName = "USER" }); context.SaveChanges(); } }
public async Task Create_WithValidModel_ShouldWorkCorrectly() { // Arrange const int ticketsCount = 10; var context = new EventuresDbContext(new DbContextOptionsBuilder <EventuresDbContext>() .UseInMemoryDatabase(Guid.NewGuid().ToString()) .Options); var ordersService = new OrdersService(context); var user = new EventuresUser { UserName = "******" }; await context.Users.AddAsync(user); var eventModel = new EventuresEvent { Name = "TestEvent", TotalTickets = ticketsCount }; await context.Events.AddAsync(eventModel); await context.SaveChangesAsync(); var model = new OrderServiceModel { OrderedOn = DateTime.UtcNow, EventId = eventModel.Id, TicketsCount = 2 }; // Act var result = await ordersService.Create(model, user.UserName); // Assert Assert.True(result); var remainingTickets = (await context.Events.SingleAsync()).TotalTickets; Assert.Equal(ticketsCount - model.TicketsCount, remainingTickets); var count = await context.Orders.CountAsync(); Assert.Equal(1, count); var orderUserId = (await context.Orders.SingleAsync()).UserId; Assert.Equal(user.Id, orderUserId); }
public async Task GetAllForUser_WithNonExistentUser_ShouldWorkCorrectly() { // Arrange var context = new EventuresDbContext(new DbContextOptionsBuilder <EventuresDbContext>() .UseInMemoryDatabase(Guid.NewGuid().ToString()) .Options); var ordersService = new OrdersService(context); // Act var all = await ordersService.GetAllForUser("NonExistentUser"); // Assert Assert.Null(all); }
private void SeedOrders(EventuresDbContext dbContext) { var eventureEvent = dbContext.EventureEvents.FirstOrDefault(); var user = dbContext.Users.FirstOrDefault(); var order = new Order { CreatedOn = DateTime.Now.AddDays(1), Event = eventureEvent, User = user }; dbContext.Add(order); dbContext.SaveChanges(); }
public void AllOrdersWorksCorrectly() { var options = new DbContextOptionsBuilder <EventuresDbContext>() .UseInMemoryDatabase(databaseName: "All_Orders_Db") .Options; var db = new EventuresDbContext(options); db.Orders.AddRange(this.TestData().AsQueryable()); db.SaveChanges(); Assert.True(db.Orders.Count() == 3); Assert.True(db.Orders.First().Event.Name == "FootballGame"); Assert.True(db.Orders.ToList()[1].Event.Name == "PrivateParty"); Assert.True(db.Orders.Last().Event.Name == "New Years Eve"); }
public async Task InvokeAsync(HttpContext context, EventuresDbContext db, RoleManager <IdentityRole> roleManager) { if (!db.Events.Any()) { SeedEvents(db); } if (!roleManager.RoleExistsAsync("Administrator").Result) { await roleManager.CreateAsync(new IdentityRole("Administrator")); } await _next(context); }