utils: Simplify python RPC Response implementation

Reduce bloat in the python RPC Response class by making better use of
superclass methods and recursion. As part of this change, add tests for
the Response class.

utils/python-rpc/framework/rpc.py

@@ -33,32 +33,22 @@
 
 class Response(dict):
     def __init__(self, d):
-        for k in d.keys():
-            if type(d[k]) == dict:
-                self[k] = Response(d[k])
-            elif type(d[k]) == list:
-                self[k] = []
-                for i in range(len(d[k])):
-                    if type(d[k][i]) == dict:
-                        self[k].append(Response(d[k][i]))
-                    else:
-                        self[k].append(d[k][i])
-            else:
-                self[k] = d[k]
+        for k, v in d.items():
+            self[k] = self._decode(v)
+
+    @staticmethod
+    def _decode(o):
+        if isinstance(o, dict):
+            return Response(o)
+        elif isinstance(o, list):
+            return [Response._decode(i) for i in o]
+        else:
+            return o
 
     def __getattr__(self, key):
         return self[key]
     def __setattr__(self, key, value):
         self[key] = value
-    def __eq__(self, other):
-        if type(other) == dict:
-            return self == Response(other)
-        if self.keys() != other.keys():
-            return False
-        for k in self.keys():
-            if self[k] != other[k]:
-                return False
-        return True
 
 class JSONRPC(object):
     def __init__(self, url, username=None, password=None):
@@ -73,7 +63,7 @@ def send_request(self, path, inputs, result_field = None):
             headers={'content-type': 'application/json'},
             auth=HTTPDigestAuth(self.username, self.password) if self.username is not None else None)
         res = res.json()
-        
+
         assert 'error' not in res, res
 
         if result_field:

utils/python-rpc/framework/test_rpc.py

@@ -0,0 +1,134 @@
+#!/usr/bin/env python3
+import functools
+import unittest
+
+from rpc import Response
+
+
+class TestResponse(unittest.TestCase):
+    def test_init__empty(self):
+        r = Response({})
+        assert isinstance(r, Response)
+        assert len(r) == 0
+
+    def test_init__scalar_values(self):
+        r = Response(dict(k='v', k2='vv'))
+        assert len(r) == 2
+        assert r['k'] == 'v'
+        assert r['k2'] == 'vv'
+
+    def test_init__response_value(self):
+        child = Response(dict(ck='cv'))
+        root = dict(k=child)
+        r = Response(root)
+        assert len(r) == 1
+        assert isinstance(r['k'], Response)
+        assert r['k'] == child
+        assert r['k'] is not child
+
+    def test_init__dict_value(self):
+        child = dict(ck='cv')
+        root = dict(k=child)
+        r = Response(root)
+        assert len(r) == 1
+        assert isinstance(r['k'], Response)
+        assert r['k'] == Response(child)
+        assert r['k'] is not child
+
+    def test_init__list_value(self):
+        value = [1, 2]
+        r = Response(dict(k=value))
+        assert len(r) == 1
+        assert r['k'] == value
+        assert r['k'] is not value
+
+    def test_init__list_value_with_nested_response(self):
+        nested = dict(ck=[1])
+        root = dict(k=[nested])
+        r = Response(root)
+        assert len(r) == 1
+        assert r['k'] == [Response(nested)]
+        assert isinstance(r['k'][0], Response)
+
+    def test_init__list_value_with_nested_list(self):
+        nested = [1, 2]
+        root = dict(k=[nested])
+        r = Response(root)
+        assert len(r) == 1
+        assert r['k'] == [nested]
+
+    def test_getattr__present(self):
+        r = Response(dict(k='v'))
+        assert r.k == 'v'
+
+    def test_getattr__missing(self):
+        # This should raise an AttributeError to match the python data model.
+        # However, to maintain  backwards compatibility, it raises a KeyError.
+        r = Response({})
+        with self.assertRaises(KeyError):
+            r.k
+
+    def test_setattr(self):
+        r = Response({})
+        r.k = 'v'
+        assert r.k == 'v'
+        assert r['k'] == 'v'
+
+    def test_eq__identity(self):
+        r = Response({})
+        assert r == r
+
+    def test_eq__empty(self):
+        assert Response({}) == Response({})
+
+    def test_eq__nonnested_matching(self):
+        assert Response(dict(k='v')) == Response(dict(k='v'))
+
+    def test_eq__nonnested_size_mismatch(self):
+        assert Response(dict(k='v')) != Response(dict(k='v', k2='v'))
+
+    def test_eq__nonnested_key_mismatch(self):
+        assert Response(dict(k='v')) != Response(dict(k2='v'))
+
+    def test_eq__nonnested_value_mismatch(self):
+        assert Response(dict(k='v')) != Response(dict(k='v2'))
+
+    def test_eq__nested(self):
+        def data():
+            return dict(k='v', c=dict(ck='cv'))
+
+        assert Response(data()) == Response(data())
+
+    def test_eq__list_nonnested(self):
+        def data():
+            return dict(k=[1, 2])
+
+        assert Response(data()) == Response(data())
+
+    def test_eq__list_nested_response(self):
+        def data():
+            return dict(k=[Response(dict(ck=[1]))])
+
+        assert Response(data()) == Response(data())
+
+    def test_eq__list_nested_list(self):
+        def data():
+            return dict(k=[[Response(dict(k=1))]])
+
+        assert Response(data()) == Response(data())
+
+    def test_eq__dict__empty(self):
+        assert Response({}) == {}
+
+    def test_eq__dict__nonnested(self):
+        assert Response(dict(k='v')) == dict(k='v')
+
+    def test_eq__dict__nested(self):
+        def data():
+            return dict(k='v', c=dict(ck='cv'))
+
+        assert Response(data()) == data()
+
+
+if __name__ == '__main__':
+    unittest.main()