Free ACSCE-5X Practice Test Questions and Answers (2026)

In the context of an Alfresco Share page rendering a node's details, a special root object named document is exposed to the FreeMarker template. This document object is a TemplateNode wrapper around the actual content node. If the node has the cm:templatable aspect applied and a presentation template is associated with it, the web script controller resolves this template's path. This path is then made available as the .template property on the document object. Therefore, the expression document.template is used to access and subsequently include this presentation template.

A. template: This is ambiguous. It could refer to the current template context but does not specifically access the presentation template associated with the document node.

B. node.template: The standard node root object (of type ScriptNode) does not have a .template property to access the associated presentation template.

C. node.document: This represents an incorrect object hierarchy. document is a root-level object, not a property of the generic node object in this context.

D. document: This expression accesses the entire document object wrapper (TemplateNode), not the specific presentation template property associated with it.

1. Alfresco Content Services 5.2 Documentation, Content Model Guide: The cm:templatable aspect is defined in the out-of-the-box content models. This aspect adds the cm:template association, which links a node to its presentation template node. The logic for document.template relies on this association being present. (See: Alfresco 5.2 Docs, systemdictionary.xml model definition for cm:templatable).

2. Default Alfresco Share Template Source Code: The default FreeMarker template for the document details page (document-details.get.html.ftl) in Alfresco 5.x explicitly uses this expression. The relevant code snippet is:

freemarker

...

This demonstrates the canonical method for checking and including a presentation template. (Source: tomcat/webapps/share/WEB-INF/classes/alfresco/site-webscripts/org/alfresco/components/document-details/document-details.get.html.ftl).

3. Alfresco Content Services 5.2 Documentation, Web Scripts: The documentation on web scripts explains that controllers (.get.js files) prepare a model for the view (.get.html.ftl file). The controller for the document details page resolves the template and places it in the model, making it accessible via the document root object. (See: Alfresco 5.2 Docs, Developing -> APIs -> Web Scripts -> Architecture and framework).

Smart Folders are not a unique content type but rather a standard Alfresco folder (cm:folder) with a specific aspect, smf:smartFolder, applied to it. This aspect is the key identifier that distinguishes a Smart Folder from a regular folder. It contains the properties, such as the search query (smf:query) and the template (smf:template), that define the folder's dynamic behavior and how its content is populated. Therefore, recognizing the presence of the smf:smartFolder aspect is the correct method for identifying a Smart Folder.

A. Smart Folders are not a distinct node type. They are standard cm:folder nodes enhanced with an aspect.

B. smf:contains is the child-association type used for the virtual nodes within a Smart Folder, not for identifying the folder itself.

D. A node reference is a unique identifier for any node in the repository; it does not inherently describe the node's behavior or identify it as a Smart Folder.

E. Smart Folders are functionally different from standard folders due to the applied smf:smartFolder aspect, which enables their dynamic, query-based content.

1. Alfresco Content Services 5.2 Documentation, "Smart Folders": "A Smart Folder is a standard Alfresco folder (cm:folder) that has the aspect smf:smartFolder applied. The aspect adds the required properties for a search query and a template." This statement directly confirms that the aspect is the defining characteristic.

Source: Alfresco Content Services 5.2 Documentation, Administering > Administering Content Services > Smart Folders.

2. Alfresco Content Services 5.2 Documentation, "Smart Folder model": The documentation details the smf:smartFolder aspect and its properties (smf:query, smf:template, smf:language, etc.). This shows the aspect is the container for all Smart Folder-specific metadata.

Source: Alfresco Content Services 5.2 Documentation, Developing > Content model > Out-of-the-box models > Smart Folder model.

The file util.js is a core part of the Alfresco Share client-side JavaScript library. It defines the Alfresco.util namespace, which contains a collection of commonly-used, general-purpose utility functions. These functions are designed to be reusable across various components and widgets within the Share user interface. Examples of functions provided include those for HTML encoding (encodeHTML), date formatting (formatDate), managing CSS dependencies (loadCSS), and creating unique DOM IDs (generateDomId), among others.

A. common.js is not a standard file in the core Alfresco Share JavaScript framework for housing general-purpose utility functions.

C. slingshot.js is the main application file for the Share web application (codenamed "Slingshot"), responsible for initializing the application's primary components and page structure.

D. alfresco.js is the bootstrap file that creates the root Alfresco JavaScript namespace and loads other core components, but it does not contain the utility functions themselves.

1. Alfresco Content Services 5.2 Documentation, Share Client-side Library: The official documentation describes the Alfresco.util object as the location for common utility functions. The file that provides this object is util.js.

Source: Alfresco Content Services 5.2 Documentation, "Share Client-side Library". (While the page doesn't explicitly state "util.js contains Alfresco.util", this is the standard convention and verifiable in the source code. The documentation focuses on the API namespace provided by the file).

2. Alfresco Content Services 5.2 Documentation, JavaScript API: The JavaScript API reference details the functions available under the Alfresco.util namespace, confirming its role as the central repository for client-side utilities.

Source: Alfresco Content Services 5.2 Documentation, "JavaScript API > Alfresco.util object". This section lists the utility functions such as encodeHTML, formatDate, and generateDomId.

The TemplateNode is the specific FreeMarker API wrapper provided by Alfresco to access and manipulate repository nodes and their properties within a template. When a ScriptNode object is passed from a web script controller to the FreeMarker model, it is automatically converted into a TemplateNode for use in the view. This API provides convenient methods and property accessors (e.g., ${document.name}, ${document.properties.title}, ${document.children}) suitable for a templating context.

A. ScriptNode is the API used in server-side JavaScript (e.g., web script controllers), not directly within FreeMarker templates.

C. NodeRef is a low-level object representing a node's unique identifier, not the high-level API with methods for accessing properties.

D. TemplateObject is a generic term and not the specific name of the Alfresco API class for accessing nodes in templates.

1. Alfresco Content Services 5.2 Documentation, "FreeMarker Template Guide": This guide explicitly states the role of TemplateNode. In the section "The Alfresco Template Model," it details how objects are made available to the template. It clarifies: "Alfresco Repository script objects of type ScriptNode are automatically converted to objects of type TemplateNode."

Source: Alfresco Content Services 5.2 Documentation > Developing > API > Scripting API > FreeMarker Template Guide.

2. Alfresco Content Services 5.2 Documentation, "ScriptNode API": This document describes the ScriptNode object, which is used in the server-side JavaScript context of a web script controller. This distinguishes it from the TemplateNode used in the FreeMarker view.

Source: Alfresco Content Services 5.2 Documentation > Developing > API > Scripting API > Scripting API services > ScriptNode API.

3. Alfresco Content Services 5.2 Documentation, "Web scripts": The overview of web scripts explains the Model-View-Controller (MVC) pattern used. The controller (JavaScript) prepares a model of data, which often includes ScriptNode objects. These are then passed to the view (FreeMarker template), where they are accessed as TemplateNode objects.

Source: Alfresco Content Services 5.2 Documentation > Developing > API > Web scripts.

The simplest and most direct method to execute a custom script from a content rule is by leveraging the built-in "Execute a Script" action. This standard action is designed to locate and run JavaScript files stored in a specific, predefined location within the repository: the Data Dictionary/Scripts folder. When configuring a rule in the user interface, this action provides a dropdown list of all available scripts from that folder. This approach requires no custom Java development, Spring configuration, or packaging into an AMP, making it the most straightforward option.

A. Creating a new custom action and bundling it into an AMP is a more complex, heavyweight development process, not the simplest way.

C. Placing a script on the classpath with a specific function name does not automatically register it as a new, selectable rule action in the UI.

D. The "Execute a Script" action is hard-coded to look in the Data Dictionary/Scripts folder, not the folder where the rule is applied.

1. Alfresco Content Services 5.2 Documentation, "Out-of-the-box actions": This official documentation lists the available actions for content rules. For the "Execute script" action, it states: "Executes a script against the content item. You select a script from the menu that contains all the scripts available in the Data Dictionary > Scripts folder."

Source: Alfresco Documentation, Alfresco Content Services 5.2, "Using rules > Out-of-the-box actions". (Specific section reference).

2. Alfresco Content Services 5.2 Documentation, "Repository-side JavaScript files": This section explains where to store repository-side JavaScript files for them to be accessible by features like rules. It specifies: "Store your scripts in the repository in Company Home > Data Dictionary > Scripts. The out-of-the-box rule action 'Execute a script' can then be used to run the script."

Source: Alfresco Documentation, Alfresco Content Services 5.2, "Developing > Customizing and Extending > Repository-side JavaScript > Repository-side JavaScript files". (Specific section reference).

The Alfresco 5.2 REST API, specifically the Repository-level API, is built upon the Web Script Framework. The framework's dispatcher servlet, which handles incoming RESTful calls, is mapped to two primary URL patterns by default. The base URL http://server/alfresco/service is the main entry point for web scripts. Additionally, http://server/alfresco/s is provided as an alias for /service that enforces authentication for the web script call. Both are valid base URLs for accessing the web script-based REST API.

B. http://server/alfresco/restful: This is not a default or standard base URL for any of the REST APIs provided with Alfresco 5.2.

C. http://server/alfresco/script: This URL pattern is not used by the Web Script Framework; the correct patterns are /service and /s.

D. http://server/alfresco/ws: This base URL is reserved for the Alfresco SOAP (Simple Object Access Protocol) Web Services, not the REST API.

1. Alfresco Content Services 5.2 Documentation, "Web script dispatcher": This official documentation page details the configuration of the web script dispatcher servlet. It explicitly states the URL mappings: "The Web Script Framework is bound to the URL /service/ and /s/ by the web script dispatcher servlet." This confirms that both /service (E) and /s (A) are correct base URLs.

Source: Alfresco Content Services 5.2 Documentation > Developing > Web Scripts > Web Script Framework > Dispatcher.

2. Alfresco Content Services 5.2 Documentation, "Web Services": This section describes the SOAP-based web services. It provides examples of WSDL URLs, such as http://localhost:8080/alfresco/ws/API/Repository?wsdl, which confirms that the /ws path (D) is designated for SOAP Web Services, not REST.

Source: Alfresco Content Services 5.2 Documentation > Developing > Integrations > Web Services.

The web script descriptor's element controls the transactional context for the script's execution. If this element is omitted from the descriptor file (.desc.xml), Alfresco defaults to a value of required. This default behavior ensures that by default, all repository operations performed by the web script are wrapped in a transaction, guaranteeing data consistency and integrity. The script will join an existing transaction if one is present, or a new one will be initiated if not.

A. None: none is a valid value that must be explicitly set. It is often used for read-only (GET) operations to improve performance but is not the default.

B. None for GET Web Scripts, “required” for POST/PUT: This describes a common best practice, not the framework's default behavior. The default is required for all HTTP methods.

D. Depends on the value of : The and elements are independent configuration settings within the descriptor; one does not influence the default of the other.

1. Alfresco Content Services 5.2 Documentation, Web Script description language reference:

Section:

Content: "Specifies the transactional context in which the web script will run... If not specified, the default is required."

Reference: Alfresco Documentation - Web Script Description Language Reference for ACS 5.2.

2. Alfresco One 5.1 Documentation, Web Script description language reference:

Section:

Content: The documentation for this earlier but compatible version also confirms the default. "If not specified, the default is required."

Reference: Alfresco Documentation - Web Script Description Language Reference for Alfresco One 5.1.

The Alfresco Content Services security model is fundamentally hierarchical. By default, a node (a file or folder) inherits its Access Control List (ACL) from its parent folder. When a node is moved from one folder to another, its parent in the repository hierarchy changes. Consequently, the node ceases to inherit permissions from its original parent and begins inheriting the ACL from its new parent folder. This ensures that content automatically adopts the security context of the location to which it is moved, which is a core principle of managing permissions within the Alfresco repository.

B. It will inherit the ACL from the user who is moving it.

A user's permissions determine if they can perform the move action, but the object's permissions are derived from its location, not the user acting upon it.

C. It will inherit the system wide ACL.

There is no single "system wide ACL" for content. Permissions are granular and determined by a node's position within the folder hierarchy, not a global setting.

D. It will keep its old ACL.

This is incorrect for the inherited portion of its permissions. While a node can have its own local ACL, it also inherits permissions, and that inherited part will change upon moving.

1. Alfresco Content Services 5.2 Documentation, Administering, Managing Permissions: The documentation states, "By default, a folder or content item inherits the permissions of its parent folder." This core principle dictates that changing the parent by moving the item will change the source of inherited permissions. (Source: Alfresco Content Services 5.2 Documentation, docs.alfresco.com, Section: "Managing permissions").

2. Alfresco Content Services 5.2 Documentation, Repository Concepts, Permissions: This section explains the hierarchical model: "The permission model is hierarchical. Permissions set on a container (a space) are inherited by the objects it contains (other spaces, content items)." A move operation is a change of container, which directly implies a change in inherited permissions. (Source: Alfresco Content Services 5.2 Documentation, docs.alfresco.com, Section: "Repository concepts > Permissions").

Alfresco's official Software Development Kit (SDK) for the 5.x platform is fundamentally based on Apache Maven. The SDK provides Maven archetypes to generate standardized project structures, such as the All-In-One (AIO) project, which is the recommended starting point for most customizations. This approach streamlines the entire development lifecycle, including dependency management, compilation, packaging of extensions into Alfresco Module Packages (AMPs) or simple JARs, and running integration tests. The use of Maven is deeply integrated into the documented development process, making it the unequivocally preferred tool for building and packaging extensions for Alfresco 5.x.

A. Winzip: This is a file archiving utility, not a build automation tool. It cannot compile Java code, manage dependencies, or execute project lifecycle phases.

B. Ant: While used in much older Alfresco versions (pre-4.0), Ant was superseded by Maven as the preferred tool due to Maven's superior dependency management and standardized project structure.

D. Gradle: Although a capable modern build tool, the official Alfresco SDK, tutorials, and project archetypes for the 5.x series are exclusively based on Maven, not Gradle.

1. Alfresco Content Services 5.2 Documentation, "Introduction to the Alfresco SDK": "The Alfresco SDK is a Maven-based development kit that makes it easy for developers to build customizations for Alfresco. It is based on a standard Maven layout, and provides a number of archetypes (project templates) that can be used to generate projects for a number of common use cases."

Source: Alfresco Content Services 5.2 Official Documentation, docs.alfresco.com, Section: Developing -> Alfresco SDK -> Introduction to the Alfresco SDK.

2. Alfresco Content Services 5.2 Documentation, "Creating an Alfresco project with the SDK": The primary instruction for creating a new extension project is to use a Maven command: mvn archetype:generate ... -DartifactId=my-project-repo-amp. This demonstrates that Maven is the required tool for using the official SDK.

Source: Alfresco Content Services 5.2 Official Documentation, docs.alfresco.com, Section: Developing -> Alfresco SDK -> Getting Started with the Alfresco SDK -> Creating an Alfresco project with the SDK.

The url.templateArgs object is specifically designed to access values from placeholders within a web script's URI template. When a URL like /user/{username} is defined, and a request is made to /user/johndoe, the value "johndoe" is captured and made available in both the JavaScript controller and the FreeMarker template via url.templateArgs.username. This object provides a map of the arguments extracted directly from the URL path.

B. url.args: This object contains parameters passed in the query string of the URL (e.g., ?name=value), not from the URL path itself.

C. arguments: This is a standard JavaScript object that provides access to arguments passed to a function, not a specific Alfresco root object for URL parameters.

D. args: This is a convenient root-level shortcut for url.args, which contains query string parameters, not parameters from the URL path template.

1. Alfresco Content Services 5.2 Documentation, "Root objects": This official documentation page lists the root objects available to web scripts. It explicitly defines url.templateArgs as "An associative array of arguments extracted from the URI path." and args as "An associative array of all query parameter values from the URI."

Reference: Alfresco Content Services 5.2 Documentation > Developing > APIs > Web Scripts > Web script reference > Root objects.

2. Alfresco Content Services 5.2 Documentation, "url": This section details the properties of the url root object.

Reference: Alfresco Content Services 5.2 Documentation > Developing > APIs > Web Scripts > Web script reference > Root objects > url. It states:

templateArgs: "An associative array of arguments from the URI path."

args: "An associative array of arguments from the URI query string."

The CMIS query predicate CONTAINS() is specifically designed to execute a full-text search against the repository's search index. In Alfresco Content Services, this function queries the underlying search engine (e.g., Solr). The primary purpose of this search is to find terms within the textual content extracted from a document's binary file (e.g., the text inside a PDF or Word document). While Alfresco's default configuration also includes certain metadata properties like name and title in the full-text index, the core and distinguishing function of CONTAINS() is to search the document's body content, which cannot be queried using standard property-based operators. Therefore, this option is the most accurate description of the predicate's main function.

A. This is incomplete. The CONTAINS() predicate's primary function is to search the document's body content, which this option completely omits.

C. This is incorrect. CONTAINS() performs a broad full-text search, not a search limited to a single, specific metadata property.

D. This is incorrect. CONTAINS() performs a broad full-text search, not a search limited to a single, specific metadata property.

E. This is incorrect. CONTAINS() performs a broad full-text search, not a search limited to a single, specific metadata property.

---

1. OASIS CMIS v1.1 Specification:

Section 2.2.2.2.3 CONTAINS() Predicate Function: "The CONTAINS() predicate function is used to query the repository for objects that have been full-text indexed... The query is evaluated against the full-text index for the object-type specified in the FROM clause." This establishes that CONTAINS() is the standard mechanism for full-text search.

2. Alfresco Content Services 5.2 Documentation, Alfresco Full Text Search Reference:

Section: What is indexed?: The documentation states, "By default, Solr indexes the content of every property of type d:text and d:mltext and d:content." The d:content type refers to the actual binary content of the document, confirming that the document's body is the primary target for indexing and full-text search.

3. Alfresco Content Services 5.2 Documentation, CMIS:

Section: Alfresco CMIS repository features: The documentation explicitly states, "The CONTAINS() predicate is used for full-text searching." This directly links the CMIS function to Alfresco's full-text search capabilities, which are centered on document content.

The Content Management Interoperability Services (CMIS) 1.1 specification defines a domain model that includes core object types such as Document, Folder, Policy, and Relationship. The specification also provides a comprehensive model for versioning Document objects. However, the CMIS standard does not include a model for workflow or business process management. While a CMIS-compliant repository like Alfresco has a powerful workflow engine, interaction with it is handled through repository-specific APIs (like the Alfresco REST API for Activiti/Process Services), not through the standardized CMIS protocol.

A. versioning: CMIS explicitly supports versioning for document objects, including services for check-out, check-in, and managing the version history.

C. policy: The CMIS object model includes a cmis:policy base object type, which can be applied to other objects to enforce administrative rules.

D. document: The cmis:document is a fundamental base object type in the CMIS specification, representing an object that has content.

1. OASIS. (2013). Content Management Interoperability Services (CMIS) Version 1.1. OASIS Standard.

Section 2.1.3, "Object Model": Lists the base object types as Document, Folder, Relationship, Policy, and Item. It makes no mention of a Workflow object type.

Section 2.1.5, "Policies": Defines the Policy object and its purpose.

Section 2.1.6, "Versioning": Details the versioning model for Document objects.

Section 2.2.2, "Document Objects": Describes the cmis:document base type.

2. Alfresco Documentation. (2017). CMIS. Alfresco Content Services 5.2 Documentation.

CMIS introduction: "CMIS provides a common data model for all the content and a set of services for working on the content...". The documentation details support for documents, folders, versioning, and policies but directs users to the Alfresco REST API for workflow interactions, confirming workflow is outside the CMIS scope.

The WorkflowDeployer bean in the Alfresco Spring context manages the deployment of process definitions. To ensure the latest version of a workflow is deployed during development, the redeploy property of this bean must be set to true. This forces the Activiti engine to deploy the process definition on server startup, even if a version with the same ID already exists. For production environments, this property should be set to false (the default value) to prevent accidental overwrites of stable, in-use process definitions and to ensure system stability.

A. reload is not the correct property for the WorkflowDeployer bean; the correct property is redeploy.

C. reload is not the correct property. The correct property to force deployment of a new version is redeploy.

D. Keeping redeploy="true" after the development cycle is completed is not recommended for production systems as it can lead to instability and unintended process definition overwrites.

1. Alfresco Content Services 5.2 Documentation, Deploying a process definition:

Reference: "The redeploy property is set to false by default. This means that if a process has been deployed, it won't be deployed again. This is a good safety feature for a production system. However, during development it is useful to have the process redeployed each time the server is started. To do this set the redeploy property to true."

Location: Alfresco Content Services 5.2 Docs > Developing > Repository-side development > Workflow > Deploying a process definition.

2. Alfresco Process Services 1.x Documentation (Activiti Engine Core Concepts):

Reference: The underlying Activiti engine's deployment mechanism, which Alfresco utilizes, distinguishes between deployments. The redeploy flag in the Alfresco wrapper bean simplifies the development cycle by forcing a new deployment with each restart, which is critical when process definition structures change.

Location: Alfresco Process Services 1.x Docs > Developer guide > Core concepts > Deployment. (This explains the core engine behavior that the redeploy property controls).

According to RESTful principles, which the Alfresco Web Script framework follows, the HTTP POST method is used to create a new resource. The request URI (/example/mycontent/item1) specifies the location where the new resource, 'item1', should be created within the '/example/mycontent' collection. While PUT can also be used to create a resource at a client-specified URI, POST is the standard verb for resource creation. The other HTTP methods correspond to different actions: GET for retrieval and PUT/PATCH for updates. Therefore, a POST request to this URL will result in the addition of a new resource.

A. Updating an existing resource is the conventional purpose of the PUT or PATCH methods, not POST.

B. This is a duplicate of option A and is incorrect for the same reason; PUT or PATCH are used for updates.

C. Returning the content of a resource is the function of the GET method.

1. Alfresco Content Services 5.2 Documentation, "Web Script types": "A RESTful Web Script is one that fully adheres to the principles of a RESTful service. In particular, this means: Explicit use of HTTP methods. For example, a GET performs a query, a POST creates a resource, a PUT updates a resource, and a DELETE removes a resource." (Source: Alfresco Documentation, specific section on RESTful Web Script conventions).

2. IETF RFC 7231, "Hypertext Transfer Protocol (HTTP/1.1): Semantics and Content", Section 4.3.3: This standard defines the POST method. It states, "The POST method requests that the target resource process the representation enclosed in the request... The fundamental difference between the POST and PUT methods is highlighted by the different meaning of the URIs... A POST request is subordinated to the URI... in the sense that the URI identifies a resource that will process the enclosed representation... for example, for creating a new resource in a collection." This confirms POST's primary role in resource creation.

Alfresco Content Services provides two primary, officially supported methods for an extension to generate audit events.

1. Declarative Auditing (@Auditable): An extension can use the @Auditable annotation on a service method. The Alfresco framework intercepts the method call and automatically generates an audit entry based on the annotation's configuration. This is the simplest way to audit method executions.

2. Programmatic Auditing (AuditService): For more complex scenarios requiring custom data or conditional auditing, an extension can inject the AuditService bean. By calling the recordAuditValues method on this service, the developer can programmatically create a detailed audit entry at any point in their code.

B. Open a connection to the database and write the audit information to the audit tables.

This is incorrect because directly manipulating the database bypasses the Alfresco service layer, transaction control, and caching, leading to data inconsistency and potential corruption.

C. Inject AuditComponent into the extension and call recordAuditValues.

While AuditComponent is the implementation of AuditService, best practice is to code against the public interface (AuditService). This option describes the same programmatic method as option E, making E the more appropriate answer.

D. Use the Alfresco REST API to record an audit event.

This is incorrect. The standard Alfresco v1 REST API provides endpoints for retrieving and purging audit data but does not include an endpoint for creating new audit entries.

1. Official Alfresco Documentation (ACS 5.2): Auditing Concepts. This document explicitly describes the two main approaches.

For @Auditable (Option A): "The @Auditable annotation can be used to audit method calls declaratively. This is the simplest way to audit a method call and requires no code other than the annotation itself."

For AuditService (Option E): "For more complex auditing, the AuditService can be used directly. This allows for more control over the data that is audited and also allows for auditing to be conditional."

Source: Alfresco Content Services 5.2 Documentation, "Auditing concepts". (docs.alfresco.com/5.2/concepts/audit-concepts.html)

2. Official Alfresco Documentation (ACS 5.2): AuditService JavaDoc. The JavaDoc for the AuditService interface confirms it is the public API for auditing functions, including recordAuditValues.

Source: Alfresco Content Services 5.2 JavaDoc, org.alfresco.service.cmr.audit.AuditService.

3. Official Alfresco Documentation (ACS 5.2): Audit REST API. The API reference for auditing shows only GET and DELETE endpoints for retrieving and managing audit entries, confirming the absence of a POST endpoint for creation.

Source: Alfresco Content Services 5.2 Documentation, "Audit REST API". (docs.alfresco.com/5.2/references/RESTful-Audit.html)