Salesforce PDI Online Access

 Salesforce CLI is a command-line interface that lets you run commands to create, test, and deploy Salesforce applications. You can easily integrate Salesforce CLI commands into various CI tools, such as CircleCI, Jenkins, or Travis CI, to automate testing and deployment of Salesforce applications against scratch orgs. Salesforce CLI also supports the Salesforce DX development model, which enables source-driven development, team collaboration, and agile delivery. References:

• Continuous Integration | Salesforce DX Developer Guide
• Set Up Continuous Integration for Your Salesforce Projects | Salesforce Developers Blog
• Collaborate Using Continuous Integration Unit | Salesforce Trailhead

Component and application events are two types of events that can be used to communicate between components in Lightning. Component events are handled by the component that fired the event or a component in its containment hierarchy. Application events are handled by any component that is listening to the event, regardless of where it is in the DOM1. Some of the best practices when it comes to component and application event handling are:

• Reuse the event logic in a component bundle, by putting the logic in the helper. This practice allows the developer to avoid duplicating code and to maintain consistency and modularity. The helper class can contain common methods that can be invoked by the controller or the renderer of the component2.
• Handle low-level events in the event handler and re-fire them as higher-level events. This practice allows the developer to abstract away the details of the low-level events and provide a more meaningful and relevant event for the consumers. For example, a component can handle a mouse click event and re-fire it as a select event with additional data3.

The other options are not best practices because:

• Use component events to communicate actions that should be handled at the application level. This practice is not recommended, because component events are scoped to the component that fired them or its parents. If the action should be handled by a component that is not in the same containment hierarchy, the component event will not reach it. Application events are more suitable for cross-component communication1.
• Try to use application events as opposed to component events. This practice is not advisable, because application events are broadcast to all components that are listening to them, which can cause performance issues and unwanted side effects. Component events are more efficient and secure, as they are only handled by the relevant components1.

References:

• : Communicating with Events
• : Helper Functions
• : Advanced Events Example

 To deploy Apex or package it for the Salesforce AppExchange, unit tests must cover at least 75% of your Apex code, and those tests must pass1. Code coverage indicates how many executable lines of code in your classes and triggers have been exercised by test methods1. Test classes (classes that are annotated with @isTest) are excluded from the code coverage calculation1. Therefore, the developer needs to create a test class and methods to cover the Apex trigger, as the helper class alone is not enough to meet the code coverage requirement. Running the tests using the ‘Run All Tests’ method, removing the failing test methods from the test class, or increasing the test class coverage on the helper class will not solve the problem, as the trigger itself is still not covered by any test. References: 1 Testing and Code Coverage | Apex Developer Guide - Salesforce Developers1

When deploying to a production org, all Apex code, including triggers, must have at least 75% test coverage. This means that at least 75% of the lines of code in each Apex class and trigger must be executed by unit tests. This is a requirement to ensure the quality and reliability of the code and to prevent any unexpected behavior or errors in production. Test coverage is calculated by dividing the number of covered lines by the total number of lines in each class or trigger. Test coverage can be measured by running tests in the Developer Console, the Salesforce CLI, or the Apex Test Execution page in Setup. Test coverage can also be viewed in the Code Coverage page in Setup or in the Problems tab in the Developer Console. Test coverage is different from test results, which indicate whether the tests passed or failed based on the assertions and expected outcomes. Test results do not affect the deployment, but they can help identify and fix any bugs or issues in the code. Test coverage and test results are both important aspects of testing Apex code and ensuring its functionality and performance. References:

• Testing Apex from the Apex Developer Guide
• Get Started with Apex Unit Tests from the Salesforce Trailhead
• Deploying Apex to a Production Organization from the Apex Developer Guide