Write events test suite

api/validators/FeedbackControllerRequests.ts

@@ -2,7 +2,6 @@ import { Type } from 'class-transformer';
 import { IsDefined, IsNotEmpty, MinLength, ValidateNested } from 'class-validator';
 import { IsValidFeedbackType, IsValidFeedbackStatus } from '../decorators/Validators';
 import {
-  SubmitEventFeedbackRequest as ISubmitEventFeedbackRequest,
   SubmitFeedbackRequest as ISubmitFeedbackRequest,
   UpdateFeedbackStatusRequest as IUpdateFeedbackStatusRequest,
   Feedback as IFeedback,
@@ -24,11 +23,6 @@ export class Feedback implements IFeedback {
   type: FeedbackType;
 }
 
-export class SubmitEventFeedbackRequest implements ISubmitEventFeedbackRequest {
-  @IsDefined()
-  feedback: string[];
-}
-
 export class SubmitFeedbackRequest implements ISubmitFeedbackRequest {
   @Type(() => Feedback)
   @ValidateNested()

services/EventService.ts

@@ -18,7 +18,7 @@ export default class EventService {
   public async create(event: Event) {
     const eventCreated = await this.transactions.readWrite(async (txn) => {
       const eventRepository = Repositories.event(txn);
-      const isUnusedAttendanceCode = eventRepository.isUnusedAttendanceCode(event.attendanceCode);
+      const isUnusedAttendanceCode = await eventRepository.isUnusedAttendanceCode(event.attendanceCode);
       if (!isUnusedAttendanceCode) throw new UserError('Attendance code has already been used');
       return eventRepository.upsertEvent(EventModel.create(event));
     });

tests/data/EventFactory.ts

@@ -24,21 +24,45 @@ export class EventFactory {
 
   public static fake(): EventModel {
     const [start, end] = EventFactory.randomTime();
+    return EventFactory.fakeWithTime(start, end);
+  }
+
+  private static fakeWithTime(start: Date, end: Date): EventModel {
+    const event = EventFactory.fakeWithoutTime();
+    event.start = start;
+    event.end = end;
+    return event;
+  }
+
+  public static fakeWithoutTime(): EventModel {
     return EventModel.create({
       uuid: uuid(),
       organization: FactoryUtils.pickRandomValue(EventFactory.ORGS),
       title: faker.random.hexaDecimal(10),
       description: faker.lorem.sentences(2),
       location: faker.random.hexaDecimal(10),
-      start,
-      end,
       attendanceCode: faker.random.hexaDecimal(10),
       pointValue: EventFactory.randomPointValue(),
       requiresStaff: FactoryUtils.getRandomBoolean(),
       staffPointBonus: EventFactory.randomPointValue(),
     });
   }
 
+  public static fakePastEvent(daysAgo = 1): EventModel {
+    const [start, end] = EventFactory.randomPastTime(daysAgo);
+    return EventFactory.fakeWithTime(start, end);
+  }
+
+  public static fakeOngoingEvent(): EventModel {
+    const [start, end] = EventFactory.randomOngoingTime();
+    return EventFactory.fakeWithTime(start, end);
+  }
+
+  public static fakeFutureEvent(daysAhead = 1): EventModel {
+    const [start, end] = EventFactory.randomFutureTime(daysAhead);
+    return EventFactory.fakeWithTime(start, end);
+  }
+
   private static randomTime(): [Date, Date] {
     // between last and next week
     const days = FactoryUtils.getRandomNumber(-7, 7);
@@ -48,7 +72,41 @@ export class EventFactory {
     const duration = FactoryUtils.getRandomNumber(30, 150, 30);
     const start = moment().subtract(days, 'days').hour(hour);
     const end = moment(start.valueOf()).add(duration, 'minutes');
-    return [new Date(start.valueOf()), new Date(end.valueOf())];
+    return [start.toDate(), end.toDate()];
+  }
+
+  private static randomPastTime(daysAgo: number): [Date, Date] {
+    // random day between daysAgo and a week before daysAgo
+    const days = FactoryUtils.getRandomNumber(daysAgo, daysAgo + 7);
+    // between 8 AM and 6 PM
+    const hour = FactoryUtils.getRandomNumber(9, 19);
+    // between 0.5 and 2.5 hours long, rounded to the half hour
+    const duration = FactoryUtils.getRandomNumber(30, 150, 30);
+    const start = moment().subtract(days, 'days').hour(hour);
+    const end = moment(start.valueOf()).add(duration, 'minutes');
+    return [start.toDate(), end.toDate()];
+  }
+
+  private static randomOngoingTime(): [Date, Date] {
+    // 0-2 hours before now
+    const hour = FactoryUtils.getRandomNumber(0, 2);
+    // between 2.5 and 6 hours long, rounded to the half hour
+    const duration = FactoryUtils.getRandomNumber(150, 480, 30);
+    const start = moment().subtract(hour, 'hours');
+    const end = moment(start.valueOf()).add(duration, 'minutes');
+    return [start.toDate(), end.toDate()];
+  }
+
+  private static randomFutureTime(daysAhead: number): [Date, Date] {
+    // random day between daysAhead and a week before daysAhead
+    const days = FactoryUtils.getRandomNumber(daysAhead, daysAhead + 7);
+    // between 8 AM and 6 PM
+    const hour = FactoryUtils.getRandomNumber(9, 19);
+    // between 0.5 and 2.5 hours long, rounded to the half hour
+    const duration = FactoryUtils.getRandomNumber(30, 150, 30);
+    const start = moment().add(days, 'days').hour(hour);
+    const end = moment(start.valueOf()).add(duration, 'minutes');
+    return [start.toDate(), end.toDate()];
   }
 
   private static randomPointValue(): number {

tests/data/FeedbackFactory.ts

@@ -19,6 +19,10 @@ export class FeedbackFactory {
     };
   }
 
+  public static createEventFeedback(n: number): string[] {
+    return new Array(n).fill(faker.random.word());
+  }
+
   private static randomFeedbackType(): FeedbackType {
     return FactoryUtils.pickRandomValue(Object.values(FeedbackType));
   }

tests/data/FileFactory.ts

@@ -0,0 +1,24 @@
+import { File } from '../../types';
+
+const ONE_BYTE_FILLER = 'a';
+
+// Factory for mocking in-memory files for testing with multer
+export class FileFactory {
+  public static image(size: number): File {
+    const imageContents = ONE_BYTE_FILLER.repeat(size);
+    const buffer = Buffer.from(imageContents);
+    return {
+      fieldname: 'image',
+      originalname: 'image.jpg',
+      filename: 'image.jpg',
+      mimetype: 'image/jpg',
+      buffer,
+      encoding: '7bit',
+      size,
+      // the below fields are unused for in-memory multer storage but are still required by type def
+      stream: null,
+      destination: null,
+      path: null,
+    };
+  }
+}

tests/data/index.ts

@@ -3,5 +3,7 @@ export * from './DatabaseConnection';
 export * from './UserFactory';
 export * from './EventFactory';
 export * from './MerchFactory';
+export * from './FeedbackFactory';
+export * from './FileFactory';
 
 export * from './PortalState';

tests/event.test.ts

@@ -0,0 +1,225 @@
+import { validate } from 'class-validator';
+import { plainToClass } from 'class-transformer';
+import { DatabaseConnection, EventFactory, FeedbackFactory, FileFactory, PortalState, UserFactory } from './data';
+import { ControllerFactory } from './controllers';
+import { UserAccessType } from '../types';
+import { Config } from '../config';
+import { StorageUtils } from './utils';
+import { SubmitEventFeedbackRequest } from '../api/validators/EventControllerRequests';
+
+beforeAll(async () => {
+  await DatabaseConnection.connect();
+});
+
+beforeEach(async () => {
+  await DatabaseConnection.clear();
+});
+
+afterAll(async () => {
+  await DatabaseConnection.clear();
+  await DatabaseConnection.close();
+});
+
+describe('event CRUD operations', () => {
+  test('events from the past, future, and all time can be pulled', async () => {
+    const conn = await DatabaseConnection.get();
+    const pastEvent = EventFactory.fakePastEvent();
+    const ongoingEvent = EventFactory.fakeOngoingEvent();
+    const futureEvent = EventFactory.fakeFutureEvent();
+    const user = UserFactory.fake();
+
+    await new PortalState()
+      .createEvents([pastEvent, ongoingEvent, futureEvent])
+      .createUsers([user])
+      .write();
+
+    const eventController = ControllerFactory.event(conn);
+
+    const pastEventsResponse = await eventController.getPastEvents({}, user);
+    const futureEventsResponse = await eventController.getFutureEvents({}, user);
+    const allEventsResponse = await eventController.getAllEvents({}, user);
+
+    expect(pastEventsResponse.events).toEqual(
+      expect.arrayContaining([pastEvent.getPublicEvent()]),
+    );
+    expect(futureEventsResponse.events).toEqual(
+      expect.arrayContaining([
+        ongoingEvent.getPublicEvent(),
+        futureEvent.getPublicEvent(),
+      ]),
+    );
+    expect(allEventsResponse.events).toEqual(
+      expect.arrayContaining([
+        pastEvent.getPublicEvent(),
+        ongoingEvent.getPublicEvent(),
+        futureEvent.getPublicEvent(),
+      ]),
+    );
+  });
+
+  test('events can be created with unused attendance codes', async () => {
+    const conn = await DatabaseConnection.get();
+    const [event1] = EventFactory.with({ attendanceCode: 'code' });
+    const [event2] = EventFactory.with({ attendanceCode: 'different-code' });
+    const [admin] = UserFactory.with({ accessType: UserAccessType.ADMIN });
+
+    await new PortalState()
+      .createEvents([event1])
+      .createUsers([admin])
+      .write();
+
+    const createEventResponse = await ControllerFactory.event(conn).createEvent({ event: event2 }, admin);
+
+    expect(createEventResponse.error).toBeNull();
+  });
+
+  test('events cannot be created with duplicate attendance codes', async () => {
+    const conn = await DatabaseConnection.get();
+    const [event1] = EventFactory.with({ attendanceCode: 'code' });
+    const [event2] = EventFactory.with({ attendanceCode: 'code' });
+    const [admin] = UserFactory.with({ accessType: UserAccessType.ADMIN });
+
+    await new PortalState()
+      .createEvents([event1])
+      .createUsers([admin])
+      .write();
+
+    const eventController = ControllerFactory.event(conn);
+    const errorMessage = 'Attendance code has already been used';
+
+    await expect(
+      eventController.createEvent({ event: event2 }, admin),
+    ).rejects.toThrow(errorMessage);
+
+    const eventsResponse = await eventController.getAllEvents({}, admin);
+
+    expect(eventsResponse.events).toHaveLength(1);
+  });
+});
+
+describe('event covers', () => {
+  const storage = new StorageUtils();
+
+  afterEach(async () => {
+    await storage.deleteAllFilesInFolder(Config.file.EVENT_COVER_UPLOAD_PATH);
+  });
+
+  test('properly updates cover photo in database and on S3', async () => {
+    const conn = await DatabaseConnection.get();
+    const [event] = EventFactory.create(1);
+    const [admin] = UserFactory.with({ accessType: UserAccessType.ADMIN });
+    const cover = FileFactory.image(Config.file.MAX_EVENT_COVER_FILE_SIZE / 2);
+
+    await new PortalState()
+      .createUsers([admin])
+      .createEvents([event])
+      .write();
+
+    const eventCoverResponse = await ControllerFactory.event(conn).updateEventCover(cover, event.uuid, admin);
+    expect(eventCoverResponse.event.cover).toBeTruthy();
+
+    const eventCoverFiles = await storage.getAllFilesFromFolder(Config.file.EVENT_COVER_UPLOAD_PATH);
+    expect(eventCoverFiles).toHaveLength(1);
+
+    const fileName = StorageUtils.parseFirstFileNameFromFiles(eventCoverFiles);
+    expect(fileName).toEqual(event.uuid);
+  });
+
+  test('rejects upload if file size too large', async () => {
+    // TODO: implement once API wrappers exist (since multer validation can't be mocked with function calls)
+  });
+});
+
+describe('event feedback', () => {
+  test('can be persisted and rewarded points when submitted for an event already attended', async () => {
+    const conn = await DatabaseConnection.get();
+    const event = EventFactory.fakeOngoingEvent();
+    const user = UserFactory.fake();
+    const feedback = FeedbackFactory.createEventFeedback(3);
+
+    await new PortalState()
+      .createUsers([user])
+      .createEvents([event])
+      .attendEvents([user], [event], false)
+      .write();
+
+    const previousPoints = user.points;
+
+    await ControllerFactory.event(conn).submitEventFeedback(event.uuid, { feedback }, user);
+
+    const attendanceResponse = await ControllerFactory.attendance(conn).getAttendancesForCurrentUser(user);
+    const attendance = attendanceResponse.attendances[0];
+
+    expect(attendance.feedback).toEqual(feedback);
+
+    expect(user.points).toEqual(previousPoints + Config.pointReward.EVENT_FEEDBACK_POINT_REWARD);
+  });
+
+  test('is rejected on submission to an event not attended', async () => {
+    const conn = await DatabaseConnection.get();
+    const event = EventFactory.fakeOngoingEvent();
+    const user = UserFactory.fake();
+    const feedback = FeedbackFactory.createEventFeedback(3);
+
+    await new PortalState()
+      .createUsers([user])
+      .createEvents([event])
+      .write();
+
+    const errorMessage = 'You must attend this event before submiting feedback';
+
+    await expect(
+      ControllerFactory.event(conn).submitEventFeedback(event.uuid, { feedback }, user),
+    ).rejects.toThrow(errorMessage);
+  });
+
+  test('is rejected if submitted to an event multiple times', async () => {
+    const conn = await DatabaseConnection.get();
+    const event = EventFactory.fakeOngoingEvent();
+    const user = UserFactory.fake();
+    const feedback = FeedbackFactory.createEventFeedback(3);
+
+    await new PortalState()
+      .createUsers([user])
+      .createEvents([event])
+      .attendEvents([user], [event], false)
+      .write();
+
+    const eventController = ControllerFactory.event(conn);
+    await eventController.submitEventFeedback(event.uuid, { feedback }, user);
+
+    const errorMessage = 'You cannot submit feedback for this event more than once';
+
+    await expect(
+      eventController.submitEventFeedback(event.uuid, { feedback }, user),
+    ).rejects.toThrow(errorMessage);
+  });
+
+  test('is rejected if sent after 2 days of event completion', async () => {
+    const conn = await DatabaseConnection.get();
+    const event = EventFactory.fakePastEvent(3);
+    const user = UserFactory.fake();
+    const feedback = FeedbackFactory.createEventFeedback(3);
+
+    await new PortalState()
+      .createUsers([user])
+      .createEvents([event])
+      .attendEvents([user], [event], false)
+      .write();
+
+    const errorMessage = 'You must submit feedback within 2 days of the event ending';
+
+    await expect(
+      ControllerFactory.event(conn).submitEventFeedback(event.uuid, { feedback }, user),
+    ).rejects.toThrow(errorMessage);
+  });
+
+  test('is rejected if more than 3 feedback is provided', async () => {
+    const feedback = FeedbackFactory.createEventFeedback(4);
+    const errors = await validate(plainToClass(SubmitEventFeedbackRequest, { feedback }));
+
+    expect(errors).toBeDefined();
+    expect(errors).toHaveLength(1);
+    expect(errors[0].property).toEqual('feedback');
+  });
+});