solid-logic 1.3.17-6a574cd0 → 1.3.17-6e0634d8

package/test/helpers/dataSetup.ts

@@ -0,0 +1,134 @@
+import { sym } from 'rdflib'
+import * as rdf from "rdflib";
+import solidNamespace from "solid-namespace";
+import { SolidNamespace } from '../../src/types';
+const ns: SolidNamespace = solidNamespace(rdf);
+
+//------ Club -------------------------------------------------------
+const club = sym('https://club.example.com/profile/card.ttl#it')
+const ClubPreferencesFile = sym('https://club.example.com/settings/prefs.ttl')
+const ClubPublicTypeIndex = sym('https://club.example.com/profile/public-type-index.ttl')
+const ClubPrivateTypeIndex = sym('https://club.example.com/settings/private-type-index.ttl')
+
+const ClubProfile = `
+
+<#it> a vcard:Organization;
+    space:preferencesFile ${ClubPreferencesFile};
+    solid:publicTypeIndex ${ClubPublicTypeIndex};
+    vcard:fn "Card Club" .
+`
+const ClubPreferences =  `
+    ${club} solid:privateTypeIndex ${ClubPrivateTypeIndex} .
+`
+const ClubPublicTypes = `
+
+:chat1 solid:forClass meeting:LongChat; solid:instance <../publicStuff/ourChat.ttl#this> .
+
+:todo solid:forClass wf:Tracker; solid:instance  <../publicStuff/actionItems.ttl#this>.
+
+:issues solid:forClass wf:Tracker; solid:instance  <../project4/clubIssues.ttl#this>.
+`;
+
+const ClubPrivateTypes = `
+:id1592319218311 solid:forClass wf:Tracker; solid:instance  <../privateStuff/ToDo.ttl#this>.
+
+:id1592319391415 solid:forClass wf:Tracker; solid:instance <../privateStuff/Goals.ttl#this>.
+
+:id1595595377864 solid:forClass wf:Tracker; solid:instance <../privateStuff/tasks.ttl#this>.
+
+:id1596123375929 solid:forClass meeting:Meeting; solid:instance  <../project4/clubMeeting.ttl#this>.
+
+`;
+
+//------ Alice -------------------------------------------------------
+const alice = sym("https://alice.example.com/profile/card.ttl#me")
+const AliceProfileFile = alice.doc()
+const AlicePreferencesFile = sym('https://alice.example.com/settings/prefs.ttl')
+const AlicePublicTypeIndex = sym('https://alice.example.com/profile/public-type-index.ttl')
+const AlicePrivateTypeIndex = sym('https://alice.example.com/settings/private-type-index.ttl')
+const AlicePhotoFolder = sym(alice.dir().uri + "Photos/")
+const AliceProfile = `
+<#me> a vcard:Individual;
+    space:preferencesFile ${AlicePreferencesFile};
+    solid:publicTypeIndex ${AlicePublicTypeIndex};
+    vcard:fn "Alice" .
+`
+const AlicePreferences =  `
+    ${alice} solid:privateTypeIndex ${AlicePrivateTypeIndex};
+    solid:community ${club} .
+`
+const AlicePublicTypes = `
+
+:chat1 solid:forClass meeting:LongChat; solid:instance <../publicStuff/myChat.ttl#this> .
+
+:todo solid:forClass wf:Tracker; solid:instance  <../publicStuff/actionItems.ttl#this>.
+
+:issues solid:forClass wf:Tracker; solid:instance  <../project4/issues.ttl#this>.
+
+:photos solid:forClass schema:Image; solid:instanceContainer  ${AlicePhotoFolder} .
+`;
+
+const AlicePrivateTypes = `
+:id1592319218311 solid:forClass wf:Tracker; solid:instance  <../privateStuff/ToDo.ttl#this>.
+
+:id1592319391415 solid:forClass wf:Tracker; solid:instance <../privateStuff/Goals.ttl#this>.
+
+:id1595595377864 solid:forClass wf:Tracker; solid:instance <../privateStuff/workingOn.ttl#this>.
+
+:id1596123375929 solid:forClass meeting:Meeting; solid:instance  <../project4/meeting1.ttl#this>.
+
+`;
+
+const AlicePhotos = `
+<>
+    a ldp:BasicContainer, ldp:Container;
+    dct:modified "2021-04-26T05:34:16Z"^^xsd:dateTime;
+    ldp:contains
+        <photo1.png>, <photo2.png>, <photo3.png> ;
+    stat:mtime 1619415256.541;
+    stat:size 4096 .
+`
+
+//------ Bob -------------------------------------------------------
+const bob = sym('https://bob.example.com/profile/card.ttl#me')
+
+const BobProfile = `
+<#me> a vcard:Individual;
+vcard:fn "Bob" .
+`
+
+//------ Boby -------------------------------------------------------
+const boby = sym('https://boby.example.com/profile/card.ttl#me')
+
+const BobyProfile = `
+<#me> a vcard:Individual;
+vcard:fn "Boby" .
+`
+export function loadWebObject() {
+    const web = {}
+    web[alice.doc().uri] = AliceProfile
+    web[AlicePreferencesFile.uri] = AlicePreferences
+    web[AlicePrivateTypeIndex.uri] = AlicePrivateTypes
+    web[AlicePublicTypeIndex.uri] = AlicePublicTypes
+    web[AlicePhotoFolder.uri] = AlicePhotos
+    web[bob.doc().uri] = BobProfile
+    web[boby.doc().uri] = BobyProfile
+
+    web[club.doc().uri] = ClubProfile
+    web[ClubPreferencesFile.uri] = ClubPreferences
+    web[ClubPrivateTypeIndex.uri] = ClubPrivateTypes
+    web[ClubPublicTypeIndex.uri] = ClubPublicTypes
+    return web
+}
+
+function clearLocalStore(store) {
+    store.statements.slice().forEach(store.remove.bind(store))
+}
+
+export {
+    alice, bob, boby, club,
+    AlicePhotoFolder, AlicePreferences, AlicePhotos, AlicePreferencesFile, AlicePrivateTypeIndex, AlicePrivateTypes, AliceProfile, AliceProfileFile, AlicePublicTypeIndex, AlicePublicTypes,
+    BobProfile,
+    ClubPreferences, ClubPreferencesFile, ClubPrivateTypeIndex, ClubPrivateTypes, ClubProfile, ClubPublicTypeIndex, ClubPublicTypes,
+    clearLocalStore
+}

package/test/helpers/setup.ts

@@ -1,5 +1,9 @@
 import { error, log, trace, warn } from '../../src/util/debug'
 import fetchMock from "jest-fetch-mock";
+import { TextEncoder, TextDecoder } from 'util'
+global.TextEncoder = TextEncoder
+global.TextDecoder = TextDecoder
+
 
 fetchMock.enableMocks();
 // We don't want to output debug messages to console as part of the tests

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,8 @@ describe("Inbox logic", () => {
       beforeEach(async () => {
         bobHasAnInbox();
         inboxHasSomeContainmentTriples();
-        result = await inbox.getNewMessages(bob);
+        const messages = await inboxLogic.getNewMessages(bob);
+        result = messages.map(oneMessage => oneMessage.value)
       });
       it("Resolves to an array with URLs of non-container resources in inbox", () => {
         expect(result.sort()).toEqual([
@@ -65,14 +67,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 +84,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 +98,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 +137,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 +162,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 +178,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('')
+
+        })
+    })
+})