create-new-unit-tests

core/pom.xml

@@ -49,6 +49,25 @@
 					</instructions>
 				</configuration>
 			</plugin>
+			<plugin>
+				<groupId>org.jacoco</groupId>
+				<artifactId>jacoco-maven-plugin</artifactId>
+				<version>0.8.6</version>
+				<executions>
+					<execution>
+						<goals>
+							<goal>prepare-agent</goal>
+						</goals>
+					</execution>
+					<execution>
+						<id>report</id>
+						<phase>prepare-package</phase>
+						<goals>
+							<goal>report</goal>
+						</goals>
+					</execution>
+				</executions>
+			</plugin>
 		</plugins>
 	</build>
 	<dependencies>
@@ -89,6 +108,13 @@
 			<version>2.8.9</version>
 			<scope>provided</scope>
 		</dependency>
+		<!--    Needs to be loaded before uber-jar caused by overridden classes    -->
+		<dependency>
+			<groupId>org.apache.sling</groupId>
+			<artifactId>org.apache.sling.testing.sling-mock-oak</artifactId>
+			<version>3.1.2-1.40.0</version>
+			<scope>test</scope>
+		</dependency>
 		<dependency>
 			<groupId>com.adobe.aem</groupId>
 			<artifactId>uber-jar</artifactId>
@@ -101,35 +127,56 @@
 			<version>1.0.0</version>
 			<scope>provided</scope>
 		</dependency>
+
+		<!-- Testing -->
 		<dependency>
-			<groupId>junit</groupId>
-			<artifactId>junit</artifactId>
-			<version>4.13.2</version>
-			<scope>compile</scope>
-		</dependency>
-		<dependency>
-			<groupId>io.wcm</groupId>
-			<artifactId>io.wcm.testing.aem-mock.junit5</artifactId>
-			<version>5.0.0</version>
+			<groupId>org.junit.jupiter</groupId>
+			<artifactId>junit-jupiter</artifactId>
 			<scope>test</scope>
 		</dependency>
 		<dependency>
 			<groupId>org.mockito</groupId>
 			<artifactId>mockito-core</artifactId>
-			<version>4.1.0</version>
 			<scope>test</scope>
 		</dependency>
 		<dependency>
 			<groupId>org.mockito</groupId>
 			<artifactId>mockito-inline</artifactId>
-			<version>4.1.0</version>
 			<scope>test</scope>
 		</dependency>
 		<dependency>
 			<groupId>org.mockito</groupId>
 			<artifactId>mockito-junit-jupiter</artifactId>
-			<version>4.1.0</version>
 			<scope>test</scope>
 		</dependency>
+		<dependency>
+			<groupId>junit-addons</groupId>
+			<artifactId>junit-addons</artifactId>
+			<scope>test</scope>
+		</dependency>
+		<dependency>
+			<groupId>io.wcm</groupId>
+			<artifactId>io.wcm.testing.aem-mock.junit5</artifactId>
+			<scope>test</scope>
+		</dependency>
+		<dependency>
+			<groupId>com.adobe.cq</groupId>
+			<artifactId>core.wcm.components.testing.aem-mock-plugin</artifactId>
+			<scope>test</scope>
+		</dependency>
+		<!-- Required to be able to support injection with @Self and @Via -->
+		<dependency>
+			<groupId>org.apache.sling</groupId>
+			<artifactId>org.apache.sling.models.impl</artifactId>
+			<version>1.4.4</version>
+			<scope>test</scope>
+		</dependency>
+		<dependency>
+			<groupId>xerces</groupId>
+			<artifactId>xercesImpl</artifactId>
+			<version>2.12.2</version>
+			<scope>test</scope>
+		</dependency>
+
 	</dependencies>
 </project>

core/src/main/java/io/wttech/stubway/StubFinderService.java

@@ -12,11 +12,8 @@
 import org.osgi.service.component.annotations.Component;
 import org.osgi.service.component.annotations.Reference;
 
-import java.util.Collections;
-import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
-import java.util.stream.Collectors;
 import java.util.stream.StreamSupport;
 
 @Component(service = StubFinderService.class)

core/src/main/java/io/wttech/stubway/collector/QueryParametersCollector.java

@@ -9,8 +9,6 @@
 
 public class QueryParametersCollector implements PropertiesCollector {
 
-	private static QueryParametersCollector instance;
-
 	private QueryParametersCollector() {}
 
 	public static PropertiesCollector create() {

core/src/main/java/io/wttech/stubway/collector/RequestBodyCollector.java

@@ -15,8 +15,6 @@
 
 public class RequestBodyCollector implements PropertiesCollector {
 
-	private static RequestBodyCollector instance;
-
 	private RequestBodyCollector() {}
 
 	public static PropertiesCollector create() {

core/src/test/java/io/wttech/stubway/StubFinderServiceTest.java

@@ -0,0 +1,178 @@
+package io.wttech.stubway;
+
+import io.wttech.stubway.matcher.Matcher;
+import io.wttech.stubway.matcher.MatchersRegistry;
+import io.wttech.stubway.request.FetchingParametersException;
+import io.wttech.stubway.request.HttpMethod;
+import io.wttech.stubway.request.MissingSupportedMethodException;
+import io.wttech.stubway.request.RequestParameters;
+import io.wttech.stubway.response.StubResponse;
+import io.wttech.stubway.stub.Stub;
+import org.apache.commons.io.IOUtils;
+import org.apache.sling.api.SlingHttpServletRequest;
+import org.apache.sling.api.request.RequestPathInfo;
+import org.apache.sling.api.resource.Resource;
+import org.apache.sling.api.resource.ResourceResolver;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockedConstruction;
+import org.mockito.Mockito;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.util.ArrayList;
+import java.util.List;
+
+@ExtendWith(MockitoExtension.class)
+class StubFinderServiceTest {
+
+    private static final String expectedMessageForNotFoundStub = "{\n"
+            + "  \"message\": \"Stub not found\",\n"
+            + "  \"statusCode\": 404\n"
+            + "}";
+
+    @InjectMocks
+    private StubFinderService stubFinderService;
+
+    @Mock
+    private MatchersRegistry matchersRegistry;
+
+    @Mock
+    private Matcher matcher;
+
+    @Mock
+    private SlingHttpServletRequest request;
+
+    @Mock
+    private RequestPathInfo requestPathInfo;
+
+    @Mock
+    private ResourceResolver resourceResolver;
+
+    @Mock
+    private Resource stubsResource;
+
+    @Mock
+    private Stub stub;
+
+    @BeforeEach
+    void setUp() {
+        String resourcePath = "/content/stubway/stubs/library/books";
+        Mockito.when(request.getRequestPathInfo()).thenReturn(requestPathInfo);
+        Mockito.when(requestPathInfo.getResourcePath()).thenReturn(resourcePath);
+        Mockito.when(request.getResourceResolver()).thenReturn(resourceResolver);
+        Mockito.when(resourceResolver.getResource(resourcePath)).thenReturn(stubsResource);
+    }
+
+    @Test
+    void getStubResponseShouldPassWhenStubNotFound() throws FetchingParametersException, IOException {
+        try (MockedConstruction<RequestParameters> mocked = Mockito.mockConstruction(RequestParameters.class)) {
+            RequestParameters requestParameters = new RequestParameters(request);
+            StubResponse stubResponse = stubFinderService.getStubResponse(request);
+            Assertions.assertEquals(404, stubResponse.getStatusCode());
+            Assertions.assertEquals(expectedMessageForNotFoundStub,
+                    IOUtils.toString(stubResponse.getInputStream(), Charset.defaultCharset()));
+        }
+    }
+
+    @Test
+    void getStubResponseShouldPassWhenRequestParamsMatch()
+            throws IOException, MissingSupportedMethodException {
+
+        prepareMocks();
+        Mockito.when(stub.getStatusCode()).thenReturn(200);
+        Mockito.when(stub.getInputStream()).thenReturn(IOUtils.toInputStream("Response message", Charset.defaultCharset()));
+        Mockito.when(stub.getMethod()).thenReturn(HttpMethod.GET);
+        Mockito.when(matchersRegistry.getMatcher(HttpMethod.GET)).thenReturn(matcher);
+
+        try (MockedConstruction<RequestParameters> mocked = Mockito.mockConstruction(RequestParameters.class,
+                (mock, context) -> {
+                    Mockito.when(mock.getMethod()).thenReturn(HttpMethod.GET);
+                    Mockito.when(matcher.matches(stub, mock)).thenReturn(true);
+                })) {
+
+            StubResponse stubResponse = stubFinderService.getStubResponse(request);
+            Assertions.assertEquals(200, stubResponse.getStatusCode());
+            Assertions.assertEquals("Response message", IOUtils.toString(stubResponse.getInputStream(), Charset.defaultCharset()));
+        }
+    }
+
+    @Test
+    void getStubResponseShouldPassWhenMethodMatchButParamsDontMatch() throws IOException, MissingSupportedMethodException {
+
+        prepareMocks();
+        Mockito.when(stub.getMethod()).thenReturn(HttpMethod.GET);
+        Mockito.when(matchersRegistry.getMatcher(HttpMethod.GET)).thenReturn(matcher);
+
+        try (MockedConstruction<RequestParameters> mocked = Mockito.mockConstruction(RequestParameters.class,
+                (mock, context) -> {
+                    Mockito.when(mock.getMethod()).thenReturn(HttpMethod.GET);
+                    Mockito.when(matcher.matches(stub, mock)).thenReturn(false);
+                })) {
+
+            StubResponse stubResponse = stubFinderService.getStubResponse(request);
+            Assertions.assertEquals(404, stubResponse.getStatusCode());
+            Assertions.assertEquals(expectedMessageForNotFoundStub,
+                    IOUtils.toString(stubResponse.getInputStream(), Charset.defaultCharset()));
+        }
+    }
+
+    @Test
+    void getStubResponseShouldPassWhenMethodDoesntMatch() throws IOException, MissingSupportedMethodException {
+        prepareMocks();
+        Mockito.when(stub.getMethod()).thenReturn(HttpMethod.PUT);
+
+        try (MockedConstruction<RequestParameters> mocked = Mockito.mockConstruction(RequestParameters.class,
+                (mock, context) -> {
+                    Mockito.when(mock.getMethod()).thenReturn(HttpMethod.GET);
+                })) {
+            StubResponse stubResponse = stubFinderService.getStubResponse(request);
+            Assertions.assertEquals(404, stubResponse.getStatusCode());
+            Assertions.assertEquals(expectedMessageForNotFoundStub,
+                    IOUtils.toString(stubResponse.getInputStream(), Charset.defaultCharset()));
+        }
+    }
+
+    @Test
+    void getStubResponseShouldPassWhenMethodIsMissingInStub() throws IOException, MissingSupportedMethodException {
+        prepareMocks();
+        Mockito.when(stub.getMethod()).thenThrow(MissingSupportedMethodException.class);
+
+        try (MockedConstruction<RequestParameters> mocked = Mockito.mockConstruction(RequestParameters.class,
+                (mock, context) -> {
+                    Mockito.when(mock.getMethod()).thenReturn(HttpMethod.GET);
+                })) {
+
+            StubResponse stubResponse = stubFinderService.getStubResponse(request);
+            Assertions.assertEquals(404, stubResponse.getStatusCode());
+            Assertions.assertEquals(expectedMessageForNotFoundStub,
+                    IOUtils.toString(stubResponse.getInputStream(), Charset.defaultCharset()));
+        }
+
+    }
+
+    @Test
+    void getStubResponseShouldPassWhenCannotGetParams() throws IOException, MissingSupportedMethodException {
+        try (MockedConstruction<RequestParameters> mocked = Mockito.mockConstruction(RequestParameters.class,
+                (mock, context) -> {
+                    Mockito.when(mock.getMethod()).thenReturn(HttpMethod.GET);
+                })) {
+            // TODO: it should test the scenario when constructor for RequestParameters throws FetchingParametersException
+            StubResponse stubResponse = stubFinderService.getStubResponse(request);
+            // TODO: add assertions
+        }
+    }
+
+    private void prepareMocks() throws MissingSupportedMethodException {
+        List<Resource> resourceList = new ArrayList<>();
+        Resource mockedResource = Mockito.mock(Resource.class);
+        Mockito.when(mockedResource.adaptTo(Stub.class)).thenReturn(stub);
+        resourceList.add(mockedResource);
+        Mockito.when(stubsResource.getChildren()).thenReturn(resourceList);
+    }
+}

core/src/test/java/io/wttech/stubway/filter/StubFilterTest.java

@@ -0,0 +1,66 @@
+package io.wttech.stubway.filter;
+
+import io.wttech.stubway.StubServlet;
+import org.apache.sling.api.SlingHttpServletRequest;
+import org.apache.sling.api.resource.Resource;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import javax.servlet.FilterChain;
+import javax.servlet.ServletException;
+import javax.servlet.ServletResponse;
+import java.io.IOException;
+
+import static org.mockito.Mockito.times;
+
+@ExtendWith(MockitoExtension.class)
+class StubFilterTest {
+
+    @InjectMocks
+    private StubFilter stubFilter;
+
+    @Mock
+    private SlingHttpServletRequest request;
+
+    @Mock
+    private ServletResponse response;
+
+    @Mock
+    private FilterChain filterChain;
+
+    @Mock
+    private StubServlet stubServlet;
+
+    @Mock Resource resource;
+
+    @BeforeEach
+    void setUp() {
+        Mockito.when(request.getResource()).thenReturn(resource);;
+    }
+
+    @Test
+    void testDoFilterIfResourceTypeIsStubway() throws IOException, ServletException {
+        Mockito.when(resource.getResourceType()).thenReturn("stubway/stub");
+        Mockito.doNothing().when(stubServlet).service(request, response);
+
+        stubFilter.doFilter(request, response, filterChain);
+
+        Mockito.verify(stubServlet, times(1)).service(request, response);
+    }
+
+    @Test
+    void testDoFilterIfResourceTypeIsNotStubway() throws IOException, ServletException {
+        Mockito.when(resource.getResourceType()).thenReturn("fake/resource");
+        Mockito.doNothing().when(filterChain).doFilter(request, response);
+
+        stubFilter.doFilter(request, response, filterChain);
+
+        Mockito.verify(filterChain, times(1)).doFilter(request, response);
+    }
+
+}