@openstax/ts-utils 1.33.1 → 1.34.0

package/packages/utils/src/services/lrsGateway/attempt-utils.spec.ts

@@ -0,0 +1,847 @@
+import addDate from 'date-fns/add';
+import formatISO from 'date-fns/formatISO';
+import subDate from 'date-fns/sub';
+import {v4 as uuid} from 'uuid';
+import * as utils from './attempt-utils';
+import { LrsGateway } from '.';
+
+afterEach(() => {
+  jest.clearAllMocks();
+});
+
+beforeEach(() => {
+  jest.useFakeTimers();
+  jest.setSystemTime(new Date(2020, 1, 1));
+});
+
+const defaultStatementFields = () => ({
+  id: uuid(),
+  timestamp: formatISO(new Date()),
+  actor: {
+    account: {
+      homePage: 'https://openstax.org' as const,
+      name: uuid(),
+    },
+    objectType: 'Agent' as const,
+  },
+});
+
+const mockLrsGateway = {getXapiStatements: jest.fn(), getMoreXapiStatements: jest.fn(), getAllXapiStatements: jest.fn(), putXapiStatements: jest.fn()};
+
+describe('resolveAttemptInfo', () => {
+  it('works with no statements', () => {
+    const result = utils.resolveAttemptInfo([]);
+    expect(result).toEqual({
+      attempts: 0,
+      completedAttempts: 0,
+      currentAttempt: undefined,
+      currentAttemptCompleted: undefined,
+      currentAttemptStatements: [],
+      mostRecentAttemptWithCompleted: undefined,
+      mostRecentAttemptWithCompletedCompleted: undefined,
+    });
+  });
+
+  it('finds an attempt', () => {
+    const attempt = {
+      ...defaultStatementFields(),
+      ...utils.createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'}),
+      stored: '2025-01-01T01:01:01Z',
+    };
+    const result = utils.resolveAttemptInfo([attempt], { activityIRI: 'my cool activity' });
+    expect(result).toEqual({
+      attempts: 1,
+      completedAttempts: 0,
+      currentAttempt: attempt,
+      currentAttemptCompleted: undefined,
+      currentAttemptStatements: [],
+      mostRecentAttemptWithCompleted: undefined,
+      mostRecentAttemptWithCompletedCompleted: undefined,
+    });
+  });
+
+  it('uses most recent attempt as current', () => {
+    const attempt1 = {
+      ...defaultStatementFields(),
+      ...utils.createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'})
+    };
+    const attempt2 = {
+      ...defaultStatementFields(),
+      ...utils.createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'}),
+      timestamp: formatISO(subDate(new Date(), {hours: 1})),
+    };
+    const result = utils.resolveAttemptInfo([attempt1, attempt2], { activityIRI: 'my cool activity' });
+    expect(result).toEqual({
+      attempts: 2,
+      completedAttempts: 0,
+      currentAttempt: attempt1,
+      currentAttemptCompleted: undefined,
+      currentAttemptStatements: [],
+      mostRecentAttemptWithCompleted: undefined,
+      mostRecentAttemptWithCompletedCompleted: undefined,
+    });
+  });
+
+  it('uses oldest attempt as current', () => {
+    const attempt1 = {
+      ...defaultStatementFields(),
+      ...utils.createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'}),
+      stored: defaultStatementFields().timestamp,
+    };
+    const attempt2 = {
+      ...defaultStatementFields(),
+      ...utils.createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'}),
+      timestamp: formatISO(addDate(new Date(), {hours: 1})),
+    };
+    const result = utils.resolveAttemptInfo([attempt1, attempt2], { activityIRI: 'my cool activity', currentPreference: 'oldest'});
+    expect(result).toEqual({
+      attempts: 2,
+      completedAttempts: 0,
+      currentAttempt: attempt1,
+      currentAttemptCompleted: undefined,
+      currentAttemptStatements: [],
+      mostRecentAttemptWithCompleted: undefined,
+      mostRecentAttemptWithCompletedCompleted: undefined,
+    });
+  });
+
+  it('uses input attempt as current', () => {
+    const attempt1 = {
+      ...defaultStatementFields(),
+      ...utils.createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'})
+    };
+    const attempt2 = {
+      ...defaultStatementFields(),
+      ...utils.createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'}),
+      timestamp: formatISO(subDate(new Date(), {hours: 1})),
+    };
+    const result = utils.resolveAttemptInfo([attempt1, attempt2], { activityIRI: 'my cool activity', currentAttempt: attempt2.id});
+    expect(result).toEqual({
+      attempts: 2,
+      completedAttempts: 0,
+      currentAttempt: attempt2,
+      currentAttemptCompleted: undefined,
+      currentAttemptStatements: [],
+      mostRecentAttemptWithCompleted: undefined,
+      mostRecentAttemptWithCompletedCompleted: undefined,
+    });
+  });
+
+  it('ignores attempt for other activity', () => {
+    const attempt = {
+      ...defaultStatementFields(),
+      ...utils.createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'})
+    };
+    const result = utils.resolveAttemptInfo([attempt], { activityIRI: 'other activity' });
+    expect(result).toEqual({
+      attempts: 0,
+      completedAttempts: 0,
+      currentAttempt: undefined,
+      currentAttemptCompleted: undefined,
+      currentAttemptStatements: [],
+      mostRecentAttemptWithCompleted: undefined,
+      mostRecentAttemptWithCompletedCompleted: undefined,
+    });
+  });
+
+  it('collects attempt events (and ignores other events)', () => {
+    const attempt = {
+      ...defaultStatementFields(),
+      ...utils.createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'})
+    };
+    const otherEvent = {
+      ...defaultStatementFields(),
+      ...utils.createStatement({id: 'did a thing'}, {iri: 'my cool activity', type: 'cool type', name: 'the activity name'}, attempt.id)
+    };
+    const otherEvent2 = {
+      ...defaultStatementFields(),
+      ...utils.createStatement({id: 'did a thing'}, {iri: 'my cool activity', type: 'cool type', name: 'the activity name'}, 'foo')
+    };
+    const otherEvent3 = {
+      ...defaultStatementFields(),
+      ...utils.createStatement({id: 'did a thing'}, {iri: 'other activity', type: 'cool type', name: 'the activity name'}, attempt.id)
+    };
+    const result = utils.resolveAttemptInfo([attempt, otherEvent, otherEvent2, otherEvent3], { activityIRI: 'my cool activity' });
+    expect(result).toEqual({
+      attempts: 1,
+      completedAttempts: 0,
+      currentAttempt: attempt,
+      currentAttemptCompleted: undefined,
+      currentAttemptStatements: [otherEvent],
+      mostRecentAttemptWithCompleted: undefined,
+      mostRecentAttemptWithCompletedCompleted: undefined,
+    });
+  });
+
+  it('finds a completed attempt', () => {
+    const attempt = {
+      ...defaultStatementFields(),
+      ...utils.createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'})
+    };
+    const otherEvent = {
+      ...defaultStatementFields(),
+      ...utils.createStatement({id: 'did a thing'}, {iri: 'my cool activity', type: 'cool type', name: 'the activity name'}, attempt.id)
+    };
+    const completed = {
+      ...defaultStatementFields(),
+      ...utils.createCompletedStatement(attempt)
+    };
+    const otherEvent3 = {
+      ...defaultStatementFields(),
+      ...utils.createStatement({id: 'did a thing'}, {iri: 'other activity', type: 'cool type', name: 'the activity name'}, attempt.id)
+    };
+    const result = utils.resolveAttemptInfo([attempt, otherEvent, completed, otherEvent3], { activityIRI: 'my cool activity' });
+    expect(result).toEqual({
+      attempts: 1,
+      completedAttempts: 1,
+      currentAttempt: attempt,
+      currentAttemptCompleted: completed,
+      currentAttemptStatements: [otherEvent],
+      mostRecentAttemptWithCompleted: attempt,
+      mostRecentAttemptWithCompletedCompleted: completed,
+    });
+  });
+
+  it('finds a completed attempt and a newer uncompleted event', () => {
+    const olderAttempt = {
+      ...defaultStatementFields(),
+      ...utils.createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'})
+    };
+    jest.setSystemTime(addDate(new Date(), {hours: 1}));
+    const oldAttempt = {
+      ...defaultStatementFields(),
+      ...utils.createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'})
+    };
+    jest.setSystemTime(addDate(new Date(), {hours: 1}));
+    const attempt = {
+      ...defaultStatementFields(),
+      ...utils.createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'})
+    };
+    jest.setSystemTime(addDate(new Date(), {hours: 1}));
+    const otherEvent = {
+      ...defaultStatementFields(),
+      ...utils.createStatement({id: 'did a thing'}, {iri: 'my cool activity', type: 'cool type', name: 'the activity name'}, attempt.id)
+    };
+    jest.setSystemTime(addDate(new Date(), {hours: 1}));
+    const completed = {
+      ...defaultStatementFields(),
+      ...utils.createCompletedStatement(attempt)
+    };
+    jest.setSystemTime(addDate(new Date(), {hours: 1}));
+    const malformed = {
+      ...defaultStatementFields(),
+      object: {
+        definition: {
+          name: {
+            'en-US': 'asdf',
+          },
+          type: 'cool type',
+        },
+        id: 'my cool activity',
+        objectType: 'Activity' as const
+      },
+      verb: {id: 'http://adlnet.gov/expapi/verbs/completed'},
+    };
+    jest.setSystemTime(addDate(new Date(), {hours: 1}));
+    const newAttempt = {
+      ...defaultStatementFields(),
+      ...utils.createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'})
+    };
+    const result = utils.resolveAttemptInfo([malformed, olderAttempt, attempt, otherEvent, completed, newAttempt, oldAttempt], { activityIRI: 'my cool activity' });
+    expect(result).toEqual({
+      attempts: 4,
+      completedAttempts: 1,
+      currentAttempt: newAttempt,
+      currentAttemptCompleted: undefined,
+      currentAttemptStatements: [],
+      mostRecentAttemptWithCompleted: attempt,
+      mostRecentAttemptWithCompletedCompleted: completed,
+    });
+  });
+
+  it('finds most recent attempt with completed', () => {
+    const oldAttempt = {
+      ...defaultStatementFields(),
+      ...utils.createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'})
+    };
+    jest.setSystemTime(addDate(new Date(), {hours: 1}));
+    const attempt1 = {
+      ...defaultStatementFields(),
+      ...utils.createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'})
+    };
+    jest.setSystemTime(addDate(new Date(), {hours: 1}));
+    const completed1 = {
+      ...defaultStatementFields(),
+      ...utils.createCompletedStatement(attempt1)
+    };
+    jest.setSystemTime(addDate(new Date(), {hours: 1}));
+    const attempt = {
+      ...defaultStatementFields(),
+      ...utils.createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'})
+    };
+    jest.setSystemTime(addDate(new Date(), {hours: 1}));
+    const completed = {
+      ...defaultStatementFields(),
+      ...utils.createCompletedStatement(attempt)
+    };
+    const result = utils.resolveAttemptInfo([oldAttempt, completed, attempt, completed1, attempt1], { activityIRI: 'my cool activity' });
+    expect(result).toEqual({
+      attempts: 3,
+      completedAttempts: 2,
+      currentAttempt: attempt,
+      currentAttemptCompleted: completed,
+      currentAttemptStatements: [],
+      mostRecentAttemptWithCompleted: attempt,
+      mostRecentAttemptWithCompletedCompleted: completed,
+    });
+  });
+
+  it('finds most recent attempt with completed without any options', () => {
+    const oldAttempt = {
+      ...defaultStatementFields(),
+      ...utils.createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'})
+    };
+    jest.setSystemTime(addDate(new Date(), {hours: 1}));
+    const attempt1 = {
+      ...defaultStatementFields(),
+      ...utils.createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'})
+    };
+    jest.setSystemTime(addDate(new Date(), {hours: 1}));
+    const completed1 = {
+      ...defaultStatementFields(),
+      ...utils.createCompletedStatement(attempt1)
+    };
+    jest.setSystemTime(addDate(new Date(), {hours: 1}));
+    const attempt = {
+      ...defaultStatementFields(),
+      ...utils.createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'})
+    };
+    jest.setSystemTime(addDate(new Date(), {hours: 1}));
+    const completed = {
+      ...defaultStatementFields(),
+      ...utils.createCompletedStatement(attempt)
+    };
+    const result = utils.resolveAttemptInfo([oldAttempt, completed, attempt, completed1, attempt1]);
+    expect(result).toEqual({
+      attempts: 3,
+      completedAttempts: 2,
+      currentAttempt: attempt,
+      currentAttemptCompleted: completed,
+      currentAttemptStatements: [],
+      mostRecentAttemptWithCompleted: attempt,
+      mostRecentAttemptWithCompletedCompleted: completed,
+    });
+  });
+
+  it('ignores records from other parent attempts', () => {
+    const parentAttempt1 = {
+      ...defaultStatementFields(),
+      ...utils.createAttemptStatement({iri: 'my parent activity', type: 'parent type', name: 'cool parent'})
+    };
+    const parentAttempt2 = {
+      ...defaultStatementFields(),
+      ...utils.createAttemptStatement({iri: 'my parent activity', type: 'parent type', name: 'cool parent'})
+    };
+    const attempt1 = {
+      ...defaultStatementFields(),
+      ...utils.createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'}, {iri: 'my parent activity', attempt: parentAttempt1.id})
+    };
+    const otherEvent = {
+      ...defaultStatementFields(),
+      ...utils.createStatement({id: 'did a thing'}, {iri: 'my cool activity', type: 'cool type', name: 'the activity name'}, attempt1.id, 'my parent activity')
+    };
+    const attempt2 = {
+      ...defaultStatementFields(),
+      ...utils.createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'}, {iri: 'my parent activity', attempt: parentAttempt2.id})
+    };
+    const completed2 = {
+      ...defaultStatementFields(),
+      ...utils.createCompletedStatement(attempt2)
+    };
+    const malformed = {
+      ...defaultStatementFields(),
+      object: {
+        definition: {
+          name: {
+            'en-US': 'asdf',
+          },
+          type: 'cool type',
+        },
+        id: 'my cool activity',
+        objectType: 'Activity' as const
+      },
+      verb: {id: 'http://adlnet.gov/expapi/verbs/attempted'},
+    };
+    const completed3 = {
+      ...defaultStatementFields(),
+      ...utils.createCompletedStatement(malformed)
+    };
+    const result = utils.resolveAttemptInfo([malformed, attempt1, otherEvent, attempt2, completed2, completed3], { activityIRI: 'my cool activity', parentActivityAttempt: parentAttempt2.id});
+    expect(result).toEqual({
+      attempts: 1,
+      completedAttempts: 1,
+      currentAttempt: attempt2,
+      currentAttemptCompleted: completed2,
+      currentAttemptStatements: [],
+      mostRecentAttemptWithCompleted: attempt2,
+      mostRecentAttemptWithCompletedCompleted: completed2,
+    });
+  });
+
+  it('selects bestCompletedAttempt based on highest score', () => {
+
+    const attempt1 = {
+      ...defaultStatementFields(),
+      ...utils.createAttemptStatement({ iri: 'activity-id', type: 'type', name: 'activity' })
+    };
+    const attempt2 = {
+      ...defaultStatementFields(),
+      ...utils.createAttemptStatement({ iri: 'activity-id', type: 'type', name: 'activity' })
+    };
+    const attempt3 = {
+      ...defaultStatementFields(),
+      ...utils.createAttemptStatement({ iri: 'activity-id', type: 'type', name: 'activity' }),
+      timestamp: formatISO(addDate(new Date(), {hours: 1})),
+
+    };
+
+
+    const completed1 = {
+      ...defaultStatementFields(),
+      ...utils.createCompletedStatement(attempt1, {score: {raw: 3, max: 5, min: 0, scaled: 0.6}}),
+    };
+    const completed2 = {
+      ...defaultStatementFields(),
+      ...utils.createCompletedStatement(attempt2, {score: {raw: 5, max: 5, min: 0, scaled: 1}}),
+    };
+    const completed3 = {
+      ...defaultStatementFields(),
+      ...utils.createCompletedStatement(attempt3, {score: {raw: 4, max: 5, min: 0, scaled: 0.8}}),
+
+    };
+
+    const result = utils.resolveAttemptInfo(
+      [attempt1, completed1, attempt2, completed2, attempt3, completed3],
+      { activityIRI: 'activity-id' }
+    );
+    expect(result).toEqual({
+      attempts: 3,
+      bestCompletedAttempt: attempt2,
+      bestCompletedAttemptCompleted: completed2,
+      completedAttempts: 3,
+      currentAttempt: attempt3,
+      currentAttemptCompleted: completed3,
+      currentAttemptStatements: [],
+      mostRecentAttemptWithCompleted: attempt3,
+      mostRecentAttemptWithCompletedCompleted: completed3,
+    });
+  });
+
+});
+
+describe('putCompletedStatement', () => {
+  it('calls gateway', () => {
+    const putXapiStatements = jest.fn((x => Promise.resolve(x.map(s => ({...defaultStatementFields(), ...s})))) as LrsGateway['putXapiStatements']);
+    const gateway = {...mockLrsGateway, putXapiStatements} as LrsGateway;
+    const attempt = {
+      ...defaultStatementFields(),
+      id: 'attempt id',
+      ...utils.createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'})
+    };
+    utils.putCompletedStatement(gateway, attempt, undefined);
+    expect(putXapiStatements.mock.calls).toHaveLength(1);
+    expect(putXapiStatements.mock.calls[0][0]).toMatchInlineSnapshot(`
+[
+  {
+    "context": {
+      "statement": {
+        "id": "attempt id",
+        "objectType": "StatementRef",
+      },
+    },
+    "object": {
+      "definition": {
+        "extensions": {},
+        "name": {
+          "en-US": "the activity name",
+        },
+        "type": "cool type",
+      },
+      "id": "my cool activity",
+      "objectType": "Activity",
+    },
+    "result": {
+      "duration": "P0Y0M0DT0H0M0S",
+    },
+    "verb": {
+      "display": {
+        "en-US": "Completed",
+      },
+      "id": "http://adlnet.gov/expapi/verbs/completed",
+    },
+  },
+]
+`);
+  });
+});
+
+describe('putAttemptStatement', () => {
+  it('calls gateway', () => {
+    const putXapiStatements = jest.fn((x => Promise.resolve(x.map(s => ({...defaultStatementFields(), ...s})))) as LrsGateway['putXapiStatements']);
+    const gateway = {...mockLrsGateway, putXapiStatements} as LrsGateway;
+    utils.putAttemptStatement(gateway, {iri: 'my cool activity', type: 'cool type', name: 'activity name'});
+    expect(putXapiStatements.mock.calls).toHaveLength(1);
+    expect(putXapiStatements.mock.calls[0][0]).toMatchInlineSnapshot(`
+[
+  {
+    "object": {
+      "definition": {
+        "extensions": {},
+        "name": {
+          "en-US": "activity name",
+        },
+        "type": "cool type",
+      },
+      "id": "my cool activity",
+      "objectType": "Activity",
+    },
+    "verb": {
+      "display": {
+        "en-US": "Attempted",
+      },
+      "id": "http://adlnet.gov/expapi/verbs/attempted",
+    },
+  },
+]
+`);
+  });
+});
+
+describe('loadStatementsForActivityAndFirstChildren', () => {
+  it('calls gateway', () => {
+    const getAllXapiStatements = jest.fn((() => Promise.resolve([])) as LrsGateway['getAllXapiStatements']);
+    const gateway = {...mockLrsGateway, getAllXapiStatements} as LrsGateway;
+    utils.loadStatementsForActivityAndFirstChildren(gateway, 'my cool activity');
+    expect(getAllXapiStatements.mock.calls).toHaveLength(1);
+    expect(getAllXapiStatements.mock.calls[0][0]).toEqual({activity: 'my cool activity', related_activities: true});
+  });
+
+  it('calls gateway with attempt', () => {
+    const getAllXapiStatements = jest.fn((() => Promise.resolve([])) as LrsGateway['getAllXapiStatements']);
+    const gateway = {...mockLrsGateway, getAllXapiStatements} as LrsGateway;
+    utils.loadStatementsForActivityAndFirstChildren(gateway, 'my cool activity', { attempt: 'attempt id' });
+    expect(getAllXapiStatements.mock.calls).toHaveLength(1);
+    expect(getAllXapiStatements.mock.calls[0][0]).toEqual({activity: 'my cool activity', related_activities: true, registration: 'attempt id'});
+  });
+});
+
+describe('loadActivityAttemptInfo', () => {
+  it('finds an attempt', async () => {
+    const attempt = {
+      ...defaultStatementFields(),
+      ...utils.createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'})
+    };
+    const getAllXapiStatements = jest.fn((() => Promise.resolve([attempt])) as LrsGateway['getAllXapiStatements']);
+    const gateway = {...mockLrsGateway, getAllXapiStatements} as LrsGateway;
+    const result = await utils.loadActivityAttemptInfo(gateway, 'my cool activity');
+    expect(result).toEqual({
+      attempts: 1,
+      completedAttempts: 0,
+      currentAttempt: attempt,
+      currentAttemptCompleted: undefined,
+      currentAttemptStatements: [],
+      mostRecentAttemptWithCompleted: undefined,
+      mostRecentAttemptWithCompletedCompleted: undefined,
+    });
+  });
+
+  it('filters on registration if parentActivityAttempt is specified', async () => {
+    const attempt = {
+      ...defaultStatementFields(),
+      ...utils.createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'})
+    };
+    const getAllXapiStatements = jest.fn((() => Promise.resolve([attempt])) as LrsGateway['getAllXapiStatements']);
+    const gateway = {...mockLrsGateway, getAllXapiStatements} as LrsGateway;
+    await utils.loadActivityAttemptInfo(gateway, 'my cool activity', {parentActivityAttempt: 'some uuid'});
+    expect(getAllXapiStatements).toHaveBeenCalledWith(expect.objectContaining({
+      registration: 'some uuid'
+    }));
+  });
+});
+
+describe('matchAttemptCompleted', () => {
+  it('matches attempt', () => {
+    const attempt = {
+      ...defaultStatementFields(),
+      ...utils.createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'})
+    };
+    const completed = {
+      ...defaultStatementFields(),
+      ...utils.createCompletedStatement(attempt)
+    };
+    expect(utils.matchAttemptCompleted(attempt)(completed)).toBe(true);
+  });
+
+  it('does not match other attempt', () => {
+    const attempt1 = {
+      ...defaultStatementFields(),
+      ...utils.createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'})
+    };
+    const attempt2 = {
+      ...defaultStatementFields(),
+      ...utils.createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'})
+    };
+    const completed = {
+      ...defaultStatementFields(),
+      ...utils.createCompletedStatement(attempt1)
+    };
+    expect(utils.matchAttemptCompleted(attempt2)(completed)).toBe(false);
+  });
+
+  it('does not match completed without context (malformed)', () => {
+    const attempt = {
+      ...defaultStatementFields(),
+      ...utils.createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'})
+    };
+    const {context, ...completed} = {
+      ...defaultStatementFields(),
+      ...utils.createCompletedStatement(attempt)
+    };
+    expect(utils.matchAttemptCompleted(attempt)(completed)).toBe(false);
+  });
+
+  it('does not match completed without context statement (malformed)', () => {
+    const attempt = {
+      ...defaultStatementFields(),
+      ...utils.createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'})
+    };
+    const completed = {
+      ...defaultStatementFields(),
+      ...utils.createCompletedStatement(attempt),
+      context: {}
+    };
+    expect(utils.matchAttemptCompleted(attempt)(completed)).toBe(false);
+  });
+
+  it('matches attempt with registration', () => {
+    const attempt = {
+      ...defaultStatementFields(),
+      ...utils.createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'}, {attempt: 'registration'})
+    };
+    const completed = {
+      ...defaultStatementFields(),
+      ...utils.createCompletedStatement(attempt)
+    };
+    expect(utils.matchAttemptCompleted(attempt)(completed)).toBe(true);
+  });
+});
+
+describe('createAttemptStatement', () => {
+  it('creates with no context', () => {
+    expect(
+utils.createAttemptStatement({ iri: 'my cool activity', type: 'cool type', name: 'the activity name' })).
+toMatchInlineSnapshot(`
+{
+  "object": {
+    "definition": {
+      "extensions": {},
+      "name": {
+        "en-US": "the activity name",
+      },
+      "type": "cool type",
+    },
+    "id": "my cool activity",
+    "objectType": "Activity",
+  },
+  "verb": {
+    "display": {
+      "en-US": "Attempted",
+    },
+    "id": "http://adlnet.gov/expapi/verbs/attempted",
+  },
+}
+`);
+  });
+
+  it('creates with parent iri', () => {
+    expect(
+utils.createAttemptStatement({ iri: 'my cool activity', type: 'cool type', name: 'the activity name' }, { iri: 'parent iri' })).
+toMatchInlineSnapshot(`
+{
+  "context": {
+    "contextActivities": {
+      "parent": [
+        {
+          "id": "parent iri",
+          "objectType": "Activity",
+        },
+      ],
+    },
+  },
+  "object": {
+    "definition": {
+      "extensions": {},
+      "name": {
+        "en-US": "the activity name",
+      },
+      "type": "cool type",
+    },
+    "id": "my cool activity",
+    "objectType": "Activity",
+  },
+  "verb": {
+    "display": {
+      "en-US": "Attempted",
+    },
+    "id": "http://adlnet.gov/expapi/verbs/attempted",
+  },
+}
+`);
+  });
+
+  it('creates with parent attempt', () => {
+    expect(
+utils.createAttemptStatement({ iri: 'my cool activity', type: 'cool type', name: 'the activity name' }, { attempt: 'parent attempt' })).
+toMatchInlineSnapshot(`
+{
+  "context": {
+    "registration": "parent attempt",
+  },
+  "object": {
+    "definition": {
+      "extensions": {},
+      "name": {
+        "en-US": "the activity name",
+      },
+      "type": "cool type",
+    },
+    "id": "my cool activity",
+    "objectType": "Activity",
+  },
+  "verb": {
+    "display": {
+      "en-US": "Attempted",
+    },
+    "id": "http://adlnet.gov/expapi/verbs/attempted",
+  },
+}
+`);
+  });
+});
+
+describe('createAttemptActivityStatement', () => {
+  it('creates', () => {
+    const attempt = {
+      ...defaultStatementFields(),
+      id: 'attempt id',
+      ...utils.createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'})
+    };
+    expect(utils.createAttemptActivityStatement(attempt, { id: 'verb' })).toMatchInlineSnapshot(`
+{
+  "context": {
+    "registration": "attempt id",
+  },
+  "object": {
+    "definition": {
+      "extensions": {},
+      "name": {
+        "en-US": "the activity name",
+      },
+      "type": "cool type",
+    },
+    "id": "my cool activity",
+    "objectType": "Activity",
+  },
+  "verb": {
+    "id": "verb",
+  },
+}
+`);
+  });
+
+  it('creates with result', () => {
+    const attempt = {
+      ...defaultStatementFields(),
+      id: 'attempt id',
+      ...utils.createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'})
+    };
+    expect(utils.createAttemptActivityStatement(attempt, { id: 'verb' }, { response: 'cool response' })).toMatchInlineSnapshot(`
+{
+  "context": {
+    "registration": "attempt id",
+  },
+  "object": {
+    "definition": {
+      "extensions": {},
+      "name": {
+        "en-US": "the activity name",
+      },
+      "type": "cool type",
+    },
+    "id": "my cool activity",
+    "objectType": "Activity",
+  },
+  "result": {
+    "response": "cool response",
+  },
+  "verb": {
+    "id": "verb",
+  },
+}
+`);
+  });
+
+  it('keeps attempt context activities', () => {
+    const attempt = {
+      ...defaultStatementFields(),
+      id: 'attempt id',
+      ...utils.createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'}, {iri: 'parent iri'})
+    };
+    expect(utils.createAttemptActivityStatement(attempt, { id: 'verb' }, { response: 'cool response' })).toMatchInlineSnapshot(`
+{
+  "context": {
+    "contextActivities": {
+      "parent": [
+        {
+          "id": "parent iri",
+          "objectType": "Activity",
+        },
+      ],
+    },
+    "registration": "attempt id",
+  },
+  "object": {
+    "definition": {
+      "extensions": {},
+      "name": {
+        "en-US": "the activity name",
+      },
+      "type": "cool type",
+    },
+    "id": "my cool activity",
+    "objectType": "Activity",
+  },
+  "result": {
+    "response": "cool response",
+  },
+  "verb": {
+    "id": "verb",
+  },
+}
+`);
+  });
+});
+
+describe('putAttemptActivityStatement', () => {
+  it('calls gateway', async() => {
+    const putXapiStatements = jest.fn().mockReturnValue(Promise.resolve([]));
+    const attempt = {
+      ...defaultStatementFields(),
+      id: 'attempt id',
+      ...utils.createAttemptStatement({iri: 'my cool activity', type: 'cool type', name: 'the activity name'})
+    };
+    await utils.putAttemptActivityStatement({...mockLrsGateway, putXapiStatements}, attempt, {id: 'verb'});
+
+    expect(putXapiStatements).toHaveBeenCalled();
+  });
+});