Added additional tests and missing functionality.

Added pin tests
Added log functions/tests
Added other random tests
Removed tailing separator on directory paths in multipart

License: MIT
Signed-off-by: Luke Stack <[email protected]>

Author: jlstack

ipfsApi/client.py

@@ -74,6 +74,9 @@ class Client(object):
     config -- controls configuration variables
     config_show -- returns a dict containing the server's configuration
     config_replace -- replaces the existing config with a user-defined config
+    log_level -- changes the logging output of a running daemon
+    log_ls -- lists the logging subsystems of a running daemon
+    log_tail -- reads log outputs as they are written
     version -- returns the software version of the currently connected node
     files_cp -- copies files into MFS
     files_ls -- lists directory contents in MFS
@@ -166,6 +169,9 @@ def __init__(self, host=None, port=None,
         self._config             = ArgCommand('/config')
         self._config_show        = Command('/config/show')
         self._config_replace     = ArgCommand('/config/replace')
+        self._log_level          = ArgCommand('/log/level')
+        self._log_ls             = Command('/log/ls')
+        self._log_tail           = Command('/log/tail')
         self._version            = Command('/version')
 
         # MFS COMMANDS
@@ -837,6 +843,41 @@ def config_replace(self, *args, **kwargs):
         """
         return self._config_replace.request(self._client, *args, **kwargs)
 
+    def log_level(self, subsystem, level, **kwargs):
+        """Changes the logging output of a running daemon.
+
+        Keyword arguments:
+        subsystem -- the subsystem logging identifier
+                     (Use 'all' for all subsystems)
+        level -- one of: debug, info, warning, error, fatal, panic
+        kwargs -- additional named arguments
+        """
+        return self._log_level.request(self._client, subsystem,
+                                       level, **kwargs)
+
+    def log_ls(self, *args, **kwargs):
+        """Lists the logging subsystems of a running daemon.
+
+        Keyword arguments:
+        args -- additional unnamed arguments
+        kwargs -- additional named arguments
+        """
+        return self._log_ls.request(self._client, *args, **kwargs)
+
+    def log_tail(self, *args, **kwargs):
+        """Reads log outputs as they are written.
+
+        This function returns a reponse object that can be iterated over
+        by the user. The user should make sure to close the response object
+        when they are done reading from it.
+
+        Keyword arguments:
+        args -- additional unnamed arguments
+        kwargs -- additional named arguments
+        """
+        return self._log_tail.request(self._client, stream=True,
+                                      *args, **kwargs)
+
     def version(self, **kwargs):
         """Returns the software version of the currently connected node.
 

ipfsApi/multipart.py

@@ -408,6 +408,8 @@ def headers(self):
     def _prepare(self):
         """Pre-formats the multipart HTTP request to transmit the directory."""
         names = []
+        if self.directory.endswith(os.sep):
+            self.directory = self.directory[:-1]
         # identify the unecessary portion of the relative path
         truncate = os.path.dirname(self.directory)
         # traverse the filesystem downward from the target directory's uri

test/functional/tests.py

@@ -1,6 +1,7 @@
 # _*_ coding: utf-8 -*-
 import os
 import shutil
+import json
 import unittest
 
 import ipfsApi
@@ -84,6 +85,19 @@ def tearDown(self):
     # TESTS #
     #########
 
+    def test_version(self):
+        expected = ['Repo', 'Commit', 'Version']
+        resp_version = self.api.version()
+        for key in expected:
+            self.assertTrue(key in resp_version)
+
+    def test_id(self):
+        expected = ['PublicKey', 'ProtocolVersion',
+                    'ID', 'AgentVersion', 'Addresses']
+        resp_id = self.api.id()
+        for key in expected:
+            self.assertTrue(key in resp_id)
+
     def test_add_single_from_str(self):
         res = self.api.add(self.fake_file)
         self.assertEqual(res, self.fake_file_only_res)
@@ -104,7 +118,6 @@ def test_add_multiple_from_dirname(self):
                          sorted(self.fake_dir_res,
                                 key=lambda x: x['Name']))
 
-
     def test_add_recursive(self):
         res = self.api.add(self.fake_dir, recursive=True)
         self.assertEqual(sorted(res,
@@ -170,6 +183,117 @@ def test_cat_single_file_str(self):
         self.assertEqual("dsadsad\n", res)
 
 
+class IpfsApiLogTest(unittest.TestCase):
+
+    def setUp(self):
+        self.api = ipfsApi.Client()
+
+    def test_log_ls_level(self):
+        """
+        Unfortunately there is no way of knowing the logging levels prior
+        to this test. This makes it impossible to guarantee that the logging
+        levels are the same as before the test was run.
+        """
+        # Retrieves the list of logging subsystems for a running daemon.
+        resp_ls = self.api.log_ls()
+        # The response should be a dictionary with only one key ('Strings').
+        self.assertTrue('Strings' in resp_ls)
+
+        # Sets the logging level to 'error' for the first subsystem found.
+        sub = resp_ls['Strings'][0]
+        resp_level = self.api.log_level(sub, 'error')
+        self.assertEqual(resp_level['Message'],
+                         "Changed log level of \'%s\' to 'error'\n" % sub)
+
+    def test_log_tail(self):
+        # Gets the response object.
+        tail = self.api.log_tail()
+
+        # Takes the first log received.
+        line = tail.readline()
+        log = json.loads(line.decode())
+
+        # Closes the response object.
+        tail.close()
+
+        # The log should have been parsed into a dictionary object with
+        # various keys depending on the event that occured.
+        self.assertTrue(type(log) is dict)
+
+
+class IpfsApiPinTest(unittest.TestCase):
+
+    fake_dir_hash = 'QmYqqgRahxbZvudnzDu2ZzUS1vFSNEuCrxghM8hgT8uBFY'
+
+    def setUp(self):
+        self.api = ipfsApi.Client()
+        # Add resources to be pinned.
+        self.resource = self.api.add_str(u'Mary had a little lamb')
+        resp_add = self.api.add('fake_dir', recursive=True)
+        self.fake_dir_hashes = [el['Hash'] for el in resp_add if 'Hash' in el]
+
+    def test_pin_ls_add_rm_single(self):
+        # Get pinned objects at start.
+        pins_begin = self.api.pin_ls()['Keys']
+
+        # Unpin the resource if already pinned.
+        if self.resource in pins_begin.keys():
+            self.api.pin_rm(self.resource)
+
+        # No matter what, the resource should not be pinned at this point.
+        self.assertFalse(self.resource in self.api.pin_ls()['Keys'])
+
+        for option in [True, False]:
+            # Pin the resource.
+            resp_add = self.api.pin_add(self.resource,
+                                        opts={"recursive":str(option)})
+            pins_afer_add = self.api.pin_ls()['Keys']
+            self.assertEqual(resp_add['Pins'], [self.resource])
+            self.assertTrue(self.resource in pins_afer_add)
+            self.assertEqual(pins_afer_add[self.resource]['Type'] == 'recursive',
+                             option)
+
+            # Unpin the resource.
+            resp_rm = self.api.pin_rm(self.resource)
+            pins_afer_rm = self.api.pin_ls()['Keys']
+            self.assertEqual(resp_rm['Pins'], [self.resource])
+            self.assertFalse(self.resource in pins_afer_rm)
+
+        # Get pinned objects at end.
+        pins_end = self.api.pin_ls()['Keys']
+
+        # Compare pinned items from start to finish of test.
+        self.assertFalse(self.resource in pins_end.keys())
+
+    def test_pin_ls_add_rm_directory(self):
+        # Get pinned objects at start.
+        pins_begin = self.api.pin_ls()['Keys']
+
+        # Remove fake_dir if it had previously been pinned.
+        if self.fake_dir_hash in pins_begin.keys() and \
+           pins_begin[self.fake_dir_hash]['Type'] == 'recursive':
+            self.api.pin_rm(self.fake_dir_hash)
+
+        # Make sure I removed it
+        pins_after_rm = self.api.pin_ls()['Keys']
+        self.assertFalse(self.fake_dir_hash in pins_after_rm.keys() and \
+                        pins_after_rm[self.fake_dir_hash]['Type'] == 'recursive')
+
+        # Add 'fake_dir' recursively.
+        self.api.pin_add(self.fake_dir_hash)
+
+        # Make sure all appear on the list of pinned objects.
+        pins_after_add = self.api.pin_ls()['Keys'].keys()
+        for el in self.fake_dir_hashes:
+            self.assertTrue(el in pins_after_add)
+
+        # Clean up.
+        self.api.pin_rm(self.fake_dir_hash)
+        pins_end = self.api.pin_ls()['Keys'].keys()
+        self.assertFalse(self.fake_dir_hash in pins_end and \
+                        pins_after_rm[self.fake_dir_hash]['Type'] == 'recursive')
+
+
 class IpfsApiMFSTest(unittest.TestCase):
 
     test_files = {
@@ -269,6 +393,8 @@ def setUp(self):
         self.api = ipfsApi.Client()
         self._olddir = os.getcwd()
         os.chdir(HERE)
+        # Add a resource to get the stats for.
+        self.resource = self.api.add_str(u'Mary had a little lamb')
 
     def tearDown(self):
         os.chdir(self._olddir)
@@ -279,6 +405,13 @@ def test_object_new(self):
         for key in expected_keys:
             self.assertTrue(key in res)
 
+    def test_object_stat(self):
+        expected = ['Hash', 'CumulativeSize', 'DataSize',
+                    'NumLinks', 'LinksSize', 'BlockSize']
+        resp_stat = self.api.object_stat(self.resource)
+        for key in expected:
+            self.assertTrue(key in resp_stat)
+
     def test_object_put_get(self):
         # Set paths to test json files
         path_no_links = os.path.join(os.path.dirname(__file__),