private void RunFinished()
{
if (Bridge.Context.LaunchId != null)
{
var requestFinishLaunch = new FinishLaunchRequest
{
EndTime = DateTime.UtcNow
};
var eventArg = new RunFinishedEventArgs(Bridge.Service, requestFinishLaunch, null, Bridge.Context.LaunchId);
if (BeforeRunFinished != null)
{
BeforeRunFinished(this, eventArg);
}
if (!eventArg.Canceled)
{
var message = Bridge.Service.FinishLaunch(Bridge.Context.LaunchId, requestFinishLaunch);
if (AfterRunFinished != null)
{
AfterRunFinished(this, new RunFinishedEventArgs(Bridge.Service, requestFinishLaunch, message.Info, Bridge.Context.LaunchId));
}
}
_suiteIds = null;
Bridge.Context.LaunchId = null;
}
}
public static void AfterTestRun()
{
if (Bridge.Context.LaunchReporter != null)
{
var request = new FinishLaunchRequest
{
EndTime = DateTime.UtcNow
};
var eventArg = new RunFinishedEventArgs(Bridge.Service, request, Bridge.Context.LaunchReporter);
if (BeforeRunFinished != null)
{
BeforeRunFinished(null, eventArg);
}
if (!eventArg.Canceled)
{
Bridge.Context.LaunchReporter.Finish(request);
Bridge.Context.LaunchReporter.FinishTask.Wait();
if (AfterRunFinished != null)
{
AfterRunFinished(null,
new RunFinishedEventArgs(Bridge.Service, request, Bridge.Context.LaunchReporter));
}
}
}
}
private BeforeLaunchFinishingEventArgs NotifyFinishing(FinishLaunchRequest request)
{
var args = new BeforeLaunchFinishingEventArgs(_service, _configuration, request);
Notify(() => ReportEventsSource.RaiseBeforeLaunchFinishing(_reportEventsSource, this, args));
return(args);
}
private void RunFinished()
{
if (Bridge.Context.LaunchReporter != null)
{
var requestFinishLaunch = new FinishLaunchRequest
{
EndTime = DateTime.UtcNow
};
Bridge.Context.LaunchReporter.Finish(requestFinishLaunch);
Stopwatch stopwatch = Stopwatch.StartNew();
Console.WriteLine("Finishing to send results to Report Portal...");
try
{
Bridge.Context.LaunchReporter.FinishTask.Wait(TimeSpan.FromMinutes(30));
}
catch (Exception exp)
{
Console.WriteLine(exp);
throw;
}
stopwatch.Stop();
Console.WriteLine($"Results are sent to Report Portal. Sync time: {stopwatch.Elapsed}");
}
}
public RunFinishedEventArgs(Service service, FinishLaunchRequest request, ILaunchReporter launchReporter, string report)
{
Service = service;
FinishLaunchRequest = request;
LaunchReporter = launchReporter;
Report = report;
}
public static void AfterTestRun()
{
try
{
if (_launchReporter != null)
{
var request = new FinishLaunchRequest
{
EndTime = DateTime.UtcNow
};
var eventArg = new RunFinishedEventArgs(_service, request, _launchReporter);
ReportPortalAddin.OnBeforeRunFinished(null, eventArg);
if (!eventArg.Canceled)
{
_launchReporter.Finish(request);
var sw = Stopwatch.StartNew();
_traceLogger.Info($"Finishing to send results to ReportPortal...");
_launchReporter.Sync();
_traceLogger.Info($"Elapsed: {sw.Elapsed}");
_traceLogger.Info(_launchReporter.StatisticsCounter.ToString());
ReportPortalAddin.OnAfterRunFinished(null, new RunFinishedEventArgs(_service, request, _launchReporter));
}
}
}
catch (Exception exp)
{
_traceLogger.Error(exp.ToString());
}
}
public static void AfterTestRun()
{
if (Bridge.Context.LaunchId != null)
{
var request = new FinishLaunchRequest
{
EndTime = DateTime.UtcNow
};
var eventArg = new RunFinishedEventArgs(Bridge.Service, request);
if (BeforeRunFinished != null)
{
BeforeRunFinished(null, eventArg);
}
if (!eventArg.Canceled)
{
var message = Bridge.Service.FinishLaunch(Bridge.Context.LaunchId, request).Info;
if (AfterRunFinished != null)
{
AfterRunFinished(null, new RunFinishedEventArgs(Bridge.Service, request, message));
}
Bridge.Context.LaunchId = null;
}
}
}
public async Task StartFinishDeleteLaunch()
{
var startLaunchRequest = new StartLaunchRequest
{
Name = "StartFinishDeleteLaunch",
StartTime = DateTime.UtcNow
};
var launch = await Service.Launch.StartAsync(startLaunchRequest);
Assert.NotNull(launch.Uuid);
Assert.NotEqual(0, launch.Number);
var finishLaunchRequest = new FinishLaunchRequest
{
EndTime = DateTime.UtcNow.AddHours(1)
};
var message = await Service.Launch.FinishAsync(launch.Uuid, finishLaunchRequest);
Assert.Equal(launch.Uuid, message.Id);
var gotLaunch = await Service.Launch.GetAsync(launch.Uuid);
Assert.Equal("StartFinishDeleteLaunch", gotLaunch.Name);
Assert.Equal(startLaunchRequest.StartTime, gotLaunch.StartTime);
Assert.Equal(finishLaunchRequest.EndTime, gotLaunch.EndTime);
var delMessage = await Service.Launch.DeleteAsync(gotLaunch.Id);
Assert.Contains("successfully", delMessage.Info);
}
public void Finish(FinishLaunchRequest request)
{
TraceLogger.Verbose($"Scheduling request to finish launch in {GetHashCode()} proxy instance");
if (StartTask == null)
{
throw new InsufficientExecutionStackException("The launch wasn't scheduled for starting to finish it properly.");
}
if (FinishTask != null)
{
throw new InsufficientExecutionStackException("The launch is already scheduled for finishing.");
}
var dependentTasks = new List <Task>();
if (ChildTestReporters != null)
{
dependentTasks.AddRange(ChildTestReporters.Select(tn => tn.FinishTask));
}
dependentTasks.Add(StartTask);
FinishTask = Task.Factory.ContinueWhenAll(dependentTasks.ToArray(), async(dts) =>
{
try
{
if (StartTask.IsFaulted)
{
throw new Exception("Cannot finish launch due starting launch failed.", StartTask.Exception);
}
if (ChildTestReporters?.Any(ctr => ctr.FinishTask.IsFaulted) == true)
{
throw new AggregateException("Cannot finish launch due inner items failed to finish.", ChildTestReporters.Where(ctr => ctr.FinishTask.IsFaulted).Select(ctr => ctr.FinishTask.Exception).ToArray());
}
if (request.EndTime < LaunchInfo.StartTime)
{
request.EndTime = LaunchInfo.StartTime;
}
if (!_isExternalLaunchId)
{
await _service.FinishLaunchAsync(LaunchInfo.Id, request);
}
}
catch (Exception)
{
throw;
}
finally
{
// clean childs
ChildTestReporters = null;
}
}).Unwrap();
}
/// <summary>
/// Stopes specified launch even if inner tests are not finished yet.
/// </summary>
/// <param name="id">ID of specified launch.</param>
/// <param name="request">Information about representation of launch to finish.</param>
/// <returns>A message from service.</returns>
public virtual async Task <LaunchFinishedResponse> StopAsync(long id, FinishLaunchRequest request)
{
var uri = BaseUri.Append($"{ProjectName}/launch/{id}/stop");
var body = ModelSerializer.Serialize <FinishLaunchRequest>(request);
var response = await HttpClient.PutAsync(uri, new StringContent(body, Encoding.UTF8, "application/json")).ConfigureAwait(false);
response.VerifySuccessStatusCode();
return(ModelSerializer.Deserialize <LaunchFinishedResponse>(await response.Content.ReadAsStringAsync().ConfigureAwait(false)));
}
public void Finish(FinishLaunchRequest request, bool force = false)
{
FinishTask = Task.Run(async() =>
{
StartTask.Wait();
TestNodes.ToList().ForEach(tn => tn.FinishTask.Wait());
await _service.FinishLaunchAsync(LaunchId, request, force);
});
}
/// <summary>
/// Finishes specified launch.
/// </summary>
/// <param name="id">ID of specified launch.</param>
/// <param name="model">Information about representation of launch to finish.</param>
/// <param name="force">Force finish launch even if test items are in progress.</param>
/// <returns>A message from service.</returns>
public async Task <Message> FinishLaunchAsync(string id, FinishLaunchRequest model, bool force = false)
{
var uri = BaseUri.Append($"{Project}/launch/{id}");
uri = force == true?uri.Append("/stop") : uri.Append("/finish");
var body = ModelSerializer.Serialize <FinishLaunchRequest>(model);
var response = await _httpClient.PutAsync(uri, new StringContent(body, Encoding.UTF8, "application/json")).ConfigureAwait(false);
response.VerifySuccessStatusCode();
return(ModelSerializer.Deserialize <Message>(await response.Content.ReadAsStringAsync().ConfigureAwait(false)));
}
private async Task FinishLaunch(Launch launch)
{
if (launch.IsNotFinished())
{
var finishRequest = new FinishLaunchRequest {
EndTime = DateTime.UtcNow
};
var message = await _service.FinishLaunchAsync(launch.Id, finishRequest, true).ConfigureAwait(false);
_logger?.LogDebug(message.Info);
}
}
public async Task <Launch> CleanAsync(Launch launch)
{
if (launch.IsNotFinished())
{
var finishRequest = new FinishLaunchRequest {
EndTime = DateTime.UtcNow
};
var message = await _service.FinishLaunchAsync(launch.Id, finishRequest, true).ConfigureAwait(false);
_logger.LogDebug(message.Info);
}
return(await _decorated.CleanAsync(launch).ConfigureAwait(false));
}
private void FinishRun(XmlDocument xmlDoc)
{
try
{
var finishLaunchRequest = new FinishLaunchRequest
{
EndTime = DateTime.UtcNow,
};
var eventArg = new RunFinishedEventArgs(Bridge.Service, finishLaunchRequest, Bridge.Context.LaunchReporter);
try
{
if (BeforeRunFinished != null)
{
BeforeRunFinished(this, eventArg);
}
}
catch (Exception exp)
{
Console.WriteLine("Exception was thrown in 'BeforeRunFinished' subscriber." + Environment.NewLine + exp);
}
if (!eventArg.Canceled)
{
var sw = Stopwatch.StartNew();
Console.Write("Finishing to send the results to Report Portal... ");
Bridge.Context.LaunchReporter.Finish(finishLaunchRequest, force: false);
Bridge.Context.LaunchReporter.FinishTask.Wait();
Console.WriteLine($"Elapsed: {sw.Elapsed}");
try
{
if (AfterRunFinished != null)
{
AfterRunFinished(this, new RunFinishedEventArgs(Bridge.Service, finishLaunchRequest, Bridge.Context.LaunchReporter));
}
}
catch (Exception exp)
{
Console.WriteLine("Exception was thrown in 'AfterRunFinished' subscriber." + Environment.NewLine + exp);
}
}
}
catch (Exception exception)
{
Console.WriteLine("ReportPortal exception was thrown." + Environment.NewLine + exception);
}
}
private void Events_TestRunComplete(object sender, TestRunCompleteEventArgs e)
{
//TODO: apply smarter way to finish suites in real-time tests execution
//finish suites
while (_suitesflow.Count != 0)
{
var deeperKey = _suitesflow.Keys.OrderBy(s => s.Split('.').Length).Last();
TraceLogger.Verbose($"Finishing namespace '{deeperKey}'");
var deeperSuite = _suitesflow[deeperKey];
var finishSuiteRequest = new FinishTestItemRequest
{
EndTime = DateTime.UtcNow,
//TODO: identify correct suite status based on inner nodes
Status = Status.Passed
};
deeperSuite.Finish(finishSuiteRequest);
_suitesflow.Remove(deeperKey);
}
// finish launch
var requestFinishLaunch = new FinishLaunchRequest
{
EndTime = DateTime.UtcNow
};
_launchReporter.Finish(requestFinishLaunch);
Stopwatch stopwatch = Stopwatch.StartNew();
Console.Write("Finishing to send results to Report Portal...");
try
{
_launchReporter.Sync();
}
catch (Exception exp)
{
Console.WriteLine(exp);
throw;
}
stopwatch.Stop();
Console.WriteLine($" Sync time: {stopwatch.Elapsed}");
}
public Task <LaunchFinishedResponse> StopAsync(long id, FinishLaunchRequest model)
{
throw new NotImplementedException();
}
public override async Task <Message> FinishLaunchAsync(string id, FinishLaunchRequest model, bool force = false)
{
return(await Task.FromResult(new Message()));
}
public RunFinishedEventArgs(Service service, FinishLaunchRequest request, string message, string id)
: this(service, request, message)
{
_id = id;
}
public async Task <LaunchFinishedResponse> FinishAsync(string uuid, FinishLaunchRequest model)
{
return(await Task.FromResult(new LaunchFinishedResponse()));
}
public void Finish(FinishLaunchRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
TraceLogger.Verbose($"Scheduling request to finish launch in {GetHashCode()} proxy instance");
if (StartTask == null)
{
var exp = new InsufficientExecutionStackException("The launch wasn't scheduled for starting to finish it properly.");
TraceLogger.Error(exp.ToString());
throw exp;
}
if (FinishTask != null)
{
var exp = new InsufficientExecutionStackException("The launch is already scheduled for finishing.");
TraceLogger.Error(exp.ToString());
throw exp;
}
var dependentTasks = new List <Task>();
dependentTasks.Add(StartTask);
if (_logsReporter != null)
{
dependentTasks.Add(_logsReporter.ProcessingTask);
}
if (_additionalTasks != null)
{
dependentTasks.AddRange(_additionalTasks);
}
if (ChildTestReporters != null)
{
var childTestReporterFinishTasks = ChildTestReporters.Select(tn => tn.FinishTask);
if (childTestReporterFinishTasks.Contains(null))
{
throw new InsufficientExecutionStackException("Some of child test item(s) are not scheduled to finish yet.");
}
dependentTasks.AddRange(childTestReporterFinishTasks);
}
FinishTask = Task.Factory.ContinueWhenAll(dependentTasks.ToArray(), async(dts) =>
{
try
{
if (StartTask.IsFaulted || StartTask.IsCanceled)
{
var exp = new Exception("Cannot finish launch due starting launch failed.", StartTask.Exception);
if (StartTask.IsCanceled)
{
exp = new Exception($"Cannot finish launch due timeout while starting it.");
}
TraceLogger.Error(exp.ToString());
throw exp;
}
if (ChildTestReporters != null)
{
var failedChildTestReporters = ChildTestReporters.Where(ctr => ctr.FinishTask.IsFaulted || ctr.FinishTask.IsCanceled);
if (failedChildTestReporters.Any())
{
var errors = new List <Exception>();
foreach (var failedChildTestReporter in failedChildTestReporters)
{
if (failedChildTestReporter.FinishTask.IsFaulted)
{
errors.Add(failedChildTestReporter.FinishTask.Exception);
}
else if (failedChildTestReporter.FinishTask.IsCanceled)
{
errors.Add(new Exception($"Cannot finish launch due timeout while finishing test item."));
}
}
var exp = new AggregateException("Cannot finish launch due finishing of child items failed.", errors);
TraceLogger.Error(exp.ToString());
throw exp;
}
}
if (request.EndTime < _launchInfo.StartTime)
{
request.EndTime = _launchInfo.StartTime;
_launchInfo.FinishTime = request.EndTime;
}
if (!_isExternalLaunchId && _rerunOfUuid == null)
{
NotifyFinishing(request);
await _requestExecuter.ExecuteAsync(() => _service.Launch.FinishAsync(Info.Uuid, request), null).ConfigureAwait(false);
NotifyFinished();
}
}
finally
{
// clean childs
// ChildTestReporters = null;
}
}, TaskContinuationOptions.PreferFairness).Unwrap();
}
public Task <LaunchFinishedResponse> StopAsync(long id, FinishLaunchRequest request)
{
return(PutAsJsonAsync <LaunchFinishedResponse, FinishLaunchRequest>($"{ProjectName}/launch/{id}/stop", request));
}
public RunFinishedEventArgs(Service service, FinishLaunchRequest request, LaunchReporter launchReporter)
{
Service = service;
Launch = request;
LaunchReporter = launchReporter;
}
public Task <LaunchFinishedResponse> FinishAsync(string uuid, FinishLaunchRequest request)
{
return(PutAsJsonAsync <LaunchFinishedResponse, FinishLaunchRequest>($"{ProjectName}/launch/{uuid}/finish", request));
}
private void Events_TestRunComplete(object sender, TestRunCompleteEventArgs e)
{
try
{
//TODO: apply smarter way to finish suites in real-time tests execution
//finish suites
while (_suitesflow.Count != 0)
{
var deeperKey = _suitesflow.Keys.OrderBy(s => s.Split('.').Length).Last();
TraceLogger.Verbose($"Finishing namespace '{deeperKey}'");
var deeperSuite = _suitesflow[deeperKey];
var finishSuiteRequest = new FinishTestItemRequest
{
EndTime = DateTime.UtcNow,
//TODO: identify correct suite status based on inner nodes
Status = Status.Passed
};
deeperSuite.Finish(finishSuiteRequest);
_suitesflow.Remove(deeperKey);
}
// finish launch
var requestFinishLaunch = new FinishLaunchRequest
{
EndTime = DateTime.UtcNow
};
_launchReporter.Finish(requestFinishLaunch);
if (Environment.GetEnvironmentVariable("DTA.RerunIterationCount") != null)
{
Environment.SetEnvironmentVariable("REPORTPORTAL_RerunOfLaunchUuid", _launchReporter.LaunchInfo.Uuid);
}
Stopwatch stopwatch = Stopwatch.StartNew();
Console.Write("Finishing to send results to Report Portal...");
try
{
_launchReporter.Sync();
}
catch (Exception exp)
{
Console.WriteLine(exp);
throw;
}
stopwatch.Stop();
Console.WriteLine($" Sync time: {stopwatch.Elapsed}");
}
catch (Exception exp)
{
var error = $"Unexpected exception in {nameof(Events_TestRunComplete)}: {exp}";
TraceLogger.Error(error);
Console.WriteLine(error);
}
}
public RunFinishedEventArgs(Service service, FinishLaunchRequest request)
{
_service = service;
_request = request;
}
public RunFinishedEventArgs(Service service, FinishLaunchRequest request, string message)
: this(service, request)
{
_message = message;
}
public RunFinishedEventArgs(IClientService service, FinishLaunchRequest request, ILaunchReporter launchReporter)
{
Service = service;
FinishLaunchRequest = request;
LaunchReporter = launchReporter;
}
public BeforeLaunchFinishingEventArgs(IClientService clientService, IConfiguration configuration, FinishLaunchRequest finishLaunchRequest) : base(clientService, configuration)
{
FinishLaunchRequest = finishLaunchRequest;
}
