@openstax/ts-utils 1.33.1 → 1.34.0

package/packages/utils/src/services/lrsGateway/xapiUtils.spec.ts

@@ -0,0 +1,887 @@
+import { v4 as uuid, v5 as uuidV5 } from 'uuid';
+import { AccountsGateway } from '../accountsGateway';
+import { AuthProvider, User } from '../authProvider';
+import { createAttemptStatement, createCompletedStatement } from './attempt-utils';
+import { getAssignmentGrades, getCurrentGrade, getRegistrationAttemptInfo } from './xapiUtils';
+import { LrsGateway } from '.';
+
+describe('getRegistrationAttemptInfo', () => {
+  let mockGetStatements: jest.SpyInstance;
+  let lrs: LrsGateway;
+  const mockRegistration = uuidV5('1', uuidV5('platform id', uuidV5.URL));
+  const accountUuid = '8cf86c14-20c6-474c-ba44-f4ac932a0a2d';
+
+  const defaultStatementFields = () => ({
+    id: uuid(),
+    timestamp: new Date().toISOString(),
+    actor: {
+      account: {
+        homePage: 'https://openstax.org' as const,
+        name: accountUuid,
+      },
+      objectType: 'Agent' as const,
+    },
+  });
+
+  beforeEach(() => {
+    mockGetStatements = jest.fn();
+    lrs = {getAllXapiStatements: mockGetStatements} as unknown as LrsGateway;
+  });
+
+  it('returns empty object when there are no statements', async () => {
+    mockGetStatements.mockReturnValue(Promise.resolve([]));
+    const infoPerUser = await getRegistrationAttemptInfo(lrs, mockRegistration);
+    expect(infoPerUser).toEqual({});
+  });
+
+  it('returns user info when there are statements', async () => {
+    const attempt = {
+      ...defaultStatementFields(),
+      ...createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'})
+    };
+    const attemptCompleted = {
+      ...defaultStatementFields(),
+      ...createCompletedStatement(attempt, {score: {raw: 4, max: 5, min: 0, scaled: 0.8}})
+    };
+    mockGetStatements.mockReturnValue(Promise.resolve([
+      attempt,
+      attemptCompleted
+    ]));
+    const infoPerUser = await getRegistrationAttemptInfo(lrs, mockRegistration);
+    const userInfo = infoPerUser[accountUuid];
+
+    expect(userInfo.attempts).toBe(1);
+    expect(userInfo.completedAttempts).toBe(1);
+    expect(userInfo.currentAttempt).toBe(attempt);
+    expect(userInfo.currentAttemptCompleted).toBe(attemptCompleted);
+  });
+
+  it('gets only the oldest attempt', async () => {
+    const attempt = {
+      ...defaultStatementFields(),
+      ...createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'})
+    };
+    const attemptCompleted = {
+      ...defaultStatementFields(),
+      ...createCompletedStatement(attempt, {score: {raw: 4, max: 5, min: 0, scaled: 0.8}})
+    };
+
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    const attempt2 = {
+      ...defaultStatementFields(),
+      ...createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'})
+    };
+    mockGetStatements.mockReturnValue(Promise.resolve([
+      attempt,
+      attemptCompleted,
+      attempt2
+    ]));
+    const infoPerUser = await getRegistrationAttemptInfo(lrs, mockRegistration, { currentPreference: 'oldest' });
+    const userInfo = infoPerUser[accountUuid];
+
+    expect(userInfo.attempts).toBe(2);
+    expect(userInfo.completedAttempts).toBe(1);
+    expect(userInfo.currentAttempt).toBe(attempt);
+    expect(userInfo.currentAttemptCompleted).toBe(attemptCompleted);
+  });
+});
+
+describe('getCurrentGrade', () => {
+  let mockGetStatements: jest.SpyInstance;
+  let mockGetUser: jest.SpyInstance;
+  let services: {
+    ltiAuthProvider: AuthProvider;
+    lrs: LrsGateway;
+  };
+  const mockRegistration = uuidV5('1', uuidV5('platform id', uuidV5.URL));
+  const accountsUuid = '8cf86c14-20c6-474c-ba44-f4ac932a0a2d';
+  const user = { uuid: accountsUuid } as User;
+
+  const defaultStatementFields = () => ({
+    id: uuid(),
+    timestamp: new Date().toISOString(),
+    actor: {
+      account: {
+        homePage: 'https://openstax.org' as const,
+        name: accountsUuid,
+      },
+      objectType: 'Agent' as const,
+    },
+  });
+
+  beforeEach(() => {
+    mockGetStatements = jest.fn();
+    mockGetUser = jest.fn();
+    services = {
+      ltiAuthProvider: {getUser: mockGetUser},
+      lrs: {getAllXapiStatements: mockGetStatements},
+    } as any;
+  });
+
+  it('returns null when there is no user', async () => {
+    mockGetUser.mockReturnValue(Promise.resolve(undefined));
+    const grade = await getCurrentGrade(services, mockRegistration);
+
+    expect(grade).toBeNull();
+  });
+
+  it('gets zero grade when there are no statements', async () => {
+    mockGetStatements.mockReturnValue(Promise.resolve([]));
+    mockGetUser.mockReturnValue(Promise.resolve(user));
+    const grade = await getCurrentGrade(services, mockRegistration);
+
+    expect(grade).toMatchInlineSnapshot(`
+{
+  "grade": {
+    "activityProgress": "Started",
+    "gradingProgress": "FullyGraded",
+    "scoreGiven": 0,
+    "scoreMaximum": 100,
+    "submission": {},
+    "userId": "8cf86c14-20c6-474c-ba44-f4ac932a0a2d",
+  },
+  "name": undefined,
+  "progress": {
+    "scaled": 0,
+  },
+}
+`);
+  });
+
+  it('gets grade when there are statements', async () => {
+    const attempt = {
+      ...defaultStatementFields(),
+      ...createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'})
+    };
+    mockGetStatements.mockReturnValue(Promise.resolve([
+      attempt,
+      {
+        ...defaultStatementFields(),
+        ...createCompletedStatement(attempt, {score: {raw: 4, max: 5, min: 0, scaled: 0.8}})
+      }
+    ]));
+    mockGetUser.mockReturnValue(Promise.resolve(user));
+    const grade = await getCurrentGrade(services, mockRegistration, { scoreMaximum: 10 });
+
+    expect(grade).toStrictEqual({
+      grade: {
+        activityProgress: 'Completed',
+        gradingProgress: 'FullyGraded',
+        scoreGiven: 8,
+        scoreMaximum: 10,
+        submission: {
+          startedAt: expect.any(String),
+          submittedAt: expect.any(String),
+        },
+        userId: '8cf86c14-20c6-474c-ba44-f4ac932a0a2d'
+      },
+      name: undefined,
+      progress: {
+        scaled: 1
+      }
+    });
+  });
+
+  it('gets default grade when there are no completed statements and no incompleteAttemptCallback', async () => {
+    const attempt = {
+      ...defaultStatementFields(),
+      ...createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'})
+    };
+    mockGetStatements.mockReturnValue(Promise.resolve([
+      attempt,
+    ]));
+    mockGetUser.mockReturnValue(Promise.resolve(user));
+    const grade = await getCurrentGrade(services, mockRegistration);
+
+    expect(grade).toStrictEqual({
+      grade: {
+        activityProgress: 'Started',
+        gradingProgress: 'FullyGraded',
+        scoreGiven: 0,
+        scoreMaximum: 100,
+        submission: {
+          startedAt: expect.any(String),
+        },
+        userId: '8cf86c14-20c6-474c-ba44-f4ac932a0a2d'
+      },
+      name: undefined,
+      progress: {
+        scaled: 0
+      }
+    });
+  });
+
+  it('can accept a callback to get incomplete assignments', async () => {
+    const userId = 'a3ee0232-06c4-46cd-8d2f-0d7a12788b4a';
+    const attempt = {
+      ...defaultStatementFields(),
+      ...createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'})
+    };
+    mockGetStatements.mockReturnValue(Promise.resolve([
+      attempt,
+    ]));
+    mockGetUser.mockReturnValue(Promise.resolve(user));
+
+    const incompleteAttemptCallback = jest.fn().mockReturnValue(Promise.resolve({
+      activityProgress: 'Started',
+      gradingProgress: 'FullyGraded',
+      scoreGiven: 1,
+      scoreMaximum: 5,
+      userId,
+    }));
+    const grade = await getCurrentGrade(services, mockRegistration, { incompleteAttemptCallback, userId });
+
+    expect(grade).toMatchInlineSnapshot(`
+{
+  "activityProgress": "Started",
+  "gradingProgress": "FullyGraded",
+  "scoreGiven": 1,
+  "scoreMaximum": 5,
+  "userId": "a3ee0232-06c4-46cd-8d2f-0d7a12788b4a",
+}
+`);
+
+    expect(incompleteAttemptCallback).toHaveBeenCalledTimes(1);
+
+    const args = incompleteAttemptCallback.mock.calls[0];
+    expect(args).toHaveLength(1);
+
+    const info = args[0];
+
+    expect(info.attempts).toBe(1);
+    expect(info.completedAttempts).toBe(0);
+  });
+
+  it('gets grade when grade has no min/max/raw values', async () => {
+    const attempt = {
+      ...defaultStatementFields(),
+      ...createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'})
+    };
+    mockGetStatements.mockReturnValue(Promise.resolve([
+      attempt,
+      {
+        ...defaultStatementFields(),
+        ...createCompletedStatement(attempt, {score: {scaled: 0.8}})
+      }
+    ]));
+    mockGetUser.mockReturnValue(Promise.resolve(user));
+    const grade = await getCurrentGrade(services, mockRegistration, { userId: 'user id' });
+
+    expect(grade).toStrictEqual({
+      grade: {
+        activityProgress: 'Completed',
+        gradingProgress: 'FullyGraded',
+        scoreGiven: 80,
+        scoreMaximum: 100,
+        submission: {
+          startedAt: expect.any(String),
+          submittedAt: expect.any(String),
+        },
+        userId: 'user id'
+      },
+      name: undefined,
+      progress: {
+        scaled: 1
+      }
+    });
+  });
+
+  it('gets only the oldest attempt', async () => {
+    const attempt = {
+      ...defaultStatementFields(),
+      ...createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'})
+    };
+    const attemptCompleted = {
+      ...defaultStatementFields(),
+      ...createCompletedStatement(attempt, {score: {raw: 4, max: 5, min: 0, scaled: 0.8}})
+    };
+
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    const attempt2 = {
+      ...defaultStatementFields(),
+      ...createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'})
+    };
+    mockGetStatements.mockReturnValue(Promise.resolve([
+      attempt,
+      attemptCompleted,
+      attempt2
+    ]));
+    mockGetUser.mockReturnValue(Promise.resolve(user));
+    const grade = await getCurrentGrade(
+      services, mockRegistration, { currentPreference: 'oldest', userId: 'user id' }
+    );
+
+    expect(grade).toStrictEqual({
+      grade: {
+        activityProgress: 'Completed',
+        gradingProgress: 'FullyGraded',
+        scoreGiven: 80,
+        scoreMaximum: 100,
+        submission: {
+          startedAt: expect.any(String),
+          submittedAt: expect.any(String),
+        },
+        userId: 'user id'
+      },
+      name: undefined,
+      progress: {
+        scaled: 1
+      }
+    });
+  });
+});
+
+describe('getAssignmentGrades', () => {
+  let mockMapUserUuids: jest.SpyInstance;
+  let mockLogEvent: jest.SpyInstance;
+  let mockGetStatements: jest.SpyInstance;
+  let services: {
+    accountsGateway: AccountsGateway;
+    lrs: LrsGateway;
+  };
+  const platformId = uuid();
+  const assignmentIRI = 'https://openstax.org/orn/assignment/e2c1e160-4913-4397-b295-b31b0b4367ec';
+  const mockRegistration = uuidV5(uuid(), uuidV5(platformId, uuidV5.URL));
+  const studentId1 = 'a3ee0232-06c4-46cd-8d2f-0d7a12788b4a';
+  const studentId2 = '74f3254c-cbc6-417f-9442-dc76d877f744';
+  const studentId3 = 'e9accd58-f8ad-4132-a8fe-69486f81ae6e';
+  const studentUuid1 = '3beb5a53-2628-4c82-8853-5892577cb672';
+  const studentUuid2 = 'efe70ccb-9712-424a-912a-51486b2ae138';
+  const studentUuid3 = '6aaebe17-d1e2-432a-8506-f6ce6f809bf0';
+  const userUuidToPlatformUserIdMap: { [uuid: string]: string } = {
+    [studentUuid1]: studentId1,
+    [studentUuid2]: studentId2,
+    [studentUuid3]: studentId3,
+  };
+  const userUuidToNameMap: { [uuid: string]: string } = {
+    [studentUuid1]: 'Alice',
+    [studentUuid2]: 'Bob',
+    [studentUuid3]: 'Carol',
+  };
+
+  const defaultStatementFields = (accountName: string) => ({
+    id: uuid(),
+    timestamp: new Date().toISOString(),
+    actor: {
+      account: {
+        homePage: 'https://openstax.org' as const,
+        name: accountName,
+      },
+      objectType: 'Agent' as const,
+    },
+  });
+
+  beforeEach(() => {
+    mockMapUserUuids = jest.fn().mockImplementation(<T>(
+      userUuidsMap: { [uuid: string]: T }, platformId: string
+    ) => Object.entries(userUuidsMap).map(
+      ([uuid, data]) => ({
+        data,
+        fullName: userUuidToNameMap[uuid],
+        platformUserId: platformId ? userUuidToPlatformUserIdMap[uuid] : undefined,
+        uuid,
+      })
+    ));
+    mockLogEvent = jest.fn();
+    mockGetStatements = jest.fn();
+    services = {
+      accountsGateway: {mapUserUuids: mockMapUserUuids},
+      lrs: {getAllXapiStatements: mockGetStatements},
+    } as any;
+  });
+
+  it('gets no grades when there are no statements', async () => {
+    mockGetStatements.mockReturnValue(Promise.resolve([]));
+    const grades = await getAssignmentGrades(services, assignmentIRI, mockRegistration);
+
+    expect(grades).toEqual([]);
+
+    expect(mockLogEvent).not.toHaveBeenCalled();
+  });
+
+  it('gets grade when there are statements', async () => {
+    const attempt1 = {
+      ...defaultStatementFields(studentUuid1),
+      ...createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'})
+    };
+    const attempt2 = {
+      ...defaultStatementFields(studentUuid2),
+      ...createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'})
+    };
+    const attempt3 = {
+      ...defaultStatementFields(studentUuid3),
+      ...createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'})
+    };
+    mockGetStatements.mockReturnValue(Promise.resolve([
+      attempt1,
+      {
+        ...defaultStatementFields(studentUuid1),
+        ...createCompletedStatement(attempt1, {score: {raw: 4, max: 5, min: 0, scaled: 0.8}})
+      },
+      attempt2,
+      {
+        ...defaultStatementFields(studentUuid2),
+        ...createCompletedStatement(attempt2, {score: {raw: 3, max: 5, min: 0, scaled: 0.6}})
+      },
+      attempt3,
+    ]));
+    const grades = await getAssignmentGrades(services, assignmentIRI, mockRegistration);
+
+    expect(grades).toStrictEqual([
+      {
+        grade: {
+          activityProgress: 'Completed',
+          gradingProgress: 'FullyGraded',
+          scoreGiven: 80,
+          scoreMaximum: 100,
+          submission: {
+            startedAt: expect.any(String),
+            submittedAt: expect.any(String),
+          },
+          userId: undefined
+        },
+        name: 'Alice',
+        progress: {
+          scaled: 1
+        }
+      },
+      {
+        grade: {
+          activityProgress: 'Completed',
+          gradingProgress: 'FullyGraded',
+          scoreGiven: 60,
+          scoreMaximum: 100,
+          submission: {
+            startedAt: expect.any(String),
+            submittedAt: expect.any(String),
+          },
+          userId: undefined
+        },
+        name: 'Bob',
+        progress: {
+          scaled: 1
+        }
+      },
+      {
+        grade: {
+          activityProgress: 'Started',
+          gradingProgress: 'FullyGraded',
+          scoreGiven: 0,
+          scoreMaximum: 100,
+          submission: {
+            startedAt: expect.any(String),
+          },
+          userId: undefined
+        },
+        name: 'Carol',
+        progress: {
+          scaled: 0
+        }
+      },
+    ]);
+
+    expect(mockLogEvent).not.toHaveBeenCalled();
+  });
+
+  it('can accept a callback to get incomplete assignments', async () => {
+    const attempt1 = {
+      ...defaultStatementFields(studentUuid1),
+      ...createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'})
+    };
+    const attempt2 = {
+      ...defaultStatementFields(studentUuid2),
+      ...createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'})
+    };
+    const attempt3 = {
+      ...defaultStatementFields(studentUuid3),
+      ...createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'})
+    };
+    mockGetStatements.mockReturnValue(Promise.resolve([
+      attempt1,
+      {
+        ...defaultStatementFields(studentUuid1),
+        ...createCompletedStatement(attempt1, {score: {raw: 4, max: 5, min: 0, scaled: 0.8}})
+      },
+      attempt2,
+      {
+        ...defaultStatementFields(studentUuid2),
+        ...createCompletedStatement(attempt2, {score: {raw: 3, max: 5, min: 0, scaled: 0.6}})
+      },
+      attempt3,
+    ]));
+
+    const incompleteAttemptsCallback = jest.fn().mockReturnValue(Promise.resolve([]));
+    const grades = await getAssignmentGrades(
+      services, assignmentIRI, mockRegistration, { incompleteAttemptsCallback }
+    );
+
+    expect(grades).toStrictEqual([
+      {
+        grade: {
+          activityProgress: 'Completed',
+          gradingProgress: 'FullyGraded',
+          scoreGiven: 80,
+          scoreMaximum: 100,
+          submission: {
+            startedAt: expect.any(String),
+            submittedAt: expect.any(String),
+          },
+          userId: undefined
+        },
+        name: 'Alice',
+        progress: {
+          scaled: 1
+        }
+      },
+      {
+        grade: {
+          activityProgress: 'Completed',
+          gradingProgress: 'FullyGraded',
+          scoreGiven: 60,
+          scoreMaximum: 100,
+          submission: {
+            startedAt: expect.any(String),
+            submittedAt: expect.any(String),
+          },
+          userId: undefined
+        },
+        name: 'Bob',
+        progress: {
+          scaled: 1
+        }
+      }
+    ]);
+
+    expect(incompleteAttemptsCallback).toHaveBeenCalledTimes(1);
+
+    const args = incompleteAttemptsCallback.mock.calls[0];
+    expect(args).toHaveLength(1);
+
+    const mappedInfo = args[0];
+    expect(mappedInfo).toHaveLength(1);
+
+    const { data, fullName, platformUserId, uuid } = mappedInfo[0];
+    expect(data.attempts).toBe(1);
+    expect(data.completedAttempts).toBe(0);
+    expect(fullName).toBe('Carol');
+    expect(platformUserId).toBeUndefined();
+    expect(uuid).toEqual(studentUuid3);
+
+    expect(mockLogEvent).not.toHaveBeenCalled();
+  });
+
+  it('gets grade when grade has no min/max/raw values', async () => {
+    const attempt1 = {
+      ...defaultStatementFields(studentUuid1),
+      ...createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'})
+    };
+    const attempt2 = {
+      ...defaultStatementFields(studentUuid2),
+      ...createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'})
+    };
+    mockGetStatements.mockReturnValue(Promise.resolve([
+      attempt1,
+      {
+        ...defaultStatementFields(studentUuid1),
+        ...createCompletedStatement(attempt1, {score: {scaled: 0.8}})
+      },
+      attempt2,
+      {
+        ...defaultStatementFields(studentUuid2),
+        ...createCompletedStatement(attempt2, {score: {scaled: 0.6}})
+      },
+    ]));
+    const grades = await getAssignmentGrades(
+      services, assignmentIRI, mockRegistration, { platformId, scoreMaximum: 10 }
+    );
+
+    expect(grades).toStrictEqual([
+      {
+        grade: {
+          activityProgress: 'Completed',
+          gradingProgress: 'FullyGraded',
+          scoreGiven: 8,
+          scoreMaximum: 10,
+          submission: {
+            startedAt: expect.any(String),
+            submittedAt: expect.any(String),
+          },
+          userId: 'a3ee0232-06c4-46cd-8d2f-0d7a12788b4a'
+        },
+        name: 'Alice',
+        progress: {
+          scaled: 1
+        }
+      },
+      {
+        grade: {
+          activityProgress: 'Completed',
+          gradingProgress: 'FullyGraded',
+          scoreGiven: 6,
+          scoreMaximum: 10,
+          submission: {
+            startedAt: expect.any(String),
+            submittedAt: expect.any(String),
+          },
+          userId: '74f3254c-cbc6-417f-9442-dc76d877f744'
+        },
+        name: 'Bob',
+        progress: {
+          scaled: 1
+        }
+      }
+    ]);
+
+    expect(mockLogEvent).not.toHaveBeenCalled();
+  });
+
+  it('uses best completed attempt when gradePreference is "best" and partitions accordingly', async () => {
+    // Alice has two completed attempts. Best is the older
+    const aliceOlderAttempt = {
+      ...defaultStatementFields(studentUuid1),
+      ...createAttemptStatement({ iri: 'my cool activity', type: 'cool type', name: 'the activity name' }),
+    };
+    const aliceOlderCompleted = {
+      ...defaultStatementFields(studentUuid1),
+      ...createCompletedStatement(aliceOlderAttempt, { score: { raw: 9, max: 10, min: 0, scaled: 0.9 } }),
+    };
+    const aliceNewerAttempt = {
+      ...defaultStatementFields(studentUuid1),
+      ...createAttemptStatement({ iri: 'my cool activity', type: 'cool type', name: 'the activity name' }),
+    };
+    const aliceNewerCompleted = {
+      ...defaultStatementFields(studentUuid1),
+      ...createCompletedStatement(aliceNewerAttempt, { score: { raw: 4, max: 10, min: 0, scaled: 0.4 } }),
+    };
+
+    // Bob has an uncompleted attempt
+    const bobAttemptOnly = {
+      ...defaultStatementFields(studentUuid2),
+      ...createAttemptStatement({ iri: 'my cool activity', type: 'cool type', name: 'the activity name' }),
+    };
+
+    // Carol has two completed attempts. The newer one is the best. 
+    const carolOlderAttempt = {
+      ...defaultStatementFields(studentUuid3),
+      ...createAttemptStatement({ iri: 'my cool activity', type: 'cool type', name: 'the activity name' }),
+    };
+    const carolOlderCompleted = {
+      ...defaultStatementFields(studentUuid3),
+      ...createCompletedStatement(carolOlderAttempt, { score: { scaled: 0.6 } }),
+    };
+    const carolNewerAttempt = {
+      ...defaultStatementFields(studentUuid3),
+      ...createAttemptStatement({ iri: 'my cool activity', type: 'cool type', name: 'the activity name' }),
+    };
+    const carolNewerCompleted = {
+      ...defaultStatementFields(studentUuid3),
+      ...createCompletedStatement(carolNewerAttempt, { score: { scaled: 0.7 } }),
+    };
+
+    mockGetStatements.mockReturnValue(Promise.resolve([
+      aliceOlderAttempt, aliceOlderCompleted,
+      bobAttemptOnly,
+      carolOlderAttempt, carolOlderCompleted,
+      carolNewerAttempt, carolNewerCompleted,
+      aliceNewerAttempt, aliceNewerCompleted,
+    ]));
+
+    const incompleteAttemptsCallback = jest.fn().mockResolvedValue([]);
+
+    const grades = await getAssignmentGrades(
+      services,
+      assignmentIRI,
+      mockRegistration,
+      {
+        gradePreference: 'best',
+        platformId,
+        incompleteAttemptsCallback,
+      }
+    );
+
+    // Should grade Alice's best 0.9 and Carol's best 0.7
+    expect(grades).toStrictEqual([
+      {
+        grade: {
+          activityProgress: 'Completed',
+          gradingProgress: 'FullyGraded',
+          scoreGiven: 90,
+          scoreMaximum: 100,
+          submission: {
+            startedAt: expect.any(String),
+            submittedAt: expect.any(String),
+          },
+          userId: studentId1,
+        },
+        name: 'Alice',
+        progress: { scaled: 1 },
+      },
+      {
+        grade: {
+          activityProgress: 'Completed',
+          gradingProgress: 'FullyGraded',
+          scoreGiven: 70,
+          scoreMaximum: 100,
+          submission: {
+            startedAt: expect.any(String),
+            submittedAt: expect.any(String),
+          },
+          userId: studentId3,
+        },
+        name: 'Carol',
+        progress: { scaled: 1 },
+      },
+    ]);
+
+    // incompleteAttemptsCallback should receive only Bob because he has an incomplete attempt.
+    expect(incompleteAttemptsCallback).toHaveBeenCalledTimes(1);
+    const [incompleteList] = incompleteAttemptsCallback.mock.calls[0];
+    expect(Array.isArray(incompleteList)).toBe(true);
+    expect(incompleteList).toHaveLength(1);
+    expect(incompleteList[0].uuid).toBe(studentUuid2);
+    expect(incompleteList[0].fullName).toBe('Bob');
+  });
+
+  it('uses current attempt when gradePreference is "current" and partitions accordingly', async () => {
+    // Alice has two completed attempts. Current is the newer. 0.4 score
+    const aliceOlderAttempt = {
+      ...defaultStatementFields(studentUuid1),
+      ...createAttemptStatement({ iri: 'my cool activity', type: 'cool type', name: 'the activity name' }),
+    };
+    const aliceOlderCompleted = {
+      ...defaultStatementFields(studentUuid1),
+      ...createCompletedStatement(aliceOlderAttempt, { score: { raw: 9, max: 10, min: 0, scaled: 0.9 } }),
+    };
+    const aliceNewerAttempt = {
+      ...defaultStatementFields(studentUuid1),
+      ...createAttemptStatement({ iri: 'my cool activity', type: 'cool type', name: 'the activity name' }),
+    };
+    const aliceNewerCompleted = {
+      ...defaultStatementFields(studentUuid1),
+      ...createCompletedStatement(aliceNewerAttempt, { score: { raw: 4, max: 10, min: 0, scaled: 0.4 } }),
+    };
+
+    // Bob only an uncompleted attempt
+    const bobAttemptOnly = {
+      ...defaultStatementFields(studentUuid2),
+      ...createAttemptStatement({ iri: 'my cool activity', type: 'cool type', name: 'the activity name' }),
+    };
+
+    // Carol has two completed attempts. Current is the newer. 0.7 score
+    const carolOlderAttempt = {
+      ...defaultStatementFields(studentUuid3),
+      ...createAttemptStatement({ iri: 'my cool activity', type: 'cool type', name: 'the activity name' }),
+    };
+    const carolOlderCompleted = {
+      ...defaultStatementFields(studentUuid3),
+      ...createCompletedStatement(carolOlderAttempt, { score: { scaled: 0.6 } }),
+    };
+    const carolNewerAttempt = {
+      ...defaultStatementFields(studentUuid3),
+      ...createAttemptStatement({ iri: 'my cool activity', type: 'cool type', name: 'the activity name' }),
+    };
+    const carolNewerCompleted = {
+      ...defaultStatementFields(studentUuid3),
+      ...createCompletedStatement(carolNewerAttempt, { score: { scaled: 0.7 } }),
+    };
+
+    mockGetStatements.mockReturnValue(Promise.resolve([
+      aliceOlderAttempt, aliceOlderCompleted,
+      bobAttemptOnly,
+      carolOlderAttempt, carolOlderCompleted,
+      carolNewerAttempt, carolNewerCompleted,
+      aliceNewerAttempt, aliceNewerCompleted,
+    ]));
+
+    const incompleteAttemptsCallback = jest.fn().mockResolvedValue([]);
+
+    const grades = await getAssignmentGrades(
+      services,
+      assignmentIRI,
+      mockRegistration,
+      {
+        platformId,
+        incompleteAttemptsCallback,
+        gradePreference: 'current',
+      }
+    );
+
+    // Alice's current should have  0.4. Carol's current should have 0.7
+    expect(grades).toStrictEqual([
+      {
+        grade: {
+          activityProgress: 'Completed',
+          gradingProgress: 'FullyGraded',
+          scoreGiven: 40,
+          scoreMaximum: 100,
+          submission: {
+            startedAt: expect.any(String),
+            submittedAt: expect.any(String),
+          },
+          userId: studentId1,
+        },
+        name: 'Alice',
+        progress: { scaled: 1 },
+      },
+      {
+        grade: {
+          activityProgress: 'Completed',
+          gradingProgress: 'FullyGraded',
+          scoreGiven: 70,
+          scoreMaximum: 100,
+          submission: {
+            startedAt: expect.any(String),
+            submittedAt: expect.any(String),
+          },
+          userId: studentId3,
+        },
+        name: 'Carol',
+        progress: { scaled: 1 },
+      },
+    ]);
+
+    // Bob is the only incomplete attempt
+    expect(incompleteAttemptsCallback).toHaveBeenCalledTimes(1);
+    const [incompleteList] = incompleteAttemptsCallback.mock.calls[0];
+    expect(Array.isArray(incompleteList)).toBe(true);
+    expect(incompleteList).toHaveLength(1);
+    expect(incompleteList[0].uuid).toBe(studentUuid2);
+    expect(incompleteList[0].fullName).toBe('Bob');
+  });
+
+  it('uses current if best attempt and completed does not exist when gradePreference is "best"', async () => {
+    // Alice has one incomplete attempt but gradePreference is best
+
+    const aliceAttempt = {
+      ...defaultStatementFields(studentUuid1),
+      ...createAttemptStatement({ iri: 'my cool activity', type: 'cool type', name: 'the activity name' }),
+    };
+
+    mockGetStatements.mockReturnValue(Promise.resolve([
+      aliceAttempt,
+    ]));
+
+    const incompleteAttemptsCallback = jest.fn().mockResolvedValue([]);
+
+    const grades = await getAssignmentGrades(
+      services,
+      assignmentIRI,
+      mockRegistration,
+      {
+        gradePreference: 'best',
+        platformId,
+        incompleteAttemptsCallback,
+      }
+    );
+    expect(grades).toStrictEqual([]);
+
+    expect(incompleteAttemptsCallback).toHaveBeenCalledTimes(1);
+    const [incompleteList] = incompleteAttemptsCallback.mock.calls[0];
+    expect(Array.isArray(incompleteList)).toBe(true);
+    expect(incompleteList).toHaveLength(1);
+    expect(incompleteList[0].uuid).toBe(studentUuid1);
+    expect(incompleteList[0].fullName).toBe('Alice');
+  });
+});