test: add missing tests

packages/core/.gitignore

@@ -3,3 +3,4 @@
 dist/
 node_modules/
 doc/
+coverage/

packages/core/foundation.ts

@@ -34,3 +34,11 @@ export type {
   EditCompletedEvent,
   EditCompletedDetail,
 } from './foundation/edit-completed-event.js';
+
+/** @returns the cartesian product of `arrays` */
+export function crossProduct<T>(...arrays: T[][]): T[][] {
+  return arrays.reduce<T[][]>(
+    (a, b) => <T[][]>a.flatMap(d => b.map(e => [d, e].flat())),
+    [[]]
+  );
+}

packages/core/foundation/deprecated/history.ts

@@ -44,7 +44,6 @@ export type InfoEntry = Timestamped & InfoDetail;
 
 export type LogEntry = InfoEntry | CommitEntry;
 
-
 export function newLogEvent(
   detail: LogDetail,
   eventInitDict?: CustomEventInit<LogDetail>
@@ -70,9 +69,8 @@ export function newIssueEvent(
 }
 
 declare global {
-    interface ElementEventMap {
-      ['log']: LogEvent;
-      ['issue']: IssueEvent;
-    }
+  interface ElementEventMap {
+    ['log']: LogEvent;
+    ['issue']: IssueEvent;
   }
-  
+}

packages/core/foundation/deprecated/open-event.ts

@@ -19,7 +19,7 @@ export function newOpenDocEvent(
 }
 
 declare global {
-    interface ElementEventMap {
-      ['open-doc']: OpenDocEvent;
-    }
-  }
+  interface ElementEventMap {
+    ['open-doc']: OpenDocEvent;
+  }
+}

packages/core/foundation/deprecated/settings.ts

@@ -62,7 +62,6 @@ export function newSettingsUIEvent(
   });
 }
 
-
 declare global {
   interface ElementEventMap {
     ['oscd-settings']: SettingsUIEvent;

packages/core/foundation/deprecated/validation.ts

@@ -10,10 +10,8 @@ export function newValidateEvent(
   });
 }
 
-
 declare global {
-    interface ElementEventMap {
-      ['validate']: ValidateEvent;
-    }
+  interface ElementEventMap {
+    ['validate']: ValidateEvent;
   }
-  
+}

packages/core/foundation/deprecated/waiter.ts

@@ -5,7 +5,7 @@ export interface PendingStateDetail {
 export type PendingStateEvent = CustomEvent<PendingStateDetail>;
 
 /**
- * @deprecated
+ * @deprecated not used anymore
  */
 export function newPendingStateEvent(
   promise: Promise<void>,

packages/core/foundation/edit-event.spec.ts

@@ -0,0 +1,187 @@
+import {
+  Edit,
+  EditEvent,
+  EditEventDetail,
+  isComplex,
+  isInsert,
+  isNamespaced,
+  isRemove,
+  isUpdate,
+  NamespacedAttributeValue,
+  newEditEvent,
+} from './edit-event';
+
+const doc: XMLDocument = new DOMParser().parseFromString(
+  `<Document></Document>`,
+  'application/xml'
+);
+
+describe('edit-event.ts', () => {
+  const el: Element = doc.createElement('Parent');
+
+  describe('isComplex', () => {
+    it('should return true when `Edit` is complex', () => {
+      const complexEdit: Edit = [
+        {
+          element: el,
+          attributes: {
+            firstname: 'John',
+          },
+        },
+        {
+          element: el,
+          attributes: {
+            lastname: 'Doe',
+          },
+        },
+      ];
+
+      expect(isComplex(complexEdit)).toBeTruthy();
+    });
+
+    it('Should return false when `Edit` is simple', () => {
+      const simpleEdit: Edit = {
+        element: el,
+        attributes: {
+          name: 'John Doe',
+        },
+      };
+
+      expect(isComplex(simpleEdit)).toBeFalsy();
+    });
+  });
+
+  describe('isInsert', () => {
+    it('Should return true when `Edit` is Insert', () => {
+      const edit: Edit = {
+        parent: doc,
+        node: el,
+      };
+
+      expect(isInsert(edit)).toBeTruthy();
+    });
+
+    it('Should return false when `Edit` is Update', () => {
+      const edit: Edit = {
+        element: el,
+        attributes: {
+          name: 'John Doe',
+        },
+      };
+
+      expect(isInsert(edit)).toBeFalsy();
+    });
+  });
+
+  describe('isNamespaced', () => {
+    it('Should return true when `value` is Namespaced', () => {
+      const value: NamespacedAttributeValue = {
+        value: 'Name',
+        namespaceURI: 'TEST',
+      };
+
+      expect(isNamespaced(value)).toBeTruthy();
+    });
+
+    it('Should return false when `value` is String', () => {
+      expect(isNamespaced('TEST')).toBeFalsy();
+    });
+
+    it('Should return false when `value` is null', () => {
+      expect(isNamespaced(null)).toBeFalsy();
+    });
+  });
+
+  describe('isUpdate', () => {
+    it('Should return true when Edit is Update', () => {
+      const edit: Edit = {
+        element: el,
+        attributes: {},
+      };
+
+      expect(isUpdate(edit)).toBeTruthy();
+    });
+
+    it('Should return false when Edit is Insert', () => {
+      const edit: Edit = {
+        parent: doc,
+        node: el,
+      };
+
+      expect(isUpdate(edit)).toBeFalsy();
+    });
+  });
+
+  describe('isRemove', () => {
+    it('Should return true when Edit is Remove', () => {
+      const edit: Edit = {
+        node: el,
+      };
+
+      expect(isRemove(edit)).toBeTruthy();
+    });
+
+    it('Should return false when Edit is Update', () => {
+      const edit: Edit = {
+        element: el,
+        attributes: {},
+      };
+
+      expect(isRemove(edit)).toBeFalsy();
+    });
+  });
+
+  describe('newEditEvent', () => {
+    it('Should have name `oscd-edit`', () => {
+      const edit: Edit = {
+        element: el,
+        attributes: {},
+      };
+
+      const res: EditEvent = newEditEvent(edit);
+
+      expect(res.type).toEqual('oscd-edit');
+    });
+
+    it('Should be composed', () => {
+      const edit: Edit = {
+        element: el,
+        attributes: {},
+      };
+
+      const res: EditEvent = newEditEvent(edit);
+
+      expect(res.composed).toBeTruthy();
+    });
+
+    it('Should be bubble-able', () => {
+      const edit: Edit = {
+        element: el,
+        attributes: {},
+      };
+
+      const res: EditEvent = newEditEvent(edit);
+
+      expect(res.bubbles).toBeTruthy();
+    });
+
+    it('Should have Edit as Detail', () => {
+      const edit: Edit = {
+        element: el,
+        attributes: {},
+      };
+
+      const res: EditEvent = newEditEvent(edit);
+
+      const expectedEventDetail: EditEventDetail<Edit> = {
+        edit: {
+          element: el,
+          attributes: {},
+        },
+        initiator: 'user',
+      };
+
+      expect(res.detail).toEqual(expectedEventDetail);
+    });
+  });
+});

packages/core/foundation/open-event.spec.ts

@@ -0,0 +1,39 @@
+import { newOpenEvent, OpenEvent } from './open-event';
+
+const doc: XMLDocument = new DOMParser().parseFromString(
+  `<Document></Document>`,
+  'application/xml'
+);
+
+describe('open-event.ts', () => {
+  const docName = 'test.xml';
+
+  describe('newOpenEvent', () => {
+    it('Should have name `oscd-open`', () => {
+      const res: OpenEvent = newOpenEvent(doc, docName);
+
+      expect(res.type).toEqual('oscd-open');
+    });
+
+    it('Should be composed', () => {
+      const res: OpenEvent = newOpenEvent(doc, docName);
+
+      expect(res.composed).toBeTruthy();
+    });
+
+    it('Should be bubble-able', () => {
+      const res: OpenEvent = newOpenEvent(doc, docName);
+
+      expect(res.bubbles).toBeTruthy();
+    });
+
+    it('Should have Edit as Detail', () => {
+      const res: OpenEvent = newOpenEvent(doc, docName);
+
+      expect(res.detail).toEqual({
+        docName: docName,
+        doc: doc,
+      });
+    });
+  });
+});