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

refactor: updated test cases to split subscription

Browse Source
This commit is contained in:
ankitsridhar16
2023-01-23 15:23:53 +05:30
parent 25b7ef3d2e
commit 626d703d77
1 changed files with 164 additions and 104 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -18,12 +18,6 @@ const userHistoryService = new UserHistoryService(
mockPubSub as any,
);
enum SubscriptionType {
Created = 'created',
Updated = 'updated',
Deleted = 'deleted',
}
beforeEach(() => {
mockReset(mockPrisma);
mockPubSub.publish.mockClear();
@@ -143,7 +137,7 @@ describe('UserHistoryService', () => {
});
});
describe('addRequestToHistory', () => {
test('Should resolve right and add a REST request to users history, publish a subscription and return a `UserHistory` object', async () => {
test('Should resolve right and add a REST request to users history and return a `UserHistory` object', async () => {
userHistoryService.validateReqType('REST');
mockPrisma.userHistory.create.mockResolvedValueOnce({
userUid: 'abc',
@@ -165,11 +159,6 @@ describe('UserHistoryService', () => {
isStarred: false,
};
await userHistoryService.publishUserHistorySubscription(
userHistory,
SubscriptionType.Created,
);
return expect(
await userHistoryService.addRequestToHistory(
'abc',
@@ -179,7 +168,7 @@ describe('UserHistoryService', () => {
),
).toEqualRight(userHistory);
});
test('Should resolve right and add a GQL request to users history, publish a subscription and return a `UserHistory` object', async () => {
test('Should resolve right and add a GQL request to users history and return a `UserHistory` object', async () => {
userHistoryService.validateReqType('GQL');
mockPrisma.userHistory.create.mockResolvedValueOnce({
userUid: 'abc',
@@ -201,11 +190,6 @@ describe('UserHistoryService', () => {
isStarred: false,
};
await userHistoryService.publishUserHistorySubscription(
userHistory,
SubscriptionType.Created,
);
return expect(
await userHistoryService.addRequestToHistory(
'abc',
@@ -226,8 +210,76 @@ describe('UserHistoryService', () => {
),
).toEqualLeft(USER_HISTORY_INVALID_REQ_TYPE);
});
test('Should add a GQL request to users history and publish a created subscription', 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.addRequestToHistory(
'abc',
JSON.stringify([{}]),
JSON.stringify([{}]),
'GQL',
);
return expect(await mockPubSub.publish).toHaveBeenCalledWith(
`user_history/${userHistory.userUid}/created`,
userHistory,
);
});
test('Should add a REST request to users history and publish a created subscription', 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.addRequestToHistory(
'abc',
JSON.stringify([{}]),
JSON.stringify([{}]),
'REST',
);
return expect(await mockPubSub.publish).toHaveBeenCalledWith(
`user_history/${userHistory.userUid}/created`,
userHistory,
);
});
});
describe('starUnstarRequestInHistory', () => {
describe('toggleHistoryStarStatus', () => {
test('Should resolve right and star/unstar a request in the history', async () => {
mockPrisma.userHistory.findFirst.mockResolvedValueOnce({
userUid: 'abc',
@@ -259,25 +311,57 @@ describe('UserHistoryService', () => {
isStarred: true,
};
await userHistoryService.publishUserHistorySubscription(
userHistory,
SubscriptionType.Updated,
);
return expect(
await userHistoryService.starUnstarRequestInHistory('abc', '1'),
await userHistoryService.toggleHistoryStarStatus('abc', '1'),
).toEqualRight(userHistory);
});
test('Should resolve left and error out due to invalid request ID', async () => {
test('Should resolve left and error out due to invalid user history request ID', async () => {
mockPrisma.userHistory.findFirst.mockResolvedValueOnce(null);
return expect(
await userHistoryService.starUnstarRequestInHistory('abc', '1'),
await userHistoryService.toggleHistoryStarStatus('abc', '1'),
).toEqualLeft(USER_HISTORY_NOT_FOUND);
});
test('Should star/unstar a request in the history and publish a updated subscription', 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.toggleHistoryStarStatus('abc', '1');
return expect(mockPubSub.publish).toHaveBeenCalledWith(
`user_history/${userHistory.userUid}/updated`,
userHistory,
);
});
});
describe('removeRequestFromHistory', () => {
test('Should resolve right and delete request from users history, publish a subscription', async () => {
test('Should resolve right and delete request from users history', async () => {
mockPrisma.userHistory.delete.mockResolvedValueOnce({
userUid: 'abc',
id: '1',
@@ -298,11 +382,6 @@ describe('UserHistoryService', () => {
isStarred: false,
};
await userHistoryService.publishUserHistorySubscription(
userHistory,
SubscriptionType.Deleted,
);
return expect(
await userHistoryService.removeRequestFromHistory('abc', '1'),
).toEqualRight(userHistory);
@@ -314,6 +393,34 @@ describe('UserHistoryService', () => {
await userHistoryService.removeRequestFromHistory('abc', '1'),
).toEqualLeft(USER_HISTORY_NOT_FOUND);
});
test('Should delete request from users history and publish deleted 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.removeRequestFromHistory('abc', '1');
return expect(mockPubSub.publish).toHaveBeenCalledWith(
`user_history/${userHistory.userUid}/deleted`,
userHistory,
);
});
});
describe('deleteAllUserHistory', () => {
test('Should resolve right and delete all user REST history for a request type', async () => {
@@ -343,6 +450,30 @@ describe('UserHistoryService', () => {
await userHistoryService.deleteAllUserHistory('abc', 'INVALID'),
).toEqualLeft(USER_HISTORY_INVALID_REQ_TYPE);
});
test('Should delete all user REST history for a request type and publish deleted many subscription', async () => {
userHistoryService.validateReqType('REST');
mockPrisma.userHistory.deleteMany.mockResolvedValueOnce({
count: 2,
});
await userHistoryService.deleteAllUserHistory('abc', 'REST');
return expect(mockPubSub.publish).toHaveBeenCalledWith(
`user_history/abc/deleted_many`,
2,
);
});
test('Should delete all user GQL history for a request type and publish deleted many subscription', async () => {
userHistoryService.validateReqType('GQL');
mockPrisma.userHistory.deleteMany.mockResolvedValueOnce({
count: 2,
});
await userHistoryService.deleteAllUserHistory('abc', 'GQL');
return expect(mockPubSub.publish).toHaveBeenCalledWith(
`user_history/abc/deleted_many`,
2,
);
});
});
describe('validateReqType', () => {
test('Should resolve right when a valid REST ReqType is provided', async () => {
@@ -361,75 +492,4 @@ describe('UserHistoryService', () => {
);
});
});
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();
});
});
});