test: add more integration cases

Author: g-saracca

src/files/infra/repositories/FilesRepository.ts

@@ -51,6 +51,7 @@ export interface UploadedFileRequestBody {
   directoryLabel?: string
   categories?: string[]
   restrict?: boolean
+  forceReplace?: boolean
 }
 
 export interface ChecksumRequestBody {
@@ -311,6 +312,7 @@ export class FilesRepository extends ApiRepository implements IFilesRepository {
       },
       mimeType: uploadedFileDTO.mimeType,
       storageIdentifier: uploadedFileDTO.storageId,
+      forceReplace: uploadedFileDTO.forceReplace,
       ...(uploadedFileDTO.description && { description: uploadedFileDTO.description }),
       ...(uploadedFileDTO.categories && { categories: uploadedFileDTO.categories }),
       ...(uploadedFileDTO.restrict && { restrict: uploadedFileDTO.restrict }),

test/integration/files/DirectUpload.test.ts

@@ -4,6 +4,7 @@ import {
   DatasetNotNumberedVersion,
   FileOrderCriteria,
   UploadedFileDTO,
+  WriteError,
   createDataset
 } from '../../../src'
 import { DataverseApiAuthMechanism } from '../../../src/core/infra/repositories/ApiConfig'
@@ -29,6 +30,9 @@ describe('Direct Upload', () => {
   let testDataset1Ids: CreatedDatasetIdentifiers
   let testDataset2Ids: CreatedDatasetIdentifiers
   let testDataset3Ids: CreatedDatasetIdentifiers
+  let testDatset4Ids: CreatedDatasetIdentifiers
+  let testDataset5Ids: CreatedDatasetIdentifiers
+  let testDataset6Ids: CreatedDatasetIdentifiers
 
   const filesRepositorySut = new FilesRepository()
   const directUploadSut: DirectUploadClient = new DirectUploadClient(filesRepositorySut)
@@ -63,6 +67,18 @@ describe('Direct Upload', () => {
         TestConstants.TEST_NEW_DATASET_DTO,
         testCollectionAlias
       )
+      testDatset4Ids = await createDataset.execute(
+        TestConstants.TEST_NEW_DATASET_DTO,
+        testCollectionAlias
+      )
+      testDataset5Ids = await createDataset.execute(
+        TestConstants.TEST_NEW_DATASET_DTO,
+        testCollectionAlias
+      )
+      testDataset6Ids = await createDataset.execute(
+        TestConstants.TEST_NEW_DATASET_DTO,
+        testCollectionAlias
+      )
     } catch (error) {
       throw new Error('Tests beforeAll(): Error while creating test dataset')
     }
@@ -74,6 +90,9 @@ describe('Direct Upload', () => {
     await deleteUnpublishedDatasetViaApi(testDataset1Ids.numericId)
     await deleteUnpublishedDatasetViaApi(testDataset2Ids.numericId)
     await deleteUnpublishedDatasetViaApi(testDataset3Ids.numericId)
+    await deleteUnpublishedDatasetViaApi(testDatset4Ids.numericId)
+    await deleteUnpublishedDatasetViaApi(testDataset5Ids.numericId)
+    await deleteUnpublishedDatasetViaApi(testDataset6Ids.numericId)
     await deleteCollectionViaApi(testCollectionAlias)
   })
 
@@ -220,7 +239,7 @@ describe('Direct Upload', () => {
     ).rejects.toThrow(FileUploadCancelError)
   })
 
-  test('should upload file add it to the dataset, upload a new one and replace it', async () => {
+  test('should replace a file succesfully', async () => {
     // 1 - Upload first file and add it to the dataset
     const destination = await createTestFileUploadDestination(
       singlepartFile,
@@ -327,6 +346,324 @@ describe('Direct Upload', () => {
     expect(datasetFiles.files[0].storageIdentifier).toContain('localstack1://mybucket:')
   })
 
+  test('should fail to replace a file when mimetype is different and forceReplace is false', async () => {
+    // 1 - Upload first file and add it to the dataset
+    const destination = await createTestFileUploadDestination(
+      singlepartFile,
+      testDatset4Ids.numericId
+    )
+    const singlepartFileUrl = destination.urls[0]
+
+    const progressMock = jest.fn()
+    const abortController = new AbortController()
+
+    expect(await singlepartFileExistsInBucket(singlepartFileUrl)).toBe(false)
+
+    const actualStorageId = await directUploadSut.uploadFile(
+      testDatset4Ids.numericId,
+      singlepartFile,
+      progressMock,
+      abortController,
+      destination
+    )
+    expect(actualStorageId).toBe(destination.storageId)
+
+    expect(await singlepartFileExistsInBucket(singlepartFileUrl)).toBe(true)
+
+    let datasetFiles = await filesRepositorySut.getDatasetFiles(
+      testDatset4Ids.numericId,
+      DatasetNotNumberedVersion.LATEST,
+      true,
+      FileOrderCriteria.NAME_AZ
+    )
+
+    expect(datasetFiles.totalFilesCount).toBe(0)
+
+    const fileArrayBuffer = await singlepartFile.arrayBuffer()
+    const fileBuffer = Buffer.from(fileArrayBuffer)
+
+    const uploadedFileDTO = {
+      fileName: singlepartFile.name,
+      storageId: actualStorageId,
+      checksumType: checksumAlgorithm,
+      checksumValue: calculateBlobChecksum(fileBuffer),
+      mimeType: singlepartFile.type
+    }
+
+    await filesRepositorySut.addUploadedFilesToDataset(testDatset4Ids.numericId, [uploadedFileDTO])
+
+    datasetFiles = await filesRepositorySut.getDatasetFiles(
+      testDatset4Ids.numericId,
+      DatasetNotNumberedVersion.LATEST,
+      true,
+      FileOrderCriteria.NAME_AZ
+    )
+
+    expect(datasetFiles.totalFilesCount).toBe(1)
+    expect(datasetFiles.files[0].name).toBe('singlepart-file')
+    expect(datasetFiles.files[0].sizeBytes).toBe(singlepartFile.size)
+    expect(datasetFiles.files[0].storageIdentifier).toContain('localstack1://mybucket:')
+
+    // 2 - Upload a new file and get the new storage id
+    const newSinglepartFile = await createSinglepartFileBlob(
+      'new-singlepart-file',
+      1500,
+      'text/csv'
+    )
+    const newDestination = await createTestFileUploadDestination(
+      newSinglepartFile,
+      testDatset4Ids.numericId
+    )
+    const newSinglepartFileUrl = newDestination.urls[0]
+
+    expect(await singlepartFileExistsInBucket(newSinglepartFileUrl)).toBe(false)
+
+    const newFileStorageId = await directUploadSut.uploadFile(
+      testDatset4Ids.numericId,
+      newSinglepartFile,
+      progressMock,
+      abortController,
+      newDestination
+    )
+    expect(newFileStorageId).toBe(newDestination.storageId)
+
+    expect(await singlepartFileExistsInBucket(newSinglepartFileUrl)).toBe(true)
+
+    // 3 - Replace the old file with the new file (must have different content)
+    const currentFileId = datasetFiles.files[0].id
+    const newFileArrayBuffer = await newSinglepartFile.arrayBuffer()
+    const newFileBuffer = Buffer.from(newFileArrayBuffer)
+    const newUploadedFileDTO: UploadedFileDTO = {
+      fileName: newSinglepartFile.name,
+      storageId: newFileStorageId,
+      checksumType: checksumAlgorithm,
+      checksumValue: calculateBlobChecksum(newFileBuffer),
+      mimeType: newSinglepartFile.type,
+      forceReplace: false
+    }
+
+    const expectedError = new WriteError(
+      '[400] The original file (Plain Text) and replacement file (Comma Separated Values) are different file types.'
+    )
+
+    await expect(filesRepositorySut.replaceFile(currentFileId, newUploadedFileDTO)).rejects.toThrow(
+      expectedError
+    )
+  })
+
+  test('should replace a file succesfully when mimetype is different but forceReplace is true', async () => {
+    // 1 - Upload first file and add it to the dataset
+    const destination = await createTestFileUploadDestination(
+      singlepartFile,
+      testDataset5Ids.numericId
+    )
+    const singlepartFileUrl = destination.urls[0]
+
+    const progressMock = jest.fn()
+    const abortController = new AbortController()
+
+    expect(await singlepartFileExistsInBucket(singlepartFileUrl)).toBe(false)
+
+    const actualStorageId = await directUploadSut.uploadFile(
+      testDataset5Ids.numericId,
+      singlepartFile,
+      progressMock,
+      abortController,
+      destination
+    )
+    expect(actualStorageId).toBe(destination.storageId)
+
+    expect(await singlepartFileExistsInBucket(singlepartFileUrl)).toBe(true)
+
+    let datasetFiles = await filesRepositorySut.getDatasetFiles(
+      testDataset5Ids.numericId,
+      DatasetNotNumberedVersion.LATEST,
+      true,
+      FileOrderCriteria.NAME_AZ
+    )
+
+    expect(datasetFiles.totalFilesCount).toBe(0)
+
+    const fileArrayBuffer = await singlepartFile.arrayBuffer()
+    const fileBuffer = Buffer.from(fileArrayBuffer)
+
+    const uploadedFileDTO = {
+      fileName: singlepartFile.name,
+      storageId: actualStorageId,
+      checksumType: checksumAlgorithm,
+      checksumValue: calculateBlobChecksum(fileBuffer),
+      mimeType: singlepartFile.type
+    }
+
+    await filesRepositorySut.addUploadedFilesToDataset(testDataset5Ids.numericId, [uploadedFileDTO])
+
+    datasetFiles = await filesRepositorySut.getDatasetFiles(
+      testDataset5Ids.numericId,
+      DatasetNotNumberedVersion.LATEST,
+      true,
+      FileOrderCriteria.NAME_AZ
+    )
+
+    expect(datasetFiles.totalFilesCount).toBe(1)
+    expect(datasetFiles.files[0].name).toBe('singlepart-file')
+    expect(datasetFiles.files[0].sizeBytes).toBe(singlepartFile.size)
+    expect(datasetFiles.files[0].storageIdentifier).toContain('localstack1://mybucket:')
+
+    // 2 - Upload a new file and get the new storage id
+    const newSinglepartFile = await createSinglepartFileBlob(
+      'new-singlepart-file-diff-mimetype',
+      1500,
+      'text/csv'
+    )
+    const newDestination = await createTestFileUploadDestination(
+      newSinglepartFile,
+      testDataset5Ids.numericId
+    )
+    const newSinglepartFileUrl = newDestination.urls[0]
+
+    expect(await singlepartFileExistsInBucket(newSinglepartFileUrl)).toBe(false)
+
+    const newFileStorageId = await directUploadSut.uploadFile(
+      testDataset5Ids.numericId,
+      newSinglepartFile,
+      progressMock,
+      abortController,
+      newDestination
+    )
+    expect(newFileStorageId).toBe(newDestination.storageId)
+
+    expect(await singlepartFileExistsInBucket(newSinglepartFileUrl)).toBe(true)
+
+    // 3 - Replace the old file with the new file (must have different content), the new file has a different mimetype but forceReplace is true
+    const currentFileId = datasetFiles.files[0].id
+    const newFileArrayBuffer = await newSinglepartFile.arrayBuffer()
+    const newFileBuffer = Buffer.from(newFileArrayBuffer)
+    const newUploadedFileDTO: UploadedFileDTO = {
+      fileName: newSinglepartFile.name,
+      storageId: newFileStorageId,
+      checksumType: checksumAlgorithm,
+      checksumValue: calculateBlobChecksum(newFileBuffer),
+      mimeType: newSinglepartFile.type,
+      forceReplace: true
+    }
+
+    await filesRepositorySut.replaceFile(currentFileId, newUploadedFileDTO)
+
+    // 4 - Verify that the new file is in the dataset and the old file is not
+    datasetFiles = await filesRepositorySut.getDatasetFiles(
+      testDataset5Ids.numericId,
+      DatasetNotNumberedVersion.LATEST,
+      true,
+      FileOrderCriteria.NAME_AZ
+    )
+
+    expect(datasetFiles.totalFilesCount).toBe(1)
+    expect(datasetFiles.files[0].name).toBe('new-singlepart-file-diff-mimetype')
+    expect(datasetFiles.files[0].contentType).toBe(newSinglepartFile.type)
+    expect(datasetFiles.files[0].sizeBytes).toBe(newSinglepartFile.size)
+    expect(datasetFiles.files[0].storageIdentifier).toContain('localstack1://mybucket:')
+  })
+
+  test('should fail to replace a file when the new image has the same content as the old image', async () => {
+    // 1 - Upload first file and add it to the dataset
+    const destination = await createTestFileUploadDestination(
+      singlepartFile,
+      testDataset6Ids.numericId
+    )
+    const singlepartFileUrl = destination.urls[0]
+
+    const progressMock = jest.fn()
+    const abortController = new AbortController()
+
+    expect(await singlepartFileExistsInBucket(singlepartFileUrl)).toBe(false)
+
+    const actualStorageId = await directUploadSut.uploadFile(
+      testDataset6Ids.numericId,
+      singlepartFile,
+      progressMock,
+      abortController,
+      destination
+    )
+    expect(actualStorageId).toBe(destination.storageId)
+
+    expect(await singlepartFileExistsInBucket(singlepartFileUrl)).toBe(true)
+
+    let datasetFiles = await filesRepositorySut.getDatasetFiles(
+      testDataset6Ids.numericId,
+      DatasetNotNumberedVersion.LATEST,
+      true,
+      FileOrderCriteria.NAME_AZ
+    )
+
+    expect(datasetFiles.totalFilesCount).toBe(0)
+
+    const fileArrayBuffer = await singlepartFile.arrayBuffer()
+    const fileBuffer = Buffer.from(fileArrayBuffer)
+
+    const uploadedFileDTO = {
+      fileName: singlepartFile.name,
+      storageId: actualStorageId,
+      checksumType: checksumAlgorithm,
+      checksumValue: calculateBlobChecksum(fileBuffer),
+      mimeType: singlepartFile.type
+    }
+
+    await filesRepositorySut.addUploadedFilesToDataset(testDataset6Ids.numericId, [uploadedFileDTO])
+
+    datasetFiles = await filesRepositorySut.getDatasetFiles(
+      testDataset6Ids.numericId,
+      DatasetNotNumberedVersion.LATEST,
+      true,
+      FileOrderCriteria.NAME_AZ
+    )
+
+    expect(datasetFiles.totalFilesCount).toBe(1)
+    expect(datasetFiles.files[0].name).toBe('singlepart-file')
+    expect(datasetFiles.files[0].sizeBytes).toBe(singlepartFile.size)
+    expect(datasetFiles.files[0].storageIdentifier).toContain('localstack1://mybucket:')
+
+    // 2 - Upload a new file with the same content and get the new storage id
+    const newSinglepartFile = await createSinglepartFileBlob()
+    const newDestination = await createTestFileUploadDestination(
+      newSinglepartFile,
+      testDataset6Ids.numericId
+    )
+    const newSinglepartFileUrl = newDestination.urls[0]
+
+    expect(await singlepartFileExistsInBucket(newSinglepartFileUrl)).toBe(false)
+
+    const newFileStorageId = await directUploadSut.uploadFile(
+      testDataset6Ids.numericId,
+      newSinglepartFile,
+      progressMock,
+      abortController,
+      newDestination
+    )
+    expect(newFileStorageId).toBe(newDestination.storageId)
+
+    expect(await singlepartFileExistsInBucket(newSinglepartFileUrl)).toBe(true)
+
+    // 3 - Replace the old file with the new file (must have different content), the new file has a different mimetype but forceReplace is true
+    const currentFileId = datasetFiles.files[0].id
+    const newFileArrayBuffer = await newSinglepartFile.arrayBuffer()
+    const newFileBuffer = Buffer.from(newFileArrayBuffer)
+    const newUploadedFileDTO: UploadedFileDTO = {
+      fileName: newSinglepartFile.name,
+      storageId: newFileStorageId,
+      checksumType: checksumAlgorithm,
+      checksumValue: calculateBlobChecksum(newFileBuffer),
+      mimeType: newSinglepartFile.type
+    }
+
+    const expectedError = new WriteError(
+      '[400] Error! You may not replace a file with a file that has duplicate content.'
+    )
+
+    await expect(filesRepositorySut.replaceFile(currentFileId, newUploadedFileDTO)).rejects.toThrow(
+      expectedError
+    )
+  })
+
   const createTestFileUploadDestination = async (file: File, testDatasetId: number) => {
     const filesRepository = new FilesRepository()
     const destination = await filesRepository.getFileUploadDestination(testDatasetId, file)