public async Task WhenBehaviorSetToForceAndPermissionsGranted_ThenDialogIsSkippedAndCredentialsAreGenerated()
{
var taskDialog = new Mock <ITaskDialog>();
var credentialPrompt = CreateCredentialsPrompt(true, true, taskDialog);
var settings = InstanceConnectionSettings.CreateNew(SampleInstance);
settings.RdpCredentialGenerationBehavior.EnumValue = RdpCredentialGenerationBehavior.Force;
await credentialPrompt.ShowCredentialsPromptAsync(
null,
SampleInstance,
settings,
true);
Assert.AreEqual("bob", settings.RdpUsername.StringValue);
Assert.AreEqual("secret", settings.RdpPassword.ClearTextValue);
Assert.IsNull(settings.RdpDomain.Value);
// No dialog shown.
taskDialog.Verify(t => t.ShowOptionsTaskDialog(
It.IsAny <IWin32Window>(),
It.IsAny <IntPtr>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <IList <string> >(),
It.IsAny <string>(),
out It.Ref <bool> .IsAny), Times.Never);
}
public async Task WhenNoSuggestedUserNameProvidedAndSilentIsTrue_ThenSuggestionIsDerivedFromSigninNameWithoutPrompting()
{
var serviceRegistry = new ServiceRegistry();
var auth = new Mock <IAuthorization>();
auth.SetupGet(a => a.Email).Returns("*****@*****.**");
serviceRegistry.AddMock <IAuthorizationAdapter>()
.SetupGet(a => a.Authorization).Returns(auth.Object);
serviceRegistry.AddSingleton <IJobService, SynchronousJobService>();
serviceRegistry.AddMock <IComputeEngineAdapter>()
.Setup(a => a.ResetWindowsUserAsync(
It.IsAny <InstanceLocator>(),
It.Is <string>(user => user == "bobsemail"),
It.IsAny <CancellationToken>()))
.ReturnsAsync(new NetworkCredential("bobsemail", "password"));
var credDialog = serviceRegistry.AddMock <IGenerateCredentialsDialog>();
var settings = InstanceConnectionSettings.CreateNew(SampleInstance);
var credentialsService = new CredentialsService(serviceRegistry);
await credentialsService.GenerateCredentialsAsync(
null,
SampleInstance,
settings,
true);
Assert.AreEqual("bobsemail", settings.RdpUsername.Value);
Assert.AreEqual("password", settings.RdpPassword.ClearTextValue);
credDialog.Verify(d => d.PromptForUsername(
It.IsAny <IWin32Window>(),
It.IsAny <string>()), Times.Never);
}
public async Task WhenNoSessionExists_ThenActivateOrConnectInstanceAsyncUsesKeyValidityFromSettings()
{
var settings = InstanceConnectionSettings.CreateNew(SampleLocator.ProjectId, SampleLocator.Name);
settings.SshPort.IntValue = 2222;
settings.SshUsername.StringValue = "bob";
var settingsService = this.serviceRegistry.AddMock <IConnectionSettingsService>();
settingsService.Setup(s => s.GetConnectionSettings(It.IsAny <IProjectExplorerNode>()))
.Returns(settings
.ToPersistentSettingsCollection(s => Assert.Fail("should not be called")));
var sshSettingsRepository = this.serviceRegistry.GetService <SshSettingsRepository>();
var sshSettings = sshSettingsRepository.GetSettings();
sshSettings.PublicKeyValidity.IntValue = (int)TimeSpan.FromDays(4).TotalSeconds;
sshSettingsRepository.SetSettings(sshSettings);
var vmNode = new Mock <IProjectExplorerInstanceNode>();
vmNode.SetupGet(n => n.Instance).Returns(SampleLocator);
var service = new SshConnectionService(this.serviceRegistry);
await service.ActivateOrConnectInstanceAsync(vmNode.Object);
this.authorizedKeyService.Verify(s => s.AuthorizeKeyAsync(
It.Is <InstanceLocator>(l => l == SampleLocator),
It.IsAny <ISshKey>(),
It.Is <TimeSpan>(validity => validity == TimeSpan.FromDays(4)),
It.IsAny <string>(),
It.IsAny <AuthorizeKeyMethods>(),
It.IsAny <CancellationToken>()), Times.Once);
}
private async Task <IRemoteDesktopSession> Connect(
IapTunnel tunnel,
InstanceLocator vmInstanceReference)
{
using (var gceAdapter = new ComputeEngineAdapter(this.serviceProvider.GetService <IAuthorizationAdapter>()))
{
var credentials = await gceAdapter.ResetWindowsUserAsync(
vmInstanceReference,
CreateRandomUsername(),
TimeSpan.FromSeconds(60),
CancellationToken.None);
var settings = InstanceConnectionSettings.CreateNew(vmInstanceReference);
settings.RdpUsername.Value = credentials.UserName;
settings.RdpPassword.Value = credentials.SecurePassword;
settings.RdpAuthenticationLevel.Value = RdpAuthenticationLevel.NoServerAuthentication;
settings.RdpBitmapPersistence.Value = RdpBitmapPersistence.Disabled;
settings.RdpDesktopSize.Value = RdpDesktopSize.ClientSize;
var rdpService = new RemoteDesktopSessionBroker(this.serviceProvider);
return(rdpService.Connect(
vmInstanceReference,
"localhost",
(ushort)tunnel.LocalPort,
settings));
}
}
public void WhenSuggestedUserNameProvided_ThenSuggestionIsUsed()
{
var serviceRegistry = new ServiceRegistry();
var credDialog = serviceRegistry.AddMock <IGenerateCredentialsDialog>();
credDialog
.Setup(d => d.PromptForUsername(
It.IsAny <IWin32Window>(),
It.IsAny <string>()))
.Returns <string>(null); // Cancel dialog
var settings = InstanceConnectionSettings.CreateNew(SampleInstance);
settings.RdpUsername.Value = "alice";
var credentialsService = new CredentialsService(serviceRegistry);
AssertEx.ThrowsAggregateException <TaskCanceledException>(
() => credentialsService.GenerateCredentialsAsync(
null,
SampleInstance,
settings,
false).Wait());
credDialog.Verify(d => d.PromptForUsername(
It.IsAny <IWin32Window>(),
It.Is <string>(u => u == "alice")), Times.Once);
}
public void WhenNoSuggestedUserNameProvided_ThenSuggestionIsDerivedFromSigninName()
{
var serviceRegistry = new ServiceRegistry();
var auth = new Mock <IAuthorization>();
auth.SetupGet(a => a.Email).Returns("*****@*****.**");
serviceRegistry.AddMock <IAuthorizationAdapter>()
.SetupGet(a => a.Authorization).Returns(auth.Object);
var credDialog = serviceRegistry.AddMock <IGenerateCredentialsDialog>();
credDialog
.Setup(d => d.PromptForUsername(
It.IsAny <IWin32Window>(),
It.IsAny <string>()))
.Returns <string>(null); // Cancel dialog
var settings = InstanceConnectionSettings.CreateNew(SampleInstance);
var credentialsService = new CredentialsService(serviceRegistry);
AssertEx.ThrowsAggregateException <TaskCanceledException>(
() => credentialsService.GenerateCredentialsAsync(
null,
SampleInstance,
settings,
false).Wait());
credDialog.Verify(d => d.PromptForUsername(
It.IsAny <IWin32Window>(),
It.Is <string>(u => u == "bobsemail")), Times.Once);
}
public async Task WhenNoSessionExists_ThenActivateOrConnectInstanceAsyncUsesPreferredUsername()
{
var settings = InstanceConnectionSettings.CreateNew(SampleLocator.ProjectId, SampleLocator.Name);
settings.SshPort.IntValue = 2222;
settings.SshUsername.StringValue = "bob";
var settingsService = this.serviceRegistry.AddMock <IConnectionSettingsService>();
settingsService.Setup(s => s.GetConnectionSettings(It.IsAny <IProjectExplorerNode>()))
.Returns(settings
.ToPersistentSettingsCollection(s => Assert.Fail("should not be called")));
var vmNode = new Mock <IProjectExplorerVmInstanceNode>();
vmNode.SetupGet(n => n.Reference).Returns(SampleLocator);
var service = new SshConnectionService(this.serviceRegistry);
await service.ActivateOrConnectInstanceAsync(vmNode.Object);
this.authorizedKeyService.Verify(s => s.AuthorizeKeyAsync(
It.Is <InstanceLocator>(l => l == SampleLocator),
It.IsAny <ISshKey>(),
It.IsAny <TimeSpan>(),
It.Is <string>(user => user == "bob"),
It.IsAny <AuthorizeKeyMethods>(),
It.IsAny <CancellationToken>()), Times.Once);
}
public async Task WhenNoSessionExists_ThenActivateOrConnectInstanceAsyncUsesConnectionTimeout()
{
var settings = InstanceConnectionSettings.CreateNew(SampleLocator.ProjectId, SampleLocator.Name);
settings.SshPort.IntValue = 2222;
settings.SshConnectionTimeout.IntValue = (int)TimeSpan.FromSeconds(123).TotalSeconds;
var settingsService = this.serviceRegistry.AddMock <IConnectionSettingsService>();
settingsService.Setup(s => s.GetConnectionSettings(It.IsAny <IProjectExplorerNode>()))
.Returns(settings
.ToPersistentSettingsCollection(s => Assert.Fail("should not be called")));
var vmNode = new Mock <IProjectExplorerVmInstanceNode>();
vmNode.SetupGet(n => n.Reference).Returns(SampleLocator);
var service = new SshConnectionService(this.serviceRegistry);
await service.ActivateOrConnectInstanceAsync(vmNode.Object);
this.tunnelBrokerService.Verify(s => s.ConnectAsync(
It.Is <TunnelDestination>(d => d.RemotePort == 2222),
It.IsAny <ISshRelayPolicy>(),
It.Is <TimeSpan>(t => t == TimeSpan.FromSeconds(123))), Times.Once);
}
public async Task WhenCredentialsInvalid_ThenErrorIsShownAndWindowIsClosed(
[WindowsInstance(MachineType = MachineTypeForRdp)] ResourceTask <InstanceLocator> testInstance,
[Credential(Role = PredefinedRole.IapTunnelUser)] ResourceTask <ICredential> credential)
{
var locator = await testInstance;
using (var tunnel = IapTunnel.ForRdp(
locator,
await credential))
{
var settings = InstanceConnectionSettings.CreateNew(
locator.ProjectId,
locator.Name);
settings.RdpUsername.StringValue = "wrong";
settings.RdpPassword.Value = SecureStringExtensions.FromClearText("wrong");
settings.RdpAuthenticationLevel.EnumValue = RdpAuthenticationLevel.NoServerAuthentication;
settings.RdpUserAuthenticationBehavior.EnumValue = RdpUserAuthenticationBehavior.AbortOnFailure;
settings.RdpDesktopSize.EnumValue = RdpDesktopSize.ClientSize;
var rdpService = new RemoteDesktopSessionBroker(this.serviceProvider);
var session = rdpService.Connect(
locator,
"localhost",
(ushort)tunnel.LocalPort,
settings);
AwaitEvent <SessionAbortedEvent>();
Assert.IsNotNull(this.ExceptionShown);
Assert.IsInstanceOf(typeof(RdpDisconnectedException), this.ExceptionShown);
Assert.AreEqual(2055, ((RdpDisconnectedException)this.ExceptionShown).DisconnectReason);
}
}
public void WhenParseStringCreatedByToString_ResultIsSame()
{
var settings = InstanceConnectionSettings.CreateNew("project-1", "instance-1");
settings.RdpUsername.Value = "user";
settings.RdpDomain.Value = "domain";
settings.RdpConnectionBar.Value = RdpConnectionBarState.Off;
settings.RdpDesktopSize.Value = RdpDesktopSize.ScreenSize;
settings.RdpAuthenticationLevel.Value = RdpAuthenticationLevel.RequireServerAuthentication;
settings.RdpColorDepth.Value = RdpColorDepth.TrueColor;
settings.RdpAudioMode.Value = RdpAudioMode.PlayOnServer;
settings.RdpRedirectClipboard.Value = RdpRedirectClipboard.Disabled;
settings.RdpCredentialGenerationBehavior.Value = RdpCredentialGenerationBehavior.Disallow;
var url = new IapRdpUrl(
new InstanceLocator("project-1", "us-central1-a", "instance-1"),
settings.ToUrlQuery());
var copy = InstanceConnectionSettings.FromUrl(url);
Assert.AreEqual("user", copy.RdpUsername.Value);
Assert.AreEqual("domain", copy.RdpDomain.Value);
Assert.AreEqual(RdpConnectionBarState.Off, copy.RdpConnectionBar.Value);
Assert.AreEqual(RdpDesktopSize.ScreenSize, copy.RdpDesktopSize.Value);
Assert.AreEqual(RdpAuthenticationLevel.RequireServerAuthentication, copy.RdpAuthenticationLevel.Value);
Assert.AreEqual(RdpColorDepth.TrueColor, copy.RdpColorDepth.Value);
Assert.AreEqual(RdpAudioMode.PlayOnServer, copy.RdpAudioMode.Value);
Assert.AreEqual(RdpRedirectClipboard.Disabled, copy.RdpRedirectClipboard.Value);
Assert.AreEqual(RdpCredentialGenerationBehavior.Disallow, copy.RdpCredentialGenerationBehavior.Value);
}
public void WhenKeyAuthorizationFails_ThenActivateOrConnectInstanceAsyncActivatesSessionThrowsSshKeyPushFailedException()
{
var settingsService = this.serviceRegistry.AddMock <IConnectionSettingsService>();
settingsService.Setup(s => s.GetConnectionSettings(It.IsAny <IProjectExplorerNode>()))
.Returns(
InstanceConnectionSettings
.CreateNew(SampleLocator.ProjectId, SampleLocator.Name)
.ToPersistentSettingsCollection(s => Assert.Fail("should not be called")));
this.authorizedKeyService.Setup(a => a.AuthorizeKeyAsync(
It.IsAny <InstanceLocator>(),
It.IsAny <ISshKey>(),
It.IsAny <TimeSpan>(),
It.IsAny <string>(),
It.IsAny <AuthorizeKeyMethods>(),
It.IsAny <CancellationToken>()))
.ThrowsAsync(new SshKeyPushFailedException("mock", HelpTopics.ManagingOsLogin));
var vmNode = new Mock <IProjectExplorerVmInstanceNode>();
vmNode.SetupGet(n => n.Reference).Returns(SampleLocator);
var service = new SshConnectionService(this.serviceRegistry);
AssertEx.ThrowsAggregateException <SshKeyPushFailedException>(
() => service.ActivateOrConnectInstanceAsync(vmNode.Object).Wait());
}
public void WhenQueryStringContainsValidUserOrDomain_ThenSettingsUseDecodedValues()
{
var url = IapRdpUrl.FromString("iap-rdp:///my-project/us-central1-a/my-instance?" +
"userNAME=John%20Doe&PassworD=ignore&Domain=%20%20mydomain&");
var settings = InstanceConnectionSettings.FromUrl(url);
Assert.AreEqual("John Doe", settings.RdpUsername.Value);
Assert.IsNull(settings.RdpPassword.Value);
Assert.AreEqual(" mydomain", settings.RdpDomain.Value);
}
public async Task WhenConnectingByUrlWithUsernameAndCredentialsExist_ThenConnectionIsMadeWithUsernameFromUrl()
{
var settings = InstanceConnectionSettings.CreateNew("project", "instance-1");
settings.RdpUsername.Value = "existinguser";
settings.RdpPassword.Value = SecureStringExtensions.FromClearText("password");
var settingsService = this.serviceRegistry.AddMock <IConnectionSettingsService>();
settingsService.Setup(s => s.GetConnectionSettings(
It.IsAny <IProjectModelNode>()))
.Returns(
settings.ToPersistentSettingsCollection(s => Assert.Fail("should not be called")));
var vmNode = new Mock <IProjectModelInstanceNode>();
vmNode.SetupGet(n => n.Instance)
.Returns(new InstanceLocator("project-1", "zone-1", "instance-1"));
this.serviceRegistry.AddMock <ICredentialPrompt>()
.Setup(p => p.ShowCredentialsPromptAsync(
It.IsAny <IWin32Window>(),
It.IsAny <InstanceLocator>(),
It.IsAny <ConnectionSettingsBase>(),
It.IsAny <bool>()));
this.serviceRegistry.AddMock <IProjectModelService>()
.Setup(p => p.GetNodeAsync(
It.IsAny <ResourceLocator>(),
It.IsAny <CancellationToken>()))
.ReturnsAsync(vmNode.Object);
var remoteDesktopService = new Mock <IRemoteDesktopSessionBroker>();
remoteDesktopService.Setup(s => s.Connect(
It.IsAny <InstanceLocator>(),
"localhost",
It.IsAny <ushort>(),
It.IsAny <InstanceConnectionSettings>())).Returns <IRemoteDesktopSession>(null);
this.serviceRegistry.AddSingleton <IRemoteDesktopSessionBroker>(remoteDesktopService.Object);
var service = new RdpConnectionService(this.serviceRegistry);
await service.ActivateOrConnectInstanceAsync(
IapRdpUrl.FromString("iap-rdp:///project/us-central-1/instance-1?username=john%20doe"));
remoteDesktopService.Verify(s => s.Connect(
It.IsAny <InstanceLocator>(),
"localhost",
It.IsAny <ushort>(),
It.Is <InstanceConnectionSettings>(i => i.RdpUsername.StringValue == "john doe")), Times.Once);
settingsService.Verify(s => s.GetConnectionSettings(
It.IsAny <IProjectModelNode>()), Times.Once);
}
private async Task ConnectInstanceAsync(
InstanceLocator instance,
InstanceConnectionSettings settings)
{
var tunnel = await this.jobService.RunInBackground(
new JobDescription(
$"Opening Cloud IAP tunnel to {instance.Name}...",
JobUserFeedbackType.BackgroundFeedback),
async token =>
{
try
{
var destination = new TunnelDestination(
instance,
(ushort)settings.RdpPort.IntValue);
// Give IAP the same timeout for probing as RDP itself.
// Note that the timeouts are not additive.
var timeout = TimeSpan.FromSeconds(settings.RdpConnectionTimeout.IntValue);
return(await this.tunnelBroker.ConnectAsync(
destination,
new SameProcessRelayPolicy(),
timeout)
.ConfigureAwait(false));
}
catch (NetworkStreamClosedException e)
{
throw new ConnectionFailedException(
"Connecting to the instance failed. Make sure that you have " +
"configured your firewall rules to permit Cloud IAP access " +
$"to {instance.Name}",
HelpTopics.CreateIapFirewallRule,
e);
}
catch (UnauthorizedException)
{
throw new ConnectionFailedException(
"You are not authorized to connect to this VM instance.\n\n" +
$"Verify that the Cloud IAP API is enabled in the project {instance.ProjectId} " +
"and that your user has the 'IAP-secured Tunnel User' role.",
HelpTopics.IapAccess);
}
}).ConfigureAwait(true);
this.sessionBroker.Connect(
instance,
"localhost",
(ushort)tunnel.LocalPort,
settings);
}
public async Task WhenConnectingByNodeAndPersistentCredentialsAllowed_ThenCredentialsAreUsed()
{
var settings = InstanceConnectionSettings.CreateNew("project", "instance-1");
settings.RdpUsername.Value = "existinguser";
settings.RdpPassword.Value = SecureStringExtensions.FromClearText("password");
bool settingsSaved = false;
var settingsService = this.serviceRegistry.AddMock <IConnectionSettingsService>();
settingsService.Setup(s => s.GetConnectionSettings(
It.IsAny <IProjectExplorerNode>()))
.Returns(
settings.ToPersistentSettingsCollection(s => settingsSaved = true));
var vmNode = new Mock <IProjectExplorerInstanceNode>();
vmNode.SetupGet(n => n.Instance)
.Returns(new InstanceLocator("project-1", "zone-1", "instance-1"));
this.serviceRegistry.AddMock <IProjectExplorer>()
.Setup(p => p.TryFindNode(
It.IsAny <InstanceLocator>()))
.Returns(vmNode.Object);
var remoteDesktopService = new Mock <IRemoteDesktopSessionBroker>();
remoteDesktopService.Setup(s => s.Connect(
It.IsAny <InstanceLocator>(),
"localhost",
It.IsAny <ushort>(),
It.IsAny <InstanceConnectionSettings>())).Returns <IRemoteDesktopSession>(null);
this.serviceRegistry.AddSingleton <IRemoteDesktopSessionBroker>(remoteDesktopService.Object);
var service = new RdpConnectionService(this.serviceRegistry);
await service.ActivateOrConnectInstanceAsync(vmNode.Object, true);
remoteDesktopService.Verify(s => s.Connect(
It.IsAny <InstanceLocator>(),
"localhost",
It.IsAny <ushort>(),
It.Is <InstanceConnectionSettings>(i =>
i.RdpUsername.StringValue == "existinguser" &&
i.RdpPassword.ClearTextValue == "password")), Times.Once);
Assert.IsTrue(settingsSaved);
}
public async Task WhenCredentialsFoundAndBehaviorSetToAllowIfNoCredentialsFound_ThenDialogIsSkipped(
[Values(true, false)] bool isGrantedPermissionToGenerateCredentials)
{
var taskDialog = new Mock <ITaskDialog>();
taskDialog.Setup(t => t.ShowOptionsTaskDialog(
It.IsAny <IWin32Window>(),
It.IsAny <IntPtr>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <IList <string> >(),
It.IsAny <string>(),
out It.Ref <bool> .IsAny)).Returns(0);
var credentialPrompt = CreateCredentialsPrompt(
isGrantedPermissionToGenerateCredentials,
false,
taskDialog);
var settings = InstanceConnectionSettings.CreateNew(SampleInstance);
settings.RdpCredentialGenerationBehavior.EnumValue = RdpCredentialGenerationBehavior.AllowIfNoCredentialsFound;
settings.RdpUsername.StringValue = "alice";
settings.RdpPassword.ClearTextValue = "alicespassword";
await credentialPrompt.ShowCredentialsPromptAsync(
null,
SampleInstance,
settings,
true);
Assert.AreEqual("alice", settings.RdpUsername.Value);
Assert.AreEqual("alicespassword", settings.RdpPassword.ClearTextValue);
Assert.IsNull(settings.RdpDomain.Value);
taskDialog.Verify(t => t.ShowOptionsTaskDialog(
It.IsAny <IWin32Window>(),
It.IsAny <IntPtr>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <IList <string> >(),
It.IsAny <string>(),
out It.Ref <bool> .IsAny), Times.Never);
}
public void WhenVmInstanceSettingsArePopulated_ThenToUrlQueryExcludesPassword()
{
var settings = InstanceConnectionSettings.CreateNew("pro-1", "instance-1");
settings.RdpUsername.Value = "bob";
settings.RdpPassword.ClearTextValue = "secret";
settings.RdpRedirectClipboard.EnumValue = RdpRedirectClipboard.Disabled;
settings.RdpConnectionTimeout.IntValue = 123;
var query = settings.ToUrlQuery();
Assert.AreEqual(3, query.Count);
Assert.AreEqual("bob", query["Username"]);
Assert.AreEqual("0", query["RedirectClipboard"]);
Assert.AreEqual("123", query["ConnectionTimeout"]);
}
public void WhenSettingsContainsEscapableChars_ThenToStringEscapesThem()
{
var settings = InstanceConnectionSettings.CreateNew("project-1", "instance-1");
settings.RdpUsername.Value = "Tom & Jerry?";
settings.RdpDomain.Value = "\"?\"";
var url = new IapRdpUrl(
new InstanceLocator("project-1", "us-central1-a", "instance-1"),
settings.ToUrlQuery());
Assert.AreEqual(
"iap-rdp:///project-1/us-central1-a/instance-1?" +
"Username=Tom+%26+Jerry%3f&Domain=%22%3f%22",
url.ToString());
}
public void WhenServerInvalid_ThenErrorIsShownAndWindowIsClosed()
{
var settings = InstanceConnectionSettings.CreateNew(this.SampleLocator);
var rdpService = new RemoteDesktopSessionBroker(this.serviceProvider);
rdpService.Connect(
this.SampleLocator,
"invalid.corp",
3389,
settings);
AwaitEvent <SessionAbortedEvent>();
Assert.IsInstanceOf(typeof(RdpDisconnectedException), this.ExceptionShown);
Assert.AreEqual(260, ((RdpDisconnectedException)this.ExceptionShown).DisconnectReason);
}
public void WhenQueryStringContainsNonsense_ThenSettingsUsesDefaults()
{
var url = IapRdpUrl.FromString("iap-rdp:///my-project/us-central1-a/my-instance?a=b&user=wrongcase&_");
var settings = InstanceConnectionSettings.FromUrl(url);
Assert.IsNull(settings.RdpUsername.Value);
Assert.IsNull(settings.RdpPassword.Value);
Assert.IsNull(settings.RdpDomain.Value);
Assert.AreEqual(RdpConnectionBarState._Default, settings.RdpConnectionBar.Value);
Assert.AreEqual(RdpDesktopSize._Default, settings.RdpDesktopSize.Value);
Assert.AreEqual(RdpAuthenticationLevel._Default, settings.RdpAuthenticationLevel.Value);
Assert.AreEqual(RdpColorDepth._Default, settings.RdpColorDepth.Value);
Assert.AreEqual(RdpAudioMode._Default, settings.RdpAudioMode.Value);
Assert.AreEqual(RdpRedirectClipboard._Default, settings.RdpRedirectClipboard.Value);
Assert.AreEqual(RdpCredentialGenerationBehavior._Default, settings.RdpCredentialGenerationBehavior.Value);
}
public void WhenWrongPort_ThenErrorIsShownAndWindowIsClosed()
{
var settings = InstanceConnectionSettings.CreateNew(this.SampleLocator);
var rdpService = new RemoteDesktopSessionBroker(this.serviceProvider);
rdpService.Connect(
this.SampleLocator,
"localhost",
135, // That one will be listening, but it is RPC, not RDP.
settings);
AwaitEvent <SessionAbortedEvent>();
Assert.IsInstanceOf(typeof(RdpDisconnectedException), this.ExceptionShown);
Assert.AreEqual(2308, ((RdpDisconnectedException)this.ExceptionShown).DisconnectReason);
}
public void WhenQueryStringContainsValidSettings_ThenSettingsUseDecodedValues()
{
var url = IapRdpUrl.FromString("iap-rdp:///my-project/us-central1-a/my-instance?" +
"ConnectionBar=1&DesktopSize=1&AuthenticationLevel=0&ColorDepth=2&" +
"AudioMode=2&RedirectClipboard=0&CredentialGenerationBehavior=0&Rdpport=13389");
var settings = InstanceConnectionSettings.FromUrl(url);
Assert.AreEqual(RdpConnectionBarState.Pinned, settings.RdpConnectionBar.Value);
Assert.AreEqual(RdpDesktopSize.ScreenSize, settings.RdpDesktopSize.Value);
Assert.AreEqual(RdpAuthenticationLevel.AttemptServerAuthentication, settings.RdpAuthenticationLevel.Value);
Assert.AreEqual(RdpColorDepth.DeepColor, settings.RdpColorDepth.Value);
Assert.AreEqual(RdpAudioMode.DoNotPlay, settings.RdpAudioMode.Value);
Assert.AreEqual(RdpRedirectClipboard.Disabled, settings.RdpRedirectClipboard.Value);
Assert.AreEqual(RdpCredentialGenerationBehavior.Allow, settings.RdpCredentialGenerationBehavior.Value);
Assert.AreEqual(13389, settings.RdpPort.Value);
}
public async Task WhenSigningOutPerSendKeys_ThenWindowIsClosed(
[WindowsInstance(ImageFamily = WindowsInstanceAttribute.WindowsServer2019)]
ResourceTask <InstanceLocator> testInstance,
[Credential(Role = PredefinedRole.IapTunnelUser)] ResourceTask <ICredential> credential)
{
var locator = await testInstance;
using (var tunnel = IapTunnel.ForRdp(
locator,
await credential))
using (var gceAdapter = new ComputeEngineAdapter(this.serviceProvider.GetService <IAuthorizationAdapter>()))
{
var credentials = await gceAdapter.ResetWindowsUserAsync(
locator,
CreateRandomUsername(),
TimeSpan.FromSeconds(60),
CancellationToken.None);
var settings = InstanceConnectionSettings.CreateNew(
locator.ProjectId,
locator.Name);
settings.RdpUsername.StringValue = credentials.UserName;
settings.RdpPassword.Value = credentials.SecurePassword;
settings.RdpAuthenticationLevel.EnumValue = RdpAuthenticationLevel.NoServerAuthentication;
settings.RdpBitmapPersistence.EnumValue = RdpBitmapPersistence.Disabled;
settings.RdpDesktopSize.EnumValue = RdpDesktopSize.ClientSize;
var rdpService = new RemoteDesktopSessionBroker(this.serviceProvider);
var session = (RemoteDesktopPane)rdpService.Connect(
locator,
"localhost",
(ushort)tunnel.LocalPort,
settings);
AwaitEvent <SessionStartedEvent>();
Thread.Sleep(5000);
session.ShowSecurityScreen();
Thread.Sleep(1000);
session.SendKeys(Keys.Menu, Keys.S); // Sign out.
AwaitEvent <SessionEndedEvent>();
Assert.IsNull(this.ExceptionShown);
}
}
public void WhenPortNotListening_ThenErrorIsShownAndWindowIsClosed()
{
var settings = InstanceConnectionSettings.CreateNew(this.SampleLocator);
settings.RdpConnectionTimeout.IntValue = 5;
var rdpService = new RemoteDesktopSessionBroker(this.serviceProvider);
rdpService.Connect(
this.SampleLocator,
"localhost",
1,
settings);
AwaitEvent <SessionAbortedEvent>();
Assert.IsInstanceOf(typeof(RdpDisconnectedException), this.ExceptionShown);
Assert.AreEqual(516, ((RdpDisconnectedException)this.ExceptionShown).DisconnectReason);
}
public async Task WhenConnected_ThenGetActivePaneReturnsPane(
[WindowsInstance(MachineType = MachineTypeForRdp)] ResourceTask <InstanceLocator> testInstance,
[Credential(Role = PredefinedRole.IapTunnelUser)] ResourceTask <ICredential> credential)
{
var locator = await testInstance;
using (var tunnel = IapTunnel.ForRdp(
locator,
await credential))
using (var gceAdapter = new ComputeEngineAdapter(this.serviceProvider.GetService <IAuthorizationAdapter>()))
{
var credentials = await gceAdapter.ResetWindowsUserAsync(
locator,
CreateRandomUsername(),
TimeSpan.FromSeconds(60),
CancellationToken.None);
var settings = InstanceConnectionSettings.CreateNew(
locator.ProjectId,
locator.Name);
settings.RdpUsername.StringValue = credentials.UserName;
settings.RdpPassword.Value = credentials.SecurePassword;
// Connect
var broker = new RemoteDesktopSessionBroker(this.serviceProvider);
IRemoteDesktopSession session = null;
AssertRaisesEvent <SessionStartedEvent>(
() => session = (RemoteDesktopPane)broker.Connect(
locator,
"localhost",
(ushort)tunnel.LocalPort,
settings));
Assert.IsNull(this.ExceptionShown);
Assert.AreSame(session, RemoteDesktopPane.TryGetActivePane(this.mainForm));
Assert.AreSame(session, RemoteDesktopPane.TryGetExistingPane(this.mainForm, locator));
Assert.IsTrue(broker.IsConnected(locator));
Assert.IsTrue(broker.TryActivate(locator));
AssertRaisesEvent <SessionEndedEvent>(
() => session.Close());
}
}
public void WhenQueryStringContainsOutOfRangeValues_ThenSettingsUsesDefaults()
{
var url = IapRdpUrl.FromString("iap-rdp:///my-project/us-central1-a/my-instance?" +
"ConnectionBar=-1&DesktopSize=a&AuthenticationLevel=null&ColorDepth=&" +
"AudioMode=9999&RedirectClipboard=b&RedirectClipboard=c&" +
"CredentialGenerationBehavior=-11");
var settings = InstanceConnectionSettings.FromUrl(url);
Assert.IsNull(settings.RdpUsername.Value);
Assert.IsNull(settings.RdpPassword.Value);
Assert.IsNull(settings.RdpDomain.Value);
Assert.AreEqual(RdpConnectionBarState._Default, settings.RdpConnectionBar.Value);
Assert.AreEqual(RdpDesktopSize._Default, settings.RdpDesktopSize.Value);
Assert.AreEqual(RdpAuthenticationLevel._Default, settings.RdpAuthenticationLevel.Value);
Assert.AreEqual(RdpColorDepth._Default, settings.RdpColorDepth.Value);
Assert.AreEqual(RdpAudioMode._Default, settings.RdpAudioMode.Value);
Assert.AreEqual(RdpRedirectClipboard._Default, settings.RdpRedirectClipboard.Value);
Assert.AreEqual(RdpCredentialGenerationBehavior._Default, settings.RdpCredentialGenerationBehavior.Value);
}
public async Task WhenConnectingByNodeAndPersistentCredentialsDisallowed_ThenPasswordIsClear()
{
var settings = InstanceConnectionSettings.CreateNew("project", "instance-1");
settings.RdpUsername.Value = "existinguser";
settings.RdpPassword.Value = SecureStringExtensions.FromClearText("password");
var settingsService = this.serviceRegistry.AddMock <IConnectionSettingsService>();
settingsService.Setup(s => s.GetConnectionSettings(
It.IsAny <IProjectModelNode>()))
.Returns(
settings.ToPersistentSettingsCollection(s => Assert.Fail("should not be called")));
var vmNode = CreateInstanceNodeMock();
this.serviceRegistry.AddMock <IProjectModelService>()
.Setup(p => p.GetNodeAsync(
It.IsAny <ResourceLocator>(),
It.IsAny <CancellationToken>()))
.ReturnsAsync(vmNode.Object);
var remoteDesktopService = new Mock <IRemoteDesktopSessionBroker>();
remoteDesktopService.Setup(s => s.Connect(
It.IsAny <InstanceLocator>(),
"localhost",
It.IsAny <ushort>(),
It.IsAny <InstanceConnectionSettings>())).Returns <IRemoteDesktopSession>(null);
this.serviceRegistry.AddSingleton <IRemoteDesktopSessionBroker>(remoteDesktopService.Object);
var service = new RdpConnectionService(this.serviceRegistry);
await service.ActivateOrConnectInstanceAsync(vmNode.Object, false);
remoteDesktopService.Verify(s => s.Connect(
It.IsAny <InstanceLocator>(),
"localhost",
It.IsAny <ushort>(),
It.Is <InstanceConnectionSettings>(i =>
i.RdpUsername.StringValue == "existinguser" &&
i.RdpPassword.ClearTextValue == "")), Times.Once);
}
public async Task WhenNoCredentialsFoundAndPermissionGrantedAndBehaviorSetToAllowIfNoCredentialsFound_ThenGenerateOptionIsShown()
{
var taskDialog = new Mock <ITaskDialog>();
taskDialog.Setup(t => t.ShowOptionsTaskDialog(
It.IsAny <IWin32Window>(),
It.IsAny <IntPtr>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <IList <string> >(),
It.IsAny <string>(),
out It.Ref <bool> .IsAny)).Returns(0);
var credentialPrompt = CreateCredentialsPrompt(true, false, taskDialog);
var settings = InstanceConnectionSettings.CreateNew(SampleInstance);
settings.RdpCredentialGenerationBehavior.EnumValue = RdpCredentialGenerationBehavior.AllowIfNoCredentialsFound;
await credentialPrompt.ShowCredentialsPromptAsync(
null,
SampleInstance,
settings,
true);
Assert.AreEqual("bob", settings.RdpUsername.Value);
Assert.AreEqual("secret", settings.RdpPassword.ClearTextValue);
Assert.IsNull(settings.RdpDomain.Value);
taskDialog.Verify(t => t.ShowOptionsTaskDialog(
It.IsAny <IWin32Window>(),
It.IsAny <IntPtr>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.Is <IList <string> >(options => options.Count == 3),
It.IsAny <string>(),
out It.Ref <bool> .IsAny), Times.Once);
}
public async Task WhenNoCredentialsFoundAndBehaviorSetToDisallowAndJumpToSettingsNotAllowed_ThenDialogIsSkipped()
{
var taskDialog = new Mock <ITaskDialog>();
taskDialog.Setup(t => t.ShowOptionsTaskDialog(
It.IsAny <IWin32Window>(),
It.IsAny <IntPtr>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <IList <string> >(),
It.IsAny <string>(),
out It.Ref <bool> .IsAny)).Returns(1);
var credentialPrompt = CreateCredentialsPrompt(true, false, taskDialog);
var settings = InstanceConnectionSettings.CreateNew(SampleInstance);
settings.RdpCredentialGenerationBehavior.EnumValue = RdpCredentialGenerationBehavior.Disallow;
await credentialPrompt.ShowCredentialsPromptAsync(
null,
SampleInstance,
settings,
false);
Assert.IsNull(settings.RdpUsername.Value);
Assert.IsNull(settings.RdpPassword.Value);
Assert.IsNull(settings.RdpDomain.Value);
taskDialog.Verify(t => t.ShowOptionsTaskDialog(
It.IsAny <IWin32Window>(),
It.IsAny <IntPtr>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <IList <string> >(),
It.IsAny <string>(),
out It.Ref <bool> .IsAny), Times.Never);
}
public void WhenBehaviorSetToForceAndPermissionsNotGranted_ThenJumpToSettingsOptionIsShown()
{
var taskDialog = new Mock <ITaskDialog>();
taskDialog.Setup(t => t.ShowOptionsTaskDialog(
It.IsAny <IWin32Window>(),
It.IsAny <IntPtr>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <IList <string> >(),
It.IsAny <string>(),
out It.Ref <bool> .IsAny)).Returns(0);
var credentialPrompt = CreateCredentialsPrompt(false, false, taskDialog);
var window = this.serviceRegistry.AddMock <IConnectionSettingsWindow>();
var settings = InstanceConnectionSettings.CreateNew(SampleInstance);
settings.RdpCredentialGenerationBehavior.EnumValue = RdpCredentialGenerationBehavior.Force;
AssertEx.ThrowsAggregateException <TaskCanceledException>(
() => credentialPrompt.ShowCredentialsPromptAsync(
null,
SampleInstance,
settings,
true).Wait());
window.Verify(w => w.ShowWindow(), Times.Once);
taskDialog.Verify(t => t.ShowOptionsTaskDialog(
It.IsAny <IWin32Window>(),
It.IsAny <IntPtr>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.Is <IList <string> >(options => options.Count == 2),
It.IsAny <string>(),
out It.Ref <bool> .IsAny), Times.Once);
}
