forcedotcom/sf-skills / plugins/builder/salesforce-development/skills/platform-apex-test-run
platform-apex-test-run
VerifiedApex test execution, coverage analysis, and test-fix loops with 120-point scoring. Use when the user runs Apex tests, checks code coverage, fixes failing tests, or touches *Test.cls / *_Test.cls files. DO NOT TRIGGER when writing Apex production code (use platform-apex-generate), Agentforce agent testing (use agentforce-test), or Jest/LWC tests (use experience-lwc-generate).
| File | Kind | Size |
|---|---|---|
| README.md | markdown | 3.0 KB |
| SKILL.md | skill md | 7.3 KB |
| assets/basic-test.cls | other | 12.7 KB |
| assets/bulk-test.cls | other | 11.3 KB |
| assets/dml-mock.cls | other | 12.6 KB |
| assets/mock-callout-test.cls | other | 13.6 KB |
| assets/stub-provider-example.cls | other | 12.2 KB |
| assets/test-data-factory.cls | other | 14.3 KB |
| references/cli-commands.md | markdown | 5.7 KB |
| references/mocking-patterns.md | markdown | 13.2 KB |
| references/performance-optimization.md | markdown | 7.5 KB |
| references/test-fix-loop.md | markdown | 2.0 KB |
| references/test-patterns.md | markdown | 4.2 KB |
| references/testing-best-practices.md | markdown | 15.6 KB |
| scripts/parse-test-results.py | script | 12.8 KB |
assets/dml-mock.cls
View on GitHub/**
* DML Mocking Framework
*
* Enables true unit testing by replacing database operations with in-memory tracking.
* Tests using this pattern run ~35x faster than tests with actual DML.
*
* See: references/mocking-patterns.md for usage guidance
*/
// ═══════════════════════════════════════════════════════════════════════════
// INTERFACE: IDML
// Define the contract for DML operations
// ═══════════════════════════════════════════════════════════════════════════
/**
* Interface for DML operations - enables dependency injection
*/
public interface IDML {
void doInsert(SObject record);
void doInsert(List<SObject> records);
void doUpdate(SObject record);
void doUpdate(List<SObject> records);
void doUpsert(SObject record);
void doUpsert(List<SObject> records);
void doDelete(SObject record);
void doDelete(List<SObject> records);
}
// ═══════════════════════════════════════════════════════════════════════════
// PRODUCTION: DML
// Performs actual database operations
// ═══════════════════════════════════════════════════════════════════════════
/**
* Production implementation performing real database operations
*/
public class DML implements IDML {
public void doInsert(SObject record) {
insert record;
}
public void doInsert(List<SObject> records) {
if (records != null && !records.isEmpty()) {
insert records;
}
}
public void doUpdate(SObject record) {
update record;
}
public void doUpdate(List<SObject> records) {
if (records != null && !records.isEmpty()) {
update records;
}
}
public void doUpsert(SObject record) {
upsert record;
}
public void doUpsert(List<SObject> records) {
if (records != null && !records.isEmpty()) {
upsert records;
}
}
public void doDelete(SObject record) {
delete record;
}
public void doDelete(List<SObject> records) {
if (records != null && !records.isEmpty()) {
delete records;
}
}
}
// ═══════════════════════════════════════════════════════════════════════════
// TEST MOCK: DMLMock
// Tracks operations without hitting the database
// ═══════════════════════════════════════════════════════════════════════════
/**
* Mock DML implementation for fast unit tests
*
* Usage:
* DMLMock.reset();
* MyService service = new MyService(new DMLMock());
* service.doSomething();
* Assert.areEqual(1, DMLMock.InsertedRecords.size());
*/
@IsTest
public class DMLMock implements IDML {
// ═══════════════════════════════════════════════════════════════════
// TRACKED OPERATIONS
// ═══════════════════════════════════════════════════════════════════
public static List<SObject> InsertedRecords = new List<SObject>();
public static List<SObject> UpdatedRecords = new List<SObject>();
public static List<SObject> UpsertedRecords = new List<SObject>();
public static List<SObject> DeletedRecords = new List<SObject>();
// Counter for generating unique fake IDs
private static Integer idCounter = 1;
// ═══════════════════════════════════════════════════════════════════
// DML OPERATIONS
// ═══════════════════════════════════════════════════════════════════
public void doInsert(SObject record) {
doInsert(new List<SObject>{ record });
}
public void doInsert(List<SObject> records) {
if (records == null || records.isEmpty()) {
return;
}
for (SObject record : records) {
// Generate fake ID to simulate database insert
if (record.Id == null) {
record.Id = generateFakeId(record.getSObjectType());
}
InsertedRecords.add(record);
}
}
public void doUpdate(SObject record) {
doUpdate(new List<SObject>{ record });
}
public void doUpdate(List<SObject> records) {
if (records != null && !records.isEmpty()) {
UpdatedRecords.addAll(records);
}
}
public void doUpsert(SObject record) {
doUpsert(new List<SObject>{ record });
}
public void doUpsert(List<SObject> records) {
if (records != null && !records.isEmpty()) {
for (SObject record : records) {
if (record.Id == null) {
record.Id = generateFakeId(record.getSObjectType());
}
}
UpsertedRecords.addAll(records);
}
}
public void doDelete(SObject record) {
doDelete(new List<SObject>{ record });
}
public void doDelete(List<SObject> records) {
if (records != null && !records.isEmpty()) {
DeletedRecords.addAll(records);
}
}
// ═══════════════════════════════════════════════════════════════════
// UTILITY METHODS
// ═══════════════════════════════════════════════════════════════════
/**
* Reset all tracked operations - call at start of each test
*/
public static void reset() {
InsertedRecords.clear();
UpdatedRecords.clear();
UpsertedRecords.clear();
DeletedRecords.clear();
idCounter = 1;
}
/**
* Generate a valid Salesforce ID for testing
* Uses the object's key prefix for realistic IDs
*/
private static Id generateFakeId(Schema.SObjectType sObjectType) {
String keyPrefix = sObjectType.getDescribe().getKeyPrefix();
if (keyPrefix == null) {
keyPrefix = '000'; // Fallback for objects without prefix
}
String idBody = String.valueOf(idCounter++).leftPad(12, '0');
return Id.valueOf(keyPrefix + idBody);
}
// ═══════════════════════════════════════════════════════════════════
// HELPER METHODS FOR ASSERTIONS
// ═══════════════════════════════════════════════════════════════════
/**
* Get inserted records of a specific SObject type
*/
public static List<SObject> getInsertedOfType(Schema.SObjectType sObjectType) {
List<SObject> result = new List<SObject>();
for (SObject record : InsertedRecords) {
if (record.getSObjectType() == sObjectType) {
result.add(record);
}
}
return result;
}
/**
* Get updated records of a specific SObject type
*/
public static List<SObject> getUpdatedOfType(Schema.SObjectType sObjectType) {
List<SObject> result = new List<SObject>();
for (SObject record : UpdatedRecords) {
if (record.getSObjectType() == sObjectType) {
result.add(record);
}
}
return result;
}
/**
* Get deleted records of a specific SObject type
*/
public static List<SObject> getDeletedOfType(Schema.SObjectType sObjectType) {
List<SObject> result = new List<SObject>();
for (SObject record : DeletedRecords) {
if (record.getSObjectType() == sObjectType) {
result.add(record);
}
}
return result;
}
/**
* Check if any records of a specific type were inserted
*/
public static Boolean wasInserted(Schema.SObjectType sObjectType) {
return !getInsertedOfType(sObjectType).isEmpty();
}
/**
* Check if any records of a specific type were updated
*/
public static Boolean wasUpdated(Schema.SObjectType sObjectType) {
return !getUpdatedOfType(sObjectType).isEmpty();
}
/**
* Check if any records of a specific type were deleted
*/
public static Boolean wasDeleted(Schema.SObjectType sObjectType) {
return !getDeletedOfType(sObjectType).isEmpty();
}
}
// ═══════════════════════════════════════════════════════════════════════════
// EXAMPLE: Service Using Injected DML
// ═══════════════════════════════════════════════════════════════════════════
/**
* Example service class demonstrating DML injection
*/
public class AccountService {
private IDML dml;
// Production constructor - uses real DML
public AccountService() {
this(new DML());
}
// Test constructor - accepts mock DML
@TestVisible
private AccountService(IDML dml) {
this.dml = dml;
}
public Id createAccount(Account acc) {
if (acc == null) {
throw new IllegalArgumentException('Account cannot be null');
}
dml.doInsert(acc);
return acc.Id;
}
public void updateAccounts(List<Account> accounts) {
dml.doUpdate(accounts);
}
}
// ═══════════════════════════════════════════════════════════════════════════
// EXAMPLE: Test Class Using DML Mock
// ═══════════════════════════════════════════════════════════════════════════
@IsTest
private class AccountServiceTest {
@IsTest
static void testCreateAccount_Success() {
// Arrange
DMLMock.reset();
AccountService service = new AccountService(new DMLMock());
Account testAcc = new Account(Name = 'Test Corp', Industry = 'Technology');
// Act
Test.startTest();
Id accountId = service.createAccount(testAcc);
Test.stopTest();
// Assert
Assert.isNotNull(accountId, 'Should have generated ID');
Assert.areEqual(1, DMLMock.InsertedRecords.size(), 'Should have 1 insert');
Assert.isTrue(DMLMock.wasInserted(Account.SObjectType), 'Account was inserted');
Account inserted = (Account) DMLMock.InsertedRecords[0];
Assert.areEqual('Test Corp', inserted.Name, 'Name should match');
Assert.areEqual('Technology', inserted.Industry, 'Industry should match');
}
@IsTest
static void testCreateAccount_NullInput_ThrowsException() {
// Arrange
DMLMock.reset();
AccountService service = new AccountService(new DMLMock());
// Act/Assert
try {
service.createAccount(null);
Assert.fail('Expected IllegalArgumentException');
} catch (IllegalArgumentException e) {
Assert.isTrue(e.getMessage().contains('null'), 'Error should mention null');
}
// Verify no DML occurred
Assert.areEqual(0, DMLMock.InsertedRecords.size(), 'No records should be inserted');
}
}
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| finishing-a-development-branchobra/superpowersUse when implementation is complete, all tests pass, and you need to decide how to integrate the work | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| systematic-debuggingobra/superpowersUse when encountering any bug, test failure, or unexpected behavior, before proposing fixes | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| test-driven-developmentobra/superpowersUse when implementing any feature or bugfix, before writing implementation code | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| skill-creatoranthropics/skillsCreate new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, edit, or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy. | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |