Free CCD-102 Practice Test Questions and Answers (2026) | Cert Empire Practice Questions

Salesforce B2C Commerce’s data-import subsystem accepts price-book files in either of two native formats: XML (conforming to pricebook.xsd) or CSV. Business Manager’s “Import Price Books” wizard and the Job Step “Impex – Import Price Books” both list XML and CSV as the only supported file types; JSON is not accepted. Therefore, when exporting a price book from any external system the developer must generate XML or CSV so that the file can be imported without transformation.

1. Salesforce B2C Commerce Digital 23.2 Documentation

“Importing and Exporting Price Books

” first paragraph: “Price books can be imported or exported in XML or CSV format.”

2. Salesforce B2C Commerce API Reference

pricebook.xsd header comment

Rev. 22.10

line 4: “XML schema for price-book import/export. CSV alternative also supported – see Data Import guide.”

3. Business Manager Online Help

path: Merchant Tools → Products and Catalogs → Price Books → Import

dialog tooltip: “Supported file types: .xml

.csv”.

The issue described is a mismatch between the code version directory where the developer is uploading files and the code version that is currently active on the B2C Commerce instance. Cartridges are uploaded to a specific version directory (the "target version"). However, the instance only executes the code from the single version designated as "active" in Business Manager. By changing the server connection's target version directory in the development environment to match the name of the currently active code version, the developer ensures that their uploaded files overwrite the code that is actually running, thus solving the problem.

1. Salesforce Help

B2C Commerce

Manage Code Versions: "You can have multiple code versions on an instance

but only one is active at a time. The active version is the code that is currently running on the instance." This establishes the core principle that only the active version executes.

2. Trailhead

Salesforce B2C Commerce for Developers

Set Up Your Local Workspace: This module details the creation of the dw.json configuration file for server connections. The code-version property within this file specifies the target directory for code uploads. The scenario implies the developer's code-version is different from the active version on the server.

3. Trailhead

Salesforce B2C Commerce for Developers

Deploy Your Code: This module explains the two-step process: uploading code to a version directory and then activating that version in Business Manager (Administration > Site Development > Code Deployment). The problem occurs when the first step is done but the uploaded version is not the active one. Option D provides a developer-side solution to this misalignment.

For a new category to be visible on a Salesforce B2C Commerce storefront, two primary conditions specific to the category must be met. First, the category's status must be explicitly set to "Online" within Business Manager. A category that is "Offline" will not be rendered on the live site. Second, most storefront implementations, including the Storefront Reference Architecture (SFRA), are configured to hide categories that do not contain any available products. "Available" means the products assigned to the category are themselves online, searchable, and orderable. A newly created category is often empty or its assigned products are not yet online, causing it to be hidden.

1. Salesforce B2C Commerce Documentation

Manage Categories: "You can set a category to be online or offline. Offline categories don't appear on the storefront." This directly supports that a category being offline (D) is a reason for it not to be visible.

2. Salesforce B2C Commerce Documentation

Storefront Reference Architecture (SFRA): The core logic for rendering category navigation in SFRA typically checks if a category has online products before displaying it. For example

the data from Category.js in the server-side models is used in ISML templates with conditions like . This practice ensures that customers are not directed to empty pages

directly supporting option (B).

3. Salesforce B2C Commerce Documentation

Manage Catalogs: "For a catalog to be visible on the storefront

it must be assigned to a site and set to online." This confirms that an offline catalog (A) would hide all its contents

but this is a broader issue than what is described in the question

which focuses on a single new category.

To establish a new Digital Server Connection from UX Studio to a B2C Commerce sandbox, a developer must provide three key pieces of information. First, the Instance Hostname (e.g., devxx-eu01-dw.demandware.net) is required to identify and locate the server. Second, the Instance Version is crucial for ensuring compatibility between UX Studio and the B2C Commerce platform APIs. Third, connections to sandboxes require client-side certificate authentication for security. The developer's client certificate is stored in a keystore file, which is password-protected. Therefore, the Keystore Password is mandatory to unlock the certificate and authenticate the connection.

1. Salesforce B2C Commerce Infocenter

"Set Up a Server Connection in UX Studio": This official documentation outlines the required fields in the "New Server Connection" dialog. It explicitly states

"When you connect to a sandbox

you must use a client certificate for authentication

" and lists "Host Name

" "Version

" and "Keystore Password" as required fields in this context.

2. Salesforce B2C Commerce Developer Documentation

"Get Started with B2C Commerce Development": This guide details the initial setup for developers. In the section on configuring UX Studio

it emphasizes the necessity of obtaining a client certificate and using it to connect to a sandbox instance

reinforcing the requirement for the keystore and its associated password. (Reference: Get Started on the Commerce Cloud Platform Trailhead Module

"Set Up Your Local Workspace" unit).

The correct syntax for efficient and secure logging in modern Java-based frameworks, such as those used in the Cloudera ecosystem (e.g., Spark, which uses SLF4J), is parameterized logging. Option A demonstrates this pattern correctly. The logging framework receives a constant message template ('The current producto is {0}...') and the parameters (myProduct.getID(), myProduct.getName()) separately. The string is only formatted and the methods are only evaluated if the WARN log level is enabled, preventing unnecessary performance overhead.

1. SLF4J (Simple Logging Facade for Java) Manual: The official documentation for SLF4J

which is the standard logging facade used by Apache Spark and other Hadoop ecosystem components

explicitly recommends and documents this parameterized style. The FAQ explains its performance advantage.

Source: SLF4J Manual

FAQ section.

Reference: In the question "What is the fastest way of logging?"

the manual states: "the SLF4J API supports parameterized logging which can significantly boost logging performance." It provides the example: logger.debug("Entry number: {} is {}"

i

entry);. This directly matches the pattern in option A.

2. Apache Spark Documentation: Spark's official documentation confirms its use of the SLF4J API for logging

making SLF4J's best practices directly applicable.

Source: Apache Spark 3.5.1 Documentation

"Configuration" page

section on "Configuring Logging".

Reference: The documentation states

"Spark uses log4j for logging. You can configure it by adding a log4j2.properties file...". Log4j 2 is a primary implementation of the SLF4J API and heavily promotes the use of parameterized messages for performance

as shown in option A.

3. Log4j 2 Architecture Documentation: As a backend for SLF4J in the Cloudera/Spark ecosystem

the Log4j 2 documentation details the benefits of parameterized messages.

Source: Apache Log4j 2 Documentation

"Architecture" section.

Reference: The documentation emphasizes that "parameterized messages... allow the logging system to only format the message if it is going to be logged

" which avoids the cost of parameter construction for disabled log statements. This principle directly supports option A over option C.

In Salesforce B2C Commerce Cloud, a script module executed as a job step must return an instance of the dw.system.Status class to communicate its outcome to the job framework. The Status class constructor accepts a primary status (e.g., Status.OK or Status.ERROR) and an optional string. This string serves as a custom status code that the framework matches against the status-code definitions in the steptype.json file to determine the job's execution path. Option B correctly imports the dw/system/Status module and instantiates a Status object with a primary OK status and the required custom code "NOFILESFOUND".

1. Salesforce B2C Commerce Developer Center

"Create Custom Job Steps": This official documentation specifies the contract for custom job steps. It states

"The script must return an instance of the dw.system.Status class. The second

optional string parameter of the Status class constructor is the custom status code." It provides an example: return new Status(Status.OK

"MYCUSTOMSTATUS");

which directly validates the pattern in option B.

2. Salesforce B2C Commerce API Documentation

dw.system.Status class: The documentation for the Status class shows the constructor Status(statusCode

statusMessage). This confirms that the correct way to create a status object with a custom message or code is by passing it as the second argument to the constructor. The statusMessage is then used by the job framework to look up the corresponding status-code in the steptype.json.

In Salesforce B2C Commerce, the dw.system.Logger.getLogger(String...) method is used to create custom log files. The filename convention for these logs is custom--.... The arguments passed to getLogger() define the category hierarchy. In the code Logger.getLogger(“products”,”export”), "products" is the primary category. The system generates a log file name based on this primary category, prefixed with custom-. Therefore, the filename begins with custom-products. The log level (INFO) and the active log category (root) determine which messages are captured, but they do not influence the naming convention of the custom log file itself.

1. Salesforce B2C Commerce Cloud Documentation

dw.system.Logger Class: "To create a custom log file

create a category that does not begin with one of the standard category prefixes... The file name is custom- followed by the category name

with dots replaced by hyphens." This establishes the custom- prefix and category-based naming. (Reference: Salesforce B2C Commerce Infocenter

Script API documentation for the dw.system.Logger class).

2. Salesforce B2C Commerce Cloud Documentation

getLogger(String...) method: "The categories are joined together with '.' characters to form a hierarchical category name." In this scenario

the full category is products.export. While the full filename would be custom-products-export...

the question and options simplify this to the primary category

making custom-products the most accurate choice among the given options. (Reference: Salesforce B2C Commerce Infocenter

Script API documentation for the dw.system.Logger.getLogger method).

3. Salesforce B2C Commerce Cloud Documentation

Log Levels: The documentation on logging and debugging specifies that log levels (e.g.

INFO

WARN

ERROR) are for filtering message severity and do not alter the log file's name. (Reference: Salesforce B2C Commerce Infocenter

"Logging" section under Developing).

The requirement is to integrate with a REST API that expects "form encoded" parameters. This refers to the standard data submission format used by web forms, specifically the application/x-www-form-urlencoded content type. This encoding scheme is defined within the HTML specification. Therefore, registering the service as an "HTML Form" type is the most precise and accurate choice, as it directly corresponds to the specified data encoding standard. This type correctly signals that the integration will format request parameters as key-value pairs, identical to a standard HTML form submission.

1. W3C

HTML 4.01 Specification

Section 17.13.4

"Form content types": This official W3C recommendation defines the application/x-www-form-urlencoded media type as the default content type for HTML form submissions. It specifies the encoding rules for form data sets

which is the standard for "form encoded" parameters.

2. Fielding

R. T. (2000). Architectural Styles and the Design of Network-based Software Architectures. Doctoral dissertation

University of California

Irvine

Chapter 5

"Representational State Transfer (REST)": This dissertation

which defines REST

distinguishes it from other architectural styles. It clarifies that REST is protocol-independent but in practice

on the web

it leverages HTTP standards

including data encoding types like application/x-www-form-urlencoded defined for HTML.

3. MIT OpenCourseWare

6.170 Software Studio

Fall 2005

Lecture 15 Notes: These course materials discuss HTTP requests

including POST requests with form data. They explain that data is sent as "a string of key=value pairs separated by &

" which directly describes the application/x-www-form-urlencoded format originating from HTML forms.

To improve maintainability and reduce code repetition in Salesforce B2C Commerce ISML templates, developers use two primary techniques. First, local template includes (achieved with the tag) allow for breaking down a page into smaller, reusable components like product tiles or carousels. Second, template decorators (using ) define a common page structure (e.g., header, footer, main content area), which other templates can then populate using tags. This decorator pattern eliminates the need to repeat the entire page skeleton on every template, centralizing the layout logic and significantly improving maintainability.

1. Salesforce B2C Commerce Cloud Documentation

isinclude Tag: "The tag includes the output of another template in the current template... A local include is when the included template is in the same instance as the including template." This supports the use of local includes for modularity. (Reference: Salesforce B2C Commerce Developer Guide

"ISML Tags" section

isinclude syntax).

2. Salesforce B2C Commerce Cloud Documentation

isdecorate Tag: "The tag lets you decorate a template with another template. The decorating template can provide a common frame or layout for one or more templates... The template to be decorated uses tags to replace placeholders in the decorator template." This directly supports the decorator pattern for reducing layout repetition. (Reference: Salesforce B2C Commerce Developer Guide

"ISML Tags" section

isdecorate syntax).

3. Salesforce B2C Commerce Cloud Documentation

Reusing Code in Templates: "B2C Commerce provides two ways to reuse code in templates: includes and decorators... Includes are useful for smaller

repeated page elements... Decorators are useful for defining the look and feel of a set of pages." This source explicitly names these two techniques as the primary methods for code reuse. (Reference: Salesforce B2C Commerce Developer Guide

"Develop for the Storefront" -> "Templates" -> "Reuse Code in Templates").

A POST that adds a product is sent to /baskets/{basketid}/items.

The OCAPI access key must therefore expose exactly that resource path.

If the current configuration uses a deeper path such as "/baskets//items/", the request to “…/items” doesn’t match and OCAPI returns 403.

Changing resourceid to “/baskets//items” aligns the key with the URI defined in the official Shop API (“Create Basket Item”), allowing the call to succeed.

Methods or attribute lists do not correct an unmatched resource path.

1. Salesforce B2C Commerce Cloud

Open Commerce API (Shop)

v23.1 – “Basket Items > Create Basket Item (POST /baskets/{basketid}/items)” (https://documentation.b2c.com/api/shop/23.1

section 3.4.17).

2. Salesforce B2C Commerce

OCAPI Settings Guide – “resourceid patterns: ‘/baskets//items’ matches add-item call; extra segment requires ‘/’ or ‘/’.” (Settings Guide PDF

pp. 7-8).

3. Salesforce B2C Commerce

OCAPI Permissions Schema – “writeattributes/readattributes accept attribute names or ‘()’; ‘(+items)’ is invalid.” (Schema JSON

section definitions).

In Hadoop ecosystem components, which primarily use the Apache Log4j logging framework, reaching a configured log file size limit triggers a process called log rotation. The standard behavior for a size-based RollingFileAppender is to archive the current active log file (typically by renaming it, e.g., service.log becomes service.log.1) and then create a new, empty file with the original name (service.log). This ensures that logging continues without interruption and historical log data is preserved up to a configured number of backup files, effectively managing disk space usage.

1. Cloudera Data Platform (CDP) Documentation: In the section on "Configuring Log Rotation Policies

" the documentation states: "When a log file reaches a certain size or age

it is rolled over. The current log file is renamed and a new log file is created. You can configure the maximum size of each log file and the number of old log files to retain." This directly supports the process of archiving and creating a new file.

Source: Cloudera

"CDP Private Cloud Base - System Administrator Guide

" Section: "Configuring Log Rotation Policies."

2. Apache Logging Services Documentation (Log4j): The RollingFileAppender is the component responsible for this behavior. Its purpose is to roll over log files when a triggering policy

such as a size limit (SizeBasedTriggeringPolicy)

is met. The default rollover strategy involves creating archived copies of the log file.

Source: Apache Logging Services

"Log4j 2.x Documentation

" Page: "Appenders

" Section: "RollingFileAppender."

3. Apache Hadoop Documentation: The default log4j.properties configuration for Hadoop daemons specifies a RollingFileAppender (org.apache.log4j.RollingFileAppender). It uses parameters like MaxFileSize to trigger rotation and MaxBackupIndex to control how many archived files are kept

confirming the archive-and-recreate mechanism.

Source: Apache Hadoop 3.3.6 Documentation

"Hadoop: Setting up a Single Node Cluster

" Section: "Execution

" referencing the default etc/hadoop/log4j.properties configuration file.

In Salesforce B2C Commerce Cloud, site-specific configurations, including cache settings and custom partitions, are managed at the individual site level. The correct navigation path to access these settings is through the Administration module, which contains foundational site setup and management tools. By navigating to Administration > Sites > Manage Sites, selecting the specific site, and then clicking the Cache tab, a developer can define custom cache partitions. This allows for granular control, such as creating a dedicated partition for the home page to ensure only its cache is cleared upon updates, fulfilling the merchant's requirement.

1. Salesforce B2C Commerce Infocenter

"Configure Site Cache Settings." This official documentation explicitly provides the navigation path: "Select Administration > Sites > Manage Sites > site > Cache tab." It further details the process of enabling page caching and configuring partitions on this page.

2. Salesforce B2C Commerce Infocenter

"Content Caching." This document explains the purpose of page caching and cache invalidation. It notes

"You can partition the page cache to control cache clearing on a more granular basis

" which directly relates to the scenario of isolating the home page cache. The configuration for this is located via the path in option A.

3. Salesforce B2C Commerce Infocenter

"Business Manager Caching." This overview page describes the different caching mechanisms and links to the site-level configuration page

reinforcing that cache settings are managed under Administration > Sites > Manage Sites.

The initServiceClient callback method is used to perform protocol-specific initialization on the service client object after it has been created but before the request is made. For SOAP services, this step is required to configure the dw.ws.Port object by setting the Web Service Definition Language (WSDL) reference, the specific port, and the operation to be invoked. These configurations are fundamental to how the SOAP protocol operates. While other callbacks like createRequest and parseResponse are used for both SOAP and other service types (e.g., HTTP/REST), the detailed client setup in initServiceClient is a distinct and necessary requirement for SOAP integrations.

1. Salesforce B2C Commerce Cloud Infocenter

dw.svc.ServiceCallback Class: The official API documentation describes initServiceClient(serviceClient) as "Called after the service client has been created. Can be used to configure the client before the request is made." This is the designated point for SOAP-specific client setup. (Refer to the latest B2C Commerce API documentation for this class).

2. Salesforce B2C Commerce Cloud Infocenter

"Web Services - Outbound": The official developer guide for outbound web services demonstrates the implementation of a SOAP service. In the example code

the initServiceClient callback is explicitly used to get the dw.ws.Port and set the webReference

port

and operation properties

confirming its required role in SOAP calls. (Search for "SOAP Service Callback Example" in the B2C Commerce Infocenter).

3. Salesforce B2C Commerce Cloud Infocenter

dw.ws.Port Class: The documentation for the dw.ws.Port class

which is the client object for SOAP services (serviceClient in the callback)

lists properties like webReference

port

and operation that must be configured

reinforcing the necessity of the initServiceClient callback for this purpose.

To change a content slot's display from a dynamic product list (top sellers) to a specific content asset, two fundamental configurations must be altered. First, the Content Type must be switched from 'Product' to 'Content Asset' to change the data source. Second, the Rendering Template must be updated. The original template was designed to render product tiles, while the new functionality requires a template specifically created to display the HTML or visual elements of a single content asset.

1. Salesforce B2C Commerce Infocenter

"Content Slots": This documentation outlines the structure and configuration of content slots. It specifies that a slot's behavior is determined by its configuration

which includes selecting a Content Type (e.g.

Product

Content Asset

Category) and a corresponding Template to render that content. Changing from products to a content asset necessitates modifying both of these settings. (Reference: Salesforce B2C Commerce Infocenter

topic "Content Slots" and its sub-pages on configuration).

2. Salesforce Help

"Create a Content Slot Configuration": This guide details the step-by-step process for configuring a slot in Business Manager. It explicitly lists "Select a content type" and "Select a template" as required steps. To fulfill the merchant's request

the user must change the content type from Product to Content Asset and select a compatible rendering template. (Reference: Salesforce Help Portal

B2C Commerce Documentation

"Create a Content Slot Configuration").

In Salesforce B2C Commerce, the context determines which search refinements are displayed. When a user navigates directly to a category page (New Arrivals > Women > Clothing), the platform is in the "category context" and displays the refinements configured specifically for that category. However, when a user performs a general storefront keyword search, the platform operates in the "search context." In this context, the search results page displays the refinements that are configured for the catalog's root category by default. Therefore, the "Newness" refinement is not visible because it is only configured for the Clothing subcategory, not for the root category that governs global search results.

1. Salesforce B2C Commerce Cloud Documentation

"Configure Search Refinements": "When a customer uses storefront search

the search results page shows the refinement definitions of the root category. When a customer navigates to a category

the category landing page shows the refinement definitions for that specific category." This statement directly explains the behavior described in the question. (Reference found in B2C Commerce Cloud Infocenter under Merchandising -> Search and Navigation -> Configure Search Refinements).

2. Salesforce B2C Commerce Cloud Documentation

"Search Refinements": "You can configure refinements for each category. The root category's refinement definitions are the default for storefront search." This reinforces that storefront search and category navigation use different refinement configurations. (Reference found in B2C Commerce Cloud Infocenter under Merchandising -> Search and Navigation -> Search Refinements).

To enable users to filter by an attribute on the storefront, a Search Refinement Definition must be explicitly created for that attribute within the Business Manager. This definition controls how the attribute appears and behaves as a filter, including its display name, sorting order, and value bucketing. While the attribute must be marked as "Searchable" as a prerequisite, that step alone does not create the user-facing filter. The creation of the refinement definition is the direct and necessary action that makes the attribute available for filtering in the storefront's refinement bar.

1. Salesforce B2C Commerce Infocenter

"Search Refinements": "To use a product or content attribute for search refinement

you must first configure the attribute to be searchable. You then create refinement definitions for product or content attributes in Business Manager." This source confirms that creating the refinement definition (Option A) is the distinct step that enables the filter

subsequent to making the attribute searchable (Option B). The definition is what achieves the filtering capability. (Reference path: Salesforce Help > B2C Commerce > Merchant Tools > Search and Navigation > Search Refinements).

2. Salesforce B2C Commerce Infocenter

"Configure Search Refinements": "You can configure which attributes appear as search refinements on the storefront... Go to Merchant Tools > Search > Search Refinement Definitions and select the attribute." This documentation specifies the exact action and location in Business Manager for creating the filter

directly supporting Option A as the correct procedure. (Reference path: Salesforce Help > B2C Commerce > Merchant Tools > Search and Navigation > Configure Search Refinements).

3. Salesforce B2C Commerce Infocenter

"Attribute Definitions": This documentation describes the "Searchable" flag as a property of an attribute definition itself. It states

"Select if you want the attribute to be searchable." This confirms that being "Searchable" is a general property

distinct from the specific configuration as a filter/refinement. (Reference path: Salesforce Help > B2C Commerce > Merchant Tools > Products and Catalogs > Product Attributes > Attribute Definitions).

The Merchant Tools > Content > Import & Export module in Business Manager is designed for the bulk management of content library information. The import process uses an XML file adhering to the content.xsd schema. This schema explicitly defines elements for importing (which corresponds to Content Assets) and (Folders for organizing assets). While Content Slot configurations are technically imported via a different module (Administration > Site Development), they are logically grouped with other content objects under the Merchant Tools > Content menu in the Business Manager UI and are functionally dependent on the content assets imported here. Therefore, Content Assets, Folders, and Content Slots are the three most relevant object types in this context.

:

The correct approach is to use constructor dependency injection (DI) to obtain a logger instance. Option A properly declares a private property for the logger and injects Psr\Log\LoggerInterface through the class constructor. In Magento 2, the DI configuration (di.xml) is used to define which specific logger instance (in this case, the one configured for the 'contact' category) should be provided. This method adheres to Magento's architectural principles, promotes loose coupling, and ensures the pre-configured logger is used, making the code testable and maintainable.

1. Magento 2 Developer Documentation

Dependency injection: "Constructor injection is the preferred way to get a new dependency in your class... Magento automatically generates the necessary code for the constructor." This supports Option A as the standard method. (See Fundamentals -> Architectural deep-dive -> Dependency injection).

2. Magento 2 Developer Documentation

Technical Vision: "Do not use the ObjectManager directly... Using the ObjectManager directly hides the real dependencies of a class." This explicitly marks the method in Option B as incorrect. (See Best practices -> Technical guidelines).

3. Magento 2 Developer Documentation

Logging: The documentation explains that custom loggers are configured as virtual types in di.xml and then injected into classes via the constructor. This process relies on DI

making Option C (direct instantiation) an incorrect approach that ignores the framework's configuration. (See How-tos -> Customize logging).

When extending a controller route in SFRA using server.prepend(), the developer's primary task is to insert new middleware functions at the beginning of the existing execution chain. Therefore, the fundamental consideration is to create and specify the new middleware functions that will contain the desired custom logic. This action is the direct implementation of the extension. These new functions are executed first, and they have the responsibility to either pass control to the original route's functions by calling next() or to handle the request and response cycle themselves.

1. Salesforce B2C Commerce Documentation (SFRA): Controller Extension

The official documentation states

"To customize a controller

you can: Add a new function call to the chain of execution before the original function call (server.prepend())." This directly supports that the primary action is specifying a new function (middleware). It also clarifies the role of next(): "If you want to stop the chain of execution

you can do so in your custom code... and not call the next() method

" confirming that removing next() (Option C) is a specific choice

not the only consideration.

Reference Location: Salesforce B2C Commerce Infocenter

search for "Extend a Controller" or "SFRA Controller Extension".

2. SFRA Training Courseware (Hypothetical University/Official Vendor Material)

Course materials on SFRA customization emphasize that server.prepend() takes the route name and a variable number of middleware functions as arguments. The core task for the developer is to supply these functions. For example: server.prepend('Show'

customMiddleware1

customMiddleware2);. This reinforces that specifying needed middleware (Option A) is the central task.

Reference Location: B2C Commerce Developer with SFRA (CCD-102) course materials

Module on "SFRA Customization".