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);
}
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);
}
//[AdminCreateLoggerFilter]
public async Task <IActionResult> Create(EventCreateBindingModel model)
{
if (ModelState.IsValid)
{
var @event = new Event
{
Name = model.Name,
Place = model.Place,
Start = model.Start,
End = model.End,
TotalTickets = model.TotalTickets,
PricePerTicket = model.PricePerTicket,
};
_context.Add(@event);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(All)));
}
return(View(model));
}
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 GetAll_WithNoOrdersInDbShouldReturnEmptyList()
{
var context = new EventuresDbContext(this.Options);
var orders = new List <Order>
{
};
await context.Orders.AddRangeAsync(orders);
await context.SaveChangesAsync();
var ordersService = new OrdersService(context);
var resultOrders = ordersService.GetAll();
Assert.Empty(resultOrders);
}
public async Task GetAllOrderedByStart_EmptyDbSetShouldReturnEmptyList()
{
var context = new EventuresDbContext(this.Options);
var events = new List <Event>
{
};
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);
}
public async Task Seed()
{
if (!context.Roles.Any())
{
context.Roles.Add(new IdentityRole
{
Name = "Admin",
NormalizedName = "ADMIN"
});
context.Roles.Add(new IdentityRole
{
Name = "User",
NormalizedName = "USER"
});
}
await context.SaveChangesAsync();
}
public async Task GetAll_ShouldReturnAllOrdersWithLoadedEventAndCustomer()
{
var context = new EventuresDbContext(this.Options);
var @event = new Event {
TotalTickets = 100, Name = "UnitTesting"
};
var customer = new User {
FirstName = "Pesho"
};
var orders = new List <Order>
{
new Order {
Event = @event, TicketsCount = 5, Customer = customer
},
new Order {
Event = @event, TicketsCount = 5, Customer = customer
},
new Order {
Event = @event, TicketsCount = 5, Customer = customer
},
new Order {
Event = @event, TicketsCount = 5, Customer = customer
},
new Order {
Event = @event, TicketsCount = 5, Customer = customer
},
};
await context.Orders.AddRangeAsync(orders);
await context.SaveChangesAsync();
var ordersService = new OrdersService(context);
var resultOrders = ordersService.GetAll();
Assert.Equal(5, resultOrders.Count);
Assert.Equal(customer.FirstName, resultOrders[0].Customer.FirstName);
Assert.Equal(@event.Name, resultOrders[0].Event.Name);
}
public async Task GetAll_WithTickets_ShouldReturnCorrectValue()
{
// Arrange
var options = new DbContextOptionsBuilder <EventuresDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;
var context = new EventuresDbContext(options);
var eventsService = new EventsService(context);
object[] models =
{
new EventuresEvent
{
Name = "Test Event 1",
Place = "Test Place 1",
StartDate = DateTime.UtcNow,
EndDate = DateTime.UtcNow,
TotalTickets = 2,
PricePerTicket = 2
},
new EventuresEvent
{
Name = "Test Event 2",
Place = "Test Place 2",
StartDate = DateTime.UtcNow,
EndDate = DateTime.UtcNow,
TotalTickets = 3,
PricePerTicket = 3
}
};
await context.AddRangeAsync(models);
await context.SaveChangesAsync();
// Act
var count = (await eventsService.GetAll()).Count();
// Assert
Assert.Equal(2, count);
}
public async Task Create_WithNullUser_ShouldNotChangeAnything()
{
// Arrange
const int ticketsCount = 10;
var context = new EventuresDbContext(new DbContextOptionsBuilder <EventuresDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var ordersService = new OrdersService(context);
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, null);
// Assert
Assert.False(result);
var remainingTickets = (await context.Events.SingleAsync()).TotalTickets;
Assert.Equal(ticketsCount, remainingTickets);
var count = await context.Orders.CountAsync();
Assert.Equal(0, count);
}
private async Task SeedEvents(EventuresDbContext context)
{
var sampleEvents = new List <EventuresEvent>();
for (var i = 0; i < 10; i++)
{
var sampleEvent = new EventuresEvent
{
Name = $"Event number {i}",
Place = $"Place number {i}",
Start = DateTime.Now.AddDays(i),
End = DateTime.Now.AddMonths(i),
PricePerTicket = 10 * i,
TotalTickets = 1000 * i
};
sampleEvents.Add(sampleEvent);
}
await context.Events.AddRangeAsync(sampleEvents);
await context.SaveChangesAsync();
}
public async Task InvokeAsync(HttpContext httpContext,
EventuresDbContext dbContext,
UserManager <EventuresUser> userManager,
RoleManager <IdentityRole> roleManager)
{
if (!this.executed)
{
this.executed = true;
dbContext.Database.EnsureCreated();
if (!await roleManager.RoleExistsAsync(GlobalConstants.AdminRoleName))
{
await roleManager.CreateAsync(new IdentityRole(GlobalConstants.AdminRoleName));
}
if (await dbContext.Events.CountAsync() < 35)
{
var currTime = DateTime.Now;
var random = new Random();
var events = new EventuresEvent[35];
for (int i = 0; i < 35; i++)
{
var startDate = currTime.AddDays(random.NextDouble() * 300 - 150);
var endDate = startDate.AddDays(random.NextDouble() * 15 + 5);
events[i] = new EventuresEvent
{
Name = "Seeded Event " + (i + 1),
Place = "Seeded Place " + (i % 10 + 1),
StartDate = startDate,
EndDate = endDate,
TotalTickets = random.Next(5, 500),
PricePerTicket = (decimal)random.NextDouble() * 150 + 50,
};
}
await dbContext.Events.AddRangeAsync(events);
await dbContext.SaveChangesAsync();
}
if (!userManager.Users.Any(u => u.UserName == "admin"))
{
var user = new EventuresUser
{
UserName = "******",
Email = "*****@*****.**",
FirstName = "admin",
LastName = "admin",
UniqueCitizenNumber = "0000000000"
};
await userManager.CreateAsync(user, "admin");
await userManager.AddToRoleAsync(user, GlobalConstants.AdminRoleName);
}
}
await this.next(httpContext);
}
public async Task GetAllForUser_WithNoOrders_ShouldWorkCorrectly()
{
// Arrange
var context = new EventuresDbContext(new DbContextOptionsBuilder <EventuresDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var ordersService = new OrdersService(context);
var eventModel = new EventuresEvent
{
Name = "Test Event",
TotalTickets = 30,
StartDate = DateTime.UtcNow,
EndDate = DateTime.UtcNow,
Place = "Test Place",
PricePerTicket = 30
};
await context.Events.AddAsync(eventModel);
var user = new EventuresUser
{
UserName = "******"
};
await context.Users.AddAsync(user);
var otherUser = new EventuresUser
{
UserName = "******"
};
await context.Users.AddAsync(otherUser);
var orders = new[]
{
new Order
{
OrderedOn = DateTime.UtcNow,
TicketsCount = 1,
Event = eventModel,
User = otherUser
},
new Order
{
OrderedOn = DateTime.UtcNow,
TicketsCount = 2,
Event = eventModel,
User = otherUser
},
new Order
{
OrderedOn = DateTime.UtcNow,
TicketsCount = 3,
Event = eventModel,
User = otherUser
}
};
await context.Orders.AddRangeAsync(orders);
await context.SaveChangesAsync();
// Act
var all = await ordersService.GetAllForUser(user.UserName);
// Assert
var count = all.Count();
Assert.Equal(0, count);
}
