f5d2e4f11f
* feat: added query in infra to fetch all shortcodes * feat: added mutation in admin to delete shortcode * chore: added new tests for methods in shortcode module * chore: removed .vscode file * chore: added a new ShortcodeCreator type to output of fetchAllShortcodes query * chore: shortcodeCreator type is now nullable * chore: added type defs to fetchAllShortcodes method in admin module * docs: update code comments * chore: changed target to prod in hoppscotch-old-backend --------- Co-authored-by: Mir Arif Hasan <arif.ishan05@gmail.com>
570 lines
17 KiB
TypeScript
570 lines
17 KiB
TypeScript
import { mockDeep, mockReset } from 'jest-mock-extended';
|
|
import { PrismaService } from '../prisma/prisma.service';
|
|
import {
|
|
INVALID_EMAIL,
|
|
SHORTCODE_INVALID_PROPERTIES_JSON,
|
|
SHORTCODE_INVALID_REQUEST_JSON,
|
|
SHORTCODE_NOT_FOUND,
|
|
SHORTCODE_PROPERTIES_NOT_FOUND,
|
|
} from 'src/errors';
|
|
import { Shortcode, ShortcodeWithUserEmail } from './shortcode.model';
|
|
import { ShortcodeService } from './shortcode.service';
|
|
import { UserService } from 'src/user/user.service';
|
|
import { AuthUser } from 'src/types/AuthUser';
|
|
|
|
const mockPrisma = mockDeep<PrismaService>();
|
|
|
|
const mockPubSub = {
|
|
publish: jest.fn().mockResolvedValue(null),
|
|
};
|
|
|
|
const mockDocFunc = jest.fn();
|
|
|
|
const mockFB = {
|
|
firestore: {
|
|
doc: mockDocFunc,
|
|
},
|
|
};
|
|
const mockUserService = new UserService(mockPrisma as any, mockPubSub as any);
|
|
|
|
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
|
|
// @ts-ignore
|
|
const shortcodeService = new ShortcodeService(
|
|
mockPrisma,
|
|
mockPubSub as any,
|
|
mockUserService,
|
|
);
|
|
|
|
beforeEach(() => {
|
|
mockReset(mockPrisma);
|
|
mockPubSub.publish.mockClear();
|
|
});
|
|
const createdOn = new Date();
|
|
|
|
const user: AuthUser = {
|
|
uid: '123344',
|
|
email: 'dwight@dundermifflin.com',
|
|
displayName: 'Dwight Schrute',
|
|
photoURL: 'https://en.wikipedia.org/wiki/Dwight_Schrute',
|
|
isAdmin: false,
|
|
refreshToken: 'hbfvdkhjbvkdvdfjvbnkhjb',
|
|
createdOn: createdOn,
|
|
currentGQLSession: {},
|
|
currentRESTSession: {},
|
|
};
|
|
|
|
const mockEmbed = {
|
|
id: '123',
|
|
request: '{}',
|
|
embedProperties: '{}',
|
|
createdOn: createdOn,
|
|
creatorUid: user.uid,
|
|
updatedOn: createdOn,
|
|
};
|
|
|
|
const mockShortcode = {
|
|
id: '123',
|
|
request: '{}',
|
|
embedProperties: null,
|
|
createdOn: createdOn,
|
|
creatorUid: user.uid,
|
|
updatedOn: createdOn,
|
|
};
|
|
|
|
const shortcodes = [
|
|
{
|
|
id: 'blablabla',
|
|
request: {
|
|
hello: 'there',
|
|
},
|
|
embedProperties: {
|
|
foo: 'bar',
|
|
},
|
|
creatorUid: user.uid,
|
|
createdOn: new Date(),
|
|
updatedOn: createdOn,
|
|
},
|
|
{
|
|
id: 'blablabla1',
|
|
request: {
|
|
hello: 'there',
|
|
},
|
|
embedProperties: {
|
|
foo: 'bar',
|
|
},
|
|
creatorUid: user.uid,
|
|
createdOn: new Date(),
|
|
updatedOn: createdOn,
|
|
},
|
|
];
|
|
|
|
const shortcodesWithUserEmail = [
|
|
{
|
|
id: 'blablabla',
|
|
request: {
|
|
hello: 'there',
|
|
},
|
|
embedProperties: {
|
|
foo: 'bar',
|
|
},
|
|
creatorUid: user.uid,
|
|
createdOn: new Date(),
|
|
updatedOn: createdOn,
|
|
User: user,
|
|
},
|
|
{
|
|
id: 'blablabla1',
|
|
request: {
|
|
hello: 'there',
|
|
},
|
|
embedProperties: {
|
|
foo: 'bar',
|
|
},
|
|
creatorUid: user.uid,
|
|
createdOn: new Date(),
|
|
updatedOn: createdOn,
|
|
User: user,
|
|
},
|
|
];
|
|
|
|
describe('ShortcodeService', () => {
|
|
describe('getShortCode', () => {
|
|
test('should return a valid Shortcode with valid Shortcode ID', async () => {
|
|
mockPrisma.shortcode.findFirstOrThrow.mockResolvedValueOnce(mockEmbed);
|
|
|
|
const result = await shortcodeService.getShortCode(mockEmbed.id);
|
|
expect(result).toEqualRight(<Shortcode>{
|
|
id: mockEmbed.id,
|
|
createdOn: mockEmbed.createdOn,
|
|
request: JSON.stringify(mockEmbed.request),
|
|
properties: JSON.stringify(mockEmbed.embedProperties),
|
|
});
|
|
});
|
|
|
|
test('should throw SHORTCODE_NOT_FOUND error when shortcode ID is invalid', async () => {
|
|
mockPrisma.shortcode.findFirstOrThrow.mockRejectedValueOnce(
|
|
'NotFoundError',
|
|
);
|
|
|
|
const result = await shortcodeService.getShortCode('invalidID');
|
|
expect(result).toEqualLeft(SHORTCODE_NOT_FOUND);
|
|
});
|
|
});
|
|
|
|
describe('fetchUserShortCodes', () => {
|
|
test('should return list of Shortcode with valid inputs and no cursor', async () => {
|
|
mockPrisma.shortcode.findMany.mockResolvedValueOnce(shortcodes);
|
|
|
|
const result = await shortcodeService.fetchUserShortCodes(user.uid, {
|
|
cursor: null,
|
|
take: 10,
|
|
});
|
|
expect(result).toEqual(<Shortcode[]>[
|
|
{
|
|
id: shortcodes[0].id,
|
|
request: JSON.stringify(shortcodes[0].request),
|
|
properties: JSON.stringify(shortcodes[0].embedProperties),
|
|
createdOn: shortcodes[0].createdOn,
|
|
},
|
|
{
|
|
id: shortcodes[1].id,
|
|
request: JSON.stringify(shortcodes[1].request),
|
|
properties: JSON.stringify(shortcodes[1].embedProperties),
|
|
createdOn: shortcodes[1].createdOn,
|
|
},
|
|
]);
|
|
});
|
|
|
|
test('should return list of Shortcode with valid inputs and cursor', async () => {
|
|
mockPrisma.shortcode.findMany.mockResolvedValue([shortcodes[1]]);
|
|
|
|
const result = await shortcodeService.fetchUserShortCodes(user.uid, {
|
|
cursor: 'blablabla',
|
|
take: 10,
|
|
});
|
|
expect(result).toEqual(<Shortcode[]>[
|
|
{
|
|
id: shortcodes[1].id,
|
|
request: JSON.stringify(shortcodes[1].request),
|
|
properties: JSON.stringify(shortcodes[1].embedProperties),
|
|
createdOn: shortcodes[1].createdOn,
|
|
},
|
|
]);
|
|
});
|
|
|
|
test('should return an empty array for an invalid cursor', async () => {
|
|
mockPrisma.shortcode.findMany.mockResolvedValue([]);
|
|
|
|
const result = await shortcodeService.fetchUserShortCodes(user.uid, {
|
|
cursor: 'invalidcursor',
|
|
take: 10,
|
|
});
|
|
|
|
expect(result).toHaveLength(0);
|
|
});
|
|
|
|
test('should return an empty array for an invalid user id and null cursor', async () => {
|
|
mockPrisma.shortcode.findMany.mockResolvedValue([]);
|
|
|
|
const result = await shortcodeService.fetchUserShortCodes('invalidid', {
|
|
cursor: null,
|
|
take: 10,
|
|
});
|
|
|
|
expect(result).toHaveLength(0);
|
|
});
|
|
|
|
test('should return an empty array for an invalid user id and an invalid cursor', async () => {
|
|
mockPrisma.shortcode.findMany.mockResolvedValue([]);
|
|
|
|
const result = await shortcodeService.fetchUserShortCodes('invalidid', {
|
|
cursor: 'invalidcursor',
|
|
take: 10,
|
|
});
|
|
|
|
expect(result).toHaveLength(0);
|
|
});
|
|
});
|
|
|
|
describe('createShortcode', () => {
|
|
test('should throw SHORTCODE_INVALID_REQUEST_JSON error if incoming request data is invalid', async () => {
|
|
const result = await shortcodeService.createShortcode(
|
|
'invalidRequest',
|
|
null,
|
|
user,
|
|
);
|
|
expect(result).toEqualLeft(SHORTCODE_INVALID_REQUEST_JSON);
|
|
});
|
|
|
|
test('should throw SHORTCODE_INVALID_PROPERTIES_JSON error if incoming properties data is invalid', async () => {
|
|
const result = await shortcodeService.createShortcode(
|
|
'{}',
|
|
'invalid_data',
|
|
user,
|
|
);
|
|
expect(result).toEqualLeft(SHORTCODE_INVALID_PROPERTIES_JSON);
|
|
});
|
|
|
|
test('should successfully create a new Embed with valid user uid', async () => {
|
|
// generateUniqueShortCodeID --> getShortcode
|
|
mockPrisma.shortcode.findFirstOrThrow.mockRejectedValueOnce(
|
|
'NotFoundError',
|
|
);
|
|
mockPrisma.shortcode.create.mockResolvedValueOnce(mockEmbed);
|
|
|
|
const result = await shortcodeService.createShortcode('{}', '{}', user);
|
|
expect(result).toEqualRight(<Shortcode>{
|
|
id: mockEmbed.id,
|
|
createdOn: mockEmbed.createdOn,
|
|
request: JSON.stringify(mockEmbed.request),
|
|
properties: JSON.stringify(mockEmbed.embedProperties),
|
|
});
|
|
});
|
|
|
|
test('should successfully create a new ShortCode with valid user uid', async () => {
|
|
// generateUniqueShortCodeID --> getShortcode
|
|
mockPrisma.shortcode.findFirstOrThrow.mockRejectedValueOnce(
|
|
'NotFoundError',
|
|
);
|
|
mockPrisma.shortcode.create.mockResolvedValueOnce(mockShortcode);
|
|
|
|
const result = await shortcodeService.createShortcode('{}', null, user);
|
|
expect(result).toEqualRight(<Shortcode>{
|
|
id: mockShortcode.id,
|
|
createdOn: mockShortcode.createdOn,
|
|
request: JSON.stringify(mockShortcode.request),
|
|
properties: mockShortcode.embedProperties,
|
|
});
|
|
});
|
|
|
|
test('should send pubsub message to `shortcode/{uid}/created` on successful creation of a Shortcode', async () => {
|
|
// generateUniqueShortCodeID --> getShortcode
|
|
mockPrisma.shortcode.findFirstOrThrow.mockRejectedValueOnce(
|
|
'NotFoundError',
|
|
);
|
|
mockPrisma.shortcode.create.mockResolvedValueOnce(mockShortcode);
|
|
|
|
const result = await shortcodeService.createShortcode('{}', null, user);
|
|
|
|
expect(mockPubSub.publish).toHaveBeenCalledWith(
|
|
`shortcode/${mockShortcode.creatorUid}/created`,
|
|
<Shortcode>{
|
|
id: mockShortcode.id,
|
|
createdOn: mockShortcode.createdOn,
|
|
request: JSON.stringify(mockShortcode.request),
|
|
properties: mockShortcode.embedProperties,
|
|
},
|
|
);
|
|
});
|
|
|
|
test('should send pubsub message to `shortcode/{uid}/created` on successful creation of an Embed', async () => {
|
|
// generateUniqueShortCodeID --> getShortcode
|
|
mockPrisma.shortcode.findFirstOrThrow.mockRejectedValueOnce(
|
|
'NotFoundError',
|
|
);
|
|
mockPrisma.shortcode.create.mockResolvedValueOnce(mockEmbed);
|
|
|
|
const result = await shortcodeService.createShortcode('{}', '{}', user);
|
|
|
|
expect(mockPubSub.publish).toHaveBeenCalledWith(
|
|
`shortcode/${mockEmbed.creatorUid}/created`,
|
|
<Shortcode>{
|
|
id: mockEmbed.id,
|
|
createdOn: mockEmbed.createdOn,
|
|
request: JSON.stringify(mockEmbed.request),
|
|
properties: JSON.stringify(mockEmbed.embedProperties),
|
|
},
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('revokeShortCode', () => {
|
|
test('should return true on successful deletion of Shortcode with valid inputs', async () => {
|
|
mockPrisma.shortcode.delete.mockResolvedValueOnce(mockEmbed);
|
|
|
|
const result = await shortcodeService.revokeShortCode(
|
|
mockEmbed.id,
|
|
mockEmbed.creatorUid,
|
|
);
|
|
|
|
expect(mockPrisma.shortcode.delete).toHaveBeenCalledWith({
|
|
where: {
|
|
creator_uid_shortcode_unique: {
|
|
creatorUid: mockEmbed.creatorUid,
|
|
id: mockEmbed.id,
|
|
},
|
|
},
|
|
});
|
|
|
|
expect(result).toEqualRight(true);
|
|
});
|
|
|
|
test('should return SHORTCODE_NOT_FOUND error when Shortcode is invalid and user uid is valid', async () => {
|
|
mockPrisma.shortcode.delete.mockRejectedValue('RecordNotFound');
|
|
expect(
|
|
shortcodeService.revokeShortCode('invalid', 'testuser'),
|
|
).resolves.toEqualLeft(SHORTCODE_NOT_FOUND);
|
|
});
|
|
|
|
test('should return SHORTCODE_NOT_FOUND error when Shortcode is valid and user uid is invalid', async () => {
|
|
mockPrisma.shortcode.delete.mockRejectedValue('RecordNotFound');
|
|
expect(
|
|
shortcodeService.revokeShortCode('blablablabla', 'invalidUser'),
|
|
).resolves.toEqualLeft(SHORTCODE_NOT_FOUND);
|
|
});
|
|
|
|
test('should return SHORTCODE_NOT_FOUND error when both Shortcode and user uid are invalid', async () => {
|
|
mockPrisma.shortcode.delete.mockRejectedValue('RecordNotFound');
|
|
expect(
|
|
shortcodeService.revokeShortCode('invalid', 'invalid'),
|
|
).resolves.toEqualLeft(SHORTCODE_NOT_FOUND);
|
|
});
|
|
|
|
test('should send pubsub message to `shortcode/{uid}/revoked` on successful deletion of Shortcode', async () => {
|
|
mockPrisma.shortcode.delete.mockResolvedValueOnce(mockEmbed);
|
|
|
|
const result = await shortcodeService.revokeShortCode(
|
|
mockEmbed.id,
|
|
mockEmbed.creatorUid,
|
|
);
|
|
|
|
expect(mockPubSub.publish).toHaveBeenCalledWith(
|
|
`shortcode/${mockEmbed.creatorUid}/revoked`,
|
|
{
|
|
id: mockEmbed.id,
|
|
createdOn: mockEmbed.createdOn,
|
|
request: JSON.stringify(mockEmbed.request),
|
|
properties: JSON.stringify(mockEmbed.embedProperties),
|
|
},
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('deleteUserShortCodes', () => {
|
|
test('should successfully delete all users Shortcodes with valid user uid', async () => {
|
|
mockPrisma.shortcode.deleteMany.mockResolvedValueOnce({ count: 1 });
|
|
|
|
const result = await shortcodeService.deleteUserShortCodes(
|
|
mockEmbed.creatorUid,
|
|
);
|
|
expect(result).toEqual(1);
|
|
});
|
|
|
|
test('should return 0 when user uid is invalid', async () => {
|
|
mockPrisma.shortcode.deleteMany.mockResolvedValueOnce({ count: 0 });
|
|
|
|
const result = await shortcodeService.deleteUserShortCodes(
|
|
mockEmbed.creatorUid,
|
|
);
|
|
expect(result).toEqual(0);
|
|
});
|
|
});
|
|
|
|
describe('updateShortcode', () => {
|
|
test('should return SHORTCODE_PROPERTIES_NOT_FOUND error when updatedProps in invalid', async () => {
|
|
const result = await shortcodeService.updateEmbedProperties(
|
|
mockEmbed.id,
|
|
user.uid,
|
|
'',
|
|
);
|
|
expect(result).toEqualLeft(SHORTCODE_PROPERTIES_NOT_FOUND);
|
|
});
|
|
|
|
test('should return SHORTCODE_PROPERTIES_NOT_FOUND error when updatedProps in invalid JSON format', async () => {
|
|
const result = await shortcodeService.updateEmbedProperties(
|
|
mockEmbed.id,
|
|
user.uid,
|
|
'{kk',
|
|
);
|
|
expect(result).toEqualLeft(SHORTCODE_INVALID_PROPERTIES_JSON);
|
|
});
|
|
|
|
test('should return SHORTCODE_NOT_FOUND error when Shortcode ID is invalid', async () => {
|
|
mockPrisma.shortcode.update.mockRejectedValue('RecordNotFound');
|
|
const result = await shortcodeService.updateEmbedProperties(
|
|
'invalidID',
|
|
user.uid,
|
|
'{}',
|
|
);
|
|
expect(result).toEqualLeft(SHORTCODE_NOT_FOUND);
|
|
});
|
|
|
|
test('should successfully update a Shortcodes with valid inputs', async () => {
|
|
mockPrisma.shortcode.update.mockResolvedValueOnce({
|
|
...mockEmbed,
|
|
embedProperties: '{"foo":"bar"}',
|
|
});
|
|
|
|
const result = await shortcodeService.updateEmbedProperties(
|
|
mockEmbed.id,
|
|
user.uid,
|
|
'{"foo":"bar"}',
|
|
);
|
|
expect(result).toEqualRight({
|
|
id: mockEmbed.id,
|
|
createdOn: mockEmbed.createdOn,
|
|
request: JSON.stringify(mockEmbed.request),
|
|
properties: JSON.stringify('{"foo":"bar"}'),
|
|
});
|
|
});
|
|
|
|
test('should send pubsub message to `shortcode/{uid}/updated` on successful Update of Shortcode', async () => {
|
|
mockPrisma.shortcode.update.mockResolvedValueOnce({
|
|
...mockEmbed,
|
|
embedProperties: '{"foo":"bar"}',
|
|
});
|
|
|
|
const result = await shortcodeService.updateEmbedProperties(
|
|
mockEmbed.id,
|
|
user.uid,
|
|
'{"foo":"bar"}',
|
|
);
|
|
|
|
expect(mockPubSub.publish).toHaveBeenCalledWith(
|
|
`shortcode/${mockEmbed.creatorUid}/updated`,
|
|
{
|
|
id: mockEmbed.id,
|
|
createdOn: mockEmbed.createdOn,
|
|
request: JSON.stringify(mockEmbed.request),
|
|
properties: JSON.stringify('{"foo":"bar"}'),
|
|
},
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('deleteShortcode', () => {
|
|
test('should return true on successful deletion of Shortcode with valid inputs', async () => {
|
|
mockPrisma.shortcode.delete.mockResolvedValueOnce(mockEmbed);
|
|
|
|
const result = await shortcodeService.deleteShortcode(mockEmbed.id);
|
|
expect(result).toEqualRight(true);
|
|
});
|
|
|
|
test('should return SHORTCODE_NOT_FOUND error when Shortcode is invalid', async () => {
|
|
mockPrisma.shortcode.delete.mockRejectedValue('RecordNotFound');
|
|
|
|
expect(shortcodeService.deleteShortcode('invalid')).resolves.toEqualLeft(
|
|
SHORTCODE_NOT_FOUND,
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('fetchAllShortcodes', () => {
|
|
test('should return list of Shortcodes with valid inputs and no cursor', async () => {
|
|
mockPrisma.shortcode.findMany.mockResolvedValueOnce(
|
|
shortcodesWithUserEmail,
|
|
);
|
|
|
|
const result = await shortcodeService.fetchAllShortcodes(
|
|
{
|
|
cursor: null,
|
|
take: 10,
|
|
},
|
|
user.email,
|
|
);
|
|
expect(result).toEqual(<ShortcodeWithUserEmail[]>[
|
|
{
|
|
id: shortcodes[0].id,
|
|
request: JSON.stringify(shortcodes[0].request),
|
|
properties: JSON.stringify(shortcodes[0].embedProperties),
|
|
createdOn: shortcodes[0].createdOn,
|
|
creator: {
|
|
uid: user.uid,
|
|
email: user.email,
|
|
},
|
|
},
|
|
{
|
|
id: shortcodes[1].id,
|
|
request: JSON.stringify(shortcodes[1].request),
|
|
properties: JSON.stringify(shortcodes[1].embedProperties),
|
|
createdOn: shortcodes[1].createdOn,
|
|
creator: {
|
|
uid: user.uid,
|
|
email: user.email,
|
|
},
|
|
},
|
|
]);
|
|
});
|
|
|
|
test('should return list of Shortcode with valid inputs and cursor', async () => {
|
|
mockPrisma.shortcode.findMany.mockResolvedValue([
|
|
shortcodesWithUserEmail[1],
|
|
]);
|
|
|
|
const result = await shortcodeService.fetchAllShortcodes(
|
|
{
|
|
cursor: 'blablabla',
|
|
take: 10,
|
|
},
|
|
user.email,
|
|
);
|
|
expect(result).toEqual(<ShortcodeWithUserEmail[]>[
|
|
{
|
|
id: shortcodes[1].id,
|
|
request: JSON.stringify(shortcodes[1].request),
|
|
properties: JSON.stringify(shortcodes[1].embedProperties),
|
|
createdOn: shortcodes[1].createdOn,
|
|
creator: {
|
|
uid: user.uid,
|
|
email: user.email,
|
|
},
|
|
},
|
|
]);
|
|
});
|
|
|
|
test('should return an empty array for an invalid cursor', async () => {
|
|
mockPrisma.shortcode.findMany.mockResolvedValue([]);
|
|
|
|
const result = await shortcodeService.fetchAllShortcodes(
|
|
{
|
|
cursor: 'invalidcursor',
|
|
take: 10,
|
|
},
|
|
user.email,
|
|
);
|
|
|
|
expect(result).toHaveLength(0);
|
|
});
|
|
});
|
|
});
|