test: fix ts errors in functional tests

Author: g-saracca

test/functional/collections/CreateCollection.test.ts

@@ -29,15 +29,15 @@ describe('execute', () => {
   test('should throw an error when the parent collection does not exist', async () => {
     const testNewCollection = createCollectionDTO()
     expect.assertions(2)
-    let writeError: WriteError
+    let writeError: WriteError | undefined = undefined
     try {
       await createCollection.execute(testNewCollection, TestConstants.TEST_DUMMY_COLLECTION_ID)
       throw new Error('Use case should throw an error')
     } catch (error) {
       writeError = error
     } finally {
       expect(writeError).toBeInstanceOf(WriteError)
-      expect(writeError.message).toEqual(
+      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/functional/collections/GetCollectionFacets.test.ts

@@ -27,15 +27,15 @@ describe('execute', () => {
 
   test('should throw an error when collection does not exist', async () => {
     expect.assertions(2)
-    let readError: ReadError
+    let readError: ReadError | undefined = undefined
     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(
+      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/functional/collections/GetCollectionItems.test.ts

@@ -15,7 +15,6 @@ import {
 } from '../../testHelpers/collections/collectionHelper'
 import { uploadFileViaApi } from '../../testHelpers/files/filesHelper'
 import { deleteUnpublishedDatasetViaApi } from '../../testHelpers/datasets/datasetHelper'
-import { CollectionItemSubset } from '../../../src/collections/domain/models/CollectionItemSubset'
 
 describe('execute', () => {
   const testCollectionAlias = 'collectionsRepositoryFunctionalTestCollection'
@@ -59,33 +58,32 @@ describe('execute', () => {
     // Give enough time to Solr for indexing
     await new Promise((resolve) => setTimeout(resolve, 5000))
 
-    let actual: CollectionItemSubset
     try {
-      actual = await getCollectionItems.execute(testCollectionAlias)
-    } catch (error) {
-      throw new Error('Item subset should be retrieved')
-    } finally {
+      const actual = await getCollectionItems.execute(testCollectionAlias)
+
       const actualFilePreview = actual.items[0] as FilePreview
       const actualDatasetPreview = actual.items[1] as DatasetPreview
 
       expect(actualFilePreview.name).toBe('test-file-1.txt')
       expect(actualDatasetPreview.title).toBe('Dataset created using the createDataset use case')
 
       expect(actual.totalItemCount).toBe(2)
+    } catch (error) {
+      throw new Error('Item subset should be retrieved')
     }
   })
 
   test('should throw an error when collection does not exist', async () => {
     expect.assertions(2)
-    let readError: ReadError
+    let readError: ReadError | undefined = undefined
     try {
       await getCollectionItems.execute(TestConstants.TEST_DUMMY_COLLECTION_ALIAS)
       throw new Error('Use case should throw an error')
     } catch (error) {
       readError = error
     } finally {
       expect(readError).toBeInstanceOf(ReadError)
-      expect(readError.message).toEqual(
+      expect(readError?.message).toEqual(
         `There was an error when reading the resource. Reason was: [400] Could not find dataverse with alias ${TestConstants.TEST_DUMMY_COLLECTION_ALIAS}`
       )
     }

test/functional/collections/GetCollectionUserPermissions.test.ts

@@ -1,9 +1,4 @@
-import {
-  ApiConfig,
-  CollectionUserPermissions,
-  ReadError,
-  getCollectionUserPermissions
-} from '../../../src'
+import { ApiConfig, ReadError, getCollectionUserPermissions } from '../../../src'
 import { TestConstants } from '../../testHelpers/TestConstants'
 import { DataverseApiAuthMechanism } from '../../../src/core/infra/repositories/ApiConfig'
 
@@ -19,49 +14,47 @@ describe('execute', () => {
   })
 
   test('should return user permissions for the default collection', async () => {
-    let actual: CollectionUserPermissions
     try {
-      actual = await getCollectionUserPermissions.execute()
+      const permissions = await getCollectionUserPermissions.execute()
+
+      expect(permissions.canAddDataset).toBe(true)
+      expect(permissions.canAddCollection).toBe(true)
+      expect(permissions.canDeleteCollection).toBe(true)
+      expect(permissions.canEditCollection).toBe(true)
+      expect(permissions.canManageCollectionPermissions).toBe(true)
+      expect(permissions.canPublishCollection).toBe(true)
+      expect(permissions.canViewUnpublishedCollection).toBe(true)
     } catch (error) {
       throw new Error('Permissions should be retrieved')
-    } finally {
-      expect(actual.canAddDataset).toBe(true)
-      expect(actual.canAddCollection).toBe(true)
-      expect(actual.canDeleteCollection).toBe(true)
-      expect(actual.canEditCollection).toBe(true)
-      expect(actual.canManageCollectionPermissions).toBe(true)
-      expect(actual.canPublishCollection).toBe(true)
-      expect(actual.canViewUnpublishedCollection).toBe(true)
     }
   })
   test('should return user permissions when a valid collection alias is provided', async () => {
-    let actual: CollectionUserPermissions
     try {
-      actual = await getCollectionUserPermissions.execute(ROOT_COLLECTION_ALIAS)
+      const permissions = await getCollectionUserPermissions.execute(ROOT_COLLECTION_ALIAS)
+
+      expect(permissions.canAddDataset).toBe(true)
+      expect(permissions.canAddCollection).toBe(true)
+      expect(permissions.canDeleteCollection).toBe(true)
+      expect(permissions.canEditCollection).toBe(true)
+      expect(permissions.canManageCollectionPermissions).toBe(true)
+      expect(permissions.canPublishCollection).toBe(true)
+      expect(permissions.canViewUnpublishedCollection).toBe(true)
     } catch (error) {
       throw new Error('Permissions should be retrieved')
-    } finally {
-      expect(actual.canAddDataset).toBe(true)
-      expect(actual.canAddCollection).toBe(true)
-      expect(actual.canDeleteCollection).toBe(true)
-      expect(actual.canEditCollection).toBe(true)
-      expect(actual.canManageCollectionPermissions).toBe(true)
-      expect(actual.canPublishCollection).toBe(true)
-      expect(actual.canViewUnpublishedCollection).toBe(true)
     }
   })
 
   test('should throw an error when collection does not exist', async () => {
     expect.assertions(2)
-    let readError: ReadError
+    let readError: ReadError | undefined = undefined
     try {
       await getCollectionUserPermissions.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(
+      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/functional/collections/UpdateCollection.test.ts

@@ -38,15 +38,15 @@ describe('execute', () => {
   test('should throw an error when the parent collection does not exist', async () => {
     const testNewCollection = createCollectionDTO()
     expect.assertions(2)
-    let writeError: WriteError
+    let writeError: WriteError | undefined = undefined
     try {
       await updateCollection.execute(TestConstants.TEST_DUMMY_COLLECTION_ID, testNewCollection)
       throw new Error('Use case should throw an error')
     } catch (error) {
       writeError = error
     } finally {
       expect(writeError).toBeInstanceOf(WriteError)
-      expect(writeError.message).toEqual(
+      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/functional/datasets/CreateDataset.test.ts

@@ -1,4 +1,4 @@
-import { createDataset, CreatedDatasetIdentifiers } from '../../../src/datasets'
+import { createDataset, DatasetDTO } from '../../../src/datasets'
 import { ApiConfig } from '../../../src'
 import { TestConstants } from '../../testHelpers/TestConstants'
 import { DataverseApiAuthMechanism } from '../../../src/core/infra/repositories/ApiConfig'
@@ -48,16 +48,16 @@ describe('execute', () => {
       ]
     }
     expect.assertions(3)
-    let createdDatasetIdentifiers: CreatedDatasetIdentifiers
+
     try {
-      createdDatasetIdentifiers = await createDataset.execute(testNewDataset)
-    } catch (error) {
-      throw new Error('Dataset should be created')
-    } finally {
+      const createdDatasetIdentifiers = await createDataset.execute(testNewDataset)
+
       expect(createdDatasetIdentifiers).not.toBeNull()
       expect(createdDatasetIdentifiers.numericId).not.toBeNull()
       expect(createdDatasetIdentifiers.persistentId).not.toBeNull()
       await deleteUnpublishedDatasetViaApi(createdDatasetIdentifiers.numericId)
+    } catch (error) {
+      throw new Error('Dataset should be created')
     }
   })
 
@@ -94,25 +94,25 @@ describe('execute', () => {
       ]
     }
     expect.assertions(5)
-    let fieldValidationError: FieldValidationError
+    let fieldValidationError: FieldValidationError | undefined = undefined
     try {
       await createDataset.execute(testNewDataset)
       throw new Error('Use case should throw an error')
     } catch (error) {
       fieldValidationError = error
     } finally {
       expect(fieldValidationError).toBeInstanceOf(FieldValidationError)
-      expect(fieldValidationError.citationBlockName).toEqual('citation')
-      expect(fieldValidationError.metadataFieldName).toEqual('title')
-      expect(fieldValidationError.parentMetadataFieldName).toEqual(undefined)
-      expect(fieldValidationError.message).toEqual(
+      expect(fieldValidationError?.citationBlockName).toEqual('citation')
+      expect(fieldValidationError?.metadataFieldName).toEqual('title')
+      expect(fieldValidationError?.parentMetadataFieldName).toEqual(undefined)
+      expect(fieldValidationError?.message).toEqual(
         'There was an error when validating the field title from metadata block citation. Reason was: The field should not be empty.'
       )
     }
   })
 
   test('should throw an error when a second level required field is missing', async () => {
-    const testNewDataset = {
+    const testNewDataset: DatasetDTO = {
       metadataBlockValues: [
         {
           name: 'citation',
@@ -144,19 +144,19 @@ describe('execute', () => {
       ]
     }
     expect.assertions(6)
-    let fieldValidationError: FieldValidationError
+    let fieldValidationError: FieldValidationError | undefined = undefined
     try {
       await createDataset.execute(testNewDataset)
       throw new Error('Use case should throw an error')
     } catch (error) {
       fieldValidationError = error
     } finally {
       expect(fieldValidationError).toBeInstanceOf(FieldValidationError)
-      expect(fieldValidationError.citationBlockName).toEqual('citation')
-      expect(fieldValidationError.metadataFieldName).toEqual('authorName')
-      expect(fieldValidationError.parentMetadataFieldName).toEqual('author')
-      expect(fieldValidationError.fieldPosition).toEqual(0)
-      expect(fieldValidationError.message).toEqual(
+      expect(fieldValidationError?.citationBlockName).toEqual('citation')
+      expect(fieldValidationError?.metadataFieldName).toEqual('authorName')
+      expect(fieldValidationError?.parentMetadataFieldName).toEqual('author')
+      expect(fieldValidationError?.fieldPosition).toEqual(0)
+      expect(fieldValidationError?.message).toEqual(
         'There was an error when validating the field authorName from metadata block citation with parent field author in position 0. Reason was: The field should not be empty.'
       )
     }
@@ -196,19 +196,19 @@ describe('execute', () => {
       ]
     }
     expect.assertions(6)
-    let fieldValidationError: FieldValidationError
+    let fieldValidationError: FieldValidationError | undefined = undefined
     try {
       await createDataset.execute(testNewDataset)
       throw new Error('Use case should throw an error')
     } catch (error) {
       fieldValidationError = error
     } finally {
       expect(fieldValidationError).toBeInstanceOf(FieldValidationError)
-      expect(fieldValidationError.citationBlockName).toEqual('citation')
-      expect(fieldValidationError.metadataFieldName).toEqual('subject')
-      expect(fieldValidationError.parentMetadataFieldName).toEqual(undefined)
-      expect(fieldValidationError.fieldPosition).toEqual(1)
-      expect(fieldValidationError.message).toEqual(
+      expect(fieldValidationError?.citationBlockName).toEqual('citation')
+      expect(fieldValidationError?.metadataFieldName).toEqual('subject')
+      expect(fieldValidationError?.parentMetadataFieldName).toEqual(undefined)
+      expect(fieldValidationError?.fieldPosition).toEqual(1)
+      expect(fieldValidationError?.message).toEqual(
         'There was an error when validating the field subject from metadata block citation in position 1. Reason was: The field does not have a valid controlled vocabulary value.'
       )
     }

test/functional/metadataBlocks/GetAllFacetableMetadataFields.test.ts

@@ -12,15 +12,15 @@ describe('execute', () => {
   })
 
   test('should return all facetable metadata fields', async () => {
-    let metadataFieldInfos: MetadataFieldInfo[] = null
+    let metadataFieldInfos: MetadataFieldInfo[] | null = null
     try {
       metadataFieldInfos = await getAllFacetableMetadataFields.execute()
     } catch (error) {
       throw new Error('Should not raise an error')
     } finally {
-      expect(metadataFieldInfos.length).toBe(59)
-      expect(metadataFieldInfos[0].name).toBe('authorName')
-      expect(metadataFieldInfos[0].displayName).toBe('Author Name')
+      expect(metadataFieldInfos?.length).toBe(59)
+      expect(metadataFieldInfos?.[0].name).toBe('authorName')
+      expect(metadataFieldInfos?.[0].displayName).toBe('Author Name')
     }
   })
 })

test/functional/metadataBlocks/GetAllMetadataBlocks.test.ts

@@ -12,15 +12,15 @@ describe('execute', () => {
   })
 
   test('should successfully return metadatablocks', async () => {
-    let metadataBlocks: MetadataBlock[] = null
+    let metadataBlocks: MetadataBlock[] | null = null
     try {
       metadataBlocks = await getAllMetadataBlocks.execute()
     } catch (error) {
       throw new Error('Should not raise an error')
     } finally {
       expect(metadataBlocks).not.toBeNull()
-      expect(metadataBlocks.length).toBe(6)
-      expect(metadataBlocks[0].metadataFields.title.name).toBe('title')
+      expect(metadataBlocks?.length).toBe(6)
+      expect(metadataBlocks?.[0].metadataFields.title.name).toBe('title')
     }
   })
 })

test/functional/metadataBlocks/GetCollectionMetadataBlocks.test.ts

@@ -12,29 +12,29 @@ describe('execute', () => {
   })
 
   test('should successfully return collection metadatablocks when collection exists', async () => {
-    let collectionMetadataBlocks: MetadataBlock[] = null
+    let collectionMetadataBlocks: MetadataBlock[] | null = null
     try {
       collectionMetadataBlocks = await getCollectionMetadataBlocks.execute('root')
     } catch (error) {
       throw new Error('Should not raise an error')
     } finally {
       expect(collectionMetadataBlocks).not.toBeNull()
-      expect(collectionMetadataBlocks.length).toBe(1)
-      expect(collectionMetadataBlocks[0].metadataFields.title.name).toBe('title')
+      expect(collectionMetadataBlocks?.length).toBe(1)
+      expect(collectionMetadataBlocks?.[0].metadataFields.title.name).toBe('title')
     }
   })
 
   test('should throw an error when a collection is not found', async () => {
     expect.assertions(2)
-    let readError: ReadError
+    let readError: ReadError | undefined = undefined
     try {
       await getCollectionMetadataBlocks.execute('notFoundCollectionAlias')
       throw new Error('Use case should throw an error')
     } catch (error) {
       readError = error
     } finally {
       expect(readError).toBeInstanceOf(ReadError)
-      expect(readError.message).toEqual(
+      expect(readError?.message).toEqual(
         `There was an error when reading the resource. Reason was: [404] Can't find dataverse with identifier='notFoundCollectionAlias'`
       )
     }