@wordpress/abilities 0.1.1-next.dc3f6d3c1.0 → 0.2.1-next.8b30e05b0.0

package/build-module/store/tests/actions.test.js

@@ -1,804 +0,0 @@
-// packages/abilities/src/store/tests/actions.test.ts
-import { resolveSelect } from "@wordpress/data";
-import {
-  receiveAbilities,
-  registerAbility,
-  unregisterAbility,
-  receiveCategories,
-  registerAbilityCategory,
-  unregisterAbilityCategory
-} from "../actions";
-import {
-  RECEIVE_ABILITIES,
-  REGISTER_ABILITY,
-  UNREGISTER_ABILITY,
-  RECEIVE_CATEGORIES,
-  REGISTER_ABILITY_CATEGORY,
-  UNREGISTER_ABILITY_CATEGORY
-} from "../constants";
-jest.mock("@wordpress/data", () => ({
-  resolveSelect: jest.fn()
-}));
-describe("Store Actions", () => {
-  describe("receiveAbilities", () => {
-    it("should create an action to receive abilities", () => {
-      const abilities = [
-        {
-          name: "test/ability1",
-          label: "Test Ability 1",
-          description: "First test ability",
-          category: "test-category",
-          input_schema: { type: "object" },
-          output_schema: { type: "object" }
-        },
-        {
-          name: "test/ability2",
-          label: "Test Ability 2",
-          description: "Second test ability",
-          category: "test-category",
-          input_schema: { type: "object" },
-          output_schema: { type: "object" }
-        }
-      ];
-      const action = receiveAbilities(abilities);
-      expect(action).toEqual({
-        type: RECEIVE_ABILITIES,
-        abilities
-      });
-    });
-    it("should handle empty abilities array", () => {
-      const abilities = [];
-      const action = receiveAbilities(abilities);
-      expect(action).toEqual({
-        type: RECEIVE_ABILITIES,
-        abilities: []
-      });
-    });
-  });
-  describe("registerAbility", () => {
-    let mockSelect;
-    let mockDispatch;
-    beforeEach(() => {
-      jest.clearAllMocks();
-      const defaultCategories = [
-        {
-          slug: "test-category",
-          label: "Test Category",
-          description: "Test category for testing"
-        },
-        {
-          slug: "data-retrieval",
-          label: "Data Retrieval",
-          description: "Abilities that retrieve data"
-        }
-      ];
-      mockSelect = {
-        getAbility: jest.fn().mockReturnValue(null),
-        getAbilityCategories: jest.fn().mockReturnValue(defaultCategories),
-        getAbilityCategory: jest.fn().mockImplementation((slug) => {
-          const categories = {
-            "test-category": {
-              slug: "test-category",
-              label: "Test Category",
-              description: "Test category for testing"
-            },
-            "data-retrieval": {
-              slug: "data-retrieval",
-              label: "Data Retrieval",
-              description: "Abilities that retrieve data"
-            }
-          };
-          return categories[slug] || null;
-        })
-      };
-      mockDispatch = jest.fn();
-      resolveSelect.mockReturnValue({
-        getAbilityCategories: jest.fn().mockResolvedValue(defaultCategories)
-      });
-    });
-    it("should register a valid client ability", async () => {
-      const ability = {
-        name: "test/ability",
-        label: "Test Ability",
-        description: "Test ability description",
-        category: "test-category",
-        input_schema: {
-          type: "object",
-          properties: {
-            message: { type: "string" }
-          }
-        },
-        output_schema: {
-          type: "object",
-          properties: {
-            success: { type: "boolean" }
-          }
-        },
-        callback: jest.fn()
-      };
-      const action = registerAbility(ability);
-      await action({ select: mockSelect, dispatch: mockDispatch });
-      expect(mockDispatch).toHaveBeenCalledWith({
-        type: REGISTER_ABILITY,
-        ability
-      });
-    });
-    it("should register server-side abilities", async () => {
-      const ability = {
-        name: "test/server-ability",
-        label: "Server Ability",
-        description: "Server-side ability",
-        category: "test-category",
-        input_schema: { type: "object" },
-        output_schema: { type: "object" }
-      };
-      const action = registerAbility(ability);
-      await action({ select: mockSelect, dispatch: mockDispatch });
-      expect(mockDispatch).toHaveBeenCalledWith({
-        type: REGISTER_ABILITY,
-        ability
-      });
-    });
-    it("should validate and reject ability without name", async () => {
-      const ability = {
-        name: "",
-        label: "Test Ability",
-        description: "Test description",
-        category: "test-category",
-        callback: jest.fn()
-      };
-      const action = registerAbility(ability);
-      await expect(
-        action({ select: mockSelect, dispatch: mockDispatch })
-      ).rejects.toThrow("Ability name is required");
-      expect(mockDispatch).not.toHaveBeenCalled();
-    });
-    it("should validate and reject ability with invalid name format", async () => {
-      const testCases = [
-        "invalid",
-        // No namespace
-        "my-plugin/feature/action",
-        // Multiple slashes
-        "My-Plugin/feature",
-        // Uppercase letters
-        "my_plugin/feature",
-        // Underscores not allowed
-        "my-plugin/feature!",
-        // Special characters not allowed
-        "my plugin/feature"
-        // Spaces not allowed
-      ];
-      for (const invalidName of testCases) {
-        const ability = {
-          name: invalidName,
-          label: "Test Ability",
-          description: "Test description",
-          category: "test-category",
-          callback: jest.fn()
-        };
-        const action = registerAbility(ability);
-        await expect(
-          action({ select: mockSelect, dispatch: mockDispatch })
-        ).rejects.toThrow(
-          "Ability name must be a string containing a namespace prefix"
-        );
-        expect(mockDispatch).not.toHaveBeenCalled();
-        mockDispatch.mockClear();
-      }
-    });
-    it("should validate and reject ability without label", async () => {
-      const ability = {
-        name: "test/ability",
-        label: "",
-        description: "Test description",
-        category: "test-category",
-        callback: jest.fn()
-      };
-      const action = registerAbility(ability);
-      await expect(
-        action({ select: mockSelect, dispatch: mockDispatch })
-      ).rejects.toThrow('Ability "test/ability" must have a label');
-      expect(mockDispatch).not.toHaveBeenCalled();
-    });
-    it("should validate and reject ability without description", async () => {
-      const ability = {
-        name: "test/ability",
-        label: "Test Ability",
-        description: "",
-        category: "test-category",
-        callback: jest.fn()
-      };
-      const action = registerAbility(ability);
-      await expect(
-        action({ select: mockSelect, dispatch: mockDispatch })
-      ).rejects.toThrow(
-        'Ability "test/ability" must have a description'
-      );
-      expect(mockDispatch).not.toHaveBeenCalled();
-    });
-    it("should validate and reject ability without category", async () => {
-      const ability = {
-        name: "test/ability",
-        label: "Test Ability",
-        description: "Test description",
-        category: "",
-        callback: jest.fn()
-      };
-      const action = registerAbility(ability);
-      await expect(
-        action({ select: mockSelect, dispatch: mockDispatch })
-      ).rejects.toThrow('Ability "test/ability" must have a category');
-      expect(mockDispatch).not.toHaveBeenCalled();
-    });
-    it("should validate and reject ability with invalid category format", async () => {
-      const testCases = [
-        "Data-Retrieval",
-        // Uppercase letters
-        "data_retrieval",
-        // Underscores not allowed
-        "data.retrieval",
-        // Dots not allowed
-        "data/retrieval",
-        // Slashes not allowed
-        "-data-retrieval",
-        // Leading dash
-        "data-retrieval-",
-        // Trailing dash
-        "data--retrieval"
-        // Double dash
-      ];
-      for (const invalidCategory of testCases) {
-        const ability = {
-          name: "test/ability",
-          label: "Test Ability",
-          description: "Test description",
-          category: invalidCategory,
-          callback: jest.fn()
-        };
-        const action = registerAbility(ability);
-        await expect(
-          action({ select: mockSelect, dispatch: mockDispatch })
-        ).rejects.toThrow(
-          'Ability "test/ability" has an invalid category. Category must be lowercase alphanumeric with dashes only'
-        );
-        expect(mockDispatch).not.toHaveBeenCalled();
-        mockDispatch.mockClear();
-      }
-    });
-    it("should accept ability with valid category format", async () => {
-      const validCategories = [
-        "data-retrieval",
-        "user-management",
-        "analytics-123",
-        "ecommerce"
-      ];
-      for (const validCategory of validCategories) {
-        const ability = {
-          name: "test/ability-" + validCategory,
-          label: "Test Ability",
-          description: "Test description",
-          category: validCategory,
-          callback: jest.fn()
-        };
-        const categoriesForTest = [
-          {
-            slug: "test-category",
-            label: "Test Category",
-            description: "Test category for testing"
-          },
-          {
-            slug: "data-retrieval",
-            label: "Data Retrieval",
-            description: "Abilities that retrieve data"
-          },
-          {
-            slug: validCategory,
-            label: "Test Category",
-            description: "Test"
-          }
-        ];
-        mockSelect.getAbilityCategories.mockReturnValue(
-          categoriesForTest
-        );
-        resolveSelect.mockReturnValue({
-          getAbilityCategories: jest.fn().mockResolvedValue(categoriesForTest)
-        });
-        mockSelect.getAbility.mockReturnValue(null);
-        mockDispatch.mockClear();
-        const action = registerAbility(ability);
-        await action({ select: mockSelect, dispatch: mockDispatch });
-        expect(mockDispatch).toHaveBeenCalledWith({
-          type: REGISTER_ABILITY,
-          ability
-        });
-      }
-    });
-    it("should validate and reject ability with non-existent category", async () => {
-      mockSelect.getAbilityCategories.mockReturnValue([
-        {
-          slug: "test-category",
-          label: "Test Category",
-          description: "Test category for testing"
-        },
-        {
-          slug: "data-retrieval",
-          label: "Data Retrieval",
-          description: "Abilities that retrieve data"
-        }
-      ]);
-      const ability = {
-        name: "test/ability",
-        label: "Test Ability",
-        description: "Test description",
-        category: "non-existent-category",
-        callback: jest.fn()
-      };
-      const action = registerAbility(ability);
-      await expect(
-        action({ select: mockSelect, dispatch: mockDispatch })
-      ).rejects.toThrow(
-        'Ability "test/ability" references non-existent category "non-existent-category". Please register the category first.'
-      );
-      expect(mockDispatch).not.toHaveBeenCalled();
-    });
-    it("should accept ability with existing category", async () => {
-      const categoriesForTest = [
-        {
-          slug: "test-category",
-          label: "Test Category",
-          description: "Test category for testing"
-        },
-        {
-          slug: "data-retrieval",
-          label: "Data Retrieval",
-          description: "Abilities that retrieve data"
-        }
-      ];
-      mockSelect.getAbilityCategories.mockReturnValue(
-        categoriesForTest
-      );
-      resolveSelect.mockReturnValue({
-        getAbilityCategories: jest.fn().mockResolvedValue(categoriesForTest)
-      });
-      const ability = {
-        name: "test/ability",
-        label: "Test Ability",
-        description: "Test description",
-        category: "data-retrieval",
-        callback: jest.fn()
-      };
-      const action = registerAbility(ability);
-      await action({ select: mockSelect, dispatch: mockDispatch });
-      expect(resolveSelect).toHaveBeenCalledWith("core/abilities");
-      expect(mockDispatch).toHaveBeenCalledWith({
-        type: REGISTER_ABILITY,
-        ability
-      });
-    });
-    it("should validate and reject ability with invalid callback", async () => {
-      const ability = {
-        name: "test/ability",
-        label: "Test Ability",
-        description: "Test description",
-        category: "test-category",
-        callback: "not a function"
-      };
-      const action = registerAbility(ability);
-      await expect(
-        action({ select: mockSelect, dispatch: mockDispatch })
-      ).rejects.toThrow(
-        'Ability "test/ability" has an invalid callback. Callback must be a function'
-      );
-      expect(mockDispatch).not.toHaveBeenCalled();
-    });
-    it("should validate and reject already registered ability", async () => {
-      const existingAbility = {
-        name: "test/ability",
-        label: "Existing Ability",
-        description: "Already registered",
-        category: "test-category"
-      };
-      mockSelect.getAbility.mockReturnValue(existingAbility);
-      const ability = {
-        name: "test/ability",
-        label: "Test Ability",
-        description: "Test description",
-        category: "test-category",
-        callback: jest.fn()
-      };
-      const action = registerAbility(ability);
-      await expect(
-        action({ select: mockSelect, dispatch: mockDispatch })
-      ).rejects.toThrow('Ability "test/ability" is already registered');
-      expect(mockDispatch).not.toHaveBeenCalled();
-    });
-    it("should load categories using resolveSelect before validation", async () => {
-      const categories = [
-        {
-          slug: "test-category",
-          label: "Test Category",
-          description: "Test category"
-        }
-      ];
-      resolveSelect.mockReturnValue({
-        getAbilityCategories: jest.fn().mockResolvedValue(categories)
-      });
-      const ability = {
-        name: "test/ability",
-        label: "Test Ability",
-        description: "Test description",
-        category: "test-category",
-        callback: jest.fn()
-      };
-      const action = registerAbility(ability);
-      await action({ select: mockSelect, dispatch: mockDispatch });
-      expect(resolveSelect).toHaveBeenCalledWith("core/abilities");
-      expect(mockDispatch).toHaveBeenCalledWith({
-        type: REGISTER_ABILITY,
-        ability
-      });
-    });
-  });
-  describe("unregisterAbility", () => {
-    it("should create an action to unregister an ability", () => {
-      const abilityName = "test/ability";
-      const action = unregisterAbility(abilityName);
-      expect(action).toEqual({
-        type: UNREGISTER_ABILITY,
-        name: abilityName
-      });
-    });
-    it("should handle valid namespaced ability names", () => {
-      const abilityName = "my-plugin/feature-action";
-      const action = unregisterAbility(abilityName);
-      expect(action).toEqual({
-        type: UNREGISTER_ABILITY,
-        name: abilityName
-      });
-    });
-  });
-  describe("receiveCategories", () => {
-    it("should create an action to receive categories", () => {
-      const categories = [
-        {
-          slug: "data-retrieval",
-          label: "Data Retrieval",
-          description: "Abilities that retrieve data"
-        },
-        {
-          slug: "user-management",
-          label: "User Management",
-          description: "Abilities for managing users"
-        }
-      ];
-      const action = receiveCategories(categories);
-      expect(action).toEqual({
-        type: RECEIVE_CATEGORIES,
-        categories
-      });
-    });
-    it("should handle empty categories array", () => {
-      const categories = [];
-      const action = receiveCategories(categories);
-      expect(action).toEqual({
-        type: RECEIVE_CATEGORIES,
-        categories: []
-      });
-    });
-  });
-  describe("registerAbilityCategory", () => {
-    let mockSelect;
-    let mockDispatch;
-    beforeEach(() => {
-      jest.clearAllMocks();
-      mockSelect = {
-        getAbilityCategory: jest.fn().mockReturnValue(null),
-        getAbilityCategories: jest.fn().mockReturnValue([])
-      };
-      mockDispatch = jest.fn();
-      resolveSelect.mockReturnValue({
-        getAbilityCategories: jest.fn().mockResolvedValue(void 0)
-      });
-    });
-    it("should register a valid category", async () => {
-      const slug = "test-category";
-      const args = {
-        label: "Test Category",
-        description: "A test category for testing"
-      };
-      const action = registerAbilityCategory(slug, args);
-      await action({ select: mockSelect, dispatch: mockDispatch });
-      expect(mockDispatch).toHaveBeenCalledWith({
-        type: REGISTER_ABILITY_CATEGORY,
-        category: {
-          slug,
-          label: args.label,
-          description: args.description,
-          meta: {
-            _clientRegistered: true
-          }
-        }
-      });
-    });
-    it("should register a category with meta", async () => {
-      const slug = "test-category";
-      const args = {
-        label: "Test Category",
-        description: "A test category",
-        meta: { foo: "bar", nested: { key: "value" } }
-      };
-      const action = registerAbilityCategory(slug, args);
-      await action({ select: mockSelect, dispatch: mockDispatch });
-      expect(mockDispatch).toHaveBeenCalledWith({
-        type: REGISTER_ABILITY_CATEGORY,
-        category: {
-          slug,
-          label: args.label,
-          description: args.description,
-          meta: {
-            ...args.meta,
-            _clientRegistered: true
-          }
-        }
-      });
-    });
-    it("should validate and reject empty slug", async () => {
-      const args = {
-        label: "Test",
-        description: "Test"
-      };
-      const action = registerAbilityCategory("", args);
-      await expect(
-        action({ select: mockSelect, dispatch: mockDispatch })
-      ).rejects.toThrow("Category slug is required");
-      expect(mockDispatch).not.toHaveBeenCalled();
-    });
-    it("should validate and reject invalid slug formats", async () => {
-      const testCases = [
-        "Data-Retrieval",
-        // Uppercase
-        "data_retrieval",
-        // Underscores
-        "data.retrieval",
-        // Dots
-        "data/retrieval",
-        // Slashes
-        "-data-retrieval",
-        // Leading dash
-        "data-retrieval-",
-        // Trailing dash
-        "data--retrieval",
-        // Double dash
-        "data retrieval",
-        // Spaces
-        "data!retrieval"
-        // Special characters
-      ];
-      const args = {
-        label: "Test",
-        description: "Test"
-      };
-      for (const invalidSlug of testCases) {
-        const action = registerAbilityCategory(invalidSlug, args);
-        await expect(
-          action({ select: mockSelect, dispatch: mockDispatch })
-        ).rejects.toThrow(
-          "Category slug must contain only lowercase alphanumeric characters and dashes"
-        );
-        expect(mockDispatch).not.toHaveBeenCalled();
-        mockDispatch.mockClear();
-      }
-    });
-    it("should accept valid slug formats", async () => {
-      const validSlugs = [
-        "data-retrieval",
-        "user-management",
-        "analytics-123",
-        "ecommerce",
-        "a",
-        "123",
-        "test-multiple-words-with-dashes"
-      ];
-      const args = {
-        label: "Test Category",
-        description: "Test description"
-      };
-      for (const validSlug of validSlugs) {
-        mockSelect.getAbilityCategory.mockReturnValue(null);
-        mockDispatch.mockClear();
-        const action = registerAbilityCategory(validSlug, args);
-        await action({ select: mockSelect, dispatch: mockDispatch });
-        expect(mockDispatch).toHaveBeenCalledWith({
-          type: REGISTER_ABILITY_CATEGORY,
-          category: {
-            slug: validSlug,
-            label: args.label,
-            description: args.description,
-            meta: {
-              _clientRegistered: true
-            }
-          }
-        });
-      }
-    });
-    it("should validate and reject missing label", async () => {
-      const slug = "test-category";
-      const args = {
-        label: "",
-        description: "Test"
-      };
-      const action = registerAbilityCategory(slug, args);
-      await expect(
-        action({ select: mockSelect, dispatch: mockDispatch })
-      ).rejects.toThrow(
-        "The category properties must contain a `label` string."
-      );
-      expect(mockDispatch).not.toHaveBeenCalled();
-    });
-    it("should validate and reject non-string label", async () => {
-      const slug = "test-category";
-      const args = {
-        label: 123,
-        description: "Test"
-      };
-      const action = registerAbilityCategory(slug, args);
-      await expect(
-        action({ select: mockSelect, dispatch: mockDispatch })
-      ).rejects.toThrow(
-        "The category properties must contain a `label` string."
-      );
-      expect(mockDispatch).not.toHaveBeenCalled();
-    });
-    it("should validate and reject missing description", async () => {
-      const slug = "test-category";
-      const args = {
-        label: "Test",
-        description: ""
-      };
-      const action = registerAbilityCategory(slug, args);
-      await expect(
-        action({ select: mockSelect, dispatch: mockDispatch })
-      ).rejects.toThrow(
-        "The category properties must contain a `description` string."
-      );
-      expect(mockDispatch).not.toHaveBeenCalled();
-    });
-    it("should validate and reject non-string description", async () => {
-      const slug = "test-category";
-      const args = {
-        label: "Test",
-        description: 123
-      };
-      const action = registerAbilityCategory(slug, args);
-      await expect(
-        action({ select: mockSelect, dispatch: mockDispatch })
-      ).rejects.toThrow(
-        "The category properties must contain a `description` string."
-      );
-      expect(mockDispatch).not.toHaveBeenCalled();
-    });
-    it("should validate and reject non-object meta", async () => {
-      const slug = "test-category";
-      const args = {
-        label: "Test",
-        description: "Test",
-        meta: "invalid"
-      };
-      const action = registerAbilityCategory(slug, args);
-      await expect(
-        action({ select: mockSelect, dispatch: mockDispatch })
-      ).rejects.toThrow(
-        "The category properties should provide a valid `meta` object."
-      );
-      expect(mockDispatch).not.toHaveBeenCalled();
-    });
-    it("should validate and reject array as meta", async () => {
-      const slug = "test-category";
-      const args = {
-        label: "Test",
-        description: "Test",
-        meta: ["invalid"]
-      };
-      const action = registerAbilityCategory(slug, args);
-      await expect(
-        action({ select: mockSelect, dispatch: mockDispatch })
-      ).rejects.toThrow(
-        "The category properties should provide a valid `meta` object."
-      );
-      expect(mockDispatch).not.toHaveBeenCalled();
-    });
-    it("should validate and reject already registered category", async () => {
-      const existingCategory = {
-        slug: "test-category",
-        label: "Existing Category",
-        description: "Already registered"
-      };
-      mockSelect.getAbilityCategory.mockReturnValue(existingCategory);
-      const args = {
-        label: "Test",
-        description: "Test"
-      };
-      const action = registerAbilityCategory("test-category", args);
-      await expect(
-        action({ select: mockSelect, dispatch: mockDispatch })
-      ).rejects.toThrow(
-        'Category "test-category" is already registered.'
-      );
-      expect(mockDispatch).not.toHaveBeenCalled();
-    });
-    it("should allow registering ability after registering category", async () => {
-      const categorySlug = "new-category";
-      const categoryArgs = {
-        label: "New Category",
-        description: "A newly registered category"
-      };
-      const categoryAction = registerAbilityCategory(
-        categorySlug,
-        categoryArgs
-      );
-      await categoryAction({
-        select: mockSelect,
-        dispatch: mockDispatch
-      });
-      expect(mockDispatch).toHaveBeenCalledWith({
-        type: REGISTER_ABILITY_CATEGORY,
-        category: {
-          slug: categorySlug,
-          label: categoryArgs.label,
-          description: categoryArgs.description,
-          meta: {
-            _clientRegistered: true
-          }
-        }
-      });
-      const categoriesWithNew = [
-        {
-          slug: categorySlug,
-          label: categoryArgs.label,
-          description: categoryArgs.description
-        }
-      ];
-      mockSelect.getAbilityCategories = jest.fn().mockReturnValue(categoriesWithNew);
-      resolveSelect.mockReturnValue({
-        getAbilityCategories: jest.fn().mockResolvedValue(categoriesWithNew)
-      });
-      mockSelect.getAbility = jest.fn().mockReturnValue(null);
-      mockDispatch.mockClear();
-      const ability = {
-        name: "test/ability",
-        label: "Test Ability",
-        description: "Test description",
-        category: categorySlug,
-        callback: jest.fn()
-      };
-      const abilityAction = registerAbility(ability);
-      await abilityAction({
-        select: mockSelect,
-        dispatch: mockDispatch
-      });
-      expect(mockDispatch).toHaveBeenCalledWith({
-        type: REGISTER_ABILITY,
-        ability
-      });
-    });
-  });
-  describe("unregisterAbilityCategory", () => {
-    it("should create an action to unregister a category", () => {
-      const slug = "test-category";
-      const action = unregisterAbilityCategory(slug);
-      expect(action).toEqual({
-        type: UNREGISTER_ABILITY_CATEGORY,
-        slug
-      });
-    });
-    it("should handle valid category slugs", () => {
-      const slug = "data-retrieval";
-      const action = unregisterAbilityCategory(slug);
-      expect(action).toEqual({
-        type: UNREGISTER_ABILITY_CATEGORY,
-        slug
-      });
-    });
-  });
-});
-//# sourceMappingURL=actions.test.js.map