public async Task WhenNoEnrollmentProvided_ThenDeviceCertiticateAuthenticationIsOff(
[Credential(Role = PredefinedRole.ComputeViewer)] ResourceTask <ICredential> credential)
{
var adapter = new ComputeEngineAdapter(await credential);
Assert.IsFalse(adapter.IsDeviceCertiticateAuthenticationEnabled);
}
public async Task WhenGuestAttributesDisabledByPolicy_ThenOsPropertiesAreNull(
[WindowsInstance] ResourceTask <InstanceLocator> testInstance,
[Credential(Role = PredefinedRole.ComputeViewer)] ResourceTask <ICredential> credential)
{
var locator = await testInstance;
var gceAdapter = new ComputeEngineAdapter(await credential);
var inventoryService = new Mock <IInventoryService>();
inventoryService.Setup(s => s.GetInstanceInventoryAsync(
It.IsAny <InstanceLocator>(),
It.IsAny <CancellationToken>()))
.Throws(new GoogleApiException("mock", "mock")
{
Error = new Apis.Requests.RequestError()
{
Code = 412
}
});
var model = await InstancePropertiesInspectorModel.LoadAsync(
await testInstance,
gceAdapter,
inventoryService.Object,
CancellationToken.None);
Assert.AreEqual(locator.Name, model.InstanceName);
Assert.AreEqual("RUNNING", model.Status);
Assert.IsFalse(model.IsOsInventoryInformationPopulated);
Assert.IsNull(model.Architecture);
Assert.IsNull(model.KernelVersion);
Assert.IsNull(model.OperatingSystemFullName);
Assert.IsNull(model.OperatingSystemVersion);
}
public void Populate(
IEnumerable <Instance> allInstances,
Func <InstanceLocator, bool> isConnected)
{
this.Nodes.Clear();
// Narrow the list down to Windows instances - there is no point
// of adding Linux instanes to the list of servers.
var instances = allInstances.Where(i => ComputeEngineAdapter.IsWindowsInstance(i));
var zoneIds = instances.Select(i => InventoryNode.ShortIdFromUrl(i.Zone)).ToHashSet();
foreach (var zoneId in zoneIds)
{
var zoneNode = new ZoneNode(zoneId, this);
var instancesInZone = instances
.Where(i => InventoryNode.ShortIdFromUrl(i.Zone) == zoneId)
.OrderBy(i => i.Name);
foreach (var instance in instancesInZone)
{
var instanceNode = new VmInstanceNode(instance, zoneNode);
instanceNode.IsConnected = isConnected(
new InstanceLocator(this.ProjectId, zoneId, instance.Name));
zoneNode.Nodes.Add(instanceNode);
}
this.Nodes.Add(zoneNode);
zoneNode.Expand();
}
Expand();
}
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 WhenCredentialsValid_ThenConnectingSucceeds(
[Values(RdpConnectionBarState.AutoHide, RdpConnectionBarState.Off, RdpConnectionBarState.Pinned)]
RdpConnectionBarState connectionBarState,
[Values(RdpDesktopSize.ClientSize, RdpDesktopSize.ScreenSize)]
RdpDesktopSize desktopSize,
[Values(RdpAudioMode.DoNotPlay, RdpAudioMode.PlayLocally, RdpAudioMode.PlayOnServer)]
RdpAudioMode audioMode,
[Values(RdpRedirectClipboard.Disabled, RdpRedirectClipboard.Enabled)]
RdpRedirectClipboard redirectClipboard,
// Use a slightly larger machine type as all this RDP'ing consumes a fair
// amount of memory.
[WindowsInstance(MachineType = "n1-standard-2")] InstanceRequest testInstance)
{
await testInstance.AwaitReady();
using (var tunnel = RdpTunnel.Create(testInstance.InstanceReference))
using (var gceAdapter = new ComputeEngineAdapter(this.serviceProvider.GetService <IAuthorizationService>()))
{
var credentials = await gceAdapter.ResetWindowsUserAsync(
testInstance.InstanceReference,
"test",
CancellationToken.None);
var rdpService = new RemoteDesktopService(this.serviceProvider);
var session = rdpService.Connect(
testInstance.InstanceReference,
"localhost",
(ushort)tunnel.LocalPort,
new VmInstanceSettings()
{
Username = credentials.UserName,
Password = credentials.SecurePassword,
ConnectionBar = connectionBarState,
DesktopSize = desktopSize,
AudioMode = audioMode,
RedirectClipboard = redirectClipboard,
AuthenticationLevel = RdpAuthenticationLevel.NoServerAuthentication,
BitmapPersistence = RdpBitmapPersistence.Disabled
});
AwaitEvent <RemoteDesktopConnectionSuceededEvent>();
Assert.IsNull(this.ExceptionShown);
RemoteDesktopWindowClosedEvent expectedEvent = null;
this.serviceProvider.GetService <IEventService>()
.BindHandler <RemoteDesktopWindowClosedEvent>(e =>
{
expectedEvent = e;
});
session.Close();
Assert.IsNotNull(expectedEvent);
}
}
public async Task WhenInstanceCreated_ThenListInstanceEventsAsyncCanFeedHistorySetBuilder(
[LinuxInstance] InstanceRequest testInstance)
{
await testInstance.AwaitReady();
var instanceRef = await testInstance.GetInstanceAsync();
var instanceBuilder = new InstanceSetHistoryBuilder(
DateTime.UtcNow.AddDays(-7),
DateTime.UtcNow);
var computeAdapter = new ComputeEngineAdapter(Defaults.GetCredential());
instanceBuilder.AddExistingInstances(
await computeAdapter.ListInstancesAsync(Defaults.ProjectId, CancellationToken.None),
await computeAdapter.ListDisksAsync(Defaults.ProjectId, CancellationToken.None),
Defaults.ProjectId);
var adapter = new AuditLogAdapter(Defaults.GetCredential());
await adapter.ListInstanceEventsAsync(
new[] { Defaults.ProjectId },
null, // all zones.
null, // all instances.
instanceBuilder.StartDate,
instanceBuilder,
CancellationToken.None);
var set = instanceBuilder.Build();
var testInstanceHistory = set.Instances.FirstOrDefault(i => i.Reference == instanceRef);
Assert.IsNotNull(testInstanceHistory, "Instance found in history");
}
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(),
CancellationToken.None);
var rdpService = new RemoteDesktopService(this.serviceProvider);
return(rdpService.Connect(
vmInstanceReference,
"localhost",
(ushort)tunnel.LocalPort,
new VmInstanceConnectionSettings()
{
Username = credentials.UserName,
Password = credentials.SecurePassword,
AuthenticationLevel = RdpAuthenticationLevel.NoServerAuthentication,
BitmapPersistence = RdpBitmapPersistence.Disabled,
DesktopSize = RdpDesktopSize.ClientSize
}));
}
}
public async Task WhenLoadAsyncCompletes_ThenPropertiesArePopulated(
[WindowsInstance] ResourceTask <InstanceLocator> testInstance,
[Credential(Role = PredefinedRole.ComputeViewer)] ResourceTask <ICredential> credential)
{
var locator = await testInstance;
var gceAdapter = new ComputeEngineAdapter(await credential);
var model = await InstancePropertiesInspectorModel.LoadAsync(
await testInstance,
gceAdapter,
new InventoryService(gceAdapter),
CancellationToken.None);
Assert.AreEqual(locator.Name, model.InstanceName);
Assert.IsNull(model.Hostname);
Assert.AreEqual("RUNNING", model.Status);
Assert.IsNotNull(model.InternalIp);
Assert.IsNotNull(model.ExternalIp);
Assert.IsNotNull(model.Licenses);
Assert.AreEqual(model.IsOsInventoryInformationPopulated
? FeatureFlag.Enabled : FeatureFlag.Disabled, model.OsInventory);
Assert.AreEqual(FeatureFlag.Disabled, model.Diagnostics);
Assert.AreEqual(FeatureFlag.Enabled, model.GuestAttributes);
Assert.IsNull(model.InternalDnsMode);
Assert.IsFalse(model.IsSoleTenant);
Assert.AreEqual(WindowsInstanceAttribute.DefaultMachineType, model.MachineType);
Assert.IsNull(model.Tags);
}
public async Task WhenUserNotInRole_ThenGetProjectThrowsResourceAccessDeniedException(
[Credential(Role = PredefinedRole.IapTunnelUser)] ResourceTask <ICredential> credential)
{
var adapter = new ComputeEngineAdapter(await credential);
AssertEx.ThrowsAggregateException <ResourceAccessDeniedException>(
() => adapter.GetProjectAsync(
TestProject.ProjectId,
CancellationToken.None).Wait());
}
public async Task WhenProjectIdInvalid_ThenGetProjectThrowsGoogleApiException(
[Credential(Role = PredefinedRole.IapTunnelUser)] ResourceTask <ICredential> credential)
{
var adapter = new ComputeEngineAdapter(await credential);
AssertEx.ThrowsAggregateException <GoogleApiException>(
() => adapter.GetProjectAsync(
"invalid",
CancellationToken.None).Wait());
}
public async Task WhenUserNotInRole_ThenListInstancesAsyncByZoneThrowsResourceAccessDeniedException(
[Credential(Role = PredefinedRole.IapTunnelUser)] ResourceTask <ICredential> credential)
{
var adapter = new ComputeEngineAdapter(await credential);
AssertEx.ThrowsAggregateException <ResourceAccessDeniedException>(
() => adapter.ListInstancesAsync(
new ZoneLocator(TestProject.ProjectId, "us-central1-a"),
CancellationToken.None).Wait());
}
public async Task WhenUserNotInRole_ThenGetImageThrowsResourceAccessDeniedException(
[Credential(Role = PredefinedRole.IapTunnelUser)] CredentialRequest credential)
{
var adapter = new ComputeEngineAdapter(await credential.GetCredentialAsync());
AssertEx.ThrowsAggregateException <ResourceAccessDeniedException>(
() => adapter.GetImageAsync(
new ImageLocator(TestProject.ProjectId, "someimage"),
CancellationToken.None).Wait());
}
public async Task WhenInstanceLacksPublicIp_ThenPublicAddressReturnsNull(
[LinuxInstance(PublicIp = false)] ResourceTask <InstanceLocator> testInstance,
[Credential(Role = PredefinedRole.ComputeViewer)] ResourceTask <ICredential> credential)
{
var adapter = new ComputeEngineAdapter(await credential);
var instance = await adapter.GetInstanceAsync(
await testInstance,
CancellationToken.None);
Assert.IsNull(instance.PublicAddress());
}
public async Task WhenUserNotInRole_ThenIsGrantedPermissionToResetWindowsUserReturnsFalse(
[WindowsInstance] ResourceTask <InstanceLocator> testInstance,
[Credential(Role = PredefinedRole.ComputeViewer)] ResourceTask <ICredential> credential)
{
var locator = await testInstance;
var adapter = new ComputeEngineAdapter(await credential);
var result = await adapter.IsGrantedPermissionToResetWindowsUser(
locator);
Assert.IsFalse(result);
}
public async Task WhenUserInViewerRole_ThenGetProjectReturnsProject(
[Credential(Role = PredefinedRole.ComputeViewer)] ResourceTask <ICredential> credential)
{
var adapter = new ComputeEngineAdapter(await credential);
var project = await adapter.GetProjectAsync(
TestProject.ProjectId,
CancellationToken.None);
Assert.IsNotNull(project);
Assert.AreEqual(TestProject.ProjectId, project.Name);
}
public async Task WhenUserNotInRole_ThenGetInstanceAsyncThrowsResourceAccessDeniedException(
[LinuxInstance] ResourceTask <InstanceLocator> testInstance,
[Credential(Role = PredefinedRole.IapTunnelUser)] ResourceTask <ICredential> credential)
{
var locator = await testInstance;
var adapter = new ComputeEngineAdapter(await credential);
AssertEx.ThrowsAggregateException <ResourceAccessDeniedException>(
() => adapter.GetInstanceAsync(
locator,
CancellationToken.None).Wait());
}
public async Task WhenConnected_ThenTryActivateReturnsTrue(
[LinuxInstance] ResourceTask <InstanceLocator> testInstance,
[Credential(Role = PredefinedRole.ComputeInstanceAdminV1)] ResourceTask <ICredential> credential)
{
var locator = await testInstance;
using (var key = new RsaSshKey(new RSACng()))
using (var gceAdapter = new ComputeEngineAdapter(
this.serviceProvider.GetService <IAuthorizationAdapter>()))
using (var keyAdapter = new AuthorizedKeyService(
this.serviceProvider.GetService <IAuthorizationAdapter>(),
new ComputeEngineAdapter(await credential),
new ResourceManagerAdapter(await credential),
new Mock <IOsLoginService>().Object))
{
var authorizedKey = await keyAdapter.AuthorizeKeyAsync(
locator,
key,
TimeSpan.FromMinutes(10),
null,
AuthorizeKeyMethods.InstanceMetadata,
CancellationToken.None)
.ConfigureAwait(true);
var instance = await gceAdapter.GetInstanceAsync(
locator,
CancellationToken.None)
.ConfigureAwait(true);
// Connect
var broker = new SshTerminalSessionBroker(this.serviceProvider);
ISshTerminalSession session = null;
await AssertRaisesEventAsync <SessionStartedEvent>(
async() => session = await broker.ConnectAsync(
locator,
new IPEndPoint(instance.PublicAddress(), 22),
authorizedKey,
null,
TimeSpan.FromSeconds(10)));
Assert.IsNull(this.ExceptionShown);
Assert.AreSame(session, SshTerminalPane.TryGetActivePane(this.mainForm));
Assert.AreSame(session, SshTerminalPane.TryGetExistingPane(this.mainForm, locator));
Assert.IsTrue(broker.IsConnected(locator));
Assert.IsTrue(broker.TryActivate(locator));
AssertRaisesEvent <SessionEndedEvent>(
() => session.Close());
}
}
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 WhenUserLacksInstanceListPermission_ThenIsGrantedPermissionFailsOpenAndReturnsTrue(
[LinuxInstance] ResourceTask <InstanceLocator> testInstance,
[Credential(Role = PredefinedRole.IapTunnelUser)] ResourceTask <ICredential> credential)
{
var locator = await testInstance;
var adapter = new ComputeEngineAdapter(await credential);
var result = await adapter.IsGrantedPermission(
locator,
Permissions.ComputeInstancesSetMetadata);
Assert.IsTrue(result);
}
public async Task WhenUserInRole_ThenIsGrantedPermissionReturnsTrue(
[LinuxInstance] ResourceTask <InstanceLocator> testInstance,
[Credential(Role = PredefinedRole.ComputeViewer)] ResourceTask <ICredential> credential)
{
var locator = await testInstance;
var adapter = new ComputeEngineAdapter(await credential);
var result = await adapter.IsGrantedPermission(
locator,
Permissions.ComputeInstancesGet);
Assert.IsTrue(result);
}
public async Task WhenInstanceHasNoServiceAccountAndUserInInstanceAdminRole_ThenResetWindowsUserAsyncSucceeds(
[WindowsInstance(ServiceAccount = InstanceServiceAccount.None)] ResourceTask <InstanceLocator> testInstance,
[Credential(Role = PredefinedRole.ComputeInstanceAdminV1)] ResourceTask <ICredential> credential)
{
var adapter = new ComputeEngineAdapter(await credential);
var username = "******" + Guid.NewGuid().ToString().Substring(20);
var result = await adapter.ResetWindowsUserAsync(
await testInstance,
username,
CancellationToken.None);
Assert.IsNotNull(result.Password);
}
public async Task WhenInstanceHasServiceAccountAndUserInInstanceAdminRole_ThenResetWindowsUserAsyncThrowsPasswordResetException(
[WindowsInstance(ServiceAccount = InstanceServiceAccount.ComputeDefault)] ResourceTask <InstanceLocator> testInstance,
[Credential(Role = PredefinedRole.ComputeInstanceAdminV1)] ResourceTask <ICredential> credential)
{
var locator = await testInstance;
var adapter = new ComputeEngineAdapter(await credential);
var username = "******" + Guid.NewGuid().ToString();
AssertEx.ThrowsAggregateException <PasswordResetException>(
() => adapter.ResetWindowsUserAsync(
locator,
username,
CancellationToken.None).Wait());
}
public async Task WhenInstancePopulated_ThenGetInstanceLocatorSucceeds(
[LinuxInstance] ResourceTask <InstanceLocator> testInstance,
[Credential(Role = PredefinedRole.ComputeViewer)] ResourceTask <ICredential> credential)
{
var adapter = new ComputeEngineAdapter(await credential);
var instance = await adapter.GetInstanceAsync(await testInstance);
var zoneLocator = instance.GetZoneLocator();
var instanceLocator = instance.GetInstanceLocator();
Assert.AreEqual(TestProject.Zone, zoneLocator.Name);
Assert.AreEqual(TestProject.Zone, instanceLocator.Zone);
Assert.AreEqual(await testInstance, instanceLocator);
}
public async Task WhenUserNotInRole_ThenGetInstanceAsyncThrowsResourceAccessDeniedException(
[LinuxInstance] InstanceRequest testInstance,
[Credential(Role = PredefinedRole.IapTunnelUser)] CredentialRequest credential)
{
await testInstance.AwaitReady();
var instanceRef = await testInstance.GetInstanceAsync();
var adapter = new ComputeEngineAdapter(await credential.GetCredentialAsync());
AssertEx.ThrowsAggregateException <ResourceAccessDeniedException>(
() => adapter.GetInstanceAsync(
testInstance.Locator,
CancellationToken.None).Wait());
}
public async Task WhenInstanceHasPublicIp_ThenPublicAddressReturnsNonRfc1918Ip(
[LinuxInstance] ResourceTask <InstanceLocator> testInstance,
[Credential(Role = PredefinedRole.ComputeViewer)] ResourceTask <ICredential> credential)
{
var adapter = new ComputeEngineAdapter(await credential);
var instance = await adapter.GetInstanceAsync(
await testInstance,
CancellationToken.None);
Assert.IsNotNull(instance.PublicAddress());
CollectionAssert.DoesNotContain(
new byte[] { 172, 192, 10 },
instance.PublicAddress().GetAddressBytes()[0],
"Is not a RFC1918 address");
}
public async Task WhenImageNotFound_ThenAnnotationNotAdded()
{
var annotatedSet = CreateSet(
new ImageLocator("unknown", "beos"));
Assert.AreEqual(0, annotatedSet.LicenseAnnotations.Count());
var computeEngineAdapter = new ComputeEngineAdapter(Defaults.GetCredential());
await LicenseLoader.LoadLicenseAnnotationsAsync(
annotatedSet,
computeEngineAdapter,
CancellationToken.None);
Assert.AreEqual(0, annotatedSet.LicenseAnnotations.Count());
}
private static bool IsRunningOperatingSystem(
Instance instance,
OperatingSystems operatingSystems)
{
switch (operatingSystems)
{
case OperatingSystems.Windows:
return(ComputeEngineAdapter.IsWindowsInstance(instance));
case OperatingSystems.Linux:
return(!ComputeEngineAdapter.IsWindowsInstance(instance));
default:
return(true);
}
}
public async Task WhenUserInViewerRole_ThenListInstancesAsyncReturnsInstances(
[LinuxInstance] ResourceTask <InstanceLocator> testInstance,
[Credential(Role = PredefinedRole.ComputeViewer)] ResourceTask <ICredential> credential)
{
// Make sure there is at least one instance.
await testInstance;
var instanceRef = await testInstance;
var adapter = new ComputeEngineAdapter(await credential);
var instances = await adapter.ListInstancesAsync(
TestProject.ProjectId,
CancellationToken.None);
Assert.Greater(instances.Count(), 1);
Assert.IsNotNull(instances.FirstOrDefault(i => i.Name == instanceRef.Name));
}
public async Task WhenImageNotFound_ThenAnnotationNotAdded(
[Credential(Role = PredefinedRole.ComputeViewer)] ResourceTask <ICredential> credential)
{
var annotatedSet = CreateSet(
new ImageLocator("unknown", "beos"));
Assert.AreEqual(0, annotatedSet.LicenseAnnotations.Count());
var computeEngineAdapter = new ComputeEngineAdapter(
await credential);
await LicenseLoader.LoadLicenseAnnotationsAsync(
annotatedSet,
computeEngineAdapter,
CancellationToken.None);
Assert.AreEqual(0, annotatedSet.LicenseAnnotations.Count());
}
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);
}
}
