Added: dataset update repository logic and unit tests

Author: GPortas

src/core/infra/repositories/ApiRepository.ts

@@ -22,16 +22,15 @@ export abstract class ApiRepository {
     data: string | object,
     queryParams: object = {}
   ): Promise<AxiosResponse> {
-    return await axios
-      .post(
-        this.buildRequestUrl(apiEndpoint),
-        JSON.stringify(data),
-        this.buildRequestConfig(true, queryParams)
-      )
-      .then((response) => response)
-      .catch((error) => {
-        throw new WriteError(this.buildErrorMessage(error))
-      })
+    return await this.doRequest('post', apiEndpoint, data, queryParams)
+  }
+
+  public async doPut(
+    apiEndpoint: string,
+    data: string | object,
+    queryParams: object = {}
+  ): Promise<AxiosResponse> {
+    return await this.doRequest('put', apiEndpoint, data, queryParams)
   }
 
   protected buildApiEndpoint(
@@ -83,4 +82,22 @@ export abstract class ApiRepository {
     const message = error.response && error.response.data ? ` ${error.response.data.message}` : ''
     return `[${status}]${message}`
   }
+
+  private async doRequest(
+    method: 'post' | 'put',
+    apiEndpoint: string,
+    data: string | object,
+    queryParams: object = {}
+  ): Promise<AxiosResponse> {
+    const requestData = JSON.stringify(data)
+    const requestUrl = this.buildRequestUrl(apiEndpoint)
+    const requestConfig = this.buildRequestConfig(true, queryParams)
+
+    try {
+      const response = await axios[method](requestUrl, requestData, requestConfig)
+      return response
+    } catch (error) {
+      throw new WriteError(this.buildErrorMessage(error))
+    }
+  }
 }

src/datasets/domain/repositories/IDatasetsRepository.ts

@@ -3,7 +3,7 @@ import { DatasetLock } from '../models/DatasetLock'
 import { DatasetPreviewSubset } from '../models/DatasetPreviewSubset'
 import { DatasetUserPermissions } from '../models/DatasetUserPermissions'
 import { CreatedDatasetIdentifiers } from '../models/CreatedDatasetIdentifiers'
-import { NewDatasetDTO } from '../dtos/DatasetDTO'
+import { DatasetDTO } from '../dtos/DatasetDTO'
 import { MetadataBlock } from '../../../metadataBlocks'
 
 export interface IDatasetsRepository {
@@ -28,14 +28,14 @@ export interface IDatasetsRepository {
   getPrivateUrlDatasetCitation(token: string): Promise<string>
   getDatasetUserPermissions(datasetId: number | string): Promise<DatasetUserPermissions>
   createDataset(
-    newDataset: NewDatasetDTO,
+    newDataset: DatasetDTO,
     datasetMetadataBlocks: MetadataBlock[],
     collectionId: string
   ): Promise<CreatedDatasetIdentifiers>
   publishDataset(datasetId: number | string, versionUpdateType: VersionUpdateType): Promise<void>
   updateDataset(
     datasetId: number | string,
-    newDataset: NewDatasetDTO,
+    dataset: DatasetDTO,
     datasetMetadataBlocks: MetadataBlock[]
   ): Promise<void>
 }

src/datasets/domain/useCases/UpdateDataset.ts

@@ -26,6 +26,6 @@ export class UpdateDataset extends DatasetWriteUseCase<void> {
   async execute(datasetId: number | string, updatedDataset: DatasetDTO): Promise<void> {
     const metadataBlocks = await this.getNewDatasetMetadataBlocks(updatedDataset)
     this.getNewDatasetValidator().validate(updatedDataset, metadataBlocks)
-    this.getDatasetsRepository().updateDataset(datasetId, updatedDataset, metadataBlocks)
+    return this.getDatasetsRepository().updateDataset(datasetId, updatedDataset, metadataBlocks)
   }
 }

src/datasets/infra/repositories/DatasetsRepository.ts

@@ -175,13 +175,18 @@ export class DatasetsRepository extends ApiRepository implements IDatasetsReposi
       })
   }
 
-  // TODO
   public async updateDataset(
     datasetId: string | number,
-    newDataset: any,
+    dataset: DatasetDTO,
     datasetMetadataBlocks: MetadataBlock[]
   ): Promise<void> {
-    console.log(datasetId + newDataset + datasetMetadataBlocks.length)
-    throw new Error('Method not implemented.')
+    return this.doPut(
+      this.buildApiEndpoint(this.datasetsResourceName, `editMetadata`, datasetId),
+      transformDatasetModelToRequestPayload(dataset, datasetMetadataBlocks)
+    )
+      .then(() => undefined)
+      .catch((error) => {
+        throw error
+      })
   }
 }

test/unit/datasets/UpdateDataset.test.ts

@@ -0,0 +1,134 @@
+import { UpdateDataset } from '../../../src/datasets/domain/useCases/UpdateDataset'
+import { IDatasetsRepository } from '../../../src/datasets/domain/repositories/IDatasetsRepository'
+import { ResourceValidator } from '../../../src/core/domain/useCases/validators/ResourceValidator'
+import {
+  createDatasetDTO,
+  createDatasetMetadataBlockModel
+} from '../../testHelpers/datasets/datasetHelper'
+import { IMetadataBlocksRepository } from '../../../src/metadataBlocks/domain/repositories/IMetadataBlocksRepository'
+import { ResourceValidationError } from '../../../src/core/domain/useCases/validators/errors/ResourceValidationError'
+import { WriteError, ReadError } from '../../../src'
+
+describe('execute', () => {
+  const testDataset = createDatasetDTO()
+  const testMetadataBlocks = [createDatasetMetadataBlockModel()]
+
+  test('should return undefined when validation is successful and repository call is successful', async () => {
+    const datasetsRepositoryStub = <IDatasetsRepository>{}
+    datasetsRepositoryStub.updateDataset = jest.fn().mockResolvedValue(undefined)
+
+    const datasetValidatorStub = <ResourceValidator>{}
+    datasetValidatorStub.validate = jest.fn().mockResolvedValue(undefined)
+
+    const metadataBlocksRepositoryStub = <IMetadataBlocksRepository>{}
+    metadataBlocksRepositoryStub.getMetadataBlockByName = jest
+      .fn()
+      .mockResolvedValue(testMetadataBlocks[0])
+
+    const sut = new UpdateDataset(
+      datasetsRepositoryStub,
+      metadataBlocksRepositoryStub,
+      datasetValidatorStub
+    )
+
+    const actual = await sut.execute(1, testDataset)
+
+    expect(actual).toEqual(undefined)
+
+    expect(metadataBlocksRepositoryStub.getMetadataBlockByName).toHaveBeenCalledWith(
+      testMetadataBlocks[0].name
+    )
+    expect(datasetValidatorStub.validate).toHaveBeenCalledWith(testDataset, testMetadataBlocks)
+    expect(datasetsRepositoryStub.updateDataset).toHaveBeenCalledWith(
+      1,
+      testDataset,
+      testMetadataBlocks
+    )
+  })
+
+  test('should throw ResourceValidationError and not call repository when validation is unsuccessful', async () => {
+    const datasetsRepositoryMock = <IDatasetsRepository>{}
+    datasetsRepositoryMock.updateDataset = jest.fn().mockResolvedValue(undefined)
+
+    const datasetValidatorStub = <ResourceValidator>{}
+    datasetValidatorStub.validate = jest.fn().mockImplementation(() => {
+      throw new ResourceValidationError('Test error')
+    })
+
+    const metadataBlocksRepositoryStub = <IMetadataBlocksRepository>{}
+    metadataBlocksRepositoryStub.getMetadataBlockByName = jest
+      .fn()
+      .mockResolvedValue(testMetadataBlocks[0])
+
+    const sut = new UpdateDataset(
+      datasetsRepositoryMock,
+      metadataBlocksRepositoryStub,
+      datasetValidatorStub
+    )
+
+    await expect(sut.execute(1, testDataset)).rejects.toThrow(ResourceValidationError)
+
+    expect(metadataBlocksRepositoryStub.getMetadataBlockByName).toHaveBeenCalledWith(
+      testMetadataBlocks[0].name
+    )
+    expect(datasetValidatorStub.validate).toHaveBeenCalledWith(testDataset, testMetadataBlocks)
+    expect(datasetsRepositoryMock.updateDataset).not.toHaveBeenCalled()
+  })
+
+  test('should throw WriteError when validation is successful and repository raises an error', async () => {
+    const datasetsRepositoryStub = <IDatasetsRepository>{}
+    const testWriteError = new WriteError('Test error')
+    datasetsRepositoryStub.updateDataset = jest.fn().mockRejectedValue(testWriteError)
+
+    const datasetValidatorStub = <ResourceValidator>{}
+    datasetValidatorStub.validate = jest.fn().mockResolvedValue(undefined)
+
+    const metadataBlocksRepositoryStub = <IMetadataBlocksRepository>{}
+    metadataBlocksRepositoryStub.getMetadataBlockByName = jest
+      .fn()
+      .mockResolvedValue(testMetadataBlocks[0])
+
+    const sut = new UpdateDataset(
+      datasetsRepositoryStub,
+      metadataBlocksRepositoryStub,
+      datasetValidatorStub
+    )
+    await expect(sut.execute(1, testDataset)).rejects.toThrow(testWriteError)
+
+    expect(metadataBlocksRepositoryStub.getMetadataBlockByName).toHaveBeenCalledWith(
+      testMetadataBlocks[0].name
+    )
+    expect(datasetValidatorStub.validate).toHaveBeenCalledWith(testDataset, testMetadataBlocks)
+    expect(datasetsRepositoryStub.updateDataset).toHaveBeenCalledWith(
+      1,
+      testDataset,
+      testMetadataBlocks
+    )
+  })
+
+  test('should throw ReadError when metadata blocks repository raises an error', async () => {
+    const datasetsRepositoryMock = <IDatasetsRepository>{}
+    datasetsRepositoryMock.updateDataset = jest.fn().mockResolvedValue(undefined)
+
+    const datasetValidatorMock = <ResourceValidator>{}
+    datasetValidatorMock.validate = jest.fn().mockResolvedValue(undefined)
+
+    const metadataBlocksRepositoryStub = <IMetadataBlocksRepository>{}
+    const testReadError = new ReadError('Test error')
+    metadataBlocksRepositoryStub.getMetadataBlockByName = jest.fn().mockRejectedValue(testReadError)
+
+    const sut = new UpdateDataset(
+      datasetsRepositoryMock,
+      metadataBlocksRepositoryStub,
+      datasetValidatorMock
+    )
+    await expect(sut.execute(1, testDataset)).rejects.toThrow(testReadError)
+
+    expect(datasetValidatorMock.validate).not.toHaveBeenCalled()
+    expect(datasetsRepositoryMock.updateDataset).not.toHaveBeenCalled()
+
+    expect(metadataBlocksRepositoryStub.getMetadataBlockByName).toHaveBeenCalledWith(
+      testMetadataBlocks[0].name
+    )
+  })
+})