test: add unit, functional and integration test cases

Author: g-saracca

test/functional/collections/DeleteCollection.test.ts

@@ -0,0 +1,55 @@
+import {
+  ApiConfig,
+  ReadError,
+  WriteError,
+  createCollection,
+  deleteCollection,
+  getCollection
+} from '../../../src'
+import { TestConstants } from '../../testHelpers/TestConstants'
+import { DataverseApiAuthMechanism } from '../../../src/core/infra/repositories/ApiConfig'
+import { createCollectionDTO } from '../../testHelpers/collections/collectionHelper'
+
+describe('execute', () => {
+  beforeEach(async () => {
+    ApiConfig.init(
+      TestConstants.TEST_API_URL,
+      DataverseApiAuthMechanism.API_KEY,
+      process.env.TEST_API_KEY
+    )
+  })
+
+  test('should successfully delete a collection', async () => {
+    const testCollectionAlias = 'deleteCollection-functional-test'
+    const testNewCollection = createCollectionDTO(testCollectionAlias)
+    await createCollection.execute(testNewCollection)
+
+    expect.assertions(1)
+    try {
+      await deleteCollection.execute(testCollectionAlias)
+    } catch (error) {
+      throw new Error('Collection should be deleted')
+    } finally {
+      const expectedError = new ReadError(
+        `[404] Can't find dataverse with identifier='${testCollectionAlias}'`
+      )
+      await expect(getCollection.execute(testCollectionAlias)).rejects.toThrow(expectedError)
+    }
+  })
+
+  test('should throw an error when the collection does not exist', async () => {
+    expect.assertions(2)
+    let writeError: WriteError | undefined = undefined
+    try {
+      await deleteCollection.execute(TestConstants.TEST_DUMMY_COLLECTION_ID)
+      throw new Error('Use case should throw an error')
+    } catch (error) {
+      writeError = error as WriteError
+    } finally {
+      expect(writeError).toBeInstanceOf(WriteError)
+      expect(writeError?.message).toEqual(
+        `There was an error when writing the resource. Reason was: [404] Can't find dataverse with identifier='${TestConstants.TEST_DUMMY_COLLECTION_ID}'`
+      )
+    }
+  })
+})

test/integration/collections/CollectionsRepository.test.ts

@@ -47,6 +47,7 @@ describe('CollectionsRepository', () => {
   const sut: CollectionsRepository = new CollectionsRepository()
   let testCollectionId: number
   const currentYear = new Date().getFullYear()
+
   beforeAll(async () => {
     ApiConfig.init(
       TestConstants.TEST_API_URL,
@@ -146,6 +147,7 @@ describe('CollectionsRepository', () => {
       expect(createdCollection.name).toBe(newCollectionDTO.name)
     })
   })
+
   describe('createCollection', () => {
     const testCreateCollectionAlias1 = 'createCollection-test-1'
     const testCreateCollectionAlias2 = 'createCollection-test-2'
@@ -247,6 +249,35 @@ describe('CollectionsRepository', () => {
     })
   })
 
+  describe('deleteCollection', () => {
+    test('should delete collection successfully', async () => {
+      const collectionAlias = 'deleteCollection-test'
+      const collectionDTO = createCollectionDTO(collectionAlias)
+      await sut.createCollection(collectionDTO)
+
+      const createdCollection = await sut.getCollection(collectionAlias)
+
+      expect(createdCollection.alias).toBe(collectionAlias)
+
+      const deleteResult = await sut.deleteCollection(collectionAlias)
+      const expectedError = new ReadError(
+        `[404] Can't find dataverse with identifier='${collectionAlias}'`
+      )
+
+      expect(deleteResult).toBeUndefined()
+      await expect(sut.getCollection(collectionAlias)).rejects.toThrow(expectedError)
+    })
+
+    test('should return error when collection does not exist', async () => {
+      const expectedError = new WriteError(
+        `[404] Can't find dataverse with identifier='${TestConstants.TEST_DUMMY_COLLECTION_ID}'`
+      )
+      await expect(sut.deleteCollection(TestConstants.TEST_DUMMY_COLLECTION_ID)).rejects.toThrow(
+        expectedError
+      )
+    })
+  })
+
   describe('getCollectionFacets', () => {
     test('should return collection facets given a valid collection alias', async () => {
       const actual = await sut.getCollectionFacets(testCollectionAlias)

test/unit/collections/CollectionsRepository.test.ts

@@ -569,4 +569,87 @@ describe('CollectionsRepository', () => {
       expect(error).toBeInstanceOf(Error)
     })
   })
+
+  describe('deleteCollection', () => {
+    const deleteTestCollectionAlias = 'deleteCollection-unit-test'
+    const deleteTestCollectionId = 123
+
+    describe('by numeric id', () => {
+      const expectedApiEndpoint = `${TestConstants.TEST_API_URL}/dataverses/${deleteTestCollectionId}`
+
+      test('should delete a collection when providing a valid id', async () => {
+        jest.spyOn(axios, 'delete').mockResolvedValue({ data: { status: 'OK' } })
+
+        // API Key auth
+        await sut.deleteCollection(deleteTestCollectionId)
+
+        expect(axios.delete).toHaveBeenCalledWith(
+          expectedApiEndpoint,
+          TestConstants.TEST_EXPECTED_AUTHENTICATED_REQUEST_CONFIG_API_KEY
+        )
+
+        // Session cookie auth
+        ApiConfig.init(TestConstants.TEST_API_URL, DataverseApiAuthMechanism.SESSION_COOKIE)
+
+        await sut.deleteCollection(deleteTestCollectionId)
+
+        expect(axios.delete).toHaveBeenCalledWith(
+          expectedApiEndpoint,
+          TestConstants.TEST_EXPECTED_AUTHENTICATED_REQUEST_CONFIG_SESSION_COOKIE
+        )
+      })
+
+      test('should return error result on error response', async () => {
+        jest.spyOn(axios, 'delete').mockRejectedValue(TestConstants.TEST_ERROR_RESPONSE)
+
+        let error = undefined as unknown as WriteError
+        await sut.deleteCollection(deleteTestCollectionId).catch((e) => (error = e))
+
+        expect(axios.delete).toHaveBeenCalledWith(
+          expectedApiEndpoint,
+          TestConstants.TEST_EXPECTED_AUTHENTICATED_REQUEST_CONFIG_API_KEY
+        )
+        expect(error).toBeInstanceOf(WriteError)
+      })
+    })
+
+    describe('by alias id', () => {
+      const expectedApiEndpoint = `${TestConstants.TEST_API_URL}/dataverses/${deleteTestCollectionAlias}`
+
+      test('should delete a collection when providing a valid alias', async () => {
+        jest.spyOn(axios, 'delete').mockResolvedValue({ data: { status: 'OK' } })
+
+        // API Key auth
+        await sut.deleteCollection(deleteTestCollectionAlias)
+
+        expect(axios.delete).toHaveBeenCalledWith(
+          expectedApiEndpoint,
+          TestConstants.TEST_EXPECTED_AUTHENTICATED_REQUEST_CONFIG_API_KEY
+        )
+
+        // Session cookie auth
+        ApiConfig.init(TestConstants.TEST_API_URL, DataverseApiAuthMechanism.SESSION_COOKIE)
+
+        await sut.deleteCollection(deleteTestCollectionAlias)
+
+        expect(axios.delete).toHaveBeenCalledWith(
+          expectedApiEndpoint,
+          TestConstants.TEST_EXPECTED_AUTHENTICATED_REQUEST_CONFIG_SESSION_COOKIE
+        )
+      })
+
+      test('should return error result on error response', async () => {
+        jest.spyOn(axios, 'delete').mockRejectedValue(TestConstants.TEST_ERROR_RESPONSE)
+
+        let error = undefined as unknown as WriteError
+        await sut.deleteCollection(deleteTestCollectionAlias).catch((e) => (error = e))
+
+        expect(axios.delete).toHaveBeenCalledWith(
+          expectedApiEndpoint,
+          TestConstants.TEST_EXPECTED_AUTHENTICATED_REQUEST_CONFIG_API_KEY
+        )
+        expect(error).toBeInstanceOf(WriteError)
+      })
+    })
+  })
 })

test/unit/collections/DeleteCollection.test.ts

@@ -0,0 +1,23 @@
+import { ICollectionsRepository } from '../../../src/collections/domain/repositories/ICollectionsRepository'
+import { WriteError } from '../../../src'
+import { DeleteCollection } from '../../../src/collections/domain/useCases/DeleteCollection'
+
+describe('execute', () => {
+  test('should return undefined on repository success', async () => {
+    const collectionRepositoryStub: ICollectionsRepository = {} as ICollectionsRepository
+    collectionRepositoryStub.deleteCollection = jest.fn().mockResolvedValue(undefined)
+    const testDeleteCollection = new DeleteCollection(collectionRepositoryStub)
+
+    const actual = await testDeleteCollection.execute(1)
+
+    expect(actual).toEqual(undefined)
+  })
+
+  test('should return error result on repository error', async () => {
+    const collectionRepositoryStub: ICollectionsRepository = {} as ICollectionsRepository
+    collectionRepositoryStub.deleteCollection = jest.fn().mockRejectedValue(new WriteError())
+    const testDeleteCollection = new DeleteCollection(collectionRepositoryStub)
+
+    await expect(testDeleteCollection.execute(1)).rejects.toThrow(WriteError)
+  })
+})