public void DeleteUser()
{
var id = 1;
var user1 = new PasswordUser
{
Id = id,
FirstName = "Bent",
LastName = "Nielsen",
Email = "*****@*****.**",
PhoneNumber = "12345678",
Country = "Denmark",
Street = "H.C.Andersen gade 12",
ZipCode = "5000",
Username = "******",
Password = "******"
};
var userRepo = new Mock <IUserRepository>();
userRepo.Setup(x => x.DeleteUser(id)).Returns(user1);
var auth = new Mock <IAuthenticationHelper>();
IUserService service = new UserService(userRepo.Object, auth.Object);
var result = service.DeleteUser(id);
Assert.Equal(user1, result);
}
public async Task Save(PasswordUser user)
{
using (var session = _store.LightweightSession())
{
session.Update(user);
await session.SaveChangesAsync();
}
}
public ActionResult <User> Put(int id, [FromBody] PasswordUser user)
{
if (id < 1 || id != user.Id)
{
return(BadRequest("Parameter Id and Order Id must be the same"));
}
return(Ok(_userService.UpdateUser(user)));
}
public ActionResult <User> Post([FromBody] PasswordUser user)
{
try
{
return(Ok(_userService.CreateUser(user)));
}
catch (Exception e)
{
return(BadRequest("Cannot create user. Reason: " + e.Message));
}
}
public User UpdateUser(PasswordUser updatedUser)
{
if (string.IsNullOrEmpty(updatedUser.FirstName))
{
throw new InvalidDataException("Must have a first name");
}
if (string.IsNullOrEmpty(updatedUser.LastName))
{
throw new InvalidDataException("Must have a last name");
}
if (string.IsNullOrEmpty(updatedUser.Email))
{
throw new InvalidDataException("Must have a email address");
}
if (string.IsNullOrEmpty(updatedUser.PhoneNumber))
{
throw new InvalidDataException("Must have a phone number");
}
if (string.IsNullOrEmpty(updatedUser.Username))
{
throw new InvalidDataException("Must have a username");
}
if (string.IsNullOrEmpty(updatedUser.Password))
{
throw new InvalidDataException("For security a user must have a password");
}
if (string.IsNullOrEmpty(updatedUser.Street))
{
throw new InvalidDataException("Must have street");
}
if (string.IsNullOrEmpty(updatedUser.ZipCode))
{
throw new InvalidDataException("Must have a zipcode");
}
if (string.IsNullOrEmpty(updatedUser.Country))
{
throw new InvalidDataException("Must have a country");
}
byte[] passwordHash, passwordSalt;
_authenticationHelper.CreatePasswordHash(updatedUser.Password, out passwordHash, out passwordSalt);
updatedUser.PasswordHash = passwordHash;
updatedUser.PasswordSalt = passwordSalt;
return(_userRepository.UpdateUser(updatedUser));
}
public void CreateUserGivesIsAdminFalse()
{
var user = new PasswordUser
{
FirstName = "Bent",
LastName = "Nielsen",
Email = "*****@*****.**",
PhoneNumber = "12345678",
Country = "Denmark",
Street = "H.C.Andersen gade 12",
ZipCode = "5000",
Username = "******",
Password = "******"
};
Assert.False(user.IsAdmin);
}
public async Task <string> Create(PasswordUser user)
{
try
{
using (var session = _store.LightweightSession())
{
session.Store(user);
await session.SaveChangesAsync();
}
return(user.Id.ToString("D"));
}
catch (Exception)
{
return(user.Id.ToString("D"));
}
}
public async Task <IActionResult> UserCreated([FromBody] PasswordUserModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var dto = new PasswordUser
{
Id = CreateUserId(model.UserName),
Email = model.Email,
UserName = model.UserName,
Password = model.Password
};
var id = await _store.Create(dto);
return(Ok(id));
}
public async Task <string> Create(PasswordUser user)
{
try
{
var result =
await
_client.CreateDocumentAsync(
UriFactory.CreateDocumentCollectionUri(_database, _collection),
user);
return(result.Resource.Id);
}
catch (DocumentClientException ex)
{
if (ex.StatusCode != HttpStatusCode.Conflict)
{
throw;
}
return(user.Id.ToString("D"));
}
}
public void UpdateUserWithEmptyFirstNameThrowsException()
{
var user1 = new PasswordUser
{
FirstName = "Bent",
LastName = "Nielsen",
Email = "*****@*****.**",
PhoneNumber = "12345678",
Country = "Denmark",
Street = "H.C.Andersen gade 12",
ZipCode = "5000",
Username = "******",
Password = "******"
};
var updatedUser = new PasswordUser
{
LastName = "Nielsen",
Email = "*****@*****.**",
PhoneNumber = "12345678",
Country = "Denmark",
Street = "H.C.Andersen gade 12",
ZipCode = "5000",
Username = "******",
Password = "******"
};
user1 = updatedUser;
var userRepo = new Mock <IUserRepository>();
userRepo.Setup(x => x.UpdateUser(user1)).Returns(user1);
var auth = new Mock <IAuthenticationHelper>();
IUserService service = new UserService(userRepo.Object, auth.Object);
Exception ex = Assert.Throws <InvalidDataException>(() => service.UpdateUser(user1));
Assert.Equal("Must have a first name", ex.Message);
}
public void CreateUserWithMissingFirstNameThrowsException()
{
var user = new PasswordUser
{
FirstName = null,
LastName = "Nielsen",
Email = "*****@*****.**",
PhoneNumber = "12345678",
Country = "Denmark",
Street = "H.C.Andersen gade 12",
ZipCode = "5000",
Username = "******",
Password = "******",
IsAdmin = false
};
var userRepo = new Mock <IUserRepository>();
var auth = new Mock <IAuthenticationHelper>();
IUserService service = new UserService(userRepo.Object, auth.Object);
Exception ex = Assert.Throws <InvalidDataException>(() => service.CreateUser(user));
Assert.Equal("Must have a first name", ex.Message);
}
public async Task Save(PasswordUser user)
{
await _client.ReplaceDocumentAsync(MakeDocumentUri(user.Id), user);
}
public void UpdateOrderRemoveDeliveryDateThrowsException()
{
var user = new PasswordUser
{
Id = 1,
FirstName = "Bent",
LastName = "Nielsen",
Email = "*****@*****.**",
PhoneNumber = "12345678",
Country = "Denmark",
Street = "H.C.Andersen gade 12",
ZipCode = "5000",
Username = "******",
Password = "******"
};
var cover = new Cover
{
Color = "blue",
Material = "plastic",
TypeOfBrand = "Apple",
TypeOfModel = "iPhone6",
Stock = 10,
Price = 1234,
Name = "PanserProof"
};
var ol = new OrderLine
{
Product = cover,
ProductId = cover.Id,
Qty = 2,
PriceWhenBought = cover.Price
};
var order = new Order
{
User = user,
DeliveryDate = DateTime.Now,
OrderDate = DateTime.Now,
OrderLines = new List <OrderLine>
{
ol,
new OrderLine
{
Product = cover,
ProductId = cover.Id,
Qty = 2,
PriceWhenBought = cover.Price
}
}
};
var userRepo = new Mock <IUserRepository>();
userRepo.Setup(x => x.CreateUser(user)).Returns(user);
var orderRepo = new Mock <IOrderRepository>();
orderRepo.Setup(x => x.CreateOrder(order)).Returns(order);
var updatedOrder = new Order
{
User = user,
OrderDate = DateTime.Now,
OrderLines = new List <OrderLine>
{
ol,
new OrderLine
{
Product = cover,
ProductId = cover.Id,
Qty = 3,
PriceWhenBought = cover.Price
}
}
};
order = updatedOrder;
IOrderService service = new OrderService(orderRepo.Object, userRepo.Object);
Exception ex = Assert.Throws <InvalidDataException>(() => service.UpdateOrder(order));
Assert.Equal("Must have a Delivery Date", ex.Message);
}
public void ReadOrderById()
{
var id = 1;
var user = new PasswordUser
{
Id = 1,
FirstName = "Bent",
LastName = "Nielsen",
Email = "*****@*****.**",
PhoneNumber = "12345678",
Country = "Denmark",
Street = "H.C.Andersen gade 12",
ZipCode = "5000",
Username = "******",
Password = "******"
};
var cover = new Cover
{
Color = "blue",
Material = "plastic",
TypeOfBrand = "Apple",
TypeOfModel = "iPhone6",
Stock = 10,
Price = 1234,
Name = "PanserProof"
};
var ol = new OrderLine
{
Product = cover,
ProductId = cover.Id,
Qty = 2,
PriceWhenBought = cover.Price
};
var order = new Order
{
Id = id,
User = user,
DeliveryDate = DateTime.Now,
OrderDate = DateTime.Now,
OrderLines = new List <OrderLine>
{
ol,
new OrderLine
{
Product = cover,
ProductId = cover.Id,
Qty = 2,
PriceWhenBought = cover.Price
}
}
};
var orderRepo = new Mock <IOrderRepository>();
orderRepo.Setup(x => x.GetOrderById(id)).Returns(order);
var userRepo = new Mock <IUserRepository>();
IOrderService service = new OrderService(orderRepo.Object, userRepo.Object);
var result = service.GetOrderById(id);
Assert.Equal(order, result);
}
