@nextsparkjs/theme-default 0.1.0-beta.17 → 0.1.0-beta.170

package/tests/jest/setup.ts

@@ -0,0 +1,170 @@
+/**
+ * Jest Setup for Default Theme
+ *
+ * This file provides complete Jest setup for npm mode.
+ * It includes all necessary polyfills and mocks.
+ */
+
+import '@testing-library/jest-dom'
+import { TextEncoder, TextDecoder } from 'util'
+
+// Polyfill TextEncoder/TextDecoder for jsdom
+global.TextEncoder = TextEncoder
+global.TextDecoder = TextDecoder as typeof global.TextDecoder
+
+// Polyfill Web APIs for Next.js server components testing
+class MockHeaders {
+  private _headers: Map<string, string> = new Map()
+
+  constructor(init?: HeadersInit) {
+    if (init) {
+      if (init instanceof MockHeaders) {
+        init._headers.forEach((value, key) => this._headers.set(key, value))
+      } else if (Array.isArray(init)) {
+        init.forEach(([key, value]) => this._headers.set(key.toLowerCase(), value))
+      } else {
+        Object.entries(init).forEach(([key, value]) => this._headers.set(key.toLowerCase(), value))
+      }
+    }
+  }
+
+  get(name: string) { return this._headers.get(name.toLowerCase()) || null }
+  set(name: string, value: string) { this._headers.set(name.toLowerCase(), value) }
+  has(name: string) { return this._headers.has(name.toLowerCase()) }
+  delete(name: string) { this._headers.delete(name.toLowerCase()) }
+  forEach(cb: (value: string, key: string) => void) { this._headers.forEach(cb) }
+  entries() { return this._headers.entries() }
+  keys() { return this._headers.keys() }
+  values() { return this._headers.values() }
+}
+
+class MockRequest {
+  url: string
+  method: string
+  headers: MockHeaders
+  private _body: any
+
+  constructor(input: string | URL, init?: RequestInit) {
+    this.url = typeof input === 'string' ? input : input.toString()
+    this.method = init?.method || 'GET'
+    this.headers = new MockHeaders(init?.headers as HeadersInit)
+    this._body = init?.body
+  }
+
+  async json() {
+    if (!this._body) return {}
+    return typeof this._body === 'string' ? JSON.parse(this._body) : this._body
+  }
+
+  async text() {
+    return this._body?.toString() || ''
+  }
+
+  clone() {
+    return new MockRequest(this.url, {
+      method: this.method,
+      headers: Object.fromEntries(this.headers.entries()),
+      body: this._body,
+    })
+  }
+}
+
+class MockResponse {
+  body: any
+  status: number
+  statusText: string
+  headers: MockHeaders
+  ok: boolean
+
+  constructor(body?: any, init?: ResponseInit) {
+    this.body = body
+    this.status = init?.status || 200
+    this.statusText = init?.statusText || 'OK'
+    this.headers = new MockHeaders(init?.headers as HeadersInit)
+    this.ok = this.status >= 200 && this.status < 300
+  }
+
+  async json() {
+    if (!this.body) return {}
+    return typeof this.body === 'string' ? JSON.parse(this.body) : this.body
+  }
+
+  async text() {
+    return this.body?.toString() || ''
+  }
+
+  clone() {
+    return new MockResponse(this.body, {
+      status: this.status,
+      statusText: this.statusText,
+      headers: Object.fromEntries(this.headers.entries()),
+    })
+  }
+
+  static json(data: any, init?: ResponseInit) {
+    return new MockResponse(JSON.stringify(data), {
+      ...init,
+      headers: { 'Content-Type': 'application/json', ...(init?.headers || {}) as object },
+    })
+  }
+}
+
+// Assign to global scope
+global.Headers = MockHeaders as any
+global.Request = MockRequest as any
+global.Response = MockResponse as any
+
+// Mock fetch
+global.fetch = jest.fn().mockResolvedValue(new MockResponse('{}', { status: 200 }))
+
+// Mock Web Crypto API
+const crypto = require('crypto')
+Object.defineProperty(global, 'crypto', {
+  value: {
+    getRandomValues: (arr: Uint8Array) => crypto.randomFillSync(arr),
+    randomUUID: () => crypto.randomUUID(),
+    subtle: {
+      digest: async (algorithm: string, data: BufferSource) => {
+        const hash = crypto.createHash(algorithm.toLowerCase().replace('-', ''))
+        hash.update(Buffer.from(data as ArrayBuffer))
+        return hash.digest().buffer
+      },
+      encrypt: jest.fn(),
+      decrypt: jest.fn(),
+      sign: jest.fn(),
+      verify: jest.fn(),
+      generateKey: jest.fn(),
+      importKey: jest.fn(),
+      exportKey: jest.fn(),
+    },
+  },
+})
+
+// Mock matchMedia for component tests with media queries
+Object.defineProperty(window, 'matchMedia', {
+  writable: true,
+  value: jest.fn().mockImplementation((query) => ({
+    matches: false,
+    media: query,
+    onchange: null,
+    addListener: jest.fn(),
+    removeListener: jest.fn(),
+    addEventListener: jest.fn(),
+    removeEventListener: jest.fn(),
+    dispatchEvent: jest.fn(),
+  })),
+})
+
+// Mock ResizeObserver
+global.ResizeObserver = jest.fn().mockImplementation(() => ({
+  observe: jest.fn(),
+  unobserve: jest.fn(),
+  disconnect: jest.fn(),
+}))
+
+// Mock IntersectionObserver
+global.IntersectionObserver = jest.fn().mockImplementation(() => ({
+  observe: jest.fn(),
+  unobserve: jest.fn(),
+  disconnect: jest.fn(),
+}))

package/tests/jest/tsconfig.jest.json

@@ -0,0 +1,6 @@
+{
+  "extends": "../../../../apps/dev/tsconfig.json",
+  "compilerOptions": {
+    "jsx": "react-jsx"
+  }
+}

package/tests/jest/validation/categories.test.ts

@@ -0,0 +1,429 @@
+/**
+ * Unit Tests - Post Categories Validation Schemas
+ *
+ * Tests Zod validation for post categories API:
+ * - createCategorySchema: Name, slug, parentId, icon, color
+ * - Slug auto-generation logic
+ * - Edge cases: Special characters, empty strings, hierarchical validation
+ *
+ * Focus on validation logic WITHOUT database calls.
+ */
+
+import { z } from 'zod'
+
+// Copy schemas from API route to test in isolation
+const createCategorySchema = z.object({
+  name: z.string().min(1).max(255),
+  slug: z.string().min(2).max(100).regex(/^[a-z0-9-]+$/, 'Slug must be lowercase alphanumeric with dashes').optional(),
+  description: z.string().optional(),
+  icon: z.string().optional(),
+  color: z.string().optional(),
+  parentId: z.string().optional(),
+  order: z.number().int().default(0),
+  isDefault: z.boolean().default(false)
+})
+
+// Copy helper function from API route
+function generateSlug(name: string): string {
+  return name
+    .toLowerCase()
+    .trim()
+    .replace(/[^a-z0-9\s-]/g, '') // Remove special chars
+    .replace(/\s+/g, '-')          // Replace spaces with dashes
+    .replace(/-+/g, '-')           // Replace multiple dashes with single
+    .replace(/^-|-$/g, '')         // Remove leading/trailing dashes
+}
+
+describe('Post Categories Validation', () => {
+  describe('createCategorySchema - Valid Data', () => {
+    it('should accept minimal valid category data', () => {
+      const validData = {
+        name: 'Technology'
+      }
+
+      const result = createCategorySchema.safeParse(validData)
+
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.data.name).toBe('Technology')
+        expect(result.data.order).toBe(0) // Default value
+        expect(result.data.isDefault).toBe(false) // Default value
+      }
+    })
+
+    it('should accept complete category data with all fields', () => {
+      const completeData = {
+        name: 'Web Development',
+        slug: 'web-development',
+        description: 'Posts about web development',
+        icon: 'code',
+        color: '#3B82F6',
+        parentId: 'parent-cat-id',
+        order: 5,
+        isDefault: true
+      }
+
+      const result = createCategorySchema.safeParse(completeData)
+
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.data.name).toBe('Web Development')
+        expect(result.data.slug).toBe('web-development')
+        expect(result.data.description).toBe('Posts about web development')
+        expect(result.data.icon).toBe('code')
+        expect(result.data.color).toBe('#3B82F6')
+        expect(result.data.parentId).toBe('parent-cat-id')
+        expect(result.data.order).toBe(5)
+        expect(result.data.isDefault).toBe(true)
+      }
+    })
+
+    it('should accept category without slug (for auto-generation)', () => {
+      const data = {
+        name: 'Test Category'
+      }
+
+      const result = createCategorySchema.safeParse(data)
+
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.data.slug).toBeUndefined()
+      }
+    })
+  })
+
+  describe('createCategorySchema - Name Validation', () => {
+    it('should reject empty name', () => {
+      const data = {
+        name: ''
+      }
+
+      const result = createCategorySchema.safeParse(data)
+
+      expect(result.success).toBe(false)
+      if (!result.success) {
+        expect(result.error.issues[0].path).toContain('name')
+      }
+    })
+
+    it('should reject name longer than 255 characters', () => {
+      const data = {
+        name: 'a'.repeat(256)
+      }
+
+      const result = createCategorySchema.safeParse(data)
+
+      expect(result.success).toBe(false)
+    })
+
+    it('should accept name with exactly 255 characters', () => {
+      const data = {
+        name: 'a'.repeat(255)
+      }
+
+      const result = createCategorySchema.safeParse(data)
+
+      expect(result.success).toBe(true)
+    })
+
+    it('should accept name with special characters', () => {
+      const validNames = [
+        'Technology & Science',
+        'Front-end Development',
+        'Tips/Tricks',
+        'Best Practices (2024)',
+      ]
+
+      validNames.forEach(name => {
+        const result = createCategorySchema.safeParse({ name })
+        expect(result.success).toBe(true)
+      })
+    })
+  })
+
+  describe('createCategorySchema - Slug Validation', () => {
+    it('should reject slug with uppercase letters', () => {
+      const data = {
+        name: 'Test',
+        slug: 'Test-Category'
+      }
+
+      const result = createCategorySchema.safeParse(data)
+
+      expect(result.success).toBe(false)
+      if (!result.success) {
+        expect(result.error.issues[0].message).toContain('lowercase')
+      }
+    })
+
+    it('should reject slug with special characters', () => {
+      const invalidSlugs = [
+        'test_category',
+        'test.category',
+        'test category',
+        'test@category',
+      ]
+
+      invalidSlugs.forEach(slug => {
+        const result = createCategorySchema.safeParse({ name: 'Test', slug })
+        expect(result.success).toBe(false)
+      })
+    })
+
+    it('should reject slug shorter than 2 characters', () => {
+      const data = {
+        name: 'Test',
+        slug: 'a'
+      }
+
+      const result = createCategorySchema.safeParse(data)
+
+      expect(result.success).toBe(false)
+    })
+
+    it('should reject slug longer than 100 characters', () => {
+      const data = {
+        name: 'Test',
+        slug: 'a'.repeat(101)
+      }
+
+      const result = createCategorySchema.safeParse(data)
+
+      expect(result.success).toBe(false)
+    })
+
+    it('should accept valid slugs', () => {
+      const validSlugs = [
+        'technology',
+        'web-development',
+        'tips-tricks-2024',
+        'category-123',
+      ]
+
+      validSlugs.forEach(slug => {
+        const result = createCategorySchema.safeParse({ name: 'Test', slug })
+        expect(result.success).toBe(true)
+      })
+    })
+  })
+
+  describe('createCategorySchema - Optional Fields', () => {
+    it('should accept missing description', () => {
+      const data = {
+        name: 'Test'
+      }
+
+      const result = createCategorySchema.safeParse(data)
+
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.data.description).toBeUndefined()
+      }
+    })
+
+    it('should accept missing icon', () => {
+      const data = {
+        name: 'Test'
+      }
+
+      const result = createCategorySchema.safeParse(data)
+
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.data.icon).toBeUndefined()
+      }
+    })
+
+    it('should accept missing color', () => {
+      const data = {
+        name: 'Test'
+      }
+
+      const result = createCategorySchema.safeParse(data)
+
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.data.color).toBeUndefined()
+      }
+    })
+
+    it('should accept missing parentId', () => {
+      const data = {
+        name: 'Test'
+      }
+
+      const result = createCategorySchema.safeParse(data)
+
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.data.parentId).toBeUndefined()
+      }
+    })
+  })
+
+  describe('createCategorySchema - Order Validation', () => {
+    it('should default order to 0', () => {
+      const data = {
+        name: 'Test'
+      }
+
+      const result = createCategorySchema.safeParse(data)
+
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.data.order).toBe(0)
+      }
+    })
+
+    it('should accept positive order values', () => {
+      const data = {
+        name: 'Test',
+        order: 5
+      }
+
+      const result = createCategorySchema.safeParse(data)
+
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.data.order).toBe(5)
+      }
+    })
+
+    it('should accept negative order values', () => {
+      const data = {
+        name: 'Test',
+        order: -1
+      }
+
+      const result = createCategorySchema.safeParse(data)
+
+      expect(result.success).toBe(true)
+    })
+
+    it('should reject non-integer order values', () => {
+      const data = {
+        name: 'Test',
+        order: 5.5
+      }
+
+      const result = createCategorySchema.safeParse(data)
+
+      expect(result.success).toBe(false)
+    })
+  })
+})
+
+describe('Slug Generation Logic', () => {
+  describe('generateSlug - Basic Functionality', () => {
+    it('should convert name to lowercase', () => {
+      expect(generateSlug('Technology')).toBe('technology')
+      expect(generateSlug('WEB DEVELOPMENT')).toBe('web-development')
+      expect(generateSlug('MixedCase')).toBe('mixedcase')
+    })
+
+    it('should replace spaces with dashes', () => {
+      expect(generateSlug('Web Development')).toBe('web-development')
+      expect(generateSlug('Tips and Tricks')).toBe('tips-and-tricks')
+      expect(generateSlug('Multiple   Spaces')).toBe('multiple-spaces')
+    })
+
+    it('should trim leading and trailing whitespace', () => {
+      expect(generateSlug('  Technology  ')).toBe('technology')
+      expect(generateSlug('\tWeb Development\n')).toBe('web-development')
+    })
+
+    it('should remove leading and trailing dashes', () => {
+      expect(generateSlug('-Technology-')).toBe('technology')
+      expect(generateSlug('--Web Development--')).toBe('web-development')
+    })
+  })
+
+  describe('generateSlug - Special Characters', () => {
+    it('should remove special characters', () => {
+      expect(generateSlug('Technology & Science')).toBe('technology-science')
+      expect(generateSlug('Front-end Development')).toBe('front-end-development')
+      expect(generateSlug('Tips/Tricks')).toBe('tipstricks')
+      expect(generateSlug('Category @ 2024')).toBe('category-2024')
+      expect(generateSlug('Test!@#$%Category')).toBe('testcategory')
+    })
+
+    it('should preserve numbers', () => {
+      expect(generateSlug('2024 Trends')).toBe('2024-trends')
+      expect(generateSlug('Top 10 Tips')).toBe('top-10-tips')
+      expect(generateSlug('Web 3.0')).toBe('web-30')
+    })
+
+    it('should handle parentheses', () => {
+      expect(generateSlug('Best Practices (2024)')).toBe('best-practices-2024')
+      expect(generateSlug('(Old) Category')).toBe('old-category')
+    })
+  })
+
+  describe('generateSlug - Multiple Dashes', () => {
+    it('should replace multiple dashes with single dash', () => {
+      expect(generateSlug('Web--Development')).toBe('web-development')
+      expect(generateSlug('Test---Category')).toBe('test-category')
+      expect(generateSlug('Multiple    Spaces')).toBe('multiple-spaces')
+    })
+
+    it('should handle combination of special chars and spaces', () => {
+      expect(generateSlug('Web & Mobile  Development')).toBe('web-mobile-development')
+      expect(generateSlug('Tips / Tricks   2024')).toBe('tips-tricks-2024')
+    })
+  })
+
+  describe('generateSlug - Edge Cases', () => {
+    it('should handle empty string', () => {
+      expect(generateSlug('')).toBe('')
+    })
+
+    it('should handle only special characters', () => {
+      expect(generateSlug('!@#$%')).toBe('')
+      expect(generateSlug('---')).toBe('')
+    })
+
+    it('should handle only spaces', () => {
+      expect(generateSlug('    ')).toBe('')
+    })
+
+    it('should handle unicode characters', () => {
+      // Non-ASCII characters should be removed
+      expect(generateSlug('Café')).toBe('caf')
+      expect(generateSlug('Niño Category')).toBe('nio-category')
+    })
+
+    it('should handle very long names', () => {
+      const longName = 'This is a very long category name that should be converted to a slug properly'
+      const slug = generateSlug(longName)
+
+      expect(slug).toBe('this-is-a-very-long-category-name-that-should-be-converted-to-a-slug-properly')
+      expect(slug.startsWith('-')).toBe(false)
+      expect(slug.endsWith('-')).toBe(false)
+    })
+
+    it('should handle already valid slugs', () => {
+      expect(generateSlug('web-development')).toBe('web-development')
+      expect(generateSlug('technology')).toBe('technology')
+      expect(generateSlug('tips-123')).toBe('tips-123')
+    })
+  })
+
+  describe('generateSlug - Real World Examples', () => {
+    it('should generate correct slugs for common category names', () => {
+      const examples = [
+        { name: 'Technology', expected: 'technology' },
+        { name: 'Web Development', expected: 'web-development' },
+        { name: 'Tips & Tricks', expected: 'tips-tricks' },
+        { name: 'News (2024)', expected: 'news-2024' },
+        { name: 'Front-end Development', expected: 'front-end-development' },
+        { name: 'AI / Machine Learning', expected: 'ai-machine-learning' },
+        { name: 'Product Reviews', expected: 'product-reviews' },
+        { name: 'How-to Guides', expected: 'how-to-guides' },
+      ]
+
+      examples.forEach(({ name, expected }) => {
+        expect(generateSlug(name)).toBe(expected)
+      })
+    })
+  })
+})