public async Task WhenLinuxInstanceCreated_ThenReportContainsInstanceAndLicenseInfoFromItsDisk( [LinuxInstance] InstanceRequest testInstance, [Credential(Roles = new[] { PredefinedRole.ComputeViewer, PredefinedRole.LogsViewer })] CredentialRequest credential) { await testInstance.AwaitReady(); var instanceRef = await testInstance.GetInstanceAsync(); var startDate = DateTime.UtcNow.AddDays(-1); var builder = new AuditLogReportBuilder( new AuditLogAdapter(await credential.GetCredentialAsync()), new ComputeEngineAdapter(await credential.GetCredentialAsync()), new[] { TestProject.ProjectId }, startDate); var report = await builder.BuildAsync(CancellationToken.None); var instance = report.History.Instances.First(i => i.Reference == instanceRef); Assert.IsTrue(report.IsInstanceAnnotatedAs( instance, OperatingSystemTypes.Linux, LicenseTypes.Unknown)); }
public async Task WhenSetClientConnectionEncryptionLevelSetToLow_ThenConnectionSucceeds( [WindowsInstance(InitializeScript = @" & reg add ""HKLM\SOFTWARE\Policies\Microsoft\Windows NT\Terminal Services"" /t REG_DWORD /v MinEncryptionLevel /d 1 /f | Out-Default ")] InstanceRequest testInstance, [Credential] CredentialRequest credential) { await testInstance.AwaitReady(); using (var tunnel = RdpTunnel.Create( testInstance.Locator, await credential.GetCredentialAsync())) { var session = await Connect(tunnel, testInstance.Locator); AwaitEvent <RemoteDesktopConnectionSuceededEvent>(); Assert.IsNull(this.ExceptionShown); RemoteDesktopWindowClosedEvent expectedEvent = null; this.serviceProvider.GetService <IEventService>() .BindHandler <RemoteDesktopWindowClosedEvent>(e => { expectedEvent = e; }); Delay(TimeSpan.FromSeconds(5)); session.Close(); Assert.IsNotNull(expectedEvent); } }
public async Task WhenCredentialsInvalid_ThenErrorIsShownAndWindowIsClosed( [WindowsInstance] InstanceRequest testInstance, [Credential] CredentialRequest credential) { await testInstance.AwaitReady(); using (var tunnel = RdpTunnel.Create( testInstance.Locator, await credential.GetCredentialAsync())) { var rdpService = new RemoteDesktopService(this.serviceProvider); var session = rdpService.Connect( testInstance.Locator, "localhost", (ushort)tunnel.LocalPort, new VmInstanceConnectionSettings() { Username = "******", Password = SecureStringExtensions.FromClearText("wrong"), AuthenticationLevel = RdpAuthenticationLevel.NoServerAuthentication, UserAuthenticationBehavior = RdpUserAuthenticationBehavior.AbortOnFailure, DesktopSize = RdpDesktopSize.ClientSize }); AwaitEvent <RemoteDesktopConnectionFailedEvent>(); Assert.IsNotNull(this.ExceptionShown); Assert.IsInstanceOf(typeof(RdpDisconnectedException), this.ExceptionShown); Assert.AreEqual(2055, ((RdpDisconnectedException)this.ExceptionShown).DisconnectReason); } }
public async Task WhenUsingInvalidProjectId_ThenListEventsAsyncThrowsException( [Credential(Role = PredefinedRole.LogsViewer)] CredentialRequest credential) { var startDate = DateTime.UtcNow.AddDays(-30); var request = new ListLogEntriesRequest() { ResourceNames = new[] { "projects/invalid" }, Filter = $"resource.type=\"gce_instance\" " + $"AND protoPayload.methodName:{InsertInstanceEvent.Method} " + $"AND timestamp > {startDate:yyyy-MM-dd}", PageSize = 1000, OrderBy = "timestamp desc" }; var adapter = new AuditLogAdapter(await credential.GetCredentialAsync()); AssertEx.ThrowsAggregateException <GoogleApiException>( () => adapter.ListEventsAsync( request, _ => { }, new Apis.Util.ExponentialBackOff(), CancellationToken.None).Wait()); }
public async Task WhenServerClosesConnectionAfterSingleHttpRequest_ThenRelayEnds( [LinuxInstance(InitializeScript = InstallApache)] InstanceRequest vm, [Credential] CredentialRequest credential) { await vm.AwaitReady(); var stream = ConnectToWebServer( vm.Locator, await credential.GetCredentialAsync()); byte[] request = new ASCIIEncoding().GetBytes( "GET / HTTP/1.0\r\n\r\n"); await stream.WriteAsync(request, 0, request.Length, this.tokenSource.Token); byte[] buffer = new byte[stream.MinReadSize]; var response = new HttpResponseAccumulator(); int bytesRead; while ((bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length, this.tokenSource.Token)) > 0) { response.Accumulate(buffer, 0, bytesRead); } await stream.CloseAsync(this.tokenSource.Token); Assert.AreEqual(response.ExpectedBytes, response.TotalBytesRead); }
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 WhenUserNotInRole_ThenIsGrantedPermissionReturnsFalse( [Credential(Role = PredefinedRole.ComputeViewer)] CredentialRequest credential) { var adapter = new ResourceManagerAdapter(await credential.GetCredentialAsync()); var result = await adapter.IsGrantedPermission( TestProject.ProjectId, "compute.disks.create"); Assert.IsFalse(result); }
public async Task WhenSwitchingToCloudNode_ThenControlsAreDisabled( [Credential(Role = PredefinedRole.ComputeViewer)] CredentialRequest credential) { var viewModel = CreateViewModel(await credential.GetCredentialAsync()); var node = new Mock <IProjectExplorerCloudNode>(); await viewModel.SwitchToModelAsync(node.Object); Assert.IsFalse(viewModel.IsEnableTailingButtonEnabled); Assert.IsFalse(viewModel.IsOutputBoxEnabled); StringAssert.Contains(SerialOutputViewModel.DefaultWindowTitle, viewModel.WindowTitle); }
public async Task WhenApiReturns404_ThenExecuteAsStreamOrThrowAsyncThrowsException( [Credential(Role = PredefinedRole.ComputeViewer)] CredentialRequest credential ) { var computeService = new ComputeService(new BaseClientService.Initializer { HttpClientInitializer = await credential.GetCredentialAsync() }); AssertEx.ThrowsAggregateException <GoogleApiException>( () => computeService.Instances.Get("invalid", "invalid", "invalid") .ExecuteAsStreamOrThrowAsync(CancellationToken.None).Wait()); }
public async Task WhenSwitchingToStoppedInstanceNode_ThenControlsAreDisabled( [WindowsInstance] InstanceRequest testInstance, [Credential(Role = PredefinedRole.ComputeViewer)] CredentialRequest credential) { var viewModel = CreateViewModel(await credential.GetCredentialAsync()); var node = await CreateNode(testInstance, false); await viewModel.SwitchToModelAsync(node); Assert.IsFalse(viewModel.IsEnableTailingButtonEnabled); Assert.IsFalse(viewModel.IsOutputBoxEnabled); StringAssert.Contains(SerialOutputViewModel.DefaultWindowTitle, viewModel.WindowTitle); }
public async Task WhenBlocked_ThenEnableHasNoImpactOnTailing( [WindowsInstance] InstanceRequest testInstance, [Credential(Role = PredefinedRole.ComputeViewer)] CredentialRequest credential) { var viewModel = CreateViewModel(await credential.GetCredentialAsync()); var node = await CreateNode(testInstance, true); await viewModel.SwitchToModelAsync(node); viewModel.IsTailBlocked = true; viewModel.IsTailEnabled = true; Assert.IsNull(viewModel.TailCancellationTokenSource, "not tailing yet"); }
public async Task WhenInstanceCreated_ThenListInstanceEventsAsyncCanFeedHistorySetBuilder( [LinuxInstance] InstanceRequest testInstance, [Credential(Roles = new[] { PredefinedRole.ComputeViewer, PredefinedRole.LogsViewer })] CredentialRequest credential) { await testInstance.AwaitReady(); var instanceRef = await testInstance.GetInstanceAsync(); var instanceBuilder = new InstanceSetHistoryBuilder( DateTime.UtcNow.AddDays(-7), DateTime.UtcNow); var computeAdapter = new ComputeEngineAdapter(await credential.GetCredentialAsync()); instanceBuilder.AddExistingInstances( await computeAdapter.ListInstancesAsync(TestProject.ProjectId, CancellationToken.None), await computeAdapter.ListDisksAsync(TestProject.ProjectId, CancellationToken.None), TestProject.ProjectId); var adapter = new AuditLogAdapter(await credential.GetCredentialAsync()); await adapter.ListInstanceEventsAsync( new[] { TestProject.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"); }
public async Task WhenSendingMessagesToEchoServer_MessagesAreReceivedVerbatim( [LinuxInstance(InitializeScript = InstallEchoServer)] InstanceRequest vm, [Credential] CredentialRequest credential, [Values( 1, (int)DataMessage.MaxDataLength - 1, (int)DataMessage.MaxDataLength, (int)DataMessage.MaxDataLength + 1, (int)DataMessage.MaxDataLength * 10)] int length, [Values(1, 3)] int count) { var message = new byte[length]; FillArray(message); await vm.AwaitReady(); var stream = ConnectToEchoServer( vm.Locator, await credential.GetCredentialAsync()); for (int i = 0; i < count; i++) { await stream.WriteAsync(message, 0, message.Length, this.tokenSource.Token); var response = new byte[length]; int totalBytesRead = 0; while (true) { var bytesRead = await stream.ReadAsync( response, totalBytesRead, response.Length - totalBytesRead, this.tokenSource.Token); totalBytesRead += bytesRead; if (bytesRead == 0 || totalBytesRead >= length) { break; } } Assert.AreEqual(length, totalBytesRead); Assert.AreEqual(message, response); } await stream.CloseAsync(this.tokenSource.Token); }
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 WhenInstanceCreated_ThenListLogEntriesReturnsInsertEvent( [LinuxInstance] InstanceRequest testInstance, [Credential(Role = PredefinedRole.LogsViewer)] CredentialRequest credential) { await testInstance.AwaitReady(); var instanceRef = await testInstance.GetInstanceAsync(); var startDate = DateTime.UtcNow.AddDays(-30); var endDate = DateTime.UtcNow; var adapter = new AuditLogAdapter(await credential.GetCredentialAsync()); var request = new ListLogEntriesRequest() { ResourceNames = new[] { "projects/" + TestProject.ProjectId }, Filter = $"resource.type=\"gce_instance\" " + $"AND protoPayload.methodName:{InsertInstanceEvent.Method} " + $"AND timestamp > {startDate:yyyy-MM-dd}", PageSize = 1000, OrderBy = "timestamp desc" }; var events = new List <EventBase>(); var instanceBuilder = new InstanceSetHistoryBuilder(startDate, endDate); // Creating the VM might be quicker than the logs become available. for (int retry = 0; retry < 4 && !events.Any(); retry++) { await adapter.ListEventsAsync( request, events.Add, new Apis.Util.ExponentialBackOff(), CancellationToken.None); if (!events.Any()) { await Task.Delay(20 * 1000); } } var insertEvent = events.OfType <InsertInstanceEvent>() .First(e => e.InstanceReference == instanceRef); Assert.IsNotNull(insertEvent); }
public async Task WhenSwitchingToRunningInstanceNode_ThenOutputIsPopulated( [WindowsInstance] InstanceRequest testInstance, [Credential(Role = PredefinedRole.ComputeViewer)] CredentialRequest credential) { var viewModel = CreateViewModel(await credential.GetCredentialAsync()); var node = await CreateNode(testInstance, true); await viewModel.SwitchToModelAsync(node); Assert.IsTrue(viewModel.IsEnableTailingButtonEnabled); Assert.IsTrue(viewModel.IsOutputBoxEnabled); StringAssert.Contains("Instance setup finished", viewModel.Output); StringAssert.Contains(SerialOutputViewModel.DefaultWindowTitle, viewModel.WindowTitle); StringAssert.Contains(testInstance.Locator.Name, viewModel.WindowTitle); }
public async Task WhenUserNotInRole_ThenIsGrantedPermissionReturnsFalse( [LinuxInstance] InstanceRequest testInstance, [Credential(Role = PredefinedRole.ComputeViewer)] CredentialRequest credential) { await testInstance.AwaitReady(); var instanceRef = await testInstance.GetInstanceAsync(); var adapter = new ResourceManagerAdapter(await credential.GetCredentialAsync()); var result = await adapter.IsGrantedPermission( TestProject.ProjectId, "iam.serviceAccounts.actAs"); Assert.IsFalse(result); }
public async Task WhenImageNotFound_ThenAnnotationNotAdded( [Credential(Role = PredefinedRole.ComputeViewer)] CredentialRequest credential) { var annotatedSet = CreateSet( new ImageLocator("unknown", "beos")); Assert.AreEqual(0, annotatedSet.LicenseAnnotations.Count()); var computeEngineAdapter = new ComputeEngineAdapter( await credential.GetCredentialAsync()); await LicenseLoader.LoadLicenseAnnotationsAsync( annotatedSet, computeEngineAdapter, CancellationToken.None); Assert.AreEqual(0, annotatedSet.LicenseAnnotations.Count()); }
public async Task WhenServerNotListening_ThenReadReturnsZero( [LinuxInstance] InstanceRequest vm, [Credential] CredentialRequest credential) { await vm.AwaitReady(); var stream = ConnectToWebServer( vm.Locator, await credential.GetCredentialAsync()); byte[] request = new ASCIIEncoding().GetBytes( $"GET / HTTP/1.1\r\nHost:www\r\nConnection: keep-alive\r\n\r\n"); await stream.WriteAsync(request, 0, request.Length, CancellationToken.None); byte[] buffer = new byte[stream.MinReadSize]; Assert.AreEqual(0, stream.ReadAsync(buffer, 0, buffer.Length, CancellationToken.None).Result); }
public async Task WhenLoadAsyncCompletes_ThenOutputContainsExistingData( [WindowsInstance] InstanceRequest testInstance, [Credential(Role = PredefinedRole.ComputeViewer)] CredentialRequest credential) { await testInstance.AwaitReady(); var model = await SerialOutputModel.LoadAsync( "display-name", new ComputeEngineAdapter(await credential.GetCredentialAsync()), await testInstance.GetInstanceAsync(), SerialPortStream.ConsolePort, CancellationToken.None); Assert.IsFalse(string.IsNullOrWhiteSpace(model.Output)); Assert.AreEqual("display-name", model.DisplayName); StringAssert.Contains("Instance setup finished", model.Output); }
public async Task WhenInstanceExistsAndIsListening_ThenProbeSucceeds( [WindowsInstance] InstanceRequest testInstance, [Credential] CredentialRequest credential) { await testInstance.AwaitReady(); using (var stream = new SshRelayStream( new IapTunnelingEndpoint( await credential.GetCredentialAsync(), testInstance.Locator, 3389, IapTunnelingEndpoint.DefaultNetworkInterface, TestProject.UserAgent))) { await stream.TestConnectionAsync(TimeSpan.FromSeconds(10)); } }
public async Task WhenInstanceDoesntExist_ThenProbeFailsWithUnauthorizedException( [Credential] CredentialRequest credential) { using (var stream = new SshRelayStream( new IapTunnelingEndpoint( await credential.GetCredentialAsync(), new InstanceLocator( TestProject.ProjectId, TestProject.Zone, "invalid"), 80, IapTunnelingEndpoint.DefaultNetworkInterface, TestProject.UserAgent))) { AssertEx.ThrowsAggregateException <UnauthorizedException>(() => stream.TestConnectionAsync(TimeSpan.FromSeconds(10)).Wait()); } }
public async Task WhenUserInViewerRole_ThenListInstancesAsyncReturnsInstances( [LinuxInstance] InstanceRequest testInstance, [Credential(Role = PredefinedRole.ComputeViewer)] CredentialRequest credential) { // Make sure there is at least one instance. await testInstance.AwaitReady(); var instanceRef = await testInstance.GetInstanceAsync(); var adapter = new ComputeEngineAdapter(await credential.GetCredentialAsync()); 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 WhenInstanceExistsButNotListening_ThenProbeFailsWithNetworkStreamClosedException( [WindowsInstance] InstanceRequest testInstance, [Credential] CredentialRequest credential) { await testInstance.AwaitReady(); using (var stream = new SshRelayStream( new IapTunnelingEndpoint( await credential.GetCredentialAsync(), testInstance.Locator, 22, IapTunnelingEndpoint.DefaultNetworkInterface, TestProject.UserAgent))) { AssertEx.ThrowsAggregateException <NetworkStreamClosedException>(() => stream.TestConnectionAsync(TimeSpan.FromSeconds(5)).Wait()); } }
public async Task WhenLoadAsyncCompletes_ThenPropertiesArePopulated( [WindowsInstance] InstanceRequest testInstance, [Credential(Role = PredefinedRole.ComputeViewer)] CredentialRequest credential) { await testInstance.AwaitReady(); var model = await InstanceDetailsModel.LoadAsync( await testInstance.GetInstanceAsync(), new ComputeEngineAdapter(await credential.GetCredentialAsync()), CancellationToken.None); Assert.AreEqual(testInstance.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.IsFalse(model.IsSoleTenant); }
public async Task WhenBufferIsTiny_ThenReadingFailsWithIndexOutOfRangeException( [LinuxInstance(InitializeScript = InstallApache)] InstanceRequest vm, [Credential] CredentialRequest credential) { await vm.AwaitReady(); var stream = ConnectToWebServer(vm.Locator, await credential.GetCredentialAsync()); byte[] request = new ASCIIEncoding().GetBytes( "GET / HTTP/1.0\r\n\r\n"); await stream.WriteAsync(request, 0, request.Length, CancellationToken.None); byte[] buffer = new byte[64]; AssertEx.ThrowsAggregateException <IndexOutOfRangeException>(() => { stream.ReadAsync(buffer, 0, buffer.Length, CancellationToken.None).Wait(); }); }
public async Task WhenSigningOutPerSendKeys_ThenWindowIsClosed( [WindowsInstance(ImageFamily = WindowsInstanceAttribute.WindowsServer2019)] InstanceRequest testInstance, [Credential] CredentialRequest credential) { await testInstance.AwaitReady(); using (var tunnel = RdpTunnel.Create( testInstance.Locator, await credential.GetCredentialAsync())) using (var gceAdapter = new ComputeEngineAdapter(this.serviceProvider.GetService <IAuthorizationAdapter>())) { var credentials = await gceAdapter.ResetWindowsUserAsync( testInstance.Locator, CreateRandomUsername(), CancellationToken.None); var rdpService = new RemoteDesktopService(this.serviceProvider); var session = (RemoteDesktopPane)rdpService.Connect( testInstance.Locator, "localhost", (ushort)tunnel.LocalPort, new VmInstanceConnectionSettings() { Username = credentials.UserName, Password = credentials.SecurePassword, AuthenticationLevel = RdpAuthenticationLevel.NoServerAuthentication, BitmapPersistence = RdpBitmapPersistence.Disabled, DesktopSize = RdpDesktopSize.ClientSize }); AwaitEvent <RemoteDesktopConnectionSuceededEvent>(); Thread.Sleep(5000); session.ShowSecurityScreen(); Thread.Sleep(1000); session.SendKeys(Keys.Menu, Keys.S); // Sign out. AwaitEvent <RemoteDesktopWindowClosedEvent>(); Assert.IsNull(this.ExceptionShown); } }
public async Task WhenServerNotListening_ThenReadFails( [LinuxInstance] InstanceRequest vm, [Credential] CredentialRequest credential) { await vm.AwaitReady(); var stream = ConnectToWebServer( vm.Locator, await credential.GetCredentialAsync()); byte[] request = new ASCIIEncoding().GetBytes( $"GET / HTTP/1.1\r\nHost:www\r\nConnection: keep-alive\r\n\r\n"); await stream.WriteAsync(request, 0, request.Length, CancellationToken.None); AssertEx.ThrowsAggregateException <WebSocketStreamClosedByServerException>(() => { byte[] buffer = new byte[stream.MinReadSize]; stream.ReadAsync(buffer, 0, buffer.Length, CancellationToken.None).Wait(); }); }
public async Task WhenAllowUsersToConnectRemotelyByUsingRdsIsOff_ThenErrorIsShownAndWindowIsClosed( [WindowsInstance(InitializeScript = @" # Disable Policy & reg add ""HKLM\SOFTWARE\Policies\Microsoft\Windows NT\Terminal Services"" /t REG_DWORD /v fDenyTSConnections /d 1 /f | Out-Default ")] InstanceRequest testInstance, [Credential] CredentialRequest credential) { await testInstance.AwaitReady(); using (var tunnel = RdpTunnel.Create( testInstance.Locator, await credential.GetCredentialAsync())) { var session = await Connect(tunnel, testInstance.Locator); AwaitEvent <RemoteDesktopConnectionFailedEvent>(); Assert.IsNotNull(this.ExceptionShown); Assert.IsInstanceOf(typeof(RdpDisconnectedException), this.ExceptionShown); Assert.AreEqual(264, ((RdpDisconnectedException)this.ExceptionShown).DisconnectReason); } }
public async Task WhenImageNotFoundButFromWindowsProject_ThenAnnotationIsAdded( [Credential(Role = PredefinedRole.ComputeViewer)] CredentialRequest credential) { var annotatedSet = CreateSet( new ImageLocator("windows-cloud", "windows-95")); Assert.AreEqual(0, annotatedSet.LicenseAnnotations.Count()); var computeEngineAdapter = new ComputeEngineAdapter( await credential.GetCredentialAsync()); await LicenseLoader.LoadLicenseAnnotationsAsync( annotatedSet, computeEngineAdapter, CancellationToken.None); Assert.AreEqual(1, annotatedSet.LicenseAnnotations.Count()); var annotation = annotatedSet.LicenseAnnotations.Values.First(); Assert.AreEqual(OperatingSystemTypes.Windows, annotation.OperatingSystem); Assert.AreEqual(LicenseTypes.Spla, annotation.LicenseType); }