public void Log(CreateLogItemRequest createLogItemRequest)
{
if (StartTask == null)
{
var exp = new InsufficientExecutionStackException("The launch wasn't scheduled for starting to add log messages.");
TraceLogger.Error(exp.ToString());
throw (exp);
}
if (StartTask.IsFaulted || StartTask.IsCanceled)
{
return;
}
if (FinishTask == null)
{
lock (_lockObj)
{
if (_logsReporter == null)
{
var logRequestAmender = new LaunchLogRequestAmender(this);
_logsReporter = new LogsReporter(this, _service, _extensionManager, _requestExecuter, logRequestAmender);
}
}
_logsReporter.Log(createLogItemRequest);
}
}
internal static void GetHashCode_InfiniteLoopDetails(object item, Fake <CompareHint> hint)
{
hint.Setup("Supports",
new[] { item, item, Arg.LambdaAny <ValuerChainer>() },
Behavior.Throw <InsufficientExecutionStackException>(Times.Once));
InsufficientExecutionStackException e = Tools.Asserter.Throws <InsufficientExecutionStackException>(
() => new Valuer(false, hint.Dummy).GetHashCode(item));
Tools.Asserter.Is(true, e.Message.Contains(item.GetType().Name));
}
internal static void CreateSized_InfiniteLoopDetails(Type type, Fake <CreateCollectionHint> hint, int size)
{
hint.Setup(
m => m.TryCreate(type, size, Arg.Any <RandomizerChainer>()),
Behavior.Throw <InsufficientExecutionStackException>(Times.Once));
InsufficientExecutionStackException e = Tools.Asserter.Throws <InsufficientExecutionStackException>(
() => new Randomizer(Tools.Faker, new FastRandom(), Limiter.Dozen, false, hint.Dummy).CreateSized(type, size));
Tools.Asserter.Is(true, e.Message.Contains(type.Name));
}
internal static void Copy_InfiniteLoopDetails(object instance, Fake <CopyHint> hint)
{
hint.Setup(
m => m.TryCopy(instance, Arg.Any <DuplicatorChainer>()),
Behavior.Throw <InsufficientExecutionStackException>(Times.Once));
InsufficientExecutionStackException e = Tools.Asserter.Throws <InsufficientExecutionStackException>(
() => new Duplicator(Tools.Asserter, false, hint.Dummy).Copy(instance));
Tools.Asserter.Is(true, e.Message.Contains(instance.GetType().Name));
}
public void Update(UpdateLaunchRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
TraceLogger.Verbose($"Scheduling request to update 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);
}
UpdateTask = Task.Factory.ContinueWhenAll(dependentTasks.ToArray(), async(dts) =>
await _requestExecuter.ExecuteAsync(() => _service.Launch.UpdateAsync(Info.Uuid, request), null).ConfigureAwait(false));
}
public void Start(StartLaunchRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
TraceLogger.Verbose($"Scheduling request to start new '{request.Name}' launch in {GetHashCode()} proxy instance");
if (StartTask != null)
{
var exp = new InsufficientExecutionStackException("The launch is already scheduled for starting.");
TraceLogger.Error(exp.ToString());
throw exp;
}
if (_rerunOfUuid != null)
{
request.IsRerun = true;
request.RerunOfLaunchUuid = _rerunOfUuid;
// start rerun launch item
StartTask = Task.Run(async() =>
{
NotifyStarting(request);
var launch = await _requestExecuter.ExecuteAsync(() => _service.Launch.StartAsync(request), null).ConfigureAwait(false);
_launchInfo = new LaunchInfo
{
Uuid = launch.Uuid,
Name = request.Name,
StartTime = request.StartTime
};
NotifyStarted();
});
}
else if (!_isExternalLaunchId)
{
if (_isRerun)
{
request.IsRerun = true;
}
// start new launch item
StartTask = Task.Run(async() =>
{
NotifyStarting(request);
var launch = await _requestExecuter.ExecuteAsync(() => _service.Launch.StartAsync(request), null).ConfigureAwait(false);
_launchInfo = new LaunchInfo
{
Uuid = launch.Uuid,
Name = request.Name,
StartTime = request.StartTime
};
NotifyStarted();
});
}
else
{
// get launch info
StartTask = Task.Run(async() =>
{
var launch = await _requestExecuter.ExecuteAsync(() => _service.Launch.GetAsync(Info.Uuid), null).ConfigureAwait(false);
_launchInfo = new LaunchInfo
{
Uuid = launch.Uuid,
Name = launch.Name,
StartTime = launch.StartTime
};
});
}
}
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 void Start(StartTestItemRequest startTestItemRequest)
{
if (startTestItemRequest == null)
{
throw new ArgumentNullException(nameof(startTestItemRequest));
}
if (StartTask != null)
{
var exp = new InsufficientExecutionStackException("The test item is already scheduled for starting.");
TraceLogger.Error(exp.ToString());
throw exp;
}
var parentStartTask = ParentTestReporter?.StartTask ?? LaunchReporter.StartTask;
StartTask = parentStartTask.ContinueWith(async pt =>
{
if (pt.IsFaulted || pt.IsCanceled)
{
var exp = new Exception("Cannot start test item due parent failed to start.", pt.Exception);
if (pt.IsCanceled)
{
exp = new Exception($"Cannot start test item due timeout while starting parent.");
}
TraceLogger.Error(exp.ToString());
throw exp;
}
startTestItemRequest.LaunchUuid = LaunchReporter.Info.Uuid;
if (ParentTestReporter == null)
{
if (startTestItemRequest.StartTime < LaunchReporter.Info.StartTime)
{
startTestItemRequest.StartTime = LaunchReporter.Info.StartTime;
}
NotifyStarting(startTestItemRequest);
var testModel = await _requestExecuter.ExecuteAsync(() => _service.TestItem.StartAsync(startTestItemRequest), null).ConfigureAwait(false);
_testInfo = new TestInfo
{
Uuid = testModel.Uuid,
Name = startTestItemRequest.Name,
StartTime = startTestItemRequest.StartTime
};
NotifyStarted();
}
else
{
if (startTestItemRequest.StartTime < ParentTestReporter.Info.StartTime)
{
startTestItemRequest.StartTime = ParentTestReporter.Info.StartTime;
}
NotifyStarting(startTestItemRequest);
var testModel = await _requestExecuter.ExecuteAsync(() => _service.TestItem.StartAsync(ParentTestReporter.Info.Uuid, startTestItemRequest), null).ConfigureAwait(false);
_testInfo = new TestInfo
{
Uuid = testModel.Uuid,
Name = startTestItemRequest.Name,
StartTime = startTestItemRequest.StartTime
};
NotifyStarted();
}
_testInfo.StartTime = startTestItemRequest.StartTime;
}, TaskContinuationOptions.PreferFairness).Unwrap();
}