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); }