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 CredentialsDialog(CredentialRequest request)
: this()
{
messageLabel.Text = request.Message;
try
{
foreach (var frame in request.StackTrace.GetFrames())
{
stackTraceListView.Items.Add(new ListViewItem(new string[]
{
frame.GetMethod().ToString(),
frame.GetMethod().Module.Assembly.FullName,
frame.GetMethod().Module.FullyQualifiedName,
}));
}
}
catch (Exception ex)
{
stackTraceListView.Items.Add(new ListViewItem(new string[]
{
string.Format("Failed to read stack trace. {0}", ex.Message),
ex.TargetSite.Module.Assembly.FullName,
ex.TargetSite.Module.FullyQualifiedName,
}));
}
}
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 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 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 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);
}
/// <summary>
/// Get a credential for detailed display
/// </summary>
/// <param name="id"></param>
/// <param name="user"></param>
/// <param name="skippingCache">If true, do not use the cached version</param>
/// <returns></returns>
public static ThisEntity GetDetail(int id, bool skippingCache = false)
{
CredentialRequest cr = new CredentialRequest();
cr.IsDetailRequest();
return(GetDetail(id, cr, skippingCache));
}
public void HandleRegisterButton()
{
CredentialRequest credentialRequest = registerScreen.GetRegisterCredentials();
if (credentialRequest != null)
{
loginManager.LoginServerClient.Register(credentialRequest, HandleRegisterResponse);
}
}
public void HandleLoginButton()
{
CredentialRequest credentialRequest = loginScreen.GetLoginCredentials();
if (credentialRequest != null)
{
loginManager.LoginServerClient.Authenticate(credentialRequest, HandleAuthenticateResponse);
}
}
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 static WMA.CredentialDetail GetDetailForAPI(int id, bool skippingCache = false)
{
CredentialRequest cr = new CredentialRequest();
cr.IsDetailRequest();
cr.IncludingProcessProfiles = false;
var entity = EntityHelper.GetDetail(id, cr, skippingCache);
return(MapToAPI(entity));
}
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 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);
}
/// <summary>
/// CentCom call to log in and receive an authentication token.
/// </summary>
/// <param name="credentialRequest"></param>
/// <param name="resultCallback"></param>
public void Authenticate(CredentialRequest credentialRequest, Action <string, bool> resultCallback)
{
monoBehaviour.StartCoroutine(HandlePayloadRequest(
UnityWebRequest.kHttpVerbPOST,
connectionAddress + Post_Authenticate,
JsonUtility.ToJson(credentialRequest),
"Authenticate",
false,
resultCallback
));
}
public async Task <IActionResult> LoginAsync([FromBody] CredentialRequest credentials)
{
var command = new GenerateTokenCommand(_mapper.Map <CredentialsDto>(credentials));
var result = await _bus.Send(command);
if (!string.IsNullOrEmpty(result.ErrorMessage))
{
throw new AuthenticationException(result.ErrorMessage);
}
return(Ok(_mapper.Map <TokenResponse>(result)));
}
public CredentialRequest GetLoginCredentials()
{
if (IsInputValid())
{
CredentialRequest credentialRequest = new CredentialRequest();
credentialRequest.email = emailInput.text;
credentialRequest.password = passwordInput.text;
return(credentialRequest);
}
return(null);
}
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 bool RequestCredential(CredentialRequest request, out System.Net.NetworkCredential credential)
{
credential = null;
var dialog = new CredentialsDialog(request);
if (dialog.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
credential = dialog.GetCredential();
return(true);
}
return(false);
}
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 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 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 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 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 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 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());
}
}
