public void ConnectionInformationDialog_CreateConnectionInformation_ValidModel_ReturnsConnectionInformation() { // Setup var serverUrl = "https://localhost"; var username = "******"; var inputPlaintextPassword = "******"; var securePassword = inputPlaintextPassword.ConvertToSecureString(); ConnectionInfoDialogViewModel viewModel = ConnectionInformationDialog.CreateViewModel(null); viewModel.ServerUrlRaw = serverUrl; viewModel.Username = username; viewModel.ValidateCredentials(securePassword); // Act ConnectionInformation connInfo = ConnectionInformationDialog.CreateConnectionInformation(viewModel, securePassword); // Verify Assert.IsNotNull(connInfo, "ConnectionInformation should be returned"); Assert.AreEqual(new Uri(serverUrl), connInfo.ServerUri, "Server URI returned was different"); Assert.AreEqual(username, connInfo.UserName, "Username returned was different"); string outputPlaintextPassword = connInfo.Password.ConvertToUnsecureString(); Assert.AreEqual(inputPlaintextPassword, outputPlaintextPassword, "Password returned was different"); }
public void TestSetup() { Model = new ConnectionInfoDialogViewModel(); Events = new List <PropertyChangedEventArgs>(); Model.PropertyChanged += (sender, e) => Events.Add(e); }
public void ConnectionInformationDialog_CreateConnectionInformation_ValidModel_ReturnsConnectionInformation() { // Arrange var serverUrl = "https://localhost"; var username = "******"; var inputPlaintextPassword = "******"; var securePassword = inputPlaintextPassword.ToSecureString(); ConnectionInfoDialogViewModel viewModel = ConnectionInformationDialog.CreateViewModel(null); viewModel.ServerUrlRaw = serverUrl; viewModel.Username = username; viewModel.ValidateCredentials(securePassword); // Act ConnectionInformation connInfo = ConnectionInformationDialog.CreateConnectionInformation(viewModel, securePassword); // Assert connInfo.Should().NotBeNull("ConnectionInformation should be returned"); connInfo.ServerUri.Should().Be(new Uri(serverUrl), "Server URI returned was different"); connInfo.UserName.Should().Be(username, "Username returned was different"); string outputPlaintextPassword = connInfo.Password.ToUnsecureString(); outputPlaintextPassword.Should().Be(inputPlaintextPassword, "Password returned was different"); }
public void ConnectDialogViewModel_ShowSecurityWarning_InsecureUriScheme_IsTrue() { var model = new ConnectionInfoDialogViewModel(); model.ServerUrlRaw = "http://hostname"; model.ShowSecurityWarning.Should().BeTrue("Security warning should be visible"); model.ServerUrlRaw = "https://hostname"; model.ShowSecurityWarning.Should().BeFalse("Security warning should not be visible"); }
public void ConnectDialogViewModel_GetErrorForProperty_ServerUrlRaw_NoValidationErrorWhenPristine() { // Test case 1: new model has pristine URL // Arrange var testSubject1 = new ConnectionInfoDialogViewModel(); // Act string validationError1 = GetErrorForProperty(testSubject1, nameof(testSubject1.ServerUrlRaw)); // Assert testSubject1.IsUrlPristine.Should().BeTrue("Server URL should be pristine on initial view model construction"); validationError1.Should().BeNull("Validation error should be null on initial view model construction"); // Test case 2a: setting raw server url makes it 'dirty' valid URL // Arrange var testSubject2a = new ConnectionInfoDialogViewModel { // Act ServerUrlRaw = "http://localhost" }; string validationError2a = GetErrorForProperty(testSubject2a, nameof(testSubject2a.ServerUrlRaw)); // Assert testSubject2a.IsUrlPristine.Should().BeFalse("Server URL should no longer be pristine once set to a valid URL"); validationError2a.Should().BeNull("Validation error should be null for valid URL"); // Test case 2b: setting raw server url makes it 'dirty' invalid URL // Arrange var testSubject2b = new ConnectionInfoDialogViewModel { // Act ServerUrlRaw = "not-a-valid-url" }; string validationError2b = GetErrorForProperty(testSubject2b, nameof(testSubject2b.ServerUrlRaw)); // Assert testSubject2b.IsUrlPristine.Should().BeFalse("Server URL should no longer be pristine once set to an invalid URL"); validationError2b.Should().NotBeNull("Validation error should not be null for invalid URL"); // Test case 3: clearing a non-pristine view model should still be non-pristine // Arrange var testSubject3 = new ConnectionInfoDialogViewModel { ServerUrlRaw = "blah" // Makes url field dirty }; testSubject3.IsUrlPristine.Should().BeFalse("URL should be made dirty before clearing the field"); // Sanity check // Act testSubject3.ServerUrlRaw = null; // Clear field // Assert testSubject3.IsUrlPristine.Should().BeFalse("Server URL should still be non-pristine even after clearing the field"); }
public void ConnectDialogViewModel_ShowSecurityWarning_InsecureUriScheme_IsTrue() { #pragma warning disable IDE0017 // Simplify object initialization var model = new ConnectionInfoDialogViewModel(); #pragma warning restore IDE0017 // Simplify object initialization model.ServerUrlRaw = "http://hostname"; model.ShowSecurityWarning.Should().BeTrue("Security warning should be visible"); model.ServerUrlRaw = "https://hostname"; model.ShowSecurityWarning.Should().BeFalse("Security warning should not be visible"); }
public void ConnectionInformationDialog_CreateConnectionInformation_WithExistingConnection() { // Setup var connectionInformation = new ConnectionInformation(new Uri("http://blablabla"), "admin", "P@ssword1".ConvertToSecureString()); // Act ConnectionInfoDialogViewModel viewModel = ConnectionInformationDialog.CreateViewModel(connectionInformation); // Verify Assert.AreEqual(connectionInformation.ServerUri, viewModel.ServerUrl, "Unexpected ServerUrl"); Assert.AreEqual(connectionInformation.UserName, viewModel.Username, "Unexpected UserName"); }
public void ConnectionInformationDialog_CreateConnectionInformation_WithExistingConnection() { // Arrange var connectionInformation = new ConnectionInformation(new Uri("http://blablabla"), "admin", "P@ssword1".ToSecureString()); // Act ConnectionInfoDialogViewModel viewModel = ConnectionInformationDialog.CreateViewModel(connectionInformation); // Assert viewModel.ServerUrl.Should().Be(connectionInformation.ServerUri, "Unexpected ServerUrl"); viewModel.Username.Should().Be(null, "Not expecting the user name to be populated"); }
internal /*for testing purposes*/ static ConnectionInfoDialogViewModel CreateViewModel(ConnectionInformation currentConnection) { var vm = new ConnectionInfoDialogViewModel(); if (currentConnection != null) { vm.ServerUrlRaw = currentConnection.ServerUri.AbsoluteUri; vm.Username = currentConnection.UserName; } return(vm); }
internal /*for testing purposes*/ static ConnectionInfoDialogViewModel CreateViewModel(ConnectionInformation currentConnection) { var vm = new ConnectionInfoDialogViewModel(); if (currentConnection != null) { vm.ServerUrlRaw = currentConnection.ServerUri.AbsoluteUri; // Security: don't populate the user name field, as this might be a token // See https://github.com/SonarSource/sonarlint-visualstudio/issues/1081 } return(vm); }
public void ConnectDialogViewModel_ServerUrl_SetOnlyWhenServerUrlRawIsValid() { // Arrange var model = new ConnectionInfoDialogViewModel(); // Test: // Invalid entry does not set ServerUrl model.ServerUrlRaw = "http:/localhost/"; model.ServerUrl.Should().BeNull(); // Valid entry updates ServerUrl model.ServerUrlRaw = "http://localhost/"; model.ServerUrl.Should().NotBeNull(); model.ServerUrl.Should().Be(new Uri(model.ServerUrlRaw), "Uri property should match raw string property"); }
public void ConnectDialogViewModel_ServerUrl_SetOnlyWhenServerUrlRawIsValid() { // Setup var model = new ConnectionInfoDialogViewModel(); // Test: // Invalid entry does not set ServerUrl model.ServerUrlRaw = "http:/localhost/"; Assert.IsTrue(model.ServerUrl == null, "ServerUrl should not be set"); // Valid entry updates ServerUrl model.ServerUrlRaw = "http://localhost/"; Assert.IsFalse(model.ServerUrl == null, "ServerUrl should set"); Assert.AreEqual(new Uri(model.ServerUrlRaw), model.ServerUrl, "Uri property should match raw string property"); }
public void ConnectDialogViewModel_ServerUrl_SetOnlyWhenServerUrlRawIsValid() { // Arrange #pragma warning disable IDE0017 // Simplify object initialization var model = new ConnectionInfoDialogViewModel(); #pragma warning restore IDE0017 // Simplify object initialization // Test: // Invalid entry does not set ServerUrl model.ServerUrlRaw = "http:/localhost/"; model.ServerUrl.Should().BeNull(); // Valid entry updates ServerUrl model.ServerUrlRaw = "http://localhost/"; model.ServerUrl.Should().NotBeNull(); model.ServerUrl.Should().Be(new Uri(model.ServerUrlRaw), "Uri property should match raw string property"); }
public void ConnectionInformationDialog_CreateConnectionInformation_NullArgumentChecks() { // Arrange ConnectionInfoDialogViewModel viewModel = ConnectionInformationDialog.CreateViewModel(null); // Test 1: null viewModel Exceptions.Expect <ArgumentNullException>(() => { ConnectionInformationDialog.CreateConnectionInformation(null, new SecureString()); }); // Test 2: null password Exceptions.Expect <ArgumentNullException>(() => { ConnectionInformationDialog.CreateConnectionInformation(viewModel, null); }); }
/// <summary> /// Opens a window and returns only when the dialog is closed. /// </summary> /// <param name="currentConnection">Optional, the current connection information to show in the dialog</param> /// <returns>Captured connection information if closed successfully, null otherwise.</returns> public ConnectionInformation ShowDialog(ConnectionInformation currentConnection) { ConnectionInfoDialogViewModel vm = CreateViewModel(currentConnection); ConnectionInfoDialogView dialog = CreateView(); dialog.ViewModel = vm; dialog.Owner = Application.Current.MainWindow; bool?result = dialog.ShowDialog(); if (result.GetValueOrDefault()) { return(CreateConnectionInformation(vm, dialog.Password)); } return(null); }
public void ConnectionInformationDialog_CreateConnectionInformation_InvalidModel_ReturnsNull() { // Arrange ConnectionInfoDialogViewModel viewModel = ConnectionInformationDialog.CreateViewModel(null); viewModel.IsValid.Should().BeFalse("Empty view model should be invalid"); var emptyPassword = new SecureString(); // Act ConnectionInformation connInfo; using (var assertIgnoreScope = new AssertIgnoreScope()) { connInfo = ConnectionInformationDialog.CreateConnectionInformation(viewModel, emptyPassword); } // Assert connInfo.Should().BeNull("No ConnectionInformation should be returned with an invalid model"); }
/// <summary> /// Shows a (modal) dialog which requests connection details from the user /// </summary> /// <param name="currentConnection">Connection information used to pre-populate fields</param> /// <returns>Connection details inputted by user or null if the dialog is dismissed</returns> public static ConnectionInformation ShowDialog(ConnectionInformation currentConnection = null) { var viewModel = new ConnectionInfoDialogViewModel(); var dialog = new ConnectionInfoDialogView { DataContext = viewModel, Owner = Application.Current.MainWindow }; if (null != currentConnection) { viewModel.ServerUrl = currentConnection.ServerUrl; viewModel.Login = currentConnection.Login; } bool?result = dialog.ShowDialog(); if (result.GetValueOrDefault()) { return(new ConnectionInformation(viewModel.ServerUrl, viewModel.Login, viewModel.Password)); } return(null); }
private static string GetErrorForProperty(ConnectionInfoDialogViewModel viewModel, string propertyName) { var errors = ((INotifyDataErrorInfo)viewModel).GetErrors(propertyName) as IEnumerable <string>; return(errors?.FirstOrDefault()); }
internal /* testing purposes */ static ConnectionInformation CreateConnectionInformation(ConnectionInfoDialogViewModel viewModel, SecureString password) { if (viewModel == null) { throw new ArgumentNullException(nameof(viewModel)); } if (password == null) { throw new ArgumentNullException(nameof(password)); } ConnectionInformation info = null; Debug.Assert(viewModel.IsValid, "View model should be valid when creating connection information"); if (viewModel.IsValid) { Uri serverUri = viewModel.ServerUrl; string username = viewModel.Username; info = new ConnectionInformation(serverUri, username, password); } return(info); }