JUNIT4 Archives - Sourced Code

How to Speed Up Unit Tests in JUnit 5 AEM Projects with SLF4J-NOP

briankasingli — Wed, 07 Aug 2024 12:12:18 +0000

Optimizing the performance of unit tests in AEM projects is crucial for maintaining efficient development cycles. One effective method to achieve this is by disabling logging during test execution using the slf4j-nop library. Here’s why and how you can implement it, along with some performance benchmarks.

Quick Links

Why Disable Logs During Unit Tests?
Adding slf4j-nop to Your Project
Benchmarks and Examples
Further Optimizing AEM Tests

1. Why Disable Logs During Unit Tests?

Logging during unit tests can add unnecessary overhead, especially in large projects where tests generate extensive logs. While logging is essential in production and development environments for debugging, it offers little value during unit tests where the focus is on verifying the correctness of isolated components. Disabling logs during tests provides several benefits:

Reduced I/O Overhead: Logging operations require I/O, which can slow down test execution. Disabling logging eliminates this overhead, leading to faster tests.
Cleaner Test Output: With logs disabled, test outputs are cleaner, making it easier to focus on test results without the distraction of log entries.
Improved Test Performance: Benchmarks have shown that disabling logs can significantly speed up test execution.

2. Adding slf4j-nop to Your Project

To disable logging, you can add the slf4j-nop dependency to your pom.xml:

1
2
3
4
5
6

<dependency>
<groupId>org.slf4jgroupId>
<artifactId>slf4j-nopartifactId>
<version>20.0.16version>
<scope>testscope>
dependency>

For multi-module AEM projects, ensure this dependency is also included in the core/pom.xml file.

1
2
3
4
5

<dependency>
<groupId>org.slf4jgroupId>
<artifactId>slf4j-nopartifactId>
<scope>testscope>
dependency>

https://mvnrepository.com/artifact/org.slf4j/slf4j-nop

3. Benchmarks and Examples

Here’s a comparison of test execution times to illustrate the impact of disabling logs:

JUnit 5 (with logging):
- Run from IntelliJ IDEA: 9.276 seconds
- Run with mvn clean test: 8.696 seconds
JUnit 5 (with slf4j-nop):
- Run from IntelliJ IDEA: 2.116 seconds
- Run with mvn clean test: 1.892 seconds

These results clearly demonstrate that disabling logging can drastically reduce test execution times, allowing for faster feedback during development.

4. Further Optimizing AEM Tests

In addition to disabling logging, further optimization can be achieved by selecting the appropriate AemContext:

NoResourceResolverTypeAemContext (Fastest): Ideal for tests that don’t require resource resolution.
ResourceResolverMockAemContext (Default): Best for tests that need a mocked resource resolver.
JcrMockAemContext: Useful for tests requiring JCR features like indexing.
JcrOakAemContext (Slowest): Necessary for simulating a full JCR, though it’s the slowest option.

By combining these strategies—disabling unnecessary logging and selecting the appropriate context—you can achieve significantly faster and more efficient unit tests.

Implementing these strategies ensures your unit tests are optimized, allowing you to maintain high development velocity without being slowed down by lengthy test runs.

The post How to Speed Up Unit Tests in JUnit 5 AEM Projects with SLF4J-NOP appeared first on Sourced Code.

JUnit 4: AEM How to Mock @RequestAttribute value in Sling Model

briankasingli — Thu, 20 Jan 2022 03:28:56 +0000

This blog article will show code an example for JUnit 4, for how the Request Attribute is being mocked. This example will only cover mocking the @RequestAttribute with the use of @PostConstruct runtime phase, When you are in the code runtime phase of the constructor injection, this will not work (I spent a bit of time on this).

Attention
This article will not cover how to setup JUnit 4 for AEM, but however, more information can be found on this blog article.

Sling Model Class : ExampleSlingModel.class

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

package com.sourcedcode.core.models;

import org.apache.sling.api.SlingHttpServletRequest;
import org.apache.sling.models.annotations.DefaultInjectionStrategy;
import org.apache.sling.models.annotations.Model;
import org.apache.sling.models.annotations.injectorspecific.RequestAttribute;

import javax.annotation.PostConstruct;

@Model(adaptables = SlingHttpServletRequest.class,
defaultInjectionStrategy = DefaultInjectionStrategy.OPTIONAL)
public class ExampleSlingModel {

@RequestAttribute(name = "websitename")
private String websiteName;

@RequestAttribute
private int version;

@PostConstruct
public void init() {
websiteName = websiteName.concat(":websitename");
version = version * 2;
}

public String getWebsiteName() {
return websiteName;
}

public int getVersion() {
return version;
}
}

Sling Model Test Class : ExampleSlingModelTest.class

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

package com.sourcedcode.core.models;

import io.wcm.testing.mock.aem.junit.AemContext;
import org.apache.sling.testing.mock.sling.ResourceResolverType;
import org.apache.sling.testing.mock.sling.servlet.MockSlingHttpServletRequest;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;

public class ExampleSlingModelTest {

@Rule
public final AemContext aemContext = new AemContext(ResourceResolverType.JCR_MOCK);

private MockSlingHttpServletRequest request;

private ExampleSlingModel underTest;

@Before
public void setUp() throws Exception {
aemContext.addModelsForPackage("com.sourcedcode.utils");
request = aemContext.request();
request.setAttribute("websitename", "sourcedcode");
request.setAttribute("version", 5);
}

@Test
public void test_getWebsiteName() {
underTest = request.adaptTo(ExampleSlingModel.class);
Assert.assertEquals("sourcedcode:websitename", underTest.getWebsiteName());
}

@Test
public void test_getVersion() {
underTest = request.adaptTo(ExampleSlingModel.class);
Assert.assertEquals(10, underTest.getVersion());
}
}

The post JUnit 4: AEM How to Mock @RequestAttribute value in Sling Model appeared first on Sourced Code.

JUnit 4: AEM Sling Models Unit Test Constructor Injection Example

briankasingli — Sun, 05 Jul 2020 11:14:23 +0000

In this example, we will take a look at how we can mock Sling Model Constructor Injection dependencies for a JUnit 4 Unit test.

Scenario:
The Sling Model must expose either the PROD_URL or the DEAFULT_URL endpoint based on the run mode or request parameters; this is the requirement. The example below will demonstrate the implementation of logic utilising Sling Model Constructor injection, show Unit test examples, and how mocked dependencies can be Sling Model Constructor injected during the test phase. This completes the example.

Technologies here used are:

AEM project archetype 19 (link)
Mockito 2.27.0 (link)
AEM Mocks JUnit 4 2.7.2 (link)

This example uses the AEM project archetype 19 to generate a new AEM project, Junit 4 will be used as the testing framework, Mockito 2.27.0 will be used as the mocking framework, and AEM Mocks will be used to mock AEM objects and AEM objects.

What’s really great about the latest versions of AEM mocks, is that the setup is very minimal. After spinning up a new AEM project from the AEM project archetype 19, you simply need to include the AEM Mocks dependency, and you are ready to go!

Dependencies

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

// pom.xml

<plugin>
<groupId>org.apache.maven.pluginsgroupId>
<artifactId>maven-surefire-pluginartifactId>
<version>2.20version>
<configuration>
<junitArtifactName>junit:junit:4junitArtifactName>
configuration>
plugin>
...
<dependencies>
...
<dependency>
<groupId>io.wcmgroupId>
<artifactId>io.wcm.testing.aem-mockartifactId>
<version>2.7.2version>
<scope>testscope>
dependency>
...
dependencies>

// core/pom.xml
<dependencies>
...
<dependency>
<groupId>io.wcmgroupId>
<artifactId>io.wcm.testing.aem-mockartifactId>
dependency>
...
dependencies>

Sling Model Test Class : ConstructorInjection.class

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

package com.sourcedcode.core.models;

import com.adobe.cq.export.json.ExporterConstants;
import lombok.Getter;
import org.apache.sling.api.SlingHttpServletRequest;
import org.apache.sling.api.resource.Resource;
import org.apache.sling.models.annotations.DefaultInjectionStrategy;
import org.apache.sling.models.annotations.Exporter;
import org.apache.sling.models.annotations.Model;
import org.apache.sling.models.annotations.injectorspecific.OSGiService;
import org.apache.sling.models.annotations.injectorspecific.SlingObject;
import org.apache.sling.settings.SlingSettingsService;

import javax.inject.Inject;
import javax.inject.Named;

import static org.apache.commons.lang3.StringUtils.EMPTY;
import static org.apache.commons.lang3.StringUtils.isNotEmpty;

@Model(adaptables = {SlingHttpServletRequest.class, Resource.class}, defaultInjectionStrategy = DefaultInjectionStrategy.OPTIONAL)
@Exporter(name = ExporterConstants.SLING_MODEL_EXPORTER_NAME, extensions = ExporterConstants.SLING_MODEL_EXTENSION)
public class ConstructorInjection {

protected static final String API_URL_PROD = "https://api.sourcedcode.com/v1/constructors";
protected static final String API_URL_DEFAULT = "https://uat-api.sourcedcode.com/v1/constructors";

@Getter
private String apiUrl = EMPTY;

@Inject
public ConstructorInjection(@OSGiService @Named("slingSettingsService") final SlingSettingsService slingSettingsService,
@SlingObject @Named("slingHttpServletRequest") final SlingHttpServletRequest request) {
boolean isProd = slingSettingsService.getRunModes().contains("prod");
boolean isParamProd = isNotEmpty(request.getParameter("prod")) && request.getParameter("prod").equals("true");
if (isProd || isParamProd) {
apiUrl = API_URL_PROD;
} else {
apiUrl = API_URL_DEFAULT;
}
}
}

Sling Model Test Class : ConstructorInjectionTest.class

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

package com.sourcedcode.core.models;

import io.wcm.testing.mock.aem.junit.AemContext;
import org.apache.sling.api.SlingHttpServletRequest;
import org.apache.sling.settings.SlingSettingsService;
import org.apache.sling.testing.mock.sling.ResourceResolverType;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;

import java.util.Collections;

import static org.junit.Assert.assertEquals;
import static uk.co.whitbread.wlrestaurants.core.models.ConstructorInjection.API_URL_DEFAULT;
import static uk.co.whitbread.wlrestaurants.core.models.ConstructorInjection.API_URL_PROD;

@RunWith(MockitoJUnitRunner.class)
public class ConstructorInjectionTest {

@Rule
public final AemContext context = new AemContext(ResourceResolverType.JCR_MOCK);

@Mock
private SlingSettingsService slingSettingsService;

@Mock
SlingHttpServletRequest request;

@InjectMocks
private ConstructorInjection underTest;

@Test
public void apiUrl_should_return_PROD_url_when_runmode_prod() {
context.runMode("prod");
underTest = context.request().adaptTo(ConstructorInjection.class);
assert underTest != null;
assertEquals(API_URL_PROD, underTest.getApiUrl());
}

@Test
public void apiUrl_should_return_DEFAULT_url_when_runmode_not_prod() {
context.runMode("staging");
underTest = context.request().adaptTo(ConstructorInjection.class);
assert underTest != null;
assertEquals(API_URL_DEFAULT, underTest.getApiUrl());
}

@Test
public void apiUrl_should_return_PROD_url_when_param_prod_equals_true() {
context.request().setParameterMap(Collections.singletonMap("prod", "true"));
underTest = context.request().adaptTo(ConstructorInjection.class);
assert underTest != null;
assertEquals(API_URL_PROD, underTest.getApiUrl());
}

@Test
public void apiUrl_should_return_DEFAULT_url_when_param_prod_equals_not_true() {
context.request().setParameterMap(Collections.singletonMap("prod", "test"));
underTest = context.request().adaptTo(ConstructorInjection.class);
assert underTest != null;
assertEquals(API_URL_DEFAULT, underTest.getApiUrl());

}
}

More…
Click here to view more examples of AEM JUnit 4 Unit Test Examples.

The post JUnit 4: AEM Sling Models Unit Test Constructor Injection Example appeared first on Sourced Code.

JUnit 4: AEM Sling Servlet Unit Test Example Using wcm.io AEM Mocks, Servlet by Resource Type

briankasingli — Sat, 21 Dec 2019 17:34:23 +0000

This article will demonstrate how to write AEM Unit tests for @SlingServletResourceTypes (OSGi DS 1.4 (R7) component property type annotations) using the Junit4 testing framework. With developers being more visual, the source code is posted below.

Technologies here used are:

AEM project archetype 19 (link)
Mockito 2.27.0 (link)
AEM Mocks JUnit 4 2.7.2 (link)

Using OSGI R7 annotations for your AEM project requires some additional dependencies. Check out Adobe’s guide to enable OSGI R7 annotations.

Test Framework Dependencies

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

Sling Servlet Resource Types Class : SlingServletResourceTypes.class

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

package com.sourcedcode.core.servlets;

import com.day.cq.wcm.api.Page;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.sling.api.SlingHttpServletRequest;
import org.apache.sling.api.SlingHttpServletResponse;
import org.apache.sling.api.resource.Resource;
import org.apache.sling.api.resource.ResourceResolver;
import org.apache.sling.api.servlets.SlingSafeMethodsServlet;
import org.apache.sling.servlets.annotations.SlingServletResourceTypes;
import org.osgi.service.component.annotations.Component;

import javax.servlet.Servlet;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import static com.day.crx.packaging.JSONResponse.APPLICATION_JSON_UTF8;
import static org.apache.sling.api.servlets.HttpConstants.METHOD_GET;

/**
* A demonstration sling servlet resource type class to demonstrate unit testing.
* Appending ".example.json" on any resource will activate the doGet() method below, and return Json data.
* Json Data returned is data from the immediate children of the "/content/we-retail', parent resource node.
*/
@Component(service = Servlet.class)
@SlingServletResourceTypes(
resourceTypes = "sling/servlet/default",
methods = METHOD_GET,
extensions = "json",
selectors = "example")
public class SlingServletResourceTypesExampleDS14Servlet extends SlingSafeMethodsServlet {

@Override
protected void doGet(SlingHttpServletRequest req, SlingHttpServletResponse res) throws IOException {
res.setContentType(APPLICATION_JSON_UTF8);
res.setStatus(SlingHttpServletResponse.SC_OK);
List<PageItem> pageItems = getPageItems(req);
String json = new ObjectMapper().writeValueAsString(pageItems);
res.getWriter().write(json);
}

private List<PageItem> getPageItems(SlingHttpServletRequest req) {
List<PageItem> pageItems = new ArrayList<>();
ResourceResolver resolver = req.getResourceResolver();
Resource weRetail = resolver.getResource("/content/we-retail");
if (weRetail != null) {
Iterator<Resource> it = weRetail.listChildren();
while (it.hasNext()) {
Resource resource = it.next();
if (resource.getResourceType().equalsIgnoreCase(com.day.cq.wcm.api.NameConstants.NT_PAGE)) {
Page page = resource.adaptTo(Page.class);
if (page != null) {
pageItems.add((new PageItem(page.getTitle(), resource.getPath())));
}
}
}
}
return pageItems;
}

/**
* Inner class PageItem, for creating PageItem objects.
*/
public class PageItem {

private String pageTitle;

private String pagePath;

PageItem(String pageTitle, String pagePath) {
this.pageTitle = pageTitle;
this.pagePath = pagePath;
}

public String getPageTitle() {
return pageTitle;
}

public String getPagePath() {
return pagePath;
}
}
}

Results of the output from the working as expected SlingServletResourceTypesTest.class.

Sling Servlet Resource Types Test Class : SlingServletResourceTypesTest.class

package com.sourcedcode.core.servlets;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import io.wcm.testing.mock.aem.junit.AemContext;
import org.apache.sling.testing.mock.sling.ResourceResolverType;
import org.apache.sling.testing.mock.sling.servlet.MockSlingHttpServletRequest;
import org.apache.sling.testing.mock.sling.servlet.MockSlingHttpServletResponse;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;

import java.io.IOException;

import static com.day.crx.packaging.JSONResponse.APPLICATION_JSON_UTF8;
import static junitx.framework.Assert.assertEquals;
import static org.junit.Assert.assertTrue;

@RunWith(MockitoJUnitRunner.class)
public class SlingServletResourceTypesExampleDS14ServletTest {

@Rule
public final AemContext context = new AemContext(ResourceResolverType.JCR_MOCK);

@Mock
private MockSlingHttpServletRequest req;

@Mock
private MockSlingHttpServletResponse res;

@InjectMocks
private SlingServletResourceTypesExampleDS14Servlet underTest;

@Before
public void setup() {
underTest = new SlingServletResourceTypesExampleDS14Servlet();
req = context.request();
res = context.response();
}

@Test
public void doGet_shouldReturnHeaderAsExpected() throws IOException {
underTest.doGet(req, res);
assertEquals(res.getContentType(), APPLICATION_JSON_UTF8);
}

@Test
public void doGet_shouldReturnPageItemListJsonAsExpected_0() throws IOException {
underTest.doGet(req, res);
String jsonString = res.getOutputAsString();
ObjectMapper mapper = new ObjectMapper();
JsonNode actualObj = mapper.readTree(jsonString);
assertEquals(0, actualObj.size());
}

@Test
public void doGet_shouldReturnPageItemJsonAsExpected_properties_values() throws IOException {
createPagesInJcrMock();
underTest.doGet(req, res);
String jsonString = res.getOutputAsString();
ObjectMapper mapper = new ObjectMapper();
JsonNode actualObj = mapper.readTree(jsonString);
JsonNode firstItem = actualObj.get(0);
assertTrue(firstItem.has("pageTitle"));
assertTrue(firstItem.has("pagePath"));
assertEquals( "United states", firstItem.get("pageTitle").textValue());
assertEquals("/content/we-retail/us", firstItem.get("pagePath").textValue());
}

/**
* Test helper method to create 3 pages in the on-memory JCR Mock instance.
*/
private void createPagesInJcrMock() {
context.create().page("/content/we-retail", "/", "We Retail");
context.create().page("/content/we-retail/us", "/", "United states");
context.create().page("/content/we-retail/ca", "/", "Canada");
}
}

Last Thoughts:
Though the endpoint path is ugly (because it consists of extensions, selectors, and etc…), it is recomended to register servlet by resource types rather than by path (click here to learn why @SlingServletPaths, register by path, are not recommended).

If there is a requirement to mask or to sugarcoat the ugly URI paths, a common strategy used is the Apache webserver. Click here to learn to sugar coat registered AEM servlet scripts and paths endpoint.

The post JUnit 4: AEM Sling Servlet Unit Test Example Using wcm.io AEM Mocks, Servlet by Resource Type appeared first on Sourced Code.

JUnit 4: AEM WCMUsePojo Unit Test Example (Passing Paramaters)

briankasingli — Wed, 25 Sep 2019 20:35:18 +0000

This article will demonstrate how to write AEM Unit tests for building WCMUsePojo Java classes using the Junit4 testing framework. With developers being more visual, the source code is posted below.

In this example, I am building a Sightly utils class that helps me append .html to page path that are configured by the author. The utils class can be used by any AEM components during development. A value is passed through a parameter in this demo.

Technologies here used are:

AEM project archetype 19 (link)

This example uses the AEM project archetype 19 to generate a new AEM project, Junit 4 will be used as the testing framework.

Sightly Example Use:

1
2
3
4
5
6

<div class="somecomponent">
<a href="${lnk.link}" target="_blank" rel="noopener noreferrer">
Click Here
</div>
</div>

WCMUsePojo Example Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

package com.sourcedcode.core.wcm.utils;

import com.adobe.cq.sightly.WCMUsePojo;
import org.apache.commons.lang3.StringUtils;

public class LinkChecker extends WCMUsePojo {

private static final String LINK = "link";

private String link;

@Override
public void activate() {
resolveLink();
}

/**
* Resolves the path of a JCR page path with a .html extension
*/
private void resolveLink() {
link = get(LINK, String.class);
if (StringUtils.isNotEmpty(link)) {
if (!link.contains(".html")) {
link += ".html";
}
}
}

public String getLink() {
return link;
}

}

WCMUsePojo Unit Test Example Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

package com.sourcedcode.core.wcm.utils;

import org.junit.Test;

import javax.script.Bindings;

import static junitx.framework.Assert.assertEquals;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

public class LinkCheckerTest {

@Test
public void testLinkValueWithNoHTML() {
Bindings bindings = mock(Bindings.class);
when(bindings.get("link")).thenReturn("/content/sourcedcode/home");
LinkChecker use = new LinkChecker();
use.init(bindings);
assertEquals("/content/sourcedcode/home.html", use.getLink());
}

@Test
public void testLinkValueWithHTML() {
Bindings bindings = mock(Bindings.class);
when(bindings.get("link")).thenReturn("/content/sourcedcode/home.html");
LinkChecker use = new LinkChecker();
use.init(bindings);
assertEquals("/content/sourcedcode/home.html", use.getLink());
}

}

Tip:
I hope the example above helps you out with your development of Java Classes that extend the WCMUsePojo Class. Instead of writing a new WCMUsePojo Class, you can utilise magic that sightly 1.4 offers.

Sightly 1.4 offers a quicker way for you to add extensions to a given url, as examples below:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

${'sourcedcode/home' @ extension='html'}

${'sourcedcode/home.json' @ extension='html'}

${'sourcedcode/home.selector.json' @ extension='html'}

${'sourcedcode/home.json/suffix' @ extension='html'}

${'sourcedcode/home.json?key=value' @ extension='html'}

${'sourcedcode/home.json#fragment' @ extension='html'}

${'sourcedcode/home.json' @ extension}

// documentation
https://github.com/adobe/htl-spec/blob/master/SPECIFICATION.md

Common Questions for Writing Test Code for WCMUsePojo Classes

How do I pass a parameter to the WCMUsePojo class in AEM? Call the fully qualified java class name in sightly, and use the @ symbol to pass the parameter. Take a look a the example above example

The post JUnit 4: AEM WCMUsePojo Unit Test Example (Passing Paramaters) appeared first on Sourced Code.

JUnit 4: AEM Sling Models Unit Test Example Using wcm.io AEM Mocks

briankasingli — Mon, 27 May 2019 12:31:40 +0000

Creating new AEM components, we sometimes need backend logic to compute user requests with business logic. There are multiple ways of doing so, like using the Java-Use API or Javascript-Use API, but the most popular and best practice of writing business logic for an AEM component will be using Sling Models.

This article will demonstrate how to write AEM Unit tests for sling models using the Junit4 testing framework. With developers being more visual, the source code is posted below.

Technologies here used are:

AEM project archetype 19 (link)
Mockito 2.27.0 (link)
AEM Mocks JUnit 4 2.7.2 (link)

Dependencies

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

Sling Model Class : Header.class

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

package com.sourcedcode.core.models;

import com.day.cq.wcm.api.Page;
import org.apache.sling.api.resource.Resource;
import org.apache.sling.api.resource.ResourceResolver;
import org.apache.sling.models.annotations.DefaultInjectionStrategy;
import org.apache.sling.models.annotations.Model;
import org.apache.sling.models.annotations.injectorspecific.ChildResource;
import org.apache.sling.models.annotations.injectorspecific.ScriptVariable;
import org.apache.sling.models.annotations.injectorspecific.ValueMapValue;

import javax.annotation.PostConstruct;
import javax.inject.Inject;

@Model(adaptables = Resource.class,
resourceType = Header.RESOURCE_TYPE,
defaultInjectionStrategy = DefaultInjectionStrategy.OPTIONAL)
public class Header {

protected static final String RESOURCE_TYPE = "sourcedcode/components/structure/header";

@ValueMapValue
private String contactUsPath;

@ScriptVariable(name="currentPage")
private Page currentPage;

@ChildResource(name="link")
Resource childResource;

@SlingObject
private ResourceResolver resolver;

private String contactUsPageSecretChar;

@PostConstruct
public void init() {
setContactUsPageSecretChar();
}

private void setContactUsPageSecretChar() {
Resource resource = resolver.getResource(contactUsPath);
if (resource != null) {
Page contactUsPage = resource.adaptTo(Page.class);
contactUsPageSecretChar = contactUsPage.getTitle();
}
}

public String getContactUsPageSecretChar() {
return contactUsPageSecretChar.substring(contactUsPageSecretChar.length() - 1);
}

// demo of testing the @ScriptVariable("currentPage") annotation
public String getPageTitle() {
return currentPage.getPageTitle();
}

// demo of testing the @ChildResource annotation
public String getChildLinkPropFlag() {
return childResource.getValueMap().get("flag", "");
}
}

Sling Model Test Class : HeaderTest.class

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

package com.sourcedcode.core.models;

import com.adobe.cq.commerce.common.ValueMapDecorator;
import com.day.cq.wcm.api.Page;
import com.google.common.collect.ImmutableMap;
import io.wcm.testing.mock.aem.junit.AemContext;
import org.apache.sling.api.resource.Resource;
import org.apache.sling.testing.mock.sling.ResourceResolverType;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;

import static junitx.framework.Assert.assertEquals;
import static org.mockito.Mockito.when;

@RunWith(MockitoJUnitRunner.class)
public class HeaderTest {

@Rule
public final AemContext context = new AemContext(ResourceResolverType.JCR_MOCK);

// the context.resourceResolver() is auto injected by the AemContext, cannot be mocked.
// ResourceResolver resolver;

// mocking the global AEM object "currentPage".
// variable does not need to match the variables in the underTest.class
@Mock
private Page currentPage;

// injects all the mocks into the tested object.
@InjectMocks
private Header underTest;

@Test
public void itShouldReturnTheCorrectSecretCharWhenResourceExist() {
// using the AEM context to create an AEM resource in the context, to set properties for the resource.
// the resource path can be anything made up.
Resource headerResourceContext = context.create().resource("/content/sourcedcode/home/jcr:content/header", new ValueMapDecorator(ImmutableMap.<String, Object> of(
"contactUsPath", "/content/sourcedcode/contact",
"anotherProperty", "example")));

// create mock page, resolved by the resolver.
context.create().page("/content/sourcedcode/contact", "", ImmutableMap.<String, Object>builder()
.put("jcr:title", "Contact Us Page")
.build());

underTest = headerResourceContext.adaptTo(Header.class);
assertEquals("e", underTest.getContactUsPageSecretChar());
}

@Test
public void itShouldReturnTheCorrectCurrentPageTitle() {
when(currentPage.getPageTitle()).thenReturn("Home Page");
assertEquals("Home Page", underTest.getPageTitle());
}

@Test
public void itShouldReturnTheCorrectChildLinkProperty() {
context.build().resource("/content/sourcedcode/home/jcr:content/header")
.siblingsMode()
.resource("link", "flag", "newPage");
underTest = context.resourceResolver().getResource("/content/sourcedcode/home/jcr:content/header").adaptTo(Header.class);
assertEquals("newPage", underTest.getChildLinkPropFlag());
}

}

Common Questions for Writing Test Code for Sling Models

How do I initial properties in my sling model object? First, ensure that your sling model allows a resource.class to be adaptable, then in your sling model test class, create a mockResource object, setup up the mockResource object, and adapt to the sling model class that you are trying to test.
Which Context should I be used when testing for sling models? You should use the JCR_MOCK context.

For AEM Sling Servlet by Resource Type, Unit Test Example Using wcm.io AEM Mocks, click here.

The post JUnit 4: AEM Sling Models Unit Test Example Using wcm.io AEM Mocks appeared first on Sourced Code.