SF-PD2 Practice Test 4 — 25 Questions

Question 1

A developer is optimizing a Visualforce page that displays a large dataset using a StandardSetController. The page currently loads slowly because it queries all records at once. The developer wants to implement pagination to improve performance. Which approach should be used?

Choose an answer to begin — your selection is scored in the full session.

Accepted Answer

Use the StandardSetController's setPageSize method to limit the number of records per page and rely on its built-in pagination.. The StandardSetController is specifically designed to handle pagination efficiently. By setting the page size, it automatically limits the query to the records needed for the current page, reducing the initial load and memory footprint. Manual pagination with OFFSET or client-side pagination does not offer the same performance benefits and often introduces additional complexity or inefficiencies.

Answer

Use the @ReadOnly annotation on the controller to allow the page to query all records without hitting governor limits, then paginate client-side.

Answer

Use SOQL OFFSET to manually paginate the records in the controller, fetching only the records for the current page.

Answer

Use a custom controller with a SOQL query that uses LIMIT and OFFSET, and implement pagination logic manually.

Question 2

A developer is building an Apex trigger that processes 200 Opportunity records on insert. The trigger needs to query all related OpportunityLineItem records to calculate a total. To avoid hitting the SOQL query limit, which approach should the developer use?

Accepted Answer

Use a single SOQL query in the trigger to retrieve all OpportunityLineItem records for all Opportunity IDs in the trigger context.. The correct approach is to bulkify the trigger by performing one SOQL query that retrieves all related OpportunityLineItem records for all Opportunities in the trigger context. This avoids the governor limit on the number of SOQL queries and ensures the trigger scales for bulk operations. Querying inside a loop or per record is inefficient and will fail with large data volumes.

Answer

Use a separate SOQL query for each Opportunity but limit the loop to 100 iterations to stay within limits.

Answer

Perform a SOQL query inside a loop that iterates over each Opportunity record to fetch its line items individually.

Answer

Leverage a map of OpportunityLineItem records populated by a prior query in the trigger's initial data retrieval.

Question 3

A developer needs to add a custom field to the Account object that stores a numeric risk score. The field must be available to Apex code, Flow, and the REST API, and must not be exposed on any page layout. Which metadata type and deployment approach should the developer use?

Accepted Answer

Create a CustomField metadata component on Account and deploy it via a change set or Salesforce CLI, leaving the field off layouts.. The risk score is a new piece of data on Account, so it must be defined as a CustomField metadata component. Custom fields are automatically available to Apex, Flow, and the REST API. Page layout visibility is independent of field existence, so simply not adding the field to any layout satisfies the requirement to keep it hidden from users while retaining programmatic access.

Answer

Create a FieldSet metadata component on Account containing the score field.

Answer

Create a Layout metadata component and add a hidden numeric field to it.

Answer

Create a CustomObject metadata component with a lookup to Account to store the score.

Question 4

A developer is writing an Apex test method for a service class that makes a callout to an external REST API. The test must not perform the actual callout. The developer creates a static resource containing the JSON response and writes a mock class that implements HttpCalloutMock. Which statement must the developer include in the test method to register the mock before the callout is executed?

Accepted Answer

Test.setMock(HttpCalloutMock.class, new MyApiMock());. Test.setMock is the only supported way to inject a mock implementation for HTTP callouts during Apex tests. It must be invoked before the callout is made, typically at the start of the test method. The mock's respond method then supplies the HttpResponse, allowing the developer to test success and error handling without external dependencies.

Answer

HttpCalloutMock mock = new MyApiMock(); Test.startTest(); mock.respond(new HttpRequest());

Answer

Test.setMock(WebServiceMock.class, new MyApiMock());

Answer

Test.loadData(HttpCalloutMock.SObjectType, 'MyApiMock');

Question 5

A developer is creating a Lightning Web Component that needs to display a list of Contacts for a given Account. The component will be placed on a Lightning record page for Account. The developer wants to use the getRelatedListRecords wire adapter from lightning/uiRelatedListApi to fetch the contacts. Which two parameters are required in the wire configuration object for getRelatedListRecords? (Choose two.)

Accepted Answer

relatedListId. The getRelatedListRecords wire adapter requires two parameters: parentRecordId and relatedListId. parentRecordId identifies the parent record (Account) whose related list is queried, and relatedListId specifies which related list (e.g., Contacts) to retrieve. Optional parameters like fields, sortBy, and pageSize can refine the results but are not mandatory for the adapter to execute.

Answer

sortBy

Answer

fields

Answer

pageSize

Question 6

A developer is writing an Apex trigger that updates a related object's records when a parent record is updated. The trigger currently performs a SOQL query for each child record to check if an update is needed. What is the most efficient way to optimize this trigger?

Accepted Answer

Use a single SOQL query to retrieve all related child records for the parent records in the trigger, then process them in a loop.. The trigger's performance issue is caused by executing a SOQL query for each child record, which is a classic N+1 query problem. The optimal solution is to perform a single SOQL query to retrieve all necessary child records for the parent records in the trigger context. This bulkified approach minimizes database calls, respects governor limits, and improves performance.

Answer

Move the SOQL query into a helper method and call it from the trigger to improve code organization.

Answer

Set the trigger to run asynchronously using @future to avoid governor limits.

Answer

Use a Map to cache child records after the first query, and reuse the cached data for subsequent iterations.

Question 7

A developer is designing a custom exception handling framework for an Apex class that processes large data sets. The framework must log exceptions to a custom object and ensure that the original transaction is not rolled back due to the logging operation. Which two techniques should the developer use to achieve this? (Choose two.)

Accepted Answer

Perform the logging in a future method or Queueable job that runs in a separate transaction.. To ensure logging persists despite a transaction rollback, the logging must occur in a separate transaction. Asynchronous Apex (future methods or Queueable) runs in its own transaction, so logs inserted there are not rolled back with the main transaction. Platform Events also provide asynchronous delivery, decoupling the log from the main transaction. Savepoints and DML options do not provide this isolation.

Answer

Use Database.insert with allOrNone set to false for the logging records.

Answer

Use Savepoint and rollback to isolate the logging DML.

Answer

Insert the logging records before the main DML operations and use Database.setSavepoint before the main operations.

Question 8

A developer has a Lightning Web Component that must call an imperative Apex method to save a record, then immediately display a toast confirming success only if the save actually succeeded. The Apex method returns a wrapper with a Boolean success flag and a message. Which imperative call pattern correctly handles both the success and error paths?

Accepted Answer

Use .then() to read the wrapper's success flag and conditionally fire the success toast, and .catch() to handle any Apex exception with an error toast.. Imperative Apex calls return Promises, so the response must be consumed asynchronously. Reading the wrapper's success flag inside .then() ensures the toast only fires on a genuine success, while .catch() isolates server exceptions for an error toast. Showing the toast synchronously, using a wire adapter for a save, or relying on a fixed timeout all break the asynchronous contract and produce toasts that do not reflect the real outcome.

Answer

Wrap the imperative call in a wire adapter and use the wired property's data and error values to drive the toasts.

Answer

Invoke the Apex method and use a setTimeout of 500 milliseconds before showing the toast, assuming the server will have responded by then.

Answer

Call the Apex method inside a try/catch, and show the success toast in the try block right after the invocation line without inspecting the resolved value.

Question 9

A developer is building an Apex batch job that processes 50,000 Account records. The batch class uses `Database.executeBatch` with a batch size of 200. After running the job, the developer notices that the job takes significantly longer than expected and sometimes fails with `UNABLE_TO_LOCK_ROW` errors on the Account object. What is the most likely cause of the performance degradation?

Accepted Answer

The batch job is running in parallel with another batch job that updates the same Account records, causing lock contention.. The `UNABLE_TO_LOCK_ROW` error occurs when multiple processes attempt to modify the same records simultaneously. In this scenario, the batch job likely runs concurrently with another process updating the same Accounts, causing lock contention and slowing down the job. Adjusting batch size or query selectivity would not resolve the locking issue; coordinating the timing of updates is necessary.

Answer

The batch job is using a SOQL query without a WHERE clause, causing a full table scan.

Answer

The batch size is too large, causing excessive locking on the Account records.

Answer

The batch job is not using `Database.Stateful`, causing it to lose state between batches.

Question 10

A developer is writing an Apex trigger on the Case object that updates a custom field on the Account when a Case is closed. The trigger currently performs a SOQL query to retrieve the Account for each Case in Trigger.new. The developer wants to optimize the trigger to handle bulk updates of up to 200 Cases without hitting governor limits. What is the best practice to achieve this?

Accepted Answer

Use a single SOQL query to retrieve all related Accounts based on the AccountId values from Trigger.new, then use a Map to update the Accounts.. The best practice for bulkifying a trigger is to collect all necessary IDs and perform a single SOQL query to retrieve related records. Using a Map to correlate the records allows efficient updates without additional queries. This reduces the number of queries to one, well within governor limits, and ensures the trigger can handle bulk updates. The other options either cause multiple queries or are not applicable to triggers.

Answer

Use a SOQL query inside a for loop to retrieve each Account and update it immediately.

Answer

Use a Map to store the Accounts from Trigger.new, but query the Accounts in the trigger's constructor.

Answer

Use a Database.query call with a bind variable for each AccountId to retrieve the Accounts in a single query.

Question 11

A developer maintains an Apex class that performs a callout to an external REST service and then writes the response into Salesforce records. The callout occasionally takes longer than expected, and the developer wants to ensure the transaction can recover gracefully without leaving partial data. Which approach best addresses this?

Accepted Answer

Perform the callout before any DML and use a savepoint so that if the callout or subsequent DML fails, the transaction can roll back the DML.. Because external callouts are not transactional with the database, the reliable pattern is callout first, then savepoint-protected DML with rollback on failure. This keeps the transaction consistent and respects the rule that a callout cannot follow uncommitted DML in the same Apex transaction.

Answer

Use Database.setSavepoint() before the callout and Database.rollback() after the callout to undo the external request.

Answer

Move the callout into a future method and perform the DML in the original synchronous transaction.

Answer

Set a shorter HTTP timeout using the HttpRequest.setTimeout method and rely on the timeout to prevent partial writes.

Question 12

A developer is implementing a custom Apex class that uses the Queueable interface to process a large number of records asynchronously. The class must be able to chain another job if there are more records to process. Which method should the developer use to enqueue the next job?

Accepted Answer

System.enqueueJob(new MyQueueableClass());. To chain a Queueable job, the developer must call System.enqueueJob() from within the execute method of the current Queueable class, passing a new instance of the next job. This method is the only supported way to enqueue Queueable jobs. The other options refer to different asynchronous mechanisms or invalid syntax.

Answer

System.schedule('NextJob', '0 0 0 * * ?', new MySchedulableClass());

Answer

MyQueueableClass.enqueue();

Answer

Database.executeBatch(new MyBatchClass());

Question 13

A developer needs to deploy a new Apex class to production that makes a callout to an external REST service. The callout must be made from a trigger. During testing in a sandbox, the developer writes a test class that performs DML to insert a record that fires the trigger, but the test fails with a 'CalloutException: Methods defined as TestMethod do not support Web service callouts' error. What should the developer do to allow the test to execute the callout successfully?

Accepted Answer

Implement the HttpCalloutMock interface and use Test.setMock(HttpCalloutMock.class, new MyCalloutMock()) before the DML operation.. The correct solution is to use HttpCalloutMock to simulate the external service. This allows the test to execute the callout logic without violating the platform's restriction on real callouts during tests. It also ensures that the test remains isolated, repeatable, and fast, which is essential for reliable continuous integration.

Answer

Annotate the test method with @isTest(SeeAllData=true) to allow callouts.

Answer

Use Test.startTest() and Test.stopTest() around the DML operation to enable callouts.

Answer

Wrap the callout in a try-catch block and ignore the CalloutException.

Question 14

A developer is building a Lightning Web Component that must expose a method to an Aura component wrapper so the Aura component can call it after a user action. The LWC method is decorated with @api and named doSomething. Which code in the Aura component correctly invokes it?

Accepted Answer

component.find('myLwc').call('doSomething');. Aura components invoke public Lightning Web Component methods through the call() method on the element returned by find(), passing the method name as a string. Plain function calls, the Aura get('c.method') accessor, and getReference do not reach an LWC's @api methods and fail at runtime.

Answer

component.getReference('c.doSomething')();

Answer

component.find('myLwc').get('c.doSomething')();

Answer

component.find('myLwc').doSomething();

Question 15

A developer is deploying a new Lightning web component that calls an Apex controller method. The deployment to production fails because the Apex class is not covered by tests. The developer needs to ensure the Apex class meets the 75% test coverage requirement and that the tests are robust. Which two actions should the developer take to achieve this? (Choose two.)

Accepted Answer

Write test methods that cover all branches of the Apex controller, including positive and negative scenarios.. To meet coverage requirements and ensure robust tests, the developer should write test methods that cover all branches, including positive and negative scenarios, and include assertions that validate outcomes and exception handling. These actions ensure that the Apex controller's logic is thoroughly exercised and verified, which is essential for production deployment.

Answer

Use @TestVisible private methods to expose internal logic for testing without altering the public API.

Answer

Create test data using Test.loadData() with a static resource to ensure consistent data across test methods.

Answer

Use Test.startTest() and Test.stopTest() to reset governor limits and isolate the test data.

Question 16

A developer is creating a REST API endpoint in Salesforce that external systems will call to create Case records. The external system sends a JSON payload with a custom header 'X-API-Key' for authentication. The developer needs to validate this key against a custom setting before processing the request. Which Apex class should the developer use to implement this endpoint?

Accepted Answer

A class annotated with @RestResource(urlMapping='/Cases/*'). The correct approach is to use a class annotated with @RestResource and a URL mapping. This exposes the Apex class as a REST endpoint. The developer can then define a method with @HttpPost to handle incoming POST requests, validate the 'X-API-Key' header against a custom setting, and create Case records. Other interfaces like Schedulable, Batchable, or Queueable are for asynchronous processing and do not provide REST endpoints.

Answer

A class that implements the Queueable interface

Answer

A class that implements the Schedulable interface

Answer

A class that implements the Database.Batchable interface

Question 17

A developer is building a Lightning Web Component for a Lightning Experience record page. The component must display a toast notification to the user after a successful save operation. The developer uses the ShowToastEvent from the lightning/platformShowToastEvent module. Which import statement is correct?

Accepted Answer

import { ShowToastEvent } from 'lightning/platformShowToastEvent';. The correct import statement is the one that uses the exact module name 'lightning/platformShowToastEvent' and the named export ShowToastEvent. This is the only valid way to import the toast event class in LWC. After importing, the developer instantiates the event with new ShowToastEvent({...}) and dispatches it. The other options either use wrong export names, wrong import styles, or incorrect module paths, all of which would fail at build time.

Answer

import { showToast } from 'lightning/platformShowToastEvent';

Answer

import ShowToastEvent from 'lightning/platformShowToastEvent';

Answer

import { ShowToastEvent } from 'lightning/toastEvent';

Question 18

A developer must write Apex tests that reliably cover a Queueable class which performs a callout and then enqueues a second Queueable job. The tests must not make real external callouts. (Choose two.)

Accepted Answer

Implement HttpCalloutMock and register it with Test.setMock(HttpCalloutMock.class, mock) before invoking the Queueable.. To test a Queueable that makes a callout and chains another job without real external calls, the developer registers an HttpCalloutMock so the callout is stubbed, and wraps the enqueue in Test.startTest()/Test.stopTest() so queued work runs synchronously. Together these techniques validate both the callout handling and the chained job's behavior in a controlled, offline test.

Answer

Annotate the test method with @IsTest(SeeAllData=true) so the chained job can see the records it needs.

Answer

Set the Queueable to run with System.enqueueJob(new MyQueueable(), 5) to increase the delay so the test can observe intermediate state.

Answer

Replace the callout with a hard-coded response inside the Queueable when Test.isRunningTest() returns true.

Question 19

A developer is integrating Salesforce with an external ERP using a REST API. The ERP requires that each request include a unique correlation ID for tracing. The developer implements an Apex callout that sends the correlation ID in a custom HTTP header. During testing, the callout succeeds, but the ERP logs show that the correlation ID is missing. What is the most likely cause?

Accepted Answer

The HTTP request was created using a new HttpRequest() object, but the header was set on a different HttpRequest instance.. The correct answer is that the header was set on a different HttpRequest instance than the one sent. In Apex, HttpRequest objects are not immutable; you must set headers on the same object that you pass to Http.send(). If two instances are created, the header on the unused instance is ignored, leading to the external system not receiving it. This is a subtle but common coding error.

Answer

The header name must be prefixed with 'X-' to be recognized by the external system.

Answer

The custom header was added to the request after the callout was sent.

Answer

Salesforce automatically strips custom headers from outbound callouts for security reasons.

Question 20

A developer is troubleshooting a production issue where a trigger occasionally exceeds CPU time limits. The developer wants to capture detailed debug logs for a specific user without slowing down the entire org, and then analyze the log to identify the slowest operations. Which combination of Salesforce tools should the developer use?

Accepted Answer

Debug Logs with a user-specific trace flag, then the Analysis perspective in the Developer Console. A user-specific trace flag generates debug logs only for that user, keeping overhead contained while capturing the problematic transaction. The Developer Console's Analysis perspective then parses the log and ranks operations by execution time, exposing the slowest SOQL, DML, and method calls. This focused capture and analysis directly targets the CPU time issue without impacting other users.

Answer

Event Monitoring via the EventLogFile object, then Workbench to query the logs

Answer

Setup Audit Trail to identify the user, then Apex Replay Debugger to step through the log

Answer

Apex Profiler in VS Code with the Apex extension, then the Timeline view