public void SecurityViewModel_CloseHelpCommand_IsServerHelpVisibleIsTrue_IsServerHelpVisibleIsFalse()
{
//------------Setup for test--------------------------
var viewModel = new SecurityViewModel(new SecuritySettingsTO(new WindowsGroupPermission[0]), new Mock<IResourcePickerDialog>().Object, new Mock<DirectoryObjectPickerDialog>().Object, new Mock<IWin32Window>().Object, new Mock<IEnvironmentModel>().Object) { IsServerHelpVisible = true };
//------------Execute Test---------------------------
viewModel.CloseHelpCommand.Execute(null);
//------------Assert Results-------------------------
Assert.IsFalse(viewModel.IsResourceHelpVisible);
Assert.IsFalse(viewModel.IsServerHelpVisible);
}
public void SetItem(SecurityViewModel model)
{
ItemServerPermissions = CloneServerPermissions(model.ServerPermissions);
ItemResourcePermissions = CloneResourcePermissions(model.ResourcePermissions);
}
public void SecurityViewModel_HelpText_IsResourceHelpVisibleIsTrue_ContainsResourceHelpText()
{
//------------Setup for test--------------------------
var viewModel = new SecurityViewModel(new SecuritySettingsTO(new WindowsGroupPermission[0]), new Mock<IResourcePickerDialog>().Object, new Mock<DirectoryObjectPickerDialog>().Object, new Mock<IWin32Window>().Object, new Mock<IEnvironmentModel>().Object) { IsResourceHelpVisible = true };
//------------Execute Test---------------------------
//------------Assert Results-------------------------
Assert.AreEqual(HelpTextResources.SettingsSecurityResourceHelpResource, viewModel.HelpText);
}
public void SecurityViewModel_PickResourceCommand_PermissionHasResource_PickerShouldHavePermissionResourceAsSelectedResource()
{
//------------Setup for test--------------------------
const ResourceType ResourceType = ResourceType.WorkflowService;
const string ResourceName = "Resource2";
var resourceID = Guid.NewGuid();
var resourceModel = new Mock<IResourceModel>();
resourceModel.Setup(r => r.ID).Returns(resourceID);
resourceModel.Setup(r => r.ResourceType).Returns(ResourceType);
resourceModel.Setup(r => r.ResourceName).Returns(ResourceName);
resourceModel.Setup(r => r.Category).Returns("Category2");
var permission = new WindowsGroupPermission
{
IsServer = false,
WindowsGroup = "Deploy Admins",
View = false,
Execute = false,
Contribute = false,
DeployTo = true,
DeployFrom = true,
Administrator = false,
ResourceID = resourceID,
ResourceName = ResourceName
};
var picker = new Mock<IResourcePickerDialog>();
picker.Setup(p => p.ShowDialog(null)).Returns(false);
picker.SetupProperty(p => p.SelectedResource);
var mockEnvironmentModel = new Mock<IEnvironmentModel>();
var mockResourceRepository = new Mock<IResourceRepository>();
mockResourceRepository.Setup(repository => repository.FindSingle(It.IsAny<Expression<Func<IResourceModel, bool>>>(), false, false)).Returns(resourceModel.Object);
mockEnvironmentModel.Setup(model => model.ResourceRepository).Returns(mockResourceRepository.Object);
var viewModel = new SecurityViewModel(new SecuritySettingsTO(new[] { permission }), picker.Object, new Mock<DirectoryObjectPickerDialog>().Object, new Mock<IWin32Window>().Object, mockEnvironmentModel.Object);
//------------Execute Test---------------------------
viewModel.PickResourceCommand.Execute(viewModel.ResourcePermissions[0]);
//------------Assert Results-------------------------
Assert.AreEqual(resourceModel.Object, picker.Object.SelectedResource);
}
public void SecurityViewModel_PickResourceCommand_ResultIsNotNull_PermissionResourceIsUpdated()
{
//------------Setup for test--------------------------
var resourceID = Guid.NewGuid();
const string ResourceName = "Cat\\Resource";
var permission = new WindowsGroupPermission
{
IsServer = false,
WindowsGroup = "Deploy Admins",
View = false,
Execute = false,
Contribute = false,
DeployTo = true,
DeployFrom = true,
Administrator = false,
ResourceID = resourceID,
ResourceName = ResourceName
};
const ResourceType ResourceType = ResourceType.WorkflowService;
var newResourceID = Guid.NewGuid();
var resourceModel = new Mock<IResourceModel>();
resourceModel.Setup(r => r.ID).Returns(newResourceID);
resourceModel.Setup(r => r.ResourceType).Returns(ResourceType);
resourceModel.Setup(r => r.ResourceName).Returns("Resource2");
resourceModel.Setup(r => r.Category).Returns("Category2");
var picker = new Mock<IResourcePickerDialog>();
picker.Setup(p => p.ShowDialog(It.IsAny<IEnvironmentModel>())).Returns(true);
picker.Setup(p => p.SelectedResource).Returns(resourceModel.Object);
var viewModel = new SecurityViewModel(new SecuritySettingsTO(new[] { permission }), picker.Object, new Mock<DirectoryObjectPickerDialog>().Object, new Mock<IWin32Window>().Object, new Mock<IEnvironmentModel>().Object);
//------------Execute Test---------------------------
viewModel.PickResourceCommand.Execute(viewModel.ResourcePermissions[0]);
//------------Assert Results-------------------------
Assert.AreEqual(newResourceID, viewModel.ResourcePermissions[0].ResourceID);
Assert.AreEqual(ResourceType.GetTreeDescription() + "\\Category2\\Resource2", viewModel.ResourcePermissions[0].ResourceName);
}
public void SecurityViewModel_PickResourceCommand_ResultIsNull_PermissionResourceIsNotUpdated()
{
//------------Setup for test--------------------------
var resourceID = Guid.NewGuid();
const string ResourceName = "Cat\\Resource";
var permission = new WindowsGroupPermission
{
IsServer = false,
WindowsGroup = "Deploy Admins",
View = false,
Execute = false,
Contribute = false,
DeployTo = true,
DeployFrom = true,
Administrator = false,
ResourceID = resourceID,
ResourceName = ResourceName
};
var picker = new Mock<IResourcePickerDialog>();
picker.Setup(p => p.ShowDialog(null)).Returns(true);
picker.Setup(p => p.SelectedResource).Returns((IResourceModel)null);
var viewModel = new SecurityViewModel(new SecuritySettingsTO(new[] { permission }), picker.Object, new Mock<DirectoryObjectPickerDialog>().Object, new Mock<IWin32Window>().Object, new Mock<IEnvironmentModel>().Object);
//------------Execute Test---------------------------
viewModel.PickResourceCommand.Execute(viewModel.ResourcePermissions[0]);
//------------Assert Results-------------------------
Assert.AreEqual(resourceID, viewModel.ResourcePermissions[0].ResourceID);
Assert.AreEqual(ResourceName, viewModel.ResourcePermissions[0].ResourceName);
}
public void SecurityViewModel_PickWindowsGroupCommand_PermissionIsNull_DoesNothing()
{
//------------Setup for test--------------------------
var resourceID = Guid.NewGuid();
const string ResourceName = "Cat\\Resource";
var permission = new WindowsGroupPermission
{
IsServer = false,
WindowsGroup = "Deploy Admins",
View = false,
Execute = false,
Contribute = false,
DeployTo = true,
DeployFrom = true,
Administrator = false,
ResourceID = resourceID,
ResourceName = ResourceName
};
var viewModel = new SecurityViewModel(new SecuritySettingsTO(new[] { permission }), new Mock<IResourcePickerDialog>().Object, new Mock<DirectoryObjectPickerDialog>().Object, new Mock<IWin32Window>().Object, new Mock<IEnvironmentModel>().Object);
//------------Execute Test---------------------------
viewModel.PickWindowsGroupCommand.Execute(null);
//------------Assert Results-------------------------
Assert.AreEqual("Deploy Admins", viewModel.ResourcePermissions[0].WindowsGroup);
}
public void SecurityViewModel_Save_NullPermissions_ThrowsArgumentNullException()
{
//------------Setup for test--------------------------
var viewModel = new SecurityViewModel(new SecuritySettingsTO(new WindowsGroupPermission[0]), new Mock<IResourcePickerDialog>().Object, new Mock<DirectoryObjectPickerDialog>().Object, new Mock<IWin32Window>().Object, new Mock<IEnvironmentModel>().Object);
//------------Execute Test---------------------------
viewModel.Save(null);
//------------Assert Results-------------------------
}
public void SecurityViewModel_OnPermissionPropertyChanged_ResourcePermissionWindowsGroupAndResourceNameChangedToNonEmptyAndIsNew_NewResourcePermissionIsAdded()
{
//------------Setup for test--------------------------
var viewModel = new SecurityViewModel(new SecuritySettingsTO(), new Mock<IResourcePickerDialog>().Object, new Mock<DirectoryObjectPickerDialog>().Object, new Mock<IWin32Window>().Object, new Mock<IEnvironmentModel>().Object);
Assert.AreEqual(1, viewModel.ResourcePermissions.Count);
Assert.IsTrue(viewModel.ResourcePermissions[0].IsNew);
//------------Execute Test---------------------------
viewModel.ResourcePermissions[0].ResourceName = "xxx";
viewModel.ResourcePermissions[0].WindowsGroup = "xxx";
//------------Assert Results-------------------------
Assert.IsFalse(viewModel.ResourcePermissions[0].IsNew);
Assert.AreEqual(2, viewModel.ResourcePermissions.Count);
Assert.IsTrue(viewModel.ResourcePermissions[1].IsNew);
}
public void SecurityViewModel_OnPermissionPropertyChanged_MakeExecuteFalse_MakesAdministratorPermissionFalse()
{
//------------Setup for test--------------------------
var permission = new WindowsGroupPermission
{
IsServer = true,
WindowsGroup = "Deploy Admins",
DeployFrom = true,
DeployTo = true,
Administrator = true,
Contribute = true,
View = true,
Execute = true
};
var viewModel = new SecurityViewModel(new SecuritySettingsTO(new[] { permission }), new Mock<IResourcePickerDialog>().Object, new Mock<DirectoryObjectPickerDialog>().Object, new Mock<IWin32Window>().Object, new Mock<IEnvironmentModel>().Object);
Assert.IsFalse(viewModel.IsDirty);
//------------Execute Test---------------------------
permission.Execute = false;
//------------Assert Results-------------------------
Assert.IsFalse(permission.Contribute);
Assert.IsTrue(permission.View);
Assert.IsFalse(permission.Execute);
Assert.IsFalse(permission.Administrator);
Assert.IsTrue(permission.DeployFrom);
Assert.IsTrue(permission.DeployTo);
}
static void Verify_Constructor_InitializesProperties(SecuritySettingsTO securitySettingsTO)
{
//------------Execute Test---------------------------
var viewModel = new SecurityViewModel(securitySettingsTO, new Mock<IResourcePickerDialog>().Object, new Mock<DirectoryObjectPickerDialog>().Object, new Mock<IWin32Window>().Object, new Mock<IEnvironmentModel>().Object);
//------------Assert Results-------------------------
Assert.IsTrue(viewModel.CloseHelpCommand.CanExecute(null));
Assert.IsNotNull(viewModel.PickResourceCommand);
Assert.IsTrue(viewModel.PickResourceCommand.CanExecute(null));
Assert.IsNotNull(viewModel.PickWindowsGroupCommand);
Assert.IsTrue(viewModel.PickWindowsGroupCommand.CanExecute(null));
Assert.IsNotNull(viewModel.ServerPermissions);
Assert.IsNotNull(viewModel.ResourcePermissions);
var serverPerms = securitySettingsTO == null ? new List<WindowsGroupPermission>() : securitySettingsTO.WindowsGroupPermissions.Where(p => p.IsServer).ToList();
var resourcePerms = securitySettingsTO == null ? new List<WindowsGroupPermission>() : securitySettingsTO.WindowsGroupPermissions.Where(p => !p.IsServer).ToList();
// constructor adds an extra "new" permission
Assert.AreEqual(serverPerms.Count + 1, viewModel.ServerPermissions.Count);
Assert.AreEqual(resourcePerms.Count + 1, viewModel.ResourcePermissions.Count);
}
public void SecurityViewModel_HasDuplicateResourcePermissions_DuplicateNotDeleted_ReturnsTrue()
{
//------------Setup for test--------------------------
var securityViewModel = new SecurityViewModel(new SecuritySettingsTO(), new Mock<IResourcePickerDialog>().Object, new Mock<DirectoryObjectPickerDialog>().Object, new Mock<IWin32Window>().Object, new Mock<IEnvironmentModel>().Object);
var resourceId = Guid.NewGuid();
securityViewModel.ResourcePermissions.Add(new WindowsGroupPermission
{
WindowsGroup = "Some Group",
ResourceID = resourceId,
IsServer = false
});
securityViewModel.ResourcePermissions.Add(new WindowsGroupPermission
{
WindowsGroup = "Some Group",
ResourceID = resourceId,
IsServer = false,
});
//------------Execute Test---------------------------
var hasDuplicateResourcePermissions = securityViewModel.HasDuplicateResourcePermissions();
//------------Assert Results-------------------------
Assert.IsTrue(hasDuplicateResourcePermissions);
}
public void SecurityViewModel_ServerDuplicates_Duplicates_ReturnsTrue()
{
//------------Setup for test--------------------------
var securityViewModel = new SecurityViewModel(new SecuritySettingsTO(), new Mock<IResourcePickerDialog>().Object, new Mock<DirectoryObjectPickerDialog>().Object, new Mock<IWin32Window>().Object, new Mock<IEnvironmentModel>().Object);
securityViewModel.ServerPermissions.Add(new WindowsGroupPermission
{
WindowsGroup = "Some Group",
ResourceID = Guid.Empty,
IsServer = true
});
securityViewModel.ServerPermissions.Add(new WindowsGroupPermission
{
WindowsGroup = "Some Group",
ResourceID = Guid.Empty,
IsServer = true
});
//------------Execute Test---------------------------
var hasDuplicateServerPermissions = securityViewModel.HasDuplicateServerPermissions();
//------------Assert Results-------------------------
Assert.IsTrue(hasDuplicateServerPermissions);
}
public void SecurityViewModel_Save_DeletedPermissions_DeletedPermissionsAreRemoved()
{
//------------Setup for test--------------------------
var permissions = CreatePermissions();
var deletedPermission = permissions[permissions.Count - 1];
deletedPermission.IsDeleted = true;
var viewModel = new SecurityViewModel(new SecuritySettingsTO(permissions), new Mock<IResourcePickerDialog>().Object, new Mock<DirectoryObjectPickerDialog>().Object, new Mock<IWin32Window>().Object, new Mock<IEnvironmentModel>().Object);
var target = new SecuritySettingsTO();
var expectedCount = permissions.Count - 1;
var expectedResourceCount = viewModel.ResourcePermissions.Count - 1;
//------------Execute Test---------------------------
viewModel.Save(target);
//------------Assert Results-------------------------
Assert.AreEqual(expectedCount, target.WindowsGroupPermissions.Count);
Assert.AreEqual(expectedResourceCount, viewModel.ResourcePermissions.Count);
foreach (var permission in target.WindowsGroupPermissions)
{
Assert.IsTrue(permission.IsValid);
Assert.IsFalse(permission.IsNew);
}
Assert.AreEqual(1, viewModel.ResourcePermissions.Count(p => p.IsNew));
Assert.AreEqual(1, viewModel.ServerPermissions.Count(p => p.IsNew));
}
static TestSettingsViewModel CreateSettingsViewModel(string executeCommandReadResult = "", string executeCommandWriteResult = "", SecurityViewModel securityViewModel = null)
{
var mock = new Mock<IPopupController>();
mock.Setup(controller => controller.Show()).Returns(MessageBoxResult.Yes);
return CreateSettingsViewModel(mock.Object, executeCommandReadResult, executeCommandWriteResult, securityViewModel);
}
static TestSettingsViewModel CreateSettingsViewModel(IPopupController popupController, string executeCommandReadResult = "", string executeCommandWriteResult = "", SecurityViewModel securityViewModel = null)
{
var viewModel = new TestSettingsViewModel(new Mock<IEventAggregator>().Object, popupController, AsyncWorkerTests.CreateSynchronousAsyncWorker().Object, new Mock<IWin32Window>().Object) { TheSecurityViewModel = securityViewModel };
var mockResourceRepo = new Mock<IResourceRepository>();
ExecuteMessage writeMsg = null;
if(!string.IsNullOrEmpty(executeCommandWriteResult))
{
writeMsg = new ExecuteMessage { HasError = executeCommandWriteResult != "Success" };
writeMsg.SetMessage(executeCommandWriteResult);
}
mockResourceRepo.Setup(c => c.ReadSettings(It.IsAny<IEnvironmentModel>())).Returns(executeCommandReadResult == null ? null : new Dev2JsonSerializer().Deserialize<Data.Settings.Settings>(executeCommandReadResult));
mockResourceRepo.Setup(c => c.WriteSettings(It.IsAny<IEnvironmentModel>(), It.IsAny<Data.Settings.Settings>())).Returns(writeMsg);
var environment = new Mock<IEnvironmentModel>();
environment.Setup(e => e.IsConnected).Returns(true);
environment.Setup(c => c.ResourceRepository).Returns(mockResourceRepo.Object);
Mock<IAuthorizationService> authService = new Mock<IAuthorizationService>();
authService.Setup(c => c.IsAuthorized(It.IsAny<AuthorizationContext>(), It.IsAny<string>())).Returns(true);
environment.Setup(c => c.AuthorizationService).Returns(authService.Object);
// simulate auto-loading of ConnectControl ComboBox
viewModel.ServerChangedCommand.Execute(environment.Object);
return viewModel;
}
public void SecurityViewModel_OnPermissionPropertyChanged_ResourcePermissionWindowsGroupChangedToEmptyAndIsNotNew_ResourcePermissionIsRemoved()
{
//------------Setup for test--------------------------
var permission = new WindowsGroupPermission
{
IsServer = false,
WindowsGroup = "Deploy Admins",
View = false,
Execute = false,
Contribute = false,
DeployTo = true,
DeployFrom = true,
Administrator = false
};
var viewModel = new SecurityViewModel(new SecuritySettingsTO(new[] { permission }), new Mock<IResourcePickerDialog>().Object, new Mock<DirectoryObjectPickerDialog>().Object, new Mock<IWin32Window>().Object, new Mock<IEnvironmentModel>().Object);
Assert.AreEqual(2, viewModel.ResourcePermissions.Count);
Assert.IsFalse(viewModel.ResourcePermissions[0].IsNew);
Assert.IsTrue(viewModel.ResourcePermissions[1].IsNew);
Assert.AreSame(permission, viewModel.ResourcePermissions[0]);
//------------Execute Test---------------------------
viewModel.ResourcePermissions[0].WindowsGroup = "";
//------------Assert Results-------------------------
Assert.AreEqual(1, viewModel.ResourcePermissions.Count);
Assert.IsTrue(viewModel.ResourcePermissions[0].IsNew);
Assert.AreNotSame(permission, viewModel.ResourcePermissions[0]);
}