Why exceptions in MethodContext.Build are not caught?

We noticed a behavior while working at our NSpec VS adapter, with a spec class similar to the following:

class SomeSpec: nspec
{
  // ...
  void Given_a_method_context()
  {
    // while building some data used in this context, an exception is thrown
    InputData badInput = null;
    FixtureData expected = new FixtureData(badInput);  // <-- Boom
    FixtureData actual = null;

    before = () => { ... };
    act = () => { actual = ... };

    it["Should test actual Vs expected"] = () => actual.Should().Be(expected);
  }
}

we noticed that, for interested assembly/binary, the whole discovery phase in our adapter fails (gracefully) with 0 found results for the whole binary, even if only that context in that class exposed a problem.

The trigger seems to be an exception thrown when running the main body of method context (note: context body, not the body of before, act, … hooks). In such a scenario:

1. NSpec.Domain.MethodContext.Build() catches exception only to log a message to console which, incidentally, is not visible when running from within VS test adapter. Then it just throws exception again
2. As there’s no other catch, the whole call chain up to NSpec.Domain.ContextCollection.Build() fails as well
3. At this point, our adapter had invoked such code remotely so to run on test assembly. Uncaught exception causes a TargetInvocationException in adapter code, which gets caught and logged in VS test runner output window. But this also causes the whole test discovery on that assembly to fail.

We were thinking whether there’s a way to only make fail a specific context (the one that threw) and its descendants. Any idea? Thanks

[BrainCrumbz]

Here’s how it could look like: https://github.com/mattflo/NSpec/tree/feat/bare-code-failing-spec

[BrainCrumbz]

Not sure we need to do it for anything that takes in a () => {}. Because only “bare” methods are the culprit.

Totally right. I was thinking about “bare” code run within a sub-context context[...] = () => { ... } that is not a hook, e.g.:

// ...
context["Given some sub-context"] = () =>
{
  doSomethingThatThrows();  // <-- This makes the whole sub-context building fail

  before = () => { };

  it[...] = () => { };
};

Does that makes sense?