public void WhenInstanceNamesDiffer_ThenOverlayByThrowsArgumentException()
{
var baseSettings = new VmInstanceConnectionSettings(
"instance-1",
null,
null,
null,
RdpConnectionBarState._Default,
RdpDesktopSize._Default,
RdpAuthenticationLevel._Default,
RdpColorDepth._Default,
RdpAudioMode._Default,
RdpRedirectClipboard._Default,
RdpCredentialGenerationBehavior._Default);
var overlay = new VmInstanceConnectionSettings(
"instance-2",
null,
null,
null,
RdpConnectionBarState._Default,
RdpDesktopSize._Default,
RdpAuthenticationLevel._Default,
RdpColorDepth._Default,
RdpAudioMode._Default,
RdpRedirectClipboard._Default,
RdpCredentialGenerationBehavior._Default);
Assert.Throws <ArgumentException>(() => baseSettings.OverlayBy(overlay));
}
public async Task WhenBehaviorSetToForceAndPermissionsGranted_ThenDialogIsSkippedAndCredentialsAreGenerated()
{
var taskDialog = new Mock <ITaskDialog>();
var credentialPrompt = CreateCredentialsPrompt(true, true, taskDialog);
var settings = VmInstanceConnectionSettings.CreateNew(SampleInstance);
settings.CredentialGenerationBehavior.EnumValue = RdpCredentialGenerationBehavior.Force;
await credentialPrompt.ShowCredentialsPromptAsync(
null,
SampleInstance,
settings,
true);
Assert.AreEqual("bob", settings.Username.StringValue);
Assert.AreEqual("secret", settings.Password.ClearTextValue);
Assert.IsNull(settings.Domain.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 void WhenOverlayUsesNonDefaults_ThenOverlaySettingsPrevail()
{
var baseSettings = new VmInstanceConnectionSettings(
"instance-1",
null,
null,
null,
RdpConnectionBarState._Default,
RdpDesktopSize._Default,
RdpAuthenticationLevel._Default,
RdpColorDepth._Default,
RdpAudioMode._Default,
RdpRedirectClipboard._Default,
RdpCredentialGenerationBehavior._Default);
var overlay = new VmInstanceConnectionSettings(
"instance-1",
"user",
null,
"domain",
RdpConnectionBarState.Off,
RdpDesktopSize.ScreenSize,
RdpAuthenticationLevel.RequireServerAuthentication,
RdpColorDepth.DeepColor,
RdpAudioMode.PlayOnServer,
RdpRedirectClipboard.Disabled,
RdpCredentialGenerationBehavior.Force);
AssertEx.ArePropertiesEqual(overlay, baseSettings.OverlayBy(overlay));
}
private async Task <IRemoteDesktopSession> Connect(
RdpTunnel 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 = VmInstanceConnectionSettings.CreateNew(vmInstanceReference);
settings.Username.Value = credentials.UserName;
settings.Password.Value = credentials.SecurePassword;
settings.AuthenticationLevel.Value = RdpAuthenticationLevel.NoServerAuthentication;
settings.BitmapPersistence.Value = RdpBitmapPersistence.Disabled;
settings.DesktopSize.Value = RdpDesktopSize.ClientSize;
var rdpService = new RemoteDesktopConnectionBroker(this.serviceProvider);
return(rdpService.Connect(
vmInstanceReference,
"localhost",
(ushort)tunnel.LocalPort,
settings));
}
}
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 = VmInstanceConnectionSettings.CreateNew(SampleInstance);
var credentialsService = new CredentialsService(serviceRegistry);
await credentialsService.GenerateCredentialsAsync(
null,
SampleInstance,
settings,
true);
Assert.AreEqual("bobsemail", settings.Username.Value);
Assert.AreEqual("password", settings.Password.ClearTextValue);
credDialog.Verify(d => d.PromptForUsername(
It.IsAny <IWin32Window>(),
It.IsAny <string>()), Times.Never);
}
public async Task WhenCredentialsInvalid_ThenErrorIsShownAndWindowIsClosed(
[WindowsInstance] ResourceTask <InstanceLocator> testInstance,
[Credential(Role = PredefinedRole.IapTunnelUser)] ResourceTask <ICredential> credential)
{
var locator = await testInstance;
using (var tunnel = RdpTunnel.Create(
locator,
await credential))
{
var settings = VmInstanceConnectionSettings.CreateNew(
locator.ProjectId,
locator.Name);
settings.Username.StringValue = "wrong";
settings.Password.Value = SecureStringExtensions.FromClearText("wrong");
settings.AuthenticationLevel.EnumValue = RdpAuthenticationLevel.NoServerAuthentication;
settings.UserAuthenticationBehavior.EnumValue = RdpUserAuthenticationBehavior.AbortOnFailure;
settings.DesktopSize.EnumValue = RdpDesktopSize.ClientSize;
var rdpService = new RemoteDesktopConnectionBroker(this.serviceProvider);
var session = rdpService.Connect(
locator,
"localhost",
(ushort)tunnel.LocalPort,
settings);
AwaitEvent <ConnectionFailedEvent>();
Assert.IsNotNull(this.ExceptionShown);
Assert.IsInstanceOf(typeof(RdpDisconnectedException), this.ExceptionShown);
Assert.AreEqual(2055, ((RdpDisconnectedException)this.ExceptionShown).DisconnectReason);
}
}
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 = VmInstanceConnectionSettings.CreateNew(SampleInstance);
settings.Username.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 = VmInstanceConnectionSettings.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 void WhenParseStringCreatedByToString_ResultIsSame()
{
var settings = VmInstanceConnectionSettings.CreateNew("project-1", "instance-1");
settings.Username.Value = "user";
settings.Domain.Value = "domain";
settings.ConnectionBar.Value = RdpConnectionBarState.Off;
settings.DesktopSize.Value = RdpDesktopSize.ScreenSize;
settings.AuthenticationLevel.Value = RdpAuthenticationLevel.RequireServerAuthentication;
settings.ColorDepth.Value = RdpColorDepth.TrueColor;
settings.AudioMode.Value = RdpAudioMode.PlayOnServer;
settings.RedirectClipboard.Value = RdpRedirectClipboard.Disabled;
settings.CredentialGenerationBehavior.Value = RdpCredentialGenerationBehavior.Disallow;
var url = new IapRdpUrl(
new InstanceLocator("project-1", "us-central1-a", "instance-1"),
settings.ToUrlQuery());
var copy = VmInstanceConnectionSettings.FromUrl(url);
Assert.AreEqual("user", copy.Username.Value);
Assert.AreEqual("domain", copy.Domain.Value);
Assert.AreEqual(RdpConnectionBarState.Off, copy.ConnectionBar.Value);
Assert.AreEqual(RdpDesktopSize.ScreenSize, copy.DesktopSize.Value);
Assert.AreEqual(RdpAuthenticationLevel.RequireServerAuthentication, copy.AuthenticationLevel.Value);
Assert.AreEqual(RdpColorDepth.TrueColor, copy.ColorDepth.Value);
Assert.AreEqual(RdpAudioMode.PlayOnServer, copy.AudioMode.Value);
Assert.AreEqual(RdpRedirectClipboard.Disabled, copy.RedirectClipboard.Value);
Assert.AreEqual(RdpCredentialGenerationBehavior.Disallow, copy.CredentialGenerationBehavior.Value);
}
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 = VmInstanceConnectionSettings.FromUrl(url);
Assert.AreEqual("John Doe", settings.Username.Value);
Assert.IsNull(settings.Password.Value);
Assert.AreEqual(" mydomain", settings.Domain.Value);
}
public async Task WhenConnectingByUrlWithUsernameAndCredentialsExist_ThenConnectionIsMadeWithUsernameFromUrl()
{
var settings = new VmInstanceConnectionSettings()
{
Username = "******",
Password = SecureStringExtensions.FromClearText("password")
};
var settingsService = this.serviceRegistry.AddMock <IConnectionSettingsService>();
settingsService.Setup(s => s.GetConnectionSettingsEditor(
It.IsAny <IProjectExplorerNode>()))
.Returns(new ConnectionSettingsEditor(
settings,
_ => { },
null));
var vmNode = new Mock <IProjectExplorerVmInstanceNode>();
vmNode.SetupGet(n => n.Reference)
.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 <ConnectionSettingsEditor>(),
It.IsAny <bool>()));
this.serviceRegistry.AddMock <IProjectExplorer>()
.Setup(p => p.TryFindNode(
It.IsAny <InstanceLocator>()))
.Returns(vmNode.Object);
var remoteDesktopService = new Mock <IRemoteDesktopConnectionBroker>();
remoteDesktopService.Setup(s => s.Connect(
It.IsAny <InstanceLocator>(),
"localhost",
It.IsAny <ushort>(),
It.IsAny <VmInstanceConnectionSettings>())).Returns <IRemoteDesktopSession>(null);
this.serviceRegistry.AddSingleton <IRemoteDesktopConnectionBroker>(remoteDesktopService.Object);
var service = new IapRdpConnectionService(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 <VmInstanceConnectionSettings>(i => i.Username == "john doe")), Times.Once);
settingsService.Verify(s => s.GetConnectionSettingsEditor(
It.IsAny <IProjectExplorerNode>()), Times.Once);
}
public async Task WhenConnected_ThenActiveSessionIsSetAndTryActivateReturnsTrue(
[WindowsInstance(MachineType = MachineTypeForRdp)] ResourceTask <InstanceLocator> testInstance,
[Credential(Role = PredefinedRole.IapTunnelUser)] ResourceTask <ICredential> credential)
{
var locator = await testInstance;
using (var tunnel = RdpTunnel.Create(
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 = VmInstanceConnectionSettings.CreateNew(
locator.ProjectId,
locator.Name);
settings.Username.StringValue = credentials.UserName;
settings.Password.Value = credentials.SecurePassword;
var broker = new RemoteDesktopConnectionBroker(this.serviceProvider);
var session = broker.Connect(
locator,
"localhost",
(ushort)tunnel.LocalPort,
settings);
AwaitEvent <ConnectionSuceededEvent>();
Assert.IsNull(this.ExceptionShown);
Assert.IsTrue(broker.IsConnected(locator));
Assert.AreSame(session, broker.ActiveSession);
Assert.IsTrue(broker.TryActivate(locator));
Assert.IsFalse(broker.TryActivate(SampleLocator));
Assert.IsFalse(broker.IsConnected(SampleLocator));
ConnectionClosedEvent expectedEvent = null;
this.serviceProvider.GetService <IEventService>()
.BindHandler <ConnectionClosedEvent>(e =>
{
expectedEvent = e;
});
session.Close();
Assert.IsNotNull(expectedEvent);
}
}
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 = VmInstanceConnectionSettings.CreateNew(SampleInstance);
settings.CredentialGenerationBehavior.EnumValue = RdpCredentialGenerationBehavior.AllowIfNoCredentialsFound;
settings.Username.StringValue = "alice";
settings.Password.ClearTextValue = "alicespassword";
await credentialPrompt.ShowCredentialsPromptAsync(
null,
SampleInstance,
settings,
true);
Assert.AreEqual("alice", settings.Username.Value);
Assert.AreEqual("alicespassword", settings.Password.ClearTextValue);
Assert.IsNull(settings.Domain.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 WhenQueryStringContainsNonsense_ThenSettingsUsesDefaults()
{
var url = IapRdpUrl.FromString("iap-rdp:///my-project/us-central1-a/my-instance?a=b&user=wrongcase&_");
var settings = VmInstanceConnectionSettings.FromUrl(url);
Assert.IsNull(settings.Username.Value);
Assert.IsNull(settings.Password.Value);
Assert.IsNull(settings.Domain.Value);
Assert.AreEqual(RdpConnectionBarState._Default, settings.ConnectionBar.Value);
Assert.AreEqual(RdpDesktopSize._Default, settings.DesktopSize.Value);
Assert.AreEqual(RdpAuthenticationLevel._Default, settings.AuthenticationLevel.Value);
Assert.AreEqual(RdpColorDepth._Default, settings.ColorDepth.Value);
Assert.AreEqual(RdpAudioMode._Default, settings.AudioMode.Value);
Assert.AreEqual(RdpRedirectClipboard._Default, settings.RedirectClipboard.Value);
Assert.AreEqual(RdpCredentialGenerationBehavior._Default, settings.CredentialGenerationBehavior.Value);
}
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 = VmInstanceConnectionSettings.FromUrl(url);
Assert.AreEqual(RdpConnectionBarState.Pinned, settings.ConnectionBar.Value);
Assert.AreEqual(RdpDesktopSize.ScreenSize, settings.DesktopSize.Value);
Assert.AreEqual(RdpAuthenticationLevel.AttemptServerAuthentication, settings.AuthenticationLevel.Value);
Assert.AreEqual(RdpColorDepth.DeepColor, settings.ColorDepth.Value);
Assert.AreEqual(RdpAudioMode.DoNotPlay, settings.AudioMode.Value);
Assert.AreEqual(RdpRedirectClipboard.Disabled, settings.RedirectClipboard.Value);
Assert.AreEqual(RdpCredentialGenerationBehavior.Allow, settings.CredentialGenerationBehavior.Value);
Assert.AreEqual(13389, settings.RdpPort.Value);
}
public void WhenVmInstanceSettingsArePopulated_ThenToUrlQueryExcludesPassword()
{
var settings = VmInstanceConnectionSettings.CreateNew("pro-1", "instance-1");
settings.Username.Value = "bob";
settings.Password.ClearTextValue = "secret";
settings.RedirectClipboard.EnumValue = RdpRedirectClipboard.Disabled;
settings.ConnectionTimeout.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 IRemoteDesktopSession Connect(
InstanceLocator vmInstance,
string server,
ushort port,
VmInstanceConnectionSettings settings)
{
var rdpPane = new RemoteDesktopPane(
this.serviceProvider,
vmInstance);
rdpPane.Show(this.dockPanel, DockState.Document);
rdpPane.Connect(server, port, settings);
return(rdpPane);
}
public void WhenServerInvalid_ThenErrorIsShownAndWindowIsClosed()
{
var settings = VmInstanceConnectionSettings.CreateNew(this.SampleLocator);
var rdpService = new RemoteDesktopConnectionBroker(this.serviceProvider);
rdpService.Connect(
this.SampleLocator,
"invalid.corp",
3389,
settings);
AwaitEvent <ConnectionFailedEvent>();
Assert.IsInstanceOf(typeof(RdpDisconnectedException), this.ExceptionShown);
Assert.AreEqual(260, ((RdpDisconnectedException)this.ExceptionShown).DisconnectReason);
}
internal VmInstanceNode(
Instance instance,
VmInstanceConnectionSettings settings,
Action <VmInstanceConnectionSettings> saveSettings,
ZoneNode parent)
: base(
settings.InstanceName,
DisconnectedIconIndex,
new ConnectionSettingsEditor(
settings,
changedSettings => saveSettings((VmInstanceConnectionSettings)changedSettings),
parent.SettingsEditor))
{
this.InstanceId = instance.Id.Value;
this.IsRunning = instance.Status == "RUNNING";
}
public void WhenSettingsContainsEscapableChars_ThenToStringEscapesThem()
{
var settings = VmInstanceConnectionSettings.CreateNew("project-1", "instance-1");
settings.Username.Value = "Tom & Jerry?";
settings.Domain.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 WhenWrongPort_ThenErrorIsShownAndWindowIsClosed()
{
var settings = VmInstanceConnectionSettings.CreateNew(this.SampleLocator);
var rdpService = new RemoteDesktopConnectionBroker(this.serviceProvider);
rdpService.Connect(
this.SampleLocator,
"localhost",
135, // That one will be listening, but it is RPC, not RDP.
settings);
AwaitEvent <ConnectionFailedEvent>();
Assert.IsInstanceOf(typeof(RdpDisconnectedException), this.ExceptionShown);
Assert.AreEqual(2308, ((RdpDisconnectedException)this.ExceptionShown).DisconnectReason);
}
public async Task WhenConnectingByNodeAndPersistentCredentialsDisallowed_ThenPasswordIsClear()
{
var settings = VmInstanceConnectionSettings.CreateNew("project", "instance-1");
settings.Username.Value = "existinguser";
settings.Password.Value = SecureStringExtensions.FromClearText("password");
var settingsService = this.serviceRegistry.AddMock <IConnectionSettingsService>();
settingsService.Setup(s => s.GetConnectionSettings(
It.IsAny <IProjectExplorerNode>()))
.Returns(settings);
var vmNode = new Mock <IProjectExplorerVmInstanceNode>();
vmNode.SetupGet(n => n.Reference)
.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 <VmInstanceConnectionSettings>())).Returns <IRemoteDesktopSession>(null);
this.serviceRegistry.AddSingleton <IRemoteDesktopSessionBroker>(remoteDesktopService.Object);
var service = new IapRdpConnectionService(this.serviceRegistry);
await service.ActivateOrConnectInstanceAsync(vmNode.Object, false);
remoteDesktopService.Verify(s => s.Connect(
It.IsAny <InstanceLocator>(),
"localhost",
It.IsAny <ushort>(),
It.Is <VmInstanceConnectionSettings>(i =>
i.Username.StringValue == "existinguser" &&
i.Password.ClearTextValue == "")), Times.Once);
settingsService.Verify(s => s.SaveConnectionSettings(
It.IsAny <ConnectionSettingsBase>()), Times.Never);
}
public IRemoteDesktopSession Connect(
VmInstanceReference vmInstance,
string server,
ushort port,
VmInstanceConnectionSettings settings)
{
var rdpPane = new RemoteDesktopPane(
this.eventService,
this.exceptionDialog,
vmInstance);
rdpPane.Show(this.dockPanel, DockState.Document);
rdpPane.Connect(server, port, settings);
return(rdpPane);
}
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 = RdpTunnel.Create(
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 = VmInstanceConnectionSettings.CreateNew(
locator.ProjectId,
locator.Name);
settings.Username.StringValue = credentials.UserName;
settings.Password.Value = credentials.SecurePassword;
settings.AuthenticationLevel.EnumValue = RdpAuthenticationLevel.NoServerAuthentication;
settings.BitmapPersistence.EnumValue = RdpBitmapPersistence.Disabled;
settings.DesktopSize.EnumValue = RdpDesktopSize.ClientSize;
var rdpService = new RemoteDesktopConnectionBroker(this.serviceProvider);
var session = (RemoteDesktopPane)rdpService.Connect(
locator,
"localhost",
(ushort)tunnel.LocalPort,
settings);
AwaitEvent <ConnectionSuceededEvent>();
Thread.Sleep(5000);
session.ShowSecurityScreen();
Thread.Sleep(1000);
session.SendKeys(Keys.Menu, Keys.S); // Sign out.
AwaitEvent <ConnectionClosedEvent>();
Assert.IsNull(this.ExceptionShown);
}
}
public void WhenPortNotListening_ThenErrorIsShownAndWindowIsClosed()
{
var settings = VmInstanceConnectionSettings.CreateNew(this.SampleLocator);
settings.ConnectionTimeout.IntValue = 5;
var rdpService = new RemoteDesktopConnectionBroker(this.serviceProvider);
rdpService.Connect(
this.SampleLocator,
"localhost",
1,
settings);
AwaitEvent <ConnectionFailedEvent>();
Assert.IsInstanceOf(typeof(RdpDisconnectedException), this.ExceptionShown);
Assert.AreEqual(516, ((RdpDisconnectedException)this.ExceptionShown).DisconnectReason);
}
private async Task ConnectInstanceAsync(
InstanceLocator instanceRef,
VmInstanceConnectionSettings settings)
{
var tunnel = await this.jobService.RunInBackground(
new JobDescription(
$"Opening Cloud IAP tunnel to {instanceRef.Name}...",
JobUserFeedbackType.BackgroundFeedback),
async token =>
{
try
{
var destination = new TunnelDestination(instanceRef, RemoteDesktopPort);
// Give IAP the same timeout for probing as RDP itself.
// Note that the timeouts are not additive.
var timeout = TimeSpan.FromSeconds(settings.ConnectionTimeout);
return(await this.tunnelBrokerService.ConnectAsync(destination, timeout)
.ConfigureAwait(false));
}
catch (NetworkStreamClosedException e)
{
throw new ApplicationException(
"Connecting to the instance failed. Make sure that you have " +
"configured your firewall rules to permit Cloud IAP access " +
$"to {instanceRef.Name}",
e);
}
catch (UnauthorizedException)
{
throw new ApplicationException(
"You are not authorized to connect to this VM instance.\n\n" +
$"Verify that the Cloud IAP API is enabled in the project {instanceRef.ProjectId} " +
"and that your user has the 'IAP-secured Tunnel User' role.");
}
}).ConfigureAwait(true);
this.remoteDesktopService.Connect(
instanceRef,
"localhost",
(ushort)tunnel.LocalPort,
settings);
}
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 = VmInstanceConnectionSettings.FromUrl(url);
Assert.IsNull(settings.Username.Value);
Assert.IsNull(settings.Password.Value);
Assert.IsNull(settings.Domain.Value);
Assert.AreEqual(RdpConnectionBarState._Default, settings.ConnectionBar.Value);
Assert.AreEqual(RdpDesktopSize._Default, settings.DesktopSize.Value);
Assert.AreEqual(RdpAuthenticationLevel._Default, settings.AuthenticationLevel.Value);
Assert.AreEqual(RdpColorDepth._Default, settings.ColorDepth.Value);
Assert.AreEqual(RdpAudioMode._Default, settings.AudioMode.Value);
Assert.AreEqual(RdpRedirectClipboard._Default, settings.RedirectClipboard.Value);
Assert.AreEqual(RdpCredentialGenerationBehavior._Default, settings.CredentialGenerationBehavior.Value);
}
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 = VmInstanceConnectionSettings.CreateNew(SampleInstance);
settings.CredentialGenerationBehavior.EnumValue = RdpCredentialGenerationBehavior.AllowIfNoCredentialsFound;
await credentialPrompt.ShowCredentialsPromptAsync(
null,
SampleInstance,
settings,
true);
Assert.AreEqual("bob", settings.Username.Value);
Assert.AreEqual("secret", settings.Password.ClearTextValue);
Assert.IsNull(settings.Domain.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 = VmInstanceConnectionSettings.CreateNew(SampleInstance);
settings.CredentialGenerationBehavior.EnumValue = RdpCredentialGenerationBehavior.Disallow;
await credentialPrompt.ShowCredentialsPromptAsync(
null,
SampleInstance,
settings,
false);
Assert.IsNull(settings.Username.Value);
Assert.IsNull(settings.Password.Value);
Assert.IsNull(settings.Domain.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 = VmInstanceConnectionSettings.CreateNew(SampleInstance);
settings.CredentialGenerationBehavior.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);
}
