private static async void Run()
{
if (HttpListener.IsSupported)
{
await Task.Run(() =>
{
listener = new HttpListener();
listener.Start();
IsRunning = true;
listener.Prefixes.Add($"http://*:{Port}/");
onServerStart?.Invoke(new ServerEventData(null, null, null, $"Server started on port {Port}"));
if (UsingHttps)
{
listener.Prefixes.Add($"https://*:{HttpsPort}");
onServerStart?.Invoke(new ServerEventData(null, null, null, $"Https Server started on port {HttpsPort}"));
}
while (IsRunning)
{
try
{
var context = listener.GetContext();
ContextRunner.RunWith(context);
}
catch (HttpListenerException)
{
}
}
}, cancellationToken.Token);
}
else
{
throw new ServerNotSupportedException($"HttpListener is not supported on {Environment.OSVersion.VersionString}");
}
}
public NSpecResultModel Run()
{
var reflector = new Reflector(this._dllFile);
var finder = new SpecFinder(reflector);
var builder = new ContextBuilder(finder, new Tags().Parse(_tags), new DefaultConventions());
var runner = new ContextRunner(builder, _formatter, false);
var contexts = builder.Contexts().Build();
if (contexts.AnyTaggedWithFocus())
{
builder = new ContextBuilder(finder, new Tags().Parse(NSpec.Domain.Tags.Focus), new DefaultConventions());
runner = new ContextRunner(builder, _formatter, true);
}
var contextCollection = runner.Run(contexts);
var serializableContextCollection = new SerializableContextCollection();
BuildResponse(serializableContextCollection, contextCollection);
return(new NSpecResultModel {
ContextCollection = serializableContextCollection, Output = _formatter.GetFormattedString
});
}
public void output_verification(Type output, Type [] testClasses, string tags)
{
var finder = new SpecFinder(testClasses, "");
var tagsFilter = new Tags().Parse(tags);
var builder = new ContextBuilder(finder, tagsFilter, new DefaultConventions());
var consoleFormatter = new ConsoleFormatter();
var actual = new System.Collections.Generic.List <string>();
consoleFormatter.WriteLineDelegate = actual.Add;
var runner = new ContextRunner(tagsFilter, consoleFormatter, false);
runner.Run(builder.Contexts().Build());
var expectedString = GetExpectedOutput(output)
.ScrubNewLines()
.ScrubStackTrace()
.ScrubTimes();
var actualString = String.Join("\n", actual)
.ScrubStackTrace()
.Trim()
.ScrubTimes();
actualString.Should().Be(expectedString);
}
protected when_running_specs Run(params Type[] types)
{
this.types = types;
var tagsFilter = new Tags().Parse(tags);
builder = new ContextBuilder(new SpecFinder(types), tagsFilter, new DefaultConventions());
contextCollection = builder.Contexts();
contextCollection.Build();
classContext = contextCollection
.AllContexts()
.Where(c => c is ClassContext)
.Cast <ClassContext>()
.FirstOrDefault(c => types.Contains(c.SpecType));
methodContext = contextCollection.AllContexts().FirstOrDefault(c => c is MethodContext);
runner = new ContextRunner(tagsFilter, formatter, failFast);
runner.Run(contextCollection);
return(this);
}
public void RealizeSpec(ExampleContext ctx)
{
// If we haven't run the examples yet, do so now. TestSuite is null in case of setup failure. All
// my attempts to run examples individually have failed (e.g. due to nested contexts or the use of
// beforeAll), so run everything and use the individual test cases only for reporting.
if (!_hasRun && ctx.TestSuite != null)
{
_hasRun = true;
var runner = new ContextRunner(ctx.TagsFilter, new NoopFormatter(), false);
runner.Run(ctx.TestSuite);
}
var example = ctx.Example;
if (!example.HasRun)
{
throw new Exception("The example didn't run :-(");
}
if (example.Failed())
{
if (example.Exception != null)
{
// Use ExceptionDispatchInfo to preserve the original stack trace
var edi = ExceptionDispatchInfo.Capture(example.Exception);
edi.Throw();
}
throw new Exception("The example failed, but I don't know why :-(");
}
}
static void Main(string[] args)
{
if (args.Length == 0)
{
ShowUsage();
return;
}
try
{
var classFilter = args.Length > 1 ? args[1] : "";
var specDLL = args[0];
var domain = new NSpecDomain(specDLL + ".config");
var console = new ConsoleFormatter();
domain.Run(specDLL, classFilter, console, (dll, filter, formatter) =>
{
var finder = new SpecFinder(dll, new Reflector(), filter);
var builder = new ContextBuilder(finder, new DefaultConventions());
var runner = new ContextRunner(builder, formatter);
runner.Run();
});
}
catch (Exception e)
{
//hopefully this is handled before here, but if not, this is better than crashing the runner
Console.WriteLine(e);
}
}
private static void Debug(SpecFinder finder)
{
var builder = new ContextBuilder(finder, new DefaultConventions());
var runner = new ContextRunner(new Tags(), new ConsoleFormatter(), false);
var results = runner.Run(builder.Contexts().Build());
// assert that there aren't any failures
results.Failures().Count().Should().Be(0, "all examples passed");
}
public void debug()
{
var currentSpec = this.GetType();
var finder = new SpecFinder(new[] { currentSpec });
var builder = new ContextBuilder(finder, new Tags().Parse(currentSpec.Name), new DefaultConventions());
var runner = new ContextRunner(builder, new ConsoleFormatter(), false);
var results = runner.Run(builder.Contexts().Build());
results.Failures().Count().should_be(0);
}
public void DebugServiceSpecs()
{
const string tagOrClassName = "ServiceSpecs";
var types = GetType().Assembly.GetTypes();
var finder = new SpecFinder(types, "");
var builder = new ContextBuilder(finder, new Tags().Parse(tagOrClassName), new DefaultConventions());
var runner = new ContextRunner(builder, new ConsoleFormatter(), false);
var results = runner.Run(builder.Contexts().Build());
results.Failures().Count().should_be(0);
}
public override bool Execute(RunnerOptions options)
{
var types = Assembly.GetEntryAssembly().GetTypes();
var finder = new SpecFinder(types, options.TestClass);
var tagsFilter = new Tags().Parse(options.TagsFlag);
var builder = new ContextBuilder(finder, tagsFilter, new DefaultConventions());
var runner = new ContextRunner(tagsFilter, GetFormatter(options), false);
var results = runner.Run(builder.Contexts().Build());
return(!results.Failures().Any());
}
public void debug()
{
var currentSpec = GetType();
var finder = new SpecFinder(new[] { currentSpec });
var filter = new Tags().Parse(currentSpec.Name);
var builder = new ContextBuilder(finder, filter, new DefaultConventions());
var runner = new ContextRunner(filter, new ConsoleFormatter(), false);
var result = runner.Run(builder.Contexts().Build());
//assert that there aren't any failures
result.Failures().Count().should_be(0);
}
public static void Main(string[] args)
{
var tagOrClassName = string.Join(",", args);
var types = typeof(TestRunner).Assembly.GetTypes();
var finder = new SpecFinder(types, string.Empty);
var tagsFilter = new Tags().Parse(tagOrClassName);
var builder = new ContextBuilder(finder, tagsFilter, new DefaultConventions());
var runner = new ContextRunner(tagsFilter, new ConsoleFormatter(), false);
var results = runner.Run(builder.Contexts().Build());
Environment.Exit(results.Failures().Count());
}
public static void Run <T>(this ITestOutputHelper helper) where T : NSpec.nspec
{
var spec = typeof(T);
var finder = new SpecFinder(new[] { spec });
var tags = new Tags().Parse(spec.Name);
var builder = new ContextBuilder(finder, tags, new DefaultConventions());
var formatter = new MyFormatter(helper);
var runner = new ContextRunner(tags, formatter, false);
var contexts = builder.Contexts().Build();
var results = runner.Run(contexts);
//assert that there aren't any failures
results.Failures().Count().Should().Be(0);
}
public static void Main(string[] args)
{
var types = typeof(Program).Assembly.GetTypes();
var finder = new SpecFinder(types, "");
var tagsFilter = new Tags().Parse("");
var builder = new ContextBuilder(finder, tagsFilter, new DefaultConventions());
var runner = new ContextRunner(tagsFilter, new ConsoleFormatter(), false);
var results = runner.Run(builder.Contexts().Build());
if (results.Failures().Count() > 0)
{
Environment.Exit(1);
}
}
//[Test]
public void debug()
{
var tagOrClassName = "class_or_tag_you_want_to_debug";
var types = GetType().Assembly.GetTypes();
// OR
// var types = new Type[]{typeof(Some_Type_Containg_some_Specs)};
var finder = new SpecFinder(types, "");
var builder = new ContextBuilder(finder, new Tags().Parse(tagOrClassName), new DefaultConventions());
var runner = new ContextRunner(builder, new ConsoleFormatter(), false);
var results = runner.Run(builder.Contexts().Build());
//assert that there aren't any failures
results.Failures().Count().should_be(0);
}
public static void Main()
{
var tagOrClassName = "";
var types = typeof(Program).Assembly.GetTypes();
// OR
// var types = new Type[]{typeof(Some_Type_Containg_some_Specs)};
var finder = new SpecFinder(types, "");
var builder = new ContextBuilder(finder, new Tags().Parse(tagOrClassName), new DefaultConventions());
var runner = new ContextRunner(builder, new ConsoleFormatter(), failFast: true);
var results = runner.Run(builder.Contexts().Build());
//assert that there aren't any failures
results.Failures().Count().should_be(0);
}
public void debug()
{
var tagOrClassName = "class_or_tag_you_want_to_debug";
var types = GetType().Assembly.GetTypes();
// OR
types = new System.Type[] { typeof(StatisticsCacheServiceTest.NSpecTests.garbage_collecting_test) };
var finder = new SpecFinder(types, "");
var builder = new ContextBuilder(finder, new Tags().Parse(tagOrClassName), new DefaultConventions());
var runner = new ContextRunner(builder, new ConsoleFormatter(), false);
var results = runner.Run(builder.Contexts().Build());
//assert that there aren't any failures
results.Failures().Count().should_be(0);
}
public void run()
{
var currentSpec = GetType();
var finder = new SpecFinder(new[] { currentSpec });
var builder = new ContextBuilder(finder, new Tags().Parse(currentSpec.Name), new DefaultConventions());
var runner = new ContextRunner(builder, new ConsoleFormatter(), false);
var collection = builder.Contexts().Build();
var results = runner.Run(collection);
//assert that there aren't any failures
var failures = results.Failures();
var count = failures.Count();
count.ShouldBe(0);
// TODO: figure out how to programmatically skip, when there are pending
}
static public int Main(string[] args)
{
var tagOrClassName = String.Empty;
var types = typeof(Startup).Assembly.GetTypes();
var finder = new SpecFinder(types, "");
var tagsFilter = new Tags().Parse(tagOrClassName);
var builder = new ContextBuilder(finder, tagsFilter, new DefaultConventions());
var runner = new ContextRunner(tagsFilter, new ConsoleFormatter(), false);
var results = runner.Run(builder.Contexts().Build());
System.Console.ReadLine();
return((results.Failures().Count() > 0)
? -1
: 0);
}
protected internal void RunSpecs()
{
var types = FindSpecTypes();
var finder = new SpecFinder(types, "");
var tagsFilter = new Tags().Parse(Tags);
var builder = new ContextBuilder(finder, tagsFilter, new DefaultConventions());
var runner = new ContextRunner(tagsFilter, Formatter, FailFast);
var contexts = builder.Contexts().Build();
bool hasFocusTags = contexts.AnyTaggedWithFocus();
if (hasFocusTags)
{
tagsFilter = new Tags().Parse(NSpec.Domain.Tags.Focus);
builder = new ContextBuilder(finder, tagsFilter, new DefaultConventions());
runner = new ContextRunner(tagsFilter, Formatter, FailFast);
contexts = builder.Contexts().Build();
}
var results = runner.Run(contexts);
//assert that there aren't any failures
Assert.AreEqual <int>(0, results.Failures().Count());
var pending = results.Examples().Count(xmpl => xmpl.Pending);
if (pending != 0)
{
Assert.Inconclusive("{0} spec(s) are marked as pending.", pending);
}
if (results.Examples().Count() == 0)
{
Assert.Inconclusive("Spec count is zero.");
}
if (hasFocusTags)
{
Assert.Inconclusive("One or more specs are tagged with focus.");
}
}
public static void Main(string[] args)
{
//format();
//Tests.GenerateTestComponents.Generate();
//var tagOrClassName = "focus";
var tagOrClassName = string.Empty;
var types = Assembly.GetAssembly(typeof(describe_Entity)).GetTypes();
var finder = new SpecFinder(types, "");
var tagsFilter = new Tags().Parse(tagOrClassName);
var builder = new ContextBuilder(finder, tagsFilter, new DefaultConventions());
var runner = new ContextRunner(tagsFilter, new ConsoleFormatter(), false);
var results = runner.Run(builder.Contexts().Build());
Environment.Exit(results.Failures().Count());
}
public void output_verification(Type output, Type [] testClasses, string tags)
{
var finder = new SpecFinder(testClasses, "");
var builder = new ContextBuilder(finder, new Tags().Parse(tags), new DefaultConventions());
var consoleFormatter = new ConsoleFormatter();
var actual = new System.Collections.Generic.List <string>();
consoleFormatter.WriteLineDelegate = actual.Add;
var runner = new ContextRunner(builder, consoleFormatter, false);
runner.Run(builder.Contexts().Build());
var expectedString = ScrubStackTrace(ScrubNewLines(output.GetField("Output").GetValue(null) as string));
var actualString = ScrubStackTrace(String.Join("\n", actual)).Trim();
actualString.should_be(expectedString);
var guid = Guid.NewGuid();
}
private ContextCollection RunContexts(string tags)
{
var reflector = new Reflector(this.dll);
var finder = new SpecFinder(reflector);
var builder = new ContextBuilder(finder, new Tags().Parse(tags), new DefaultConventions());
var runner = new ContextRunner(builder, new ConsoleFormatter(), false);
var contexts = builder.Contexts().Build();
if (contexts.AnyTaggedWithFocus())
{
builder = new ContextBuilder(finder, new Tags().Parse(NSpec.Domain.Tags.Focus), new DefaultConventions());
runner = new ContextRunner(builder, new ConsoleFormatter(), false);
}
return(runner.Run(builder.Contexts().Build()));
}
//[Test]
public void debug()
{
var tagOrClassName = "Board_tests";
var types = GetType().GetTypeInfo().Assembly.GetTypes();
// OR
// var types = new Type[]{typeof(Some_Type_Containg_some_Specs)};
var finder = new SpecFinder(types, "");
var tagsFilter = new Tags().Parse(tagOrClassName);
var builder = new ContextBuilder(finder, tagsFilter, new DefaultConventions());
var runner = new ContextRunner(tagsFilter, new ConsoleFormatter(), false);
var results = runner.Run(builder.Contexts().Build());
//assert that there aren't any failures
(results.Failures().Count() == 0).ShouldBeTrue();
}
static void Main(string[] args)
{
var assemblies = new Assembly[]
{
typeof(SampleSpecs.DummyPublicClass).Assembly,
typeof(ConfigSampleSpecs.DummyPublicClass).Assembly,
typeof(SampleAsyncSpecs.DummyPublicClass).Assembly,
};
//types that should be considered for testing
var types = assemblies.SelectMany(asm => asm.GetTypes()).ToArray();
//now that we have our types, set up a finder so that NSpec
//can determine the inheritance hierarchy
var finder = new SpecFinder(types);
//create a dummy, pass-all, tags filter
var transparentTagsFilter = new Tags();
//we've got our inheritance hierarchy,
//now we can build our test tree using default conventions
var builder = new ContextBuilder(finder, new DefaultConventions());
//create the nspec runner with a
//live formatter so we get console output
var runner = new ContextRunner(transparentTagsFilter, new ConsoleFormatter(), false);
//create our final collection of concrete tests
var testCollection = builder.Contexts().Build();
//run the tests and get results (to do whatever you want with)
var results = runner.Run(testCollection);
//console write line to pause the exe
Console.WriteLine(Environment.NewLine + "Press <enter> to quit...");
Console.ReadLine();
}
public void ValidateSpec()
{
var finder = new SpecFinder(new[] { GetType() });
var builder = new ContextBuilder(finder, new DefaultConventions());
ContextCollection result = new ContextRunner(builder, new MyFormatter(), false).Run(builder.Contexts().Build());
if (result.Failures() == null)
{
Assert.Fail("***** Failed to execute some tests *****");
}
var crashes = result.AllContexts().Where(context => context.Exception != null).ToList();
if (crashes.Any())
{
throw new SpecificationException("unknown", crashes.First().Exception);
}
if (result.Failures().Any())
{
throw new SpecificationException("unknown", result.First().Exception);
}
}
/// <summary>
/// Uses reflection to handle exceptions defined in a <see cref="SimpleServer.Attributes.ConfigAttribute" />
/// decorator.
/// </summary>
/// <param name="exception">An instance of a thrown <see cref="SimpleServer.Exceptions.AbstractServerException" /></param>
/// <typeparam name="T">The implied Type of the Exception that extends
/// <see cref="SimpleServer.Exceptions.AbstractServerException" /></typeparam>
public static void HandleException(AbstractServerException exception, HttpListenerContext currentContext)
{
HandleException(exception, out ResponseEntity response);
onError?.Invoke(exception);
ContextRunner.SendResponse(response, currentContext);
}
