public void UpsertShouldModifyTheGivenUserRole()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(UpsertShouldModifyTheGivenUserRole))
.EnableSensitiveDataLogging()
.Options;
using (var context = new ExpensesDbContext(options))
{
var userRoleService = new UserRoleService(context);
var toAdd = new UserRolePostModel()
{
Name = "Newbegginer",
Description = "A role for a new guy..."
};
var added = userRoleService.Create(toAdd);
var update = new UserRolePostModel()
{
Name = "New employee"
};
var toUp = userRoleService.Create(update);
Assert.IsNotNull(toUp);
Assert.AreEqual(added.Name, added.Name);
Assert.AreEqual(added.Name, added.Name);
}
}
public void UpsertShouldModifyFieldsValues()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(UpsertShouldModifyFieldsValues))
.Options;
using (var context = new ExpensesDbContext(options))
{
var userRoleService = new UserRoleService(context);
var expected = new UserRolePostModel
{
Name = "Regular",
Description = "Regular for test"
};
userRoleService.Create(expected);
var updated = new UserRolePostModel
{
Name = "Admin",
Description = "Admin for test"
};
var userUpdated = userRoleService.Upsert(5, updated); //id 5 pt ca altfel imi da eroare de as no tracking
Assert.NotNull(userUpdated);
Assert.AreEqual("Admin", userUpdated.Name);
}
}
public void DeleteShouldDeleteAndReturnTheDeletedUserRole()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(DeleteShouldDeleteAndReturnTheDeletedUserRole))
.Options;
using (var context = new ExpensesDbContext(options))
{
var userRoleService = new UserRoleService(context);
var addUserRole = new UserRolePostModel()
{
Name = "Newbegginer",
Description = "A role for a new guy..."
};
var actual = userRoleService.Create(addUserRole);
var afterDelete = userRoleService.Delete(actual.Id);
int numberOfUserRoleInDb = context.UserRoles.CountAsync().Result;
var resultUR = context.UserRoles.Find(actual.Id);
Assert.IsNotNull(afterDelete);
Assert.IsNull(resultUR);
Assert.AreEqual(0, numberOfUserRoleInDb);
}
}
public UserRoleGetModel Create(UserRolePostModel userRolePostModel)
{
UserRole toAdd = UserRolePostModel.ToUserRole(userRolePostModel);
context.UserRoles.Add(toAdd);
context.SaveChanges();
return(UserRoleGetModel.FromUserRole(toAdd));
}
public UserRole Create(UserRolePostModel userPostModel)
{
UserRole toAdd = UserRolePostModel.ToUserRole(userPostModel);
context.UserRole.Add(toAdd);
context.SaveChanges();
return(toAdd);
}
public UserRole Upsert(int id, UserRolePostModel userRole)
{
UserRole toAdd = UserRolePostModel.ToUserRole(userRole);
var existing = context.UserRole.AsNoTracking().FirstOrDefault(f => f.Id == id);
if (existing == null)
{
context.
UserRole.Add(toAdd);
context.SaveChanges();
return(toAdd);
}
toAdd.Id = id;
context.UserRole.Update(toAdd);
context.SaveChanges();
return(toAdd);
}
public UserRoleGetModel Upsert(int id, UserRolePostModel userRolePostModel)
{
var existing = context.UserRoles.AsNoTracking().FirstOrDefault(urole => urole.Id == id);
if (existing == null)
{
UserRole toAdd = UserRolePostModel.ToUserRole(userRolePostModel);
context.UserRoles.Add(toAdd);
context.SaveChanges();
return(UserRoleGetModel.FromUserRole(toAdd));
}
UserRole Up = UserRolePostModel.ToUserRole(userRolePostModel);
Up.Id = id;
context.UserRoles.Update(Up);
context.SaveChanges();
return(UserRoleGetModel.FromUserRole(Up));
}
public void GetAllShouldReturnAllUserRoles()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(GetAllShouldReturnAllUserRoles))
.Options;
using (var context = new ExpensesDbContext(options))
{
var userRoleService = new UserRoleService(context);
var addUserRole = new UserRolePostModel()
{
Name = "Newbegginer",
Description = "A role for a new guy..."
};
var current = userRoleService.Create(addUserRole);
var allUsers = userRoleService.GetAll();
Assert.IsNotNull(allUsers);
Assert.AreEqual(1, allUsers.Count());
}
}
public void CreateShouldAddAndReturnTheCreatedUserRole()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(CreateShouldAddAndReturnTheCreatedUserRole))
.Options;
using (var context = new ExpensesDbContext(options))
{
var userRoleService = new UserRoleService(context);
var addUserRole = new UserRolePostModel()
{
Name = "Newbegginer",
Description = "A role for a new guy..."
};
var current = userRoleService.Create(addUserRole);
Assert.IsNotNull(current);
Assert.AreEqual("Newbegginer", current.Name);
}
}
public void GetByIdShouldReturnAValidUserRole()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(GetByIdShouldReturnAValidUserRole))
.Options;
using (var context = new ExpensesDbContext(options))
{
UserRoleService userRoleService = new UserRoleService(context);
var addUserRole = new UserRolePostModel()
{
Name = "NewUser",
Description = "New user added"
};
var current = userRoleService.Create(addUserRole);
var expected = userRoleService.GetById(current.Id);
Assert.IsNotNull(expected);
Assert.AreEqual(expected.Name, current.Name);
Assert.AreEqual(expected.Id, current.Id);
}
}
public UserRole Upsert(UserRolePostModel userRole)
{
var existing = context.UserRoles.FirstOrDefault(f => f.Name == userRole.UserRole);
if (existing == null)
{
context.UserRoles.Add(new UserRole
{
Description = userRole.Description,
Name = userRole.UserRole
});
context.SaveChanges();
}
else
{
existing.Name = userRole.UserRole;
existing.Description = userRole.Description;
context.UserRoles.Update(existing);
}
context.SaveChanges();
return(existing = context.UserRoles.FirstOrDefault(f => f.Name == userRole.UserRole));
}
public void Post([FromBody] UserRolePostModel userRolePostModel)
{
userRoleService.Create(userRolePostModel);
}
public IActionResult Put(int id, [FromBody] UserRolePostModel userRolePostModel)
{
var result = userRoleService.Upsert(id, userRolePostModel);
return(Ok(result));
}
public void Post([FromBody] UserRolePostModel userRolePostModel)
{
User addedBy = usersService.GetCurrentUser(HttpContext);
userRoleService.Create(userRolePostModel);
}
public IActionResult Post(UserRolePostModel UserPostModel)
{
var result = _permissionService.Upsert(UserPostModel);
return(Ok(result));
}
public void ValidUpsert()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(ValidUpsert))// "ValidRegisterShouldCreateANewUser")
.Options;
using (var context = new ExpensesDbContext(options))
{
var validator = new RegisterValidator();
var usersService = new UsersService(context, validator, config);
var userRoleService = new UserRoleService(context);
var addedRole = new UserRolePostModel
{
Name = "Admin",
Description = "jskds"
};
var result = userRoleService.Create(addedRole);
var addedRole2 = new UserRolePostModel
{
Name = "Regular",
Description = "jskds"
};
var resultRegular = userRoleService.Create(addedRole2);
var added = new Lab2Expense.Models.User
{
Email = "[email protected]",
FirstName = "fdsfsdfs",
LastName = "fdsfs",
Password = "******",
Username = "******",
UserUserRoles = new List <UserUserRole>()
};
var adminRole = context
.UserRole
.FirstOrDefault(ur => ur.Name == "Admin");
context.Users.Add(added);
context.UserUserRole.Add(new UserUserRole
{
User = added,
UserRole = adminRole,
StartTime = DateTime.Now,
EndTime = null,
});
var addedRegular = new Lab2Expense.Models.User
{
Email = "[email protected]",
FirstName = "fdsfsdfs",
LastName = "fdsfs",
Password = "******",
Username = "******",
UserUserRoles = new List <UserUserRole>()
};
var RegularRole = context
.UserRole
.FirstOrDefault(ur => ur.Name == "Regular");
context.Users.Add(addedRegular);
context.UserUserRole.Add(new UserUserRole
{
User = addedRegular,
UserRole = RegularRole,
StartTime = DateTime.Now,
EndTime = null,
});
context.SaveChanges();
context.Entry(added).State = EntityState.Detached;
context.Entry(adminRole).State = EntityState.Detached;
context.Entry(addedRegular).State = EntityState.Detached;
var addedRegular2 = new Lab2Expense.Models.User
{
Email = "*****@*****.**",
FirstName = "fdsfsdfs",
LastName = "fdsfs",
Password = "******",
Username = "******",
UserUserRoles = new List <UserUserRole>()
};
context.Entry(addedRegular2).State = EntityState.Detached;
// var resultAdded = usersService.Register(added);
// var resultAuthentificate = usersService.Authenticate(added.Username, added.Password);
var resultUpdate = usersService.Upsert(addedRegular.Id, addedRegular2, added);
Assert.AreEqual("*****@*****.**", addedRegular.Email);
}
}
