Changing the CalloutUtil.makeRestCallout to an @future method is a way to address the problem of the "You have uncommitted work pending. Please commit or rollback before calling out" error. This error occurs when a DML operation is performed before a callout to an external service, such as a REST endpoint. This is because the DML operation locks the database records and prevents them from being rolled back if the callout fails. To avoid this error, the developer can use the @future annotation to mark the CalloutUtil.makeRestCallout method as asynchronous, which means it will run in a separate thread after the DML operation is committed. This way, the DML operation and the callout will not interfere with each other, and the error will be resolved. Reference: [Asynchronous Apex], [Making Callouts]

To resolve the error, the developer should ensure the records are inserted before the Test.startTest() statement and the mock callout occurs after the Test.startTest() statement. The Test.startTest() and Test.stopTest() methods are used to mark the boundaries of the test code that contains the logic to be tested. The Test.startTest() method also resets the governor limits, such as the number of DML statements, SOQL queries, and callouts, for the test code. The Test.stopTest() method also forces the asynchronous processes, such as batch jobs, future methods, and queueable jobs, to run synchronously. The error 'You have uncommitted work pending. Please commit or rollback before calling out' occurs when a test method tries to make a callout after performing a DML operation in the same transaction, as this may cause data inconsistency or deadlock issues. To avoid this error, the developer should insert the records before the Test.startTest() statement, so that the DML operation is not counted in the same transaction as the callout. The developer should also make the mock callout after the Test.startTest() statement, so that the callout is counted in the test code transaction, and the Test.stopTest() method can force the callout to complete before the assertions. Ensuring both the insertion and mock callout occur after the Test.stopTest() statement would not resolve the error, as the Test.stopTest() statement should be the last statement in the test method, and any code after it would not be executed. Ensuring the records are inserted before the Test.startTest() statement and the mock callout occurs within a method annotated with @testSetup would not resolve the error, as the @testSetup annotation is used to create test data for all test methods in a test class, not to make mock callouts. Ensuring both the insertion and mock callout occur after the Test.startTest() statement would not resolve the error, as the insertion and mock callout would still be in the same transaction, and cause the error. Reference: [Testing HTTP Callouts], [Using Test.startTest and Test.stopTest]

The most likely reason to get the error message 'Maximum Trigger Depth Exceeded' is that a trigger is recursively invoked more than 16 times. This means that the trigger is causing an update on the same object that it is triggered on, which in turn fires the trigger again, creating an infinite loop. To avoid this, the developer should use a static variable or a collection to track the records that have already been processed by the trigger and prevent them from being updated again. The SOQL governor limits, the number of DML operations, and the inclusion of a flow trigger are not directly related to this error message, although they might also cause other performance issues or exceptions. Reference: [Triggers and Order of Execution], [Apex Developer Guide]

The best way to achieve this is to schedule a batch Apex process to run every day that queries and deletes records older than seven years. Batch Apex allows the developer to process large sets of data in batches, which can handle up to 50 million records per execution. Batch Apex also supports scheduling, which allows the developer to specify the frequency and time of the execution. In this case, the developer can write a batch Apex class that implements the Database.Batchable and Schedulable interfaces, and query and delete the records that are older than seven years in the execute method. Scheduling an asynchronous process to query records older than seven years, and then recursively invoke itself in 1,000 record batches to delete them will not work, as it will hit the governor limits on the number of asynchronous jobs or the heap size. Using aggregate functions to query for records older than seven years, and then delete the aggregateResults objects will not work, as aggregateResults objects are read-only and cannot be deleted. Performing a SOSL statement to find records older than 7 years, and then delete the entire result set will not work, as SOSL does not support date literals or comparison operators, and the result set might exceed the DML limit of 10,000 records per transaction. Reference: [Batch Apex], [Schedulable Interface], [Apex Developer Guide]