SF-PD2 Testing, Debugging, and Deployment — 20 Questions

Question 1

A developer is preparing a large metadata deployment package using Salesforce CLI. Which TWO strategies should the developer implement to optimize deployment speed and minimize component locking issues? Choose 2 answers.

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

Accepted Answer

Utilize the sf project deploy validate command followed by sf project deploy quick to execute deployments without re-running tests.. Optimizing metadata deployments requires leveraging targeted validation techniques and reducing lock contention. Using Quick Deploy for pre-validated changes bypasses redundant test runs, while deploying test classes separately prevents object locking conflicts. These strategies are critical for maintaining continuous integration pipelines and preventing deployment bottlenecks in large enterprise orgs.

Answer

Include all profile and permission set metadata in every incremental hotfix deployment to ensure security consistency across environments.

Answer

Run all local unit tests during every single minor metadata deployment regardless of whether Apex classes were modified.

Answer

Disable all active workflow rules and validation rules in the target production environment manually before initiating deployments.

Question 2

A developer writes a unit test class that queries millions of records to test a bulkified batch apex job. The test fails with a QueryException regarding result size limits. Which TWO best practices should the developer apply to write robust, scalable test data? Choose 2 answers.

Accepted Answer

Inject mock data collections directly into service classes or utilize Test.setFixedSearchResults for search-based queries.. Unit tests share the same governor limits as standard transactions, albeit with generous allowances for data creation. Developers must adhere to selective querying patterns and avoid querying large production data volumes by utilizing Test.isRunningTest() guards or injecting mock datasets, ensuring tests remain performant and compliant with platform limits.

Answer

Use SeeAllData=true on the test class to access production records directly without needing to generate test data in code.

Answer

Increase the governor limit for SOQL query rows by contacting Salesforce customer support before executing test suites.

Answer

Execute all data manipulation language statements inside a single large loop without bulkifying the test setup method.

Question 3

A developer is optimizing an Apex test suite that runs slowly in the CI/CD pipeline. Which TWO techniques should the developer apply to improve test execution performance? Choose 2 answers.

Accepted Answer

Use the @testSetup annotation to create shared test records once per test class instead of re-creating them in every test method.. Optimizing test suite runtimes is essential for maintaining efficient CI/CD pipelines. Utilizing Test.startTest() and Test.stopTest() to reset governor limits, and creating minimal test data sets in @testSetup methods rather than redundant inserts in every test method, drastically reduces execution time and CPU consumption.

Answer

Disable parallel test execution in the Salesforce test runner configuration to prevent database table locking conflicts.

Answer

Execute comprehensive SOQL queries with large offset clauses inside every individual test method to verify pagination logic.

Answer

Write all unit tests in a single monolithic Apex class to avoid overhead associated with initializing multiple test contexts.

Question 4

A developer is writing a test class for a custom controller. The controller performs a DML operation that triggers an email alert. The developer needs to verify the email was sent without actually triggering an external SMTP server. Which approach is best?

Accepted Answer

Use Limits.getEmailInvocations() within the test method to assert the count is greater than zero.. Using the Limits.getEmailInvocations() method is the standard way to programmatically assert that email services were invoked during a test execution. This approach is superior because it validates the logic flow without requiring complex external mocks or risking actual email transmission. Mastering these governor-based assertions ensures robust test coverage while adhering to Salesforce's multi-tenant resource constraints.

Answer

Use a @Mock annotation on the Email class to intercept outgoing traffic during runtime.

Answer

Configure an external HTTP mock service to listen for the SMTP traffic from the Salesforce instance.

Answer

Query the EmailMessage object to verify that a record was created in the database.

Question 5

A team is adopting a continuous integration (CI) pipeline for Salesforce. Which THREE tasks are essential for ensuring a successful, reliable deployment process?

Accepted Answer

Incorporate Static Code Analysis tools like PMD or CodeScan.. Successful CI/CD in Salesforce requires automating the entire lifecycle. Running static code analysis prevents poor coding habits, automated test execution ensures that breaking changes are caught early, and using a dedicated scratch org for validation ensures that the environment is pristine. These practices form the foundation of a robust release management strategy, minimizing manual errors and accelerating the delivery of high-quality software features.

Answer

Enable 'Run Local Tests' for every deployment to production.

Answer

Manually deploy metadata via the Change Sets UI to keep a history.

Question 6

A developer is writing a test that needs to mock a callout to an external REST API. What is the required interface for the mock class?

Accepted Answer

HttpCalloutMock. The HttpCalloutMock interface is mandatory for testing Apex callouts. Salesforce forbids real outbound HTTP requests in tests, so the framework requires the developer to provide a class that implements the respond() method. This method intercept the request and returns a mock HttpResponse, ensuring tests are deterministic, fast, and avoid side effects in the remote external system during development.

Answer

WebServiceMock

Answer

Test.setMock()

Answer

RestResponseMock

Question 7

A developer needs to measure the performance of a method. Which approach provides the most accurate way to capture the CPU time consumed by that specific block of code?

Accepted Answer

Limits.getCpuTime(). Using Limits.getCpuTime() before and after a code block is the only accurate way to calculate consumed CPU time within a transaction. This allows the developer to isolate the cost of specific logic. Monitoring CPU time is a critical skill for high-performance development, as it helps prevent hitting execution limits in complex, multi-tenant environments where shared resources are strictly constrained by the platform's governor system.

Answer

System.now().getTime()

Answer

Apex profiling logs in the Developer Console

Answer

The 'Debug Logs' file size.

Question 8

Refer to the exhibit. The test is failing with a 'Too many SOQL queries' error. What is the most likely cause given the stack trace?

Accepted Answer

A SOQL query is being executed inside a 'for' loop within the trigger handler.. The error 101 specifically indicates a SOQL query being executed inside a loop. This is a common performance anti-pattern. The stack trace points to line 50 of the handler. In a test environment, where data is often inserted in batches, this code fails because it queries the database for every record in the trigger collection rather than performing a single bulk query outside the loop.

Answer

The trigger handler lacks a 'without sharing' modifier.

Answer

The test class is inserting more than 100 Account records.

Answer

The database is currently undergoing a heavy maintenance window.

Question 9

A developer is writing a test for a class that uses the 'with sharing' keyword. What THREE things must the developer keep in mind when writing tests for this class?

Accepted Answer

Tests run as a system administrator by default, ignoring sharing rules.. Even in tests, 'with sharing' enforces record visibility. Developers must create test users and share records appropriately to verify that logic respects the sharing model. Failing to account for this leads to tests that pass in a development environment but fail in a production environment due to varying record access settings, making it essential to test for security-sensitive code logic thoroughly.

Answer

The 'with sharing' keyword is ignored during unit test execution.

Answer

Tests must always be run as a standard user, never as an admin.

Question 10

A developer is writing a test class for an Apex trigger and needs to verify that the trigger correctly updates a related record. Which approach ensures the test adheres to best practices regarding data isolation and governor limits?

Accepted Answer

Wrap the trigger invocation in Test.startTest() and Test.stopTest().. Using Test.startTest() and Test.stopTest() is the industry standard for isolating asynchronous execution and resetting governor limits. This ensures that the DML operations performed within the trigger do not count against the limits of the test setup. Proper test class design is critical for reliable deployments and preventing false negatives in a continuous integration pipeline, especially when handling complex triggers that fire in bulk contexts.

Answer

Query all records from the database without using Test.startTest().

Answer

Use SeeAllData=true in the @isTest annotation to access existing records.

Answer

Hardcode record IDs in the test class for assertion verification.

Question 11

When debugging a performance issue in a production environment, which tool is the most appropriate to inspect CPU time consumption and database query patterns?

Accepted Answer

The Debug Log with 'Apex Profiling' level enabled.. The Developer Console's Execution Log, specifically with the 'Profiling' filter, allows developers to see the exact time spent in each code block and the frequency of SOQL queries. Understanding how to interpret logs is essential for identifying bottlenecks in complex Apex logic. This skill allows developers to proactively optimize code before it causes systemic failures, ensuring the application maintains optimal response times for all users.

Answer

The Setup Audit Trail.

Answer

The Salesforce Optimizer report.

Answer

The Field History tracking log.

Question 12

Which THREE steps are necessary to ensure that a deployment using Change Sets includes all dependent components for a complex Apex class?

Accepted Answer

Add the main Apex class to the Change Set.. Change Sets are additive, requiring developers to manually include all dependencies, such as custom fields, related triggers, and Apex classes. Failure to include a dependency results in a deployment failure. Mastering the manual 'Add to Change Set' workflow is essential for developers working in environments where modern CLI-based tools are not yet fully adopted, ensuring all required metadata is packaged properly for target environments.

Answer

Include the test class coverage manually in the Change Set.

Answer

Automatically include all components by checking 'Include All Dependencies'.

Question 13

Which TWO of the following are true regarding the use of 'System.runAs()' in Apex unit tests?

Accepted Answer

It can be used to test how sharing rules affect data visibility.. System.runAs() is essential for testing record-level security, as it simulates the execution context of a specific user. It allows developers to verify that sharing rules, profile permissions, and hierarchy-based access are correctly enforced. Understanding this is critical for building secure applications and ensuring that data visibility is strictly controlled according to business requirements, protecting sensitive information from unauthorized access.

Answer

It changes the user context for the entire test method execution.

Answer

It ignores all user permissions and runs as a system administrator.

Answer

It requires the creation of a new user in the production environment.

Question 14

A developer is writing a test class for a custom controller that performs complex DML operations. The developer needs to ensure that the test data does not persist in the database after the test execution finishes. Which approach should the developer use?

Accepted Answer

Annotate the class with @isTest to ensure all DML operations are rolled back automatically.. Using the @isTest annotation at the class level ensures that all test methods within the class automatically roll back any database changes made during execution. This maintains data integrity across test suites and prevents unintended side effects. Understanding test isolation is crucial for reliable, predictable CI/CD pipelines where multiple developers run tests simultaneously in shared environments.

Answer

Manually delete all created records at the end of each test method using a finally block.

Answer

Set the test class access modifier to private to prevent external data interference.

Answer

Call Test.startTest() and Test.stopTest() to wrap the DML operations.

Question 15

A developer is creating a Lightning Web Component and needs to debug issues that occur only in the production environment. Which TWO tools or features should the developer use to identify the root cause?

Accepted Answer

Enable debug logs for the specific user experiencing the issue.. Debugging in production requires non-intrusive tools because standard debuggers are unavailable. The Developer Console's debug logs provide server-side execution visibility, while Browser DevTools offer client-side inspection. Mastering these allows developers to isolate failures in environments where direct code manipulation is prohibited, ensuring high-quality production support and adherence to strict security standards regarding environment access.

Answer

Use the Salesforce Apex Debugger to set breakpoints in production code.

Answer

Attach a remote debugger to the production Lightning App Builder.

Answer

Modify the LWC source code to inject console.log statements directly in production.

Question 16

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 17

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 18

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 19

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 20

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.