public async Task DisableHttpEgressTest()
{
await ScenarioRunner.SingleTarget(
_outputHelper,
_httpClientFactory,
DiagnosticPortConnectionMode.Connect,
TestAppScenarios.AsyncWait.Name,
appValidate : async(appRunner, appClient) =>
{
int processId = await appRunner.ProcessIdTask;
ProcessInfo processInfo = await appClient.GetProcessAsync(processId);
Assert.NotNull(processInfo);
// Dump Error Check
ValidationProblemDetailsException validationProblemDetailsExceptionDumps = await Assert.ThrowsAsync <ValidationProblemDetailsException>(
() => appClient.CaptureDumpAsync(processId, DumpType.Mini));
Assert.Equal(HttpStatusCode.BadRequest, validationProblemDetailsExceptionDumps.StatusCode);
Assert.Equal(StatusCodes.Status400BadRequest, validationProblemDetailsExceptionDumps.Details.Status);
Assert.Equal(DisabledHTTPEgressErrorMessage, validationProblemDetailsExceptionDumps.Message);
// Logs Error Check
ValidationProblemDetailsException validationProblemDetailsExceptionLogs = await Assert.ThrowsAsync <ValidationProblemDetailsException>(
() => appClient.CaptureLogsAsync(processId, CommonTestTimeouts.LogsDuration, LogLevel.None, LogFormat.NewlineDelimitedJson));
Assert.Equal(HttpStatusCode.BadRequest, validationProblemDetailsExceptionLogs.StatusCode);
Assert.Equal(StatusCodes.Status400BadRequest, validationProblemDetailsExceptionLogs.Details.Status);
Assert.Equal(DisabledHTTPEgressErrorMessage, validationProblemDetailsExceptionLogs.Message);
await appRunner.SendCommandAsync(TestAppScenarios.AsyncWait.Commands.Continue);
},
disableHttpEgress : true);
}
/// <summary>
/// Verifies that a process was found in the identifiers list and checks the /process?pid={processKey} route for the same process.
/// </summary>
private async Task VerifyProcessAsync(ApiClient client, IEnumerable <ProcessIdentifier> identifiers, int processId, string expectedEnvVarValue)
{
Assert.NotNull(identifiers);
ProcessIdentifier identifier = identifiers.FirstOrDefault(p => p.Pid == processId);
Assert.NotNull(identifier);
ProcessInfo info = await client.GetProcessWithRetryAsync(_outputHelper, pid : identifier.Pid);
Assert.NotNull(info);
Assert.Equal(identifier.Pid, info.Pid);
#if NET5_0_OR_GREATER
// Currently, the runtime instance identifier is only provided for .NET 5 and higher
info = await client.GetProcessWithRetryAsync(_outputHelper, uid : identifier.Uid);
Assert.NotNull(info);
Assert.Equal(identifier.Pid, info.Pid);
Assert.Equal(identifier.Uid, info.Uid);
Dictionary <string, string> env = await client.GetProcessEnvironmentAsync(processId);
Assert.NotNull(env);
Assert.NotEmpty(env);
Assert.True(env.TryGetValue(ExpectedEnvVarName, out string actualEnvVarValue));
Assert.Equal(expectedEnvVarValue, actualEnvVarValue);
#else
// .NET Core 3.1 and earlier do not support getting the environment block
ValidationProblemDetailsException validationProblemDetailsException = await Assert.ThrowsAsync <ValidationProblemDetailsException>(
() => client.GetProcessEnvironmentAsync(processId));
Assert.Equal(HttpStatusCode.BadRequest, validationProblemDetailsException.StatusCode);
Assert.Equal(StatusCodes.Status400BadRequest, validationProblemDetailsException.Details.Status);
#endif
}
public async Task ConcurrencyLimitTest()
{
await ScenarioRunner.SingleTarget(
_outputHelper,
_httpClientFactory,
DiagnosticPortConnectionMode.Connect,
TestAppScenarios.AsyncWait.Name,
appValidate : async(appRunner, apiClient) =>
{
int processId = await appRunner.ProcessIdTask;
OperationResponse response1 = await EgressTraceWithDelay(apiClient, processId);
OperationResponse response2 = await EgressTraceWithDelay(apiClient, processId);
OperationResponse response3 = await EgressTraceWithDelay(apiClient, processId);
ValidationProblemDetailsException ex = await Assert.ThrowsAsync <ValidationProblemDetailsException>(() => EgressTraceWithDelay(apiClient, processId));
Assert.Equal(HttpStatusCode.TooManyRequests, ex.StatusCode);
Assert.Equal((int)HttpStatusCode.TooManyRequests, ex.Details.Status.GetValueOrDefault());
await CancelEgressOperation(apiClient, response1);
await CancelEgressOperation(apiClient, response2);
OperationResponse response4 = await EgressTraceWithDelay(apiClient, processId, delay: false);
await CancelEgressOperation(apiClient, response3);
await CancelEgressOperation(apiClient, response4);
await appRunner.SendCommandAsync(TestAppScenarios.AsyncWait.Commands.Continue);
},
configureTool : (toolRunner) =>
{
toolRunner.WriteKeyPerValueConfiguration(new RootOptions().AddFileSystemEgress(FileProviderName, _tempDirectory.FullName));
});
}
public Task LogsDefaultLevelNoneNotSupportedViaBodyTest(DiagnosticPortConnectionMode mode, LogFormat logFormat)
{
return(ScenarioRunner.SingleTarget(
_outputHelper,
_httpClientFactory,
mode,
TestAppScenarios.Logger.Name,
appValidate: async(runner, client) =>
{
ValidationProblemDetailsException exception = await Assert.ThrowsAsync <ValidationProblemDetailsException>(
async() =>
{
using ResponseStreamHolder _ = await client.CaptureLogsAsync(
await runner.ProcessIdTask,
CommonTestTimeouts.LogsDuration,
new LogsConfiguration()
{
LogLevel = LogLevel.None
},
logFormat);
});
Assert.Equal(HttpStatusCode.BadRequest, exception.StatusCode);
Assert.Equal(StatusCodes.Status400BadRequest, exception.Details.Status);
// Allow test app to gracefully exit by continuing the scenario.
await runner.SendCommandAsync(TestAppScenarios.Logger.Commands.StartLogging);
}));
}
/// <summary>
/// Verifies that an invalid Process request throws the correct exception (ValidationProblemDetailsException) and has the correct Status and StatusCode.
/// </summary>
private async Task VerifyInvalidRequestException(ApiClient client, int?pid, Guid?uid, string name)
{
ValidationProblemDetailsException validationProblemDetailsException = await Assert.ThrowsAsync <ValidationProblemDetailsException>(
() => client.GetProcessAsync(pid: pid, uid: uid, name: name));
Assert.Equal(HttpStatusCode.BadRequest, validationProblemDetailsException.StatusCode);
Assert.Equal(StatusCodes.Status400BadRequest, validationProblemDetailsException.Details.Status);
}
public async Task EgressNotExistTest()
{
await ScenarioRunner.SingleTarget(
_outputHelper,
_httpClientFactory,
DiagnosticPortConnectionMode.Connect,
TestAppScenarios.AsyncWait.Name,
appValidate : async(appRunner, apiClient) =>
{
int processId = await appRunner.ProcessIdTask;
ValidationProblemDetailsException validationException = await Assert.ThrowsAsync <ValidationProblemDetailsException>(
() => apiClient.EgressTraceAsync(processId, durationSeconds: 5, FileProviderName));
Assert.Equal(HttpStatusCode.BadRequest, validationException.StatusCode);
await appRunner.SendCommandAsync(TestAppScenarios.AsyncWait.Commands.Continue);
});
}
public async Task SharedConcurrencyLimitTest()
{
await ScenarioRunner.SingleTarget(
_outputHelper,
_httpClientFactory,
DiagnosticPortConnectionMode.Connect,
TestAppScenarios.AsyncWait.Name,
appValidate : async(appRunner, apiClient) =>
{
int processId = await appRunner.ProcessIdTask;
OperationResponse response1 = await EgressTraceWithDelay(apiClient, processId);
OperationResponse response3 = await EgressTraceWithDelay(apiClient, processId);
using HttpResponseMessage traceDirect1 = await TraceWithDelay(apiClient, processId);
Assert.Equal(HttpStatusCode.OK, traceDirect1.StatusCode);
ValidationProblemDetailsException ex = await Assert.ThrowsAsync <ValidationProblemDetailsException>(
() => EgressTraceWithDelay(apiClient, processId, delay: false));
Assert.Equal(HttpStatusCode.TooManyRequests, ex.StatusCode);
using HttpResponseMessage traceDirect = await TraceWithDelay(apiClient, processId, delay: false);
Assert.Equal(HttpStatusCode.TooManyRequests, traceDirect.StatusCode);
//Validate that the failure from a direct call (handled by middleware)
//matches the failure produces by egress operations (handled by the Mvc ActionResult stack)
using HttpResponseMessage egressDirect = await EgressDirect(apiClient, processId);
Assert.Equal(HttpStatusCode.TooManyRequests, egressDirect.StatusCode);
Assert.Equal(await egressDirect.Content.ReadAsStringAsync(), await traceDirect.Content.ReadAsStringAsync());
await CancelEgressOperation(apiClient, response1);
OperationResponse response4 = await EgressTraceWithDelay(apiClient, processId, delay: false);
await CancelEgressOperation(apiClient, response3);
await CancelEgressOperation(apiClient, response4);
await appRunner.SendCommandAsync(TestAppScenarios.AsyncWait.Commands.Continue);
},
configureTool : (toolRunner) =>
{
toolRunner.WriteKeyPerValueConfiguration(new RootOptions().AddFileSystemEgress(FileProviderName, _tempDirectory.FullName));
});
}
