How to pass a variable from properties file when testing my SpringBoot app with Mockito?

SOLUTION

Instead of annotating the field "path" in DiceRollerService class with @Value("${path.to.randomizer}"), I passed the annotation to class constructor:

@Service
public class DiceRollerService {
private String path;
private final CustomHttpClient client;

@Autowired
public DiceRollerService(CustomHttpClient client, @Value("${path.to.randomizer}") String path) {
    this.client = client;
    this.path = path;
}

In this case, if I use the default constructor, the path field will be linked to the corresponding value from application properties, otherwise, if I use this specific constructor, I can pass the specific path value through it. Here is how my unit-test looks now:

@RunWith(MockitoJUnitRunner.class)
public class DiceRollerTest {
private static final String PATH_FOR_TEST = "Some URL path";
private static final int DICE_NUMBER_ONE = 2;
private static final int DICE_NUMBER_TWO = 2;

@Mock
private CustomHttpClient client;

private DiceRollerService diceRollerService;

@Before
public void init() {
    diceRollerService = new DiceRollerService(client, PATH_FOR_TEST);
}

@Test
public void testDiceRollerServiceWithCorrectPathAndBody() {
    Dices expected = new Dices(DICE_NUMBER_ONE, DICE_NUMBER_TWO);
 when(client.getResponseBodyFromClient(PATH_FOR_TEST)).thenReturn(BODY_TEST);
    Dices actual = diceRollerService.roll();
    Assert.assertEquals(expected, actual);
    verify(client).getResponseBodyFromClient(anyString());
}

INITIAL PROBLEM

I need some assistance with unit- and/or integration-testing of my small project. I have a class that has only one important method to return a Dice model:

@Service
public class DiceRollerService {
    @Value("${path.to.randomizer}")
    private String path;
    private final static int FIRST_DICE_NUMBER_POS = 0;
    private final static int SECOND_DICE_NUMBER_POS = 2;
    private final CustomHttpClient client;

public DiceRollerService(CustomHttpClient client) {
    this.client = client;
}

public Dices roll() {
    String results = client.sendGetRequest(path).body();
    int firstNumber = Integer.parseInt(String.valueOf(results.charAt(FIRST_DICE_NUMBER_POS)));
    int secondNumber = Integer.parseInt(String.valueOf(results.charAt(SECOND_DICE_NUMBER_POS)));
    return new Dices(firstNumber, secondNumber);
}

public void setPath(String path) {
    this.path = path;
}
}

As you can see, in method roll() I invoke client.sendGetRequest(path) to get a HttpResponse' body and to fetch some data from it in order to build and return a Dice model. Nothing complicated except that the actual path is located at my properties file at src/main/resources/application.properties.
Later on, i decided to add some tests for my project to check the logic:

public class DiceRollerTest {
@Mock
private CustomHttpClient client;

@InjectMocks
private DiceRollerService diceRollerService;

@Before
public void init() {
    MockitoAnnotations.initMocks(this);
}

@Test
public void test() {
    Dices expected = new Dices(2, 2);
    when(client.sendGetRequest(anyString()).body()).thenReturn("2 2 ");
    Dices actual = diceRollerService.roll();
    Assert.assertEquals(expected, actual);
    verify(client, times(1)).sendGetRequest(anyString()).body();
}
}

Unfortunately, as a result a got a nullpointer at this line: when(client.sendGetRequest(anyString()).body()).thenReturn("2 2 ");
Seems that my mock doesn't work as I expected. Here are all my dependencies :

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
        <exclusions>
            <exclusion>
                <groupId>org.junit.vintage</groupId>
                <artifactId>junit-vintage-engine</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.datatype</groupId>
        <artifactId>jackson-datatype-jsr310</artifactId>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.mockito</groupId>
        <artifactId>mockito-core</artifactId>
        <version>3.3.3</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.mockito</groupId>
        <artifactId>mockito-inline</artifactId>
        <version>3.3.3</version>
        <scope>test</scope>
    </dependency>
</dependencies>

Is there any way I can use my properties in unit-testing? How can I properly fix that? Will appreciate any piece of advice. Thanks in advance.

this line

 when(client.sendGetRequest(anyString()).body()).thenReturn("2 2 ");

is chained one step too far. You need to first stub the response of client.sendGetRequest(anyString()) before you can stub the .body() call. Something like

 when(client.sendGetRequest(anyString()).thenReturn(myMockedHttpResponse); 
 when(myMockedHttpResponse.body()).thenReturn("2 2 ");

Injecting properties is a different problem; consider putting a properties file under /src/test/resources or have a look at @TestPropertySource or refactor your properties to @ConfigurationProperties-classes and inject one of those or... Endless possibilities

Faced with this exact problem, we developed a Test Extension that solves this exact problem very gracefully via integration with @InjectMocks: https://github.com/exabrial/mockito-object-injection

<dependency>
 <groupId>com.github.exabrial</groupId>
 <artifactId>mockito-object-injection</artifactId>
 <version>2.0.2</version>
 <scope>test</scope>
</dependency>

How it works is you create a field in your test named the same thing as the target field in your service or controller under test. Mark this field with an @InjectionSource annotation, then set it to whatever you want before calling the class-under-test. Pretty simple:

@ExtendWith({ MockitoExtension.class, InjectExtension.class })
class MyControllerTest {
 @InjectMocks
 private MyController myController;
 @Mock
 private Logger log;
 @Mock
 private Authenticator auther;
 @InjectionSource
 private Boolean securityEnabled;
 
 @Test
 void testDoSomething_secEnabled() throws Exception {
  securityEnabled = Boolean.TRUE;
  myController.doSomething();
  // wahoo no NPE! Test the "if then" half of the branch
 }
 
 @Test 
 void testDoSomething_secDisabled() throws Exception {
  securityEnabled = Boolean.FALSE;
  myController.doSomething();
  // wahoo no NPE! Test the "if else" half of branch
 }
}