The Postgres development platform. Supabase gives you a dedicated Postgres database to build your web, mobile, and AI applications.
TypeScript aialternativeauthdatabasedenoembeddingsexamplefirebasenextjsoauth2pgvectorpostgispostgrespostgresqlpostgrestrealtimesupabasevectorswebsockets
import { describe, expect, it } from 'vitest'
import {
COMPUTE_POLL_BASELINE_INTERVAL,
COMPUTE_POLL_TRANSIENT_INTERVAL,
computeInstanceRefetchInterval,
computeRefetchInterval,
parseComputeInstance,
} from './compute.utils'
const datum = (attributes: Record<string, unknown>) => ({
id: 'embed',
type: 'project_compute_instance',
attributes: {
build_state: 'active',
secret_generation: '1',
spec: { exposure: 'private', instances: 1, size: '2gb-1vcpu' },
...attributes,
},
})
describe('parseComputeInstance', () => {
it('maps the API response onto the view model', () => {
expect(
parseComputeInstance(
datum({
spec: { exposure: 'public', instances: 3, runtime: 'node', size: '4gb-2vcpu' },
instances: { declared: 3, live: 3, ready: 2, stale: 0 },
image_version: '1.0',
})
)
).toEqual({
name: 'embed',
buildState: 'active',
isDeleting: false,
runtime: 'node',
size: '4gb-2vcpu',
access: 'public',
declaredInstances: 3,
instances: { declared: 3, live: 3, ready: 2, stale: 0 },
imageVersion: '1.0',
stateReason: undefined,
instancesError: undefined,
})
})
it('treats any exposure other than public as private', () => {
expect(
parseComputeInstance(
datum({ spec: { exposure: 'internal', instances: 1, size: '2gb-1vcpu' } })
)
).toHaveProperty('access', 'private')
})
it('defaults deleting to false when the API omits it', () => {
expect(parseComputeInstance(datum({}))).toHaveProperty('isDeleting', false)
expect(parseComputeInstance(datum({ deleting: true }))).toHaveProperty('isDeleting', true)
})
it('falls back to failed for a build state it does not know', () => {
expect(parseComputeInstance(datum({ build_state: 'exploded' }))).toHaveProperty(
'buildState',
'failed'
)
})
it('rejects a response missing the fields the UI renders', () => {
expect(() => parseComputeInstance({ id: 'embed', attributes: {} })).toThrow()
expect(() => parseComputeInstance(undefined)).toThrow()
})
})
describe('computeRefetchInterval', () => {
const active = parseComputeInstance(datum({}))
const building = parseComputeInstance(datum({ build_state: 'building' }))
const deleting = parseComputeInstance(datum({ deleting: true }))
it('keeps polling once every instance has settled', () => {
expect(computeRefetchInterval([active])).toBe(COMPUTE_POLL_BASELINE_INTERVAL)
expect(computeRefetchInterval([])).toBe(COMPUTE_POLL_BASELINE_INTERVAL)
expect(computeRefetchInterval(undefined)).toBe(COMPUTE_POLL_BASELINE_INTERVAL)
})
it('polls faster while any instance is building or being deleted', () => {
expect(computeRefetchInterval([active, building])).toBe(COMPUTE_POLL_TRANSIENT_INTERVAL)
expect(computeRefetchInterval([active, deleting])).toBe(COMPUTE_POLL_TRANSIENT_INTERVAL)
})
})
describe('computeInstanceRefetchInterval', () => {
it('keeps polling once the instance has settled', () => {
expect(computeInstanceRefetchInterval(parseComputeInstance(datum({})))).toBe(
COMPUTE_POLL_BASELINE_INTERVAL
)
expect(computeInstanceRefetchInterval(undefined)).toBe(COMPUTE_POLL_BASELINE_INTERVAL)
})
it('polls faster while the instance is building or being deleted', () => {
expect(
computeInstanceRefetchInterval(parseComputeInstance(datum({ build_state: 'building' })))
).toBe(COMPUTE_POLL_TRANSIENT_INTERVAL)
expect(computeInstanceRefetchInterval(parseComputeInstance(datum({ deleting: true })))).toBe(
COMPUTE_POLL_TRANSIENT_INTERVAL
)
})
})