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 TestResetPasswordForNonexistingUserSucceeds(
[WindowsInstance] InstanceRequest testInstance)
{
await testInstance.AwaitReady();
var username = "******" + Guid.NewGuid().ToString().Substring(20);
var credentials = await this.instancesResource.ResetWindowsUserAsync(
testInstance.InstanceReference,
username,
CancellationToken.None);
Assert.AreEqual(username, credentials.UserName);
Assert.IsEmpty(credentials.Domain);
Assert.IsNotEmpty(credentials.Password);
}
public async Task WhenInstanceExistsAndIsListening_ThenProbeSucceeds(
[WindowsInstance] InstanceRequest testInstance)
{
await testInstance.AwaitReady();
using (var stream = new SshRelayStream(
new IapTunnelingEndpoint(
Defaults.GetCredential(),
testInstance.InstanceReference,
3389,
IapTunnelingEndpoint.DefaultNetworkInterface)))
{
await stream.TestConnectionAsync(TimeSpan.FromSeconds(10));
}
}
public async Task WhenUserDoesntExist_ThenResetPasswordCreatesNewUser(
[WindowsInstance] InstanceRequest testInstance)
{
await testInstance.AwaitReady();
var username = "******" + Guid.NewGuid().ToString().Substring(20);
var credentials = await this.instancesResource.ResetWindowsUserAsync(
testInstance.Locator,
username,
CancellationToken.None);
Assert.AreEqual(username, credentials.UserName);
Assert.IsEmpty(credentials.Domain);
Assert.IsNotEmpty(credentials.Password);
}
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 WhenInstanceExistsButNotListening_ThenProbeFailsWithNetworkStreamClosedException(
[WindowsInstance] InstanceRequest testInstance)
{
await testInstance.AwaitReady();
using (var stream = new SshRelayStream(
new IapTunnelingEndpoint(
Defaults.GetCredential(),
testInstance.InstanceReference,
22,
IapTunnelingEndpoint.DefaultNetworkInterface)))
{
AssertEx.ThrowsAggregateException <NetworkStreamClosedException>(() =>
stream.TestConnectionAsync(TimeSpan.FromSeconds(5)).Wait());
}
}
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 ServerNotListeningCausesException(
[LinuxInstance] InstanceRequest vm)
{
await vm.AwaitReady();
var stream = ConnectToWebServer(vm.InstanceReference);
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();
});
}
private static async Task <IProjectExplorerVmInstanceNode> CreateNode(
InstanceRequest testInstance,
bool markAsRunning)
{
await testInstance.AwaitReady();
var instanceLocator = await testInstance.GetInstanceAsync();
var node = new Mock <IProjectExplorerVmInstanceNode>();
node.SetupGet(n => n.IsRunning).Returns(markAsRunning);
node.SetupGet(n => n.ProjectId).Returns(instanceLocator.ProjectId);
node.SetupGet(n => n.ZoneId).Returns(instanceLocator.Zone);
node.SetupGet(n => n.InstanceName).Returns(instanceLocator.Name);
return(node.Object);
}
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 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 ReadingWithTinyBufferCausesIndexOutOfRangeException(
[LinuxInstance(InitializeScript = InstallApache)] InstanceRequest vm)
{
await vm.AwaitReady();
var stream = ConnectToWebServer(vm.InstanceReference);
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 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)
{
await testInstance.AwaitReady();
using (var tunnel = RdpTunnel.Create(testInstance.InstanceReference))
{
var session = await Connect(tunnel, testInstance.InstanceReference);
AwaitEvent <RemoteDesktopConnectionFailedEvent>();
Assert.IsNotNull(this.ExceptionShown);
Assert.IsInstanceOf(typeof(RdpDisconnectedException), this.ExceptionShown);
Assert.AreEqual(264, ((RdpDisconnectedException)this.ExceptionShown).DisconnectReason);
}
}
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 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 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 SidAvailableAfterFirstRead([LinuxInstance(InitializeScript = InstallApache)] InstanceRequest vm)
{
await vm.AwaitReady();
var stream = (SshRelayStream)ConnectToWebServer(vm.InstanceReference);
byte[] request = new ASCIIEncoding().GetBytes(
$"GET / HTTP/1.1\r\nHost:www\r\nConnection: keep-alive\r\n\r\n");
Assert.IsNull(stream.Sid);
await stream.WriteAsync(request, 0, request.Length, CancellationToken.None);
Assert.IsNull(stream.Sid);
// Read a bit.
byte[] buffer = new byte[stream.MinReadSize];
await stream.ReadAsync(buffer, 0, buffer.Length, CancellationToken.None);
Assert.IsNotNull(stream.Sid);
}
public async Task WhenUsernameIsSuperLong_ThenPasswordResetExceptionIsThrown(
[WindowsInstance] InstanceRequest testInstance)
{
await testInstance.AwaitReady();
var username = "******" + Guid.NewGuid().ToString();
try
{
await this.instancesResource.ResetWindowsUserAsync(
testInstance.Locator,
username,
CancellationToken.None);
Assert.Fail();
}
catch (PasswordResetException e)
{
Assert.IsNotEmpty(e.Message);
}
}
public async Task TestResetPasswordForSuperLongUsernameFails(
[WindowsInstance] InstanceRequest testInstance)
{
await testInstance.AwaitReady();
var username = "******" + Guid.NewGuid().ToString();
try
{
await this.instancesResource.ResetWindowsUserAsync(
testInstance.InstanceReference,
username,
CancellationToken.None);
Assert.Fail();
}
catch (PasswordResetException e)
{
Assert.IsNotEmpty(e.Message);
}
}
public async Task WhenClientClosesConnectionAfterSingleHttpRequest_ThenRelayEnds(
[LinuxInstance(InitializeScript = InstallApache)] InstanceRequest vm)
{
await vm.AwaitReady();
var stream = ConnectToWebServer(vm.InstanceReference);
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, this.tokenSource.Token);
byte[] buffer = new byte[stream.MinReadSize];
// Read a bit.
var response = new HttpResponseAccumulator();
int bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length, this.tokenSource.Token);
response.Accumulate(buffer, 0, bytesRead);
await stream.CloseAsync(this.tokenSource.Token);
}
public async Task WhenUserExists_ThenResetPasswordUpdatesPassword(
[WindowsInstance] InstanceRequest testInstance)
{
await testInstance.AwaitReady();
var username = "******";
await this.instancesResource.ResetWindowsUserAsync(
testInstance.Locator,
username,
CancellationToken.None);
var credentials = await this.instancesResource.ResetWindowsUserAsync(
testInstance.Locator,
username,
CancellationToken.None);
Assert.AreEqual(username, credentials.UserName);
Assert.IsEmpty(credentials.Domain);
Assert.IsNotEmpty(credentials.Password);
}
public async Task WhenLinuxInstanceCreated_ThenReportContainsInstanceAndLicenseInfoFromItsDisk(
[LinuxInstance] InstanceRequest testInstance)
{
await testInstance.AwaitReady();
var instanceRef = await testInstance.GetInstanceAsync();
var startDate = DateTime.UtcNow.AddDays(-1);
var builder = new AuditLogReportBuilder(
new AuditLogAdapter(Defaults.GetCredential()),
new ComputeEngineAdapter(Defaults.GetCredential()),
new[] { Defaults.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 WhenUserNotInRole_ThenListInstanceEventsAsyncThrowsResourceAccessDeniedException(
[LinuxInstance] InstanceRequest testInstance,
[Credential(Role = PredefinedRole.ComputeViewer)] CredentialRequest credential)
{
await testInstance.AwaitReady();
var instanceRef = await testInstance.GetInstanceAsync();
var instanceBuilder = new InstanceSetHistoryBuilder(
DateTime.UtcNow.AddDays(-7),
DateTime.UtcNow);
var adapter = new AuditLogAdapter(await credential.GetCredentialAsync());
AssertEx.ThrowsAggregateException <ResourceAccessDeniedException>(
() => adapter.ListInstanceEventsAsync(
new[] { TestProject.ProjectId },
null, // all zones.
null, // all instances.
instanceBuilder.StartDate,
instanceBuilder,
CancellationToken.None).Wait());
}
public async Task WhenLaunchingInstance_ThenInstanceSetupFinishedTextAppearsInStream(
[WindowsInstance] InstanceRequest testInstance)
{
await testInstance.AwaitReady();
var stream = this.instancesResource.GetSerialPortOutputStream(
testInstance.Locator,
1);
var startTime = DateTime.Now;
while (DateTime.Now < startTime.AddMinutes(3))
{
var log = await stream.ReadAsync(CancellationToken.None);
if (log.Contains("Instance setup finished"))
{
return;
}
}
Assert.Fail("Timeout waiting for serial console output to appear");
}
public async Task TestResetPasswordForSuperLongUsernameFails(
[WindowsInstance] InstanceRequest testInstance)
{
await testInstance.AwaitReady();
var stream = this.instancesResource.GetSerialPortOutputStream(
testInstance.InstanceReference,
1);
var startTime = DateTime.Now;
while (DateTime.Now < startTime.AddMinutes(3))
{
var log = await stream.ReadAsync();
if (log.Contains("Instance setup finished"))
{
return;
}
}
Assert.Fail("Timeout waiting for serial console output to appear");
}
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 WhenServerClosesConnectionMultipleHttpRequests_ThenRelayEnds(
[LinuxInstance(InitializeScript = InstallApache)] InstanceRequest vm,
[Credential] CredentialRequest credential)
{
await vm.AwaitReady();
var stream = ConnectToWebServer(
vm.Locator,
await credential.GetCredentialAsync());
for (int i = 0; i < 3; i++)
{
byte[] request = new ASCIIEncoding().GetBytes(
$"GET /?_={i} HTTP/1.1\r\nHost:www\r\nConnection: keep-alive\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);
if (response.IsComplete)
{
TraceSources.Compute.TraceVerbose("Got full response");
break;
}
}
Assert.AreEqual(response.ExpectedBytes, response.TotalBytesRead);
}
await stream.CloseAsync(this.tokenSource.Token);
}
