move update notifications store to after publish is complete, update component test

Author: ekraffmiller

src/sections/collection/publish-collection/usePublishCollection.tsx

@@ -3,7 +3,6 @@ import { CollectionRepository } from '../../../collection/domain/repositories/Co
 import { publishCollection } from '../../../collection/domain/useCases/publishCollection'
 
 import { SubmissionStatus } from '../../shared/form/DatasetMetadataForm/useSubmitDataset'
-import { needsUpdateStore } from '@/notifications/domain/hooks/needsUpdateStore'
 
 type UsePublishCollectionReturnType =
   | {
@@ -37,7 +36,6 @@ export function usePublishCollection(
       .then(() => {
         setPublishError(null)
         setSubmissionStatus(SubmissionStatus.SubmitComplete)
-        needsUpdateStore.setNeedsUpdate(true)
         onPublishSucceed()
         return
       })

src/sections/dataset/useCheckPublishCompleted.ts

@@ -3,6 +3,7 @@ import { getDatasetLocks } from '../../dataset/domain/useCases/getDatasetLocks'
 import { Dataset } from '../../dataset/domain/models/Dataset'
 import { DatasetRepository } from '../../dataset/domain/repositories/DatasetRepository'
 import { PUBLISH_DATASET_POLL_INTERVAL } from './config'
+import { needsUpdateStore } from '@/notifications/domain/hooks/needsUpdateStore'
 
 const useCheckPublishCompleted = (
   publishInProgress: boolean | undefined,
@@ -11,22 +12,27 @@ const useCheckPublishCompleted = (
 ): boolean => {
   const [publishCompleted, setPublishCompleted] = useState(false)
 
+  const handlePublishCompleted = () => {
+    setPublishCompleted(true)
+    needsUpdateStore.setNeedsUpdate(true)
+  }
+
   useEffect(() => {
     let intervalId: NodeJS.Timeout | null = null
 
     if (publishInProgress && dataset) {
       const waitForDatasetLocksReleased = async () => {
         const initialLocks = await getDatasetLocks(datasetRepository, dataset.persistentId)
         if (initialLocks.length === 0) {
-          setPublishCompleted(true)
+          handlePublishCompleted()
         } else {
           intervalId = setInterval(() => {
             const pollLocks = async () => {
               try {
                 const locks = await getDatasetLocks(datasetRepository, dataset.persistentId)
                 if (locks.length === 0) {
                   if (intervalId) clearInterval(intervalId)
-                  setPublishCompleted(true)
+                  handlePublishCompleted()
                 }
               } catch (error) {
                 if (intervalId) clearInterval(intervalId)

tests/component/sections/dataset/useCheckPublishCompleted.spec.tsx

@@ -1,11 +1,11 @@
 /// <reference types="cypress" />
 
+import { needsUpdateStore } from '@/notifications/domain/hooks/needsUpdateStore'
+import { Dataset } from '../../../../src/dataset/domain/models/Dataset'
 import { DatasetRepository } from '../../../../src/dataset/domain/repositories/DatasetRepository'
-import { renderHook } from '@testing-library/react'
 import useCheckPublishCompleted from '../../../../src/sections/dataset/useCheckPublishCompleted'
-import { DatasetMother } from '../../dataset/domain/models/DatasetMother'
 import { DatasetMockRepository } from '../../../../src/stories/dataset/DatasetMockRepository'
-import { Dataset } from '../../../../src/dataset/domain/models/Dataset'
+import { DatasetMother } from '../../dataset/domain/models/DatasetMother'
 
 interface TestComponentProps {
   publishInProgress: boolean | undefined
@@ -19,46 +19,75 @@ function TestComponent({ publishInProgress, dataset, datasetRepository }: TestCo
 }
 
 describe('useCheckPublishCompleted Hook', () => {
+  beforeEach(() => {
+    cy.stub(needsUpdateStore, 'setNeedsUpdate').as('setNeedsUpdate')
+  })
+
   it('should not set publishCompleted if publishInProgress is false', () => {
     const datasetRepository: DatasetRepository = {} as DatasetRepository
-    const { result } = renderHook(() =>
-      useCheckPublishCompleted(false, DatasetMother.create(), datasetRepository)
+
+    cy.clock()
+    cy.customMount(
+      <TestComponent
+        publishInProgress={false}
+        dataset={DatasetMother.create()}
+        datasetRepository={datasetRepository}
+      />
     )
-    cy.wait(3000).then(() => {
-      cy.wrap(result.current).should('equal', false)
-    })
+
+    cy.get('[data-testid="publish-completed"]').should('have.text', 'false')
+    cy.tick(10_000)
+    cy.get('[data-testid="publish-completed"]').should('have.text', 'false')
+    cy.get('@setNeedsUpdate').should('not.have.been.called')
   })
+
   it('should not set publishCompleted to true when locks are found initially', () => {
     const datasetRepository: DatasetMockRepository = new DatasetMockRepository()
     cy.stub(datasetRepository, 'getLocks').resolves([{ lockId: 'test-lock' }])
 
-    const { result } = renderHook(() =>
-      useCheckPublishCompleted(true, DatasetMother.create(), datasetRepository)
+    cy.clock()
+    cy.customMount(
+      <TestComponent
+        publishInProgress={true}
+        dataset={DatasetMother.create()}
+        datasetRepository={datasetRepository}
+      />
     )
 
-    cy.wait(3000).then(() => {
-      cy.wrap(result.current).should('equal', false)
-    })
+    cy.get('[data-testid="publish-completed"]').should('have.text', 'false')
+    cy.tick(10_000)
+    cy.get('[data-testid="publish-completed"]').should('have.text', 'false')
+    cy.get('@setNeedsUpdate').should('not.have.been.called')
   })
-  it('should set publishCompleted to true when no locks are found initially', () => {
+
+  it('should set publishCompleted to true (and mark needsUpdate) when no locks are found initially', () => {
     const datasetRepository: DatasetRepository = {} as DatasetRepository
     datasetRepository.getLocks = cy.stub().resolves([])
 
-    const { result } = renderHook(() =>
-      useCheckPublishCompleted(true, DatasetMother.create(), datasetRepository)
+    cy.clock()
+    cy.customMount(
+      <TestComponent
+        publishInProgress={true}
+        dataset={DatasetMother.create()}
+        datasetRepository={datasetRepository}
+      />
     )
-    cy.wait(3000).then(() => {
-      cy.wrap(result.current).should('equal', true)
-    })
+
+    cy.get('[data-testid="publish-completed"]').should('have.text', 'false')
+    cy.tick(2_000)
+    cy.get('[data-testid="publish-completed"]').should('have.text', 'true')
+    cy.get('@setNeedsUpdate').should('have.been.calledOnceWith', true)
   })
 
-  it('should set publishCompleted to true after polling finds no locks', () => {
+  it('should set publishCompleted to true (and mark needsUpdate) after polling finds no locks', () => {
     const datasetRepository: DatasetMockRepository = new DatasetMockRepository()
     const getLocksStub = cy.stub(datasetRepository, 'getLocks')
 
-    // First call finds locks, subsequent calls find no locks
+    // First lock check still sees the publish lock; the next one sees it cleared.
     getLocksStub.onFirstCall().resolves([{ lockId: 'test-lock' }])
-    getLocksStub.callsFake(() => Promise.resolve([]))
+    getLocksStub.onSecondCall().resolves([])
+
+    cy.clock()
 
     cy.customMount(
       <TestComponent
@@ -67,9 +96,19 @@ describe('useCheckPublishCompleted Hook', () => {
         datasetRepository={datasetRepository}
       />
     )
+
     cy.get('[data-testid="publish-completed"]').should('have.text', 'false')
-    cy.wait(3000).then(() => {
-      cy.get('[data-testid="publish-completed"]').should('have.text', 'true')
-    })
+
+    // Initial lock check waits 2s before calling getLocks.
+    cy.tick(2_000)
+    cy.wrap(getLocksStub).should('have.been.calledOnce')
+    cy.get('[data-testid="publish-completed"]').should('have.text', 'false')
+
+    // Polling waits 2s to fire, then the follow-up lock check waits another 2s.
+    cy.tick(4_000)
+
+    cy.get('[data-testid="publish-completed"]').should('have.text', 'true')
+    cy.wrap(getLocksStub).should('have.been.calledTwice')
+    cy.get('@setNeedsUpdate').should('have.been.calledOnceWith', true)
   })
 })