260 updates

Author: jamessimone

force-app/repository/Cursor.cls

@@ -1,8 +1,11 @@
-@SuppressWarnings('PMD.EmptyCatchBlock,PMD.EmptyStatementBlock')
 public virtual without sharing class Cursor {
-  private static final Integer MAX_FETCH_SIZE = 2000;
+  @TestVisible
+  private static Integer maxFetchSize = 2000;
   private static final Integer MAX_FETCHES_PER_TRANSACTION = Limits.getLimitFetchCallsOnApexCursor();
+  @TestVisible
+  private static Integer localFetchesMade;
 
+  private Integer cursorNumRecords;
   private Integer fetchesPerTransaction = 1;
   private final Database.Cursor cursor;
 
@@ -45,33 +48,41 @@ public virtual without sharing class Cursor {
       System.debug(System.LoggingLevel.DEBUG, 'Bypassing fetch call, no records to fetch');
       return new List<SObject>();
     }
-    Integer localFetchesMade = 0;
+    localFetchesMade = localFetchesMade ?? 0;
     Integer localStart = start;
     List<SObject> results = new List<SObject>();
-    while (localFetchesMade < this.fetchesPerTransaction) {
-      results.addAll(this.cursor?.fetch(start, this.getAdvanceBy(start, advanceBy)) ?? new List<SObject>());
-      localStart += advanceBy;
+    while (
+      localFetchesMade < this.fetchesPerTransaction &&
+      results.size() < this.getNumRecords() &&
+      localStart < start + advanceBy
+    ) {
+      Integer actualAdvanceBy = this.getAdvanceBy(localStart, advanceBy);
+      results.addAll(this.cursor?.fetch(localStart, actualAdvanceBy) ?? new List<SObject>());
+      localStart += actualAdvanceBy;
       localFetchesMade++;
     }
     return results;
   }
 
   public virtual Integer getNumRecords() {
-    return this.cursor?.getNumRecords() ?? 0;
+    // cache the value for now, as changes made to Apex Cursors currently have calling getNumRecords()
+    // consume a SOQL query each time
+    this.cursorNumRecords = this.cursorNumRecords ?? this.cursor?.getNumRecords() ?? 0;
+    return this.cursorNumRecords;
   }
 
   protected Integer getAdvanceBy(Integer start, Integer advanceBy) {
     Integer possibleFetchSize = Math.min(advanceBy, this.getNumRecords() - start);
-    if (possibleFetchSize > MAX_FETCH_SIZE) {
+    if (possibleFetchSize > maxFetchSize) {
       System.debug(
         System.LoggingLevel.DEBUG,
         'Fetch size: ' +
           possibleFetchSize +
           ' exceeded platform max fetch size of ' +
-          MAX_FETCH_SIZE +
+          maxFetchSize +
           ', defaulting to max fetch size'
       );
-      possibleFetchSize = MAX_FETCH_SIZE;
+      possibleFetchSize = maxFetchSize;
     } else if (possibleFetchSize < 0) {
       possibleFetchSize = 0;
     }

force-app/repository/CursorTest.cls

@@ -2,47 +2,95 @@
 private class CursorTest {
   @IsTest
   static void itCapsAdvanceByArgument() {
-    String query = 'SELECT Id FROM User WHERE Id = :bindVar0';
-    Map<String, Object> bindVars = new Map<String, Object>{ 'bindVar0' => UserInfo.getUserId() };
+    String accountName = 'helloWorld!';
+    insert new Account(Name = accountName);
+    String query = 'SELECT Name FROM Account WHERE Name = :bindVar0';
+    Map<String, Object> bindVars = new Map<String, Object>{ 'bindVar0' => accountName };
 
-    Cursor cursor = new Cursor(query, bindVars, System.AccessLevel.SYSTEM_MODE);
+    Cursor instance = new Cursor(query, bindVars, System.AccessLevel.SYSTEM_MODE);
 
-    Assert.areEqual(1, cursor.getNumRecords());
-    Assert.areEqual(UserInfo.getUserId(), cursor.fetch(0, 1000).get(0).Id);
+    Assert.areEqual(1, instance.getNumRecords());
+    Assert.areEqual(accountName, instance.fetch(0, 1000).get(0).get('Name'));
     Assert.areEqual(1, System.Limits.getApexCursorRows());
   }
 
   @IsTest
   static void itCapsMaxFetchSize() {
+    Cursor.maxFetchSize = 20;
     List<Account> accounts = new List<Account>();
-    for (Integer i = 0; i < 2001; i++) {
+    for (Integer i = 0; i < Cursor.maxFetchSize + 1; i++) {
       accounts.add(new Account(Name = 'Fetch ' + i));
     }
     insert accounts;
 
-    Integer oneMoreThanMaxFetch = 2001;
+    Integer oneMoreThanMaxFetch = Cursor.maxFetchSize + 1;
     Exception ex;
+    List<SObject> results;
+    Cursor instance = new Cursor('SELECT Id FROM Account', new Map<String, Object>(), System.AccessLevel.SYSTEM_MODE);
     try {
-      new Cursor('SELECT Id FROM Account', new Map<String, Object>(), System.AccessLevel.SYSTEM_MODE)
-        .fetch(0, oneMoreThanMaxFetch);
+      results = instance.fetch(0, oneMoreThanMaxFetch);
     } catch (System.InvalidParameterValueException e) {
       ex = e;
     }
 
     Assert.areEqual(null, ex?.getMessage());
+    Assert.areEqual(Cursor.maxFetchSize, results.size());
+    Assert.areEqual(1, Cursor.localFetchesMade);
+  }
+
+  @IsTest
+  static void itFetchesMultipleTimesPerTransactionWhenMoreThanMaxFetch() {
+    Cursor.maxFetchSize = 20;
+    List<Account> accounts = new List<Account>();
+    Set<String> expectedFetchNames = new Set<String>();
+    for (Integer i = 0; i < Cursor.maxFetchSize + 1; i++) {
+      String accountName = 'Fetch' + i;
+      expectedFetchNames.add(accountName);
+      accounts.add(new Account(Name = accountName));
+    }
+    insert accounts;
+
+    Integer oneMoreThanMaxFetch = Cursor.maxFetchSize + 1;
+    Cursor instance = new Cursor('SELECT Name FROM Account', new Map<String, Object>(), System.AccessLevel.SYSTEM_MODE);
+    List<SObject> results = instance.setFetchesPerTransaction(2).fetch(0, oneMoreThanMaxFetch);
+
+    Assert.areEqual(Cursor.maxFetchSize + 1, results.size());
+    Assert.areEqual(2, Cursor.localFetchesMade);
+    Set<String> actuallyFetchedNames = new Set<String>();
+    for (Account account : (List<Account>) results) {
+      actuallyFetchedNames.add(account.Name);
+    }
+    Assert.areEqual(expectedFetchNames, actuallyFetchedNames);
   }
 
   @IsTest
   static void itFetchesMultipleTimesPerTransaction() {
+    Cursor.maxFetchSize = 1;
     insert new List<Account>{ new Account(Name = 'One'), new Account(Name = 'Two') };
 
-    Cursor cursor = new Cursor('SELECT Id FROM Account', new Map<String, Object>(), System.AccessLevel.SYSTEM_MODE)
+    Cursor instance = new Cursor('SELECT Id FROM Account', new Map<String, Object>(), System.AccessLevel.SYSTEM_MODE)
       .setFetchesPerTransaction(2);
-    List<SObject> results = cursor.fetch(0, 1);
+    List<SObject> results = instance.fetch(0, 2);
 
+    Assert.areEqual(2, instance.getNumRecords());
     Assert.areEqual(2, results.size());
-    results = cursor.fetch(2, 1);
+    results = instance.fetch(2, 1);
     Assert.areEqual(0, results.size());
-    Assert.areEqual(2, cursor.getNumRecords());
+  }
+
+  @IsTest
+  static void fetchesCorrectAmountOfRecords() {
+    List<Account> accounts = new List<Account>();
+    for (Integer i = 0; i < 10; i++) {
+      accounts.add(new Account(Name = 'Fetch ' + i));
+    }
+    insert accounts;
+
+    Cursor instance = new Cursor('SELECT Id FROM Account', new Map<String, Object>(), System.AccessLevel.SYSTEM_MODE)
+      .setFetchesPerTransaction(10);
+    List<SObject> results = instance.fetch(0, 2);
+
+    Assert.areEqual(2, results.size(), '' + results);
+    Assert.areEqual(1, Cursor.localFetchesMade);
   }
 }