Fix unread counter stuck after reading all articles
markRead() fired its PUT fire-and-forget with no retry and silently swallowed failures. If one PUT among a burst (paging through article view fires one per page turn) failed or lost a race with the app's own background sync()->fetchData() refetch, that article's read-mark was permanently lost: the header's unreadCount (derived live from allItems) would show it again mid-session, and a reload reproduced it identically since the DB genuinely still had it unread. - markRead() now retries transient failures (no response / 5xx / 429) with backoff and a request timeout, skips retrying non-retryable 4xx, and surfaces a message on final failure instead of only console.log. - A pendingReadCounts refcount (keyed by article id) tracks in-flight/ retrying marks; fetchData() excludes those ids - snapshotting before its GET is dispatched, not just once the response lands - so a concurrent refetch can't resurrect an article whose read-confirmation is still in flight or unsettled at request time. - markAllRead() now reports a partial-failure summary instead of unconditionally claiming full success when some marks fail. Extends vue/src/composables/__tests__/useFeeds.spec.js with coverage for retry/backoff, non-retryable errors, the dispatch-before-response race, overlapping concurrent marks for the same id, and markAllRead's partial-failure message. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01CVw1XNQjodp4B7qiZqjtDE
This commit is contained in:
1 parent
67b970df9b
commit
5f816bb0f5
2 files changed
+282
-12
No files matched your search
@@ -1,5 +1,4 @@
|
||||
import { describe, it, expect, vi, beforeEach } from 'vitest'
|
||||
import { flushPromises } from '@vue/test-utils'
|
||||
import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
|
||||
import axios from 'axios'
|
||||
import { useFeeds } from '../useFeeds'
|
||||
|
||||
@@ -13,7 +12,7 @@ class FakeIntersectionObserver {
|
||||
vi.stubGlobal('IntersectionObserver', FakeIntersectionObserver)
|
||||
|
||||
describe('useFeeds', () => {
|
||||
const { feeds, allItems, feedFilter, feedTitles, feedUnreadCounts, unreadCount, displayedFeedUnreadCounts, refreshUnreadDisplay, setFeedFilter, showMessage, message, showModal, fetchData, sync, getReadable, setInitialLoad, handleIntersection, markAllRead, setupIntersectionObserver } = useFeeds()
|
||||
const { feeds, allItems, feedFilter, feedTitles, feedUnreadCounts, unreadCount, displayedFeedUnreadCounts, refreshUnreadDisplay, setFeedFilter, showMessage, message, showModal, fetchData, sync, getReadable, setInitialLoad, handleIntersection, markAllRead, markRead, setupIntersectionObserver } = useFeeds()
|
||||
|
||||
beforeEach(() => {
|
||||
localStorage.setItem('user-token', 'test-token')
|
||||
@@ -178,6 +177,193 @@ describe('useFeeds', () => {
|
||||
setInitialLoad(false)
|
||||
})
|
||||
|
||||
describe('markRead resilience', () => {
|
||||
// Mirrors useFeeds.js's MARK_READ_RETRY_DELAYS_MS (not exported). Kept in
|
||||
// sync via this comment: if that backoff changes, update this too — too
|
||||
// small a value just makes the affected test's `await` hang until it
|
||||
// times out, rather than pass incorrectly.
|
||||
const RETRY_BACKOFF_SUM_MS = 300 + 1000
|
||||
|
||||
// A failed assertion before a test's own vi.useRealTimers() call would
|
||||
// otherwise leak fake timers into every later test in this file.
|
||||
afterEach(() => {
|
||||
vi.useRealTimers()
|
||||
})
|
||||
|
||||
it('retries a failed mark-read PUT before giving up, with a request timeout set', async () => {
|
||||
vi.useFakeTimers()
|
||||
axios.put
|
||||
.mockRejectedValueOnce(new Error('network'))
|
||||
.mockRejectedValueOnce(new Error('network'))
|
||||
.mockResolvedValueOnce({ status: 200 })
|
||||
|
||||
const done = markRead(601)
|
||||
await vi.runAllTimersAsync()
|
||||
|
||||
expect(await done).toBe(true)
|
||||
expect(axios.put).toHaveBeenCalledTimes(3)
|
||||
expect(axios.put).toHaveBeenCalledWith(
|
||||
'/api/v1/article/read/601',
|
||||
null,
|
||||
expect.objectContaining({ timeout: expect.any(Number) }),
|
||||
)
|
||||
expect(showMessage.value).toBe(false)
|
||||
})
|
||||
|
||||
it('reports failure once retries are exhausted, and stops withholding the item from a refetch', async () => {
|
||||
vi.useFakeTimers()
|
||||
axios.put.mockRejectedValue(new Error('network'))
|
||||
|
||||
const done = markRead(602)
|
||||
// Advance past just the two retry backoffs — not runAllTimersAsync(),
|
||||
// which would also fire showMessageForXSeconds's own 5s auto-hide timer
|
||||
// and reset showMessage before the assertion below.
|
||||
await vi.advanceTimersByTimeAsync(RETRY_BACKOFF_SUM_MS)
|
||||
|
||||
expect(await done).toBe(false)
|
||||
expect(axios.put).toHaveBeenCalledTimes(3)
|
||||
expect(showMessage.value).toBe(true)
|
||||
expect(message.value).toMatch(/could not mark/i)
|
||||
|
||||
// The mark never committed, so the item genuinely is still unread
|
||||
// server-side — a refetch must be free to show it again, not hide it
|
||||
// forever as "pending".
|
||||
axios.get.mockResolvedValueOnce({
|
||||
data: {
|
||||
feeds: [{
|
||||
title: 'Feed A',
|
||||
items: [{ id: 602, title: 'A1', content: '', url: 'https://example.test/a1', timestamp: '2026-01-01 10:00:00' }],
|
||||
}],
|
||||
},
|
||||
})
|
||||
await fetchData()
|
||||
expect(feeds.value.map(f => f.id)).toEqual([602])
|
||||
})
|
||||
|
||||
it('does not retry a non-retryable 4xx mark-read failure', async () => {
|
||||
const error = new Error('Not Found')
|
||||
error.response = { status: 404 }
|
||||
axios.put.mockRejectedValueOnce(error)
|
||||
|
||||
const result = await markRead(605)
|
||||
|
||||
expect(result).toBe(false)
|
||||
expect(axios.put).toHaveBeenCalledTimes(1)
|
||||
expect(showMessage.value).toBe(true)
|
||||
})
|
||||
|
||||
it('keeps a still-unconfirmed read article out of a concurrent background refetch', async () => {
|
||||
let resolvePut
|
||||
axios.put.mockReturnValueOnce(new Promise(resolve => { resolvePut = resolve }))
|
||||
|
||||
const done = markRead(603) // simulates a page-turn's fire-and-forget mark-read, still in flight
|
||||
|
||||
// A background sync's trailing fetchData() resolves while that PUT is
|
||||
// still pending — the server hasn't committed the read yet, so it's
|
||||
// still in the response.
|
||||
axios.get.mockResolvedValueOnce({
|
||||
data: {
|
||||
feeds: [{
|
||||
title: 'Feed A',
|
||||
items: [{ id: 603, title: 'A1', content: '', url: 'https://example.test/a1', timestamp: '2026-01-01 10:00:00' }],
|
||||
}],
|
||||
},
|
||||
})
|
||||
await fetchData()
|
||||
|
||||
expect(feeds.value).toEqual([])
|
||||
|
||||
resolvePut({ status: 200 })
|
||||
await done
|
||||
})
|
||||
|
||||
it('excludes an item whose mark-read PUT settles between a refetch\'s request and its response', async () => {
|
||||
// The PUT commits (and clears the pending id) while the GET below is
|
||||
// still in flight — the GET's response nonetheless reflects the DB as
|
||||
// of before that commit, still reporting the item unread. A snapshot
|
||||
// taken only once the GET resolves would miss this; one taken before
|
||||
// it's dispatched (unioned with the live state) catches it too.
|
||||
axios.put.mockResolvedValueOnce({ status: 200 })
|
||||
const markDone = markRead(604)
|
||||
|
||||
let resolveGet
|
||||
axios.get.mockReturnValueOnce(new Promise(resolve => { resolveGet = resolve }))
|
||||
const fetchPromise = fetchData()
|
||||
|
||||
await markDone // the PUT (and pending-id cleanup) settles first...
|
||||
|
||||
resolveGet({ // ...then the already-in-flight GET resolves, still unread.
|
||||
data: {
|
||||
feeds: [{
|
||||
title: 'Feed A',
|
||||
items: [{ id: 604, title: 'A1', content: '', url: 'https://example.test/a1', timestamp: '2026-01-01 10:00:00' }],
|
||||
}],
|
||||
},
|
||||
})
|
||||
await fetchPromise
|
||||
|
||||
expect(feeds.value).toEqual([])
|
||||
})
|
||||
|
||||
it('keeps an item withheld until every overlapping markRead() call for it settles', async () => {
|
||||
// nextArticle()/prevArticle() can both re-mark the same article (page
|
||||
// forward, back, forward again) — two overlapping calls for one id.
|
||||
let resolveFirst
|
||||
let resolveSecond
|
||||
axios.put
|
||||
.mockReturnValueOnce(new Promise(resolve => { resolveFirst = resolve }))
|
||||
.mockReturnValueOnce(new Promise(resolve => { resolveSecond = resolve }))
|
||||
|
||||
const first = markRead(606)
|
||||
const second = markRead(606)
|
||||
|
||||
resolveSecond({ status: 200 }) // the second (later) call settles first
|
||||
await second
|
||||
|
||||
// The first call is still in flight — a refetch must still withhold it.
|
||||
axios.get.mockResolvedValueOnce({
|
||||
data: {
|
||||
feeds: [{
|
||||
title: 'Feed A',
|
||||
items: [{ id: 606, title: 'A1', content: '', url: 'https://example.test/a1', timestamp: '2026-01-01 10:00:00' }],
|
||||
}],
|
||||
},
|
||||
})
|
||||
await fetchData()
|
||||
expect(feeds.value).toEqual([])
|
||||
|
||||
resolveFirst({ status: 200 })
|
||||
await first
|
||||
})
|
||||
})
|
||||
|
||||
describe('markAllRead resilience', () => {
|
||||
const RETRY_BACKOFF_SUM_MS = 300 + 1000
|
||||
|
||||
afterEach(() => {
|
||||
vi.useRealTimers()
|
||||
})
|
||||
|
||||
it('reports a partial failure instead of claiming full success', async () => {
|
||||
feeds.value = [
|
||||
{ id: 701, title: 'First' },
|
||||
{ id: 702, title: 'Second' },
|
||||
]
|
||||
vi.spyOn(window, 'confirm').mockReturnValue(true)
|
||||
axios.put
|
||||
.mockResolvedValueOnce({ status: 200 }) // 701 succeeds
|
||||
.mockRejectedValue(new Error('network')) // 702 fails every attempt
|
||||
|
||||
vi.useFakeTimers()
|
||||
const done = markAllRead()
|
||||
await vi.advanceTimersByTimeAsync(RETRY_BACKOFF_SUM_MS)
|
||||
await done
|
||||
|
||||
expect(message.value).toContain('1 of 2')
|
||||
expect(message.value).not.toBe('All articles marked as read.')
|
||||
})
|
||||
})
|
||||
|
||||
describe('feed filter', () => {
|
||||
const twoFeedsResponse = {
|
||||
data: {
|
||||
|
||||
Reference in new issue
Block a user