solid-logic 1.3.17-9d25ceb7 → 1.3.17-a4538ffc

package/test/inboxLogic.test.ts

@@ -1,37 +1,38 @@
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
-import solidNamespace from "solid-namespace";
-import * as rdf from "rdflib";
-import { UpdateManager } from "rdflib";
-import { ProfileLogic } from "../src/profile/ProfileLogic";
-import { UtilityLogic } from "../src/util/UtilityLogic";
-import { InboxLogic } from "../src/inbox/InboxLogic";
-import { SolidNamespace } from "../src/types";
+/**
+* @jest-environment jsdom
+*
+*/
+import { UpdateManager, Store, Fetcher, sym } from "rdflib";
+import { createAclLogic } from "../src/acl/aclLogic";
+import { createInboxLogic } from '../src/inbox/inboxLogic';
+import { createProfileLogic } from "../src/profile/profileLogic";
+import { createContainerLogic } from "../src/util/containerLogic";
+import { createUtilityLogic } from "../src/util/utilityLogic";
 
-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");
+const alice = sym("https://alice.example.com/profile/card#me");
+const bob = sym("https://bob.example.com/profile/card#me");
 
 describe("Inbox logic", () => {
-  let inbox;
   let store;
+  let inboxLogic
   beforeEach(() => {
     fetchMock.resetMocks();
     fetchMock.mockResponse("Not Found", {
       status: 404,
     });
-    const fetcher = { fetch: fetchMock };
-    store = rdf.graph();
-    store.fetcher = rdf.fetcher(store, fetcher);
+    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);
-    const util = new UtilityLogic(store, ns, fetcher);
-    inbox = new InboxLogic(store, ns, profile, util);
+    const containerLogic = createContainerLogic(store)
+    const aclLogic = createAclLogic(store)
+    const util = createUtilityLogic(store, aclLogic, containerLogic);
+    const profile = createProfileLogic(store, authn, util);
+    inboxLogic = createInboxLogic(store, profile, util, containerLogic, aclLogic);
   });
 
   describe("getNewMessages", () => {
@@ -40,7 +41,7 @@ describe("Inbox logic", () => {
       beforeEach(async () => {
         bobHasAnInbox();
         inboxIsEmpty();
-        result = await inbox.getNewMessages(bob);
+        result = await inboxLogic.getNewMessages(bob);
       });
       it("Resolves to an empty array", () => {
         expect(result).toEqual([]);
@@ -51,7 +52,7 @@ describe("Inbox logic", () => {
       beforeEach(async () => {
         bobHasAnInbox();
         inboxHasSomeContainmentTriples();
-        result = await inbox.getNewMessages(bob);
+        result = await inboxLogic.getNewMessages(bob);
       });
       it("Resolves to an array with URLs of non-container resources in inbox", () => {
         expect(result.sort()).toEqual([
@@ -65,14 +66,14 @@ describe("Inbox logic", () => {
       aliceHasValidProfile();
       // First for the PUT:
       fetchMock.mockOnceIf(
-        "https://alice.example/p2p-inboxes/Peer%20Person/",
+        "https://alice.example.com/p2p-inboxes/Peer%20Person/",
         "Created", {
           status: 201
         }
       )
       // Then for the GET to read the ACL link:
       fetchMock.mockOnceIf(
-        "https://alice.example/p2p-inboxes/Peer%20Person/",
+        "https://alice.example.com/p2p-inboxes/Peer%20Person/",
         " ", {
           status: 200,
           headers: {
@@ -82,12 +83,12 @@ describe("Inbox logic", () => {
       )
       fetchMock.mockIf("https://some/acl", "Created", { status: 201 });
 
-      await inbox.createInboxFor('https://peer.com/#me', 'Peer Person');
+      await inboxLogic.createInboxFor('https://peer.com/#me', 'Peer Person');
     });
     it("creates the inbox", () => {
       expect(fetchMock.mock.calls).toEqual([
-        [ "https://alice.example/profile/card", fetchMock.mock.calls[0][1] ],
-        [ "https://alice.example/p2p-inboxes/Peer%20Person/", {
+        [ "https://alice.example.com/profile/card", fetchMock.mock.calls[0][1] ],
+        [ "https://alice.example.com/p2p-inboxes/Peer%20Person/", {
           body: " ",
           headers: {
             "Content-Type": "text/turtle",
@@ -96,18 +97,18 @@ describe("Inbox logic", () => {
           },
           method: "PUT"      
         }],
-        [ "https://alice.example/p2p-inboxes/Peer%20Person/", fetchMock.mock.calls[2][1] ],
+        [ "https://alice.example.com/p2p-inboxes/Peer%20Person/", fetchMock.mock.calls[2][1] ],
         [ "https://some/acl", {
           body: '@prefix acl: <http://www.w3.org/ns/auth/acl#>.\n' +
           '\n' +
           '<#alice> a acl:Authorization;\n' +
-          '  acl:agent <https://alice.example/profile/card#me>;\n' +
-          '  acl:accessTo <https://alice.example/p2p-inboxes/Peer%20Person/>;\n' +
-          '  acl:default <https://alice.example/p2p-inboxes/Peer%20Person/>;\n' +
+          '  acl:agent <https://alice.example.com/profile/card#me>;\n' +
+          '  acl:accessTo <https://alice.example.com/p2p-inboxes/Peer%20Person/>;\n' +
+          '  acl:default <https://alice.example.com/p2p-inboxes/Peer%20Person/>;\n' +
           '  acl:mode acl:Read, acl:Write, acl:Control.\n' +
           '<#bobAccessTo> a acl:Authorization;\n' +
           '  acl:agent <https://peer.com/#me>;\n' +
-          '  acl:accessTo <https://alice.example/p2p-inboxes/Peer%20Person/>;\n' +
+          '  acl:accessTo <https://alice.example.com/p2p-inboxes/Peer%20Person/>;\n' +
           '  acl:mode acl:Append.\n',
           headers: [
             [ 'Content-Type', 'text/turtle' ]
@@ -135,7 +136,7 @@ describe("Inbox logic", () => {
           headers: { "Content-Type": "text/turtle" },
         }
       );
-      await inbox.markAsRead("https://container.com/item.ttl", new Date('31 March 2111 UTC'));
+      await inboxLogic.markAsRead("https://container.com/item.ttl", new Date('31 March 2111 UTC'));
     });
     it('moves the item to archive', async () => {
       expect(fetchMock.mock.calls).toEqual([
@@ -160,11 +161,11 @@ describe("Inbox logic", () => {
 
   function aliceHasValidProfile() {
     fetchMock.mockOnceIf(
-      "https://alice.example/profile/card",
+      "https://alice.example.com/profile/card",
       `
-            <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#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: {
@@ -176,8 +177,8 @@ describe("Inbox logic", () => {
 
   function bobHasAnInbox() {
     fetchMock.mockOnceIf(
-      "https://bob.example/profile/card",
-      "<https://bob.example/profile/card#me><http://www.w3.org/ns/ldp#inbox><https://container.com/>.",
+      "https://bob.example.com/profile/card",
+      "<https://bob.example.com/profile/card#me><http://www.w3.org/ns/ldp#inbox><https://container.com/>.",
       {
         headers: { "Content-Type": "text/turtle" },
       }

package/test/logic.test.ts

@@ -1,28 +1,29 @@
-import { solidLogicSingleton } from "../src/index"
+import { solidLogicSingleton } from "../src/logic/solidLogicSingleton"
 import { silenceDebugMessages } from "./helpers/setup"
 
 silenceDebugMessages()
 
-describe('solidLogicSingleton (main global SolidLogic instance)', () => {
+describe('store', () => {
   it('exists', () => {
-    expect(solidLogicSingleton).toBeInstanceOf(Object)
+    expect(solidLogicSingleton.store).toBeInstanceOf(Object)
   })
 })
 
-describe('solidLogicSingleton.store', () => {
+describe('store.fetcher', () => {
   it('exists', () => {
-    expect(solidLogicSingleton.store).toBeInstanceOf(Object)
+    expect(solidLogicSingleton.store.fetcher).toBeInstanceOf(Object)
   })
 })
 
-describe('solidLogicSingleton.store.fetcher', () => {
+describe('store.updater', () => {
   it('exists', () => {
-    expect(solidLogicSingleton.store.fetcher).toBeInstanceOf(Object)
+    expect(solidLogicSingleton.store.updater).toBeInstanceOf(Object)
   })
 })
 
-describe('solidLogicSingleton.store.updater', () => {
+describe('authn', () => {
   it('exists', () => {
-    expect(solidLogicSingleton.store.updater).toBeInstanceOf(Object)
+    expect(solidLogicSingleton.authn).toBeInstanceOf(Object)
   })
 })
+

package/test/profileLogic.test.ts

@@ -0,0 +1,246 @@
+/**
+* @jest-environment jsdom
+* 
+*/
+import { UpdateManager, Store, Fetcher } from 'rdflib';
+import { createProfileLogic } from "../src/profile/profileLogic";
+import { createUtilityLogic } from "../src/util/utilityLogic"
+import { ns } from "../src/util/ns";
+import {
+    alice, AlicePreferencesFile, AlicePrivateTypeIndex, AliceProfileFile, bob, boby, loadWebObject
+} from './helpers/dataSetup';
+import { createAclLogic } from "../src/acl/aclLogic";
+import { createContainerLogic } from "../src/util/containerLogic";
+
+const prefixes = Object.keys(ns).map(prefix => `@prefix ${prefix}: ${ns[prefix]('')}.\n`).join('') // In turtle
+const user = alice
+const profile = user.doc()
+let requests = []
+let profileLogic
+
+describe("Profile", () => {
+
+    describe('loadProfile', () => {
+        window.$SolidTestEnvironment = { username: alice.uri }
+        let store
+        requests = []
+        const statustoBeReturned = 200
+        let web = {}
+        const authn = {
+            currentUser: () => {
+                return alice;
+            },
+        };
+        beforeEach(() => {
+            fetchMock.resetMocks();
+            web = loadWebObject()
+            requests = []
+            fetchMock.mockIf(/^https?.*$/, async req => {
+
+                if (req.method !== 'GET') {
+                    requests.push(req)
+                    if (req.method === 'PUT') {
+                    const contents = await req.text()
+                    web[req.url] = contents // Update our dummy web
+                    console.log(`Tetst: Updated ${req.url} on PUT to <<<${web[req.url]}>>>`)
+                    }
+                    return { status: statustoBeReturned }
+                }
+                const contents = web[req.url]
+                if (contents !== undefined) { //
+                    return {
+                    body: prefixes + contents, // Add namespaces to anything
+                    status: 200,
+                    headers: {
+                        "Content-Type": "text/turtle",
+                        "WAC-Allow":    'user="write", public="read"',
+                        "Accept-Patch": "application/sparql-update"
+                    }
+                    }
+                } // if contents
+                return {
+                    status: 404,
+                    body: 'Not Found'
+                    }
+            })
+
+            store = new Store()
+            store.fetcher = new Fetcher(store, { fetch: fetch });
+            store.updater = new UpdateManager(store);
+            const util = createUtilityLogic(store, createAclLogic(store), createContainerLogic(store))
+            profileLogic = createProfileLogic(store, authn, util)
+        })
+        it('exists', () => {
+            expect(profileLogic.loadProfile).toBeInstanceOf(Function)
+        })
+        it('loads data', async () => {
+            const result = await profileLogic.loadProfile(user)
+            expect(result).toBeInstanceOf(Object)
+            expect(result.uri).toEqual(AliceProfileFile.uri)
+            expect(store.holds(user, ns.rdf('type'), ns.vcard('Individual'), profile)).toEqual(true)
+            expect(store.holds(user, ns.space('preferencesFile'), AlicePreferencesFile, profile)).toEqual(true)
+            expect(store.statementsMatching(null, null, null, profile).length).toEqual(4)
+        })
+    })
+    
+    describe('silencedLoadPreferences', () => {
+        window.$SolidTestEnvironment = { username: alice.uri }
+        let store
+        requests = []
+        const statustoBeReturned = 200
+        let web = {}
+        const authn = {
+            currentUser: () => {
+                return alice;
+            },
+        };
+        beforeEach(() => {
+            fetchMock.resetMocks();
+            web = loadWebObject()
+            requests = []
+            fetchMock.mockIf(/^https?.*$/, async req => {
+
+                if (req.method !== 'GET') {
+                    requests.push(req)
+                    if (req.method === 'PUT') {
+                    const contents = await req.text()
+                    web[req.url] = contents // Update our dummy web
+                    console.log(`Tetst: Updated ${req.url} on PUT to <<<${web[req.url]}>>>`)
+                    }
+                    return { status: statustoBeReturned }
+                }
+                const contents = web[req.url]
+                if (contents !== undefined) { //
+                    return {
+                    body: prefixes + contents, // Add namespaces to anything
+                    status: 200,
+                    headers: {
+                        "Content-Type": "text/turtle",
+                        "WAC-Allow":    'user="write", public="read"',
+                        "Accept-Patch": "application/sparql-update"
+                    }
+                    }
+                } // if contents
+                return {
+                    status: 404,
+                    body: 'Not Found'
+                    }
+            })
+
+            store = new Store()
+            store.fetcher = new Fetcher(store, { fetch: fetch });
+            store.updater = new UpdateManager(store);
+                const util = createUtilityLogic(store, createAclLogic(store), createContainerLogic(store))
+            profileLogic = createProfileLogic(store, authn, util)
+        })
+        it('exists', () => {
+            expect(profileLogic.silencedLoadPreferences).toBeInstanceOf(Function)
+        })
+        it('loads data', async () => {
+            const result = await profileLogic.silencedLoadPreferences(alice)
+            expect(result).toBeInstanceOf(Object)
+            expect(result.uri).toEqual(AlicePreferencesFile.uri)
+            expect(store.holds(user, ns.rdf('type'), ns.vcard('Individual'), profile)).toEqual(true)
+            expect(store.statementsMatching(null, null, null, profile).length).toEqual(4)
+
+            expect(store.statementsMatching(null, null, null, AlicePreferencesFile).length).toEqual(2)
+            expect(store.holds(user, ns.solid('privateTypeIndex'), AlicePrivateTypeIndex, AlicePreferencesFile)).toEqual(true)
+        })
+        it('creates new file', async () => {
+            const result = await profileLogic.silencedLoadPreferences(bob)
+
+            const patchRequest = requests[0]
+            expect(patchRequest.method).toEqual('PATCH')
+            expect(patchRequest.url).toEqual(bob.doc().uri)
+            const text = await patchRequest.text()
+            expect(text).toContain('INSERT DATA { <https://bob.example.com/profile/card.ttl#me> <http://www.w3.org/ns/pim/space#preferencesFile> <https://bob.example.com/Settings/Preferences.ttl> .')
+
+            const putRequest = requests[1]
+            expect(putRequest.method).toEqual('PUT')
+            expect(putRequest.url).toEqual('https://bob.example.com/Settings/Preferences.ttl')
+            expect(web[putRequest.url]).toEqual('')
+
+        })
+    })
+
+
+    describe('loadPreferences', () => {
+        window.$SolidTestEnvironment = { username: boby.uri }
+        let store
+        requests = []
+        const statustoBeReturned = 200
+        let web = {}
+        const authn = {
+            currentUser: () => {
+                return boby;
+            },
+        };
+        beforeEach(() => {
+            fetchMock.resetMocks();
+            web = loadWebObject()
+            requests = []
+            fetchMock.mockIf(/^https?.*$/, async req => {
+
+                if (req.method !== 'GET') {
+                    requests.push(req)
+                    if (req.method === 'PUT') {
+                    const contents = await req.text()
+                    web[req.url] = contents // Update our dummy web
+                    console.log(`Tetst: Updated ${req.url} on PUT to <<<${web[req.url]}>>>`)
+                    }
+                    return { status: statustoBeReturned }
+                }
+                const contents = web[req.url]
+                if (contents !== undefined) { //
+                    return {
+                    body: prefixes + contents, // Add namespaces to anything
+                    status: 200,
+                    headers: {
+                        "Content-Type": "text/turtle",
+                        "WAC-Allow":    'user="write", public="read"',
+                        "Accept-Patch": "application/sparql-update"
+                    }
+                    }
+                } // if contents
+                return {
+                    status: 404,
+                    body: 'Not Found'
+                    }
+            })
+
+            store = new Store()
+            store.fetcher = new Fetcher(store, { fetch: fetch });
+            store.updater = new UpdateManager(store);
+            const util = createUtilityLogic(store, createAclLogic(store), createContainerLogic(store))
+            profileLogic = createProfileLogic(store, authn, util)
+        })
+        it('exists', () => {
+            expect(profileLogic.loadPreferences).toBeInstanceOf(Function)
+        })
+        it('loads data', async () => {
+            const result = await profileLogic.loadPreferences(alice)
+            expect(result).toBeInstanceOf(Object)
+            expect(result.uri).toEqual(AlicePreferencesFile.uri)
+            expect(store.holds(user, ns.rdf('type'), ns.vcard('Individual'), profile)).toEqual(true)
+            expect(store.statementsMatching(null, null, null, profile).length).toEqual(4)
+
+            expect(store.statementsMatching(null, null, null, AlicePreferencesFile).length).toEqual(2)
+            expect(store.holds(user, ns.solid('privateTypeIndex'), AlicePrivateTypeIndex, AlicePreferencesFile)).toEqual(true)
+        })
+        it('creates new file', async () => {
+            const result = await profileLogic.loadPreferences(boby)
+
+            const patchRequest = requests[0]
+            expect(patchRequest.method).toEqual('PATCH')
+            expect(patchRequest.url).toEqual(boby.doc().uri)
+            const text = await patchRequest.text()
+            expect(text).toContain('INSERT DATA { <https://boby.example.com/profile/card.ttl#me> <http://www.w3.org/ns/pim/space#preferencesFile> <https://boby.example.com/Settings/Preferences.ttl> .')
+
+            const putRequest = requests[1]
+            expect(putRequest.method).toEqual('PUT')
+            expect(putRequest.url).toEqual('https://boby.example.com/Settings/Preferences.ttl')
+            expect(web[putRequest.url]).toEqual('')
+
+        })
+    })
+})