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

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 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);

}

}

Option A: Create a Custom Permission for the users.

True.

Explanation:

Custom Permissions can be used to control access to specific functionality.

By assigning the custom permission to a small group of users, the form's availability is restricted.

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.

Option C: Developer Sandbox

Correct Answer.

Explanation:

Developer Sandboxes are intended for coding and testing by a single developer.

They copy all application and configuration information from production, ensuring the same metadata.

Each developer can work in their own isolated environment.

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.

To update the flow to create a Contact and store the Contact’s ID on the Opportunity:

Option D: Add a new Create Records element.

Explanation: The flow needs to create a new Contact record using the Create Records element. After creating the Contact, you can store the Contact's ID in a variable and then update the Opportunity with the Contact’s ID.

Steps:

Add Create Records Element: Configure it to create a Contact and store the newly created Contact's ID in a variable.

Update Opportunity: Use the existing Update Records element or add a new one to update the Opportunity with the Contact's ID.

To check the code coverage of a class after running all tests, a developer can use the Developer Console.

Option B: View the code coverage percentage for the class using the Overall Code Coverage panel in the Developer Console Tests tab.

Correct Method.

Explanation:

In the Developer Console, navigate to the Tests tab.

After running tests, the Overall Code Coverage panel displays code coverage statistics.

You can see the coverage percentage for individual classes.

When deploying Apex code to production, Salesforce requires that all Apex triggers have at least 1% code coverage and the overall code coverage must be at least 75%.

In this scenario:

The developer has a test class that covers 95% of the helper class.

The deployment fails because the trigger has 0% coverage.

The error message indicates that the trigger needs at least 1% coverage.

Solution:

Option A: Create a test class and methods to cover the Apex trigger.

Correct Action.

Explanation:

Write a test class that specifically tests the trigger's functionality.

Ensure that the trigger is executed within the test context.

This will increase the trigger's code coverage above the required 1%.

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 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.

ISV Package Development:

The ISV is developing a managed package.

They have an Apex class BodyFat with a method calculateBodyFat().

Requirement:

Ensure calculateBodyFat() is accessible by consumers outside the package namespace.

Solution:

To allow methods in a managed package to be accessible outside the package namespace, they must be declared as global.

Option B: Declare the class and method using the global access modifier.

Correct Approach.

Explanation:

Global Classes and Methods:

In managed packages, only classes and methods declared as global are accessible outside the package namespace.

Declaration:

global class BodyFat {

global void calculateBodyFat() {

// method implementation

}

}

Important Notes:

Public classes and methods in managed packages are accessible only within the namespace.

Global is required to expose the functionality to subscribers.

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.

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.

To associate multiple Engineering_Support__c records to a single Opportunity and display aggregate information on the Opportunity:

Option B: Master-detail field from Engineering_Support__c to Opportunity

Explanation:

Master-Detail Relationship: Creating a master-detail relationship from Engineering_Support__c (detail) to Opportunity (master) allows multiple support records to be related to one Opportunity.

Aggregate Information: Master-detail relationships support roll-up summary fields, enabling aggregate calculations (like COUNT, SUM) on the Opportunity object based on related Engineering_Support__c records.

To represent that an applicant has applied for a job when each applicant can apply to multiple jobs:

Option B: Junction object between Applicant and Job

Explanation: A many-to-many relationship in Salesforce is modeled using a junction object. The junction object would have two master-detail relationships, one to Applicant and one to Job.

Implementation:

Create a custom object, e.g., JobApplication.

Add master-detail relationships to both Applicant and Job.

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.

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.

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.

In Salesforce, triggers are executed in response to specific database events on standard objects (such as Account or Contact) and custom objects. The following actions can cause triggers to fire:

Option A: Cascading delete operations

Explanation: When a record is deleted, and it has child records in a master-detail relationship, the child records are automatically deleted (cascade delete). This action fires the before delete and after delete triggers on the child records.

To implement a process where every time an Opportunity is created, a follow-up Task should be created and assigned to the Opportunity Owner, the most efficient method is to use a Record-Triggered Flow on the Opportunity object.

Option B: Record-triggered flow on Opportunity

Declarative Solution: Salesforce Flows provide a powerful, declarative way to automate business processes without writing code.

Triggering Event: The flow is configured to trigger when a new Opportunity record is created.

Create Task Record: The flow includes an element to create a new Task record.

Set the Assigned To field to the Opportunity Owner.

Populate other Task fields as necessary (e.g., Subject, Due Date).

Efficiency: Flows are more efficient than Apex triggers for simple automation and are easier to maintain.

Best Practice: Salesforce recommends using Flows over Workflow Rules and Process Builders for new automations.

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.

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 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.

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.

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.

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.

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.');

}

}

}

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

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.

When comparing Lightning Web Components (LWC) with Visualforce for the View layer in the MVC paradigm, several advantages stand out.

Option A: Self-contained and reusable units of an application

Correct Advantage.

Explanation:

LWCs are built using modular components that encapsulate their own structure, style, and behavior.

Components can be reused across different parts of the application, promoting consistency and reducing development time.

This modularity allows for better maintainability and scalability.

To enable a custom event in a Lightning Web Component (LWC) to bubble up the containment hierarchy and cross the Shadow DOM boundary, the event must be dispatched with the properties:

bubbles: true

composed: true

bubbles Property:

When set to true, the event bubbles up through the DOM hierarchy, allowing parent components to listen for the event.

"The bubbles option indicates whether the event bubbles up through the DOM or not."— Lightning Web Components Developer Guide: Event Propagation

composed Property:

When set to true, the event can pass through the Shadow DOM boundary, allowing components outside the Shadow DOM to receive the event.

"The composed option controls whether the event can propagate across the boundary between the shadow DOM and the regular DOM."— Lightning Web Components Developer Guide: Event Composition

Example:

// ChildComponent.js

const event = new CustomEvent('myevent', {

bubbles: true,

composed: true,

detail: { /* event data */ }

});

this.dispatchEvent(event);

Why Other Options Are Incorrect:

Option B: bubbles: true, composed: false

The event will bubble up within the Shadow DOM but will not cross the Shadow DOM boundary.

Option C: bubbles: false, composed: false

The event will neither bubble nor cross the Shadow DOM boundary, limiting its propagation.

Option D: bubbles: false, composed: true

The event will not bubble up the containment hierarchy but can cross the Shadow DOM boundary, which is insufficient for the requirement.

Conclusion:

Setting both bubbles and composed to true ensures the event bubbles up through the component hierarchy and crosses the Shadow DOM boundary.

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.

When saving records using a custom controller in a Visualforce page, validation rule violations can occur. To display these validation error messages to the user, the developer should use the component.

Option A: Include <apex:messages> on the Visualforce page.

Correct Approach.

Explanation:

The component displays all messages that were generated for all components on the page, including validation rule violations.

When a DML operation is performed, any validation errors are automatically added to the ApexPages message collection.

Including in the page ensures that these messages are displayed to the user.

Example:

Given that Trainer__c has a lookup field to Gym__c, to retrieve the record for the 'Viridian City Gym' and all its trainers, the correct SOQL query is:

Option A:

SELECT Id, (SELECT Id FROM Trainers__r) FROM Gym__c WHERE Name = 'Viridian City Gym'

Parent-to-Child Query (Subquery):

To retrieve child records (trainers) from the parent record (gym), you perform a subquery using the child relationship name.

Child Relationship Name:

For a lookup relationship, the child relationship name can be found in the relationship settings.

By default, if the lookup field on Trainer__c is Gym__c, the child relationship name is Trainers__r.

Query Breakdown:

SELECT Id, (SELECT Id FROM Trainers__r) FROM Gym__c WHERE Name = 'Viridian City Gym'

Selects the Gym record and all related Trainers.

Why Other Options Are Incorrect:

Option B: (SELECT Id FROM Trainer__c)

Trainer__c is an object, not a relationship name, so the subquery is incorrect.

Option C: SELECT ID FROM Trainer__c WHERE Gym__r.Name = 'Viridian City Gym'

This query retrieves Trainer records, not the Gym record and its trainers as specified.

Option D: (SELECT Id FROM Trainers__c)

Trainers__c is incorrect; the child relationship name should end with __r in subqueries.

To calculate the sum of all Order Line item totals on the Order record in a master-detail relationship, the best practice is to use a Roll-up Summary Field.

Roll-up Summary Field: This field type allows you to perform calculations on a set of related records, such as summing up the total price of all Order Line items related to an Order.

"Roll-up summary fields allow you to display a value in a master record based on the values of fields in a detail record."— Salesforce Help: Define Roll-Up Summary Fields

Master-Detail Relationship: Since Order Line items are in a master-detail relationship with Orders, roll-up summary fields can be created on the master object (Order) to summarize data from the detail object (Order Line).

"You can create roll-up summary fields on any custom object that is on the master side of a master-detail relationship."— Salesforce Developer Guide: Roll-Up Summary Fields

Why Not Other Options:

A. Quick Action: Quick actions are used to create records, log calls, send emails, etc., and are not suitable for calculating and displaying aggregate data.

B. Apex Trigger: While triggers can perform the calculation, using them for this purpose is not considered best practice when declarative solutions like roll-up summary fields are available.

"Use declarative functionality (roll-up summary fields) for maintaining aggregates instead of triggers."— Salesforce Developer Guide: Best Practices for Triggers

D. Formula Field: Formula fields cannot aggregate data from child records to parent records unless they are part of a roll-up summary field in a master-detail relationship.

Conclusion: Using a roll-up summary field is the most efficient and recommended approach to sum the total prices of all Order Line items on the Order record.

Option A: <apex:pageMessages />

Correct Answer.

Explanation:

The component displays all messages that were added to the ApexPages message list, including those added via ApexPages.addMessage().

A SOQL query can return the following data types:

Option A: sObject

Explanation: A SOQL query can return a single sObject when the query returns only one record.

Example:

Account acc = [SELECT Id, Name FROM Account WHERE Id = :accountId];

Option D: List

Explanation: A SOQL query can return a list of sObjects when multiple records are retrieved.

Example:

List contacts = [SELECT Id, Name FROM Contact WHERE AccountId = :accountId];

Option E: Integer

Explanation: When using aggregate functions like COUNT(), SOQL can return an Integer value.

Example:

Integer contactCount = [SELECT COUNT() FROM Contact WHERE AccountId = :accountId];

Why Other Options Are Incorrect:

Option B: Double

Aggregate functions like SUM() return Decimal, not Double.

When working with formula fields in Salesforce, it's important to understand their characteristics and limitations.

Option A: Formulas are calculated at runtime and are not stored in the database.

True.

Explanation:

Formula fields are calculated dynamically whenever the record is accessed.

The value is not stored in the database; instead, it is computed on-the-fly based on the formula definition.

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 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.

To write unit tests for a private method in an Apex class:

Option C: Use the @TestVisible annotation.

Explanation: The @TestVisible annotation allows test methods to access private methods and variables in Apex classes. By annotating the private method with @TestVisible, it becomes accessible within test classes.

Example:

public class MyClass {

@TestVisible

private static void myPrivateMethod() {

// Implementation

}

}