Is there a way I can mock an AggregateResult?

Question

I'm trying to write most of my tests without hitting salesforce database. For that I'm implementing some simple mock class where I just return some SOQL queries when needed. The problem I'm facing now is with AggregateResult. Was someone able to create in memory this so that I can returned it in one of my mocked methods?

The query I want to mock in this particular case is: [SELECT MIN(CreatedDate) minCaseCreateDate FROM Case WHERE Id in :caseIds]

Answer 1

Check edit history for my initial approach. After revisiting this question and with a bit more experience, I would pursue this path:

public class Aggregate
{
    public static List<Aggregate> query(List<AggregateResult> results)
    {
        return service.convert(results);
    }

    final Map<String, Object> data;
    public Aggregate(AggregateResult result)
    {
        data = result.getPopulatedFieldsAsMap();
    }
    public Object get(String alias) { return data.get(alias); }

    @TestVisible Aggregate() { data = new Map<String, Object>(); }
    @TestVisible Aggregate put(String alias, Object value)
    {
        data.put(alias, value);
        return this;
    }

    static Service service = new Service();
    @TestVisible static void setMock(Service mock) { service = mock; }
    @TestVisible virtual class Service
    {
        protected virtual List<Aggregate> convert(List<AggregateResult> results)
        {
            List<Aggregate> aggregates = new List<Aggregate>();
            for (AggregateResult result : results)
                aggregates.add(new Aggregate(result));
            return aggregates;
        }
    }
}

I was able to reference this query quite similar to how it would normally look:

List<Aggregate> aggregates = Aggregate.query([
    SELECT ProfileId, count(Id) records
    FROM User GROUP BY ProfileId
]);
for (Aggregate aggregate : aggregates)
{
    system.debug(aggregate.get('ProfileId') + ' - ' + aggregate.get('records'));
}

And it would be quite easy to mock:

@IsTest
class AggregateTests
{
    class Mock extends Aggregate.Service
    {
        final List<Aggregate> aggregates = new List<Aggregate>();
        public Mock add(Aggregate aggregate)
        {
            aggregates.add(aggregate);
            return this;
        }
        public override List<Aggregate> convert(List<AggregateResult> results)
        {
            return aggregates;
        }
    }
    @IsTest static void testMocking()
    {
        Id dummyId = SObjectType.Profile.getKeyPrefix().rightPad(15, '0');

        Mock fakeData = new Mock().add(new Aggregate()
            .put('ProfileId', dummyId)
            .put('records', 42));

        Test.startTest();
            Aggregate.setMock(fakeData);
            List<Aggregate> aggregates = Aggregate.query([
                SELECT ProfileId, count(Id) records
                FROM User GROUP BY ProfileId
            ]);
        Test.stopTest();

        system.assertEquals(1, aggregates.size(), 'Only mock data should be returned');
        system.assertEquals(dummyId, aggregates[0].get('ProfileId'), 'Only mock data should be returned');
        system.assertEquals(42, aggregates[0].get('records'), 'Only mock data should be returned');
    }
}

Answer 2

I so much wanted @AdrianLarson original Json.deserialize answer to be right as it is easy to fabricate but while it works at compile time, at run time, the deserialized AggregateResult is empty ( debug displays as {} ).

So, here's what I did:

Create an AggregateResultProxy object

/**
 * AggregateResult can't be mocked so wrap with AggregateResultProxy
 * which can be mocked by test methods. 
 */

public class AggregateResultProxy {

    Map<String,Object> valuesByAlias = new Map<String,Object> ();

    public AggregateResultProxy withAggregateResult(AggregateResult groupedResult) {
        String groupedResultJson = JSON.serialize(groupedResult);
        this.valuesByAlias = (Map<String,Object>) JSON.deserializeUntyped(groupedResultJson);
        return this;
    }
    public AggregateResultProxy withAliasAndValue(String alias, Object val) {
        this.valuesByAlias.put(alias,val);
        return this;
    }

    public Map<String,Object> getValuesByAlias() {return this.valuesByAlias;}
}

My selector method

return not a List<AggregateResult> but instead a List<AggregateResultProxy>

AggregateResultProxy[] mySelectorMethod(...) {
   AggregateResultProxy[] groupedResultProxies = new List<AggregateResultProxy>();
   for (AggregateResult groupedResult: 
         [SELECT COUNT(ID) RECORDCOUNT, Status STATUS
            FROM Asset 
            WHERE ...
            GROUP BY Status ] ) {
    groupedResultProxies.add(
      new AggregateResultProxy().withAggregateResult(groupedResult));
  }
  return groupedResultProxies;
}

My runtime code

public void doStuff() {
  for (AggregateResultProxy groupedResultProxies :AssetsSelector.newInstance().mySelectorMethod() ) {
    Map<String,Object> groupedResultProxy = groupedResultProxies.getValuesByAlias();
    System.debug('Status = ' + groupedResultProxy.get('STATUS'));
    System.debug('Count = ' + groupedResultProxy.get('RECORDCOUNT')); 
  }
}

which might display

Status = Active
Count = 23
Status = Canceled
Count = 6 

and my testmethod

using ApexMocks (you could of course use your own favorite dependency injection approach)

fflib_ApexMocks mocks = new fflib_ApexMocks();
// given mocked AggregateResults
AggregateResultProxy[] mockedGroupedResults = new List<AggregateResultProxy> {
   new AggregateResultProxy()
     .withAliasAndValue('STATUS','Active')
     .withAliasAndValue('RECORDCOUNT', 2),
   new AggregateResultProxy()
     .withAliasAndValue('STATUS','Cancelled')
     .withAliasAndValue('RECORDCOUNT', 7)
}; 
// Given mock selector (stubbed return val)
AssetsSelector mocksSelector = (AssetsSelector) mocks.mock(AssetsSelector.class);
mocks.startStubbing();
mocks.when(mocksSelector.sObjectType()).thenReturn(Asset.SObjectType);
mocks.when(mocksSelector.mySelector(...))
                .thenReturn(mockedGroupedResults);
mocks.stopStubbing();
// Given mocks injected
Application.Selector.setMock(mocksSelector);

// When myMethodUnderTestIsCalled
myObject.doStuff();
// Then verify ...
...asserts or apexMocks verifies go here