@salesforce/afv-skills 1.8.0 → 1.9.0

package/skills/handling-sf-data/assets/factories/case-factory.apex

@@ -0,0 +1,237 @@
+/**
+ * Test Data Factory for Case records
+ * Supports bulk creation with Account/Contact relationships and priority variations
+ *
+ * Usage:
+ *   List<Case> cases = TestDataFactory_Case.create(200);
+ *   List<Case> casesForAccount = TestDataFactory_Case.createForAccount(50, accountId);
+ *   List<Case> highPriority = TestDataFactory_Case.createWithPriority(100, 'High');
+ */
+public class TestDataFactory_Case {
+
+    private static final String DEFAULT_SUBJECT_PREFIX = 'Test Case ';
+    private static final String DEFAULT_STATUS = 'New';
+    private static final String DEFAULT_PRIORITY = 'Medium';
+    private static final String DEFAULT_ORIGIN = 'Web';
+
+    /**
+     * Create and insert Case records (creates parent Account automatically)
+     * @param count Number of records to create
+     * @return List of inserted Case records with IDs
+     */
+    public static List<Case> create(Integer count) {
+        return create(count, true);
+    }
+
+    /**
+     * Create Case records with insert option
+     * @param count Number of records to create
+     * @param doInsert Whether to insert records
+     * @return List of Case records
+     */
+    public static List<Case> create(Integer count, Boolean doInsert) {
+        // Create parent Account and Contact
+        Account parentAccount = new Account(Name = 'Test Parent Account for Cases');
+        insert parentAccount;
+
+        Contact parentContact = new Contact(
+            FirstName = 'Test',
+            LastName = 'CaseContact',
+            AccountId = parentAccount.Id,
+            Email = 'casecontact@testfactory.example.com'
+        );
+        insert parentContact;
+
+        return createForAccountAndContact(count, parentAccount.Id, parentContact.Id, doInsert);
+    }
+
+    /**
+     * Create Case records for a specific Account
+     * @param count Number of records to create
+     * @param accountId Parent Account ID
+     * @return List of inserted Case records
+     */
+    public static List<Case> createForAccount(Integer count, Id accountId) {
+        return createForAccount(count, accountId, true);
+    }
+
+    /**
+     * Create Case records for a specific Account with insert option
+     * @param count Number of records to create
+     * @param accountId Parent Account ID
+     * @param doInsert Whether to insert records
+     * @return List of Case records
+     */
+    public static List<Case> createForAccount(Integer count, Id accountId, Boolean doInsert) {
+        List<Case> records = new List<Case>();
+        for (Integer i = 0; i < count; i++) {
+            records.add(buildRecord(i, accountId, null));
+        }
+        if (doInsert && !records.isEmpty()) {
+            insert records;
+        }
+        return records;
+    }
+
+    /**
+     * Create Case records for specific Account and Contact
+     * @param count Number of records to create
+     * @param accountId Parent Account ID
+     * @param contactId Parent Contact ID
+     * @param doInsert Whether to insert records
+     * @return List of Case records
+     */
+    public static List<Case> createForAccountAndContact(Integer count, Id accountId, Id contactId, Boolean doInsert) {
+        List<Case> records = new List<Case>();
+        for (Integer i = 0; i < count; i++) {
+            records.add(buildRecord(i, accountId, contactId));
+        }
+        if (doInsert && !records.isEmpty()) {
+            insert records;
+        }
+        return records;
+    }
+
+    /**
+     * Create Case records with a specific Priority
+     * @param count Number of records to create
+     * @param priority Priority picklist value (Low, Medium, High)
+     * @return List of inserted Case records
+     */
+    public static List<Case> createWithPriority(Integer count, String priority) {
+        Account parentAccount = new Account(Name = 'Test Account for ' + priority + ' Priority Cases');
+        insert parentAccount;
+
+        List<Case> records = new List<Case>();
+        for (Integer i = 0; i < count; i++) {
+            Case c = buildRecord(i, parentAccount.Id, null);
+            c.Priority = priority;
+            records.add(c);
+        }
+        if (!records.isEmpty()) {
+            insert records;
+        }
+        return records;
+    }
+
+    /**
+     * Create Case records with a specific Status
+     * @param count Number of records to create
+     * @param status Status picklist value
+     * @return List of inserted Case records
+     */
+    public static List<Case> createWithStatus(Integer count, String status) {
+        Account parentAccount = new Account(Name = 'Test Account for ' + status + ' Cases');
+        insert parentAccount;
+
+        List<Case> records = new List<Case>();
+        for (Integer i = 0; i < count; i++) {
+            Case c = buildRecord(i, parentAccount.Id, null);
+            c.Status = status;
+            records.add(c);
+        }
+        if (!records.isEmpty()) {
+            insert records;
+        }
+        return records;
+    }
+
+    /**
+     * Create Cases with varied Types for categorization testing
+     * @param count Number of records to create
+     * @param accountId Parent Account ID
+     * @return List of inserted Case records with varied types
+     */
+    public static List<Case> createWithVariedTypes(Integer count, Id accountId) {
+        List<String> types = new List<String>{
+            'Mechanical', 'Electrical', 'Electronic', 'Structural', 'Other',
+            'Feature Request', 'Question', 'Problem'
+        };
+
+        List<Case> records = new List<Case>();
+        for (Integer i = 0; i < count; i++) {
+            Case c = buildRecord(i, accountId, null);
+            c.Type = types[Math.mod(i, types.size())];
+            records.add(c);
+        }
+
+        if (!records.isEmpty()) {
+            insert records;
+        }
+        return records;
+    }
+
+    /**
+     * Create escalated Cases for escalation rule testing
+     * @param count Number of records to create
+     * @return List of inserted escalated Case records
+     */
+    public static List<Case> createEscalated(Integer count) {
+        Account parentAccount = new Account(Name = 'Test Account for Escalated Cases');
+        insert parentAccount;
+
+        List<Case> records = new List<Case>();
+        for (Integer i = 0; i < count; i++) {
+            Case c = buildRecord(i, parentAccount.Id, null);
+            c.Priority = 'High';
+            c.IsEscalated = true;
+            records.add(c);
+        }
+        if (!records.isEmpty()) {
+            insert records;
+        }
+        return records;
+    }
+
+    /**
+     * Build a single Case record with default values
+     * @param index Record index for unique naming
+     * @param accountId Parent Account ID
+     * @param contactId Parent Contact ID (optional)
+     * @return Case record (not inserted)
+     */
+    private static Case buildRecord(Integer index, Id accountId, Id contactId) {
+        String indexStr = String.valueOf(index).leftPad(5, '0');
+
+        return new Case(
+            Subject = DEFAULT_SUBJECT_PREFIX + indexStr,
+            AccountId = accountId,
+            ContactId = contactId,
+            Status = DEFAULT_STATUS,
+            Priority = DEFAULT_PRIORITY,
+            Origin = DEFAULT_ORIGIN,
+            Type = 'Problem',
+            Reason = 'User didn\'t attend training',
+            Description = 'Test case created by TestDataFactory for automated testing. Case index: ' + index,
+            SuppliedName = 'Test Supplied Name ' + index,
+            SuppliedEmail = 'supplied' + index + '@testfactory.example.com',
+            SuppliedPhone = '(555) 600-' + String.valueOf(1000 + index),
+            SuppliedCompany = 'Test Supplied Company ' + index
+        );
+    }
+
+    /**
+     * Get IDs of created records for cleanup
+     * @param records List of Case records
+     * @return Set of Case IDs
+     */
+    public static Set<Id> getIds(List<Case> records) {
+        Set<Id> ids = new Set<Id>();
+        for (Case c : records) {
+            if (c.Id != null) {
+                ids.add(c.Id);
+            }
+        }
+        return ids;
+    }
+
+    /**
+     * Delete records by IDs (cleanup utility)
+     * @param recordIds Set of Case IDs to delete
+     */
+    public static void cleanup(Set<Id> recordIds) {
+        if (!recordIds.isEmpty()) {
+            delete [SELECT Id FROM Case WHERE Id IN :recordIds];
+        }
+    }
+}

package/skills/handling-sf-data/assets/factories/contact-factory.apex

@@ -0,0 +1,168 @@
+/**
+ * Test Data Factory for Contact records
+ * Supports bulk creation with Account relationships
+ *
+ * Usage:
+ *   List<Contact> contacts = TestDataFactory_Contact.create(200);
+ *   List<Contact> contactsForAccount = TestDataFactory_Contact.createForAccount(50, accountId);
+ *   List<Contact> contactsNoInsert = TestDataFactory_Contact.create(200, false);
+ */
+public class TestDataFactory_Contact {
+
+    private static final String DEFAULT_FIRST_NAME_PREFIX = 'Test';
+    private static final String DEFAULT_LAST_NAME_PREFIX = 'Contact';
+    private static final String DEFAULT_EMAIL_DOMAIN = 'testfactory.example.com';
+
+    /**
+     * Create and insert Contact records (creates parent Account automatically)
+     * @param count Number of records to create
+     * @return List of inserted Contact records with IDs
+     */
+    public static List<Contact> create(Integer count) {
+        return create(count, true);
+    }
+
+    /**
+     * Create Contact records with insert option
+     * @param count Number of records to create
+     * @param doInsert Whether to insert records
+     * @return List of Contact records
+     */
+    public static List<Contact> create(Integer count, Boolean doInsert) {
+        // Create a parent Account for orphan protection
+        Account parentAccount = new Account(Name = 'Test Parent Account for Contacts');
+        insert parentAccount;
+
+        return createForAccount(count, parentAccount.Id, doInsert);
+    }
+
+    /**
+     * Create Contact records for a specific Account
+     * @param count Number of records to create
+     * @param accountId Parent Account ID
+     * @return List of inserted Contact records
+     */
+    public static List<Contact> createForAccount(Integer count, Id accountId) {
+        return createForAccount(count, accountId, true);
+    }
+
+    /**
+     * Create Contact records for a specific Account with insert option
+     * @param count Number of records to create
+     * @param accountId Parent Account ID
+     * @param doInsert Whether to insert records
+     * @return List of Contact records
+     */
+    public static List<Contact> createForAccount(Integer count, Id accountId, Boolean doInsert) {
+        List<Contact> records = new List<Contact>();
+        for (Integer i = 0; i < count; i++) {
+            records.add(buildRecord(i, accountId));
+        }
+        if (doInsert && !records.isEmpty()) {
+            insert records;
+        }
+        return records;
+    }
+
+    /**
+     * Create Contacts distributed across multiple Accounts
+     * @param accountIds List of Account IDs
+     * @param contactsPerAccount Number of Contacts per Account
+     * @return List of inserted Contact records
+     */
+    public static List<Contact> createForAccounts(List<Id> accountIds, Integer contactsPerAccount) {
+        List<Contact> records = new List<Contact>();
+        Integer globalIndex = 0;
+
+        for (Id accountId : accountIds) {
+            for (Integer i = 0; i < contactsPerAccount; i++) {
+                records.add(buildRecord(globalIndex++, accountId));
+            }
+        }
+
+        if (!records.isEmpty()) {
+            insert records;
+        }
+        return records;
+    }
+
+    /**
+     * Create Contacts with varied titles for role-based testing
+     * @param count Number of records to create
+     * @param accountId Parent Account ID
+     * @return List of inserted Contact records with varied titles
+     */
+    public static List<Contact> createWithVariedTitles(Integer count, Id accountId) {
+        List<String> titles = new List<String>{
+            'CEO', 'CFO', 'CTO', 'VP Sales', 'VP Marketing',
+            'Director', 'Manager', 'Senior Developer', 'Analyst', 'Consultant'
+        };
+
+        List<Contact> records = new List<Contact>();
+        for (Integer i = 0; i < count; i++) {
+            Contact con = buildRecord(i, accountId);
+            con.Title = titles[Math.mod(i, titles.size())];
+            records.add(con);
+        }
+
+        if (!records.isEmpty()) {
+            insert records;
+        }
+        return records;
+    }
+
+    /**
+     * Build a single Contact record with default values
+     * @param index Record index for unique naming
+     * @param accountId Parent Account ID
+     * @return Contact record (not inserted)
+     */
+    private static Contact buildRecord(Integer index, Id accountId) {
+        String indexStr = String.valueOf(index).leftPad(5, '0');
+        String firstName = DEFAULT_FIRST_NAME_PREFIX + indexStr;
+        String lastName = DEFAULT_LAST_NAME_PREFIX + indexStr;
+
+        return new Contact(
+            FirstName = firstName,
+            LastName = lastName,
+            AccountId = accountId,
+            Email = firstName.toLowerCase() + '.' + lastName.toLowerCase() + '@' + DEFAULT_EMAIL_DOMAIN,
+            Phone = '(555) 200-' + String.valueOf(1000 + index),
+            MobilePhone = '(555) 300-' + String.valueOf(1000 + index),
+            Title = 'Test Title',
+            Department = 'Test Department',
+            MailingStreet = '456 Contact Ave',
+            MailingCity = 'San Francisco',
+            MailingState = 'CA',
+            MailingPostalCode = '94103',
+            MailingCountry = 'USA',
+            Birthdate = Date.today().addYears(-30).addDays(index),
+            Description = 'Test contact created by TestDataFactory for automated testing'
+        );
+    }
+
+    /**
+     * Get IDs of created records for cleanup
+     * @param records List of Contact records
+     * @return Set of Contact IDs
+     */
+    public static Set<Id> getIds(List<Contact> records) {
+        Set<Id> ids = new Set<Id>();
+        for (Contact con : records) {
+            if (con.Id != null) {
+                ids.add(con.Id);
+            }
+        }
+        return ids;
+    }
+
+    /**
+     * Delete records by IDs (cleanup utility)
+     * @param recordIds Set of Contact IDs to delete
+     */
+    public static void cleanup(Set<Id> recordIds) {
+        if (!recordIds.isEmpty()) {
+            delete [SELECT Id FROM Contact WHERE Id IN :recordIds];
+        }
+    }
+}

package/skills/handling-sf-data/assets/factories/custom-object-factory.apex

@@ -0,0 +1,260 @@
+/**
+ * Test Data Factory Template for Custom Objects
+ *
+ * INSTRUCTIONS:
+ * 1. Copy this file and rename to TestDataFactory_[YourObject].cls
+ * 2. Replace {{ObjectName}} with your object API name (e.g., Invoice__c)
+ * 3. Replace {{ObjectLabel}} with display name (e.g., Invoice)
+ * 4. Update buildRecord() with your object's fields
+ * 5. Add object-specific creation methods as needed
+ *
+ * Usage:
+ *   List<{{ObjectName}}> records = TestDataFactory_{{ObjectLabel}}.create(200);
+ *   List<{{ObjectName}}> recordsNoInsert = TestDataFactory_{{ObjectLabel}}.create(200, false);
+ */
+public class TestDataFactory_{{ObjectLabel}} {
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // CONFIGURATION - Update these for your object
+    // ═══════════════════════════════════════════════════════════════════════
+
+    private static final String DEFAULT_NAME_PREFIX = 'Test {{ObjectLabel}} ';
+
+    // Add default values for required picklist fields
+    // private static final String DEFAULT_STATUS = 'Draft';
+    // private static final String DEFAULT_TYPE = 'Standard';
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // STANDARD FACTORY METHODS
+    // ═══════════════════════════════════════════════════════════════════════
+
+    /**
+     * Create and insert records with default values
+     * @param count Number of records to create
+     * @return List of inserted records with IDs
+     */
+    public static List<{{ObjectName}}> create(Integer count) {
+        return create(count, true);
+    }
+
+    /**
+     * Create records with insert option
+     * @param count Number of records to create
+     * @param doInsert Whether to insert records
+     * @return List of records
+     */
+    public static List<{{ObjectName}}> create(Integer count, Boolean doInsert) {
+        List<{{ObjectName}}> records = new List<{{ObjectName}}>();
+        for (Integer i = 0; i < count; i++) {
+            records.add(buildRecord(i));
+        }
+        if (doInsert && !records.isEmpty()) {
+            insert records;
+        }
+        return records;
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // RELATIONSHIP METHODS - Uncomment and modify if object has lookups
+    // ═══════════════════════════════════════════════════════════════════════
+
+    /**
+     * Create records for a specific parent Account
+     * Uncomment if your object has an Account lookup
+     */
+    /*
+    public static List<{{ObjectName}}> createForAccount(Integer count, Id accountId) {
+        return createForAccount(count, accountId, true);
+    }
+
+    public static List<{{ObjectName}}> createForAccount(Integer count, Id accountId, Boolean doInsert) {
+        List<{{ObjectName}}> records = new List<{{ObjectName}}>();
+        for (Integer i = 0; i < count; i++) {
+            {{ObjectName}} record = buildRecord(i);
+            record.Account__c = accountId;  // Update with your lookup field API name
+            records.add(record);
+        }
+        if (doInsert && !records.isEmpty()) {
+            insert records;
+        }
+        return records;
+    }
+    */
+
+    /**
+     * Create records for a specific parent (generic lookup)
+     * Uncomment and modify for your parent object
+     */
+    /*
+    public static List<{{ObjectName}}> createForParent(Integer count, Id parentId) {
+        List<{{ObjectName}}> records = new List<{{ObjectName}}>();
+        for (Integer i = 0; i < count; i++) {
+            {{ObjectName}} record = buildRecord(i);
+            record.Parent__c = parentId;  // Update with your lookup field API name
+            records.add(record);
+        }
+        if (!records.isEmpty()) {
+            insert records;
+        }
+        return records;
+    }
+    */
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // VARIATION METHODS - Add methods for specific field variations
+    // ═══════════════════════════════════════════════════════════════════════
+
+    /**
+     * Create records with a specific Status
+     * Uncomment if your object has a Status picklist
+     */
+    /*
+    public static List<{{ObjectName}}> createWithStatus(Integer count, String status) {
+        List<{{ObjectName}}> records = new List<{{ObjectName}}>();
+        for (Integer i = 0; i < count; i++) {
+            {{ObjectName}} record = buildRecord(i);
+            record.Status__c = status;  // Update with your status field API name
+            records.add(record);
+        }
+        if (!records.isEmpty()) {
+            insert records;
+        }
+        return records;
+    }
+    */
+
+    /**
+     * Create records with varied values for comprehensive testing
+     * Modify for your object's key picklist fields
+     */
+    /*
+    public static List<{{ObjectName}}> createWithVariedValues(Integer count) {
+        List<String> statuses = new List<String>{'Draft', 'Active', 'Complete', 'Cancelled'};
+
+        List<{{ObjectName}}> records = new List<{{ObjectName}}>();
+        for (Integer i = 0; i < count; i++) {
+            {{ObjectName}} record = buildRecord(i);
+            record.Status__c = statuses[Math.mod(i, statuses.size())];
+            records.add(record);
+        }
+
+        if (!records.isEmpty()) {
+            insert records;
+        }
+        return records;
+    }
+    */
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // RECORD BUILDER - Customize for your object's fields
+    // ═══════════════════════════════════════════════════════════════════════
+
+    /**
+     * Build a single record with default values
+     *
+     * UPDATE THIS METHOD with your object's fields:
+     * 1. Add all required fields
+     * 2. Add fields needed for testing
+     * 3. Use realistic test values
+     *
+     * @param index Record index for unique naming
+     * @return Record (not inserted)
+     */
+    private static {{ObjectName}} buildRecord(Integer index) {
+        String indexStr = String.valueOf(index).leftPad(5, '0');
+
+        return new {{ObjectName}}(
+            Name = DEFAULT_NAME_PREFIX + indexStr
+
+            // ─────────────────────────────────────────────────────────────
+            // ADD YOUR FIELDS BELOW
+            // ─────────────────────────────────────────────────────────────
+
+            // Text fields
+            // , Description__c = 'Test {{ObjectLabel}} created by TestDataFactory'
+
+            // Picklist fields (use valid picklist values)
+            // , Status__c = DEFAULT_STATUS
+            // , Type__c = DEFAULT_TYPE
+
+            // Number fields
+            // , Amount__c = 1000 + (index * 100)
+            // , Quantity__c = 1 + index
+
+            // Date fields
+            // , StartDate__c = Date.today()
+            // , EndDate__c = Date.today().addDays(30 + index)
+
+            // DateTime fields
+            // , ScheduledDateTime__c = DateTime.now().addDays(index)
+
+            // Checkbox fields
+            // , IsActive__c = true
+
+            // Currency fields
+            // , TotalAmount__c = 10000.00 + (index * 500)
+
+            // Percent fields
+            // , DiscountPercent__c = 10 + index
+
+            // Email fields
+            // , ContactEmail__c = 'test' + index + '@testfactory.example.com'
+
+            // Phone fields
+            // , ContactPhone__c = '(555) 900-' + String.valueOf(1000 + index)
+
+            // URL fields
+            // , Website__c = 'https://test' + index + '.example.com'
+
+            // Lookup fields (requires parent record ID)
+            // , Account__c = accountId
+            // , Contact__c = contactId
+
+            // ─────────────────────────────────────────────────────────────
+        );
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // UTILITY METHODS
+    // ═══════════════════════════════════════════════════════════════════════
+
+    /**
+     * Get IDs of created records for cleanup
+     * @param records List of records
+     * @return Set of record IDs
+     */
+    public static Set<Id> getIds(List<{{ObjectName}}> records) {
+        Set<Id> ids = new Set<Id>();
+        for ({{ObjectName}} record : records) {
+            if (record.Id != null) {
+                ids.add(record.Id);
+            }
+        }
+        return ids;
+    }
+
+    /**
+     * Delete records by IDs (cleanup utility)
+     * @param recordIds Set of record IDs to delete
+     */
+    public static void cleanup(Set<Id> recordIds) {
+        if (!recordIds.isEmpty()) {
+            delete [SELECT Id FROM {{ObjectName}} WHERE Id IN :recordIds];
+        }
+    }
+
+    /**
+     * Delete records by Name pattern (cleanup utility)
+     * @param namePattern LIKE pattern (e.g., 'Test%')
+     */
+    public static void cleanupByName(String namePattern) {
+        List<{{ObjectName}}> records = [
+            SELECT Id FROM {{ObjectName}}
+            WHERE Name LIKE :namePattern
+            LIMIT 10000
+        ];
+        if (!records.isEmpty()) {
+            delete records;
+        }
+    }
+}