diff --git a/packages/hoppscotch-backend/src/user-history/user-history.service.spec.ts b/packages/hoppscotch-backend/src/user-history/user-history.service.spec.ts new file mode 100644 index 000000000..e387330c7 --- /dev/null +++ b/packages/hoppscotch-backend/src/user-history/user-history.service.spec.ts @@ -0,0 +1,442 @@ +import { UserHistoryService } from './user-history.service'; +import { PrismaService } from '../prisma/prisma.service'; +import { PubSubService } from '../pubsub/pubsub.service'; +import { mockDeep, mockReset } from 'jest-mock-extended'; +import { ReqType, UserHistory } from './user-history.model'; +import { + USER_HISTORY_INVALID_REQ_TYPE, + USER_HISTORY_NOT_FOUND, +} from '../errors'; + +const mockPrisma = mockDeep(); +const mockPubSub = mockDeep(); + +// eslint-disable-next-line @typescript-eslint/ban-ts-comment +// @ts-ignore +const userHistoryService = new UserHistoryService( + mockPrisma, + mockPubSub as any, +); + +enum SubscriptionType { + Created = 'created', + Updated = 'updated', + Deleted = 'deleted', +} + +beforeEach(() => { + mockReset(mockPrisma); + mockPubSub.publish.mockClear(); +}); + +describe('UserHistoryService', () => { + describe('fetchUserHistory', () => { + test('Should return a list of users REST history if exists', async () => { + const executedOn = new Date(); + mockPrisma.userHistory.findMany.mockResolvedValueOnce([ + { + userUid: 'abc', + id: '1', + request: [{}], + responseMetadata: [{}], + type: ReqType.REST, + executedOn: executedOn, + isStarred: false, + }, + { + userUid: 'abc', + id: '2', + request: [{}], + responseMetadata: [{}], + type: ReqType.REST, + executedOn: executedOn, + isStarred: true, + }, + ]); + + const userHistory: UserHistory[] = [ + { + userUid: 'abc', + id: '1', + request: JSON.stringify([{}]), + responseMetadata: JSON.stringify([{}]), + reqType: ReqType.REST, + executedOn: executedOn, + isStarred: false, + }, + { + userUid: 'abc', + id: '2', + request: JSON.stringify([{}]), + responseMetadata: JSON.stringify([{}]), + reqType: ReqType.REST, + executedOn: executedOn, + isStarred: true, + }, + ]; + return expect( + await userHistoryService.fetchUserHistory('abc', ReqType.REST), + ).toEqual(userHistory); + }); + test('Should return a list of users GQL history if exists', async () => { + const executedOn = new Date(); + mockPrisma.userHistory.findMany.mockResolvedValueOnce([ + { + userUid: 'abc', + id: '1', + request: [{}], + responseMetadata: [{}], + type: ReqType.GQL, + executedOn: executedOn, + isStarred: false, + }, + { + userUid: 'abc', + id: '2', + request: [{}], + responseMetadata: [{}], + type: ReqType.GQL, + executedOn: executedOn, + isStarred: true, + }, + ]); + + const userHistory: UserHistory[] = [ + { + userUid: 'abc', + id: '1', + request: JSON.stringify([{}]), + responseMetadata: JSON.stringify([{}]), + reqType: ReqType.GQL, + executedOn: executedOn, + isStarred: false, + }, + { + userUid: 'abc', + id: '2', + request: JSON.stringify([{}]), + responseMetadata: JSON.stringify([{}]), + reqType: ReqType.GQL, + executedOn: executedOn, + isStarred: true, + }, + ]; + return expect( + await userHistoryService.fetchUserHistory('abc', ReqType.GQL), + ).toEqual(userHistory); + }); + test('Should return an empty list of users REST history if doesnt exists', async () => { + mockPrisma.userHistory.findMany.mockResolvedValueOnce([]); + + const userHistory: UserHistory[] = []; + return expect( + await userHistoryService.fetchUserHistory('abc', ReqType.REST), + ).toEqual(userHistory); + }); + test('Should return an empty list of users GQL history if doesnt exists', async () => { + mockPrisma.userHistory.findMany.mockResolvedValueOnce([]); + + const userHistory: UserHistory[] = []; + return expect( + await userHistoryService.fetchUserHistory('abc', ReqType.GQL), + ).toEqual(userHistory); + }); + }); + describe('addRequestToHistory', () => { + test('Should resolve right and add a REST request to users history, publish a subscription and return a `UserHistory` object', async () => { + userHistoryService.validateReqType('REST'); + mockPrisma.userHistory.create.mockResolvedValueOnce({ + userUid: 'abc', + id: '1', + request: [{}], + responseMetadata: [{}], + type: ReqType.REST, + executedOn: new Date(), + isStarred: false, + }); + + const userHistory: UserHistory = { + userUid: 'abc', + id: '1', + request: JSON.stringify([{}]), + responseMetadata: JSON.stringify([{}]), + reqType: ReqType.REST, + executedOn: new Date(), + isStarred: false, + }; + + await userHistoryService.publishUserHistorySubscription( + userHistory, + SubscriptionType.Created, + ); + + return expect( + await userHistoryService.addRequestToHistory( + 'abc', + JSON.stringify([{}]), + JSON.stringify([{}]), + 'REST', + ), + ).toEqualRight(userHistory); + }); + test('Should resolve right and add a GQL request to users history, publish a subscription and return a `UserHistory` object', async () => { + userHistoryService.validateReqType('GQL'); + mockPrisma.userHistory.create.mockResolvedValueOnce({ + userUid: 'abc', + id: '1', + request: [{}], + responseMetadata: [{}], + type: ReqType.GQL, + executedOn: new Date(), + isStarred: false, + }); + + const userHistory: UserHistory = { + userUid: 'abc', + id: '1', + request: JSON.stringify([{}]), + responseMetadata: JSON.stringify([{}]), + reqType: ReqType.GQL, + executedOn: new Date(), + isStarred: false, + }; + + await userHistoryService.publishUserHistorySubscription( + userHistory, + SubscriptionType.Created, + ); + + return expect( + await userHistoryService.addRequestToHistory( + 'abc', + JSON.stringify([{}]), + JSON.stringify([{}]), + 'GQL', + ), + ).toEqualRight(userHistory); + }); + test('Should resolve left when invalid ReqType is passed', async () => { + userHistoryService.validateReqType('INVALID'); + return expect( + await userHistoryService.addRequestToHistory( + 'abc', + JSON.stringify([{}]), + JSON.stringify([{}]), + 'INVALID', + ), + ).toEqualLeft(USER_HISTORY_INVALID_REQ_TYPE); + }); + }); + describe('starUnstarRequestInHistory', () => { + test('Should resolve right and star/unstar a request in the history', async () => { + mockPrisma.userHistory.findFirst.mockResolvedValueOnce({ + userUid: 'abc', + id: '1', + request: [{}], + responseMetadata: [{}], + type: ReqType.REST, + executedOn: new Date(), + isStarred: false, + }); + + mockPrisma.userHistory.update.mockResolvedValueOnce({ + userUid: 'abc', + id: '1', + request: [{}], + responseMetadata: [{}], + type: ReqType.REST, + executedOn: new Date(), + isStarred: true, + }); + + const userHistory: UserHistory = { + userUid: 'abc', + id: '1', + request: JSON.stringify([{}]), + responseMetadata: JSON.stringify([{}]), + reqType: ReqType.REST, + executedOn: new Date(), + isStarred: true, + }; + + await userHistoryService.publishUserHistorySubscription( + userHistory, + SubscriptionType.Updated, + ); + + return expect( + await userHistoryService.starUnstarRequestInHistory('abc', '1'), + ).toEqualRight(userHistory); + }); + test('Should resolve left and error out due to invalid request ID', async () => { + mockPrisma.userHistory.findFirst.mockResolvedValueOnce(null); + + return expect( + await userHistoryService.starUnstarRequestInHistory('abc', '1'), + ).toEqualLeft(USER_HISTORY_NOT_FOUND); + }); + test('Should resolve left and error out due to invalid request ID', async () => { + mockPrisma.userHistory.findFirst.mockResolvedValueOnce(null); + + return expect( + await userHistoryService.starUnstarRequestInHistory('abc', '1'), + ).toEqualLeft(USER_HISTORY_NOT_FOUND); + }); + }); + describe('removeRequestFromHistory', () => { + test('Should resolve right and delete request from users history, publish a subscription', async () => { + mockPrisma.userHistory.delete.mockResolvedValueOnce({ + userUid: 'abc', + id: '1', + request: [{}], + responseMetadata: [{}], + type: ReqType.REST, + executedOn: new Date(), + isStarred: false, + }); + + const userHistory: UserHistory = { + userUid: 'abc', + id: '1', + request: JSON.stringify([{}]), + responseMetadata: JSON.stringify([{}]), + reqType: ReqType.REST, + executedOn: new Date(), + isStarred: false, + }; + + await userHistoryService.publishUserHistorySubscription( + userHistory, + SubscriptionType.Deleted, + ); + + return expect( + await userHistoryService.removeRequestFromHistory('abc', '1'), + ).toEqualRight(userHistory); + }); + test('Should resolve left and error out when req id is invalid ', async () => { + mockPrisma.userHistory.delete.mockResolvedValueOnce(null); + + return expect( + await userHistoryService.removeRequestFromHistory('abc', '1'), + ).toEqualLeft(USER_HISTORY_NOT_FOUND); + }); + }); + describe('deleteAllUserHistory', () => { + test('Should resolve right and delete all user REST history for a request type', async () => { + userHistoryService.validateReqType('REST'); + mockPrisma.userHistory.deleteMany.mockResolvedValueOnce({ + count: 2, + }); + + return expect( + await userHistoryService.deleteAllUserHistory('abc', 'REST'), + ).toEqualRight(2); + }); + test('Should resolve right and delete all user GQL history for a request type', async () => { + userHistoryService.validateReqType('GQL'); + mockPrisma.userHistory.deleteMany.mockResolvedValueOnce({ + count: 2, + }); + + return expect( + await userHistoryService.deleteAllUserHistory('abc', 'GQL'), + ).toEqualRight(2); + }); + test('Should resolve left and error when ReqType is invalid', async () => { + userHistoryService.validateReqType('INVALID'); + + return expect( + await userHistoryService.deleteAllUserHistory('abc', 'INVALID'), + ).toEqualLeft(USER_HISTORY_INVALID_REQ_TYPE); + }); + }); + describe('validateReqType', () => { + test('Should resolve right when a valid REST ReqType is provided', async () => { + return expect(userHistoryService.validateReqType('REST')).toEqualRight( + ReqType.REST, + ); + }); + test('Should resolve right when a valid GQL ReqType is provided', async () => { + return expect(userHistoryService.validateReqType('GQL')).toEqualRight( + ReqType.GQL, + ); + }); + test('Should resolve left and error out when a invalid ReqType is provided', async () => { + return expect(userHistoryService.validateReqType('INVALID')).toEqualLeft( + USER_HISTORY_INVALID_REQ_TYPE, + ); + }); + }); + describe('publishUserHistorySubscription', () => { + test('Should publish a created subscription', async () => { + const result: UserHistory = { + userUid: 'abc', + id: '1', + request: JSON.stringify([{}]), + responseMetadata: JSON.stringify([{}]), + reqType: ReqType.REST, + executedOn: new Date(), + isStarred: false, + }; + + await mockPubSub.publish( + `user_history/${result.userUid}/created`, + result, + ); + + return expect( + await userHistoryService.publishUserHistorySubscription( + result, + SubscriptionType.Created, + ), + ).toBeUndefined(); + }); + test('Should publish a updated subscription', async () => { + const result: UserHistory = { + userUid: 'abc', + id: '1', + request: JSON.stringify([{}]), + responseMetadata: JSON.stringify([{}]), + reqType: ReqType.REST, + executedOn: new Date(), + isStarred: false, + }; + + await mockPubSub.publish( + `user_history/${result.userUid}/updated`, + result, + ); + + return expect( + await userHistoryService.publishUserHistorySubscription( + result, + SubscriptionType.Updated, + ), + ).toBeUndefined(); + }); + test('Should publish a deleted subscription', async () => { + const result: UserHistory = { + userUid: 'abc', + id: '1', + request: JSON.stringify([{}]), + responseMetadata: JSON.stringify([{}]), + reqType: ReqType.REST, + executedOn: new Date(), + isStarred: false, + }; + + await mockPubSub.publish( + `user_history/${result.userUid}/deleted`, + result, + ); + + return expect( + await userHistoryService.publishUserHistorySubscription( + result, + SubscriptionType.Deleted, + ), + ).toBeUndefined(); + }); + }); +}); diff --git a/packages/hoppscotch-backend/src/user-history/user-history.service.ts b/packages/hoppscotch-backend/src/user-history/user-history.service.ts index 8fcdfbc11..6ff279279 100644 --- a/packages/hoppscotch-backend/src/user-history/user-history.service.ts +++ b/packages/hoppscotch-backend/src/user-history/user-history.service.ts @@ -3,6 +3,10 @@ import { PrismaService } from '../prisma/prisma.service'; import { PubSubService } from '../pubsub/pubsub.service'; import { ReqType, UserHistory } from './user-history.model'; import * as E from 'fp-ts/Either'; +import { + USER_HISTORY_INVALID_REQ_TYPE, + USER_HISTORY_NOT_FOUND, +} from '../errors'; // Contains constants for the subscription types we send to pubsub service enum SubscriptionType { @@ -19,7 +23,7 @@ export class UserHistoryService { ) {} /** - * Fetch users REST or GraphQL history based on ReqType argument. + * Fetch users REST or GraphQL history based on ReqType param. * @param uid Users uid * @param reqType request Type to fetch i.e. GraphQL or REST * @returns an array of user history @@ -41,6 +45,7 @@ export class UserHistoryService { request: JSON.stringify(history.request), responseMetadata: JSON.stringify(history.responseMetadata), isStarred: history.isStarred, + executedOn: history.executedOn, }); }); @@ -53,7 +58,7 @@ export class UserHistoryService { * @param reqData the request data * @param resMetadata the response metadata * @param reqType request Type to fetch i.e. GraphQL or REST - * @returns an array of user history + * @returns a `UserHistory` object */ async addRequestToHistory( uid: string, @@ -62,12 +67,14 @@ export class UserHistoryService { reqType: string, ) { const requestType = this.validateReqType(reqType); + if (E.isLeft(requestType)) return E.left(requestType.left); + const history = await this.prisma.userHistory.create({ data: { userUid: uid, request: JSON.parse(reqData), responseMetadata: JSON.parse(resMetadata), - type: requestType, + type: requestType.right, isStarred: false, }, }); @@ -87,7 +94,7 @@ export class UserHistoryService { SubscriptionType.Created, ); - return userHistory; + return E.right(userHistory); } /** @@ -104,7 +111,7 @@ export class UserHistoryService { }); if (userHistory == null) { - return E.left('history doesnt exist'); + return E.left(USER_HISTORY_NOT_FOUND); } try { const updatedHistory = await this.prisma.userHistory.update({ @@ -130,10 +137,9 @@ export class UserHistoryService { updatedUserHistory, SubscriptionType.Updated, ); - return E.right(updatedUserHistory); } catch (e) { - E.left('error updating'); + E.left(USER_HISTORY_NOT_FOUND); } } @@ -167,7 +173,7 @@ export class UserHistoryService { ); return E.right(deletedUserHistory); } catch (e) { - return E.left('error deleting history not found'); + return E.left(USER_HISTORY_NOT_FOUND); } } @@ -179,20 +185,22 @@ export class UserHistoryService { */ async deleteAllUserHistory(uid: string, reqType: string) { const requestType = this.validateReqType(reqType); - return await this.prisma.userHistory.deleteMany({ + if (E.isLeft(requestType)) return E.left(requestType.left); + + const deletedCount = await this.prisma.userHistory.deleteMany({ where: { userUid: uid, - type: requestType, + type: requestType.right, }, }); + return E.right(deletedCount.count); } // Method that takes a request type argument as string and validates against `ReqType` validateReqType(reqType: string) { - let requestType: ReqType; - return reqType == ReqType.REST - ? (requestType = ReqType.REST) - : (requestType = ReqType.GQL); + if (reqType == ReqType.REST) return E.right(ReqType.REST); + else if (reqType == ReqType.GQL) return E.right(ReqType.GQL); + return E.left(USER_HISTORY_INVALID_REQ_TYPE); } // Method to publish subscriptions based on the subscription type of the history @@ -203,19 +211,19 @@ export class UserHistoryService { switch (subscriptionType) { case SubscriptionType.Created: await this.pubsub.publish( - `user_history/${userHistory.id}/created`, + `user_history/${userHistory.userUid}/created`, userHistory, ); break; case SubscriptionType.Updated: await this.pubsub.publish( - `user_history/${userHistory.id}/updated`, + `user_history/${userHistory.userUid}/updated`, userHistory, ); break; case SubscriptionType.Deleted: await this.pubsub.publish( - `user_history/${userHistory.id}/deleted`, + `user_history/${userHistory.userUid}/deleted`, userHistory, ); break;