How to test hooks that useSwr without deduplication?

[pke]

I would like to get an idea how to test hooks that useSwr without deduplication: 0.

Lets say I have more than one test of a hook and between tests I use cache.clear however all other tests except the first run behave weird because the deduplication logic still kicks in despite the cache being emptied between tests.
I could wrap the tests in a global config, that sets the default deduplication time to zero but that feels wrong.

It seems using jest.useFakeTimers in a beforeAll and jest.runAllTimers() in an afterAll to fix those issues.

Hook

import useSWR from "swr"

type Result = [
  /** Can be a string or an Error */
  ip: string | undefined | Error,
  refresh: () => Promise<any>,
  loading: boolean
]

/**
 * Hook for detecting the current public IP address.
 *
 * @returns the public IP Address or an error, a refresh function and loading indicator
 */
export default function useInternetAddress(): Result {
  const {
    data: ip,
    revalidate,
    isValidating,
  } = useSWR<string | Error, Error>(
    "https://ip.seeip.org",
    (url) =>
      fetch(url)
        .then((response) => response.text())
        .catch(() => new Error("Fehler")) // i81n
  )

  return [ip, revalidate, isValidating]
}

Test

// Test
/* eslint-disable i18next/no-literal-string */
import { act, renderHook } from "@testing-library/react-hooks"
import FetchMock from "jest-fetch-mock"
import { cache } from "swr"

import useInternetAddress from "./useInternetAddress"

FetchMock.enableMocks()

beforeEach(() => {
  cache.clear()
  // Clears the dedupe timeouts of swr
  jest.useFakeTimers()
})

afterEach(() => {
  act(() => {
    jest.runAllTimers()
  })
})

test("should render the hook", async () => {
  const { result, waitForNextUpdate } = renderHook(() => useInternetAddress())
  expect(result.error).toBeUndefined()
  await waitForNextUpdate()
})

test("should return ip", async () => {
  FetchMock.mockOnce("192.168.1.666")
  const { result, waitFor } = renderHook(() => useInternetAddress())
  // Loading
  expect(result.current[2]).toBe(true)
  await waitFor(() => expect(result.current[0]).toBe("192.168.1.666"))
  // Not loading anymore
  expect(result.current[2]).toBe(false)
})

test("should refresh", async () => {
  FetchMock.mockOnce("192.168.1.666")
  const { result, waitFor } = renderHook(() => useInternetAddress())
  await waitFor(() => expect(result.current[0]).toBe("192.168.1.666"))

  FetchMock.mockOnce("192.168.1.667")
  await act(() => result.current[1]())
  await waitFor(() => expect(result.current[0]).toBe("192.168.1.667"))
})

test("IP can be error object", async () => {
  FetchMock.mockRejectOnce(new Error("Network error"))
  const { result, waitForNextUpdate } = renderHook(() => useInternetAddress())
  await waitForNextUpdate()
  expect(result.current[0]).toEqual(new Error("Fehler"))
})

Without the fake timers all tests fail (with timeout) except the first one (which sets the cache for the first time).
Running each test individually each runs just fine.

Questions

1. Why does cache.clear not reset deduplication for all cache keys?
2. What is the best way to setup swr for testing?