Skip to content

The Postgres development platform. Supabase gives you a dedicated Postgres database to build your web, mobile, and AI applications.

7.9 KB
Raw Blame
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)
    }
  })
})