chore(ui): enable vitest lint rules

spinifex/services/spinifexui/frontend/oxlint.config.ts

@@ -2,9 +2,10 @@ import { defineConfig } from "oxlint"
 import core from "ultracite/oxlint/core"
 import react from "ultracite/oxlint/react"
 import remix from "ultracite/oxlint/remix"
+import vitest from "ultracite/oxlint/vitest"
 
 export default defineConfig({
-  extends: [core, react, remix],
+  extends: [core, react, remix, vitest],
   jsPlugins: [
     "@tanstack/eslint-plugin-query",
     "@tanstack/eslint-plugin-router",
@@ -65,6 +66,7 @@ export default defineConfig({
         "**/*.{test,spec}.{ts,tsx,js,jsx}",
         "**/__tests__/**/*.{ts,tsx,js,jsx}",
       ],
+      plugins: ["vitest"],
       rules: {
         "eslint/require-await": "off",
         "import/first": "off",
@@ -74,6 +76,11 @@ export default defineConfig({
         "typescript/no-unsafe-member-access": "off",
         "typescript/no-unsafe-type-assertion": "off",
         "unicorn/no-useless-undefined": "off",
+        "vitest/max-expects": "off",
+        "vitest/prefer-called-with": "off",
+        "vitest/prefer-describe-function-title": "off",
+        "vitest/prefer-import-in-mock": "off",
+        "vitest/require-mock-type-parameters": "off",
       },
     },
   ],

spinifex/services/spinifexui/frontend/package.json

@@ -6,7 +6,7 @@
     "dev": "vite --port 3000",
     "build": "vite build",
     "preview": "vite preview",
-    "check": "oxlint; oxfmt --check",
+    "lint": "oxlint; oxfmt --check",
     "fix": "oxlint --fix; oxfmt",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",

spinifex/services/spinifexui/frontend/src/components/elbv2/attributes-editor.test.tsx

@@ -156,7 +156,7 @@ describe("AttributesEditor", () => {
     expect(lbKeys).toContain("connection_logs.s3.prefix")
 
     const tgKeys = targetGroupAttributeSpecs.map((s) => s.key)
-    expect(tgKeys).toEqual([
+    expect(tgKeys).toStrictEqual([
       "deregistration_delay.timeout_seconds",
       "stickiness.enabled",
       "stickiness.type",

spinifex/services/spinifexui/frontend/src/components/elbv2/listeners-tab.test.tsx

@@ -49,11 +49,11 @@ function seedClient(opts: {
   return queryClient
 }
 
-afterEach(() => {
-  mockSend.mockReset()
-})
-
 describe("ListenersTab", () => {
+  afterEach(() => {
+    mockSend.mockReset()
+  })
+
   it("renders empty state and delete-note when no listeners", () => {
     const queryClient = seedClient({})
     render(<ListenersTab loadBalancerArn={LB_ARN} vpcId="vpc-aaa" />, {
@@ -128,7 +128,7 @@ describe("ListenersTab", () => {
       expect(mockSend.mock.calls.length).toBeGreaterThan(before),
     )
     const call = mockSend.mock.calls[before]?.[0]
-    expect(call.input).toEqual({ ListenerArn: "arn:listener/1" })
+    expect(call.input).toStrictEqual({ ListenerArn: "arn:listener/1" })
   })
 
   it("filters target groups by vpcId in the add-listener dialog", async () => {
@@ -158,7 +158,7 @@ describe("ListenersTab", () => {
     })
     await user.click(screen.getByRole("button", { name: "Add listener" }))
     await user.click(screen.getByLabelText("Default target group"))
-    expect(await screen.findByText(/tg-in-vpc/)).toBeInTheDocument()
+    await expect(screen.findByText(/tg-in-vpc/)).resolves.toBeInTheDocument()
     expect(screen.queryByText(/tg-other-vpc/)).not.toBeInTheDocument()
   })
 
@@ -190,7 +190,7 @@ describe("ListenersTab", () => {
       expect(mockSend.mock.calls.length).toBeGreaterThan(before),
     )
     const call = mockSend.mock.calls[before]?.[0]
-    expect(call.input).toEqual({
+    expect(call.input).toStrictEqual({
       LoadBalancerArn: LB_ARN,
       Protocol: "HTTP",
       Port: 80,

spinifex/services/spinifexui/frontend/src/components/elbv2/targets-tab.test.tsx

@@ -48,11 +48,11 @@ function seedClient(opts: {
   return queryClient
 }
 
-afterEach(() => {
-  mockSend.mockReset()
-})
-
 describe("TargetsTab", () => {
+  afterEach(() => {
+    mockSend.mockReset()
+  })
+
   it("renders empty state when no targets registered", () => {
     const queryClient = seedClient({})
     render(
@@ -134,7 +134,7 @@ describe("TargetsTab", () => {
       expect(mockSend.mock.calls.length).toBeGreaterThan(deregCallsBefore),
     )
     const deregCall = mockSend.mock.calls[deregCallsBefore]?.[0]
-    expect(deregCall.input).toEqual({
+    expect(deregCall.input).toStrictEqual({
       TargetGroupArn: TG_ARN,
       Targets: [{ Id: "i-aaa", Port: 80 }],
     })

spinifex/services/spinifexui/frontend/src/components/theme-provider.test.tsx

@@ -8,16 +8,18 @@ function wrapper({ children }: { children: ReactNode }) {
   return <ThemeProvider defaultTheme="light">{children}</ThemeProvider>
 }
 
-beforeEach(() => {
+function setupThemeEnv() {
   localStorage.clear()
   document.documentElement.classList.remove("light", "dark")
   Object.defineProperty(window, "matchMedia", {
     writable: true,
     value: vi.fn().mockReturnValue({ matches: false }),
   })
-})
+}
 
 describe("ThemeProvider", () => {
+  beforeEach(setupThemeEnv)
+
   it("renders children", () => {
     render(
       <ThemeProvider>
@@ -33,7 +35,7 @@ describe("ThemeProvider", () => {
         <p>Test</p>
       </ThemeProvider>,
     )
-    expect(document.documentElement.classList.contains("light")).toBe(true)
+    expect(document.documentElement.classList.contains("light")).toBeTruthy()
   })
 
   it("applies dark class to documentElement", () => {
@@ -42,7 +44,7 @@ describe("ThemeProvider", () => {
         <p>Test</p>
       </ThemeProvider>,
     )
-    expect(document.documentElement.classList.contains("dark")).toBe(true)
+    expect(document.documentElement.classList.contains("dark")).toBeTruthy()
   })
 
   it("uses system theme when set to system", () => {
@@ -55,7 +57,7 @@ describe("ThemeProvider", () => {
         <p>Test</p>
       </ThemeProvider>,
     )
-    expect(document.documentElement.classList.contains("dark")).toBe(true)
+    expect(document.documentElement.classList.contains("dark")).toBeTruthy()
   })
 
   it("reads stored theme from localStorage", () => {
@@ -65,7 +67,7 @@ describe("ThemeProvider", () => {
         <p>Test</p>
       </ThemeProvider>,
     )
-    expect(document.documentElement.classList.contains("dark")).toBe(true)
+    expect(document.documentElement.classList.contains("dark")).toBeTruthy()
   })
 
   it("ignores invalid stored theme", () => {
@@ -75,7 +77,7 @@ describe("ThemeProvider", () => {
         <p>Test</p>
       </ThemeProvider>,
     )
-    expect(document.documentElement.classList.contains("light")).toBe(true)
+    expect(document.documentElement.classList.contains("light")).toBeTruthy()
   })
 
   it("uses custom storageKey", () => {
@@ -85,11 +87,13 @@ describe("ThemeProvider", () => {
         <p>Test</p>
       </ThemeProvider>,
     )
-    expect(document.documentElement.classList.contains("dark")).toBe(true)
+    expect(document.documentElement.classList.contains("dark")).toBeTruthy()
   })
 })
 
 describe("useTheme", () => {
+  beforeEach(setupThemeEnv)
+
   it("throws when used outside ThemeProvider", () => {
     expect(() => renderHook(() => useTheme())).toThrow(
       "useTheme must be used within a ThemeProvider",
@@ -114,13 +118,13 @@ describe("useTheme", () => {
 
   it("removes previous class when theme changes", () => {
     const { result } = renderHook(() => useTheme(), { wrapper })
-    expect(document.documentElement.classList.contains("light")).toBe(true)
+    expect(document.documentElement.classList.contains("light")).toBeTruthy()
 
     act(() => {
       result.current.setTheme("dark")
     })
 
-    expect(document.documentElement.classList.contains("dark")).toBe(true)
-    expect(document.documentElement.classList.contains("light")).toBe(false)
+    expect(document.documentElement.classList.contains("dark")).toBeTruthy()
+    expect(document.documentElement.classList.contains("light")).toBeFalsy()
   })
 })

spinifex/services/spinifexui/frontend/src/hooks/use-copy-to-clipboard.test.tsx

@@ -3,23 +3,23 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
 
 import { useCopyToClipboard } from "./use-copy-to-clipboard"
 
-beforeEach(() => {
-  vi.useFakeTimers()
-  Object.defineProperty(navigator, "clipboard", {
-    value: { writeText: vi.fn().mockResolvedValue(undefined) },
-    writable: true,
-    configurable: true,
-  })
-})
-
-afterEach(() => {
-  vi.useRealTimers()
-})
-
 describe("useCopyToClipboard", () => {
+  beforeEach(() => {
+    vi.useFakeTimers()
+    Object.defineProperty(navigator, "clipboard", {
+      value: { writeText: vi.fn().mockResolvedValue(undefined) },
+      writable: true,
+      configurable: true,
+    })
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
   it("starts with copied as false", () => {
     const { result } = renderHook(() => useCopyToClipboard())
-    expect(result.current.copied).toBe(false)
+    expect(result.current.copied).toBeFalsy()
   })
 
   it("sets copied to true after calling copy", async () => {
@@ -31,7 +31,7 @@ describe("useCopyToClipboard", () => {
 
     // oxlint-disable-next-line typescript/unbound-method -- vitest mock
     expect(navigator.clipboard.writeText).toHaveBeenCalledWith("hello")
-    expect(result.current.copied).toBe(true)
+    expect(result.current.copied).toBeTruthy()
   })
 
   it("resets copied to false after 2 seconds", async () => {
@@ -40,12 +40,12 @@ describe("useCopyToClipboard", () => {
     await act(async () => {
       await result.current.copy("hello")
     })
-    expect(result.current.copied).toBe(true)
+    expect(result.current.copied).toBeTruthy()
 
     act(() => {
       vi.advanceTimersByTime(2000)
     })
-    expect(result.current.copied).toBe(false)
+    expect(result.current.copied).toBeFalsy()
   })
 
   it("resets the timer on rapid successive copies", async () => {
@@ -59,7 +59,7 @@ describe("useCopyToClipboard", () => {
     act(() => {
       vi.advanceTimersByTime(1500)
     })
-    expect(result.current.copied).toBe(true)
+    expect(result.current.copied).toBeTruthy()
 
     await act(async () => {
       await result.current.copy("second")
@@ -69,13 +69,13 @@ describe("useCopyToClipboard", () => {
     act(() => {
       vi.advanceTimersByTime(1500)
     })
-    expect(result.current.copied).toBe(true)
+    expect(result.current.copied).toBeTruthy()
 
     // 2s after second copy — should reset
     act(() => {
       vi.advanceTimersByTime(500)
     })
-    expect(result.current.copied).toBe(false)
+    expect(result.current.copied).toBeFalsy()
   })
 
   it("clears the timer on unmount", async () => {
@@ -87,9 +87,10 @@ describe("useCopyToClipboard", () => {
 
     unmount()
 
-    // Advancing time after unmount should not throw
-    act(() => {
-      vi.advanceTimersByTime(2000)
-    })
+    expect(() => {
+      act(() => {
+        vi.advanceTimersByTime(2000)
+      })
+    }).not.toThrow()
   })
 })

spinifex/services/spinifexui/frontend/src/hooks/use-initial-sidebar.test.tsx

@@ -26,10 +26,10 @@ describe("useInitialSidebar", () => {
       ({ isOpen }: { isOpen: boolean }) => useInitialSidebar(isOpen),
       { initialProps: { isOpen: true } },
     )
-    expect(mockSetOpen).toHaveBeenCalledTimes(1)
+    expect(mockSetOpen).toHaveBeenCalledOnce()
 
     rerender({ isOpen: false })
     // Should still only have been called once (the initial mount)
-    expect(mockSetOpen).toHaveBeenCalledTimes(1)
+    expect(mockSetOpen).toHaveBeenCalledOnce()
   })
 })

spinifex/services/spinifexui/frontend/src/hooks/use-mobile.test.tsx

@@ -19,28 +19,28 @@ function mockMatchMedia(matches: boolean) {
   })
 }
 
-beforeEach(() => {
-  vi.resetModules()
-  changeListener = null
-})
-
-afterEach(() => {
-  changeListener = null
-})
-
 describe("useIsMobile", () => {
+  beforeEach(() => {
+    vi.resetModules()
+    changeListener = null
+  })
+
+  afterEach(() => {
+    changeListener = null
+  })
+
   it("returns false on desktop viewport", async () => {
     mockMatchMedia(false)
     const { useIsMobile } = await import("./use-mobile")
     const { result } = renderHook(() => useIsMobile())
-    expect(result.current).toBe(false)
+    expect(result.current).toBeFalsy()
   })
 
   it("returns true on mobile viewport", async () => {
     mockMatchMedia(true)
     const { useIsMobile } = await import("./use-mobile")
     const { result } = renderHook(() => useIsMobile())
-    expect(result.current).toBe(true)
+    expect(result.current).toBeTruthy()
   })
 
   it("updates when viewport changes", async () => {
@@ -62,14 +62,14 @@ describe("useIsMobile", () => {
 
     const { useIsMobile } = await import("./use-mobile")
     const { result } = renderHook(() => useIsMobile())
-    expect(result.current).toBe(false)
+    expect(result.current).toBeFalsy()
 
     // Simulate viewport shrink
     mqlMock.matches = true
     act(() => {
       changeListener?.()
     })
-    expect(result.current).toBe(true)
+    expect(result.current).toBeTruthy()
   })
 
   it("cleans up listener on unmount", async () => {

spinifex/services/spinifexui/frontend/src/lib/auth.test.ts

@@ -11,35 +11,40 @@ let getCredentials: typeof import("./auth").getCredentials
 let setCredentials: typeof import("./auth").setCredentials
 let clearCredentials: typeof import("./auth").clearCredentials
 
-beforeEach(async () => {
-  // Reset module to get a fresh in-memory cache for each test
+async function loadAuth() {
   vi.resetModules()
   const auth = await import("./auth")
   getCredentials = auth.getCredentials
   setCredentials = auth.setCredentials
   clearCredentials = auth.clearCredentials
-})
-
-afterEach(() => {
-  localStorage.clear()
-})
+}
 
 describe("setCredentials", () => {
+  beforeEach(loadAuth)
+  afterEach(() => {
+    localStorage.clear()
+  })
+
   it("stores credentials in localStorage", () => {
     setCredentials(validCreds)
     const stored = localStorage.getItem("spinifex:v1:aws-credentials")
-    expect(JSON.parse(stored ?? "")).toEqual(validCreds)
+    expect(JSON.parse(stored ?? "")).toStrictEqual(validCreds)
   })
 
   it("caches credentials in memory", () => {
     setCredentials(validCreds)
     // Clear localStorage to prove it reads from cache
     localStorage.clear()
-    expect(getCredentials()).toEqual(validCreds)
+    expect(getCredentials()).toStrictEqual(validCreds)
   })
 })
 
 describe("getCredentials", () => {
+  beforeEach(loadAuth)
+  afterEach(() => {
+    localStorage.clear()
+  })
+
   it("returns null when nothing is stored", () => {
     expect(getCredentials()).toBeNull()
   })
@@ -49,15 +54,15 @@ describe("getCredentials", () => {
       "spinifex:v1:aws-credentials",
       JSON.stringify(validCreds),
     )
-    expect(getCredentials()).toEqual(validCreds)
+    expect(getCredentials()).toStrictEqual(validCreds)
   })
 
   it("returns cached value on subsequent calls", () => {
     setCredentials(validCreds)
     localStorage.clear()
     // Should still return from cache
-    expect(getCredentials()).toEqual(validCreds)
-    expect(getCredentials()).toEqual(validCreds)
+    expect(getCredentials()).toStrictEqual(validCreds)
+    expect(getCredentials()).toStrictEqual(validCreds)
   })
 
   it("returns null for invalid JSON in localStorage", () => {
@@ -83,6 +88,11 @@ describe("getCredentials", () => {
 })
 
 describe("clearCredentials", () => {
+  beforeEach(loadAuth)
+  afterEach(() => {
+    localStorage.clear()
+  })
+
   it("removes credentials from localStorage", () => {
     setCredentials(validCreds)
     clearCredentials()

spinifex/services/spinifexui/frontend/src/lib/subnet-calculator.test.ts

@@ -88,54 +88,54 @@ describe("calculateSubnetCidrs", () => {
 
 describe("cidrsOverlap", () => {
   it("detects overlapping CIDRs", () => {
-    expect(cidrsOverlap("10.0.0.0/20", "10.0.8.0/24")).toBe(true)
+    expect(cidrsOverlap("10.0.0.0/20", "10.0.8.0/24")).toBeTruthy()
   })
 
   it("returns false for non-overlapping CIDRs", () => {
-    expect(cidrsOverlap("10.0.0.0/20", "10.0.128.0/20")).toBe(false)
+    expect(cidrsOverlap("10.0.0.0/20", "10.0.128.0/20")).toBeFalsy()
   })
 
   it("detects identical CIDRs as overlapping", () => {
-    expect(cidrsOverlap("10.0.0.0/20", "10.0.0.0/20")).toBe(true)
+    expect(cidrsOverlap("10.0.0.0/20", "10.0.0.0/20")).toBeTruthy()
   })
 })
 
 describe("cidrContains", () => {
   it("returns true when subnet fits inside VPC", () => {
-    expect(cidrContains("10.0.0.0/16", "10.0.0.0/20")).toBe(true)
+    expect(cidrContains("10.0.0.0/16", "10.0.0.0/20")).toBeTruthy()
   })
 
   it("returns false when subnet exceeds VPC range", () => {
-    expect(cidrContains("10.0.0.0/16", "10.1.0.0/20")).toBe(false)
+    expect(cidrContains("10.0.0.0/16", "10.1.0.0/20")).toBeFalsy()
   })
 
   it("returns true for VPC containing itself", () => {
-    expect(cidrContains("10.0.0.0/16", "10.0.0.0/16")).toBe(true)
+    expect(cidrContains("10.0.0.0/16", "10.0.0.0/16")).toBeTruthy()
   })
 })
 
 describe("isValidCidr", () => {
   it("accepts valid /16 CIDR", () => {
-    expect(isValidCidr("10.0.0.0/16")).toBe(true)
+    expect(isValidCidr("10.0.0.0/16")).toBeTruthy()
   })
 
   it("accepts valid /28 CIDR", () => {
-    expect(isValidCidr("10.0.0.0/28")).toBe(true)
+    expect(isValidCidr("10.0.0.0/28")).toBeTruthy()
   })
 
   it("rejects /15 (too large)", () => {
-    expect(isValidCidr("10.0.0.0/15")).toBe(false)
+    expect(isValidCidr("10.0.0.0/15")).toBeFalsy()
   })
 
   it("rejects /29 (too small)", () => {
-    expect(isValidCidr("10.0.0.0/29")).toBe(false)
+    expect(isValidCidr("10.0.0.0/29")).toBeFalsy()
   })
 
   it("rejects invalid format", () => {
-    expect(isValidCidr("not-a-cidr")).toBe(false)
+    expect(isValidCidr("not-a-cidr")).toBeFalsy()
   })
 
   it("rejects octets > 255", () => {
-    expect(isValidCidr("256.0.0.0/16")).toBe(false)
+    expect(isValidCidr("256.0.0.0/16")).toBeFalsy()
   })
 })

spinifex/services/spinifexui/frontend/src/lib/system-managed.test.ts

@@ -15,7 +15,7 @@ describe("isSystemManagedImage", () => {
       ImageId: "ami-1",
       Tags: [{ Key: SYSTEM_MANAGED_TAG_KEY, Value: "elbv2" }],
     }
-    expect(isSystemManagedImage(image)).toBe(true)
+    expect(isSystemManagedImage(image)).toBeTruthy()
   })
 
   it("returns false for customer images with unrelated tags", () => {
@@ -23,11 +23,11 @@ describe("isSystemManagedImage", () => {
       ImageId: "ami-2",
       Tags: [{ Key: "Name", Value: "my-ami" }],
     }
-    expect(isSystemManagedImage(image)).toBe(false)
+    expect(isSystemManagedImage(image)).toBeFalsy()
   })
 
   it("returns false for images with no tags", () => {
-    expect(isSystemManagedImage({ ImageId: "ami-3" })).toBe(false)
+    expect(isSystemManagedImage({ ImageId: "ami-3" })).toBeFalsy()
   })
 })
 
@@ -37,7 +37,7 @@ describe("isLbImage", () => {
       ImageId: "ami-lb",
       Tags: [{ Key: SYSTEM_MANAGED_TAG_KEY, Value: LB_MANAGED_BY_VALUE }],
     }
-    expect(isLbImage(image)).toBe(true)
+    expect(isLbImage(image)).toBeTruthy()
   })
 
   it("returns false for system-managed images owned by other components", () => {
@@ -45,11 +45,11 @@ describe("isLbImage", () => {
       ImageId: "ami-other",
       Tags: [{ Key: SYSTEM_MANAGED_TAG_KEY, Value: "other-service" }],
     }
-    expect(isLbImage(image)).toBe(false)
+    expect(isLbImage(image)).toBeFalsy()
   })
 
   it("returns false for customer images", () => {
-    expect(isLbImage({ ImageId: "ami-cust" })).toBe(false)
+    expect(isLbImage({ ImageId: "ami-cust" })).toBeFalsy()
   })
 })
 
@@ -62,17 +62,17 @@ describe("hasLbImage", () => {
         Tags: [{ Key: SYSTEM_MANAGED_TAG_KEY, Value: LB_MANAGED_BY_VALUE }],
       },
     ]
-    expect(hasLbImage(images)).toBe(true)
+    expect(hasLbImage(images)).toBeTruthy()
   })
 
   it("returns false for an empty list", () => {
-    expect(hasLbImage([])).toBe(false)
+    expect(hasLbImage([])).toBeFalsy()
   })
 
   it("returns false when no image carries the elbv2 tag", () => {
     const images: Image[] = [
       { ImageId: "ami-cust", Tags: [{ Key: "Name", Value: "ubuntu" }] },
     ]
-    expect(hasLbImage(images)).toBe(false)
+    expect(hasLbImage(images)).toBeFalsy()
   })
 })

spinifex/services/spinifexui/frontend/src/mutations/ec2.test.tsx

@@ -1,7 +1,7 @@
 import { QueryClient, QueryClientProvider } from "@tanstack/react-query"
 import { renderHook, waitFor } from "@testing-library/react"
 import type { ReactNode } from "react"
-import { afterEach, describe, expect, it, vi } from "vitest"
+import { describe, expect, it, vi } from "vitest"
 
 const mockSend = vi.fn().mockResolvedValue({})
 
@@ -54,10 +54,6 @@ function wrapper({ children }: { children: ReactNode }) {
   )
 }
 
-afterEach(() => {
-  mockSend.mockClear()
-})
-
 function createQueryClient() {
   queryClient = new QueryClient({
     defaultOptions: {
@@ -75,11 +71,11 @@ describe("useStartInstance", () => {
 
     result.current.mutate("i-abc123")
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
     expect(mockSend).toHaveBeenCalledOnce()
 
     const command = mockSend.mock.calls[0]?.[0]
-    expect(command.input).toEqual({ InstanceIds: ["i-abc123"] })
+    expect(command.input).toStrictEqual({ InstanceIds: ["i-abc123"] })
   })
 
   it("invalidates instances query on success", async () => {
@@ -89,7 +85,7 @@ describe("useStartInstance", () => {
 
     result.current.mutate("i-abc123")
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
     expect(spy).toHaveBeenCalledWith({ queryKey: ["ec2", "instances"] })
   })
 })
@@ -101,8 +97,8 @@ describe("useStopInstance", () => {
 
     result.current.mutate("i-abc123")
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       InstanceIds: ["i-abc123"],
     })
   })
@@ -115,8 +111,8 @@ describe("useTerminateInstance", () => {
 
     result.current.mutate("i-abc123")
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       InstanceIds: ["i-abc123"],
     })
   })
@@ -135,8 +131,8 @@ describe("useCreateInstance", () => {
       subnetId: "subnet-1",
     })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toMatchObject({
       ImageId: "ami-123",
       InstanceType: "t2.micro",
       KeyName: "my-key",
@@ -158,7 +154,7 @@ describe("useCreateInstance", () => {
       subnetId: "",
     })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
     expect(mockSend.mock.calls[0]?.[0].input.SubnetId).toBeUndefined()
   })
 
@@ -174,8 +170,8 @@ describe("useCreateInstance", () => {
       placementGroupName: "my-group",
     })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input.Placement).toEqual({
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input.Placement).toStrictEqual({
       GroupName: "my-group",
     })
   })
@@ -192,7 +188,7 @@ describe("useCreateInstance", () => {
       placementGroupName: "",
     })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
     expect(mockSend.mock.calls[0]?.[0].input.Placement).toBeUndefined()
   })
 
@@ -208,7 +204,7 @@ describe("useCreateInstance", () => {
       rootDeviceName: "/dev/sda1",
     })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
     expect(
       mockSend.mock.calls[0]?.[0].input.BlockDeviceMappings,
     ).toBeUndefined()
@@ -229,17 +225,19 @@ describe("useCreateInstance", () => {
       rootDeleteOnTermination: true,
     })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input.BlockDeviceMappings).toEqual([
-      {
-        DeviceName: "/dev/sda1",
-        Ebs: {
-          VolumeSize: 100,
-          VolumeType: "gp3",
-          DeleteOnTermination: true,
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input.BlockDeviceMappings).toStrictEqual(
+      [
+        {
+          DeviceName: "/dev/sda1",
+          Ebs: {
+            VolumeSize: 100,
+            VolumeType: "gp3",
+            DeleteOnTermination: true,
+          },
         },
-      },
-    ])
+      ],
+    )
   })
 
   it("includes only the storage fields the user set", async () => {
@@ -255,15 +253,17 @@ describe("useCreateInstance", () => {
       rootDeleteOnTermination: false,
     })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input.BlockDeviceMappings).toEqual([
-      {
-        DeviceName: "/dev/sda1",
-        Ebs: {
-          DeleteOnTermination: false,
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input.BlockDeviceMappings).toStrictEqual(
+      [
+        {
+          DeviceName: "/dev/sda1",
+          Ebs: {
+            DeleteOnTermination: false,
+          },
         },
-      },
-    ])
+      ],
+    )
   })
 })
 
@@ -277,7 +277,7 @@ describe("useImportKeyPair", () => {
       publicKeyMaterial: "ssh-rsa AAAAB3Nza... user@host",
     })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
     const input = mockSend.mock.calls[0]?.[0].input
     expect(input.KeyName).toBe("my-key")
 
@@ -295,7 +295,7 @@ describe("useImportKeyPair", () => {
       publicKeyMaterial: "ssh-rsa AAAAB3Nza...",
     })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
     const decoded = new TextDecoder().decode(
       mockSend.mock.calls[0]?.[0].input.PublicKeyMaterial,
     )
@@ -311,7 +311,7 @@ describe("useImportKeyPair", () => {
       publicKeyMaterial: "  ssh-rsa   AAAAB3Nza...   user@host  ",
     })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
     const decoded = new TextDecoder().decode(
       mockSend.mock.calls[0]?.[0].input.PublicKeyMaterial,
     )
@@ -326,8 +326,8 @@ describe("useRebootInstance", () => {
 
     result.current.mutate("i-abc123")
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       InstanceIds: ["i-abc123"],
     })
   })
@@ -340,8 +340,8 @@ describe("useCreateKeyPair", () => {
 
     result.current.mutate({ keyName: "my-key" })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       KeyName: "my-key",
       KeyType: "rsa",
     })
@@ -355,8 +355,8 @@ describe("useDeleteKeyPair", () => {
 
     result.current.mutate("kp-abc123")
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       KeyPairId: "kp-abc123",
     })
   })
@@ -369,8 +369,8 @@ describe("useCreateVolume", () => {
 
     result.current.mutate({ size: 100, availabilityZone: "us-east-1a" })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       Size: 100,
       AvailabilityZone: "us-east-1a",
       VolumeType: "gp3",
@@ -385,8 +385,8 @@ describe("useModifyVolume", () => {
 
     result.current.mutate({ volumeId: "vol-123", size: 200 })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       VolumeId: "vol-123",
       Size: 200,
     })
@@ -400,8 +400,8 @@ describe("useDeleteVolume", () => {
 
     result.current.mutate("vol-123")
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       VolumeId: "vol-123",
     })
   })
@@ -414,8 +414,8 @@ describe("useCreateSnapshot", () => {
 
     result.current.mutate({ volumeId: "vol-123", description: "backup" })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       VolumeId: "vol-123",
       Description: "backup",
     })
@@ -427,7 +427,7 @@ describe("useCreateSnapshot", () => {
 
     result.current.mutate({ volumeId: "vol-123", description: "" })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
     expect(mockSend.mock.calls[0]?.[0].input.Description).toBeUndefined()
   })
 })
@@ -439,8 +439,8 @@ describe("useDeleteSnapshot", () => {
 
     result.current.mutate("snap-123")
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       SnapshotId: "snap-123",
     })
   })
@@ -457,8 +457,8 @@ describe("useCopySnapshot", () => {
       description: "copy",
     })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       SourceSnapshotId: "snap-123",
       SourceRegion: "us-east-1",
       Description: "copy",
@@ -477,8 +477,8 @@ describe("useAttachVolume", () => {
       device: "/dev/sdf",
     })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       VolumeId: "vol-123",
       InstanceId: "i-abc",
       Device: "/dev/sdf",
@@ -497,8 +497,8 @@ describe("useDetachVolume", () => {
       force: true,
     })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       VolumeId: "vol-123",
       InstanceId: "i-abc",
       Force: true,
@@ -518,8 +518,8 @@ describe("useModifyInstanceAttribute", () => {
       instanceType: "t3.large",
     })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       InstanceId: "i-abc",
       InstanceType: { Value: "t3.large" },
     })
@@ -533,8 +533,8 @@ describe("useGetConsoleOutput", () => {
 
     result.current.mutate("i-abc123")
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       InstanceId: "i-abc123",
     })
   })
@@ -551,8 +551,8 @@ describe("useCreateImage", () => {
       description: "test image",
     })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       InstanceId: "i-abc",
       Name: "my-image",
       Description: "test image",
@@ -567,8 +567,8 @@ describe("useCreateVpc", () => {
 
     result.current.mutate({ cidrBlock: "10.0.0.0/16", name: "my-vpc" })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       CidrBlock: "10.0.0.0/16",
       TagSpecifications: [
         {
@@ -585,7 +585,7 @@ describe("useCreateVpc", () => {
 
     result.current.mutate({ cidrBlock: "10.0.0.0/16", name: "" })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
     expect(mockSend.mock.calls[0]?.[0].input.TagSpecifications).toBeUndefined()
   })
 })
@@ -597,8 +597,8 @@ describe("useDeleteVpc", () => {
 
     result.current.mutate("vpc-123")
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       VpcId: "vpc-123",
     })
   })
@@ -615,8 +615,8 @@ describe("useCreateSubnet", () => {
       availabilityZone: "us-east-1a",
     })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       VpcId: "vpc-123",
       CidrBlock: "10.0.1.0/24",
       AvailabilityZone: "us-east-1a",
@@ -631,8 +631,8 @@ describe("useDeleteSubnet", () => {
 
     result.current.mutate("subnet-123")
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       SubnetId: "subnet-123",
     })
   })
@@ -645,8 +645,8 @@ describe("useCreatePlacementGroup", () => {
 
     result.current.mutate({ groupName: "my-group", strategy: "spread" })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       GroupName: "my-group",
       Strategy: "spread",
     })
@@ -659,7 +659,7 @@ describe("useCreatePlacementGroup", () => {
 
     result.current.mutate({ groupName: "my-group", strategy: "cluster" })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
     expect(spy).toHaveBeenCalledWith({
       queryKey: ["ec2", "placementGroups"],
     })
@@ -673,8 +673,8 @@ describe("useDeletePlacementGroup", () => {
 
     result.current.mutate("my-group")
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       GroupName: "my-group",
     })
   })
@@ -686,7 +686,7 @@ describe("useDeletePlacementGroup", () => {
 
     result.current.mutate("my-group")
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
     expect(spy).toHaveBeenCalledWith({
       queryKey: ["ec2", "placementGroups"],
     })
@@ -704,8 +704,8 @@ describe("useCreateSecurityGroup", () => {
       vpcId: "vpc-123",
     })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       GroupName: "web-sg",
       Description: "Allow web traffic",
       VpcId: "vpc-123",
@@ -723,7 +723,7 @@ describe("useCreateSecurityGroup", () => {
       vpcId: "vpc-123",
     })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
     expect(spy).toHaveBeenCalledWith({
       queryKey: ["ec2", "securityGroups"],
     })
@@ -737,8 +737,8 @@ describe("useDeleteSecurityGroup", () => {
 
     result.current.mutate("sg-123")
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       GroupId: "sg-123",
     })
   })
@@ -750,7 +750,7 @@ describe("useDeleteSecurityGroup", () => {
 
     result.current.mutate("sg-123")
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
     expect(spy).toHaveBeenCalledWith({
       queryKey: ["ec2", "securityGroups"],
     })
@@ -774,8 +774,8 @@ describe("useAuthorizeSecurityGroupIngress", () => {
 
     result.current.mutate(ruleParams)
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       GroupId: "sg-123",
       IpPermissions: [
         {
@@ -797,7 +797,7 @@ describe("useAuthorizeSecurityGroupIngress", () => {
 
     result.current.mutate(ruleParams)
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
     expect(spy).toHaveBeenCalledWith({
       queryKey: ["ec2", "securityGroups"],
     })
@@ -822,8 +822,8 @@ describe("useAuthorizeSecurityGroupEgress", () => {
       cidrIp: "0.0.0.0/0",
     })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       GroupId: "sg-456",
       IpPermissions: [
         {
@@ -852,8 +852,8 @@ describe("useRevokeSecurityGroupIngress", () => {
       cidrIp: "10.0.0.0/16",
     })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       GroupId: "sg-123",
       IpPermissions: [
         {
@@ -881,7 +881,7 @@ describe("useRevokeSecurityGroupIngress", () => {
       cidrIp: "10.0.0.0/16",
     })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
     expect(spy).toHaveBeenCalledWith({
       queryKey: ["ec2", "securityGroups"],
     })
@@ -906,8 +906,8 @@ describe("useRevokeSecurityGroupEgress", () => {
       cidrIp: "0.0.0.0/0",
     })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       GroupId: "sg-456",
       IpPermissions: [
         {
@@ -944,7 +944,7 @@ describe("useCreateVpcWizard", () => {
 
     result.current.mutate(baseParams)
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
     expect(mockSend).toHaveBeenCalledOnce()
     expect(mockSend.mock.calls[0]?.[0].input.CidrBlock).toBe("10.0.0.0/16")
     expect(result.current.data?.vpcId).toBe("vpc-111")
@@ -964,7 +964,7 @@ describe("useCreateVpcWizard", () => {
       autoGenerateNames: true,
     })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
     const tags = mockSend.mock.calls[0]?.[0].input.TagSpecifications
     expect(tags?.[0]?.Tags).toContainEqual({
       Key: "Name",
@@ -1005,7 +1005,7 @@ describe("useCreateVpcWizard", () => {
       privateSubnetCount: 1,
     })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
     expect(mockSend).toHaveBeenCalledTimes(10)
     expect(result.current.data?.vpcId).toBe("vpc-111")
     expect(result.current.data?.created).toHaveLength(6)
@@ -1032,7 +1032,7 @@ describe("useCreateVpcWizard", () => {
       privateSubnetCount: 1,
     })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
     expect(mockSend).toHaveBeenCalledTimes(4)
     const types = result.current.data?.created.map((r) => r.type)
     expect(types).not.toContain("Internet Gateway")
@@ -1055,7 +1055,7 @@ describe("useCreateVpcWizard", () => {
       privateSubnetCount: 1,
     })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
     expect(result.current.data?.error?.message).toBe("CIDR conflict")
     expect(result.current.data?.failedStep).toBe(
       "Failed while creating private subnets",
@@ -1072,7 +1072,7 @@ describe("useCreateVpcWizard", () => {
 
     result.current.mutate(baseParams)
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
     expect(result.current.data?.error?.message).toBe("Access denied")
     expect(result.current.data?.failedStep).toBe("Failed while creating VPC")
     expect(result.current.data?.vpcId).toBeUndefined()
@@ -1087,7 +1087,7 @@ describe("useCreateVpcWizard", () => {
 
     result.current.mutate(baseParams)
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
     expect(result.current.data?.error?.message).toContain(
       "no VPC ID was returned",
     )
@@ -1102,7 +1102,7 @@ describe("useCreateVpcWizard", () => {
 
     result.current.mutate(baseParams)
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
     expect(spy).toHaveBeenCalledWith({ queryKey: ["ec2", "vpcs"] })
     expect(spy).toHaveBeenCalledWith({ queryKey: ["ec2", "subnets"] })
     expect(spy).toHaveBeenCalledWith({
@@ -1122,7 +1122,7 @@ describe("useCreateVpcWizard", () => {
       tags: [{ key: "Env", value: "prod" }],
     })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
     const tags = mockSend.mock.calls[0]?.[0].input.TagSpecifications?.[0]?.Tags
     expect(tags).toContainEqual({ Key: "Env", Value: "prod" })
   })

spinifex/services/spinifexui/frontend/src/mutations/elbv2.test.tsx

@@ -1,7 +1,7 @@
 import { QueryClient, QueryClientProvider } from "@tanstack/react-query"
 import { renderHook, waitFor } from "@testing-library/react"
 import type { ReactNode } from "react"
-import { afterEach, describe, expect, it, vi } from "vitest"
+import { describe, expect, it, vi } from "vitest"
 
 const mockSend = vi.fn().mockResolvedValue({})
 
@@ -35,10 +35,6 @@ function wrapper({ children }: { children: ReactNode }) {
   )
 }
 
-afterEach(() => {
-  mockSend.mockClear()
-})
-
 function createQueryClient() {
   queryClient = new QueryClient({
     defaultOptions: {
@@ -64,8 +60,8 @@ describe("useModifyLoadBalancerAttributes", () => {
       ],
     })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       LoadBalancerArn: "arn:lb:1",
       Attributes: [
         { Key: "deletion_protection.enabled", Value: "true" },
@@ -87,8 +83,8 @@ describe("useModifyTargetGroupAttributes", () => {
       attributes: [{ key: "stickiness.enabled", value: "true" }],
     })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       TargetGroupArn: TG_ARN,
       Attributes: [{ Key: "stickiness.enabled", Value: "true" }],
     })
@@ -102,8 +98,8 @@ describe("useDeleteLoadBalancer", () => {
 
     result.current.mutate("arn:aws:elasticloadbalancing:lb/app/foo/abc")
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       LoadBalancerArn: "arn:aws:elasticloadbalancing:lb/app/foo/abc",
     })
   })
@@ -116,8 +112,8 @@ describe("useDeleteTargetGroup", () => {
 
     result.current.mutate("arn:aws:elasticloadbalancing:tg/app/foo/abc")
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       TargetGroupArn: "arn:aws:elasticloadbalancing:tg/app/foo/abc",
     })
   })
@@ -148,8 +144,8 @@ describe("useCreateTargetGroup", () => {
 
     result.current.mutate(baseParams)
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       Name: "my-tg",
       Protocol: "HTTP",
       Port: 80,
@@ -179,8 +175,8 @@ describe("useCreateTargetGroup", () => {
       ],
     })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input.Tags).toEqual([
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input.Tags).toStrictEqual([
       { Key: "env", Value: "prod" },
     ])
   })
@@ -199,8 +195,8 @@ describe("useCreateLoadBalancer", () => {
       tags: [{ key: "env", value: "prod" }],
     })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       Name: "my-alb",
       Scheme: "internet-facing",
       Type: "application",
@@ -223,7 +219,7 @@ describe("useCreateLoadBalancer", () => {
       tags: [],
     })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
     const input = mockSend.mock.calls[0]?.[0].input
     expect(input.SecurityGroups).toBeUndefined()
     expect(input.Tags).toBeUndefined()
@@ -242,8 +238,8 @@ describe("useCreateListener", () => {
       defaultTargetGroupArn: "arn:tg:1",
     })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       LoadBalancerArn: "arn:lb:1",
       Protocol: "HTTP",
       Port: 80,
@@ -262,8 +258,8 @@ describe("useRegisterTargets", () => {
       targets: [{ id: "i-aaa" }, { id: "i-bbb" }],
     })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       TargetGroupArn: TG_ARN,
       Targets: [
         { Id: "i-aaa", Port: undefined },
@@ -281,8 +277,8 @@ describe("useRegisterTargets", () => {
       targets: [{ id: "i-aaa", port: 8080 }],
     })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input.Targets).toEqual([
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input.Targets).toStrictEqual([
       { Id: "i-aaa", Port: 8080 },
     ])
   })
@@ -298,8 +294,8 @@ describe("useDeregisterTargets", () => {
       targets: [{ id: "i-aaa", port: 80 }],
     })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       TargetGroupArn: TG_ARN,
       Targets: [{ Id: "i-aaa", Port: 80 }],
     })
@@ -313,8 +309,8 @@ describe("useDeleteListener", () => {
 
     result.current.mutate("arn:listener:1")
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       ListenerArn: "arn:listener:1",
     })
   })
@@ -373,7 +369,7 @@ describe("useCreateLoadBalancerWizard", () => {
       },
     })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
     expect(result.current.data?.error).toBeUndefined()
     expect(result.current.data?.loadBalancerArn).toBe("arn:lb:new")
     expect(result.current.data?.created).toHaveLength(3)
@@ -402,7 +398,7 @@ describe("useCreateLoadBalancerWizard", () => {
       },
     })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
     expect(mockSend).toHaveBeenCalledTimes(2)
     expect(result.current.data?.created).toHaveLength(2)
   })
@@ -429,10 +425,10 @@ describe("useCreateLoadBalancerWizard", () => {
       },
     })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
     expect(result.current.data?.error?.message).toBe("lb boom")
     expect(result.current.data?.failedStep).toBe("creating load balancer")
-    expect(result.current.data?.created).toEqual([
+    expect(result.current.data?.created).toStrictEqual([
       { type: "Target Group", id: "arn:tg:new" },
     ])
     expect(result.current.data?.loadBalancerArn).toBeUndefined()

spinifex/services/spinifexui/frontend/src/mutations/iam.test.tsx

@@ -1,7 +1,7 @@
 import { QueryClient, QueryClientProvider } from "@tanstack/react-query"
 import { renderHook, waitFor } from "@testing-library/react"
 import type { ReactNode } from "react"
-import { afterEach, describe, expect, it, vi } from "vitest"
+import { describe, expect, it, vi } from "vitest"
 
 const mockSend = vi.fn().mockResolvedValue({})
 
@@ -39,10 +39,6 @@ function createQueryClient() {
   return queryClient
 }
 
-afterEach(() => {
-  mockSend.mockClear()
-})
-
 describe("useCreateUser", () => {
   it("sends CreateUserCommand with userName", async () => {
     createQueryClient()
@@ -50,8 +46,8 @@ describe("useCreateUser", () => {
 
     result.current.mutate({ userName: "admin" })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       UserName: "admin",
       Path: undefined,
     })
@@ -63,8 +59,8 @@ describe("useCreateUser", () => {
 
     result.current.mutate({ userName: "admin", path: "/engineering/" })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       UserName: "admin",
       Path: "/engineering/",
     })
@@ -77,7 +73,7 @@ describe("useCreateUser", () => {
 
     result.current.mutate({ userName: "admin" })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
     expect(spy).toHaveBeenCalledWith({ queryKey: ["iam", "users"] })
   })
 })
@@ -89,8 +85,10 @@ describe("useDeleteUser", () => {
 
     result.current.mutate("admin")
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({ UserName: "admin" })
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
+      UserName: "admin",
+    })
   })
 })
 
@@ -101,8 +99,10 @@ describe("useCreateAccessKey", () => {
 
     result.current.mutate("admin")
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({ UserName: "admin" })
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
+      UserName: "admin",
+    })
   })
 
   it("invalidates access-keys query on success", async () => {
@@ -112,7 +112,7 @@ describe("useCreateAccessKey", () => {
 
     result.current.mutate("admin")
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
     expect(spy).toHaveBeenCalledWith({ queryKey: ["iam", "access-keys"] })
   })
 })
@@ -124,8 +124,8 @@ describe("useDeleteAccessKey", () => {
 
     result.current.mutate({ userName: "admin", accessKeyId: "AKIA123" })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       UserName: "admin",
       AccessKeyId: "AKIA123",
     })
@@ -143,8 +143,8 @@ describe("useUpdateAccessKey", () => {
       status: "Inactive",
     })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       UserName: "admin",
       AccessKeyId: "AKIA123",
       Status: "Inactive",
@@ -162,8 +162,8 @@ describe("useCreatePolicy", () => {
       policyDocument: '{"Version":"2012-10-17"}',
     })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       PolicyName: "ReadOnly",
       Description: undefined,
       PolicyDocument: '{"Version":"2012-10-17"}',
@@ -180,7 +180,7 @@ describe("useCreatePolicy", () => {
       policyDocument: "{}",
     })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
     expect(mockSend.mock.calls[0]?.[0].input.Description).toBe(
       "Read-only access",
     )
@@ -193,7 +193,7 @@ describe("useCreatePolicy", () => {
 
     result.current.mutate({ policyName: "ReadOnly", policyDocument: "{}" })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
     expect(spy).toHaveBeenCalledWith({ queryKey: ["iam", "policies"] })
   })
 })
@@ -205,8 +205,8 @@ describe("useDeletePolicy", () => {
 
     result.current.mutate("arn:aws:iam::123:policy/ReadOnly")
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       PolicyArn: "arn:aws:iam::123:policy/ReadOnly",
     })
   })
@@ -219,8 +219,8 @@ describe("useAttachUserPolicy", () => {
 
     result.current.mutate({ userName: "admin", policyArn: "arn:test" })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       UserName: "admin",
       PolicyArn: "arn:test",
     })
@@ -233,7 +233,7 @@ describe("useAttachUserPolicy", () => {
 
     result.current.mutate({ userName: "admin", policyArn: "arn:test" })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
     expect(spy).toHaveBeenCalledWith({
       queryKey: ["iam", "attached-user-policies"],
     })
@@ -247,8 +247,8 @@ describe("useDetachUserPolicy", () => {
 
     result.current.mutate({ userName: "admin", policyArn: "arn:test" })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       UserName: "admin",
       PolicyArn: "arn:test",
     })
@@ -261,7 +261,7 @@ describe("useDetachUserPolicy", () => {
 
     result.current.mutate({ userName: "admin", policyArn: "arn:test" })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
     expect(spy).toHaveBeenCalledWith({
       queryKey: ["iam", "attached-user-policies"],
     })

spinifex/services/spinifexui/frontend/src/mutations/s3.test.tsx

@@ -1,7 +1,7 @@
 import { QueryClient, QueryClientProvider } from "@tanstack/react-query"
 import { renderHook, waitFor } from "@testing-library/react"
 import type { ReactNode } from "react"
-import { afterEach, describe, expect, it, vi } from "vitest"
+import { describe, expect, it, vi } from "vitest"
 
 const mockSend = vi.fn().mockResolvedValue({})
 
@@ -41,10 +41,6 @@ function createQueryClient() {
   return queryClient
 }
 
-afterEach(() => {
-  mockSend.mockClear()
-})
-
 describe("useCreateBucket", () => {
   it("sends CreateBucketCommand with bucket name", async () => {
     createQueryClient()
@@ -52,8 +48,10 @@ describe("useCreateBucket", () => {
 
     result.current.mutate({ bucketName: "my-bucket" })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({ Bucket: "my-bucket" })
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
+      Bucket: "my-bucket",
+    })
   })
 
   it("invalidates buckets query on success", async () => {
@@ -63,7 +61,7 @@ describe("useCreateBucket", () => {
 
     result.current.mutate({ bucketName: "my-bucket" })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
     expect(spy).toHaveBeenCalledWith({ queryKey: ["s3", "buckets"] })
   })
 })
@@ -75,8 +73,8 @@ describe("useDeleteObject", () => {
 
     result.current.mutate({ bucket: "my-bucket", key: "photos/cat.jpg" })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       Bucket: "my-bucket",
       Key: "photos/cat.jpg",
     })
@@ -89,7 +87,7 @@ describe("useDeleteObject", () => {
 
     result.current.mutate({ bucket: "my-bucket", key: "file.txt" })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
     expect(spy).toHaveBeenCalledWith({
       queryKey: ["s3", "buckets", "my-bucket", "objects"],
     })
@@ -105,7 +103,7 @@ describe("useUploadObject", () => {
     const file = new File(["hello"], "test.txt", { type: "text/plain" })
     result.current.mutate({ bucket: "my-bucket", key: "test.txt", file })
 
-    await waitFor(() => expect(result.current.isSuccess).toBe(true))
+    await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
     expect(spy).toHaveBeenCalledWith({
       queryKey: ["s3", "buckets", "my-bucket", "objects"],
     })

spinifex/services/spinifexui/frontend/src/queries/admin.test.ts

@@ -31,7 +31,7 @@ function getQueryFn(opts: {
 
 describe("adminNodesQueryOptions", () => {
   it("has the correct query key", () => {
-    expect(adminNodesQueryOptions.queryKey).toEqual(["admin", "nodes"])
+    expect(adminNodesQueryOptions.queryKey).toStrictEqual(["admin", "nodes"])
   })
 
   it("throws when not authenticated", async () => {
@@ -57,7 +57,7 @@ describe("adminNodesQueryOptions", () => {
 
 describe("adminVMsQueryOptions", () => {
   it("has the correct query key", () => {
-    expect(adminVMsQueryOptions.queryKey).toEqual(["admin", "vms"])
+    expect(adminVMsQueryOptions.queryKey).toStrictEqual(["admin", "vms"])
   })
 
   it("throws when not authenticated", async () => {
@@ -83,7 +83,7 @@ describe("adminVMsQueryOptions", () => {
 
 describe("adminStorageStatusQueryOptions", () => {
   it("has the correct query key", () => {
-    expect(adminStorageStatusQueryOptions.queryKey).toEqual([
+    expect(adminStorageStatusQueryOptions.queryKey).toStrictEqual([
       "admin",
       "storageStatus",
     ])

spinifex/services/spinifexui/frontend/src/queries/ec2.test.ts

@@ -32,11 +32,14 @@ import {
 
 describe("query keys", () => {
   it("ec2InstancesQueryOptions has correct key", () => {
-    expect(ec2InstancesQueryOptions.queryKey).toEqual(["ec2", "instances"])
+    expect(ec2InstancesQueryOptions.queryKey).toStrictEqual([
+      "ec2",
+      "instances",
+    ])
   })
 
   it("ec2InstanceQueryOptions includes instanceId in key", () => {
-    expect(ec2InstanceQueryOptions("i-123").queryKey).toEqual([
+    expect(ec2InstanceQueryOptions("i-123").queryKey).toStrictEqual([
       "ec2",
       "instances",
       "i-123",
@@ -44,11 +47,11 @@ describe("query keys", () => {
   })
 
   it("ec2ImagesQueryOptions has correct key", () => {
-    expect(ec2ImagesQueryOptions.queryKey).toEqual(["ec2", "images"])
+    expect(ec2ImagesQueryOptions.queryKey).toStrictEqual(["ec2", "images"])
   })
 
   it("ec2ImageQueryOptions uses 'none' for undefined imageId", () => {
-    expect(ec2ImageQueryOptions(undefined).queryKey).toEqual([
+    expect(ec2ImageQueryOptions(undefined).queryKey).toStrictEqual([
       "ec2",
       "images",
       "none",
@@ -56,11 +59,11 @@ describe("query keys", () => {
   })
 
   it("ec2KeyPairsQueryOptions has correct key", () => {
-    expect(ec2KeyPairsQueryOptions.queryKey).toEqual(["ec2", "keypairs"])
+    expect(ec2KeyPairsQueryOptions.queryKey).toStrictEqual(["ec2", "keypairs"])
   })
 
   it("ec2KeyPairQueryOptions includes keyPairId", () => {
-    expect(ec2KeyPairQueryOptions("kp-abc").queryKey).toEqual([
+    expect(ec2KeyPairQueryOptions("kp-abc").queryKey).toStrictEqual([
       "ec2",
       "keypairs",
       "kp-abc",
@@ -68,11 +71,11 @@ describe("query keys", () => {
   })
 
   it("ec2VolumesQueryOptions has correct key", () => {
-    expect(ec2VolumesQueryOptions.queryKey).toEqual(["ec2", "volumes"])
+    expect(ec2VolumesQueryOptions.queryKey).toStrictEqual(["ec2", "volumes"])
   })
 
   it("ec2VolumeQueryOptions includes volumeId", () => {
-    expect(ec2VolumeQueryOptions("vol-1").queryKey).toEqual([
+    expect(ec2VolumeQueryOptions("vol-1").queryKey).toStrictEqual([
       "ec2",
       "volumes",
       "vol-1",
@@ -80,11 +83,14 @@ describe("query keys", () => {
   })
 
   it("ec2SnapshotsQueryOptions has correct key", () => {
-    expect(ec2SnapshotsQueryOptions.queryKey).toEqual(["ec2", "snapshots"])
+    expect(ec2SnapshotsQueryOptions.queryKey).toStrictEqual([
+      "ec2",
+      "snapshots",
+    ])
   })
 
   it("ec2SnapshotQueryOptions includes snapshotId", () => {
-    expect(ec2SnapshotQueryOptions("snap-1").queryKey).toEqual([
+    expect(ec2SnapshotQueryOptions("snap-1").queryKey).toStrictEqual([
       "ec2",
       "snapshots",
       "snap-1",
@@ -92,11 +98,11 @@ describe("query keys", () => {
   })
 
   it("ec2VpcsQueryOptions has correct key", () => {
-    expect(ec2VpcsQueryOptions.queryKey).toEqual(["ec2", "vpcs"])
+    expect(ec2VpcsQueryOptions.queryKey).toStrictEqual(["ec2", "vpcs"])
   })
 
   it("ec2VpcQueryOptions includes vpcId", () => {
-    expect(ec2VpcQueryOptions("vpc-1").queryKey).toEqual([
+    expect(ec2VpcQueryOptions("vpc-1").queryKey).toStrictEqual([
       "ec2",
       "vpcs",
       "vpc-1",
@@ -104,11 +110,11 @@ describe("query keys", () => {
   })
 
   it("ec2SubnetsQueryOptions has correct key", () => {
-    expect(ec2SubnetsQueryOptions.queryKey).toEqual(["ec2", "subnets"])
+    expect(ec2SubnetsQueryOptions.queryKey).toStrictEqual(["ec2", "subnets"])
   })
 
   it("ec2SubnetQueryOptions includes subnetId", () => {
-    expect(ec2SubnetQueryOptions("subnet-1").queryKey).toEqual([
+    expect(ec2SubnetQueryOptions("subnet-1").queryKey).toStrictEqual([
       "ec2",
       "subnets",
       "subnet-1",
@@ -116,7 +122,7 @@ describe("query keys", () => {
   })
 
   it("ec2InstanceTypesQueryOptions has correct key", () => {
-    expect(ec2InstanceTypesQueryOptions.queryKey).toEqual([
+    expect(ec2InstanceTypesQueryOptions.queryKey).toStrictEqual([
       "ec2",
       "instances",
       "types",
@@ -124,14 +130,14 @@ describe("query keys", () => {
   })
 
   it("ec2PlacementGroupsQueryOptions has correct key", () => {
-    expect(ec2PlacementGroupsQueryOptions.queryKey).toEqual([
+    expect(ec2PlacementGroupsQueryOptions.queryKey).toStrictEqual([
       "ec2",
       "placementGroups",
     ])
   })
 
   it("ec2PlacementGroupQueryOptions includes groupId in key", () => {
-    expect(ec2PlacementGroupQueryOptions("pg-123").queryKey).toEqual([
+    expect(ec2PlacementGroupQueryOptions("pg-123").queryKey).toStrictEqual([
       "ec2",
       "placementGroups",
       "pg-123",
@@ -139,14 +145,14 @@ describe("query keys", () => {
   })
 
   it("ec2SecurityGroupsQueryOptions has correct key", () => {
-    expect(ec2SecurityGroupsQueryOptions.queryKey).toEqual([
+    expect(ec2SecurityGroupsQueryOptions.queryKey).toStrictEqual([
       "ec2",
       "securityGroups",
     ])
   })
 
   it("ec2SecurityGroupQueryOptions includes groupId in key", () => {
-    expect(ec2SecurityGroupQueryOptions("sg-123").queryKey).toEqual([
+    expect(ec2SecurityGroupQueryOptions("sg-123").queryKey).toStrictEqual([
       "ec2",
       "securityGroups",
       "sg-123",
@@ -189,7 +195,7 @@ describe("queryFn", () => {
     const options = ec2ImageQueryOptions(undefined)
     const queryFn = options.queryFn as (ctx: never) => Promise<unknown>
     const result = await queryFn({} as never)
-    expect(result).toEqual({ Images: [], $metadata: {} })
+    expect(result).toStrictEqual({ Images: [], $metadata: {} })
     expect(mockSend).not.toHaveBeenCalled()
   })
 
@@ -199,7 +205,7 @@ describe("queryFn", () => {
     ) => Promise<unknown>
     await queryFn({} as never)
     expect(mockSend).toHaveBeenCalledOnce()
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       ImageIds: ["ami-123"],
     })
   })
@@ -210,7 +216,7 @@ describe("queryFn", () => {
     ) => Promise<unknown>
     await queryFn({} as never)
     expect(mockSend).toHaveBeenCalledOnce()
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({})
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({})
   })
 
   it("ec2InstanceQueryOptions sends DescribeInstancesCommand with ID", async () => {
@@ -218,7 +224,7 @@ describe("queryFn", () => {
       ctx: never,
     ) => Promise<unknown>
     await queryFn({} as never)
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       InstanceIds: ["i-123"],
     })
   })
@@ -229,7 +235,7 @@ describe("queryFn", () => {
     ) => Promise<unknown>
     await queryFn({} as never)
     expect(mockSend).toHaveBeenCalledOnce()
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({})
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({})
   })
 
   it("ec2KeyPairQueryOptions sends DescribeKeyPairsCommand with ID", async () => {
@@ -237,7 +243,7 @@ describe("queryFn", () => {
       ctx: never,
     ) => Promise<unknown>
     await queryFn({} as never)
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       KeyPairIds: ["kp-abc"],
     })
   })
@@ -255,7 +261,7 @@ describe("queryFn", () => {
       ctx: never,
     ) => Promise<unknown>
     await queryFn({} as never)
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       VolumeIds: ["vol-1"],
     })
   })
@@ -273,7 +279,7 @@ describe("queryFn", () => {
       ctx: never,
     ) => Promise<unknown>
     await queryFn({} as never)
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       SnapshotIds: ["snap-1"],
     })
   })
@@ -291,7 +297,7 @@ describe("queryFn", () => {
       ctx: never,
     ) => Promise<unknown>
     await queryFn({} as never)
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       VpcIds: ["vpc-1"],
     })
   })
@@ -309,7 +315,7 @@ describe("queryFn", () => {
       ctx: never,
     ) => Promise<unknown>
     await queryFn({} as never)
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       SubnetIds: ["subnet-1"],
     })
   })
@@ -343,7 +349,7 @@ describe("queryFn", () => {
       ctx: never,
     ) => Promise<unknown>
     await queryFn({} as never)
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       Filters: [{ Name: "capacity", Values: ["true"] }],
     })
   })
@@ -354,7 +360,7 @@ describe("queryFn", () => {
     ) => Promise<unknown>
     await queryFn({} as never)
     expect(mockSend).toHaveBeenCalledOnce()
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({})
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({})
   })
 
   it("ec2PlacementGroupQueryOptions sends DescribePlacementGroupsCommand with ID", async () => {
@@ -362,7 +368,7 @@ describe("queryFn", () => {
       ctx: never,
     ) => Promise<unknown>
     await queryFn({} as never)
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       GroupIds: ["pg-123"],
     })
   })
@@ -373,7 +379,7 @@ describe("queryFn", () => {
     ) => Promise<unknown>
     await queryFn({} as never)
     expect(mockSend).toHaveBeenCalledOnce()
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({})
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({})
   })
 
   it("ec2SecurityGroupQueryOptions sends DescribeSecurityGroupsCommand with ID", async () => {
@@ -381,7 +387,7 @@ describe("queryFn", () => {
       ctx: never,
     ) => Promise<unknown>
     await queryFn({} as never)
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       GroupIds: ["sg-123"],
     })
   })

spinifex/services/spinifexui/frontend/src/queries/elbv2.test.ts

@@ -1,4 +1,4 @@
-import { afterEach, describe, expect, it, vi } from "vitest"
+import { describe, expect, it, vi } from "vitest"
 
 const mockSend = vi.fn()
 
@@ -18,20 +18,16 @@ import {
   elbv2TargetHealthQueryOptions,
 } from "./elbv2"
 
-afterEach(() => {
-  mockSend.mockReset()
-})
-
 describe("elbv2 query keys", () => {
   it("elbv2LoadBalancersQueryOptions has correct key", () => {
-    expect(elbv2LoadBalancersQueryOptions.queryKey).toEqual([
+    expect(elbv2LoadBalancersQueryOptions.queryKey).toStrictEqual([
       "elbv2",
       "loadBalancers",
     ])
   })
 
   it("elbv2LoadBalancerQueryOptions includes arn", () => {
-    expect(elbv2LoadBalancerQueryOptions("arn:lb").queryKey).toEqual([
+    expect(elbv2LoadBalancerQueryOptions("arn:lb").queryKey).toStrictEqual([
       "elbv2",
       "loadBalancers",
       "arn:lb",
@@ -39,23 +35,20 @@ describe("elbv2 query keys", () => {
   })
 
   it("elbv2LoadBalancerAttributesQueryOptions includes arn + attributes", () => {
-    expect(elbv2LoadBalancerAttributesQueryOptions("arn:lb").queryKey).toEqual([
-      "elbv2",
-      "loadBalancers",
-      "arn:lb",
-      "attributes",
-    ])
+    expect(
+      elbv2LoadBalancerAttributesQueryOptions("arn:lb").queryKey,
+    ).toStrictEqual(["elbv2", "loadBalancers", "arn:lb", "attributes"])
   })
 
   it("elbv2TargetGroupsQueryOptions has correct key", () => {
-    expect(elbv2TargetGroupsQueryOptions.queryKey).toEqual([
+    expect(elbv2TargetGroupsQueryOptions.queryKey).toStrictEqual([
       "elbv2",
       "targetGroups",
     ])
   })
 
   it("elbv2TargetGroupQueryOptions includes arn", () => {
-    expect(elbv2TargetGroupQueryOptions("arn:tg").queryKey).toEqual([
+    expect(elbv2TargetGroupQueryOptions("arn:tg").queryKey).toStrictEqual([
       "elbv2",
       "targetGroups",
       "arn:tg",
@@ -63,16 +56,13 @@ describe("elbv2 query keys", () => {
   })
 
   it("elbv2TargetGroupAttributesQueryOptions includes arn + attributes", () => {
-    expect(elbv2TargetGroupAttributesQueryOptions("arn:tg").queryKey).toEqual([
-      "elbv2",
-      "targetGroups",
-      "arn:tg",
-      "attributes",
-    ])
+    expect(
+      elbv2TargetGroupAttributesQueryOptions("arn:tg").queryKey,
+    ).toStrictEqual(["elbv2", "targetGroups", "arn:tg", "attributes"])
   })
 
   it("elbv2ListenersQueryOptions includes lb arn", () => {
-    expect(elbv2ListenersQueryOptions("arn:lb").queryKey).toEqual([
+    expect(elbv2ListenersQueryOptions("arn:lb").queryKey).toStrictEqual([
       "elbv2",
       "listeners",
       "arn:lb",
@@ -80,7 +70,7 @@ describe("elbv2 query keys", () => {
   })
 
   it("elbv2TargetHealthQueryOptions includes tg arn + health", () => {
-    expect(elbv2TargetHealthQueryOptions("arn:tg").queryKey).toEqual([
+    expect(elbv2TargetHealthQueryOptions("arn:tg").queryKey).toStrictEqual([
       "elbv2",
       "targetGroups",
       "arn:tg",
@@ -89,7 +79,7 @@ describe("elbv2 query keys", () => {
   })
 
   it("elbv2TagsQueryOptions spreads resource arns into key", () => {
-    expect(elbv2TagsQueryOptions(["arn:lb", "arn:tg"]).queryKey).toEqual([
+    expect(elbv2TagsQueryOptions(["arn:lb", "arn:tg"]).queryKey).toStrictEqual([
       "elbv2",
       "tags",
       "arn:lb",
@@ -111,13 +101,13 @@ describe("elbv2 implemented queries send the right command", () => {
     mockSend.mockResolvedValueOnce({ LoadBalancers: [] })
     await callQueryFn(elbv2LoadBalancersQueryOptions.queryFn)
     expect(mockSend).toHaveBeenCalledOnce()
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({})
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({})
   })
 
   it("loadBalancer detail filters by ARN", async () => {
     mockSend.mockResolvedValueOnce({ LoadBalancers: [] })
     await callQueryFn(elbv2LoadBalancerQueryOptions("arn:lb").queryFn)
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       LoadBalancerArns: ["arn:lb"],
     })
   })
@@ -125,7 +115,7 @@ describe("elbv2 implemented queries send the right command", () => {
   it("loadBalancer attributes sends arn", async () => {
     mockSend.mockResolvedValueOnce({ Attributes: [] })
     await callQueryFn(elbv2LoadBalancerAttributesQueryOptions("arn:lb").queryFn)
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       LoadBalancerArn: "arn:lb",
     })
   })
@@ -133,7 +123,7 @@ describe("elbv2 implemented queries send the right command", () => {
   it("listeners filters by load balancer arn", async () => {
     mockSend.mockResolvedValueOnce({ Listeners: [] })
     await callQueryFn(elbv2ListenersQueryOptions("arn:lb").queryFn)
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       LoadBalancerArn: "arn:lb",
     })
   })
@@ -141,7 +131,7 @@ describe("elbv2 implemented queries send the right command", () => {
   it("tags sends resource arns", async () => {
     mockSend.mockResolvedValueOnce({ TagDescriptions: [] })
     await callQueryFn(elbv2TagsQueryOptions(["arn:lb"]).queryFn)
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       ResourceArns: ["arn:lb"],
     })
   })
@@ -149,13 +139,13 @@ describe("elbv2 implemented queries send the right command", () => {
   it("targetGroups list sends DescribeTargetGroupsCommand", async () => {
     mockSend.mockResolvedValueOnce({ TargetGroups: [] })
     await callQueryFn(elbv2TargetGroupsQueryOptions.queryFn)
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({})
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({})
   })
 
   it("targetGroup detail filters by ARN", async () => {
     mockSend.mockResolvedValueOnce({ TargetGroups: [] })
     await callQueryFn(elbv2TargetGroupQueryOptions("arn:tg").queryFn)
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       TargetGroupArns: ["arn:tg"],
     })
   })
@@ -163,7 +153,7 @@ describe("elbv2 implemented queries send the right command", () => {
   it("targetGroup attributes sends arn", async () => {
     mockSend.mockResolvedValueOnce({ Attributes: [] })
     await callQueryFn(elbv2TargetGroupAttributesQueryOptions("arn:tg").queryFn)
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       TargetGroupArn: "arn:tg",
     })
   })
@@ -171,7 +161,7 @@ describe("elbv2 implemented queries send the right command", () => {
   it("targetHealth sends target group arn", async () => {
     mockSend.mockResolvedValueOnce({ TargetHealthDescriptions: [] })
     await callQueryFn(elbv2TargetHealthQueryOptions("arn:tg").queryFn)
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       TargetGroupArn: "arn:tg",
     })
   })
@@ -201,6 +191,6 @@ describe("elbv2 load balancer list poll cadence", () => {
         data: { LoadBalancers: [{ State: { Code: "active" } }] },
       },
     } as never)
-    expect(result).toBe(false)
+    expect(result).toBeFalsy()
   })
 })

spinifex/services/spinifexui/frontend/src/queries/iam.test.ts

@@ -18,11 +18,11 @@ import {
 
 describe("query keys", () => {
   it("iamUsersQueryOptions has correct key", () => {
-    expect(iamUsersQueryOptions.queryKey).toEqual(["iam", "users"])
+    expect(iamUsersQueryOptions.queryKey).toStrictEqual(["iam", "users"])
   })
 
   it("iamUserQueryOptions includes userName in key", () => {
-    expect(iamUserQueryOptions("admin").queryKey).toEqual([
+    expect(iamUserQueryOptions("admin").queryKey).toStrictEqual([
       "iam",
       "users",
       "admin",
@@ -30,7 +30,7 @@ describe("query keys", () => {
   })
 
   it("iamAccessKeysQueryOptions includes userName in key", () => {
-    expect(iamAccessKeysQueryOptions("admin").queryKey).toEqual([
+    expect(iamAccessKeysQueryOptions("admin").queryKey).toStrictEqual([
       "iam",
       "access-keys",
       "admin",
@@ -38,20 +38,20 @@ describe("query keys", () => {
   })
 
   it("iamPoliciesQueryOptions has correct key", () => {
-    expect(iamPoliciesQueryOptions.queryKey).toEqual(["iam", "policies"])
+    expect(iamPoliciesQueryOptions.queryKey).toStrictEqual(["iam", "policies"])
   })
 
   it("iamPolicyQueryOptions includes policyArn in key", () => {
     expect(
       iamPolicyQueryOptions("arn:aws:iam::123:policy/ReadOnly").queryKey,
-    ).toEqual(["iam", "policies", "arn:aws:iam::123:policy/ReadOnly"])
+    ).toStrictEqual(["iam", "policies", "arn:aws:iam::123:policy/ReadOnly"])
   })
 
   it("iamPolicyVersionQueryOptions includes policyArn and versionId in key", () => {
     expect(
       iamPolicyVersionQueryOptions("arn:aws:iam::123:policy/ReadOnly", "v1")
         .queryKey,
-    ).toEqual([
+    ).toStrictEqual([
       "iam",
       "policy-versions",
       "arn:aws:iam::123:policy/ReadOnly",
@@ -60,11 +60,9 @@ describe("query keys", () => {
   })
 
   it("iamAttachedUserPoliciesQueryOptions includes userName in key", () => {
-    expect(iamAttachedUserPoliciesQueryOptions("admin").queryKey).toEqual([
-      "iam",
-      "attached-user-policies",
-      "admin",
-    ])
+    expect(iamAttachedUserPoliciesQueryOptions("admin").queryKey).toStrictEqual(
+      ["iam", "attached-user-policies", "admin"],
+    )
   })
 })
 
@@ -111,7 +109,7 @@ describe("queryFn", () => {
     ) => Promise<unknown>
     await queryFn({} as never)
     expect(mockSend).toHaveBeenCalledOnce()
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({})
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({})
   })
 
   it("iamUserQueryOptions sends GetUserCommand with userName", async () => {
@@ -119,7 +117,9 @@ describe("queryFn", () => {
       ctx: never,
     ) => Promise<unknown>
     await queryFn({} as never)
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({ UserName: "admin" })
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
+      UserName: "admin",
+    })
   })
 
   it("iamAccessKeysQueryOptions sends ListAccessKeysCommand", async () => {
@@ -127,7 +127,9 @@ describe("queryFn", () => {
       ctx: never,
     ) => Promise<unknown>
     await queryFn({} as never)
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({ UserName: "admin" })
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
+      UserName: "admin",
+    })
   })
 
   it("iamPoliciesQueryOptions sends ListPoliciesCommand with Local scope", async () => {
@@ -135,7 +137,7 @@ describe("queryFn", () => {
       ctx: never,
     ) => Promise<unknown>
     await queryFn({} as never)
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({ Scope: "Local" })
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({ Scope: "Local" })
   })
 
   it("iamPolicyQueryOptions sends GetPolicyCommand with policyArn", async () => {
@@ -143,7 +145,7 @@ describe("queryFn", () => {
       ctx: never,
     ) => Promise<unknown>
     await queryFn({} as never)
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       PolicyArn: "arn:test",
     })
   })
@@ -153,7 +155,7 @@ describe("queryFn", () => {
       ctx: never,
     ) => Promise<unknown>
     await queryFn({} as never)
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       PolicyArn: "arn:test",
       VersionId: "v1",
     })
@@ -164,6 +166,8 @@ describe("queryFn", () => {
       ctx: never,
     ) => Promise<unknown>
     await queryFn({} as never)
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({ UserName: "admin" })
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
+      UserName: "admin",
+    })
   })
 })

spinifex/services/spinifexui/frontend/src/queries/s3.test.ts

@@ -10,11 +10,11 @@ import { s3BucketObjectsQueryOptions, s3BucketsQueryOptions } from "./s3"
 
 describe("query keys", () => {
   it("s3BucketsQueryOptions has correct key", () => {
-    expect(s3BucketsQueryOptions.queryKey).toEqual(["s3", "buckets"])
+    expect(s3BucketsQueryOptions.queryKey).toStrictEqual(["s3", "buckets"])
   })
 
   it("s3BucketObjectsQueryOptions includes bucket and empty prefix in key", () => {
-    expect(s3BucketObjectsQueryOptions("my-bucket").queryKey).toEqual([
+    expect(s3BucketObjectsQueryOptions("my-bucket").queryKey).toStrictEqual([
       "s3",
       "buckets",
       "my-bucket",
@@ -26,7 +26,7 @@ describe("query keys", () => {
   it("s3BucketObjectsQueryOptions includes prefix in key", () => {
     expect(
       s3BucketObjectsQueryOptions("my-bucket", "photos/").queryKey,
-    ).toEqual(["s3", "buckets", "my-bucket", "objects", "photos/"])
+    ).toStrictEqual(["s3", "buckets", "my-bucket", "objects", "photos/"])
   })
 })
 
@@ -41,7 +41,7 @@ describe("queryFn", () => {
     ) => Promise<unknown>
     await queryFn({} as never)
     expect(mockSend).toHaveBeenCalledOnce()
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({})
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({})
   })
 
   it("s3BucketObjectsQueryOptions sends ListObjectsV2Command with bucket and delimiter", async () => {
@@ -49,7 +49,7 @@ describe("queryFn", () => {
       ctx: never,
     ) => Promise<unknown>
     await queryFn({} as never)
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       Bucket: "my-bucket",
       Prefix: undefined,
       Delimiter: "/",
@@ -60,7 +60,7 @@ describe("queryFn", () => {
     const queryFn = s3BucketObjectsQueryOptions("my-bucket", "docs/")
       .queryFn as (ctx: never) => Promise<unknown>
     await queryFn({} as never)
-    expect(mockSend.mock.calls[0]?.[0].input).toEqual({
+    expect(mockSend.mock.calls[0]?.[0].input).toStrictEqual({
       Bucket: "my-bucket",
       Prefix: "docs/",
       Delimiter: "/",

spinifex/services/spinifexui/frontend/src/routes/_auth/ec2/(load-balancers)/create-load-balancer.test.tsx

@@ -169,7 +169,7 @@ describe("create-load-balancer route", () => {
           (call[0] as { constructor: { name: string } }).constructor.name,
       )
       .filter((name) => name.startsWith("Create"))
-    expect(createCommands).toEqual([
+    expect(createCommands).toStrictEqual([
       "CreateTargetGroupCommand",
       "CreateLoadBalancerCommand",
       "CreateListenerCommand",
@@ -222,14 +222,14 @@ describe("create-load-balancer route", () => {
     const createNames = createCalls.map(
       (call) => (call[0] as { constructor: { name: string } }).constructor.name,
     )
-    expect(createNames).toEqual([
+    expect(createNames).toStrictEqual([
       "CreateLoadBalancerCommand",
       "CreateListenerCommand",
     ])
     const listenerInput = createCalls[1]?.[0].input as {
       DefaultActions: { Type: string; TargetGroupArn: string }[]
     }
-    expect(listenerInput.DefaultActions).toEqual([
+    expect(listenerInput.DefaultActions).toStrictEqual([
       { Type: "forward", TargetGroupArn: "arn:tg:existing" },
     ])
   })
@@ -259,9 +259,9 @@ describe("create-load-balancer route", () => {
       screen.getByRole("button", { name: "Create load balancer" }),
     )
 
-    expect(
-      await screen.findByText(/Wizard failed: creating load balancer/i),
-    ).toBeInTheDocument()
+    await expect(
+      screen.findByText(/Wizard failed: creating load balancer/i),
+    ).resolves.toBeInTheDocument()
     expect(screen.getByText(/subnets span must be ≥2 AZs/)).toBeInTheDocument()
     // Partial-cleanup list should mention the orphaned TG
     expect(screen.getByText(/Target Group:/)).toBeInTheDocument()

spinifex/services/spinifexui/frontend/src/routes/_auth/ec2/(target-groups)/create-target-group.test.tsx

@@ -86,14 +86,14 @@ describe("create-target-group route", () => {
 
     setup()
 
-    expect(await screen.findByLabelText("Name")).toBeInTheDocument()
+    await expect(screen.findByLabelText("Name")).resolves.toBeInTheDocument()
     await user.type(screen.getByLabelText("Name"), "my-tg")
     await user.click(
       screen.getByRole("button", { name: "Create target group" }),
     )
 
     await waitFor(() => {
-      expect(sdk.send).toHaveBeenCalledTimes(1)
+      expect(sdk.send).toHaveBeenCalledOnce()
     })
     const input = sdk.send.mock.calls[0]?.[0].input as {
       Name: string
@@ -122,7 +122,9 @@ describe("create-target-group route", () => {
       screen.getByRole("button", { name: "Create target group" }),
     )
 
-    expect(await screen.findByText("Name is required")).toBeInTheDocument()
+    await expect(
+      screen.findByText("Name is required"),
+    ).resolves.toBeInTheDocument()
     expect(sdk.send).not.toHaveBeenCalled()
     expect(routerState.navigate).not.toHaveBeenCalled()
   })
@@ -140,9 +142,9 @@ describe("create-target-group route", () => {
       screen.getByRole("button", { name: "Create target group" }),
     )
 
-    expect(
-      await screen.findByText(/Failed to create target group/i),
-    ).toBeInTheDocument()
+    await expect(
+      screen.findByText(/Failed to create target group/i),
+    ).resolves.toBeInTheDocument()
     expect(routerState.navigate).not.toHaveBeenCalled()
   })
 })

spinifex/services/spinifexui/frontend/src/routes/_auth/ec2/-components/instance-actions.test.tsx

@@ -1,6 +1,6 @@
 import { screen, within } from "@testing-library/react"
 import userEvent from "@testing-library/user-event"
-import { beforeEach, describe, expect, it, vi } from "vitest"
+import { describe, expect, it, vi } from "vitest"
 
 import { renderWithProviders } from "@/test/utils"
 
@@ -21,10 +21,6 @@ vi.mock("@/mutations/ec2", () => ({
   useTerminateInstance: () => ({ ...defaultMutation }),
 }))
 
-beforeEach(() => {
-  mockMutate.mockReset()
-})
-
 describe("InstanceActions", () => {
   describe("running instance", () => {
     it("shows Stop, Reboot, and Terminate buttons", () => {

spinifex/services/spinifexui/frontend/src/test/elbv2-e2e.test.tsx

@@ -237,11 +237,11 @@ function mustString(value: string | undefined, label: string): string {
   return value
 }
 
-beforeEach(() => {
-  sdk.reset()
-})
-
 describe("ELBv2 cross-slice flow (mocked SDK)", () => {
+  beforeEach(() => {
+    sdk.reset()
+  })
+
   it("creates TG → LB → listener → registers targets → observes healthy state", async () => {
     const qc = createQueryClient()
 

spinifex/services/spinifexui/frontend/src/types/ec2.test.ts

@@ -26,7 +26,7 @@ describe("createInstanceSchema", () => {
       keyName: "my-key",
       count: 1,
     })
-    expect(result.success).toBe(true)
+    expect(result.success).toBeTruthy()
   })
 
   it("requires count to be at least 1", () => {
@@ -36,7 +36,7 @@ describe("createInstanceSchema", () => {
       keyName: "my-key",
       count: 0,
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("requires count to be an integer", () => {
@@ -46,7 +46,7 @@ describe("createInstanceSchema", () => {
       keyName: "my-key",
       count: 1.5,
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("allows optional subnetId", () => {
@@ -57,7 +57,7 @@ describe("createInstanceSchema", () => {
       count: 1,
       subnetId: "subnet-abc",
     })
-    expect(result.success).toBe(true)
+    expect(result.success).toBeTruthy()
   })
 
   it("allows optional placementGroupName", () => {
@@ -68,7 +68,7 @@ describe("createInstanceSchema", () => {
       count: 1,
       placementGroupName: "my-group",
     })
-    expect(result.success).toBe(true)
+    expect(result.success).toBeTruthy()
   })
 
   it("supports capacity refine", () => {
@@ -82,12 +82,12 @@ describe("createInstanceSchema", () => {
       keyName: "my-key",
       count: 5,
     })
-    expect(result.success).toBe(false)
-    if (!result.success) {
-      expect(result.error.issues[0]?.message).toBe(
-        "Cannot exceed available capacity",
-      )
+    if (result.success) {
+      throw new Error("expected validation to fail")
     }
+    expect(result.error.issues[0]?.message).toBe(
+      "Cannot exceed available capacity",
+    )
   })
 
   it("accepts optional root volume fields", () => {
@@ -101,7 +101,7 @@ describe("createInstanceSchema", () => {
       rootVolumeType: "gp3",
       rootDeleteOnTermination: true,
     })
-    expect(result.success).toBe(true)
+    expect(result.success).toBeTruthy()
   })
 
   it("rejects rootVolumeSize below 1 GiB", () => {
@@ -112,7 +112,7 @@ describe("createInstanceSchema", () => {
       count: 1,
       rootVolumeSize: 0,
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("rejects rootVolumeSize above 16384 GiB", () => {
@@ -123,7 +123,7 @@ describe("createInstanceSchema", () => {
       count: 1,
       rootVolumeSize: 16_385,
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("rejects non-integer rootVolumeSize", () => {
@@ -134,7 +134,7 @@ describe("createInstanceSchema", () => {
       count: 1,
       rootVolumeSize: 50.5,
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("rejects unsupported rootVolumeType", () => {
@@ -145,24 +145,24 @@ describe("createInstanceSchema", () => {
       count: 1,
       rootVolumeType: "io2",
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 })
 
 describe("createKeyPairSchema", () => {
   it("accepts a valid key name", () => {
     const result = createKeyPairSchema.safeParse({ keyName: "my-key" })
-    expect(result.success).toBe(true)
+    expect(result.success).toBeTruthy()
   })
 
   it("rejects empty key name", () => {
     const result = createKeyPairSchema.safeParse({ keyName: "" })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("rejects key name over 255 chars", () => {
     const result = createKeyPairSchema.safeParse({ keyName: "a".repeat(256) })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 })
 
@@ -172,7 +172,7 @@ describe("importKeyPairSchema", () => {
       keyName: "my-key",
       publicKeyMaterial: "ssh-rsa AAAAB3Nza...",
     })
-    expect(result.success).toBe(true)
+    expect(result.success).toBeTruthy()
   })
 
   it("rejects empty public key", () => {
@@ -180,7 +180,7 @@ describe("importKeyPairSchema", () => {
       keyName: "my-key",
       publicKeyMaterial: "",
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("rejects whitespace-only public key", () => {
@@ -188,7 +188,7 @@ describe("importKeyPairSchema", () => {
       keyName: "my-key",
       publicKeyMaterial: "   ",
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 })
 
@@ -198,7 +198,7 @@ describe("createVolumeSchema", () => {
       size: 10,
       availabilityZone: "us-east-1a",
     })
-    expect(result.success).toBe(true)
+    expect(result.success).toBeTruthy()
   })
 
   it("rejects size below 1", () => {
@@ -206,7 +206,7 @@ describe("createVolumeSchema", () => {
       size: 0,
       availabilityZone: "us-east-1a",
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("rejects size above 16384", () => {
@@ -214,7 +214,7 @@ describe("createVolumeSchema", () => {
       size: 16_385,
       availabilityZone: "us-east-1a",
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("rejects fractional size", () => {
@@ -222,26 +222,26 @@ describe("createVolumeSchema", () => {
       size: 10.5,
       availabilityZone: "us-east-1a",
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 })
 
 describe("modifyVolumeSchema", () => {
   it("accepts valid size", () => {
     const result = modifyVolumeSchema.safeParse({ size: 20 })
-    expect(result.success).toBe(true)
+    expect(result.success).toBeTruthy()
   })
 
   it("rejects size below 1", () => {
     const result = modifyVolumeSchema.safeParse({ size: 0 })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 })
 
 describe("createVpcSchema", () => {
   it("accepts valid CIDR block", () => {
     const result = createVpcSchema.safeParse({ cidrBlock: "10.0.0.0/16" })
-    expect(result.success).toBe(true)
+    expect(result.success).toBeTruthy()
   })
 
   it("accepts CIDR block with optional name", () => {
@@ -249,17 +249,17 @@ describe("createVpcSchema", () => {
       cidrBlock: "10.0.0.0/16",
       name: "my-vpc",
     })
-    expect(result.success).toBe(true)
+    expect(result.success).toBeTruthy()
   })
 
   it("rejects invalid CIDR format", () => {
     const result = createVpcSchema.safeParse({ cidrBlock: "not-a-cidr" })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("rejects empty CIDR block", () => {
     const result = createVpcSchema.safeParse({ cidrBlock: "" })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 })
 
@@ -269,7 +269,7 @@ describe("createSubnetSchema", () => {
       vpcId: "vpc-123",
       cidrBlock: "10.0.1.0/24",
     })
-    expect(result.success).toBe(true)
+    expect(result.success).toBeTruthy()
   })
 
   it("rejects invalid CIDR block", () => {
@@ -277,7 +277,7 @@ describe("createSubnetSchema", () => {
       vpcId: "vpc-123",
       cidrBlock: "invalid",
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("allows optional availability zone", () => {
@@ -286,19 +286,19 @@ describe("createSubnetSchema", () => {
       cidrBlock: "10.0.1.0/24",
       availabilityZone: "us-east-1a",
     })
-    expect(result.success).toBe(true)
+    expect(result.success).toBeTruthy()
   })
 })
 
 describe("createSnapshotSchema", () => {
   it("accepts valid snapshot params", () => {
     const result = createSnapshotSchema.safeParse({ volumeId: "vol-123" })
-    expect(result.success).toBe(true)
+    expect(result.success).toBeTruthy()
   })
 
   it("rejects empty volumeId", () => {
     const result = createSnapshotSchema.safeParse({ volumeId: "" })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 })
 
@@ -308,7 +308,7 @@ describe("copySnapshotSchema", () => {
       sourceSnapshotId: "snap-123",
       sourceRegion: "us-east-1",
     })
-    expect(result.success).toBe(true)
+    expect(result.success).toBeTruthy()
   })
 })
 
@@ -318,7 +318,7 @@ describe("attachVolumeSchema", () => {
       volumeId: "vol-123",
       instanceId: "i-123",
     })
-    expect(result.success).toBe(true)
+    expect(result.success).toBeTruthy()
   })
 
   it("rejects empty instanceId", () => {
@@ -326,7 +326,7 @@ describe("attachVolumeSchema", () => {
       volumeId: "vol-123",
       instanceId: "",
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 })
 
@@ -336,7 +336,7 @@ describe("createPlacementGroupSchema", () => {
       groupName: "my-group",
       strategy: "spread",
     })
-    expect(result.success).toBe(true)
+    expect(result.success).toBeTruthy()
   })
 
   it("rejects empty group name", () => {
@@ -344,7 +344,7 @@ describe("createPlacementGroupSchema", () => {
       groupName: "",
       strategy: "spread",
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("rejects group name over 255 chars", () => {
@@ -352,7 +352,7 @@ describe("createPlacementGroupSchema", () => {
       groupName: "a".repeat(256),
       strategy: "cluster",
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("accepts group name at 255 chars", () => {
@@ -360,7 +360,7 @@ describe("createPlacementGroupSchema", () => {
       groupName: "a".repeat(255),
       strategy: "spread",
     })
-    expect(result.success).toBe(true)
+    expect(result.success).toBeTruthy()
   })
 
   it("rejects empty strategy", () => {
@@ -368,38 +368,38 @@ describe("createPlacementGroupSchema", () => {
       groupName: "my-group",
       strategy: "",
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("rejects missing strategy", () => {
     const result = createPlacementGroupSchema.safeParse({
       groupName: "my-group",
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("rejects missing group name", () => {
     const result = createPlacementGroupSchema.safeParse({
       strategy: "spread",
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 })
 
 describe("formTagSchema", () => {
   it("accepts valid tag with key and value", () => {
     const result = formTagSchema.safeParse({ key: "Env", value: "prod" })
-    expect(result.success).toBe(true)
+    expect(result.success).toBeTruthy()
   })
 
   it("accepts tag with empty value", () => {
     const result = formTagSchema.safeParse({ key: "Env", value: "" })
-    expect(result.success).toBe(true)
+    expect(result.success).toBeTruthy()
   })
 
   it("rejects tag with empty key", () => {
     const result = formTagSchema.safeParse({ key: "", value: "prod" })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 })
 
@@ -410,7 +410,7 @@ describe("createSecurityGroupSchema", () => {
       description: "Allow web traffic",
       vpcId: "vpc-123",
     })
-    expect(result.success).toBe(true)
+    expect(result.success).toBeTruthy()
   })
 
   it("rejects empty group name", () => {
@@ -419,7 +419,7 @@ describe("createSecurityGroupSchema", () => {
       description: "Allow web traffic",
       vpcId: "vpc-123",
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("rejects group name over 255 chars", () => {
@@ -428,7 +428,7 @@ describe("createSecurityGroupSchema", () => {
       description: "Allow web traffic",
       vpcId: "vpc-123",
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("accepts group name at 255 chars", () => {
@@ -437,7 +437,7 @@ describe("createSecurityGroupSchema", () => {
       description: "Allow web traffic",
       vpcId: "vpc-123",
     })
-    expect(result.success).toBe(true)
+    expect(result.success).toBeTruthy()
   })
 
   it("rejects empty description", () => {
@@ -446,7 +446,7 @@ describe("createSecurityGroupSchema", () => {
       description: "",
       vpcId: "vpc-123",
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("rejects description over 255 chars", () => {
@@ -455,7 +455,7 @@ describe("createSecurityGroupSchema", () => {
       description: "a".repeat(256),
       vpcId: "vpc-123",
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("rejects empty vpcId", () => {
@@ -464,7 +464,7 @@ describe("createSecurityGroupSchema", () => {
       description: "Allow web traffic",
       vpcId: "",
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 })
 
@@ -476,7 +476,7 @@ describe("securityGroupRuleSchema", () => {
       toPort: 443,
       cidrIp: "0.0.0.0/0",
     })
-    expect(result.success).toBe(true)
+    expect(result.success).toBeTruthy()
   })
 
   it("accepts all-traffic protocol with port -1", () => {
@@ -486,7 +486,7 @@ describe("securityGroupRuleSchema", () => {
       toPort: -1,
       cidrIp: "10.0.0.0/16",
     })
-    expect(result.success).toBe(true)
+    expect(result.success).toBeTruthy()
   })
 
   it("accepts port 65535 (upper boundary)", () => {
@@ -496,7 +496,7 @@ describe("securityGroupRuleSchema", () => {
       toPort: 65_535,
       cidrIp: "0.0.0.0/0",
     })
-    expect(result.success).toBe(true)
+    expect(result.success).toBeTruthy()
   })
 
   it("rejects port 65536 (above boundary)", () => {
@@ -506,7 +506,7 @@ describe("securityGroupRuleSchema", () => {
       toPort: 443,
       cidrIp: "0.0.0.0/0",
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("rejects port -2 (below boundary)", () => {
@@ -516,7 +516,7 @@ describe("securityGroupRuleSchema", () => {
       toPort: 443,
       cidrIp: "0.0.0.0/0",
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("rejects fractional port", () => {
@@ -526,7 +526,7 @@ describe("securityGroupRuleSchema", () => {
       toPort: 443,
       cidrIp: "0.0.0.0/0",
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("rejects invalid CIDR format", () => {
@@ -536,7 +536,7 @@ describe("securityGroupRuleSchema", () => {
       toPort: 22,
       cidrIp: "not-a-cidr",
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("rejects empty CIDR", () => {
@@ -546,7 +546,7 @@ describe("securityGroupRuleSchema", () => {
       toPort: 22,
       cidrIp: "",
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("rejects empty protocol", () => {
@@ -556,7 +556,7 @@ describe("securityGroupRuleSchema", () => {
       toPort: 22,
       cidrIp: "0.0.0.0/0",
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 })
 
@@ -576,7 +576,7 @@ describe("createVpcWizardSchema", () => {
 
   it("accepts valid vpc-only mode with minimal fields", () => {
     const result = createVpcWizardSchema.safeParse(validBase)
-    expect(result.success).toBe(true)
+    expect(result.success).toBeTruthy()
   })
 
   it("accepts valid vpc-and-more mode", () => {
@@ -586,7 +586,7 @@ describe("createVpcWizardSchema", () => {
       publicSubnetCount: 1,
       privateSubnetCount: 1,
     })
-    expect(result.success).toBe(true)
+    expect(result.success).toBeTruthy()
   })
 
   it("rejects invalid mode", () => {
@@ -594,7 +594,7 @@ describe("createVpcWizardSchema", () => {
       ...validBase,
       mode: "invalid",
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("rejects empty CIDR block", () => {
@@ -602,7 +602,7 @@ describe("createVpcWizardSchema", () => {
       ...validBase,
       cidrBlock: "",
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("rejects invalid CIDR format", () => {
@@ -610,7 +610,7 @@ describe("createVpcWizardSchema", () => {
       ...validBase,
       cidrBlock: "not-a-cidr",
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("rejects CIDR with out-of-range octets", () => {
@@ -618,7 +618,7 @@ describe("createVpcWizardSchema", () => {
       ...validBase,
       cidrBlock: "999.0.0.0/16",
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("rejects CIDR with prefix out of /16-/28 range", () => {
@@ -626,7 +626,7 @@ describe("createVpcWizardSchema", () => {
       ...validBase,
       cidrBlock: "10.0.0.0/8",
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("rejects invalid tenancy", () => {
@@ -634,7 +634,7 @@ describe("createVpcWizardSchema", () => {
       ...validBase,
       tenancy: "shared",
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("rejects publicSubnetCount above 4", () => {
@@ -642,7 +642,7 @@ describe("createVpcWizardSchema", () => {
       ...validBase,
       publicSubnetCount: 5,
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("rejects negative privateSubnetCount", () => {
@@ -650,7 +650,7 @@ describe("createVpcWizardSchema", () => {
       ...validBase,
       privateSubnetCount: -1,
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("rejects fractional subnet count", () => {
@@ -658,7 +658,7 @@ describe("createVpcWizardSchema", () => {
       ...validBase,
       publicSubnetCount: 1.5,
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("rejects invalid custom subnet CIDR in vpc-and-more mode", () => {
@@ -668,7 +668,7 @@ describe("createVpcWizardSchema", () => {
       publicSubnetCount: 1,
       publicSubnetCidrs: ["not-a-cidr"],
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("rejects subnet CIDR outside VPC range", () => {
@@ -678,13 +678,13 @@ describe("createVpcWizardSchema", () => {
       publicSubnetCount: 1,
       publicSubnetCidrs: ["192.168.0.0/20"],
     })
-    expect(result.success).toBe(false)
-    if (!result.success) {
-      const issue = result.error.issues.find(
-        (i) => i.path[0] === "publicSubnetCidrs",
-      )
-      expect(issue?.message).toContain("within the VPC CIDR")
+    if (result.success) {
+      throw new Error("expected validation to fail")
     }
+    const issue = result.error.issues.find(
+      (i) => i.path[0] === "publicSubnetCidrs",
+    )
+    expect(issue?.message).toContain("within the VPC CIDR")
   })
 
   it("rejects overlapping subnet CIDRs", () => {
@@ -696,13 +696,11 @@ describe("createVpcWizardSchema", () => {
       publicSubnetCidrs: ["10.0.0.0/20"],
       privateSubnetCidrs: ["10.0.0.0/20"],
     })
-    expect(result.success).toBe(false)
-    if (!result.success) {
-      const issue = result.error.issues.find((i) =>
-        i.message.includes("overlap"),
-      )
-      expect(issue).toBeDefined()
+    if (result.success) {
+      throw new Error("expected validation to fail")
     }
+    const issue = result.error.issues.find((i) => i.message.includes("overlap"))
+    expect(issue).toBeDefined()
   })
 
   it("accepts valid custom subnet CIDRs within VPC range", () => {
@@ -714,7 +712,7 @@ describe("createVpcWizardSchema", () => {
       publicSubnetCidrs: ["10.0.0.0/20"],
       privateSubnetCidrs: ["10.0.128.0/20"],
     })
-    expect(result.success).toBe(true)
+    expect(result.success).toBeTruthy()
   })
 
   it("skips subnet CIDR validation in vpc-only mode", () => {
@@ -723,7 +721,7 @@ describe("createVpcWizardSchema", () => {
       mode: "vpc-only",
       publicSubnetCidrs: ["not-a-cidr"],
     })
-    expect(result.success).toBe(true)
+    expect(result.success).toBeTruthy()
   })
 
   it("accepts valid tags", () => {
@@ -731,7 +729,7 @@ describe("createVpcWizardSchema", () => {
       ...validBase,
       tags: [{ key: "Env", value: "prod" }],
     })
-    expect(result.success).toBe(true)
+    expect(result.success).toBeTruthy()
   })
 
   it("rejects tags with empty key", () => {
@@ -739,6 +737,6 @@ describe("createVpcWizardSchema", () => {
       ...validBase,
       tags: [{ key: "", value: "prod" }],
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 })

spinifex/services/spinifexui/frontend/src/types/elbv2.test.ts

@@ -29,7 +29,7 @@ describe("createTargetGroupSchema", () => {
       healthCheck: defaultHealthCheck,
       tags: [],
     })
-    expect(result.success).toBe(true)
+    expect(result.success).toBeTruthy()
   })
 
   it("rejects name with invalid characters", () => {
@@ -41,7 +41,7 @@ describe("createTargetGroupSchema", () => {
       healthCheck: defaultHealthCheck,
       tags: [],
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("rejects name >32 chars", () => {
@@ -53,7 +53,7 @@ describe("createTargetGroupSchema", () => {
       healthCheck: defaultHealthCheck,
       tags: [],
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("rejects port out of range", () => {
@@ -65,7 +65,7 @@ describe("createTargetGroupSchema", () => {
       healthCheck: defaultHealthCheck,
       tags: [],
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 })
 
@@ -87,7 +87,7 @@ describe("createLoadBalancerSchema", () => {
       tags: [],
       listener: baseListener,
     })
-    expect(result.success).toBe(true)
+    expect(result.success).toBeTruthy()
   })
 
   it("rejects <2 subnets", () => {
@@ -100,7 +100,7 @@ describe("createLoadBalancerSchema", () => {
       tags: [],
       listener: baseListener,
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("rejects names starting with 'internal-'", () => {
@@ -113,7 +113,7 @@ describe("createLoadBalancerSchema", () => {
       tags: [],
       listener: baseListener,
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("accepts listener with mode=new without existingTargetGroupArn", () => {
@@ -130,7 +130,7 @@ describe("createLoadBalancerSchema", () => {
         targetGroupMode: "new",
       },
     })
-    expect(result.success).toBe(true)
+    expect(result.success).toBeTruthy()
   })
 
   it("rejects listener with mode=existing but no existingTargetGroupArn", () => {
@@ -147,7 +147,7 @@ describe("createLoadBalancerSchema", () => {
         targetGroupMode: "existing",
       },
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 })
 
@@ -158,7 +158,7 @@ describe("createListenerSchema", () => {
       port: 80,
       defaultTargetGroupArn: "arn:tg:1",
     })
-    expect(result.success).toBe(true)
+    expect(result.success).toBeTruthy()
   })
 
   it("rejects listener missing default target group", () => {
@@ -167,7 +167,7 @@ describe("createListenerSchema", () => {
       port: 80,
       defaultTargetGroupArn: "",
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 })
 
@@ -176,18 +176,18 @@ describe("registerTargetsSchema", () => {
     const result = registerTargetsSchema.safeParse({
       targets: [{ instanceId: "i-123" }, { instanceId: "i-456", port: 8080 }],
     })
-    expect(result.success).toBe(true)
+    expect(result.success).toBeTruthy()
   })
 
   it("rejects empty target list", () => {
     const result = registerTargetsSchema.safeParse({ targets: [] })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 })
 
 describe("healthCheckSchema", () => {
   it("accepts the documented default values", () => {
-    expect(healthCheckSchema.parse(defaultHealthCheck)).toEqual(
+    expect(healthCheckSchema.parse(defaultHealthCheck)).toStrictEqual(
       defaultHealthCheck,
     )
   })
@@ -197,7 +197,7 @@ describe("healthCheckSchema", () => {
       ...defaultHealthCheck,
       intervalSeconds: 1,
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("rejects a malformed matcher", () => {
@@ -205,6 +205,6 @@ describe("healthCheckSchema", () => {
       ...defaultHealthCheck,
       matcher: "OK",
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 })

spinifex/services/spinifexui/frontend/src/types/iam.test.ts

@@ -5,27 +5,27 @@ import { createPolicySchema, createUserSchema } from "./iam"
 describe("createUserSchema", () => {
   it("accepts a valid user name", () => {
     const result = createUserSchema.safeParse({ userName: "admin" })
-    expect(result.success).toBe(true)
+    expect(result.success).toBeTruthy()
   })
 
   it("rejects empty user name", () => {
     const result = createUserSchema.safeParse({ userName: "" })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("rejects user name over 64 chars", () => {
     const result = createUserSchema.safeParse({ userName: "a".repeat(65) })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("rejects user name with invalid characters", () => {
     const result = createUserSchema.safeParse({ userName: "user name!" })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("accepts user name with allowed special characters", () => {
     const result = createUserSchema.safeParse({ userName: "user+=,.@-test" })
-    expect(result.success).toBe(true)
+    expect(result.success).toBeTruthy()
   })
 
   it("allows optional path", () => {
@@ -33,7 +33,7 @@ describe("createUserSchema", () => {
       userName: "admin",
       path: "/engineering/",
     })
-    expect(result.success).toBe(true)
+    expect(result.success).toBeTruthy()
   })
 })
 
@@ -43,7 +43,7 @@ describe("createPolicySchema", () => {
       policyName: "ReadOnly",
       policyDocument: '{"Version":"2012-10-17","Statement":[]}',
     })
-    expect(result.success).toBe(true)
+    expect(result.success).toBeTruthy()
   })
 
   it("rejects empty policy name", () => {
@@ -51,7 +51,7 @@ describe("createPolicySchema", () => {
       policyName: "",
       policyDocument: "{}",
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("rejects policy name over 128 chars", () => {
@@ -59,7 +59,7 @@ describe("createPolicySchema", () => {
       policyName: "a".repeat(129),
       policyDocument: "{}",
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("rejects invalid JSON in policy document", () => {
@@ -67,7 +67,7 @@ describe("createPolicySchema", () => {
       policyName: "ReadOnly",
       policyDocument: "not json",
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("rejects empty policy document", () => {
@@ -75,7 +75,7 @@ describe("createPolicySchema", () => {
       policyName: "ReadOnly",
       policyDocument: "",
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("allows optional description", () => {
@@ -84,6 +84,6 @@ describe("createPolicySchema", () => {
       description: "Read-only access",
       policyDocument: "{}",
     })
-    expect(result.success).toBe(true)
+    expect(result.success).toBeTruthy()
   })
 })

spinifex/services/spinifexui/frontend/src/types/s3.test.ts

@@ -5,60 +5,60 @@ import { createBucketSchema } from "./s3"
 describe("createBucketSchema", () => {
   it("accepts a valid bucket name", () => {
     const result = createBucketSchema.safeParse({ bucketName: "my-bucket" })
-    expect(result.success).toBe(true)
+    expect(result.success).toBeTruthy()
   })
 
   it("rejects bucket name under 3 characters", () => {
     const result = createBucketSchema.safeParse({ bucketName: "ab" })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("rejects bucket name over 63 characters", () => {
     const result = createBucketSchema.safeParse({
       bucketName: "a".repeat(64),
     })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("rejects uppercase letters", () => {
     const result = createBucketSchema.safeParse({ bucketName: "MyBucket" })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("rejects names starting with a period", () => {
     const result = createBucketSchema.safeParse({ bucketName: ".my-bucket" })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("rejects names ending with a hyphen", () => {
     const result = createBucketSchema.safeParse({ bucketName: "my-bucket-" })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("rejects consecutive periods", () => {
     const result = createBucketSchema.safeParse({ bucketName: "my..bucket" })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("rejects adjacent period and hyphen", () => {
     const result = createBucketSchema.safeParse({ bucketName: "my.-bucket" })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("rejects adjacent hyphen and period", () => {
     const result = createBucketSchema.safeParse({ bucketName: "my-.bucket" })
-    expect(result.success).toBe(false)
+    expect(result.success).toBeFalsy()
   })
 
   it("accepts bucket name with periods and hyphens", () => {
     const result = createBucketSchema.safeParse({
       bucketName: "my.test-bucket.v2",
     })
-    expect(result.success).toBe(true)
+    expect(result.success).toBeTruthy()
   })
 
   it("accepts all-numeric bucket name", () => {
     const result = createBucketSchema.safeParse({ bucketName: "123" })
-    expect(result.success).toBe(true)
+    expect(result.success).toBeTruthy()
   })
 })

spinifex/services/spinifexui/frontend/vite.config.ts

@@ -43,6 +43,7 @@ export default defineConfig({
     globals: true,
     environment: "happy-dom",
     setupFiles: "./src/test/setup.ts",
+    clearMocks: true,
     coverage: {
       include: ["src/**/*.{ts,tsx}"],
       exclude: [