AD0-E137 Practice Exam Questions with Answers Adobe Experience Manager Sites Developer Expert Certification

The correct approach to display external API results using server-side rendering in AEM is to separate responsibilities across three layers. First, create an OSGi component that encapsulates the logic for making external API calls using an HTTP client. This ensures reusability and central management of integration code. Second, create a Sling Model that references this OSGi service. Sling Models provide a resource-adaptable layer that connects AEM components to backend services, making it easier to expose data to HTL scripts. Finally, bind this Sling Model to an AEM component, which displays the fetched data in server-rendered HTML. This is aligned with Adobe’s guidance that integration logic should be handled within OSGi services, with Sling Models bridging content and services for components. Options B and C incorrectly assign responsibilities to Servlets or components, which violates best practices for modularity.

The correct approach to implementing an OSGi service in AEM is to use the Declarative Services annotation @Component(service = Interface.class). This ensures that the OSGi container properly registers the service against its interface, making it available for injection into other services, Sling Models, or servlets. In this case, the service is required to fetch store locations from an external API. Using an HTTP client within the OSGi service is the appropriate method to manage these requests. Option A is invalid because @OSGIService is not a valid annotation for service declaration. Option C is incorrect because @Service is not an OSGi Declarative Services annotation in this context. Adobe emphasizes encapsulating external API logic in OSGi services so that components and Sling Models can consume the data in a decoupled manner. This promotes separation of concerns and reusability.

In AEM, fine-grained access control is managed using JCR Access Control Entries (ACEs). To grant access only to a specific node but exclude all child nodes, the correct approach is to set the rep:glob = "" property. This ensures that permissions apply strictly to the node itself and not recursively. Option B, rep:globs = "**", would apply access recursively to all descendants. Option C, rep:glob = "child", is invalid and does not represent a valid configuration. Adobe recommends precise use of rep:glob patterns to restrict user access according to security requirements, ensuring least-privilege principles.

In Dispatcher configuration, request filtering is handled through the filters.any file. To deny access to specific content types or formats (like .json and .xml) for certain paths, the configuration must explicitly match both the extension and the path using correct syntax. The valid approach uses:

/0001 { /type "deny" /extension "(xml|json)" /path "(/path2|/path3)/*" }

Options A and B contain syntax errors. Option A incorrectly uses JSON/* instead of paths, and Option B mixes array-style brackets instead of regex or path expressions. Option C follows the correct pattern of specifying deny rules with /extension and /path. Adobe recommends always explicitly denying unwanted selectors or extensions to prevent exposure of sensitive content through JSON or XML requests.

In AEM, multi-site management allows centralized content updates to be pushed across different localized or departmental sites. The “Partial” option on the rollout configuration ensures that only specific components or regions designated for shared updates are synchronized, while leaving local content intact. This fits the described requirement where a portion of each school’s homepage must receive university updates without affecting school-specific content. Option A, Experience Fragments, could be used but are better suited for shared fragments of design/content, not controlled rollout scenarios. Option C requires manual inheritance restoration per page, which is inefficient. Option D, implementing custom rollout logic, is not needed when the built-in “Partial Rollout” option fulfills the requirement. Adobe emphasizes using partial rollout in multi-site configurations to balance central control with localized autonomy.

Explanation (Adobe Docs Reference):

When querying with QueryBuilder API:

type=cq:Page ensures only AEM pages are selected.

property=jcr:content/cq:template filters by the template path.

property.value=/conf/geometrixx/templates/homepage ensures only pages created with the homepage template are returned.

p.hits=selective restricts returned properties.

p.properties=jcr:title ensures only the jcr:title is returned.

Options B, C, and D are invalid due to wrong property paths (jcr:title/cq:template, cq:template, or jcr:content/template) or typos (jrc:title).

Adobe Documentation:

“The property parameter can be used to restrict results based on template usage. Use jcr:content/cq:template to filter by template and p.properties with p.hits=selective to return specific fields.”

— AEM QueryBuilder API Guide

Modern AEM projects often include front-end build processes for handling CSS, JavaScript, and component-specific assets. Webpack is the recommended tool for managing dependencies, bundling code, minification, transpilation (e.g., ES6+ to ES5), and optimizing assets. It integrates with the AEM Maven build process and supports workflows like Single Page Applications (SPA) and client libraries. Option B, Apache Sling, is the underlying web framework for AEM, not a front-end tool. Option C, Maven, manages project builds and back-end dependencies but not front-end asset pipelines. Option D, the AEM Sites Console, is for authoring and managing pages, not development builds. Adobe documentation for SPA Editor and modern AEM projects consistently demonstrates Webpack as the standard tool for front-end optimization.

Explanation (Adobe Docs Reference):

Unit tests for Sling Models using wcm.io AEM Mocks (AemContext) require test content to be loaded into the mock JCR repository. This is usually done with:

ctx.load().json("/path/to/test-content.json", "/content");

Without loading node data, ctx.currentResource("/content/bar") won’t resolve anything, causing adaptTo(Flarp.class) to return null.

A is wrong: AemContext is correct for Sling Models in AEM.

B is wrong: @Rule applies to JUnit4, but the test uses JUnit5 with @ExtendWith.

C is correct: Loading JSON test content is required.

Adobe/WCM.IO Documentation:

“Use context.load().json() to load test content into the JCR repository for unit tests. Then set context.currentResource(path) to adapt resources to Sling Models.”

— wcm.io AEM Mocks Documentation

Run mode-specific configurations in AEM follow a strict naming convention under the osgiconfig folder. The folder structure defines both the run mode (author or publish) and the environment (e.g., dev, stage, uat, prod). For UAT author environments, the correct structure is config.author.uat. Option C follows this convention correctly. Option A and B use incorrect naming patterns, which would prevent AEM from loading the configuration under the desired run mode. Adobe emphasizes the importance of placing OSGi configs in the correct folder paths within the ui.apps project or ui.config project depending on deployment structure.

When unit testing a service that depends on JCR queries, the best practice is to use mocking frameworks (such as Mockito) to mock the Query and QueryResult objects. The purpose of a unit test is to isolate the service under test and not rely on a real JCR repository or SlingContext persistence layer, which moves testing into integration testing territory. By mocking the Query object and using the when(...).thenReturn(...) pattern, developers can control query results and validate how the service behaves under different scenarios. This ensures that the test runs quickly, without dependency on repository setup or external data. Option B is incorrect because currentResource() is used in Sling Model tests rather than for query-driven services. Option C with SlingContext and JCR_OAK would be used in integration or functional tests, not in lightweight unit tests. Adobe documentation highlights that JCR queries should be mocked in unit tests to ensure isolation and speed.