Lady’s Gitweb - Etiquette/blob - model.test.js

   1 // 📧🏷️ Étiquette ∷ model.test.js
   2 // ====================================================================
   3 //
   4 // Copyright © 2023 Lady [@ Lady’s Computer].
   5 //
   6 // This Source Code Form is subject to the terms of the Mozilla Public
   7 // License, v. 2.0. If a copy of the MPL was not distributed with this
   8 // file, You can obtain one at <https://mozilla.org/MPL/2.0/>.
   9
  10 import {
  11   assert,
  12   assertArrayIncludes,
  13   assertEquals,
  14   assertFalse,
  15   assertObjectMatch,
  16   assertStrictEquals,
  17   assertThrows,
  18   beforeEach,
  19   describe,
  20   it,
  21 } from "./dev-deps.js";
  22 import { TagSystem } from "./model.js";
  23
  24 describe("TagSystem", () => {
  25   it("[[Call]] throws", () => {
  26     assertThrows(() => {
  27       TagSystem();
  28     });
  29   });
  30
  31   it("[[Construct]] creates a new TagSystem", () => {
  32     assertStrictEquals(
  33       Object.getPrototypeOf(new TagSystem("example", "1972-12-31")),
  34       TagSystem.prototype,
  35     );
  36   });
  37
  38   it("[[Construct]] uses the identifier if provided", () => {
  39     assertStrictEquals(
  40       new TagSystem("example", "1972-12-31", "etaoin").identifier,
  41       "etaoin",
  42     );
  43   });
  44
  45   it("[[Construct]] uses an empty identifier if none is provided", () => {
  46     assertStrictEquals(
  47       new TagSystem("example", "1972-12-31").identifier,
  48       "",
  49     );
  50   });
  51
  52   it("[[Construct]] throws if provided an invalid domain", () => {
  53     assertThrows(() => {
  54       new TagSystem("example@example", "1972-12-31");
  55     });
  56     assertThrows(() => {
  57       new TagSystem("0.0.0.0", "1972-12-31");
  58     });
  59   });
  60
  61   it("[[Construct]] throws if provided an invalid date", () => {
  62     assertThrows(() => {
  63       new TagSystem("example", "1969");
  64     });
  65     assertThrows(() => {
  66       new TagSystem("example", "1972-12-31T00:00:00Z");
  67     });
  68   });
  69
  70   describe("::Tag", () => {
  71     let Tag;
  72     let system;
  73
  74     beforeEach(() => {
  75       system = new TagSystem("example", "1972-12-31");
  76       Tag = system.Tag;
  77     });
  78
  79     it("[[Get]] returns the same value every time", () => {
  80       assertStrictEquals(Tag, system.Tag);
  81     });
  82
  83     it("[[Call]] throws", () => {
  84       assertThrows(() => {
  85         Tag();
  86       });
  87     });
  88
  89     it("[[Construct]] returns a new Tag", () => {
  90       assertStrictEquals(
  91         Object.getPrototypeOf(new Tag()),
  92         Tag.prototype,
  93       );
  94     });
  95
  96     it('[[Construct]] defaults the kind to "Tag"', () => {
  97       assertStrictEquals(new Tag().kind, "Tag");
  98     });
  99
 100     it("[[Construct]] correctly sets the tag kind", () => {
 101       assertStrictEquals(
 102         new Tag("RelationshipTag").kind,
 103         "RelationshipTag",
 104       );
 105     });
 106
 107     it("[[Construct]] defaults the preferred label to the empty string", () => {
 108       assertEquals({ ...new Tag().prefLabel }, { "@value": "" });
 109     });
 110
 111     it("[[Construct]] correctly sets the preferred label to a simple string", () => {
 112       assertEquals(
 113         { ...new Tag("RelationshipTag", "Shadow, Me").prefLabel },
 114         { "@value": "Shadow, Me" },
 115       );
 116     });
 117
 118     it("[[Construct]] initializes tag identifiers to null", () => {
 119       assertStrictEquals(
 120         new Tag().identifier,
 121         null,
 122       );
 123     });
 124
 125     it("[[Construct]] correctly sets the preferred label to a language‐tagged string", () => {
 126       assertEquals(
 127         {
 128           ...new Tag("RelationshipTag", {
 129             "@value": "Shadow, Me",
 130             "@language": "en",
 131           }).prefLabel,
 132         },
 133         { "@value": "Shadow, Me", "@language": "en" },
 134       );
 135     });
 136
 137     it("[[Construct]] throws if the tag kind is not recognized", () => {
 138       assertThrows(() => {
 139         new Tag("NotATag");
 140       });
 141     });
 142
 143     describe(".all", () => {
 144       it("[[Call]] yields all the persisted tags", () => {
 145         const tags = new Set(function* () {
 146           let i = 0;
 147           while (i++ < 5) {
 148             // Generate 5 tags and remember their identifiers.
 149             const tag = new Tag();
 150             tag.persist();
 151             yield tag.identifier;
 152           }
 153         }());
 154         for (const tag of Tag.all()) {
 155           assertStrictEquals(
 156             Object.getPrototypeOf(tag),
 157             Tag.prototype,
 158           );
 159         }
 160         assertEquals(
 161           new Set(Array.from(Tag.all(), (tag) => tag.identifier)),
 162           tags,
 163         );
 164       });
 165     });
 166
 167     describe(".constructor", () => {
 168       it("[[Get]] is `Function`", () => {
 169         assertStrictEquals(Tag.constructor, Function);
 170       });
 171     });
 172
 173     describe(".fromIRI", () => {
 174       it("[[Call]] returns the persisted tag with the given I·R·I", () => {
 175         const tag = new Tag();
 176         tag.persist();
 177         const { identifier, iri } = tag;
 178         const retrieved = Tag.fromIRI(iri);
 179         assertStrictEquals(
 180           Object.getPrototypeOf(retrieved),
 181           Tag.prototype,
 182         );
 183         assertStrictEquals(retrieved.identifier, identifier);
 184       });
 185
 186       it("[[Call]] returns undefined if no tag with the given I·R·I has been persisted", () => {
 187         assertStrictEquals(
 188           Tag.fromIRI(
 189             `https://${system.authorityName}/tag:${system.taggingEntity}:000-0000`,
 190           ),
 191           undefined,
 192         );
 193       });
 194
 195       it("[[Call]] throws if passed an invalid I·R·I", () => {
 196         assertThrows(() => {
 197           Tag.fromIRI(`bad iri`);
 198         });
 199       });
 200     });
 201
 202     describe(".fromIdentifier", () => {
 203       it("[[Call]] returns the persisted tag with the given identifier", () => {
 204         const tag = new Tag();
 205         tag.persist();
 206         const { identifier } = tag;
 207         const retrieved = Tag.fromIdentifier(identifier);
 208         assertStrictEquals(
 209           Object.getPrototypeOf(retrieved),
 210           Tag.prototype,
 211         );
 212         assertStrictEquals(retrieved.identifier, identifier);
 213       });
 214
 215       it("[[Call]] returns undefined if no tag with the given identifier has been persisted", () => {
 216         assertStrictEquals(Tag.fromIdentifier("000-0000"), undefined);
 217       });
 218
 219       it("[[Call]] throws if passed an invalid identifier", () => {
 220         assertThrows(() => {
 221           Tag.fromIdentifier(""); // wrong format
 222         });
 223         assertThrows(() => {
 224           Tag.fromIdentifier("100-0000"); // bad checksum
 225         });
 226       });
 227     });
 228
 229     describe(".fromTagURI", () => {
 230       it("[[Call]] returns the persisted tag with the given Tag U·R·I", () => {
 231         const tag = new Tag();
 232         tag.persist();
 233         const { identifier, tagURI } = tag;
 234         const retrieved = Tag.fromTagURI(tagURI);
 235         assertStrictEquals(
 236           Object.getPrototypeOf(retrieved),
 237           Tag.prototype,
 238         );
 239         assertStrictEquals(retrieved.identifier, identifier);
 240       });
 241
 242       it("[[Call]] returns undefined if no tag with the given Tag U·R·I has been persisted", () => {
 243         assertStrictEquals(
 244           Tag.fromTagURI(`tag:${system.taggingEntity}:`),
 245           undefined,
 246         );
 247         assertStrictEquals(
 248           Tag.fromTagURI(`tag:${system.taggingEntity}:000-0000`),
 249           undefined,
 250         );
 251       });
 252
 253       it("[[Call]] throws if passed an invalid Tag U·R·I", () => {
 254         assertThrows(() => {
 255           Tag.fromTagURI(""); // wrong format
 256         });
 257         assertThrows(() => {
 258           Tag.fromTagURI(
 259             "tag:unexample,1970-01-01:Z", // incorrect tagging entity
 260           );
 261         });
 262       });
 263     });
 264
 265     describe(".identifiers", () => {
 266       it("[[Call]] yields all the persisted identifiers", () => {
 267         const tags = new Set(function* () {
 268           let i = 0;
 269           while (i++ < 5) {
 270             // Generate 5 tags and remember their identifiers.
 271             const tag = new Tag();
 272             tag.persist();
 273             yield tag.identifier;
 274           }
 275         }());
 276         assertEquals(
 277           new Set(Tag.identifiers()),
 278           tags,
 279         );
 280       });
 281     });
 282
 283     describe(".system", () => {
 284       it("[[Call]] returns the `TagSystem`", () => {
 285         assertEquals(Tag.system, system);
 286       });
 287     });
 288
 289     // `.[Storage.toInstance]` is tested by `.fromIdentifier`.
 290
 291     describe("::addAltLabel", () => {
 292       it("[[Call]] does nothing if called with no arguments", () => {
 293         const tag = new Tag();
 294         tag.addAltLabel();
 295         assertEquals([...tag.altLabels()], []);
 296       });
 297
 298       it("[[Call]] adds the provided alternative labels", () => {
 299         const tag = new Tag();
 300         tag.addAltLabel(
 301           "one",
 302           { "@value": "two" },
 303           { "@value": "three", "@language": "en" },
 304         );
 305         assertEquals(
 306           Array.from(tag.altLabels(), ($) => ({ ...$ })),
 307           [
 308             { "@value": "one" },
 309             { "@value": "two" },
 310             { "@value": "three", "@language": "en" },
 311           ],
 312         );
 313       });
 314
 315       it("[[Call]] returns this", () => {
 316         const tag = new Tag();
 317         assertStrictEquals(tag.addAltLabel(), tag);
 318       });
 319     });
 320
 321     describe("::addBroaderTag", () => {
 322       it("[[Call]] does nothing if called with no arguments", () => {
 323         const tag = new Tag();
 324         tag.addBroaderTag();
 325         assertEquals([...tag.broaderTags()], []);
 326       });
 327
 328       it("[[Call]] adds the provided broader tags", () => {
 329         const broader = new Tag();
 330         broader.persist();
 331         const broader2 = new Tag();
 332         broader2.persist();
 333         const tag = new Tag();
 334         tag.addBroaderTag(broader, broader2);
 335         assertEquals(
 336           Array.from(tag.broaderTags(), ($) => $.identifier),
 337           [broader.identifier, broader2.identifier],
 338         );
 339       });
 340
 341       it("[[Call]] returns this", () => {
 342         const tag = new Tag();
 343         assertStrictEquals(tag.addBroaderTag(), tag);
 344       });
 345
 346       it("[[Call]] throws when adding a non‐persisted tag", () => {
 347         const tag = new Tag();
 348         assertThrows(() => {
 349           tag.addBroaderTag(new Tag());
 350         });
 351       });
 352
 353       it("[[Call]] throws when adding an unrecognized identifier", () => {
 354         const tag = new Tag();
 355         assertThrows(() => {
 356           tag.addBroaderTag("000-0000"); // not persisted
 357         });
 358         assertThrows(() => {
 359           tag.addBroaderTag(""); // bad format
 360         });
 361       });
 362     });
 363
 364     describe("::addHiddenLabel", () => {
 365       it("[[Call]] does nothing if called with no arguments", () => {
 366         const tag = new Tag();
 367         tag.addHiddenLabel();
 368         assertEquals([...tag.hiddenLabels()], []);
 369       });
 370
 371       it("[[Call]] adds the provided hidden labels", () => {
 372         const tag = new Tag();
 373         tag.addHiddenLabel(
 374           "one",
 375           { "@value": "two" },
 376           { "@value": "three", "@language": "en" },
 377         );
 378         assertEquals(
 379           Array.from(tag.hiddenLabels(), ($) => ({ ...$ })),
 380           [
 381             { "@value": "one" },
 382             { "@value": "two" },
 383             { "@value": "three", "@language": "en" },
 384           ],
 385         );
 386       });
 387
 388       it("[[Call]] returns this", () => {
 389         const tag = new Tag();
 390         assertStrictEquals(tag.addHiddenLabel(), tag);
 391       });
 392     });
 393
 394     describe("::addInCanonTag", () => {
 395       it("[[Call]] does nothing if called with no arguments", () => {
 396         const tag = new Tag("EntityTag");
 397         tag.addInCanonTag();
 398         assertEquals([...tag.inCanonTags()], []);
 399       });
 400
 401       it("[[Call]] adds the provided canon tags", () => {
 402         const canon = new Tag("CanonTag");
 403         canon.persist();
 404         const canon2 = new Tag("CanonTag");
 405         canon2.persist();
 406         const tag = new Tag("EntityTag");
 407         tag.addInCanonTag(canon, canon2);
 408         assertEquals(
 409           Array.from(tag.inCanonTags(), ($) => $.identifier),
 410           [canon.identifier, canon2.identifier],
 411         );
 412       });
 413
 414       it("[[Call]] returns this", () => {
 415         const tag = new Tag("EntityTag");
 416         assertStrictEquals(tag.addInCanonTag(), tag);
 417       });
 418
 419       it("[[Call]] throws when this is not a tag which can be placed in canon", () => {
 420         const canon = new Tag("CanonTag");
 421         canon.persist();
 422         assertThrows(() => {
 423           new Tag().addInCanonTag(canon);
 424         });
 425       });
 426
 427       it("[[Call]] throws when provided with a non‐canon tag", () => {
 428         const notCanon = new Tag();
 429         notCanon.persist();
 430         const tag = new Tag("EntityTag");
 431         assertThrows(() => {
 432           tag.addInCanonTag(notCanon);
 433         });
 434       });
 435
 436       it("[[Call]] throws when adding a non‐persisted tag", () => {
 437         const tag = new Tag("EntityTag");
 438         assertThrows(() => {
 439           tag.addInCanonTag(new Tag("CanonTag"));
 440         });
 441       });
 442
 443       it("[[Call]] throws when adding an unrecognized identifier", () => {
 444         const tag = new Tag("EntityTag");
 445         assertThrows(() => {
 446           tag.addInCanonTag("000-0000"); // not persisted
 447         });
 448         assertThrows(() => {
 449           tag.addInCanonTag(""); // bad format
 450         });
 451       });
 452     });
 453
 454     describe("::addInvolvesTag", () => {
 455       it("[[Call]] does nothing if called with no arguments", () => {
 456         const tag = new Tag("ConceptualTag");
 457         tag.addInvolvesTag();
 458         assertEquals([...tag.involvesTags()], []);
 459       });
 460
 461       it("[[Call]] adds the provided tags", () => {
 462         const involved = new Tag();
 463         involved.persist();
 464         const involved2 = new Tag();
 465         involved2.persist();
 466         const tag = new Tag("ConceptualTag");
 467         tag.addInvolvesTag(involved, involved2);
 468         assertEquals(
 469           Array.from(tag.involvesTags(), ($) => $.identifier),
 470           [involved.identifier, involved2.identifier],
 471         );
 472       });
 473
 474       it("[[Call]] returns this", () => {
 475         const tag = new Tag("ConceptualTag");
 476         assertStrictEquals(tag.addInvolvesTag(), tag);
 477       });
 478
 479       it("[[Call]] throws when this is not a conceptual tag", () => {
 480         const involved = new Tag();
 481         involved.persist();
 482         assertThrows(() => {
 483           new Tag().addInvolvesTag(involved);
 484         });
 485       });
 486
 487       it("[[Call]] throws when this is a relationship tag and provided with a non‐involvable tag", () => {
 488         const notInvolved = new Tag();
 489         notInvolved.persist();
 490         const tag = new Tag("RelationshipTag");
 491         assertThrows(() => {
 492           tag.addInvolvesTag(notInvolved);
 493         });
 494       });
 495
 496       it("[[Call]] throws when adding a non‐persisted tag", () => {
 497         const tag = new Tag("ConceptualTag");
 498         assertThrows(() => {
 499           tag.addInvolvesTag(new Tag());
 500         });
 501       });
 502
 503       it("[[Call]] throws when adding an unrecognized identifier", () => {
 504         const tag = new Tag("ConceptualTag");
 505         assertThrows(() => {
 506           tag.addInvolvesTag("000-0000"); // not persisted
 507         });
 508         assertThrows(() => {
 509           tag.addInvolvesTag(""); // bad format
 510         });
 511       });
 512     });
 513
 514     // `::altLabels` is tested by `::addAltLabel`.
 515
 516     describe("::authorityName", () => {
 517       it("[[Get]] returns the authority name of the tag system", () => {
 518         assertStrictEquals(
 519           new Tag().authorityName,
 520           system.authorityName,
 521         );
 522       });
 523     });
 524
 525     // `::broaderTags` is tested by `::addBroaderTag`.
 526
 527     describe("::broaderTransitiveTags", () => {
 528       it("[[Call]] returns broader tags transitively", () => {
 529         const superBroad = new Tag();
 530         superBroad.persist();
 531         const broad = new Tag();
 532         broad.addBroaderTag(superBroad);
 533         broad.persist();
 534         const tag = new Tag();
 535         tag.addBroaderTag(broad);
 536         assertEquals(
 537           Array.from(tag.broaderTransitiveTags(), ($) => $.identifier),
 538           [broad.identifier, superBroad.identifier],
 539         );
 540       });
 541
 542       it("[[Call]] cannot recurse infinitely", () => {
 543         const tag = new Tag();
 544         tag.persist();
 545         const broad = new Tag();
 546         broad.addBroaderTag(tag);
 547         broad.persist();
 548         tag.addBroaderTag(broad);
 549         tag.persist();
 550         assertEquals(
 551           Array.from(tag.broaderTransitiveTags(), ($) => $.identifier),
 552           [broad.identifier, tag.identifier],
 553         );
 554       });
 555     });
 556
 557     describe("::deleteAltLabel", () => {
 558       it("[[Call]] does nothing if called with no arguments", () => {
 559         const tag = new Tag();
 560         tag.addAltLabel("etaoin");
 561         tag.deleteAltLabel();
 562         assertEquals(
 563           Array.from(tag.altLabels(), ($) => ({ ...$ })),
 564           [{ "@value": "etaoin" }],
 565         );
 566       });
 567
 568       it("[[Call]] deletes only the provided hidden labels", () => {
 569         const tag = new Tag();
 570         tag.addAltLabel(
 571           "one",
 572           "two",
 573           { "@value": "three", "@language": "en" },
 574           "four",
 575         );
 576         tag.deleteAltLabel(
 577           "one",
 578           { "@value": "two" },
 579           { "@value": "three", "@language": "en" },
 580           { "@value": "four", "@language": "en" },
 581         );
 582         assertEquals(
 583           Array.from(tag.altLabels(), ($) => ({ ...$ })),
 584           [{ "@value": "four" }],
 585         );
 586       });
 587
 588       it("[[Call]] returns this", () => {
 589         const tag = new Tag();
 590         assertStrictEquals(tag.deleteAltLabel(), tag);
 591       });
 592     });
 593
 594     describe("::deleteBroaderTag", () => {
 595       it("[[Call]] does nothing if called with no arguments", () => {
 596         const broader = new Tag();
 597         broader.persist();
 598         const tag = new Tag();
 599         tag.addBroaderTag(broader);
 600         tag.deleteBroaderTag();
 601         assertEquals(
 602           Array.from(tag.broaderTags(), ($) => $.identifier),
 603           [broader.identifier],
 604         );
 605       });
 606
 607       it("[[Call]] deletes only the provided broader tags", () => {
 608         const superBroader = new Tag();
 609         superBroader.persist();
 610         const broader = new Tag();
 611         broader.addBroaderTag(superBroader);
 612         broader.persist();
 613         const broader2 = new Tag();
 614         broader2.addBroaderTag(superBroader);
 615         broader2.persist();
 616         const tag = new Tag();
 617         tag.addBroaderTag(broader, broader2);
 618         tag.deleteBroaderTag(broader, superBroader, "000-0000", "");
 619         assertEquals(
 620           Array.from(tag.broaderTags(), ($) => $.identifier),
 621           [broader2.identifier],
 622         );
 623       });
 624
 625       it("[[Call]] returns this", () => {
 626         const tag = new Tag();
 627         assertStrictEquals(tag.deleteBroaderTag(), tag);
 628       });
 629     });
 630
 631     describe("::deleteHiddenLabel", () => {
 632       it("[[Call]] does nothing if called with no arguments", () => {
 633         const tag = new Tag();
 634         tag.addHiddenLabel("etaoin");
 635         tag.deleteHiddenLabel();
 636         assertEquals(
 637           Array.from(tag.hiddenLabels(), ($) => ({ ...$ })),
 638           [{ "@value": "etaoin" }],
 639         );
 640       });
 641
 642       it("[[Call]] deletes only the provided alternative labels", () => {
 643         const tag = new Tag();
 644         tag.addHiddenLabel(
 645           "one",
 646           "two",
 647           { "@value": "three", "@language": "en" },
 648           "four",
 649         );
 650         tag.deleteHiddenLabel(
 651           "one",
 652           { "@value": "two" },
 653           { "@value": "three", "@language": "en" },
 654           { "@value": "four", "@language": "en" },
 655         );
 656         assertEquals(
 657           Array.from(tag.hiddenLabels(), ($) => ({ ...$ })),
 658           [{ "@value": "four" }],
 659         );
 660       });
 661
 662       it("[[Call]] returns this", () => {
 663         const tag = new Tag();
 664         assertStrictEquals(tag.deleteHiddenLabel(), tag);
 665       });
 666     });
 667
 668     describe("::deleteInCanonTag", () => {
 669       it("[[Call]] does nothing if called with no arguments", () => {
 670         const canon = new Tag("CanonTag");
 671         canon.persist();
 672         const tag = new Tag("EntityTag");
 673         tag.addInCanonTag(canon);
 674         tag.deleteInCanonTag();
 675         assertEquals(
 676           Array.from(tag.inCanonTags(), ($) => $.identifier),
 677           [canon.identifier],
 678         );
 679       });
 680
 681       it("[[Call]] deletes only the provided canon tags", () => {
 682         const canon = new Tag("CanonTag");
 683         canon.persist();
 684         const canon2 = new Tag("CanonTag");
 685         canon2.persist();
 686         const tag = new Tag("EntityTag");
 687         tag.addInCanonTag(canon, canon2);
 688         tag.deleteInCanonTag(canon, "000-0000", "");
 689         assertEquals(
 690           Array.from(tag.inCanonTags(), ($) => $.identifier),
 691           [canon2.identifier],
 692         );
 693       });
 694
 695       it("[[Call]] returns this", () => {
 696         const tag = new Tag("EntityTag");
 697         assertStrictEquals(tag.deleteInCanonTag(), tag);
 698       });
 699     });
 700
 701     describe("::deleteInvolvesTag", () => {
 702       it("[[Call]] does nothing if called with no arguments", () => {
 703         const involved = new Tag();
 704         involved.persist();
 705         const tag = new Tag("ConceptualTag");
 706         tag.addInvolvesTag(involved);
 707         tag.deleteInvolvesTag();
 708         assertEquals(
 709           Array.from(tag.involvesTags(), ($) => $.identifier),
 710           [involved.identifier],
 711         );
 712       });
 713
 714       it("[[Call]] deletes only the provided involved tags", () => {
 715         const character = new Tag("CharacterTag");
 716         character.persist();
 717         const involved = new Tag("RelationshipTag");
 718         involved.addInvolvesTag(character);
 719         involved.persist();
 720         const involved2 = new Tag("RelationshipTag");
 721         involved2.addInvolvesTag(character);
 722         involved2.persist();
 723         const tag = new Tag("RelationshipTag");
 724         tag.addInvolvesTag(involved, involved2);
 725         tag.deleteInvolvesTag(involved, character, "000-0000", "");
 726         assertEquals(
 727           Array.from(tag.involvesTags(), ($) => $.identifier),
 728           [involved2.identifier],
 729         );
 730       });
 731
 732       it("[[Call]] returns this", () => {
 733         const tag = new Tag("ConceptualTag");
 734         assertStrictEquals(tag.deleteInvolvesTag(), tag);
 735       });
 736     });
 737
 738     describe("::hasInCanonTags", () => {
 739       it("[[Call]] yields the persisted tags which have this tag in canon", () => {
 740         const canon = new Tag("CanonTag");
 741         canon.persist();
 742         const entity = new Tag("EntityTag");
 743         entity.addInCanonTag(canon);
 744         entity.persist();
 745         const entity2 = new Tag("EntityTag");
 746         entity2.addInCanonTag(canon);
 747         entity2.persist();
 748         const tag = Tag.fromIdentifier(canon.identifier); // reload
 749         assertEquals(
 750           Array.from(tag.hasInCanonTags(), ($) => $.identifier),
 751           [entity.identifier, entity2.identifier],
 752         );
 753       });
 754     });
 755
 756     // `::hiddenLabels` is tested by `::addHiddenLabel`.
 757
 758     // `::identifier` is tested by a `.fromIdentifier`.
 759
 760     // `::inCanonTags` is tested by `::addInCanonTag`.
 761
 762     describe("::involvedInTags", () => {
 763       it("[[Call]] yields the persisted tags which involve this tag", () => {
 764         const involved = new Tag();
 765         involved.persist();
 766         const conceptual = new Tag("ConceptualTag");
 767         conceptual.addInvolvesTag(involved);
 768         conceptual.persist();
 769         const conceptual2 = new Tag("ConceptualTag");
 770         conceptual2.addInvolvesTag(involved);
 771         conceptual2.persist();
 772         const tag = Tag.fromIdentifier(involved.identifier); // reload
 773         assertEquals(
 774           Array.from(tag.involvedInTags(), ($) => $.identifier),
 775           [conceptual.identifier, conceptual2.identifier],
 776         );
 777       });
 778     });
 779
 780     // `::involvesTags` is tested by `::addInvolvesTag`.
 781
 782     // `::iri` is tested by a `.fromIRI`.
 783
 784     // `::iriSpace` is tested by a `.fromIRI`.
 785
 786     // `::kind` is tested by the constructor.
 787
 788     describe("::narrowerTags", () => {
 789       it("[[Call]] yields the persisted tags which are narrower than this tag", () => {
 790         const broader = new Tag();
 791         broader.persist();
 792         const narrower = new Tag();
 793         narrower.addBroaderTag(broader);
 794         narrower.persist();
 795         const narrower2 = new Tag();
 796         narrower2.addBroaderTag(broader);
 797         narrower2.persist();
 798         const tag = Tag.fromIdentifier(broader.identifier); // reload
 799         assertEquals(
 800           Array.from(tag.narrowerTags(), ($) => $.identifier),
 801           [narrower.identifier, narrower2.identifier],
 802         );
 803       });
 804     });
 805
 806     describe("::narrowerTransitiveTags", () => {
 807       it("[[Call]] returns narrower tags transitively", () => {
 808         const broad = new Tag();
 809         broad.persist();
 810         const narrow = new Tag();
 811         narrow.addBroaderTag(broad);
 812         narrow.persist();
 813         const superNarrow = new Tag();
 814         superNarrow.addBroaderTag(narrow);
 815         superNarrow.persist();
 816         const tag = Tag.fromIdentifier(broad.identifier); // reload
 817         assertEquals(
 818           Array.from(
 819             tag.narrowerTransitiveTags(),
 820             ($) => $.identifier,
 821           ),
 822           [narrow.identifier, superNarrow.identifier],
 823         );
 824       });
 825
 826       it("[[Call]] cannot recurse infinitely", () => {
 827         const tag = new Tag();
 828         tag.persist();
 829         const broad = new Tag();
 830         broad.addBroaderTag(tag);
 831         broad.persist();
 832         tag.addBroaderTag(broad);
 833         tag.persist();
 834         assertEquals(
 835           Array.from(tag.broaderTransitiveTags(), ($) => $.identifier),
 836           [broad.identifier, tag.identifier],
 837         );
 838       });
 839     });
 840
 841     describe("::persist", () => {
 842       it("[[Call]] returns an object with expected properties if there were changes", () => {
 843         const tag = new Tag();
 844         const activity = tag.persist();
 845         assertObjectMatch(
 846           activity,
 847           {
 848             "@context":
 849               "https://ns.1024.gdn/Tagging/discovery.context.jsonld",
 850             context: system.iri,
 851             object: tag.iri,
 852           },
 853         );
 854         assertArrayIncludes(activity["@type"], ["TagActivity"]);
 855         assert("endTime" in activity);
 856       });
 857
 858       it("[[Call]] returns a Create activity with a type predicate for new objects", () => {
 859         const activity = new Tag().persist();
 860         assertEquals(activity["@type"], ["TagActivity", "Create"]);
 861         assertArrayIncludes(activity.states, [{
 862           predicate: "a",
 863           object: "Tag",
 864         }]);
 865       });
 866
 867       it("[[Call]] returns an Update activity for old objects", () => {
 868         const tag = new Tag();
 869         tag.persist();
 870         tag.prefLabel = "etaoin";
 871         const activity = tag.persist();
 872         assertEquals(activity["@type"], ["TagActivity", "Update"]);
 873       });
 874
 875       it("[[Call]] states and unstates changes", () => {
 876         const broader1 = new Tag();
 877         broader1.persist();
 878         const broader2 = new Tag();
 879         broader2.persist();
 880         const tag = new Tag();
 881         tag.addBroaderTag(broader1);
 882         tag.persist();
 883         tag.prefLabel = "etaoin";
 884         tag.deleteBroaderTag(broader1);
 885         tag.addBroaderTag(broader2);
 886         const activity = tag.persist();
 887         assertObjectMatch(activity, {
 888           unstates: [
 889             { predicate: "prefLabel", object: { "@value": "" } },
 890             { predicate: "broader", object: broader1.iri },
 891           ],
 892           states: [
 893             { predicate: "prefLabel", object: { "@value": "etaoin" } },
 894             { predicate: "broader", object: broader2.iri },
 895           ],
 896         });
 897       });
 898
 899       it("[[Call]] doesn’t state if there are no additions", () => {
 900         const tag = new Tag();
 901         tag.addAltLabel("etaoin");
 902         tag.persist();
 903         tag.deleteAltLabel("etaoin");
 904         const activity = tag.persist();
 905         assertFalse("state" in activity);
 906       });
 907
 908       it("[[Call]] doesn’t unstate if there are no removals", () => {
 909         const tag = new Tag();
 910         tag.persist();
 911         tag.addAltLabel("etaoin");
 912         const activity = tag.persist();
 913         assertFalse("unstate" in activity);
 914       });
 915
 916       it("[[Call]] returns null if no meaningful changes were made", () => {
 917         const tag = new Tag();
 918         tag.persist();
 919         const activity = tag.persist();
 920         assertStrictEquals(activity, null);
 921       });
 922
 923       it("[[Call]] returns undefined for a silent persist", () => {
 924         const broader = new Tag();
 925         broader.persist();
 926         const tag = new Tag();
 927         tag.prefLabel = "etaoin";
 928         tag.addBroaderTag(broader);
 929         assertStrictEquals(tag.persist(true), undefined);
 930       });
 931     });
 932
 933     describe("::prefLabel", () => {
 934       it("[[Set]] sets the preferred label", () => {
 935         const tag = new Tag();
 936         tag.prefLabel = "one";
 937         assertEquals({ ...tag.prefLabel }, { "@value": "one" });
 938         tag.prefLabel = { "@value": "two" };
 939         assertEquals({ ...tag.prefLabel }, { "@value": "two" });
 940         tag.prefLabel = { "@value": "three", "@language": "en" };
 941         assertEquals(
 942           { ...tag.prefLabel },
 943           { "@value": "three", "@language": "en" },
 944         );
 945       });
 946     });
 947
 948     describe("::system", () => {
 949       it("[[Get]] returns the tag system", () => {
 950         assertStrictEquals(new Tag().system, system);
 951       });
 952     });
 953
 954     // `::tagURI` is tested by a `.fromTagURI`.
 955
 956     describe("::taggingEntity", () => {
 957       it("[[Get]] returns the tagging entity of the tag system", () => {
 958         assertStrictEquals(
 959           new Tag().taggingEntity,
 960           system.taggingEntity,
 961         );
 962       });
 963     });
 964
 965     describe("::toString", () => {
 966       it("[[Get]] returns the string value of the preferred label", () => {
 967         const tag = new Tag();
 968         tag.prefLabel = { "@value": "etaoin", "@language": "zxx" };
 969         assertStrictEquals(tag.toString(), "etaoin");
 970       });
 971     });
 972
 973     // `::[Storage.toObject]` is tested by `::persist`.
 974   });
 975
 976   describe("::authorityName", () => {
 977     it("[[Get]] returns the authority name", () => {
 978       const system = new TagSystem("etaoin.example", "1972-12-31");
 979       assertStrictEquals(system.authorityName, "etaoin.example");
 980     });
 981   });
 982
 983   describe("::authorityName", () => {
 984     it("[[Get]] returns the date", () => {
 985       const system = new TagSystem("etaoin.example", "1972-12-31");
 986       assertStrictEquals(system.date, "1972-12-31");
 987     });
 988   });
 989
 990   describe("::identifiers", () => {
 991     it("[[Get]] yields the extant entities", () => {
 992       const system = new TagSystem("etaoin.example", "1972-12-31");
 993       const tags = new Set(function* () {
 994         let i = 0;
 995         while (i++ < 5) {
 996           // Generate 5 tags and remember their identifiers.
 997           const tag = new system.Tag();
 998           tag.persist();
 999           yield tag.identifier;
1000         }
1001       }());
1002       assertEquals(
1003         new Set(Array.from(system.entities(), ($) => $.identifier)),
1004         tags,
1005       );
1006     });
1007   });
1008
1009   describe("::identifier", () => {
1010     it("[[Get]] returns the identifier", () => {
1011       const system = new TagSystem("etaoin.example", "1972-12-31");
1012       assertStrictEquals(system.identifier, "");
1013       const system2 = new TagSystem(
1014         "etaoin.example",
1015         "1972-12-31",
1016         "etaoin",
1017       );
1018       assertStrictEquals(system2.identifier, "etaoin");
1019     });
1020   });
1021
1022   describe("::identifiers", () => {
1023     it("[[Get]] yields the identifiers in use", () => {
1024       const system = new TagSystem("etaoin.example", "1972-12-31");
1025       const tags = new Set(function* () {
1026         let i = 0;
1027         while (i++ < 5) {
1028           // Generate 5 tags and remember their identifiers.
1029           const tag = new system.Tag();
1030           tag.persist();
1031           yield tag.identifier;
1032         }
1033       }());
1034       assertEquals(new Set(system.identifiers()), tags);
1035     });
1036   });
1037
1038   describe("::iri", () => {
1039     it("[[Get]] returns the I·R·I", () => {
1040       const system = new TagSystem("etaoin.example", "1972-12-31");
1041       assertStrictEquals(
1042         system.iri,
1043         "https://etaoin.example/tag:etaoin.example,1972-12-31:",
1044       );
1045       const system2 = new TagSystem(
1046         "etaoin.example",
1047         "1972-12-31",
1048         "etaoin",
1049       );
1050       assertStrictEquals(
1051         system2.iri,
1052         "https://etaoin.example/tag:etaoin.example,1972-12-31:etaoin",
1053       );
1054     });
1055   });
1056
1057   describe("::iriSpace", () => {
1058     it("[[Get]] returns the I·R·I space", () => {
1059       const system = new TagSystem("etaoin.example", "1972-12-31");
1060       assertStrictEquals(
1061         system.iriSpace,
1062         "https://etaoin.example/tag:etaoin.example,1972-12-31:",
1063       );
1064       const system2 = new TagSystem(
1065         "etaoin.example",
1066         "1972-12-31",
1067         "etaoin",
1068       );
1069       assertStrictEquals(
1070         system2.iriSpace,
1071         "https://etaoin.example/tag:etaoin.example,1972-12-31:",
1072       );
1073     });
1074   });
1075
1076   describe("::tagURI", () => {
1077     it("[[Get]] returns the Tag U·R·I", () => {
1078       const system = new TagSystem("etaoin.example", "1972-12-31");
1079       assertStrictEquals(
1080         system.tagURI,
1081         "tag:etaoin.example,1972-12-31:",
1082       );
1083       const system2 = new TagSystem(
1084         "etaoin.example",
1085         "1972-12-31",
1086         "etaoin",
1087       );
1088       assertStrictEquals(
1089         system2.tagURI,
1090         "tag:etaoin.example,1972-12-31:etaoin",
1091       );
1092     });
1093   });
1094
1095   describe("::taggingEntity", () => {
1096     it("[[Get]] returns the tagging entity", () => {
1097       const system = new TagSystem("etaoin.example", "1972-12-31");
1098       assertStrictEquals(
1099         system.taggingEntity,
1100         "etaoin.example,1972-12-31",
1101       );
1102     });
1103   });
1104 });