feat: create get confirmation code logic

src/b3_stock_alerts/AlertService.unit.test.ts

@@ -19,6 +19,7 @@ describe('AlertService', () => {
     updateUser: jest.fn(),
     getUserByEmail: jest.fn(),
     createConfirmationCode: jest.fn(),
+    getConfirmationCode: jest.fn(),
   };
 
   const service = new AlertService(alert_repository_mock, user_repository_mock);

src/b3_stock_alerts/AuthService.ts

@@ -67,4 +67,10 @@ export default class AuthService {
 
     return {};
   }
+
+  async confirmCode(email: string, code: string): Promise<Result<boolean>> {
+    const confirmation_code = await this.user_repository.getConfirmationCode(email, code);
+
+    return { data: !!confirmation_code };
+  }
 }

src/b3_stock_alerts/AuthService.unit.test.ts

@@ -14,6 +14,7 @@ describe("AuthService's unit tests", () => {
     getUsers: jest.fn(),
     getUserByEmail: jest.fn(),
     createConfirmationCode: jest.fn(),
+    getConfirmationCode: jest.fn(),
   };
 
   const encryptor_mock = {
@@ -176,4 +177,36 @@ describe("AuthService's unit tests", () => {
       expect(params.code).toBe('1234');
     });
   });
+
+  describe('AuthService.confirmCode', () => {
+    afterEach(() => {
+      user_repository_mock.getConfirmationCode.mockClear();
+    });
+
+    it("returns a result with false if code doesn't exist", async () => {
+      expect.assertions(1);
+
+      const email = faker.internet.email();
+      const code = faker.string.numeric(4);
+
+      user_repository_mock.getConfirmationCode.mockResolvedValueOnce(false);
+
+      const result = await auth_service.confirmCode(email, code);
+
+      expect(result.data).toEqual(false);
+    });
+
+    it('returns a result with true if code exists', async () => {
+      expect.assertions(1);
+
+      const email = faker.internet.email();
+      const code = faker.string.numeric(4);
+
+      user_repository_mock.getConfirmationCode.mockResolvedValueOnce(true);
+
+      const result = await auth_service.confirmCode(email, code);
+
+      expect(result.data).toEqual(true);
+    });
+  });
 });

src/b3_stock_alerts/PgUserRepository.ts

@@ -1,5 +1,6 @@
 import Postgres from '@shared/Postgres';
 import { Client } from 'pg';
+import ConfirmationCode from './ConfirmationCode';
 import { User } from './User';
 import { UserConfirmationCode } from './UserConfirmationCode';
 import UserRepository from './UserRepository';
@@ -83,4 +84,17 @@ export default class PgUserRepository implements UserRepository {
       [confirmation_code.id, confirmation_code.user_id, confirmation_code.code],
     );
   }
+
+  async getConfirmationCode(email: string, code: string): Promise<ConfirmationCode | null> {
+    const result = await this.client.query(
+      'SELECT ucc.id, user_id, code FROM user_confirmation_codes ucc WHERE code = $1 JOIN users ON users.email = $2',
+      [code, email],
+    );
+
+    if (result.rows[0] === undefined) {
+      return null;
+    }
+
+    return result.rows[0];
+  }
 }

src/b3_stock_alerts/PgUserRepository.unit.test.ts

@@ -187,4 +187,47 @@ describe('PgUserRepository', () => {
       ]);
     });
   });
+
+  describe('PgUserRepository.getConfirmationCode', () => {
+    it('returns a confirmation code', async () => {
+      expect.assertions(2);
+
+      const email = faker.internet.email();
+      const code = faker.string.numeric(4);
+
+      const confirmation_code = {
+        id: faker.string.uuid(),
+        user_id: faker.string.uuid(),
+        code,
+      }
+
+      query_mock.mockResolvedValueOnce({ rows: [confirmation_code] });
+
+      const result = await repository.getConfirmationCode(email, code);
+
+      expect(query_mock).toHaveBeenCalledWith(
+        'SELECT ucc.id, user_id, code FROM user_confirmation_codes ucc WHERE code = $1 JOIN users ON users.email = $2',
+        [code, email],
+      );
+      expect(result).toEqual(confirmation_code);
+    });
+
+    it("returns NULL if confirmation code doesn't exit", async () => {
+      expect.assertions(2);
+
+      const email = faker.internet.email();
+      const code = faker.string.numeric(4);
+
+      query_mock.mockResolvedValueOnce({ rows: [] });
+
+      const result = await repository.getConfirmationCode(email, code);
+
+      expect(query_mock).toHaveBeenCalledWith(
+        'SELECT ucc.id, user_id, code FROM user_confirmation_codes ucc WHERE code = $1 JOIN users ON users.email = $2',
+        [code, email],
+      );
+
+      expect(result).toBeNull();
+    });
+  });
 });

src/b3_stock_alerts/StockEventHandler.unit.test.ts

@@ -16,6 +16,7 @@ describe("StockEventHandler's unit tests", () => {
     getUsers: jest.fn(),
     getUserByEmail: jest.fn(),
     createConfirmationCode: jest.fn(),
+    getConfirmationCode: jest.fn(),
   };
 
   const handler = new StockEventHandler(alert_notification_mock, user_repository_mock);

src/b3_stock_alerts/UserRepository.ts

@@ -1,3 +1,4 @@
+import ConfirmationCode from './ConfirmationCode';
 import { User } from './User';
 import { UserConfirmationCode } from './UserConfirmationCode';
 
@@ -9,4 +10,5 @@ export default interface UserRepository {
   deleteUser(user_id: string): Promise<void>;
   getUserByEmail(email: string): Promise<User | null>;
   createConfirmationCode(confirmation_code: UserConfirmationCode): Promise<void>;
+  getConfirmationCode(email: string, code: string): Promise<ConfirmationCode | null>;
 }

src/b3_stock_alerts/UserService.unit.test.ts

@@ -13,6 +13,7 @@ describe("UserService's unit tests", () => {
     getUsers: jest.fn(),
     getUserByEmail: jest.fn(),
     createConfirmationCode: jest.fn(),
+    getConfirmationCode: jest.fn(),
   };
 
   const encryptor_mock = {