TestContext | Provides reusable context that helps in testing Behat | Functional Testing library

It seems that JUnit 5's parallel test execution works without problems with Spring's test context caching.

For parallel test execution, JUnit 5 seems to use a ForkJoinPool under the hood. Multiple threads can access the statically cached Spring test contexts without a problem.

On many Linux distributions, the OpenSSL configuration file is at /etc/ssl/openssl.cnf.

code add-in openssl.cnf

This was a pretty tough one. Found it easier to just call the original code and mock out certain functions than try to recreate the getHistoryForKey object manually. All this code is inspired from looking at the unit tests.

Here's the code:

WaitForAssertion() needs something that throws instead of returning false.

I crafted a small test and the results are quite surprising to say the least!

In turns out that propagating higher bits gets the best percentage when it comes to be equal to the value being calculated using floating-point, rounded and casted back to an integer:

Legend:

You do not need to call context.Update() explicitly.

When loading entity, EF remember every original values for every mapped property.

Then when you change property, EF will compare current properties with original and create appropriate update SQL only for changed properties.

For further reading: Change Tracking in EF Core

The exception message is actually pretty good here. Most of the NServiceBus exception messages are.

Interfaces IMessageSession or IEndpointInstance should not be resolved from the container to enable sending or publishing messages from within sagas or message handlers. Instead, use the context parameter on the TestController.Handle method to send or publish messages.

So first, don't mix a handler in a controller. It needs to be a separate class.

Then, don't inject IMessageSession. That interface is explicitly for things like controller actions where you don't have an existing "a message is being handled right now" and you want to send a message.

Instead, if you want to send or publish within the handler, use the context:

JUnit @BeforeClass didn't work for me. Since I'm kinda in a hurry with this, I didn't bother keep on trying to make it work. I don't really need to run the command in a pipeline at the moment, so I was completely fine in running it on IntelliJ as long as it was running in parallel.

My solution was creating a custom CLI Runner that runs the context configuration before Cucumber's CLI run method.

NUnit creates an AdhocTestContext when you try to access the test context before one has been created. The name of the (non-existent) test method in the adhoc context is AdHocTestMethod. I suspect that's what you are getting.

The adhoc context is helpful in a particular scenario, which is why we implemented it. However, it's a very rare scenario and it turns out that the adhoc context can be quite confusing in more normal cases.

You haven't posted any code to indicate where in your code you are accessing the TestContext but the most common error is to try to access it in a TestCaseSource method, which is not called during the execution of your test but a century or so (in computer time) before. :-)

Hopefully my guess helps but if not, please edit the question to include code that shows where you are creating and using a TestContext.

UPDATE:

You posted the code for your attribute as a separate question, and it indicates you are creating the adhoc TestContext in the attribute constructor. (As already explained, it is created automatically as a side-effect of your trying to access it.)

Your comment also mentions NUnit "calling" the attribute. That's a misconception. NUnit merely examines the attribute. It is created by the runtime when it is needed - that's how C# attributes work. Because of this, you should never do anything in the constructor of an attribute, which depends on any outside event... in this case the creation of a proper test context. Normally, one merely saves any constructor arguments for use later.

The fact that you have made this work in your particular case is, unfortunately, just luck. Your code is not doing anything to trigger a crash but later additions to the class it calls could do so. You would be better off to work with both NUnit and the runtime rather than against them. :-)

If you want the attribute to be "active" ... that is, to do something rather than just hold data, you should use one of NUnit's extensibility interfaces. Using these interfaces is the only way to make NUnit actually call into your code in the attribute. The interfaces for custom attributes are extensively documented at https://docs.nunit.org/articles/nunit/extending-nunit/Custom-Attributes.html.