community-rule/tests/unit/validation.test.js

import { describe, it, expect } from "vitest";
import {
  validateBlogPost,
  sanitizeBlogPost,
  BLOG_POST_SCHEMA,
} from "../../lib/validation.js";

describe("Blog Post Validation", () => {
  describe("validateBlogPost", () => {
    it("should validate a correct blog post", () => {
      const validPost = {
        title: "Test Title",
        description:
          "This is a test description that meets the minimum length requirement",
        author: "Test Author",
        date: "2025-04-15",
        tags: ["test", "blog"],
        related: ["post-1", "post-2"],
      };

      const result = validateBlogPost(validPost);
      expect(result.isValid).toBe(true);
      expect(result.errors).toHaveLength(0);
    });

    it("should reject missing required fields", () => {
      const invalidPost = {
        title: "Test Title",
        // Missing description, author, date
        tags: ["test"],
      };

      const result = validateBlogPost(invalidPost);
      expect(result.isValid).toBe(false);
      expect(result.errors).toContain("Missing required field: description");
      expect(result.errors).toContain("Missing required field: author");
      expect(result.errors).toContain("Missing required field: date");
    });

    it("should validate title length constraints", () => {
      const shortTitle = {
        title: "", // Empty string (less than 1 character minimum)
        description:
          "This is a test description that meets the minimum length requirement",
        author: "Test Author",
        date: "2025-04-15",
      };

      const result = validateBlogPost(shortTitle);
      expect(result.isValid).toBe(false);
      expect(result.errors).toContain("Missing required field: title");
    });

    it("should validate date format", () => {
      const invalidDate = {
        title: "Test Title",
        description:
          "This is a test description that meets the minimum length requirement",
        author: "Test Author",
        date: "2025/04/15", // Wrong format
      };

      const result = validateBlogPost(invalidDate);
      expect(result.isValid).toBe(false);
      expect(result.errors).toContain("Field date format is invalid");
    });

    it("should validate tags array", () => {
      const invalidTags = {
        title: "Test Title",
        description:
          "This is a test description that meets the minimum length requirement",
        author: "Test Author",
        date: "2025-04-15",
        tags: "not-an-array", // Should be array
      };

      const result = validateBlogPost(invalidTags);
      expect(result.isValid).toBe(false);
      expect(result.errors).toContain("Field tags must be an array");
    });

    it("should validate tag item lengths", () => {
      const invalidTagItems = {
        title: "Test Title",
        description:
          "This is a test description that meets the minimum length requirement",
        author: "Test Author",
        date: "2025-04-15",
        tags: ["", "very-long-tag-name-that-exceeds-maximum-length"],
      };

      const result = validateBlogPost(invalidTagItems);
      expect(result.isValid).toBe(false);
      expect(result.errors).toContain(
        "Item 0 in tags must be at least 1 characters"
      );
      expect(result.errors).toContain(
        "Item 1 in tags must be no more than 20 characters"
      );
    });
  });

  describe("sanitizeBlogPost", () => {
    it("should return original data when all fields are present", () => {
      const post = {
        title: "Test Title",
        description: "Test description",
        author: "Test Author",
        date: "2025-04-15",
        tags: ["test"],
        related: ["post-1"],
      };

      const sanitized = sanitizeBlogPost(post);
      expect(sanitized).toEqual(post);
    });

    it("should add default values for missing optional fields", () => {
      const post = {
        title: "Test Title",
        description: "Test description",
        author: "Test Author",
        date: "2025-04-15",
        // Missing tags and related
      };

      const sanitized = sanitizeBlogPost(post);
      expect(sanitized.tags).toEqual([]);
      expect(sanitized.related).toEqual([]);
    });

    it("should preserve existing optional fields", () => {
      const post = {
        title: "Test Title",
        description: "Test description",
        author: "Test Author",
        date: "2025-04-15",
        tags: ["custom-tag"],
        related: ["custom-post"],
      };

      const sanitized = sanitizeBlogPost(post);
      expect(sanitized.tags).toEqual(["custom-tag"]);
      expect(sanitized.related).toEqual(["custom-post"]);
    });
  });

  describe("BLOG_POST_SCHEMA", () => {
    it("should have correct structure", () => {
      expect(BLOG_POST_SCHEMA).toHaveProperty("title");
      expect(BLOG_POST_SCHEMA).toHaveProperty("description");
      expect(BLOG_POST_SCHEMA).toHaveProperty("author");
      expect(BLOG_POST_SCHEMA).toHaveProperty("date");
      expect(BLOG_POST_SCHEMA).toHaveProperty("tags");
      expect(BLOG_POST_SCHEMA).toHaveProperty("related");
    });

    it("should have correct required field configuration", () => {
      expect(BLOG_POST_SCHEMA.title.required).toBe(true);
      expect(BLOG_POST_SCHEMA.description.required).toBe(true);
      expect(BLOG_POST_SCHEMA.author.required).toBe(true);
      expect(BLOG_POST_SCHEMA.date.required).toBe(true);
      expect(BLOG_POST_SCHEMA.tags.required).toBe(false);
      expect(BLOG_POST_SCHEMA.related.required).toBe(false);
    });
  });
});