public async Task AcceptAsync_WithNonExistentInvitation_ReturnsFalse()
{
// Arrange
const string testKey = "key111";
var context = new PoolItDbContext(new DbContextOptionsBuilder <PoolItDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var ride = new Ride();
await context.Rides.AddAsync(ride);
var user = new PoolItUser
{
UserName = "******"
};
await context.Users.AddAsync(user);
var invitationsService = new InvitationsService(
new EfRepository <Invitation>(context),
new EfRepository <Ride>(context),
new EfRepository <JoinRequest>(context),
new EfRepository <PoolItUser>(context),
new EfRepository <UserRide>(context),
null);
// Act
var result = await invitationsService.AcceptAsync(user.UserName, testKey);
// Assert
Assert.False(result);
}
public async Task AcceptAsync_WithNullInvitationKey_ReturnsFalse()
{
// Arrange
var context = new PoolItDbContext(new DbContextOptionsBuilder <PoolItDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var user = new PoolItUser
{
UserName = "******"
};
await context.Users.AddAsync(user);
context.SaveChanges();
var invitationsService = new InvitationsService(
new EfRepository <Invitation>(context),
new EfRepository <Ride>(context),
new EfRepository <JoinRequest>(context),
new EfRepository <PoolItUser>(context),
new EfRepository <UserRide>(context),
null);
// Act
var result = await invitationsService.AcceptAsync(user.UserName, null);
// Assert
Assert.False(result);
}
public async Task CreateAsync_WithValidModel_WorksCorrectly()
{
// Arrange
var context = new PoolItDbContext(new DbContextOptionsBuilder <PoolItDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var user = new PoolItUser
{
UserName = "******"
};
var car = new Car
{
Model = new CarModel
{
Model = "Test Model",
Manufacturer = new CarManufacturer()
},
Owner = user,
Colour = "TestColour"
};
await context.Cars.AddAsync(car);
await context.SaveChangesAsync();
var serviceModel = new RideServiceModel
{
Title = "Test Ride",
CarId = car.Id,
From = "Test From",
To = "Test To",
Date = DateTime.UtcNow,
AvailableSeats = 2
};
var ridesService = new RidesService(new EfRepository <Ride>(context), null, new EfRepository <Car>(context), null);
// Act
var result = await ridesService.CreateAsync(serviceModel);
// Assert
Assert.NotNull(result);
var dbModel = await context.Rides.SingleOrDefaultAsync();
Assert.NotNull(dbModel);
// - Check correct id is returned
Assert.Equal(dbModel.Id, result);
// - Check Conversation is created
Assert.NotNull(dbModel.Conversation);
// - Check organiser is added as participant
var userRideExists = await context.UserRides.AnyAsync(u => u.UserId == user.Id && u.RideId == dbModel.Id);
Assert.True(userRideExists);
}
public async Task GetAllForUserAsync_WithCorrectUser_WorksCorrectly()
{
// Arrange
const int expectedCount = 2;
var context = new PoolItDbContext(new DbContextOptionsBuilder <PoolItDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var model = new CarModel
{
Model = "Test Model",
Manufacturer = new CarManufacturer()
};
await context.CarModels.AddAsync(model);
var user = new PoolItUser
{
UserName = "******"
};
await context.Users.AddAsync(user);
await context.Cars.AddRangeAsync(
new Car
{
Colour = "Test Colour 1",
ModelId = model.Id,
OwnerId = user.Id
},
new Car
{
Colour = "Test Colour 2",
ModelId = model.Id,
OwnerId = user.Id
},
new Car
{
Colour = "Test Colour 3",
ModelId = model.Id,
Owner = new PoolItUser
{
UserName = "******"
}
}
);
await context.SaveChangesAsync();
var carsService = new CarsService(new EfRepository <Car>(context), null, new EfRepository <PoolItUser>(context));
// Act
var actualCount = (await carsService.GetAllForUserAsync(user.UserName)).Count();
// Assert
Assert.Equal(expectedCount, actualCount);
}
public async Task GetAsync_WithCorrectCarId_WorksCorrectly()
{
// Arrange
var context = new PoolItDbContext(new DbContextOptionsBuilder <PoolItDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var model = new CarModel
{
Model = "Test Model",
Manufacturer = new CarManufacturer()
};
await context.CarModels.AddAsync(model);
var user = new PoolItUser
{
UserName = "******"
};
await context.Users.AddAsync(user);
var car = new Car
{
Colour = "Test Colour 1",
ModelId = model.Id,
OwnerId = user.Id
};
await context.Cars.AddRangeAsync(
car,
new Car
{
Colour = "Test Colour 2",
ModelId = model.Id,
OwnerId = user.Id
},
new Car
{
Colour = "Test Colour 3",
ModelId = model.Id,
OwnerId = user.Id
}
);
await context.SaveChangesAsync();
var carsService = new CarsService(new EfRepository <Car>(context), null, null);
// Act
var result = await carsService.GetAsync(car.Id);
// Assert
Assert.NotNull(result);
Assert.Equal(car.Colour, result.Colour);
}
public async Task AcceptAsync_WithCorrectId_WorksCorrectly()
{
// Arrange
var context = new PoolItDbContext(new DbContextOptionsBuilder <PoolItDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var ride = new Ride
{
Title = "Test Ride",
Car = new Car
{
Owner = new PoolItUser
{
UserName = "******"
},
Model = new CarModel
{
Manufacturer = new CarManufacturer()
}
},
Conversation = new Conversation()
};
var user = new PoolItUser
{
UserName = "******"
};
var request = new JoinRequest
{
Ride = ride,
User = user,
Message = "Test Message"
};
await context.JoinRequests.AddAsync(request);
await context.SaveChangesAsync();
var joinRequestsService = new JoinRequestsService(new EfRepository <JoinRequest>(context), null, null, new EfRepository <UserRide>(context));
// Act
var result = await joinRequestsService.AcceptAsync(request.Id);
// Assert
Assert.True(result);
var joinRequestExists = await context.JoinRequests.AnyAsync();
Assert.False(joinRequestExists);
var userRideExists = await context.UserRides.AnyAsync(u => u.UserId == user.Id && u.RideId == ride.Id);
Assert.True(userRideExists);
}
private async Task RemoveFromRolesAsync(PoolItUser user, params string[] roles)
{
foreach (var role in roles)
{
if (await this.userManager.IsInRoleAsync(user, role))
{
await this.userManager.RemoveFromRoleAsync(user, role);
}
}
}
public async Task UpdateAsync_WithValidModel_WorksCorrectly()
{
// Arrange
var context = new PoolItDbContext(new DbContextOptionsBuilder <PoolItDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var model = new CarModel
{
Model = "Test Model"
};
await context.CarModels.AddAsync(model);
var user = new PoolItUser
{
UserName = "******"
};
await context.Users.AddAsync(user);
var car = new Car
{
ModelId = model.Id,
Colour = "Test Colour",
OwnerId = user.Id
};
await context.Cars.AddAsync(car);
await context.SaveChangesAsync();
var carsService = new CarsService(new EfRepository <Car>(context), null, null);
var serviceModel = new CarServiceModel
{
Id = car.Id,
ModelId = car.ModelId,
OwnerId = car.OwnerId,
Colour = "Updated Colour",
Details = "Updated Details"
};
// Act
var result = await carsService.UpdateAsync(serviceModel);
// Assert
Assert.True(result);
var dbModel = await context.Cars.SingleAsync();
Assert.Equal(serviceModel.Colour, dbModel.Colour);
Assert.Equal(serviceModel.Details, dbModel.Details);
}
public async Task UpdateAsync_WithNonExistentCarId_ReturnsFalse()
{
// Arrange
var testCarId = Guid.NewGuid().ToString();
var context = new PoolItDbContext(new DbContextOptionsBuilder <PoolItDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var model = new CarModel
{
Model = "Test Model"
};
await context.CarModels.AddAsync(model);
var user = new PoolItUser
{
UserName = "******"
};
await context.Users.AddAsync(user);
var car = new Car
{
ModelId = model.Id,
OwnerId = user.Id,
Colour = "Test Colour",
Details = "Test Details"
};
await context.Cars.AddAsync(car);
await context.SaveChangesAsync();
var carsService = new CarsService(new EfRepository <Car>(context), null, null);
var serviceModel = new CarServiceModel
{
Id = testCarId,
ModelId = car.ModelId,
OwnerId = car.OwnerId,
Colour = "Updated Colour",
Details = "Updated Details"
};
// Act
var result = await carsService.UpdateAsync(serviceModel);
// Assert
Assert.False(result);
}
public async Task CreateAsync_WithValidModel_WorksCorrectly()
{
// Arrange
var context = new PoolItDbContext(new DbContextOptionsBuilder <PoolItDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var ride = new Ride
{
Title = "TestRide"
};
await context.Rides.AddAsync(ride);
var user = new PoolItUser
{
UserName = "******"
};
await context.Users.AddAsync(user);
await context.SaveChangesAsync();
var joinRequestsService = new JoinRequestsService(
new EfRepository <JoinRequest>(context),
new EfRepository <Ride>(context),
new EfRepository <PoolItUser>(context),
null);
var serviceModel = new JoinRequestServiceModel
{
RideId = ride.Id,
User = new PoolItUserServiceModel
{
UserName = user.UserName
},
Message = "Test Message"
};
// Act
var result = await joinRequestsService.CreateAsync(serviceModel);
// Assert
Assert.True(result);
var dbModel = await context.JoinRequests.SingleOrDefaultAsync();
Assert.NotNull(dbModel);
Assert.Equal(user.Id, dbModel.UserId);
}
public async Task <IActionResult> GitHubRegister(UserGitHubRegisterBindingModel model, string returnUrl = null)
{
returnUrl = returnUrl ?? this.Url.Content("~/");
if (this.User.Identity.IsAuthenticated)
{
return(this.LocalRedirect(returnUrl));
}
var info = await this.signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
return(this.RedirectToAction("Login", new { ReturnUrl = returnUrl }));
}
if (this.ModelState.IsValid)
{
var user = new PoolItUser
{
UserName = model.Email,
Email = model.Email,
FirstName = model.FirstName,
LastName = model.LastName
};
var result = await this.signInManager.UserManager.CreateAsync(user);
if (result.Succeeded)
{
result = await this.signInManager.UserManager.AddLoginAsync(user, info);
if (result.Succeeded)
{
this.Success(string.Format(NotificationMessages.RegistrationWelcome, model.FirstName));
await this.signInManager.SignInAsync(user, isPersistent : true);
return(this.LocalRedirect(returnUrl));
}
}
foreach (var error in result.Errors)
{
this.ModelState.AddModelError(string.Empty, error.Description);
}
}
this.ViewData["ReturnUrl"] = returnUrl;
return(this.View());
}
public async Task CreateAsync_WithInvalidModel_ReturnsFalse()
{
// Arrange
var context = new PoolItDbContext(new DbContextOptionsBuilder <PoolItDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var ride = new Ride
{
Title = "TestRide"
};
await context.Rides.AddAsync(ride);
var user = new PoolItUser
{
UserName = "******"
};
await context.Users.AddAsync(user);
await context.SaveChangesAsync();
var joinRequestsService = new JoinRequestsService(
new EfRepository <JoinRequest>(context),
new EfRepository <Ride>(context),
new EfRepository <PoolItUser>(context),
null);
var serviceModel = new JoinRequestServiceModel
{
RideId = ride.Id,
User = new PoolItUserServiceModel
{
UserName = user.UserName
}
};
// Act
var result = await joinRequestsService.CreateAsync(serviceModel);
// Assert
Assert.False(result);
var existsInDb = await context.JoinRequests.AnyAsync();
Assert.False(existsInDb);
}
public async Task CreateAsync_WithValidModel_WorksCorrectly()
{
// Arrange
var context = new PoolItDbContext(new DbContextOptionsBuilder <PoolItDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var model = new CarModel
{
Model = "Test Model"
};
await context.CarModels.AddAsync(model);
var user = new PoolItUser
{
UserName = "******"
};
await context.Users.AddAsync(user);
await context.SaveChangesAsync();
var carsService = new CarsService(new EfRepository <Car>(context), new EfRepository <CarModel>(context), new EfRepository <PoolItUser>(context));
var serviceModel = new CarServiceModel
{
ModelId = model.Id,
Colour = "Test Colour",
Owner = new PoolItUserServiceModel
{
UserName = user.UserName
}
};
// Act
var result = await carsService.CreateAsync(serviceModel);
// Assert
Assert.True(result);
var dbModel = await context.Cars.SingleOrDefaultAsync();
Assert.NotNull(dbModel);
Assert.Equal(user.Id, dbModel.OwnerId);
}
public async Task SendMessageAsync_WithInvalidModel_ReturnsNull()
{
var testMessageContent = string.Empty;
var testSentOn = DateTime.UtcNow;
var context = new PoolItDbContext(new DbContextOptionsBuilder <PoolItDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var conversation = new Conversation();
context.Conversations.Add(conversation);
var author = new PoolItUser
{
UserName = "******"
};
context.Users.Add(author);
context.SaveChanges();
var conversationsService = new ConversationsService(
new EfRepository <Conversation>(context),
new EfRepository <PoolItUser>(context),
new EfRepository <Message>(context)
);
// Act
var result = await conversationsService.SendMessageAsync(new MessageServiceModel
{
ConversationId = conversation.Id,
Author = new PoolItUserServiceModel
{
UserName = author.UserName
},
SentOn = testSentOn,
Content = testMessageContent
});
// Assert
Assert.Null(result);
var dbCount = await context.Messages.CountAsync();
Assert.Equal(0, dbCount);
}
public async Task SendMessageAsync_WithValidModel_WorksCorrectly()
{
const string expectedMessageContent = "Test Message Content";
var expectedSentOn = DateTime.UtcNow;
var context = new PoolItDbContext(new DbContextOptionsBuilder <PoolItDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var conversation = new Conversation();
context.Conversations.Add(conversation);
var author = new PoolItUser
{
UserName = "******"
};
context.Users.Add(author);
context.SaveChanges();
var conversationsService = new ConversationsService(
new EfRepository <Conversation>(context),
new EfRepository <PoolItUser>(context),
new EfRepository <Message>(context)
);
// Act
var result = await conversationsService.SendMessageAsync(new MessageServiceModel
{
ConversationId = conversation.Id,
Author = new PoolItUserServiceModel
{
UserName = author.UserName
},
SentOn = expectedSentOn,
Content = expectedMessageContent
});
// Assert
var dbMessage = await context.Messages.SingleAsync(m => m.Id == result.Id);
Assert.Equal(expectedMessageContent, dbMessage.Content);
Assert.Equal(expectedSentOn, dbMessage.SentOn);
}
public async Task CreateAsync_WithUser_WorksCorrectly()
{
// Arrange
var context = new PoolItDbContext(new DbContextOptionsBuilder <PoolItDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var user = new PoolItUser
{
UserName = "******",
Email = "*****@*****.**",
FirstName = "Test",
LastName = "User"
};
await context.Users.AddAsync(user);
await context.SaveChangesAsync();
var contactMessagesService = new ContactMessagesService(new EfRepository <ContactMessage>(context), new EfRepository <PoolItUser>(context));
var serviceModel = new ContactMessageServiceModel
{
Email = "*****@*****.**",
FullName = "Other Name",
Subject = "Test Subject",
Message = "Test Message",
UserId = user.Id
};
// Act
var result = await contactMessagesService.CreateAsync(serviceModel);
// Assert
Assert.True(result);
var dbModel = await context.ContactMessages.SingleOrDefaultAsync();
Assert.NotNull(dbModel);
Assert.Null(dbModel.Email);
Assert.Null(dbModel.FullName);
Assert.Equal(user.Id, dbModel.UserId);
}
public async Task CreateAsync_WithInvalidModel_ReturnsFalse()
{
// Arrange
var context = new PoolItDbContext(new DbContextOptionsBuilder <PoolItDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var model = new CarModel
{
Model = "Test Model"
};
await context.CarModels.AddAsync(model);
var user = new PoolItUser
{
UserName = "******"
};
await context.Users.AddAsync(user);
await context.SaveChangesAsync();
var carsService = new CarsService(new EfRepository <Car>(context), new EfRepository <CarModel>(context), new EfRepository <PoolItUser>(context));
var serviceModel = new CarServiceModel
{
ModelId = model.Id,
Owner = new PoolItUserServiceModel
{
UserName = user.UserName
}
};
// Act
var result = await carsService.CreateAsync(serviceModel);
// Assert
Assert.False(result);
var dbModelAdded = await context.Cars.AnyAsync();
Assert.False(dbModelAdded);
}
public async Task <IActionResult> Register(UserRegisterBindingModel model, string returnUrl = null)
{
returnUrl = returnUrl ?? this.Url.Content("~/");
if (this.User.Identity.IsAuthenticated)
{
return(this.LocalRedirect(returnUrl));
}
if (!this.ModelState.IsValid)
{
return(this.View());
}
var user = new PoolItUser
{
UserName = model.Email,
Email = model.Email,
FirstName = model.FirstName,
LastName = model.LastName
};
var result = await this.signInManager.UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
this.Success(string.Format(NotificationMessages.RegistrationWelcome, model.FirstName));
await this.signInManager.SignInAsync(user, isPersistent : false);
return(this.LocalRedirect(returnUrl));
}
foreach (var error in result.Errors)
{
this.ModelState.AddModelError(string.Empty, error.Description);
}
return(this.View());
}
public async Task DeleteUser_WithExceptionOnSave_ReturnsFalse()
{
// Arrange
var context = new PoolItDbContext(new DbContextOptionsBuilder <PoolItDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var user = new PoolItUser
{
FirstName = "FirstName",
LastName = "LastName",
UserName = "******",
Email = "*****@*****.**"
};
await context.Users.AddAsync(user);
await context.SaveChangesAsync();
var usersRepository = new EfRepository <PoolItUser>(context);
var mockUsersRepository = new Mock <IRepository <PoolItUser> >();
mockUsersRepository.Setup(r => r.All()).Returns(usersRepository.All());
mockUsersRepository.Setup(r => r.SaveChangesAsync()).Throws <InvalidOperationException>();
var personalDataService = new PersonalDataService(mockUsersRepository.Object,
new EfRepository <JoinRequest>(context),
new EfRepository <UserRide>(context),
new EfRepository <Conversation>(context),
new EfRepository <ContactMessage>(context));
// Act
var result = await personalDataService.DeleteUser(user.Id);
// Assert
Assert.False(result);
}
public async Task UpdateAsync_WithModelAndUserChanged_DoesNotUpdate()
{
// Arrange
var context = new PoolItDbContext(new DbContextOptionsBuilder <PoolItDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var model = new CarModel
{
Model = "Test Model"
};
var newModel = new CarModel
{
Model = "New Model"
};
await context.CarModels.AddRangeAsync(model, newModel);
var user = new PoolItUser
{
UserName = "******"
};
var newUser = new PoolItUser
{
UserName = "******"
};
await context.Users.AddRangeAsync(user, newUser);
var car = new Car
{
ModelId = model.Id,
Colour = "Test Colour",
OwnerId = user.Id
};
await context.Cars.AddAsync(car);
await context.SaveChangesAsync();
var carsService = new CarsService(new EfRepository <Car>(context), null, null);
var serviceModel = new CarServiceModel
{
Id = car.Id,
ModelId = newModel.Id,
OwnerId = newUser.Id,
Colour = "Updated Colour",
Details = "Updated Details"
};
// Act
await carsService.UpdateAsync(serviceModel);
// Assert
var dbModel = await context.Cars.SingleAsync();
Assert.Equal(user.Id, dbModel.OwnerId);
Assert.Equal(model.Id, dbModel.ModelId);
}
public async Task AcceptAsync_WithCorrectUserAndInvitation_WorksCorrectly()
{
// Arrange
const string testKey = "key111";
var context = new PoolItDbContext(new DbContextOptionsBuilder <PoolItDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var ride = new Ride();
await context.Rides.AddAsync(ride);
var user = new PoolItUser
{
UserName = "******"
};
await context.Users.AddAsync(user);
var joinRequest = new JoinRequest
{
User = user,
Ride = ride
};
await context.JoinRequests.AddAsync(joinRequest);
await context.Invitations.AddAsync(new Invitation
{
Key = testKey,
Ride = ride
});
context.SaveChanges();
var invitationsService = new InvitationsService(
new EfRepository <Invitation>(context),
new EfRepository <Ride>(context),
new EfRepository <JoinRequest>(context),
new EfRepository <PoolItUser>(context),
new EfRepository <UserRide>(context),
null);
// Act
var result = await invitationsService.AcceptAsync(user.UserName, testKey);
// Assert
Assert.True(result);
// - Check for UserRide creation
var userRideExists = await context.UserRides.AnyAsync(u => u.UserId == user.Id && u.RideId == ride.Id);
Assert.True(userRideExists);
// - Check JoinRequest is removed
var joinRequestExists = await context.JoinRequests.AnyAsync();
Assert.False(joinRequestExists);
// - Check invitation is removed
var invitationExists = await context.Invitations.AnyAsync();
Assert.False(invitationExists);
}
public async Task GetReceivedForUserAsync_WithRequests_WorksCorrectly()
{
// Arrange
const int expectedCount = 2;
var context = new PoolItDbContext(new DbContextOptionsBuilder <PoolItDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var user = new PoolItUser
{
UserName = "******"
};
await context.Users.AddAsync(user);
var ride = new Ride
{
Title = "Test Ride",
Car = new Car
{
Owner = user,
Model = new CarModel
{
Manufacturer = new CarManufacturer()
}
},
Conversation = new Conversation()
};
await context.Rides.AddAsync(ride);
await context.JoinRequests.AddRangeAsync(
new JoinRequest
{
Ride = ride,
User = new PoolItUser
{
UserName = "******"
}
},
new JoinRequest
{
Ride = ride,
User = new PoolItUser
{
UserName = "******"
}
},
new JoinRequest
{
User = user,
Ride = new Ride
{
Title = "Other Ride",
Car = new Car
{
Owner = new PoolItUser
{
UserName = "******"
},
Model = new CarModel
{
Manufacturer = new CarManufacturer()
}
},
Conversation = new Conversation()
}
}
);
await context.SaveChangesAsync();
var joinRequestsService = new JoinRequestsService(new EfRepository <JoinRequest>(context), null, null, null);
// Act
var actualCount = (await joinRequestsService.GetReceivedForUserAsync(user.UserName)).Count();
// Assert
Assert.Equal(expectedCount, actualCount);
}
public async Task GetPersonalDataForUserJson_WithCorrectUserId_WorksCorrectly()
{
// Arrange
const string expectedJson =
"{\"FirstName\": \"FirstName\",\"LastName\": \"LastName\",\"Email\": \"[email protected]\"," +
"\"SentRequests\": [{\"Ride\": \"Test Ride for Join Request\",\"SentOn\": \"Thu, 01 Jan 2015 10:25:30 GMT\"," +
"\"Message\": \"Test Message for Join Request\"}],\"Cars\": [{\"Manufacturer\": \"TestManufacturer\"," +
"\"Model\": \"TestModel\",\"Colour\": \"TestColour\",\"Details\": null}],\"OrganisedRides\": " +
"[{\"Title\": \"Test Ride\",\"Date\": \"Fri, 02 Jan 2015 10:25:30 GMT\",\"From\": \"Test From\"," +
"\"To\": \"Test To\",\"AvailableSeats\": 3,\"PhoneNumber\": \"0123123123\",\"Notes\": null,\"Car\": " +
"{\"Manufacturer\": \"TestManufacturer\",\"Model\": \"TestModel\",\"Colour\": \"TestColour\",\"Details\": null}," +
"\"Participants\": [{\"FirstName\": \"Other0\",\"LastName\": \"User0\"},{\"FirstName\": \"FirstName\"," +
"\"LastName\": \"LastName\"}],\"Invitations\": [{\"Key\": \"testKey\"}],\"JoinRequests\": " +
"[{\"FirstName\": \"Other1\",\"LastName\": \"User1\",\"SentOn\": \"Wed, 31 Dec 2014 10:25:30 GMT\"," +
"\"Message\": \"Test Message\"}]}],\"ParticipantInRides\": [{\"Title\": \"Test Ride\"," +
"\"Date\": \"Fri, 02 Jan 2015 10:25:30 GMT\",\"From\": \"Test From\",\"To\": \"Test To\",\"Organiser\": " +
"{\"FirstName\": \"FirstName\",\"LastName\": \"LastName\"},\"Car\": {\"Manufacturer\": \"TestManufacturer\"," +
"\"Model\": \"TestModel\"},\"Participants\": [{\"FirstName\": \"Other0\",\"LastName\": \"User0\"}," +
"{\"FirstName\": \"FirstName\",\"LastName\": \"LastName\"}],\"Conversation\": {\"Messages\": [{\"Author\": " +
"{\"FirstName\": \"Other0\",\"LastName\": \"User0\"},\"SentOn\": \"Wed, 31 Dec 2014 10:25:30 GMT\"," +
"\"Content\": \"Test Message Content 1\"},{\"Author\": {\"FirstName\": \"Other0\",\"LastName\": \"User0\"}," +
"\"SentOn\": \"Thu, 01 Jan 2015 10:25:30 GMT\",\"Content\": \"Test Message Content 2\"}]}}]," +
"\"ContactMessages\": [{\"Subject\": \"Test Subject\",\"Message\": \"Test Message\"}]}";
var dateTime = new DateTime(2015, 1, 1, 10, 25, 30);
var context = new PoolItDbContext(new DbContextOptionsBuilder <PoolItDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var otherUsers = new List <PoolItUser>
{
new PoolItUser
{
UserName = "******",
Email = "*****@*****.**",
FirstName = "Other0",
LastName = "User0"
},
new PoolItUser
{
UserName = "******",
Email = "*****@*****.**",
FirstName = "Other1",
LastName = "User1"
}
};
var ride = new Ride
{
Title = "Test Ride",
Date = dateTime.AddDays(1),
From = "Test From",
To = "Test To",
AvailableSeats = 3,
PhoneNumber = "0123123123",
Notes = null,
Participants = new List <UserRide>
{
new UserRide
{
User = otherUsers[0],
}
},
Invitations = new List <Invitation>
{
new Invitation
{
Key = "testKey"
}
},
JoinRequests = new List <JoinRequest>
{
new JoinRequest
{
User = otherUsers[1],
SentOn = dateTime.AddDays(-1),
Message = "Test Message"
}
},
Conversation = new Conversation
{
Messages = new List <Message>
{
new Message
{
Author = otherUsers[0],
SentOn = dateTime.AddDays(-1),
Content = "Test Message Content 1"
},
new Message
{
Author = otherUsers[0],
SentOn = dateTime,
Content = "Test Message Content 2"
}
}
}
};
var user = new PoolItUser
{
FirstName = "FirstName",
LastName = "LastName",
UserName = "******",
Email = "*****@*****.**",
SentRequests = new List <JoinRequest>
{
new JoinRequest
{
Ride = new Ride
{
Title = "Test Ride for Join Request"
},
SentOn = dateTime,
Message = "Test Message for Join Request"
}
},
Cars = new List <Car>
{
new Car
{
Model = new CarModel
{
Manufacturer = new CarManufacturer
{
Name = "TestManufacturer"
},
Model = "TestModel"
},
Colour = "TestColour",
Details = null,
Rides = new List <Ride>
{
ride
}
}
},
UserRides = new List <UserRide>
{
new UserRide
{
Ride = ride
}
},
ContactMessages = new List <ContactMessage>
{
new ContactMessage
{
Subject = "Test Subject",
Message = "Test Message"
}
}
};
await context.Users.AddAsync(user);
await context.SaveChangesAsync();
var personalDataService =
new PersonalDataService(new EfRepository <PoolItUser>(context), null, null, null, null);
// Act
var actualJson = await personalDataService.GetPersonalDataForUserJson(user.Id);
// Assert
var expectedResult = JToken.Parse(expectedJson);
var actualResult = JToken.Parse(actualJson);
var equal = JToken.DeepEquals(expectedResult, actualResult);
Assert.True(equal);
}
public async Task DeleteUser_WithCorrectUserId_WorksCorrectly()
{
// Arrange
var context = new PoolItDbContext(new DbContextOptionsBuilder <PoolItDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var otherUsers = new List <PoolItUser>
{
new PoolItUser
{
UserName = "******",
Email = "*****@*****.**",
FirstName = "Other0",
LastName = "User0"
},
new PoolItUser
{
UserName = "******",
Email = "*****@*****.**",
FirstName = "Other1",
LastName = "User1"
}
};
var ride = new Ride
{
Title = "Test Ride",
Date = DateTime.UtcNow.AddDays(1),
From = "Test From",
To = "Test To",
AvailableSeats = 3,
PhoneNumber = "0123123123",
Notes = null,
Participants = new List <UserRide>
{
new UserRide
{
User = otherUsers[0],
}
},
Invitations = new List <Invitation>
{
new Invitation
{
Key = "testKey"
}
},
JoinRequests = new List <JoinRequest>
{
new JoinRequest
{
User = otherUsers[1],
SentOn = DateTime.UtcNow.AddDays(-1),
Message = "Test Message"
}
},
Conversation = new Conversation
{
Messages = new List <Message>
{
new Message
{
Author = otherUsers[0],
SentOn = DateTime.UtcNow.AddDays(-1),
Content = "Test Message Content 1"
},
new Message
{
Author = otherUsers[0],
SentOn = DateTime.UtcNow,
Content = "Test Message Content 2"
}
}
}
};
var user = new PoolItUser
{
FirstName = "FirstName",
LastName = "LastName",
UserName = "******",
Email = "*****@*****.**",
SentRequests = new List <JoinRequest>
{
new JoinRequest
{
Ride = new Ride
{
Title = "Test Ride for Join Request"
},
SentOn = DateTime.UtcNow,
Message = "Test Message for Join Request"
}
},
Cars = new List <Car>
{
new Car
{
Model = new CarModel
{
Manufacturer = new CarManufacturer
{
Name = "TestManufacturer"
},
Model = "TestModel"
},
Colour = "TestColour",
Details = null,
Rides = new List <Ride>
{
ride
}
}
},
UserRides = new List <UserRide>
{
new UserRide
{
Ride = ride
}
},
ContactMessages = new List <ContactMessage>
{
new ContactMessage
{
Subject = "Test Subject",
Message = "Test Message"
}
}
};
await context.Users.AddAsync(user);
await context.SaveChangesAsync();
var personalDataService = new PersonalDataService(new EfRepository <PoolItUser>(context),
new EfRepository <JoinRequest>(context),
new EfRepository <UserRide>(context),
new EfRepository <Conversation>(context),
new EfRepository <ContactMessage>(context));
// Act
var result = await personalDataService.DeleteUser(user.Id);
// Assert
Assert.True(result);
var carCount = await context.Cars.CountAsync();
Assert.Equal(0, carCount);
var rideCount = await context.Rides.CountAsync();
Assert.Equal(1, rideCount);
var conversationCount = await context.Conversations.CountAsync();
Assert.Equal(0, conversationCount);
var invitationCount = await context.Invitations.CountAsync();
Assert.Equal(0, invitationCount);
var joinRequestCount = await context.JoinRequests.CountAsync();
Assert.Equal(0, joinRequestCount);
var messageCount = await context.Messages.CountAsync();
Assert.Equal(0, messageCount);
var userRideCount = await context.UserRides.CountAsync();
Assert.Equal(0, userRideCount);
var userCount = await context.Users.CountAsync();
Assert.Equal(2, userCount);
var contactMessageCount = await context.ContactMessages.CountAsync();
Assert.Equal(0, contactMessageCount);
}
public async Task GetAllPastForUserAsync_WithRides_WorksCorrectly()
{
// Arrange
var expectedResult = new[] { "Ride1", "Ride2" };
const string testUser = "******";
var context = new PoolItDbContext(new DbContextOptionsBuilder <PoolItDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var user = new PoolItUser
{
UserName = testUser
};
await context.Users.AddAsync(user);
var car = new Car
{
Model = new CarModel
{
Model = "Test Model",
Manufacturer = new CarManufacturer()
},
Owner = new PoolItUser
{
UserName = "******"
}
};
await context.Cars.AddAsync(car);
await context.Rides.AddRangeAsync(
new Ride
{
Title = "Ride1",
Date = DateTime.UtcNow.AddDays(-1),
Participants = new[]
{
new UserRide
{
User = user
}
},
Car = car,
Conversation = new Conversation()
},
new Ride
{
Title = "Ride2",
Date = DateTime.UtcNow.AddDays(-2),
Participants = new[]
{
new UserRide
{
User = user
}
},
Car = car,
Conversation = new Conversation()
},
new Ride
{
Title = "OtherRide1",
Date = DateTime.UtcNow.AddDays(1),
Participants = new[]
{
new UserRide
{
User = user
}
},
Car = car,
Conversation = new Conversation()
},
new Ride
{
Title = "OtherRide2",
Date = DateTime.UtcNow.AddDays(-1),
Participants = new[]
{
new UserRide
{
User = new PoolItUser
{
UserName = "******"
}
}
},
Car = car,
Conversation = new Conversation()
}
);
await context.SaveChangesAsync();
var ridesService = new RidesService(new EfRepository <Ride>(context), new EfRepository <PoolItUser>(context), null, null);
// Act
var actualResult = (await ridesService.GetAllPastForUserAsync(testUser)).Select(r => r.Title);
// Assert
Assert.Equal(expectedResult, actualResult);
}
