How to perform JUnit testing on a class that uses interfaces not yet implemented as method parameters?

I can't figure out how to perform Junit testing on a class that uses an interface not yet implemented as method parameters. I don't know the implementation of the interface so i can't implement it.

For example I have this interface

public interface Command{
     public void execute();
     ....
} 

and class that uses the interface as method parameters.

public class Manager{
    List<Command> listCommands = new List<Command>();

    public void storeCommand(Command command){
       listCommands.add(command);
    }
}

I read online one solution could be to use mockito to mock the implementation of the interfaces but i'm not sure.

Thanks!

Yes, you can mock an implementation of your interface using mockito like this :

Command mockedCommand = Mockito.mock(Command.class)

Then you can start mocking every method of your interface that will be used in your tests specifying what it shall return.

First of all, get yourself familiar with mocking concept in the Unit Testing context, as by asking this question, you demonstrate, that you are not.

Then choose some mocking Framework to stick with. Mockito is a good, and probably the most popular one.

Finally, I will not (can not) teach you all the mocking features you can leverage with this framework, but this is one example of how you mock your type (be it an interface or class), and how you configure mocked instance to make it behave like you want it to behave:

import static org.mockito.Mockito.*;

class YourTestFixture {

    @Test
    public void yourTest()  {
        //create mock
        Command commandMock = mock(Command.class);

        //configure execute() method's return value
        when(commandMock.execute()).thenReturn("your expected value");

        //your assertions..

    }
}

Now, every time you invoke .execute() on that particular instance (commandMock), it will consistently be returning "your expected value".

Note, that you can make it throw an exception, or return null.. or just do anything you would like it to do, but the returning object/value must be of a type (or subtype) of whatever method declares to be returning.

Note, that in your example:

public class Manager{
    List<Command> listCommands = new List<Command>();

    public void storeCommand(Command command) {
        listCommands.add(command);
    }
}

you are not even using any method invocation on the command parameter. So, you can simply mock your interface as explained above.