Added: DeleteCurrentApiToken use case

Author: GPortas

src/core/infra/repositories/ApiRepository.ts

@@ -35,6 +35,15 @@ export abstract class ApiRepository {
     return await this.doRequest('put', apiEndpoint, data, queryParams)
   }
 
+  public async doDelete(apiEndpoint: string, queryParams: object = {}): Promise<AxiosResponse> {
+    return await axios
+      .delete(buildRequestUrl(apiEndpoint), buildRequestConfig(true, queryParams))
+      .then((response) => response)
+      .catch((error) => {
+        throw new WriteError(this.buildErrorMessage(error))
+      })
+  }
+
   protected buildApiEndpoint(
     resourceName: string,
     operation: string,

src/users/domain/repositories/IUsersRepository.ts

@@ -5,4 +5,5 @@ export interface IUsersRepository {
   getCurrentAuthenticatedUser(): Promise<AuthenticatedUser>
   recreateApiToken(): Promise<ApiTokenInfo>
   getCurrentApiToken(): Promise<ApiTokenInfo>
+  deleteCurrentApiToken(): Promise<void>
 }

src/users/domain/useCases/DeleteCurrentApiToken.ts

@@ -0,0 +1,19 @@
+import { UseCase } from '../../../core/domain/useCases/UseCase'
+import { IUsersRepository } from '../repositories/IUsersRepository'
+
+export class DeleteCurrentApiToken implements UseCase<void> {
+  private usersRepository: IUsersRepository
+
+  constructor(usersRepository: IUsersRepository) {
+    this.usersRepository = usersRepository
+  }
+
+  /**
+   * Deletes the API token of the current authenticated user in ApiConfig.
+   *
+   * @returns {Promise<void>}
+   */
+  async execute(): Promise<void> {
+    return await this.usersRepository.deleteCurrentApiToken()
+  }
+}

src/users/index.ts

@@ -2,12 +2,15 @@ import { UsersRepository } from './infra/repositories/UsersRepository'
 import { GetCurrentAuthenticatedUser } from './domain/useCases/GetCurrentAuthenticatedUser'
 import { RecreateApiToken } from './domain/useCases/RecreateApiToken'
 import { GetCurrentApiToken } from './domain/useCases/GetCurrentApiToken'
+import { DeleteCurrentApiToken } from './domain/useCases/DeleteCurrentApiToken'
 
 const usersRepository = new UsersRepository()
 
 const getCurrentAuthenticatedUser = new GetCurrentAuthenticatedUser(usersRepository)
 const recreateApiToken = new RecreateApiToken(usersRepository)
 const getCurrentApiToken = new GetCurrentApiToken(usersRepository)
+const deleteCurrentApiToken = new DeleteCurrentApiToken(usersRepository)
 
-export { getCurrentAuthenticatedUser, recreateApiToken, getCurrentApiToken }
+export { getCurrentAuthenticatedUser, recreateApiToken, getCurrentApiToken, deleteCurrentApiToken }
 export { AuthenticatedUser } from './domain/models/AuthenticatedUser'
+export { ApiTokenInfo } from './domain/models/ApiTokenInfo'

src/users/infra/repositories/UsersRepository.ts

@@ -35,6 +35,14 @@ export class UsersRepository extends ApiRepository implements IUsersRepository {
       })
   }
 
+  public async deleteCurrentApiToken(): Promise<void> {
+    return this.doDelete(`/${this.usersResourceName}/token`)
+      .then(() => undefined)
+      .catch((error) => {
+        throw error
+      })
+  }
+
   private getAuthenticatedUserFromResponse(response: AxiosResponse): AuthenticatedUser {
     const responseData = response.data.data
     return {

test/functional/users/DeleteCurrentApiToken.test.ts

@@ -0,0 +1,32 @@
+import { ApiConfig, WriteError, deleteCurrentApiToken } from '../../../src'
+import { DataverseApiAuthMechanism } from '../../../src/core/infra/repositories/ApiConfig'
+import { TestConstants } from '../../testHelpers/TestConstants'
+import { createApiTokenViaApi } from '../../testHelpers/users/apiTokenHelper'
+
+describe('execute', () => {
+  beforeAll(async () => {
+    ApiConfig.init(
+      TestConstants.TEST_API_URL,
+      DataverseApiAuthMechanism.API_KEY,
+      process.env.TEST_API_KEY
+    )
+  })
+
+  afterAll(async () => {
+    ApiConfig.init(
+      TestConstants.TEST_API_URL,
+      DataverseApiAuthMechanism.API_KEY,
+      process.env.TEST_API_KEY
+    )
+  })
+
+  test('should successfully recreate the API token', async () => {
+    const testApiToken = await createApiTokenViaApi('deleteCurrentApiTokenFTUser')
+    ApiConfig.init(TestConstants.TEST_API_URL, DataverseApiAuthMechanism.API_KEY, testApiToken)
+    await deleteCurrentApiToken.execute()
+    // Since the token has been deleted, the next call using it should return a WriteError
+    await expect(
+      deleteCurrentApiToken.execute()
+    ).rejects.toBeInstanceOf(WriteError)
+  })
+})

test/integration/users/UsersRepository.test.ts

@@ -75,4 +75,22 @@ describe('UsersRepository', () => {
       await expect(sut.getCurrentApiToken()).rejects.toThrow(errorExpected)
     })
   })
+
+  describe('deleteCurrentApiToken', () => {
+    test('should return API token info when valid authentication is provided', async () => {
+      const testApiToken = await createApiTokenViaApi('deleteCurrentApiTokenITUser')
+      ApiConfig.init(TestConstants.TEST_API_URL, DataverseApiAuthMechanism.API_KEY, testApiToken)
+      await sut.deleteCurrentApiToken()
+      // Since the token has been deleted, the next call using it should return 401
+      const errorExpected: WriteError = new WriteError('[401] Bad API key')
+      await expect(sut.deleteCurrentApiToken()).rejects.toThrow(errorExpected)
+    })
+
+    test('should return error when authentication is not valid', async () => {
+      ApiConfig.init(TestConstants.TEST_API_URL, DataverseApiAuthMechanism.API_KEY, 'invalidApiKey')
+
+      const errorExpected: WriteError = new WriteError('[401] Bad API key')
+      await expect(sut.deleteCurrentApiToken()).rejects.toThrow(errorExpected)
+    })
+  })
 })

test/unit/users/DeleteCurrentApiToken.test.ts

@@ -0,0 +1,23 @@
+import { IUsersRepository } from '../../../src/users/domain/repositories/IUsersRepository'
+import { WriteError } from '../../../src'
+import { DeleteCurrentApiToken } from '../../../src/users/domain/useCases/DeleteCurrentApiToken'
+
+describe('execute', () => {
+  test('should return undefined on repository success', async () => {
+    const usersRepositoryStub: IUsersRepository = {} as IUsersRepository
+    usersRepositoryStub.deleteCurrentApiToken = jest.fn().mockResolvedValue(undefined)
+    const sut = new DeleteCurrentApiToken(usersRepositoryStub)
+
+    const actual = await sut.execute()
+
+    expect(actual).toBeUndefined()
+  })
+
+  test('should return error result on repository error', async () => {
+    const usersRepositoryStub: IUsersRepository = {} as IUsersRepository
+    usersRepositoryStub.deleteCurrentApiToken = jest.fn().mockRejectedValue(new WriteError())
+    const sut = new DeleteCurrentApiToken(usersRepositoryStub)
+
+    await expect(sut.execute()).rejects.toThrow(WriteError)
+  })
+})