@sanity/sdk-react 0.0.0-alpha.1 → 0.0.0-alpha.10

package/src/hooks/auth/useAuthState.test.tsx

@@ -1,106 +1,16 @@
-import {
-  type AuthState,
-  type AuthStore,
-  createSanityInstance,
-  getAuthStore,
-  type SanityInstance,
-} from '@sanity/sdk'
-import {renderHook} from '@testing-library/react'
-import {describe, expect, it, vi} from 'vitest'
+import {getAuthState} from '@sanity/sdk'
+import {identity} from 'rxjs'
+import {describe, it} from 'vitest'
 
-import {SanityProvider} from '../../components/context/SanityProvider'
-import * as context from '../context/useSanityInstance'
-import {useAuthState} from './useAuthState'
+import {createStateSourceHook} from '../helpers/createStateSourceHook'
 
-// Mock dependencies
-vi.mock('@sanity/sdk')
-vi.mock('../context/useSanityInstance')
-
-const createMockAuthStore = (authState: AuthState): AuthStore => ({
-  authState: {
-    getState: () => authState,
-    getInitialState: () => authState,
-    subscribe: vi.fn(),
-  },
-  tokenState: {
-    getState: vi.fn(),
-    getInitialState: vi.fn(),
-    subscribe: vi.fn(),
-  },
-  currentUserState: {
-    getState: vi.fn(),
-    getInitialState: vi.fn(),
-    subscribe: vi.fn(),
-  },
-  handleCallback: vi.fn(),
-  logout: vi.fn(),
-  dispose: vi.fn(),
-  getLoginUrls: vi.fn(),
-})
-
-const mockUser = {
-  id: 'user-123',
-  name: 'Test User',
-  email: 'test@example.com',
-  role: 'developer',
-  roles: [{name: 'developer', title: 'Developer'}],
-}
+vi.mock('../helpers/createStateSourceHook', () => ({createStateSourceHook: vi.fn(identity)}))
+vi.mock('@sanity/sdk', () => ({getAuthState: vi.fn()}))
 
 describe('useAuthState', () => {
-  const mockInstance: SanityInstance = {
-    identity: {
-      id: 'abc123store',
-      projectId: 'project-123',
-      dataset: 'dataset-123',
-    },
-    config: {},
-  }
-
-  // Setup mock for useSanityInstance
-  beforeEach(() => {
-    vi.spyOn(context, 'useSanityInstance').mockReturnValue(mockInstance)
-  })
-
-  it('should return the current auth state', () => {
-    const mockAuthStore = createMockAuthStore({
-      type: 'logged-in',
-      token: 'token-123',
-      currentUser: mockUser,
-    })
-    vi.mocked(getAuthStore).mockReturnValue(mockAuthStore)
-
-    const sanityInstance = createSanityInstance({projectId: 'test', dataset: 'test'})
-    const {result} = renderHook(() => useAuthState(), {
-      wrapper: ({children}) => (
-        <SanityProvider sanityInstance={sanityInstance}>{children}</SanityProvider>
-      ),
-    })
-    const current = result.current as Extract<AuthState, {type: 'logged-in'}>
-    expect(current.type).toBe('logged-in')
-    expect(current.token).toBe('token-123')
-    expect(current.currentUser).toBe(mockUser)
-  })
-
-  it('should handle signed out state', () => {
-    const mockAuthStore = createMockAuthStore({type: 'logged-out', isDestroyingSession: false})
-    vi.mocked(getAuthStore).mockReturnValue(mockAuthStore)
-
-    const {result} = renderHook(() => useAuthState())
-    expect(result.current.type).toBe('logged-out')
-  })
-
-  it('should subscribe to auth state changes', () => {
-    const subscribe = vi.fn()
-    const mockAuthStore = createMockAuthStore({
-      type: 'logged-in',
-      token: 'token-123',
-      currentUser: null,
-    })
-    mockAuthStore.authState.subscribe = subscribe
-
-    vi.mocked(getAuthStore).mockReturnValue(mockAuthStore)
-
-    renderHook(() => useAuthState())
-    expect(subscribe).toHaveBeenCalled()
+  it('calls `createStateSourceHook` with `getAuthState`', async () => {
+    const {useAuthState} = await import('./useAuthState')
+    expect(createStateSourceHook).toHaveBeenCalledWith(getAuthState)
+    expect(useAuthState).toBe(getAuthState)
   })
 })

package/src/hooks/auth/useAuthState.tsx

@@ -1,13 +1,13 @@
-import {type AuthState, getAuthStore} from '@sanity/sdk'
-import {useStore} from 'zustand/react'
+import {type AuthState, getAuthState} from '@sanity/sdk'
 
-import {useSanityInstance} from '../context/useSanityInstance'
+import {createStateSourceHook} from '../helpers/createStateSourceHook'
 
 /**
+ * @internal
  * A React hook that subscribes to authentication state changes.
  *
  * This hook provides access to the current authentication state type from the Sanity auth store.
- * It automatically re-renders the component when the authentication state changes.
+ * It automatically re-renders when the authentication state changes.
  *
  * @remarks
  * The hook uses `useSyncExternalStore` to safely subscribe to auth state changes
@@ -25,9 +25,4 @@ import {useSanityInstance} from '../context/useSanityInstance'
  *
  * @public
  */
-export function useAuthState(): AuthState {
-  const instance = useSanityInstance()
-  const {authState} = getAuthStore(instance)
-
-  return useStore(authState)
-}
+export const useAuthState: () => AuthState = createStateSourceHook(getAuthState)

package/src/hooks/auth/useAuthToken.test.tsx

@@ -1,94 +1,16 @@
-import {type AuthStore, getAuthStore, type SanityInstance} from '@sanity/sdk'
-import {renderHook} from '@testing-library/react'
-import {describe, expect, it, vi} from 'vitest'
+import {getTokenState} from '@sanity/sdk'
+import {identity} from 'rxjs'
+import {describe, it} from 'vitest'
 
-import {useSanityInstance} from '../context/useSanityInstance'
-import {useAuthToken} from './useAuthToken'
+import {createStateSourceHook} from '../helpers/createStateSourceHook'
 
-// Mock dependencies
-vi.mock('@sanity/sdk', () => ({
-  getAuthStore: vi.fn(),
-}))
-
-vi.mock('../context/useSanityInstance', () => ({
-  useSanityInstance: vi.fn(),
-}))
+vi.mock('../helpers/createStateSourceHook', () => ({createStateSourceHook: vi.fn(identity)}))
+vi.mock('@sanity/sdk', () => ({getTokenState: vi.fn()}))
 
 describe('useAuthToken', () => {
-  // Helper function to create mock instance
-  const createMockInstance = (): SanityInstance => ({
-    identity: {
-      id: 'abc123',
-      projectId: 'test-project-id',
-      dataset: 'test-dataset',
-    },
-    config: {},
-  })
-
-  // Helper function to create mock auth store
-  const createMockAuthStore = (token: string | null) => {
-    const authType = token ? 'logged-in' : 'logged-out'
-    return {
-      tokenState: {
-        getInitialState: () => token,
-        getState: () => token,
-        subscribe: vi.fn(),
-      },
-      authState: {
-        getInitialState: () => ({
-          type: authType,
-          isDestroyingSession: false,
-          ...(token && {token, currentUser: null}),
-        }),
-        getState: () => ({
-          type: authType,
-          isDestroyingSession: false,
-          ...(token && {token, currentUser: null}),
-        }),
-        subscribe: vi.fn(),
-      },
-      currentUserState: {
-        getInitialState: () => null,
-        getState: () => null,
-        subscribe: vi.fn(),
-      },
-      handleCallback: vi.fn(),
-      logout: vi.fn(),
-      dispose: vi.fn(),
-      getLoginUrls: vi.fn(),
-    } as unknown as AuthStore
-  }
-
-  beforeEach(() => {
-    vi.clearAllMocks()
-  })
-
-  it('should return null when no token is present', () => {
-    const mockInstance = createMockInstance()
-    const mockAuthStore = createMockAuthStore(null)
-
-    vi.mocked(useSanityInstance).mockReturnValue(mockInstance)
-    vi.mocked(getAuthStore).mockReturnValue(mockAuthStore)
-
-    const {result} = renderHook(() => useAuthToken())
-
-    expect(result.current).toBeNull()
-    expect(useSanityInstance).toHaveBeenCalled()
-    expect(getAuthStore).toHaveBeenCalledWith(mockInstance)
-  })
-
-  it('should return token when authenticated', () => {
-    const mockInstance = createMockInstance()
-    const mockToken = 'test-auth-token'
-    const mockAuthStore = createMockAuthStore(mockToken)
-
-    vi.mocked(useSanityInstance).mockReturnValue(mockInstance)
-    vi.mocked(getAuthStore).mockReturnValue(mockAuthStore)
-
-    const {result} = renderHook(() => useAuthToken())
-
-    expect(result.current).toBe(mockToken)
-    expect(useSanityInstance).toHaveBeenCalled()
-    expect(getAuthStore).toHaveBeenCalledWith(mockInstance)
+  it('calls `createStateSourceHook` with `getTokenState`', async () => {
+    const {useAuthToken} = await import('./useAuthToken')
+    expect(createStateSourceHook).toHaveBeenCalledWith(getTokenState)
+    expect(useAuthToken).toBe(getTokenState)
   })
 })

package/src/hooks/auth/useAuthToken.tsx

@@ -1,16 +1,10 @@
-import {getAuthStore} from '@sanity/sdk'
-import {useStore} from 'zustand'
+import {getTokenState} from '@sanity/sdk'
 
-import {useSanityInstance} from '../context/useSanityInstance'
+import {createStateSourceHook} from '../helpers/createStateSourceHook'
 
 /**
  * Hook to get the currently logged in user
- * @public
+ * @internal
  * @returns The current user or null if not authenticated
  */
-export const useAuthToken = (): string | null => {
-  const instance = useSanityInstance()
-  const {tokenState} = getAuthStore(instance)
-
-  return useStore(tokenState)
-}
+export const useAuthToken = createStateSourceHook(getTokenState)

package/src/hooks/auth/useCurrentUser.test.tsx

@@ -1,50 +1,16 @@
-import {type AuthStore, type CurrentUser, getAuthStore, type SanityInstance} from '@sanity/sdk'
-import {renderHook} from '@testing-library/react'
-import {describe, expect, it, vi} from 'vitest'
+import {getCurrentUserState} from '@sanity/sdk'
+import {identity} from 'rxjs'
+import {describe, it} from 'vitest'
 
-import {useSanityInstance} from '../context/useSanityInstance'
-import {useCurrentUser} from './useCurrentUser'
+import {createStateSourceHook} from '../helpers/createStateSourceHook'
 
-// Mock dependencies
-vi.mock('../context/useSanityInstance')
-vi.mock('@sanity/sdk')
-
-const mockUser: CurrentUser = {
-  id: 'user-123',
-  name: 'Test User',
-  email: 'test@example.com',
-  role: 'admin',
-  roles: [],
-}
+vi.mock('../helpers/createStateSourceHook', () => ({createStateSourceHook: vi.fn(identity)}))
+vi.mock('@sanity/sdk', () => ({getCurrentUserState: vi.fn()}))
 
 describe('useCurrentUser', () => {
-  it('returns the current user when authenticated', () => {
-    vi.mocked(useSanityInstance).mockReturnValue({} as unknown as SanityInstance)
-
-    // Mock the auth store with an authenticated user
-    vi.mocked(getAuthStore).mockReturnValue({
-      currentUserState: {
-        getState: () => mockUser,
-        subscribe: vi.fn(),
-      },
-    } as unknown as AuthStore)
-
-    const {result} = renderHook(() => useCurrentUser())
-    expect(result.current).toEqual(mockUser)
-  })
-
-  it('returns null when not authenticated', () => {
-    vi.mocked(useSanityInstance).mockReturnValue({} as unknown as SanityInstance)
-
-    // Mock the auth store with no user
-    vi.mocked(getAuthStore).mockReturnValue({
-      currentUserState: {
-        getState: () => null,
-        subscribe: vi.fn(),
-      },
-    } as unknown as AuthStore)
-
-    const {result} = renderHook(() => useCurrentUser())
-    expect(result.current).toBeNull()
+  it('calls `createStateSourceHook` with `getTokenState`', async () => {
+    const {useCurrentUser} = await import('./useCurrentUser')
+    expect(createStateSourceHook).toHaveBeenCalledWith(getCurrentUserState)
+    expect(useCurrentUser).toBe(getCurrentUserState)
   })
 })

package/src/hooks/auth/useCurrentUser.tsx

@@ -1,27 +1,27 @@
-import {type CurrentUser, type CurrentUserSlice, getAuthStore} from '@sanity/sdk'
-import {useStore} from 'zustand'
+import {type CurrentUser, getCurrentUserState} from '@sanity/sdk'
 
-import {useSanityInstance} from '../context/useSanityInstance'
+import {createStateSourceHook} from '../helpers/createStateSourceHook'
 
 /**
- * Hook to get the currently logged in user
+ * @TODO This should suspend! And possibly not return `null`?
+ *
  * @public
- * @returns The current user or null if not authenticated
+ *
+ * The `useCurrentUser` hook returns the currently authenticated user’s profile information (their name, email, roles, etc).
+ * If no users are currently logged in, the hook returns null.
+ *
+ * @returns The current user data, or `null` if not authenticated
+ *
+ * @example Rendering a basic user profile
+ * ```
+ * const user = useCurrentUser()
+ *
+ * return (
+ *   <figure>
+ *     <img src={user?.profileImage} alt=`Profile image for ${user?.name}` />
+ *     <h2>{user?.name}</h2>
+ *   </figure>
+ * )
+ * ```
  */
-export const useCurrentUser = (): CurrentUser | null => {
-  const instance = useSanityInstance()
-  const {currentUserState} = getAuthStore(instance)
-
-  // TODO: update this hook so it can never return null
-  if (!currentUserState.getState())
-    throw new Promise<void>((resolve) => {
-      const unsubscribe = currentUserState.subscribe((currentUser) => {
-        if (currentUser) {
-          unsubscribe()
-          resolve()
-        }
-      })
-    })
-
-  return useStore<CurrentUserSlice>(currentUserState)
-}
+export const useCurrentUser: () => CurrentUser | null = createStateSourceHook(getCurrentUserState)

package/src/hooks/auth/useHandleCallback.test.tsx

@@ -1,25 +1,16 @@
-import {getAuthStore} from '@sanity/sdk'
-import {renderHook} from '@testing-library/react'
-import {type Mock, vi} from 'vitest'
+import {handleCallback} from '@sanity/sdk'
+import {identity} from 'rxjs'
+import {describe, it} from 'vitest'
 
-import {useSanityInstance} from '../context/useSanityInstance'
-import {useHandleCallback} from './useHandleCallback'
+import {createCallbackHook} from '../helpers/createCallbackHook'
 
-vi.mock('../context/useSanityInstance')
-vi.mock('@sanity/sdk', () => ({getAuthStore: vi.fn()}))
+vi.mock('../helpers/createCallbackHook', () => ({createCallbackHook: vi.fn(identity)}))
+vi.mock('@sanity/sdk', () => ({handleCallback: vi.fn()}))
 
 describe('useHandleCallback', () => {
-  it('returns handleCallback from auth store', () => {
-    const mockInstance = {id: 'test'}
-    const mockHandleCallback = vi.fn()
-    const mockAuthStore = {handleCallback: mockHandleCallback}
-
-    ;(useSanityInstance as Mock).mockReturnValue(mockInstance)
-    ;(getAuthStore as Mock).mockReturnValue(mockAuthStore)
-
-    const {result} = renderHook(() => useHandleCallback())
-
-    expect(getAuthStore).toHaveBeenCalledWith(mockInstance)
-    expect(result.current).toBe(mockHandleCallback)
+  it('calls `createCallbackHook` with `handleCallback`', async () => {
+    const {useHandleCallback} = await import('./useHandleCallback')
+    expect(createCallbackHook).toHaveBeenCalledWith(handleCallback)
+    expect(useHandleCallback).toBe(handleCallback)
   })
 })

package/src/hooks/auth/useHandleCallback.tsx

@@ -1,9 +1,9 @@
-import {type AuthStore, getAuthStore} from '@sanity/sdk'
-import {useMemo} from 'react'
+import {handleCallback} from '@sanity/sdk'
 
-import {useSanityInstance} from '../context/useSanityInstance'
+import {createCallbackHook} from '../helpers/createCallbackHook'
 
 /**
+ * @internal
  * A React hook that returns a function for handling authentication callbacks.
  *
  * @remarks
@@ -42,9 +42,4 @@ import {useSanityInstance} from '../context/useSanityInstance'
  * @returns A callback handler function that processes OAuth redirects
  * @public
  */
-export function useHandleCallback(): AuthStore['handleCallback'] {
-  const instance = useSanityInstance()
-  const authStore = useMemo(() => getAuthStore(instance), [instance])
-
-  return authStore.handleCallback
-}
+export const useHandleCallback = createCallbackHook(handleCallback)

package/src/hooks/auth/useLogOut.test.tsx

@@ -1,67 +1,16 @@
-import {type AuthStore, getAuthStore, type SanityInstance} from '@sanity/sdk'
-import {renderHook} from '@testing-library/react'
-import {describe, expect, it, vi} from 'vitest'
+import {logout} from '@sanity/sdk'
+import {identity} from 'rxjs'
+import {describe, it} from 'vitest'
 
-import {useSanityInstance} from '../context/useSanityInstance'
-import {useLogOut} from './useLogOut'
+import {createCallbackHook} from '../helpers/createCallbackHook'
 
-// Mock dependencies
-vi.mock('@sanity/sdk', () => ({
-  getAuthStore: vi.fn(),
-}))
+vi.mock('../helpers/createCallbackHook', () => ({createCallbackHook: vi.fn(identity)}))
+vi.mock('@sanity/sdk', () => ({logout: vi.fn()}))
 
-vi.mock('../context/useSanityInstance', () => ({
-  useSanityInstance: vi.fn(),
-}))
-
-describe('useLogOut', () => {
-  it('should return logout function from auth store', () => {
-    // Setup mocks
-    const mockInstance: SanityInstance = {
-      identity: {
-        id: 'abc123',
-        projectId: 'test-project-id',
-        dataset: 'test-dataset',
-      },
-      config: {},
-    }
-
-    const mockLogout = vi.fn()
-    const mockAuthStore: AuthStore = {
-      authState: {
-        getInitialState: vi.fn(),
-        getState: vi.fn(),
-        subscribe: vi.fn(),
-      },
-      tokenState: {
-        getInitialState: vi.fn(),
-        getState: vi.fn(),
-        subscribe: vi.fn(),
-      },
-      currentUserState: {
-        getInitialState: vi.fn(),
-        getState: vi.fn(),
-        subscribe: vi.fn(),
-      },
-      handleCallback: vi.fn(),
-      logout: mockLogout,
-      dispose: vi.fn(),
-      getLoginUrls: vi.fn(),
-    }
-
-    vi.mocked(useSanityInstance).mockReturnValue(mockInstance)
-    vi.mocked(getAuthStore).mockReturnValue(mockAuthStore)
-
-    // Test the hook
-    const {result} = renderHook(() => useLogOut())
-
-    // Verify the returned function is the logout function
-    expect(result.current).toBe(mockLogout)
-    expect(useSanityInstance).toHaveBeenCalled()
-    expect(getAuthStore).toHaveBeenCalledWith(mockInstance)
-
-    // Verify the logout function can be called
-    result.current()
-    expect(mockLogout).toHaveBeenCalled()
+describe('useHandleCallback', () => {
+  it('calls `createCallbackHook` with `handleCallback`', async () => {
+    const {useLogOut} = await import('./useLogOut')
+    expect(createCallbackHook).toHaveBeenCalledWith(logout)
+    expect(useLogOut).toBe(logout)
   })
 })

package/src/hooks/auth/useLogOut.tsx

@@ -1,15 +1,10 @@
-import {type AuthStore, getAuthStore} from '@sanity/sdk'
+import {logout} from '@sanity/sdk'
 
-import {useSanityInstance} from '../context/useSanityInstance'
+import {createCallbackHook} from '../helpers/createCallbackHook'
 
 /**
  * Hook to log out of the current session
- * @public
+ * @internal
  * @returns A function to log out of the current session
  */
-export const useLogOut = (): AuthStore['logout'] => {
-  const instance = useSanityInstance()
-  const {logout} = getAuthStore(instance)
-
-  return logout
-}
+export const useLogOut = createCallbackHook(logout)

package/src/hooks/auth/useLoginUrls.test.tsx

@@ -1,61 +1,68 @@
-import {type AuthStore, createSanityInstance, getAuthStore} from '@sanity/sdk'
-import {renderHook, waitFor} from '@testing-library/react'
-import {Suspense} from 'react'
+import {createSanityInstance, fetchLoginUrls, getLoginUrlsState} from '@sanity/sdk'
+import {renderHook} from '@testing-library/react'
+import {act, Suspense} from 'react'
+import {throwError} from 'rxjs'
 import {describe, expect, it, vi} from 'vitest'
 
-import {SanityProvider} from '../../components/context/SanityProvider'
 import {useLoginUrls} from './useLoginUrls'
 
+vi.mock('../context/useSanityInstance', () => ({
+  useSanityInstance: vi.fn().mockReturnValue(createSanityInstance({projectId: 'p', dataset: 'd'})),
+}))
+
 vi.mock(import('@sanity/sdk'), async (importOriginal) => {
   const actual = await importOriginal()
-  return {
-    ...actual,
-    getAuthStore: vi.fn(),
-  }
+  return {...actual, getLoginUrlsState: vi.fn(), fetchLoginUrls: vi.fn()}
 })
 
 describe('useLoginUrls', () => {
-  it('should handle synchronous provider URLs', () => {
-    const mockProviders = [{name: 'google', title: 'Google', url: 'http://test.com/auth/google'}]
-    const mockAuthStore = {
-      getLoginUrls: () => mockProviders,
-    }
-    vi.mocked(getAuthStore).mockReturnValue(mockAuthStore as AuthStore)
+  it('should suspend by throwing `fetchLoginUrls` if `getLoginUrlsState().getCurrent()` is falsy', async () => {
+    const subscribe = vi.fn()
+    const getCurrent = vi.fn().mockReturnValue(undefined)
 
-    const sanityInstance = createSanityInstance({projectId: 'test', dataset: 'test'})
-    const wrapper = ({children}: {children: React.ReactNode}) => (
-      <SanityProvider sanityInstance={sanityInstance}>{children}</SanityProvider>
+    let resolve: () => void
+    const promise = new Promise<void>((thisResolve) => {
+      resolve = thisResolve
+    })
+    vi.mocked(fetchLoginUrls).mockReturnValue(
+      promise as unknown as ReturnType<typeof fetchLoginUrls>,
     )
 
-    const {result} = renderHook(() => useLoginUrls(), {wrapper})
-    expect(result.current).toEqual(mockProviders)
-  })
-
-  it('should handle asynchronous provider URLs', async () => {
-    const mockProviders = [{name: 'google', title: 'Google', url: 'http://test.com/auth/google'}]
-
-    const getLoginUrls = vi
-      .fn<AuthStore['getLoginUrls']>()
-      .mockResolvedValueOnce(mockProviders)
-      .mockReturnValueOnce(mockProviders)
-
-    vi.mocked(getAuthStore).mockReturnValue({getLoginUrls} as unknown as AuthStore)
+    vi.mocked(getLoginUrlsState).mockReturnValue({
+      getCurrent,
+      subscribe,
+      observable: throwError(() => new Error('Unexpected usage of observable')),
+    })
 
-    const sanityInstance = createSanityInstance({projectId: 'test', dataset: 'test'})
     const wrapper = ({children}: {children: React.ReactNode}) => (
-      <Suspense fallback={<>Loading…</>}>
-        <SanityProvider sanityInstance={sanityInstance}>{children}</SanityProvider>
-      </Suspense>
+      <Suspense fallback={<>Loading…</>}>{children}</Suspense>
     )
 
-    const {result} = renderHook(() => useLoginUrls(), {wrapper})
-
-    // Initially empty
+    const {result, rerender} = renderHook(() => useLoginUrls(), {wrapper})
     expect(result.current).toEqual(null)
 
-    // Wait for providers to load
-    await waitFor(() => {
-      expect(result.current).toEqual(mockProviders)
+    const mockProviders = [{name: 'google', title: 'Google', url: 'http://test.com/auth/google'}]
+
+    await act(async () => {
+      getCurrent.mockReturnValue(mockProviders)
+      resolve()
+      rerender()
+      await promise
     })
+
+    expect(result.current).toEqual(mockProviders)
+  })
+
+  it('should render according to `getLoginUrlsState`', () => {
+    const subscribe = vi.fn()
+    const mockProviders = [{name: 'google', title: 'Google', url: 'http://test.com/auth/google'}]
+    vi.mocked(getLoginUrlsState).mockReturnValue({
+      getCurrent: () => mockProviders,
+      subscribe,
+      observable: throwError(() => new Error('Unexpected usage of observable')),
+    })
+
+    const {result} = renderHook(() => useLoginUrls())
+    expect(result.current).toEqual(mockProviders)
   })
 })