@sanity/sdk 3.0.0-rc.0 → 3.0.0-rc.1

package/src/auth/refreshStampedToken.test.ts

@@ -1,37 +1,38 @@
-// NOTE: vi.mock REMOVED
-
 import {of, Subscription, throwError} from 'rxjs'
-import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest' // Removed Mock type
+import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest'
 
 import {createSanityInstance} from '../store/createSanityInstance'
 import {createStoreState} from '../store/createStoreState'
 import {AuthStateType} from './authStateType'
 import {type AuthState, authStore} from './authStore'
-import {
-  getLastRefreshTime,
-  getNextRefreshDelay,
-  refreshStampedToken,
-  setLastRefreshTime,
-} from './refreshStampedToken'
+import {refreshStampedToken} from './refreshStampedToken'
 import {createLoggedInAuthState} from './utils'
 
-// Type definitions for Web Locks (can be kept if needed for context)
-// ... (Lock, LockOptions, LockGrantedCallback types)
+// Mock logger to prevent actual logging during tests
+vi.mock('../utils/logger', async (importOriginal) => {
+  const original = await importOriginal<typeof import('../utils/logger')>()
+  return {
+    ...original,
+    createLogger: vi.fn(() => ({
+      info: vi.fn(),
+      debug: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+      trace: vi.fn(),
+    })),
+  }
+})
 
 describe('refreshStampedToken', () => {
   let mockStorage: Storage
-  let originalNavigator: typeof navigator // Restored
   let originalDocument: Document
   let subscriptions: Subscription[]
-  // mockLocksRequest removed
 
   beforeEach(() => {
     subscriptions = []
     vi.clearAllMocks()
     vi.useFakeTimers()
 
-    originalNavigator = global.navigator // Restore original navigator setup
-
     // Mock document for visibility API
     originalDocument = global.document
     Object.defineProperty(global, 'document', {
@@ -52,49 +53,10 @@ describe('refreshStampedToken', () => {
       key: vi.fn(),
       length: 0,
     }
-    // Restore a basic, functional mock for navigator.locks
-    // This mock *will* run the callback, including the infinite loop
-    // if not handled carefully in tests.
-    const mockLocks = {
-      request: vi.fn(
-        async (
-          _name: string,
-          _options: LockOptions | LockGrantedCallback,
-          callback?: LockGrantedCallback,
-        ) => {
-          const actualCallback = typeof _options === 'function' ? _options : callback
-          if (!actualCallback) return false
-          const mockLock: Lock = {name: 'mock-lock', mode: 'exclusive'}
-          try {
-            await new Promise((resolve) => setTimeout(resolve, 0))
-            // CAUTION: This executes the callback provided by acquireTokenRefreshLock
-            // which contains the infinite loop. Tests need to avoid triggering
-            // timers indefinitely if this runs.
-            await actualCallback(mockLock)
-            // This return is unlikely to be hit if callback loops
-            return true
-          } catch (error) {
-            // eslint-disable-next-line no-console
-            console.error('Mock lock request failed:', error)
-            return false
-          }
-        },
-      ),
-      query: vi.fn(async () => ({held: [], pending: []})),
-    }
-    Object.defineProperty(global, 'navigator', {
-      value: {locks: mockLocks},
-      writable: true,
-    })
   })
 
   afterEach(async () => {
     subscriptions.forEach((sub) => sub.unsubscribe())
-    // Restore original navigator
-    Object.defineProperty(global, 'navigator', {
-      value: originalNavigator,
-      writable: true,
-    })
     // Restore original document
     Object.defineProperty(global, 'document', {
       value: originalDocument,
@@ -110,351 +72,229 @@ describe('refreshStampedToken', () => {
     vi.useRealTimers()
   })
 
-  describe('dashboard context', () => {
-    it('refreshes the token immediately without using locks', async () => {
-      // Test setup remains similar, using fake timers
-      const mockClient = {
-        observable: {request: vi.fn(() => of({token: 'sk-refreshed-token-st123'}))},
-      }
-      const mockClientFactory = vi.fn().mockReturnValue(mockClient)
-      const instance = createSanityInstance({
-        auth: {clientFactory: mockClientFactory, storageArea: mockStorage},
-      })
-      const initialState = authStore.getInitialState(instance, null)
-      initialState.authState = {
-        type: AuthStateType.LOGGED_IN,
-        token: 'sk-initial-token-st123',
-        currentUser: null,
-      }
-      initialState.dashboardContext = {mode: 'test'}
-      const state = createStoreState(initialState)
-
-      const subscription = refreshStampedToken({state, instance, key: null})
-      subscriptions.push(subscription)
-
-      await vi.advanceTimersToNextTimerAsync()
-
-      const finalAuthStateDash = state.get().authState
-      expect(finalAuthStateDash.type).toBe(AuthStateType.LOGGED_IN)
-      // Ensure token was updated
-      if (finalAuthStateDash.type === AuthStateType.LOGGED_IN) {
-        expect(finalAuthStateDash.token).toBe('sk-refreshed-token-st123')
-      }
-      // Verify navigator.locks.request was NOT called
-      const locksRequest = navigator.locks.request as ReturnType<typeof vi.fn>
-      expect(locksRequest).not.toHaveBeenCalled()
+  it('refreshes the token when the interval timer fires', async () => {
+    const mockClient = {
+      observable: {request: vi.fn(() => of({token: 'sk-refreshed-token-st123'}))},
+    }
+    const mockClientFactory = vi.fn().mockReturnValue(mockClient)
+    const instance = createSanityInstance({
+      projectId: 'p',
+      dataset: 'd',
+      auth: {clientFactory: mockClientFactory, storageArea: mockStorage},
     })
+    const initialState = authStore.getInitialState(instance, null)
+    initialState.authState = {
+      type: AuthStateType.LOGGED_IN,
+      token: 'sk-initial-token-st123',
+      currentUser: null,
+    }
+    const state = createStoreState(initialState)
+
+    const subscription = refreshStampedToken({state, instance, key: null})
+    subscriptions.push(subscription)
+
+    await vi.advanceTimersToNextTimerAsync()
+
+    const finalAuthState = state.get().authState
+    expect(finalAuthState.type).toBe(AuthStateType.LOGGED_IN)
+    if (finalAuthState.type === AuthStateType.LOGGED_IN) {
+      expect(finalAuthState.token).toBe('sk-refreshed-token-st123')
+    }
+  })
+
+  it('writes the refreshed token to storage', async () => {
+    const mockClient = {
+      observable: {request: vi.fn(() => of({token: 'sk-refreshed-token-st123'}))},
+    }
+    const mockClientFactory = vi.fn().mockReturnValue(mockClient)
+    const instance = createSanityInstance({
+      projectId: 'p',
+      dataset: 'd',
+      auth: {clientFactory: mockClientFactory, storageArea: mockStorage},
+    })
+    const initialState = authStore.getInitialState(instance, null)
+    initialState.authState = {
+      type: AuthStateType.LOGGED_IN,
+      token: 'sk-initial-token-st123',
+      currentUser: null,
+    }
+    const state = createStoreState(initialState)
+
+    const subscription = refreshStampedToken({state, instance, key: null})
+    subscriptions.push(subscription)
+
+    await vi.advanceTimersToNextTimerAsync()
+
+    expect(mockClient.observable.request).toHaveBeenCalled()
+    expect(mockStorage.setItem).toHaveBeenCalledWith(
+      initialState.options.storageKey,
+      JSON.stringify({token: 'sk-refreshed-token-st123'}),
+    )
+  })
 
-    it('does not refresh on visibility change when lastTokenRefresh is recent', async () => {
-      const mockClient = {
-        observable: {request: vi.fn(() => of({token: 'sk-refreshed-token-st123'}))},
-      }
-      const mockClientFactory = vi.fn().mockReturnValue(mockClient)
-      const instance = createSanityInstance({
-        defaultResource: {projectId: 'p', dataset: 'd'},
-        auth: {clientFactory: mockClientFactory, storageArea: mockStorage},
-      })
-      const initialState = authStore.getInitialState(instance, null)
-      initialState.authState = createLoggedInAuthState('sk-initial-token-st123', null)
-      initialState.dashboardContext = {mode: 'test'}
-      const state = createStoreState(initialState)
-
-      const subscription = refreshStampedToken({state, instance, key: null})
-      subscriptions.push(subscription)
-
-      const addEventListenerMock = global.document.addEventListener as ReturnType<typeof vi.fn>
-      expect(addEventListenerMock).toHaveBeenCalledWith('visibilitychange', expect.any(Function))
-      const visibilityHandler = addEventListenerMock.mock.calls[0][1] as () => void
-
-      Object.defineProperty(global.document, 'visibilityState', {
-        value: 'visible',
-        writable: true,
-        configurable: true,
-      })
-
-      visibilityHandler()
-      await vi.advanceTimersByTimeAsync(100)
-
-      expect(mockClient.observable.request).not.toHaveBeenCalled()
-      const finalAuthState = state.get().authState
-      if (finalAuthState.type === AuthStateType.LOGGED_IN) {
-        expect(finalAuthState.token).toBe('sk-initial-token-st123')
-      }
+  it('does not refresh on visibility change when lastTokenRefresh is recent', async () => {
+    const mockClient = {
+      observable: {request: vi.fn(() => of({token: 'sk-refreshed-token-st123'}))},
+    }
+    const mockClientFactory = vi.fn().mockReturnValue(mockClient)
+    const instance = createSanityInstance({
+      auth: {clientFactory: mockClientFactory, storageArea: mockStorage},
     })
+    const initialState = authStore.getInitialState(instance, null)
+    initialState.authState = createLoggedInAuthState('sk-initial-token-st123', null)
+    const state = createStoreState(initialState)
+
+    const subscription = refreshStampedToken({state, instance, key: null})
+    subscriptions.push(subscription)
 
-    it('refreshes on visibility change when lastTokenRefresh is stale', async () => {
-      const REFRESH_INTERVAL = 12 * 60 * 60 * 1000
-      const mockClient = {
-        observable: {request: vi.fn(() => of({token: 'sk-refreshed-token-st123'}))},
-      }
-      const mockClientFactory = vi.fn().mockReturnValue(mockClient)
-      const instance = createSanityInstance({
-        defaultResource: {projectId: 'p', dataset: 'd'},
-        auth: {clientFactory: mockClientFactory, storageArea: mockStorage},
-      })
-      const initialState = authStore.getInitialState(instance, null)
-      const staleTimestamp = Date.now() - REFRESH_INTERVAL - 1000
-      initialState.authState = {
-        type: AuthStateType.LOGGED_IN,
-        token: 'sk-initial-token-st123',
-        currentUser: null,
-        lastTokenRefresh: staleTimestamp,
-      }
-      initialState.dashboardContext = {mode: 'test'}
-      const state = createStoreState(initialState)
-
-      const subscription = refreshStampedToken({state, instance, key: null})
-      subscriptions.push(subscription)
-
-      const addEventListenerMock = global.document.addEventListener as ReturnType<typeof vi.fn>
-      expect(addEventListenerMock).toHaveBeenCalledWith('visibilitychange', expect.any(Function))
-      const visibilityHandler = addEventListenerMock.mock.calls[0][1] as () => void
-
-      Object.defineProperty(global.document, 'visibilityState', {
-        value: 'visible',
-        writable: true,
-        configurable: true,
-      })
-
-      visibilityHandler()
-      await vi.advanceTimersToNextTimerAsync()
-
-      expect(mockClient.observable.request).toHaveBeenCalled()
-      const finalAuthState = state.get().authState
-      if (finalAuthState.type === AuthStateType.LOGGED_IN) {
-        expect(finalAuthState.token).toBe('sk-refreshed-token-st123')
-        expect(finalAuthState.lastTokenRefresh).toBeGreaterThan(staleTimestamp)
-      }
+    const addEventListenerMock = global.document.addEventListener as ReturnType<typeof vi.fn>
+    expect(addEventListenerMock).toHaveBeenCalledWith('visibilitychange', expect.any(Function))
+    const visibilityHandler = addEventListenerMock.mock.calls[0][1] as () => void
+
+    Object.defineProperty(global.document, 'visibilityState', {
+      value: 'visible',
+      writable: true,
+      configurable: true,
     })
 
-    it('refreshes on visibility change when lastTokenRefresh is undefined (pre-fix behavior)', async () => {
-      const mockClient = {
-        observable: {request: vi.fn(() => of({token: 'sk-refreshed-token-st123'}))},
-      }
-      const mockClientFactory = vi.fn().mockReturnValue(mockClient)
-      const instance = createSanityInstance({
-        defaultResource: {projectId: 'p', dataset: 'd'},
-        auth: {clientFactory: mockClientFactory, storageArea: mockStorage},
-      })
-      const initialState = authStore.getInitialState(instance, null)
-      initialState.authState = {
-        type: AuthStateType.LOGGED_IN,
-        token: 'sk-initial-token-st123',
-        currentUser: null,
-        // lastTokenRefresh intentionally omitted to demonstrate the old bug
-      }
-      initialState.dashboardContext = {mode: 'test'}
-      const state = createStoreState(initialState)
-
-      const subscription = refreshStampedToken({state, instance, key: null})
-      subscriptions.push(subscription)
-
-      const addEventListenerMock = global.document.addEventListener as ReturnType<typeof vi.fn>
-      const visibilityHandler = addEventListenerMock.mock.calls[0][1] as () => void
-
-      Object.defineProperty(global.document, 'visibilityState', {
-        value: 'visible',
-        writable: true,
-        configurable: true,
-      })
-
-      visibilityHandler()
-      await vi.advanceTimersToNextTimerAsync()
-
-      // Without lastTokenRefresh, shouldRefreshToken returns true — this is the bug
-      expect(mockClient.observable.request).toHaveBeenCalled()
+    visibilityHandler()
+    await vi.advanceTimersByTimeAsync(100)
+
+    expect(mockClient.observable.request).not.toHaveBeenCalled()
+    const finalAuthState = state.get().authState
+    if (finalAuthState.type === AuthStateType.LOGGED_IN) {
+      expect(finalAuthState.token).toBe('sk-initial-token-st123')
+    }
+  })
+
+  it('refreshes on visibility change when lastTokenRefresh is stale', async () => {
+    const REFRESH_INTERVAL = 12 * 60 * 60 * 1000
+    const mockClient = {
+      observable: {request: vi.fn(() => of({token: 'sk-refreshed-token-st123'}))},
+    }
+    const mockClientFactory = vi.fn().mockReturnValue(mockClient)
+    const instance = createSanityInstance({
+      auth: {clientFactory: mockClientFactory, storageArea: mockStorage},
     })
+    const initialState = authStore.getInitialState(instance, null)
+    const staleTimestamp = Date.now() - REFRESH_INTERVAL - 1000
+    initialState.authState = {
+      type: AuthStateType.LOGGED_IN,
+      token: 'sk-initial-token-st123',
+      currentUser: null,
+      lastTokenRefresh: staleTimestamp,
+    }
+    const state = createStoreState(initialState)
 
-    it('does not refresh when tab is not visible', async () => {
-      // Set visibility to hidden
-      Object.defineProperty(global, 'document', {
-        value: {
-          visibilityState: 'hidden',
-          addEventListener: vi.fn(),
-          removeEventListener: vi.fn(),
-        },
-        writable: true,
-        configurable: true,
-      })
-
-      const mockClient = {
-        observable: {request: vi.fn(() => of({token: 'sk-refreshed-token-st123'}))},
-      }
-      const mockClientFactory = vi.fn().mockReturnValue(mockClient)
-      const instance = createSanityInstance({
-        auth: {clientFactory: mockClientFactory, storageArea: mockStorage},
-      })
-      const initialState = authStore.getInitialState(instance, null)
-      initialState.authState = {
-        type: AuthStateType.LOGGED_IN,
-        token: 'sk-initial-token-st123',
-        currentUser: null,
-      }
-      initialState.dashboardContext = {mode: 'test'}
-      const state = createStoreState(initialState)
-
-      const subscription = refreshStampedToken({state, instance, key: null})
-      subscriptions.push(subscription)
-
-      await vi.advanceTimersToNextTimerAsync()
-
-      // Verify that no refresh occurred
-      expect(mockClient.observable.request).not.toHaveBeenCalled()
-      const finalAuthState = state.get().authState
-      if (finalAuthState.type === AuthStateType.LOGGED_IN) {
-        expect(finalAuthState.token).toBe('sk-initial-token-st123')
-      }
+    const subscription = refreshStampedToken({state, instance, key: null})
+    subscriptions.push(subscription)
+
+    const addEventListenerMock = global.document.addEventListener as ReturnType<typeof vi.fn>
+    expect(addEventListenerMock).toHaveBeenCalledWith('visibilitychange', expect.any(Function))
+    const visibilityHandler = addEventListenerMock.mock.calls[0][1] as () => void
+
+    Object.defineProperty(global.document, 'visibilityState', {
+      value: 'visible',
+      writable: true,
+      configurable: true,
     })
+
+    visibilityHandler()
+    await vi.advanceTimersToNextTimerAsync()
+
+    expect(mockClient.observable.request).toHaveBeenCalled()
+    const finalAuthState = state.get().authState
+    if (finalAuthState.type === AuthStateType.LOGGED_IN) {
+      expect(finalAuthState.token).toBe('sk-refreshed-token-st123')
+      expect(finalAuthState.lastTokenRefresh).toBeGreaterThan(staleTimestamp)
+    }
   })
 
-  describe('non-dashboard context', () => {
-    // Test is simplified: just ensure it runs without error
-    it('attempts token refresh coordination when not in dashboard context', async () => {
-      // Fake timers enabled via beforeEach
-      const mockClient = {observable: {request: vi.fn()}}
-      const mockClientFactory = vi.fn().mockReturnValue(mockClient)
-      const instance = createSanityInstance({
-        auth: {clientFactory: mockClientFactory, storageArea: mockStorage},
-      })
-      const initialState = authStore.getInitialState(instance, null)
-      initialState.authState = {
-        type: AuthStateType.LOGGED_IN,
-        token: 'sk-initial-token-st123',
-        currentUser: null,
-      }
-      const state = createStoreState(initialState)
-
-      let subscription: Subscription | undefined
-      // We expect this NOT to throw, but accept we can't easily test the lock call or outcome
-      expect(() => {
-        subscription = refreshStampedToken({state, instance, key: null})
-        subscriptions.push(subscription!)
-      }).not.toThrow()
-
-      // DO NOT advance timers or yield here - focus on immediate observable logic
-      // We cannot reliably test that failingLocksRequest is called due to async/timer issues,
-      // but we *can* test the consequence of it resolving to false.
-
-      // VERIFY THE OUTCOME:
-      // Check client request was NOT made (because filter(hasLock => hasLock) receives false)
-      expect(mockClient.observable.request).not.toHaveBeenCalled()
-      // Check state remains unchanged
-      const finalAuthState = state.get().authState
-      expect(finalAuthState.type).toBe(AuthStateType.LOGGED_IN)
-      if (finalAuthState.type === AuthStateType.LOGGED_IN) {
-        expect(finalAuthState.token).toBe('sk-initial-token-st123')
-      }
+  it('refreshes on visibility change when lastTokenRefresh is undefined (pre-fix behavior)', async () => {
+    const mockClient = {
+      observable: {request: vi.fn(() => of({token: 'sk-refreshed-token-st123'}))},
+    }
+    const mockClientFactory = vi.fn().mockReturnValue(mockClient)
+    const instance = createSanityInstance({
+      auth: {clientFactory: mockClientFactory, storageArea: mockStorage},
     })
+    const initialState = authStore.getInitialState(instance, null)
+    initialState.authState = {
+      type: AuthStateType.LOGGED_IN,
+      token: 'sk-initial-token-st123',
+      currentUser: null,
+      // lastTokenRefresh intentionally omitted to demonstrate the old bug
+    }
+    const state = createStoreState(initialState)
+
+    const subscription = refreshStampedToken({state, instance, key: null})
+    subscriptions.push(subscription)
+
+    const addEventListenerMock = global.document.addEventListener as ReturnType<typeof vi.fn>
+    const visibilityHandler = addEventListenerMock.mock.calls[0][1] as () => void
 
-    it('skips refresh if lock request returns false', async () => {
-      // Fake timers enabled via beforeEach
-      // Mock navigator.locks.request LOCALLY for this test to return false
-      const originalLocks = navigator.locks
-      // Use mockResolvedValue: the from(acquireTokenRefreshLock(...)) expects a Promise
-      const failingLocksRequest = vi.fn().mockResolvedValue(false)
-      Object.defineProperty(global, 'navigator', {
-        value: {locks: {...originalLocks, request: failingLocksRequest}},
-        writable: true,
-      })
-
-      try {
-        const mockClient = {
-          observable: {request: vi.fn(() => of({token: 'sk-refreshed-token-st123'}))},
-        }
-        const mockClientFactory = vi.fn().mockReturnValue(mockClient)
-        const instance = createSanityInstance({
-          auth: {clientFactory: mockClientFactory, storageArea: mockStorage},
-        })
-        const initialState = authStore.getInitialState(instance, null)
-        initialState.authState = {
-          type: AuthStateType.LOGGED_IN,
-          token: 'sk-initial-token-st123',
-          currentUser: null,
-        }
-        const state = createStoreState(initialState)
-
-        const subscription = refreshStampedToken({state, instance, key: null})
-        subscriptions.push(subscription)
-
-        // DO NOT advance timers or yield here - focus on immediate observable logic
-        // We cannot reliably test that failingLocksRequest is called due to async/timer issues,
-        // but we *can* test the consequence of it resolving to false.
-
-        // VERIFY THE OUTCOME:
-        // Check client request was NOT made (because filter(hasLock => hasLock) receives false)
-        expect(mockClient.observable.request).not.toHaveBeenCalled()
-        // Check state remains unchanged
-        const finalAuthState = state.get().authState
-        expect(finalAuthState.type).toBe(AuthStateType.LOGGED_IN)
-        if (finalAuthState.type === AuthStateType.LOGGED_IN) {
-          expect(finalAuthState.token).toBe('sk-initial-token-st123')
-        }
-      } finally {
-        // Restore original navigator.locks
-        Object.defineProperty(global, 'navigator', {value: {locks: originalLocks}, writable: true})
-      }
+    Object.defineProperty(global.document, 'visibilityState', {
+      value: 'visible',
+      writable: true,
+      configurable: true,
     })
+
+    visibilityHandler()
+    await vi.advanceTimersToNextTimerAsync()
+
+    // Without lastTokenRefresh, shouldRefreshToken returns true — this is the bug
+    expect(mockClient.observable.request).toHaveBeenCalled()
   })
 
-  describe('unsupported environments', () => {
-    it('falls back to immediate refresh if Web Locks API is not supported', async () => {
-      // Temporarily remove navigator.locks for this test
-      const originalLocks = navigator.locks
-      Object.defineProperty(global.navigator, 'locks', {
-        value: undefined,
-        writable: true,
-      })
-
-      try {
-        const mockClient = {
-          observable: {request: vi.fn(() => of({token: 'sk-refreshed-immediately-st123'}))},
-        }
-        const mockClientFactory = vi.fn().mockReturnValue(mockClient)
-        const instance = createSanityInstance({
-          auth: {clientFactory: mockClientFactory, storageArea: mockStorage},
-        })
-        const initialState = authStore.getInitialState(instance, null)
-        initialState.authState = {
-          type: AuthStateType.LOGGED_IN,
-          token: 'sk-initial-token-st123',
-          currentUser: null,
-        }
-        const state = createStoreState(initialState)
-
-        const subscription = refreshStampedToken({state, instance, key: null})
-        subscriptions.push(subscription)
-
-        // Advance timers to allow the async `performRefresh` to execute
-        await vi.advanceTimersToNextTimerAsync()
-
-        // Verify the refresh was performed and state was updated
-        expect(mockClient.observable.request).toHaveBeenCalled()
-        const finalAuthState = state.get().authState
-        expect(finalAuthState.type).toBe(AuthStateType.LOGGED_IN)
-        if (finalAuthState.type === AuthStateType.LOGGED_IN) {
-          expect(finalAuthState.token).toBe('sk-refreshed-immediately-st123')
-        }
-        // Verify token was set in storage
-        expect(mockStorage.setItem).toHaveBeenCalledWith(
-          initialState.options.storageKey,
-          JSON.stringify({token: 'sk-refreshed-immediately-st123'}),
-        )
-      } finally {
-        // Restore navigator.locks
-        Object.defineProperty(global.navigator, 'locks', {
-          value: originalLocks,
-          writable: true,
-        })
-      }
+  it('does not refresh when tab is not visible', async () => {
+    // Set visibility to hidden
+    Object.defineProperty(global, 'document', {
+      value: {
+        visibilityState: 'hidden',
+        addEventListener: vi.fn(),
+        removeEventListener: vi.fn(),
+      },
+      writable: true,
+      configurable: true,
+    })
+
+    const mockClient = {
+      observable: {request: vi.fn(() => of({token: 'sk-refreshed-token-st123'}))},
+    }
+    const mockClientFactory = vi.fn().mockReturnValue(mockClient)
+    const instance = createSanityInstance({
+      projectId: 'p',
+      dataset: 'd',
+      auth: {clientFactory: mockClientFactory, storageArea: mockStorage},
     })
+    const initialState = authStore.getInitialState(instance, null)
+    initialState.authState = {
+      type: AuthStateType.LOGGED_IN,
+      token: 'sk-initial-token-st123',
+      currentUser: null,
+    }
+    const state = createStoreState(initialState)
+
+    const subscription = refreshStampedToken({state, instance, key: null})
+    subscriptions.push(subscription)
+
+    await vi.advanceTimersToNextTimerAsync()
+
+    // Verify that no refresh occurred
+    expect(mockClient.observable.request).not.toHaveBeenCalled()
+    const finalAuthState = state.get().authState
+    if (finalAuthState.type === AuthStateType.LOGGED_IN) {
+      expect(finalAuthState.token).toBe('sk-initial-token-st123')
+    }
   })
 
-  // Restore other tests to their simpler form
   it('sets an error state when token refresh fails', async () => {
     const error = new Error('Refresh failed')
     const mockClient = {observable: {request: vi.fn(() => throwError(() => error))}}
     const mockClientFactory = vi.fn().mockReturnValue(mockClient)
     const instance = createSanityInstance({
+      projectId: 'p',
+      dataset: 'd',
       auth: {clientFactory: mockClientFactory, storageArea: mockStorage},
     })
     const initialState = authStore.getInitialState(instance, null)
@@ -463,7 +303,6 @@ describe('refreshStampedToken', () => {
       token: 'sk-initial-token-st123',
       currentUser: null,
     }
-    initialState.dashboardContext = {mode: 'test'}
     const state = createStoreState(initialState)
 
     const subscription = refreshStampedToken({state, instance, key: null})
@@ -482,6 +321,8 @@ describe('refreshStampedToken', () => {
   it('does nothing if user is not logged in', async () => {
     const mockClientFactory = vi.fn()
     const instance = createSanityInstance({
+      projectId: 'p',
+      dataset: 'd',
       auth: {clientFactory: mockClientFactory, storageArea: mockStorage},
     })
     const initialState = authStore.getInitialState(instance, null)
@@ -497,8 +338,6 @@ describe('refreshStampedToken', () => {
     await vi.advanceTimersByTimeAsync(0)
 
     expect(mockClientFactory).not.toHaveBeenCalled()
-    const locksRequest = navigator.locks.request as ReturnType<typeof vi.fn>
-    expect(locksRequest).not.toHaveBeenCalled()
     expect(state.get().authState.type).toBe(AuthStateType.LOGGED_OUT)
   })
 
@@ -506,6 +345,8 @@ describe('refreshStampedToken', () => {
     const mockClient = {observable: {request: vi.fn()}}
     const mockClientFactory = vi.fn().mockReturnValue(mockClient)
     const instance = createSanityInstance({
+      projectId: 'p',
+      dataset: 'd',
       auth: {clientFactory: mockClientFactory, storageArea: mockStorage},
     })
     const initialState = authStore.getInitialState(instance, null)
@@ -522,8 +363,6 @@ describe('refreshStampedToken', () => {
     await vi.advanceTimersByTimeAsync(0)
 
     expect(mockClient.observable.request).not.toHaveBeenCalled()
-    const locksRequest = navigator.locks.request as ReturnType<typeof vi.fn>
-    expect(locksRequest).not.toHaveBeenCalled()
     // Add type guard before accessing token property
     const finalAuthState = state.get().authState
     expect(finalAuthState.type).toBe(AuthStateType.LOGGED_IN)
@@ -532,92 +371,3 @@ describe('refreshStampedToken', () => {
     }
   })
 })
-
-describe('time-based refresh helpers', () => {
-  let mockStorage: Storage
-  const storageKey = 'my-test-key'
-
-  beforeEach(() => {
-    mockStorage = {
-      getItem: vi.fn(),
-      setItem: vi.fn(),
-      removeItem: vi.fn(),
-      clear: vi.fn(),
-      key: vi.fn(),
-      length: 0,
-    }
-    vi.useFakeTimers()
-  })
-
-  afterEach(() => {
-    vi.useRealTimers()
-  })
-
-  describe('getLastRefreshTime', () => {
-    it('returns 0 if storage is undefined', () => {
-      expect(getLastRefreshTime(undefined, storageKey)).toBe(0)
-    })
-
-    it('returns 0 if item is not in storage', () => {
-      vi.spyOn(mockStorage, 'getItem').mockReturnValue(null)
-      expect(getLastRefreshTime(mockStorage, storageKey)).toBe(0)
-      expect(mockStorage.getItem).toHaveBeenCalledWith(`${storageKey}_last_refresh`)
-    })
-
-    it('returns the parsed timestamp from storage', () => {
-      const now = Date.now()
-      vi.spyOn(mockStorage, 'getItem').mockReturnValue(now.toString())
-      expect(getLastRefreshTime(mockStorage, storageKey)).toBe(now)
-    })
-
-    it('returns 0 if stored data is malformed', () => {
-      vi.spyOn(mockStorage, 'getItem').mockReturnValue('not a number')
-      expect(getLastRefreshTime(mockStorage, storageKey)).toBe(0)
-    })
-
-    it('returns 0 on storage access error', () => {
-      vi.spyOn(mockStorage, 'getItem').mockImplementation(() => {
-        throw new Error('Storage access failed')
-      })
-      expect(getLastRefreshTime(mockStorage, storageKey)).toBe(0)
-    })
-  })
-
-  describe('setLastRefreshTime', () => {
-    it('sets the current timestamp in storage', () => {
-      const now = Date.now()
-      setLastRefreshTime(mockStorage, storageKey)
-      expect(mockStorage.setItem).toHaveBeenCalledWith(`${storageKey}_last_refresh`, now.toString())
-    })
-
-    it('does not throw on storage access error', () => {
-      vi.spyOn(mockStorage, 'setItem').mockImplementation(() => {
-        throw new Error('Storage access failed')
-      })
-      expect(() => setLastRefreshTime(mockStorage, storageKey)).not.toThrow()
-    })
-  })
-
-  describe('getNextRefreshDelay', () => {
-    const REFRESH_INTERVAL = 12 * 60 * 60 * 1000
-
-    it('returns 0 if last refresh time is not available', () => {
-      vi.spyOn(mockStorage, 'getItem').mockReturnValue(null)
-      expect(getNextRefreshDelay(mockStorage, storageKey)).toBe(0)
-    })
-
-    it('returns the remaining time until the next refresh', () => {
-      const lastRefresh = Date.now() - 10000 // 10 seconds ago
-      vi.spyOn(mockStorage, 'getItem').mockReturnValue(lastRefresh.toString())
-
-      const delay = getNextRefreshDelay(mockStorage, storageKey)
-      expect(delay).toBeCloseTo(REFRESH_INTERVAL - 10000, -2)
-    })
-
-    it('returns 0 if the refresh interval has passed', () => {
-      const lastRefresh = Date.now() - REFRESH_INTERVAL - 5000 // 5 seconds past due
-      vi.spyOn(mockStorage, 'getItem').mockReturnValue(lastRefresh.toString())
-      expect(getNextRefreshDelay(mockStorage, storageKey)).toBe(0)
-    })
-  })
-})