tempo.ts 0.12.0 → 0.13.0

package/src/wagmi/Hooks/policy.test.ts

@@ -1,665 +0,0 @@
-import type { Address } from 'viem'
-import { describe, expect, test, vi } from 'vitest'
-import { useConnect } from 'wagmi'
-import { accounts } from '../../../test/viem/config.js'
-import { config, queryClient, renderHook } from '../../../test/wagmi/config.js'
-import * as Actions from '../Actions/policy.js'
-import * as hooks from './policy.js'
-
-const account = accounts[0]
-const account2 = accounts[1]
-
-describe('useCreate', () => {
-  test('default', async () => {
-    const { result } = await renderHook(() => ({
-      connect: useConnect(),
-      createSync: hooks.useCreateSync(),
-    }))
-
-    await result.current.connect.connectAsync({
-      connector: config.connectors[0]!,
-    })
-
-    // create whitelist policy
-    const { receipt, ...createResult } =
-      await result.current.createSync.mutateAsync({
-        type: 'whitelist',
-      })
-    expect(receipt).toBeDefined()
-    expect(createResult).toMatchInlineSnapshot(`
-      {
-        "policyId": 2n,
-        "policyType": 0,
-        "updater": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
-      }
-    `)
-
-    const { policyId } = createResult
-
-    // verify policy was created
-    const data = await Actions.getData(config, {
-      policyId,
-    })
-    expect(data.admin).toBe(account.address)
-    expect(data.type).toBe('whitelist')
-  })
-
-  test('behavior: blacklist', async () => {
-    const { result } = await renderHook(() => ({
-      connect: useConnect(),
-      createSync: hooks.useCreateSync(),
-    }))
-
-    await result.current.connect.connectAsync({
-      connector: config.connectors[0]!,
-    })
-
-    // create blacklist policy
-    const { receipt: blacklistReceipt, ...blacklistResult } =
-      await result.current.createSync.mutateAsync({
-        type: 'blacklist',
-      })
-    expect(blacklistReceipt).toBeDefined()
-    expect(blacklistResult).toMatchInlineSnapshot(`
-      {
-        "policyId": 3n,
-        "policyType": 1,
-        "updater": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
-      }
-    `)
-
-    const { policyId } = blacklistResult
-
-    // verify policy was created
-    const data = await Actions.getData(config, {
-      policyId,
-    })
-    expect(data.admin).toBe(account.address)
-    expect(data.type).toBe('blacklist')
-  })
-})
-
-describe('useSetAdmin', () => {
-  test('default', async () => {
-    const { result } = await renderHook(() => ({
-      connect: useConnect(),
-      createSync: hooks.useCreateSync(),
-      setAdminSync: hooks.useSetAdminSync(),
-    }))
-
-    await result.current.connect.connectAsync({
-      connector: config.connectors[0]!,
-    })
-
-    // create policy
-    const { policyId } = await result.current.createSync.mutateAsync({
-      type: 'whitelist',
-    })
-
-    // set new admin
-    const { receipt: setAdminReceipt, ...setAdminResult } =
-      await result.current.setAdminSync.mutateAsync({
-        policyId,
-        admin: account2.address,
-      })
-    expect(setAdminReceipt).toBeDefined()
-    expect(setAdminResult).toMatchInlineSnapshot(`
-      {
-        "admin": "0x8C8d35429F74ec245F8Ef2f4Fd1e551cFF97d650",
-        "policyId": 4n,
-        "updater": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
-      }
-    `)
-
-    {
-      // verify new admin
-      const data = await Actions.getData(config, { policyId })
-      expect(data.admin).toBe(account2.address)
-    }
-  })
-})
-
-describe('useModifyWhitelist', () => {
-  test('default', async () => {
-    const { result } = await renderHook(() => ({
-      connect: useConnect(),
-      createSync: hooks.useCreateSync(),
-      modifyWhitelistSync: hooks.useModifyWhitelistSync(),
-    }))
-
-    await result.current.connect.connectAsync({
-      connector: config.connectors[0]!,
-    })
-
-    // create whitelist policy
-    const { policyId } = await result.current.createSync.mutateAsync({
-      type: 'whitelist',
-    })
-
-    // verify account2 is not authorized
-    {
-      const isAuthorized = await Actions.isAuthorized(config, {
-        policyId,
-        user: account2.address,
-      })
-      expect(isAuthorized).toBe(false)
-    }
-
-    // add account2 to whitelist
-    const { receipt: addReceipt, ...addResult } =
-      await result.current.modifyWhitelistSync.mutateAsync({
-        policyId,
-        address: account2.address,
-        allowed: true,
-      })
-    expect(addReceipt).toBeDefined()
-    expect(addResult).toMatchInlineSnapshot(`
-      {
-        "account": "0x8C8d35429F74ec245F8Ef2f4Fd1e551cFF97d650",
-        "allowed": true,
-        "policyId": 5n,
-        "updater": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
-      }
-    `)
-
-    // verify account2 is authorized
-    {
-      const isAuthorized = await Actions.isAuthorized(config, {
-        policyId,
-        user: account2.address,
-      })
-      expect(isAuthorized).toBe(true)
-    }
-
-    // remove account2 from whitelist
-    const { receipt: removeReceipt, ...removeResult } =
-      await result.current.modifyWhitelistSync.mutateAsync({
-        policyId,
-        address: account2.address,
-        allowed: false,
-      })
-    expect(removeReceipt).toBeDefined()
-    expect(removeResult).toMatchInlineSnapshot(`
-      {
-        "account": "0x8C8d35429F74ec245F8Ef2f4Fd1e551cFF97d650",
-        "allowed": false,
-        "policyId": 5n,
-        "updater": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
-      }
-    `)
-
-    // verify account2 is no longer authorized
-    {
-      const isAuthorized = await Actions.isAuthorized(config, {
-        policyId,
-        user: account2.address,
-      })
-      expect(isAuthorized).toBe(false)
-    }
-  })
-})
-
-describe('useModifyBlacklist', () => {
-  test('default', async () => {
-    const { result } = await renderHook(() => ({
-      connect: useConnect(),
-      createSync: hooks.useCreateSync(),
-      modifyBlacklistSync: hooks.useModifyBlacklistSync(),
-    }))
-
-    await result.current.connect.connectAsync({
-      connector: config.connectors[0]!,
-    })
-
-    // create blacklist policy
-    const { policyId } = await result.current.createSync.mutateAsync({
-      type: 'blacklist',
-    })
-
-    // verify account2 is authorized (not blacklisted)
-    {
-      const isAuthorized = await Actions.isAuthorized(config, {
-        policyId,
-        user: account2.address,
-      })
-      expect(isAuthorized).toBe(true)
-    }
-
-    // add account2 to blacklist
-    const { receipt: addBlacklistReceipt, ...addBlacklistResult } =
-      await result.current.modifyBlacklistSync.mutateAsync({
-        policyId,
-        address: account2.address,
-        restricted: true,
-      })
-    expect(addBlacklistReceipt).toBeDefined()
-    expect(addBlacklistResult).toMatchInlineSnapshot(`
-      {
-        "account": "0x8C8d35429F74ec245F8Ef2f4Fd1e551cFF97d650",
-        "policyId": 6n,
-        "restricted": true,
-        "updater": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
-      }
-    `)
-
-    // verify account2 is not authorized (blacklisted)
-    {
-      const isAuthorized = await Actions.isAuthorized(config, {
-        policyId,
-        user: account2.address,
-      })
-      expect(isAuthorized).toBe(false)
-    }
-
-    // remove account2 from blacklist
-    const removeResult = await result.current.modifyBlacklistSync.mutateAsync({
-      policyId,
-      address: account2.address,
-      restricted: false,
-    })
-
-    expect(removeResult.receipt).toBeDefined()
-    expect(removeResult.policyId).toBe(policyId)
-    expect(removeResult.account).toBe(account2.address)
-    expect(removeResult.restricted).toBe(false)
-    expect(removeResult.updater).toBe(account.address)
-
-    // verify account2 is authorized again
-    {
-      const isAuthorized = await Actions.isAuthorized(config, {
-        policyId,
-        user: account2.address,
-      })
-      expect(isAuthorized).toBe(true)
-    }
-  })
-})
-
-describe('useGetData', () => {
-  test('default', async () => {
-    const { result: setupResult } = await renderHook(() => ({
-      connect: useConnect(),
-      createSync: hooks.useCreateSync(),
-    }))
-
-    await setupResult.current.connect.connectAsync({
-      connector: config.connectors[0]!,
-    })
-
-    // create policy
-    const { policyId } = await setupResult.current.createSync.mutateAsync({
-      type: 'whitelist',
-    })
-
-    {
-      // get policy data
-      const { result } = await renderHook(() => hooks.useGetData({ policyId }))
-
-      await vi.waitFor(() => expect(result.current.isSuccess).toBeTruthy())
-
-      expect(result.current.data?.admin).toBe(account.address)
-      expect(result.current.data?.type).toBe('whitelist')
-    }
-  })
-
-  test('behavior: blacklist', async () => {
-    const { result: setupResult } = await renderHook(() => ({
-      connect: useConnect(),
-      createSync: hooks.useCreateSync(),
-    }))
-
-    await setupResult.current.connect.connectAsync({
-      connector: config.connectors[0]!,
-    })
-
-    // create blacklist policy
-    const { policyId } = await setupResult.current.createSync.mutateAsync({
-      type: 'blacklist',
-    })
-
-    {
-      // get policy data
-      const { result } = await renderHook(() => hooks.useGetData({ policyId }))
-
-      await vi.waitFor(() => expect(result.current.isSuccess).toBeTruthy())
-
-      expect(result.current.data?.admin).toBe(account.address)
-      expect(result.current.data?.type).toBe('blacklist')
-    }
-  })
-
-  test('reactivity: policyId parameter', async () => {
-    const { result: setupResult } = await renderHook(() => ({
-      connect: useConnect(),
-      createSync: hooks.useCreateSync(),
-    }))
-
-    await setupResult.current.connect.connectAsync({
-      connector: config.connectors[0]!,
-    })
-
-    // Create policy
-    const { policyId } = await setupResult.current.createSync.mutateAsync({
-      type: 'whitelist',
-    })
-
-    // Query with undefined policyId initially
-    const { result, rerender } = await renderHook(
-      (props) => hooks.useGetData({ policyId: props?.policyId }),
-      { initialProps: { policyId: undefined as bigint | undefined } },
-    )
-
-    await vi.waitFor(() => result.current.fetchStatus === 'fetching')
-
-    // Should be disabled when policyId is undefined
-    expect(result.current.data).toBeUndefined()
-    expect(result.current.isPending).toBe(true)
-    expect(result.current.isEnabled).toBe(false)
-
-    // Set policyId
-    rerender({ policyId })
-
-    await vi.waitFor(() => expect(result.current.isSuccess).toBeTruthy())
-
-    // Should now be enabled and have data
-    expect(result.current.isEnabled).toBe(true)
-    expect(result.current.data?.admin).toBe(account.address)
-    expect(result.current.data?.type).toBe('whitelist')
-  })
-
-  describe('queryOptions', () => {
-    test('default', async () => {
-      const { result: setupResult } = await renderHook(() => ({
-        connect: useConnect(),
-        createSync: hooks.useCreateSync(),
-      }))
-
-      await setupResult.current.connect.connectAsync({
-        connector: config.connectors[0]!,
-      })
-
-      // create policy
-      const { policyId } = await setupResult.current.createSync.mutateAsync({
-        type: 'whitelist',
-      })
-
-      const options = Actions.getData.queryOptions(config, { policyId })
-      const data = await queryClient.fetchQuery(options)
-
-      expect(data.admin).toBe(account.address)
-      expect(data.type).toBe('whitelist')
-    })
-  })
-})
-
-describe('useIsAuthorized', () => {
-  test('special policy: always-reject (policyId 0)', async () => {
-    const { result } = await renderHook(() =>
-      hooks.useIsAuthorized({
-        policyId: 0n,
-        user: account.address,
-      }),
-    )
-
-    await vi.waitFor(() => expect(result.current.isSuccess).toBeTruthy())
-
-    expect(result.current.data).toBe(false)
-  })
-
-  test('special policy: always-allow (policyId 1)', async () => {
-    const { result } = await renderHook(() =>
-      hooks.useIsAuthorized({
-        policyId: 1n,
-        user: account.address,
-      }),
-    )
-
-    await vi.waitFor(() => expect(result.current.isSuccess).toBeTruthy())
-
-    expect(result.current.data).toBe(true)
-  })
-
-  test('reactivity: policyId and user parameters', async () => {
-    const { result: setupResult } = await renderHook(() => ({
-      connect: useConnect(),
-      createSync: hooks.useCreateSync(),
-      modifyWhitelistSync: hooks.useModifyWhitelistSync(),
-    }))
-
-    await setupResult.current.connect.connectAsync({
-      connector: config.connectors[0]!,
-    })
-
-    // Create whitelist policy
-    const { policyId } = await setupResult.current.createSync.mutateAsync({
-      type: 'whitelist',
-    })
-
-    // Add account2 to whitelist
-    await setupResult.current.modifyWhitelistSync.mutateAsync({
-      policyId,
-      address: account2.address,
-      allowed: true,
-    })
-
-    // Query with undefined parameters initially
-    const { result, rerender } = await renderHook(
-      (props) =>
-        hooks.useIsAuthorized({
-          policyId: props?.policyId,
-          user: props?.user,
-        }),
-      {
-        initialProps: {
-          policyId: undefined as bigint | undefined,
-          user: undefined as Address | undefined,
-        },
-      },
-    )
-
-    await vi.waitFor(() => result.current.fetchStatus === 'fetching')
-
-    // Should be disabled when parameters are undefined
-    expect(result.current.data).toBeUndefined()
-    expect(result.current.isPending).toBe(true)
-    expect(result.current.isEnabled).toBe(false)
-
-    // Set parameters
-    rerender({ policyId, user: account2.address })
-
-    await vi.waitFor(() => expect(result.current.isSuccess).toBeTruthy())
-
-    // Should now be enabled and have data
-    expect(result.current.isEnabled).toBe(true)
-    expect(result.current.data).toBe(true)
-  })
-
-  describe('queryOptions', () => {
-    test('default', async () => {
-      const options = Actions.isAuthorized.queryOptions(config, {
-        policyId: 1n,
-        user: account.address,
-      })
-      const isAuthorized = await queryClient.fetchQuery(options)
-
-      expect(isAuthorized).toBe(true)
-    })
-  })
-})
-
-describe('useWatchCreate', () => {
-  test('default', async () => {
-    const { result: connectResult } = await renderHook(() => ({
-      connect: useConnect(),
-      createSync: hooks.useCreateSync(),
-    }))
-
-    await connectResult.current.connect.connectAsync({
-      connector: config.connectors[0]!,
-    })
-
-    const events: any[] = []
-    await renderHook(() =>
-      hooks.useWatchCreate({
-        onPolicyCreated(args) {
-          events.push(args)
-        },
-      }),
-    )
-
-    // Create policy
-    await connectResult.current.createSync.mutateAsync({
-      type: 'whitelist',
-    })
-
-    await vi.waitUntil(() => events.length >= 1)
-
-    expect(events.length).toBeGreaterThanOrEqual(1)
-    expect(events[0]?.policyId).toBeDefined()
-    expect(events[0]?.updater).toBe(account.address)
-    expect(events[0]?.type).toBe('whitelist')
-  })
-})
-
-describe('useWatchAdminUpdated', () => {
-  test('default', async () => {
-    const { result: connectResult } = await renderHook(() => ({
-      connect: useConnect(),
-      createSync: hooks.useCreateSync(),
-      setAdminSync: hooks.useSetAdminSync(),
-    }))
-
-    await connectResult.current.connect.connectAsync({
-      connector: config.connectors[0]!,
-    })
-
-    // Create policy
-    const { policyId } = await connectResult.current.createSync.mutateAsync({
-      type: 'whitelist',
-    })
-
-    const events: any[] = []
-    await renderHook(() =>
-      hooks.useWatchAdminUpdated({
-        onAdminUpdated(args) {
-          events.push(args)
-        },
-      }),
-    )
-
-    // Set new admin
-    await connectResult.current.setAdminSync.mutateAsync({
-      policyId,
-      admin: account2.address,
-    })
-
-    await vi.waitUntil(() => events.length >= 1)
-
-    expect(events.length).toBeGreaterThanOrEqual(1)
-    expect(events[0]?.policyId).toBe(policyId)
-    expect(events[0]?.updater).toBe(account.address)
-    expect(events[0]?.admin).toBe(account2.address)
-  })
-})
-
-describe('useWatchWhitelistUpdated', () => {
-  test('default', async () => {
-    const { result: connectResult } = await renderHook(() => ({
-      connect: useConnect(),
-      createSync: hooks.useCreateSync(),
-      modifyWhitelistSync: hooks.useModifyWhitelistSync(),
-    }))
-
-    await connectResult.current.connect.connectAsync({
-      connector: config.connectors[0]!,
-    })
-
-    // Create whitelist policy
-    const { policyId } = await connectResult.current.createSync.mutateAsync({
-      type: 'whitelist',
-    })
-
-    const events: any[] = []
-    await renderHook(() =>
-      hooks.useWatchWhitelistUpdated({
-        onWhitelistUpdated(args) {
-          events.push(args)
-        },
-      }),
-    )
-
-    // Add address to whitelist
-    await connectResult.current.modifyWhitelistSync.mutateAsync({
-      policyId,
-      address: account2.address,
-      allowed: true,
-    })
-
-    // Remove address from whitelist
-    await connectResult.current.modifyWhitelistSync.mutateAsync({
-      policyId,
-      address: account2.address,
-      allowed: false,
-    })
-
-    await vi.waitUntil(() => events.length >= 2)
-
-    expect(events.length).toBeGreaterThanOrEqual(2)
-    expect(events[0]?.policyId).toBe(policyId)
-    expect(events[0]?.updater).toBe(account.address)
-    expect(events[0]?.account).toBe(account2.address)
-    expect(events[0]?.allowed).toBe(true)
-    expect(events[1]?.allowed).toBe(false)
-  })
-})
-
-describe('useWatchBlacklistUpdated', () => {
-  test('default', async () => {
-    const { result: connectResult } = await renderHook(() => ({
-      connect: useConnect(),
-      createSync: hooks.useCreateSync(),
-      modifyBlacklistSync: hooks.useModifyBlacklistSync(),
-    }))
-
-    await connectResult.current.connect.connectAsync({
-      connector: config.connectors[0]!,
-    })
-
-    // Create blacklist policy
-    const { policyId } = await connectResult.current.createSync.mutateAsync({
-      type: 'blacklist',
-    })
-
-    const events: any[] = []
-    await renderHook(() =>
-      hooks.useWatchBlacklistUpdated({
-        onBlacklistUpdated(args) {
-          events.push(args)
-        },
-      }),
-    )
-
-    // Add address to blacklist
-    await connectResult.current.modifyBlacklistSync.mutateAsync({
-      policyId,
-      address: account2.address,
-      restricted: true,
-    })
-
-    // Remove address from blacklist
-    await connectResult.current.modifyBlacklistSync.mutateAsync({
-      policyId,
-      address: account2.address,
-      restricted: false,
-    })
-
-    await vi.waitUntil(() => events.length >= 2)
-
-    expect(events.length).toBeGreaterThanOrEqual(2)
-    expect(events[0]?.policyId).toBe(policyId)
-    expect(events[0]?.updater).toBe(account.address)
-    expect(events[0]?.account).toBe(account2.address)
-    expect(events[0]?.restricted).toBe(true)
-    expect(events[1]?.restricted).toBe(false)
-  })
-})