chore: moved auth utility functions to auth/helper.ts from src/utils.ts

This commit is contained in:
Balu Babu
2023-02-01 18:47:11 +05:30
parent 587e7118c9
commit b5e7877912
4 changed files with 311 additions and 308 deletions

View File

@@ -40,274 +40,276 @@ beforeEach(() => {
mockPubSub.publish.mockClear();
});
describe('findUserByEmail', () => {
test('should successfully return a valid user given a valid email', async () => {
mockPrisma.user.findUniqueOrThrow.mockResolvedValueOnce(user);
describe('UserService', () => {
describe('findUserByEmail', () => {
test('should successfully return a valid user given a valid email', async () => {
mockPrisma.user.findUniqueOrThrow.mockResolvedValueOnce(user);
const result = await userService.findUserByEmail(
'dwight@dundermifflin.com',
);
expect(result).toEqualSome(user);
});
test('should return a null user given a invalid email', async () => {
mockPrisma.user.findUniqueOrThrow.mockRejectedValueOnce('NotFoundError');
const result = await userService.findUserByEmail('jim@dundermifflin.com');
expect(result).resolves.toBeNone;
});
});
describe('findUserById', () => {
test('should successfully return a valid user given a valid user uid', async () => {
mockPrisma.user.findUniqueOrThrow.mockResolvedValueOnce(user);
const result = await userService.findUserById('123344');
expect(result).toEqualSome(user);
});
test('should return a null user given a invalid user uid', async () => {
mockPrisma.user.findUniqueOrThrow.mockRejectedValueOnce('NotFoundError');
const result = await userService.findUserById('sdcvbdbr');
expect(result).resolves.toBeNone;
});
});
describe('createUserViaMagicLink', () => {
test('should successfully create user and account for magic-link given valid inputs', async () => {
mockPrisma.user.create.mockResolvedValueOnce(user);
const result = await userService.createUserViaMagicLink(
'dwight@dundermifflin.com',
);
expect(result).toEqual(user);
});
});
describe('createUserSSO', () => {
test('should successfully create user and account for SSO provider given valid inputs ', async () => {
mockPrisma.user.create.mockResolvedValueOnce(user);
const result = await userService.createUserSSO(
'sdcsdcsdc',
'dscsdc',
exampleSSOProfileData,
);
expect(result).toEqual(user);
});
test('should successfully create user and account for SSO provider given no displayName ', async () => {
mockPrisma.user.create.mockResolvedValueOnce({
...user,
displayName: null,
const result = await userService.findUserByEmail(
'dwight@dundermifflin.com',
);
expect(result).toEqualSome(user);
});
const result = await userService.createUserSSO('sdcsdcsdc', 'dscsdc', {
...exampleSSOProfileData,
displayName: null,
});
test('should return a null user given a invalid email', async () => {
mockPrisma.user.findUniqueOrThrow.mockRejectedValueOnce('NotFoundError');
expect(result).toEqual({
...user,
displayName: null,
const result = await userService.findUserByEmail('jim@dundermifflin.com');
expect(result).resolves.toBeNone;
});
});
test('should successfully create user and account for SSO provider given no photoURL ', async () => {
mockPrisma.user.create.mockResolvedValueOnce({
...user,
photoURL: null,
describe('findUserById', () => {
test('should successfully return a valid user given a valid user uid', async () => {
mockPrisma.user.findUniqueOrThrow.mockResolvedValueOnce(user);
const result = await userService.findUserById('123344');
expect(result).toEqualSome(user);
});
const result = await userService.createUserSSO('sdcsdcsdc', 'dscsdc', {
...exampleSSOProfileData,
photoURL: null,
});
test('should return a null user given a invalid user uid', async () => {
mockPrisma.user.findUniqueOrThrow.mockRejectedValueOnce('NotFoundError');
expect(result).toEqual({
...user,
photoURL: null,
});
});
});
describe('createProviderAccount', () => {
test('should successfully create ProviderAccount for user given valid inputs ', async () => {
mockPrisma.account.create.mockResolvedValueOnce({
id: '123dcdc',
userId: user.uid,
provider: exampleSSOProfileData.provider,
providerAccountId: exampleSSOProfileData.id,
providerRefreshToken: 'dscsdc',
providerAccessToken: 'sdcsdcsdc',
providerScope: 'user.email',
loggedIn: currentTime,
});
const result = await userService.createProviderAccount(
user,
'sdcsdcsdc',
'dscsdc',
exampleSSOProfileData,
);
expect(result).toEqual({
id: '123dcdc',
userId: user.uid,
provider: exampleSSOProfileData.provider,
providerAccountId: exampleSSOProfileData.id,
providerRefreshToken: 'dscsdc',
providerAccessToken: 'sdcsdcsdc',
providerScope: 'user.email',
loggedIn: currentTime,
const result = await userService.findUserById('sdcvbdbr');
expect(result).resolves.toBeNone;
});
});
test('should successfully create ProviderAccount for user given no accessToken ', async () => {
mockPrisma.account.create.mockResolvedValueOnce({
id: '123dcdc',
userId: user.uid,
provider: exampleSSOProfileData.provider,
providerAccountId: exampleSSOProfileData.id,
providerRefreshToken: 'dscsdc',
providerAccessToken: null,
providerScope: 'user.email',
loggedIn: currentTime,
});
describe('createUserViaMagicLink', () => {
test('should successfully create user and account for magic-link given valid inputs', async () => {
mockPrisma.user.create.mockResolvedValueOnce(user);
const result = await userService.createProviderAccount(
user,
'sdcsdcsdc',
'dscsdc',
exampleSSOProfileData,
);
expect(result).toEqual({
id: '123dcdc',
userId: user.uid,
provider: exampleSSOProfileData.provider,
providerAccountId: exampleSSOProfileData.id,
providerRefreshToken: 'dscsdc',
providerAccessToken: null,
providerScope: 'user.email',
loggedIn: currentTime,
const result = await userService.createUserViaMagicLink(
'dwight@dundermifflin.com',
);
expect(result).toEqual(user);
});
});
test('should successfully create ProviderAccount for user given no refreshToken', async () => {
mockPrisma.account.create.mockResolvedValueOnce({
id: '123dcdc',
userId: user.uid,
provider: exampleSSOProfileData.provider,
providerAccountId: exampleSSOProfileData.id,
providerRefreshToken: null,
providerAccessToken: 'sdcsdcsdc',
providerScope: 'user.email',
loggedIn: currentTime,
describe('createUserSSO', () => {
test('should successfully create user and account for SSO provider given valid inputs ', async () => {
mockPrisma.user.create.mockResolvedValueOnce(user);
const result = await userService.createUserSSO(
'sdcsdcsdc',
'dscsdc',
exampleSSOProfileData,
);
expect(result).toEqual(user);
});
const result = await userService.createProviderAccount(
user,
'sdcsdcsdc',
'dscsdc',
exampleSSOProfileData,
);
expect(result).toEqual({
id: '123dcdc',
userId: user.uid,
provider: exampleSSOProfileData.provider,
providerAccountId: exampleSSOProfileData.id,
providerRefreshToken: null,
providerAccessToken: 'sdcsdcsdc',
providerScope: 'user.email',
loggedIn: currentTime,
});
});
});
describe('updateUserSessions', () => {
test('Should resolve right and update users GQL session', async () => {
const sessionData = user.currentGQLSession;
mockPrisma.user.update.mockResolvedValue({
...user,
currentGQLSession: sessionData,
currentRESTSession: null,
});
const result = await userService.updateUserSessions(
user,
JSON.stringify(sessionData),
'GQL',
);
expect(result).toEqualRight({
...user,
currentGQLSession: JSON.stringify(sessionData),
currentRESTSession: null,
});
});
test('Should resolve right and update users REST session', async () => {
const sessionData = user.currentGQLSession;
mockPrisma.user.update.mockResolvedValue({
...user,
currentGQLSession: null,
currentRESTSession: sessionData,
});
const result = await userService.updateUserSessions(
user,
JSON.stringify(sessionData),
'REST',
);
expect(result).toEqualRight({
...user,
currentGQLSession: null,
currentRESTSession: JSON.stringify(sessionData),
});
});
test('Should reject left and update user for invalid GQL session', async () => {
const sessionData = 'invalid json';
const result = await userService.updateUserSessions(
user,
sessionData,
'GQL',
);
expect(result).toEqualLeft(JSON_INVALID);
});
test('Should reject left and update user for invalid REST session', async () => {
const sessionData = 'invalid json';
const result = await userService.updateUserSessions(
user,
sessionData,
'REST',
);
expect(result).toEqualLeft(JSON_INVALID);
});
test('Should publish pubsub message on user update sessions', async () => {
mockPrisma.user.update.mockResolvedValue({
...user,
});
await userService.updateUserSessions(
user,
JSON.stringify(user.currentGQLSession),
'GQL',
);
expect(mockPubSub.publish).toHaveBeenCalledTimes(1);
expect(mockPubSub.publish).toHaveBeenCalledWith(
`user/${user.uid}/updated`,
{
test('should successfully create user and account for SSO provider given no displayName ', async () => {
mockPrisma.user.create.mockResolvedValueOnce({
...user,
currentGQLSession: JSON.stringify(user.currentGQLSession),
currentRESTSession: JSON.stringify(user.currentRESTSession),
},
);
displayName: null,
});
const result = await userService.createUserSSO('sdcsdcsdc', 'dscsdc', {
...exampleSSOProfileData,
displayName: null,
});
expect(result).toEqual({
...user,
displayName: null,
});
});
test('should successfully create user and account for SSO provider given no photoURL ', async () => {
mockPrisma.user.create.mockResolvedValueOnce({
...user,
photoURL: null,
});
const result = await userService.createUserSSO('sdcsdcsdc', 'dscsdc', {
...exampleSSOProfileData,
photoURL: null,
});
expect(result).toEqual({
...user,
photoURL: null,
});
});
});
describe('createProviderAccount', () => {
test('should successfully create ProviderAccount for user given valid inputs ', async () => {
mockPrisma.account.create.mockResolvedValueOnce({
id: '123dcdc',
userId: user.uid,
provider: exampleSSOProfileData.provider,
providerAccountId: exampleSSOProfileData.id,
providerRefreshToken: 'dscsdc',
providerAccessToken: 'sdcsdcsdc',
providerScope: 'user.email',
loggedIn: currentTime,
});
const result = await userService.createProviderAccount(
user,
'sdcsdcsdc',
'dscsdc',
exampleSSOProfileData,
);
expect(result).toEqual({
id: '123dcdc',
userId: user.uid,
provider: exampleSSOProfileData.provider,
providerAccountId: exampleSSOProfileData.id,
providerRefreshToken: 'dscsdc',
providerAccessToken: 'sdcsdcsdc',
providerScope: 'user.email',
loggedIn: currentTime,
});
});
test('should successfully create ProviderAccount for user given no accessToken ', async () => {
mockPrisma.account.create.mockResolvedValueOnce({
id: '123dcdc',
userId: user.uid,
provider: exampleSSOProfileData.provider,
providerAccountId: exampleSSOProfileData.id,
providerRefreshToken: 'dscsdc',
providerAccessToken: null,
providerScope: 'user.email',
loggedIn: currentTime,
});
const result = await userService.createProviderAccount(
user,
'sdcsdcsdc',
'dscsdc',
exampleSSOProfileData,
);
expect(result).toEqual({
id: '123dcdc',
userId: user.uid,
provider: exampleSSOProfileData.provider,
providerAccountId: exampleSSOProfileData.id,
providerRefreshToken: 'dscsdc',
providerAccessToken: null,
providerScope: 'user.email',
loggedIn: currentTime,
});
});
test('should successfully create ProviderAccount for user given no refreshToken', async () => {
mockPrisma.account.create.mockResolvedValueOnce({
id: '123dcdc',
userId: user.uid,
provider: exampleSSOProfileData.provider,
providerAccountId: exampleSSOProfileData.id,
providerRefreshToken: null,
providerAccessToken: 'sdcsdcsdc',
providerScope: 'user.email',
loggedIn: currentTime,
});
const result = await userService.createProviderAccount(
user,
'sdcsdcsdc',
'dscsdc',
exampleSSOProfileData,
);
expect(result).toEqual({
id: '123dcdc',
userId: user.uid,
provider: exampleSSOProfileData.provider,
providerAccountId: exampleSSOProfileData.id,
providerRefreshToken: null,
providerAccessToken: 'sdcsdcsdc',
providerScope: 'user.email',
loggedIn: currentTime,
});
});
});
describe('updateUserSessions', () => {
test('Should resolve right and update users GQL session', async () => {
const sessionData = user.currentGQLSession;
mockPrisma.user.update.mockResolvedValue({
...user,
currentGQLSession: sessionData,
currentRESTSession: null,
});
const result = await userService.updateUserSessions(
user,
JSON.stringify(sessionData),
'GQL',
);
expect(result).toEqualRight({
...user,
currentGQLSession: JSON.stringify(sessionData),
currentRESTSession: null,
});
});
test('Should resolve right and update users REST session', async () => {
const sessionData = user.currentGQLSession;
mockPrisma.user.update.mockResolvedValue({
...user,
currentGQLSession: null,
currentRESTSession: sessionData,
});
const result = await userService.updateUserSessions(
user,
JSON.stringify(sessionData),
'REST',
);
expect(result).toEqualRight({
...user,
currentGQLSession: null,
currentRESTSession: JSON.stringify(sessionData),
});
});
test('Should reject left and update user for invalid GQL session', async () => {
const sessionData = 'invalid json';
const result = await userService.updateUserSessions(
user,
sessionData,
'GQL',
);
expect(result).toEqualLeft(JSON_INVALID);
});
test('Should reject left and update user for invalid REST session', async () => {
const sessionData = 'invalid json';
const result = await userService.updateUserSessions(
user,
sessionData,
'REST',
);
expect(result).toEqualLeft(JSON_INVALID);
});
test('Should publish pubsub message on user update sessions', async () => {
mockPrisma.user.update.mockResolvedValue({
...user,
});
await userService.updateUserSessions(
user,
JSON.stringify(user.currentGQLSession),
'GQL',
);
expect(mockPubSub.publish).toHaveBeenCalledTimes(1);
expect(mockPubSub.publish).toHaveBeenCalledWith(
`user/${user.uid}/updated`,
{
...user,
currentGQLSession: JSON.stringify(user.currentGQLSession),
currentRESTSession: JSON.stringify(user.currentRESTSession),
},
);
});
});
});