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

The System.runAs() method is used in test classes to enforce record sharing. This method allows you to write test methods that change user contexts to ensure that the proper record sharing is enforced. References:

Understanding the runAs Method

To troubleshoot the issue of a trigger creating two order records, adding System.debug() statements in the trigger and analyzing the log output in the Developer Console is an effective technique. This will help identify if the trigger is being called more than once or if there is another automation (such as a flow or workflow) causing the additional record creation.

A single trigger on Contact that handles both after update and before update events, utilizing helper classes for each logic set, is the most optimal implementation. It centralizes the logic for maintaining primary contacts and normalizing last names while allowing for clear separation of concerns through helper classes.

When an unhandled exception occurs, publishing a custom platform event using EventBus.publish() method is the appropriate way. The external system can then subscribe to this event using technologies like CometD to receive notifications. References: Publish and Subscribe to Platform Events

Creating a helper class allows the logic to be centralized and reused in both the trigger and the Lightning Web Component (LWC), avoiding repetition. Using custom metadata to store the criteria value allows easy updates without code changes and can be referenced from both the helper class and the trigger.

When you want a Lightning web component to only render for a specific form factor, you can use the <targets> tag within the component’s .xml configuration file. To specify that the component should only appear on a desktop, you use the <targetConfig> tag with the targets="lightning__RecordPage" attribute and nest a <supportedFormFactors> tag inside it. Within this tag, you include a <supportedFormFactor> tag with the attribute type="Large".

Option B is the correct markup to ensure that the component only appears for the desktop form factor on a record page.

The connectedCallback() lifecycle hook in Lightning Web Components (LWC) is used to perform logic after a component is inserted into the DOM, making it the ideal place to execute custom logic when the component is loaded.

To communicate a property change up a containment hierarchy in Lightning Web Components (LWC), the child component should dispatch a custom event with the detail of the change. The parent component listens for this event and handles it accordingly.

Option A is the correct method because it creates a new custom event with the detail property containing the new value of passthrough. This event is then dispatched, and the parent component can listen for this event to handle the updated value.

Options B, C, and D are incorrect because they either don't pass any data with the event or they don't use the detail object which is the standard way to pass data with custom events in LWC.

Lightning-layout and lightning-layout-item are components used in Lightning Web Components to create responsive grid layouts that adapt to the screen size of various devices.

Jest tests are essential for developing Lightning Web Components (LWC) because they allow developers to ensure the quality and correctness of their components in isolation from the rest of the application. Reason A is incorrect because testing non-public properties breaks encapsulation and is considered bad practice. B is correct because Jest tests can simulate user interactions with the component, such as clicking buttons or entering text, to ensure it behaves as expected. C is correct as well because Jest tests can confirm that the component renders the expected DOM output, which is crucial for ensuring that the HTML structure of the component is accurate. D is not the best choice since Jest is more suited for testing components in isolation rather than how multiple components interact; integration tests are more appropriate for that. Lastly, E is correct because Jest tests can verify that events are fired at the appropriate times, which is a critical part of the component's interaction with the rest of the application.

References

Jest Testing: Lightning Web Components Testing

Jest Testing Best Practices: Lightning Web Components Jest Best Practices

When an Apex class does not achieve the expected code coverage, it suggests that the test methods are not executing parts of the class. The @testvisible annotation can be used to increase code coverage by allowing test methods to access private or protected members of another class. This enables the test method to call methods that may not be directly accessible, but it is not a direct means to generate code coverage. The code coverage is actually achieved when the test methods execute the code within these methods. Therefore, to properly generate code coverage, the developer must ensure that the test methods call the relevant portions of the code that need to be covered. The use of @testvisible can facilitate this process by making otherwise inaccessible code available for testing.

If the test class does not retrieve the updated value from the database, it will not see any changes made by the page logic. This can cause assertions that check for those changes to fail. The test should query for the most recent value from the database after the operation that is supposed to update the value.

When dealing with large data volumes in Salesforce and ensuring optimal performance for queries, it's important to choose an approach that both handles the data volume efficiently and retrieves the complete result set.

Option D is correct because using the Database.QueryLocator method is a best practice for handling large data volumes. It is typically used with batch Apex, which can process records in batches, thus reducing the likelihood of hitting governor limits. It's designed to handle very large data sets that would otherwise exceed normal SOQL query limits.

Option A is incorrect because creating a formula field doesn't improve the performance of the query. It simply creates a new field that combines existing data, but it does not inherently optimize the query execution.

Option B is incorrect because breaking down the query into two parts and joining them in Apex could potentially be less efficient and would require additional code to manage the combined result sets. This approach does not leverage the built-in Salesforce features designed to handle large data volumes.

Option C is incorrect because the @Future annotation makes the method execute asynchronously, but it does not help with query performance or large data volume management.

To make a callout to set the Address fields when an Account is inserted without violating the Salesforce limit against callouts from triggers, a developer can use a trigger to execute a Queueable job. The Queueable job can then safely make the callout.

When rolling back to a savepoint, any DML operations that occurred after that savepoint are undone, but static variables are not reverted. Therefore, when a rollback occurs, the state of all static variables at the time of the rollback remains the same as it was just before the rollback.

Savepoints in Apex are markers within a transaction and rolling back to an earlier savepoint (SP1) invalidates any savepoints created after it. Thus, SP3 is invalidated when the code rolls back to SP1, causing a runtime error when a rollback to SP3 is attempted.

To ensure error messages are properly displayed in a Lightning web component, the developer should use JavaScript to handle errors in the component's client-side code and use HTML to display the message on the UI. This can be combined with Apex exception handling for server-side operations.