PDII Practice Exam Questions with Answers Salesforce Certified Platform Developer II (Plat-Dev-301) Certification

The valid SOQL query on a Big Object must match the indexed fields exactly. Since Account__c, Program__c, and Transaction_Date__c are the indexed fields, the SOQL query must specify those fields exactly in the WHERE clause, including exact match conditions (no LIKE or INCLUDES).References: Salesforce Developer Guide - Working with Big Objects

Setting unique fields on related objects as External IDs allows for the creation of relationships during imports without needing Salesforce IDs. The upsert operation in Data Loader can then use these External IDs to relate records, which streamlines the process and avoids the need to export Salesforce IDs manually.

References:

• Data Loader Guide

For the data to be passed back to the Aura component, all properties of the Apex class that are intended to be accessed from the component need to be annotated with @AuraEnabled. Without this annotation, the Aura framework cannot serialize the properties to send them to the front end.References: Aura Components Developer Guide - AuraEnabled Annotation

For retrieving specific records using a known ID, the REST API is optimal due to its stateless, cacheable communications and lightweight structure. It's ideal for web applications that use JavaScript to make requests directly from the user’s browser. Using the REST API, the web page can make a simple HTTP GET request to the Salesforce REST service endpoint and retrieve the account information in a format that's easily handled by JavaScript (typically JSON).

References:

• REST API Developer Guide

Create and dispatch a custom event. This approach allows LWC components to communicate effectively, maintaining component encapsulation and reusability.References: Communicating Between Lightning Web Components

When multiple users are updating the same record at the same time, there is a risk of overwriting each other's changes. Salesforce provides a mechanism called 'record locking' to prevent this from happening.

• Option D is correct because including FOR UPDATE in the SOQL query locks the retrieved records for the duration of the transaction. This prevents other transactions from updating the record until the current transaction is complete, which is essential for avoiding race conditions where two users might overwrite each other's updates.
• Option A is incorrect because while adding a try/catch block around the update operation is good practice for handling exceptions, it does not prevent overwrites from concurrent updates.
• Option B is incorrect because using upsert instead of update does not address the problem of concurrent updates. The upsert operation is used to either insert a new record or update an existing one based on whether a record with a matching ID or external ID already exists.
• Option C is incorrect because FOR UPDATE should be used in the SOQL query to lock the records, not in the SELECT statement itself.

References:

• Salesforce Developer Documentation on Locking Statements: Locking Statements
• Salesforce Developer Blog on Handling Concurrency in Apex: Handling Concurrency in Apex

• Overriding the standard Case New Action with a Lightning Flow allows the developer to create a custom wizard-style interface for creating cases. Lightning Flows can be embedded in Lightning Experience and provide a guided visual experience.

References:

• Lightning Flow

Using a dedicated sandbox for testing before deployment can prevent issues like overwriting changes in production. When administrators deploy their own change sets without coordination, they might inadvertently overwrite each other's changes, including page layouts. References: Best Practices for Deployments with Change Sets

To improve the performance of an Aura component that is loading slowly, the developer can make the following change:

• D. Change the default for showContactInfo to “False": By setting the default value of showContactInfo to False, the component does not fetch or render the contact information by default, which can reduce the initial load time. The information can be fetched and displayed later based on user action or other triggers.

Changing the type of contactInfo to "Map" (Option A) or moving the contents of <c:contactInfo> into the component (Option B) may not necessarily improve load times. Adding a change event handler for showContactInfo (Option C) adds more processing and can potentially slow down the component if not handled efficiently.

References:

• Lightning Components Performance Best Practices: Improve Performance

To test Queueable Apex, Test.startTest() and Test.stopTest() should be used to ensure the asynchronous code is executed before assertions are made. After calling Test.stopTest(), you would then query for the records to assert that the queueable job correctly created the Account records.References: Apex Developer Guide - Testing Asynchronous Apex

Implementing an asynchronous callout using the Continuation class is the optimal solution to handle long response times and avoid timeouts in Salesforce. It allows the Apex code to make a long-running request to an external service and free up the thread to serve other requests.References: Apex Developer Guide - Asynchronous Callouts

Use the @salesforce/i18n module with the firstDayOfWeek property. It provides locale-aware functionality essential for internationalization.References: Internationalization with Lightning Web Components

Custom metadata types are ideal for storing payment processor settings that need to be changed by an administrator post-deployment. They can be deployed with managed packages and are upgradeable. Unlike Custom Objects, Custom Metadata Types also support a deployment with active data and can have their records retrieved via SOQL in Apex.References: Salesforce Help - Custom Metadata Types Overview

Casting each object to an sObject and using the get method to compare the Name fields is the correct approach. This is because sObjects are generic object representations that can be used to access the fields of any Salesforce object dynamically. References:

• sObject Class

Custom metadata is best for storing configurable settings. It's deployable, packageable, and upgradeable. Allows different configurations for different instances.References: Custom Metadata Types

Callouts cannot be made from a synchronous context such as an Apex trigger because they might exceed the maximum execution time, leading to timeouts. Asynchronous methods, such as future or Queueable, are required to handle callouts from triggers.References: Apex Developer Guide - Asynchronous Apex

For community users within the same Account hierarchy to see records based on a custom junction object, Apex managed sharing can be used. An Apex trigger can create sharing records based on the junction object relationships, allowing users to see records from different departments as required.References: Apex Developer Guide - Sharing a Record Using Apex

To retrieve Tasks that are between 12 and 24 months old, we need to use a SOQL query that filters based on the CreatedDate. The query must exclude deleted records and include both active and archived tasks. Since Tasks can be archived after a certain period (typically 12 months), we must ensure the query includes these as well.

• Option C is correct because it uses ALL ROWS in the SOQL query, which includes both active and archived (soft-deleted) records. The query also correctly uses a range for CreatedDate to ensure it selects Tasks created between 12 to 24 months ago.
• Option A is incorrect because it does not include the ALL ROWS keyword, which is necessary to include archived Tasks in the results.
• Option B is incorrect because it only retrieves Tasks created in the last 12 months, not between 12 to 24 months ago.
• Option D is incorrect because it does not filter Tasks based on their creation date correctly to include only those that are between 12 and 24 months old.

References:

• Salesforce Developer Documentation on SOQL and SOSL Reference: SOQL and SOSL Reference
• Salesforce Developer Documentation on Working with Archived Records: Working with Archived Records

Use Database.Batchable for handling large data sets. It can efficiently process 100,000 Catalog Items asynchronously and update CurrencylsoCodes.References: Using Batch Apex

Based on the code provided, here are the necessary changes:

• Change B is required because the argument in the Apex controller's serverEcho method must match the data type expected by the JavaScript calling the method. The Apex method expects an Object named firstName, which is then cast to a String inside the method. The JavaScript is passing an object with a property firstName, so no change is needed in the JavaScript.
• Change D is correct because line 06 is redundant and unnecessary. We can directly use firstName in the return statement as it is already a String type. The get() method is typically used when you have a Map and you need to retrieve a value by its key. Since firstName is already being passed as a String, there's no need to cast it or retrieve it using get().

References:

• Apex Developer Guide

Making a callout from an Apex trigger is not allowed synchronously; hence, such callouts must be performed in an asynchronous context. The only way to perform this within the Salesforce platform is by using asynchronous Apex, such as @future methods or Queueable Apex.References: Apex Developer Guide - Asynchronous Apex

To resolve the issue of the Visualforce page taking too long to display results or exceeding the view state limit, the developer should use a StandardSetController or implement SOQL LIMIT in the Apex controller. This limits the number of records that are processed and displayed at one time, which can prevent view state errors and improve performance.References: Visualforce Developer Guide - StandardSetController

To retrieve the Show_Help__c preference for the current user from a hierarchy custom setting, the getInstance() method should be used. This method retrieves the custom setting data for the user or the organization default if no user-specific setting is found.References: Salesforce Help - GetInstance Method

The correct code snippet to assert that the remote action returned the correct Account is option C. This is because the getAccount method is a global static method within the MyRemoter class and can be directly called without needing to instantiate an object of the class.References: Apex Developer Guide - Exposing Apex Methods to JavaScript

The correct answer is B, lightning-messages. This Lightning Web Components (LWC) service component provides a way to display error messages that are generated during the processing of lightning-input-field components within a lightning-record-edit-form.

References:

• Display Error Messages

The correct feature to use is C, Named Credentials. Named Credentials are a secure way of storing the endpoint and authentication details for callouts to external services. When URLs change frequently, using Named Credentials allows you to manage the endpoint URL in one place without changing the Apex code.

References:

• Named Credentials

To display lightning-layout-items in one column on small devices and in two columns on larger devices, you should set the size attribute to "12" for small devices and the medium-device-size attribute to "6". This ensures that on small devices each item takes the full width, and on medium or larger devices, items take up half the width.References: Lightning Web Components Developer Guide - Layout Components

To ensure that the DOM is clean before each test runs, the developer should use the afterEach() method to reset it. This is part of the setup and teardown process in Jest tests, which helps to avoid state leakage between tests. References:

• Jest Globals afterEach

Application Events in Aura components are used for communication between components that are not in the same containment hierarchy. An application event to alert users about the arrival of a guest at the front desk is appropriate because it allows any component within the app to listen and respond to the event, regardless of where it is located in the component hierarchy.References: Aura Components Developer Guide - Application Event

@testSetup method improves test performance. It allows data sharing across test methods within a class, reducing redundant data creation.References: Using the testSetup Method

To load a static resource within a Lightning web component, you should use an import statement with the @salesforce/resourceUrl module. This statement correctly refers to the static resource by its name.References: Lightning Web Components Developer Guide - Use Static Resources

Custom labels are used for translating text strings in Salesforce that need to be presented in multiple languages. They support translations and can be referenced in Aura components, Visualforce pages, and Apex code.References: Salesforce Help - Create and Edit Custom Labels

The Apex class needs to have the method annotated with @AuraEnabled to expose it to the LWC. The 'with sharing' keyword ensures that the data access is enforced according to the user’s permissions. @AuraEnabled(cacheable=true) allows client-side caching for improved performance.

References:

• @AuraEnabled Annotation: Apex Developer Guide
• Enforcing Sharing Rules: Apex Developer Guide

Salesforce validation rules are declarative and can be used to validate more than one field on an object and display multiple error messages. This approach requires minimal JavaScript code and uses Salesforce's built-in validation framework. References:

• Validation Rules

• Lazy loading improves performance by loading data only when needed.
• Lightning Data Service (LDS) handles data operations and caching efficiently.
• Using {Cacheable=true} on Apex methods enables the Lightning Component framework to cache the method's return value, reducing server round-trips for the same data.

References:

• Lightning Web Components Developer Guide

The optimal way to fix the failing unit tests after adding a new required field to the Account object is to create a TestDataFactory class that serves as a centralized place to create Accounts for unit tests. This class would include the new required field, ensuring that all unit tests have the necessary data setup.References: Apex Developer Guide - Using a Test Data Factory

For a one-time bulk operation on a large data set, using a Database.Batchable class is the best approach. This allows complex logic to be processed in manageable chunks and efficiently manages system resources.References: Apex Developer Guide - Using Batch Apex

When users need to see multiple error messages at a time related to their input on a form, client-side validation is the preferred method. This allows immediate feedback on the input fields without the need to submit the form to the server.

• Option B (Client-side validation) is correct because it enables validation of multiple fields before submitting the form, allowing users to see all error messages at once for the fields that fail validation.
• Options A (Apex REST), C (Custom validation rules), and D (Next Best Action) are not directly related to the validation of form inputs in the context of a Lightning web component.

References:

• Lightning Web Components Developer Guide: Lightning Web Components and Salesforce Data

Using an Email Alert with Flow Builder allows for scalable solutions that can handle large volumes of emails, and it offloads the processing from Apex to Salesforce's declarative automation tools. This approach is also bulk-safe, as it does not rely on Apex code that could hit governor limits.References: Flow Builder - Email Alerts

Option D, which uses the Database.query() method in combination with a for loop, is the most memory-efficient way to process records. This is known as the Query Locator pattern, which allows you to work with a large number of records by querying them in batches. This approach helps to avoid hitting the governor limit for "Apex heap size too large" as it processes one record at a time from the database without storing the entire result set in memory.

References:

• Working with Very Large SOQL Queries
• Apex Governor Limits

Since the SeeAllData=true annotation is used, the test class does not have its own test data and is relying on the data in the org. The org already has accounts with the name starting with "Test", so the assertion that no accounts should exist after the deletion will fail because the test method only deletes the account that was created within its scope.

References:

• Apex Developer Guide

Visualforce can render pages as PDFs, which Lightning Components cannot do. This functionality is crucial if PDF rendering is required.References: Visualforce Developer Guide - Rendering a Page as a PDF

To implement a Lightning web component that allows users to create a Case, you would need components that allow for input fields and the creation of records.

• Option C (Lightning-input) is correct because it allows developers to create custom form input elements that can be positioned in a non-linear fashion as required.
• Option D (lightning-record-form) is correct because it provides a simple way to create forms for viewing and editing Salesforce records and would be suitable for creating a new Case record.
• Option A (Lightning-record-edit-form) is not a valid component; it seems to be a misprint of lightning-record-edit-form, which is indeed a component used for creating and editing records but was not listed as an option.
• Option B (lightning-input-field) is used within the lightning-record-edit-form or lightning-record-view-form components to create editable or displayable fields respectively, but is not as versatile as lightning-input for custom layout purposes.

References:

• Lightning Web Components Documentation: Lightning-input

Platform events provide a robust and scalable way to communicate changes and events from Salesforce to external systems, especially when there is no requirement for Salesforce to wait for a response. They are designed to support event-driven architectures and can handle high volumes of events that can be published and consumed by external systems. Outbound messages, on the other hand, are limited by the need for an acknowledgment response from the target system, which can introduce latency.

The correct SOQL query to retrieve all fields for a specific Account is to use the FIELDS(ALL) function within the SELECT clause of the SOQL query. This will return all fields for the Account named 'Acme'.References: SOQL and SOSL Reference Guide - FIELDS() Function

• and components can cause the form data to be sent to the server and can be configured to refresh specific parts of the page.
• adds AJAX support to other components and can trigger partial page updates based on events such as onclick, onchange, etc.

References:

• Visualforce Guide

When a test class fails with an "Insufficient privileges" error during deployment, it indicates that the user profile under which the tests are being executed doesn't have the necessary permissions to perform the actions required by the test. In a sandbox, the test might have been running with a different set of permissions compared to the production environment.

By using System.runAs(), you can specify a user context in which the test should run, which allows you to simulate the appropriate permissions. For this to work, you need to create a User instance in your test class with the profile that has the necessary permissions and then enclose the logic of your test within a System.runAs() block with this user.

This is a preferred solution over seeAllData=true, which would give the test access to all data in the production environment, potentially leading to tests that are not isolated and thus less reliable. It's also preferred over changing organization-wide settings or relying on specific setup in test classes, such as making sure Test.startTest() is not inside a loop.

References:

• Salesforce Documentation on Using the runAs Method: Testing with the runAs Method
• Salesforce Help Article on System Permissions: Profiles and Permissions

Using toLabel() in the SOQL query ensures that picklist values are returned in the user’s language, which is necessary for organizations that have the translation workbench enabled.

References:

• Multi-language Solutions: [Salesforce Developer Guide](https://developer.salesforce.com/docs/atlas.en-us.soql_sosl.meta/soql_s