Additional client-facing unit tests

src/mktl/config.py

@@ -200,7 +200,7 @@ def from_format_enumerated(self, key, value):
                 break
 
         if unformatted is None:
-            raise KeyError('invalid enumerator: ' + repr(value))
+            raise KeyError('invalid enumeration value: ' + repr(value))
 
         return unformatted
 
@@ -682,12 +682,18 @@ def to_format_enumerated(self, key, value):
 
         # {"0": "No", "1": "Yes", "2": "Unknown"}
 
+        if value is None:
+            return ''
+
+        if isinstance(value, bool):
+            value = int(value)
+
         value = str(value)
 
         try:
             formatted = enumerators[value]
         except KeyError:
-            formatted = value
+            raise KeyError('invalid enumerator: ' + repr(value))
 
         return formatted
 
@@ -711,6 +717,7 @@ def to_format_mask(self, key, value):
 
         value = int(value)
         formatted = list()
+        verified = 0
 
         for bit,name in enumerators.items():
             if bit == 'None':
@@ -720,6 +727,10 @@ def to_format_mask(self, key, value):
             bit_value = 1 << bit
             if value & bit_value:
                 formatted.append(name)
+                verified += bit_value
+
+        if verified != value:
+            raise KeyError('value contains unknown active bits: ' + str(value))
 
         if len(formatted) == 0:
             try:
@@ -972,9 +983,8 @@ def update(self, block, save=True):
             del items[key]
             items[lower] = item
 
-        # Allow for the possibility that a boolean item does not include
-        # enumerators in its description. This check is only necessary
-        # for authoritative blocks.
+        # Normalize the formatting of enumerators for any relevant items.
+        # This check is only necessary for authoritative blocks.
 
         if uuid == self.authoritative_uuid:
             for key in items.keys():
@@ -985,24 +995,50 @@ def update(self, block, save=True):
                 except KeyError:
                     continue
 
-                if type == 'boolean':
+                # First pass: make sure the enumerators are in with
+                # strings as keys instead of integers.
+
+                if type == 'boolean' or type == 'enumerated' or type == 'mask':
+                    additions = dict()
+                    deletions = list()
+
                     try:
                         enumerators = item_config['enumerators']
                     except KeyError:
                         enumerators = dict()
                         item_config['enumerators'] = enumerators
 
+                    for enumerator in enumerators.keys():
+                        # This would be a nice place to handle the enumerator
+                        # being None for a mask, but if that were the case an
+                        # exception would already be thrown when trying to
+                        # convert the configuration block to JSON.
+
+                        if isinstance(enumerator, int):
+                            additions[str(enumerator)] = enumerators[enumerator]
+                            deletions.append(enumerator)
+
+                    enumerators.update(additions)
+
+                    for deletion in deletions:
+                        del enumerators[deletion]
+
+                # Second pass: fill in default boolean values if they
+                # are not specified.
+
+                if type == 'boolean':
                     try:
                         enumerators['0']
-                    except:
+                    except KeyError:
                         enumerators['0'] = 'False'
 
                     try:
                         enumerators['1']
-                    except:
+                    except KeyError:
                         enumerators['1'] = 'True'
 
 
+
         # It's possible the contents of the local authoritative block changed.
         # Update the hash and configuration timestamp if that is the case.
 

src/mktl/item.py

@@ -833,11 +833,7 @@ def to_format(self, value):
             This is the inverse of :func:`from_format`.
         """
 
-        try:
-            formatted = self.store.config.to_format(self.key, value)
-        except:
-            formatted = str(self.value)
-
+        formatted = self.store.config.to_format(self.key, value)
         return formatted
 
 

src/mktl/store.py

@@ -30,19 +30,26 @@ def __init__(self, name):
     def __contains__(self, key):
 
         if isinstance(key, Item):
-            key = key.key
+            item = key
+            key = item.key
+
+            my_item = self._items[key]
+            return item is my_item
+
         else:
             key = key.lower()
-
-        return key in self._items
+            return key in self._items
 
 
     def __delitem__(self, key):
         raise NotImplementedError("you cannot delete a Store's key directly")
 
 
     def __getitem__(self, key):
-        key = key.lower()
+        if isinstance(key, Item):
+            key = key.key
+        else:
+            key = key.lower()
 
         try:
             item = self._items[key]
@@ -60,11 +67,10 @@ def __getitem__(self, key):
             if item is None:
                 try:
                     item = Item(self, key)
-                except:
+                finally:
                     self._items_lock.release()
-                    raise
-
-            self._items_lock.release()
+            else:
+                self._items_lock.release()
 
             # The Item assigns itself to our self._items dictionary as an early
             # step in its initialization process, there is no need to manipulate
@@ -87,7 +93,7 @@ def __len__(self):
 
 
     def __repr__(self):
-        return 'store.Store: ' + repr(self._items)
+        return "mktl.Store(%s): %s" % (self.name, repr(self._items))
 
 
     def __setitem__(self, name, value):

tests/README.md

@@ -0,0 +1,29 @@
+The tests here are expecting to be invoked via `pytest`. This will inspect
+all test_*.py files in the local directory, including any subdirectories,
+and invoke all defined tests discovered in this fashion. The simplest
+invocation requires no arguments::
+
+    pytest
+
+If you only want to specify a subset of tests to run, you can do so; one
+straightforward path is to select a file containing tests of interest::
+
+    pytest ./test_items.py
+
+pytest has a long list of ways it can be invoked. One report that may be
+of particular interest is test coverage; the simplest invocation with a
+summary of coverage would be::
+
+    pytest --cov=mktl
+
+You can also request a complete breakdown listing which sections of
+code are not covered::
+
+    pytest --cov=mktl --cov-report term-missing
+
+The other `--cov-report` options, such as the HTML-formatted report, can
+provide additional context beyond just the line numbers. It's worth remembering
+that 100% test coverage doesn't mean all the corner cases have been exercised--
+it's important that the tests cover as many cases as possible, which generally
+means any given line of code will be exercised many times, in many different
+ways, depending on the inputs provided.

tests/protocol/test_payload.py

@@ -0,0 +1,82 @@
+import mktl
+import pytest
+import time
+
+def test_basics():
+
+    start = time.time()
+
+    for test_value in (44, True, None, 35.5, (1,2,3), {1: 'one'}, 'string'):
+        payload = mktl.protocol.message.Payload(test_value)
+        assert payload.value is test_value
+        assert payload.time > start
+        assert payload.bulk == None
+        assert payload.dtype == None
+        assert payload.error == None
+        assert payload.refresh == None
+        assert payload.shape == None
+        ## Pull request is pending
+        ##assert payload.reply == True
+        payload.encapsulate()
+
+
+def test_encapsulate():
+
+    test_value = 44
+    for test_value in (44, True, None, 35.5, [1,2,3], 'string'):
+        payload = mktl.protocol.message.Payload(test_value)
+
+        encapsulated = payload.encapsulate()
+        assert isinstance(encapsulated, bytes)
+
+        decoded = mktl.json.loads(encapsulated)
+        assert isinstance(decoded, dict)
+
+        assert 'time' in decoded
+        assert 'value' in decoded
+        assert decoded['value'] == test_value
+
+
+    bad_payload = mktl.protocol.message.Payload({None: 'none'})
+
+    with pytest.raises(TypeError):
+        bad_payload.encapsulate()
+
+
+def test_kwargs():
+
+    payload = mktl.protocol.message.Payload('something', testing='testing')
+    assert payload.testing == 'testing'
+
+    encapsulated = payload.encapsulate()
+    decoded = mktl.json.loads(encapsulated)
+
+    assert 'time' in decoded
+    assert 'value' in decoded
+    assert 'testing' in decoded
+
+    payload.omit.add('testing')
+
+    encapsulated = payload.encapsulate()
+    decoded = mktl.json.loads(encapsulated)
+
+    assert not 'testing' in decoded
+
+
+def test_origin():
+
+    payload = mktl.protocol.message.Payload('something')
+    payload.add_origin()
+
+    encapsulated = payload.encapsulate()
+    decoded = mktl.json.loads(encapsulated)
+
+    assert '_user' in decoded
+    assert '_hostname' in decoded
+    assert '_pid' in decoded
+    assert '_ppid' in decoded
+    assert '_executable' in decoded
+    assert '_argv' in decoded
+
+
+# vim: set expandtab tabstop=8 softtabstop=4 shiftwidth=4 autoindent: