@salesforce/afv-skills 1.22.0 → 1.24.0

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

@@ -1,364 +0,0 @@
-/**
- * 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

@@ -1,328 +0,0 @@
-/**
- * @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;
-    }
-}