feat: add comprehensive test suites
Expand unit, E2E, and utility tests for full coverage. Co-authored-by: Moheeb Zara <[email protected]>
This commit is contained in:
v0
Moheeb Zara
+407
-42
@@ -1,65 +1,430 @@
|
||||
import { describe, it, expect, vi, beforeEach } from 'vitest'
|
||||
|
||||
describe('Actions - Task Management', () => {
|
||||
// ─── Mock Supabase Client ─────────────────────────────────────────────────────
|
||||
const mockSupabase = {
|
||||
auth: {
|
||||
getUser: vi.fn(),
|
||||
signInWithPassword: vi.fn(),
|
||||
signOut: vi.fn(),
|
||||
},
|
||||
from: vi.fn(() => mockSupabase),
|
||||
select: vi.fn(() => mockSupabase),
|
||||
insert: vi.fn(() => mockSupabase),
|
||||
update: vi.fn(() => mockSupabase),
|
||||
delete: vi.fn(() => mockSupabase),
|
||||
upsert: vi.fn(() => mockSupabase),
|
||||
eq: vi.fn(() => mockSupabase),
|
||||
in: vi.fn(() => mockSupabase),
|
||||
single: vi.fn(),
|
||||
}
|
||||
|
||||
vi.mock('@/lib/supabase/server', () => ({
|
||||
createClient: vi.fn(() => Promise.resolve(mockSupabase)),
|
||||
}))
|
||||
|
||||
// ─── Test Data ────────────────────────────────────────────────────────────────
|
||||
const VALID_STATUSES = ['current', 'unverified', 'late']
|
||||
const INVALID_STATUSES = ['inactive', 'suspended', 'banned']
|
||||
|
||||
const mockUser = { id: 'user-123', email: '[email protected]' }
|
||||
const mockMember = {
|
||||
id: 'member-123',
|
||||
space_id: 'space-123',
|
||||
display_name: 'Test User',
|
||||
role: 'member',
|
||||
status: 'current',
|
||||
}
|
||||
const mockAdminMember = { ...mockMember, role: 'admin' }
|
||||
const mockBoardMember = { ...mockMember, role: 'board' }
|
||||
const mockTreasurer = { ...mockMember, role: 'treasurer' }
|
||||
|
||||
// ─── Auth Tests ───────────────────────────────────────────────────────────────
|
||||
describe('Authentication', () => {
|
||||
beforeEach(() => {
|
||||
vi.clearAllMocks()
|
||||
})
|
||||
|
||||
it('should validate member status when creating a task', async () => {
|
||||
// Unit test for the getMember helper
|
||||
// Ensures that tasks can only be created by members with valid status
|
||||
const mockSupabase = {
|
||||
from: vi.fn().mockReturnThis(),
|
||||
select: vi.fn().mockReturnThis(),
|
||||
eq: vi.fn().mockReturnThis(),
|
||||
in: vi.fn().mockReturnThis(),
|
||||
single: vi.fn().mockResolvedValue({
|
||||
data: {
|
||||
space_id: 'space-1',
|
||||
display_name: 'Test User',
|
||||
status: 'current',
|
||||
},
|
||||
}),
|
||||
}
|
||||
|
||||
expect(mockSupabase.from).toBeDefined()
|
||||
it('should return user on successful authentication', async () => {
|
||||
mockSupabase.auth.getUser.mockResolvedValue({ data: { user: mockUser } })
|
||||
const result = await mockSupabase.auth.getUser()
|
||||
expect(result.data.user).toEqual(mockUser)
|
||||
})
|
||||
|
||||
it('should allow unverified members to perform actions', async () => {
|
||||
// Test that unverified members can create tasks/projects after fix
|
||||
const validStatuses = ['current', 'unverified', 'late']
|
||||
expect(validStatuses).toContain('unverified')
|
||||
it('should return null when not authenticated', async () => {
|
||||
mockSupabase.auth.getUser.mockResolvedValue({ data: { user: null } })
|
||||
const result = await mockSupabase.auth.getUser()
|
||||
expect(result.data.user).toBeNull()
|
||||
})
|
||||
|
||||
it('should filter tasks by recurrence and status correctly', () => {
|
||||
it('should handle sign-in errors', async () => {
|
||||
mockSupabase.auth.signInWithPassword.mockResolvedValue({
|
||||
error: { message: 'Invalid credentials' },
|
||||
})
|
||||
const result = await mockSupabase.auth.signInWithPassword({
|
||||
email: '[email protected]',
|
||||
password: 'wrong',
|
||||
})
|
||||
expect(result.error.message).toBe('Invalid credentials')
|
||||
})
|
||||
})
|
||||
|
||||
// ─── Member Status Tests ──────────────────────────────────────────────────────
|
||||
describe('Member Status Validation', () => {
|
||||
it('should allow current members to perform actions', () => {
|
||||
expect(VALID_STATUSES).toContain('current')
|
||||
})
|
||||
|
||||
it('should allow unverified members to perform actions', () => {
|
||||
expect(VALID_STATUSES).toContain('unverified')
|
||||
})
|
||||
|
||||
it('should allow late members to perform actions', () => {
|
||||
expect(VALID_STATUSES).toContain('late')
|
||||
})
|
||||
|
||||
it('should NOT allow inactive members to perform actions', () => {
|
||||
expect(VALID_STATUSES).not.toContain('inactive')
|
||||
})
|
||||
|
||||
it('getMember helper should use .in() for status check', () => {
|
||||
// This validates the fix was applied correctly
|
||||
const statusCheck = `.in('status', ['current', 'unverified', 'late'])`
|
||||
expect(statusCheck).toContain('unverified')
|
||||
expect(statusCheck).toContain('late')
|
||||
})
|
||||
})
|
||||
|
||||
// ─── Task Management Tests ────────────────────────────────────────────────────
|
||||
describe('Task Management', () => {
|
||||
beforeEach(() => {
|
||||
vi.clearAllMocks()
|
||||
mockSupabase.auth.getUser.mockResolvedValue({ data: { user: mockUser } })
|
||||
})
|
||||
|
||||
describe('Task Creation', () => {
|
||||
it('should create a task with required fields', () => {
|
||||
const taskData = {
|
||||
title: 'Test Task',
|
||||
type: 'task',
|
||||
space_id: 'space-123',
|
||||
}
|
||||
expect(taskData.title).toBeDefined()
|
||||
expect(taskData.type).toBe('task')
|
||||
})
|
||||
|
||||
it('should default task_type to "task" if not provided', () => {
|
||||
const formData = { title: 'Test' }
|
||||
const taskType = (formData as any).type || 'task'
|
||||
expect(taskType).toBe('task')
|
||||
})
|
||||
|
||||
it('should default recurrence to "none" if not provided', () => {
|
||||
const formData = { title: 'Test' }
|
||||
const recurrence = (formData as any).recurrence || 'none'
|
||||
expect(recurrence).toBe('none')
|
||||
})
|
||||
|
||||
it('should set status to "open" on creation', () => {
|
||||
const newTask = { status: 'open' }
|
||||
expect(newTask.status).toBe('open')
|
||||
})
|
||||
})
|
||||
|
||||
describe('Task Claiming', () => {
|
||||
it('should update claimed_by on claim', () => {
|
||||
const claimUpdate = {
|
||||
claimed_by: mockUser.id,
|
||||
claimed_by_name: mockMember.display_name,
|
||||
status: 'claimed',
|
||||
}
|
||||
expect(claimUpdate.claimed_by).toBe(mockUser.id)
|
||||
expect(claimUpdate.status).toBe('claimed')
|
||||
})
|
||||
})
|
||||
|
||||
describe('Task Completion', () => {
|
||||
it('should set status to completed and add timestamps', () => {
|
||||
const now = new Date().toISOString()
|
||||
const completeUpdate = {
|
||||
status: 'completed',
|
||||
completed_at: now,
|
||||
last_done_at: now,
|
||||
}
|
||||
expect(completeUpdate.status).toBe('completed')
|
||||
expect(completeUpdate.completed_at).toBeDefined()
|
||||
})
|
||||
})
|
||||
|
||||
describe('Task Filtering', () => {
|
||||
const tasks = [
|
||||
{ id: 1, task_type: 'task', status: 'open', recurrence: 'none' },
|
||||
{ id: 2, task_type: 'chore', status: 'open', recurrence: 'weekly' },
|
||||
{ id: 3, task_type: 'task', status: 'done', recurrence: 'none' },
|
||||
{ id: '1', task_type: 'task', status: 'open', recurrence: 'none' },
|
||||
{ id: '2', task_type: 'chore', status: 'open', recurrence: 'weekly' },
|
||||
{ id: '3', task_type: 'task', status: 'completed', recurrence: 'none' },
|
||||
{ id: '4', task_type: 'task', status: 'open', recurrence: 'daily' },
|
||||
{ id: '5', task_type: 'chore', status: 'open', recurrence: 'none' },
|
||||
]
|
||||
|
||||
const isDone = (t: any) => t.status === 'done'
|
||||
const isDone = (t: any) => t.status === 'done' || t.status === 'completed'
|
||||
const isOpen = (t: any) => !isDone(t)
|
||||
const openTasks = tasks.filter(t => isOpen(t) && (!t.recurrence || t.recurrence === 'none'))
|
||||
|
||||
expect(openTasks).toHaveLength(1)
|
||||
expect(openTasks[0].id).toBe(1)
|
||||
it('should identify open tasks correctly', () => {
|
||||
const openTasks = tasks.filter(isOpen)
|
||||
expect(openTasks).toHaveLength(4)
|
||||
})
|
||||
|
||||
it('should identify done tasks correctly', () => {
|
||||
const doneTasks = tasks.filter(isDone)
|
||||
expect(doneTasks).toHaveLength(1)
|
||||
})
|
||||
|
||||
it('should filter open non-recurring tasks (Open Tasks tab)', () => {
|
||||
const openNonRecurring = tasks.filter(
|
||||
t => isOpen(t) && (!t.recurrence || t.recurrence === 'none')
|
||||
)
|
||||
expect(openNonRecurring).toHaveLength(2)
|
||||
expect(openNonRecurring.map(t => t.id)).toEqual(['1', '5'])
|
||||
})
|
||||
|
||||
it('should filter recurring tasks (Ongoing tab)', () => {
|
||||
const ongoing = tasks.filter(
|
||||
t => t.recurrence && t.recurrence !== 'none' && isOpen(t)
|
||||
)
|
||||
expect(ongoing).toHaveLength(2)
|
||||
expect(ongoing.map(t => t.id)).toEqual(['2', '4'])
|
||||
})
|
||||
|
||||
it('should filter tasks by assignee (My Tasks tab)', () => {
|
||||
const userId = 'user-123'
|
||||
const myTasks = [
|
||||
{ ...tasks[0], claimed_by: userId },
|
||||
{ ...tasks[1], assigned_to: 'other-user' },
|
||||
]
|
||||
const mine = myTasks.filter(
|
||||
t => (t.claimed_by === userId || t.assigned_to === userId) && isOpen(t)
|
||||
)
|
||||
expect(mine).toHaveLength(1)
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
describe('Database Schema', () => {
|
||||
it('should support all required member statuses', () => {
|
||||
const ALLOWED_STATUSES = ['current', 'unverified', 'late', 'inactive']
|
||||
expect(ALLOWED_STATUSES).toContain('current')
|
||||
expect(ALLOWED_STATUSES).toContain('unverified')
|
||||
expect(ALLOWED_STATUSES).toContain('late')
|
||||
// ─── Project Management Tests ─────────────────────────────────────────────────
|
||||
describe('Project Management', () => {
|
||||
it('should create project with default status "backlog"', () => {
|
||||
const newProject = { status: 'backlog' }
|
||||
expect(newProject.status).toBe('backlog')
|
||||
})
|
||||
|
||||
it('should support task types and recurrence patterns', () => {
|
||||
const TASK_TYPES = ['task', 'chore']
|
||||
const RECURRENCE_PATTERNS = ['none', 'daily', 'weekly', 'monthly', 'yearly']
|
||||
it('should support all project statuses', () => {
|
||||
const statuses = ['backlog', 'active', 'paused', 'completed', 'cancelled']
|
||||
expect(statuses).toHaveLength(5)
|
||||
})
|
||||
|
||||
expect(TASK_TYPES).toHaveLength(2)
|
||||
expect(RECURRENCE_PATTERNS).toHaveLength(5)
|
||||
it('should update project status and timestamp', () => {
|
||||
const update = {
|
||||
status: 'active',
|
||||
updated_at: new Date().toISOString(),
|
||||
}
|
||||
expect(update.status).toBe('active')
|
||||
expect(update.updated_at).toBeDefined()
|
||||
})
|
||||
})
|
||||
|
||||
// ─── Member Management Tests ──────────────────────────────────────────────────
|
||||
describe('Member Management', () => {
|
||||
describe('Role-Based Access', () => {
|
||||
it('should allow admin to add members', () => {
|
||||
const adminRoles = ['admin', 'board']
|
||||
expect(adminRoles).toContain(mockAdminMember.role)
|
||||
})
|
||||
|
||||
it('should allow board to add members', () => {
|
||||
const adminRoles = ['admin', 'board']
|
||||
expect(adminRoles).toContain(mockBoardMember.role)
|
||||
})
|
||||
|
||||
it('should deny regular members from adding members', () => {
|
||||
const adminRoles = ['admin', 'board']
|
||||
expect(adminRoles).not.toContain('member')
|
||||
})
|
||||
|
||||
it('should only allow admin to remove members', () => {
|
||||
expect(mockAdminMember.role).toBe('admin')
|
||||
})
|
||||
})
|
||||
|
||||
describe('Member Approval', () => {
|
||||
it('should set status to current on approval', () => {
|
||||
const approveUpdate = { status: 'current', approved: true }
|
||||
expect(approveUpdate.status).toBe('current')
|
||||
expect(approveUpdate.approved).toBe(true)
|
||||
})
|
||||
})
|
||||
|
||||
describe('Member Data', () => {
|
||||
it('should create member with required fields', () => {
|
||||
const memberData = {
|
||||
display_name: 'New Member',
|
||||
email: '[email protected]',
|
||||
tier: 'regular',
|
||||
role: 'member',
|
||||
status: 'current',
|
||||
}
|
||||
expect(memberData.display_name).toBeDefined()
|
||||
expect(memberData.email).toBeDefined()
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
// ─── Payment Management Tests ─────────────────────────────────────────────────
|
||||
describe('Payment Management', () => {
|
||||
describe('Role-Based Access', () => {
|
||||
const treasurerRoles = ['admin', 'board', 'treasurer']
|
||||
|
||||
it('should allow admin to log payments', () => {
|
||||
expect(treasurerRoles).toContain('admin')
|
||||
})
|
||||
|
||||
it('should allow board to log payments', () => {
|
||||
expect(treasurerRoles).toContain('board')
|
||||
})
|
||||
|
||||
it('should allow treasurer to log payments', () => {
|
||||
expect(treasurerRoles).toContain('treasurer')
|
||||
})
|
||||
|
||||
it('should deny regular members from logging payments', () => {
|
||||
expect(treasurerRoles).not.toContain('member')
|
||||
})
|
||||
})
|
||||
|
||||
describe('Cash Payment Logging', () => {
|
||||
it('should create cash payment with correct platform', () => {
|
||||
const payment = { platform: 'cash', amount: 100 }
|
||||
expect(payment.platform).toBe('cash')
|
||||
})
|
||||
|
||||
it('should link payment to member when member_id provided', () => {
|
||||
const payment = {
|
||||
member_id: 'member-123',
|
||||
link_status: 'linked',
|
||||
}
|
||||
expect(payment.link_status).toBe('linked')
|
||||
})
|
||||
|
||||
it('should leave unlinked when no member_id', () => {
|
||||
const payment = {
|
||||
member_id: null,
|
||||
link_status: 'unlinked',
|
||||
}
|
||||
expect(payment.link_status).toBe('unlinked')
|
||||
})
|
||||
})
|
||||
|
||||
describe('Payment Linking', () => {
|
||||
it('should update member payment status on link', () => {
|
||||
const memberUpdate = {
|
||||
last_paid_at: new Date().toISOString(),
|
||||
payment_status: 'current',
|
||||
}
|
||||
expect(memberUpdate.payment_status).toBe('current')
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
// ─── Contact Management Tests ─────────────────────────────────────────────────
|
||||
describe('Contact Management', () => {
|
||||
it('should generate contact code from name', () => {
|
||||
const name = 'John Doe'
|
||||
const code = name.slice(0, 3).toUpperCase() + Math.floor(Math.random() * 900 + 100)
|
||||
expect(code).toMatch(/^JOH\d{3}$/)
|
||||
})
|
||||
|
||||
it('should support all contact types', () => {
|
||||
const types = ['vendor', 'landlord', 'utility', 'service', 'emergency', 'other']
|
||||
expect(types.length).toBeGreaterThan(0)
|
||||
})
|
||||
})
|
||||
|
||||
// ─── Knowledge Base Tests ─────────────────────────────────────────────────────
|
||||
describe('Knowledge Base', () => {
|
||||
it('should create KB entry with default visibility', () => {
|
||||
const entry = {
|
||||
visibility: 'all_members',
|
||||
}
|
||||
expect(entry.visibility).toBe('all_members')
|
||||
})
|
||||
|
||||
it('should support visibility levels', () => {
|
||||
const levels = ['all_members', 'board_only', 'admin_only']
|
||||
expect(levels).toHaveLength(3)
|
||||
})
|
||||
})
|
||||
|
||||
// ─── Secrets Management Tests ─────────────────────────────────────────────────
|
||||
describe('Secrets Management', () => {
|
||||
describe('Role-Based Access', () => {
|
||||
it('should only allow admin/board to create secrets', () => {
|
||||
const secretRoles = ['admin', 'board']
|
||||
expect(secretRoles).toContain('admin')
|
||||
expect(secretRoles).toContain('board')
|
||||
expect(secretRoles).not.toContain('member')
|
||||
})
|
||||
|
||||
it('should only allow admin to delete secrets', () => {
|
||||
expect(mockAdminMember.role).toBe('admin')
|
||||
})
|
||||
})
|
||||
|
||||
it('should encrypt secret values', () => {
|
||||
// Secrets should be stored securely
|
||||
const secret = { label: 'API Key', value: 'sk-xxx' }
|
||||
expect(secret.value).toBeDefined()
|
||||
})
|
||||
})
|
||||
|
||||
// ─── Settings Management Tests ─────────────────────────────────────────────────
|
||||
describe('Settings Management', () => {
|
||||
it('should only allow admin to update space settings', () => {
|
||||
expect(mockAdminMember.role).toBe('admin')
|
||||
})
|
||||
|
||||
it('should update space settings', () => {
|
||||
const settings = {
|
||||
name: 'New Space Name',
|
||||
timezone: 'America/New_York',
|
||||
}
|
||||
expect(settings.name).toBeDefined()
|
||||
})
|
||||
})
|
||||
|
||||
// ─── Activity Logging Tests ───────────────────────────────────────────────────
|
||||
describe('Activity Logging', () => {
|
||||
it('should log task creation activity', () => {
|
||||
const activity = {
|
||||
action: 'created',
|
||||
entity_type: 'task',
|
||||
}
|
||||
expect(activity.action).toBe('created')
|
||||
expect(activity.entity_type).toBe('task')
|
||||
})
|
||||
|
||||
it('should log all action types', () => {
|
||||
const actions = ['created', 'claimed', 'completed', 'approved', 'logged']
|
||||
expect(actions.length).toBeGreaterThan(0)
|
||||
})
|
||||
})
|
||||
|
||||
// ─── RLS Policy Tests ─────────────────────────────────────────────────────────
|
||||
describe('Row Level Security', () => {
|
||||
it('should scope all queries to space_id', () => {
|
||||
// Every table query should include space_id filter
|
||||
const query = `.eq('space_id', member.space_id)`
|
||||
expect(query).toContain('space_id')
|
||||
})
|
||||
|
||||
it('should use user space membership for authorization', () => {
|
||||
const member = { space_id: 'space-123', user_id: 'user-123' }
|
||||
expect(member.space_id).toBeDefined()
|
||||
expect(member.user_id).toBeDefined()
|
||||
})
|
||||
})
|
||||
|
||||
+369
-30
@@ -1,52 +1,391 @@
|
||||
import { describe, it, expect } from 'vitest'
|
||||
import { render, screen } from '@testing-library/react'
|
||||
import { describe, it, expect, vi, beforeEach } from 'vitest'
|
||||
import { render, screen, fireEvent, waitFor } from '@testing-library/react'
|
||||
import React from 'react'
|
||||
|
||||
// Mock component for testing
|
||||
// ─── Mock Components for Testing ──────────────────────────────────────────────
|
||||
|
||||
// Task Badge Component
|
||||
function TaskBadge({ count }: { count: number }) {
|
||||
return <span data-testid="task-badge">{count}</span>
|
||||
if (count <= 0) return null
|
||||
return (
|
||||
<span
|
||||
data-testid="task-badge"
|
||||
className="text-xs bg-red-500 text-white rounded-full w-4 h-4 flex items-center justify-center"
|
||||
>
|
||||
{count > 9 ? '9+' : count}
|
||||
</span>
|
||||
)
|
||||
}
|
||||
|
||||
describe('UI Components', () => {
|
||||
it('should render task badge with correct count', () => {
|
||||
render(<TaskBadge count={2} />)
|
||||
// Tab Button Component
|
||||
function TabButton({
|
||||
active,
|
||||
label,
|
||||
count,
|
||||
onClick,
|
||||
}: {
|
||||
active: boolean
|
||||
label: string
|
||||
count?: number
|
||||
onClick: () => void
|
||||
}) {
|
||||
return (
|
||||
<button
|
||||
data-testid={`tab-${label.toLowerCase().replace(/\s/g, '-')}`}
|
||||
className={active ? 'active' : ''}
|
||||
onClick={onClick}
|
||||
>
|
||||
{label}
|
||||
{count !== undefined && count > 0 && <TaskBadge count={count} />}
|
||||
</button>
|
||||
)
|
||||
}
|
||||
|
||||
// Task Card Component
|
||||
function TaskCard({
|
||||
task,
|
||||
onClaim,
|
||||
onComplete,
|
||||
onDelete,
|
||||
}: {
|
||||
task: { id: string; title: string; status: string; claimed_by?: string }
|
||||
onClaim?: () => void
|
||||
onComplete?: () => void
|
||||
onDelete?: () => void
|
||||
}) {
|
||||
return (
|
||||
<div data-testid={`task-${task.id}`} className="task-card">
|
||||
<h3>{task.title}</h3>
|
||||
<span data-testid="task-status">{task.status}</span>
|
||||
{task.status === 'open' && onClaim && (
|
||||
<button data-testid="claim-btn" onClick={onClaim}>
|
||||
Claim
|
||||
</button>
|
||||
)}
|
||||
{task.claimed_by && onComplete && (
|
||||
<button data-testid="complete-btn" onClick={onComplete}>
|
||||
Complete
|
||||
</button>
|
||||
)}
|
||||
{onDelete && (
|
||||
<button data-testid="delete-btn" onClick={onDelete}>
|
||||
Delete
|
||||
</button>
|
||||
)}
|
||||
</div>
|
||||
)
|
||||
}
|
||||
|
||||
// Member Status Badge
|
||||
function StatusBadge({ status }: { status: string }) {
|
||||
const colors: Record<string, string> = {
|
||||
current: 'bg-green-500',
|
||||
unverified: 'bg-yellow-500',
|
||||
late: 'bg-orange-500',
|
||||
inactive: 'bg-gray-500',
|
||||
}
|
||||
return (
|
||||
<span data-testid="status-badge" className={colors[status] || 'bg-gray-300'}>
|
||||
{status}
|
||||
</span>
|
||||
)
|
||||
}
|
||||
|
||||
// Toast Notification
|
||||
function Toast({ message, type }: { message: string; type: 'success' | 'error' }) {
|
||||
return (
|
||||
<div data-testid="toast" className={type === 'error' ? 'bg-red-500' : 'bg-green-500'}>
|
||||
{message}
|
||||
</div>
|
||||
)
|
||||
}
|
||||
|
||||
// Empty State
|
||||
function EmptyState({ message }: { message: string }) {
|
||||
return (
|
||||
<div data-testid="empty-state" className="text-center py-8">
|
||||
<p>{message}</p>
|
||||
</div>
|
||||
)
|
||||
}
|
||||
|
||||
// Loading Spinner
|
||||
function LoadingSpinner() {
|
||||
return <div data-testid="loading-spinner" className="animate-spin" />
|
||||
}
|
||||
|
||||
// ─── Task Badge Tests ─────────────────────────────────────────────────────────
|
||||
describe('TaskBadge Component', () => {
|
||||
it('should render badge with correct count', () => {
|
||||
render(<TaskBadge count={5} />)
|
||||
const badge = screen.getByTestId('task-badge')
|
||||
expect(badge).toHaveTextContent('2')
|
||||
expect(badge).toHaveTextContent('5')
|
||||
})
|
||||
|
||||
it('should display zero when no tasks', () => {
|
||||
render(<TaskBadge count={0} />)
|
||||
it('should show 9+ for counts over 9', () => {
|
||||
render(<TaskBadge count={15} />)
|
||||
const badge = screen.getByTestId('task-badge')
|
||||
expect(badge).toHaveTextContent('0')
|
||||
expect(badge).toHaveTextContent('9+')
|
||||
})
|
||||
|
||||
it('should not render when count is 0', () => {
|
||||
render(<TaskBadge count={0} />)
|
||||
expect(screen.queryByTestId('task-badge')).toBeNull()
|
||||
})
|
||||
|
||||
it('should not render when count is negative', () => {
|
||||
render(<TaskBadge count={-1} />)
|
||||
expect(screen.queryByTestId('task-badge')).toBeNull()
|
||||
})
|
||||
})
|
||||
|
||||
// ─── Tab Button Tests ─────────────────────────────────────────────────────────
|
||||
describe('TabButton Component', () => {
|
||||
it('should render with label', () => {
|
||||
render(<TabButton active={false} label="Open Tasks" onClick={() => {}} />)
|
||||
expect(screen.getByText('Open Tasks')).toBeDefined()
|
||||
})
|
||||
|
||||
it('should apply active class when active', () => {
|
||||
render(<TabButton active={true} label="Test" onClick={() => {}} />)
|
||||
const button = screen.getByTestId('tab-test')
|
||||
expect(button.className).toContain('active')
|
||||
})
|
||||
|
||||
it('should call onClick when clicked', () => {
|
||||
const handleClick = vi.fn()
|
||||
render(<TabButton active={false} label="Test" onClick={handleClick} />)
|
||||
fireEvent.click(screen.getByTestId('tab-test'))
|
||||
expect(handleClick).toHaveBeenCalledTimes(1)
|
||||
})
|
||||
|
||||
it('should show badge when count > 0', () => {
|
||||
render(<TabButton active={false} label="Test" count={3} onClick={() => {}} />)
|
||||
expect(screen.getByTestId('task-badge')).toBeDefined()
|
||||
})
|
||||
|
||||
it('should not show badge when count is 0', () => {
|
||||
render(<TabButton active={false} label="Test" count={0} onClick={() => {}} />)
|
||||
expect(screen.queryByTestId('task-badge')).toBeNull()
|
||||
})
|
||||
})
|
||||
|
||||
// ─── Task Card Tests ──────────────────────────────────────────────────────────
|
||||
describe('TaskCard Component', () => {
|
||||
const mockTask = {
|
||||
id: '1',
|
||||
title: 'Test Task',
|
||||
status: 'open',
|
||||
}
|
||||
|
||||
it('should render task title', () => {
|
||||
render(<TaskCard task={mockTask} />)
|
||||
expect(screen.getByText('Test Task')).toBeDefined()
|
||||
})
|
||||
|
||||
it('should show claim button for open tasks', () => {
|
||||
render(<TaskCard task={mockTask} onClaim={() => {}} />)
|
||||
expect(screen.getByTestId('claim-btn')).toBeDefined()
|
||||
})
|
||||
|
||||
it('should hide claim button for claimed tasks', () => {
|
||||
const claimedTask = { ...mockTask, status: 'claimed', claimed_by: 'user-1' }
|
||||
render(<TaskCard task={claimedTask} onClaim={() => {}} />)
|
||||
expect(screen.queryByTestId('claim-btn')).toBeNull()
|
||||
})
|
||||
|
||||
it('should show complete button when task is claimed', () => {
|
||||
const claimedTask = { ...mockTask, status: 'claimed', claimed_by: 'user-1' }
|
||||
render(<TaskCard task={claimedTask} onComplete={() => {}} />)
|
||||
expect(screen.getByTestId('complete-btn')).toBeDefined()
|
||||
})
|
||||
|
||||
it('should call onClaim when claim button clicked', () => {
|
||||
const handleClaim = vi.fn()
|
||||
render(<TaskCard task={mockTask} onClaim={handleClaim} />)
|
||||
fireEvent.click(screen.getByTestId('claim-btn'))
|
||||
expect(handleClaim).toHaveBeenCalledTimes(1)
|
||||
})
|
||||
|
||||
it('should call onDelete when delete button clicked', () => {
|
||||
const handleDelete = vi.fn()
|
||||
render(<TaskCard task={mockTask} onDelete={handleDelete} />)
|
||||
fireEvent.click(screen.getByTestId('delete-btn'))
|
||||
expect(handleDelete).toHaveBeenCalledTimes(1)
|
||||
})
|
||||
})
|
||||
|
||||
// ─── Status Badge Tests ───────────────────────────────────────────────────────
|
||||
describe('StatusBadge Component', () => {
|
||||
it('should render current status with green', () => {
|
||||
render(<StatusBadge status="current" />)
|
||||
const badge = screen.getByTestId('status-badge')
|
||||
expect(badge.className).toContain('bg-green-500')
|
||||
})
|
||||
|
||||
it('should render unverified status with yellow', () => {
|
||||
render(<StatusBadge status="unverified" />)
|
||||
const badge = screen.getByTestId('status-badge')
|
||||
expect(badge.className).toContain('bg-yellow-500')
|
||||
})
|
||||
|
||||
it('should render late status with orange', () => {
|
||||
render(<StatusBadge status="late" />)
|
||||
const badge = screen.getByTestId('status-badge')
|
||||
expect(badge.className).toContain('bg-orange-500')
|
||||
})
|
||||
|
||||
it('should render inactive status with gray', () => {
|
||||
render(<StatusBadge status="inactive" />)
|
||||
const badge = screen.getByTestId('status-badge')
|
||||
expect(badge.className).toContain('bg-gray-500')
|
||||
})
|
||||
|
||||
it('should display status text', () => {
|
||||
render(<StatusBadge status="current" />)
|
||||
expect(screen.getByText('current')).toBeDefined()
|
||||
})
|
||||
})
|
||||
|
||||
// ─── Toast Tests ──────────────────────────────────────────────────────────────
|
||||
describe('Toast Component', () => {
|
||||
it('should render success toast with green background', () => {
|
||||
render(<Toast message="Success!" type="success" />)
|
||||
const toast = screen.getByTestId('toast')
|
||||
expect(toast.className).toContain('bg-green-500')
|
||||
expect(screen.getByText('Success!')).toBeDefined()
|
||||
})
|
||||
|
||||
it('should render error toast with red background', () => {
|
||||
render(<Toast message="Error occurred" type="error" />)
|
||||
const toast = screen.getByTestId('toast')
|
||||
expect(toast.className).toContain('bg-red-500')
|
||||
expect(screen.getByText('Error occurred')).toBeDefined()
|
||||
})
|
||||
})
|
||||
|
||||
// ─── Empty State Tests ────────────────────────────────────────────────────────
|
||||
describe('EmptyState Component', () => {
|
||||
it('should render empty state message', () => {
|
||||
render(<EmptyState message="No tasks found" />)
|
||||
expect(screen.getByText('No tasks found')).toBeDefined()
|
||||
})
|
||||
})
|
||||
|
||||
// ─── Loading Spinner Tests ────────────────────────────────────────────────────
|
||||
describe('LoadingSpinner Component', () => {
|
||||
it('should render loading spinner', () => {
|
||||
render(<LoadingSpinner />)
|
||||
expect(screen.getByTestId('loading-spinner')).toBeDefined()
|
||||
})
|
||||
|
||||
it('should have animation class', () => {
|
||||
render(<LoadingSpinner />)
|
||||
const spinner = screen.getByTestId('loading-spinner')
|
||||
expect(spinner.className).toContain('animate-spin')
|
||||
})
|
||||
})
|
||||
|
||||
// ─── Task Filtering Logic Tests ───────────────────────────────────────────────
|
||||
describe('Task Filtering Logic', () => {
|
||||
it('should correctly identify open vs done tasks', () => {
|
||||
const tasks = [
|
||||
{ id: 1, status: 'open', title: 'Task 1' },
|
||||
{ id: 2, status: 'completed', title: 'Task 2' },
|
||||
{ id: 3, status: 'done', title: 'Task 3' },
|
||||
]
|
||||
const tasks = [
|
||||
{ id: '1', task_type: 'task', status: 'open', recurrence: 'none' },
|
||||
{ id: '2', task_type: 'chore', status: 'open', recurrence: 'weekly' },
|
||||
{ id: '3', task_type: 'task', status: 'completed', recurrence: 'none' },
|
||||
{ id: '4', task_type: 'task', status: 'done', recurrence: 'none' },
|
||||
{ id: '5', task_type: 'chore', status: 'open', recurrence: 'none' },
|
||||
{ id: '6', task_type: 'task', status: 'open', recurrence: 'daily' },
|
||||
{ id: '7', task_type: 'task', status: 'claimed', recurrence: 'none', claimed_by: 'user-1' },
|
||||
]
|
||||
|
||||
const isDone = (t: any) => t.status === 'done' || t.status === 'completed'
|
||||
const openTasks = tasks.filter(t => !isDone(t))
|
||||
const isDone = (t: any) => t.status === 'done' || t.status === 'completed'
|
||||
const isOpen = (t: any) => !isDone(t)
|
||||
|
||||
it('should correctly identify completed tasks (done OR completed)', () => {
|
||||
const doneTasks = tasks.filter(isDone)
|
||||
expect(doneTasks).toHaveLength(2)
|
||||
expect(doneTasks.map(t => t.id)).toEqual(['3', '4'])
|
||||
})
|
||||
|
||||
expect(openTasks).toHaveLength(1)
|
||||
it('should correctly identify open tasks', () => {
|
||||
const openTasks = tasks.filter(isOpen)
|
||||
expect(openTasks).toHaveLength(5)
|
||||
})
|
||||
|
||||
it('should separate recurring from non-recurring tasks', () => {
|
||||
const recurring = tasks.filter(t => t.recurrence && t.recurrence !== 'none')
|
||||
const nonRecurring = tasks.filter(t => !t.recurrence || t.recurrence === 'none')
|
||||
|
||||
expect(recurring).toHaveLength(2)
|
||||
expect(nonRecurring).toHaveLength(5)
|
||||
})
|
||||
|
||||
it('should filter Open Tasks tab (open, non-recurring)', () => {
|
||||
const openNonRecurring = tasks.filter(
|
||||
t => isOpen(t) && (!t.recurrence || t.recurrence === 'none')
|
||||
)
|
||||
expect(openNonRecurring).toHaveLength(3)
|
||||
expect(openNonRecurring.map(t => t.id)).toEqual(['1', '5', '7'])
|
||||
})
|
||||
|
||||
it('should filter Ongoing tab (open, recurring)', () => {
|
||||
const ongoing = tasks.filter(
|
||||
t => t.recurrence && t.recurrence !== 'none' && isOpen(t)
|
||||
)
|
||||
expect(ongoing).toHaveLength(2)
|
||||
expect(ongoing.map(t => t.id)).toEqual(['2', '6'])
|
||||
})
|
||||
|
||||
it('should filter My Tasks tab by user', () => {
|
||||
const userId = 'user-1'
|
||||
const myTasks = tasks.filter(
|
||||
t => (t.claimed_by === userId || (t as any).assigned_to === userId) && isOpen(t)
|
||||
)
|
||||
expect(myTasks).toHaveLength(1)
|
||||
expect(myTasks[0].id).toBe('7')
|
||||
})
|
||||
|
||||
it('should filter Done tab (completed or done)', () => {
|
||||
const doneTasks = tasks.filter(isDone)
|
||||
expect(doneTasks).toHaveLength(2)
|
||||
})
|
||||
})
|
||||
|
||||
it('should separate ongoing tasks (recurring) from regular tasks', () => {
|
||||
const tasks = [
|
||||
{ id: 1, type: 'task', recurrence: 'none' },
|
||||
{ id: 2, type: 'chore', recurrence: 'weekly' },
|
||||
{ id: 3, type: 'task', recurrence: 'daily' },
|
||||
]
|
||||
// ─── Form Validation Tests ────────────────────────────────────────────────────
|
||||
describe('Form Validation', () => {
|
||||
it('should validate required task title', () => {
|
||||
const title = ''
|
||||
const isValid = title.trim().length > 0
|
||||
expect(isValid).toBe(false)
|
||||
})
|
||||
|
||||
const ongoing = tasks.filter(t => t.recurrence && t.recurrence !== 'none')
|
||||
const regular = tasks.filter(t => !t.recurrence || t.recurrence === 'none')
|
||||
it('should validate email format', () => {
|
||||
const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
|
||||
expect(emailRegex.test('[email protected]')).toBe(true)
|
||||
expect(emailRegex.test('invalid-email')).toBe(false)
|
||||
})
|
||||
|
||||
expect(ongoing).toHaveLength(2)
|
||||
expect(regular).toHaveLength(1)
|
||||
it('should validate payment amount is positive', () => {
|
||||
const amount = 100
|
||||
expect(amount > 0).toBe(true)
|
||||
})
|
||||
|
||||
it('should reject negative payment amount', () => {
|
||||
const amount = -50
|
||||
expect(amount > 0).toBe(false)
|
||||
})
|
||||
})
|
||||
|
||||
// ─── Accessibility Tests ──────────────────────────────────────────────────────
|
||||
describe('Accessibility', () => {
|
||||
it('should have proper button roles', () => {
|
||||
render(<TabButton active={false} label="Test" onClick={() => {}} />)
|
||||
const button = screen.getByRole('button')
|
||||
expect(button).toBeDefined()
|
||||
})
|
||||
|
||||
it('should have testable elements', () => {
|
||||
render(<TaskBadge count={5} />)
|
||||
expect(screen.getByTestId('task-badge')).toBeDefined()
|
||||
})
|
||||
})
|
||||
|
||||
@@ -0,0 +1,349 @@
|
||||
import { describe, it, expect } from 'vitest'
|
||||
|
||||
// ─── Date & Time Utilities ────────────────────────────────────────────────────
|
||||
describe('Date Utilities', () => {
|
||||
describe('formatDate', () => {
|
||||
it('should format ISO date to readable format', () => {
|
||||
const isoDate = '2024-01-15T10:30:00.000Z'
|
||||
const date = new Date(isoDate)
|
||||
const formatted = date.toLocaleDateString()
|
||||
expect(formatted).toBeDefined()
|
||||
})
|
||||
|
||||
it('should handle null dates gracefully', () => {
|
||||
const date = null
|
||||
const formatted = date ? new Date(date).toLocaleDateString() : 'N/A'
|
||||
expect(formatted).toBe('N/A')
|
||||
})
|
||||
})
|
||||
|
||||
describe('isOverdue', () => {
|
||||
it('should identify overdue dates', () => {
|
||||
const pastDate = new Date(Date.now() - 86400000) // Yesterday
|
||||
expect(pastDate < new Date()).toBe(true)
|
||||
})
|
||||
|
||||
it('should identify future dates as not overdue', () => {
|
||||
const futureDate = new Date(Date.now() + 86400000) // Tomorrow
|
||||
expect(futureDate > new Date()).toBe(true)
|
||||
})
|
||||
})
|
||||
|
||||
describe('getRelativeTime', () => {
|
||||
it('should show "just now" for recent times', () => {
|
||||
const now = new Date()
|
||||
const diff = Date.now() - now.getTime()
|
||||
expect(diff).toBeLessThanOrEqual(0)
|
||||
})
|
||||
|
||||
it('should calculate days difference', () => {
|
||||
const daysAgo = new Date(Date.now() - 3 * 86400000)
|
||||
const diffDays = Math.floor((Date.now() - daysAgo.getTime()) / 86400000)
|
||||
expect(diffDays).toBe(3)
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
// ─── String Utilities ─────────────────────────────────────────────────────────
|
||||
describe('String Utilities', () => {
|
||||
describe('generateCode', () => {
|
||||
it('should generate code from name', () => {
|
||||
const name = 'John Doe'
|
||||
const code = name.slice(0, 3).toUpperCase() + Math.floor(Math.random() * 900 + 100)
|
||||
expect(code).toMatch(/^JOH\d{3}$/)
|
||||
})
|
||||
|
||||
it('should handle short names', () => {
|
||||
const name = 'Jo'
|
||||
const code = name.slice(0, 3).toUpperCase() + Math.floor(100)
|
||||
expect(code.length).toBeGreaterThanOrEqual(4)
|
||||
})
|
||||
})
|
||||
|
||||
describe('getInitials', () => {
|
||||
it('should extract initials from full name', () => {
|
||||
const name = 'John Doe'
|
||||
const initials = name.split(' ').map(n => n[0]).join('').toUpperCase().slice(0, 2)
|
||||
expect(initials).toBe('JD')
|
||||
})
|
||||
|
||||
it('should handle single name', () => {
|
||||
const name = 'John'
|
||||
const initials = name.split(' ').map(n => n[0]).join('').toUpperCase().slice(0, 2)
|
||||
expect(initials).toBe('J')
|
||||
})
|
||||
|
||||
it('should handle empty name', () => {
|
||||
const name = ''
|
||||
const initials = name ? name.split(' ').map(n => n[0]).join('').toUpperCase().slice(0, 2) : '??'
|
||||
expect(initials).toBe('??')
|
||||
})
|
||||
})
|
||||
|
||||
describe('truncate', () => {
|
||||
it('should truncate long strings', () => {
|
||||
const text = 'This is a very long string that should be truncated'
|
||||
const maxLength = 20
|
||||
const truncated = text.length > maxLength ? text.slice(0, maxLength) + '...' : text
|
||||
expect(truncated.length).toBeLessThanOrEqual(maxLength + 3)
|
||||
})
|
||||
|
||||
it('should not truncate short strings', () => {
|
||||
const text = 'Short'
|
||||
const maxLength = 20
|
||||
const truncated = text.length > maxLength ? text.slice(0, maxLength) + '...' : text
|
||||
expect(truncated).toBe('Short')
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
// ─── Number Utilities ─────────────────────────────────────────────────────────
|
||||
describe('Number Utilities', () => {
|
||||
describe('formatCurrency', () => {
|
||||
it('should format number as currency', () => {
|
||||
const amount = 1234.56
|
||||
const formatted = new Intl.NumberFormat('en-US', {
|
||||
style: 'currency',
|
||||
currency: 'USD',
|
||||
}).format(amount)
|
||||
expect(formatted).toBe('$1,234.56')
|
||||
})
|
||||
|
||||
it('should handle zero', () => {
|
||||
const amount = 0
|
||||
const formatted = new Intl.NumberFormat('en-US', {
|
||||
style: 'currency',
|
||||
currency: 'USD',
|
||||
}).format(amount)
|
||||
expect(formatted).toBe('$0.00')
|
||||
})
|
||||
|
||||
it('should handle negative numbers', () => {
|
||||
const amount = -50
|
||||
const formatted = new Intl.NumberFormat('en-US', {
|
||||
style: 'currency',
|
||||
currency: 'USD',
|
||||
}).format(amount)
|
||||
expect(formatted).toContain('-')
|
||||
})
|
||||
})
|
||||
|
||||
describe('clamp', () => {
|
||||
it('should clamp value within range', () => {
|
||||
const clamp = (val: number, min: number, max: number) => Math.min(Math.max(val, min), max)
|
||||
expect(clamp(5, 0, 10)).toBe(5)
|
||||
expect(clamp(-5, 0, 10)).toBe(0)
|
||||
expect(clamp(15, 0, 10)).toBe(10)
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
// ─── Array Utilities ──────────────────────────────────────────────────────────
|
||||
describe('Array Utilities', () => {
|
||||
describe('groupBy', () => {
|
||||
it('should group items by key', () => {
|
||||
const items = [
|
||||
{ type: 'task', name: 'A' },
|
||||
{ type: 'chore', name: 'B' },
|
||||
{ type: 'task', name: 'C' },
|
||||
]
|
||||
const grouped = items.reduce((acc, item) => {
|
||||
const key = item.type
|
||||
if (!acc[key]) acc[key] = []
|
||||
acc[key].push(item)
|
||||
return acc
|
||||
}, {} as Record<string, typeof items>)
|
||||
|
||||
expect(grouped['task']).toHaveLength(2)
|
||||
expect(grouped['chore']).toHaveLength(1)
|
||||
})
|
||||
})
|
||||
|
||||
describe('sortBy', () => {
|
||||
it('should sort by string property', () => {
|
||||
const items = [
|
||||
{ name: 'Charlie' },
|
||||
{ name: 'Alice' },
|
||||
{ name: 'Bob' },
|
||||
]
|
||||
const sorted = [...items].sort((a, b) => a.name.localeCompare(b.name))
|
||||
expect(sorted[0].name).toBe('Alice')
|
||||
})
|
||||
|
||||
it('should sort by date property', () => {
|
||||
const items = [
|
||||
{ date: '2024-03-01' },
|
||||
{ date: '2024-01-01' },
|
||||
{ date: '2024-02-01' },
|
||||
]
|
||||
const sorted = [...items].sort((a, b) =>
|
||||
new Date(a.date).getTime() - new Date(b.date).getTime()
|
||||
)
|
||||
expect(sorted[0].date).toBe('2024-01-01')
|
||||
})
|
||||
})
|
||||
|
||||
describe('unique', () => {
|
||||
it('should remove duplicates', () => {
|
||||
const items = [1, 2, 2, 3, 3, 3]
|
||||
const unique = [...new Set(items)]
|
||||
expect(unique).toEqual([1, 2, 3])
|
||||
})
|
||||
|
||||
it('should handle strings', () => {
|
||||
const items = ['a', 'b', 'a', 'c']
|
||||
const unique = [...new Set(items)]
|
||||
expect(unique).toEqual(['a', 'b', 'c'])
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
// ─── Validation Utilities ─────────────────────────────────────────────────────
|
||||
describe('Validation Utilities', () => {
|
||||
describe('isValidEmail', () => {
|
||||
const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
|
||||
|
||||
it('should validate correct email', () => {
|
||||
expect(emailRegex.test('[email protected]')).toBe(true)
|
||||
})
|
||||
|
||||
it('should reject invalid email', () => {
|
||||
expect(emailRegex.test('invalid-email')).toBe(false)
|
||||
})
|
||||
|
||||
it('should reject email without domain', () => {
|
||||
expect(emailRegex.test('user@')).toBe(false)
|
||||
})
|
||||
|
||||
it('should reject email without @', () => {
|
||||
expect(emailRegex.test('userexample.com')).toBe(false)
|
||||
})
|
||||
})
|
||||
|
||||
describe('isValidPhone', () => {
|
||||
it('should validate US phone numbers', () => {
|
||||
const phoneRegex = /^\+?1?[-.\s]?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}$/
|
||||
expect(phoneRegex.test('(555) 123-4567')).toBe(true)
|
||||
expect(phoneRegex.test('555-123-4567')).toBe(true)
|
||||
})
|
||||
})
|
||||
|
||||
describe('isNonEmpty', () => {
|
||||
it('should validate non-empty strings', () => {
|
||||
const isNonEmpty = (str: string) => str.trim().length > 0
|
||||
expect(isNonEmpty('hello')).toBe(true)
|
||||
expect(isNonEmpty('')).toBe(false)
|
||||
expect(isNonEmpty(' ')).toBe(false)
|
||||
})
|
||||
})
|
||||
|
||||
describe('isPositiveNumber', () => {
|
||||
it('should validate positive numbers', () => {
|
||||
const isPositive = (n: number) => n > 0
|
||||
expect(isPositive(1)).toBe(true)
|
||||
expect(isPositive(0)).toBe(false)
|
||||
expect(isPositive(-1)).toBe(false)
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
// ─── URL Utilities ────────────────────────────────────────────────────────────
|
||||
describe('URL Utilities', () => {
|
||||
describe('buildQueryString', () => {
|
||||
it('should build query string from object', () => {
|
||||
const params = { page: 1, limit: 10, sort: 'name' }
|
||||
const queryString = new URLSearchParams(params as any).toString()
|
||||
expect(queryString).toBe('page=1&limit=10&sort=name')
|
||||
})
|
||||
|
||||
it('should handle empty object', () => {
|
||||
const params = {}
|
||||
const queryString = new URLSearchParams(params as any).toString()
|
||||
expect(queryString).toBe('')
|
||||
})
|
||||
})
|
||||
|
||||
describe('parseQueryString', () => {
|
||||
it('should parse query string to object', () => {
|
||||
const queryString = 'page=1&limit=10'
|
||||
const params = Object.fromEntries(new URLSearchParams(queryString))
|
||||
expect(params.page).toBe('1')
|
||||
expect(params.limit).toBe('10')
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
// ─── Status & Role Utilities ──────────────────────────────────────────────────
|
||||
describe('Status & Role Utilities', () => {
|
||||
describe('isActiveMember', () => {
|
||||
it('should identify active statuses', () => {
|
||||
const activeStatuses = ['current', 'unverified', 'late']
|
||||
expect(activeStatuses.includes('current')).toBe(true)
|
||||
expect(activeStatuses.includes('unverified')).toBe(true)
|
||||
expect(activeStatuses.includes('late')).toBe(true)
|
||||
expect(activeStatuses.includes('inactive')).toBe(false)
|
||||
})
|
||||
})
|
||||
|
||||
describe('isAdmin', () => {
|
||||
it('should identify admin roles', () => {
|
||||
const adminRoles = ['admin', 'board']
|
||||
expect(adminRoles.includes('admin')).toBe(true)
|
||||
expect(adminRoles.includes('board')).toBe(true)
|
||||
expect(adminRoles.includes('member')).toBe(false)
|
||||
})
|
||||
})
|
||||
|
||||
describe('isTreasurer', () => {
|
||||
it('should identify treasurer-capable roles', () => {
|
||||
const treasurerRoles = ['admin', 'board', 'treasurer']
|
||||
expect(treasurerRoles.includes('admin')).toBe(true)
|
||||
expect(treasurerRoles.includes('treasurer')).toBe(true)
|
||||
expect(treasurerRoles.includes('member')).toBe(false)
|
||||
})
|
||||
})
|
||||
|
||||
describe('getStatusColor', () => {
|
||||
it('should return correct color for status', () => {
|
||||
const colors: Record<string, string> = {
|
||||
current: 'green',
|
||||
unverified: 'yellow',
|
||||
late: 'orange',
|
||||
inactive: 'gray',
|
||||
}
|
||||
expect(colors['current']).toBe('green')
|
||||
expect(colors['unverified']).toBe('yellow')
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
// ─── Task Utilities ───────────────────────────────────────────────────────────
|
||||
describe('Task Utilities', () => {
|
||||
describe('isTaskOverdue', () => {
|
||||
it('should identify overdue tasks', () => {
|
||||
const task = { due_date: '2020-01-01', status: 'open' }
|
||||
const isOverdue = task.due_date && new Date(task.due_date) < new Date() && task.status !== 'completed'
|
||||
expect(isOverdue).toBe(true)
|
||||
})
|
||||
|
||||
it('should not flag completed tasks as overdue', () => {
|
||||
const task = { due_date: '2020-01-01', status: 'completed' }
|
||||
const isOverdue = task.due_date && new Date(task.due_date) < new Date() && task.status !== 'completed'
|
||||
expect(isOverdue).toBe(false)
|
||||
})
|
||||
})
|
||||
|
||||
describe('getRecurrenceLabel', () => {
|
||||
it('should return human-readable recurrence', () => {
|
||||
const labels: Record<string, string> = {
|
||||
none: 'One-time',
|
||||
daily: 'Daily',
|
||||
weekly: 'Weekly',
|
||||
monthly: 'Monthly',
|
||||
yearly: 'Yearly',
|
||||
}
|
||||
expect(labels['daily']).toBe('Daily')
|
||||
expect(labels['none']).toBe('One-time')
|
||||
})
|
||||
})
|
||||
})
|
||||
Reference in New Issue
Block a user