From a3ea2e1165a6c024a9bec1d1572c02c7f32557bb Mon Sep 17 00:00:00 2001
From: haad <haad@headbanggames.com>
Date: Tue, 13 Feb 2024 09:26:39 +0100
Subject: [PATCH] Test storage interfaces and LevelStorage

---
 test/storage.test.js | 73 ++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 71 insertions(+), 2 deletions(-)

diff --git a/test/storage.test.js b/test/storage.test.js
index 5e8ca82..6447f33 100644
--- a/test/storage.test.js
+++ b/test/storage.test.js
@@ -2,7 +2,7 @@ import { strictEqual, notStrictEqual } from 'assert'
 import { rimraf } from 'rimraf'
 import { copy } from 'fs-extra'
 import { Log, Identities, KeyStore } from '../src/index.js'
-import { IPFSBlockStorage, MemoryStorage, LRUStorage, ComposedStorage } from '../src/storage/index.js'
+import { IPFSBlockStorage, MemoryStorage, LRUStorage, ComposedStorage, LevelStorage } from '../src/storage/index.js'
 import testKeysPath from './fixtures/test-keys-path.js'
 import createHelia from './utils/create-helia.js'
 
@@ -33,6 +33,7 @@ describe('Storages', function () {
       await keystore.close()
     }
 
+    await rimraf('./level')
     await rimraf('./ipfs1')
     await rimraf(keysPath)
   })
@@ -41,26 +42,56 @@ describe('Storages', function () {
     const amount = 100
     const log1 = await Log(testIdentity, { logId: 'A', entryStorage: storage })
     const log2 = await Log(testIdentity, { logId: 'A', entryStorage: storage })
+
     for (let i = 0; i < amount; i++) {
       await log1.append('hello' + i)
       await log2.append('hello' + i)
     }
+
     const values = await log1.values()
     const heads = await log1.heads()
+
     strictEqual(heads.length, 1)
     strictEqual(values.length, amount)
+
     await log1.storage.clear()
     await log2.storage.clear()
+
+    const result = []
+    for await (const v of log1.storage.iterator()) {
+      result.push(v)
+    }
+    for await (const v of log2.storage.iterator()) {
+      result.push(v)
+    }
+
+    strictEqual(result.length, 0)
+
     await log1.storage.close()
     await log2.storage.close()
   }
 
+  const testInterface = (storage) => {
+    notStrictEqual(storage.put, undefined)
+    notStrictEqual(storage.get, undefined)
+    notStrictEqual(storage.del, undefined)
+    notStrictEqual(storage.iterator, undefined)
+    notStrictEqual(storage.merge, undefined)
+    notStrictEqual(storage.clear, undefined)
+    notStrictEqual(storage.close, undefined)
+  }
+
   describe('LRUStorage', () => {
     it('tests the storage', async () => {
       const storage = await LRUStorage()
       notStrictEqual(storage, undefined)
       await runTestWithStorage(storage)
     })
+
+    it('has correct interface', async () => {
+      const storage = await LRUStorage()
+      testInterface(storage)
+    })
   })
 
   describe('MemoryStorage', () => {
@@ -69,6 +100,11 @@ describe('Storages', function () {
       notStrictEqual(storage, undefined)
       await runTestWithStorage(storage)
     })
+
+    it('has correct interface', async () => {
+      const storage = await MemoryStorage()
+      testInterface(storage)
+    })
   })
 
   describe('IPFSBlockStorage', () => {
@@ -77,9 +113,27 @@ describe('Storages', function () {
       notStrictEqual(storage, undefined)
       await runTestWithStorage(storage)
     })
+
+    it('has correct interface', async () => {
+      const storage = await IPFSBlockStorage({ ipfs })
+      testInterface(storage)
+    })
   })
 
-  describe('Composed Storages', () => {
+  describe('LevelStorage', () => {
+    it('tests the storage', async () => {
+      const storage = await LevelStorage()
+      notStrictEqual(storage, undefined)
+      await runTestWithStorage(storage)
+    })
+
+    it('has correct interface', async () => {
+      const storage = await LevelStorage()
+      testInterface(storage)
+    })
+  })
+
+  describe('Composed Storage', () => {
     it('tests Memory + IPFSBlockStorage composition', async () => {
       const storage1 = await MemoryStorage()
       const storage2 = await IPFSBlockStorage({ ipfs })
@@ -88,6 +142,14 @@ describe('Storages', function () {
       await runTestWithStorage(storage)
     })
 
+    it('tests Memory + LevelStorage composition', async () => {
+      const storage1 = await MemoryStorage()
+      const storage2 = await LevelStorage()
+      const storage = await ComposedStorage(storage1, storage2)
+      notStrictEqual(storage, undefined)
+      await runTestWithStorage(storage)
+    })
+
     it('tests LRU + IPFSBlockStorage composition', async () => {
       const storage1 = await LRUStorage({ size: -1 })
       const storage2 = await IPFSBlockStorage({ ipfs })
@@ -111,5 +173,12 @@ describe('Storages', function () {
       notStrictEqual(storage, undefined)
       await runTestWithStorage(storage)
     })
+
+    it('has correct interface', async () => {
+      const storage1 = await LRUStorage()
+      const storage2 = await MemoryStorage()
+      const storage = await ComposedStorage(storage1, storage2)
+      testInterface(storage)
+    })
   })
 })