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

Question 1

A developer is writing a test class for an Apex trigger that performs a callout. The developer uses a mock class implementing HttpCalloutMock. What happens if the developer fails to implement the mock interface correctly?

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

Accepted Answer

The test will throw a CalloutException when the trigger code attempts to invoke the HTTP method.. Apex code cannot perform real HTTP callouts during unit tests; Salesforce enforces this to prevent unpredictable external side effects. If the mock interface is not implemented or registered properly using Test.setMock, the system throws a CalloutException. Understanding this mechanism is vital for building robust integration tests, ensuring that external dependency behavior is deterministic and verifiable without hitting actual production endpoints during development cycles.

Answer

The test class will execute the real callout successfully if the endpoint is whitelisted in Remote Site Settings.

Answer

The trigger will process the callout using the default settings defined in Named Credentials.

Answer

The system will automatically generate a mock response based on the WSDL or OpenApi schema.

Question 2

Refer to the exhibit. A developer encounters this LimitException in a bulkified trigger. What is the most likely cause based on the provided stack trace?

Accepted Answer

A SOQL query is being executed inside a 'for' loop that iterates over the Trigger.new collection.. The LimitException indicating 'Too many SOQL queries' signifies that the code is executing a SOQL query inside a loop. This is a common performance bottleneck in Apex. Proper bulkification requires moving queries outside of loops by gathering IDs into a Set or List, then performing a single query. Mastering bulkification is essential for passing the PD2 exam and writing scalable enterprise applications.

Answer

The trigger is running on a massive dataset, exceeding the total record processing limit of 50,000 records.

Answer

The trigger is calling a static method that is performing a DML operation on the same object causing recursion.

Answer

The system is experiencing temporary resource contention due to excessive concurrent users in the organization.

Question 3

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 4

A developer is preparing to deploy a complex change set from a sandbox to production. The change set includes Apex classes, Visualforce pages, and a new custom object. The developer runs all tests in the sandbox and achieves 100% coverage, but the deployment to production fails with the error: 'Your organization's code coverage is 68%. You need at least 75% coverage to complete this deployment.' What is the most likely cause of this discrepancy?

Accepted Answer

The production org has existing Apex classes that are not covered by the tests in the change set, lowering the overall coverage.. The deployment failed because Salesforce requires 75% overall code coverage across the entire organization, not just the new code. Production likely contains legacy Apex classes that are not covered by the tests in the change set. To resolve this, the developer must include tests that cover those existing classes or ensure that the deployed tests exercise them.

Answer

The production org has a higher number of asynchronous Apex jobs that interfere with test execution.

Answer

The sandbox and production have different API versions, causing the tests to run differently.

Answer

The change set does not include the test classes, so they are not run in production.

Question 5

A developer deploys metadata to a production org using the Salesforce CLI. The deployment succeeds, but a post-deployment validation script that relies on a newly created custom setting record fails because the record is missing. The developer confirms the custom setting metadata was included in the package. What is the most likely explanation?

Accepted Answer

Custom setting records are not deployable through Metadata API, so they must be inserted with Apex or the data loader after deployment.. Custom setting records are treated as data rather than metadata, so a deployment that includes the custom setting definition does not carry its records. The post-deploy script fails because it queries a record that was never inserted into production. The developer must load the record separately after the metadata deployment completes, typically through Anonymous Apex or the data loader.

Answer

The deployment ran with the --dry-run flag, which validates but does not commit custom setting records to the target org.

Answer

Custom setting records deploy only when the org has the Custom Settings license enabled on the target user's profile.

Answer

The post-deployment script ran before the custom setting metadata finished indexing, so the record existed but was not yet queryable.

Question 6

A developer is writing an Apex test class for a service that must be resilient against partial failures. The service calls a REST endpoint using a callout and, when the callout succeeds, performs a DML update on a set of Account records. The developer wants the test to simulate the HTTP response without hitting the real external system. Which approach should the developer use?

Accepted Answer

Implement the HttpCalloutMock interface and register it with Test.setMock(HttpCalloutMock.class, new MyMock()) before the callout is invoked.. The Apex testing framework provides Test.setMock with an HttpCalloutMock implementation precisely so callouts can be exercised without external dependencies. Registering the mock before the request executes makes the runtime substitute the developer-defined HttpResponse, letting assertions validate both the request built by the code and the handling of the response, including error status codes.

Answer

Create the mock response by inserting a ContentVersion record and reference it from the callout using the endpoint URL of the mock.

Answer

Annotate the test method with @IsTest(SeeAllData=true) so the test can reach the live endpoint and then assert on the returned payload.

Answer

Wrap the callout in Test.startTest() and Test.stopTest() so the platform automatically intercepts the outbound request and returns a synthetic 200 response.

Question 7

A developer is troubleshooting an Apex class that intermittently throws a System.LimitException during integration tests. The developer needs to see the exact sequence of method calls and the values of variables at each step without modifying the class. Which Salesforce feature should the developer use?

Accepted Answer

Apex Replay Debugger. Apex Replay Debugger consumes a captured debug log and replays execution with breakpoints, variable inspection, and call-stack navigation, all without altering the class. Because the failure is intermittent and occurs during integration tests, the developer can capture a log of the failing run and replay it to find the exact point where the limit is exceeded.

Answer

The Apex Test Execution page in Setup

Answer

Checkpoints in the Developer Console

Answer

Debug Log levels set to FINEST for Apex Code

Question 8

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 9

A developer has written an Apex class that includes a method to calculate shipping costs. The method contains several conditional branches. The developer wants to ensure that all branches are tested and that the test class provides sufficient coverage for deployment. Which Salesforce feature should the developer use to identify which lines of code are not covered by tests?

Accepted Answer

The Code Coverage view in the Developer Console. The Code Coverage view in the Developer Console is the correct tool because it provides a visual representation of which lines of code are executed during tests. Uncovered lines are highlighted in red, enabling developers to quickly identify and address gaps in test coverage. This is essential for meeting deployment requirements.

Answer

The Apex Test Coverage report in Salesforce Reports

Answer

The Apex Test Execution page in Setup

Answer

The Developer Console's Test > New Run feature

Question 10

A developer needs to run a single Apex test method named testBulkInsert in a class named AccountServiceTest against a sandbox org and view the results from the command line. Which Salesforce CLI command should the developer use?

Accepted Answer

sf apex run test --tests AccountServiceTest.testBulkInsert --target-org mySandbox --result-format human. The sf apex run test command is the current Salesforce CLI command for executing Apex tests, and its --tests flag accepts a fully qualified ClassName.methodName to target a single method. Adding --result-format human makes the output readable in the terminal, which matches the developer's goal of running one test and viewing results from the command line.

Answer

sf project deploy start --test-level RunSpecifiedTests --tests AccountServiceTest.testBulkInsert

Answer

sf apex get test --tests AccountServiceTest.testBulkInsert --target-org mySandbox

Answer

sf apex run --file AccountServiceTest.cls --target-org mySandbox

Question 11

A developer is deploying a new Apex class to production using a change set. The class contains a method that performs a callout to an external web service. During deployment, the developer receives an error: 'Callout not allowed from a test method.' Which action should the developer take to resolve this error while ensuring the test method still validates the callout logic?

Accepted Answer

Implement the HttpCalloutMock interface and use Test.setMock to simulate the callout response in the test method.. The correct solution is to implement HttpCalloutMock and use Test.setMock, which allows the test to simulate the callout response without making a real callout. This adheres to Salesforce's testing requirements and ensures the callout logic is properly validated. Other options either do not resolve the error or compromise test coverage.

Answer

Use Test.isRunningTest to conditionally skip the callout when the test is executing.

Answer

Move the callout logic to a future method and call it from the test method.

Answer

Wrap the callout in a try-catch block to suppress the error during test execution.

Question 12

A developer is preparing to deploy a change set from a sandbox to production. The change set includes a new custom object, its fields, a Visualforce page, and an Apex controller. After uploading the change set, the developer notices that the custom object and fields are missing from the change set components. What is the most likely reason?

Accepted Answer

The custom object and fields were not explicitly added to the change set when it was created.. Change sets do not automatically include dependencies. When a developer adds a Visualforce page or Apex class, the associated custom object and fields are not added automatically. The developer must manually add each component. Therefore, the missing object and fields are due to them not being explicitly added during change set creation.

Answer

The change set was created in a sandbox that is not the source of the custom object and fields.

Answer

The custom object and fields are only available in the sandbox and cannot be deployed to production.

Answer

The custom object and fields were not added to the change set because they are not supported in change sets.

Question 13

A developer is preparing an Apex test class that must cover a service which schedules a Queueable job, and the test must verify that the queued job's logic actually ran and updated a record. The developer also needs the test to pass reliably in a CI pipeline. (Choose two.)

Accepted Answer

Assert on the updated record after Test.stopTest() returns, since the queued job's DML completes by then.. To test Queueable logic, enqueue the job between Test.startTest() and Test.stopTest(); stopTest() forces the asynchronous transaction to complete synchronously, and assertions placed afterward validate the real record changes. This pattern produces deterministic results in CI because the job's effects are observable before the test ends.

Answer

Use Test.setCreatedDate() to backdate the queued job's enqueue timestamp so the scheduler picks it up immediately.

Answer

Enqueue the job before Test.startTest() so it is queued outside the limit-reset boundary and runs independently.

Answer

Wrap the enqueue call in a try/catch for System.AsyncException and treat a caught exception as proof the job executed successfully.

Question 14

A developer is preparing a deployment of a new Apex class and its test class to production. The test class uses @TestSetup to insert 200 Account records, and each of six test methods queries all 200 Accounts. The deployment fails during validation with a CPU timeout error. Which change most directly addresses the timeout without reducing coverage?

Accepted Answer

Replace the full-object queries with selective SOQL that filters and returns only the fields and rows each test actually needs.. CPU timeouts in test execution usually trace to expensive query volume. Querying every row with every field six times forces the platform to materialize a large result set repeatedly. Tightening the SOQL so each test retrieves only the fields and rows it needs cuts CPU consumption directly while keeping the same behavioral assertions and coverage.

Answer

Move the Account insertion into each test method instead of @TestSetup so each method gets a fresh set of records.

Answer

Annotate the test class with @isTest(OnInstall=false) to defer test execution until after the package is installed.

Answer

Convert the test methods to use System.runAs() so the queries execute under a user with fewer permission checks.

Question 15

A developer maintains a managed package and must release a new version. During packaging, the developer needs to ensure that a specific Apex class is accessible to subscriber orgs but that its implementation details remain hidden. Which packaging construct should the developer use?

Accepted Answer

Mark the Apex class as global and expose only global method signatures, keeping internal helper methods private.. Managed package Apex visibility is governed by the global access modifier. Declaring the class and selected methods global exposes a stable API to subscriber code across namespaces, while private helpers and internal logic stay hidden. This supports controlled upgrades because global signatures are versioned with the package.

Answer

Deploy the Apex class using the Metadata API with the unpackaged flag enabled to keep it outside the managed namespace.

Answer

Set the Apex class access to Public in the package's profile settings so subscribers can call it directly.

Answer

Add the Apex class to a protected custom setting so it is packaged but not exposed to subscriber code.