List of Classes and Methods of org.mockito.internal.handler package of Mockito Framework

The parentheses are poorly placed.

You need to use:

doThrow(new Exception()).when(mockedObject).methodReturningVoid(...);
                                          ^

and NOT use:

doThrow(new Exception()).when(mockedObject.methodReturningVoid(...));
                                                                   ^

This is explained in the documentation

@InjectMocks is a Mockito mechanism for injecting declared fields in the test class into matching fields in the class under test. It doesn't require the class under test to be a Spring component.

@Autowired is Spring's annotation for autowiring a bean into a production, non-test class.

If you wanted to leverage the @Autowired annotations in the class under test, another approach would be to use springockito which allows you to declare mock beans so that they will be autowired into the class under test the same way that Spring would autowire the bean. But typically that's not necessary.

You can refactor the code to call the super method in some other method like:

      class foo extends JApplet(){

       public void destroy(){
          callSuperDestroy();
       }
       public void callSuperDestroy(){
           super.destroy();
       }}

And then verify:

verify(foo).callSuperDestroy();

First, create a ResponseEntity object:

HttpHeaders header = new HttpHeaders();
header.setContentType(MediaType.APPLICATION_JSON);

ResponseEntity<?> responseEntity = new ResponseEntity<>(
    "some response body",
    header, 
    HttpStatus.OK
);

Then build a mock to return the responseEntity object:

when(restC.SomeMethod(client)).thenReturn(responseEntity);

Point to pay attention:

Avoid to use ResponseEntity inside @Service class. You should use ResponseEntity in @RestController class.

And you can Inject your @Service class using @Autowired annotation, like:

@RestController
public class YourControllerClass {

    @Autowired
    private YourServiceClass yourServiceClass;

Or using constructor, like:

@RestController
public class YourControllerClass {

    private YourServiceClass yourServiceClass;

    public YourControllerClass(YourServiceClass yourServiceClass) {
        this.yourServiceClass= yourServiceClass;
    }

So:

@Service class will handle business or data objects and @RestController class will handle Response and Request objects. Thus we have Single Responsibility principle.

Some nice links:

• Spring MVC - Using RequestEntity and ResponseEntity
• How do I mock a REST template
• Building REST services with Spring
• Understanding the Single Responsibility Principle

Hope this helps!

Mockito can handle chained stubs:

Foo mock = mock(Foo.class, RETURNS_DEEP_STUBS);

// note that we're stubbing a chain of methods here: getBar().getName()
when(mock.getBar().getName()).thenReturn("deep");

// note that we're chaining method calls: getBar().getName()
assertEquals("deep", mock.getBar().getName());

AFAIK, the first method in the chain returns a mock, which is set up to return your value on the second chained method call.

Mockito's authors note that this should only be used for legacy code. A better thing to do otherwise is to push the behavior into your CacheContext and provide any information it needs to do the job itself. The amount of information you're pulling from CacheContext suggests that your class has feature envy.

this one did the trick

@Test
void willReturnTheInjectedUUIDValueTest() {

    UUID uuid = UUID.randomUUID();
    Gateway gateway = Mockito.mock(Gateway.class);

    doAnswer(ans -> {
        Consumer<UUID> callback = (Consumer<UUID>) ans.getArgument(1);
        callback.accept(uuid);
        return null;
    }).when(gateway).process(Mockito.any(String.class), Mockito.any(Consumer.class));

    Interactor.builder().gateway(gateway).build().process("ignored", s -> {
        Assertions.assertEquals(uuid.toString(), s);
    });
}

This answer was the hint -> https://stackoverflow.com/a/47226374/148397

I suggest to use Mockito Framework it is very easy to use and understand.

@Mock
private EntityManager entityManager; 

If you want to use any method that belongs to entityManager, you should call.

Mockito.when(METHOD_EXPECTED_TO_BE_CALLED).thenReturn(AnyObjectoftheReturnType);

When you run your test, any call previosly declared in the Mockito.when for the EntityManager will return the value put in the declaration..

Read full documentation here.

https://static.javadoc.io/org.mockito/mockito-core/2.12.0/org/mockito/Mockito.html#stubbing

You could refactor MyClass so that it uses dependency injection. Instead of having it create an AnythingPerformerClass instance you could pass in an instance of the class to the constructor of MyClass like so :

class MyClass {

   private final AnythingPerformerClass clazz;

   MyClass(AnythingPerformerClass clazz) {
      this.clazz = clazz;
   }

   public boolean performAnything() {         
     return clazz.doSomething();        
   }
}

You can then pass in the mock implementation in the unit test

@Test
public void testPerformAnything() throws Exception {
   AnythingPerformerClass mockedPerformer = Mockito.mock(AnythingPerformerClass.class);
   MyClass clazz = new MyClass(mockedPerformer);
   ...
}

Alternatively, if your AnythingPerformerClass contains state then you could pass a AnythingPerformerClassBuilder to the constructor.

This is a known issue with PowerMock (see, e.g., bug 597). In short, if you replace the rule module with the rule-agent module, it should do the trick. I.e., replace this requirement:

<dependency>
    <groupId>org.powermock</groupId>
    <artifactId>powermock-module-junit4-rule</artifactId>
    <version>${powermock-version}</version>
    <scope>test</scope>
</dependency>

With:

<dependency>
    <groupId>org.powermock</groupId>
    <artifactId>powermock-module-junit4-rule-agent</artifactId>
    <version>${powermock-version}</version>
    <scope>test</scope>
</dependency>