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);
}
