@salesforce/afv-skills 1.8.0 → 1.9.0

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

@@ -0,0 +1,190 @@
+/**
+ * Test Data Factory for Lead records
+ * Supports bulk creation with status and source variations
+ *
+ * Usage:
+ *   List<Lead> leads = TestDataFactory_Lead.create(200);
+ *   List<Lead> openLeads = TestDataFactory_Lead.createWithStatus(100, 'Open - Not Contacted');
+ *   List<Lead> qualifiedLeads = TestDataFactory_Lead.createQualified(50);
+ */
+public class TestDataFactory_Lead {
+
+    private static final String DEFAULT_FIRST_NAME_PREFIX = 'Test';
+    private static final String DEFAULT_LAST_NAME_PREFIX = 'Lead';
+    private static final String DEFAULT_COMPANY_PREFIX = 'Test Company ';
+    private static final String DEFAULT_STATUS = 'Open - Not Contacted';
+    private static final String DEFAULT_EMAIL_DOMAIN = 'testlead.example.com';
+
+    /**
+     * Create and insert Lead records with default values
+     * @param count Number of records to create
+     * @return List of inserted Lead records with IDs
+     */
+    public static List<Lead> create(Integer count) {
+        return create(count, true);
+    }
+
+    /**
+     * Create Lead records with insert option
+     * @param count Number of records to create
+     * @param doInsert Whether to insert records
+     * @return List of Lead records
+     */
+    public static List<Lead> create(Integer count, Boolean doInsert) {
+        List<Lead> records = new List<Lead>();
+        for (Integer i = 0; i < count; i++) {
+            records.add(buildRecord(i));
+        }
+        if (doInsert && !records.isEmpty()) {
+            insert records;
+        }
+        return records;
+    }
+
+    /**
+     * Create Lead records with a specific Status
+     * @param count Number of records to create
+     * @param status Lead Status picklist value
+     * @return List of inserted Lead records
+     */
+    public static List<Lead> createWithStatus(Integer count, String status) {
+        List<Lead> records = new List<Lead>();
+        for (Integer i = 0; i < count; i++) {
+            Lead lead = buildRecord(i);
+            lead.Status = status;
+            records.add(lead);
+        }
+        if (!records.isEmpty()) {
+            insert records;
+        }
+        return records;
+    }
+
+    /**
+     * Create qualified Lead records (ready for conversion)
+     * @param count Number of records to create
+     * @return List of inserted qualified Lead records
+     */
+    public static List<Lead> createQualified(Integer count) {
+        List<Lead> records = new List<Lead>();
+        for (Integer i = 0; i < count; i++) {
+            Lead lead = buildRecord(i);
+            lead.Status = 'Qualified';
+            lead.Rating = 'Hot';
+            lead.NumberOfEmployees = 100;
+            lead.AnnualRevenue = 1000000;
+            records.add(lead);
+        }
+        if (!records.isEmpty()) {
+            insert records;
+        }
+        return records;
+    }
+
+    /**
+     * Create Leads with varied Lead Sources for attribution testing
+     * @param count Number of records to create
+     * @return List of inserted Lead records with varied sources
+     */
+    public static List<Lead> createWithVariedSources(Integer count) {
+        List<String> sources = new List<String>{
+            'Web', 'Phone Inquiry', 'Partner Referral', 'Purchased List',
+            'Other', 'Trade Show', 'Employee Referral', 'External Referral'
+        };
+
+        List<Lead> records = new List<Lead>();
+        for (Integer i = 0; i < count; i++) {
+            Lead lead = buildRecord(i);
+            lead.LeadSource = sources[Math.mod(i, sources.size())];
+            records.add(lead);
+        }
+
+        if (!records.isEmpty()) {
+            insert records;
+        }
+        return records;
+    }
+
+    /**
+     * Create Leads with varied Industries for segmentation testing
+     * @param count Number of records to create
+     * @return List of inserted Lead records with varied industries
+     */
+    public static List<Lead> createWithVariedIndustries(Integer count) {
+        List<String> industries = new List<String>{
+            'Technology', 'Healthcare', 'Finance', 'Manufacturing',
+            'Retail', 'Education', 'Energy', 'Media', 'Government'
+        };
+
+        List<Lead> records = new List<Lead>();
+        for (Integer i = 0; i < count; i++) {
+            Lead lead = buildRecord(i);
+            lead.Industry = industries[Math.mod(i, industries.size())];
+            records.add(lead);
+        }
+
+        if (!records.isEmpty()) {
+            insert records;
+        }
+        return records;
+    }
+
+    /**
+     * Build a single Lead record with default values
+     * @param index Record index for unique naming
+     * @return Lead record (not inserted)
+     */
+    private static Lead buildRecord(Integer index) {
+        String indexStr = String.valueOf(index).leftPad(5, '0');
+        String firstName = DEFAULT_FIRST_NAME_PREFIX + indexStr;
+        String lastName = DEFAULT_LAST_NAME_PREFIX + indexStr;
+
+        return new Lead(
+            FirstName = firstName,
+            LastName = lastName,
+            Company = DEFAULT_COMPANY_PREFIX + indexStr,
+            Status = DEFAULT_STATUS,
+            Email = firstName.toLowerCase() + '.' + lastName.toLowerCase() + '@' + DEFAULT_EMAIL_DOMAIN,
+            Phone = '(555) 400-' + String.valueOf(1000 + index),
+            MobilePhone = '(555) 500-' + String.valueOf(1000 + index),
+            Title = 'Decision Maker',
+            Industry = 'Technology',
+            LeadSource = 'Web',
+            Rating = 'Warm',
+            NumberOfEmployees = 50 + index,
+            AnnualRevenue = 500000 + (index * 10000),
+            Street = '789 Lead Blvd',
+            City = 'San Francisco',
+            State = 'CA',
+            PostalCode = '94104',
+            Country = 'USA',
+            Website = 'https://testlead' + index + '.example.com',
+            Description = 'Test lead created by TestDataFactory for automated testing'
+        );
+    }
+
+    /**
+     * Get IDs of created records for cleanup
+     * @param records List of Lead records
+     * @return Set of Lead IDs
+     */
+    public static Set<Id> getIds(List<Lead> records) {
+        Set<Id> ids = new Set<Id>();
+        for (Lead lead : records) {
+            if (lead.Id != null) {
+                ids.add(lead.Id);
+            }
+        }
+        return ids;
+    }
+
+    /**
+     * Delete records by IDs (cleanup utility)
+     * @param recordIds Set of Lead IDs to delete
+     */
+    public static void cleanup(Set<Id> recordIds) {
+        if (!recordIds.isEmpty()) {
+            delete [SELECT Id FROM Lead WHERE Id IN :recordIds];
+        }
+    }
+}

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

@@ -0,0 +1,206 @@
+/**
+ * Test Data Factory for Opportunity records
+ * Supports bulk creation with Account relationships and stage variations
+ *
+ * Usage:
+ *   List<Opportunity> opps = TestDataFactory_Opportunity.create(200);
+ *   List<Opportunity> oppsForAccount = TestDataFactory_Opportunity.createForAccount(50, accountId);
+ *   List<Opportunity> closedWon = TestDataFactory_Opportunity.createWithStage(100, 'Closed Won');
+ */
+public class TestDataFactory_Opportunity {
+
+    private static final String DEFAULT_NAME_PREFIX = 'Test Opportunity ';
+    private static final String DEFAULT_STAGE = 'Prospecting';
+    private static final Integer DEFAULT_CLOSE_DAYS = 30;
+
+    /**
+     * Create and insert Opportunity records (creates parent Account automatically)
+     * @param count Number of records to create
+     * @return List of inserted Opportunity records with IDs
+     */
+    public static List<Opportunity> create(Integer count) {
+        return create(count, true);
+    }
+
+    /**
+     * Create Opportunity records with insert option
+     * @param count Number of records to create
+     * @param doInsert Whether to insert records
+     * @return List of Opportunity records
+     */
+    public static List<Opportunity> create(Integer count, Boolean doInsert) {
+        // Create a parent Account
+        Account parentAccount = new Account(Name = 'Test Parent Account for Opportunities');
+        insert parentAccount;
+
+        return createForAccount(count, parentAccount.Id, doInsert);
+    }
+
+    /**
+     * Create Opportunity records for a specific Account
+     * @param count Number of records to create
+     * @param accountId Parent Account ID
+     * @return List of inserted Opportunity records
+     */
+    public static List<Opportunity> createForAccount(Integer count, Id accountId) {
+        return createForAccount(count, accountId, true);
+    }
+
+    /**
+     * Create Opportunity 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 Opportunity records
+     */
+    public static List<Opportunity> createForAccount(Integer count, Id accountId, Boolean doInsert) {
+        List<Opportunity> records = new List<Opportunity>();
+        for (Integer i = 0; i < count; i++) {
+            records.add(buildRecord(i, accountId));
+        }
+        if (doInsert && !records.isEmpty()) {
+            insert records;
+        }
+        return records;
+    }
+
+    /**
+     * Create Opportunities with a specific Stage
+     * @param count Number of records to create
+     * @param stageName StageName picklist value
+     * @return List of inserted Opportunity records
+     */
+    public static List<Opportunity> createWithStage(Integer count, String stageName) {
+        Account parentAccount = new Account(Name = 'Test Parent Account for ' + stageName + ' Opps');
+        insert parentAccount;
+
+        return createWithStageForAccount(count, stageName, parentAccount.Id);
+    }
+
+    /**
+     * Create Opportunities with a specific Stage for an Account
+     * @param count Number of records to create
+     * @param stageName StageName picklist value
+     * @param accountId Parent Account ID
+     * @return List of inserted Opportunity records
+     */
+    public static List<Opportunity> createWithStageForAccount(Integer count, String stageName, Id accountId) {
+        List<Opportunity> records = new List<Opportunity>();
+        for (Integer i = 0; i < count; i++) {
+            Opportunity opp = buildRecord(i, accountId);
+            opp.StageName = stageName;
+
+            // Set Probability based on stage
+            if (stageName == 'Closed Won') {
+                opp.Probability = 100;
+            } else if (stageName == 'Closed Lost') {
+                opp.Probability = 0;
+            }
+
+            records.add(opp);
+        }
+        if (!records.isEmpty()) {
+            insert records;
+        }
+        return records;
+    }
+
+    /**
+     * Create Opportunities with varied Stages for pipeline testing
+     * @param count Number of records to create
+     * @param accountId Parent Account ID
+     * @return List of inserted Opportunity records with varied stages
+     */
+    public static List<Opportunity> createWithVariedStages(Integer count, Id accountId) {
+        List<String> stages = new List<String>{
+            'Prospecting', 'Qualification', 'Needs Analysis',
+            'Value Proposition', 'Id. Decision Makers', 'Perception Analysis',
+            'Proposal/Price Quote', 'Negotiation/Review', 'Closed Won', 'Closed Lost'
+        };
+
+        List<Opportunity> records = new List<Opportunity>();
+        for (Integer i = 0; i < count; i++) {
+            Opportunity opp = buildRecord(i, accountId);
+            opp.StageName = stages[Math.mod(i, stages.size())];
+            records.add(opp);
+        }
+
+        if (!records.isEmpty()) {
+            insert records;
+        }
+        return records;
+    }
+
+    /**
+     * Create Opportunities with varied Amounts for revenue testing
+     * @param count Number of records to create
+     * @param accountId Parent Account ID
+     * @param minAmount Minimum amount
+     * @param maxAmount Maximum amount
+     * @return List of inserted Opportunity records
+     */
+    public static List<Opportunity> createWithVariedAmounts(Integer count, Id accountId, Decimal minAmount, Decimal maxAmount) {
+        List<Opportunity> records = new List<Opportunity>();
+        Decimal range = maxAmount - minAmount;
+
+        for (Integer i = 0; i < count; i++) {
+            Opportunity opp = buildRecord(i, accountId);
+            // Distribute amounts evenly across the range
+            opp.Amount = minAmount + (range * i / count);
+            records.add(opp);
+        }
+
+        if (!records.isEmpty()) {
+            insert records;
+        }
+        return records;
+    }
+
+    /**
+     * Build a single Opportunity record with default values
+     * @param index Record index for unique naming
+     * @param accountId Parent Account ID
+     * @return Opportunity record (not inserted)
+     */
+    private static Opportunity buildRecord(Integer index, Id accountId) {
+        String indexStr = String.valueOf(index).leftPad(5, '0');
+
+        return new Opportunity(
+            Name = DEFAULT_NAME_PREFIX + indexStr,
+            AccountId = accountId,
+            StageName = DEFAULT_STAGE,
+            CloseDate = Date.today().addDays(DEFAULT_CLOSE_DAYS + index),
+            Amount = 10000 + (index * 1000),
+            Probability = 20,
+            Type = 'New Customer',
+            LeadSource = 'Web',
+            NextStep = 'Follow up call',
+            Description = 'Test opportunity created by TestDataFactory for automated testing'
+        );
+    }
+
+    /**
+     * Get IDs of created records for cleanup
+     * @param records List of Opportunity records
+     * @return Set of Opportunity IDs
+     */
+    public static Set<Id> getIds(List<Opportunity> records) {
+        Set<Id> ids = new Set<Id>();
+        for (Opportunity opp : records) {
+            if (opp.Id != null) {
+                ids.add(opp.Id);
+            }
+        }
+        return ids;
+    }
+
+    /**
+     * Delete records by IDs (cleanup utility)
+     * @param recordIds Set of Opportunity IDs to delete
+     */
+    public static void cleanup(Set<Id> recordIds) {
+        if (!recordIds.isEmpty()) {
+            delete [SELECT Id FROM Opportunity WHERE Id IN :recordIds];
+        }
+    }
+}

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

@@ -0,0 +1,246 @@
+/**
+ * Test Data Factory for Task records
+ * Supports bulk creation with polymorphic Who/What relationships
+ *
+ * Usage:
+ *   List<Task> tasks = TestDataFactory_Task.create(200);
+ *   List<Task> tasksForContact = TestDataFactory_Task.createForWho(50, contactId);
+ *   List<Task> tasksForAccount = TestDataFactory_Task.createForWhat(50, accountId);
+ */
+public class TestDataFactory_Task {
+
+    private static final String DEFAULT_SUBJECT_PREFIX = 'Test Task ';
+    private static final String DEFAULT_STATUS = 'Not Started';
+    private static final String DEFAULT_PRIORITY = 'Normal';
+
+    /**
+     * Create and insert Task records (creates related Contact automatically)
+     * @param count Number of records to create
+     * @return List of inserted Task records with IDs
+     */
+    public static List<Task> create(Integer count) {
+        return create(count, true);
+    }
+
+    /**
+     * Create Task records with insert option
+     * @param count Number of records to create
+     * @param doInsert Whether to insert records
+     * @return List of Task records
+     */
+    public static List<Task> create(Integer count, Boolean doInsert) {
+        // Create parent Account and Contact for Who field
+        Account parentAccount = new Account(Name = 'Test Parent Account for Tasks');
+        insert parentAccount;
+
+        Contact parentContact = new Contact(
+            FirstName = 'Test',
+            LastName = 'TaskContact',
+            AccountId = parentAccount.Id
+        );
+        insert parentContact;
+
+        List<Task> records = new List<Task>();
+        for (Integer i = 0; i < count; i++) {
+            records.add(buildRecord(i, parentContact.Id, parentAccount.Id));
+        }
+        if (doInsert && !records.isEmpty()) {
+            insert records;
+        }
+        return records;
+    }
+
+    /**
+     * Create Task 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 Task records
+     */
+    public static List<Task> createForWho(Integer count, Id whoId) {
+        return createForWho(count, whoId, true);
+    }
+
+    /**
+     * Create Task 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 Task records
+     */
+    public static List<Task> createForWho(Integer count, Id whoId, Boolean doInsert) {
+        List<Task> records = new List<Task>();
+        for (Integer i = 0; i < count; i++) {
+            records.add(buildRecord(i, whoId, null));
+        }
+        if (doInsert && !records.isEmpty()) {
+            insert records;
+        }
+        return records;
+    }
+
+    /**
+     * Create Task 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 Task records
+     */
+    public static List<Task> createForWhat(Integer count, Id whatId) {
+        return createForWhat(count, whatId, true);
+    }
+
+    /**
+     * Create Task 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 Task records
+     */
+    public static List<Task> createForWhat(Integer count, Id whatId, Boolean doInsert) {
+        List<Task> records = new List<Task>();
+        for (Integer i = 0; i < count; i++) {
+            records.add(buildRecord(i, null, whatId));
+        }
+        if (doInsert && !records.isEmpty()) {
+            insert records;
+        }
+        return records;
+    }
+
+    /**
+     * Create Task records for both Who and What
+     * @param count Number of records to create
+     * @param whoId Contact or Lead ID
+     * @param whatId Account, Opportunity, or Case ID
+     * @return List of inserted Task records
+     */
+    public static List<Task> createForWhoAndWhat(Integer count, Id whoId, Id whatId) {
+        List<Task> records = new List<Task>();
+        for (Integer i = 0; i < count; i++) {
+            records.add(buildRecord(i, whoId, whatId));
+        }
+        if (!records.isEmpty()) {
+            insert records;
+        }
+        return records;
+    }
+
+    /**
+     * Create Tasks with a specific Status
+     * @param count Number of records to create
+     * @param status Task Status picklist value
+     * @return List of inserted Task records
+     */
+    public static List<Task> createWithStatus(Integer count, String status) {
+        Account parentAccount = new Account(Name = 'Test Account for ' + status + ' Tasks');
+        insert parentAccount;
+
+        List<Task> records = new List<Task>();
+        for (Integer i = 0; i < count; i++) {
+            Task t = buildRecord(i, null, parentAccount.Id);
+            t.Status = status;
+            records.add(t);
+        }
+        if (!records.isEmpty()) {
+            insert records;
+        }
+        return records;
+    }
+
+    /**
+     * Create completed Tasks for history testing
+     * @param count Number of records to create
+     * @return List of inserted completed Task records
+     */
+    public static List<Task> createCompleted(Integer count) {
+        Account parentAccount = new Account(Name = 'Test Account for Completed Tasks');
+        insert parentAccount;
+
+        List<Task> records = new List<Task>();
+        for (Integer i = 0; i < count; i++) {
+            Task t = buildRecord(i, null, parentAccount.Id);
+            t.Status = 'Completed';
+            t.Priority = 'Normal';
+            records.add(t);
+        }
+        if (!records.isEmpty()) {
+            insert records;
+        }
+        return records;
+    }
+
+    /**
+     * Create Tasks with varied Subjects for search testing
+     * @param count Number of records to create
+     * @return List of inserted Task records with varied subjects
+     */
+    public static List<Task> createWithVariedSubjects(Integer count) {
+        List<String> subjects = new List<String>{
+            'Call', 'Email', 'Meeting', 'Send Letter', 'Send Quote',
+            'Follow Up', 'Demo', 'Proposal', 'Contract Review', 'Other'
+        };
+
+        Account parentAccount = new Account(Name = 'Test Account for Varied Tasks');
+        insert parentAccount;
+
+        List<Task> records = new List<Task>();
+        for (Integer i = 0; i < count; i++) {
+            Task t = buildRecord(i, null, parentAccount.Id);
+            t.Subject = subjects[Math.mod(i, subjects.size())];
+            records.add(t);
+        }
+
+        if (!records.isEmpty()) {
+            insert records;
+        }
+        return records;
+    }
+
+    /**
+     * Build a single Task 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 Task record (not inserted)
+     */
+    private static Task buildRecord(Integer index, Id whoId, Id whatId) {
+        String indexStr = String.valueOf(index).leftPad(5, '0');
+
+        return new Task(
+            Subject = DEFAULT_SUBJECT_PREFIX + indexStr,
+            WhoId = whoId,
+            WhatId = whatId,
+            Status = DEFAULT_STATUS,
+            Priority = DEFAULT_PRIORITY,
+            ActivityDate = Date.today().addDays(7 + index),
+            Description = 'Test task created by TestDataFactory for automated testing. Task index: ' + index,
+            Type = 'Call',
+            IsReminderSet = false,
+            TaskSubtype = 'Task'
+        );
+    }
+
+    /**
+     * Get IDs of created records for cleanup
+     * @param records List of Task records
+     * @return Set of Task IDs
+     */
+    public static Set<Id> getIds(List<Task> records) {
+        Set<Id> ids = new Set<Id>();
+        for (Task t : records) {
+            if (t.Id != null) {
+                ids.add(t.Id);
+            }
+        }
+        return ids;
+    }
+
+    /**
+     * Delete records by IDs (cleanup utility)
+     * @param recordIds Set of Task IDs to delete
+     */
+    public static void cleanup(Set<Id> recordIds) {
+        if (!recordIds.isEmpty()) {
+            delete [SELECT Id FROM Task WHERE Id IN :recordIds];
+        }
+    }
+}