Pass the Salesforce Developers PDII Questions and answers with CertsForce

To use the @wire service in a Lightning Web Component (LWC) to retrieve data from an Apex method, the Apex method must be marked as cacheable. In the provided OpportunityController class, the findMyOpportunities method is annotated with @AuraEnabled, but it lacks the mandatory cacheable=true property.

The @wire service is part of the Lightning Data Service (LDS) reactive framework. Salesforce requires wireable methods to be cacheable to improve performance and ensure that data can be stored in the client-side cache. Without (cacheable=true), the @wire decorator will fail to execute, resulting in the "Error retrieving data" message or a similar runtime failure.

Option C is the correct fix: the developer must update the annotation to @AuraEnabled(cacheable=true). Option A (Continuation) is only for long-running external callouts. Option B (without sharing) might affect visibility but isn't a requirement for the wire service itself. Option D (OWD) affects whether records are visible based on security, but the technical failure described is rooted in the component-to-Apex binding requirement. Once marked as cacheable, the LDS can properly manage the data lifecycle for the component.

In Aura components, the <aura:if> tag is "lazy." It does not instantiate or render the components within its body until its isTrue expression evaluates to true. In the provided code, showContactInfo is defaulted to true. This means that when the parent component begins its initialization, it immediately starts creating and rendering the child component simultaneously.

By changing the default for showContactInfo to "false" (Option C), the developer implements a "Lazy Loading" pattern. The parent component will load quickly because it skips the heavy lifting required to render the child. The init handler then runs, retrieves the necessary data, and sets the boolean to true only when the data is ready. This improves the "perceived performance" and the Initial Page Load time.

Option A is incorrect because it increases the complexity and weight of the parent component, likely making it slower. Option B (changing to a Map) does not fundamentally affect the rendering engine's speed. Starting with the display attribute as false ensures the browser only renders what is absolutely necessary during the critical first few milliseconds of the page load.

Comprehensive and Detailed Explanation:

To programmatically identify custom objects in Apex, developers utilize Schema Describe information. The Schema.getGlobalDescribe() method returns a map of all object tokens in the org. By iterating through these tokens and calling the getDescribe() method on each, the developer can access various properties of the object's metadata.

The specific property to distinguish between standard and custom objects is the isCustom() method (Option C). This boolean method returns true if the object is a custom object (including custom settings and custom metadata types) and false if it is a standard platform object.

Option A is incorrect because @salesforce/schema is used in LWC to import references to specific known objects/fields, not to discover the entire org's metadata dynamically. Option B is incorrect as getObjectType() returns an SObjectType token, not a string value like 'Custom'. Option D is incorrect because there is no getCustomObjects() method in the standard Schema class; discovery must be done via the global describe map.

123

To properly test a Visualforce Controller Extension in Apex, the developer must replicate the instantiation process used by the Lightning Platform at runtime. A4 controller extension is a class whose constructor is specifically defined to accept a single parameter of the type ApexPages.StandardController. 5The standard controller acts as the bridge b6etween the custom extension logic and the underlying Salesforce record (in this case, an Account).

In the provided test method, a record acet has been inserted into the database. To create the extension object, the developer must first instantiate the StandardController by passing the acet SObject record into its constructor. Once the standard controller instance (e.g., sc) is created, it is then passed into the constructor of the AccountControllerExt class. Option B is the correct implementation of this two-step pattern. Option C is incorrect because the StandardController constructor requires a full SObject record, not just an ID string. Options A and D are incorrect because extension classes do not support constructors that take an SObject or an ID directly; they specifically require the StandardController object to provide the necessary context for standard actions and fields. Following the correct pattern ensures the test accurately simulates the page execution context.

==========

38

In Salesforce, all triggers that fire as a result of an initial DML operation ru39n within the same execution context and the same transaction. This means that all governor limits—such as the limit of 10,000 records processed by DML statements—are shared across the entire chain of events.

In this scenario, the transaction begins with the update of 200 Accounts. The Account trigger then attempts to update 10,000 related Contacts (50 Contacts per Account across 200 Accounts). This update of 10,000 Contacts then fires the Contact trigger, which attempts to update 10,000 related Campaign Members. When the system attempts to process these updates, the total number of records processed via DML in a single transaction will exceed the platform limit of 10,000 rows.

Even though the Account update is only 200 records, the subsequent cascading updates (10,000 Contacts + 10,000 Campaign Members) bring the total DML count to 20,200. This triggers a LimitException, and because Apex transactions are atomic, the entire operation will fail and roll back. To resolve this, the developer would need to handle these updates asynchronously (e.g., using Batch Apex or Queueable) to split the cascading updates into separate transactions with their own sets of governor limits.

==========

The issue described involves hitting DML limits due to a high volume of records (over 10,000) being processed in a single transaction. In Salesforce, a single synchronous transaction or a standard Scheduled Apex job has strict governor limits on the number of DML statements (150) and the total number of records processed (10,000 for DML rows).

To resolve this, the developer should implement the Database.Batchable interface. Batch Apex is specifically designed to handle large data volumes by breaking the processing into smaller, manageable chunks (batches) of records (default 200). Each batch runs within its own transaction context, resetting the governor limits for that specific batch. This prevents the "Too many DML rows" exception. While Queueable (Option D) and @future (Option C) provide asynchronous processing, they are not inherently designed to iterate over large datasets in the same robust, governor-limit-safe manner as Batch Apex, particularly when the record count exceeds the thousands.

Every Apex test execution is treated as a temporary transaction. One of the most critical aspects of this execution is that any changes made to the database—including the insertion, modification, or deletion of records—are automatically rolled back at the end of the test run. This mechanism ensures that unit tests do not leave behind "garbage" data or alter the state of the organization's actual business data, maintaining a consistent environment for development and production.1234

In this specific scenario, the @isTest(SeeAllData=true) annotation is used, which allows the test method to view existing data in the organization. Bec5ause the org already contains five accounts starting with "Test," the test method sees them. When the test code inserts a new 6account named "Test1," the count within that specific transaction becomes six. The subsequent code queries for these six accounts an7d del8etes them. While the test is running, the deletion is successful, which is why the assertion checking for zero accounts passes.

However, once the test finishes, the entire transaction is rolled back. The rollback effectively "undoes" the deletion of the original five accounts and the creation of the one new account. Consequently, the organization returns to its exact state from before the test was initiated. The five original accounts remain in the database as if the test never occurred, making option A the correct answer.

The requirement involves enforcing a business rule across two different objects (Contact and Survey_Response__c) and through different entry points: standard UI/Triggers for Contacts and a custom Visualforce page for Survey Responses. Implementing the logic separately in a trigger and a controller (Option C) is a poor architectural choice because it duplicates code, leading to increased maintenance effort and a higher risk of inconsistency if the logic needs to change in the future. Validation rules (Option A) are also unsuitable here because they cannot natively perform a dynamic lookup against a list of records in a separate "Blocked Domains" object without complex and unscalable workarounds.

The optimal approach is to centralize the validation logic within a single "Helper" or "Service" class. This follows the DRY (Don't Repeat Yourself) principle of software development. By creating a shared method in a helper class, the developer can ensure that both the Contact trigger and the Visualforce controller use the exact same logic to verify email domains. This centralized method queries the custom object containing the blocked domains and returns a validation result. This architecture simplifies testing, ensures uniform enforcement of business rules across the entire platform, and allows administrators to update the blocked domains list without requiring any further code modifications.

==========

This is a classic case of trigger recursion caused by the Salesforce Order of Execution. When an Account is updated to "Customer," the following occurs:

The original "Before" and "After" triggers run. The After trigger creates the first Account Plan.

The Record-Triggered Flow executes and updates the "Customer Since" date field.

Because a Flow (or Workflow) performed a field update, Salesforce re-triggers the Apex triggers on the Account object to ensure any logic dependent on that new date field is executed.

During this second pass, the After trigger runs again and, seeing the status is still "Customer," creates a second Account Plan.

To prevent this, developers use a static variable (Option D) in a handler class to act as a "recursion guard." Static variables persist for the duration of the entire transaction. By checking this variable at the start of the trigger, the code can detect that it has already run once and skip the record creation on the second pass. Option B and C describe standard Flow behavior but are not the "fix" for the trigger logic. Option A would cause issues with limits but wouldn't necessarily cause a double-fire unless recursion was involved.