testfixtures | mock objects that are useful when writing automated tests | Mock library

Not entirely certain but when I've had this sort of problem in the past its because I was trying to share classes from moduleA in moduleB... but as they're spring boot applications, they're packaged differently and this is impossible.

What I can say looking at the above is you've set the root project build.gradle to apply the plugin application. The root project will not be an application and subprojects are springboot applications, so this can be removed entirely. You're essentially specifying two lots of "mainClass" - one for the application plugin inherited from the root project, and another for the springboot application plugin - applied at root - but the :common project is not a springboot application.. so it needs pushing down the module hierarchy to the modules which are actually springboot applications, and not applied at the root where it will be inherited by all applications.

If you move the plugins to the relevant modules that need them, you'll find the build.graldes will become cleaner as you won't have to disable unused plugins in the sub-build.gradle definitions.

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.