btwedutech/hoppscotch
5
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 6 Wiki Activity

chore: added service files for user history and unit tests

Browse Source
This commit is contained in:
ankitsridhar16
2022-12-20 21:05:58 +05:30
parent 71c70a1b36
commit f7dadda52a
2 changed files with 467 additions and 17 deletions
Download Patch File Download Diff File Expand all files Collapse all files

442
packages/hoppscotch-backend/src/user-history/user-history.service.spec.ts Normal file
View File

@@ -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<PrismaService>();
const mockPubSub = mockDeep<PubSubService>();
// 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 = <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 = <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 = <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 = <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();
});
});
});

42
packages/hoppscotch-backend/src/user-history/user-history.service.ts
View File

@@ -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;