@atproto/repo 0.0.1 → 0.1.0

package/tests/mst.test.ts

@@ -1,7 +1,8 @@
-import { MST, DataAdd, DataUpdate, DataDelete } from '../src/mst'
-import { countPrefixLen } from '../src/mst/util'
+import { MST } from '../src/mst'
+import DataDiff, { DataAdd, DataUpdate, DataDelete } from '../src/data-diff'
+import { countPrefixLen, InvalidMstKeyError } from '../src/mst/util'
 
-import { MemoryBlockstore } from '../src/blockstore'
+import { MemoryBlockstore } from '../src/storage'
 import * as util from './_util'
 
 import { CID } from 'multiformats'
@@ -15,7 +16,7 @@ describe('Merkle Search Tree', () => {
   beforeAll(async () => {
     blockstore = new MemoryBlockstore()
     mst = await MST.create(blockstore)
-    mapping = await util.generateBulkTidMapping(1000, blockstore)
+    mapping = await util.generateBulkDataKeys(1000, blockstore)
     shuffled = util.shuffle(Object.entries(mapping))
   })
 
@@ -90,8 +91,8 @@ describe('Merkle Search Tree', () => {
   })
 
   it('saves and loads from blockstore', async () => {
-    const cid = await mst.stage()
-    const loaded = await MST.load(blockstore, cid)
+    const root = await util.saveMst(blockstore, mst)
+    const loaded = await MST.load(blockstore, root)
     const origNodes = await mst.allNodes()
     const loadedNodes = await loaded.allNodes()
     expect(origNodes.length).toBe(loadedNodes.length)
@@ -104,7 +105,7 @@ describe('Merkle Search Tree', () => {
     let toDiff = mst
 
     const toAdd = Object.entries(
-      await util.generateBulkTidMapping(100, blockstore),
+      await util.generateBulkDataKeys(100, blockstore),
     )
     const toEdit = shuffled.slice(500, 600)
     const toDel = shuffled.slice(400, 500)
@@ -131,7 +132,7 @@ describe('Merkle Search Tree', () => {
       expectedDels[entry[0]] = { key: entry[0], cid: entry[1] }
     }
 
-    const diff = await mst.diff(toDiff)
+    const diff = await DataDiff.of(toDiff, mst)
 
     expect(diff.addList().length).toBe(100)
     expect(diff.updateList().length).toBe(100)
@@ -154,127 +155,273 @@ describe('Merkle Search Tree', () => {
     }
   })
 
-  // Special Cases (these are made for fanout 32)
-  // ------------
-
-  it('trims the top of an MST on stage', async () => {
-    const layer0 = [
-      '3j6hnk65jis2t',
-      '3j6hnk65jit2t',
-      '3j6hnk65jiu2t',
-      '3j6hnk65jne2t',
-      '3j6hnk65jnm2t',
-    ]
-    const layer1 = '3j6hnk65jju2t'
-    mst = await MST.create(blockstore, [], { fanout: 32 })
-    const cid = await util.randomCid()
-    const tids = [...layer0, layer1]
-    for (const tid of tids) {
-      mst = await mst.add(tid, cid)
-    }
-    const layer = await mst.getLayer()
-    expect(layer).toBe(1)
-    mst = await mst.delete(layer1)
-    const root = await mst.stage()
-    const loaded = MST.load(blockstore, root)
-    const loadedLayer = await loaded.getLayer()
-    expect(loadedLayer).toBe(0)
+  describe('utils', () => {
+    it('counts prefix length', () => {
+      expect(countPrefixLen('abc', 'abc')).toBe(3)
+      expect(countPrefixLen('', 'abc')).toBe(0)
+      expect(countPrefixLen('abc', '')).toBe(0)
+      expect(countPrefixLen('ab', 'abc')).toBe(2)
+      expect(countPrefixLen('abc', 'ab')).toBe(2)
+      expect(countPrefixLen('abcde', 'abc')).toBe(3)
+      expect(countPrefixLen('abc', 'abcde')).toBe(3)
+      expect(countPrefixLen('abcde', 'abc1')).toBe(3)
+      expect(countPrefixLen('abcde', 'abb')).toBe(2)
+      expect(countPrefixLen('abcde', 'qbb')).toBe(0)
+      expect(countPrefixLen('', 'asdf')).toBe(0)
+      expect(countPrefixLen('abc', 'abc\x00')).toBe(3)
+      expect(countPrefixLen('abc\x00', 'abc')).toBe(3)
+    })
   })
 
-  // These are some tricky things that can come up that may not be included in a randomized tree
-
-  /**
-   *   `f` gets added & it does two node splits (e is no longer grouped with g/h)
-   *
-   *                *                                  *
-   *       _________|________                      ____|_____
-   *       |   |    |    |   |                    |    |     |
-   *       *   d    *    i   *       ->           *    f     *
-   *     __|__    __|__    __|__                __|__      __|___
-   *    |  |  |  |  |  |  |  |  |              |  |  |    |  |   |
-   *    a  b  c  e  g  h  j  k  l              *  d  *    *  i   *
-   *                                         __|__   |   _|_   __|__
-   *                                        |  |  |  |  |   | |  |  |
-   *                                        a  b  c  e  g   h j  k  l
-   *
-   */
-  it('handles splits that must go 2 deep', async () => {
-    const layer0 = [
-      '3j6hnk65jis2t',
-      '3j6hnk65jit2t',
-      '3j6hnk65jiu2t',
-      '3j6hnk65jne2t',
-      '3j6hnk65jnm2t',
-      '3j6hnk65jnn2t',
-      '3j6hnk65kvx2t',
-      '3j6hnk65kvy2t',
-      '3j6hnk65kvz2t',
-    ]
-    const layer1 = ['3j6hnk65jju2t', '3j6hnk65kve2t']
-    const layer2 = '3j6hnk65jng2t'
-    mst = await MST.create(blockstore, [], { fanout: 32 })
-    const cid = await util.randomCid()
-    for (const tid of layer0) {
-      mst = await mst.add(tid, cid)
-    }
-    for (const tid of layer1) {
-      mst = await mst.add(tid, cid)
+  describe('MST Interop Allowable Keys', () => {
+    let blockstore: MemoryBlockstore
+    let mst: MST
+    let cid1: CID
+
+    beforeAll(async () => {
+      blockstore = new MemoryBlockstore()
+      mst = await MST.create(blockstore)
+      cid1 = CID.parse(
+        'bafyreie5cvv4h45feadgeuwhbcutmh6t2ceseocckahdoe6uat64zmz454',
+      )
+    })
+
+    const expectReject = async (key: string) => {
+      const promise = mst.add(key, cid1)
+      await expect(promise).rejects.toThrow(InvalidMstKeyError)
     }
-    mst = await mst.add(layer2, cid)
-    const layer = await mst.getLayer()
-    expect(layer).toBe(2)
 
-    const root = await mst.stage()
-    mst = MST.load(blockstore, root, { fanout: 32 })
-
-    const allTids = [...layer0, ...layer1, layer2]
-    for (const tid of allTids) {
-      const got = await mst.get(tid)
-      expect(cid.equals(got)).toBeTruthy()
-    }
+    it('rejects the empty key', async () => {
+      await expectReject('')
+    })
+
+    it('rejects a key with no collection', async () => {
+      await expectReject('asdf')
+    })
+
+    it('rejects a key with a nested collection', async () => {
+      await expectReject('nested/collection/asdf')
+    })
+
+    it('rejects on empty coll or rkey', async () => {
+      await expectReject('coll/')
+      await expectReject('/rkey')
+    })
+
+    it('rejects non-ascii chars', async () => {
+      await expectReject('coll/jalapeñoA')
+      await expectReject('coll/coöperative')
+      await expectReject('coll/abc💩')
+    })
+
+    it('rejects ascii that we dont support', async () => {
+      await expectReject('coll/key$')
+      await expectReject('coll/key%')
+      await expectReject('coll/key(')
+      await expectReject('coll/key)')
+      await expectReject('coll/key+')
+      await expectReject('coll/key=')
+    })
+
+    it('rejects keys over 256 chars', async () => {
+      await expectReject(
+        'coll/asdofiupoiwqeurfpaosidfuapsodirupasoirupasoeiruaspeoriuaspeoriu2p3o4iu1pqw3oiuaspdfoiuaspdfoiuasdfpoiasdufpwoieruapsdofiuaspdfoiuasdpfoiausdfpoasidfupasodifuaspdofiuasdpfoiasudfpoasidfuapsodfiuasdpfoiausdfpoasidufpasodifuapsdofiuasdpofiuasdfpoaisdufpao',
+      )
+    })
   })
-  /**
-   *   `b` gets added & it hashes to 2 levels above any existing leaves
-   *
-   *          *        ->            *
-   *        __|__                  __|__
-   *       |     |                |  |  |
-   *       a     c                *  b  *
-   *                              |     |
-   *                              *     *
-   *                              |     |
-   *                              a     c
-   *
-   */
-  it('handles new layers that are two higher than existing', async () => {
-    const layer0 = ['3j6hnk65jis2t', '3j6hnk65kvz2t']
-    const layer2 = '3j6hnk65jng2t'
-    mst = await MST.create(blockstore, [], { fanout: 32 })
-    const cid = await util.randomCid()
-    for (const tid of layer0) {
-      mst = await mst.add(tid, cid)
-    }
-    mst = await mst.add(layer2, cid)
-
-    const root = await mst.stage()
-    mst = MST.load(blockstore, root, { fanout: 32 })
 
-    const layer = await mst.getLayer()
-    expect(layer).toBe(2)
-    const allTids = [...layer0, layer2]
-    for (const tid of allTids) {
-      const got = await mst.get(tid)
-      expect(cid.equals(got)).toBeTruthy()
-    }
+  describe('MST Interop Known Maps', () => {
+    let blockstore: MemoryBlockstore
+    let mst: MST
+    let cid1: CID
+
+    beforeAll(async () => {
+      blockstore = new MemoryBlockstore()
+      cid1 = CID.parse(
+        'bafyreie5cvv4h45feadgeuwhbcutmh6t2ceseocckahdoe6uat64zmz454',
+      )
+    })
+
+    beforeEach(async () => {
+      mst = await MST.create(blockstore)
+    })
+
+    it('computes "empty" tree root CID', async () => {
+      expect(await mst.leafCount()).toBe(0)
+      expect((await mst.getPointer()).toString()).toBe(
+        'bafyreie5737gdxlw5i64vzichcalba3z2v5n6icifvx5xytvske7mr3hpm',
+      )
+    })
+
+    it('computes "trivial" tree root CID', async () => {
+      mst = await mst.add('com.example.record/3jqfcqzm3fo2j', cid1)
+      expect(await mst.leafCount()).toBe(1)
+      expect((await mst.getPointer()).toString()).toBe(
+        'bafyreibj4lsc3aqnrvphp5xmrnfoorvru4wynt6lwidqbm2623a6tatzdu',
+      )
+    })
+
+    it('computes "singlelayer2" tree root CID', async () => {
+      mst = await mst.add('com.example.record/3jqfcqzm3fx2j', cid1)
+      expect(await mst.leafCount()).toBe(1)
+      expect(await mst.layer).toBe(2)
+      expect((await mst.getPointer()).toString()).toBe(
+        'bafyreih7wfei65pxzhauoibu3ls7jgmkju4bspy4t2ha2qdjnzqvoy33ai',
+      )
+    })
+
+    it('computes "simple" tree root CID', async () => {
+      mst = await mst.add('com.example.record/3jqfcqzm3fp2j', cid1) // level 0
+      mst = await mst.add('com.example.record/3jqfcqzm3fr2j', cid1) // level 0
+      mst = await mst.add('com.example.record/3jqfcqzm3fs2j', cid1) // level 1
+      mst = await mst.add('com.example.record/3jqfcqzm3ft2j', cid1) // level 0
+      mst = await mst.add('com.example.record/3jqfcqzm4fc2j', cid1) // level 0
+      expect(await mst.leafCount()).toBe(5)
+      expect((await mst.getPointer()).toString()).toBe(
+        'bafyreicmahysq4n6wfuxo522m6dpiy7z7qzym3dzs756t5n7nfdgccwq7m',
+      )
+    })
   })
-})
 
-describe('utils', () => {
-  it('counts prefix length', () => {
-    expect(countPrefixLen('abc', 'abc')).toBe(3)
-    expect(countPrefixLen('', 'abc')).toBe(0)
-    expect(countPrefixLen('abc', '')).toBe(0)
-    expect(countPrefixLen('ab', 'abc')).toBe(2)
-    expect(countPrefixLen('abc', 'ab')).toBe(2)
+  describe('MST Interop Edge Cases', () => {
+    let blockstore: MemoryBlockstore
+    let mst: MST
+    let cid1: CID
+
+    beforeAll(async () => {
+      blockstore = new MemoryBlockstore()
+      cid1 = CID.parse(
+        'bafyreie5cvv4h45feadgeuwhbcutmh6t2ceseocckahdoe6uat64zmz454',
+      )
+    })
+
+    beforeEach(async () => {
+      mst = await MST.create(blockstore)
+    })
+
+    it('trims top of tree on delete', async () => {
+      const l1root =
+        'bafyreifnqrwbk6ffmyaz5qtujqrzf5qmxf7cbxvgzktl4e3gabuxbtatv4'
+      const l0root =
+        'bafyreie4kjuxbwkhzg2i5dljaswcroeih4dgiqq6pazcmunwt2byd725vi'
+
+      mst = await mst.add('com.example.record/3jqfcqzm3fn2j', cid1) // level 0
+      mst = await mst.add('com.example.record/3jqfcqzm3fo2j', cid1) // level 0
+      mst = await mst.add('com.example.record/3jqfcqzm3fp2j', cid1) // level 0
+      mst = await mst.add('com.example.record/3jqfcqzm3fs2j', cid1) // level 1
+      mst = await mst.add('com.example.record/3jqfcqzm3ft2j', cid1) // level 0
+      mst = await mst.add('com.example.record/3jqfcqzm3fu2j', cid1) // level 0
+
+      expect(await mst.leafCount()).toBe(6)
+      expect(await mst.layer).toBe(1)
+      expect((await mst.getPointer()).toString()).toBe(l1root)
+
+      mst = await mst.delete('com.example.record/3jqfcqzm3fs2j') // level 1
+      expect(await mst.leafCount()).toBe(5)
+      expect(await mst.layer).toBe(0)
+      expect((await mst.getPointer()).toString()).toBe(l0root)
+    })
+
+    /**
+     *
+     *                *                                  *
+     *       _________|________                      ____|_____
+     *       |   |    |    |   |                    |    |     |
+     *       *   d    *    i   *       ->           *    f     *
+     *     __|__    __|__    __|__                __|__      __|___
+     *    |  |  |  |  |  |  |  |  |              |  |  |    |  |   |
+     *    a  b  c  e  g  h  j  k  l              *  d  *    *  i   *
+     *                                         __|__   |   _|_   __|__
+     *                                        |  |  |  |  |   | |  |  |
+     *                                        a  b  c  e  g   h j  k  l
+     *
+     */
+    it('handles insertion that splits two layers down', async () => {
+      const l1root =
+        'bafyreiettyludka6fpgp33stwxfuwhkzlur6chs4d2v4nkmq2j3ogpdjem'
+      const l2root =
+        'bafyreid2x5eqs4w4qxvc5jiwda4cien3gw2q6cshofxwnvv7iucrmfohpm'
+
+      mst = await mst.add('com.example.record/3jqfcqzm3fo2j', cid1) // A; level 0
+      mst = await mst.add('com.example.record/3jqfcqzm3fp2j', cid1) // B; level 0
+      mst = await mst.add('com.example.record/3jqfcqzm3fr2j', cid1) // C; level 0
+      mst = await mst.add('com.example.record/3jqfcqzm3fs2j', cid1) // D; level 1
+      mst = await mst.add('com.example.record/3jqfcqzm3ft2j', cid1) // E; level 0
+      // GAP for F
+      mst = await mst.add('com.example.record/3jqfcqzm3fz2j', cid1) // G; level 0
+      mst = await mst.add('com.example.record/3jqfcqzm4fc2j', cid1) // H; level 0
+      mst = await mst.add('com.example.record/3jqfcqzm4fd2j', cid1) // I; level 1
+      mst = await mst.add('com.example.record/3jqfcqzm4ff2j', cid1) // J; level 0
+      mst = await mst.add('com.example.record/3jqfcqzm4fg2j', cid1) // K; level 0
+      mst = await mst.add('com.example.record/3jqfcqzm4fh2j', cid1) // L; level 0
+
+      expect(await mst.leafCount()).toBe(11)
+      expect(await mst.layer).toBe(1)
+      expect((await mst.getPointer()).toString()).toBe(l1root)
+
+      // insert F, which will push E out of the node with G+H to a new node under D
+      mst = await mst.add('com.example.record/3jqfcqzm3fx2j', cid1) // F; level 2
+      expect(await mst.leafCount()).toBe(12)
+      expect(await mst.layer).toBe(2)
+      expect((await mst.getPointer()).toString()).toBe(l2root)
+
+      // remove F, which should push E back over with G+H
+      mst = await mst.delete('com.example.record/3jqfcqzm3fx2j') // F; level 2
+      expect(await mst.leafCount()).toBe(11)
+      expect(await mst.layer).toBe(1)
+      expect((await mst.getPointer()).toString()).toBe(l1root)
+    })
+
+    /**
+     *
+     *          *        ->            *
+     *        __|__                  __|__
+     *       |     |                |  |  |
+     *       a     c                *  b  *
+     *                              |     |
+     *                              *     *
+     *                              |     |
+     *                              a     c
+     *
+     */
+    it('handles new layers that are two higher than existing', async () => {
+      const l0root =
+        'bafyreidfcktqnfmykz2ps3dbul35pepleq7kvv526g47xahuz3rqtptmky'
+      const l2root =
+        'bafyreiavxaxdz7o7rbvr3zg2liox2yww46t7g6hkehx4i4h3lwudly7dhy'
+      const l2root2 =
+        'bafyreig4jv3vuajbsybhyvb7gggvpwh2zszwfyttjrj6qwvcsp24h6popu'
+
+      mst = await mst.add('com.example.record/3jqfcqzm3ft2j', cid1) // A; level 0
+      mst = await mst.add('com.example.record/3jqfcqzm3fz2j', cid1) // C; level 0
+      expect(await mst.leafCount()).toBe(2)
+      expect(await mst.layer).toBe(0)
+      expect((await mst.getPointer()).toString()).toBe(l0root)
+
+      // insert B, which is two levels above
+      mst = await mst.add('com.example.record/3jqfcqzm3fx2j', cid1) // B; level 2
+      expect(await mst.leafCount()).toBe(3)
+      expect(await mst.layer).toBe(2)
+      expect((await mst.getPointer()).toString()).toBe(l2root)
+
+      // remove B
+      mst = await mst.delete('com.example.record/3jqfcqzm3fx2j') // B; level 2
+      expect(await mst.leafCount()).toBe(2)
+      expect(await mst.layer).toBe(0)
+      expect((await mst.getPointer()).toString()).toBe(l0root)
+
+      // insert B (level=2) and D (level=1)
+      mst = await mst.add('com.example.record/3jqfcqzm3fx2j', cid1) // B; level 2
+      mst = await mst.add('com.example.record/3jqfcqzm4fd2j', cid1) // D; level 1
+      expect(await mst.leafCount()).toBe(4)
+      expect(await mst.layer).toBe(2)
+      expect((await mst.getPointer()).toString()).toBe(l2root2)
+
+      // remove D
+      mst = await mst.delete('com.example.record/3jqfcqzm4fd2j') // D; level 1
+      expect(await mst.leafCount()).toBe(3)
+      expect(await mst.layer).toBe(2)
+      expect((await mst.getPointer()).toString()).toBe(l2root)
+    })
   })
 })

package/tests/repo.test.ts

@@ -1,107 +1,105 @@
-import * as auth from '@atproto/auth'
-
+import * as crypto from '@atproto/crypto'
 import { Repo } from '../src/repo'
-import { MemoryBlockstore } from '../src/blockstore'
+import { MemoryBlockstore } from '../src/storage'
 import * as util from './_util'
 import { TID } from '@atproto/common'
+import { RepoContents, verifyCommitSig, WriteOpAction } from '../src'
+import { Secp256k1Keypair } from '@atproto/crypto'
 
 describe('Repo', () => {
-  const verifier = new auth.Verifier()
   const collName = 'com.example.posts'
 
-  let blockstore: MemoryBlockstore
-  let authStore: auth.AuthStore
+  let storage: MemoryBlockstore
+  let keypair: crypto.Keypair
   let repo: Repo
-  let repoData: util.RepoData
+  let repoData: RepoContents
 
   it('creates repo', async () => {
-    blockstore = new MemoryBlockstore()
-    authStore = await verifier.createTempAuthStore()
-    await authStore.claimFull()
-    repo = await Repo.create(blockstore, await authStore.did(), authStore)
+    storage = new MemoryBlockstore()
+    keypair = await Secp256k1Keypair.create()
+    repo = await Repo.create(storage, keypair.did(), keypair)
   })
 
   it('has proper metadata', async () => {
-    expect(repo.meta.did).toEqual(await authStore.did())
-    expect(repo.meta.version).toBe(1)
-    expect(repo.meta.datastore).toBe('mst')
+    expect(repo.did).toEqual(keypair.did())
+    expect(repo.version).toBe(2)
   })
 
   it('does basic operations', async () => {
     const rkey = TID.nextStr()
     const record = util.generateObject()
-    repo = await repo
-      .stageUpdate({
-        action: 'create',
+    repo = await repo.applyWrites(
+      {
+        action: WriteOpAction.Create,
         collection: collName,
-        rkey: rkey,
-        value: record,
-      })
-      .createCommit(authStore)
+        rkey,
+        record,
+      },
+      keypair,
+    )
 
     let got = await repo.getRecord(collName, rkey)
     expect(got).toEqual(record)
 
     const updatedRecord = util.generateObject()
-    repo = await repo
-      .stageUpdate({
-        action: 'update',
+    repo = await repo.applyWrites(
+      {
+        action: WriteOpAction.Update,
         collection: collName,
-        rkey: rkey,
-        value: updatedRecord,
-      })
-      .createCommit(authStore)
+        rkey,
+        record: updatedRecord,
+      },
+      keypair,
+    )
     got = await repo.getRecord(collName, rkey)
     expect(got).toEqual(updatedRecord)
 
-    repo = await repo
-      .stageUpdate({
-        action: 'delete',
+    repo = await repo.applyWrites(
+      {
+        action: WriteOpAction.Delete,
         collection: collName,
         rkey: rkey,
-      })
-      .createCommit(authStore)
+      },
+      keypair,
+    )
     got = await repo.getRecord(collName, rkey)
     expect(got).toBeNull()
   })
 
   it('adds content collections', async () => {
-    const filled = await util.fillRepo(repo, authStore, 100)
+    const filled = await util.fillRepo(repo, keypair, 100)
     repo = filled.repo
     repoData = filled.data
-    await util.checkRepo(repo, repoData)
+    const contents = await repo.getContents()
+    expect(contents).toEqual(repoData)
   })
 
   it('edits and deletes content', async () => {
-    const edited = await util.editRepo(repo, repoData, authStore, {
+    const edited = await util.editRepo(repo, repoData, keypair, {
       adds: 20,
       updates: 20,
       deletes: 20,
     })
     repo = edited.repo
-    await util.checkRepo(repo, repoData)
+    const contents = await repo.getContents()
+    expect(contents).toEqual(repoData)
   })
 
-  it('adds a valid signature to commit', async () => {
-    const commit = await repo.commit
-    const verified = await verifier.verifySignature(
-      repo.did,
-      commit.root.bytes,
-      commit.sig,
-    )
+  it('has a valid signature to commit', async () => {
+    const verified = await verifyCommitSig(repo.commit, keypair.did())
     expect(verified).toBeTruthy()
   })
 
   it('sets correct DID', async () => {
-    expect(repo.did).toEqual(await authStore.did())
+    expect(repo.did).toEqual(keypair.did())
   })
 
   it('loads from blockstore', async () => {
-    const reloadedRepo = await Repo.load(blockstore, repo.cid)
+    const reloadedRepo = await Repo.load(storage, repo.cid)
 
-    await util.checkRepo(reloadedRepo, repoData)
-    expect(repo.meta.did).toEqual(await authStore.did())
-    expect(repo.meta.version).toBe(1)
-    expect(repo.meta.datastore).toBe('mst')
+    const contents = await reloadedRepo.getContents()
+    expect(contents).toEqual(repoData)
+    expect(repo.did).toEqual(keypair.did())
+    expect(repo.version).toBe(2)
   })
 })

package/tests/sync/checkout.test.ts

@@ -0,0 +1,57 @@
+import * as crypto from '@atproto/crypto'
+import { Repo, RepoContents, RepoVerificationError } from '../../src'
+import { MemoryBlockstore } from '../../src/storage'
+import * as sync from '../../src/sync'
+
+import * as util from '../_util'
+
+describe('Checkout Sync', () => {
+  let storage: MemoryBlockstore
+  let syncStorage: MemoryBlockstore
+  let repo: Repo
+  let keypair: crypto.Keypair
+  let repoData: RepoContents
+
+  const repoDid = 'did:example:test'
+
+  beforeAll(async () => {
+    storage = new MemoryBlockstore()
+    keypair = await crypto.Secp256k1Keypair.create()
+    repo = await Repo.create(storage, repoDid, keypair)
+    syncStorage = new MemoryBlockstore()
+    const filled = await util.fillRepo(repo, keypair, 20)
+    repo = filled.repo
+    repoData = filled.data
+  })
+
+  it('sync a non-historical repo checkout', async () => {
+    const checkoutCar = await sync.getCheckout(storage, repo.cid)
+    const checkout = await sync.loadCheckout(
+      syncStorage,
+      checkoutCar,
+      repoDid,
+      keypair.did(),
+    )
+    const checkoutRepo = await Repo.load(syncStorage, checkout.root)
+    const contents = await checkoutRepo.getContents()
+    expect(contents).toEqual(repoData)
+    expect(checkout.contents).toEqual(repoData)
+  })
+
+  it('does not sync unneeded blocks during checkout', async () => {
+    const commitPath = await storage.getCommitPath(repo.cid, null)
+    if (!commitPath) {
+      throw new Error('Could not get commitPath')
+    }
+    const hasGenesisCommit = await syncStorage.has(commitPath[0])
+    expect(hasGenesisCommit).toBeFalsy()
+  })
+
+  it('throws on a bad signature', async () => {
+    const badRepo = await util.addBadCommit(repo, keypair)
+    const checkoutCar = await sync.getCheckout(storage, badRepo.cid)
+    await expect(
+      sync.loadCheckout(syncStorage, checkoutCar, repoDid, keypair.did()),
+    ).rejects.toThrow(RepoVerificationError)
+  })
+})