mocks | Tiny collection of mocks for faking a network connection | Mock library

Put your method call into a closure and evaluate the closure during each iteration:

Do not use @InjectMocks

Try something like this

This is not the answer to the question you wrote but I guess it could be the answer you need:

From the code you posted there is no reason to mock classA. In the @Before annotated method you even instantiate the objects by calling the constructor. This means those objects (objAWithIsEnableAsTrue and objAWithIsEnableAsFalse) are not even mocked in your tests.

In order to make your tests more clear, I would suggest moving the setup logic of your tests into the test methods themselves.

Your test has two issues:

You say that when mockIterator.hasNext() is called, it should first return true and then false. The issue here is that your test method iterates over mockList and therefore needs to call mockIterator.hasNext() and then uses the first, the true, value. The tested method #prune() then also attempts to iterate the list, but will only get the second, the false, value, thus skipping the loop. You don't need the loop in your test method, so you can and should remove it.

The second issue is mockProduct.setProductAnalyticsIdentifier(99999999). mockProduct is a mock, so the methods don't do anything when not configured for example via when(mockProduct...).... So the value 99999999 is not stored anywhere and #getProductAnalyticsIdentifier() in the test returns 0, the default value. What you actually want to do is to configure the getter method, for example with:

Actually, that's up to you, but I would recommend putting them in .gitignore.

Mocks are not sensitive information like access keys or some internal configurations, so no worries from this point of view. However, storing generated files in source control could possibly lead to merge conflicts at some point while working with the team and resolving conflicts on generated files - well, that's strange and not what you want.

Since the files could be generated, there is no need to add the *.mocks.dart to the source control repository - you should ignore them. Just make sure that you extend your project's ReadMe file with documentation on how to generate these mocks so all the team members would know what's happening when tests could not be run. One disadvantage of this is that your team members would probably need to regenerate these mocks every single time before running the tests on newly pulled code, but that's a drawback you should accept with any code generation.

In my experience, I am using packages like json_serializable, freezed, generating Dart files for localizations, assets using flutter_gen - these also require generating files from source code (e.g. *.g.dart and *.freezed.dart ones). Those files are not stored in source control. Also, when using CI/CD tools for the project, you can just trigger the flutter pub run build_runner build command (or any other that generates your files) before building the code and everything should be good to go.

Maybe using the __mock__ directory can help you.

from the docs:

Manual mocks are defined by writing a module in a mocks/ subdirectory immediately adjacent to the module. For example, to mock a module called user in the models directory, create a file called user.js and put it in the models/mocks directory.

You can also mock modules from the node_modules directory.

Manual Mocks

Someone contributed a PR to add this post the 1.0 release, so you should read this thread: https://github.com/intuit/karate/issues/1566

And you should be able to test and provide feedback on 1.1.0.RC2

Of course if you can contribute code, nothing like it :)

Are you able to do service = new AuthService()? It doesn't complain that it needs an argument?

Try doing:

to cover the callback argument of custom hook, you just need to configure a mock by implementing the function like that: