Added: GetCollectionFacets use case

Author: GPortas

src/collections/domain/repositories/ICollectionsRepository.ts

@@ -7,4 +7,5 @@ export interface ICollectionsRepository {
     collectionDTO: CollectionDTO,
     parentCollectionId: number | string
   ): Promise<number>
+  getCollectionFacets(collectionIdOrAlias: number | string): Promise<string[]>
 }

src/collections/domain/useCases/GetCollectionFacets.ts

@@ -1 +1,22 @@
-// TODO
+import { UseCase } from '../../../core/domain/useCases/UseCase'
+import { ICollectionsRepository } from '../repositories/ICollectionsRepository'
+import { ROOT_COLLECTION_ALIAS } from '../models/Collection'
+
+export class GetCollectionFacets implements UseCase<string[]> {
+  private collectionsRepository: ICollectionsRepository
+
+  constructor(collectionsRepository: ICollectionsRepository) {
+    this.collectionsRepository = collectionsRepository
+  }
+
+  /**
+   * Returns the names of the configured collection facets, given a collection identifier or alias.
+   *
+   * @param {number | string} [collectionIdOrAlias = 'root'] - A generic collection identifier, which can be either a string (for queries by CollectionAlias), or a number (for queries by CollectionId)
+   * If this parameter is not set, the default value is: 'root'
+   * @returns {Promise<Collection>}
+   */
+  async execute(collectionIdOrAlias: number | string = ROOT_COLLECTION_ALIAS): Promise<string[]> {
+    return await this.collectionsRepository.getCollectionFacets(collectionIdOrAlias)
+  }
+}

src/collections/index.ts

@@ -1,13 +1,15 @@
 import { CreateCollection } from './domain/useCases/CreateCollection'
 import { GetCollection } from './domain/useCases/GetCollection'
+import { GetCollectionFacets } from './domain/useCases/GetCollectionFacets'
 
 import { CollectionsRepository } from './infra/repositories/CollectionsRepository'
 
 const collectionsRepository = new CollectionsRepository()
 
 const getCollection = new GetCollection(collectionsRepository)
 const createCollection = new CreateCollection(collectionsRepository)
+const getCollectionFacets = new GetCollectionFacets(collectionsRepository)
 
-export { getCollection, createCollection }
+export { getCollection, createCollection, getCollectionFacets }
 export { Collection } from './domain/models/Collection'
 export { CollectionDTO, DatasetFieldTypeInputLevelDTO } from './domain/dtos/CollectionDTO'

src/collections/infra/repositories/CollectionsRepository.ts

@@ -80,4 +80,12 @@ export class CollectionsRepository extends ApiRepository implements ICollections
         throw error
       })
   }
+
+  public async getCollectionFacets(collectionIdOrAlias: string | number): Promise<string[]> {
+    return this.doGet(`/${this.collectionsResourceName}/${collectionIdOrAlias}/facets`, true)
+      .then((response) => response.data.data)
+      .catch((error) => {
+        throw error
+      })
+  }
 }

test/functional/collections/GetCollectionFacets.test.ts

@@ -0,0 +1,44 @@
+import { ApiConfig, ReadError, getCollectionFacets } from '../../../src'
+import { TestConstants } from '../../testHelpers/TestConstants'
+import { DataverseApiAuthMechanism } from '../../../src/core/infra/repositories/ApiConfig'
+import { ROOT_COLLECTION_ALIAS } from '../../../src/collections/domain/models/Collection'
+
+describe('execute', () => {
+  beforeEach(async () => {
+    ApiConfig.init(
+      TestConstants.TEST_API_URL,
+      DataverseApiAuthMechanism.API_KEY,
+      process.env.TEST_API_KEY
+    )
+  })
+
+  test('should return facets when a valid collection alias is provided', async () => {
+    let actual: string[] = []
+    try {
+      actual = await getCollectionFacets.execute(ROOT_COLLECTION_ALIAS)
+    } catch (error) {
+      throw new Error('Facets should be retrieved')
+    } finally {
+      expect(actual).toContain('authorName')
+      expect(actual).toContain('subject')
+      expect(actual).toContain('keywordValue')
+      expect(actual).toContain('dateOfDeposit')
+    }
+  })
+
+  test('should throw an error when collection does not exist', async () => {
+    expect.assertions(2)
+    let readError: ReadError
+    try {
+      await getCollectionFacets.execute(TestConstants.TEST_DUMMY_COLLECTION_ID)
+      throw new Error('Use case should throw an error')
+    } catch (error) {
+      readError = error
+    } finally {
+      expect(readError).toBeInstanceOf(ReadError)
+      expect(readError.message).toEqual(
+        `There was an error when reading the resource. Reason was: [404] Can't find dataverse with identifier='${TestConstants.TEST_DUMMY_COLLECTION_ID}'`
+      )
+    }
+  })
+})

test/integration/collections/CollectionsRepository.test.ts

@@ -122,4 +122,24 @@ describe('CollectionsRepository', () => {
       ).rejects.toThrow(expectedError)
     })
   })
+
+  describe('getCollectionFacets', () => {
+    test('should return collection facets given a valid collection alias', async () => {
+      const actual = await sut.getCollectionFacets(testCollectionAlias)
+      expect(actual).toContain('authorName')
+      expect(actual).toContain('subject')
+      expect(actual).toContain('keywordValue')
+      expect(actual).toContain('dateOfDeposit')
+    })
+
+    test('should return error when collection does not exist', async () => {
+      const expectedError = new ReadError(
+        `[404] Can't find dataverse with identifier='${TestConstants.TEST_DUMMY_COLLECTION_ALIAS}'`
+      )
+
+      await expect(
+        sut.getCollectionFacets(TestConstants.TEST_DUMMY_COLLECTION_ALIAS)
+      ).rejects.toThrow(expectedError)
+    })
+  })
 })

test/unit/collections/CollectionsRepository.test.ts

@@ -172,4 +172,60 @@ describe('CollectionsRepository', () => {
       expect(error).toBeInstanceOf(Error)
     })
   })
+
+  describe('getCollectionFacets', () => {
+    const testFacetsSuccessfulResponse = {
+      data: {
+        status: 'OK',
+        data: ['authorName', 'subject', 'keywordValue', 'dateOfDeposit']
+      }
+    }
+
+    describe('by numeric id', () => {
+      test('should return facets when providing a valid id', async () => {
+        jest.spyOn(axios, 'get').mockResolvedValue(testFacetsSuccessfulResponse)
+        const expectedApiEndpoint = `${TestConstants.TEST_API_URL}/dataverses/${testCollectionModel.id}/facets`
+
+        // API Key auth
+        let actual = await sut.getCollectionFacets(testCollectionModel.id)
+
+        expect(axios.get).toHaveBeenCalledWith(
+          expectedApiEndpoint,
+          TestConstants.TEST_EXPECTED_AUTHENTICATED_REQUEST_CONFIG_API_KEY
+        )
+        expect(actual).toContain('authorName')
+        expect(actual).toContain('subject')
+        expect(actual).toContain('keywordValue')
+        expect(actual).toContain('dateOfDeposit')
+
+        // Session cookie auth
+        ApiConfig.init(TestConstants.TEST_API_URL, DataverseApiAuthMechanism.SESSION_COOKIE)
+
+        actual = await sut.getCollectionFacets(testCollectionModel.id)
+
+        expect(axios.get).toHaveBeenCalledWith(
+          expectedApiEndpoint,
+          TestConstants.TEST_EXPECTED_AUTHENTICATED_REQUEST_CONFIG_SESSION_COOKIE
+        )
+        expect(actual).toContain('authorName')
+        expect(actual).toContain('subject')
+        expect(actual).toContain('keywordValue')
+        expect(actual).toContain('dateOfDeposit')
+      })
+
+      test('should return error on repository read error', async () => {
+        jest.spyOn(axios, 'get').mockRejectedValue(TestConstants.TEST_ERROR_RESPONSE)
+        const expectedApiEndpoint = `${TestConstants.TEST_API_URL}/dataverses/${testCollectionModel.id}/facets`
+        let error = undefined as unknown as ReadError
+
+        await sut.getCollectionFacets(testCollectionModel.id).catch((e) => (error = e))
+
+        expect(axios.get).toHaveBeenCalledWith(
+          expectedApiEndpoint,
+          TestConstants.TEST_EXPECTED_AUTHENTICATED_REQUEST_CONFIG_API_KEY
+        )
+        expect(error).toBeInstanceOf(Error)
+      })
+    })
+  })
 })

test/unit/collections/GetCollectionFacets.test.ts

@@ -0,0 +1,24 @@
+import { GetCollectionFacets } from '../../../src/collections/domain/useCases/GetCollectionFacets'
+import { ICollectionsRepository } from '../../../src/collections/domain/repositories/ICollectionsRepository'
+import { ReadError } from '../../../src'
+
+describe('execute', () => {
+  test('should return collection facets on repository success', async () => {
+    const testFacets = ['test1', 'test2']
+    const collectionRepositoryStub: ICollectionsRepository = {} as ICollectionsRepository
+    collectionRepositoryStub.getCollectionFacets = jest.fn().mockResolvedValue(testFacets)
+    const testGetCollection = new GetCollectionFacets(collectionRepositoryStub)
+
+    const actual = await testGetCollection.execute(1)
+
+    expect(actual).toEqual(testFacets)
+  })
+
+  test('should return error result on repository error', async () => {
+    const collectionRepositoryStub: ICollectionsRepository = {} as ICollectionsRepository
+    collectionRepositoryStub.getCollectionFacets = jest.fn().mockRejectedValue(new ReadError())
+    const testGetCollection = new GetCollectionFacets(collectionRepositoryStub)
+
+    await expect(testGetCollection.execute(1)).rejects.toThrow(ReadError)
+  })
+})