@salesforce/afv-skills 1.8.0 → 1.9.0

package/skills/running-apex-tests/assets/stub-provider-example.cls

@@ -0,0 +1,364 @@
+/**
+ * StubProvider Examples
+ *
+ * The Stub API enables dynamic mocking of interfaces and virtual classes.
+ * Use when you need conditional logic or method tracking in your mocks.
+ *
+ * See: references/mocking-patterns.md for detailed patterns and usage guidance
+ */
+
+// ═══════════════════════════════════════════════════════════════════════════
+// EXAMPLE 1: Simple StubProvider for Interface
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * Interface to be stubbed
+ */
+public interface IAccountService {
+    Account getAccount(Id accountId);
+    List<Account> getAccounts(Set<Id> accountIds);
+    Integer getAccountCount();
+    void updateAccount(Account acc);
+}
+
+/**
+ * Basic stub implementation with configurable responses
+ */
+@IsTest
+public class AccountServiceStub implements System.StubProvider {
+
+    // Track method calls for verification
+    public List<String> calledMethods = new List<String>();
+    public Map<String, List<Object>> methodParams = new Map<String, List<Object>>();
+
+    // Configurable responses
+    private Map<String, Object> responses = new Map<String, Object>();
+
+    /**
+     * Configure what a method should return
+     */
+    public AccountServiceStub whenCalled(String methodName, Object response) {
+        responses.put(methodName, response);
+        return this;
+    }
+
+    /**
+     * Required StubProvider method
+     */
+    public Object handleMethodCall(
+        Object stubbedObject,
+        String stubbedMethodName,
+        Type returnType,
+        List<Type> paramTypes,
+        List<String> paramNames,
+        List<Object> paramValues
+    ) {
+        // Track this call
+        calledMethods.add(stubbedMethodName);
+        methodParams.put(stubbedMethodName, paramValues);
+
+        // Return configured response if available
+        if (responses.containsKey(stubbedMethodName)) {
+            return responses.get(stubbedMethodName);
+        }
+
+        // Default responses based on return type
+        if (returnType == Account.class) {
+            return new Account(Id = generateFakeId(), Name = 'Default Stub Account');
+        }
+        if (returnType == List<Account>.class) {
+            return new List<Account>{
+                new Account(Id = generateFakeId(), Name = 'Stub Account 1')
+            };
+        }
+        if (returnType == Integer.class) {
+            return 0;
+        }
+
+        return null;
+    }
+
+    /**
+     * Verify a method was called
+     */
+    public Boolean wasCalled(String methodName) {
+        return calledMethods.contains(methodName);
+    }
+
+    /**
+     * Get call count for a method
+     */
+    public Integer getCallCount(String methodName) {
+        Integer count = 0;
+        for (String called : calledMethods) {
+            if (called == methodName) {
+                count++;
+            }
+        }
+        return count;
+    }
+
+    // Fake ID generator
+    private static Integer idCounter = 1;
+    private static Id generateFakeId() {
+        String idBody = String.valueOf(idCounter++).leftPad(12, '0');
+        return Id.valueOf('001' + idBody);
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// EXAMPLE 2: Using the Stub in Tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+@IsTest
+private class AccountServiceStubTest {
+
+    @IsTest
+    static void testWithConfiguredResponse() {
+        // Arrange - Configure stub responses
+        AccountServiceStub stub = new AccountServiceStub()
+            .whenCalled('getAccountCount', 42)
+            .whenCalled('getAccount', new Account(Name = 'Configured Account'));
+
+        // Create stubbed instance
+        IAccountService service = (IAccountService) Test.createStub(
+            IAccountService.class,
+            stub
+        );
+
+        // Act
+        Test.startTest();
+        Integer count = service.getAccountCount();
+        Account acc = service.getAccount(null);
+        Test.stopTest();
+
+        // Assert - Verify responses
+        Assert.areEqual(42, count, 'Should return configured count');
+        Assert.areEqual('Configured Account', acc.Name, 'Should return configured account');
+
+        // Assert - Verify calls were tracked
+        Assert.isTrue(stub.wasCalled('getAccountCount'), 'getAccountCount was called');
+        Assert.isTrue(stub.wasCalled('getAccount'), 'getAccount was called');
+        Assert.areEqual(1, stub.getCallCount('getAccountCount'), 'Called once');
+    }
+
+    @IsTest
+    static void testDefaultResponses() {
+        // Arrange - No configured responses
+        AccountServiceStub stub = new AccountServiceStub();
+        IAccountService service = (IAccountService) Test.createStub(
+            IAccountService.class,
+            stub
+        );
+
+        // Act
+        Test.startTest();
+        Account acc = service.getAccount(null);
+        Test.stopTest();
+
+        // Assert - Verify default response
+        Assert.isNotNull(acc, 'Should return default account');
+        Assert.areEqual('Default Stub Account', acc.Name, 'Should have default name');
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// EXAMPLE 3: Conditional StubProvider
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * Stub with conditional logic based on parameters
+ */
+@IsTest
+public class ConditionalStub implements System.StubProvider {
+
+    public Object handleMethodCall(
+        Object stubbedObject,
+        String stubbedMethodName,
+        Type returnType,
+        List<Type> paramTypes,
+        List<String> paramNames,
+        List<Object> paramValues
+    ) {
+        // Conditional response based on method and params
+        if (stubbedMethodName == 'getAccount') {
+            Id requestedId = (Id) paramValues[0];
+
+            // Return different accounts based on ID pattern
+            String idStr = String.valueOf(requestedId);
+            if (idStr.startsWith('001')) {
+                return new Account(Id = requestedId, Name = 'Standard Account');
+            } else if (idStr.startsWith('0018')) {
+                return new Account(Id = requestedId, Name = 'Person Account');
+            }
+        }
+
+        if (stubbedMethodName == 'getAccountCount') {
+            // Simulate different counts for different scenarios
+            return 100;
+        }
+
+        return null;
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// EXAMPLE 4: Exception-Throwing Stub
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * Stub that throws exceptions for error testing
+ */
+@IsTest
+public class ErrorStub implements System.StubProvider {
+
+    private String methodToFail;
+    private String errorMessage;
+
+    public ErrorStub failOn(String methodName, String message) {
+        this.methodToFail = methodName;
+        this.errorMessage = message;
+        return this;
+    }
+
+    public Object handleMethodCall(
+        Object stubbedObject,
+        String stubbedMethodName,
+        Type returnType,
+        List<Type> paramTypes,
+        List<String> paramNames,
+        List<Object> paramValues
+    ) {
+        if (stubbedMethodName == methodToFail) {
+            throw new AuraHandledException(errorMessage);
+        }
+        return null;
+    }
+}
+
+@IsTest
+private class ErrorStubTest {
+
+    @IsTest
+    static void testErrorHandling() {
+        // Arrange
+        ErrorStub stub = new ErrorStub().failOn('getAccount', 'Account not found');
+        IAccountService service = (IAccountService) Test.createStub(
+            IAccountService.class,
+            stub
+        );
+
+        // Act/Assert
+        try {
+            service.getAccount(null);
+            Assert.fail('Expected AuraHandledException');
+        } catch (AuraHandledException e) {
+            Assert.areEqual('Account not found', e.getMessage());
+        }
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// EXAMPLE 5: Universal Mock (Flexible Stub)
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * Highly flexible stub that can mock any interface
+ *
+ * Inspired by: Suraj Pillai's UniversalMock pattern
+ */
+@IsTest
+public class UniversalMock implements System.StubProvider {
+
+    // Store method -> return value mappings
+    private Map<String, Object> returnValues = new Map<String, Object>();
+
+    // Store method -> exception mappings
+    private Map<String, Exception> exceptions = new Map<String, Exception>();
+
+    // Track all calls
+    private List<MethodCall> calls = new List<MethodCall>();
+
+    public class MethodCall {
+        public String methodName;
+        public List<Object> arguments;
+        public Datetime calledAt;
+
+        public MethodCall(String methodName, List<Object> arguments) {
+            this.methodName = methodName;
+            this.arguments = arguments;
+            this.calledAt = Datetime.now();
+        }
+    }
+
+    /**
+     * Configure return value for a method
+     */
+    public UniversalMock setReturnValue(String methodName, Object value) {
+        returnValues.put(methodName, value);
+        return this;
+    }
+
+    /**
+     * Configure exception for a method
+     */
+    public UniversalMock throwException(String methodName, Exception e) {
+        exceptions.put(methodName, e);
+        return this;
+    }
+
+    public Object handleMethodCall(
+        Object stubbedObject,
+        String stubbedMethodName,
+        Type returnType,
+        List<Type> paramTypes,
+        List<String> paramNames,
+        List<Object> paramValues
+    ) {
+        // Track the call
+        calls.add(new MethodCall(stubbedMethodName, paramValues));
+
+        // Throw configured exception
+        if (exceptions.containsKey(stubbedMethodName)) {
+            throw exceptions.get(stubbedMethodName);
+        }
+
+        // Return configured value
+        if (returnValues.containsKey(stubbedMethodName)) {
+            return returnValues.get(stubbedMethodName);
+        }
+
+        // Return type-appropriate defaults
+        if (returnType == Boolean.class) return false;
+        if (returnType == Integer.class) return 0;
+        if (returnType == String.class) return '';
+        if (returnType == List<SObject>.class) return new List<SObject>();
+
+        return null;
+    }
+
+    /**
+     * Get all calls to a specific method
+     */
+    public List<MethodCall> getCalls(String methodName) {
+        List<MethodCall> result = new List<MethodCall>();
+        for (MethodCall call : calls) {
+            if (call.methodName == methodName) {
+                result.add(call);
+            }
+        }
+        return result;
+    }
+
+    /**
+     * Verify method was called with specific arguments
+     */
+    public Boolean wasCalledWith(String methodName, List<Object> expectedArgs) {
+        for (MethodCall call : getCalls(methodName)) {
+            if (call.arguments.equals(expectedArgs)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

package/skills/running-apex-tests/assets/test-data-factory.cls

@@ -0,0 +1,328 @@
+/**
+ * @description Test Data Factory for creating consistent test data across all test classes.
+ *              Use this pattern to avoid hardcoded test data and ensure test isolation.
+ *
+ * USAGE:
+ *   List<Account> accounts = TestDataFactory.createAccounts(5);
+ *   insert accounts;
+ *
+ *   // Or with auto-insert:
+ *   List<Account> accounts = TestDataFactory.createAndInsertAccounts(5);
+ *
+ * @created     {{Date}}
+ */
+@IsTest
+public class TestDataFactory {
+
+    // ═══════════════════════════════════════════════════════════════════════════
+    // ACCOUNT METHODS
+    // ═══════════════════════════════════════════════════════════════════════════
+
+    /**
+     * @description Creates Account records without inserting
+     * @param count Number of accounts to create
+     * @return List of Account records (not inserted)
+     */
+    public static List<Account> createAccounts(Integer count) {
+        List<Account> accounts = new List<Account>();
+        for (Integer i = 0; i < count; i++) {
+            accounts.add(new Account(
+                Name = 'Test Account ' + i,
+                Industry = 'Technology',
+                BillingStreet = '123 Test Street',
+                BillingCity = 'San Francisco',
+                BillingState = 'CA',
+                BillingPostalCode = '94105',
+                BillingCountry = 'USA',
+                Phone = '555-000-' + String.valueOf(i).leftPad(4, '0'),
+                Website = 'https://testaccount' + i + '.example.com'
+            ));
+        }
+        return accounts;
+    }
+
+    /**
+     * @description Creates and inserts Account records
+     * @param count Number of accounts to create
+     * @return List of inserted Account records
+     */
+    public static List<Account> createAndInsertAccounts(Integer count) {
+        List<Account> accounts = createAccounts(count);
+        insert accounts;
+        return accounts;
+    }
+
+    /**
+     * @description Creates Account with specific attributes
+     * @param name Account name
+     * @param industry Industry value
+     * @return Account record (not inserted)
+     */
+    public static Account createAccount(String name, String industry) {
+        return new Account(
+            Name = name,
+            Industry = industry,
+            BillingCity = 'San Francisco',
+            BillingState = 'CA',
+            BillingCountry = 'USA'
+        );
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════════
+    // CONTACT METHODS
+    // ═══════════════════════════════════════════════════════════════════════════
+
+    /**
+     * @description Creates Contact records without inserting
+     * @param count Number of contacts to create
+     * @param accountId Parent account ID
+     * @return List of Contact records (not inserted)
+     */
+    public static List<Contact> createContacts(Integer count, Id accountId) {
+        List<Contact> contacts = new List<Contact>();
+        for (Integer i = 0; i < count; i++) {
+            contacts.add(new Contact(
+                FirstName = 'Test',
+                LastName = 'Contact ' + i,
+                AccountId = accountId,
+                Email = 'testcontact' + i + '@example.com',
+                Phone = '555-001-' + String.valueOf(i).leftPad(4, '0'),
+                Title = 'Test Title ' + i,
+                MailingStreet = '456 Test Ave',
+                MailingCity = 'San Francisco',
+                MailingState = 'CA',
+                MailingPostalCode = '94105',
+                MailingCountry = 'USA'
+            ));
+        }
+        return contacts;
+    }
+
+    /**
+     * @description Creates and inserts Contact records
+     * @param count Number of contacts to create
+     * @param accountId Parent account ID
+     * @return List of inserted Contact records
+     */
+    public static List<Contact> createAndInsertContacts(Integer count, Id accountId) {
+        List<Contact> contacts = createContacts(count, accountId);
+        insert contacts;
+        return contacts;
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════════
+    // LEAD METHODS
+    // ═══════════════════════════════════════════════════════════════════════════
+
+    /**
+     * @description Creates Lead records without inserting
+     * @param count Number of leads to create
+     * @return List of Lead records (not inserted)
+     */
+    public static List<Lead> createLeads(Integer count) {
+        List<Lead> leads = new List<Lead>();
+        for (Integer i = 0; i < count; i++) {
+            leads.add(new Lead(
+                FirstName = 'Test',
+                LastName = 'Lead ' + i,
+                Company = 'Test Company ' + i,
+                Email = 'testlead' + i + '@example.com',
+                Phone = '555-002-' + String.valueOf(i).leftPad(4, '0'),
+                Status = 'Open - Not Contacted',
+                Industry = 'Technology',
+                LeadSource = 'Web'
+            ));
+        }
+        return leads;
+    }
+
+    /**
+     * @description Creates and inserts Lead records
+     * @param count Number of leads to create
+     * @return List of inserted Lead records
+     */
+    public static List<Lead> createAndInsertLeads(Integer count) {
+        List<Lead> leads = createLeads(count);
+        insert leads;
+        return leads;
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════════
+    // OPPORTUNITY METHODS
+    // ═══════════════════════════════════════════════════════════════════════════
+
+    /**
+     * @description Creates Opportunity records without inserting
+     * @param count Number of opportunities to create
+     * @param accountId Parent account ID
+     * @return List of Opportunity records (not inserted)
+     */
+    public static List<Opportunity> createOpportunities(Integer count, Id accountId) {
+        List<Opportunity> opportunities = new List<Opportunity>();
+        for (Integer i = 0; i < count; i++) {
+            opportunities.add(new Opportunity(
+                Name = 'Test Opportunity ' + i,
+                AccountId = accountId,
+                StageName = 'Prospecting',
+                CloseDate = Date.today().addDays(30 + i),
+                Amount = 10000 * (i + 1)
+            ));
+        }
+        return opportunities;
+    }
+
+    /**
+     * @description Creates and inserts Opportunity records
+     * @param count Number of opportunities to create
+     * @param accountId Parent account ID
+     * @return List of inserted Opportunity records
+     */
+    public static List<Opportunity> createAndInsertOpportunities(Integer count, Id accountId) {
+        List<Opportunity> opportunities = createOpportunities(count, accountId);
+        insert opportunities;
+        return opportunities;
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════════
+    // CASE METHODS
+    // ═══════════════════════════════════════════════════════════════════════════
+
+    /**
+     * @description Creates Case records without inserting
+     * @param count Number of cases to create
+     * @param accountId Parent account ID (optional)
+     * @param contactId Related contact ID (optional)
+     * @return List of Case records (not inserted)
+     */
+    public static List<Case> createCases(Integer count, Id accountId, Id contactId) {
+        List<Case> cases = new List<Case>();
+        for (Integer i = 0; i < count; i++) {
+            cases.add(new Case(
+                Subject = 'Test Case ' + i,
+                Description = 'Test case description ' + i,
+                Status = 'New',
+                Priority = 'Medium',
+                Origin = 'Web',
+                AccountId = accountId,
+                ContactId = contactId
+            ));
+        }
+        return cases;
+    }
+
+    /**
+     * @description Creates and inserts Case records
+     * @param count Number of cases to create
+     * @param accountId Parent account ID (optional)
+     * @param contactId Related contact ID (optional)
+     * @return List of inserted Case records
+     */
+    public static List<Case> createAndInsertCases(Integer count, Id accountId, Id contactId) {
+        List<Case> cases = createCases(count, accountId, contactId);
+        insert cases;
+        return cases;
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════════
+    // USER METHODS (for System.runAs testing)
+    // ═══════════════════════════════════════════════════════════════════════════
+
+    /**
+     * @description Creates a test User with specified profile
+     *              Use with System.runAs() for permission testing
+     * @param profileName Name of the profile to assign
+     * @param uniqueIdentifier Unique string to avoid duplicate usernames
+     * @return User record (not inserted)
+     */
+    public static User createUser(String profileName, String uniqueIdentifier) {
+        Profile p = [SELECT Id FROM Profile WHERE Name = :profileName LIMIT 1];
+
+        String uniqueEmail = uniqueIdentifier + '@testuser.example.com';
+        String uniqueUsername = uniqueIdentifier + '@testuser.example.com.test';
+
+        return new User(
+            FirstName = 'Test',
+            LastName = 'User ' + uniqueIdentifier,
+            Email = uniqueEmail,
+            Username = uniqueUsername,
+            Alias = uniqueIdentifier.left(8),
+            ProfileId = p.Id,
+            TimeZoneSidKey = 'America/Los_Angeles',
+            LocaleSidKey = 'en_US',
+            EmailEncodingKey = 'UTF-8',
+            LanguageLocaleKey = 'en_US'
+        );
+    }
+
+    /**
+     * @description Creates and inserts a test User
+     * @param profileName Name of the profile to assign
+     * @param uniqueIdentifier Unique string to avoid duplicate usernames
+     * @return Inserted User record
+     */
+    public static User createAndInsertUser(String profileName, String uniqueIdentifier) {
+        User u = createUser(profileName, uniqueIdentifier);
+        insert u;
+        return u;
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════════
+    // CUSTOM OBJECT METHODS (Template)
+    // ═══════════════════════════════════════════════════════════════════════════
+
+    /**
+     * @description Template for custom object creation
+     *              Copy and modify for your custom objects
+     * @param count Number of records to create
+     * @return List of custom object records (not inserted)
+     */
+    /*
+    public static List<Custom_Object__c> createCustomObjects(Integer count) {
+        List<Custom_Object__c> records = new List<Custom_Object__c>();
+        for (Integer i = 0; i < count; i++) {
+            records.add(new Custom_Object__c(
+                Name = 'Test Record ' + i,
+                Custom_Field__c = 'Value ' + i
+                // Add more fields as needed
+            ));
+        }
+        return records;
+    }
+
+    public static List<Custom_Object__c> createAndInsertCustomObjects(Integer count) {
+        List<Custom_Object__c> records = createCustomObjects(count);
+        insert records;
+        return records;
+    }
+    */
+
+    // ═══════════════════════════════════════════════════════════════════════════
+    // UTILITY METHODS
+    // ═══════════════════════════════════════════════════════════════════════════
+
+    /**
+     * @description Generates a unique string for test data
+     *              Useful for avoiding unique constraint violations
+     * @return Unique string based on timestamp
+     */
+    public static String generateUniqueString() {
+        return String.valueOf(Datetime.now().getTime()) +
+               String.valueOf(Math.random()).substring(2, 8);
+    }
+
+    /**
+     * @description Creates a map of records by a specified field
+     *              Useful for test assertions
+     * @param records List of SObjects
+     * @param fieldName API name of the field to use as key
+     * @return Map with field values as keys
+     */
+    public static Map<String, SObject> createMapByField(List<SObject> records, String fieldName) {
+        Map<String, SObject> recordMap = new Map<String, SObject>();
+        for (SObject record : records) {
+            String keyValue = String.valueOf(record.get(fieldName));
+            recordMap.put(keyValue, record);
+        }
+        return recordMap;
+    }
+}