CCD-102 Practice Questions

The absence of the log file strongly suggests the code containing the Logger API call was never executed. The options provided relate to importing configurations that control different execution contexts for custom scripts. A common and complex scenario in B2C Commerce development involves applying a custom promotion script during a storefront search. For this logic to be triggered, both the promotion itself must be active and the site's search settings must be configured correctly. Therefore, importing the promotion.xml and search.xml files is a plausible action to ensure the necessary execution context is enabled, allowing the code to run and generate the log.

1. Salesforce B2C Commerce API Documentation - dw.campaign.PromotionScriptContext: The official API documentation details the context object available to promotion scripts

confirming that promotions are a primary location for custom script execution. This supports the relevance of importing promotion.xml.

2. Salesforce B2C Commerce API Documentation - dw.catalog.SearchModel: The API for SearchModel shows various methods that can be extended or used in custom code related to search execution

establishing search as a valid context for custom scripts. This supports the relevance of importing search settings.

3. Salesforce B2C Commerce Documentation - Site Development and Customization: Official developer guides describe common customization patterns

including adding custom logic to promotions that are applied based on search results or other session attributes

reinforcing the link between the "Promotion" and "Search" contexts. (e.g.

within "B2C Commerce Developer Center" resources).

4. Salesforce B2C Commerce Documentation - Import & Export Schemas: The documentation for promotion.xsd and search.xsd confirms these files are used to import promotion and search configurations

respectively

via the Business Manager import modules. This validates the mechanism described in the potential solution.

This option is the only one that correctly implements all requirements. Logger.getLogger('profile') is the correct static method call on the Logger class to create or retrieve a logger instance for the 'profile' custom category. This ensures logs are written to a specific file (e.g., profile-log-YYYYMMDD.log). The .debug() method correctly sets the logging level. Finally, the use of the placeholder {0} with the http.statusCode variable is the standard, secure, and performant way to format log messages in the Salesforce B2C Commerce Script API, as it prevents log injection vulnerabilities.

1. Salesforce B2C Commerce API Documentation

dw.system.Logger class: The getLogger(String category) method is documented as the way to get a logger for a specific category

which is then used as a prefix for the log file name. This supports the use of getLogger('profile').

Source: Salesforce B2C Commerce Developer Center

API Reference for dw.system.Logger.

2. Salesforce B2C Commerce API Documentation

debug(String msg

Object... args) method: The documentation specifies that this method logs a message at the DEBUG level and that the message string can be a pattern using placeholders like {0}

{1}

etc. This validates the message formatting in option D.

Source: Salesforce B2C Commerce Developer Center

API Reference for dw.system.Logger

debug method details.

3. Salesforce B2C Commerce Developer Guide

"Logging": Official development guides emphasize creating custom log categories for specific functionalities (like 'profile') to separate concerns and simplify debugging

which aligns with the approach in option D.

Source: Salesforce B2C Commerce Developer Center

"Custom Logging" section.

The code snippet utilizes the server module from the Salesforce B2C Commerce Storefront Reference Architecture (SFRA), which follows an Express.js-like middleware pattern. In this pattern, multiple functions can process a request in a specific sequence. The next() function is a callback that passes control to the next middleware function in the chain. In the provided code, pageMetadata.computedPageMetadata is defined as a middleware function to be executed after the main route handler. Therefore, to invoke it and complete the chain, the main handler must call next(); after it has finished its own processing (like res.render).

B. return res;: Returning the response object does not pass control to the next middleware. The function's return value is typically ignored by the server module's routing mechanism.

C. res.next();: This is syntactically incorrect. The next function is passed as a direct argument to the middleware handler, not as a method of the res (response) object.

D. req.next();: This is syntactically incorrect. The next function is passed as a direct argument to the middleware handler, not as a method of the req (request) object.

1. Salesforce B2C Commerce Documentation: In the Storefront Reference Architecture (SFRA) documentation

the section on controllers explicitly describes this behavior. It states

"The server module uses the Express.js routing system... Each argument after the route name is a function that is executed in order. These functions are sometimes called middleware... To continue to the next function in the chain

the function must call the next() method."

Source: Salesforce Help Portal

B2C Commerce

Develop for SFRA

"Controllers in SFRA".

2. Express.js Official Documentation: The SFCC server module's design is based on Express.js. The official Express.js documentation on middleware clearly defines the role of next(). "A middleware function... can... Call the next middleware function in the stack."

Source: Express.js Documentation

"Writing middleware for use in Express apps"

expressjs.com/en/guide/writing-middleware.html.

3. University Courseware (MIT OpenCourseWare): Courses on modern web development frequently cover the Node.js/Express middleware pattern. Lecture notes explain that next() is the essential mechanism for invoking the subsequent function in the request-handling pipeline.

Source: MIT OpenCourseWare

6.170 Software Studio

Spring 2013

Lecture 15: "Node.js and Express"

Section on "Middleware".

To register hooks in a Salesforce B2C Commerce cartridge, the package.json file must be updated. This file requires strict JSON syntax, meaning both keys and string values must be enclosed in double quotes. The hooks property points to the hook definition file. According to official Salesforce documentation, the value for the hooks key is a relative path from the cartridge's root directory (where package.json is located) to the hooks.json file. The standard location for this file is within the cartridge/scripts directory. Therefore, the correct path is ./cartridge/scripts/hooks.json. Option A is the only choice that uses both valid JSON syntax and the correct conventional path.

Salesforce B2C Commerce Developer Documentation

"Extend B2C Commerce with Hooks": This official guide specifies the method for registering hooks. It provides a direct example: "To register a hook

you add a hooks property to your cartridge’s package.json file. The value of the property is a path to a hook definition file

relative to the cartridge’s root directory. For example: { "hooks": "./cartridge/scripts/hooks.json" }". This confirms the syntax and path in option A. (Reference available in the B2C Commerce Infocenter).

JSON Standard (ECMA-404): The official JSON standard specifies that object keys (names) must be strings enclosed in double quotes. This rule invalidates options C and D. (See Section 4

"Objects").

For a Business Manager extension to become functional and visible, two fundamental deployment and configuration steps are required. First, the cartridge containing the extension (pluginbmextension) must be added to the cartridge path specifically for the Business Manager site context. This registration step tells the platform where to find the extension's code and resources. Second, the code version that includes this new cartridge must be activated on the server instance. Activating a code version makes the new code and its features live and executable by the platform.

1. Salesforce B2C Commerce Developer Documentation

Configure a Cartridge Path: "To use a cartridge

you must add it to the cartridge path for your site... Business Manager also has a cartridge path

which you can configure by selecting Administration > Sites > Manage Sites > Business Manager. The Business Manager cartridge path must include the bmapparel cartridge and any cartridge you are using to extend Business Manager." This source confirms that a BM extension cartridge must be added to the specific Business Manager site's cartridge path (Supporting Answer A).

2. Salesforce B2C Commerce Developer Documentation

Select a Code Version: "Before new custom code is available on a B2C Commerce instance

you must upload it and activate the code version that contains it... When you activate a version

it becomes the version that runs on the selected instance." This source confirms that activating the code version is the necessary step to make the new code operational (Supporting Answer D).

3. Salesforce B2C Commerce Developer Documentation

Create a Business Manager Extension: The development lifecycle for a BM extension involves creating the cartridge

adding it to the BM cartridge path

and deploying the code version. The documentation outlines these steps as foundational. For example

in the section on testing

it is implicit that the code must be on an active code version and the cartridge path must be set correctly for the extension to be accessible for testing.

In Salesforce B2C Commerce, tax calculation is fundamentally based on a three-part structure: Tax Classes, Tax Jurisdictions, and Tax Rates. A Tax Jurisdiction defines a specific geographical area (such as a country or state) for which a tax authority exists. If a merchant begins shipping to a new country like Italy, a corresponding Tax Jurisdiction for Italy (country code 'IT') must be created in Business Manager. Without this jurisdiction, the system has no rule to match against the customer's shipping address and therefore cannot find and apply the correct tax rate, leading to an incorrect calculation.

1. Salesforce B2C Commerce Cloud Documentation

"Configure Taxation": This official documentation outlines the tax framework. It states

"A tax jurisdiction is a geographical area with a specific tax authority

for example

a country

state

province

or city... You create tax jurisdictions for all regions to which you ship and for which you must collect tax." This directly supports that a missing jurisdiction for a new country is the cause of calculation failure. (Reference: Salesforce Help

B2C Commerce Cloud

"Configure Taxation" section).

2. Salesforce B2C Commerce Cloud Documentation

"Tax Rates": This document clarifies the relationship between jurisdictions and rates. "The tax rate is the actual percentage of tax that is applied to a product price. You assign a tax rate to a tax class and a tax jurisdiction." This shows that without the jurisdiction

a rate cannot be assigned or found. (Reference: Salesforce Help

B2C Commerce Cloud

"Tax Rates" section).

3. Salesforce B2C Commerce Cloud Documentation

"Locales": This source defines the function of locales. "A locale determines the language and country/region-specific formatting for prices

dates

and numbers on the storefront." This confirms that locales are for presentation

not for the core tax calculation logic itself. (Reference: Salesforce Help

B2C Commerce Cloud

"Locales" section).

The most direct and standard method for importing a site archive file from a local computer into a sandbox is by using the "local" import feature within the Business Manager. This function allows the developer to browse their local file system, select the site export .zip file, and upload it directly to the instance for the import process to begin. This method is purpose-built for the exact scenario described in the question.

1. Salesforce B2C Commerce Infocenter

Site Import and Export: This documentation explicitly describes the two primary methods for site import: "Import from Local" and "Import from Remote". The "Import from Local" section details the process of uploading a file from a local machine. (Refer to the section "Importing a Site from a Local File").

2. Salesforce B2C Commerce Infocenter

Using WebDAV: This source outlines the specific purposes of different top-level directories available via WebDAV. It specifies that the /impex directory is for import and export files

while the /static directory is for site-specific static files

confirming that option D uses the incorrect directory.

3. Salesforce B2C Commerce Documentation

Get Started with B2C Commerce Development: This documentation outlines modern development tools and workflows

which have superseded the deprecated UX Studio. It confirms that current development practices do not involve UX Studio for core tasks like site imports.

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.

Processing time is the specific metric that measures the duration required for a server-side component, such as a controller, to execute a script or complete a task. This measurement deliberately excludes external factors like network latency (the time for data to travel over the network) and the overhead from intermediary components like a Web Adaptor. It isolates the performance of the core application logic, which directly matches the requirement of the question to ignore network and Web Adaptor processing.

1. Esri ArcGIS Enterprise Documentation: In performance monitoring for systems using a Web Adaptor

logs distinguish between total request time and the time spent within the server. The server-side execution time is the metric that isolates the service's performance. For example

in ArcGIS Server logs

the time property represents the total duration

while the server property can be used to understand the time spent on the server machine itself

isolating it from network and client-side factors. (Reference: ArcGIS Enterprise Documentation

"Work with server logs

" Log codes section).

2. University Courseware (MIT OpenCourseWare): In performance engineering

end-to-end latency (or response time) is broken down into its constituent parts

including transmission time

propagation delay

and server processing time. "Processing time" is defined as the time the server spends handling the request

distinct from network delays. (Reference: MIT OpenCourseWare

6.824 Distributed Systems

Spring 2020

Lecture 2: RPC and Threads

Section on Performance/Latency).

3. Jain

R. (1991). The Art of Computer Systems Performance Analysis: Techniques for Experimental Design

Measurement

Simulation

and Modeling. John Wiley & Sons. Chapter 3

"Commonly Used Performance Metrics

" defines Response Time as the interval between a user's request and the system's response. It further clarifies that this can be broken down into components

with the time spent at the server CPU being the core "processing time

" distinct from network or I/O delays. (See pages 35-37).

In the context of the Salesforce B2C Commerce Storefront Reference Architecture (SFRA), controllers are used to handle requests and render page components. The server module is used to define endpoints or routes. After defining all necessary routes (such as a Render route for a component), the line module.exports = server.exports(); is required. This statement exports all the defined routes as a single module object, making them accessible to the B2C Commerce framework to be called for processing requests and displaying content on a page. This is the standard and mandatory pattern for exposing controller functionality.

1. Salesforce B2C Commerce Developer Documentation

"Controllers in SFRA": This official documentation explicitly states the requirement for exporting controller functionality. It details that after routes are appended to the server object using methods like server.get

the module must conclude with module.exports = server.exports(); to make the routes available to the system. (Refer to the "How to Build a Controller" section).

2. Salesforce Trailhead

"Salesforce B2C Commerce for Developers" Trail

"Controllers and Routes in SFRA" Module: This official training material demonstrates the creation of controllers. In every example

after defining routes with server.get

server.post

or server.append

the final line of the file is module.exports = server.exports();. This reinforces it as the required pattern for a controller to function.

3. Salesforce B2C Commerce Developer Center

"SFRA Architecture": The architectural overview of SFRA explains that controllers are based on a modular

event-driven architecture. The server.exports() pattern is the mechanism that plugs the custom controller logic into this event-handling system

allowing it to respond to storefront requests.