public static SkipResult Skip(string _line, DateTime _dateTime)
{
const string prefix = SKIPPED + " ";
string trimmed = "";
if (_line.StartsWith(prefix))
{
trimmed = _line.Replace(prefix, "");
}
else
{
Debug.Fail("skip prefix not supported!");
}
string[] split = trimmed.Split(new[] { "] because [" }, StringSplitOptions.None);
Debug.Assert(split.Length == 2);
string source = split[0].TrimStart('[');
//var destination = split[1].TrimEnd(']');
SkipResult result = new SkipResult(source, _line, _dateTime);
return(result);
}
CaseResult Skip(Case @case, string reason)
{
var result = new SkipResult(@case, reason);
listener.CaseSkipped(result);
return(result);
}
CaseResult Skip(Case @case)
{
var result = new SkipResult(@case, GetSkipReason(@case));
listener.CaseSkipped(result);
return(result);
}
public void ToXmlTwiceDoesNotDoubleCounts()
{
XmlDocument doc = new XmlDocument();
doc.LoadXml("<foo/>");
XmlNode parentNode = doc.ChildNodes[0];
ClassResult classResult = new ClassResult(typeof(object));
PassedResult passedResult = new PassedResult("foo", "bar", null, null);
passedResult.ExecutionTime = 1.1;
FailedResult failedResult = new FailedResult("foo", "bar", null, null, "extype", "message", "stack");
failedResult.ExecutionTime = 2.2;
SkipResult skipResult = new SkipResult("foo", "bar", null, null, "reason");
classResult.Add(passedResult);
classResult.Add(failedResult);
classResult.Add(skipResult);
XmlNode resultNode1 = classResult.ToXml(parentNode);
XmlNode resultNode2 = classResult.ToXml(parentNode);
Assert.Equal(resultNode1.Attributes["time"].Value, resultNode2.Attributes["time"].Value);
Assert.Equal(resultNode1.Attributes["total"].Value, resultNode2.Attributes["total"].Value);
Assert.Equal(resultNode1.Attributes["passed"].Value, resultNode2.Attributes["passed"].Value);
Assert.Equal(resultNode1.Attributes["failed"].Value, resultNode2.Attributes["failed"].Value);
Assert.Equal(resultNode1.Attributes["skipped"].Value, resultNode2.Attributes["skipped"].Value);
Assert.Equal(resultNode1.SelectNodes("test").Count, resultNode2.SelectNodes("test").Count);
}
public void ToXml_WithChildren()
{
XmlDocument doc = new XmlDocument();
doc.LoadXml("<foo/>");
XmlNode parentNode = doc.ChildNodes[0];
PassedResult passedResult = new PassedResult("foo", "bar", null, null);
passedResult.ExecutionTime = 1.1;
FailedResult failedResult = new FailedResult("foo", "bar", null, null, "extype", "message", "stack");
failedResult.ExecutionTime = 2.2;
SkipResult skipResult = new SkipResult("foo", "bar", null, null, "reason");
ClassResult classResult = new ClassResult(typeof(object));
classResult.Add(passedResult);
classResult.Add(failedResult);
classResult.Add(skipResult);
AssemblyResult assemblyResult = new AssemblyResult(filename);
assemblyResult.Add(classResult);
XmlNode resultNode = assemblyResult.ToXml(parentNode);
Assert.Equal("3.300", resultNode.Attributes["time"].Value);
Assert.Equal("3", resultNode.Attributes["total"].Value);
Assert.Equal("1", resultNode.Attributes["passed"].Value);
Assert.Equal("1", resultNode.Attributes["failed"].Value);
Assert.Equal("1", resultNode.Attributes["skipped"].Value);
Assert.Single(resultNode.SelectNodes("class"));
}
public void CaseSkipped(SkipResult result)
{
tdnet.TestFinished(new TestResult
{
Name = result.Case.Name,
State = TestState.Ignored
});
}
public void CaseSkipped(SkipResult result)
{
tdnet.TestFinished(new TestResult
{
Name = result.Case.Name,
State = TestState.Ignored
});
}
public void CaseSkipped(SkipResult result)
{
tdnet.TestFinished(new TestResult
{
Name = result.Name,
State = TestState.Ignored,
Message = result.SkipReason
});
}
public void CaseSkipped(SkipResult result)
{
log.RecordResult(new TestResult(TestCase(result.MethodGroup))
{
DisplayName = result.Name,
Outcome = Map(CaseStatus.Passed),
ComputerName = Environment.MachineName
});
}
public EzSkipResult(
SkipResult result
)
{
if (result.item != null)
{
Item = new EzAwait(result.item);
}
StampSheet = result.stampSheet;
StampSheetEncryptionKeyId = result.stampSheetEncryptionKeyId;
}
public void SkipReturnSkipResult()
{
MethodInfo method = typeof(SpyStub).GetMethod("Skip");
SkipCommand command = new SkipCommand(Reflector.Wrap(method), null, "reason");
MethodResult result = command.Execute(new SpyStub());
SkipResult skipResult = Assert.IsType <SkipResult>(result);
Assert.Equal("reason", skipResult.Reason);
}
public ConventionResult Run(Convention convention, Listener listener, params Type[] candidateTypes)
{
var executionPlan = new ExecutionPlan(convention);
var conventionResult = new ConventionResult(convention.GetType().FullName);
foreach (var testClass in convention.Classes.Filter(candidateTypes))
{
var classResult = new ClassResult(testClass.FullName);
var methods = convention.Methods.Filter(testClass);
var cases = methods.SelectMany(method => CasesForMethod(convention, method)).ToArray();
var casesBySkipState = cases.ToLookup(convention.CaseExecution.SkipPredicate);
var casesToSkip = casesBySkipState[true];
var casesToExecute = casesBySkipState[false];
foreach (var @case in casesToSkip)
{
var skipResult = new SkipResult(@case, convention.CaseExecution.SkipReasonProvider(@case));
listener.CaseSkipped(skipResult);
classResult.Add(CaseResult.Skipped(skipResult.Case.Name, skipResult.Reason));
}
var caseExecutions = casesToExecute.Select(@case => new CaseExecution(@case)).ToArray();
if (caseExecutions.Any())
{
convention.ClassExecution.OrderCases(caseExecutions);
var classExecution = new ClassExecution(executionPlan, testClass, caseExecutions);
executionPlan.Execute(classExecution);
foreach (var caseExecution in caseExecutions)
{
if (caseExecution.Exceptions.Any())
{
var failResult = new FailResult(caseExecution, convention.HideExceptionDetails);
listener.CaseFailed(failResult);
classResult.Add(CaseResult.Failed(failResult.Case.Name, failResult.Duration, failResult.ExceptionSummary));
}
else
{
var passResult = new PassResult(caseExecution);
listener.CasePassed(passResult);
classResult.Add(CaseResult.Passed(passResult.Case.Name, passResult.Duration));
}
}
}
conventionResult.Add(classResult);
}
return conventionResult;
}
private static IMessageSinkMessage Map(SkipResult result)
{
if (result == null)
{
return(null);
}
var message = A.Fake <ITestSkipped>();
A.CallTo(() => message.Test.DisplayName).Returns(result.DisplayName);
A.CallTo(() => message.Reason).Returns(result.Reason);
return(message);
}
public ConventionResult Execute(Listener listener, params Type[] candidateTypes)
{
var conventionResult = new ConventionResult(GetType().FullName);
foreach (var testClass in Classes.Filter(candidateTypes))
{
var classResult = new ClassResult(testClass.FullName);
var methods = Methods.Filter(testClass);
var cases = methods.SelectMany(method => CasesForMethod(testClass, method)).ToArray();
var casesBySkipState = cases.ToLookup(CaseExecution.SkipPredicate);
var casesToSkip = casesBySkipState[true];
var casesToExecute = casesBySkipState[false];
foreach (var @case in casesToSkip)
{
var skipResult = new SkipResult(@case, CaseExecution.SkipReasonProvider(@case));
listener.CaseSkipped(skipResult);
classResult.Add(CaseResult.Skipped(skipResult.Case.Name, skipResult.Reason));
}
var caseExecutions = casesToExecute.Select(@case => new CaseExecution(@case)).ToArray();
if (caseExecutions.Any())
{
ClassExecution.Behavior.Execute(testClass, this, caseExecutions);
foreach (var caseExecution in caseExecutions)
{
if (caseExecution.Exceptions.Any())
{
var failResult = new FailResult(caseExecution, AssertionLibrary);
listener.CaseFailed(failResult);
classResult.Add(CaseResult.Failed(failResult.Case.Name, failResult.Duration, failResult.ExceptionSummary));
}
else
{
var passResult = new PassResult(caseExecution);
listener.CasePassed(passResult);
classResult.Add(CaseResult.Passed(passResult.Case.Name, passResult.Duration));
}
}
}
conventionResult.Add(classResult);
}
return(conventionResult);
}
public void CaseSkipped(SkipResult result)
{
var caseResult = (CaseResult)result;
Post(new TestResult
{
testFramework = "Fixie",
fileName = fileName,
testName = caseResult.Name,
outcome = "Skipped",
durationMilliseconds = caseResult.Duration.TotalMilliseconds.ToString("0"),
StdOut = caseResult.Output,
ErrorMessage = caseResult.SkipReason,
ErrorStackTrace = null
});
}
public void ToXml()
{
XmlDocument doc = new XmlDocument();
doc.LoadXml("<foo/>");
XmlNode parentNode = doc.ChildNodes[0];
MethodInfo method = typeof(StubClass).GetMethod("StubMethod");
SkipResult skipResult = new SkipResult(Reflector.Wrap(method), null, "the reason");
XmlNode resultNode = skipResult.ToXml(parentNode);
Assert.Equal("Skip", resultNode.Attributes["result"].Value);
Assert.Null(resultNode.Attributes["success"]);
Assert.Null(resultNode.Attributes["time"]);
Assert.Null(resultNode.SelectSingleNode("failure"));
Assert.Equal("the reason", resultNode.SelectSingleNode("reason/message").InnerText);
}
public void CaseSkipped(SkipResult result)
{
if (isParameterized)
{
var newTask = new TestCaseTask(result.Case.Name, nodeRunner.CurrentTask.AssemblyLocation);
server.CreateDynamicElement(newTask);
nodeRunner.AddTask(newTask);
}
var task = nodeRunner.CurrentTask;
task.CloseTask(TaskResult.Skipped, result.Case.Name);
if (isParameterized)
{
nodeRunner.FinishCurrentTask(task);
}
}
public void CaseSkipped(SkipResult result)
{
}
public void CaseSkipped(SkipResult result)
{
log.Add(string.Format("{0} skipped{1}", result.Name, result.SkipReason == null ? "." : ": " + result.SkipReason));
}
public void CaseSkipped(SkipResult result)
{
Message("testIgnored name='{0}' message='{1}'", result.Name, result.SkipReason);
}
public void CaseSkipped(SkipResult result)
{
Message("testIgnored name='{0}'", result.Case.Name);
}
public void CaseSkipped(SkipResult result)
{
log.Add(string.Format("{0} skipped{1}", result.Case.Name, result.Reason == null ? "." : ": " + result.Reason));
}
public void CaseSkipped(SkipResult result) => Log.Add(result);
protected async override Task <JObject[]> ExecuteAsync(AsyncCodeActivityContext context)
{
var ignoreErrors = IgnoreErrors.Get(context);
var encrypt = EncryptFields.Get(context);
if (encrypt == null)
{
encrypt = "";
}
var collection = Collection.Get(context);
if (string.IsNullOrEmpty(collection))
{
collection = "entities";
}
var type = Type.Get(context);
var uniqueness = Uniqueness.Get(context);
// JObject[] result = null;
var results = new List <JObject>();
var items = Items.Get(context);
foreach (var o in items)
{
JObject result = null;
if (o.GetType() != typeof(JObject))
{
var t = Task.Factory.StartNew(() =>
{
result = JObject.FromObject(o);
});
t.Wait();
}
else
{
result = (JObject)o;
}
if (!string.IsNullOrEmpty(encrypt))
{
result["_encrypt"] = encrypt;
}
var name = result.GetValue("name", StringComparison.OrdinalIgnoreCase)?.Value <string>();
result["name"] = name;
if (!string.IsNullOrEmpty(type))
{
result["_type"] = type;
}
results.Add(result);
}
var _result = await global.webSocketClient.InsertOrUpdateMany(collection, 1, false, uniqueness, SkipResult.Get(context), results.ToArray());
System.Windows.Forms.Application.DoEvents();
return(_result);
}
public void CaseSkipped(SkipResult result)
{
using (Foreground.Yellow)
Console.WriteLine("Test '{0}' skipped{1}", result.Case.Name, result.Reason == null ? null : ": " + result.Reason);
}
public void CaseSkipped(SkipResult result)
{
Message("testIgnored name='{0}'", result.Name);
}
public void CaseSkipped(SkipResult result)
{
using (Foreground.Yellow)
Console.WriteLine("Test '{0}' skipped{1}", result.Name, result.SkipReason == null ? null : ": " + result.SkipReason);
}
public void CaseSkipped(SkipResult result)
{
var optionalReason = result.SkipReason == null ? null : ": " + result.SkipReason;
log.Add($"{result.Name} skipped{optionalReason}");
}
