testfixtures | A library for preparing test data from yaml files in Rust | Database library

Most important concept in the Gradle java-test-fixtures plugin is stated in their documentation:

[this plugin] will automatically create a testFixtures source set, in which you can write your test fixtures. Test fixtures are configured so that:

• they can see the main source set classes
• test sources can see the test fixtures classes

This plugin will indeed create the following dependencies: main <-- testFixtures , and testFixtures <-- test

In your case, testFixtures module should automatically depend on main sources, and also on main dependencies declared in api scope ( com.my.extenal.project:1.0)

See a similar example in a valid sample project here https://github.com/mricciuti/so-64133013 :

• Simpsons class has access to Person class from main module
• TestHelpers class has access to main dependencies declared in api configuration

Note that testFixtures will not inherit dependencies from the test module: if you need to use such libraries in this module (eg. JUnit, Mockito, ...) you will need to declare explicit dependency , using testFixturesImplementation or testFixturesApi configuration.

See example in core-module

If fixed this using the java-platform plugin.

Platform:

my solution involved using unittest.mock.patch:

My understanding is that ProjectBuilder is more for unit-like tests. So with what you have, you should only be asserting that a task named iwillfailyou exists, is of a certain type, and has the correct configuration.

The order of execution in this case is strictly defined by NUnit.

Base class TestFixtureSetUp will always execute first, the the derived class TestFixtureSetUp. TestFixtureTearDown methods execute in the reverse order: derived class first followed by bsse class.

Note that TestFixtureSetUp and TestFixtureTearDown are used in earlier releases of NUnit. In more recent versions use OneTimeSetUp and OneTimeTearDown instead. The order of execution remains the same.

You're missing the multiple threads. TransactionScope uses thread local storage. So you should be constructing, using and disposing of it all on one thread. Quoting the documentation:

You should also use the TransactionScope and DependentTransaction class for applications that require the use of the same transaction across multiple function calls or multiple thread calls.

So if you want to use TransactionScope in a thread-safe manner you need to use DependentTransaction. See here for an example on how to do so safely.

Edit

You can also use TransactionScopeAsyncFlowOption.Enabled when constructing the scope, which will prevent TLS and allow scope to flow through async/await calls.

Be aware the default is TransactionScopeAsyncFlowOption.Suppress.

The --test command-line option is used to construct a filter, which determines which tests are run. It doesn't affect order - no command-line options have to do with order. NUnit applies the created filter to the tests as it examines them, deciding one test at a time whether it should be executed.

Neither the order of the options nor the order in which NUnit examines the tests has any connection to the order in which they are executed. The execution order is determined by:

1. Any OrderAttributes you use in your tests.
2. If no such attributes are used, the order is unspecified. (*)

You can specify [Order(n)] on any fixture or method. Those items with an OrderAttribute execute first, starting with the lowest value of n. If you are running tests in parallel, the order doesn't guarantee that following tests will not start while the first test is running. It's up to you to ensure you don't run such tests in parallel.

See the docs as well: https://github.com/nunit/docs/wiki/Order-Attribute

*Note: some people use the alphabetical order of tests. Some versions of NUnit, in some environments use that ordering. It's not guaranteed by NUnit, so it's not a good idea to rely on it.

So I've found a workaround:

Add a new configuration:

The xUnit documentation suggests putting code like this in the constructor:

xUnit.net creates a new instance of the test class for every test that is run, so any code which is placed into the constructor of the test class will be run for every single test.

xUnit documentation: Shared context between tests