test: add unit, integration and functional tests

Author: g-saracca

test/functional/files/DeleteFile.test.ts

@@ -0,0 +1,89 @@
+import {
+  ApiConfig,
+  createDataset,
+  CreatedDatasetIdentifiers,
+  deleteFile,
+  getDatasetFileCounts,
+  getDatasetFiles,
+  WriteError
+} from '../../../src'
+import { DataverseApiAuthMechanism } from '../../../src/core/infra/repositories/ApiConfig'
+import {
+  createCollectionViaApi,
+  deleteCollectionViaApi
+} from '../../testHelpers/collections/collectionHelper'
+import { deleteUnpublishedDatasetViaApi } from '../../testHelpers/datasets/datasetHelper'
+import { uploadFileViaApi } from '../../testHelpers/files/filesHelper'
+import { TestConstants } from '../../testHelpers/TestConstants'
+
+describe('execute', () => {
+  const testCollectionAlias = 'deleteFileFunctionalTest'
+  let testDatasetIds: CreatedDatasetIdentifiers
+  const testTextFile1Name = 'test-file-1.txt'
+
+  beforeAll(async () => {
+    ApiConfig.init(
+      TestConstants.TEST_API_URL,
+      DataverseApiAuthMechanism.API_KEY,
+      process.env.TEST_API_KEY
+    )
+    await createCollectionViaApi(testCollectionAlias)
+
+    try {
+      testDatasetIds = await createDataset.execute(
+        TestConstants.TEST_NEW_DATASET_DTO,
+        testCollectionAlias
+      )
+    } catch (error) {
+      throw new Error('Tests beforeAll(): Error while creating test dataset')
+    }
+    await uploadFileViaApi(testDatasetIds.numericId, testTextFile1Name).catch(() => {
+      throw new Error(`Tests beforeAll(): Error while uploading file ${testTextFile1Name}`)
+    })
+  })
+
+  afterAll(async () => {
+    try {
+      await deleteUnpublishedDatasetViaApi(testDatasetIds.numericId)
+    } catch (error) {
+      throw new Error('Tests afterAll(): Error while deleting test dataset')
+    }
+    try {
+      await deleteCollectionViaApi(testCollectionAlias)
+    } catch (error) {
+      throw new Error('Tests afterAll(): Error while deleting test collection')
+    }
+  })
+
+  test('should successfully delete a file', async () => {
+    try {
+      const datasetFiles = await getDatasetFiles.execute(testDatasetIds.numericId)
+      console.log({ datasetFiles })
+      await deleteFile.execute(datasetFiles.files[0].id)
+    } catch (error) {
+      throw new Error('File should be deleted')
+    } finally {
+      const datasetFileCounts = await getDatasetFileCounts.execute(testDatasetIds.numericId)
+      console.log({ datasetFileCounts })
+      expect(datasetFileCounts.total).toEqual(0)
+    }
+  })
+
+  test('should throw an error when the file id does not exist', async () => {
+    expect.assertions(2)
+    let writeError: WriteError | undefined = undefined
+    const nonExistentFileId = 5
+
+    try {
+      await deleteFile.execute(nonExistentFileId)
+      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] File with ID ${nonExistentFileId} not found.`
+      )
+    }
+  })
+})

test/integration/files/FilesRepository.test.ts

@@ -28,7 +28,7 @@ import {
 } from '../../../src/datasets'
 import { FileModel } from '../../../src/files/domain/models/FileModel'
 import { FileCounts } from '../../../src/files/domain/models/FileCounts'
-import { FileDownloadSizeMode } from '../../../src'
+import { FileDownloadSizeMode, WriteError } from '../../../src'
 import {
   deaccessionDatasetViaApi,
   publishDatasetViaApi,
@@ -646,4 +646,83 @@ describe('FilesRepository', () => {
       ).rejects.toThrow(errorExpected)
     })
   })
+
+  describe('deleteFile', () => {
+    let deleFileTestDatasetIds: CreatedDatasetIdentifiers
+    const testTextFile1Name = 'test-file-1.txt'
+
+    beforeEach(async () => {
+      try {
+        deleFileTestDatasetIds = await createDataset.execute(TestConstants.TEST_NEW_DATASET_DTO)
+      } catch (error) {
+        throw new Error('Tests beforeEach(): Error while creating test dataset')
+      }
+      await uploadFileViaApi(deleFileTestDatasetIds.numericId, testTextFile1Name).catch(() => {
+        throw new Error(`Tests beforeEach(): Error while uploading file ${testTextFile1Name}`)
+      })
+    })
+
+    test('should successfully delete a file', async () => {
+      const datasetFiles = await sut.getDatasetFiles(
+        deleFileTestDatasetIds.numericId,
+        latestDatasetVersionId,
+        false,
+        FileOrderCriteria.NAME_AZ
+      )
+      await sut.deleteFile(datasetFiles.files[0].id)
+
+      const datasetFileCounts = await sut.getDatasetFileCounts(
+        deleFileTestDatasetIds.numericId,
+        latestDatasetVersionId,
+        false
+      )
+      expect(datasetFileCounts.total).toEqual(0)
+
+      await deleteUnpublishedDatasetViaApi(deleFileTestDatasetIds.numericId)
+    })
+
+    test('should delete a file from the draft dataset but not from the published dataset', async () => {
+      await publishDatasetViaApi(deleFileTestDatasetIds.numericId).catch(() => {
+        throw new Error('Error while publishing test Dataset')
+      })
+
+      await waitForNoLocks(deleFileTestDatasetIds.numericId, 10).catch(() => {
+        throw new Error('Error while waiting for no locks')
+      })
+
+      const datasetFiles = await sut.getDatasetFiles(
+        deleFileTestDatasetIds.numericId,
+        latestDatasetVersionId,
+        false,
+        FileOrderCriteria.NAME_AZ
+      )
+      await sut.deleteFile(datasetFiles.files[0].id)
+
+      const datasetFileCounts = await sut.getDatasetFileCounts(
+        deleFileTestDatasetIds.numericId,
+        DatasetNotNumberedVersion.DRAFT,
+        false
+      )
+
+      expect(datasetFileCounts.total).toEqual(0)
+
+      const publishedDatasetFileCounts = await sut.getDatasetFileCounts(
+        deleFileTestDatasetIds.numericId,
+        DatasetNotNumberedVersion.LATEST_PUBLISHED,
+        false
+      )
+
+      expect(publishedDatasetFileCounts.total).toBeGreaterThan(0)
+
+      await deletePublishedDatasetViaApi(deleFileTestDatasetIds.persistentId).catch(() => {
+        throw new Error('Error while deleting published test Dataset')
+      })
+    })
+
+    test('should return error when file does not exist', async () => {
+      const expectedError = new WriteError(`[404] File with ID ${nonExistentFiledId} not found.`)
+
+      await expect(sut.deleteFile(nonExistentFiledId)).rejects.toThrow(expectedError)
+    })
+  })
 })

test/unit/files/DeleteFile.test.ts

@@ -0,0 +1,25 @@
+import { IFilesRepository } from '../../../src/files/domain/repositories/IFilesRepository'
+import { WriteError } from '../../../src'
+import { DeleteFile } from '../../../src/files/domain/useCases/DeleteFile'
+
+describe('execute', () => {
+  test('should return undefined when repository call is successful', async () => {
+    const filesRepositoryStub: IFilesRepository = {} as IFilesRepository
+    filesRepositoryStub.deleteFile = jest.fn().mockResolvedValue(undefined)
+
+    const sut = new DeleteFile(filesRepositoryStub)
+
+    const actual = await sut.execute(1)
+
+    expect(actual).toEqual(undefined)
+  })
+
+  test('should return error result on repository error', async () => {
+    const filesRepositoryStub: IFilesRepository = {} as IFilesRepository
+    filesRepositoryStub.deleteFile = jest.fn().mockRejectedValue(new WriteError())
+
+    const sut = new DeleteFile(filesRepositoryStub)
+
+    await expect(sut.execute(1)).rejects.toThrow(WriteError)
+  })
+})