PDII Salesforce Certified Platform Developer II (Plat-Dev-301) Free Practice Exam Questions (2025 Updated)

To test a Visualforce controller that works with specific records, you should insert the necessary test data in the test class. Then instantiate a PageReference for the Visualforce page, set the record id in the page parameters, and use System.currentPageReference().getParameters().put('id', recordId) to simulate navigating to the page with that record.

For communication between unrelated Lightning web components that are in different DOM trees, the most suitable approach is to use the Lightning Message Service (LMS). This service allows components to communicate with each other using a message channel, which is particularly useful when the components are not in the same containment hierarchy. By publishing and subscribing to messages on a message channel, components can exchange data and notifications, which is ideal for the scenario described.

To identify the configuration changes made by the former administrator, the developer should leverage the Setup Audit Trail. This allows tracking changes made in the Setup area of Salesforce, showing the date of the change, who made it, and what the change was.

When writing a test class for a Queueable class in Salesforce, the goal is to ensure that the asynchronous code is executed within the test context and that it does not affect the state of the production org or depend on its data.

Option C is correct because using Test.startTest() and Test.stopTest() ensures that the asynchronous code is executed immediately within the test's context. This is essential for testing Queueable classes because it allows the test to wait for the asynchronous process to complete before assertions are made. Without this, the asynchronous job would not necessarily run during the test execution.

Option D is correct because Test.isRunningTest() can be used within the Queueable class to prevent the chaining of jobs during test execution. Chaining queueable jobs can lead to governor limits being hit and is generally not allowed in test methods. This conditional check allows the developer to bypass sections of the code not suitable for a testing context.

Option A is incorrect because the seeAllData=True annotation is not required for testing Queueable classes, and it is not a best practice to depend on live data for tests. It's preferable to create test data within the test class itself.

Option B is incorrect because having the 'View All' permission on the Order object is not related to the successful execution of the Queueable class in tests. Permissions are typically not enforced in test contexts unless using System.runAs() to test with a specific user context.

To determine which objects to include in the response, the developer should check the isCustom() value on the sObject describe result. This method returns a Boolean indicating whether the sObject is a custom object.

If a flow is configured to evaluate when a record is created and every time it's edited, and an Apex trigger also fires upon the same conditions, it could result in duplicate operations. In this case, two Account Plan records are created because both the flow and the trigger execute upon the Account being marked as a Customer.

The error "You have uncommitted work pending. Please commit or rollback before calling out" usually indicates that DML operations (like insert, update, delete) are being performed before a callout in a test context. This is not allowed because Salesforce does not support this sequence of operations in a single transaction. However, the use of seeAllData=true is generally not a recommended practice and does not address the core issue of mixed DML and callouts in tests. The correct solution is to use a mocking framework to simulate the callout response. By using Test.setMock(), developers can avoid performing actual callouts in test methods, thus bypassing the uncommitted work error.

When dealing with large datasets and the need to perform complex calculations or data aggregation, batch Apex and scheduling are typically used to efficiently process records in batches and to execute the process during off-peak hours.

Option B is correct because using the @future annotation allows you to run methods in the background, but it is not suitable for operations that need to process more than 50,000 records, which is the governor limit for future methods.

Option C is correct because implementing the Schedulable interface allows you to schedule the class to run at specified times, such as after business hours, which is a requirement for this scenario.

Option A is incorrect because Queueable is typically used for chaining jobs and handling asynchronous processing of individual transactions, not for processing large datasets at scheduled times.

Option D is incorrect because the Database.Batchable interface is what's needed for processing large datasets, not Database.Stateful. The Database.Stateful interface is used to maintain state across batch job transactions.

To prevent race conditions during an Apex transaction, the SOQL query can be modified to include the "FOR UPDATE" keyword. This keyword locks the records that are returned by the query, preventing other transactions from modifying them until the current transaction is complete. This ensures that the retrieved records cannot be changed by another process before the current transaction is completed, thus preventing race conditions. The correct option to use in the code snippet provided is:

[SELECT Id, Name, Amount__c FROM Credit_Memo__c WHERE Customer_Id__c = :customerId LIMIT 50 FOR UPDATE]

This will lock up to 50 records of Credit_Memo__c with the specified Customer_Id__c for the duration of the transaction.

The $Locale value provider should be used to ensure the Lightning application respects the user's locale for dates, times, numbers, currency, and currency symbols. This global value provider gives components access to locale formats and labels, which are automatically rendered according to the user's locale settings.

To make the test pass, @isTest(SeeAllData=true) should be used to allow the test to access historical data from the org. This is required because field history tracking data is not copied to a test context, so you need to allow the test to access live data to assert against it.

The use of getRecordTypeInfosByDeveloperName is a best practice to handle record types. This approach avoids the need for SOQL queries, reducing the number of governor limits consumed, and efficiently retrieves record type Ids by their DeveloperName, which is consistent across all Salesforce environments.

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.

Apex managed sharing is the correct feature to control the visibility and access to cases shared with external partners. It allows developers to programmatically create sharing records that grant access to users based on specific criteria, providing granular control over record sharing.

The requirement described in the question calls for a flexible way to query records based on user-selected fields. Dynamic SOQL is the perfect tool for this job as it allows the construction of a SOQL string at runtime, which can include any number of fields and filter conditions that are determined at the time the user interacts with the page. This enables the creation of a highly customizable query interface. A, B, and C are not suitable for this requirement as they serve different purposes: A (Streaming API) is for receiving real-time streams of data changes, B (Metadata API) is for managing the metadata of your Salesforce org, and C (variable binding) is used in Visualforce to bind data between the page and the controller but does not provide dynamic query capabilities.

References

Dynamic SOQL: Dynamic SOQL in Apex Developer Guide

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.

Custom metadata types are the optimal way to store secret data that needs to be accessed by certain profiles and users. Access to custom metadata records can be controlled by the Salesforce sharing model.

Custom metadata types are ideal for storing configuration data such as shipping rates by region. These rates can be deployed to production without additional steps and can be queried in Apex, allowing the calculations to work immediately post-deployment.

Create and dispatch a custom event. This approach allows LWC components to communicate effectively, maintaining component encapsulation and reusability.