PDII Exam Dumps - Salesforce Certified Platform Developer II ( Plat-Dev-301 )

In Lightning Web Components (LWC), components communicate up the containment hierarchy (from child to parent) by creating and dispatching Custom Events.

Unlike the older Aura framework, which used specific "Component" or "Application" event types (Options B and C), LWC relies on standard web browser event protocols. The child component (c-order) would instantiate a CustomEvent object, optionally including a data payload in the detail property (such as the orderId), and then call the this.dispatchEvent() method.

The parent component (c-selected-order) then listens for this event using an on prefix (e.g., onselection={handleSelection}) in its HTML template. While you could technically use a standard DOM event (Option D), the CustomEvent interface is the platform-standard best practice in LWC for passing custom data payloads between components. Custom events allow for clean encapsulation and follow the modern "Events Up, Properties Down" design pattern common in reactive frameworks like LWC, React, and Vue.

In Visualforce, the "View State" is a hidden form field that maintains the state of the page (and the controller's variables) across postbacks to the server. If the View State becomes too large, it can slow down page loads and eventually hit the Salesforce View State limit (170KB), causing the page to crash.

The transient keyword is used to declare instance variables in Apex controllers that should not be saved in the View State. When a variable is marked as transient, its value is discarded after the request finishes and is not transmitted back to the client. This effectively reduces the size of the View State. It is commonly used for data that is needed only for the duration of the current request (like a large list of records displayed in a read-only table) and can be easily requeried or recalculated if needed.

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.

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.

==========

Salesforce enforces a strict restriction: Actual network callouts are prohibited during unit tests. This is to ensure that tests are deterministic, fast, and do not rely on the availability or state of external third-party systems. When the testing engine encounters a System.Http.send() or a web service call without a mock, it throws the error: "Methods defined as TestMethod do no1t support Web servi2ce callouts."34

To resolve this, the developer must provide a Mock Implementation. By using Test.setMock() (Option D), the developer instructs the Apex runtime to intercept any callouts and return a pre-defined response instead of attempting a real connection. The mock class5 must implement either the HttpCalloutMock interface (for REST) or the WebServiceMock interface (for SOAP).

Furthermore, the call to the mock and the callout method should be wrapped in Test.startTest() and Test.stopTest().6

Test.startTest(): Resets governor limits, providing a fresh context for the specific logic being tested.7

Test.stopTest(): Forces any asynchronous processing (often used in cal8louts, such as @future or Queueable) to complete before the next line of code executes.

In the provided code, Test.setMock must be called before CalloutUtil.sendAccountUpdate for the platform to know which mock to use. Once Test.stopTest() is reached, the mock response is processed, the checkbox is updated, and the subsequent SOQL query and assertion will correctly see the updated data. Option A is a poor practice because it skips the logic entirely, resulting in 0% code coverage for the integration logic.

28

When dealing with External Users (Community/Experience Cloud users), standard sharing mechanisms like Role Hierarchies o29ften do not apply, especially for high-volume Customer Community licenses which do not use the Role Hierarchy at all.

Sharing Sets (Option B) are specifically designed to grant external users access to records associated with their Account or Contact. A Sharing Set allows an administrator to define a simple mapping: for example, "Grant access to Cases where the Case's Account matches the User's Account." This is the most efficient and scalable way to provide external partners visibility into records relevant to them without using complex Apex code.

While Apex managed sharing (Option A) could technically work, it is much more complex to maintain and is only available for "Customer Community Plus" or "Partner" licenses. Criteria-based sharing rules (Option D) are typically used for internal users or broad groups, not for granular, account-specific access for individual external partners. Sharing Sets provide a high-performance, declarative solution for controlling external record visibility.

Comprehensive and Detailed 150 to 25110 words of Explana12tion:

The Salesforce Lightning Inspector is a Chrome DevTools extension used to investigate and optimize Lightning components. When a page fails to show the most current reference data, the issue often lies within the client-side caching mechanism. The Storage tab (A) is specifically designed to help developers inspect the client-side data stores used by the Lightning Data Service (LDS) and custom component caching.

In this tab, a developer can view the contents of the various storage caches (such as actions, records, and lists). It allows the developer to see exactly what data is currently stored in the cache, its expiration time, and whether the data is being retrieved from the server or served directly from the cache. By analyzing the Storage tab, a developer can determine if a component is incorrectly holding onto "stale" data instead of refreshing from the server.

The Actions tab (C) is useful for monitoring the status of server-side controller actions, and the Event Log (B) tracks the sequence of application and component events. However, for a data consistency issue specifically related to caching, the Storage tab provides the most direct visibility into the underlying cause. Using this tool, a developer can verify if the cache invalidation logic is working correctly or if the storage limits are causing unexpected data eviction.

==========

To create a responsive design in Salesforce Aura components, the lightning:layout and lightning:layoutItem components utilize a 12-column grid system based on the Salesforce Lightning Design System (SLDS). The issue in the original code is that size="6" is hardcoded, which forces each item to occupy 50% of the container width regardless of the screen size. On small mobile screens, 50% width is often insufficient for text content, leading to horizontal scrolling or overlapping.

Option B resolves this by using device-specific size attributes. By setting smallDeviceSize="12", each item is instructed to take up the full width (12 out of 12 columns) on mobile devices. This causes the items to stack vertically instead of sitting side-by-side. The mediumDeviceSize="6" and largeDeviceSize="6" attributes ensure that on tablets and desktop screens, the items return to a side-by-side layout (50% width each).

For this stacking to occur, the parent lightning:layout must have the multipleRows="true" attribute enabled. This allows the layout to wrap items to a new line once the total column count in a single row exceeds 12. Without multipleRows="true", the items would try to squeeze into a single line regardless of their individual size settings, which would not solve the horizontal scrolling problem. Option B is the only choice that correctly applies the grid logic to handle multiple breakpoints effectively.