solid-logic 3.1.1-dbb83f7 → 3.1.1-e3eba68

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

@@ -0,0 +1,17 @@
+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
+jest.mock('../../src/util/debug')
+
+export function silenceDebugMessages () {
+  (log as any).mockImplementation(() => null)
+  ;(warn as any).mockImplementation(() => null)
+  ;(error as any).mockImplementation(() => null)
+  ;(trace as any).mockImplementation(() => null)
+}

package/test/inboxLogic.test.ts

@@ -0,0 +1,218 @@
+/**
+* @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 alice = sym("https://alice.example.com/profile/card#me");
+const bob = sym("https://bob.example.com/profile/card#me");
+
+describe("Inbox logic", () => {
+  let store;
+  let inboxLogic
+  beforeEach(() => {
+    fetchMock.resetMocks();
+    fetchMock.mockResponse("Not Found", {
+      status: 404,
+    });
+    store = new Store()
+    store.fetcher = new Fetcher(store, { fetch: fetch });
+    store.updater = new UpdateManager(store);
+    const authn = {
+      currentUser: () => {
+        return alice;
+      },
+    };
+    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", () => {
+    describe("When inbox is empty", () => {
+      let result;
+      beforeEach(async () => {
+        bobHasAnInbox();
+        inboxIsEmpty();
+        result = await inboxLogic.getNewMessages(bob);
+      });
+      it("Resolves to an empty array", () => {
+        expect(result).toEqual([]);
+      });
+    });
+    describe("When container has some containment triples", () => {
+      let result;
+      beforeEach(async () => {
+        bobHasAnInbox();
+        inboxHasSomeContainmentTriples();
+        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([
+          'https://container.com/foo.txt'
+        ].sort());
+      });
+    });
+  });
+  describe('createInboxFor', () => {
+    beforeEach(async () => {
+      aliceHasValidProfile();
+      // First for the PUT:
+      fetchMock.mockOnceIf(
+        "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.com/p2p-inboxes/Peer%20Person/",
+        " ", {
+          status: 200,
+          headers: {
+            Link: '<https://some/acl>; rel="acl"',
+          }
+        }
+      )
+      fetchMock.mockIf("https://some/acl", "Created", { status: 201 });
+
+      await inboxLogic.createInboxFor('https://peer.com/#me', 'Peer Person');
+    });
+    it("creates the inbox", () => {
+      expect(fetchMock.mock.calls).toEqual([
+        [ "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",
+            "If-None-Match": "*",
+            Link: "<http://www.w3.org/ns/ldp#BasicContainer>; rel=\"type\"",
+          },
+          method: "PUT"      
+        }],
+        [ "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.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.com/p2p-inboxes/Peer%20Person/>;\n' +
+          '  acl:mode acl:Append.\n',
+          headers: [
+            [ 'Content-Type', 'text/turtle' ]
+          ],
+          method: 'PUT'
+        }]
+      ]);
+    });
+
+  });
+  describe('markAsRead', () => {
+    beforeEach(async () => {
+      fetchMock.mockOnceIf(
+        "https://container.com/item.ttl",
+        "<#some> <#inbox> <#item> .",
+        {
+          headers: { "Content-Type": "text/turtle" },
+        }
+      );
+      fetchMock.mockOnceIf(
+        "https://container.com/archive/2111/03/31/item.ttl",
+        "Created",
+        {
+          status: 201,
+          headers: { "Content-Type": "text/turtle" },
+        }
+      );
+      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([
+        [ "https://container.com/item.ttl" ],
+        [
+          "https://container.com/archive/2111/03/31/item.ttl",
+          {
+            "body": "<#some> <#inbox> <#item> .",
+            "headers": [
+              [
+                "Content-Type",
+                "text/turtle",
+              ],
+            ],
+            "method": "PUT",
+          },
+        ],
+        [ "https://container.com/item.ttl", { method: 'DELETE' } ],
+      ]);
+    });
+  });
+
+  function aliceHasValidProfile() {
+    fetchMock.mockOnceIf(
+      "https://alice.example.com/profile/card",
+      `
+            <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: {
+          "Content-Type": "text/turtle",
+        },
+      }
+    );
+  }
+
+  function bobHasAnInbox() {
+    fetchMock.mockOnceIf(
+      "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" },
+      }
+    );
+  }
+
+  function inboxIsEmpty() {
+    fetchMock.mockOnceIf(
+      "https://container.com/",
+      " ", // FIXME: https://github.com/jefflau/jest-fetch-mock/issues/189
+      {
+        headers: { "Content-Type": "text/turtle" },
+      }
+    );
+  }
+
+  function inboxHasSomeContainmentTriples() {
+    fetchMock.mockOnceIf(
+      "https://container.com/",
+      "<.> <http://www.w3.org/ns/ldp#contains> <./foo.txt>, <./bar/> .",
+      {
+        headers: { "Content-Type": "text/turtle" },
+      }
+    );
+  }
+
+  function inboxItemExists() {
+    fetchMock.mockOnceIf(
+      "https://container.com/item.ttl",
+      "<#some> <#inbox> <#item> .",
+      {
+        headers: { "Content-Type": "text/turtle" },
+      }
+    );
+  }
+});

package/test/logic.test.ts

@@ -0,0 +1,29 @@
+import { solidLogicSingleton } from "../src/logic/solidLogicSingleton"
+import { silenceDebugMessages } from "./helpers/setup"
+
+silenceDebugMessages()
+
+describe('store', () => {
+  it('exists', () => {
+    expect(solidLogicSingleton.store).toBeInstanceOf(Object)
+  })
+})
+
+describe('store.fetcher', () => {
+  it('exists', () => {
+    expect(solidLogicSingleton.store.fetcher).toBeInstanceOf(Object)
+  })
+})
+
+describe('store.updater', () => {
+  it('exists', () => {
+    expect(solidLogicSingleton.store.updater).toBeInstanceOf(Object)
+  })
+})
+
+describe('authn', () => {
+  it('exists', () => {
+    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('')
+
+        })
+    })
+})