SF-PD2 Practice Test 9 — 10 Questions

Question 1

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?

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

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 2

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 3

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 4

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 5

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 6

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 7

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 8

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 9

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 10

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.