Agentic AI Security: Tool Poisoning and Audit Trails
Explore agentic AI security risks, including MCP tool poisoning, and learn how governance, permissions, approvals, and audit trails reduce exposure.
Apex Test Classes are essential for ensuring code quality and reliability in Salesforce. They help validate Apex code functionality, enforce best practices, and ensure that new changes do not break existing features. Test classes are required for deploying Apex code to production, with a minimum of 75% code coverage.
In this example, we have defined a simple class called “AccountUpdateClass“, which contains a single method that updates the name of an Account record. We then defined an Apex test class called “TestAccountUpdateClass“, which contains a single test method called “testUpdateAccount()”.
In the test method, we first set up a test Account record, then call the “updateAccount()” method on an instance of the “AccountUpdateClass” class. Finally, we verify that the Account name has been updated as expected by querying for the Account record and using the “System.assertEquals()” method.
By following this example, you can create your own simple class and corresponding Apex test class and start testing your custom code in Salesforce.
Test data Isolation:
Test data isolation is the concept of ensuring that each test method runs independently of other test methods, and that the data used in one test method does not affect the results of another test method. This is important because it helps ensure that the results of one test method are not affected by the changes made by another test method.
In Apex, test data isolation is achieved by using the SeeAllData attribute in the @isTest annotation. By default, tests run in a separate, isolated context that does not have access to existing data in the organization. However, if you set SeeAllData=true, your tests will have access to all data in the organization.
Here is an example of how test data isolation can help ensure that tests run independently of one another:
@isTest
private class TestDataIsolationExample {
@isTest static void testAccountCreation() {
// Create test data
Account testAccount = new Account(Name = ‘Test Account’);
insert testAccount;
// Retrieve the inserted record
Account acc = [SELECT Id, Name FROM Account WHERE Id = :testAccount.Id];
// Assert the expected behavior
System.assertEquals(‘Test Account’, acc.Name);
}
@isTest static void testOpportunityCreation() {
// Create test data independently
Account testAccount = new Account(Name = ‘Opportunity Account’);
insert testAccount;
Opportunity testOpp = new Opportunity(
Name = ‘Test Opportunity’,
StageName = ‘Prospecting’,
CloseDate = Date.today(),
AccountId = testAccount.Id
);
insert testOpp;
// Retrieve and validate the inserted record
Opportunity opp = [SELECT Id, Name FROM Opportunity WHERE Id = :testOpp.Id];
System.assertEquals(‘Test Opportunity’, opp.Name);
}
}
In this example, we have two test methods, testCreateAccount() and testUpdateAccount(), that test different scenarios for creating and updating an Account record. Each test method sets up its own test data and verifies the results independently. Since each test method runs in its own isolated context, the results of one test method are not affected by the changes made by another test method. This helps ensure that the tests are reliable and provide accurate results.
Testing apex trigger:
Testing Apex triggers is an important aspect of ensuring the quality and reliability of your Salesforce application. The following steps provide an overview of how to test Apex triggers:
Here’s a simple example of how you can test a trigger that updates a related record when the status of a record is changed:
trigger UpdateContactStatus on Account (after update) {
for (Account acc : Trigger.new) {
if (acc.Status__c == ‘Closed’) {
Contact relatedContact = [SELECT Id, Status__c FROM Contact WHERE AccountId = :acc.Id LIMIT 1];
relatedContact.Status__c = ‘Inactive’;
update relatedContact;
}
}
}
@isTest
private class TestTriggerUpdate {
@isTest static void testAccountStatusChange() {
// Create test Account and Contact
Account testAccount = new Account(Name = ‘Test Account’, Status__c = ‘Open’);
insert testAccount;
Contact testContact = new Contact(FirstName = ‘John’, LastName = ‘Doe’, AccountId = testAccount.Id, Status__c = ‘Active’);
insert testContact;
// Update Account status to trigger the logic
testAccount.Status__c = ‘Closed’;
update testAccount;
// Retrieve and verify the updated Contact
Contact updatedContact = [SELECT Status__c FROM Contact WHERE Id = :testContact.Id];
System.assertEquals(‘Inactive’, updatedContact.Status__c);
}
}
@isTest
private class TestTriggerUpdate {
@isTest static void testAccountStatusChange() {
// Create test Account and Contact
Account testAccount = new Account(Name = ‘Test Account’, Status__c = ‘Open’);
insert testAccount;
Contact testContact = new Contact(FirstName = ‘John’, LastName = ‘Doe’, AccountId = testAccount.Id, Status__c = ‘Active’);
insert testContact;
// Update Account status to trigger the logic
testAccount.Status__c = ‘Closed’;
update testAccount;
// Retrieve and verify the updated Contact
Contact updatedContact = [SELECT Status__c FROM Contact WHERE Id = :testContact.Id];
System.assertEquals(‘Inactive’, updatedContact.Status__c);
}
}
In this example, we first create an Account and a related Contact record. Then, we update the Status__c field on the Account record and verify that the related Contact record was also updated with the expected value for the Account_Status__c field.
It’s important to test triggers in different scenarios to ensure that they behave as expected in all cases. For example, you can test the trigger behavior when multiple records are updated at the same time, or when the trigger is fired multiple times in succession. By thoroughly testing your triggers, you can ensure that they work as expected and provide a reliable experience for your users.
Testing apex batch jobs:
Apex batch jobs are a powerful tool in Salesforce that allow you to process large amounts of data in an efficient and scalable way. Testing Apex batch jobs is important to ensure that they behave as expected and that they can handle any errors that may occur during processing.
To test an Apex batch job, you need to create a test class that includes one or more test methods that run the batch job and verify its behavior. The first step in testing an Apex batch job is to create test data that the batch job can process. You can do this by creating test records in your org or by using test methods to create test data.
Once you have your test data, you can write test methods to run the batch job and verify its behavior. To run the batch job, you’ll need to create an instance of the batch class and call the execute() method on that instance. For example:
global class SampleBatch implements Database.Batchable<sObject> {
global Database.QueryLocator start(Database.BatchableContext BC) {
return Database.getQueryLocator(‘SELECT Id, Name FROM Account’);
}
global void execute(Database.BatchableContext BC, List<Account> scope) {
for (Account acc : scope) {
acc.Name = acc.Name + ‘ – Updated’;
}
update scope;
}
global void finish(Database.BatchableContext BC) {
System.debug(‘Batch Job Completed’);
}
}
After running the batch job, you can use Test.startTest() and Test.stopTest() to isolate the batch job’s behavior and to verify its results. For example, you can use System.assert() statements to verify that the batch job processed the expected number of records, or that it updated records as expected.
Salesforce, the world’s leading customer relationship management (CRM) platform, offers a multitude of tools to streamline business processes and enhance productivity. Among these, Apex stands out as the powerhouse of Salesforce automation.
As Salesforce’s proprietary programming language, Apex provides unmatched flexibility and power, enabling developers to create sophisticated and customized automations that go beyond the capabilities of point-and-click tools like Flow Builder and Process Builder. In this blog, we will delve into what makes Apex an indispensable tool for Salesforce automation, its key features, benefits, and some practical use cases.
Apex is an object-oriented programming language that allows developers to execute flow and transaction control statements on the Salesforce platform. It is designed to help developers add business logic to most system events, including button clicks, related record updates, and Visualforce pages.
Get Started
Share a few details about your goals: a Mirketa consultant will follow up within one business day.