Salesforce CRT-450 Salesforce Certified Platform Developer I (WI25) Exam Practice Test

To replace a JavaScript button from Salesforce Classic that creates records with prepopulated values in Lightning Experience, the developer can use:

Option A: Quick Actions

Quick Actions (Specifically, Object-Specific Actions):

Quick Actions allow users to perform actions, such as creating or updating records, from a record page or global context.

Prepopulating Fields:

You can predefine field values in Quick Actions using predefined values or by utilizing Lightning Component actions.

For integrating automated tests into a Continuous Integration (CI) process, the Universal Containers development team should use the Salesforce CLI.

Option C: Salesforce CLI

Salesforce CLI (Command Line Interface) is a powerful command-line tool that allows developers to script and automate various Salesforce tasks, including running tests, deploying code, and retrieving metadata.

Automated Testing:

Developers can use the sfdx force:apex:test:run command to run Apex tests and include it in their CI scripts.

Example Command:

sfdx force:apex:test:run --testlevel RunLocalTests --resultformat human --outputdir test-results

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 ensure that the component works for both users without showing errors due to field-level security, the developer should handle field accessibility programmatically.

Option D: Use Security.stripInaccessible to remove fields inaccessible to the current user.

Correct Answer.

Explanation:

The Security.stripInaccessible method can be used in Apex to remove fields from SObjects that the current user doesn't have access to.

When data is fetched using SOQL, the method can be applied to ensure that inaccessible fields are not included, preventing any security exceptions when the component tries to display them.

This method enforces field-level security and prevents exposure of inaccessible data.

Usage:

// Apex Controller

public with sharing class SalesRecordsController {

@AuraEnabled(cacheable=true)

public static List getSalesRecords() {

List records = [SELECT Id, Name, Commission__c, Other_Field__c FROM Sales_Record__c];

return (List) Security.stripInaccessible(AccessType.READABLE, records);

}

}

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.

Universal Containers (UC) wants to calculate the estimated ship date for an Order, which should be the date when all Order Line Items are available. The availability date is stored on each Order Line Item.

Given that the relationship between Order and Order Line Item is Master-Detail, we can leverage Roll-Up Summary Fields to perform calculations on the child records (Order Line Items) and summarize them on the parent record (Order).

Option A: Use a MAX Roll-Up Summary field on the latest availability date fields.

Correct Approach.

Explanation:

Create a Roll-Up Summary Field on the Order object.

Use the MAX function to calculate the latest availability date among all related Order Line Items.

The Roll-Up Summary Field will display the maximum (latest) availability date, which represents the date when all items are available.

This date can be used as the estimated ship date for the Order since the Order can only be shipped when all items are available.

Benefits:

Declarative Solution: No code required.

Real-Time Calculation: Automatically updates when Order Line Items change.

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

}

}

To address the view state limit error caused by loading over 10,000 records in a Visualforce page, the developer should implement pagination with a StandardSetController.

StandardSetController: This controller allows developers to easily paginate large sets of records in Visualforce pages.

"A StandardSetController object contains a reference to a list of records with pagination support, similar to the display in a list view."— Apex Developer Guide: StandardSetController Class

Benefits:

Efficient Data Handling: It retrieves only a subset of records at a time, reducing the amount of data held in view state.

Built-in Pagination: Provides methods to navigate through pages of records (next, previous, etc.).

View State Limit: Visualforce pages have a view state limit of 170KB. Loading all records at once exceeds this limit.

"To optimize your Visualforce pages, minimize your use of view state. The view state of a Visualforce page is limited to 170KB."— Visualforce Developer Guide: View State in Visualforce Pages

Why Not Other Options:

A. Implement pagination with an OffsetController: There's no standard OffsetController in Visualforce. Implementing custom pagination with offsets is less efficient and can be complex.

B. Use JavaScript remoting with SOQL Offset: While JavaScript remoting can reduce view state size, using SOQL OFFSET is not efficient for large offsets (over 2,000 records).

"When using OFFSET with a large number of records, performance degrades significantly."— SOQL and SOSL Reference: OFFSET Clause

D. Use lazy loading and a transient List variable: Lazy loading can help, but it doesn't solve the issue of handling large datasets efficiently. Transient variables reduce view state but do not manage data retrieval or pagination.

Conclusion: Implementing pagination with a StandardSetController is the recommended solution to handle large datasets efficiently in Visualforce pages and prevent view state limit errors.

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.

Scratch Orgs are disposable Salesforce orgs that can be created quickly and configured with different features and settings. They are ideal for source-driven development and allow developers to work independently.

Option D: Scratch orgs

Correct Answer.

Scratch orgs support source-driven development and can be fully configured through scripts and the Salesforce CLI.

Developers can create and destroy scratch orgs as needed, ensuring they have isolated environments.

When writing tests for Apex code that performs callouts to external services, Salesforce requires that callouts are mocked to ensure that tests do not depend on external systems and to allow for consistent and predictable test results.

Correct Option:

Option D: Write a class that implements HttpCalloutMock.

True.

Explanation:

To test HTTP callouts, you implement the HttpCalloutMock interface and provide a fake response for the HTTP request.

This mock response is then used in your test methods to simulate the callout.

The test method uses Test.setMock to set the mock class.

Option A: After-save record-triggered flow

True.

An after-save record-triggered flow can update records after they are saved.

If the flow updates a record that the trigger is listening to, it can cause the trigger to fire again, affecting the number of times it executes.

Universal Containers wants to prevent Opportunities from being edited once they reach the Closed/Won stage. To achieve this, the developer can use the following strategies:

Option A: Use a validation rule.

Correct Approach.

Explanation:

A validation rule can be created on the Opportunity object to prevent users from editing records when the Stage is Closed/Won.

The validation rule would evaluate whether the record's StageName is 'Closed Won' and, if so, display an error message when a user attempts to edit and save the record.

Example Validation Rule:

AND(

ISPICKVAL(StageName, 'Closed Won'),

ISCHANGED(ANYFIELD) // Replace ANYFIELD with specific fields if needed

)

Benefits:

Declarative Solution: No code required.

Consistent Enforcement: Applies across all user interfaces and API.

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.

When using Lightning Data Service (LDS) in a Lightning Web Component (LWC), it's important to understand how data security is handled.

Option D: Lightning Data Service handles sharing rules and field-level security.

Correct Statement.

Explanation:

Lightning Data Service enforces all the security and sharing rules that are in place in the Salesforce org.

This includes object-level, field-level, and record-level security.

When a component uses LDS to access data, the framework ensures that the user only sees data they have access to.

Benefits:

Simplifies development by abstracting security checks.

Ensures compliance with organizational security policies.

In Lightning Web Components (LWC), communication between parent and child components can be achieved in several ways.

Option A: The parent component can use a public property to pass the data to the child component.

Correct Method.

Explanation:

The child component can declare a public property using the @api decorator.

The parent component can then pass data to the child component via this property in the template.

Example:

Child Component (childComponent.js):

import { LightningElement, api } from 'lwc';

export default class ChildComponent extends LightningElement {

@api

myProperty;

}

Parent Component Template (parentComponent.html):

Change Sets are a point-and-click tool for migrating metadata between related Salesforce orgs, such as from a sandbox to a production org.

Option C: Deployment is done in a one-way, single transaction.

Correct.

Explanation:

Change sets are deployed in a one-way direction from the source org to the destination org.

The deployment occurs in a single transaction. If any component fails to deploy, the entire deployment is rolled back.

To script the deployment and unit test execution as part of continuous integration (CI), developers use tools that can be automated and run from the command line or scripts.

Option D: Salesforce CLI

Correct.

Explanation:

The Salesforce CLI (Command-Line Interface) is a powerful command-line tool that allows developers to interact with Salesforce orgs.

It supports scripting of deployments using commands like sfdx force:source:deploy and running unit tests using sfdx force:apex:test:run.

The CLI can be integrated into CI/CD pipelines to automate deployments and 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.

When deploying Apex code to production, the following considerations are required:

Option B: All triggers must have at least one line of test coverage.

Explanation:

Salesforce mandates that every trigger has some test coverage.

When updating a record of a junction object in Salesforce (an object used to create a many-to-many relationship), you must have the appropriate permissions.

Required Permissions:

Read/Write access on the junction object: To update the junction object record itself.

Read/Write access on both master (parent) records: Because the junction object is in two master-detail relationships, and its security settings are controlled by the parent records.

Given the options:

Option A: Read/Write access on the primary relationship

Option B: Read/Write access on the secondary relationship

These options correspond to having Read/Write access on both parent objects.

Supporting References:

Master-Detail Relationships:

Permissions Inheritance: The detail (junction) record inherits sharing and security settings from the master (parent) records.

Updating Records: To update a detail record, users must have Read/Write access to both the detail record and its parent records.

There are several ways to execute tests in a Salesforce org:

Option A: Setup Menu

Valid Method.

Explanation:

Tests can be run from the Salesforce Setup menu under Apex Test Execution.

Allows selecting and running test classes and methods.

Option A: Specifying loading order

True.

Explanation:

The tag allows you to specify the order in which scripts are loaded by the sequence in the scripts attribute.

When a Lightning component needs to execute a complex SOQL query that joins two objects, and such queries are not supported directly in Lightning components, the solution is to use an Apex controller method.

Option C: Invoke an Apex class with the method annotated as @AuraEnabled to perform the query.

Correct Approach.

Explanation:

The Lightning component can call an Apex method annotated with @AuraEnabled.

The Apex method can perform the complex SOQL query and return the results to the component.

When using the @InvocableMethod annotation in Apex, there are specific considerations to keep in mind:

Option A: Only one method using the @InvocableMethod annotation can be defined per Apex class.

True.

Explanation:

An Apex class can contain only one method annotated with @InvocableMethod.

This ensures that when the class is invoked from a flow or process, there is no ambiguity about which method to execute.

The accurate statements about debug logs are:

Option A: System debug logs are retained for 24 hours.

Explanation: Salesforce retains debug logs for 24 hours after they are generated.

Option D: Use Test.getStandardPricebookId() to get the standard price book ID.

Correct Answer.

Explanation:

The Test.getStandardPricebookId() method returns the ID of the standard price book, which can be used in test classes without using SeeAllData=true.

This allows the test to access and use the standard price book in a controlled manner.

Declarative customizations in Salesforce refer to point-and-click configurations made through the Salesforce UI, such as creating objects, fields, workflows, and processes.

Option C: Declarative customizations automatically update with each Salesforce release.

True.

Explanation:

Declarative features are managed by Salesforce and are automatically updated and enhanced with each new release.

Users benefit from new features without needing to modify existing configurations.

In the provided code snippet:

Boolean isOK;

Integer x;

String theString = 'Hello';

if (isOK == false && theString == 'Hello') {

x = 1;

} else if (isOK == true && theString == 'Hello') {

x = 2;

} else if (isOK != null && theString == 'Hello') {

x = 3;

} else {

x = 4;

}

Variable Initialization:

Boolean isOK; → Declared but not initialized, so isOK is null.

Integer x; → Declared but not initialized.

String theString = 'Hello'; → Initialized to 'Hello'.

Evaluation of Conditions:

First Condition:

if (isOK == false && theString == 'Hello')

isOK == false → Since isOK is null, this evaluates to false.

Overall condition: false && true → false.

Second Condition:

else if (isOK == true && theString == 'Hello')

isOK == true → Since isOK is null, this evaluates to false.

Overall condition: false && true → false.

Third Condition:

else if (isOK != null && theString == 'Hello')

isOK != null → Since isOK is null, this evaluates to false.

Overall condition: false && true → false.

Else Block:

else {

x = 4;

}

Since none of the previous conditions are met, the else block is executed.

x is assigned the value 4.

Conclusion:

The variable x is assigned the value 4.

References:

Variable Initialization:

"Instance variables are initialized to null. Local variables are not initialized, so their value is undefined until you assign a value."— Apex Developer Guide: Variables

Conditional Statements and Null Values:

"In Apex, comparisons with null are straightforward. If you compare null to a value, the result is false."— Apex Developer Guide: Expressions

When creating a Visualforce page that uses a standard controller and a controller extension for a custom object named Notice__c, the correct syntax is:

Option D: apex

standardController="Notice__c" extensions="myControllerExtension"

Correct Syntax.

standardController attribute specifies the standard controller for the custom object Notice__c.

extensions attribute specifies the name of the Apex class myControllerExtension that extends the functionality of the standard controller.

The recommended process for deploying code and configurations from a Sandbox to Production is to use a change set.

Option C: Use a change set to deploy the Apex code and Lightning Components.

Explanation: Change sets are the standard mechanism provided by Salesforce for deploying customizations between connected orgs (e.g., Sandbox to Production). They support deploying Apex classes, Lightning components, and configurations.

To update the Timezone__c field on Account based on the Postal Code and values from PostalCodeToTimezone__c:

Option B: Account Trigger

Explanation:

An Apex trigger can query the PostalCodeToTimezone__c object and update the Timezone__c field when the Postal Code is changed.

To check whether the current user has permission to delete an Account, the developer should use the Schema.sObjectType methods.

Option D: Schema.sObjectType.Account.isDeletable()

Correct Method.

Explanation:

The Schema.sObjectType.Account provides describe information about the Account object.

The isDeletable() method returns a Boolean indicating whether the current user has permission to delete records of this type.

Usage:

if (Schema.sObjectType.Account.isDeletable()) {

// User has permission to delete Accounts

delete accountRec;

} else {

// Handle lack of permission

}

Options Not Applicable:

Option A: Account.isDeletable()

No such static method on the Account object.

Option B: accountRec.sObjectType.isDeletable()

sObjectType returns a token; to get describe results, you need to call getDescribe().

Option C: accountRec.isDeletable()

There is no instance method isDeletable() on sObject records.

Conclusion:

To ensure proper permission checks, the developer should use Schema.sObjectType.Account.isDeletable(), which is Option D.

To get the status of an enqueued job for a class that implements the Queueable interface, a developer can:

Option C: View the Apex Jobs page

Correct Answer.

Explanation:

The Apex Jobs page in Salesforce Setup lists all asynchronous Apex jobs, including queueable jobs.

Developers can view the status, start time, and completion time of the job.

When overriding standard buttons in Salesforce Classic and Lightning Experience, different technologies are used.

Salesforce Classic:

Visualforce pages are used to override standard buttons like Edit.

Lightning Experience:

Lightning Components (Aura Components or Lightning Web Components) are used.

Option C: A Visualforce page in Salesforce Classic and a Lightning component in Lightning Experience

Correct Answer.

Explanation:

In Salesforce Classic, override the Edit button with a Visualforce page.

In Lightning Experience, use a Lightning Component to override the Edit action.

In a before insert trigger:

Trigger.old is null.

There is no existing record in the database to reference.

Why Not Other Options:

Option A: Describes Trigger.new.

Option B: The variable is defined but has a null value.

Option D: Trigger.old is not an empty list; it is null.

References:

Trigger Context Variables:

"In insert triggers, Trigger.old is null because the records are new."— Apex Developer Guide: Trigger Context Variables

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.

In Aura Components, application events are fired by invoking the fire() method on the event instance.

Option D: fire()

Correct.

Explanation:

To fire an application event, you first get the event instance using cmp.getEvent("eventName") and then call fire() on it.

Example:

var appEvent = $A.get("e.namespace:eventName");

appEvent.setParams({ "param1" : value1 });

appEvent.fire();

Using Database.insert with allOrNone=false allows partial success in DML operations.

Option D: Use the Database method with allOrNone set to false.

Records that cause errors are not inserted.

Successful records are committed.

Prevents the entire batch from failing.

Why Not Other Options:

Option A: Deactivating the trigger is not practical.

Option B: Removing the class from the profile may cause other issues.

Option C: A try-catch block won't prevent the batch from failing.

References:

Database Methods:

"Use the Database DML methods to specify whether or not to allow partial record processing."— Apex Developer Guide: Using the Database Class

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.

To build a responsive application capable of responding to touch events and executed on stateful clients, the developer should use technologies that support modern web standards, responsive design, and touch interactions. The two technologies that meet these requirements are Aura Components and Lightning Web Components.

Option A: Aura Components

Explanation: Aura Components are part of the Lightning Component Framework and are designed to build dynamic web applications for mobile and desktop devices. They support responsive design and can handle touch events, making them suitable for building applications that run on stateful clients.