SF-PD2 Testing, Debugging, and Deployment Practice Test 2 — 15 Questions

Question 1

Refer to the exhibit. A developer encounters this error in a test method that processes a batch of records. What is the most efficient way to resolve this while ensuring the code remains testable?

Accepted Answer

Wrap the code block executing the SOQL queries in Test.startTest() and Test.stopTest().. The LimitException occurs because the code exceeds the 100 SOQL query limit. Wrapping the core logic within Test.startTest() and Test.stopTest() allows the developer to reset governor limits. This is a critical pattern in Salesforce testing to ensure that complex bulk processing logic can be validated against platform limits without artificial failures caused by test setup overhead.

Answer

Increase the number of test records created in the setup phase to match production.

Answer

Rewrite the SOQL queries to be more selective using index fields.

Answer

Increase the SOQL query limit by modifying the Org's system settings.

Question 2

A developer is preparing a deployment from a Developer sandbox to a Full Copy sandbox. Which THREE steps are mandatory to ensure a successful and compliant deployment using Salesforce CLI?

Accepted Answer

Run 'sf project deploy validate' to perform a check-only deployment.. Successful deployment requires rigorous source control management, metadata validation, and test execution. Developers must ensure that local source matches the target, validate against production-like environments, and include unit tests for coverage. These practices minimize downtime, prevent configuration drift, and ensure that only verified code reaches downstream environments, which is vital for maintaining the stability of the entire release pipeline.

Answer

Force all deployments to production using the --ignore-warnings flag.

Answer

Include a data migration script to ensure production data is in the sandbox.

Question 3

A developer is investigating a race condition in a test class that interacts with asynchronous Apex. What is the best way to synchronize the test execution with the asynchronous operation?

Accepted Answer

Wrap the asynchronous trigger logic in Test.stopTest().. Asynchronous processes like @future, Queueable, or Batch Apex run in a separate thread. Using Test.stopTest() forces the Salesforce platform to process all queued asynchronous jobs before the test continues. This is the only reliable way to assert the results of asynchronous side effects, as it guarantees the jobs complete before the validation phase of the test begins.

Answer

Insert a Thread.sleep(5000) call to wait for the job to finish.

Answer

Query the AsyncApexJob object within a while loop to check for completion.

Answer

Use the System.enqueueJob() method within the test method itself.

Question 4

A developer needs to optimize a test suite that is running slow in the CI/CD pipeline. Which TWO strategies should be implemented to reduce test execution time?

Accepted Answer

Use @testSetup to create common test data once for all methods in the class.. Test suite performance is critical for CI/CD speed. Avoiding excessive data setup, specifically by using static resources or @testSetup, significantly reduces transaction overhead. Furthermore, parallelizing execution and ensuring tests are independent prevents bottlenecks. These strategies help maintain a fast feedback loop, allowing developers to iterate quickly while ensuring that the entire codebase remains well-covered by high-quality, efficient unit tests.

Answer

Create test data inside each individual test method to ensure complete isolation.

Answer

Run all tests in a single transaction to minimize the overhead of setup/teardown.

Answer

Increase the batch size of the test class to run more records at once.

Question 5

A developer needs to verify that an Apex trigger is correctly handling a bulk DML operation that involves 500 records. What is the most important practice to include in the test method?

Accepted Answer

Verify the result by querying the database after the DML operation.. Testing with a collection of records (greater than 200) is the only way to ensure that the code is bulk-safe and handles governor limits correctly. Using bulk data tests catches issues related to SOQL in loops or DML in loops that would pass with single-record tests but fail in production scenarios, ensuring robust code performance.

Answer

Use System.runAs() to execute the test as a user with limited permissions.

Answer

Ensure the test method has the @isTest(SeeAllData=true) annotation enabled.

Answer

Use Test.startTest() to ensure the trigger runs in a separate thread.

Question 6

A developer is writing a test class for a custom controller that performs complex DML operations. The developer needs to ensure that the test class does not impact the production data while verifying that the DML operations perform as expected. Which approach should the developer use?

Accepted Answer

Annotate the test class with @isTest to ensure all DML operations are rolled back.. Using the @isTest annotation on the class and individual test methods ensures that all DML operations are automatically rolled back when the test finishes. This maintains data integrity, ensuring production data remains untouched. This pattern is crucial for reliable CI/CD pipelines, as it allows developers to execute comprehensive tests without managing side effects or data cleanup routines, ensuring that every deployment remains idempotent and predictable.

Answer

Call the Database.rollback() method explicitly at the end of every test method.

Answer

Create a separate setup class to insert necessary test data and delete it in a finally block.

Answer

Use the Test.startTest() and Test.stopTest() methods to enclose the DML operations.

Question 7

A developer is diagnosing a slow-running Apex method that executes multiple SOQL queries inside a loop. Which TWO actions should the developer take to identify the performance bottlenecks and optimize the code?

Accepted Answer

Enable 'Finest' debug log levels for the Apex Profiling category and analyze the execution log.. Identifying performance bottlenecks requires both monitoring execution logs and refactoring code to follow bulkification patterns. Debug logs provide the granular timing data necessary to pinpoint exactly which queries are expensive. Meanwhile, moving SOQL outside of loops is the fundamental architectural requirement for scalable Salesforce applications. Combining these two approaches ensures the developer identifies the issue and implements a robust, platform-compliant solution that avoids governor limit exceptions in high-volume environments.

Answer

Increase the SOQL query governor limits using the Test.setLimitConfiguration() method.

Answer

Use the Developer Console to perform a system-wide search for all SOQL queries in the org.

Answer

Manually restart the application server to clear the cached query plans.

Question 8

A developer is writing a test class for an Apex class that performs a callout to an external REST API. Which TWO steps must be taken to ensure the test passes successfully?

Accepted Answer

Implement the HttpCalloutMock interface in a separate test class.. Testing callouts requires mocking the response because external network traffic is prohibited during Apex tests. The HttpCalloutMock interface allows developers to simulate server responses without actual network communication, ensuring tests remain fast and reliable. Without this mocking, the test will fail as the platform blocks the callout, highlighting the need to decouple internal logic from external infrastructure in a controlled, predictable testing environment.

Answer

Call the Test.startTest() method before executing the callout.

Answer

Include the external API endpoint in the Remote Site Settings.

Answer

Wrap the callout logic in a try-catch block to handle connection timeouts.

Question 9

Which tool is best for viewing real-time debug logs for a specific user session during a complex deployment process?

Accepted Answer

Developer Console with Trace Flags configured for the user.. The Developer Console provides a persistent 'Logs' tab that allows a developer to set trace flags for a specific user. This is the primary mechanism for real-time debugging in Salesforce. By setting these flags, the developer captures granular event details, which is indispensable for identifying logic errors or unexpected behavior as it occurs, ensuring that issues are resolved quickly during time-sensitive deployment windows.

Answer

Salesforce Setup 'Debug Logs' page.

Answer

The Salesforce CLI 'force:apex:log:get' command.

Answer

Event Monitoring logs in the Setup menu.

Question 10

Refer to the exhibit. A developer is applying this policy to a CI/CD pipeline. What is the impact of this policy on the deployment process?

Accepted Answer

It grants permission to execute Apex code during the deployment process.. The policy enables the execution of Apex code via the CI/CD pipeline. In a Salesforce context, this allows the deployment process to trigger unit tests and potentially perform destructive changes or metadata operations. This is a critical governance component, ensuring that the pipeline has the necessary permissions to validate code quality before it is promoted to production, thus maintaining the integrity of the release management lifecycle.

Answer

It restricts the deployment to read-only access for metadata.

Answer

It limits the deployment to only executing tests in the sandbox.

Answer

It prevents the deployment from executing any Apex code.

Question 11

A developer wants to verify if a method is being called by a trigger. Which approach allows the developer to test this interaction effectively?

Accepted Answer

Use a static boolean flag in the handler to track method execution.. Using a mock or a logging framework is the standard way to verify interactions. However, in Apex, developers often use a 'setter' injection or static variables to track if a method was invoked. This pattern ensures that the test code can inspect the internal execution path of the trigger, confirming that the business logic was triggered correctly, which is vital for verifying complex object-oriented designs.

Answer

Use the Test.isRunningTest() check inside the production trigger.

Answer

Query the Debug logs to ensure the trigger execution string is present.

Answer

Implement the Trigger Framework to capture call history in a custom object.

Question 12

Which THREE practices are essential for developing robust and maintainable Apex unit tests?

Accepted Answer

Create all necessary test data within the test method or @testSetup.. Robust tests rely on data isolation, bulkification, and clear assertions. Data isolation ensures tests are unaffected by the environment, bulkification ensures the code scales, and clear assertions provide immediate feedback when logic fails. Following these practices makes the test suite a reliable asset for developers, preventing regressions and ensuring that code quality remains high as the project grows in complexity and scale over time.

Answer

Test with a single record to ensure the simplest case is covered.

Answer

Execute multiple tests in a single method to save time.

Question 13

A developer is tasked with debugging a production issue where a trigger occasionally fails with a 'UNABLE_TO_LOCK_ROW' error. The error occurs only when multiple users update the same parent record's child records simultaneously. The developer needs to reproduce the issue in a sandbox. Which approach is most effective for simulating the concurrent updates?

Accepted Answer

Create a script using Salesforce CLI to make multiple simultaneous API calls that update child records.. To reproduce row lock contention, the developer must generate concurrent updates to the same parent record's children. Using an external tool like Salesforce CLI to send multiple simultaneous API calls can create the necessary parallelism. This allows the developer to observe the locking behavior and test potential solutions, such as retry logic or record locking.

Answer

Write an Apex test that uses Test.startTest() and performs DML in parallel using Queueable jobs.

Answer

Use the Developer Console to execute anonymous Apex that performs updates in a loop.

Answer

Enable Apex debug logs for all users and monitor for lock errors.

Question 14

A developer is troubleshooting an Apex class that intermittently exceeds CPU time limits in production. The class performs complex string manipulation and recursive processing on large collections. The developer wants to capture detailed timing and query information for a specific user's transaction without enabling verbose logging for the whole org. Which tool should the developer use?

Accepted Answer

Developer Console's Logs panel with the log level set to FINEST for the Apex Code category and the user filter applied.. Granular trace flags scoped to one user, combined with the Developer Console's log inspection and execution timeline, expose CPU time, cumulative resource usage, and individual SOQL statements at the FINEST level. This isolates the expensive code path while avoiding org-wide verbose logging, which would degrade performance and consume log storage.

Answer

Event Monitoring's ApexExecution event type queried through the EventLogFile object to obtain per-transaction CPU metrics.

Answer

Apex Replay Debugger launched against a production org with the Apex Interactive Debugger enabled for all users.

Answer

Setup Audit Trail filtered by the affected user to review the sequence of Apex executions and their CPU consumption.

Question 15

A developer is writing an Apex class that uses a SOQL query to fetch Account records based on a dynamic search string provided by the user. The query is constructed using string concatenation. Which approach should the developer use in the test class to ensure the query is not vulnerable to SOQL injection and to maintain test coverage?

Accepted Answer

Use Database.queryWithBinds to bind the user input as a variable in the query.. Using Database.queryWithBinds is the correct approach because it binds user input as a variable, preventing SOQL injection by ensuring the input is treated as a value, not code. This method is secure and recommended for dynamic queries with untrusted input. Other options either provide incomplete protection or are invalid for dynamic queries.

Answer

Use Database.query with the user input concatenated and rely on the platform's built-in sanitization.

Answer

Use String.escapeSingleQuotes on the user input before concatenating it into the query string.

Answer

Use a static SOQL query with a WHERE clause that includes the user input as a literal.