public async Task GetAllTest()
{
var repo = new EventRepository(new Deserializer());
var lengthBefore = (await repo.GetAllAsync()).Count;
var event1 = new BetEvent
{
Id = Guid.NewGuid(), Name = "name1", Description = "desc1", BetDeadline = DateTime.Now, CreatorId = 1000000
};
await repo.CreateAsync(event1);
Thread.Sleep(1000);
var event2 = new BetEvent
{
Id = Guid.NewGuid(), Name = "name2", Description = "desc2", BetDeadline = DateTime.Now, CreatorId = event1.CreatorId
};
await repo.CreateAsync(event2);
Thread.Sleep(1000);
var event3 = new BetEvent
{
Id = Guid.NewGuid(), Name = "name3", Description = "desc3", BetDeadline = DateTime.Now, CreatorId = event1.CreatorId
};
await repo.CreateAsync(event3);
var events = await repo.GetAllAsync();
Assert.AreEqual(lengthBefore + 3, events.Count);
}
public override async Task UpdateWorksAsync()
{
int id = 0;
int wrongId = 10;
Event EventSaved = null;
// arrange (use the context directly - we assume that works)
var options = new DbContextOptionsBuilder <Project15Context>()
.UseInMemoryDatabase("db_Event_test_update").Options;
// act (for act, only use the repo, to test it)
using (var db = new Project15Context(options));
// act (for act, only use the repo, to test it)
using (var db = new Project15Context(options))
{
var repo = new EventRepository(db);
Event Event = new Event {
Name = $"Jazz Fest", Type = $"Music", Cost = 40
};
EventSaved = await repo.CreateAsync(Event);
await repo.SaveChangesAsync();
id = EventSaved.Id;
}
// assert (for assert, once again use the context directly for verify.)
using (var db = new Project15Context(options))
{
var repo = new EventRepository(db);
Event Event = await repo.GetByIdAsync(id);
Assert.NotEqual(0, Event.Id); // should get some generated ID
Assert.Equal(EventSaved.Id, Event.Id);
Assert.Equal("Jazz Fest", Event.Name);
Assert.Equal("Music", Event.Type);
Assert.Equal(40, Event.Cost);
Event.Name = "Hip-Hop-Night";
Event.Type = "Music";
await repo.UpdateAsync(Event, id);
await repo.SaveChangesAsync();
Event = await repo.GetByIdAsync(Event.Id);
Assert.NotEqual(wrongId, Event.Id);
Assert.Equal("Hip-Hop-Night", Event.Name);
Assert.Equal("Music", Event.Type);
}
}
public async Task DeleteTest()
{
var repo = new EventRepository(new Deserializer());
var event1 = new BetEvent
{
Id = Guid.NewGuid(), Name = "name1", Description = "desc1", BetDeadline = DateTime.Now, CreatorId = 389
};
await repo.CreateAsync(event1);
await repo.DeleteAsync(event1.Id);
}
public async Task CreateTest()
{
var repo = new EventRepository(new Deserializer());
var event1 = new BetEvent
{
Id = Guid.NewGuid(), Name = "name1", Description = "desc1", BetDeadline = DateTime.Now, CreatorId = 235
};
var createdEvent = await repo.CreateAsync(event1);
Assert.AreEqual(event1.Id, createdEvent.Id);
}
public async Task <IHttpActionResult> CreateEventAsync(Core.Model.Event obj)
{
try
{
var result = await eventRepo.CreateAsync(obj);
return(Created(Request.RequestUri.ToString() + "/" + result.Id, result));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task UpdateTest()
{
var repo = new EventRepository(new Deserializer());
var event1 = new BetEvent
{
Id = Guid.NewGuid(), Name = "name1", Description = "desc1", BetDeadline = DateTime.Now, CreatorId = 134
};
await repo.CreateAsync(event1);
var event2 = new BetEvent
{
Id = event1.Id, Name = "namenew", Description = "descnew", BetDeadline = DateTime.Now, CreatorId = event1.CreatorId
};
var updatedEvent = await repo.UpdateAsync(event2);
Assert.AreEqual(updatedEvent.Id, event1.Id);
}
public override async Task GetAllWorksAsync()
{
List <Event> Events = new List <Event>();
Event EventSaved = null;
var options = new DbContextOptionsBuilder <Project15Context>()
.UseInMemoryDatabase("db_Event_test_getAll").Options;
using (var db = new Project15Context(options));
using (var db = new Project15Context(options))
{
var repo = new EventRepository(db);
for (int i = 0; i < 5; i++)
{
Event Event = new Event {
Name = $"Jazz Fest {i}", Type = $"Music {i}", Cost = i
};
EventSaved = await repo.CreateAsync(Event);
await repo.SaveChangesAsync();
Events.Add(EventSaved);
}
}
using (var db = new Project15Context(options))
{
var repo = new EventRepository(db);
List <Event> EventList = (List <Event>) await repo.GetAllAsync();
// should equal the same amount of Events
Assert.Equal(Events.Count, EventList.Count);
for (int i = 0; i < Events.Count; i++)
{
Assert.Equal(Events[i].Name, EventList[i].Name);
Assert.Equal(Events[i].Type, EventList[i].Type);
Assert.Equal(Events[i].Cost, EventList[i].Cost);
Assert.NotEqual(0, Events[i].Id);
}
}
}
public async Task <int> CreateEvent(EventBody eventBody, int locationId, int organiserId)
{
// save image to blob
string imageName = await azureService.saveImageToBlobStorage(eventBody.Image);
// create new event
Event newEvent = new Event
{
Title = eventBody.Title,
Description = eventBody.Description,
StartTime = eventBody.StartTime,
OrganisorId = organiserId,
Image = imageName,
MaxRegistrations = eventBody.MaxRegistrations,
LocationId = locationId
};
// save event
await eventRepository.CreateAsync(newEvent);
return(newEvent.Id);
}
public async Task CreateAsync_given_event_create()
{
using (var connection = await CreateConnectionAsync())
using (var context = await CreateContextAsync(connection))
{
var repo = new EventRepository(context);
var ev = new EventDTO
{
DateTime = new DateTime(2019, 08, 03, 15, 0, 0),
Location = "location",
WineType = WineTypes.Rose
};
var created = await repo.CreateAsync(ev);
var entity = await context.Events.FindAsync(created);
Assert.Equal(new DateTime(2019, 08, 03, 15, 0, 0), entity.DateTime);
Assert.Equal("location", entity.Location);
Assert.Equal(WineTypes.Rose, entity.WineType);
}
}
public override async Task CreateWorksAsync()
{
Event EventSaved = null;
// arrange (use the context directly - we assume that works)
var options = new DbContextOptionsBuilder <Project15Context>()
.UseInMemoryDatabase("db_event_test_create").Options;
using (var db = new Project15Context(options));
// act (for act, only use the repo, to test it)
using (var db = new Project15Context(options))
{
var repo = new EventRepository(db);
//Create Event
Event Event = new Event {
Name = "Jazz Fest", Type = "Music", Cost = 40
};
EventSaved = await repo.CreateAsync(Event);
await repo.SaveChangesAsync();
}
// assert (for assert, once again use the context directly for verify.)
using (var db = new Project15Context(options))
{
var repo = new EventRepository(db);
Event Event = Mapper.Map <Events, Event>(db.Events.First(m => m.Name == "Jazz Fest"));
Assert.NotEqual(0, Event.Id); // should get some generated ID
Assert.Equal(EventSaved.Id, Event.Id);
Assert.Equal("Jazz Fest", Event.Name);
Assert.Equal("Music", Event.Type);
Assert.Equal(40, Event.Cost);
}
}
public override async Task DeleteWorksAsync()
{
int id = 0;
Customer customerSaved = null;
Event EventSaved = null;
EventCustomer eventCustomerSaved = null;
// arrange (use the context directly - we assume that works)
var options = new DbContextOptionsBuilder <Project15Context>()
.UseInMemoryDatabase("db_eventcustomer_test_delete_2").Options;
using (var db = new Project15Context(options));
// act (for act, only use the repo, to test it)
using (var db = new Project15Context(options))
{
var customerRepo = new CustomerRepository(db);
var eventRepo = new EventRepository(db);
var repo = new EventCustomerRepository(db);
//Create customer
Customer customer = new Customer {
Name = "Axel", Address1 = "111 Address"
};
customer = await customerRepo.CreateAsync(customer);
await customerRepo.SaveChangesAsync();
Event Event = new Event {
Name = "Jazz Fest", Type = "Music", Cost = 40
};
Event = await eventRepo.CreateAsync(Event);
await eventRepo.SaveChangesAsync();
EventCustomer eventCustomer = new EventCustomer
{
CustomerId = customer.Id,
EventId = Event.Id,
Paid = true
};
eventCustomerSaved = await repo.CreateAsync(eventCustomer);
await repo.SaveChangesAsync();
EventSaved = Event;
customerSaved = customer;
id = eventCustomerSaved.Id;
}
// assert (for assert, once again use the context directly for verify.)
using (var db = new Project15Context(options))
{
var repo = new EventCustomerRepository(db);
EventCustomer eventCustomer = await repo.GetByIdAsync(id);
Assert.NotEqual(0, eventCustomer.Id);
Assert.Equal(eventCustomerSaved.Id, eventCustomer.Id);
Assert.True(eventCustomer.Paid);
await repo.DeleteAsync(id);
await repo.SaveChangesAsync();
eventCustomer = await repo.GetByIdAsync(id);
Assert.Null(eventCustomer);
}
}
public override async Task UpdateWorksAsync()
{
int id = 0;
int wrongId = 10;
EventCustomer eventCustomerSaved = null;
Event EventSaved = null;
Customer customerSaved = null;
// arrange (use the context directly - we assume that works)
var options = new DbContextOptionsBuilder <Project15Context>()
.UseInMemoryDatabase("db_eventcustomer_test_updatebyid").Options;
// act (for act, only use the repo, to test it)
using (var db = new Project15Context(options));
using (var db = new Project15Context(options))
{
var customerRepo = new CustomerRepository(db);
var eventRepo = new EventRepository(db);
var repo = new EventCustomerRepository(db);
Customer customer = new Customer {
Name = "Axel", Address1 = "111 Address"
};
customer = await customerRepo.CreateAsync(customer);
await customerRepo.SaveChangesAsync();
Event Event = new Event {
Name = "Jazz Fest", Type = "Music", Cost = 40
};
Event = await eventRepo.CreateAsync(Event);
await eventRepo.SaveChangesAsync();
EventCustomer eventCustomer = new EventCustomer
{
CustomerId = customer.Id,
EventId = Event.Id,
Paid = true
};
eventCustomerSaved = await repo.CreateAsync(eventCustomer);
await repo.SaveChangesAsync();
EventSaved = Event;
customerSaved = customer;
id = eventCustomerSaved.Id;
}
using (var db = new Project15Context(options))
{
var repo = new EventCustomerRepository(db);
EventCustomer eventCustomer = await repo.GetByIdAsync(id);
Assert.NotEqual(0, eventCustomer.Id); // should get some generated ID
Assert.Equal(eventCustomerSaved.Id, eventCustomer.Id);
Assert.Equal(EventSaved.Id, eventCustomer.EventId);
eventCustomer.Paid = false;
await repo.UpdateAsync(eventCustomer, id);
await repo.SaveChangesAsync();
eventCustomer = await repo.GetByIdAsync(eventCustomer.Id);
Assert.NotEqual(wrongId, eventCustomer.Id); // should get some generated ID
Assert.False(eventCustomer.Paid);
}
}
public override async Task GetAllWorksAsync()
{
List <EventCustomer> eventCustomersList = new List <EventCustomer>();
EventCustomer eventCustomerSaved = null;
Customer customerSaved = null;
Event EventSaved = null;
var options = new DbContextOptionsBuilder <Project15Context>()
.UseInMemoryDatabase("db_eventcustomer_test_getall").Options;
using (var db = new Project15Context(options));
using (var db = new Project15Context(options))
{
var customerRepo = new CustomerRepository(db);
var eventRepo = new EventRepository(db);
var repo = new EventCustomerRepository(db);
//Create customer
Customer customer = new Customer {
Name = "Axel", Address1 = "111 Address"
};
customer = await customerRepo.CreateAsync(customer);
await customerRepo.SaveChangesAsync();
Event Event = new Event {
Name = "Jazz Fest", Type = "Music", Cost = 40
};
Event = await eventRepo.CreateAsync(Event);
await eventRepo.SaveChangesAsync();
for (int i = 0; i < 5; i++)
{
EventCustomer eventCustomer = new EventCustomer
{
CustomerId = customer.Id,
EventId = Event.Id,
};
eventCustomerSaved = await repo.CreateAsync(eventCustomer);
await repo.SaveChangesAsync();
eventCustomersList.Add(eventCustomerSaved);
}
EventSaved = Event;
customerSaved = customer;
}
using (var db = new Project15Context(options))
{
var repo = new EventCustomerRepository(db);
List <EventCustomer> list = (List <EventCustomer>) await repo.GetAllAsync();
Assert.Equal(eventCustomersList.Count, list.Count);
for (int i = 0; i < 5; i++)
{
Assert.Equal(eventCustomersList[i].CustomerId, list[i].CustomerId);
Assert.Equal(eventCustomersList[i].EventId, list[i].EventId);
Assert.NotEqual(0, list[i].Id);
}
}
}
