Fixed some dump/load problems.

Author: rohe

src/cryptojwt/key_bundle.py

@@ -153,6 +153,26 @@ def ec_init(spec):
 class KeyBundle:
     """The Key Bundle"""
 
+    params = {
+        "cache_time": 0,
+        "etag": "",
+        "fileformat": "jwks",
+        "httpc_params": {},
+        "ignore_errors_period": 0,
+        "ignore_errors_until": None,
+        "ignore_invalid_keys": True,
+        "imp_jwks": None,
+        "keytype": "RSA",
+        "keyusage": None,
+        "last_local": None,
+        "last_remote": None,
+        "last_updated": 0,
+        "local": False,
+        "remote": False,
+        "source": None,
+        "time_out": 0,
+    }
+
     def __init__(
         self,
         keys=None,
@@ -491,6 +511,7 @@ def update(self):
 
             # reread everything
             self._keys = []
+            updated = None
 
             try:
                 if self.local:
@@ -753,66 +774,67 @@ def difference(self, bundle):
         return [k for k in self._keys if k not in bundle]
 
     def dump(self, exclude_attributes: Optional[List[str]] = None):
-        _keys = []
-        for _k in self._keys:
-            _ser = _k.to_dict()
-            if _k.inactive_since:
-                _ser["inactive_since"] = _k.inactive_since
-            _keys.append(_ser)
-
-        res = {
-            "keys": _keys,
-            "cache_time": self.cache_time,
-            "etag": self.etag,
-            "fileformat": self.fileformat,
-            "httpc_params": self.httpc_params,
-            "ignore_errors_period": self.ignore_errors_period,
-            "ignore_errors_until": self.ignore_errors_until,
-            "ignore_invalid_keys": self.ignore_invalid_keys,
-            "imp_jwks": self.imp_jwks,
-            "keytype": self.keytype,
-            "keyusage": self.keyusage,
-            "last_local": self.last_local,
-            "last_remote": self.last_remote,
-            "last_updated": self.last_updated,
-            "local": self.local,
-            "remote": self.remote,
-            "time_out": self.time_out,
-        }
-
-        if self.source:
-            res["source"] = self.source
-
-        if exclude_attributes:
-            for attr in exclude_attributes:
-                try:
-                    del res[attr]
-                except KeyError:
-                    pass
+        if exclude_attributes is None:
+            exclude_attributes = []
+
+        res = {}
+
+        if "keys" not in exclude_attributes:
+            _keys = []
+            for _k in self._keys:
+                _ser = _k.to_dict()
+                if _k.inactive_since:
+                    _ser["inactive_since"] = _k.inactive_since
+                _keys.append(_ser)
+            res["keys"] = _keys
+
+        for attr, default in self.params.items():
+            if attr in exclude_attributes:
+                continue
+            val = getattr(self, attr)
+            res[attr] = val
+
+        # res = {
+        #     "cache_time": self.cache_time,
+        #     "etag": self.etag,
+        #     "fileformat": self.fileformat,
+        #     "httpc_params": self.httpc_params,
+        #     "ignore_errors_period": self.ignore_errors_period,
+        #     "ignore_errors_until": self.ignore_errors_until,
+        #     "ignore_invalid_keys": self.ignore_invalid_keys,
+        #     "imp_jwks": self.imp_jwks,
+        #     "keytype": self.keytype,
+        #     "keyusage": self.keyusage,
+        #     "last_local": self.last_local,
+        #     "last_remote": self.last_remote,
+        #     "last_updated": self.last_updated,
+        #     "local": self.local,
+        #     "remote": self.remote,
+        #     "time_out": self.time_out,
+        # }
+
+        # if self.source:
+        #     res["source"] = self.source
 
         return res
 
     def load(self, spec):
+        """
+        Sets attributes according to a specification.
+        Does not overwrite an existing attributes value with a default value.
+
+        :param spec: Dictionary with attributes and value to populate the instance with
+        :return: The instance itself
+        """
         _keys = spec.get("keys", [])
         if _keys:
             self.do_keys(_keys)
-        self.cache_time = spec.get("cache_time", 0)
-        self.etag = spec.get("etag", "")
-        self.fileformat = spec.get("fileformat", "jwks")
-        self.httpc_params = spec.get("httpc_params", {})
-        self.ignore_errors_period = spec.get("ignore_errors_period", 0)
-        self.ignore_errors_until = spec.get("ignore_errors_until", None)
-        self.ignore_invalid_keys = spec.get("ignore_invalid_keys", True)
-        self.imp_jwks = spec.get("imp_jwks", None)
-        self.keytype = (spec.get("keytype", "RSA"),)
-        self.keyusage = (spec.get("keyusage", None),)
-        self.last_local = spec.get("last_local", None)
-        self.last_remote = spec.get("last_remote", None)
-        self.last_updated = spec.get("last_updated", 0)
-        self.local = spec.get("local", False)
-        self.remote = spec.get("remote", False)
-        self.source = spec.get("source", None)
-        self.time_out = spec.get("time_out", 0)
+
+        for attr, default in self.params.items():
+            val = spec.get(attr)
+            if val:
+                setattr(self, attr, val)
+
         return self
 
     def flush(self):

src/cryptojwt/key_issuer.py

@@ -17,13 +17,22 @@
 
 __author__ = "Roland Hedberg"
 
-
 logger = logging.getLogger(__name__)
 
 
 class KeyIssuer(object):
     """ A key issuer instance contains a number of KeyBundles. """
 
+    params = {
+        "ca_certs": None,
+        "keybundle_cls": KeyBundle,
+        "remove_after": 3600,
+        "httpc": None,
+        "httpc_params": None,
+        "name": "",
+        "spec2key": None,
+    }
+
     def __init__(
         self,
         ca_certs=None,
@@ -360,27 +369,23 @@ def dump(self, exclude_attributes: Optional[List[str]] = None) -> dict:
         :return: A dictionary
         """
 
-        _bundles = []
-        for kb in self._bundles:
-            _bundles.append(kb.dump(exclude_attributes=exclude_attributes))
-
-        info = {
-            "name": self.name,
-            "bundles": _bundles,
-            "keybundle_cls": qualified_name(self.keybundle_cls),
-            "spec2key": self.spec2key,
-            "ca_certs": self.ca_certs,
-            "remove_after": self.remove_after,
-            "httpc_params": self.httpc_params,
-        }
-
-        # remove after the fact
-        if exclude_attributes:
-            for attr in exclude_attributes:
-                try:
-                    del info[attr]
-                except KeyError:
-                    pass
+        if exclude_attributes is None:
+            exclude_attributes = []
+
+        info = {}
+        for attr, default in self.params.items():
+            if attr in exclude_attributes:
+                continue
+            val = getattr(self, attr)
+            if attr == "keybundle_cls":
+                val = qualified_name(val)
+            info[attr] = val
+
+        if "bundles" not in exclude_attributes:
+            _bundles = []
+            for kb in self._bundles:
+                _bundles.append(kb.dump(exclude_attributes=exclude_attributes))
+            info["bundles"] = _bundles
 
         return info
 
@@ -390,24 +395,20 @@ def load(self, info):
         :param items: A dictionary with the information to load
         :return:
         """
-        self.name = info["name"]
-        self.keybundle_cls = importer(info["keybundle_cls"])
-        self.spec2key = info["spec2key"]
-        self.ca_certs = info["ca_certs"]
-        self.remove_after = info["remove_after"]
-        self.httpc_params = info["httpc_params"]
+        for attr, default in self.params.items():
+            val = info.get(attr)
+            if val:
+                if attr == "keybundle_cls":
+                    val = importer(val)
+                setattr(self, attr, val)
+
         self._bundles = [KeyBundle().load(val) for val in info["bundles"]]
         return self
 
     def flush(self):
-        self.ca_certs = (None,)
-        self.keybundle_cls = (KeyBundle,)
-        self.remove_after = (3600,)
-        self.httpc = (None,)
-        self.httpc_params = (None,)
-        self.name = ""
-        self.spec2key = None
-        self.remove_after = 0
+        for attr, default in self.params.items():
+            setattr(self, attr, default)
+
         self._bundles = []
         return self
 

src/cryptojwt/serialize/item.py

@@ -7,7 +7,7 @@ class KeyIssuer:
     @staticmethod
     def serialize(item: key_issuer.KeyIssuer) -> str:
         """ Convert from KeyIssuer to JSON """
-        return json.dumps(item.dump())
+        return json.dumps(item.dump(exclude_attributes=["keybundle_cls", "httpc"]))
 
     def deserialize(self, spec: str) -> key_issuer.KeyIssuer:
         """ Convert from JSON to KeyIssuer """

tests/test_03_key_bundle.py

@@ -968,6 +968,7 @@ def test_export_inactive():
         "last_local",
         "remote",
         "local",
+        "source",
         "time_out",
     }
 
@@ -1085,3 +1086,18 @@ def test_ignore_invalid_keys():
 
     with pytest.raises(UnknownKeyType):
         KeyBundle(keys={"keys": [rsa_key_dict]}, ignore_invalid_keys=False)
+
+
+def test_exclude_attributes():
+    source = "https://example.com/keys.json"
+    # Mock response
+    with responses.RequestsMock() as rsps:
+        rsps.add(method="GET", url=source, json=JWKS_DICT, status=200)
+        httpc_params = {"timeout": (2, 2)}  # connect, read timeouts in seconds
+        kb = KeyBundle(source=source, httpc=requests.request, httpc_params=httpc_params)
+        kb.do_remote()
+
+    exp = kb.dump(exclude_attributes=["cache_time", "ignore_invalid_keys"])
+    kb2 = KeyBundle(cache_time=600, ignore_invalid_keys=False).load(exp)
+    assert kb2.cache_time == 600
+    assert kb2.ignore_invalid_keys is False