Industries-CPQ-Developer Practice Test Questions

Explanation:

In Salesforce Industries (Vlocity) CPQ, the Price Details window is used to understand how the final price was calculated for a cart line item. To detect adjustments (discounts, promotions, overrides), you look specifically at elements that describe changes applied on top of the base price.

Option-by-option breakdown

❌ A. The display text of the base price:
Shows the starting price from the price list.
Does not indicate any adjustments applied afterward.

✅ B. The display text of the pricing adjustment (Correct):
Explicitly shows:
* Discounts
* Promotions
* Amount or percentage reductions
This is a primary indicator that an adjustment was applied.

✅ C. The display text of the pricing override (Correct):
Indicates that the original calculated price was manually or programmatically overridden.
Overrides are a type of adjustment, and their display text reveals that change.

❌ D. The display text of the product description:
Descriptive only.
Unrelated to pricing logic or adjustments.

❌ E. The display text of the price list:
Identifies the source of the base price.
Does not reflect discounts or overrides.

📚 Key Exam Concept to Remember:
Adjustments and overrides are layered on top of the base price and are surfaced explicitly in the Price Details view.

Explanation:

Vlocity decouples pricing from the product record. While a standard Salesforce Product record can only have one "List Price" per Price Book, Vlocity Price Lists provide much more flexibility:

Segmented Pricing:
You can have a "Retail Price List" where a phone costs $800 and an "Employee Price List" where the same phone costs $600. Both are "Base Prices" (Price List Entries), but they reside in different containers.

Contextual Selection:
When the Cart is launched, the system determines which Price List to use. Once a Price List is selected, the CPQ engine only "sees" the base price assigned to that specific list.

Simplified Management:
This prevents "Product Sprawl." Instead of creating "Phone - Retail" and "Phone - Employee" as two separate products, you maintain one product with two distinct entries across different Price Lists.

Analysis of Incorrect Answers

B. You don't need the Salesforce price book:
This is a common misconception. While Vlocity uses its own Price Lists for logic, the underlying Salesforce architecture still requires a Standard Price Book to be present and the product to be active within it. Vlocity Price Lists essentially sit "on top" of the Salesforce Price Book structure.

C. You can ignore affectivity time frames:
Actually, multiple price lists make affectivity (start and end dates) more important. You must ensure that the Price List itself and the individual Price List Entries are active and within their valid time frames for the CPQ engine to retrieve the price correctly.

References:
Salesforce Help: Price Lists in Industries CPQ
Vlocity Documentation: Multiple Price Lists and Pricing Elements

Explanation:

Promotions and Child Product Discounts in Salesforce CPQ/Vlocity:
Promotions can include time-bound discounts on child products (e.g., "20% off for the first 3 months of a 12-month promotion").
The parent promotion’s end date and child product discount’s end date are independent.

Why "True"?

Example:
Promotion runs for 12 months (Jan–Dec).
Child product discount expires after 3 months (Jan–Mar).

Reference: Salesforce CPQ Promotions

Explanation:

In Salesforce Industries CPQ, the Qualification context rule type is used to determine whether a customer is eligible for a promotion before it’s added to the cart. These rules evaluate conditions such as:

Account type (e.g., B2B vs. B2C)
Customer location
Subscription status
Any custom field or context dimension

By applying Qualification rules, you ensure that promotions are only offered to customers who meet specific criteria—helping maintain pricing integrity and targeting accuracy.

❌ Why not Penalty?
Penalty rules are used to apply consequences (like fees or restrictions) when a customer cancels a promotion or contract early.
They do not determine initial eligibility.

Explanation:

In Salesforce Industries CPQ (formerly Vlocity CPQ), Guided Selling experiences (including the Vlocity Cart / Industries Cart in OmniScripts or guided flows) use remote actions to perform CPQ operations such as:

Creating carts (createCart)
Getting cart items (getCartsItems)
Getting cart products (getCartsProducts)
Adding/updating items (postCartsItems, putCartsItems)
Checking out/submitting (checkout, submit)

These remote methods are not individual classes but methods on the global Apex class/interface CpqAppHandler (full name: vlocity_cmt.CpqAppHandler).

CpqAppHandler:
CpqAppHandler is the central class that exposes all CPQ cart-based operations.
In OmniScripts (common in Guided Selling), remote actions invoke CpqAppHandler methods via invokeMethod (e.g., cpqAppHandler.invokeMethod('getCartsProducts', inputMap, ...)).
Official documentation and APIs refer to these as CpqAppHandler methods or Cart-Based APIs (REST endpoints map to the same underlying logic).
You can also implement custom hooks via CpqAppHandlerHook to extend Pre/Post invoke behavior for these methods.

Why not the other options?

A. done — Not a class or method name (likely a status or placeholder).
B. vlcCart — Refers to the persistent cart component (Angular/LWC directive or UI element in Vlocity Cart), not the class handling remote methods.
D. createCart — This is a method on CpqAppHandler (used to create a new cart), not the class itself.
E. getCartsltems (likely typo for getCartsItems) — Method on CpqAppHandler.
F. getCartsProducts — Method on CpqAppHandler.
G. putCartsltems (putCartsItems) — Method on CpqAppHandler.
H. postCartsltems (postCartsItems) — Method for adding items.
I. checkout — Method for checkout.
J. submit — Likely refers to submitOrder or similar, but still a method.

The question asks for the class containing these remote methods → CpqAppHandler.

Key Concept Summary:

Guided Selling → Relies on OmniScripts calling remote actions to CpqAppHandler methods for cart operations.
CpqAppHandler → Global interface/class with methods like createCart, getCartsProducts, postCartsItems, checkout, etc.
Cart-Based APIs (REST) and remote actions in UI/OmniScripts both use this class under the hood.
Custom extensions use CpqAppHandlerHook interface.

References:
Salesforce Help: "Cart-Based APIs" and "CpqAppHandler" sections in Industries CPQ docs — Describes CpqAppHandler as the class managing CPQ functions in cart/guided selling.
Trailhead: "Guided Selling in Industries CPQ" and "Cart APIs" modules — Cover remote actions invoking CpqAppHandler methods.

Explanation:

In the Salesforce Industries (formerly Vlocity) Digital Commerce framework, dcChildCatalog is a specific Lightning Web Component (LWC) designed to handle hierarchical navigation within a large product catalog.

API Interaction: This component uses the catalogCode (specifically a child catalog's code) as a parameter to call the Digital Commerce Get Offers by Catalog API.
Response Handling: The API returns a list of products and promotions associated with that specific child catalog, which the component then renders for the user to browse.
Structural Role: It is typically nested within the broader dcCatalog component and is responsible for fetching and displaying the subset of products relevant to a sub-category or child catalog selection.

Why other options are incorrect:

A. dcCatalog: This is the high-level container component. While it orchestrates the overall catalog view, it does not specifically use the child catalog code to fetch filtered product lists; rather, it often manages the root catalog or overall user context.
C. dcOffersList: This component is generally used to display a flat list of eligible offers (products and promotions) based on user eligibility and context rather than browsing specifically by child catalog codes.

Explanation:

In Vlocity (Salesforce Industries) Context Rules, a context mapping defines how the rule navigates Salesforce data starting from the root context object (for example, Order, Quote, Opportunity, or Asset).

In simple terms:
A context mapping tells the rule where to find the data it needs.
It specifies the relationship path between objects so rule conditions can be evaluated correctly.

Example:
Root context: Order
Context mapping: Order → Account
The rule can now evaluate Account-level data (industry, region, customer type, etc.)

Option-by-option breakdown:

A. a link to data stored in sObjects, calculated using a function, or typed in during designtime: This describes a context value source, not a context mapping.
B. A variable that stores rule condition values: This describes a context dimension or variable, not how data is accessed.
C. The relational path from a root sObject, such as an Order, to related sObjects, such as Account (Correct): This is the definition of a context mapping.
It defines object relationships used during rule evaluation.
D. A multi-dimensional array of sObject data: That describes a calculation matrix, not a context mapping.

Key Exam Concept to Remember:
Context Mapping = Object relationship path (Root object → Related objects)
This is a core Ind-Dev-201 concept, often tested to distinguish between: mappings, dimensions, values, matrices.

Exam Shortcut:
If the question mentions: root context, related sObjects, path → The answer is Context Mapping → relational path.

Explanation:

In Salesforce Industries CPQ (Vlocity), a pricing element is a fundamental building block of the pricing engine that defines how a price or charge is calculated and what the resulting amount is.

C. The pricing calculation –
This defines the logic or formula used to compute the price (e.g., percentage of list price, fixed amount, tiered pricing, etc.).

D. The charge (amount) –
This is the resulting monetary value (e.g., $10.00, -$5.00 discount) after applying the calculation.

Together, these two parts form the core of a pricing element: how it's calculated and what the charge is.

Why the Other Options Are Incorrect:
A. The currency code – Incorrect. Currency is a property of the price list or quote, not an intrinsic part of a pricing element. Pricing elements assume the currency context from their parent object.
B. The price category – Incorrect. Price categories (e.g., "Recurring," "One-Time," "Usage") classify the type of charge but are separate metadata, not a core part of the pricing element structure.

Reference:
Salesforce Industries CPQ pricing architecture:
Pricing Elements consist of:
Calculation Type (e.g., Percent of Total, Fixed Amount).
Calculation Value (e.g., 10%, $50).
Resulting Charge (the output amount).

The calculation and charge are essential; currency and category are higher-level attributes.

Explanation:

The createCart method (part of the CpqAppHandler or CpqService) is designed to work with the standard Salesforce "Sales Excellence" objects.

Transactional Nature:
Opportunities, Quotes, and Orders represent active stages of a sales cycle. createCart takes the ID of one of these records and prepares the internal JSON structures required to browse the catalog and calculate prices.

The Exception:
A Contract is fundamentally different in the Vlocity lifecycle. While a Contract can be generated after an Order is fulfilled, or a "Frame Agreement" can influence pricing, you do not "create" a Cart from a Contract. Instead, you usually create a Quote or Order first and then link it to a Contract, or use the Contract Authoring tools.

Analysis of Incorrect Answers:
A, B, and D: These are all valid inputs for the createCart method.
* If you pass an Opportunity ID, the method prepares a cart for opportunity line items.
* If you pass a Quote ID, it prepares the quote-to-cart experience.
* If you pass an Order ID, it opens the order for configuration and pricing.

Method Signature Note:
When calling this via Apex or a Remote Action, the input JSON typically looks like this:
{ "methodName": "createCart",
"input": {
"objectType": "Order", // or Quote/Opportunity
"parentId": "001XXXXXXXXXXXX" // The Account ID or Parent Record ID
}
}

References:
Salesforce Help: CPQ API - createCart Method
Vlocity Developer Guide: CpqAppHandler Method Reference

Explanation:

In Salesforce Industries (formerly Vlocity) EPC, Object Types are designed using a standard Prototypal Inheritance model known as "IS-A" inheritance.

IS-A Relationship:
When you create an Object Type (such as "Smartphones") that is a child of another Object Type (such as "Mobile Devices"), the child is a version of the parent.

Inheritance of Attributes and Layouts:
Child object types automatically inherit all attributes, fields, and layout configurations defined at the parent level. For example, if "Mobile Devices" has a "Manufacturer" attribute, every "Smartphone" automatically possesses that attribute.

Specialization:
This architecture allows developers to define common characteristics at a high level and then specialize those characteristics in child levels (overriding default values if necessary) without duplicating data.

Why other options are incorrect:
B. HAS-A inheritance architecture:
This refers to Composition (e.g., a Car has an Engine). In EPC, this describes how products are bundled together (Product Bundling), but it is not the term used for the metadata inheritance of Object Types.
C. Hybrid (Virtual) inheritance architecture:
This is a term from C++ programming used to solve the "Diamond Problem" in multiple inheritance. Salesforce Industries uses a strict single-inheritance hierarchy for Object Types.
D. Protected (Private) inheritance architecture:
This refers to access modifiers in Object-Oriented Programming (like Java or C#) that control visibility, not the structural architecture of the data model.

References:
Object Types in EPC (Salesforce Help)
Create Object Types (Trailhead)