updateCurrentStreak.ts

import { crons } from '../../src/cron/index';
import cron from '../../src/cron/updateCurrentStreak';
import { usersFixture } from '../fixture';
import { Settings, User, UserStreak } from '../../src/entity';
import { doNotFake, expectSuccessfulCron, saveFixtures } from '../helpers';
import { DataSource } from 'typeorm';
import createOrGetConnection from '../../src/db';
import nock from 'nock';
import { UserStreakAction, UserStreakActionType } from '../../src/entity';
import { CoresRole } from '../../src/types';

let con: DataSource;

beforeAll(async () => {
  con = await createOrGetConnection();
});

beforeEach(async () => {
  jest.useFakeTimers({ doNotFake }).setSystemTime(new Date('2024-06-26')); // Wednesday
  await saveFixtures(con, User, [usersFixture[0]]);
  await con.getRepository(UserStreak).save([
    {
      userId: '1',
      currentStreak: 1,
      lastViewAt: new Date('2024-06-24'), // Monday
    },
  ]);
});

afterEach(() => {
  jest.useRealTimers();
});

describe('updateCurrentStreak cron', () => {
  it('should be registered', () => {
    const registeredWorker = crons.find((item) => item.name === cron.name);

    expect(registeredWorker).toBeDefined();
  });

  it('should reset a past streak if 2 days old', async () => {
    nock('http://localhost:5000').post('/e').reply(204);
    await expectSuccessfulCron(cron);
    const streak = await con
      .getRepository(UserStreak)
      .findOneBy({ userId: '1' });
    expect(streak.currentStreak).toBe(0);
  });

  it('should not reset a past streak if 1 days old', async () => {
    await con
      .getRepository(UserStreak)
      .update({ userId: '1' }, { lastViewAt: new Date('2024-06-25') });
    await expectSuccessfulCron(cron);
    const streak = await con
      .getRepository(UserStreak)
      .findOneBy({ userId: '1' });
    expect(streak.currentStreak).toBe(1);
  });

  it('should not reset a past streak if weekend', async () => {
    // This is a friday
    await con
      .getRepository(UserStreak)
      .update({ userId: '1' }, { lastViewAt: new Date('2024-06-21') });
    // This is a Monday
    jest.useFakeTimers({ doNotFake }).setSystemTime(new Date('2024-06-24'));
    await expectSuccessfulCron(cron);
    const streak = await con
      .getRepository(UserStreak)
      .findOneBy({ userId: '1' });
    expect(streak.currentStreak).toBe(1);
  });

  describe('incorporating streaks recovery', () => {
    beforeEach(() => {
      nock('http://localhost:5000').post('/e').reply(204);
    });

    it('should not reset streak if user has recovered date of today', async () => {
      /*
      Day today is Wednesday
      1. Last read was Monday
      2. User did not read anything on Tuesday
      3. Wednesday arrived and resets the streak to 0
      4. User recovers the streak on Wednesday
      5. When the cron job runs, streak should stay at 1
    */
      await con.getRepository(UserStreakAction).save([
        {
          userId: '1',
          createdAt: new Date('2024-06-26'),
          type: UserStreakActionType.Recover,
        },
      ]);
      await expectSuccessfulCron(cron);
      const streak = await con
        .getRepository(UserStreak)
        .findOneBy({ userId: '1' });
      expect(streak.currentStreak).toBe(1);
    });

    it('should not reset streak if user has recovered date of today with timezone considered', async () => {
      jest.useFakeTimers({ doNotFake }).setSystemTime(new Date('2024-11-07')); // Thursday
      /*
        1. Day today is Thursday
        2. Last read was Monday
        3. User did not read anything on Tuesday
        4. Wednesday arrived and resets the streak to 0
        5. User recovers the streak on Wednesday
        6. Thursday arrived and the streak got reset since there was still no read
        7. User recovers the streak on Thursday
        8. Running the cron on the same day should not reset the streak
       */
      await con
        .getRepository(User)
        .update({ id: '1' }, { timezone: 'Europe/Athens' });
      await con.getRepository(UserStreakAction).save([
        {
          userId: '1',
          createdAt: new Date('2024-11-07'),
          type: UserStreakActionType.Recover,
        },
      ]);
      await expectSuccessfulCron(cron);
      const streak = await con
        .getRepository(UserStreak)
        .findOneBy({ userId: '1' });
      expect(streak.currentStreak).toBe(1);
    });

    it('should reset streak if a day had passed after restoring the streak', async () => {
      jest.useFakeTimers({ doNotFake }).setSystemTime(new Date('2024-06-27')); // Thursday
      /*
      1. Last read was Monday
      2. User did not read anything on Tuesday
      3. Wednesday arrived and resets the streak to 0
      4. User recovers the streak on Wednesday but did not read again
      5. Thursday should reset the streak to 0
    */
      await con.getRepository(UserStreakAction).save([
        {
          userId: '1',
          createdAt: new Date('2024-06-26'),
          type: UserStreakActionType.Recover,
        },
      ]);
      await expectSuccessfulCron(cron);
      const streak = await con
        .getRepository(UserStreak)
        .findOneBy({ userId: '1' });
      expect(streak.currentStreak).toBe(0);
    });

    it('should reset streak if two days had passed after restoring the streak', async () => {
      jest.useFakeTimers({ doNotFake }).setSystemTime(new Date('2024-06-28')); // Friday
      /*
      1. Last read was Monday
      2. User did not read anything on Tuesday
      3. Wednesday arrived and resets the streak to 0
      4. User recovers the streak on Wednesday but did not read again
      5. Friday should reset the streak to 0
    */
      await saveFixtures(con, User, [usersFixture[1]]);
      await con.getRepository(UserStreak).save([
        {
          userId: '2',
          currentStreak: 10,
          lastViewAt: new Date('2024-06-21'),
        },
      ]);
      await con.getRepository(UserStreakAction).save([
        {
          userId: '2',
          createdAt: new Date('2024-06-25'),
          type: UserStreakActionType.Recover,
        },
      ]);
      await expectSuccessfulCron(cron);
      const streak = await con
        .getRepository(UserStreak)
        .findOneBy({ userId: '2' });
      expect(streak.currentStreak).toBe(0);
    });

    it('should reset on Monday if user recovered on Friday but still did not read', async () => {
      jest.useFakeTimers({ doNotFake }).setSystemTime(new Date('2024-06-24')); // Monday
      /*
      1. Last read was Wednesday
      2. User did not read anything on Thursday
      3. Friday arrived and resets the streak to 0
      4. User recovers the streak on Friday but did not read again
      5. Monday should reset the streak to 0
    */
      await saveFixtures(con, User, [usersFixture[1]]);
      await con.getRepository(UserStreak).save([
        {
          userId: '2',
          currentStreak: 10,
          lastViewAt: new Date('2024-06-19'),
        },
      ]);
      await con.getRepository(UserStreakAction).save([
        {
          userId: '2',
          createdAt: new Date('2024-06-21'),
          type: UserStreakActionType.Recover,
        },
      ]);
      await expectSuccessfulCron(cron);
      const streak = await con
        .getRepository(UserStreak)
        .findOneBy({ userId: '2' });
      expect(streak.currentStreak).toBe(0);
    });

    it('should reset on weekend if user recovered on Friday but still did not read', async () => {
      jest.useFakeTimers({ doNotFake }).setSystemTime(new Date('2024-06-22')); // Monday
      /*
      1. Last read was Wednesday
      2. User did not read anything on Thursday
      3. Friday arrived and resets the streak to 0
      4. User recovers the streak on Friday but did not read again
      5. Saturday arrived should reset streak as it is the same thing as being on Monday
    */
      await saveFixtures(con, User, [usersFixture[1]]);
      await con.getRepository(UserStreak).save([
        {
          userId: '2',
          currentStreak: 10,
          lastViewAt: new Date('2024-06-19'),
        },
      ]);
      await con.getRepository(UserStreakAction).save([
        {
          userId: '2',
          createdAt: new Date('2024-06-21'),
          type: UserStreakActionType.Recover,
        },
      ]);
      await expectSuccessfulCron(cron);
      const streak = await con
        .getRepository(UserStreak)
        .findOneBy({ userId: '2' });
      expect(streak.currentStreak).toBe(0);
    });
  });

  describe('incorporating streak freeze', () => {
    beforeEach(async () => {
      nock('http://localhost:5000').post('/e').reply(204);
      await con
        .getRepository(User)
        .update({ id: '1' }, { coresRole: CoresRole.User });
    });

    it('should consume a single streak freeze instead of resetting when one day was missed', async () => {
      await con
        .getRepository(UserStreak)
        .update({ userId: '1' }, { freezesAvailable: 3 });

      await expectSuccessfulCron(cron);

      const streak = await con
        .getRepository(UserStreak)
        .findOneBy({ userId: '1' });
      expect(streak.currentStreak).toBe(1);
      expect(streak.freezesAvailable).toBe(2);

      const freezeActions = await con
        .getRepository(UserStreakAction)
        .findBy({ userId: '1', type: UserStreakActionType.Freeze });
      expect(freezeActions).toHaveLength(1);
      expect(freezeActions[0].createdAt).toEqual(new Date('2024-06-25'));
    });

    it('should consume one freeze per missed day when the gap spans multiple days', async () => {
      await con.getRepository(UserStreak).update(
        { userId: '1' },
        {
          lastViewAt: new Date('2024-06-23'), // Sunday
          freezesAvailable: 2,
        },
      );

      await expectSuccessfulCron(cron);

      const streak = await con
        .getRepository(UserStreak)
        .findOneBy({ userId: '1' });
      expect(streak.currentStreak).toBe(1);
      expect(streak.freezesAvailable).toBe(0);

      const freezeActions = await con
        .getRepository(UserStreakAction)
        .findBy({ userId: '1', type: UserStreakActionType.Freeze });
      expect(freezeActions).toHaveLength(2);
      const sortedTimes = freezeActions
        .map(({ createdAt }) => createdAt.getTime())
        .sort((a, b) => a - b);
      expect(sortedTimes).toEqual([
        new Date('2024-06-24').getTime(),
        new Date('2024-06-25').getTime(),
      ]);
    });

    it('should reset the streak when the freeze balance cannot cover the whole gap', async () => {
      await con.getRepository(UserStreak).update(
        { userId: '1' },
        {
          lastViewAt: new Date('2024-06-23'), // Sunday
          freezesAvailable: 1,
        },
      );

      await expectSuccessfulCron(cron);

      const streak = await con
        .getRepository(UserStreak)
        .findOneBy({ userId: '1' });
      expect(streak.currentStreak).toBe(0);
      expect(streak.freezesAvailable).toBe(1);

      const freezeActions = await con
        .getRepository(UserStreakAction)
        .findBy({ userId: '1', type: UserStreakActionType.Freeze });
      expect(freezeActions).toHaveLength(0);
    });

    it('should reset the streak when the user opted out of automated streak freeze', async () => {
      await con
        .getRepository(UserStreak)
        .update({ userId: '1' }, { freezesAvailable: 3 });
      await con
        .getRepository(Settings)
        .save({ userId: '1', optOutStreakFreeze: true });

      await expectSuccessfulCron(cron);

      const streak = await con
        .getRepository(UserStreak)
        .findOneBy({ userId: '1' });
      expect(streak.currentStreak).toBe(0);
      expect(streak.freezesAvailable).toBe(3);
    });

    it('should reset the streak when the user has no Cores access, even with freezes available', async () => {
      await con
        .getRepository(User)
        .update({ id: '1' }, { coresRole: CoresRole.None });
      await con
        .getRepository(UserStreak)
        .update({ userId: '1' }, { freezesAvailable: 3 });

      await expectSuccessfulCron(cron);

      const streak = await con
        .getRepository(UserStreak)
        .findOneBy({ userId: '1' });
      expect(streak.currentStreak).toBe(0);
      expect(streak.freezesAvailable).toBe(3);
    });

    it('should not consume a freeze twice for the same missed day across consecutive cron runs', async () => {
      await con
        .getRepository(UserStreak)
        .update({ userId: '1' }, { freezesAvailable: 3 });

      await expectSuccessfulCron(cron);
      await expectSuccessfulCron(cron);

      const streak = await con
        .getRepository(UserStreak)
        .findOneBy({ userId: '1' });
      expect(streak.currentStreak).toBe(1);
      expect(streak.freezesAvailable).toBe(2);

      const freezeActions = await con
        .getRepository(UserStreakAction)
        .findBy({ userId: '1', type: UserStreakActionType.Freeze });
      expect(freezeActions).toHaveLength(1);
    });
  });
});