Stash: RecreateApiToken use case WIP

Author: GPortas

src/users/domain/repositories/IUsersRepository.ts

@@ -2,4 +2,5 @@ import { AuthenticatedUser } from '../models/AuthenticatedUser'
 
 export interface IUsersRepository {
   getCurrentAuthenticatedUser(): Promise<AuthenticatedUser>
+  recreateApiToken(): Promise<string>
 }

src/users/domain/useCases/RecreateApiToken.ts

@@ -0,0 +1,19 @@
+import { UseCase } from '../../../core/domain/useCases/UseCase'
+import { IUsersRepository } from '../repositories/IUsersRepository'
+
+export class RecreateApiToken implements UseCase<string> {
+  private usersRepository: IUsersRepository
+
+  constructor(usersRepository: IUsersRepository) {
+    this.usersRepository = usersRepository
+  }
+
+  /**
+   * Reacreates the API token of the current authenticated user and returns the new one.
+   *
+   * @returns {Promise<AuthenticatedUser>}
+   */
+  async execute(): Promise<string> {
+    return await this.usersRepository.recreateApiToken()
+  }
+}

src/users/infra/repositories/UsersRepository.ts

@@ -4,14 +4,24 @@ import { AuthenticatedUser } from '../../domain/models/AuthenticatedUser'
 import { AxiosResponse } from 'axios'
 
 export class UsersRepository extends ApiRepository implements IUsersRepository {
+  private readonly usersResourceName: string = 'users'
+
   public async getCurrentAuthenticatedUser(): Promise<AuthenticatedUser> {
-    return this.doGet('/users/:me', true)
+    return this.doGet(`/${this.usersResourceName}/:me`, true)
       .then((response) => this.getAuthenticatedUserFromResponse(response))
       .catch((error) => {
         throw error
       })
   }
 
+  public async recreateApiToken(): Promise<string> {
+    return this.doPost(`/${this.usersResourceName}/token/recreate`, {})
+      .then((response) => response.data.data)
+      .catch((error) => {
+        throw error
+      })
+  }
+
   private getAuthenticatedUserFromResponse(response: AxiosResponse): AuthenticatedUser {
     const responseData = response.data.data
     return {

test/integration/users/UsersRepository.test.ts

@@ -6,24 +6,27 @@ import {
 import { TestConstants } from '../../testHelpers/TestConstants'
 import { ReadError } from '../../../src'
 
-describe('getCurrentAuthenticatedUser', () => {
+describe('UsersRepository', () => {
   const sut: UsersRepository = new UsersRepository()
 
-  test('should return error when authentication is not valid', async () => {
-    ApiConfig.init(TestConstants.TEST_API_URL, DataverseApiAuthMechanism.API_KEY, 'invalidApiKey')
+  describe('getCurrentAuthenticatedUser', () => {
+    test('should return error when authentication is not valid', async () => {
+      ApiConfig.init(TestConstants.TEST_API_URL, DataverseApiAuthMechanism.API_KEY, 'invalidApiKey')
 
-    const errorExpected: ReadError = new ReadError('[401] Bad API key')
-    await expect(sut.getCurrentAuthenticatedUser()).rejects.toThrow(errorExpected)
-  })
-
-  test('should return authenticated user when valid authentication is provided', async () => {
-    ApiConfig.init(
-      TestConstants.TEST_API_URL,
-      DataverseApiAuthMechanism.API_KEY,
-      process.env.TEST_API_KEY
-    )
+      const errorExpected: ReadError = new ReadError('[401] Bad API key')
+      await expect(sut.getCurrentAuthenticatedUser()).rejects.toThrow(errorExpected)
+    })
 
-    const actual = await sut.getCurrentAuthenticatedUser()
-    expect(actual.firstName).toBe('Dataverse')
+    test('should return authenticated user when valid authentication is provided', async () => {
+      ApiConfig.init(
+        TestConstants.TEST_API_URL,
+        DataverseApiAuthMechanism.API_KEY,
+        process.env.TEST_API_KEY
+      )
+      const actual = await sut.getCurrentAuthenticatedUser()
+      expect(actual.firstName).toBe('Dataverse')
+    })
   })
+
+  describe('recreateApiToken', () => {})
 })

test/unit/users/GetCurrentAuthenticatedUser.test.ts

@@ -6,9 +6,10 @@ import { createAuthenticatedUser } from '../../testHelpers/users/authenticatedUs
 describe('execute', () => {
   test('should return successful result with authenticated user on repository success', async () => {
     const testAuthenticatedUser = createAuthenticatedUser()
-    const usersRepositoryStub: IUsersRepository = {
-      getCurrentAuthenticatedUser: jest.fn().mockReturnValue(testAuthenticatedUser)
-    }
+    const usersRepositoryStub: IUsersRepository = {} as IUsersRepository
+    usersRepositoryStub.getCurrentAuthenticatedUser = jest
+      .fn()
+      .mockResolvedValue(testAuthenticatedUser)
     const sut = new GetCurrentAuthenticatedUser(usersRepositoryStub)
 
     const actual = await sut.execute()
@@ -17,14 +18,10 @@ describe('execute', () => {
   })
 
   test('should return error result on repository error', async () => {
-    const usersRepositoryStub: IUsersRepository = {
-      getCurrentAuthenticatedUser: jest.fn().mockRejectedValue(new ReadError())
-    }
+    const usersRepositoryStub: IUsersRepository = {} as IUsersRepository
+    usersRepositoryStub.getCurrentAuthenticatedUser = jest.fn().mockRejectedValue(new ReadError())
     const sut = new GetCurrentAuthenticatedUser(usersRepositoryStub)
 
-    let actualError: ReadError = undefined
-    await sut.execute().catch((e) => (actualError = e))
-
-    expect(actualError).toBeInstanceOf(ReadError)
+    await expect(sut.execute()).rejects.toThrow(ReadError)
   })
 })