CRT-450 Salesforce Certified Platform Developer I (SU24) Questions and Answers

When using Salesforce DX, developers need to enable the Dev Hub in their org to create and manage scratch orgs.

Option A: Dev Hub

Correct Answer.

Explanation:

The Dev Hub is a feature that must be enabled in a Salesforce org (usually in a Developer Edition or a production org).

It allows developers to create and manage scratch orgs using Salesforce DX commands.

Dev Hub is the central point for creating and managing your scratch orgs.

To integrate Order__c records with the ERP system after their status is set to 'Placed', and considering that orders may be uploaded in bulk, the developer should:

Option D: Callout from a Queueable class called from a trigger

Explanation:

Trigger: Implement an after-update trigger on Order__c to detect when the status changes to 'Placed'.

Queueable Apex: Use Queueable Apex to handle asynchronous processing and callouts. Queueable classes support callouts by implementing the Database.AllowsCallouts interface.

Benefits:

Handles Bulk Data: Queueable Apex can process records in batches and can be chained for processing large volumes.

Supports Callouts: Unlike future methods, Queueable Apex allows for more complex data types and supports callouts with fewer limitations.

The first step in the Salesforce order of execution:

Option D: The original record is loaded from the database.

This is Step 1 in the order of execution.

Why Not Other Options:

Option A: Overwriting old values happens after loading the record.

Option B: JavaScript validation occurs on the client side before server processing.

Option C: System validation for field lengths happens after loading the record.

References:

Order of Execution:

"1. Loads the original record from the database or initializes the record for an upsert statement."— Apex Developer Guide: Triggers and Order of Execution

Option B: Use an Assignment Flow element.

Correct Answer.

Explanation:

Using a record-triggered flow, you can automatically assign new cases based on the case origin.

Flows provide flexibility to set field values, assign records, and automate complex logic without code.

To ensure that only records accessible to the currently logged-in user are displayed when developing an Apex class for custom search functionality launched from a Lightning Web Component (LWC), the developer should use the with sharing keyword.

with sharing Keyword: This keyword enforces the sharing rules of the current user, ensuring that the Apex class respects the user's record-level access permissions. When an Apex class is declared with with sharing, it enforces sharing rules, meaning users can only access records they have permission to see.

"Use the with sharing keyword when declaring a class to enforce the sharing rules that apply to the current user."— Apex Developer Guide: Using the with sharing or without sharing Keywords

Importance in LWCs: Lightning Web Components invoke Apex methods annotated with @AuraEnabled, which execute in system context by default. Without specifying sharing, these methods can access all records, potentially exposing data that the user shouldn't see.

"By default, Apex code runs in system context; that is, the current user's permissions and field-level security do not apply."— Apex Developer Guide: Enforcing Sharing Rules

Why Not inherited sharing: While inherited sharing allows an Apex class to run in the sharing context of the caller, in this scenario, since the LWC does not have an inherent sharing context, using with sharing explicitly ensures sharing rules are enforced.

WITH SECURITY_ENFORCED Clause: This SOQL clause enforces field-level security (FLS) and object-level security (OLS), not record-level sharing rules. Therefore, it does not restrict records based on the user's sharing settings.

"The WITH SECURITY_ENFORCED clause applies object-level and field-level security checks to SOQL queries to ensure that users don't see fields or objects they don't have access to."— SOQL and SOSL Reference: WITH SECURITY_ENFORCED Clause

Conclusion: By declaring the Apex class with with sharing, the developer ensures that only records the user has access to are returned, aligning with the requirement.

In the provided class:

public class myClass {

public void myMethod() { /* implementation */ }

}

The class myClass is declared without any sharing keyword (with sharing, without sharing, or inherited sharing).

Default Sharing Behavior:

Apex classes without an explicit sharing declaration run in system context, meaning they do not enforce sharing rules.

Option B: Sharing rules will not be enforced for the running user.

Explanation: Since myClass does not specify with sharing, methods within it execute without enforcing sharing rules, allowing access to all data irrespective of the running user's sharing rules.

When a batch Apex job is timing out and not completing, the first step in troubleshooting is to check the job's status and logs in the Asynchronous Job Monitoring page. This page provides information about all asynchronous Apex jobs, including batch Apex, scheduled Apex, future methods, and queueable Apex.

Option D: Check the asynchronous job monitoring page to view the job status and logs.

Correct Approach.

Explanation:

The Asynchronous Job Monitoring page (also known as the Apex Jobs page) in Salesforce Setup allows developers to see the status of all asynchronous Apex jobs.

By checking this page, the developer can see whether the batch job is still running, failed, or completed.

If the job has failed, the page provides error messages that can help identify the cause of the failure.

This is the first step to determine what is happening with the batch job.

Option A: Data Import Wizard does not support Opportunities.

Explanation: The Data Import Wizard supports importing data for certain standard objects (Accounts, Contacts, Leads, Solutions, Campaign Members, and Person Accounts) and custom objects. It does not support importing data into all standard objects like Opportunities.

To ensure that the Food_Preference__c picklist field has a value every time a record is created or updated, marking the field as Required on the field definition is the optimal solution.

Option C: Mark the field as Required on the field definition

Universal Enforcement: Setting the field as required at the field level ensures that it must have a value regardless of how the record is created or updated (UI, API, data import).

Data Integrity: Prevents records from being saved without a value in the picklist field, maintaining data consistency.

No Additional Code: Achieves the requirement declaratively without the need for Apex code.

Option C: Handle low-level events in the event handler and re-fire them as higher-level events.

True.

Explanation:

It's a best practice to encapsulate lower-level events and re-emit them as higher-level, application-specific events to decouple components and simplify event handling.

To expose an Apex class as a RESTful web service, you use the @RestResource annotation.

Option C: @RestResource(urlMapping='/myService/*')

@RestResource Annotation:

The @RestResource annotation is used to define an Apex class as a RESTful web service, specifying the URL mapping.

Methods within the class are annotated with @HttpGet, @HttpPost, @HttpPut, etc., to handle HTTP requests.

Example:

apex

Copy code

@RestResource(urlMapping='/myService/*')

global with sharing class MyRestService {

@HttpGet

global static String doGet() {

// Implementation

}

}

As of Winter '20 (API version 47.0), Salesforce introduced the ability to test Autolaunched Flows with test coverage.

However, as of the current knowledge cutoff (2023-09), there is no direct way within the Salesforce UI to check the test coverage of autolaunched flows before deploying them via change sets.

To check the test coverage of flows, developers can use the Tooling API to query for test coverage.

Option A: Use SOQL and the Tooling API.

Correct Answer.

Explanation:

Developers can use the Tooling API to query for Flow test coverage information.

By executing a SOQL query on FlowTestCoverage and FlowVersionView objects via the Tooling API, developers can retrieve coverage data.

This allows checking flow test coverage programmatically before deployment.

When designing a new application on the Salesforce platform that needs to support multiple tenants effectively (i.e., multiple customers or users), the developer should consider the Model-View-Controller (MVC) framework.

Option B: Model-View-Controller (MVC)

Correct Design Framework.

Explanation:

MVC is a software architectural pattern for implementing user interfaces.

Model: Represents the data and business logic.

View: Represents the presentation layer.

Controller: Handles user input and interactions.

Salesforce's platform follows the MVC pattern, which helps in separating concerns, ensuring scalability, and maintainability.

Declarative Development refers to building applications using Salesforce's point-and-click tools without writing code. It has several characteristics:

Option C: Declarative development does not require Apex test classes.

True.

Declarative tools like Flows, Process Builder, and Validation Rules do not require Apex test classes because they are configured via the UI and not through code.

To meet the given requirements, we need a relationship that allows:

Calculating the total amount on an Order.

This can be achieved using roll-up summary fields on the Order object to sum up values from its Line Item child records.

Roll-up summary fields are only available on the master object in a master-detail relationship.

Option A: Roll-up summary fields can cause the parent record to go through Save.

True.

When a child record changes, roll-up summary fields on the parent object are recalculated.

This causes the parent record to save, which can trigger triggers on the parent object.

Option C: In a test setup method, test data is inserted once and made available for all test methods in the test class.

True.

The @testSetup method runs once before any test methods in the class.

Test data created in this method is available to all test methods, promoting code reuse and efficiency.

Option C: Update the PrimaryId__c field definition to mark it as an External Id.

Correct Answer.

Explanation:

Marking PrimaryId__c as an External ID allows data loading tools to match records based on this field.

This facilitates upserting data and ensures that the CSV data correctly maps to existing records.

When importing an Apex method into a Lightning Web Component (LWC), the correct syntax is:

import methodName from '@salesforce/apex/ClassName.methodName';

Option D: import updateAccounts from '@salesforce/apex/AccountController.updateaccounts';

Correct Syntax.

Explanation:

import updateAccounts:

Specifies the JavaScript function name to reference in the LWC.

from '@salesforce/apex/AccountController.updateaccounts';:

Indicates that we are importing from an Apex class named AccountController, and the method is updateaccounts.

Case Sensitivity:

The class and method names are case-sensitive and should match the Apex code.

To enforce that only Container__c records with a status of "Decommissioned" can be deleted, we need to prevent deletion of records unless they meet this criteria.

Possible Approaches:

Option A: Apex Trigger

Correct.

Explanation:

An Apex before delete trigger can be written to check the Status__c field of each record being deleted.

If the status is not "Decommissioned," the trigger can add an error to prevent deletion.

trigger PreventContainerDeletion on Container__c (before delete) {

for (Container__c container : Trigger.old) {

if (container.Status__c != 'Decommissioned') {

container.addError('Only decommissioned containers can be deleted.');

}

}

}

Since users can see Accounts they do not own in a private sharing model, the custom Apex code is likely not enforcing sharing rules. To enforce sharing permissions, the developer should use the with sharing keyword on the class declaration.

with sharing Keyword: This enforces the sharing rules of the current user, ensuring that the Apex class respects the user's record-level access permissions.

"Use the with sharing keyword when declaring a class to enforce the sharing rules that apply to the current user."— Apex Developer Guide: Using the with sharing or without sharing Keywords

Private Sharing Model: In a private sharing model, users should only see records they own or have been shared with them.

"Private: Only the record owner and users above that role in the hierarchy can view, edit, and report on those records."— Salesforce Help: Organization-Wide Sharing Defaults

Why Not Other Options:

A. Use the schema describe calls to determine if the logged-in user has access to the Account object: Schema describe calls check for object-level access, not record-level sharing.

"Schema describe information provides metadata about object and field properties, but it doesn't enforce record-level access."— Apex Developer Guide: Schema Namespace

C. Use the without sharing keyword on the class declaration: This runs the class in system context, ignoring sharing rules, which is the opposite of what's needed.

"Classes declared as without sharing or those that do not specify a keyword default to without sharing and don't enforce the sharing rules of the current user."— Apex Developer Guide: Using the with sharing or without sharing Keywords

D. Use the UserInfo Apex class to filter all SOQL queries to return records owned by the logged-in user: Manually filtering queries is error-prone and not a best practice when with sharing can enforce sharing automatically.

"Avoid hardcoding user or profile IDs and using the UserInfo class to enforce security. Instead, use declarative security features."— Apex Developer Guide: Enforcing Security in Apex

Conclusion: By declaring the class with with sharing, the Apex code respects the user's sharing rules, ensuring that users only see Accounts they have access to.

To troubleshoot query performance issues:

Option B: Developer Console

Explanation: The Developer Console provides tools like the Query Plan to analyze SOQL queries for performance.

Using Query Plan Tool:

Open Developer Console.

Go to the Query Editor.

Enter your SOQL query.

Click on "Explain" to see the query plan.

The Lightning Component framework is used to develop:

Option B: Lightning Pages

Explanation: Lightning Components can be used to build custom components that can be added to Lightning Pages, enhancing the Lightning Experience and Salesforce mobile app.

In the Aura framework, application events propagate through the component hierarchy in specific phases. The two main phases are:

Option A: Bubble

Correct Phase.

Explanation:

In the bubble phase, the event propagates upward from the source component to the root component.

Components can handle the event during this phase by registering an event handler with phase="bubble".

Defining the Order Number field as an External ID and marking it as Unique ensures:

External ID:

Allows the field to be used for matching during data import.

Helps in upsert operations.

Unique:

Ensures no duplicate Order Numbers exist.

Maintains data integrity.

Why Not Other Options:

Option A: Direct Lookup is not a valid field type for this scenario.

Option B: Lookup fields create relationships, not suitable here.

Option D: Indirect Lookup is used with external objects.

References:

External IDs:

"An external ID is a custom field that has the External ID attribute, meaning that it contains unique record identifiers from a system outside of Salesforce."— Salesforce Help: External ID Fields

To test the trigger with 200 account records with unique names using the least amount of code:

Option A: Use Test.loadData to populate data in your test methods.

Explanation: Test.loadData allows you to load test data from a static resource (CSV file) into your test method. This approach minimizes code since you don't have to write code to create each record.

Since Case and Defect__c have Private organization-wide defaults (OWD), users need explicit access to the parent records to access the child records in a master-detail or junction object relationship.

The Case_Defect__c is a junction object between Case and Defect__c.

Option C: Share the parent Case and Defect__c records.

Correct Answer.

Explanation:

To access a record on a junction object (Case_Defect__c), a user must have access to both parent records.

Sharing both the Case and Defect__c records with the user will grant them access to the Case_Defect__c record.

To ensure Pricing_Structure__c records are available when the test class is executed, the developer can use the following approaches:

Option A: Use a Test Data Factory class.

Valid Approach.

Explanation:

A Test Data Factory class is a utility class that creates test data for use in test methods.

It helps in generating consistent test data and promotes reusability.

The factory class can create the necessary Pricing_Structure__c records for testing.

When deciding between SOQL (Salesforce Object Query Language) and SOSL (Salesforce Object Search Language), developers must consider the use case and limitations of each.

Option A: SOSL is faster for text searches.

Correct Statement.

Explanation:

SOSL is optimized for searching text, especially across multiple objects and fields.

It uses full-text search indexes and can quickly find records that match search terms.

Ideal for scenarios where you need to search for a string across many fields.

Lightning Web Components (LWC) can access various Salesforce resources.

Option B: SVG resources

Accessible.

Explanation:

LWCs can include SVG files to define custom icons for the component.

The SVG file is placed in the component bundle with the name componentName.svg.

To perform DML operations that insert new records and update existing records in a list of Order__c records using the external ID field Order_Number__c, you should use:

Option D: upsert orders Order_Number__c;

Upsert Statement:

The upsert DML operation either inserts or updates records based on whether they already exist.

By specifying the external ID field (Order_Number__c), Salesforce will match existing records based on this field.

Syntax:

upsert orders Order_Number__c;

orders is the list of Order__c records.

Order_Number__c is the external ID field used for matching.

To run a script that deploys to a sandbox:

Option A: VSCode

Explanation: Visual Studio Code with the Salesforce Extensions Pack allows developers to deploy code using scripts and integrates with Salesforce CLI.

Option D: SFDX CLI

Explanation: The Salesforce CLI (SFDX CLI) can be used to script deployments to any org, including sandboxes.

Example Command:

sfdx force:source:deploy -u sandboxAlias -p path/to/source

To notify the parent component from a child component when a button is clicked:

Option C: Create a custom event

Explanation: In Lightning Web Components, child components communicate with parent components by dispatching custom events.

Child Component:

// ChildComponent.js

handleClick() {

const nextEvent = new CustomEvent('next');

this.dispatchEvent(nextEvent);

}

Parent Component:

javascript

Copy code

// ParentComponent.js

handleNext() {

// Navigate to the next page

}

To override the Account's standard Edit button in Lightning Experience:

Option A: Lightning component

Explanation: In Lightning Experience, you can override standard buttons with Lightning components by implementing the appropriate interface.

Implementation:

The Lightning component must implement lightning:actionOverride interface.

Option A: Developer and Developer Pro sandboxes have different storage limits.

True.

Explanation:

Developer Sandbox:

Provides 200 MB of data storage and 200 MB of file storage.

Developer Pro Sandbox:

Provides 1 GB of data storage and 1 GB of file storage.

The storage limits affect how much data you can import into these environments.

Scenario:

Universal Containers (UC) wants to allow multiple Accounts to share a default pickup address.

They have created a custom object called Global Address.

Requirement:

Create an efficient model to link multiple Accounts to a single Global Address.

Solution:

To associate multiple Accounts with a single Global Address, we need to create a lookup relationship from Account to Global Address.

Option D: Add a lookup field on the Account object to the Global Address object.

Correct Approach.

Explanation:

Adding a Lookup Field on the Account object that references the Global Address object allows multiple Accounts to reference the same Global Address.

This setup models a many-to-one relationship:

Many Accounts can have the same Global Address as their pickup address.

Benefits:

Data Normalization: Reduces data redundancy by storing the address once.

Ease of Maintenance: Updating the Global Address updates it for all associated Accounts.