@openstax/ts-utils 1.34.0 → 1.35.0

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

@@ -1,887 +0,0 @@
-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');
-  });
-});