[Salesforce] PDII - Certified Platform Developer II ​ Exam Dumps & Study Guide

Free [Salesforce] PDII - Certified Platform Developer II ​ Practice Questions Preview

• Question 1

  A Visualforce page loads slowly due to the large amount of data it displays.
  Which strategy can a developer use to improve the performance?
  

  • A. Use Javascript to move data processing to the browser instead of the controller.
  • B. Use the transient keywords for the List variables used in the custom controller.
  • C. Use lazy loading to load the data on demand, instead of the controller's constructor.
  • D. Use an <apex:actionPoller> in the page to load all of the data asynchronously.

  Correct Answer: C

  Explanation:

  The AI agrees with the suggested answer, C (Use lazy loading to load the data on demand, instead of the controller's constructor.).
  Reasoning: Lazy loading is a performance optimization technique that defers the initialization of an object until the point at which it is needed. In the context of a Visualforce page, this means that data is only loaded when it is actually required for display. This approach can significantly reduce the initial page load time, especially when dealing with large datasets. By loading data on demand instead of in the controller's constructor, you avoid unnecessary processing and data transfer if the user doesn't actually need to see all the data immediately. This aligns with best practices for improving Visualforce page performance.
  Why other options are not optimal:

  • A: While using JavaScript for client-side processing can improve performance in some cases, it's generally not the best approach for handling large amounts of data initially loaded. Moving data processing to the browser might introduce complexity and potential security concerns if not implemented carefully.
  • B: The `transient` keyword prevents a variable from being saved as part of the view state. While this can reduce view state size and improve performance, it means the variable's value won't be persisted across page requests, requiring it to be recomputed or re-fetched each time. This might not be suitable if the data is needed across multiple interactions, and it doesn't directly address the issue of initial data loading time.
  • D: The `` component is used to periodically send AJAX requests to the server. While it can be used for asynchronous data loading, it's not the most efficient way to load large amounts of data. Polling can introduce unnecessary server load and network traffic if the data doesn't change frequently. Additionally, using it to load *all* data asynchronously might result in a poor user experience as the page content gradually appears.

• Question 2

  Universal Containers wants to use a Customer Community with Customer Community Plus licenses so their customers can track how many containers they are renting and when they are due back. Many of their customers are global companies with complex Account hierarchies, representing various departments within the same organization. One of the requirements is that certain community users within the same Account hierarchy be able to see several departments' containers, based on a junction object that relates the Contact to the various Account records that represent the departments.
  Which solution solves these requirements?
  

  • A. A Visualforce page that uses a Custom Controller that specifies without sharing to expose the records
  • B. A Custom List View on the junction object with filters that will show the proper records based on owner
  • C. A Custom Report Type and a report Lightning Component on the Community Home Page
  • D. An Apex Trigger that creates Apex Managed Sharing records based on the junction object's relationships

  Correct Answer: D

  Explanation:

  The AI agrees with the suggested answer D.
  Reasoning: The scenario requires granting community users access to records across Account hierarchies based on a junction object's relationships. Standard sharing mechanisms may not suffice for this complex requirement. Apex Managed Sharing allows programmatic control over record access, making it suitable for dynamically sharing records based on the junction object's relationships.
  Option D, using an Apex Trigger to create Apex Managed Sharing records, directly addresses the requirement of sharing records based on the junction object's relationships. This ensures that community users can see containers from different departments within the same Account hierarchy as specified.
  Reasons for not choosing the other options:
  

  • A: Visualforce page with `without sharing`: This option exposes all data without any security, which is generally not recommended for security reasons. It bypasses the organization-wide defaults, role hierarchies, sharing rules, and manual sharing. This could lead to unintended data exposure.
  • B: Custom List View: List views are subject to the user's existing permissions and sharing settings. They cannot grant access beyond what the user already has. Therefore, a list view cannot solve the problem of sharing records across Account hierarchies.
  • C: Custom Report Type and report: Reports also respect existing sharing settings. They cannot grant users access to records they do not already have permission to see. While a report can display the data, it does not solve the underlying sharing issue.

  • Sharing Architecture, https://developer.salesforce.com/docs/atlas.en-us.securityImplGuide.meta/securityImplGuide/security_sharing_architecture.htm
  • Apex Managed Sharing, https://developer.salesforce.com/docs/atlas.en-us.apexcode.meta/apexcode/apex_bulk_sharing_creating.htm

• Question 3

  Universal Containers wants to use an external Web Service provided by a third-party vendor to validate that shipping and billing addresses are correct. The current vendor uses basic password authentication, but Universal Containers might switch to a different vendor who uses OAuth.
  What would allow Universal Containers to switch vendors without updating the code to handle authentication?
  

  • A. Custom Metadata
  • B. Custom Setting (List)
  • C. Dynamic Endpoint
  • D. Named Credential

  Correct Answer: D

  Explanation:

  The suggested answer is correct. The recommended answer is D: Named Credential.
  Reasoning: Named Credentials are the best choice because they abstract the authentication details away from the Apex code. This allows Universal Containers to switch vendors, and thus authentication methods (from basic password to OAuth), without modifying the code that calls the web service. The Named Credential handles the authentication behind the scenes.
  Why other options are not suitable:

  • A. Custom Metadata: Custom Metadata is used to store configuration data, not authentication information. It would not facilitate switching authentication methods.
  • B. Custom Setting (List): Custom Settings, particularly List Custom Settings, are also for storing configuration data, but they do not provide the necessary abstraction for handling different authentication schemes.
  • C. Dynamic Endpoint: While Dynamic Endpoints allow you to change the URL of the web service, they do not handle authentication. The authentication mechanism would still need to be managed in the Apex code.

  Therefore, Named Credentials are the correct approach for decoupling the authentication process from the code and enabling easy switching between vendors with different authentication methods.

  Cititations:

  • Salesforce Named Credentials, https://help.salesforce.com/s/articleView?id=sf.security_named_credentials.htm&type=5

• Question 4

  A company has a Lightning Page with many Lightning Components, some that cache reference data. It is reported that the page does not always show the most current reference data.
  What can a developer use to analyze and diagnose the problem in the Lightning Page?
  

  • A. Salesforce Lightning Inspector Actions Tab
  • B. Salesforce Lightning Inspector Event Log Tab
  • C. Salesforce Lightning Inspector Transactions Tab
  • D. Salesforce Lightning Inspector Storage Tab

  Correct Answer: D

  Explanation:

  The AI agrees with the suggested answer.
  The correct answer is D (Salesforce Lightning Inspector Storage Tab).
  Reasoning: The problem is related to cached reference data not being current. The Salesforce Lightning Inspector's Storage tab is the appropriate tool to analyze and diagnose issues related to client-side storage, including cached data in Lightning components. This tab allows developers to inspect the data stored, identify outdated or incorrect data, and understand how the caching mechanism is functioning. The discussion summary also supports this by mentioning that the Storage tab can be used to see which actions are cached and the size of each cached action, allowing for analysis of storage in the Salesforce mobile app and Lightning Experience.
  Reasons for not choosing the other options:
  

  • A. Salesforce Lightning Inspector Actions Tab: This tab is useful for inspecting the actions that are fired, their parameters, and their responses, but it does not provide detailed information about cached data.
  • B. Salesforce Lightning Inspector Event Log Tab: This tab is helpful for debugging event-related issues, but it does not provide information about cached data.
  • C. Salesforce Lightning Inspector Transactions Tab: This tab is helpful for viewing server requests and responses, but does not directly address client-side caching problems.

  • Citations:
  • Salesforce Lightning Inspector, https://developer.salesforce.com/docs/component-library/documentation/en/lwc/lwc.debugging

• Question 5

  A company has code to update a Request and Request Lines and make a callout to their external ERP system's REST endpoint with the updated records.
  
  The CalloutUtil.makeRestCallout fails with a 'You have uncommitted work pending. Please commit or rollback before calling out' error.
  What should be done to address the problem?
  

  • A. Remove the Database.setSavepoint and Database.rollback.
  • B. Change the CalloutUtil.makeRestCallout to an @InvocableMethod method.
  • C. Change the CalloutUtil.makeRestCallout to an @future method.
  • D. Move the CalloutUtil.makeRestCallout method call below the catch block.

  Correct Answer: C

  Explanation:

  The suggested answer is C.
  Reasoning: The error 'You have uncommitted work pending. Please commit or rollback before calling out' indicates that a callout is being made within the same transaction as DML operations (updates to Request and Request Lines). Salesforce does not allow callouts to be made in the same transaction as DML operations unless the callout is asynchronous. Option C, changing the CalloutUtil.makeRestCallout to an @future method, makes the callout asynchronous, resolving the issue. @future methods run in a separate context, allowing the pending DML operations to commit before the callout is made.
  Why other options are incorrect:
  

  • A. Removing the Database.setSavepoint and Database.rollback would not solve the problem. These are used for transaction control, but the core issue is the synchronous callout after DML.
  • B. Changing the CalloutUtil.makeRestCallout to an @InvocableMethod would not solve the problem directly. @InvocableMethod is typically used for making Apex methods callable from process builder or flow. The synchronous nature of the callout within the same transaction would still cause the error.
  • D. Moving the CalloutUtil.makeRestCallout method call below the catch block may avoid the exception in some scenarios but doesn't address the core problem of performing a callout in the same transaction as DML. Also, the catch block is only executed if an exception occurs, meaning the callout would still happen synchronously if no exception occurs.

  The explanation provided in the discussion summary is also correct, emphasizing the asynchronous nature of @future methods and their ability to resolve the uncommitted work error. The necessity of passing IDs and querying within the @future method ensures data consistency by working with committed data.

• Question 6

  A Visualforce page contains an industry select list and displays a table of Accounts that have a matching value in their Industry field.
  <apex:selectList value="{!selectedIndustry}">
  <apex:selectOptions values="{!industries}"/>
  </apex:selectList>
  When a user changes the value in the industry select list, the table of Accounts should be automatically updated to show the Accounts associated with the selected industry.
  What is the optimal way to implement this?
  

  • A. Add an <apex:actionFunction> within the <apex:selectOptions>.
  • B. Add an <apex:actionFunction> within the <apex:selectList>.
  • C. Add an <apex:actionSupport> within the <apex:selectList>.
  • D. Add an <apex:actionSupport> within the <apex:selectOptions>.

  Correct Answer: B

  Explanation:

  The AI assistant suggests that the correct answer is C. Add an <apex:actionSupport> within the <apex:selectList>.
  
  Reasoning:
  The requirement is to automatically update the table of Accounts when the user changes the value in the industry select list. This means we need to trigger an action when the selected value changes. <apex:actionSupport> is the appropriate component for this scenario because it allows us to trigger a server-side action based on a client-side event on a Visualforce component.
  
  Here's a breakdown:

  • <apex:actionSupport>: This component is designed to add AJAX support to existing Visualforce components. It allows you to define an event (like onchange for a selectList) that triggers an action.
  • <apex:selectList>: This is the component that displays the industry select list.

  By placing <apex:actionSupport> inside the <apex:selectList> and specifying the 'onchange' event, we can trigger a server-side action (a method in the controller) that updates the Account table whenever the selected industry changes. The 'rerender' attribute of <apex:actionSupport> can then be used to update the Account table on the page.
  Reasons for not choosing the other options:

  • A: Add an <apex:actionFunction> within the <apex:selectOptions>.: <apex:actionFunction> is used to expose controller methods to JavaScript. It doesn't directly respond to UI events on a Visualforce component. Placing it inside <apex:selectOptions> doesn't make sense as selectOptions are just the list of options; the event needs to be tied to the selectList itself.
  • B: Add an <apex:actionFunction> within the <apex:selectList>.: While placing <apex:actionFunction> within <apex:selectList> is syntactically valid, it still doesn't directly handle the onchange event. <apex:actionFunction> requires a JavaScript call to invoke it, so it doesn't provide the automatic update needed in this scenario. We need a component which directly support to call apex method after some action in VF component.
  • D: Add an <apex:actionSupport> within the <apex:selectOptions>.: <apex:actionSupport> needs to be within the component that triggers the event (the selectList), not the individual options. The selectOptions themselves don't trigger the change event; the selectList does.

  Citations:

  • apex:actionSupport, https://developer.salesforce.com/docs/atlas.en-us.pages.meta/pages/pages_compref_actionSupport.htm
  • apex:actionFunction, https://developer.salesforce.com/docs/atlas.en-us.pages.meta/pages/pages_compref_actionFunction.htm

• Question 7

  
  The test method above calls a web service that updates an external system with Account information and sets the Account's Integration_Updated__c checkbox to
  True when it completes. The test fails to execute and exits with an error: "Methods defined as TestMethod do not support Web service callouts. "
  What is the optimal way to fix this?
  

  • A. Add Test.startTest() before and Test.setMock and Test.stopTest() after CalloutUtil.sendAccountUpdate.
  • B. Add Test.startTest() and Test.setMock before and Test.stopTest() after CalloutUtil.sendAccountUpdate.
  • C. Add if (!Test.isRunningTest()) around CalloutUtil.sendAccountUpdate.
  • D. Add Test.startTest() before and Test.stopTest() after CalloutUtil.sendAccountUpdate.

  Correct Answer: B

  Explanation:

  The AI agrees with the suggested answer, which is B.
  
  The optimal way to fix the "Methods defined as TestMethod do not support Web service callouts" error is to use Test.setMock to mock the web service callout. This involves adding Test.startTest() and Test.setMock before the CalloutUtil.sendAccountUpdate method and Test.stopTest() after it.
  
  Here's a breakdown of why this approach works and why the others are less suitable:
  

  • Test.startTest() and Test.stopTest(): These methods are crucial for isolating the section of code you are testing. Test.startTest() resets governor limits, and Test.stopTest() executes any asynchronous code.
  • Test.setMock(): This is the key to resolving the error. It allows you to replace the actual web service call with a mock implementation. This prevents the test from attempting a real callout, which is prohibited in test methods unless you use a Mock.

  Reasoning for Choosing Answer B:
  

  • Using Test.setMock is essential to avoid the actual web service callout during testing.
  • Test.startTest() and Test.stopTest() ensure proper isolation and execution of asynchronous processes triggered by the callout.

  Reasoning for Not Choosing Other Answers:
  

  • A: Adding Test.setMock after CalloutUtil.sendAccountUpdate would be incorrect. The mock needs to be in place before the callout is executed.
  • C: Adding if (!Test.isRunningTest()) around CalloutUtil.sendAccountUpdate would prevent the callout from ever happening in a test context, which defeats the purpose of testing the callout logic. While it would prevent the error, it doesn't allow testing of the callout functionality.
  • D: Missing Test.setMock, so it is still making callout, and the error is still happening.

• Question 8

  A developer created and tested a Visualforce page in their developer sandbox, but now receives reports that users are encountering ViewState errors when using it in Production.
  What should the developer ensure to correct these errors?
  

  • A. Ensure queries do not exceed governor limits.
  • B. Ensure properties are marked as Transient.
  • C. Ensure properties are marked as private.
  • D. Ensure profiles have access to the Visualforce page.

  Correct Answer: B

  Explanation:

  The AI agrees with the suggested answer, which is B. Ensure properties are marked as Transient.
  
  Reasoning:
  ViewState errors in Visualforce pages often occur when the amount of data being stored in the ViewState exceeds the allowed limit. Marking properties as 'transient' prevents them from being persisted in the ViewState. This can significantly reduce the ViewState size and resolve related errors.
  
  Here's a more detailed breakdown:

  • Option A: Ensure queries do not exceed governor limits. While exceeding governor limits can cause errors, it doesn't directly relate to ViewState errors. Governor limits typically throw different types of exceptions.
  • Option B: Ensure properties are marked as Transient. This is the correct answer. The 'transient' keyword prevents a variable from being serialized as part of the ViewState. This is useful for data that doesn't need to be persisted between requests, such as calculations or temporary data. By marking appropriate properties as transient, the ViewState size can be reduced, preventing ViewState errors. Refer to the Salesforce documentation for details on using transient variables with ViewState.
  • Option C: Ensure properties are marked as private. Making properties private controls access to the properties but doesn't affect the ViewState size. Private properties can still contribute to ViewState if they hold data.
  • Option D: Ensure profiles have access to the Visualforce page. Access issues would typically manifest as a different error (e.g., insufficient privileges), not a ViewState error. If users are encountering ViewState errors, it implies they can access the page itself.

  Therefore, Option B is the most appropriate solution to address ViewState errors in a Visualforce page.

  • Salesforce View State, https://developer.salesforce.com/docs/atlas.en-us.pages.meta/pages/pages_working_with_view_state.htm

• Question 9

  <lightning:layout multipleRows="true">
  <lightning:layoutItem size="12">{!v.account.Name}
  </lightning:layoutItem>
  <lightning:layoutItem size="12">{!v.account.AccountNumber}
  </lightning:layoutItem>
  <lightning:layoutItem size="12">{!v.account.Industry}
  </lightning:layoutItem>
  </lightning:layout>
  Refer to the component code above. The information displays as expected (in three rows) on a mobile device. However, the information is not displaying as desired (in a single row) on a desktop or tablet.
  Which option has the correct component changes to display correctly on desktops and tablets?
  

  • A. <lightning:layout multipleRows="true"> <lightning:layoutItem size="12" mediumDeviceSize="6" largeDeviceSize="4">{!v.account.Name} </lightning:layoutItem> <lightning:layoutItem size="12" mediumDeviceSize="6" largeDeviceSize="4">{!v.account.AccountNumber} </lightning:layoutItem> <lightning:layoutItem size="12" mediumDeviceSize="6" largeDeviceSize="4">{!v.account.Industry} </lightning:layoutItem> </lightning:layout>
  • B. <lightning:layout multipleRows="true"> <lightning:layoutItem size="12" largeDeviceSize="4">{!v.account.Name} </lightning:layoutItem> <lightning:layoutItem size="12" largeDeviceSize="4">{!v.account.AccountNumber} </lightning:layoutItem> <lightning:layoutItem size="12" largeDeviceSize="4">{!v.account.Industry} </lightning:layoutItem> </lightning:layout>
  • C. <lightning:layout multipleRows="true"> <lightning:layoutItem size="12" mediumDeviceSize="4">{!v.account.Name} </lightning:layoutItem> <lightning:layoutItem size="12" mediumDeviceSize="4">{!v.account.AccountNumber} </lightning:layoutItem> <lightning:layoutItem size="12" mediumDeviceSize="4">{!v.account.Industry} </lightning:layoutItem> </lightning:layout>
  • D. <lightning:layout multipleRows="true"> <lightning:layoutItem size="12" mediumDeviceSize="6">{!v.account.Name} </lightning:layoutItem> <lightning:layoutItem size="12" mediumDeviceSize="6">{!v.account.AccountNumber} </lightning:layoutItem> <lightning:layoutItem size="12" mediumDeviceSize="6">{!v.account.Industry} </lightning:layoutItem> </lightning:layout>

  Correct Answer: C

  Explanation:

  The AI agrees with the suggested answer C.
  Reasoning:
  The question requires the component to display in three rows on mobile devices but in a single row on desktops and tablets. The key to solving this is understanding how `lightning:layout` and `lightning:layoutItem` components work with different device sizes.
  On mobile devices, the default `size="12"` ensures each `lightning:layoutItem` occupies the full width (12 out of 12 columns), resulting in each item being displayed on a new row.
  To display the items in a single row on desktops and tablets, we need to adjust the `lightning:layoutItem` sizes for medium (tablets) and large (desktops) devices using `mediumDeviceSize` and `largeDeviceSize` attributes. Since we want three items in a single row, each item should occupy 4 out of 12 columns.
  Option C correctly uses `mediumDeviceSize="4"`. This makes each of the three items take up 4 columns on medium and large devices, fitting all three in a single row.
  Why other options are incorrect:

  • A. Using `mediumDeviceSize="6"` and `largeDeviceSize="4"` is inconsistent. It would display two items per row on medium devices and three items per row on large devices, which isn't the desired behavior.
  • B. Using only `largeDeviceSize="4"` would only affect large devices (desktops), while medium devices (tablets) would still display one item per row, as the default size is 12.
  • D. Using `mediumDeviceSize="6"` would display two items per row on medium devices, not the desired single row with three items.

  In summary, option C is the only option that correctly sets the `mediumDeviceSize` to 4, ensuring that the items are displayed in a single row on both tablets and desktops while maintaining the desired layout on mobile devices.

  
  

  Citations:

  • lightning:layout, https://developer.salesforce.com/docs/component-library/bundle/lightning:layout/documentation
  • lightning:layoutItem, https://developer.salesforce.com/docs/component-library/bundle/lightning:layoutItem/documentation

• Question 10

  A company's support process dictates that any time a Case is closed with a Status of 'Could not fix', an Engineering Review custom object record should be created and populated with information from the Case, the Contact, and any of the Products associated with the Case.
  What is the correct way to automate this using an Apex trigger?
  

  • A. An after update trigger that creates the Engineering Review record and inserts it
  • B. A before update trigger that creates the Engineering Review record and inserts it
  • C. An after upsert trigger that creates the Engineering Review record and inserts it
  • D. A before upsert trigger that creates the Engineering Review record and inserts it

  Correct Answer: A

  Explanation:

  The AI agrees with the suggested answer, which is option A: An after update trigger that creates the Engineering Review record and inserts it.
  
  Reasoning:
  The requirement is to create an 'Engineering Review' record when a Case is closed with a Status of 'Could not fix'. This needs to happen after the Case record has been updated with the 'Could not fix' status. Therefore, an 'after update' trigger is the most suitable choice. This ensures that the trigger logic executes only after the Case record has been successfully updated in the database. Also, using an 'after' trigger allows access to the final values of the Case fields, which is necessary to determine if the status is 'Could not fix' and to populate the 'Engineering Review' record with the correct information.
  
  Why other options are not appropriate:
  

  • B: A before update trigger that creates the Engineering Review record and inserts it: A 'before update' trigger is executed before the Case record is saved to the database. At this point, the status might not yet be 'Could not fix', so the trigger might execute prematurely or not at all. Moreover, performing a DML operation (inserting a new record) in a before trigger is generally discouraged due to potential governor limit issues and transaction management complexities.
  • C: An after upsert trigger that creates the Engineering Review record and inserts it: An 'after upsert' trigger is fired both when a record is inserted and when it's updated. While it would work for the update scenario, it's not ideal because the requirement is specifically for when a Case is *closed* with a specific status, which implies an update to an existing record. The upsert trigger would also run when a case is initially created, which isn't what the requirement specifies.
  • D: A before upsert trigger that creates the Engineering Review record and inserts it: Similar to option B, a 'before upsert' trigger runs before the record is saved. It suffers from the same problems of potentially running before the status is 'Could not fix' and the issues related to performing DML operations in a before trigger. Also, like option C, it runs on both insert and update.

  Therefore, using an 'after update' trigger (Option A) ensures the logic is executed only when a Case is updated, specifically after it has been updated with the 'Could not fix' status, making it the most appropriate choice.

  • Salesforce Apex Triggers, https://developer.salesforce.com/docs/atlas.en-us.apexcode.meta/apexcode/apex_triggers.htm