kunthawat
2d1be52177
Fixes: 1. media.ts: wrap placeholder generation in try-catch 2. toolbar.ts: check r.ok, display error message in popover
783 lines
21 KiB
TypeScript
783 lines
21 KiB
TypeScript
import { describe, it, expect } from "vitest";
|
|
|
|
import type { SeedFile } from "../../../src/seed/types.js";
|
|
import { validateSeed } from "../../../src/seed/validate.js";
|
|
|
|
describe("validateSeed", () => {
|
|
describe("basic validation", () => {
|
|
it("should reject non-object input", () => {
|
|
expect(validateSeed(null)).toMatchObject({
|
|
valid: false,
|
|
errors: ["Seed must be an object"],
|
|
});
|
|
|
|
expect(validateSeed("string")).toMatchObject({
|
|
valid: false,
|
|
errors: ["Seed must be an object"],
|
|
});
|
|
});
|
|
|
|
it("should require version field", () => {
|
|
const result = validateSeed({});
|
|
expect(result.valid).toBe(false);
|
|
expect(result.errors).toContain("Seed must have a version field");
|
|
});
|
|
|
|
it("should reject unsupported versions", () => {
|
|
const result = validateSeed({ version: "2" });
|
|
expect(result.valid).toBe(false);
|
|
expect(result.errors).toContain("Unsupported seed version: 2");
|
|
});
|
|
|
|
it("should accept valid minimal seed", () => {
|
|
const result = validateSeed({ version: "1" });
|
|
expect(result.valid).toBe(true);
|
|
expect(result.errors).toHaveLength(0);
|
|
});
|
|
});
|
|
|
|
describe("collection validation", () => {
|
|
it("should require collections to be an array", () => {
|
|
const result = validateSeed({
|
|
version: "1",
|
|
collections: "not an array",
|
|
});
|
|
expect(result.valid).toBe(false);
|
|
expect(result.errors).toContain("collections must be an array");
|
|
});
|
|
|
|
it("should require collection slug", () => {
|
|
const result = validateSeed({
|
|
version: "1",
|
|
collections: [{ label: "Posts", fields: [] }],
|
|
});
|
|
expect(result.valid).toBe(false);
|
|
expect(result.errors).toContain("collections[0]: slug is required");
|
|
});
|
|
|
|
it("should require collection label", () => {
|
|
const result = validateSeed({
|
|
version: "1",
|
|
collections: [{ slug: "posts", fields: [] }],
|
|
});
|
|
expect(result.valid).toBe(false);
|
|
expect(result.errors).toContain("collections[0]: label is required");
|
|
});
|
|
|
|
it("should validate slug format", () => {
|
|
const result = validateSeed({
|
|
version: "1",
|
|
collections: [{ slug: "My Posts", label: "Posts", fields: [] }],
|
|
});
|
|
expect(result.valid).toBe(false);
|
|
expect(result.errors[0]).toContain("must start with a letter");
|
|
});
|
|
|
|
it("should reject duplicate collection slugs", () => {
|
|
const result = validateSeed({
|
|
version: "1",
|
|
collections: [
|
|
{ slug: "posts", label: "Posts", fields: [] },
|
|
{ slug: "posts", label: "Posts Again", fields: [] },
|
|
],
|
|
});
|
|
expect(result.valid).toBe(false);
|
|
expect(result.errors).toContain('collections[1].slug: duplicate collection slug "posts"');
|
|
});
|
|
|
|
it("should require fields to be an array", () => {
|
|
const result = validateSeed({
|
|
version: "1",
|
|
collections: [{ slug: "posts", label: "Posts", fields: "not array" }],
|
|
});
|
|
expect(result.valid).toBe(false);
|
|
expect(result.errors).toContain("collections[0].fields: must be an array");
|
|
});
|
|
|
|
it("should validate field properties", () => {
|
|
const result = validateSeed({
|
|
version: "1",
|
|
collections: [
|
|
{
|
|
slug: "posts",
|
|
label: "Posts",
|
|
fields: [{ slug: "title" }], // missing label and type
|
|
},
|
|
],
|
|
});
|
|
expect(result.valid).toBe(false);
|
|
expect(result.errors).toContain("collections[0].fields[0]: label is required");
|
|
expect(result.errors).toContain("collections[0].fields[0]: type is required");
|
|
});
|
|
|
|
it("should reject invalid field types", () => {
|
|
const result = validateSeed({
|
|
version: "1",
|
|
collections: [
|
|
{
|
|
slug: "posts",
|
|
label: "Posts",
|
|
fields: [{ slug: "title", label: "Title", type: "invalid" }],
|
|
},
|
|
],
|
|
});
|
|
expect(result.valid).toBe(false);
|
|
expect(result.errors[0]).toContain('unsupported field type "invalid"');
|
|
});
|
|
|
|
it("should reject duplicate field slugs", () => {
|
|
const result = validateSeed({
|
|
version: "1",
|
|
collections: [
|
|
{
|
|
slug: "posts",
|
|
label: "Posts",
|
|
fields: [
|
|
{ slug: "title", label: "Title", type: "string" },
|
|
{ slug: "title", label: "Title 2", type: "string" },
|
|
],
|
|
},
|
|
],
|
|
});
|
|
expect(result.valid).toBe(false);
|
|
expect(result.errors[0]).toContain('duplicate field slug "title"');
|
|
});
|
|
|
|
it("should accept valid collection with fields", () => {
|
|
const result = validateSeed({
|
|
version: "1",
|
|
collections: [
|
|
{
|
|
slug: "posts",
|
|
label: "Posts",
|
|
fields: [
|
|
{ slug: "title", label: "Title", type: "string", required: true },
|
|
{ slug: "content", label: "Content", type: "portableText" },
|
|
],
|
|
},
|
|
],
|
|
});
|
|
expect(result.valid).toBe(true);
|
|
expect(result.errors).toHaveLength(0);
|
|
});
|
|
});
|
|
|
|
describe("taxonomy validation", () => {
|
|
it("should require taxonomy name", () => {
|
|
const result = validateSeed({
|
|
version: "1",
|
|
taxonomies: [{ label: "Categories", hierarchical: true, collections: [] }],
|
|
});
|
|
expect(result.valid).toBe(false);
|
|
expect(result.errors).toContain("taxonomies[0]: name is required");
|
|
});
|
|
|
|
it("should require taxonomy label", () => {
|
|
const result = validateSeed({
|
|
version: "1",
|
|
taxonomies: [{ name: "category", hierarchical: true, collections: [] }],
|
|
});
|
|
expect(result.valid).toBe(false);
|
|
expect(result.errors).toContain("taxonomies[0]: label is required");
|
|
});
|
|
|
|
it("should require hierarchical field", () => {
|
|
const result = validateSeed({
|
|
version: "1",
|
|
taxonomies: [{ name: "category", label: "Categories", collections: [] }],
|
|
});
|
|
expect(result.valid).toBe(false);
|
|
expect(result.errors).toContain("taxonomies[0]: hierarchical is required");
|
|
});
|
|
|
|
it("should warn about taxonomy with no collections", () => {
|
|
const result = validateSeed({
|
|
version: "1",
|
|
taxonomies: [
|
|
{
|
|
name: "category",
|
|
label: "Categories",
|
|
hierarchical: true,
|
|
collections: [],
|
|
},
|
|
],
|
|
});
|
|
expect(result.valid).toBe(true);
|
|
expect(result.warnings).toContain(
|
|
'taxonomies[0].collections: taxonomy "category" is not assigned to any collections',
|
|
);
|
|
});
|
|
|
|
it("should reject duplicate taxonomy names", () => {
|
|
const result = validateSeed({
|
|
version: "1",
|
|
taxonomies: [
|
|
{
|
|
name: "category",
|
|
label: "Categories",
|
|
hierarchical: true,
|
|
collections: ["posts"],
|
|
},
|
|
{
|
|
name: "category",
|
|
label: "Categories 2",
|
|
hierarchical: true,
|
|
collections: ["posts"],
|
|
},
|
|
],
|
|
});
|
|
expect(result.valid).toBe(false);
|
|
expect(result.errors).toContain('taxonomies[1].name: duplicate taxonomy name "category"');
|
|
});
|
|
|
|
it("should validate term properties", () => {
|
|
const result = validateSeed({
|
|
version: "1",
|
|
taxonomies: [
|
|
{
|
|
name: "category",
|
|
label: "Categories",
|
|
hierarchical: true,
|
|
collections: ["posts"],
|
|
terms: [{ slug: "news" }], // missing label
|
|
},
|
|
],
|
|
});
|
|
expect(result.valid).toBe(false);
|
|
expect(result.errors).toContain("taxonomies[0].terms[0]: label is required");
|
|
});
|
|
|
|
it("should reject duplicate term slugs", () => {
|
|
const result = validateSeed({
|
|
version: "1",
|
|
taxonomies: [
|
|
{
|
|
name: "category",
|
|
label: "Categories",
|
|
hierarchical: true,
|
|
collections: ["posts"],
|
|
terms: [
|
|
{ slug: "news", label: "News" },
|
|
{ slug: "news", label: "News 2" },
|
|
],
|
|
},
|
|
],
|
|
});
|
|
expect(result.valid).toBe(false);
|
|
expect(result.errors[0]).toContain('duplicate term slug "news"');
|
|
});
|
|
|
|
it("should reject self-referencing parent", () => {
|
|
const result = validateSeed({
|
|
version: "1",
|
|
taxonomies: [
|
|
{
|
|
name: "category",
|
|
label: "Categories",
|
|
hierarchical: true,
|
|
collections: ["posts"],
|
|
terms: [{ slug: "news", label: "News", parent: "news" }],
|
|
},
|
|
],
|
|
});
|
|
expect(result.valid).toBe(false);
|
|
expect(result.errors).toContain(
|
|
"taxonomies[0].terms[0].parent: term cannot be its own parent",
|
|
);
|
|
});
|
|
|
|
it("should reject invalid parent reference", () => {
|
|
const result = validateSeed({
|
|
version: "1",
|
|
taxonomies: [
|
|
{
|
|
name: "category",
|
|
label: "Categories",
|
|
hierarchical: true,
|
|
collections: ["posts"],
|
|
terms: [{ slug: "news", label: "News", parent: "nonexistent" }],
|
|
},
|
|
],
|
|
});
|
|
expect(result.valid).toBe(false);
|
|
expect(result.errors).toContain(
|
|
'taxonomies[0].terms[0].parent: parent term "nonexistent" not found in taxonomy',
|
|
);
|
|
});
|
|
|
|
it("should warn about parent on non-hierarchical taxonomy", () => {
|
|
const result = validateSeed({
|
|
version: "1",
|
|
taxonomies: [
|
|
{
|
|
name: "tag",
|
|
label: "Tags",
|
|
hierarchical: false,
|
|
collections: ["posts"],
|
|
terms: [{ slug: "news", label: "News", parent: "other" }],
|
|
},
|
|
],
|
|
});
|
|
expect(result.valid).toBe(true);
|
|
expect(result.warnings[0]).toContain("is not hierarchical, parent will be ignored");
|
|
});
|
|
});
|
|
|
|
describe("menu validation", () => {
|
|
it("should require menu name and label", () => {
|
|
const result = validateSeed({
|
|
version: "1",
|
|
menus: [{ items: [] }],
|
|
});
|
|
expect(result.valid).toBe(false);
|
|
expect(result.errors).toContain("menus[0]: name is required");
|
|
expect(result.errors).toContain("menus[0]: label is required");
|
|
});
|
|
|
|
it("should reject duplicate menu names", () => {
|
|
const result = validateSeed({
|
|
version: "1",
|
|
menus: [
|
|
{ name: "primary", label: "Primary", items: [] },
|
|
{ name: "primary", label: "Primary 2", items: [] },
|
|
],
|
|
});
|
|
expect(result.valid).toBe(false);
|
|
expect(result.errors).toContain('menus[1].name: duplicate menu name "primary"');
|
|
});
|
|
|
|
it("should validate menu item types", () => {
|
|
const result = validateSeed({
|
|
version: "1",
|
|
menus: [
|
|
{
|
|
name: "primary",
|
|
label: "Primary",
|
|
items: [{ type: "invalid" }],
|
|
},
|
|
],
|
|
});
|
|
expect(result.valid).toBe(false);
|
|
expect(result.errors[0]).toContain('must be "custom", "page", "post"');
|
|
});
|
|
|
|
it("should require url for custom items", () => {
|
|
const result = validateSeed({
|
|
version: "1",
|
|
menus: [
|
|
{
|
|
name: "primary",
|
|
label: "Primary",
|
|
items: [{ type: "custom", label: "Link" }],
|
|
},
|
|
],
|
|
});
|
|
expect(result.valid).toBe(false);
|
|
expect(result.errors).toContain("menus[0].items[0]: url is required for custom menu items");
|
|
});
|
|
|
|
it("should require ref for page/post items", () => {
|
|
const result = validateSeed({
|
|
version: "1",
|
|
menus: [
|
|
{
|
|
name: "primary",
|
|
label: "Primary",
|
|
items: [{ type: "page", label: "About" }],
|
|
},
|
|
],
|
|
});
|
|
expect(result.valid).toBe(false);
|
|
expect(result.errors).toContain(
|
|
"menus[0].items[0]: ref is required for page/post menu items",
|
|
);
|
|
});
|
|
|
|
it("should validate nested menu items", () => {
|
|
const result = validateSeed({
|
|
version: "1",
|
|
menus: [
|
|
{
|
|
name: "primary",
|
|
label: "Primary",
|
|
items: [
|
|
{
|
|
type: "custom",
|
|
url: "/about",
|
|
label: "About",
|
|
children: [{ type: "page" }], // missing ref
|
|
},
|
|
],
|
|
},
|
|
],
|
|
});
|
|
expect(result.valid).toBe(false);
|
|
expect(result.errors).toContain(
|
|
"menus[0].items[0].items[0]: ref is required for page/post menu items",
|
|
);
|
|
});
|
|
|
|
it("should warn about menu refs not in content", () => {
|
|
const result = validateSeed({
|
|
version: "1",
|
|
menus: [
|
|
{
|
|
name: "primary",
|
|
label: "Primary",
|
|
items: [{ type: "page", ref: "about" }],
|
|
},
|
|
],
|
|
content: {
|
|
pages: [{ id: "home", slug: "home", data: { title: "Home" } }],
|
|
},
|
|
});
|
|
expect(result.valid).toBe(true);
|
|
expect(result.warnings).toContain(
|
|
'Menu item references content "about" which is not in the seed file',
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("widget area validation", () => {
|
|
it("should require widget area name and label", () => {
|
|
const result = validateSeed({
|
|
version: "1",
|
|
widgetAreas: [{ widgets: [] }],
|
|
});
|
|
expect(result.valid).toBe(false);
|
|
expect(result.errors).toContain("widgetAreas[0]: name is required");
|
|
expect(result.errors).toContain("widgetAreas[0]: label is required");
|
|
});
|
|
|
|
it("should reject duplicate widget area names", () => {
|
|
const result = validateSeed({
|
|
version: "1",
|
|
widgetAreas: [
|
|
{ name: "sidebar", label: "Sidebar", widgets: [] },
|
|
{ name: "sidebar", label: "Sidebar 2", widgets: [] },
|
|
],
|
|
});
|
|
expect(result.valid).toBe(false);
|
|
expect(result.errors).toContain('widgetAreas[1].name: duplicate widget area name "sidebar"');
|
|
});
|
|
|
|
it("should validate widget types", () => {
|
|
const result = validateSeed({
|
|
version: "1",
|
|
widgetAreas: [
|
|
{
|
|
name: "sidebar",
|
|
label: "Sidebar",
|
|
widgets: [{ type: "invalid" }],
|
|
},
|
|
],
|
|
});
|
|
expect(result.valid).toBe(false);
|
|
expect(result.errors[0]).toContain('must be "content", "menu", or "component"');
|
|
});
|
|
|
|
it("should require menuName for menu widgets", () => {
|
|
const result = validateSeed({
|
|
version: "1",
|
|
widgetAreas: [
|
|
{
|
|
name: "sidebar",
|
|
label: "Sidebar",
|
|
widgets: [{ type: "menu", title: "Nav" }],
|
|
},
|
|
],
|
|
});
|
|
expect(result.valid).toBe(false);
|
|
expect(result.errors).toContain(
|
|
"widgetAreas[0].widgets[0]: menuName is required for menu widgets",
|
|
);
|
|
});
|
|
|
|
it("should require componentId for component widgets", () => {
|
|
const result = validateSeed({
|
|
version: "1",
|
|
widgetAreas: [
|
|
{
|
|
name: "sidebar",
|
|
label: "Sidebar",
|
|
widgets: [{ type: "component", title: "Recent Posts" }],
|
|
},
|
|
],
|
|
});
|
|
expect(result.valid).toBe(false);
|
|
expect(result.errors).toContain(
|
|
"widgetAreas[0].widgets[0]: componentId is required for component widgets",
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("redirect validation", () => {
|
|
it("should require redirects to be an array", () => {
|
|
const result = validateSeed({
|
|
version: "1",
|
|
redirects: "not an array",
|
|
});
|
|
expect(result.valid).toBe(false);
|
|
expect(result.errors).toContain("redirects must be an array");
|
|
});
|
|
|
|
it("should require source and destination", () => {
|
|
const result = validateSeed({
|
|
version: "1",
|
|
redirects: [{}],
|
|
});
|
|
expect(result.valid).toBe(false);
|
|
expect(result.errors).toContain("redirects[0]: source is required");
|
|
expect(result.errors).toContain("redirects[0]: destination is required");
|
|
});
|
|
|
|
it("should validate redirect source and destination paths", () => {
|
|
const result = validateSeed({
|
|
version: "1",
|
|
redirects: [{ source: "https://example.com", destination: "//external" }],
|
|
});
|
|
expect(result.valid).toBe(false);
|
|
expect(result.errors).toContain(
|
|
"redirects[0].source: must be a path starting with / (no protocol-relative URLs, path traversal, or newlines)",
|
|
);
|
|
expect(result.errors).toContain(
|
|
"redirects[0].destination: must be a path starting with / (no protocol-relative URLs, path traversal, or newlines)",
|
|
);
|
|
});
|
|
|
|
it("should validate redirect type", () => {
|
|
const result = validateSeed({
|
|
version: "1",
|
|
redirects: [{ source: "/old", destination: "/new", type: 303 }],
|
|
});
|
|
expect(result.valid).toBe(false);
|
|
expect(result.errors).toContain("redirects[0].type: must be 301, 302, 307, or 308");
|
|
});
|
|
|
|
it("should reject duplicate redirect sources", () => {
|
|
const result = validateSeed({
|
|
version: "1",
|
|
redirects: [
|
|
{ source: "/old", destination: "/new" },
|
|
{ source: "/old", destination: "/newer" },
|
|
],
|
|
});
|
|
expect(result.valid).toBe(false);
|
|
expect(result.errors).toContain('redirects[1].source: duplicate redirect source "/old"');
|
|
});
|
|
|
|
it("should accept valid redirects", () => {
|
|
const result = validateSeed({
|
|
version: "1",
|
|
redirects: [
|
|
{ source: "/old", destination: "/new" },
|
|
{ source: "/temp", destination: "/next", type: 302, enabled: false },
|
|
],
|
|
});
|
|
expect(result.valid).toBe(true);
|
|
expect(result.errors).toHaveLength(0);
|
|
});
|
|
});
|
|
|
|
describe("content validation", () => {
|
|
it("should require content to be an object", () => {
|
|
const result = validateSeed({
|
|
version: "1",
|
|
content: [],
|
|
});
|
|
expect(result.valid).toBe(false);
|
|
expect(result.errors).toContain("content must be an object (collection -> entries)");
|
|
});
|
|
|
|
it("should require content entries to be arrays", () => {
|
|
const result = validateSeed({
|
|
version: "1",
|
|
content: { posts: "not array" },
|
|
});
|
|
expect(result.valid).toBe(false);
|
|
expect(result.errors).toContain("content.posts: must be an array");
|
|
});
|
|
|
|
it("should require entry id and slug", () => {
|
|
const result = validateSeed({
|
|
version: "1",
|
|
content: {
|
|
posts: [{ data: { title: "Hello" } }],
|
|
},
|
|
});
|
|
expect(result.valid).toBe(false);
|
|
expect(result.errors).toContain("content.posts[0]: id is required");
|
|
expect(result.errors).toContain("content.posts[0]: slug is required");
|
|
});
|
|
|
|
it("should require entry data to be an object", () => {
|
|
const result = validateSeed({
|
|
version: "1",
|
|
content: {
|
|
posts: [{ id: "hello", slug: "hello", data: "not object" }],
|
|
},
|
|
});
|
|
expect(result.valid).toBe(false);
|
|
expect(result.errors).toContain("content.posts[0]: data must be an object");
|
|
});
|
|
|
|
it("should reject duplicate entry ids", () => {
|
|
const result = validateSeed({
|
|
version: "1",
|
|
content: {
|
|
posts: [
|
|
{ id: "hello", slug: "hello", data: { title: "Hello" } },
|
|
{ id: "hello", slug: "hello-2", data: { title: "Hello 2" } },
|
|
],
|
|
},
|
|
});
|
|
expect(result.valid).toBe(false);
|
|
expect(result.errors).toContain(
|
|
'content.posts[1].id: duplicate entry id "hello" in collection "posts"',
|
|
);
|
|
});
|
|
|
|
it("should validate byline references in content entries", () => {
|
|
const result = validateSeed({
|
|
version: "1",
|
|
bylines: [{ id: "editorial", slug: "editorial", displayName: "Editorial" }],
|
|
content: {
|
|
posts: [
|
|
{
|
|
id: "post-1",
|
|
slug: "hello",
|
|
data: { title: "Hello" },
|
|
bylines: [{ byline: "missing" }],
|
|
},
|
|
],
|
|
},
|
|
});
|
|
expect(result.valid).toBe(false);
|
|
expect(result.errors).toContain(
|
|
'content.posts[0].bylines[0].byline: references unknown byline "missing"',
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("byline validation", () => {
|
|
it("should require byline id, slug, and displayName", () => {
|
|
const result = validateSeed({
|
|
version: "1",
|
|
bylines: [{ slug: "editorial" }],
|
|
});
|
|
expect(result.valid).toBe(false);
|
|
expect(result.errors).toContain("bylines[0]: id is required");
|
|
expect(result.errors).toContain("bylines[0]: displayName is required");
|
|
});
|
|
|
|
it("should reject duplicate byline ids and slugs", () => {
|
|
const result = validateSeed({
|
|
version: "1",
|
|
bylines: [
|
|
{ id: "editorial", slug: "editorial", displayName: "Editorial" },
|
|
{ id: "editorial", slug: "editorial", displayName: "Editorial 2" },
|
|
],
|
|
});
|
|
expect(result.valid).toBe(false);
|
|
expect(result.errors).toContain('bylines[1].id: duplicate byline id "editorial"');
|
|
expect(result.errors).toContain('bylines[1].slug: duplicate byline slug "editorial"');
|
|
});
|
|
});
|
|
|
|
describe("full seed validation", () => {
|
|
it("should accept a complete valid seed", () => {
|
|
const seed: SeedFile = {
|
|
version: "1",
|
|
meta: {
|
|
name: "Blog Starter",
|
|
description: "A simple blog template",
|
|
},
|
|
settings: {
|
|
title: "My Blog",
|
|
tagline: "Thoughts and ideas",
|
|
},
|
|
collections: [
|
|
{
|
|
slug: "posts",
|
|
label: "Posts",
|
|
fields: [
|
|
{ slug: "title", label: "Title", type: "string", required: true },
|
|
{ slug: "content", label: "Content", type: "portableText" },
|
|
],
|
|
},
|
|
{
|
|
slug: "pages",
|
|
label: "Pages",
|
|
fields: [
|
|
{ slug: "title", label: "Title", type: "string", required: true },
|
|
{ slug: "content", label: "Content", type: "portableText" },
|
|
],
|
|
},
|
|
],
|
|
taxonomies: [
|
|
{
|
|
name: "category",
|
|
label: "Categories",
|
|
hierarchical: true,
|
|
collections: ["posts"],
|
|
terms: [
|
|
{ slug: "news", label: "News" },
|
|
{ slug: "tutorials", label: "Tutorials" },
|
|
],
|
|
},
|
|
],
|
|
menus: [
|
|
{
|
|
name: "primary",
|
|
label: "Primary Navigation",
|
|
items: [
|
|
{ type: "custom", url: "/", label: "Home" },
|
|
{ type: "page", ref: "about" },
|
|
],
|
|
},
|
|
],
|
|
redirects: [
|
|
{ source: "/old-about", destination: "/about" },
|
|
{ source: "/legacy-feed", destination: "/rss.xml", type: 308, groupName: "import" },
|
|
],
|
|
widgetAreas: [
|
|
{
|
|
name: "sidebar",
|
|
label: "Sidebar",
|
|
widgets: [
|
|
{
|
|
type: "component",
|
|
componentId: "core:recent-posts",
|
|
props: { count: 5 },
|
|
},
|
|
],
|
|
},
|
|
],
|
|
content: {
|
|
pages: [
|
|
{
|
|
id: "about",
|
|
slug: "about",
|
|
status: "published",
|
|
data: { title: "About", content: [] },
|
|
},
|
|
],
|
|
posts: [
|
|
{
|
|
id: "hello",
|
|
slug: "hello-world",
|
|
status: "published",
|
|
data: { title: "Hello World", content: [] },
|
|
taxonomies: { category: ["news"] },
|
|
},
|
|
],
|
|
},
|
|
};
|
|
|
|
const result = validateSeed(seed);
|
|
expect(result.valid).toBe(true);
|
|
expect(result.errors).toHaveLength(0);
|
|
});
|
|
});
|
|
});
|