solid-logic 1.3.17-9d25ceb7 → 1.3.17-a849582e

package/src/util/containerLogic.ts

@@ -0,0 +1,54 @@
+import { NamedNode, Statement, sym } from "rdflib";
+
+/**
+ * Container-related class
+ */
+export function createContainerLogic(store) {
+
+    function getContainerElements(containerNode: NamedNode): NamedNode[] {
+            return store
+                .statementsMatching(
+                    containerNode,
+                    sym("http://www.w3.org/ns/ldp#contains"),
+                    undefined,
+                    containerNode.doc()
+                )
+                .map((st: Statement) => st.object as NamedNode);
+    }
+
+    function isContainer(url: string) {
+            return url.charAt(url.length - 1) === "/";
+    }
+
+    async function createContainer(url: string) {
+            if (!isContainer(url)) {
+                throw new Error(`Not a container URL ${url}`);
+            }
+            // Copied from https://github.com/solidos/solid-crud-tests/blob/v3.1.0/test/surface/create-container.test.ts#L56-L64
+            const result = await store.fetcher._fetch(url, {
+                method: "PUT",
+                headers: {
+                    "Content-Type": "text/turtle",
+                    "If-None-Match": "*",
+                    Link: '<http://www.w3.org/ns/ldp#BasicContainer>; rel="type"', // See https://github.com/solidos/node-solid-server/issues/1465
+                },
+                body: " ", // work around https://github.com/michielbdejong/community-server/issues/4#issuecomment-776222863
+            });
+            if (result.status.toString()[0] !== '2') {
+                throw new Error(`Not OK: got ${result.status} response while creating container at ${url}`);
+            }
+    }
+
+    async function getContainerMembers(containerUrl: string): Promise<string[]> {
+            const containerNode = store.sym(containerUrl);
+            await store.fetcher.load(containerNode);
+            const nodes = getContainerElements(containerNode);
+            return nodes.map(node => node.value);
+    }
+    return {
+        isContainer,
+        createContainer,
+        getContainerElements,
+        getContainerMembers
+    }
+}

package/src/util/ns.js

@@ -0,0 +1,5 @@
+// Namespaces we commonly use and have common prefixes for around Solid
+import solidNamespace from 'solid-namespace' // Delegate to this which takes RDFlib as param.
+import * as $rdf from 'rdflib'
+
+export const ns = solidNamespace($rdf)

package/src/util/utilityLogic.ts

@@ -0,0 +1,155 @@
+import { NamedNode, st } from "rdflib";
+import { CrossOriginForbiddenError, FetchError, NotEditableError, SameOriginForbiddenError, UnauthorizedError, WebOperationError } from "../logic/CustomError";
+import * as debug from '../util/debug';
+import { differentOrigin } from "./utils";
+
+export function createUtilityLogic(store, aclLogic, containerLogic) {
+
+  async function recursiveDelete(url: string) {
+      try {
+        if (containerLogic.isContainer(url)) {
+          const aclDocUrl = await aclLogic.findAclDocUrl(url);
+          await store.fetcher._fetch(aclDocUrl, { method: "DELETE" });
+          const containerMembers = await containerLogic.getContainerMembers(url);
+          await Promise.all(
+            containerMembers.map((url) => recursiveDelete(url))
+          );
+        }
+        return store.fetcher._fetch(url, { method: "DELETE" });
+      } catch (e) {
+        // debug.log(`Please manually remove ${url} from your system under test.`, e);
+      }
+  }
+
+  /**
+   * Create a resource if it really does not exist
+   * Be absolutely sure something does not exist before creating a new empty file
+   * as otherwise existing could  be deleted.
+   * @param doc {NamedNode} - The resource
+   */
+  async function loadOrCreateIfNotExists(doc: NamedNode) {
+    let response
+    try {
+      response = await store.fetcher.load(doc)
+    } catch (err) {
+      if (err.response.status === 404) {
+        try {
+          await store.fetcher.webOperation('PUT', doc, { data: '', contentType: 'text/turtle' })
+        } catch (err) {
+          const msg = 'createIfNotExists: PUT FAILED: ' + doc + ': ' + err
+          throw new WebOperationError(msg)
+        }
+        await store.fetcher.load(doc)
+      } else {
+        if (err.response.status === 401) {
+          throw new UnauthorizedError();
+        }
+        if (err.response.status === 403) {
+          if (differentOrigin(doc)) {
+            throw new CrossOriginForbiddenError();
+          }
+          throw new SameOriginForbiddenError();
+        }
+        const msg = 'createIfNotExists doc load error NOT 404:  ' + doc + ': ' + err
+        throw new FetchError(err.status, err.message + msg)
+      }
+    }
+    return response
+  }
+
+  /* Follow link from this doc to another thing, or else make a new link
+  **
+  ** @returns existing object, or creates it if non existent
+  */
+  async function followOrCreateLink(subject: NamedNode, predicate: NamedNode,
+    object: NamedNode, doc: NamedNode
+  ): Promise<NamedNode | null> {
+    await store.fetcher.load(doc)
+    const result = store.any(subject, predicate, null, doc)
+
+    if (result) return result as NamedNode
+    if (!store.updater.editable(doc)) {
+      const msg = `followOrCreateLink: cannot edit ${doc.value}`
+      debug.warn(msg)
+      throw new NotEditableError(msg)
+    }
+    try {
+      await store.updater.update([], [st(subject, predicate, object, doc)])
+    } catch (err) {
+      const msg = `followOrCreateLink: Error making link in ${doc} to ${object}: ${err}`
+      debug.warn(msg)
+      throw new WebOperationError(err)
+    }
+
+    try {
+      await loadOrCreateIfNotExists(object)
+      // store.fetcher.webOperation('PUT', object, { data: '', contentType: 'text/turtle'})
+    } catch (err) {
+      debug.warn(`followOrCreateLink: Error loading or saving new linked document: ${object}: ${err}`)
+      throw err;
+    }
+    return object
+  }
+
+  // Copied from https://github.com/solidos/web-access-control-tests/blob/v3.0.0/test/surface/delete.test.ts#L5
+  async function setSinglePeerAccess(options: {
+    ownerWebId: string,
+    peerWebId: string,
+    accessToModes?: string,
+    defaultModes?: string,
+    target: string
+  }) {
+    let str = [
+      '@prefix acl: <http://www.w3.org/ns/auth/acl#>.',
+      '',
+      `<#alice> a acl:Authorization;\n  acl:agent <${options.ownerWebId}>;`,
+      `  acl:accessTo <${options.target}>;`,
+      `  acl:default <${options.target}>;`,
+      '  acl:mode acl:Read, acl:Write, acl:Control.',
+      ''
+    ].join('\n')
+    if (options.accessToModes) {
+      str += [
+        '<#bobAccessTo> a acl:Authorization;',
+        `  acl:agent <${options.peerWebId}>;`,
+        `  acl:accessTo <${options.target}>;`,
+        `  acl:mode ${options.accessToModes}.`,
+        ''
+      ].join('\n')
+    }
+    if (options.defaultModes) {
+      str += [
+        '<#bobDefault> a acl:Authorization;',
+        `  acl:agent <${options.peerWebId}>;`,
+        `  acl:default <${options.target}>;`,
+        `  acl:mode ${options.defaultModes}.`,
+        ''
+      ].join('\n')
+    }
+    const aclDocUrl = await aclLogic.findAclDocUrl(options.target);
+    return store.fetcher._fetch(aclDocUrl, {
+      method: 'PUT',
+      body: str,
+      headers: [
+        ['Content-Type', 'text/turtle']
+      ]
+    });
+  }
+
+  async function createEmptyRdfDoc(doc: NamedNode, comment: string) {
+    await store.fetcher.webOperation("PUT", doc.uri, {
+      data: `# ${new Date()} ${comment}
+  `,
+      contentType: "text/turtle",
+    });
+  }
+  
+  return {
+    recursiveDelete,
+    setSinglePeerAccess,
+    createEmptyRdfDoc,
+    followOrCreateLink,
+    loadOrCreateIfNotExists
+  }
+}
+

package/src/util/utils.ts

@@ -0,0 +1,52 @@
+import { NamedNode, sym } from "rdflib";
+
+export function newThing(doc: NamedNode): NamedNode {
+    return sym(doc.uri + "#" + "id" + ("" + Date.now()));
+}
+
+export function uniqueNodes (arr: NamedNode[]): NamedNode[] {
+    const uris = arr.map(x => x.uri)
+    const set = new Set(uris)
+    const uris2 = Array.from(set)
+    const arr2 = uris2.map(u => new NamedNode(u))
+    return arr2 // Array.from(new Set(arr.map(x => x.uri))).map(u => sym(u))
+}
+
+export function getArchiveUrl(baseUrl: string, date: Date) {
+    const year = date.getUTCFullYear();
+    const month = ('0' + (date.getUTCMonth()+1)).slice(-2);
+    const day = ('0' + (date.getUTCDate())).slice(-2);
+    const parts = baseUrl.split('/');
+    const filename = parts[parts.length -1 ];
+    return new URL(`./archive/${year}/${month}/${day}/${filename}`, baseUrl).toString();
+}
+
+export function differentOrigin(doc): boolean {
+    if (!doc) {
+        return true;
+    }
+    return (
+        `${window.location.origin}/` !== new URL(doc.value).origin
+    );
+}
+
+export function suggestPreferencesFile (me:NamedNode) {
+    const stripped = me.uri.replace('/profile/', '/').replace('/public/', '/')
+    // const stripped = me.uri.replace(\/[p|P]rofile/\g, '/').replace(\/[p|P]ublic/\g, '/')
+    const folderURI = stripped.split('/').slice(0,-1).join('/') + '/Settings/'
+    const fileURI = folderURI + 'Preferences.ttl'
+    return sym(fileURI)
+}
+
+export function determineChatContainer(
+    invitee: NamedNode,
+    podRoot: NamedNode
+): NamedNode {
+    // Create chat
+    // See https://gitter.im/solid/chat-app?at=5f3c800f855be416a23ae74a
+    const chatContainerStr = new URL(
+        `IndividualChats/${new URL(invitee.value).host}/`,
+        podRoot.value
+    ).toString();
+    return new NamedNode(chatContainerStr);
+}

package/test/aclLogic.test.ts

@@ -1,12 +1,21 @@
-import { sym } from 'rdflib'
-import { setACLUserPublic } from '../src/acl/aclLogic' 
+import { Fetcher, Store, sym, UpdateManager } from 'rdflib';
+import { createAclLogic } from '../src/acl/aclLogic';
 
 describe('setACLUserPublic', () => {
+    let aclLogic
+    let store
+    beforeAll(() => {
+        const options = { fetch: fetch };
+        store = new Store()
+        store.fetcher = new Fetcher(store, options);
+        store.updater = new UpdateManager(store);
+        aclLogic = createAclLogic(store)
+    })
     it('exists', () => {
-        expect(setACLUserPublic).toBeInstanceOf(Function)
+        expect(aclLogic.setACLUserPublic).toBeInstanceOf(Function)
     })
     it.skip('runs', async () => {
-        expect(await setACLUserPublic(
+        expect(await aclLogic.setACLUserPublic(
         'https://test.test#',
         sym('https://test.test#'),
         {}

package/test/chatLogic.test.ts

@@ -1,34 +1,35 @@
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
-import { ChatLogic } from "../src/chat/ChatLogic";
-import solidNamespace from "solid-namespace";
-import * as rdf from "rdflib";
-import { ProfileLogic } from "../src/profile/ProfileLogic";
-import { UpdateManager } from "rdflib";
-import { SolidNamespace } from "../src/types";
+/**
+* @jest-environment jsdom
+*
+*/
+import { UpdateManager, Store, Fetcher } from "rdflib";
+import { createAclLogic } from "../src/acl/aclLogic";
+import { createChatLogic } from '../src/chat/chatLogic';
+import { createProfileLogic } from "../src/profile/profileLogic";
+import { createContainerLogic } from "../src/util/containerLogic";
+import { createUtilityLogic } from "../src/util/utilityLogic";
+import { alice, bob } from "./helpers/dataSetup";
 
-const ns: SolidNamespace = solidNamespace(rdf);
-
-const alice = rdf.sym("https://alice.example/profile/card#me");
-const bob = rdf.sym("https://bob.example/profile/card#me");
+window.$SolidTestEnvironment = { username: alice.uri }
 
 describe("Chat logic", () => {
-  let chat;
+  let chatLogic;
   let store;
   beforeEach(() => {
     fetchMock.resetMocks();
     fetchMock.mockResponse("Not Found", {
       status: 404,
     });
-    store = rdf.graph();
-    store.fetcher = rdf.fetcher(store, { fetch: fetchMock, timeout: 5 });
+    store = new Store()
+    store.fetcher = new Fetcher(store, { fetch: fetch });
     store.updater = new UpdateManager(store);
     const authn = {
       currentUser: () => {
         return alice;
       },
     };
-    const profile = new ProfileLogic(store, ns, authn);
-    chat = new ChatLogic(store, ns, profile);
+    const util = createUtilityLogic(store, createAclLogic(store), createContainerLogic(store))
+    chatLogic = createChatLogic(store, createProfileLogic(store, authn, util))
   });
 
   describe("get chat, without creating", () => {
@@ -37,19 +38,19 @@ describe("Chat logic", () => {
       beforeEach(async () => {
         aliceHasValidProfile();
         noChatWithBobExists();
-        result = await chat.getChat(bob, false);
+        result = await chatLogic.getChat(bob, false);
       });
       it("does not return a chat", async () => {
         expect(result).toBeNull();
       });
       it("loaded the current user profile", () => {
         expect(fetchMock.mock.calls[0][0]).toBe(
-          "https://alice.example/profile/card"
+          "https://alice.example.com/profile/card.ttl"
         );
       });
       it("tried to load the chat document", () => {
         expect(fetchMock.mock.calls[1][0]).toBe(
-          "https://alice.example/IndividualChats/bob.example/index.ttl"
+          "https://alice.example.com/IndividualChats/bob.example.com/index.ttl"
         );
       });
       it("has no additional fetch requests", () => {
@@ -74,23 +75,23 @@ describe("Chat logic", () => {
         chatContainerAclCanBeSet();
         editablePrivateTypeIndexIsFound();
         privateTypeIndexIsUpdated();
-        result = await chat.getChat(bob, true);
+        result = await chatLogic.getChat(bob, true);
       });
-      it("returns the chat URI based on the invitee's WebID", async () => {
+      it("returns the chat URI based on the invitee's WebID", () => {
         expect(result.uri).toBe(
-          "https://alice.example/IndividualChats/bob.example/index.ttl#this"
+          "https://alice.example.com/IndividualChats/bob.example.com/index.ttl#this"
         );
       });
       it("created a chat document", () => {
         const request = getRequestTo(
           "PUT",
-          "https://alice.example/IndividualChats/bob.example/index.ttl"
+          "https://alice.example.com/IndividualChats/bob.example.com/index.ttl"
         );
         expect(request.body).toBe(`@prefix : <#>.
 @prefix dc: <http://purl.org/dc/elements/1.1/>.
 @prefix meeting: <http://www.w3.org/ns/pim/meeting#>.
 @prefix xsd: <http://www.w3.org/2001/XMLSchema#>.
-@prefix c: </profile/card#>.
+@prefix c: </profile/card.ttl#>.
 
 :this
     a meeting:LongChat;
@@ -102,41 +103,42 @@ describe("Chat logic", () => {
       it("allowed Bob to participate in the chat by adding an ACL", () => {
         const request = getRequestTo(
           "PUT",
-          "https://alice.example/IndividualChats/bob.example/.acl"
+          "https://alice.example.com/IndividualChats/bob.example.com/.acl"
         );
         expect(request.body).toBe(`
-@prefix acl: <http://www.w3.org/ns/auth/acl#>.
-<#owner>
-    a acl:Authorization;
-    acl:agent <https://alice.example/profile/card#me>;
-    acl:accessTo <.>;
-    acl:default <.>;
-    acl:mode
-        acl:Read, acl:Write, acl:Control.
-<#invitee>
-    a acl:Authorization;
-    acl:agent <https://bob.example/profile/card#me>;
-    acl:accessTo <.>;
-    acl:default <.>;
-    acl:mode
-        acl:Read, acl:Append.
-`);
+            @prefix acl: <http://www.w3.org/ns/auth/acl#>.
+            <#owner>
+            a acl:Authorization;
+            acl:agent <https://alice.example.com/profile/card.ttl#me>;
+            acl:accessTo <.>;
+            acl:default <.>;
+            acl:mode
+                acl:Read, acl:Write, acl:Control.
+            <#invitee>
+            a acl:Authorization;
+            acl:agent <https://bob.example.com/profile/card.ttl#me>;
+            acl:accessTo <.>;
+            acl:default <.>;
+            acl:mode
+                acl:Read, acl:Append.
+            `);
       });
       it("sent an invitation to invitee inbox", () => {
-        const request = getRequestTo("POST", "https://bob.example/inbox");
+        const request = getRequestTo("POST", "https://bob.example.com/inbox");
         expect(request.body).toContain(`
-<> a <http://www.w3.org/ns/pim/meeting#LongChatInvite> ;
-<http://www.w3.org/1999/02/22-rdf-syntax-ns#seeAlso> <https://alice.example/IndividualChats/bob.example/index.ttl#this> .
-  `);});
+        <> a <http://www.w3.org/ns/pim/meeting#LongChatInvite> ;
+        <http://www.w3.org/1999/02/22-rdf-syntax-ns#seeAlso> <https://alice.example.com/IndividualChats/bob.example.com/index.ttl#this> .
+        `);
+      });
       it("added the new chat to private type index", () => {
         const request = getRequestTo(
           "PATCH",
-          "https://alice.example/settings/privateTypeIndex.ttl"
+          "https://alice.example.com/settings/privateTypeIndex.ttl"
         );
         expect(request.body)
-          .toBe(`INSERT DATA { <https://alice.example/settings/privateTypeIndex.ttl#id1612606272000> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://www.w3.org/ns/solid/terms#TypeRegistration> .
-<https://alice.example/settings/privateTypeIndex.ttl#id1612606272000> <http://www.w3.org/ns/solid/terms#forClass> <http://www.w3.org/ns/pim/meeting#LongChat> .
-<https://alice.example/settings/privateTypeIndex.ttl#id1612606272000> <http://www.w3.org/ns/solid/terms#instance> <https://alice.example/IndividualChats/bob.example/index.ttl#this> .
+          .toBe(`INSERT DATA { <https://alice.example.com/settings/privateTypeIndex.ttl#id1612606272000> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://www.w3.org/ns/solid/terms#TypeRegistration> .
+<https://alice.example.com/settings/privateTypeIndex.ttl#id1612606272000> <http://www.w3.org/ns/solid/terms#forClass> <http://www.w3.org/ns/pim/meeting#LongChat> .
+<https://alice.example.com/settings/privateTypeIndex.ttl#id1612606272000> <http://www.w3.org/ns/solid/terms#instance> <https://alice.example.com/IndividualChats/bob.example.com/index.ttl#this> .
  }
 `);
       });
@@ -148,13 +150,13 @@ describe("Chat logic", () => {
 
   describe("possible errors", () => {
     it("profile does not link to storage", async () => {
-      fetchMock.mockOnceIf("https://alice.example/profile/card", "<><><>.", {
+      fetchMock.mockOnceIf("https://alice.example.com/profile/card.ttl", "<><><>.", {
         headers: {
           "Content-Type": "text/turtle",
         },
       });
       const expectedError = new Error("User pod root not found!");
-      await expect(chat.getChat(bob, false)).rejects.toEqual(expectedError);
+      await expect(chatLogic.getChat(bob, false)).rejects.toEqual(expectedError);
     });
 
     it("invitee inbox not found", async () => {
@@ -163,19 +165,19 @@ describe("Chat logic", () => {
       chatWithBobCanBeCreated();
       bobDoesNotHaveAnInbox();
       const expectedError = new Error(
-        "Invitee inbox not found! https://bob.example/profile/card#me"
+        "Invitee inbox not found! https://bob.example.com/profile/card.ttl#me"
       );
-      await expect(chat.getChat(bob, true)).rejects.toEqual(expectedError);
+      await expect(chatLogic.getChat(bob, true)).rejects.toEqual(expectedError);
     });
   });
 
   function aliceHasValidProfile() {
     fetchMock.mockOnceIf(
-      "https://alice.example/profile/card",
+      "https://alice.example.com/profile/card.ttl",
       `
-            <https://alice.example/profile/card#me>
-              <http://www.w3.org/ns/pim/space#storage> <https://alice.example/> ;
-              <http://www.w3.org/ns/solid/terms#privateTypeIndex> <https://alice.example/settings/privateTypeIndex.ttl> ;
+            <https://alice.example.com/profile/card.ttl#me>
+              <http://www.w3.org/ns/pim/space#storage> <https://alice.example.com/> ;
+              <http://www.w3.org/ns/solid/terms#privateTypeIndex> <https://alice.example.com/settings/privateTypeIndex.ttl> ;
             .`,
       {
         headers: {
@@ -188,7 +190,7 @@ describe("Chat logic", () => {
   function noChatWithBobExists() {
     return fetchMock.mockOnceIf(
       ({ url, method }) =>
-        url === "https://alice.example/IndividualChats/bob.example/index.ttl" &&
+        url === "https://alice.example.com/IndividualChats/bob.example.com/index.ttl" &&
         method === "GET",
       "Not found",
       {
@@ -200,7 +202,7 @@ describe("Chat logic", () => {
   function chatWithBobCanBeCreated() {
     return fetchMock.mockOnceIf(
       ({ url, method }) =>
-        url === "https://alice.example/IndividualChats/bob.example/index.ttl" &&
+        url === "https://alice.example.com/IndividualChats/bob.example.com/index.ttl" &&
         method === "PUT",
       "Created",
       {
@@ -211,8 +213,8 @@ describe("Chat logic", () => {
 
   function bobHasAnInbox() {
     fetchMock.mockOnceIf(
-      "https://bob.example/profile/card",
-      "<https://bob.example/profile/card#me><http://www.w3.org/ns/ldp#inbox><https://bob.example/inbox>.",
+      "https://bob.example.com/profile/card.ttl",
+      "<https://bob.example.com/profile/card.ttl#me><http://www.w3.org/ns/ldp#inbox><https://bob.example.com/inbox>.",
       {
         headers: { "Content-Type": "text/turtle" },
       }
@@ -220,7 +222,7 @@ describe("Chat logic", () => {
   }
 
   function bobDoesNotHaveAnInbox() {
-    fetchMock.mockOnceIf("https://bob.example/profile/card", "<><><>.", {
+    fetchMock.mockOnceIf("https://bob.example.com/profile/card.ttl", "<><><>.", {
       headers: {
         "Content-Type": "text/turtle",
       },
@@ -230,13 +232,13 @@ describe("Chat logic", () => {
   function invitationCanBeSent() {
     return fetchMock.mockOnceIf(
       ({ url, method }) =>
-        url === "https://bob.example/inbox" && method === "POST",
+        url === "https://bob.example.com/inbox" && method === "POST",
       "Created",
       {
         status: 201,
         headers: {
           location:
-            "https://bob.example/inbox/22373339-6cc0-49fc-b69e-0402edda6e4e.ttl",
+            "https://bob.example.com/inbox/22373339-6cc0-49fc-b69e-0402edda6e4e.ttl",
         },
       }
     );
@@ -245,7 +247,7 @@ describe("Chat logic", () => {
   function chatContainerIsFound() {
     return fetchMock.mockOnceIf(
       ({ url, method }) =>
-        url === "https://alice.example/IndividualChats/bob.example/" &&
+        url === "https://alice.example.com/IndividualChats/bob.example.com/" &&
         method === "GET",
       "<><><>.",
       {
@@ -261,7 +263,7 @@ describe("Chat logic", () => {
   function chatContainerAclCanBeSet() {
     return fetchMock.mockOnceIf(
       ({ url, method }) =>
-        url === "https://alice.example/IndividualChats/bob.example/.acl" &&
+        url === "https://alice.example.com/IndividualChats/bob.example.com/.acl" &&
         method === "PUT",
       "Created",
       {
@@ -273,7 +275,7 @@ describe("Chat logic", () => {
   function editablePrivateTypeIndexIsFound() {
     return fetchMock.mockOnceIf(
       ({ url, method }) =>
-        url === "https://alice.example/settings/privateTypeIndex.ttl" &&
+        url === "https://alice.example.com/settings/privateTypeIndex.ttl" &&
         method === "GET",
       "<><><>.",
       {
@@ -290,7 +292,7 @@ describe("Chat logic", () => {
   function privateTypeIndexIsUpdated() {
     return fetchMock.mockOnceIf(
       ({ url, method }) =>
-        url === "https://alice.example/settings/privateTypeIndex.ttl" &&
+        url === "https://alice.example.com/settings/privateTypeIndex.ttl" &&
         method === "PATCH",
       "OK",
       {
@@ -299,9 +301,6 @@ describe("Chat logic", () => {
     );
   }
 
-  /*
-    
-     */
   function getRequestTo(
     method: "GET" | "PUT" | "POST" | "DELETE" | "PATCH",
     url: string

package/test/container.test.ts

@@ -0,0 +1,56 @@
+/**
+* @jest-environment jsdom
+* 
+*/
+import { UpdateManager, Store, Fetcher } from "rdflib";
+import { createContainerLogic } from "../src/util/containerLogic";
+import { alice } from "./helpers/dataSetup";
+
+window.$SolidTestEnvironment = { username: alice.uri }
+
+describe("Container", () => {
+    let store
+    let containerLogic
+    beforeEach(() => {
+        fetchMock.resetMocks()
+        store = new Store()
+        store.fetcher = new Fetcher(store, { fetch: fetch });
+        store.updater = new UpdateManager(store);
+        containerLogic = createContainerLogic(store)
+    })
+
+    it("getContainerMembers - When container has some containment triples", async () => {
+            containerHasSomeContainmentTriples()
+            const result = await containerLogic.getContainerMembers('https://com/');
+            expect(result.sort()).toEqual([
+                'https://com/foo.txt',
+                'https://com/bar/'
+            ].sort());
+    });
+    it("getContainerMembers- When container is empty - Resolves to an empty array", async () => {
+        containerIsEmpty();
+        const result = await containerLogic.getContainerMembers('https://container.com/');
+        expect(result).toEqual([]);
+    });
+
+    function containerIsEmpty() {
+        fetchMock.mockOnceIf(
+            "https://com/",
+            " ", // FIXME: https://github.com/jefflau/jest-fetch-mock/issues/189
+            {
+                headers: { "Content-Type": "text/turtle" },
+            }
+        );
+    }
+    
+    function containerHasSomeContainmentTriples() {
+        fetchMock.mockOnceIf(
+            "https://com/",
+            "<.> <http://www.w3.org/ns/ldp#contains> <./foo.txt>, <./bar/> .",
+            {
+                headers: { "Content-Type": "text/turtle" },
+            }
+        );
+        
+    }
+})