@salesforce/afv-skills 1.8.0 → 1.9.0

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

@@ -0,0 +1,275 @@
+/**
+ * Test Data Factory for Event records
+ * Supports bulk creation with polymorphic Who/What relationships and scheduling
+ *
+ * Usage:
+ *   List<Event> events = TestDataFactory_Event.create(200);
+ *   List<Event> eventsForContact = TestDataFactory_Event.createForWho(50, contactId);
+ *   List<Event> allDayEvents = TestDataFactory_Event.createAllDay(50);
+ */
+public class TestDataFactory_Event {
+
+    private static final String DEFAULT_SUBJECT_PREFIX = 'Test Event ';
+    private static final Integer DEFAULT_DURATION_MINUTES = 60;
+
+    /**
+     * Create and insert Event records (creates related Contact automatically)
+     * @param count Number of records to create
+     * @return List of inserted Event records with IDs
+     */
+    public static List<Event> create(Integer count) {
+        return create(count, true);
+    }
+
+    /**
+     * Create Event records with insert option
+     * @param count Number of records to create
+     * @param doInsert Whether to insert records
+     * @return List of Event records
+     */
+    public static List<Event> create(Integer count, Boolean doInsert) {
+        // Create parent Account and Contact for Who field
+        Account parentAccount = new Account(Name = 'Test Parent Account for Events');
+        insert parentAccount;
+
+        Contact parentContact = new Contact(
+            FirstName = 'Test',
+            LastName = 'EventContact',
+            AccountId = parentAccount.Id
+        );
+        insert parentContact;
+
+        List<Event> records = new List<Event>();
+        for (Integer i = 0; i < count; i++) {
+            records.add(buildRecord(i, parentContact.Id, parentAccount.Id));
+        }
+        if (doInsert && !records.isEmpty()) {
+            insert records;
+        }
+        return records;
+    }
+
+    /**
+     * Create Event records for a specific Who (Contact or Lead)
+     * @param count Number of records to create
+     * @param whoId Contact or Lead ID for the Who field
+     * @return List of inserted Event records
+     */
+    public static List<Event> createForWho(Integer count, Id whoId) {
+        return createForWho(count, whoId, true);
+    }
+
+    /**
+     * Create Event records for a specific Who with insert option
+     * @param count Number of records to create
+     * @param whoId Contact or Lead ID
+     * @param doInsert Whether to insert records
+     * @return List of Event records
+     */
+    public static List<Event> createForWho(Integer count, Id whoId, Boolean doInsert) {
+        List<Event> records = new List<Event>();
+        for (Integer i = 0; i < count; i++) {
+            records.add(buildRecord(i, whoId, null));
+        }
+        if (doInsert && !records.isEmpty()) {
+            insert records;
+        }
+        return records;
+    }
+
+    /**
+     * Create Event records for a specific What (Account, Opportunity, Case, etc.)
+     * @param count Number of records to create
+     * @param whatId Account, Opportunity, or Case ID
+     * @return List of inserted Event records
+     */
+    public static List<Event> createForWhat(Integer count, Id whatId) {
+        return createForWhat(count, whatId, true);
+    }
+
+    /**
+     * Create Event records for a specific What with insert option
+     * @param count Number of records to create
+     * @param whatId Account, Opportunity, or Case ID
+     * @param doInsert Whether to insert records
+     * @return List of Event records
+     */
+    public static List<Event> createForWhat(Integer count, Id whatId, Boolean doInsert) {
+        List<Event> records = new List<Event>();
+        for (Integer i = 0; i < count; i++) {
+            records.add(buildRecord(i, null, whatId));
+        }
+        if (doInsert && !records.isEmpty()) {
+            insert records;
+        }
+        return records;
+    }
+
+    /**
+     * Create all-day Event records
+     * @param count Number of records to create
+     * @return List of inserted all-day Event records
+     */
+    public static List<Event> createAllDay(Integer count) {
+        Account parentAccount = new Account(Name = 'Test Account for All-Day Events');
+        insert parentAccount;
+
+        List<Event> records = new List<Event>();
+        for (Integer i = 0; i < count; i++) {
+            Event e = new Event(
+                Subject = 'All Day Event ' + String.valueOf(i).leftPad(5, '0'),
+                WhatId = parentAccount.Id,
+                IsAllDayEvent = true,
+                ActivityDate = Date.today().addDays(i),
+                Description = 'Test all-day event created by TestDataFactory'
+            );
+            records.add(e);
+        }
+        if (!records.isEmpty()) {
+            insert records;
+        }
+        return records;
+    }
+
+    /**
+     * Create recurring Event records
+     * @param count Number of recurring event series to create
+     * @param recurrencePattern Recurrence pattern (Daily, Weekly, Monthly)
+     * @return List of inserted recurring Event records
+     */
+    public static List<Event> createRecurring(Integer count, String recurrencePattern) {
+        Account parentAccount = new Account(Name = 'Test Account for Recurring Events');
+        insert parentAccount;
+
+        List<Event> records = new List<Event>();
+        DateTime startTime = DateTime.now().addDays(1);
+
+        for (Integer i = 0; i < count; i++) {
+            Event e = new Event(
+                Subject = 'Recurring Event ' + String.valueOf(i).leftPad(5, '0'),
+                WhatId = parentAccount.Id,
+                StartDateTime = startTime.addHours(i),
+                EndDateTime = startTime.addHours(i + 1),
+                IsRecurrence = true,
+                RecurrenceType = recurrencePattern,
+                RecurrenceInterval = 1,
+                RecurrenceStartDateTime = startTime.addHours(i),
+                RecurrenceEndDateOnly = Date.today().addMonths(3),
+                Description = 'Test recurring event created by TestDataFactory'
+            );
+            records.add(e);
+        }
+        if (!records.isEmpty()) {
+            insert records;
+        }
+        return records;
+    }
+
+    /**
+     * Create Events with varied types for reporting testing
+     * @param count Number of records to create
+     * @return List of inserted Event records with varied types
+     */
+    public static List<Event> createWithVariedTypes(Integer count) {
+        List<String> types = new List<String>{
+            'Meeting', 'Call', 'Email', 'Other', 'Webinar',
+            'Conference', 'Demo', 'Training', 'Interview', 'Presentation'
+        };
+
+        Account parentAccount = new Account(Name = 'Test Account for Varied Events');
+        insert parentAccount;
+
+        List<Event> records = new List<Event>();
+        for (Integer i = 0; i < count; i++) {
+            Event e = buildRecord(i, null, parentAccount.Id);
+            e.Type = types[Math.mod(i, types.size())];
+            records.add(e);
+        }
+
+        if (!records.isEmpty()) {
+            insert records;
+        }
+        return records;
+    }
+
+    /**
+     * Create Events scheduled at different times for calendar testing
+     * @param count Number of records to create
+     * @param startDate First event date
+     * @return List of inserted Event records spread across dates
+     */
+    public static List<Event> createSpreadAcrossDates(Integer count, Date startDate) {
+        Account parentAccount = new Account(Name = 'Test Account for Calendar Events');
+        insert parentAccount;
+
+        List<Event> records = new List<Event>();
+        DateTime baseDateTime = DateTime.newInstance(startDate, Time.newInstance(9, 0, 0, 0));
+
+        for (Integer i = 0; i < count; i++) {
+            Event e = new Event(
+                Subject = 'Calendar Event ' + String.valueOf(i).leftPad(5, '0'),
+                WhatId = parentAccount.Id,
+                StartDateTime = baseDateTime.addDays(i),
+                EndDateTime = baseDateTime.addDays(i).addHours(1),
+                Description = 'Test calendar event created by TestDataFactory'
+            );
+            records.add(e);
+        }
+
+        if (!records.isEmpty()) {
+            insert records;
+        }
+        return records;
+    }
+
+    /**
+     * Build a single Event record with default values
+     * @param index Record index for unique naming
+     * @param whoId Contact or Lead ID (optional)
+     * @param whatId Account, Opportunity, or Case ID (optional)
+     * @return Event record (not inserted)
+     */
+    private static Event buildRecord(Integer index, Id whoId, Id whatId) {
+        String indexStr = String.valueOf(index).leftPad(5, '0');
+        DateTime startTime = DateTime.now().addDays(1).addHours(index);
+
+        return new Event(
+            Subject = DEFAULT_SUBJECT_PREFIX + indexStr,
+            WhoId = whoId,
+            WhatId = whatId,
+            StartDateTime = startTime,
+            EndDateTime = startTime.addMinutes(DEFAULT_DURATION_MINUTES),
+            Location = 'Test Location ' + index,
+            Description = 'Test event created by TestDataFactory for automated testing. Event index: ' + index,
+            Type = 'Meeting',
+            ShowAs = 'Busy',
+            IsPrivate = false,
+            IsReminderSet = false
+        );
+    }
+
+    /**
+     * Get IDs of created records for cleanup
+     * @param records List of Event records
+     * @return Set of Event IDs
+     */
+    public static Set<Id> getIds(List<Event> records) {
+        Set<Id> ids = new Set<Id>();
+        for (Event e : records) {
+            if (e.Id != null) {
+                ids.add(e.Id);
+            }
+        }
+        return ids;
+    }
+
+    /**
+     * Delete records by IDs (cleanup utility)
+     * @param recordIds Set of Event IDs to delete
+     */
+    public static void cleanup(Set<Id> recordIds) {
+        if (!recordIds.isEmpty()) {
+            delete [SELECT Id FROM Event WHERE Id IN :recordIds];
+        }
+    }
+}

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

@@ -0,0 +1,372 @@
+/**
+ * Test Data Factory for creating complete Account->Contact->Opportunity hierarchies
+ * Creates parent-child relationships in a single operation for comprehensive testing
+ *
+ * Usage:
+ *   Map<String, List<SObject>> data = TestDataFactory_Hierarchy.createAccountHierarchy(5, 3, 2);
+ *   List<Account> accounts = (List<Account>) data.get('accounts');
+ *   List<Contact> contacts = (List<Contact>) data.get('contacts');
+ *   List<Opportunity> opportunities = (List<Opportunity>) data.get('opportunities');
+ *
+ *   // Full hierarchy with Cases and Tasks
+ *   Map<String, List<SObject>> fullData = TestDataFactory_Hierarchy.createFullHierarchy(5, 3, 2, 2, 1);
+ */
+public class TestDataFactory_Hierarchy {
+
+    /**
+     * Create Account->Contact->Opportunity hierarchy
+     *
+     * @param accountCount Number of parent Accounts to create
+     * @param contactsPerAccount Number of Contacts per Account
+     * @param oppsPerAccount Number of Opportunities per Account
+     * @return Map with keys: 'accounts', 'contacts', 'opportunities'
+     */
+    public static Map<String, List<SObject>> createAccountHierarchy(
+        Integer accountCount,
+        Integer contactsPerAccount,
+        Integer oppsPerAccount
+    ) {
+        // ═══════════════════════════════════════════════════════════════════
+        // Step 1: Create Accounts
+        // ═══════════════════════════════════════════════════════════════════
+        List<Account> accounts = new List<Account>();
+        for (Integer i = 0; i < accountCount; i++) {
+            accounts.add(new Account(
+                Name = 'Hierarchy Account ' + String.valueOf(i).leftPad(3, '0'),
+                Industry = getIndustryForIndex(i),
+                Type = 'Prospect',
+                BillingCity = 'San Francisco',
+                BillingState = 'CA',
+                BillingCountry = 'USA',
+                Description = 'Parent account for hierarchy testing'
+            ));
+        }
+        insert accounts;
+
+        // ═══════════════════════════════════════════════════════════════════
+        // Step 2: Create Contacts for each Account
+        // ═══════════════════════════════════════════════════════════════════
+        List<Contact> contacts = new List<Contact>();
+        Integer contactIndex = 0;
+
+        for (Account acc : accounts) {
+            for (Integer i = 0; i < contactsPerAccount; i++) {
+                String indexStr = String.valueOf(contactIndex++).leftPad(5, '0');
+                contacts.add(new Contact(
+                    FirstName = 'Contact',
+                    LastName = 'Hierarchy' + indexStr,
+                    AccountId = acc.Id,
+                    Email = 'contact.hierarchy' + indexStr + '@testfactory.example.com',
+                    Phone = '(555) 100-' + String.valueOf(1000 + contactIndex),
+                    Title = getTitleForIndex(i),
+                    Description = 'Contact for ' + acc.Name
+                ));
+            }
+        }
+        if (!contacts.isEmpty()) {
+            insert contacts;
+        }
+
+        // ═══════════════════════════════════════════════════════════════════
+        // Step 3: Create Opportunities for each Account
+        // ═══════════════════════════════════════════════════════════════════
+        List<Opportunity> opportunities = new List<Opportunity>();
+        Integer oppIndex = 0;
+
+        for (Account acc : accounts) {
+            for (Integer i = 0; i < oppsPerAccount; i++) {
+                String indexStr = String.valueOf(oppIndex++).leftPad(5, '0');
+                opportunities.add(new Opportunity(
+                    Name = 'Hierarchy Opportunity ' + indexStr,
+                    AccountId = acc.Id,
+                    StageName = getStageForIndex(i),
+                    CloseDate = Date.today().addDays(30 + (i * 7)),
+                    Amount = 10000 + (oppIndex * 5000),
+                    Type = 'New Customer',
+                    LeadSource = 'Web',
+                    Description = 'Opportunity for ' + acc.Name
+                ));
+            }
+        }
+        if (!opportunities.isEmpty()) {
+            insert opportunities;
+        }
+
+        // Return all created records
+        return new Map<String, List<SObject>>{
+            'accounts' => accounts,
+            'contacts' => contacts,
+            'opportunities' => opportunities
+        };
+    }
+
+    /**
+     * Create full hierarchy including Cases and Tasks
+     *
+     * @param accountCount Number of parent Accounts
+     * @param contactsPerAccount Number of Contacts per Account
+     * @param oppsPerAccount Number of Opportunities per Account
+     * @param casesPerAccount Number of Cases per Account
+     * @param tasksPerContact Number of Tasks per Contact
+     * @return Map with keys: 'accounts', 'contacts', 'opportunities', 'cases', 'tasks'
+     */
+    public static Map<String, List<SObject>> createFullHierarchy(
+        Integer accountCount,
+        Integer contactsPerAccount,
+        Integer oppsPerAccount,
+        Integer casesPerAccount,
+        Integer tasksPerContact
+    ) {
+        // Create base hierarchy
+        Map<String, List<SObject>> hierarchy = createAccountHierarchy(
+            accountCount, contactsPerAccount, oppsPerAccount
+        );
+
+        List<Account> accounts = (List<Account>) hierarchy.get('accounts');
+        List<Contact> contacts = (List<Contact>) hierarchy.get('contacts');
+
+        // ═══════════════════════════════════════════════════════════════════
+        // Step 4: Create Cases for each Account
+        // ═══════════════════════════════════════════════════════════════════
+        List<Case> cases = new List<Case>();
+        Integer caseIndex = 0;
+
+        // Get first contact per account for case contact
+        Map<Id, Contact> accountToContact = new Map<Id, Contact>();
+        for (Contact con : contacts) {
+            if (!accountToContact.containsKey(con.AccountId)) {
+                accountToContact.put(con.AccountId, con);
+            }
+        }
+
+        for (Account acc : accounts) {
+            Contact accountContact = accountToContact.get(acc.Id);
+            for (Integer i = 0; i < casesPerAccount; i++) {
+                String indexStr = String.valueOf(caseIndex++).leftPad(5, '0');
+                cases.add(new Case(
+                    Subject = 'Hierarchy Case ' + indexStr,
+                    AccountId = acc.Id,
+                    ContactId = accountContact?.Id,
+                    Status = 'New',
+                    Priority = getPriorityForIndex(i),
+                    Origin = 'Web',
+                    Type = 'Problem',
+                    Description = 'Case for ' + acc.Name
+                ));
+            }
+        }
+        if (!cases.isEmpty()) {
+            insert cases;
+        }
+
+        // ═══════════════════════════════════════════════════════════════════
+        // Step 5: Create Tasks for each Contact
+        // ═══════════════════════════════════════════════════════════════════
+        List<Task> tasks = new List<Task>();
+        Integer taskIndex = 0;
+
+        for (Contact con : contacts) {
+            for (Integer i = 0; i < tasksPerContact; i++) {
+                String indexStr = String.valueOf(taskIndex++).leftPad(5, '0');
+                tasks.add(new Task(
+                    Subject = 'Hierarchy Task ' + indexStr,
+                    WhoId = con.Id,
+                    WhatId = con.AccountId,
+                    Status = 'Not Started',
+                    Priority = 'Normal',
+                    ActivityDate = Date.today().addDays(7 + i),
+                    Description = 'Task for ' + con.FirstName + ' ' + con.LastName
+                ));
+            }
+        }
+        if (!tasks.isEmpty()) {
+            insert tasks;
+        }
+
+        // Add new records to hierarchy map
+        hierarchy.put('cases', cases);
+        hierarchy.put('tasks', tasks);
+
+        return hierarchy;
+    }
+
+    /**
+     * Create nested Account hierarchy (parent-child accounts)
+     *
+     * @param rootCount Number of root (top-level) accounts
+     * @param levelsDeep Number of child levels (1-4 recommended)
+     * @param childrenPerLevel Number of child accounts per parent
+     * @return Map with keys: 'level0', 'level1', 'level2', etc.
+     */
+    public static Map<String, List<Account>> createNestedAccountHierarchy(
+        Integer rootCount,
+        Integer levelsDeep,
+        Integer childrenPerLevel
+    ) {
+        Map<String, List<Account>> hierarchy = new Map<String, List<Account>>();
+
+        // Create root accounts
+        List<Account> rootAccounts = new List<Account>();
+        for (Integer i = 0; i < rootCount; i++) {
+            rootAccounts.add(new Account(
+                Name = 'Root Account ' + String.valueOf(i).leftPad(3, '0'),
+                Industry = 'Technology',
+                Type = 'Customer',
+                Description = 'Root level account'
+            ));
+        }
+        insert rootAccounts;
+        hierarchy.put('level0', rootAccounts);
+
+        // Create child levels
+        List<Account> parentLevel = rootAccounts;
+
+        for (Integer level = 1; level <= levelsDeep; level++) {
+            List<Account> childLevel = new List<Account>();
+            Integer childIndex = 0;
+
+            for (Account parent : parentLevel) {
+                for (Integer i = 0; i < childrenPerLevel; i++) {
+                    childLevel.add(new Account(
+                        Name = 'Level' + level + ' Account ' + String.valueOf(childIndex++).leftPad(3, '0'),
+                        ParentId = parent.Id,
+                        Industry = parent.Industry,
+                        Type = 'Customer',
+                        Description = 'Child of ' + parent.Name
+                    ));
+                }
+            }
+
+            if (!childLevel.isEmpty()) {
+                insert childLevel;
+                hierarchy.put('level' + level, childLevel);
+                parentLevel = childLevel;
+            }
+        }
+
+        return hierarchy;
+    }
+
+    /**
+     * Create bulk test hierarchy for performance/bulkification testing
+     * Creates 251+ records to test Salesforce batch boundaries
+     *
+     * @return Map with keys: 'accounts', 'contacts', 'opportunities'
+     */
+    public static Map<String, List<SObject>> createBulkTestHierarchy() {
+        // 51 accounts x 5 contacts = 255 contacts
+        // 51 accounts x 5 opportunities = 255 opportunities
+        return createAccountHierarchy(51, 5, 5);
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // HELPER METHODS
+    // ═══════════════════════════════════════════════════════════════════════
+
+    private static String getIndustryForIndex(Integer index) {
+        List<String> industries = new List<String>{
+            'Technology', 'Healthcare', 'Finance', 'Manufacturing',
+            'Retail', 'Education', 'Energy', 'Media'
+        };
+        return industries[Math.mod(index, industries.size())];
+    }
+
+    private static String getTitleForIndex(Integer index) {
+        List<String> titles = new List<String>{
+            'CEO', 'CFO', 'CTO', 'VP Sales', 'VP Marketing',
+            'Director', 'Manager', 'Senior Developer', 'Analyst'
+        };
+        return titles[Math.mod(index, titles.size())];
+    }
+
+    private static String getStageForIndex(Integer index) {
+        List<String> stages = new List<String>{
+            'Prospecting', 'Qualification', 'Needs Analysis',
+            'Proposal/Price Quote', 'Negotiation/Review'
+        };
+        return stages[Math.mod(index, stages.size())];
+    }
+
+    private static String getPriorityForIndex(Integer index) {
+        List<String> priorities = new List<String>{'Low', 'Medium', 'High'};
+        return priorities[Math.mod(index, priorities.size())];
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // CLEANUP METHODS
+    // ═══════════════════════════════════════════════════════════════════════
+
+    /**
+     * Get all IDs from a hierarchy map
+     * @param hierarchy Map returned by create methods
+     * @return Set of all record IDs
+     */
+    public static Map<String, Set<Id>> getAllIds(Map<String, List<SObject>> hierarchy) {
+        Map<String, Set<Id>> idsByType = new Map<String, Set<Id>>();
+
+        for (String key : hierarchy.keySet()) {
+            Set<Id> ids = new Set<Id>();
+            for (SObject record : hierarchy.get(key)) {
+                if (record.Id != null) {
+                    ids.add(record.Id);
+                }
+            }
+            idsByType.put(key, ids);
+        }
+
+        return idsByType;
+    }
+
+    /**
+     * Delete all records in a hierarchy (in correct order)
+     * Deletes children before parents to avoid referential integrity errors
+     *
+     * @param hierarchy Map returned by create methods
+     */
+    public static void cleanup(Map<String, List<SObject>> hierarchy) {
+        // Delete in reverse dependency order
+        List<String> deleteOrder = new List<String>{
+            'tasks', 'events', 'cases', 'opportunities', 'contacts', 'accounts'
+        };
+
+        for (String key : deleteOrder) {
+            if (hierarchy.containsKey(key)) {
+                List<SObject> records = hierarchy.get(key);
+                if (!records.isEmpty()) {
+                    try {
+                        delete records;
+                    } catch (DmlException e) {
+                        System.debug('Cleanup error for ' + key + ': ' + e.getMessage());
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Delete nested account hierarchy (in correct order - leaves first)
+     *
+     * @param hierarchy Map returned by createNestedAccountHierarchy
+     */
+    public static void cleanupNestedHierarchy(Map<String, List<Account>> hierarchy) {
+        // Find max level
+        Integer maxLevel = 0;
+        for (String key : hierarchy.keySet()) {
+            if (key.startsWith('level')) {
+                Integer level = Integer.valueOf(key.replace('level', ''));
+                maxLevel = Math.max(maxLevel, level);
+            }
+        }
+
+        // Delete from deepest level up
+        for (Integer level = maxLevel; level >= 0; level--) {
+            String key = 'level' + level;
+            if (hierarchy.containsKey(key)) {
+                List<Account> accounts = hierarchy.get(key);
+                if (!accounts.isEmpty()) {
+                    delete accounts;
+                }
+            }
+        }
+    }
+}