@cubicweb/client 1.0.1 → 1.0.3

package/src/__tests__/Schema.specs.ts

@@ -1,347 +0,0 @@
-import { Schema } from "../schema/Schema";
-
-describe("Schema", () => {
-  describe("From loosely typed schema", () => {
-    const looselyTypedSchema = new Schema({
-      entities: [
-        {
-          type: "Person",
-          description: "A Person",
-          final: false,
-        },
-        {
-          type: "Task",
-          description: "Something that must be done",
-          final: false,
-        },
-      ],
-      relations_definitions: [
-        {
-          type: "has_task",
-          description: "Something that the person must do",
-          final: false,
-          cardinality: "*+",
-          subject: "Person",
-          object: "Task",
-          constraints: null,
-        },
-      ],
-    });
-    describe("entities", () => {
-      it("should be a list of 2 entity schemas", () => {
-        expect(looselyTypedSchema.entities).toHaveLength(2);
-      });
-    });
-    describe("relation_definitions", () => {
-      it("should be a list of 1 relation schemas", () => {
-        expect(looselyTypedSchema.relationsDefinitions).toHaveLength(1);
-      });
-    });
-    describe("get", () => {
-      it("Get an existing entity", () => {
-        expect(looselyTypedSchema.getEntity("Person")?.type).toBe("Person");
-      });
-      it("Get a non-existing entity", () => {
-        expect(looselyTypedSchema.getEntity("Thing")).toBeNull();
-      });
-    });
-    describe("matchRelationDefinitions", () => {
-      it("Get a relation by its type", () => {
-        const hasTaskMatch = looselyTypedSchema.matchRelationDefinitions({
-          type: "has_task",
-        });
-        expect(hasTaskMatch).toHaveLength(1);
-        expect(hasTaskMatch[0].type).toBe("has_task");
-      });
-      it("Get a relation by its subject", () => {
-        const hasTaskMatch = looselyTypedSchema.matchRelationDefinitions({
-          subject: "Person",
-        });
-        expect(hasTaskMatch).toHaveLength(1);
-        expect(hasTaskMatch[0].type).toBe("has_task");
-      });
-      it("Get a non-existing relation", () => {
-        const hasTaskMatch = looselyTypedSchema.matchRelationDefinitions({
-          subject: "Thing",
-        });
-        expect(hasTaskMatch).toHaveLength(0);
-      });
-    });
-
-    describe("EntitySchema", () => {
-      describe("subjectRelationDefinitions", () => {
-        it("should be a relation with Person as subject", () => {
-          expect(
-            looselyTypedSchema.getEntity("Person")
-              ?.subjectRelationDefinitions[0].type
-          ).toBe("has_task");
-        });
-      });
-      describe("getSubjectRelationDefinition", () => {
-        it("should be the has_task relation", () => {
-          expect(
-            looselyTypedSchema
-              .getEntity("Person")
-              ?.getSubjectRelationDefinition("has_task").type
-          ).toBe("has_task");
-        });
-      });
-      describe("getObjectRelationDefinition", () => {
-        it("should be the has_task relation", () => {
-          expect(
-            looselyTypedSchema
-              .getEntity("Task")
-              ?.getObjectRelationDefinition("has_task").type
-          ).toBe("has_task");
-        });
-      });
-      describe("attributes", () => {
-        it("should be an empty array", () => {
-          expect(
-            looselyTypedSchema.getEntity("Person")?.attributes
-          ).toHaveLength(0);
-        });
-      });
-      describe("attributes", () => {
-        it("should be an empty array", () => {
-          expect(
-            looselyTypedSchema.getEntity("Person")?.attributes
-          ).toHaveLength(0);
-        });
-      });
-      describe("isRelationRequired", () => {
-        it("Should not be required", () => {
-          expect(
-            looselyTypedSchema
-              .getEntity("Person")
-              ?.isRelationRequired("has_task", "subject")
-          ).toBeFalsy();
-        });
-        it("Should throw an error", () => {
-          expect(() =>
-            looselyTypedSchema
-              .getEntity("Person")
-              ?.isRelationRequired("has_task", "object")
-          ).toThrow();
-        });
-        it("Should not be required", () => {
-          expect(
-            looselyTypedSchema
-              .getEntity("Task")
-              ?.isRelationRequired("has_task", "object")
-          ).toBeTruthy();
-        });
-        it("Should throw an error", () => {
-          expect(() =>
-            looselyTypedSchema
-              .getEntity("Task")
-              ?.isRelationRequired("has_task", "subject")
-          ).toThrow();
-        });
-      });
-    });
-
-    describe("RelationDefinitionSchema", () => {
-      describe("subject", () => {
-        it("should be a Person entity", () => {
-          expect(
-            looselyTypedSchema.matchRelationDefinitions({ type: "has_task" })[0]
-              .subject.type
-          ).toBe("Person");
-        });
-      });
-      describe("object", () => {
-        it("should be a Task entity", () => {
-          expect(
-            looselyTypedSchema.matchRelationDefinitions({ type: "has_task" })[0]
-              .object.type
-          ).toBe("Task");
-        });
-      });
-    });
-  });
-
-  describe("From strongly typed schema", () => {
-    interface PersonWithATask {
-      entities: [
-        {
-          type: "Person";
-          description: "A Person";
-          final: false;
-        },
-        {
-          type: "Task";
-          description: "Something that must be done";
-          final: false;
-        }
-      ];
-      relations_definitions: [
-        {
-          type: "has_task";
-          description: "Something that the person must do";
-          final: false;
-          cardinality: "*+";
-          subject: "Person";
-          object: "Task";
-          constraints: null;
-        }
-      ];
-    }
-    const stronglyTypedSchema = new Schema<
-      PersonWithATask["entities"],
-      PersonWithATask["relations_definitions"]
-    >({
-      entities: [
-        {
-          type: "Person",
-          description: "A Person",
-          final: false,
-        },
-        {
-          type: "Task",
-          description: "Something that must be done",
-          final: false,
-        },
-      ],
-      relations_definitions: [
-        {
-          type: "has_task",
-          description: "Something that the person must do",
-          final: false,
-          cardinality: "*+",
-          subject: "Person",
-          object: "Task",
-          constraints: null,
-        },
-      ],
-    });
-    describe("entities", () => {
-      it("should be a list of 2 entity schemas", () => {
-        expect(stronglyTypedSchema.entities).toHaveLength(2);
-      });
-    });
-    describe("relation_definitions", () => {
-      it("should be a list of 1 relation schemas", () => {
-        expect(stronglyTypedSchema.relationsDefinitions).toHaveLength(1);
-      });
-    });
-    describe("get", () => {
-      it("Get an existing entity", () => {
-        expect(stronglyTypedSchema.getEntity("Person")?.type).toBe("Person");
-      });
-      it("Get a non-existing entity", () => {
-        expect(stronglyTypedSchema.getEntity("Thing")).toBeNull();
-      });
-    });
-    describe("matchRelationDefinitions", () => {
-      it("Get a relation by its type", () => {
-        const hasTaskMatch = stronglyTypedSchema.matchRelationDefinitions({
-          type: "has_task",
-        });
-        expect(hasTaskMatch).toHaveLength(1);
-        expect(hasTaskMatch[0].type).toBe("has_task");
-      });
-      it("Get a relation by its subject", () => {
-        const hasTaskMatch = stronglyTypedSchema.matchRelationDefinitions({
-          subject: "Person",
-        });
-        expect(hasTaskMatch).toHaveLength(1);
-        expect(hasTaskMatch[0].type).toBe("has_task");
-      });
-    });
-
-    describe("EntitySchema", () => {
-      describe("subjectRelationDefinitions", () => {
-        it("should be a relation with Person as subject", () => {
-          expect(
-            stronglyTypedSchema.getEntity("Person")
-              ?.subjectRelationDefinitions[0].type
-          ).toBe("has_task");
-        });
-      });
-      describe("getSubjectRelationDefinition", () => {
-        it("should be the has_task relation", () => {
-          expect(
-            stronglyTypedSchema
-              .getEntity("Person")
-              ?.getSubjectRelationDefinition("has_task").type
-          ).toBe("has_task");
-        });
-      });
-      describe("getObjectRelationDefinition", () => {
-        it("should be the has_task relation", () => {
-          expect(
-            stronglyTypedSchema
-              .getEntity("Task")
-              ?.getObjectRelationDefinition("has_task").type
-          ).toBe("has_task");
-        });
-      });
-      describe("attributes", () => {
-        it("should be an empty array", () => {
-          expect(
-            stronglyTypedSchema.getEntity("Person")?.attributes
-          ).toHaveLength(0);
-        });
-      });
-      describe("attributes", () => {
-        it("should be an empty array", () => {
-          expect(
-            stronglyTypedSchema.getEntity("Person")?.attributes
-          ).toHaveLength(0);
-        });
-      });
-      describe("isRelationRequired", () => {
-        it("Should not be required", () => {
-          expect(
-            stronglyTypedSchema
-              .getEntity("Person")
-              ?.isRelationRequired("has_task", "subject")
-          ).toBeFalsy();
-        });
-        it("Should throw an error", () => {
-          expect(() =>
-            stronglyTypedSchema
-              .getEntity("Person")
-              ?.isRelationRequired("has_task", "object")
-          ).toThrow();
-        });
-        it("Should not be required", () => {
-          expect(
-            stronglyTypedSchema
-              .getEntity("Task")
-              ?.isRelationRequired("has_task", "object")
-          ).toBeTruthy();
-        });
-        it("Should throw an error", () => {
-          expect(() =>
-            stronglyTypedSchema
-              .getEntity("Task")
-              ?.isRelationRequired("has_task", "subject")
-          ).toThrow();
-        });
-      });
-    });
-
-    describe("RelationDefinitionSchema", () => {
-      describe("subject", () => {
-        it("should be a Person entity", () => {
-          expect(
-            stronglyTypedSchema.matchRelationDefinitions({
-              type: "has_task",
-            })[0].subject.type
-          ).toBe("Person");
-        });
-      });
-      describe("object", () => {
-        it("should be a Task entity", () => {
-          expect(
-            stronglyTypedSchema.matchRelationDefinitions({
-              type: "has_task",
-            })[0].object.type
-          ).toBe("Task");
-        });
-      });
-    });
-  });
-});