Hi team,
I facing issues in the first challenge in APEX Specialist superBadge.
what I have done in this challenge is 
step-1>>  I created New trailhead
Step-2>> Install the unmanaged package(How We Roll Maintenance)
step-3>> Renamed the Objects  "Case" TO "Maintenance Request"
                                             "Products"  TO "Equipment"
Note;  I also changed "Products" TO "Vehicle" 
 
Step-4 >>Here My Code :
MY TRIGGER:
trigger MaintenanceRequest on Case (before update, after update) {
    if ( Trigger.isAfter && Trigger.isUpdate ) {
        MaintenanceRequestHelper.updateWorkOrders ( Trigger.New, Trigger.OldMap );
    }
}
MY APEX CLASS:
public class MaintenanceRequestHelper {
    
    // Retrieve the Cases from the database, in order to retrieve the related Equipments.
    public static List<Case> updatedMaintenanceList( List<Case> maintenanceRequests ) {
        return [ SELECT ID, Equipment__r.Maintenance_Cycle__c, Type, Status, Vehicle__c, Subject, Equipment__c FROM CASE WHERE ID =: maintenanceRequests ];
    }
    
    // Create a new Routine and Update Work Orders
    public static void updateWorkOrders( List<Case> maintenanceRequests, Map<Id, Case> mapOldRecords ) {
    
        List<Case> maintenanceRequestsThatMetTheCriteria = new List<Case>();
    
        // New maintenances.
        List<Case> newMaintenanceListForRoutineCheckup = new List<Case>();
        
        // Iterating to check for those that meet the criteria
        for ( Case maintenanceRequest : updatedMaintenanceList( maintenanceRequests ) ) {
            Case oldMaintenance = mapOldRecords.get( maintenanceRequest.Id );
            
            if ( meetCriteria( maintenanceRequest, oldMaintenance ) && maintenanceRequest.Type == 'Repair' || maintenanceRequest.Type == 'Routine Maintenance' ) {
                maintenanceRequestsThatMetTheCriteria.add( maintenanceRequest );
            }
        }
        
        // Retrieve the mimimun number of cycle days required to close the newest case.
        Map<Id, Decimal> mapMaintenanceIdWithCycleDays = retrieveMinimunCycleDays( maintenanceRequestsThatMetTheCriteria );
        
        for ( Case newMaintenaceRequest : maintenanceRequestsThatMetTheCriteria ) {
            // Create a new routine once the first one is closed, with same vehicle and equipment
            Case routineCheckupMaintenance = new Case();
            routineCheckupMaintenance.Vehicle__c = newMaintenaceRequest.Vehicle__c;
            routineCheckupMaintenance.Equipment__c = newMaintenaceRequest.Equipment__c;
            routineCheckupMaintenance.Type = 'Routine Maintenance';
            routineCheckupMaintenance.Subject = String.isBlank( newMaintenaceRequest.Subject ) ? 'New Routine ' : newMaintenaceRequest.Subject;
            routineCheckupMaintenance.Status = 'New';
            routineCheckupMaintenance.Date_Reported__c = System.today();
            if ( mapMaintenanceIdWithCycleDays.containsKey( newMaintenaceRequest.Id ) ) {
                routineCheckupMaintenance.Date_Due__c = System.today().addDays( ( Integer ) mapMaintenanceIdWithCycleDays.get( newMaintenaceRequest.Id ) );
            } //else {
              //  routineCheckupMaintenance.Date_Due__c = System.today().addDays( ( Integer ) newMaintenaceRequest.Equipment__r.Maintenance_Cycle__c );
            //}
            routineCheckupMaintenance.Old_Case__c  = newMaintenaceRequest.Id;
            newMaintenanceListForRoutineCheckup.add( routineCheckupMaintenance );  
        }
        
        insert newMaintenanceListForRoutineCheckup;
        updateRelatedWorkParts( newMaintenanceListForRoutineCheckup );
    }
    
    // Once the new maintenance records are created, update the work parts
    public static void updateRelatedWorkParts( List<Case> createdMaintenances) {
        
        Map<Id, Id> mapNewMaintenancesWithClosedMaintenances = new Map<Id, Id>();
        for ( Case newMaintenances : createdMaintenances ) {
            mapNewMaintenancesWithClosedMaintenances.put( newMaintenances.Old_Case__c , newMaintenances.Id );
        }
        
        List<Work_Part__c> workParkList = new List<Work_Part__c>();
        
        // Query work parts to be updated
        for ( Work_Part__c workPart : [ SELECT Id, Maintenance_Request__c, Equipment__c, Quantity__c  FROM Work_Part__c
                                            WHERE Maintenance_Request__c =: mapNewMaintenancesWithClosedMaintenances.keySet() ] ) {
            workParkList.add(new Work_Part__c(Maintenance_Request__c = mapNewMaintenancesWithClosedMaintenances.get( workPart.Maintenance_Request__c ), 
                                              Equipment__c = workPart.Equipment__c, Quantity__c = workPart.Quantity__c));
        }
        
        insert workParkList;
    }
    
    // Method to check if the cases being updated meet the criteria (They must be closed)
    public static boolean meetCriteria( Case newcase, Case oldMaintenance ) {
        Boolean falg = false;
        if ( newCase.Status == 'Closed' && oldMaintenance.Status != newCase.Status ) {
            falg = true;
        }
        return falg;
    }
    
    // Use an aggregate function to return the minimum number of cycle days related to the Case
    public static Map<Id, Decimal> retrieveMinimunCycleDays( List<Case> maintenanceRequests ) {
        
      AggregateResult[] listWorkParts = [ SELECT Maintenance_Request__c, MIN( Equipment__r.Maintenance_Cycle__c )
                             FROM Work_Part__c WHERE Maintenance_Request__c =: maintenanceRequests 
                            Group By Maintenance_Request__c ];
    
    Map<Id, Decimal> mapWorkPartaAndMaintenanceRecords = new Map<Id, Decimal>();        
        for ( AggregateResult ar : listWorkParts ) {
            mapWorkPartaAndMaintenanceRecords.put( ( Id ) ar.get( 'Maintenance_Request__c' ), ( Decimal ) ar.get( 'expr0' ) );
        }
        
        return mapWorkPartaAndMaintenanceRecords;
    }
    
}

MY APEX TEST
@isTest
public class MaintenanceRequestTest {

    @testSetup
    static void setup(){
        Product2 prod = new Product2();
        prod.Cost__c = 50;
        prod.Name = 'Ball Valve 10 cm';
        prod.Lifespan_Months__c = 12;
        prod.Maintenance_Cycle__c = 365;
        prod.Current_Inventory__c = 50;
        prod.Replacement_Part__c = true;
        prod.Warehouse_SKU__c = '100009';
        insert prod;
        
        Product2 prod2 = new Product2();
        prod2.Cost__c = 50;
        prod2.Name = 'Ball Valve 10 cm';
        prod2.Lifespan_Months__c = 12;
        prod2.Maintenance_Cycle__c = 240;
        prod2.Current_Inventory__c = 50;
        prod2.Replacement_Part__c = true;
        prod2.Warehouse_SKU__c = '100009';
        insert prod2;
        
        List<Case> caseList = new List<Case>();
        for(Integer i=0; i<300; i++) {
            Case caseNew = new Case();
            caseNew.Subject = 'Maintenance ' + i;
            caseNew.Type = 'Other';
            caseNew.Status = 'New';
            caseNew.Equipment__c = prod.Id;
            caseNew.SuppliedName = 'Test';
            caseList.add(caseNew);   
            
            if(i==10){
                caseNew.Subject = 'Maintenance test 10';
            }
        }
        
        insert case list;
        
        List<Work_Part__c> workPartList = new List<Work_Part__c>();
        for(Case caseHere : [select Id, Subject from Case where SuppliedName = 'Test']) {
            Work_Part__c workPart = new Work_Part__c();
            workPart.Maintenance_Request__c = caseHere.Id;
            workPart.Equipment__c = prod.Id;
            workPartList.add(workPart);   
            
            if(caseHere.Subject == 'Maintenance test 10'){
                Work_Part__c workPart2 = new Work_Part__c();
                workPart2.Maintenance_Request__c = caseHere.Id;
                workPart2.Equipment__c = prod2.Id;
                workPartList.add(workPart2);
            }
        }
        
        insert workPartList;
    }
    
    @isTest
    static void testMaintenanceRequest(){
        List<Case> caseList = new List<Case>();
        for(Case caseHere : [select Id from Case where SuppliedName = 'Test']) {
            caseHere.Type = 'Repair';
            caseHere.Status = 'Closed';
            caseList.add(caseHere);
        }
        
        Test.startTest();
        update caseList;
        System.assertEquals(300, [SELECT count() FROM Case WHERE Type = 'Routine Maintenance' and Date_Reported__c = :Date.today()]);
        Test.stopTest();
        
    }
}
 
MY ERROR:

Challenge Not yet complete... here's what's wrong:
Closing a Maintenance Request of type 'Routine Maintenance' or 'Repair' did not create of a new Maintenance Request with the correct due date. The challenge is expecting the due date to be calculated using the maintenance cycle defined on the related equipment records. If multiple equipments are used in the maintenance request, choose the shortest maintenance cycle to define the service date.
Close errors
 
Thanks in advance
Further Information:
My Email Id:anagarajasfdc@gmail.com