The Postgres development platform. Supabase gives you a dedicated Postgres database to build your web, mobile, and AI applications.
TypeScript aialternativeauthdatabasedenoembeddingsexamplefirebasenextjsoauth2pgvectorpostgispostgrespostgresqlpostgrestrealtimesupabasevectorswebsockets
import { describe, expect, test } from 'vitest'
import {
buildProjectPayload,
buildSsoPayload,
categorizeInviteEmails,
emailSchema,
MAX_BATCH_INVITE_SIZE,
parseEmails,
} from '@/components/interfaces/Organization/TeamSettings/InviteMemberButton.utils'
import type { OrganizationMember } from '@/data/organizations/organization-members-query'
describe('parseEmails', () => {
test('parses a single email', () => {
expect(parseEmails('[email protected]')).toStrictEqual(['[email protected]'])
})
test('parses multiple comma-separated emails', () => {
expect(parseEmails('[email protected],[email protected],[email protected]')).toStrictEqual([
'[email protected]',
'[email protected]',
'[email protected]',
])
})
test('trims whitespace around each email', () => {
expect(parseEmails(' [email protected] , [email protected] ')).toStrictEqual([
'[email protected]',
'[email protected]',
])
})
test('filters out empty entries from trailing, leading, or double commas', () => {
expect(parseEmails(',[email protected],,[email protected],')).toStrictEqual([
'[email protected]',
'[email protected]',
])
})
test('removes duplicate email addresses', () => {
expect(parseEmails('[email protected],[email protected]')).toStrictEqual(['[email protected]'])
})
test.each(['', ' ', ',,,,'])('returns an empty array for %j', (value) => {
expect(parseEmails(value)).toStrictEqual([])
})
test('parses space-separated emails', () => {
expect(parseEmails('[email protected] [email protected]')).toStrictEqual([
'[email protected]',
'[email protected]',
])
})
test('parses line breaks and mixed comma or space separators', () => {
expect(parseEmails('[email protected]\n[email protected], [email protected]')).toStrictEqual([
'[email protected]',
'[email protected]',
'[email protected]',
])
})
})
function makeMember(overrides: Partial<OrganizationMember> = {}): OrganizationMember {
return {
gotrue_id: 'gotrue-1',
primary_email: '[email protected]',
role_ids: [1],
username: 'member',
...overrides,
} as OrganizationMember
}
describe('categorizeInviteEmails', () => {
test('places a new email in toInvite when no members exist', () => {
expect(categorizeInviteEmails(['[email protected]'], [])).toStrictEqual({
alreadyInvited: [],
alreadyMembers: [],
toInvite: ['[email protected]'],
})
})
test('places an email in alreadyMembers when that member exists without an invited_id', () => {
const members = [makeMember({ primary_email: '[email protected]' })]
expect(categorizeInviteEmails(['[email protected]'], members)).toStrictEqual({
alreadyInvited: [],
alreadyMembers: ['[email protected]'],
toInvite: [],
})
})
test('places an email in alreadyInvited when that member has an invited_id', () => {
const members = [makeMember({ primary_email: '[email protected]', invited_id: 42 })]
expect(categorizeInviteEmails(['[email protected]'], members)).toStrictEqual({
alreadyInvited: ['[email protected]'],
alreadyMembers: [],
toInvite: [],
})
})
test('correctly categorizes a mixed batch', () => {
const members = [
makeMember({ primary_email: '[email protected]' }),
makeMember({ primary_email: '[email protected]', invited_id: 7 }),
]
expect(
categorizeInviteEmails(
['[email protected]', '[email protected]', '[email protected]'],
members
)
).toStrictEqual({
alreadyInvited: ['[email protected]'],
alreadyMembers: ['[email protected]'],
toInvite: ['[email protected]'],
})
})
test('returns all-empty for an empty email list', () => {
expect(categorizeInviteEmails([], [makeMember()])).toStrictEqual({
alreadyInvited: [],
alreadyMembers: [],
toInvite: [],
})
})
test('uses strict equality — does not match different casing', () => {
// The component lowercases emails before calling this function,
// so '[email protected]' must NOT match '[email protected]'
const members = [makeMember({ primary_email: '[email protected]' })]
const result = categorizeInviteEmails(['[email protected]'], members)
expect(result.toInvite).toStrictEqual(['[email protected]'])
expect(result.alreadyMembers).toStrictEqual([])
})
})
describe('buildProjectPayload', () => {
test('returns empty object when applyToOrg is true', () => {
expect(buildProjectPayload(true, [])).toStrictEqual({})
})
test('throws an error when applyToOrg is false but no projects are selected', () => {
expect(() => buildProjectPayload(false, [])).toThrowError(
'At least one project is required when applyToOrg is false'
)
})
test('returns all selected projects when applyToOrg is false and multiple are selected', () => {
expect(buildProjectPayload(false, ['ref_abc', 'ref_def', 'ref_ghi'])).toStrictEqual({
projects: ['ref_abc', 'ref_def', 'ref_ghi'],
})
})
})
describe('buildSsoPayload', () => {
test('returns empty object for "auto"', () => {
expect(buildSsoPayload('auto')).toStrictEqual({})
})
test('returns { requireSso: true } for "sso"', () => {
expect(buildSsoPayload('sso')).toStrictEqual({ requireSso: true })
})
test('returns { requireSso: false } for "non-sso"', () => {
expect(buildSsoPayload('non-sso')).toStrictEqual({ requireSso: false })
})
})
function makeEmailList(count: number): string {
return Array.from({ length: count }, (_, i) => `user${i + 1}@example.com`).join(', ')
}
function makeEmailListSpaceSeparated(count: number): string {
return Array.from({ length: count }, (_, i) => `user${i + 1}@example.com`).join(' ')
}
describe('emailSchema', () => {
test('accepts a single valid email', () => {
expect(emailSchema.safeParse('[email protected]').success).toBe(true)
})
test('accepts exactly 50 emails', () => {
expect(emailSchema.safeParse(makeEmailList(MAX_BATCH_INVITE_SIZE)).success).toBe(true)
})
test('rejects 51 emails — singular "address" when exactly 1 needs removing', () => {
const result = emailSchema.safeParse(makeEmailList(51))
expect(result.success).toBe(false)
if (!result.success) {
expect(result.error.issues[0].message).toBe(
'You can invite up to 50 members at a time. Remove 1 email address to continue.'
)
}
})
test('rejects 51 space-separated emails (same as comma-separated batch limit)', () => {
const result = emailSchema.safeParse(makeEmailListSpaceSeparated(51))
expect(result.success).toBe(false)
if (!result.success) {
expect(result.error.issues[0].message).toBe(
'You can invite up to 50 members at a time. Remove 1 email address to continue.'
)
}
})
test('rejects 99 emails — plural "addresses" when more than 1 needs removing', () => {
const result = emailSchema.safeParse(makeEmailList(99))
expect(result.success).toBe(false)
if (!result.success) {
expect(result.error.issues[0].message).toBe(
'You can invite up to 50 members at a time. Remove 49 email addresses to continue.'
)
}
})
test('rejects an empty string', () => {
const result = emailSchema.safeParse('')
expect(result.success).toBe(false)
})
test('rejects an invalid email address and names it', () => {
const result = emailSchema.safeParse('notanemail')
expect(result.success).toBe(false)
if (!result.success) {
expect(result.error.issues[0].message).toBe('Invalid email address: "notanemail"')
}
})
test('truncates a very long invalid token in the error message', () => {
const longToken = `${'x'.repeat(130)}@`
const result = emailSchema.safeParse(longToken)
expect(result.success).toBe(false)
if (!result.success) {
expect(result.error.issues[0].message.startsWith('Invalid email address: "')).toBe(true)
expect(result.error.issues[0].message.endsWith('…"')).toBe(true)
expect(result.error.issues[0].message.length).toBeLessThan(longToken.length + 50)
}
})
})