com.wallstop-studios.dxmessaging 2.1.4 → 2.1.6

package/scripts/__tests__/validate-skills-optional-fields.test.js.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: eda9624434fd28f4e94513c20aea9342
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/scripts/__tests__/validate-skills-required-fields.test.js

@@ -0,0 +1,188 @@
+/**
+ * @fileoverview Tests for validate-skills.js required field validation logic.
+ *
+ * These tests validate the required field detection in skill files:
+ * - Missing required fields (undefined/null)
+ * - Empty required fields (empty string)
+ * - Valid required fields
+ *
+ * The validation logic ensures that skill files have all required frontmatter
+ * fields properly populated.
+ */
+
+"use strict";
+
+const {
+    validateRequiredField,
+    validateRequiredFields,
+    REQUIRED_FIELDS,
+} = require('../validate-skills.js');
+
+describe("validate-skills required field validation", () => {
+    const testPath = "testing/sample-skill.md";
+
+    describe("missing required fields (undefined/null)", () => {
+        test("should error when required field is undefined", () => {
+            const frontmatter = {
+                id: "sample-skill",
+                category: "testing",
+                version: "1.0.0",
+                created: "2025-01-01",
+                updated: "2025-01-01",
+                status: "active",
+                // title is undefined
+            };
+
+            const errors = validateRequiredField(frontmatter, 'title', testPath);
+
+            expect(errors).toHaveLength(1);
+            expect(errors[0].field).toBe("title");
+            expect(errors[0].message).toContain("Required field 'title' is missing");
+        });
+
+        test("should error when required field is null", () => {
+            const frontmatter = {
+                title: null,
+                id: "sample-skill",
+                category: "testing",
+                version: "1.0.0",
+                created: "2025-01-01",
+                updated: "2025-01-01",
+                status: "active",
+            };
+
+            const errors = validateRequiredField(frontmatter, 'title', testPath);
+
+            expect(errors).toHaveLength(1);
+            expect(errors[0].field).toBe("title");
+            expect(errors[0].message).toContain("Required field 'title' is missing");
+        });
+    });
+
+    describe("empty required fields", () => {
+        test("should error when required field is empty string", () => {
+            const frontmatter = {
+                title: "",
+                id: "sample-skill",
+                category: "testing",
+                version: "1.0.0",
+                created: "2025-01-01",
+                updated: "2025-01-01",
+                status: "active",
+            };
+
+            const errors = validateRequiredField(frontmatter, 'title', testPath);
+
+            expect(errors).toHaveLength(1);
+            expect(errors[0].field).toBe("title");
+            expect(errors[0].message).toContain("Required field 'title' is empty");
+        });
+
+        test("should distinguish between missing and empty in error messages", () => {
+            const missingFrontmatter = {
+                id: "sample-skill",
+                // title is undefined
+            };
+
+            const emptyFrontmatter = {
+                title: "",
+                id: "sample-skill",
+            };
+
+            const missingErrors = validateRequiredField(missingFrontmatter, 'title', testPath);
+            const emptyErrors = validateRequiredField(emptyFrontmatter, 'title', testPath);
+
+            expect(missingErrors[0].message).toContain("is missing");
+            expect(emptyErrors[0].message).toContain("is empty");
+            expect(missingErrors[0].message).not.toEqual(emptyErrors[0].message);
+        });
+    });
+
+    describe("valid required fields", () => {
+        test("should not error when required field has valid string value", () => {
+            const frontmatter = {
+                title: "Sample Skill",
+                id: "sample-skill",
+                category: "testing",
+                version: "1.0.0",
+                created: "2025-01-01",
+                updated: "2025-01-01",
+                status: "active",
+            };
+
+            const errors = validateRequiredField(frontmatter, 'title', testPath);
+
+            expect(errors).toHaveLength(0);
+        });
+
+        test("should not error when all required fields are present", () => {
+            const frontmatter = {
+                title: "Sample Skill",
+                id: "sample-skill",
+                category: "testing",
+                version: "1.0.0",
+                created: "2025-01-01",
+                updated: "2025-01-01",
+                status: "active",
+            };
+
+            const errors = validateRequiredFields(frontmatter, testPath);
+
+            expect(errors).toHaveLength(0);
+        });
+    });
+
+    describe("multiple missing fields", () => {
+        test("should report errors for all missing required fields", () => {
+            const frontmatter = {
+                title: "Sample Skill",
+                // id is undefined
+                category: "testing",
+                // version is undefined
+                created: "2025-01-01",
+                updated: "2025-01-01",
+                status: "active",
+            };
+
+            const errors = validateRequiredFields(frontmatter, testPath);
+
+            expect(errors).toHaveLength(2);
+            expect(errors.map(e => e.field)).toContain("id");
+            expect(errors.map(e => e.field)).toContain("version");
+        });
+
+        test("should report errors for mix of missing and empty fields", () => {
+            const frontmatter = {
+                title: "Sample Skill",
+                id: null, // missing (null)
+                category: "", // empty
+                version: "1.0.0",
+                created: "2025-01-01",
+                updated: "2025-01-01",
+                status: "active",
+            };
+
+            const errors = validateRequiredFields(frontmatter, testPath);
+
+            expect(errors).toHaveLength(2);
+
+            const idError = errors.find(e => e.field === "id");
+            const categoryError = errors.find(e => e.field === "category");
+
+            expect(idError.message).toContain("is missing");
+            expect(categoryError.message).toContain("is empty");
+        });
+    });
+
+    describe("each required field", () => {
+        test.each(REQUIRED_FIELDS)("should validate '%s' as required field", (field) => {
+            const frontmatter = {};
+
+            const errors = validateRequiredField(frontmatter, field, testPath);
+
+            expect(errors).toHaveLength(1);
+            expect(errors[0].field).toBe(field);
+            expect(errors[0].message).toContain(`Required field '${field}' is missing`);
+        });
+    });
+});

package/scripts/__tests__/validate-skills-required-fields.test.js.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 44d2c7652f77a384fad8119aa2ca0ce3
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/scripts/__tests__/validate-skills-tags.test.js

@@ -0,0 +1,353 @@
+/**
+ * @fileoverview Tests for validate-skills.js tags validation logic.
+ *
+ * These tests validate the tags field validation in skill files:
+ * - Missing tags (undefined/null)
+ * - Wrong type (string, object, number instead of array)
+ * - Empty tags array
+ * - Valid tags array
+ *
+ * The validation logic ensures that skill files have properly formatted
+ * tags arrays for the skills index generation.
+ */
+
+"use strict";
+
+const { validateTags } = require('../validate-skills.js');
+
+describe("validate-skills tags validation", () => {
+    const testPath = "testing/sample-skill.md";
+
+    describe("missing tags field", () => {
+        test("should warn when tags is undefined", () => {
+            const frontmatter = {
+                title: "Sample Skill",
+                id: "sample-skill",
+                // tags is undefined
+            };
+
+            const warnings = validateTags(frontmatter, testPath);
+
+            expect(warnings).toHaveLength(1);
+            expect(warnings[0].field).toBe("tags");
+            expect(warnings[0].message).toContain("Missing 'tags' array");
+        });
+
+        test("should warn when tags is null", () => {
+            const frontmatter = {
+                title: "Sample Skill",
+                id: "sample-skill",
+                tags: null,
+            };
+
+            const warnings = validateTags(frontmatter, testPath);
+
+            expect(warnings).toHaveLength(1);
+            expect(warnings[0].field).toBe("tags");
+            expect(warnings[0].message).toContain("Missing 'tags' array");
+        });
+    });
+
+    describe("wrong type for tags", () => {
+        test("should warn when tags is an empty string", () => {
+            const frontmatter = {
+                title: "Sample Skill",
+                id: "sample-skill",
+                tags: "",
+            };
+
+            const warnings = validateTags(frontmatter, testPath);
+
+            expect(warnings).toHaveLength(1);
+            expect(warnings[0].field).toBe("tags");
+            // Empty string is defined but wrong type
+            expect(warnings[0].message).toContain("'tags' must be an array");
+            expect(warnings[0].message).toContain("got string");
+        });
+
+        test("should warn when tags is a zero", () => {
+            const frontmatter = {
+                title: "Sample Skill",
+                id: "sample-skill",
+                tags: 0,
+            };
+
+            const warnings = validateTags(frontmatter, testPath);
+
+            expect(warnings).toHaveLength(1);
+            expect(warnings[0].field).toBe("tags");
+            // 0 is defined but wrong type
+            expect(warnings[0].message).toContain("'tags' must be an array");
+            expect(warnings[0].message).toContain("got number");
+        });
+
+        test("should warn when tags is boolean false", () => {
+            const frontmatter = {
+                title: "Sample Skill",
+                id: "sample-skill",
+                tags: false,
+            };
+
+            const warnings = validateTags(frontmatter, testPath);
+
+            expect(warnings).toHaveLength(1);
+            expect(warnings[0].field).toBe("tags");
+            // false is defined but wrong type
+            expect(warnings[0].message).toContain("'tags' must be an array");
+            expect(warnings[0].message).toContain("got boolean");
+        });
+
+        test("should warn when tags is a string", () => {
+            const frontmatter = {
+                title: "Sample Skill",
+                id: "sample-skill",
+                tags: "testing, validation",
+            };
+
+            const warnings = validateTags(frontmatter, testPath);
+
+            expect(warnings).toHaveLength(1);
+            expect(warnings[0].field).toBe("tags");
+            expect(warnings[0].message).toContain("'tags' must be an array");
+            expect(warnings[0].message).toContain("got string");
+        });
+
+        test("should warn when tags is a number", () => {
+            const frontmatter = {
+                title: "Sample Skill",
+                id: "sample-skill",
+                tags: 42,
+            };
+
+            const warnings = validateTags(frontmatter, testPath);
+
+            expect(warnings).toHaveLength(1);
+            expect(warnings[0].field).toBe("tags");
+            expect(warnings[0].message).toContain("'tags' must be an array");
+            expect(warnings[0].message).toContain("got number");
+        });
+
+        test("should warn when tags is an object", () => {
+            const frontmatter = {
+                title: "Sample Skill",
+                id: "sample-skill",
+                tags: { tag1: "testing", tag2: "validation" },
+            };
+
+            const warnings = validateTags(frontmatter, testPath);
+
+            expect(warnings).toHaveLength(1);
+            expect(warnings[0].field).toBe("tags");
+            expect(warnings[0].message).toContain("'tags' must be an array");
+            expect(warnings[0].message).toContain("got object");
+        });
+
+        test("should warn when tags is boolean true", () => {
+            const frontmatter = {
+                title: "Sample Skill",
+                id: "sample-skill",
+                tags: true,
+            };
+
+            const warnings = validateTags(frontmatter, testPath);
+
+            expect(warnings).toHaveLength(1);
+            expect(warnings[0].field).toBe("tags");
+            expect(warnings[0].message).toContain("'tags' must be an array");
+            expect(warnings[0].message).toContain("got boolean");
+        });
+
+        test("should warn when tags is a function", () => {
+            const frontmatter = {
+                title: "Sample Skill",
+                id: "sample-skill",
+                tags: () => ["test"],
+            };
+
+            const warnings = validateTags(frontmatter, testPath);
+
+            expect(warnings).toHaveLength(1);
+            expect(warnings[0].field).toBe("tags");
+            expect(warnings[0].message).toContain("'tags' must be an array");
+            expect(warnings[0].message).toContain("got function");
+        });
+
+        test("should warn when tags is a symbol", () => {
+            const frontmatter = {
+                title: "Sample Skill",
+                id: "sample-skill",
+                tags: Symbol("tags"),
+            };
+
+            const warnings = validateTags(frontmatter, testPath);
+
+            expect(warnings).toHaveLength(1);
+            expect(warnings[0].field).toBe("tags");
+            expect(warnings[0].message).toContain("'tags' must be an array");
+            expect(warnings[0].message).toContain("got symbol");
+        });
+    });
+
+    describe("empty tags array", () => {
+        test("should warn when tags is an empty array", () => {
+            const frontmatter = {
+                title: "Sample Skill",
+                id: "sample-skill",
+                tags: [],
+            };
+
+            const warnings = validateTags(frontmatter, testPath);
+
+            expect(warnings).toHaveLength(1);
+            expect(warnings[0].field).toBe("tags");
+            expect(warnings[0].message).toContain("Empty 'tags' array");
+        });
+    });
+
+    describe("valid tags array", () => {
+        test("should not warn when tags has one element", () => {
+            const frontmatter = {
+                title: "Sample Skill",
+                id: "sample-skill",
+                tags: ["testing"],
+            };
+
+            const warnings = validateTags(frontmatter, testPath);
+
+            expect(warnings).toHaveLength(0);
+        });
+
+        test("should not warn when tags has multiple elements", () => {
+            const frontmatter = {
+                title: "Sample Skill",
+                id: "sample-skill",
+                tags: ["testing", "validation", "skills"],
+            };
+
+            const warnings = validateTags(frontmatter, testPath);
+
+            expect(warnings).toHaveLength(0);
+        });
+
+        test("should not warn when tags contains empty string", () => {
+            // Empty string in array is valid from validation perspective
+            // (content validation would be separate)
+            const frontmatter = {
+                title: "Sample Skill",
+                id: "sample-skill",
+                tags: [""],
+            };
+
+            const warnings = validateTags(frontmatter, testPath);
+
+            expect(warnings).toHaveLength(0);
+        });
+
+        test("should not warn when tags contains mixed types", () => {
+            // Mixed types in array is valid from type validation perspective
+            // (content validation would be separate)
+            const frontmatter = {
+                title: "Sample Skill",
+                id: "sample-skill",
+                tags: ["testing", 123, null],
+            };
+
+            const warnings = validateTags(frontmatter, testPath);
+
+            expect(warnings).toHaveLength(0);
+        });
+    });
+
+    describe("error message content", () => {
+        test("should include skills index reference in missing tags message", () => {
+            const frontmatter = { title: "Test" };
+
+            const warnings = validateTags(frontmatter, testPath);
+
+            expect(warnings[0].message).toContain("will show empty Tags column in skills index");
+        });
+
+        test("should include skills index reference in wrong type message", () => {
+            const frontmatter = { title: "Test", tags: "string" };
+
+            const warnings = validateTags(frontmatter, testPath);
+
+            expect(warnings[0].message).toContain("will show empty Tags column in skills index");
+        });
+
+        test("should include skills index reference in empty array message", () => {
+            const frontmatter = { title: "Test", tags: [] };
+
+            const warnings = validateTags(frontmatter, testPath);
+
+            expect(warnings[0].message).toContain("will show empty Tags column in skills index");
+        });
+
+        test("should include correct file path in warning", () => {
+            const customPath = "custom/path/to/skill.md";
+            const frontmatter = { title: "Test" };
+
+            const warnings = validateTags(frontmatter, customPath);
+
+            expect(warnings[0].file).toBe(customPath);
+        });
+
+        test("should report correct field name", () => {
+            const frontmatter = { title: "Test" };
+
+            const warnings = validateTags(frontmatter, testPath);
+
+            expect(warnings[0].field).toBe("tags");
+        });
+    });
+
+    describe("edge cases", () => {
+        test("should handle frontmatter with no properties", () => {
+            const frontmatter = {};
+
+            const warnings = validateTags(frontmatter, testPath);
+
+            expect(warnings).toHaveLength(1);
+            expect(warnings[0].message).toContain("Missing 'tags' array");
+        });
+
+        test("should handle array-like objects", () => {
+            // Array-like object (not a real array)
+            const frontmatter = {
+                title: "Sample Skill",
+                id: "sample-skill",
+                tags: { 0: "test", 1: "tags", length: 2 },
+            };
+
+            const warnings = validateTags(frontmatter, testPath);
+
+            expect(warnings).toHaveLength(1);
+            expect(warnings[0].message).toContain("'tags' must be an array");
+            expect(warnings[0].message).toContain("got object");
+        });
+
+        test("should accept array created with Array constructor", () => {
+            const frontmatter = {
+                title: "Sample Skill",
+                id: "sample-skill",
+                tags: new Array("testing", "validation"),
+            };
+
+            const warnings = validateTags(frontmatter, testPath);
+
+            expect(warnings).toHaveLength(0);
+        });
+
+        test("should handle very long tags array", () => {
+            const frontmatter = {
+                title: "Sample Skill",
+                id: "sample-skill",
+                tags: Array.from({ length: 100 }, (_, i) => `tag${i}`),
+            };
+
+            const warnings = validateTags(frontmatter, testPath);
+
+            expect(warnings).toHaveLength(0);
+        });
+    });
+});

package/scripts/__tests__/validate-skills-tags.test.js.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 5e9f3a7b2c4d6e8f0a1b3c5d7e9f1a2b
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: