Revert "update tests for the MyData api fix"

This reverts commit a787da9.

Author: ChengShi-1

test/functional/collections/GetMyDataCollectionItems.test.ts

@@ -3,7 +3,8 @@ import {
   createDataset,
   CreatedDatasetIdentifiers,
   CollectionPreview,
-  getMyDataCollectionItems
+  getMyDataCollectionItems,
+  ReadError
 } from '../../../src'
 import { TestConstants } from '../../testHelpers/TestConstants'
 import { DataverseApiAuthMechanism } from '../../../src/core/infra/repositories/ApiConfig'
@@ -65,218 +66,136 @@ describe('execute', () => {
       throw new Error('Tests afterAll(): Error while deleting test collection')
     }
   })
-  test('should return an empty item subset when repository returns no results', async () => {
-    const actual = await getMyDataCollectionItems.execute(
-      testRoleIds,
-      testCollectionItemTypes,
-      [PublicationStatus.Deaccessioned],
-      undefined,
-      undefined,
-      'no-results-for-get-my-data-collection-items'
-    )
-
-    expect(actual.items).toEqual([])
-    expect(actual.totalItemCount).toBe(0)
-    expect(actual.publicationStatusCounts).toEqual([
-      {
-        publicationStatus: 'Published',
-        count: 0
-      },
-      {
-        publicationStatus: 'Unpublished',
-        count: 0
-      },
-      {
-        publicationStatus: 'Draft',
-        count: 0
-      },
-      {
-        publicationStatus: 'In Review',
-        count: 0
-      },
-      {
-        publicationStatus: 'Deaccessioned',
-        count: 0
-      }
-    ])
-    expect(actual.countPerObjectType).toEqual({
-      collections: 0,
-      datasets: 0,
-      files: 0
-    })
-  })
-
-  test('should return items when valid roles,collection types, and publishingStatuses are provided', async () => {
-    // Give enough time to Solr for indexing
-    await new Promise((resolve) => setTimeout(resolve, 5000))
-
+  test('should return error message when repository returns empty item subset', async () => {
+    expect.assertions(2)
+    let readError: ReadError | undefined = undefined
     try {
-      const actual = await getMyDataCollectionItems.execute(
+      await getMyDataCollectionItems.execute(
         testRoleIds,
         testCollectionItemTypes,
-        testPublishingStatuses,
+        [PublicationStatus.Deaccessioned],
         undefined,
         undefined,
-        testCollectionAlias
+        undefined
       )
-
-      const actualCollectionPreview = actual.items[0] as CollectionPreview
-      expect(actualCollectionPreview.alias).toBe(testCollectionAlias)
-
-      expect(actual.totalItemCount).toBe(1)
-      expect(actual.publicationStatusCounts).toEqual([
-        {
-          publicationStatus: 'Published',
-          count: 0
-        },
-        {
-          publicationStatus: 'Unpublished',
-          count: 1
-        },
-        {
-          publicationStatus: 'Draft',
-          count: 0
-        },
-        {
-          publicationStatus: 'In Review',
-          count: 0
-        },
-        {
-          publicationStatus: 'Deaccessioned',
-          count: 0
-        }
-      ])
-      expect(actual.countPerObjectType).toEqual({
-        collections: 1,
-        datasets: 0,
-        files: 0
-      })
+      throw new Error('Use case should throw an error')
     } catch (error) {
-      console.log(error)
-      throw new Error('Item subset should be retrieved')
+      readError = error as ReadError
+    } finally {
+      expect(readError).toBeInstanceOf(ReadError)
+      expect(readError?.message).toEqual(
+        'There was an error when reading the resource. Reason was: Sorry, no results were found.'
+      )
     }
-  })
+  }),
+    test('should return items when valid roles,collection types, and publishingStatuses are provided', async () => {
+      // Give enough time to Solr for indexing
+      await new Promise((resolve) => setTimeout(resolve, 5000))
 
-  test('should return an empty item subset when no role is specified', async () => {
-    const actual = await getMyDataCollectionItems.execute(
-      [],
-      [],
-      [],
-      undefined,
-      undefined,
-      undefined
-    )
-
-    expect(actual.items).toEqual([])
-    expect(actual.totalItemCount).toBe(0)
-    expect(actual.publicationStatusCounts).toEqual([
-      {
-        publicationStatus: 'Published',
-        count: 0
-      },
-      {
-        publicationStatus: 'Unpublished',
-        count: 0
-      },
-      {
-        publicationStatus: 'Draft',
-        count: 0
-      },
-      {
-        publicationStatus: 'In Review',
-        count: 0
-      },
-      {
-        publicationStatus: 'Deaccessioned',
-        count: 0
-      }
-    ])
-    expect(actual.countPerObjectType).toEqual({
-      collections: 0,
-      datasets: 0,
-      files: 0
-    })
-  })
+      try {
+        const actual = await getMyDataCollectionItems.execute(
+          testRoleIds,
+          testCollectionItemTypes,
+          testPublishingStatuses,
+          undefined,
+          undefined,
+          testCollectionAlias
+        )
 
-  test('should return an empty item subset when no publication status is specified', async () => {
-    const actual = await getMyDataCollectionItems.execute(
-      testRoleIds,
-      testCollectionItemTypes,
-      [],
-      undefined,
-      undefined,
-      undefined
-    )
+        const actualCollectionPreview = actual.items[0] as CollectionPreview
+        expect(actualCollectionPreview.alias).toBe(testCollectionAlias)
 
-    expect(actual.items).toEqual([])
-    expect(actual.totalItemCount).toBe(0)
-    expect(actual.publicationStatusCounts).toEqual([
-      {
-        publicationStatus: 'Published',
-        count: 0
-      },
-      {
-        publicationStatus: 'Unpublished',
-        count: 0
-      },
-      {
-        publicationStatus: 'Draft',
-        count: 0
-      },
-      {
-        publicationStatus: 'In Review',
-        count: 0
-      },
-      {
-        publicationStatus: 'Deaccessioned',
-        count: 0
+        expect(actual.totalItemCount).toBe(1)
+        expect(actual.publicationStatusCounts).toEqual([
+          {
+            publicationStatus: 'Published',
+            count: 0
+          },
+          {
+            publicationStatus: 'Unpublished',
+            count: 1
+          },
+          {
+            publicationStatus: 'Draft',
+            count: 0
+          },
+          {
+            publicationStatus: 'In Review',
+            count: 0
+          },
+          {
+            publicationStatus: 'Deaccessioned',
+            count: 0
+          }
+        ])
+        expect(actual.countPerObjectType).toEqual({
+          collections: 1,
+          datasets: 0,
+          files: 0
+        })
+      } catch (error) {
+        console.log(error)
+        throw new Error('Item subset should be retrieved')
       }
-    ])
-    expect(actual.countPerObjectType).toEqual({
-      collections: 0,
-      datasets: 0,
-      files: 0
     })
-  })
-
-  test('should return an empty item subset when no collection type is specified', async () => {
-    const actual = await getMyDataCollectionItems.execute(
-      testRoleIds,
-      [],
-      testPublishingStatuses,
-      undefined,
-      undefined,
-      undefined
-    )
 
-    expect(actual.items).toEqual([])
-    expect(actual.totalItemCount).toBe(0)
-    expect(actual.publicationStatusCounts).toEqual([
-      {
-        publicationStatus: 'Published',
-        count: 0
-      },
-      {
-        publicationStatus: 'Unpublished',
-        count: 0
-      },
-      {
-        publicationStatus: 'Draft',
-        count: 0
-      },
-      {
-        publicationStatus: 'In Review',
-        count: 0
-      },
-      {
-        publicationStatus: 'Deaccessioned',
-        count: 0
-      }
-    ])
-    expect(actual.countPerObjectType).toEqual({
-      collections: 0,
-      datasets: 0,
-      files: 0
-    })
+  test('should return an error message when no role is specified', async () => {
+    expect.assertions(2)
+    let readError: ReadError | undefined = undefined
+    try {
+      await getMyDataCollectionItems.execute([], [], [], undefined, undefined, undefined)
+      throw new Error('Use case should throw an error')
+    } catch (error) {
+      readError = error as ReadError
+    } finally {
+      expect(readError).toBeInstanceOf(ReadError)
+      expect(readError?.message).toEqual(
+        `There was an error when reading the resource. Reason was: No results. Please select at least one Role.`
+      )
+    }
+  })
+  test('should return an error message when no publication status is specified', async () => {
+    expect.assertions(2)
+    let readError: ReadError | undefined = undefined
+    try {
+      await getMyDataCollectionItems.execute(
+        testRoleIds,
+        testCollectionItemTypes,
+        [],
+        undefined,
+        undefined,
+        undefined
+      )
+      throw new Error('Use case should throw an error')
+    } catch (error) {
+      readError = error as ReadError
+    } finally {
+      expect(readError).toBeInstanceOf(ReadError)
+      expect(readError?.message).toEqual(
+        `There was an error when reading the resource. Reason was: No user found for: "Published, Unpublished, Draft, In Review, Deaccessioned"`
+      )
+    }
+  })
+  test('should an error message when no collection type is specified', async () => {
+    expect.assertions(2)
+    let readError: ReadError | undefined = undefined
+    try {
+      await getMyDataCollectionItems.execute(
+        testRoleIds,
+        testCollectionItemTypes,
+        [],
+        undefined,
+        undefined,
+        undefined
+      )
+      throw new Error('Use case should throw an error')
+    } catch (error) {
+      readError = error as ReadError
+    } finally {
+      expect(readError).toBeInstanceOf(ReadError)
+      expect(readError?.message).toEqual(
+        `There was an error when reading the resource. Reason was: No user found for: "Published, Unpublished, Draft, In Review, Deaccessioned"`
+      )
+    }
   })
 })