solid-logic 1.3.17-2bf19bb6 → 1.3.17-64c8b7a5

package/test/discoveryLogic.test.ts

@@ -0,0 +1,712 @@
+/**
+* @jest-environment jsdom
+*
+*/
+import fetchMock from 'jest-fetch-mock'
+import { Fetcher, Store, sym, UpdateManager } from 'rdflib'
+import * as $rdf from 'rdflib'
+import {
+  followOrCreateLink, getAppInstances, getScopedAppInstances, loadCommunityTypeIndexes, loadOrCreateIfNotExists,
+  loadPreferences, loadProfile, loadTypeIndexesFor, registerInstanceInTypeIndex, uniqueNodes
+} from '../src/discovery/discoveryLogic'
+import solidNamespace from 'solid-namespace'
+
+/* Discovery Logic tests */
+
+const ns = solidNamespace($rdf)
+
+const prefixes = Object.keys(ns).map(prefix => `@prefix ${prefix}: ${ns[prefix]('')}.\n`).join('') // In turtle
+
+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/profle/public-type-index.ttl')
+const AlicePrivateTypeIndex = sym('https://alice.example.com/settings/private-type-index.ttl')
+const AlicePhotoFolder = sym(Alice.dir().uri + "Photos/")
+
+// the Club is a community which Alice is involved and so she gets to
+// interact with things in its type indexes.
+
+const Club = sym('https://club.example.com/profile/card.ttl#it')
+const ClubProfileFile = Club.doc()
+const ClubPreferencesFile = sym('https://club.example.com/settings/prefs.ttl')
+const ClubPublicTypeIndex = sym('https://club.example.com/profle/public-type-index.ttl')
+const ClubPrivateTypeIndex = sym('https://club.example.com/settings/private-type-index.ttl')
+
+const Bob = sym('https://bob.example.com/profile/card.ttl#me')
+
+window.$SolidTestEnvironment = { username: Alice.uri }
+
+const user = Alice
+const profile = user.doc()
+
+// const klass = sym('http://www.w3.org/2006/vcard/ns#AddressBook')
+const klass = ns.wf('Tracker')
+const Tracker = ns.wf('Tracker')
+const Image = ns.schema('Image')
+
+//////////////////////////////////////////////////////////// User Alice
+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} .
+# :bookmarks
+#    a solid:TypeRegistration;
+#    solid:forClass bookm:Bookmark;
+#    solid:instance </public/poddit.ttl>.
+`;
+
+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 .
+`
+
+//////////////////////////////////////////////////////////// User Bob
+const BobProfile = `
+<#me> a vcard:Individual;
+
+  vcard:fn "Bob" .
+`
+
+//////////////////////////////////////////////////////////// User Club
+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>.
+
+# :bookmarks
+#    a solid:TypeRegistration;
+#    solid:forClass bookm:Bookmark;
+#    solid:instance </public/poddit.ttl>.
+`;
+
+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>.
+
+`;
+
+////////////////////////////////////////////////////////////////////////////
+
+const web = {}
+web[profile.uri] = AliceProfile
+web[AlicePreferencesFile.uri] = AlicePreferences
+web[AlicePrivateTypeIndex.uri] = AlicePrivateTypes
+web[AlicePublicTypeIndex.uri] = AlicePublicTypes
+web[AlicePhotoFolder.uri] = AlicePhotos
+web[Bob.doc().uri] = BobProfile
+
+web[Club.doc().uri] = ClubProfile
+web[ClubPreferencesFile.uri] = ClubPreferences
+web[ClubPrivateTypeIndex.uri] = ClubPrivateTypes
+web[ClubPublicTypeIndex.uri] = ClubPublicTypes
+
+let requests = []
+let statustoBeReturned  = 200
+
+describe("Discovery Logic", () => {
+  let store;
+  let options;
+  beforeEach(() => {
+    fetchMock.resetMocks();
+    requests = []
+    statustoBeReturned = 200
+    const init = {headers: { "Content-Type": "text/turtle" }} // Fetch options tend to be called this
+
+    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'
+        }
+    })
+
+
+    options = { fetch: fetch };
+    store = new Store()
+    store.fetcher = new Fetcher (store, options);
+    store.updater = new UpdateManager(store);
+  });
+
+describe('uniqueNodes', () => {
+  it('exists', () => {
+    expect(uniqueNodes).toBeInstanceOf(Function)
+  })
+  it('removed duplicates', async () => {
+    const input = [ sym('https://a.com/'), sym('https://b.com/'),sym('https://a.com/'), sym('https://a.com/'),  sym('https://c.com/'),  ]
+    const expected = [ sym('https://a.com/'), sym('https://b.com/'), sym('https://c.com/'),  ]
+    const result =  uniqueNodes(input)
+    expect(result).toEqual(expected)
+
+  })
+  it('handles an empty array', async () => {
+    const result = await uniqueNodes([])
+    expect(result).toEqual([])
+  })
+})
+  
+describe('loadOrCreateIfNotExists', () => {
+  it('exists', () => {
+    expect(loadOrCreateIfNotExists).toBeInstanceOf(Function)
+  })
+  it('does nothing if existing file', async () => {
+    const result = await loadOrCreateIfNotExists(store, Alice.doc())
+    expect(requests).toEqual([])
+
+  })
+  it('creates empty file if did not exist', async () => {
+    const newFile = sym(Bob.doc().uri + '/refhoijhoegg/')
+    const result = await loadOrCreateIfNotExists(store, newFile)
+    expect(requests[0].method).toEqual('PUT')
+    expect(requests[0].url).toEqual(newFile.uri)
+  })
+})
+
+describe('followOrCreateLink', () => {
+  it('exists', () => {
+    expect(followOrCreateLink).toBeInstanceOf(Function)
+  })
+  it('follows existing link', async () => {
+    const suggestion = 'https://alice.example.com/settings/prefsSuggestion.ttl'
+    const result = await followOrCreateLink(store, Alice, ns.space('preferencesFile'), sym(suggestion), Alice.doc())
+    expect(result).toEqual(AlicePreferencesFile)
+
+    })
+  it('creates empty file if did not exist and new link', async () => {
+    const suggestion = 'https://bob.example.com/settings/prefsSuggestion.ttl'
+    const result = await followOrCreateLink(store, Bob, ns.space('preferencesFile'), sym(suggestion), Bob.doc())
+    expect(result).toEqual(sym(suggestion))
+    expect(requests[0].method).toEqual('PATCH') // or patch first?
+    expect(requests[0].url).toEqual(Bob.doc().uri)
+    expect(requests[1].method).toEqual('PUT') // or patch first?
+    expect(requests[1].url).toEqual(suggestion)
+    expect(store.holds(Bob, ns.space('preferencesFile'), sym(suggestion), Bob.doc())).toEqual(true)
+  })
+  //
+  it('returns null if it cannot create the new file', async () => {
+    const suggestion = 'https://bob.example.com/settings/prefsSuggestion.ttl'
+    statustoBeReturned = 403 // Unauthorized
+    const result = await followOrCreateLink(store, Bob, ns.space('preferencesFile'), sym(suggestion), Bob.doc())
+    expect(result).toEqual(null)
+  })
+
+})
+
+describe('loadProfile', () => {
+  it('exists', () => {
+    expect(loadProfile).toBeInstanceOf(Function)
+  })
+  it('loads data', async () => {
+    const result = await loadProfile(store, 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('loadPreferences', () => {
+  it('exists', () => {
+    expect(loadPreferences).toBeInstanceOf(Function)
+  })
+  it('loads data', async () => {
+    const result = await loadPreferences(store, 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 loadPreferences(store, 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('')
+
+  })
+
+})
+
+const AliceScopes = [ {
+    "agent":  {
+      "classOrder": 5,
+      "termType": "NamedNode",
+      "value": "https://alice.example.com/profile/card.ttl#me",
+    },
+    "index": {
+      "classOrder": 5,
+      "termType": "NamedNode",
+      "value": "https://alice.example.com/profle/public-type-index.ttl",
+    },
+    "label": "public",
+  },
+  {
+    "agent": {
+      "classOrder": 5,
+      "termType": "NamedNode",
+      "value": "https://alice.example.com/profile/card.ttl#me",
+    },
+    "index": {
+      "classOrder": 5,
+      "termType": "NamedNode",
+      "value": "https://alice.example.com/settings/private-type-index.ttl",
+    },
+    "label": "private",
+  }
+];
+
+describe('loadTypeIndexesFor', () => {
+  it('exists', () => {
+    expect(loadTypeIndexesFor).toBeInstanceOf(Function)
+  })
+  it('loads data', async () => {
+    const result = await loadTypeIndexesFor(store, user)
+    expect(result).toEqual(AliceScopes)
+    expect(store.statementsMatching(null, null, null, AlicePrivateTypeIndex).length).toEqual(8)
+    expect(store.statementsMatching(null, null, null, AlicePublicTypeIndex).length).toEqual(8)
+  })
+})
+
+const ClubScopes =
+  [
+    {
+      "agent":  {
+        "classOrder": 5,
+        "termType": "NamedNode",
+        "value": "https://club.example.com/profile/card.ttl#it",
+      },
+      "index":  {
+        "classOrder": 5,
+        "termType": "NamedNode",
+        "value": "https://club.example.com/profle/public-type-index.ttl",
+      },
+      "label": "public",
+    },
+    {
+      "agent": {
+        "classOrder": 5,
+        "termType": "NamedNode",
+        "value": "https://club.example.com/profile/card.ttl#it",
+      },
+      "index": {
+        "classOrder": 5,
+        "termType": "NamedNode",
+        "value": "https://club.example.com/settings/private-type-index.ttl",
+      },
+      "label": "private",
+    }
+    ]
+    describe('loadCommunityTypeIndexes', () => {
+        it('exists', () => {
+            expect(loadCommunityTypeIndexes).toBeInstanceOf(Function)
+        })
+        it('loads data', async () => {
+            const result = await loadCommunityTypeIndexes(store, user)
+            expect(result).toEqual(ClubScopes)
+        })
+    })
+
+const AliceAndClubScopes =
+[
+  {
+    "instance":  {
+      "classOrder": 5,
+      "termType": "NamedNode",
+      "value": "https://alice.example.com/publicStuff/actionItems.ttl#this",
+    },
+    "scope":  {
+      "agent":  {
+        "classOrder": 5,
+        "termType": "NamedNode",
+        "value": "https://alice.example.com/profile/card.ttl#me",
+      },
+      "index":  {
+        "classOrder": 5,
+        "termType": "NamedNode",
+        "value": "https://alice.example.com/profle/public-type-index.ttl",
+      },
+      "label": "public",
+    },
+  },
+  {
+    "instance":  {
+      "classOrder": 5,
+      "termType": "NamedNode",
+      "value": "https://alice.example.com/project4/issues.ttl#this",
+    },
+    "scope": {
+      "agent":  {
+        "classOrder": 5,
+        "termType": "NamedNode",
+        "value": "https://alice.example.com/profile/card.ttl#me",
+      },
+      "index": {
+        "classOrder": 5,
+        "termType": "NamedNode",
+        "value": "https://alice.example.com/profle/public-type-index.ttl",
+      },
+      "label": "public",
+    },
+  },
+  {
+    "instance":  {
+      "classOrder": 5,
+      "termType": "NamedNode",
+      "value": "https://alice.example.com/privateStuff/ToDo.ttl#this",
+    },
+    "scope":  {
+      "agent": {
+        "classOrder": 5,
+        "termType": "NamedNode",
+        "value": "https://alice.example.com/profile/card.ttl#me",
+      },
+      "index":  {
+        "classOrder": 5,
+        "termType": "NamedNode",
+        "value": "https://alice.example.com/settings/private-type-index.ttl",
+      },
+      "label": "private",
+    },
+  },
+  {
+    "instance":  {
+      "classOrder": 5,
+      "termType": "NamedNode",
+      "value": "https://alice.example.com/privateStuff/Goals.ttl#this",
+    },
+    "scope": {
+      "agent":  {
+        "classOrder": 5,
+        "termType": "NamedNode",
+        "value": "https://alice.example.com/profile/card.ttl#me",
+      },
+      "index":  {
+        "classOrder": 5,
+        "termType": "NamedNode",
+        "value": "https://alice.example.com/settings/private-type-index.ttl",
+      },
+      "label": "private",
+    },
+  },
+  {
+    "instance":  {
+      "classOrder": 5,
+      "termType": "NamedNode",
+      "value": "https://alice.example.com/privateStuff/workingOn.ttl#this",
+    },
+    "scope":  {
+      "agent":  {
+        "classOrder": 5,
+        "termType": "NamedNode",
+        "value": "https://alice.example.com/profile/card.ttl#me",
+      },
+      "index":  {
+        "classOrder": 5,
+        "termType": "NamedNode",
+        "value": "https://alice.example.com/settings/private-type-index.ttl",
+      },
+      "label": "private",
+    },
+  },
+  {
+    "instance":  {
+      "classOrder": 5,
+      "termType": "NamedNode",
+      "value": "https://club.example.com/publicStuff/actionItems.ttl#this",
+    },
+    "scope": {
+      "agent":  {
+        "classOrder": 5,
+        "termType": "NamedNode",
+        "value": "https://club.example.com/profile/card.ttl#it",
+      },
+      "index":  {
+        "classOrder": 5,
+        "termType": "NamedNode",
+        "value": "https://club.example.com/profle/public-type-index.ttl",
+      },
+      "label": "public",
+    },
+  },
+  {
+    "instance":  {
+      "classOrder": 5,
+      "termType": "NamedNode",
+      "value": "https://club.example.com/project4/clubIssues.ttl#this",
+    },
+    "scope":  {
+      "agent": {
+        "classOrder": 5,
+        "termType": "NamedNode",
+        "value": "https://club.example.com/profile/card.ttl#it",
+      },
+      "index":  {
+        "classOrder": 5,
+        "termType": "NamedNode",
+        "value": "https://club.example.com/profle/public-type-index.ttl",
+      },
+      "label": "public",
+    },
+  },
+  {
+    "instance": {
+      "classOrder": 5,
+      "termType": "NamedNode",
+      "value": "https://club.example.com/privateStuff/ToDo.ttl#this",
+    },
+    "scope":  {
+      "agent":  {
+        "classOrder": 5,
+        "termType": "NamedNode",
+        "value": "https://club.example.com/profile/card.ttl#it",
+      },
+      "index":  {
+        "classOrder": 5,
+        "termType": "NamedNode",
+        "value": "https://club.example.com/settings/private-type-index.ttl",
+      },
+      "label": "private",
+    },
+  },
+  {
+    "instance":  {
+      "classOrder": 5,
+      "termType": "NamedNode",
+      "value": "https://club.example.com/privateStuff/Goals.ttl#this",
+    },
+    "scope":  {
+      "agent":  {
+        "classOrder": 5,
+        "termType": "NamedNode",
+        "value": "https://club.example.com/profile/card.ttl#it",
+      },
+      "index":  {
+        "classOrder": 5,
+        "termType": "NamedNode",
+        "value": "https://club.example.com/settings/private-type-index.ttl",
+      },
+      "label": "private",
+    },
+  },
+  {
+    "instance":  {
+      "classOrder": 5,
+      "termType": "NamedNode",
+      "value": "https://club.example.com/privateStuff/tasks.ttl#this",
+    },
+    "scope":  {
+      "agent":  {
+        "classOrder": 5,
+        "termType": "NamedNode",
+        "value": "https://club.example.com/profile/card.ttl#it",
+      },
+      "index":  {
+        "classOrder": 5,
+        "termType": "NamedNode",
+        "value": "https://club.example.com/settings/private-type-index.ttl",
+      },
+      "label": "private",
+    },
+  },
+]
+
+describe('getScopedAppInstances', () => {
+  it('exists', () => {
+    expect(getScopedAppInstances).toBeInstanceOf(Function)
+  })
+  it('pulls in users scopes and also community ones', async () => {
+    const result = await getScopedAppInstances(store, Tracker, user)
+    expect(result).toEqual(AliceAndClubScopes)
+  })
+  it('creates new typeIndeex files where they dont exist', async () => {
+    const result = await getScopedAppInstances(store, Tracker, Bob)
+
+    expect(requests[0].method).toEqual('PATCH') // Add link to preferrencesFile
+    expect(requests[0].url).toEqual('https://bob.example.com/profile/card.ttl')
+
+    expect(requests[1].method).toEqual('PUT') // Link to pub typ ind
+    expect(requests[1].url).toEqual('https://bob.example.com/profile/publicTypeIndex.ttl')
+
+    expect(requests[2].method).toEqual('PATCH') // Add link to preferrencesFile
+    expect(requests[2].url).toEqual('https://bob.example.com/profile/card.ttl')
+
+    expect(requests[3].method).toEqual('PATCH')
+    expect(requests[3].url).toEqual('https://bob.example.com/Settings/Preferences.ttl')
+
+    expect(requests[4].method).toEqual('PUT')
+    expect(requests[4].url).toEqual('https://bob.example.com/Settings/privateTypeIndex.ttl')
+
+    expect(requests.length).toEqual(5)
+
+  })
+})
+
+const TRACKERS =
+[
+  {
+    "classOrder": 5,
+    "termType": "NamedNode",
+    "value": "https://alice.example.com/publicStuff/actionItems.ttl#this",
+  },
+  {
+    "classOrder": 5,
+    "termType": "NamedNode",
+    "value": "https://alice.example.com/project4/issues.ttl#this",
+  },
+  {
+    "classOrder": 5,
+    "termType": "NamedNode",
+    "value": "https://alice.example.com/privateStuff/ToDo.ttl#this",
+  },
+  {
+    "classOrder": 5,
+    "termType": "NamedNode",
+    "value": "https://alice.example.com/privateStuff/Goals.ttl#this",
+  },
+  {
+    "classOrder": 5,
+    "termType": "NamedNode",
+    "value": "https://alice.example.com/privateStuff/workingOn.ttl#this",
+  },
+  {
+    "classOrder": 5,
+    "termType": "NamedNode",
+    "value": "https://club.example.com/publicStuff/actionItems.ttl#this",
+  },
+  {
+    "classOrder": 5,
+    "termType": "NamedNode",
+    "value": "https://club.example.com/project4/clubIssues.ttl#this",
+  },
+  {
+    "classOrder": 5,
+    "termType": "NamedNode",
+    "value": "https://club.example.com/privateStuff/ToDo.ttl#this",
+  },
+  {
+    "classOrder": 5,
+    "termType": "NamedNode",
+    "value": "https://club.example.com/privateStuff/Goals.ttl#this",
+  },
+  {
+    "classOrder": 5,
+    "termType": "NamedNode",
+    "value": "https://club.example.com/privateStuff/tasks.ttl#this",
+  },
+]
+
+describe('getAppInstances', () =>  {
+  it('exists', () => {
+    expect(getAppInstances).toBeInstanceOf(Function)
+  })
+  it('finds trackers', async () => {
+    const result = await getAppInstances(store, Tracker)
+    expect(result).toEqual(TRACKERS)
+    expect(result).toEqual(uniqueNodes(result)) // shoud have no dups
+  })
+  it('finds images in containers', async () => {
+    const result = await getAppInstances(store, Image)
+    expect(result.length).toEqual(3)
+    expect(result).toEqual(uniqueNodes(result)) // shoud have no dups
+    expect(result.map(x => x.uri).join()).toEqual("https://alice.example.com/profile/Photos/photo1.png,https://alice.example.com/profile/Photos/photo2.png,https://alice.example.com/profile/Photos/photo3.png")
+  })
+})
+
+describe('registerInstanceInTypeIndex', () =>  {
+  it('exists', () => {
+    expect(registerInstanceInTypeIndex).toBeInstanceOf(Function)
+  })
+  it('adds a registration', async () => {
+    const instance = sym(Alice.doc().uri + 'trackers/myToDo.ttl#this')
+    const index = AlicePublicTypeIndex
+    const result = await registerInstanceInTypeIndex(store, instance, index, klass)
+    expect(result.doc()).toEqual(index)
+    expect(store.any(result, ns.solid('forClass'), null, index)).toEqual(klass)
+    expect(store.any(result, ns.solid('instance'), null, index)).toEqual(instance)
+    expect(store.holds(result, ns.rdf('type'), ns.solid('TypeRegistration'), index)).toEqual(true)
+    expect(requests[0].url).toEqual(index.uri)
+  })
+})
+
+})