fix: update naming and test

Author: ChengShi-1

docs/useCases.md

@@ -2152,18 +2152,18 @@ Returns the number of unread notifications for the current authenticated user.
 ##### Example call:
 
 ```typescript
-import { getUnreadCount } from '@iqss/dataverse-client-javascript'
+import { getUnreadNotificationsCount } from '@iqss/dataverse-client-javascript'
 
 /* ... */
 
-getUnreadCount.execute().then((count: number) => {
+getUnreadNotificationsCount.execute().then((count: number) => {
   console.log(`You have ${count} unread notifications`)
 })
 
 /* ... */
 ```
 
-_See [use case](../src/notifications/domain/useCases/GetUnreadCount.ts) implementation_.
+_See [use case](../src/notifications/domain/useCases/GetUnreadNotificationsCount.ts) implementation_.
 
 #### Mark As Read
 
@@ -2172,20 +2172,20 @@ Marks a specific notification as read for the current authenticated user. This o
 ##### Example call:
 
 ```typescript
-import { markAsRead } from '@iqss/dataverse-client-javascript'
+import { markNotificationAsRead } from '@iqss/dataverse-client-javascript'
 
 /* ... */
 
 const notificationId = 123
 
-markAsRead.execute(notificationId).then(() => {
+markNotificationAsRead.execute(notificationId).then(() => {
   console.log('Notification marked as read')
 })
 
 /* ... */
 ```
 
-_See [use case](../src/notifications/domain/useCases/MarkAsRead.ts) implementation_.
+_See [use case](../src/notifications/domain/useCases/MarkNotificationAsRead.ts) implementation_.
 
 ## Search
 

src/notifications/domain/models/Notification.ts

@@ -54,8 +54,8 @@ export interface Notification {
   userGuidesVersion?: string
   userGuidesSectionPath?: string
   roleAssignments?: RoleAssignment[]
-  dataverseAlias?: string
-  dataverseDisplayName?: string
+  collectionAlias?: string
+  collectionDisplayName?: string
   datasetPersistentIdentifier?: string
   datasetDisplayName?: string
   ownerPersistentIdentifier?: string

src/notifications/domain/repositories/INotificationsRepository.ts

@@ -3,6 +3,6 @@ import { Notification } from '../models/Notification'
 export interface INotificationsRepository {
   getAllNotificationsByUser(inAppNotificationFormat?: boolean): Promise<Notification[]>
   deleteNotification(notificationId: number): Promise<void>
-  getUnreadCount(): Promise<number>
-  markAsRead(notificationId: number): Promise<void>
+  getUnreadNotificationsCount(): Promise<number>
+  markNotificationAsRead(notificationId: number): Promise<void>
 }

…ations/domain/useCases/GetUnreadCount.ts …/useCases/GetUnreadNotificationsCount.tssrc/notifications/domain/useCases/GetUnreadCount.ts renamed to src/notifications/domain/useCases/GetUnreadNotificationsCount.ts src/notifications/domain/useCases/GetUnreadCount.ts renamed to src/notifications/domain/useCases/GetUnreadNotificationsCount.ts

@@ -1,7 +1,7 @@
 import { UseCase } from '../../../core/domain/useCases/UseCase'
 import { INotificationsRepository } from '../repositories/INotificationsRepository'
 
-export class GetUnreadCount implements UseCase<number> {
+export class GetUnreadNotificationsCount implements UseCase<number> {
   private notificationsRepository: INotificationsRepository
 
   constructor(notificationsRepository: INotificationsRepository) {
@@ -14,6 +14,6 @@ export class GetUnreadCount implements UseCase<number> {
    * @returns {Promise<number>} - A promise that resolves to the number of unread notifications.
    */
   async execute(): Promise<number> {
-    return await this.notificationsRepository.getUnreadCount()
+    return await this.notificationsRepository.getUnreadNotificationsCount()
   }
 }

…ifications/domain/useCases/MarkAsRead.ts …omain/useCases/MarkNotificationAsRead.tssrc/notifications/domain/useCases/MarkAsRead.ts renamed to src/notifications/domain/useCases/MarkNotificationAsRead.ts src/notifications/domain/useCases/MarkAsRead.ts renamed to src/notifications/domain/useCases/MarkNotificationAsRead.ts

@@ -1,7 +1,7 @@
 import { UseCase } from '../../../core/domain/useCases/UseCase'
 import { INotificationsRepository } from '../repositories/INotificationsRepository'
 
-export class MarkAsRead implements UseCase<void> {
+export class MarkNotificationAsRead implements UseCase<void> {
   private notificationsRepository: INotificationsRepository
 
   constructor(notificationsRepository: INotificationsRepository) {
@@ -15,6 +15,6 @@ export class MarkAsRead implements UseCase<void> {
    * @returns {Promise<void>} - A promise that resolves when the notification is marked as read.
    */
   async execute(notificationId: number): Promise<void> {
-    return await this.notificationsRepository.markAsRead(notificationId)
+    return await this.notificationsRepository.markNotificationAsRead(notificationId)
   }
 }

src/notifications/index.ts

@@ -1,16 +1,21 @@
 import { NotificationsRepository } from './infra/repositories/NotificationsRepository'
 import { GetAllNotificationsByUser } from './domain/useCases/GetAllNotificationsByUser'
 import { DeleteNotification } from './domain/useCases/DeleteNotification'
-import { GetUnreadCount } from './domain/useCases/GetUnreadCount'
-import { MarkAsRead } from './domain/useCases/MarkAsRead'
+import { GetUnreadNotificationsCount } from './domain/useCases/GetUnreadNotificationsCount'
+import { MarkNotificationAsRead } from './domain/useCases/MarkNotificationAsRead'
 
 const notificationsRepository = new NotificationsRepository()
 
 const getAllNotificationsByUser = new GetAllNotificationsByUser(notificationsRepository)
 const deleteNotification = new DeleteNotification(notificationsRepository)
-const getUnreadCount = new GetUnreadCount(notificationsRepository)
-const markAsRead = new MarkAsRead(notificationsRepository)
+const getUnreadNotificationsCount = new GetUnreadNotificationsCount(notificationsRepository)
+const markNotificationAsRead = new MarkNotificationAsRead(notificationsRepository)
 
-export { getAllNotificationsByUser, deleteNotification, getUnreadCount, markAsRead }
+export {
+  getAllNotificationsByUser,
+  deleteNotification,
+  getUnreadNotificationsCount,
+  markNotificationAsRead
+}
 
 export { Notification, NotificationType, RoleAssignment } from './domain/models/Notification'

src/notifications/infra/repositories/NotificationsRepository.ts

@@ -1,6 +1,7 @@
 import { ApiRepository } from '../../../core/infra/repositories/ApiRepository'
 import { INotificationsRepository } from '../../domain/repositories/INotificationsRepository'
 import { Notification } from '../../domain/models/Notification'
+import { NotificationPayload } from '../transformers/NotificationPayload'
 
 export class NotificationsRepository extends ApiRepository implements INotificationsRepository {
   private readonly notificationsResourceName: string = 'notifications'
@@ -14,7 +15,17 @@ export class NotificationsRepository extends ApiRepository implements INotificat
       true,
       queryParams
     )
-      .then((response) => response.data.data.notifications as Notification[])
+      .then((response) => {
+        const notifications = response.data.data.notifications
+        return notifications.map((notification: NotificationPayload) => {
+          const { dataverseDisplayName, dataverseAlias, ...restNotification } = notification
+          return {
+            ...restNotification,
+            ...(dataverseDisplayName && { collectionDisplayName: dataverseDisplayName }),
+            ...(dataverseAlias && { collectionAlias: dataverseAlias })
+          }
+        }) as Notification[]
+      })
       .catch((error) => {
         throw error
       })
@@ -30,14 +41,14 @@ export class NotificationsRepository extends ApiRepository implements INotificat
       })
   }
 
-  public async getUnreadCount(): Promise<number> {
+  public async getUnreadNotificationsCount(): Promise<number> {
     return this.doGet(
       this.buildApiEndpoint(this.notificationsResourceName, 'unreadCount'),
       true
     ).then((response) => response.data.data.unreadCount as number)
   }
 
-  public async markAsRead(notificationId: number): Promise<void> {
+  public async markNotificationAsRead(notificationId: number): Promise<void> {
     return this.doPut(
       this.buildApiEndpoint(this.notificationsResourceName, 'markAsRead', notificationId),
       {}

src/notifications/infra/transformers/NotificationPayload.ts

@@ -0,0 +1,30 @@
+import { RoleAssignment } from '../../domain/models/Notification'
+
+export interface NotificationPayload {
+  id: number
+  type: string
+  subjectText?: string
+  messageText?: string
+  sentTimestamp: string
+  displayAsRead: boolean
+  installationBrandName?: string
+  userGuidesBaseUrl?: string
+  userGuidesVersion?: string
+  userGuidesSectionPath?: string
+  roleAssignments?: RoleAssignment[]
+  dataverseAlias?: string
+  dataverseDisplayName?: string
+  datasetPersistentIdentifier?: string
+  datasetDisplayName?: string
+  ownerPersistentIdentifier?: string
+  ownerAlias?: string
+  ownerDisplayName?: string
+  requestorFirstName?: string
+  requestorLastName?: string
+  requestorEmail?: string
+  dataFileId?: number
+  dataFileDisplayName?: string
+  currentCurationStatus?: string
+  additionalInfo?: string
+  objectDeleted?: boolean
+}

test/integration/notifications/NotificationsRepository.test.ts

@@ -11,6 +11,11 @@ import {
 import { createDataset, CreatedDatasetIdentifiers } from '../../../src/datasets'
 import { publishDatasetViaApi, waitForNoLocks } from '../../testHelpers/datasets/datasetHelper'
 import { WriteError } from '../../../src'
+import { createCollection } from '../../../src/collections'
+import {
+  createCollectionDTO,
+  deleteCollectionViaApi
+} from '../../testHelpers/collections/collectionHelper'
 
 describe('NotificationsRepository', () => {
   const sut: NotificationsRepository = new NotificationsRepository()
@@ -90,17 +95,18 @@ describe('NotificationsRepository', () => {
     expect(notification).toHaveProperty('displayAsRead')
   })
 
-  test('should find notification with ASSIGNROLE type', async () => {
+  test('should find notification with ASSIGNROLE type that has not been deleted', async () => {
     const notifications: Notification[] = await sut.getAllNotificationsByUser(true)
 
-    // Find a notification with ASSIGNROLE type
-    const assignRoleNotification = notifications.find((n) => n.type === NotificationType.ASSIGNROLE)
+    const assignRoleNotification = notifications.find(
+      (n) => n.type === NotificationType.ASSIGNROLE && !n.objectDeleted
+    )
 
     expect(assignRoleNotification).toBeDefined()
     expect(assignRoleNotification?.type).toBe(NotificationType.ASSIGNROLE)
     expect(assignRoleNotification?.sentTimestamp).toBeDefined()
     expect(assignRoleNotification?.displayAsRead).toBeDefined()
-    expect(assignRoleNotification?.dataverseDisplayName).toBeDefined()
+    expect(assignRoleNotification?.collectionDisplayName).toBeDefined()
 
     expect(assignRoleNotification?.roleAssignments).toBeDefined()
     expect(assignRoleNotification?.roleAssignments?.length).toBeGreaterThan(0)
@@ -110,14 +116,42 @@ describe('NotificationsRepository', () => {
     expect(assignRoleNotification?.roleAssignments?.[0]).toHaveProperty('definitionPointId')
   })
 
+  test('should create a collection and find the notification with CREATEDV type', async () => {
+    const testCollectionAlias = 'test-notification-collection'
+    const createdCollectionId = await createCollection.execute(
+      createCollectionDTO(testCollectionAlias)
+    )
+
+    expect(createdCollectionId).toBeDefined()
+    expect(createdCollectionId).toBeGreaterThan(0)
+
+    const notifications: Notification[] = await sut.getAllNotificationsByUser(true)
+    expect(Array.isArray(notifications)).toBe(true)
+    expect(notifications.length).toBeGreaterThan(0)
+
+    const createdvNotification = notifications.find(
+      (n) => n.collectionAlias === testCollectionAlias
+    )
+
+    expect(createdvNotification).toBeDefined()
+    expect(createdvNotification?.type).toBe(NotificationType.CREATEDV)
+    expect(createdvNotification?.collectionAlias).toBe(testCollectionAlias)
+    expect(createdvNotification?.sentTimestamp).toBeDefined()
+    expect(createdvNotification?.displayAsRead).toBe(false)
+    expect(createdvNotification?.collectionDisplayName).toBe('Test Collection')
+    expect(createdvNotification?.collectionAlias).toBe(testCollectionAlias)
+
+    await deleteCollectionViaApi(testCollectionAlias)
+  })
+
   test('should return array when inAppNotificationFormat is false', async () => {
     const notifications: Notification[] = await sut.getAllNotificationsByUser(false)
 
     expect(Array.isArray(notifications)).toBe(true)
   })
 
   test('should return unread count', async () => {
-    const unreadCount = await sut.getUnreadCount()
+    const unreadCount = await sut.getUnreadNotificationsCount()
 
     expect(typeof unreadCount).toBe('number')
     expect(unreadCount).toBeGreaterThanOrEqual(0)
@@ -130,7 +164,7 @@ describe('NotificationsRepository', () => {
 
     const unreadNotification = notifications[0]
 
-    await expect(sut.markAsRead(unreadNotification.id)).resolves.toBeUndefined()
+    await expect(sut.markNotificationAsRead(unreadNotification.id)).resolves.toBeUndefined()
 
     const updatedNotifications: Notification[] = await sut.getAllNotificationsByUser()
     const updatedNotification = updatedNotifications.find((n) => n.id === unreadNotification.id)
@@ -145,6 +179,8 @@ describe('NotificationsRepository', () => {
       `[404] Notification ${nonExistentNotificationId} not found.`
     )
 
-    await expect(sut.markAsRead(nonExistentNotificationId)).rejects.toThrow(expectedError)
+    await expect(sut.markNotificationAsRead(nonExistentNotificationId)).rejects.toThrow(
+      expectedError
+    )
   })
 })

test/unit/notifications/GetUnreadCount.test.ts

@@ -1,24 +1,26 @@
-import { GetUnreadCount } from '../../../src/notifications/domain/useCases/GetUnreadCount'
+import { GetUnreadNotificationsCount } from '../../../src/notifications/domain/useCases/GetUnreadNotificationsCount'
 import { INotificationsRepository } from '../../../src/notifications/domain/repositories/INotificationsRepository'
 import { ReadError } from '../../../src'
 
-describe('GetUnreadCount', () => {
+describe('GetUnreadNotificationsCount', () => {
   test('should return unread count from repository', async () => {
     const notificationsRepositoryStub: INotificationsRepository = {} as INotificationsRepository
 
-    notificationsRepositoryStub.getUnreadCount = jest.fn().mockResolvedValue(5)
-    const sut = new GetUnreadCount(notificationsRepositoryStub)
+    notificationsRepositoryStub.getUnreadNotificationsCount = jest.fn().mockResolvedValue(5)
+    const sut = new GetUnreadNotificationsCount(notificationsRepositoryStub)
 
     const result = await sut.execute()
 
-    expect(notificationsRepositoryStub.getUnreadCount).toHaveBeenCalledWith()
+    expect(notificationsRepositoryStub.getUnreadNotificationsCount).toHaveBeenCalledWith()
     expect(result).toBe(5)
   })
 
   test('should throw error when repository throws error', async () => {
     const notificationsRepositoryStub: INotificationsRepository = {} as INotificationsRepository
-    notificationsRepositoryStub.getUnreadCount = jest.fn().mockRejectedValue(new ReadError())
-    const sut = new GetUnreadCount(notificationsRepositoryStub)
+    notificationsRepositoryStub.getUnreadNotificationsCount = jest
+      .fn()
+      .mockRejectedValue(new ReadError())
+    const sut = new GetUnreadNotificationsCount(notificationsRepositoryStub)
 
     await expect(sut.execute()).rejects.toThrow(ReadError)
   })