fix conflicts

2019-05-10 23:22:52 +03:00
parent ba8fce515b 01492d1674
commit 6f7ebf8574
1803 changed files with 33727 additions and 6129 deletions
@@ -0,0 +1 @@
+/report-*.json
@@ -1,2 +1,3 @@
 ### Relevant Articles:
- 
+
+- [Get the Path of the /src/test/resources Directory in JUnit](https://www.baeldung.com/junit-src-test-resources-directory-path)
@@ -16,11 +16,55 @@
    </parent>

    <dependencies>
+        <dependency>
+            <groupId>org.junit.platform</groupId>
+            <artifactId>junit-platform-engine</artifactId>
+            <version>${junit.platform.version}</version>
+        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-params</artifactId>
            <version>${junit.jupiter.version}</version>
        </dependency>
+        <dependency>
+            <groupId>org.junit.platform</groupId>
+            <artifactId>junit-platform-runner</artifactId>
+            <version>${junit.platform.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.vintage</groupId>
+            <artifactId>junit-vintage-engine</artifactId>
+            <version>${junit.vintage.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-migrationsupport</artifactId>
+            <version>${junit.vintage.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.h2database</groupId>
+            <artifactId>h2</artifactId>
+            <version>${h2.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-test</artifactId>
+            <version>${spring.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-context</artifactId>
+            <version>${spring.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-orm</artifactId>
+            <version>${spring.version}</version>
+        </dependency>
    </dependencies>

    <build>
@@ -29,13 +73,87 @@
                <directory>src/test/resources</directory>
                <filtering>true</filtering>
            </resource>
+            <resource>
+                <directory>src/main/resources</directory>
+                <filtering>true</filtering>
+            </resource>
+
        </resources>
    </build>

+    <profiles>
+        <profile>
+            <id>filtering</id>
+            <activation>
+                <activeByDefault>false</activeByDefault>
+            </activation>
+            <build>
+                <plugins>
+                    <plugin>
+                        <artifactId>maven-surefire-plugin</artifactId>
+                        <version>${maven-surefire-plugin.version}</version>
+                        <dependencies>
+                            <dependency>
+                                <groupId>org.junit.platform</groupId>
+                                <artifactId>junit-platform-surefire-provider</artifactId>
+                                <version>${junit.platform.version}</version>
+                            </dependency>
+                        </dependencies>
+                        <configuration>
+                            <excludes>
+                                **/*IntegrationTest.java
+                            </excludes>
+                        </configuration>
+                    </plugin>
+                </plugins>
+            </build>
+        </profile>
+        <profile>
+            <id>category</id>
+            <activation>
+                <activeByDefault>false</activeByDefault>
+            </activation>
+            <build>
+                <plugins>
+                    <plugin>
+                        <artifactId>maven-surefire-plugin</artifactId>
+                        <version>${maven-surefire-plugin.version}</version>
+                        <configuration>
+                            <groups>com.baeldung.categories.UnitTest</groups>
+                            <excludedGroups>com.baeldung.categories.IntegrationTest</excludedGroups>
+                        </configuration>
+                    </plugin>
+                </plugins>
+            </build>
+        </profile>
+        <profile>
+            <id>tags</id>
+            <activation>
+                <activeByDefault>false</activeByDefault>
+            </activation>
+            <build>
+                <plugins>
+                    <plugin>
+                        <artifactId>maven-surefire-plugin</artifactId>
+                        <version>${maven-surefire-plugin.version}</version>
+                        <configuration>
+                            <groups>UnitTest</groups>
+                            <excludedGroups>IntegrationTest</excludedGroups>
+                        </configuration>
+                    </plugin>
+                </plugins>
+            </build>
+        </profile>
+
+    </profiles>
+    
    <properties>
-        <junit.jupiter.version>5.3.1</junit.jupiter.version>
+        <junit.jupiter.version>5.4.2</junit.jupiter.version>
        <junit.platform.version>1.2.0</junit.platform.version>
        <junit.vintage.version>5.2.0</junit.vintage.version>
+        <h2.version>1.4.196</h2.version>
+        <spring.version>5.0.6.RELEASE</spring.version>
+        <maven-surefire-plugin.version>2.21.0</maven-surefire-plugin.version>
    </properties>

 </project>
@@ -0,0 +1,44 @@
+package com.baeldung.junit.tags.example;
+
+public class Employee {
+    private int id;
+
+    private String firstName;
+
+    private String lastName;
+
+    private String address;
+
+    public int getId() {
+        return id;
+    }
+
+    public void setId(final int id) {
+        this.id = id;
+    }
+
+    public String getFirstName() {
+        return firstName;
+    }
+
+    public void setFirstName(final String firstName) {
+        this.firstName = firstName;
+    }
+
+    public String getLastName() {
+        return lastName;
+    }
+
+    public void setLastName(final String lastName) {
+        this.lastName = lastName;
+    }
+
+    public String getAddress() {
+        return address;
+    }
+
+    public void setAddress(final String address) {
+        this.address = address;
+    }
+
+}
@@ -0,0 +1,58 @@
+package com.baeldung.junit.tags.example;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
+import org.springframework.jdbc.core.simple.SimpleJdbcInsert;
+import org.springframework.stereotype.Repository;
+
+import javax.sql.DataSource;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@Repository
+public class EmployeeDAO {
+
+    private JdbcTemplate jdbcTemplate;
+
+    private NamedParameterJdbcTemplate namedParameterJdbcTemplate;
+
+    private SimpleJdbcInsert simpleJdbcInsert;
+
+    @Autowired
+    public void setDataSource(final DataSource dataSource) {
+        jdbcTemplate = new JdbcTemplate(dataSource);
+
+        namedParameterJdbcTemplate = new NamedParameterJdbcTemplate(dataSource);
+        simpleJdbcInsert = new SimpleJdbcInsert(dataSource).withTableName("EMPLOYEE");
+
+    }
+
+    public int getCountOfEmployees() {
+        return jdbcTemplate.queryForObject("SELECT COUNT(*) FROM EMPLOYEE", Integer.class);
+    }
+
+    public List<Employee> getAllEmployees() {
+        return jdbcTemplate.query("SELECT * FROM EMPLOYEE", new EmployeeRowMapper());
+    }
+
+    public int addEmplyee(final int id) {
+        return jdbcTemplate.update("INSERT INTO EMPLOYEE VALUES (?, ?, ?, ?)", id, "Bill", "Gates", "USA");
+    }
+
+    public int addEmplyeeUsingSimpelJdbcInsert(final Employee emp) {
+        final Map<String, Object> parameters = new HashMap<String, Object>();
+        parameters.put("ID", emp.getId());
+        parameters.put("FIRST_NAME", emp.getFirstName());
+        parameters.put("LAST_NAME", emp.getLastName());
+        parameters.put("ADDRESS", emp.getAddress());
+
+        return simpleJdbcInsert.execute(parameters);
+    }
+
+    // for testing
+    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
+        this.jdbcTemplate = jdbcTemplate;
+    }
+}
@@ -0,0 +1,21 @@
+package com.baeldung.junit.tags.example;
+
+import org.springframework.jdbc.core.RowMapper;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+public class EmployeeRowMapper implements RowMapper<Employee> {
+
+    @Override
+    public Employee mapRow(final ResultSet rs, final int rowNum) throws SQLException {
+        final Employee employee = new Employee();
+
+        employee.setId(rs.getInt("ID"));
+        employee.setFirstName(rs.getString("FIRST_NAME"));
+        employee.setLastName(rs.getString("LAST_NAME"));
+        employee.setAddress(rs.getString("ADDRESS"));
+
+        return employee;
+    }
+}
@@ -0,0 +1,19 @@
+package com.baeldung.junit.tags.example;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseBuilder;
+import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType;
+
+import javax.sql.DataSource;
+
+@Configuration
+@ComponentScan("com.baeldung.junit.tags.example")
+public class SpringJdbcConfig {
+
+    @Bean
+    public DataSource dataSource() {
+        return new EmbeddedDatabaseBuilder().setType(EmbeddedDatabaseType.H2).addScript("classpath:jdbc/schema.sql").addScript("classpath:jdbc/test-data.sql").build();
+    }
+}
@@ -0,0 +1,7 @@
+CREATE TABLE EMPLOYEE
+(
+	ID int  NOT NULL PRIMARY KEY,
+	FIRST_NAME varchar(255),
+	LAST_NAME varchar(255),
+	ADDRESS varchar(255),
+);
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
+    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
+		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd"
+>
+
+    <bean id="employeeDao" class="org.baeldung.jdbc.EmployeeDAO">
+        <property name="dataSource" ref="dataSource"/>
+    </bean>
+
+    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
+        <property name="driverClassName" value="${jdbc.driverClassName}"/>
+        <property name="url" value="${jdbc.url}"/>
+        <property name="username" value="${jdbc.username}"/>
+        <property name="password" value="${jdbc.password}"/>
+    </bean>
+
+    <context:property-placeholder location="jdbc.properties"/>
+</beans>
@@ -0,0 +1,7 @@
+INSERT INTO EMPLOYEE VALUES (1, 'James', 'Gosling', 'Canada');
+
+INSERT INTO EMPLOYEE VALUES (2, 'Donald', 'Knuth', 'USA');
+
+INSERT INTO EMPLOYEE VALUES (3, 'Linus', 'Torvalds', 'Finland');
+
+INSERT INTO EMPLOYEE VALUES (4, 'Dennis', 'Ritchie', 'USA');
@@ -0,0 +1,66 @@
+package com.baeldung.categories;
+
+import com.baeldung.junit.tags.example.Employee;
+import com.baeldung.junit.tags.example.EmployeeDAO;
+import com.baeldung.junit.tags.example.SpringJdbcConfig;
+import org.hamcrest.CoreMatchers;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.support.AnnotationConfigContextLoader;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = { SpringJdbcConfig.class }, loader = AnnotationConfigContextLoader.class)
+public class EmployeeDAOCategoryIntegrationTest {
+
+    @Autowired
+    private EmployeeDAO employeeDao;
+
+    @Mock
+    private JdbcTemplate jdbcTemplate;
+    private EmployeeDAO employeeDAO;
+
+    @Before
+    public void setup() {
+        MockitoAnnotations.initMocks(this);
+        employeeDAO = new EmployeeDAO();
+        employeeDAO.setJdbcTemplate(jdbcTemplate);
+    }
+
+    @Test
+    @Category(IntegrationTest.class)
+    public void testAddEmployeeUsingSimpelJdbcInsert() {
+        final Employee emp = new Employee();
+        emp.setId(12);
+        emp.setFirstName("testFirstName");
+        emp.setLastName("testLastName");
+        emp.setAddress("testAddress");
+
+        Assert.assertEquals(employeeDao.addEmplyeeUsingSimpelJdbcInsert(emp), 1);
+    }
+
+    @Test
+    @Category(UnitTest.class)
+    public void givenNumberOfEmployeeWhenCountEmployeeThenCountMatch() {
+
+        // given
+        Mockito.when(jdbcTemplate.queryForObject(Mockito.any(String.class), Mockito.eq(Integer.class)))
+                .thenReturn(1);
+
+        // when
+        int countOfEmployees = employeeDAO.getCountOfEmployees();
+
+        // then
+        Assert.assertThat(countOfEmployees, CoreMatchers.is(1));
+    }
+
+}
@@ -0,0 +1,12 @@
+package com.baeldung.categories;
+
+import org.junit.experimental.categories.Categories;
+import org.junit.experimental.categories.Categories.IncludeCategory;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite.SuiteClasses;
+
+@RunWith(Categories.class)
+@IncludeCategory(UnitTest.class)
+@SuiteClasses(EmployeeDAOCategoryIntegrationTest.class)
+public class EmployeeDAOUnitTestSuite {
+}
@@ -0,0 +1,4 @@
+package com.baeldung.categories;
+
+public interface IntegrationTest {
+}
@@ -0,0 +1,4 @@
+package com.baeldung.categories;
+
+public interface UnitTest {
+}
@@ -0,0 +1,41 @@
+package com.baeldung.example;
+
+import com.baeldung.junit.tags.example.Employee;
+import com.baeldung.junit.tags.example.EmployeeDAO;
+import com.baeldung.junit.tags.example.SpringJdbcConfig;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.support.AnnotationConfigContextLoader;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = { SpringJdbcConfig.class }, loader = AnnotationConfigContextLoader.class)
+public class EmployeeDAOIntegrationTest {
+
+    @Autowired
+    private EmployeeDAO employeeDao;
+
+    @Test
+    public void testQueryMethod() {
+        Assert.assertEquals(employeeDao.getAllEmployees().size(), 4);
+    }
+
+    @Test
+    public void testUpdateMethod() {
+        Assert.assertEquals(employeeDao.addEmplyee(5), 1);
+    }
+
+    @Test
+    public void testAddEmployeeUsingSimpelJdbcInsert() {
+        final Employee emp = new Employee();
+        emp.setId(11);
+        emp.setFirstName("testFirstName");
+        emp.setLastName("testLastName");
+        emp.setAddress("testAddress");
+
+        Assert.assertEquals(employeeDao.addEmplyeeUsingSimpelJdbcInsert(emp), 1);
+    }
+}
@@ -0,0 +1,40 @@
+package com.baeldung.example;
+
+import com.baeldung.junit.tags.example.EmployeeDAO;
+import org.hamcrest.CoreMatchers;
+import org.junit.Assert;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.springframework.jdbc.core.JdbcTemplate;
+
+public class EmployeeUnitTest {
+
+    @Mock
+    private JdbcTemplate jdbcTemplate;
+
+    private EmployeeDAO employeeDAO;
+
+    @BeforeEach
+    public void setup() {
+        MockitoAnnotations.initMocks(this);
+        employeeDAO = new EmployeeDAO();
+        employeeDAO.setJdbcTemplate(jdbcTemplate);
+    }
+
+    @Test
+    public void givenNumberOfEmployeeWhenCountEmployeeThenCountMatch() {
+
+        // given
+        Mockito.when(jdbcTemplate.queryForObject(Mockito.any(String.class), Mockito.eq(Integer.class)))
+            .thenReturn(1);
+
+        // when
+        int countOfEmployees = employeeDAO.getCountOfEmployees();
+
+        // then
+        Assert.assertThat(countOfEmployees, CoreMatchers.is(1));
+    }
+}
@@ -0,0 +1,65 @@
+package com.baeldung.tags;
+
+import com.baeldung.junit.tags.example.Employee;
+import com.baeldung.junit.tags.example.EmployeeDAO;
+import com.baeldung.junit.tags.example.SpringJdbcConfig;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit.jupiter.SpringExtension;
+import org.springframework.test.context.support.AnnotationConfigContextLoader;
+
+@ExtendWith(SpringExtension.class)
+@ContextConfiguration(classes = { SpringJdbcConfig.class }, loader = AnnotationConfigContextLoader.class)
+public class EmployeeDAOIntegrationTest {
+
+    @Autowired
+    private EmployeeDAO employeeDao;
+
+    @Mock
+    private JdbcTemplate jdbcTemplate;
+    private EmployeeDAO employeeDAO;
+
+    @BeforeEach
+    public void setup() {
+        MockitoAnnotations.initMocks(this);
+        employeeDAO = new EmployeeDAO();
+        employeeDAO.setJdbcTemplate(jdbcTemplate);
+    }
+
+    @Test
+    @Tag("IntegrationTest")
+    public void testAddEmployeeUsingSimpelJdbcInsert() {
+        final Employee emp = new Employee();
+        emp.setId(12);
+        emp.setFirstName("testFirstName");
+        emp.setLastName("testLastName");
+        emp.setAddress("testAddress");
+
+        Assertions.assertEquals(employeeDao.addEmplyeeUsingSimpelJdbcInsert(emp), 1);
+    }
+
+    @Test
+    @Tag("UnitTest")
+    public void givenNumberOfEmployeeWhenCountEmployeeThenCountMatch() {
+
+        // given
+        Mockito.when(jdbcTemplate.queryForObject(Mockito.any(String.class), Mockito.eq(Integer.class)))
+                .thenReturn(1);
+
+        // when
+        int countOfEmployees = employeeDAO.getCountOfEmployees();
+
+        // then
+        Assertions.assertEquals(1, countOfEmployees);
+    }
+
+}
@@ -0,0 +1,12 @@
+package com.baeldung.tags;
+
+import org.junit.platform.runner.JUnitPlatform;
+import org.junit.platform.suite.api.IncludeTags;
+import org.junit.platform.suite.api.SelectPackages;
+import org.junit.runner.RunWith;
+
+@RunWith(JUnitPlatform.class)
+@SelectPackages("com.baeldung.tags")
+@IncludeTags("UnitTest")
+public class EmployeeDAOTestSuite {
+}
@@ -128,7 +128,6 @@
        <junit.platform.version>1.4.2</junit.platform.version>
        <junit.vintage.version>5.4.2</junit.vintage.version>
        <log4j2.version>2.8.2</log4j2.version>
-        <h2.version>1.4.196</h2.version>
        <powermock.version>2.0.0-RC.1</powermock.version>
        <maven-surefire-plugin.version>2.21.0</maven-surefire-plugin.version>
        <exec-maven-plugin.version>1.6.0</exec-maven-plugin.version>
@@ -2,7 +2,4 @@

 - [Mockito’s Java 8 Features](http://www.baeldung.com/mockito-2-java-8)
 - [Lazy Verification with Mockito 2](http://www.baeldung.com/mockito-2-lazy-verification)
-
-## Mockito 2 and Java 8 Tips
-
-Examples on how to leverage Java 8 new features with Mockito version 2
+- [Mockito Strict Stubbing and The UnnecessaryStubbingException](https://www.baeldung.com/mockito-unnecessary-stubbing-exception)
@@ -0,0 +1,51 @@
+package com.baeldung.mockito.misusing;
+
+import org.hamcrest.Matchers;
+import org.junit.Assert;
+import org.junit.rules.MethodRule;
+import org.junit.runners.model.FrameworkMethod;
+import org.junit.runners.model.Statement;
+
+public class ExpectedTestFailureRule implements MethodRule {
+
+    private final MethodRule testedRule;
+    private FailureAssert failureAssert = null;
+
+    public ExpectedTestFailureRule(MethodRule testedRule) {
+        this.testedRule = testedRule;
+    }
+
+    @Override
+    public Statement apply(final Statement base, final FrameworkMethod method, final Object target) {
+        return new Statement() {
+            public void evaluate() throws Throwable {
+                try {
+                    testedRule.apply(base, method, target)
+                        .evaluate();
+                } catch (Throwable t) {
+                    if (failureAssert == null) {
+                        throw t;
+                    }
+                    failureAssert.doAssert(t);
+                    return;
+                }
+            }
+        };
+    }
+
+    @SuppressWarnings("unchecked")
+    public void expectedFailure(final Class<? extends Throwable> expected) {
+        FailureAssert assertion = t -> Assert.assertThat(t, Matchers.isA((Class<Throwable>) expected));
+        this.expectedFailure(assertion);
+    }
+
+    private void expectedFailure(FailureAssert failureAssert) {
+        this.failureAssert = failureAssert;
+    }
+
+    @FunctionalInterface
+    private interface FailureAssert {
+        abstract void doAssert(Throwable t);
+    }
+
+}
@@ -0,0 +1,52 @@
+package com.baeldung.mockito.misusing;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.Mockito.lenient;
+import static org.mockito.Mockito.when;
+
+import java.util.ArrayList;
+
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.mockito.exceptions.misusing.UnnecessaryStubbingException;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.quality.Strictness;
+
+public class MockitoUnecessaryStubUnitTest {
+
+    @Rule
+    public ExpectedTestFailureRule rule = new ExpectedTestFailureRule(MockitoJUnit.rule()
+        .strictness(Strictness.STRICT_STUBS));
+
+    @Mock
+    private ArrayList<String> mockList;
+
+    @Before
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+    }
+
+    @Test
+    public void givenUnusedStub_whenInvokingGetThenThrowUnnecessaryStubbingException() {
+        rule.expectedFailure(UnnecessaryStubbingException.class);
+
+        when(mockList.add("one")).thenReturn(true);
+        when(mockList.get(anyInt())).thenReturn("hello");
+
+        assertEquals("List should contain hello", "hello", mockList.get(1));
+    }
+
+    @Test
+    public void givenLenientdStub_whenInvokingGetThenDontThrowUnnecessaryStubbingException() {
+        lenient().when(mockList.add("one"))
+            .thenReturn(true);
+        when(mockList.get(anyInt())).thenReturn("hello");
+
+        assertEquals("List should contain hello", "hello", mockList.get(1));
+    }
+
+}
@@ -197,8 +197,6 @@
        <jackson.version>2.9.7</jackson.version>
        <jackson-coreutils.version>1.8</jackson-coreutils.version>
        <guava.version>19.0</guava.version>
-
-        <javax.servlet-api.version>3.1.0</javax.servlet-api.version>
        <servlet-api.version>2.5</servlet-api.version>
        <javax.mail.version>1.4.7</javax.mail.version>
        <jetty.version>9.4.0.v20161208</jetty.version>
@@ -149,9 +149,6 @@
    </build>

    <properties>
-        <!-- marshalling -->
-        <jackson.version>2.9.7</jackson.version>
-
        <!-- util -->
        <guava.version>19.0</guava.version>
        <commons-lang3.version>3.5</commons-lang3.version>
@@ -103,7 +103,6 @@
        <junit.platform.version>1.0.1</junit.platform.version>
        <junit.vintage.version>4.12.1</junit.vintage.version>
        <log4j2.version>2.8.2</log4j2.version>
-        <h2.version>1.4.196</h2.version>
        <mockito.version>2.21.0</mockito.version>
        <spring.version>5.0.1.RELEASE</spring.version>
        <testcontainers.version>1.7.2</testcontainers.version>