Hi, I have Return Randomized logic, and logic is working as expected, but during the deployment Test class, throwing an error. Test coverage is 75%. During deployment, it is showing as 50%.
Please help to resolve the error. Thank you very much for your help!

Error Message: System.DmlException: Insert failed. First exception on row 0; first error: CANNOT_EXECUTE_FLOW_TRIGGER, We can't save this record because the “Panel List Member: Set Last Panel Assign Date” process failed. Give your Salesforce admin these details. <b>An unhandled fault has occurred in this flow</b><br>An unhandled fault has occurred while processing the flow. Please contact your system administrator for more information.: []
Stack Trace: Class.PanelListSelection_ControllerTest.testController: line 27, column 1.

Apex Class

public class PanelListSelection_Controller {

    @AuraEnabled
    public static List<Panel_List_Member__c> addAvailablePanelListMembersToPanelList(String panelListId) {
        Panel_List__c panelList = getPanelListDetails(panelListId);
        List<Panel_List_Member__c> newPanelMembers = addPanelListMembersToPanelList(panelList, Integer.valueOf(panelList.Number_Available_Members__c));
        panelList.Status__c = 'Panel Selected';
        update panelList;
        return newPanelMembers;
    }

    @AuraEnabled
    public static List<Panel_List_Member__c> addPanelListMembersToPanelList(String panelListId, Integer numberOfMembersToAdd) {
        Panel_List__c panelList = getPanelListDetails(panelListId);
        return addPanelListMembersToPanelList(panelList, numberOfMembersToAdd);
    }

    @AuraEnabled
    public static List<Panel_List_Member__c> addPanelListMembersToPanelList(Panel_List__c panelList, Integer numberOfMembersToAdd) {
        
        List<Account> newPanelListMemberAccounts = getAvailablePanelMembers(panelList, numberOfMembersToAdd);

        List<Panel_List_Member__c> newPanelListMembers = new List<Panel_List_Member__c>();
        for(Account acc : newPanelListMemberAccounts) {
            newPanelListMembers.add(new Panel_List_Member__c(
                Case_System_ID__c = panelList.Case_System_ID__c,
                Panel_List__c = panelList.Id,
                Panel_Member__c = acc.PersonContactId,
                Status__c = 'Selected'
            ));
        }

        if(newPanelListMembers.size() != numberOfMembersToAdd)
            panelList.addError('No available panel members to select from'); 

        if(newPanelListMembers.size() > 0)
            insert newPanelListMembers;

        return newPanelListMembers;
    }

    public static List<Account> getAvailablePanelMembers(Panel_List__c panelList, Integer numberOfMembersToAdd) {

        String query = 'SELECT Id, Name, PersonContactId FROM Account WHERE Panel_Member_Status__c = \'Active\' AND Process_Category_Eligibility__c INCLUDES (\'' + panelList.Panel_Type__c + '\') ';
        if(!String.isBlank(panelList.Special_Criteria_to_Include_in_Draw__c))
            query += ' AND Panel_Member_Additional_Criteria__c INCLUDES (\'' + panelList.Special_Criteria_to_Include_in_Draw__c + '\') ';
        if(!String.isBlank(panelList.Special_Criteria_to_Exclude_in_Draw__c))
            query += ' AND Panel_Member_Additional_Criteria__c EXCLUDES (\'' + panelList.Special_Criteria_to_Exclude_in_Draw__c + '\') ';
        List<Account> availablePanelMembers = Database.query(query);
        Map<Id,Account> availablePanelMembersMap = new Map<Id,Account>();
        for(Account acc:availablePanelMembers){
            availablePanelMembersMap.put(acc.Id,acc);
        }
        List<Account> finalListPanelMembers = new List<Account>();
        Set<Id> finalMemberIds = getFinalPanelListMemberIdSet(panelList,availablePanelMembersMap.keySet(),numberOfMembersToAdd);
        system.debug(':::finalMemberIds:::'+finalMemberIds);
        if(finalMemberIds != null && finalMemberIds.size() > 0){
            for(Id memberId : finalMemberIds){
                finalListPanelMembers.add(availablePanelMembersMap.get(memberId));
            }
        }
                
        system.debug('::::availablePanelMembers:::'+finalListPanelMembers);
        return finalListPanelMembers;
    }

    // The panel members that are selected cannot be on the most recent panel list for the same Panel Type.
    // 1. Get Available Accounts
    // 2. Recent 100 Panel List related members with same type with Descending order
    // 3. If Panel List size =1, Process only other than recent panel members
    // 4. If Panel List Size greater than 1 
    // 4.a Get the count of total panel list assigned to each panel member by excluding recent panel members
    // 4.b Sort the Panel Members in Ascending order
    // 5. Process available panel member with the panel members fetched at above step

    public static Set<Id> getFinalPanelListMemberIdSet(Panel_List__c panelList,Set<Id> availableMemberIdSet,Integer numberOfMembersToAdd) {
     	Set<Id> finalIdSet = new Set<Id>();
        List<MemberCountWrapper> memberWrapList = new List<MemberCountWrapper>();
        try {
            List<Panel_List__c> latestPanelList = [SELECT Id,CreatedDate, 
                                                (SELECT Panel_Member__c, Panel_Member__r.AccountId 
                                                   FROM Panel_List_Members__r
                                                  WHERE Panel_Member__r.Account.Panel_Member_Status__c = 'Active')
                                            FROM Panel_List__c 
                                            WHERE Panel_Type__c = :panelList.Panel_Type__c AND Id != :panelList.Id 
                                            ORDER BY CreatedDate DESC LIMIT 100];
            Map<Id,Integer> memberCountMap = new Map<Id,Integer>();
            Panel_List__c recentPL;
            List<Id> recentMembers = new List<Id>();
            if(latestPanelList != null && latestPanelList.size() > 0){
                recentPL = latestPanelList.get(0);
                for(Panel_List_Member__c plm : recentPL.Panel_List_Members__r) {
                    if(plm.Panel_Member__r.AccountId != null ){
                        recentMembers.add(plm.Panel_Member__r.AccountId);
                    }
                }
                if(latestPanelList.size() == 1){
                    for(Id availableId : availableMemberIdSet ){
                        if( recentMembers != null && !recentMembers.contains(availableId) && finalIdSet.size() < numberOfMembersToAdd ){
                            finalIdSet.add(availableId);
                        }
                    }
                }
            }

            if(latestPanelList != null && latestPanelList.size() > 1){
            	latestPanelList.remove(0);
                for(Panel_List__c pl : latestPanelList) {
                    for(Panel_List_Member__c plm : pl.Panel_List_Members__r) {
                        if(plm.Panel_Member__r.AccountId != null ){ 
                            if(!memberCountMap.containsKey(plm.Panel_Member__r.AccountId)){
                                memberCountMap.put(plm.Panel_Member__r.AccountId,0);
                            }
                            Integer count = memberCountMap.get(plm.Panel_Member__r.AccountId)+1;
                            memberCountMap.put(plm.Panel_Member__r.AccountId,count);    
                        }
                    }
                    for(Id recentMember : recentMembers){
                        if(memberCountMap.containsKey(recentMember)){
                            memberCountMap.remove(recentMember);
                        }
                    }
                }    
            }
            
            //process non-assigned members first  
            for(Id availableId : availableMemberIdSet ){
                if(memberCountMap != null && !memberCountMap.containsKey(availableId) && recentMembers != null && !recentMembers.contains(availableId) && finalIdSet.size() < numberOfMembersToAdd ){
                    finalIdSet.add(availableId);
                }
            }
            //process recent members
            Map<Integer,List<Id>> countMemberIdListMap = new Map<Integer,List<Id>>();
            if(memberCountMap != null && memberCountMap.size() > 0){
                for(Id memberId:memberCountMap.keySet()){
                    if(!countMemberIdListMap.containsKey(memberCountMap.get(memberId))){
                        countMemberIdListMap.put(memberCountMap.get(memberId),new List<Id>());
                    }
                    countMemberIdListMap.get(memberCountMap.get(memberId)).add(memberId);
                }
            }
            for(Integer count: countMemberIdListMap.keyset()) {
                memberWrapList.add(new MemberCountWrapper(countMemberIdListMap.get(count),count));
            }
            memberWrapList.sort();
            for(MemberCountWrapper mcw : memberWrapList){
                system.debug('::process-count:::'+mcw.counter+':::'+mcw.memberIds);
                for(Id memberId : mcw.memberIds ){
                    if(availableMemberIdSet.contains(memberId) && finalIdSet.size() < numberOfMembersToAdd){
                        finalIdSet.add(memberId);
                    } 
                }
            }
            //process most recent members
            if(finalIdSet.size() < numberOfMembersToAdd && recentMembers != null && recentMembers.size() > 0){
                for(Id memberId : recentMembers ){
                    if(availableMemberIdSet.contains(memberId) && finalIdSet.size() < numberOfMembersToAdd){
                        finalIdSet.add(memberId);
                    } 
                }
            }
               
        } 
        catch(Exception ex) {  /* apex not liking this query for return 0 results */
        }
        return finalIdSet;
    }
    
    @AuraEnabled
    public static List<Panel_List_Member__c> replacePanelMember(String panelListMemberId) {
        Panel_List_Member__c panelListMember = getPanelListMemberDetails(panelListMemberId);
        panelListMember.Status__c = 'Rejected';
        update panelListMember;

        return addPanelListMembersToPanelList(panelListMember.Panel_List__c, 1);
    }
    
    @AuraEnabled
    public static Panel_List__c setNewPanelChairMemberTieBreaker(String panelListId) {
        List<Panel_List_Member__c> panelListMembers = [SELECT Id, Panel_Score__c, Panel_Member__c FROM Panel_List_Member__c WHERE Panel_List__c = :panelListId AND Status__c = 'Selected' ORDER BY Panel_Score__c ASC];
        List<Panel_List_Member__c> panelChairTieMembers = new List<Panel_List_Member__c>();
        Decimal tiedScoreValue = panelListMembers[0].Panel_Score__c;
        for(Panel_List_Member__c plm : panelListMembers) {
            if(plm.Panel_Score__c == tiedScoreValue)
                panelChairTieMembers.add(plm);
            else
                break;
        }

        Integer randomIndex = Integer.valueOf(Math.floor(Math.random() * (( panelChairTieMembers.size() -1)+1) + 1)) - 1;

        return setNewPanelChairMember(panelListId, panelChairTieMembers[randomIndex]);
    }
    
    @AuraEnabled
    public static Panel_List__c setNewPanelChairMember(String panelListId) {
        List<Panel_List_Member__c> newPanelListChairMember = addPanelListMembersToPanelList(panelListId, 1);
        return setNewPanelChairMember(panelListId, newPanelListChairMember[0]);
    }

    public static Panel_List__c setNewPanelChairMember(String panelListId, Panel_List_Member__c newPanelChair) {
        Panel_List__c pl = new Panel_List__c(Id = panelListId, Selected_Panel_Chair__c = newPanelChair.Panel_Member__c, Status__c = 'Panel Chair Appointed');
        update pl;
        return pl;
    }

    public static Panel_List__c getPanelListDetails(Id recordId) {
        return [SELECT Id, Active__c, Case_System_ID__c, List_Type__c, Panel_Iteration__c, Panel_Size__c, Number_Selected_Members__c, Number_Available_Members__c, Panel_Type__c, Selected_Panel_Chair__c, Special_Criteria_to_Exclude_in_Draw__c, Special_Criteria_to_Include_in_Draw__c, Status__c
                FROM Panel_List__c
                WHERE Id = :recordId LIMIT 1];
    }

    public static Panel_List_Member__c getPanelListMemberDetails(Id recordId) {
        return [SELECT Id, Panel_List__c, Status__c FROM Panel_List_Member__c WHERE Id = :recordId LIMIT 1];
    }
    
    public class MemberCountWrapper implements Comparable{
        public Integer counter;
        public List<Id> memberIds;
        public MemberCountWrapper(List<Id> memberIds, Integer counter) {
            this.memberIds = memberIds;
            this.counter = counter;
        }
        public Integer compareTo(Object compareTo) {
            MemberCountWrapper compareToMem = (MemberCountWrapper)compareTo;
            if (counter == compareToMem.counter) return 0;
            if (counter > compareToMem.counter) return 1;
            return -1;        
        }
    }
}

Test Class

@isTest
public class PanelListSelection_ControllerTest  {

    @isTest
    static void testController() {
        
        Account testAcc = TestDataFactory.getPersonAccount();
        testAcc.Process_Category_Eligibility__c = '312';
        testAcc.Panel_Member_Additional_Criteria__c = 'Blue Ribbon';
        testAcc.Panel_Member_Status__c = 'Active';
        insert testAcc;
        Contact c = new Contact(LastName = 'test');
        insert c;

        Case testCase = TestDataFactory.getCase();
        insert testCase;

        Panel_List__c testPanelList = TestDataFactory.getPanelList(testCase.Id);
        insert testPanelList;
        
        Panel_List__c testPaneChair = TestDataFactory.getPanelList(testCase.Id);
        insert testPaneChair;
        
              
         List<Panel_List_Member__c> newMembers = PanelListSelection_Controller.addAvailablePanelListMembersToPanelList(testPanelList.Id);
         Panel_List_Member__c plm = new Panel_List_Member__c(Panel_List__c = testPanelList.Id, Status__c = 'Selected');
         insert plm;
         plm.Status__c = 'Rejected';
         update plm;

        
         PanelListSelection_Controller.replacePanelMember(plm.Id);

         PanelListSelection_Controller.setNewPanelChairMemberTieBreaker(testPanelList.Id);
        
         PanelListSelection_Controller.setNewPanelChairMember(testPaneChair.Id);
           }
}