public void Resources_HasAllPermissionAreaTitles()
{
using (TestingContext context = new TestingContext())
using (Configuration configuration = new Configuration(context, null))
{
configuration.SeedData();
foreach (Permission permission in context.Set <Permission>().Where(permission => permission.Area != null))
{
Assert.True(!String.IsNullOrEmpty(Resource.ForPermission(permission.Area)),
$"'{permission.Area}' permission, does not have a title.");
}
}
}
public void InsertRange_AddsModelsToDbSet()
{
TestModel[] models = { ObjectFactory.CreateTestModel(1), ObjectFactory.CreateTestModel(2) };
DbSet <TestModel> set = Substitute.For <DbSet <TestModel>, IQueryable>();
TestingContext testingContext = Substitute.For <TestingContext>();
testingContext.Set <TestModel>().Returns(set);
unitOfWork.Dispose();
unitOfWork = new UnitOfWork(testingContext);
unitOfWork.InsertRange(models);
set.Received().AddRange(models);
}
public void Resources_HasAllPermissionActionTitles()
{
using (TestingContext context = new TestingContext())
using (Configuration configuration = new Configuration(context, null))
{
configuration.SeedData();
foreach (Permission permission in context.Set <Permission>())
{
Assert.True(!String.IsNullOrEmpty(Resource.ForPermission(permission.Area, permission.Controller, permission.Action)),
$"'{permission.Area}{permission.Controller}{permission.Action} permission', does not have a title.");
}
}
}
public LoggableEntityTests()
{
using (context = new TestingContext())
{
context.Set <TestModel>().RemoveRange(context.Set <TestModel>());
context.Set <TestModel>().Add(ObjectFactory.CreateTestModel());
context.Set <Role>().Add(ObjectFactory.CreateRole());
context.DropData();
}
context = new TestingContext();
model = context.Set <TestModel>().Single();
entry = context.Entry <BaseModel>(model);
}
public void Log_Added()
{
entry.State = EntityState.Added;
logger.Log(new[] { entry });
logger.Save();
LoggableEntity expected = new LoggableEntity(entry);
AuditLog actual = context.Set <AuditLog>().Single();
Assert.Equal(expected.ToString(), actual.Changes);
Assert.Equal(expected.Name, actual.EntityName);
Assert.Equal(expected.Action, actual.Action);
Assert.Equal(expected.Id(), actual.EntityId);
Assert.Equal(1, actual.AccountId);
}
public async Task <TestTaskEditorResponse> Handle(
EditCommand <MultipleChoiceTestTaskCreateEditCommand, TestTaskEditorResponse> request,
CancellationToken cancellationToken)
{
var task = await context.Set <MultipleChoiceTestTask>()
.Include(x => x.Options)
.Include(x => x.Test)
.SingleAsync(x => x.Id == request.Id, cancellationToken);
if (task.Test.StartedAt != null)
{
throw new InvalidOperationException("A feladatok nem szerkeszthetők a dolgozat megkezése után.");
}
context.Set <MultipleChoiceTestTaskOption>()
.RemoveRange(task.Options);
var options = request.InnerCommand.Options.Select(x => new MultipleChoiceTestTaskOption
{
Id = Guid.NewGuid(),
Value = x,
TestTask = task
}).ToList();
context.Set <MultipleChoiceTestTaskOption>()
.AddRange(options);
task.CorrectOption = options[request.InnerCommand.CorrectOptionIndex];
task.Description = request.InnerCommand.Description;
task.PointValue = request.InnerCommand.PointValue;
task.IncorrectAnswerPointValue = request.InnerCommand.IncorrectAnswerPointValue;
await context.SaveChangesAsync(cancellationToken);
return(mapper.Map <MultipleChoiceTestTaskEditorResponse>(task));
}
public void GetViews_ReturnsRoleViews()
{
RoleView[] actual = service.GetViews().ToArray();
RoleView[] expected = context
.Set <Role>()
.ProjectTo <RoleView>()
.OrderByDescending(view => view.Id)
.ToArray();
for (Int32 i = 0; i < expected.Length || i < actual.Length; i++)
{
Assert.Equal(expected[i].Permissions.SelectedIds, actual[i].Permissions.SelectedIds);
Assert.Equal(expected[i].CreationDate, actual[i].CreationDate);
Assert.Equal(expected[i].Title, actual[i].Title);
Assert.Equal(expected[i].Id, actual[i].Id);
}
}
public void GetViews_ReturnsRoleViews()
{
IEnumerator <RoleView> actual = service.GetViews().GetEnumerator();
IEnumerator <RoleView> expected = context
.Set <Role>()
.ProjectTo <RoleView>()
.OrderByDescending(view => view.Id)
.GetEnumerator();
while (expected.MoveNext() | actual.MoveNext())
{
Assert.Equal(expected.Current.Permissions.SelectedIds, actual.Current.Permissions.SelectedIds);
Assert.Equal(expected.Current.CreationDate, actual.Current.CreationDate);
Assert.Equal(expected.Current.Title, actual.Current.Title);
Assert.Equal(expected.Current.Id, actual.Current.Id);
}
}
private Account CreateAccountWithPrivilegeFor(String area, String controller, String action, Boolean isLocked = false)
{
using (TestingContext context = new TestingContext())
{
RolePrivilege rolePrivilege = ObjectFactory.CreateRolePrivilege();
Account account = ObjectFactory.CreateAccount();
account.RoleId = rolePrivilege.RoleId;
account.IsLocked = isLocked;
account.Role = null;
rolePrivilege.Privilege.Controller = controller;
rolePrivilege.Privilege.Action = action;
rolePrivilege.Privilege.Area = area;
context.Set <RolePrivilege>().Add(rolePrivilege);
context.Set <Account>().Add(account);
context.SaveChanges();
SetUpDependencyResolver();
provider.Refresh();
return(account);
}
}
private Int32 CreateAccountWithPermissionFor(String area, String controller, String action, Boolean isLocked = false)
{
using (TestingContext context = new TestingContext())
{
RolePermission rolePermission = ObjectFactory.CreateRolePermission();
Account account = ObjectFactory.CreateAccount();
account.RoleId = rolePermission.RoleId;
account.IsLocked = isLocked;
account.Role = null;
rolePermission.Permission.Controller = controller;
rolePermission.Permission.Action = action;
rolePermission.Permission.Area = area;
context.Set <RolePermission>().Add(rolePermission);
context.Set <Account>().Add(account);
context.SaveChanges();
SetUpDependencyResolver();
authorization.Refresh();
return(account.Id);
}
}
public void LoggableEntity_SetsEntityTypeName()
{
entry = context.Entry <BaseModel>(context.Set <Role>().Add(new Role()));
String actual = new LoggableEntity(entry).Name;
String expected = typeof(Role).Name;
Assert.AreNotEqual("System.Data.Entity.DynamicProxies", entry.Entity.GetType().Namespace);
Assert.AreEqual(expected, actual);
}
private void TearDownData()
{
using (TestingContext context = new TestingContext())
{
context.Set <Privilege>().RemoveRange(context.Set <Privilege>());
context.Set <Account>().RemoveRange(context.Set <Account>());
context.Set <Role>().RemoveRange(context.Set <Role>());
context.SaveChanges();
}
}
public void GetAs_ReturnsModelAsDestinationModelById()
{
context.Add(model);
context.SaveChanges();
RoleView expected = Mapper.Map <RoleView>(context.Set <Role>().AsNoTracking().Single());
RoleView actual = unitOfWork.GetAs <Role, RoleView>(model.Id);
Assert.Equal(expected.CreationDate, actual.CreationDate);
Assert.Equal(expected.Title, actual.Title);
Assert.Equal(expected.Id, actual.Id);
}
public void GetViews_ReturnsAccountViews()
{
AccountView[] actual = service.GetViews().ToArray();
AccountView[] expected = context
.Set <Account>()
.ProjectTo <AccountView>()
.OrderByDescending(view => view.Id)
.ToArray();
for (Int32 i = 0; i < expected.Length || i < actual.Length; i++)
{
Assert.Equal(expected[i].CreationDate, actual[i].CreationDate);
Assert.Equal(expected[i].RoleTitle, actual[i].RoleTitle);
Assert.Equal(expected[i].IsLocked, actual[i].IsLocked);
Assert.Equal(expected[i].Username, actual[i].Username);
Assert.Equal(expected[i].Email, actual[i].Email);
Assert.Equal(expected[i].Id, actual[i].Id);
}
}
public void LoggableEntity_CreatesPropertiesForAttachedEntity()
{
context.Dispose();
String title = model.Title;
context = new TestingContext();
context.Set <TestModel>().Attach(model);
entry = context.Entry <BaseModel>(model);
entry.OriginalValues["Title"] = "Role";
entry.CurrentValues["Title"] = "Role";
entry.State = EntityState.Modified;
LoggableProperty expected = new LoggableProperty(entry.Property("Title"), title);
LoggableProperty actual = new LoggableEntity(entry).Properties.Single();
Assert.Equal(expected.IsModified, actual.IsModified);
Assert.Equal(expected.ToString(), actual.ToString());
}
public void Resources_HasAllPermissionControllerTitles()
{
ResourceManager manager = RadyaLabs.Resources.Permission.Controller.Titles.ResourceManager;
using (TestingContext context = new TestingContext())
using (Configuration configuration = new Configuration(context))
{
configuration.SeedData();
String[] controllers = context
.Set <Permission>()
.Select(permission => permission.Area + permission.Controller)
.Distinct()
.ToArray();
foreach (String controller in controllers)
{
Assert.True(!String.IsNullOrEmpty(manager.GetString(controller)), $"'{controller}' permission, does not have a title.");
}
}
}
public void CanLogin_IncorrectPassword_ReturnsFalse()
{
account = context.Set <Account>().Single();
account.IsLocked = true;
context.SaveChanges();
AccountLoginView view = ObjectFactory.CreateAccountLoginView();
hasher.VerifyPassword(view.Password, Arg.Any <String>()).Returns(false);
Boolean canLogin = validator.CanLogin(view);
Alert alert = validator.Alerts.Single();
Assert.False(canLogin);
Assert.Equal(0, alert.Timeout);
Assert.Empty(validator.ModelState);
Assert.Equal(AlertType.Danger, alert.Type);
Assert.Equal(Validations.IncorrectAuthentication, alert.Message);
}
public void Resources_HasAllPermissionActionTitles()
{
ResourceManager manager = MvcTemplate.Resources.Permission.Action.Titles.ResourceManager;
using (TestingContext context = new TestingContext())
using (Configuration configuration = new Configuration(context))
{
configuration.SeedData();
String[] actions = context
.Set <Permission>()
.Select(permission => permission.Area + permission.Controller + permission.Action)
.Distinct()
.ToArray();
foreach (String action in actions)
{
Assert.True(!String.IsNullOrEmpty(manager.GetString(action)), $"'{action} permission', does not have a title.");
}
}
}
public void FilterById_FromCurrentFilter()
{
TestingContext context = new TestingContext();
Role role = ObjectFactory.CreateRole();
context.Set <Role>().Add(role);
context.SaveChanges();
IUnitOfWork unitOfWork = new UnitOfWork(context);
datalist = new MvcDatalist <Role, RoleView>(unitOfWork);
datalist.Filter.Id = role.Id.ToString();
RoleView expected = unitOfWork.Select <Role>().To <RoleView>().Single();
RoleView actual = datalist.FilterById(null).Single();
Assert.Equal(expected.CreationDate, actual.CreationDate);
Assert.Equal(expected.Title, actual.Title);
Assert.Equal(expected.Id, actual.Id);
}
private void SetUpData()
{
Account account = ObjectFactory.CreateAccount();
role = ObjectFactory.CreateRole();
account.RoleId = role.Id;
context.Set <Account>().Add(account);
role.RolePrivileges = new List <RolePrivilege>();
Int32 privNumber = 1;
IEnumerable <String> controllers = new[] { "Accounts", "Roles" };
IEnumerable <String> actions = new[] { "Index", "Create", "Details", "Edit", "Delete" };
foreach (String controller in controllers)
{
foreach (String action in actions)
{
RolePrivilege rolePrivilege = ObjectFactory.CreateRolePrivilege(privNumber++);
rolePrivilege.Privilege = new Privilege()
{
Area = "Administration", Controller = controller, Action = action
};
rolePrivilege.Privilege.Id = rolePrivilege.Id;
rolePrivilege.PrivilegeId = rolePrivilege.Id;
rolePrivilege.RoleId = role.Id;
rolePrivilege.Role = role;
role.RolePrivileges.Add(rolePrivilege);
}
}
context.Set <Role>().Add(role);
context.SaveChanges();
}
private void SetUpData()
{
role = ObjectFactory.CreateRole();
foreach (String controller in new[] { "Roles", "Profile" })
{
foreach (String action in new[] { "Edit", "Delete" })
{
RolePermission rolePermission = ObjectFactory.CreateRolePermission(role.Permissions.Count + 1);
rolePermission.Permission.Area = controller == "Roles" ? "Administration" : null;
rolePermission.Permission.Controller = controller;
rolePermission.Permission.Action = action;
rolePermission.RoleId = role.Id;
rolePermission.Role = null;
role.Permissions.Add(rolePermission);
}
}
using (TestingContext testingContext = new TestingContext())
{
testingContext.Set <Role>().Add(role);
testingContext.SaveChanges();
}
}
public void LoggableEntity_CreatesPropertiesForAttachedEntity()
{
context.Dispose();
String title = model.Title;
context = new TestingContext();
context.Set <Role>().Attach(model);
entry = context.Entry <BaseModel>(model);
entry.OriginalValues["Title"] = "Role";
entry.CurrentValues["Title"] = "Role";
entry.State = EntityState.Modified;
IEnumerator <LoggableProperty> expected = new List <LoggableProperty> {
new LoggableProperty(entry.Property("Title"), title)
}.GetEnumerator();
IEnumerator <LoggableProperty> actual = new LoggableEntity(entry).Properties.GetEnumerator();
while (expected.MoveNext() | actual.MoveNext())
{
Assert.Equal(expected.Current.IsModified, actual.Current.IsModified);
Assert.Equal(expected.Current.ToString(), actual.Current.ToString());
}
}
public void GetAs_ReturnsModelAsDestinationModelById()
{
context.Set <TestModel>().Add(model);
context.SaveChanges();
TestView expected = Mapper.Map <TestView>(model);
TestView actual = unitOfWork.GetAs <TestModel, TestView>(model.Id);
Assert.Equal(expected.CreationDate, actual.CreationDate);
Assert.Equal(expected.Title, actual.Title);
Assert.Equal(expected.Id, actual.Id);
}
public void GetViews_ReturnsAccountViews()
{
IEnumerator <AccountView> actual = service.GetViews().GetEnumerator();
IEnumerator <AccountView> expected = context
.Set <Account>()
.ProjectTo <AccountView>()
.OrderByDescending(view => view.Id)
.GetEnumerator();
while (expected.MoveNext() | actual.MoveNext())
{
Assert.Equal(expected.Current.CreationDate, actual.Current.CreationDate);
Assert.Equal(expected.Current.RoleTitle, actual.Current.RoleTitle);
Assert.Equal(expected.Current.IsLocked, actual.Current.IsLocked);
Assert.Equal(expected.Current.Username, actual.Current.Username);
Assert.Equal(expected.Current.Email, actual.Current.Email);
Assert.Equal(expected.Current.Id, actual.Current.Id);
}
}
public void RolesTable_HasSysAdmin()
{
Assert.NotNull(context.Set <Role>().SingleOrDefault(role => role.Title == "Sys_Admin"));
}
public void Update(StudentTestResult item)
{
// db.Entry(item).State = EntityState.Modified;
db.Set <StudentTestResult>().AddOrUpdate(item);
}
public void Seed_Roles()
{
configuration.Seed();
Assert.Single(context.Set <Role>(), role => role.Title == "Sys_Admin");
}
public void CanReset_CanNotResetAccountWithExpiredToken()
{
Account account = context.Set <Account>().Single();
account.RecoveryTokenExpirationDate = DateTime.Now.AddMinutes(-5);
context.SaveChanges();
Assert.False(validator.CanReset(ObjectFactory.CreateAccountResetView()));
}
public void SeedPrivilegesTree_FirstDepth()
{
IEnumerable <Privilege> privileges = CreateRoleWithPrivileges().RolePrivileges.Select(rolePriv => rolePriv.Privilege);
context.Set <Privilege>().AddRange(privileges);
context.SaveChanges();
RoleView role = new RoleView();
service.SeedPrivilegesTree(role);
IEnumerator <JsTreeNode> expected = CreateRoleView().PrivilegesTree.Nodes.GetEnumerator();
IEnumerator <JsTreeNode> actual = role.PrivilegesTree.Nodes.GetEnumerator();
while (expected.MoveNext() | actual.MoveNext())
{
Assert.Equal(expected.Current.Id, actual.Current.Id);
Assert.Equal(expected.Current.Title, actual.Current.Title);
Assert.Equal(expected.Current.Nodes.Count, actual.Current.Nodes.Count);
}
}
public void GetViews_GetsAccountViews()
{
IEnumerable <AccountView> actual = service.GetViews();
IEnumerable <AccountView> expected = context
.Set <Account>()
.Project()
.To <AccountView>()
.OrderByDescending(account => account.EntityDate);
TestHelper.EnumPropertyWiseEqual(expected, actual);
}