public async Task UpdateDescription()
{
var originalRequest = new StartTestItemRequest
{
LaunchUuid = _fixture.LaunchUuid,
Name = "UpdateDescription",
StartTime = DateTime.UtcNow
};
var test = await Service.TestItem.StartAsync(originalRequest);
var tempTest = await Service.TestItem.GetAsync(test.Uuid);
var updateRequest = new UpdateTestItemRequest()
{
Description = "newDesc",
};
var updateMessage = await Service.TestItem.UpdateAsync(tempTest.Id, updateRequest);
updateMessage.Info.Should().Contain("successfully");
var updatedTest = await Service.TestItem.GetAsync(test.Uuid);
updatedTest.Name.Should().Be(originalRequest.Name);
updatedTest.Description.Should().Be(updateRequest.Description);
await Service.TestItem.FinishAsync(test.Uuid, new FinishTestItemRequest
{
EndTime = DateTime.UtcNow,
Status = Status.Passed
});
}
public async Task UpdateOfInProgressIsNotAllowed()
{
var originalRequest = new StartTestItemRequest
{
LaunchUuid = _fixture.LaunchUuid,
Name = "UpdateAttributes",
StartTime = DateTime.UtcNow
};
var test = await Service.TestItem.StartAsync(originalRequest);
var tempTest = await Service.TestItem.GetAsync(test.Uuid);
var updateRequest = new UpdateTestItemRequest()
{
Status = Status.Passed
};
Func <Task> act = async() => await Service.TestItem.UpdateAsync(tempTest.Id, updateRequest);
var exp = await act.Should().ThrowExactlyAsync <ReportPortalException>();
exp.WithInnerExceptionExactly <HttpRequestException>().WithMessage("*Unable to update status*");
await Service.TestItem.FinishAsync(test.Uuid, new FinishTestItemRequest
{
EndTime = DateTime.UtcNow,
Status = Status.Passed
});
}
private TestReporter AddTestReporter(IReadonlyNode <TestReporter> parent, Path path, Location test, string tags)
{
TestItemType type = TestItemType.Suite;
if (test.Index == path.Length - 2)
{
type = TestItemType.Test;
}
else if (test.Index == path.Length - 1)
{
type = TestItemType.Step;
}
var startTestItemRequest = new StartTestItemRequest()
{
Name = test.Name,
StartTime = DateTime.UtcNow,
Type = type,
Tags = SplitOnTags(tags)
};
var suite = parent.Value != null
? parent.Value.StartNewTestNode(startTestItemRequest)
: _launchReporter.StartNewTestNode(startTestItemRequest);
return(suite);
}
public void TestStarted(TestName testName)
{
if (Bridge.Context.LaunchId != null)
{
// get parent suite id from stack
string parentSuiteId = (_suiteIds.Count > 0) ? _suiteIds.Peek() : null;
var requestNewTest = new StartTestItemRequest
{
LaunchId = Bridge.Context.LaunchId,
Name = testName.Name,
StartTime = DateTime.UtcNow,
Type = TestItemType.Step
};
var eventArg = new TestItemStartedEventArgs(Bridge.Service, requestNewTest);
if (BeforeTestStarted != null)
{
BeforeTestStarted(this, eventArg);
}
if (!eventArg.Canceled)
{
_testId = Bridge.Service.StartTestItem(parentSuiteId, requestNewTest).Id;
Bridge.Context.TestId = _testId;
if (AfterTestStarted != null)
{
AfterTestStarted(this, new TestItemStartedEventArgs(Bridge.Service, requestNewTest, _testId));
}
}
}
}
private void CommandsSource_OnBeginLogScopeCommand(Shared.Execution.ILogContext logContext, Shared.Extensibility.Commands.CommandArgs.LogScopeCommandArgs args)
{
var logScope = args.LogScope;
var startRequest = new StartTestItemRequest
{
Name = logScope.Name,
StartTime = logScope.BeginTime,
HasStats = false
};
ITestReporter testReporter = null;
if (logScope.Parent != null)
{
if (ReportPortalAddin.LogScopes.ContainsKey(logScope.Parent.Id))
{
testReporter = ReportPortalAddin.LogScopes[logScope.Parent.Id];
}
}
else
{
testReporter = GetCurrentTestReporter();
}
if (testReporter != null)
{
var nestedStep = testReporter.StartChildTestReporter(startRequest);
ReportPortalAddin.LogScopes[logScope.Id] = nestedStep;
}
else
{
_traceLogger.Warn("Unknown current step context to begin new log scope.");
}
}
public StepStartedEventArgs(IClientService service, StartTestItemRequest request, ITestReporter testReporter, FeatureContext featureContext, ScenarioContext scenarioContext, ScenarioStepContext stepContext)
: this(service, request, testReporter)
{
FeatureContext = featureContext;
ScenarioContext = scenarioContext;
StepContext = stepContext;
}
public void BeforeScenario()
{
if (CurrentFeature != null)
{
CurrentScenarioDescription = string.Empty;
Status = Status.Passed;
var request = new StartTestItemRequest
{
Name = ScenarioContext.Current.ScenarioInfo.Title,
StartTime = DateTime.UtcNow,
Type = TestItemType.Step,
Description = CurrentScenarioDescription,
Tags = new List <string>(ScenarioContext.Current.ScenarioInfo.Tags)
};
var eventArg = new TestItemStartedEventArgs(Bridge.Service, request);
if (BeforeScenarioStarted != null)
{
BeforeScenarioStarted(this, eventArg);
}
if (!eventArg.Canceled)
{
CurrentScenario = CurrentFeature.StartNewTestNode(request);
if (AfterScenarioStarted != null)
{
AfterScenarioStarted(this,
new TestItemStartedEventArgs(Bridge.Service, request, CurrentScenario));
}
}
}
}
public ITestReporter StartChildTestReporter(StartTestItemRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
TraceLogger.Verbose($"Scheduling request to start new '{request.Name}' test item in {GetHashCode()} proxy instance");
var newTestNode = new TestReporter(_service, _configuration, LaunchReporter, this, _requestExecuter, _extensionManager, _reportEventsSource);
newTestNode.Start(request);
lock (_lockObj)
{
if (ChildTestReporters == null)
{
lock (_lockObj)
{
ChildTestReporters = new List <ITestReporter>();
}
}
ChildTestReporters.Add(newTestNode);
}
return(newTestNode);
}
private BeforeTestStartingEventArgs NotifyStarting(StartTestItemRequest request)
{
var args = new BeforeTestStartingEventArgs(_service, _configuration, request);
Notify(() => ReportEventsSource.RaiseBeforeTestStarting(_reportEventsSource, this, args));
return(args);
}
public async Task FinishTestWithAttributes()
{
var startTestItemRequest = new StartTestItemRequest
{
LaunchUuid = _fixture.LaunchUuid,
Name = "Test1",
StartTime = DateTime.UtcNow,
Type = TestItemType.Test
};
var test = await Service.TestItem.StartAsync(startTestItemRequest);
var finishTestRequest = new FinishTestItemRequest
{
EndTime = DateTime.UtcNow,
Attributes = new List <ItemAttribute> {
new ItemAttribute {
Value = "v"
}
}
};
await Service.TestItem.FinishAsync(test.Uuid, finishTestRequest);
var getTest = await Service.TestItem.GetAsync(test.Uuid);
getTest.Attributes.Should().NotBeEmpty();
}
public void BeforeScenario()
{
var currentFeature = ReportPortalAddin.GetFeatureTestReporter(this.FeatureContext);
if (currentFeature != null)
{
var request = new StartTestItemRequest
{
Name = this.ScenarioContext.ScenarioInfo.Title,
StartTime = DateTime.UtcNow,
Type = TestItemType.Step,
Tags = new List <string>(this.ScenarioContext.ScenarioInfo.Tags)
};
var eventArg = new TestItemStartedEventArgs(Bridge.Service, request);
ReportPortalAddin.OnBeforeScenarioStarted(this, eventArg);
if (!eventArg.Canceled)
{
var currentScenario = currentFeature.StartNewTestNode(request);
ReportPortalAddin.SetScenarioTestReporter(this.ScenarioContext, currentScenario);
ReportPortalAddin.OnAfterScenarioStarted(this, new TestItemStartedEventArgs(Bridge.Service, request, currentFeature));
}
}
}
public static void BeforeFeature()
{
if (Bridge.Context.LaunchReporter != null)
{
var request = new StartTestItemRequest
{
Name = FeatureContext.Current.FeatureInfo.Title,
Description = FeatureContext.Current.FeatureInfo.Description,
StartTime = DateTime.UtcNow,
Type = TestItemType.Suite,
Tags = new List <string>(FeatureContext.Current.FeatureInfo.Tags)
};
var eventArg = new TestItemStartedEventArgs(Bridge.Service, request);
if (BeforeFeatureStarted != null)
{
BeforeFeatureStarted(null, eventArg);
}
if (!eventArg.Canceled)
{
CurrentFeature = Bridge.Context.LaunchReporter.StartNewTestNode(request);
if (AfterFeatureStarted != null)
{
AfterFeatureStarted(null, new TestItemStartedEventArgs(Bridge.Service, request, CurrentFeature));
}
}
}
}
public async Task UpdateStatus(Status status)
{
var originalRequest = new StartTestItemRequest
{
LaunchUuid = _fixture.LaunchUuid,
Name = "UpdateAttributes",
StartTime = DateTime.UtcNow
};
var test = await Service.TestItem.StartAsync(originalRequest);
await Service.TestItem.FinishAsync(test.Uuid, new FinishTestItemRequest
{
EndTime = DateTime.UtcNow,
Status = Status.Passed
});
var tempTest = await Service.TestItem.GetAsync(test.Uuid);
var updateRequest = new UpdateTestItemRequest()
{
Status = status
};
await Service.TestItem.UpdateAsync(tempTest.Id, updateRequest);
var updatedTest = await Service.TestItem.GetAsync(test.Uuid);
updatedTest.Name.Should().Be(originalRequest.Name);
updatedTest.Description.Should().Be(originalRequest.Description);
updatedTest.Status.Should().Be(status);
}
public void BeforeScenario()
{
if (CurrentFeatureId != null)
{
var request = new StartTestItemRequest
{
LaunchId = Bridge.Context.LaunchId,
Name = ScenarioContext.Current.ScenarioInfo.Title,
StartTime = DateTime.UtcNow,
Type = TestItemType.Test,
Tags = new List <string>(ScenarioContext.Current.ScenarioInfo.Tags)
};
var eventArg = new TestItemStartedEventArgs(Bridge.Service, request);
if (BeforeScenarioStarted != null)
{
BeforeScenarioStarted(this, eventArg);
}
if (!eventArg.Canceled)
{
CurrentScenarioId = Bridge.Service.StartTestItem(CurrentFeatureId, request).Id;
if (AfterScenarioStarted != null)
{
AfterScenarioStarted(this,
new TestItemStartedEventArgs(Bridge.Service, request, CurrentScenarioId));
}
}
}
}
private void StartSuite(XmlDocument xmlDoc)
{
try
{
var id = xmlDoc.SelectSingleNode("/*/@id").Value;
var parentId = xmlDoc.SelectSingleNode("/*/@parentId").Value;
var name = xmlDoc.SelectSingleNode("/*/@name").Value;
var startSuiteRequest = new StartTestItemRequest
{
StartTime = DateTime.UtcNow,
Name = name,
Type = TestItemType.Suite
};
var beforeSuiteEventArg = new TestItemStartedEventArgs(Bridge.Service, startSuiteRequest);
try
{
if (BeforeSuiteStarted != null)
{
BeforeSuiteStarted(this, beforeSuiteEventArg);
}
}
catch (Exception exp)
{
Console.WriteLine("Exception was thrown in 'BeforeSuiteStarted' subscriber." + Environment.NewLine + exp);
}
if (!beforeSuiteEventArg.Canceled)
{
TestReporter test;
if (string.IsNullOrEmpty(parentId) || !_suitesFlow.ContainsKey(parentId))
{
test = Bridge.Context.LaunchReporter.StartNewTestNode(startSuiteRequest);
}
else
{
test = _suitesFlow[parentId].StartNewTestNode(startSuiteRequest);
}
_suitesFlow[id] = test;
try
{
if (AfterSuiteStarted != null)
{
AfterSuiteStarted(this, new TestItemStartedEventArgs(Bridge.Service, startSuiteRequest, test));
}
}
catch (Exception exp)
{
Console.WriteLine("Exception was thrown in 'AfterSuiteStarted' subscriber." + Environment.NewLine + exp);
}
}
}
catch (Exception exception)
{
Console.WriteLine("ReportPortal exception was thrown." + Environment.NewLine + exception);
}
}
/// <summary>
/// Creates a new test item.
/// </summary>
/// <param name="id">ID of parent item.</param>
/// <param name="model">Information about representation of test item.</param>
/// <returns>Representation of created test item.</returns>
public virtual async Task <TestItem> StartTestItemAsync(string id, StartTestItemRequest model)
{
var uri = BaseUri.Append($"{Project}/item/{id}");
var body = ModelSerializer.Serialize <StartTestItemRequest>(model);
var response = await _httpClient.PostAsync(uri, new StringContent(body, Encoding.UTF8, "application/json")).ConfigureAwait(false);
response.VerifySuccessStatusCode();
return(ModelSerializer.Deserialize <TestItem>(await response.Content.ReadAsStringAsync().ConfigureAwait(false)));
}
public async Task StartFinishFullTest()
{
var attributes = new List <ItemAttribute> {
new ItemAttribute {
Key = "a1", Value = "v1"
}, new ItemAttribute {
Key = "a2", Value = "v2"
}, new ItemAttribute {
Value = "v3"
}
};
var parameters = new List <KeyValuePair <string, string> > {
new KeyValuePair <string, string>("a1", "v1")
};
var startTestItemRequest = new StartTestItemRequest
{
LaunchUuid = _fixture.LaunchUuid,
Name = "Test1",
StartTime = DateTime.UtcNow,
Type = TestItemType.Test,
Description = "Desc for test",
Attributes = attributes,
Parameters = parameters,
CodeReference = "SomeNamespace.SomeClassname.SomeMethodname"
};
var test = await Service.TestItem.StartAsync(startTestItemRequest);
Assert.NotNull(test.Uuid);
var getTest = await Service.TestItem.GetAsync(test.Uuid);
Assert.Null(getTest.ParentId);
Assert.Equal(startTestItemRequest.Name, getTest.Name);
Assert.Equal(startTestItemRequest.StartTime, getTest.StartTime);
Assert.Equal(startTestItemRequest.Type, getTest.Type);
Assert.Equal(startTestItemRequest.Description, getTest.Description);
Assert.Equal(parameters, getTest.Parameters);
Assert.Equal("SomeNamespace.SomeClassname.SomeMethodname", getTest.CodeReference);
getTest.Attributes.Should().BeEquivalentTo(attributes);
var finishTestItemRequest = new FinishTestItemRequest
{
EndTime = DateTime.UtcNow,
Status = Status.Passed
};
var message = await Service.TestItem.FinishAsync(test.Uuid, finishTestItemRequest);
Assert.Contains("successfully", message.Info);
getTest = await Service.TestItem.GetAsync(test.Uuid);
Assert.Equal(finishTestItemRequest.Status, getTest.Status);
Assert.Equal(finishTestItemRequest.EndTime, getTest.EndTime);
}
public void StartTest(XmlDocument xmlDoc)
{
try
{
var id = xmlDoc.SelectSingleNode("/*/@id").Value;
var parentId = xmlDoc.SelectSingleNode("/*/@parentId").Value;
var name = xmlDoc.SelectSingleNode("/*/@name").Value;
var fullname = xmlDoc.SelectSingleNode("/*/@fullname").Value;
var startTestRequest = new StartTestItemRequest
{
StartTime = DateTime.UtcNow,
Name = name,
Type = TestItemType.Step
};
var beforeTestEventArg = new TestItemStartedEventArgs(Bridge.Service, startTestRequest);
try
{
if (BeforeTestStarted != null)
{
BeforeTestStarted(this, beforeTestEventArg);
}
}
catch (Exception exp)
{
Console.WriteLine("Exception was thrown in 'BeforeTestStarted' subscriber." + Environment.NewLine +
exp);
}
if (!beforeTestEventArg.Canceled)
{
var test = _suitesFlow[parentId].StartNewTestNode(startTestRequest);
_testFlowIds[id] = test;
_testFlowNames[fullname] = test;
try
{
if (AfterTestStarted != null)
{
AfterTestStarted(this, new TestItemStartedEventArgs(Bridge.Service, startTestRequest, test));
}
}
catch (Exception exp)
{
Console.WriteLine("Exception was thrown in 'AfterTestStarted' subscriber." + Environment.NewLine +
exp);
}
}
}
catch (Exception exception)
{
Console.WriteLine("ReportPortal exception was thrown." + Environment.NewLine + exception);
}
}
public override async Task <TestItem> StartTestItemAsync(string id, StartTestItemRequest model)
{
lock (_startTestItemCounterLockObj)
{
StartTestItemCounter++;
}
await Task.Delay(RequestsDelay);
return(await Task.FromResult(new TestItem { Id = Guid.NewGuid().ToString() }));
}
public async Task StartFinishFullTest()
{
var attributes = new List <StartTestItemRequest.Attribute> {
new StartTestItemRequest.Attribute {
Key = "a1", Value = "v1"
}, new StartTestItemRequest.Attribute {
Key = "a2", Value = "v2"
}
};
var parameters = new List <KeyValuePair <string, string> > {
new KeyValuePair <string, string>("a1", "v1")
};
var startTestItemRequest = new StartTestItemRequest
{
LaunchUuid = _fixture.LaunchUuid,
Name = "Test1",
StartTime = DateTime.UtcNow,
Type = TestItemType.Test,
Description = "Desc for test",
Attributes = attributes,
Parameters = parameters,
Tags = new List <string> {
"b", "c"
}
};
var test = await Service.TestItem.StartAsync(startTestItemRequest);
Assert.NotNull(test.Uuid);
var getTest = await Service.TestItem.GetAsync(test.Uuid);
Assert.Null(getTest.ParentId);
Assert.Equal(startTestItemRequest.Name, getTest.Name);
Assert.Equal(startTestItemRequest.StartTime, getTest.StartTime);
Assert.Equal(startTestItemRequest.Type, getTest.Type);
Assert.Equal(startTestItemRequest.Description, getTest.Description);
Assert.Equal(parameters, getTest.Parameters);
Assert.Equal(attributes.Select(a => new { a.Key, a.Value }), getTest.Attributes.Select(a => new { a.Key, a.Value }));
var finishTestItemRequest = new FinishTestItemRequest
{
EndTime = DateTime.UtcNow,
Status = Status.Passed
};
var message = await Service.TestItem.FinishAsync(test.Uuid, finishTestItemRequest);
Assert.Contains("successfully", message.Info);
getTest = await Service.TestItem.GetAsync(test.Uuid);
Assert.Equal(finishTestItemRequest.Status, getTest.Status);
Assert.Equal(finishTestItemRequest.EndTime, getTest.EndTime);
}
public TestReporter StartNewTestNode(StartTestItemRequest request)
{
var newTestNode = new TestReporter(_service, _launchNode, this);
newTestNode.Start(request);
TestNodes.Add(newTestNode);
_launchNode.LastTestNode = newTestNode;
return(newTestNode);
}
public void SuiteStarted(string name, TestResult result)
{
var requestNewSuite = new StartTestItemRequest
{
Name = name,
StartTime = result.StartTime.UtcDateTime,
Type = TestItemType.Suite
};
_suiteId = Bridge.Context.LaunchReporter.StartNewTestNode(requestNewSuite);
}
private ITestReporter GetOrStartSuiteNode(string fullName, DateTime startTime)
{
if (_suitesflow.ContainsKey(fullName))
{
return(_suitesflow[fullName]);
}
else
{
var parts = fullName.Split('.');
if (parts.Length == 1)
{
if (_suitesflow.ContainsKey(parts[0]))
{
return(_suitesflow[parts[0]]);
}
else
{
// create root
var startSuiteRequest = new StartTestItemRequest
{
Name = fullName,
StartTime = startTime,
Type = TestItemType.Suite
};
var rootSuite = _launchReporter.StartChildTestReporter(startSuiteRequest);
_suitesflow[fullName] = rootSuite;
return(rootSuite);
}
}
else
{
var parent = GetOrStartSuiteNode(string.Join(".", parts.Take(parts.Length - 1)), startTime);
// create
var startSuiteRequest = new StartTestItemRequest
{
Name = parts.Last(),
StartTime = startTime,
Type = TestItemType.Suite
};
var suite = parent.StartChildTestReporter(startSuiteRequest);
_suitesflow[fullName] = suite;
return(suite);
}
}
}
public override Task <TestItem> StartTestItemAsync(string id, StartTestItemRequest model)
{
lock (_startTestItemCounterLockObj)
{
if (_isFirstTimeStartTestItem == false)
{
_isFirstTimeStartTestItem = true;
throw new Exception("StartTestItemAsync first time fails");
}
}
return(base.StartTestItemAsync(id, model));
}
public void StartTest(XmlDocument xmlDoc)
{
try
{
var id = xmlDoc.SelectSingleNode("/*/@id").Value;
var parentId = xmlDoc.SelectSingleNode("/*/@parentId").Value;
var name = xmlDoc.SelectSingleNode("/*/@name").Value;
var fullname = xmlDoc.SelectSingleNode("/*/@fullname").Value;
var startTime = DateTime.UtcNow;
var startTestRequest = new StartTestItemRequest
{
StartTime = startTime,
Name = name,
Type = TestItemType.Step
};
var beforeTestEventArg = new TestItemStartedEventArgs(Bridge.Service, startTestRequest, null, xmlDoc.OuterXml);
try
{
BeforeTestStarted?.Invoke(this, beforeTestEventArg);
}
catch (Exception exp)
{
Console.WriteLine("Exception was thrown in 'BeforeTestStarted' subscriber." + Environment.NewLine +
exp);
}
if (!beforeTestEventArg.Canceled)
{
var testReporter = _flowItems[parentId].TestReporter.StartChildTestReporter(startTestRequest);
_flowItems[id] = new FlowItemInfo(id, parentId, FlowItemInfo.FlowType.Test, fullname, testReporter, startTime);
try
{
AfterTestStarted?.Invoke(this, new TestItemStartedEventArgs(Bridge.Service, startTestRequest, testReporter, xmlDoc.OuterXml));
}
catch (Exception exp)
{
Console.WriteLine("Exception was thrown in 'AfterTestStarted' subscriber." + Environment.NewLine +
exp);
}
}
}
catch (Exception exception)
{
Console.WriteLine("ReportPortal exception was thrown." + Environment.NewLine + exception);
}
}
public ITestReporter StartChildTestReporter(StartTestItemRequest request)
{
var newTestNode = new TestReporter(_service, this, null, request);
if (ChildTestReporters == null)
{
ChildTestReporters = new ConcurrentBag <ITestReporter>();
}
ChildTestReporters.Add(newTestNode);
LastTestNode = newTestNode;
return(newTestNode);
}
public void Start(StartTestItemRequest request)
{
if (StartTask != null)
{
throw new InsufficientExecutionStackException("The test item is already scheduled for starting.");
}
var parentStartTask = ParentTestReporter?.StartTask ?? LaunchReporter.StartTask;
StartTask = parentStartTask.ContinueWith(async(pt) =>
{
if (pt.IsFaulted)
{
throw pt.Exception;
}
request.LaunchId = LaunchReporter.LaunchInfo.Id;
if (ParentTestReporter == null)
{
if (request.StartTime < LaunchReporter.LaunchInfo.StartTime)
{
request.StartTime = LaunchReporter.LaunchInfo.StartTime;
}
var id = (await _service.StartTestItemAsync(request)).Id;
TestInfo = new TestItem
{
Id = id
};
}
else
{
if (request.StartTime < ParentTestReporter.TestInfo.StartTime)
{
request.StartTime = ParentTestReporter.TestInfo.StartTime;
}
var id = (await _service.StartTestItemAsync(ParentTestReporter.TestInfo.Id, request)).Id;
TestInfo = new TestItem
{
Id = id
};
}
TestInfo.StartTime = request.StartTime;
}).Unwrap();
}
public ITestReporter StartChildTestReporter(StartTestItemRequest request)
{
var newTestNode = new TestReporter(_service, LaunchReporter, this);
newTestNode.Start(request);
if (ChildTestReporters == null)
{
ChildTestReporters = new ConcurrentBag <ITestReporter>();
}
ChildTestReporters.Add(newTestNode);
(LaunchReporter as LaunchReporter).LastTestNode = newTestNode;
return(newTestNode);
}
public ITestReporter StartChildTestReporter(StartTestItemRequest request)
{
TraceLogger.Verbose("Scheduling request to start new test item");
var newTestNode = new TestReporter(_service, LaunchReporter, this, request);
if (ChildTestReporters == null)
{
ChildTestReporters = new ConcurrentBag <ITestReporter>();
}
ChildTestReporters.Add(newTestNode);
(LaunchReporter as LaunchReporter).LastTestNode = newTestNode;
return(newTestNode);
}
public void TraceStep(StepInstance stepInstance, bool showAdditionalArguments)
{
if (CurrentScenarioId != null)
{
var description = stepInstance.MultilineTextArgument;
if (stepInstance.TableArgument != null)
{
description = string.Empty;
foreach (var header in stepInstance.TableArgument.Header)
{
description += "| " + header + "	";
}
description += "|\n";
foreach (var row in stepInstance.TableArgument.Rows)
{
foreach (var value in row.Values)
{
description += "| " + value + "	";
}
description += "|\n";
}
}
var request = new StartTestItemRequest
{
LaunchId = Bridge.Context.LaunchId,
Name = stepInstance.Keyword + " " + stepInstance.Text,
Description = description,
StartTime = DateTime.UtcNow,
Type = TestItemType.Step
};
var eventArg = new TestItemStartedEventArgs(Bridge.Service, request);
if (BeforeStepStarted != null)
{
BeforeStepStarted(this, eventArg);
}
if (!eventArg.Canceled)
{
CurrentStepId = Bridge.Service.StartTestItem(CurrentScenarioId, request).Id;
Bridge.Context.TestId = CurrentStepId;
if (AfterStepStarted != null)
{
AfterStepStarted(this, new TestItemStartedEventArgs(Bridge.Service, request, CurrentStepId));
}
}
}
}
