public TestCaseDTO[] DiscoverTests()
{
var conv = new DefaultConventions().Initialize();
var finder = new SpecFinder(SandboxedAssembly.GetTypes(), "");
var cb = new ContextBuilder(finder, new Tags());
var dia = new DiaSession(SandboxedAssembly.Location);
var examples = cb.Contexts()
.Build()
.AllContexts()
.SelectMany(context => context.Examples);
var result = from example in examples
let method = GetAction(example)
let location = dia.GetNavigationData(method.DeclaringType.FullName, method.Name)
?? new DiaNavigationData(null, 0, 0)
select new TestCaseDTO
{
Name = example.FullName(),
FileName = location.FileName,
LineNumber = location.MinLineNumber,
Traits = example.Tags.ToArray()
};
return result.ToArray();
}
public void debug()
{
//the specification class you want to test
//this can be a regular expression
var testClassYouWantToDebug = "describe_SomeTest";
//initialize NSpec's specfinder
var finder = new SpecFinder(
Assembly.GetExecutingAssembly().Location,
new Reflector(),
testClassYouWantToDebug);
//initialize NSpec's builder
var builder = new ContextBuilder(
finder,
new DefaultConventions());
//initialize the root context
var contexts = builder.Contexts();
//build the tests
contexts.Build();
//run the tests that were found
contexts.Run();
//print the output
new ConsoleFormatter().Write(contexts);
//assert that there aren't any failures
contexts.Failures().Count().should_be(0);
}
Test GetAssemblyTest(IAssemblyInfo assembly, Test parentTest, Version frameworkVersion, bool populateRecursively)
{
NSpecAssemblyTest assemblyTest;
if (!assemblyTests.TryGetValue(assembly, out assemblyTest))
{
assemblyTest = new NSpecAssemblyTest(assembly.Name, assembly, frameworkVersion);
assemblyTest.Kind = TestKinds.Assembly;
ModelUtils.PopulateMetadataFromAssembly(assembly, assemblyTest.Metadata);
string frameworkName = String.Format("NSpec v{0}", frameworkVersion);
assemblyTest.Metadata.SetValue(MetadataKeys.Framework, frameworkName);
assemblyTest.Metadata.SetValue(MetadataKeys.File, assembly.Path);
assemblyTest.Kind = TestKinds.Assembly;
parentTest.AddChild(assemblyTest);
assemblyTests.Add(assembly, assemblyTest);
}
if (populateRecursively)
{
var reflector = new NSpec.Domain.Reflector(assembly.Path);
var finder = new SpecFinder(reflector);
var builder = new ContextBuilder(finder, new DefaultConventions());
ContextCollection contexts = builder.Contexts();
contexts.Build();
contexts.Do(c => assemblyTest.AddChild(this.CreateGallioTestFrom(c)));
}
return assemblyTest;
}
public ContextCollection Run()
{
var reflector = new Reflector(this.dll);
var finder = new SpecFinder(reflector);
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();
if(contexts.AnyTaggedWithFocus())
{
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();
}
return runner.Run(contexts);
}
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 };
}
protected when_running_specs Run(params Type[] types)
{
//if (types.Count() == 1) tags = types.First().Name;
this.types = types;
builder = new ContextBuilder(new SpecFinder(types), new Tags().Parse(tags), new DefaultConventions());
runner = new ContextRunner(builder, formatter, failFast);
contextCollection = builder.Contexts();
contextCollection.Build();
classContext = contextCollection
.AllContexts()
.Where(c => c is ClassContext)
.Cast<ClassContext>()
.FirstOrDefault(c => types.Contains(c.type));
methodContext = contextCollection.AllContexts().FirstOrDefault(c => c is MethodContext);
runner.Run(contextCollection);
return this;
}
static void Main(string[] args)
{
if(args.Length==0)
{
ShowUsage();
return;
}
try
{
var classFilter = args.Length > 1 ? args[1] : "";
var finder = new SpecFinder(args[0], new Reflector(), classFilter);
//var finder = new SpecFinder(@"C:\Development\GameTrader\GameTrader.Specs\bin\Debug\GameTrader.Specs.dll", new Reflector(), "desribe_AuthenticationController");
//var finder = new SpecFinder(@"C:\users\amir\nspec\samplespecs\bin\debug\samplespecs.dll", new Reflector(), "class_level_before");
var builder = new ContextBuilder(finder);
new ContextRunner(builder).Run();
//new ContextRunner(new ContextBuilder(new SpecFinder(@"C:\Development\GameTrader\GameTrader.Specs\bin\Debug\GameTrader.Specs.dll", new Reflector()))).Run();
}
catch (Exception e)
{
//hopefully this is handled before here, but if not, this is better than crashing the runner
Console.WriteLine(e);
}
}
public ContextCollection Run()
{
var finder = new SpecFinder(this.dll, new Reflector());
var builder = new ContextBuilder(finder, new Tags().Parse(Tags), new DefaultConventions());
var runner = new ContextRunner(builder, Formatter, failFast);
return runner.Run(builder.Contexts().Build());
}
public void setup()
{
finder = MockRepository.GenerateMock<ISpecFinder>();
finder.Stub(f => f.SpecClasses()).IgnoreArguments().Return(new[] { typeof(child), typeof(parent), typeof(sibling) });
builder = new ContextBuilder(finder);
builder.Contexts();
}
public void setup()
{
var finder = MockRepository.GenerateMock<ISpecFinder>();
var builder = new ContextBuilder(finder);
classContext = new Context("class");
builder.BuildMethodContexts(classContext, typeof(SpecClass));
}
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 void Execute(IReceiveTestResult observer)
{
this.observer = observer;
var finder = new SpecFinder(SandboxedAssembly.GetTypes(), "");
var cb = new ContextBuilder(finder, new Tags());
cb.Contexts()
.Build()
.ForEach(context => context.Run(this, false));
}
public void setup_base()
{
finder = MockRepository.GenerateMock<ISpecFinder>();
typesForFinder = new List<Type>();
finder.Stub(f => f.SpecClasses()).IgnoreArguments().Return(typesForFinder);
DefaultConventions conventions = new DefaultConventions();
conventions.Initialize();
builder = new ContextBuilder(finder, conventions);
}
public void setup()
{
reflector = MockRepository.GenerateMock<IReflector>();
RhinoMocksExtensions.Stub(reflector, r => r.GetTypesFrom("")).IgnoreArguments().Return(new[] { typeof(SpecClass) });
var contextBuilder = new ContextBuilder(new SpecFinder("", reflector), new DefaultConventions());
classContext = contextBuilder.Contexts().First();
classContext.Build();
classContext.Run(new SilentLiveFormatter(), failFast: false);
}
public void it_runs_things_in_a_strange_order()
{
SpecFinder finder = new SpecFinder(new[] { typeof(before_all_sampleSpec) });
var builder = new ContextBuilder(finder, new DefaultConventions());
var runner = new ContextRunner(builder, new SilentLiveFormatter(), false);
contexts = runner.Run(builder.Contexts().Build());
var instance = contexts.Find("before all sampleSpec").GetInstance() as before_all_sampleSpec;
CollectionAssert.AreEqual(new[] { "messed_up_context", "before_all", "another_messed_up_context", "a_regular_context_method" }, instance.sequence);
}
public void debug()
{
var testClassYouWantToDebug = "";
var finder = new SpecFinder(
Assembly.GetExecutingAssembly().Location,
new Reflector(),
testClassYouWantToDebug);
var builder = new ContextBuilder(
finder,
new DefaultConventions());
new ContextRunner(builder, new ConsoleFormatter()).Run();
}
public void Execute(IReceiveTestResult observer, string[] testNames)
{
this.observer = observer;
var examples = new HashSet<string>(testNames);
var finder = new SpecFinder(SandboxedAssembly.GetTypes(), "");
var cb = new ContextBuilder(finder, new Tags());
cb.Contexts()
.Build()
.SelectMany(c => c.AllExamples())
.Where(example => examples.Contains(example.FullName()))
.ForEach(example => example.Context.Run(this, false, example.Context.GetInstance()));
}
//[Test]
public void debug()
{
var tagOrClassName = "";
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 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
}
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);
}
public void AllTests()
{
var finder = new ShimFinder(typeof(RunnerShim).Assembly.GetTypes());
var builder = new ContextBuilder(finder, new DefaultConventions());
var runner = new ContextRunner(builder);
runner.Run();
var results = runner.Failures();
if (results.Count() != 0) {
foreach (var result in results)
Assert.Fail(String.Format("{0} failed because of {1}", result.Spec, result.Exception));
} else {
} Assert.Pass("All " + runner.Examples().Count() + " passed");
}
public void debug()
{
//the specification class you want to test
//this can be a regular expression
var testClassYouWantToDebug = "NSpecSpecs.ClassContextBug.Child";
//initialize NSpec's specfinder
var finder = new SpecFinder(
Assembly.GetExecutingAssembly().Location,
new Reflector(),
testClassYouWantToDebug );
//initialize NSpec's builder
var builder = new ContextBuilder( finder, new DefaultConventions() );
//this line runs the tests you specified in the filter
TestFormatter formatter = new TestFormatter();
new ContextRunner( builder, formatter ).Run();
Context grandParent = formatter.Contexts[0];
Assert.That( grandParent.Name, Is.EqualTo( "Grand Parent" ) );
Assert.That( grandParent.Contexts.Count, Is.EqualTo( 2 ) );
Assert.That( grandParent.Contexts[0].Name, Is.EqualTo( "Grand Parent Context" ) );
Assert.That( grandParent.Contexts[1].Name, Is.EqualTo( "Parent" ) );
Assert.That( grandParent.Contexts[0].Examples[0].Spec, Is.EqualTo( "TestValue should be \"Grand Parent!!!\"" ) );
Assert.That( grandParent.Contexts[0].Examples[0].ExampleLevelException, Is.Null );
Assert.That( grandParent.Contexts[0].Examples[0].Pending, Is.False );
Context parent = formatter.Contexts[0].Contexts[1];
Assert.That( parent.Name, Is.EqualTo( "Parent" ) );
Assert.That( parent.Contexts.Count, Is.EqualTo( 2 ) );
Assert.That( parent.Contexts[0].Name, Is.EqualTo( "Parent Context" ) );
Assert.That( parent.Contexts[1].Name, Is.EqualTo( "Child" ) );
Assert.That( parent.Contexts[0].Examples[0].Spec, Is.EqualTo( "TestValue should be \"Grand Parent.Parent!!!@@@\"" ) );
Assert.That( parent.Contexts[0].Examples[0].ExampleLevelException, Is.Null );
Assert.That( parent.Contexts[0].Examples[0].Pending, Is.False );
Context child = formatter.Contexts[0].Contexts[1].Contexts[1];
Assert.That( child.Name, Is.EqualTo( "Child" ) );
Assert.That( child.Contexts.Count, Is.EqualTo( 1 ) );
Assert.That( child.Contexts[0].Name, Is.EqualTo( "Child Context" ) );
Assert.That( child.Contexts[0].Examples[0].Spec, Is.EqualTo( "TestValue should be \"Grand Parent.Parent.Child!!!@@@###\"" ) );
Assert.That( child.Contexts[0].Examples[0].ExampleLevelException, Is.Null );
Assert.That( child.Contexts[0].Examples[0].Pending, Is.False );
}
public void setup()
{
var finder = MockRepository.GenerateMock<ISpecFinder>();
finder.Stub(f => f.Except).Return(new SpecFinder().Except);
finder.Stub(s => s.SpecClasses()).Return(new[] { typeof(SpecClass) });
var builder = new ContextBuilder(finder);
classContext = new Context("class");
classContext.Type = typeof(SpecClass);
builder.BuildMethodContexts(classContext, typeof(SpecClass));
classContext.Run();
}
public void Execute(IReceiveTestResult observer, string[] testNames)
{
this.observer = observer;
var selectedExamples = new HashSet<string>(testNames);
var finder = new SpecFinder(SandboxedAssembly.GetTypes(), "");
var cb = new ContextBuilder(finder, new Tags());
ContextCollection contextCollection = cb.Contexts().Build();
FilterOutNonSelectedExamples(contextCollection, selectedExamples);
contextCollection.ForEach(context =>
{
context.Run(this, false);
});
}
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());
}
protected void Run(Type type)
{
var finder = new SpecFinder(new[] { type });
var builder = new ContextBuilder(finder, new DefaultConventions());
var contexts = builder.Contexts();
contexts.Build();
contexts.Run();
classContext = contexts
.AllContexts()
.Select(c => c as ClassContext)
.First(c => c.type == type);
methodContext = contexts.AllContexts().First(c => c is MethodContext);
}
public void debug()
{
//the specification class you want to test
//this can be a regular expression
var testClassYouWantToDebug = "describe_SomeTest";
//initialize NSpec's specfinder
var finder = new SpecFinder(
Assembly.GetExecutingAssembly().Location,
new Reflector(),
testClassYouWantToDebug);
//initialize NSpec's builder
var builder = new ContextBuilder(
finder,
new DefaultConventions());
//this line runs the tests you specified in the filter
new ContextRunner(builder, new ConsoleFormatter()).Run();
}
protected when_running_specs Init(Type[] types, string tags = null, bool failFast = false)
{
this.types = types;
builder = new ContextBuilder(new SpecFinder(types), new Tags().Parse(tags), new DefaultConventions());
runner = new ContextRunner(builder, formatter, failFast);
contextCollection = builder.Contexts();
contextCollection.Build();
classContext = contextCollection
.AllContexts()
.Where(c => c is ClassContext)
.Cast<ClassContext>()
.FirstOrDefault(c => types.Contains(c.type));
methodContext = contextCollection.AllContexts().FirstOrDefault(c => c is MethodContext);
return this;
}
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);
}
}
public ContextRunner(ContextBuilder builder, IFormatter formatter)
{
this.builder = builder;
this.formatter = formatter;
}
public ContextRunner(ContextBuilder builder)
{
this.builder = builder;
}
public ContextRunner(ContextBuilder builder, IFormatter formatter, bool failFast)
{
this.failFast = failFast;
this.builder = builder;
this.formatter = formatter;
}
