请求编写Salesforce Apex测试类：销售共享逻辑验证

云原生阿岚

2026-8-24

需求说明

我开发了Salesforce的Apex共享类Sharing_Sales，要实现以下业务逻辑：

创建**销售代表分配（Sales_Rep_Assignment__c）**记录，或把该记录设为激活状态时，将关联的Account及Order共享给对应销售代表
删除该记录，或把该记录设为非激活状态时，移除销售代表对相关记录的编辑权限；重新激活则再次共享

以下是修正后的实现代码，以及对应的Apex测试类。

修正后的共享类代码

public with sharing class Sharing_Sales {
    public static void SharingRelatedOrdersAndAccount(List<Sales_Rep_Assignment__c> triggerNew, 
            Map<Id, Sales_Rep_Assignment__c> oldMap){
        List<Sales_Rep_Assignment__c> activeAssignments = new List<Sales_Rep_Assignment__c>();
        Set<Id> accIds = new Set<Id>();
        Set<Id> salesRepsIds = new Set<Id>();
        Map<Id, List<Order>> ordersByAccountId = new Map<Id, List<Order>>();

        // 筛选出需要激活共享的分配记录
        for(Sales_Rep_Assignment__c sar: triggerNew){
            if(sar.Active__c == true && (oldMap == null || oldMap.get(sar.Id).Active__c == false)) {
                activeAssignments.add(sar);
                salesRepsIds.add(sar.Sales_Reps__c);
                accIds.add(sar.Account__c);
            }
        }

        // 批量查询关联的Order
        for(Order ord : [SELECT Id, AccountId FROM Order WHERE AccountId IN :accIds]) {
            if (!ordersByAccountId.containsKey(ord.AccountId)) {
                ordersByAccountId.put(ord.AccountId, new List<Order>());
            }
            ordersByAccountId.get(ord.AccountId).add(ord);
        }
        
        List<OrderShare> orderSharingRecords = new List<OrderShare>();
        List<AccountShare> accountSharingRecords = new List<AccountShare>();

        // 生成Account和Order的共享记录
        for (Sales_Rep_Assignment__c srs : activeAssignments) {
            // 处理Account共享
            AccountShare accShare = new AccountShare();
            accShare.AccountId = srs.Account__c;
            accShare.AccountAccessLevel = 'Edit';
            accShare.UserOrGroupId = srs.Sales_Reps__c;
            accShare.RowCause = Schema.AccountShare.RowCause.Manual;
            accountSharingRecords.add(accShare);

            // 处理Order共享
            if(ordersByAccountId.containsKey(srs.Account__c)){
                for (Order ord : ordersByAccountId.get(srs.Account__c)) {
                    OrderShare orderShare = new OrderShare();
                    orderShare.OrderId = ord.Id;
                    orderShare.OrderAccessLevel = 'Edit';
                    orderShare.UserOrGroupId = srs.Sales_Reps__c;
                    orderShare.RowCause = Schema.OrderShare.RowCause.Manual;
                    orderSharingRecords.add(orderShare);
                }
            }
        }

        // 统一执行DML，避免多次操作
        if(!accountSharingRecords.isEmpty()){
            insert accountSharingRecords;
        }
        if(!orderSharingRecords.isEmpty()){
            insert orderSharingRecords;
        }
    }  

    public static void SharingOrderAndAccountIsDelete(List<Sales_Rep_Assignment__c> triggerNew, 
            Map<Id, Sales_Rep_Assignment__c> oldMap){
        List<Sales_Rep_Assignment__c> inactiveOrDeletedAssignments = new List<Sales_Rep_Assignment__c>();
        Set<Id> accIds = new Set<Id>();
        Set<Id> salesRepsIds = new Set<Id>();

        // 处理更新为非激活的场景
        if(triggerNew != null){
            for(Sales_Rep_Assignment__c sar: triggerNew){
                if(sar.Active__c == false && oldMap != null && oldMap.get(sar.Id).Active__c == true){
                    inactiveOrDeletedAssignments.add(sar);
                    salesRepsIds.add(sar.Sales_Reps__c);
                    accIds.add(sar.Account__c);
                }
            }
        } else {
            // 处理删除记录的场景，从oldMap中获取已删除的激活记录
            for(Sales_Rep_Assignment__c sar: oldMap.values()){
                if(sar.Active__c == true){
                    inactiveOrDeletedAssignments.add(sar);
                    salesRepsIds.add(sar.Sales_Reps__c);
                    accIds.add(sar.Account__c);
                }
            }
        }

        // 查询需要删除的共享记录
        List<AccountShare> accSharesToDelete = [
            SELECT Id FROM AccountShare 
            WHERE AccountId IN :accIds 
            AND UserOrGroupId IN :salesRepsIds
            AND RowCause = 'Manual'
        ];
        List<OrderShare> orderSharesToDelete = [
            SELECT Id FROM OrderShare 
            WHERE OrderId IN (SELECT Id FROM Order WHERE AccountId IN :accIds)
            AND UserOrGroupId IN :salesRepsIds
            AND RowCause = 'Manual'
        ];

        // 统一删除共享记录
        if(!accSharesToDelete.isEmpty()){
            delete accSharesToDelete;
        }
        if(!orderSharesToDelete.isEmpty()){
            delete orderSharesToDelete;
        }
    }
}

对应的Apex测试类

@isTest
private class Sharing_Sales_Test {
    @testSetup
    static void setupTestData(){
        // 创建测试销售代表用户
        Profile testProfile = [SELECT Id FROM Profile WHERE Name = 'Standard User' LIMIT 1];
        User testSalesRep = new User(
            FirstName = 'Test',
            LastName = 'Rep',
            Email = 'test.rep@example.com',
            Username = 'test.rep' + System.now().getTime() + '@example.com',
            Alias = 'testrep',
            TimeZoneSidKey = 'America/Los_Angeles',
            LocaleSidKey = 'en_US',
            EmailEncodingKey = 'UTF-8',
            LanguageLocaleKey = 'en_US',
            ProfileId = testProfile.Id
        );
        insert testSalesRep;

        // 创建测试Account
        Account testAcc = new Account(Name = 'Test Account');
        insert testAcc;

        // 创建关联的测试Order
        Order testOrder = new Order(
            AccountId = testAcc.Id,
            EffectiveDate = Date.today(),
            Status = 'Draft'
        );
        insert testOrder;
    }

    // 测试：创建激活的分配记录，验证共享记录生成
    @isTest
    static void testCreateActiveAssignment(){
        User testSalesRep = [SELECT Id FROM User WHERE Username LIKE '%test.rep%' LIMIT 1];
        Account testAcc = [SELECT Id FROM Account WHERE Name = 'Test Account' LIMIT 1];

        Sales_Rep_Assignment__c assignment = new Sales_Rep_Assignment__c(
            Account__c = testAcc.Id,
            Sales_Reps__c = testSalesRep.Id,
            Active__c = true
        );
        insert assignment;

        // 验证Account共享记录存在
        List<AccountShare> accShares = [
            SELECT Id FROM AccountShare 
            WHERE AccountId = :testAcc.Id 
            AND UserOrGroupId = :testSalesRep.Id
            AND AccountAccessLevel = 'Edit'
        ];
        System.assertEquals(1, accShares.size(), 'Account共享记录未生成');

        // 验证Order共享记录存在
        Order testOrder = [SELECT Id FROM Order WHERE AccountId = :testAcc.Id LIMIT 1];
        List<OrderShare> orderShares = [
            SELECT Id FROM OrderShare 
            WHERE OrderId = :testOrder.Id 
            AND UserOrGroupId = :testSalesRep.Id
            AND OrderAccessLevel = 'Edit'
        ];
        System.assertEquals(1, orderShares.size(), 'Order共享记录未生成');
    }

    // 测试：将激活记录改为非激活，验证共享记录删除
    @isTest
    static void testDeactivateAssignment(){
        User testSalesRep = [SELECT Id FROM User WHERE Username LIKE '%test.rep%' LIMIT 1];
        Account testAcc = [SELECT Id FROM Account WHERE Name = 'Test Account' LIMIT 1];
        Order testOrder = [SELECT Id FROM Order WHERE AccountId = :testAcc.Id LIMIT 1];

        Sales_Rep_Assignment__c assignment = new Sales_Rep_Assignment__c(
            Account__c = testAcc.Id,
            Sales_Reps__c = testSalesRep.Id,
            Active__c = true
        );
        insert assignment;

        // 将记录改为非激活
        assignment.Active__c = false;
        update assignment;

        // 验证Account共享记录已删除
        List<AccountShare> accShares = [
            SELECT Id FROM AccountShare 
            WHERE AccountId = :testAcc.Id 
            AND UserOrGroupId = :testSalesRep.Id
        ];
        System.assertEquals(0, accShares.size(), 'Account共享记录未删除');

        // 验证Order共享记录已删除
        List<OrderShare> orderShares = [
            SELECT Id FROM OrderShare 
            WHERE OrderId = :testOrder.Id 
            AND UserOrGroupId = :testSalesRep.Id
        ];
        System.assertEquals(0, orderShares.size(), 'Order共享记录未删除');
    }

    // 测试：将非激活记录重新激活，验证共享记录重新生成
    @isTest
    static void testReactivateAssignment(){
        User testSalesRep = [SELECT Id FROM User WHERE Username LIKE '%test.rep%' LIMIT 1];
        Account testAcc = [SELECT Id FROM Account WHERE Name = 'Test Account' LIMIT 1];
        Order testOrder = [SELECT Id FROM Order WHERE AccountId = :testAcc.Id LIMIT 1];

        Sales_Rep_Assignment__c assignment = new Sales_Rep_Assignment__c(
            Account__c = testAcc.Id,
            Sales_Reps__c = testSalesRep.Id,
            Active__c = false
        );
        insert assignment;

        // 改为激活状态
        assignment.Active__c = true;
        update assignment;

        // 验证Account共享记录重新生成
        List<AccountShare> accShares = [
            SELECT Id FROM AccountShare 
            WHERE AccountId = :testAcc.Id 
            AND UserOrGroupId = :testSalesRep.Id
            AND AccountAccessLevel = 'Edit'
        ];
        System.assertEquals(1, accShares.size(), 'Account共享记录未重新生成');

        // 验证Order共享记录重新生成
        List<OrderShare> orderShares = [
            SELECT Id FROM OrderShare 
            WHERE OrderId = :testOrder.Id 
            AND UserOrGroupId = :testSalesRep.Id
            AND OrderAccessLevel = 'Edit'
        ];
        System.assertEquals(1, orderShares.size(), 'Order共享记录未重新生成');
    }

    // 测试：删除激活的分配记录，验证共享记录删除
    @isTest
    static void testDeleteActiveAssignment(){
        User testSalesRep = [SELECT Id FROM User WHERE Username LIKE '%test.rep%' LIMIT 1];
        Account testAcc = [SELECT Id FROM Account WHERE Name = 'Test Account' LIMIT 1];
        Order testOrder = [SELECT Id FROM Order WHERE AccountId = :testAcc.Id LIMIT 1];

        Sales_Rep_Assignment__c assignment = new Sales_Rep_Assignment__c(
            Account__c = testAcc.Id,
            Sales_Reps__c = testSalesRep.Id,
            Active__c = true
        );
        insert assignment;

        // 删除分配记录
        delete assignment;

        // 验证Account共享记录已删除
        List<AccountShare> accShares = [
            SELECT Id FROM AccountShare 
            WHERE AccountId = :testAcc.Id 
            AND UserOrGroupId = :testSalesRep.Id
        ];
        System.assertEquals(0, accShares.size(), 'Account共享记录未删除');

        // 验证Order共享记录已删除
        List<OrderShare> orderShares = [
            SELECT Id FROM OrderShare 
            WHERE OrderId = :testOrder.Id 
            AND UserOrGroupId = :testSalesRep.Id
        ];
        System.assertEquals(0, orderShares.size(), 'Order共享记录未删除');
    }
}

补充说明

原代码已修正多处逻辑错误：包括共享记录的正确赋值、DML操作批量优化、删除场景的完整处理，以及补充了需求中要求的Account共享逻辑
测试类使用@testSetup统一初始化测试数据，提升测试执行效率
测试覆盖了所有业务场景，确保共享逻辑的正确性

内容的提问来源于stack exchange，提问作者Witaliy Galiy

请求编写Salesforce Apex测试类：销售共享逻辑验证

修正后的共享类代码 #

对应的Apex测试类 #

补充说明 #

修正后的共享类代码

对应的Apex测试类

补充说明