/// <summary>
/// Runner for ensuring PullRecordingHttpTrigger.Run() implementation runs correctly for concurrent executions.
/// </summary>
/// <param name="queue">The queue of tests to run.</param>
public void PullRecordingRunnerLocal(ConcurrentQueue <TestConfiguration> queue)
{
TestConfiguration nextTestConfiguration = null;
while (!queue.IsEmpty)
{
if (queue.TryDequeue(out nextTestConfiguration))
{
HttpRequest request = CreateHttpPostRequest(nextTestConfiguration.InputId, nextTestConfiguration.CallSid);
ExecutionContext context = new ExecutionContext()
{
FunctionAppDirectory = Directory.GetCurrentDirectory(),
};
IActionResult result = PullRecordingHttpTrigger.Run(request, _log, context).Result;
Assert.IsInstanceOfType(result, typeof(OkObjectResult));
OkObjectResult okResult = (OkObjectResult)result;
Assert.AreEqual(200, okResult.StatusCode);
Assert.IsInstanceOfType(okResult.Value, typeof(PullRecordingResponse));
PullRecordingResponse response = (PullRecordingResponse)okResult.Value;
Assert.AreEqual(nextTestConfiguration.CallSid, response.CallSid);
Assert.IsNotNull(response.RecordingUri);
// Assert.IsTrue(response.RecordingLength > 600000); // Recording size should be ~800KB
Assert.IsNotNull(response.FullRecordingUrl);
Assert.AreEqual((int)CommonStatusCode.Ok, response.StatusCode);
Assert.AreEqual(Enum.GetName(typeof(CommonStatusCode), CommonStatusCode.Ok), response.StatusDesc);
Assert.IsFalse(response.HasError);
Assert.AreEqual((int)CommonErrorCode.NoError, response.ErrorCode);
Assert.IsNull(response.ErrorDetails);
_log.LogInformation("Writing returned recording uri to test configuration...");
nextTestConfiguration.RecordingUri = response.RecordingUri;
}
TH.Thread.Sleep(2000);
}
_concurrentConfig.Save(GlobalTestConstants.ConcurrentTestConfigurationFilePath);
}
public void TranscribeCallHttpTriggerConcurrentRuns()
{
FunctionSettings functionSettings = FunctionSettings.Load(@".\functionSettings.json");
using (HttpClient httpClient = new HttpClient())
{
string accessToken = AzureADHelper.GetAccessTokenAsync(functionSettings.Authority, functionSettings.ApplicationId, functionSettings.ClientSecret, functionSettings.ResourceId).Result;
if (accessToken == null)
{
throw new Exception("Could not obtain access token!");
}
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
Task[] threads = new Task[_concurrentConfig.NumberOfThreads];
for (int i = 0; i < _concurrentConfig.NumberOfThreads; i++)
{
threads[i] = Task.Run(
new Action(
() => TranscribeCallRunnerAsync(httpClient, functionSettings, _concurrentConfig.TestConfigurationQueue).Wait()));
}
_log.LogInformation("Waiting on threads...");
Task.WaitAll(threads);
_log.LogInformation("All threads completed...");
}
_concurrentConfig.Save(GlobalTestConstants.ConcurrentTestConfigurationFilePath);
}
public void DeleteRecordingsImplementationConcurrentRuns()
{
Task[] threads = new Task[_concurrentConfig.NumberOfThreads];
for (int i = 0; i < _concurrentConfig.NumberOfThreads; i++)
{
threads[i] = Task.Run(
new Action(
() => DeleteRecordingsRunnerLocal(_concurrentConfig.TestConfigurationQueue)));
}
_log.LogInformation("Waiting on threads...");
Task.WaitAll(threads);
_log.LogInformation("All threads completed...");
_concurrentConfig.Save(GlobalTestConstants.ConcurrentTestConfigurationFilePath);
}
/// <summary>
/// Runner for ensuring InitiateCallHttpTrigger.Run() implementation runs correctly.
/// </summary>
/// <param name="queue">The queue of tests to run.</param>
public void InitiateCallRunnerLocal(ConcurrentQueue <TestConfiguration> queue)
{
TestConfiguration nextTestConfiguration = null;
while (!queue.IsEmpty)
{
if (queue.TryDequeue(out nextTestConfiguration))
{
HttpRequest request = CreateHttpPostRequest(nextTestConfiguration.InputId, null);
ExecutionContext context = new ExecutionContext()
{
FunctionAppDirectory = Directory.GetCurrentDirectory(),
};
IActionResult result = InitiateCallHttpTrigger.Run(request, _log, context).Result;
Assert.IsInstanceOfType(result, typeof(OkObjectResult));
OkObjectResult okResult = (OkObjectResult)result;
Assert.AreEqual(200, okResult.StatusCode);
Assert.IsInstanceOfType(okResult.Value, typeof(InitiateCallResponse));
InitiateCallResponse response = (InitiateCallResponse)okResult.Value;
Assert.AreEqual(nextTestConfiguration.InputId, response.InputId);
Assert.IsFalse(string.IsNullOrWhiteSpace(response.CallSid));
Assert.AreEqual((int)CommonStatusCode.Ok, response.StatusCode);
Assert.AreEqual(Enum.GetName(typeof(CommonStatusCode), CommonStatusCode.Ok), response.StatusDesc);
Assert.IsFalse(response.HasError);
Assert.AreEqual((int)CommonErrorCode.NoError, response.ErrorCode);
Assert.IsNull(response.ErrorDetails);
_log.LogInformation("Writing returned call sid to test configuration...");
nextTestConfiguration.CallSid = response.CallSid;
}
TH.Thread.Sleep(2000);
}
_concurrentConfig.Save(GlobalTestConstants.ConcurrentTestConfigurationFilePath);
}
/// <summary>
/// Runner for ensuring ExtractInfoHttpTrigger.Run() implementation runs correctly for concurrent executions.
/// </summary>
/// <param name="queue">The queue of tests to run.</param>
public void ExtractInfoRunnerLocal(ConcurrentQueue <TestConfiguration> queue)
{
TestConfiguration nextTestConfiguration = null;
while (!queue.IsEmpty)
{
if (queue.TryDequeue(out nextTestConfiguration))
{
HttpRequest request = CreateHttpPostRequest(nextTestConfiguration.CallSid, nextTestConfiguration.Transcript);
ExecutionContext context = new ExecutionContext()
{
FunctionAppDirectory = Directory.GetCurrentDirectory(),
};
IActionResult result = ExtractInfoHttpTrigger.Run(request, _log, context).Result;
Assert.IsInstanceOfType(result, typeof(OkObjectResult));
OkObjectResult okResult = (OkObjectResult)result;
Assert.AreEqual(200, okResult.StatusCode);
Assert.IsInstanceOfType(okResult.Value, typeof(ExtractInfoResponse));
ExtractInfoResponse response = (ExtractInfoResponse)okResult.Value;
Assert.AreEqual(nextTestConfiguration.CallSid, response.CallSid);
Assert.IsNotNull(response.Data);
_log.LogInformation("Writing extracted data to test configuration...");
nextTestConfiguration.Data = response.Data;
}
TH.Thread.Sleep(2000);
}
_concurrentConfig.Save(GlobalTestConstants.ConcurrentTestConfigurationFilePath);
}
/// <summary>
/// Initializes test.
/// </summary>
/// <param name="log">Trace logger instance.</param>
/// <param name="reset">Flag indicating if previous run information should be cleared from tracking file.</param>
/// <returns>A tuple with sequential and concurrent test configuration information.</returns>
public static Tuple <TestConfiguration, ConcurrentTestConfiguration> InitializeTest(ConsoleLogger log, bool reset = false)
{
log.LogInformation($"Loading test configuration from '{GlobalTestConstants.TestConfigurationFilePath}'...");
TestConfiguration config = TestConfiguration.Load(GlobalTestConstants.TestConfigurationFilePath);
log.LogInformation($"Loading concurrent test configuration from '{GlobalTestConstants.ConcurrentTestConfigurationFilePath}'...");
ConcurrentTestConfiguration concurrentConfig = ConcurrentTestConfiguration.Load(GlobalTestConstants.ConcurrentTestConfigurationFilePath);
if (!string.IsNullOrWhiteSpace(config.CallSid) && reset)
{
log.LogInformation("Previous run information present. Clearing out previous information...");
config.CallSid = null;
config.RecordingUri = null;
config.Save(GlobalTestConstants.TestConfigurationFilePath);
log.LogInformation("Test configuration saved to clean state.");
}
bool uncleanTestConfig = false;
foreach (TestConfiguration configuration in concurrentConfig.TestConfigurationQueue)
{
if (!string.IsNullOrWhiteSpace(configuration.CallSid) && reset)
{
uncleanTestConfig = true;
log.LogInformation("Previous run information present. Clearing out previous information...");
configuration.CallSid = null;
configuration.RecordingUri = null;
}
if (uncleanTestConfig)
{
concurrentConfig.Save(GlobalTestConstants.ConcurrentTestConfigurationFilePath);
log.LogInformation("Test configuration saved to clean state.");
}
}
return(new Tuple <TestConfiguration, ConcurrentTestConfiguration>(config, concurrentConfig));
}
