Add fixes, cleanup, id & cached property, inc, val, peers methods

Author: phillmac

orbitdbapi/db.py

@@ -37,6 +37,10 @@ def cache_remove(self, item):
         if item in self.__cache:
             del self.__cache[item]
 
+    @property
+    def cached(self):
+        return self.__use_cache
+
     @property
     def index_by(self):
         return self.__index_by
@@ -53,6 +57,10 @@ def params(self):
     def dbname(self):
         return self.__dbname
 
+    @property
+    def id(self):
+        return self.__id
+
     @property
     def dbtype(self):
         return self.__type
@@ -128,8 +136,8 @@ def get_raw(self, item):
     def put(self,  item, cache=None):
         if self.__enforce_caps and not self.putable:
             raise CapabilityError(f'Db {self.__dbname} does not have put capability')
-        if self.indexed and (not hasattr(item, self.__index_by)) and self.__enforce_indexby:
-            raise MissingIndexError("The provided document doesn't contain field '{}'".format(self.__index_by))
+        if self.indexed and (not self.__index_by in item) and self.__enforce_indexby:
+            raise MissingIndexError(f"The provided document {item} doesn't contain field '{self.__index_by}'")
 
         if cache is None: cache = self.__use_cache
         if cache:
@@ -140,7 +148,7 @@ def put(self,  item, cache=None):
             if index_val:
                 self.__cache[index_val] = item
         endpoint = '/'.join(['db', self.__id_safe, 'put'])
-        entry_hash = self.__client._call('POST', endpoint, item).get('hash')
+        entry_hash = self.__client._call('POST', endpoint, json=item).get('hash')
         if cache and entry_hash: self.__cache[entry_hash] = item
         return entry_hash
 
@@ -149,10 +157,19 @@ def add(self, item, cache=None):
             raise CapabilityError(f'Db {self.__dbname} does not have add capability')
         if cache is None: cache = self.__use_cache
         endpoint = '/'.join(['db', self.__id_safe, 'add'])
-        entry_hash = self.__client._call('POST', endpoint, item).get('hash')
+        entry_hash = self.__client._call('POST', endpoint, json=item).get('hash')
         if cache and entry_hash: self.__cache[entry_hash] = item
         return entry_hash
 
+    def inc(self, val):
+        val = int(val)
+        endpoint = '/'.join(['db', self.__id_safe, 'inc'])
+        return self.__client._call('POST', endpoint, json={'val':val})
+
+    def value(self):
+        endpoint = '/'.join(['db', self.__id_safe, 'value'])
+        return self.__client._call('GET', endpoint)
+
     def iterator_raw(self, **kwargs):
         if self.__enforce_caps and not self.iterable:
             raise CapabilityError(f'Db {self.__dbname} does not have iterator capability')
@@ -190,11 +207,19 @@ def unload(self):
 
     def events(self, eventname):
         endpoint = '/'.join(['db', self.__id_safe, 'events', urlquote(eventname, safe='')])
-        #return SSEClient('{}/{}'.format(self.__client.base_url, endpoint), session=self.__client.session)
         res = self.__client._call_raw('GET', endpoint, stream=True)
         res.raise_for_status()
         return SSEClient(res.stream()).events()
 
+    def findPeers(self, **kwargs):
+        endpoint = '/'.join(['peers','searches','db', self.__id_safe])
+        return self.__client._call('POST', endpoint, json=kwargs)
+
+    def getPeers(self):
+        endpoint = '/'.join(['db', self.__id_safe, 'peers'])
+        return self.__client._call('GET', endpoint)
+
+
 class CapabilityError(Exception):
     pass
 

tests/test.py

@@ -0,0 +1,142 @@
+#!/usr/bin/env python
+import json
+import logging
+import os
+import random
+import string
+import sys
+import unittest
+from time import sleep
+
+from orbitdbapi.client import OrbitDbAPI
+
+base_url=os.environ.get('ORBIT_DB_HTTP_API_URL')
+
+def randString(k=5, lowercase=False, both=False):
+    if both:
+        return ''.join(random.choices(string.ascii_letters + string.digits, k=k))
+    if lowercase:
+        return ''.join(random.choices(string.ascii_lowercase + string.digits, k=k))
+    return  ''.join(random.choices(string.ascii_uppercase + string.digits, k=k))
+
+class CapabilitiesTestCase(unittest.TestCase):
+    def setUp(self):
+        client = OrbitDbAPI(base_url=base_url)
+        self.kevalue_test = client.db('keyvalue_test', json={'create':True, 'type': 'keyvalue'})
+        self.feed_test = client.db('feed_test', json={'create':True, 'type': 'feed'})
+        self.event_test = client.db('event_test', json={'create':True, 'type': 'eventlog'})
+        self.docstore_test = client.db('docstore_test', json={'create':True, 'type': 'docstore'})
+        self.counter_test = client.db('counter_test', json={'create':True, 'type': 'counter'})
+
+    def runTest(self):
+        self.assertEqual(set(['get', 'put', 'remove']), set(self.kevalue_test.capabilities))
+        self.assertEqual(set(['add', 'get', 'iterator', 'remove']), set(self.feed_test.capabilities))
+        self.assertEqual(set(['add', 'get', 'iterator']), set(self.event_test.capabilities))
+        self.assertEqual(set(['get', 'put', 'query', 'remove']), set(self.docstore_test.capabilities))
+        self.assertEqual(set(['inc', 'value']), set(self.counter_test.capabilities))
+
+    def tearDown(self):
+        self.kevalue_test.unload()
+        self.feed_test.unload()
+        self.event_test.unload()
+        self.docstore_test.unload()
+        self.counter_test.unload()
+
+class CounterIncrementTestCase(unittest.TestCase):
+    def setUp(self):
+        client = OrbitDbAPI(base_url=base_url)
+        self.counter_test = client.db('counter_test', json={'create':True, 'type': 'counter'})
+
+    def runTest(self):
+        localVal = self.counter_test.value()
+        self.assertEqual(localVal, self.counter_test.value())
+        for _c in range(1,100):
+            incVal = random.randrange(1,100)
+            localVal += incVal
+            self.counter_test.inc(incVal)
+            self.assertEqual(localVal, self.counter_test.value())
+
+    def tearDown(self):
+        self.counter_test.unload()
+
+
+class KVStoreGetPutTestCase(unittest.TestCase):
+    def setUp(self):
+        client = OrbitDbAPI(base_url=base_url, use_db_cache=False)
+        self.kevalue_test = client.db('keyvalue_test', json={'create':True, 'type': 'keyvalue'})
+
+    def runTest(self):
+        self.assertFalse(self.kevalue_test.cached)
+        localKV = {}
+        for _c in range(1,100):
+            k = randString()
+            v = randString(k=100, both=True)
+            localKV[k] = v
+            self.kevalue_test.put({'key':k, 'value':v})
+            self.assertEqual(localKV.get(k), self.kevalue_test.get(k))
+            self.assertDictContainsSubset(localKV, self.kevalue_test.all())
+
+    def tearDown(self):
+        self.kevalue_test.unload()
+
+class DocStoreGetPutTestCase(unittest.TestCase):
+    def setUp(self):
+        client = OrbitDbAPI(base_url=base_url, use_db_cache=False)
+        self.docstore_test = client.db('docstore_test', json={'create':True, 'type': 'docstore'})
+
+    def runTest(self):
+        self.assertFalse(self.docstore_test.cached)
+        localDocs = []
+        for _c in range(1,100):
+            k = randString()
+            v = randString(k=100, both=True)
+            item = {'_id':k, 'value':v}
+            localDocs.append(item)
+            self.docstore_test.put(item)
+            self.assertDictContainsSubset(item, self.docstore_test.get(k)[0])
+        self.assertTrue(all(item in self.docstore_test.all() for item in localDocs))
+
+    def tearDown(self):
+        self.docstore_test.unload()
+
+
+class SearchesTestCase(unittest.TestCase):
+    def setUp(self):
+        self.client = OrbitDbAPI(base_url=base_url)
+        self.kevalue_test = self.client.db('keyvalue_test', json={'create':True, 'type': 'keyvalue'})
+
+
+    def runTest(self):
+        self.kevalue_test.findPeers()
+        searches = self.client.searches()
+        self.assertGreater(len(searches), 0)
+        self.assertGreater(len([s for s in searches if s.get('searchID') == self.kevalue_test.id]), 0)
+
+    def tearDown(self):
+        self.kevalue_test.unload()
+
+class SearchPeersTestCase(unittest.TestCase):
+    def setUp(self):
+        self.client = OrbitDbAPI(base_url=base_url)
+        self.kevalue_test = self.client.db('keyvalue_test', json={'create':True, 'type': 'keyvalue'})
+
+    def runTest(self):
+        self.kevalue_test.findPeers(useCustomFindProvs=True)
+        dbPeers = []
+        count = 0
+        while len(dbPeers) < 1:
+            sleep(5)
+            dbPeers = self.kevalue_test.getPeers()
+            if count > 60: break
+        self.assertGreater(len(dbPeers), 0)
+
+
+#     def tearDown(self):
+#         self.kevalue_test.unload()
+
+
+
+if __name__ == '__main__':
+    logfmt = '%(asctime)s - %(levelname)s - %(message)s'
+    logging.basicConfig(format=logfmt, stream=sys.stdout, level=15)
+    unittest.main()