Merge lp:~zyga/checkbox/session-peek-api into lp:checkbox

[Zygmunt Krynicki]

933a1ed plainbox:session: add SessionStorage.id
5897758 plainbox:session: make SessionStorage.load_checkpoint() handle missing files
6e72202 plainbox:session: refactor _restore_SessionState_metadata()
08a3e28 plainbox:session: create EnvelopeUnpackMixIn
f300476 plainbox:session: add SessionPeekHelper

[Daniel Manrique (roadmr)]

Very cool :) the refactoring part looks OK and the peek stuff is a clever use of session metadata (I guess as the code says, if we restored the session to look at the metadata it could possibly barf). THanks!

review: Approve

=== modified file 'plainbox/plainbox/impl/session/__init__.py'
--- plainbox/plainbox/impl/session/__init__.py	2014-01-27 23:26:33 +0000
+++ plainbox/plainbox/impl/session/__init__.py	2014-04-30 19:25:48 +0000
@@ -79,6 +79,7 @@
     'JobState',
     'SessionManager',
     'SessionMetaData',
+    'SessionPeekHelper',
     'SessionState',
     'SessionStateLegacyAPI',
     'SessionStorage',
@@ -91,7 +92,8 @@
 from plainbox.impl.session.jobs import UndesiredJobReadinessInhibitor
 from plainbox.impl.session.legacy import SessionStateLegacyAPI
 from plainbox.impl.session.manager import SessionManager
+from plainbox.impl.session.resume import SessionPeekHelper
+from plainbox.impl.session.state import SessionMetaData
 from plainbox.impl.session.state import SessionState
-from plainbox.impl.session.state import SessionMetaData
 from plainbox.impl.session.storage import SessionStorage
 from plainbox.impl.session.storage import SessionStorageRepository
 
=== modified file 'plainbox/plainbox/impl/session/resume.py'
--- plainbox/plainbox/impl/session/resume.py	2014-03-17 11:30:19 +0000
+++ plainbox/plainbox/impl/session/resume.py	2014-04-30 19:25:48 +0000
@@ -56,6 +56,7 @@
 from plainbox.impl.result import IOLogRecord
 from plainbox.impl.result import MemoryJobResult
 from plainbox.impl.secure.qualifiers import SimpleQualifier
+from plainbox.impl.session.state import SessionMetaData
 from plainbox.impl.session.state import SessionState
 
 logger = logging.getLogger("plainbox.session.resume")
@@ -92,7 +93,78 @@
     """
 
 
-class SessionResumeHelper:
+class EnvelopeUnpackMixIn:
+    """
+    A mix-in class capable of unpacking the envelope of the session storage
+    """
+
+    def unpack_envelope(self, data):
+        """
+        Unpack the binary envelope and get access to a JSON object
+
+        :param data:
+            Bytes representing the dormant session
+        :returns:
+            the JSON representation of a session stored in the envelope
+        :raises CorruptedSessionError:
+            if the representation of the session is corrupted in any way
+        """
+        try:
+            data = gzip.decompress(data)
+        except IOError:
+            raise CorruptedSessionError(_("Cannot decompress session data"))
+        try:
+            text = data.decode("UTF-8")
+        except UnicodeDecodeError:
+            raise CorruptedSessionError(_("Cannot decode session text"))
+        try:
+            return json.loads(text)
+        except ValueError:
+            raise CorruptedSessionError(_("Cannot interpret session JSON"))
+
+
+class SessionPeekHelper(EnvelopeUnpackMixIn):
+
+    def peek(self, data):
+        """
+        Peek at the meta-data of a dormant session.
+
+        :param data:
+            Bytes representing the dormant session
+        :returns:
+            a SessionMetaData object
+        :raises CorruptedSessionError:
+            if the representation of the session is corrupted in any way
+        :raises IncompatibleSessionError:
+            if session serialization format is not supported
+        """
+        json_repr = self.unpack_envelope(data)
+        return self._peek_json(json_repr)
+
+    def _peek_json(self, json_repr):
+        """
+        Resume a SessionMetaData object from the JSON representation.
+
+        This method is called by :meth:`peek()` after the initial envelope
+        and parsing is done. The only error conditions that can happen
+        are related to semantic incompatibilities or corrupted internal state.
+        """
+        logger.debug(_("Peeking at json... (see below)"))
+        logger.debug(json.dumps(json_repr, indent=4))
+        _validate(json_repr, value_type=dict)
+        version = _validate(json_repr, key="version", choice=[1])
+        if version == 1:
+            return SessionPeekHelper1().peek_json(json_repr)
+        elif version == 2:
+            return SessionPeekHelper2().peek_json(json_repr)
+        elif version == 3:
+            return SessionPeekHelper3().peek_json(json_repr)
+        else:
+            raise IncompatibleSessionError(
+                _("Unsupported version {}").format(version))
+
+
+class SessionResumeHelper(EnvelopeUnpackMixIn):
     """
     Helper class for implementing session resume feature.
 
@@ -139,18 +211,7 @@
         :raises IncompatibleJobError:
             if serialized jobs are not the same as current jobs
         """
-        try:
-            data = gzip.decompress(data)
-        except IOError:
-            raise CorruptedSessionError(_("Cannot decompress session data"))
-        try:
-            text = data.decode("UTF-8")
-        except UnicodeDecodeError:
-            raise CorruptedSessionError(_("Cannot decode session text"))
-        try:
-            json_repr = json.loads(text)
-        except ValueError:
-            raise CorruptedSessionError(_("Cannot interpret session JSON"))
+        json_repr = self.unpack_envelope(data)
         return self._resume_json(json_repr, early_cb)
 
     def _resume_json(self, json_repr, early_cb=None):
@@ -195,7 +256,143 @@
         return job.id not in self._retain_id_set
 
 
-class SessionResumeHelper1:
+class MetaDataHelper1MixIn:
+
+    @classmethod
+    def _restore_SessionState_metadata(cls, metadata, session_repr):
+        """
+        Extract meta-data information from the representation of the session
+        and set it in the given session object
+        """
+        # Get the representation of the meta-data
+        metadata_repr = _validate(
+            session_repr, key='metadata', value_type=dict)
+        # Set each bit back to the session
+        metadata.title = _validate(
+            metadata_repr, key='title', value_type=str, value_none=True)
+        metadata.flags = set([
+            _validate(
+                flag, value_type=str,
+                value_type_msg=_("Each flag must be a string"))
+            for flag in _validate(
+                metadata_repr, key='flags', value_type=list)])
+        metadata.running_job_name = _validate(
+            metadata_repr, key='running_job_name', value_type=str,
+            value_none=True)
+
+
+class MetaDataHelper2MixIn(MetaDataHelper1MixIn):
+
+    @classmethod
+    def _restore_SessionState_metadata(cls, metadata, session_repr):
+        """
+        Extract meta-data information from the representation of the session
+        and set it in the given session object
+        """
+        super()._restore_SessionState_metadata(metadata, session_repr)
+        # Get the representation of the meta-data
+        metadata_repr = _validate(
+            session_repr, key='metadata', value_type=dict)
+        app_blob = _validate(
+            metadata_repr, key='app_blob', value_type=str,
+            value_none=True)
+        if app_blob is not None:
+            try:
+                app_blob = app_blob.encode("ASCII")
+            except UnicodeEncodeError:
+                # TRANSLATORS: please don't translate app_blob
+                raise CorruptedSessionError(_("app_blob is not ASCII"))
+            try:
+                app_blob = base64.standard_b64decode(app_blob)
+            except binascii.Error:
+                # TRANSLATORS: please don't translate app_blob
+                raise CorruptedSessionError(_("Cannot base64 decode app_blob"))
+        metadata.app_blob = app_blob
+
+
+class MetaDataHelper3MixIn(MetaDataHelper2MixIn):
+
+    @classmethod
+    def _restore_SessionState_metadata(cls, metadata, session_repr):
+        """
+        Extract meta-data information from the representation of the session
+        and set it in the given session object
+        """
+        super()._restore_SessionState_metadata(metadata, session_repr)
+        # Get the representation of the meta-data
+        metadata_repr = _validate(
+            session_repr, key='metadata', value_type=dict)
+        metadata.app_id = _validate(
+            metadata_repr, key='app_id', value_type=str,
+            value_none=True)
+
+
+class SessionPeekHelper1(MetaDataHelper1MixIn):
+    """
+    Helper class for implementing session peek feature
+
+    This class works with data constructed by
+    :class:`~plainbox.impl.session.suspend.SessionSuspendHelper1` which has
+    been pre-processed by :class:`SessionPeekHelper` (to strip the initial
+    envelope).
+
+    The only goal of this class is to reconstruct session state meta-data.
+    """
+
+    def peek_json(self, json_repr):
+        """
+        Resume a SessionState object from the JSON representation.
+
+        This method is called by :meth:`peek()` after the initial envelope and
+        parsing is done. The only error conditions that can happen are related
+        to semantic incompatibilities or corrupted internal state.
+        """
+        _validate(json_repr, key="version", choice=[1])
+        session_repr = _validate(json_repr, key='session', value_type=dict)
+        metadata = SessionMetaData()
+        self._restore_SessionState_metadata(metadata, session_repr)
+        return metadata
+
+    def _build_SessionState(self, session_repr, early_cb=None):
+        """
+        Reconstruct the session state object.
+
+        This method creates a fresh SessionState instance and restores
+        jobs, results, meta-data and desired job list using helper methods.
+        """
+        logger.debug(_("Starting to restore metadata..."))
+        metadata = SessionMetaData()
+        self._peek_SessionState_metadata(metadata, session_repr)
+        return metadata
+
+
+class SessionPeekHelper2(MetaDataHelper2MixIn, SessionPeekHelper1):
+    """
+    Helper class for implementing session peek feature
+
+    This class works with data constructed by
+    :class:`~plainbox.impl.session.suspend.SessionSuspendHelper1` which has
+    been pre-processed by :class:`SessionPeekHelper` (to strip the initial
+    envelope).
+
+    The only goal of this class is to reconstruct session state meta-data.
+    """
+
+
+class SessionPeekHelper3(MetaDataHelper3MixIn, SessionPeekHelper2):
+    """
+    Helper class for implementing session peek feature
+
+    This class works with data constructed by
+    :class:`~plainbox.impl.session.suspend.SessionSuspendHelper1` which has
+    been pre-processed by :class:`SessionPeekHelper` (to strip the initial
+    envelope).
+
+    The only goal of this class is to reconstruct session state meta-data.
+    """
+
+
+class SessionResumeHelper1(MetaDataHelper1MixIn):
     """
     Helper class for implementing session resume feature
 
@@ -257,7 +454,8 @@
             _("Starting to restore jobs and results to %r..."), session)
         self._restore_SessionState_jobs_and_results(session, session_repr)
         logger.debug(_("Starting to restore metadata..."))
-        self._restore_SessionState_metadata(session, session_repr)
+        self._restore_SessionState_metadata(session.metadata, session_repr)
+        logger.debug(_("restored metadata %r"), session.metadata)
         logger.debug(_("Starting to restore desired job list..."))
         self._restore_SessionState_desired_job_list(session, session_repr)
         logger.debug(_("Starting to restore job list..."))
@@ -372,29 +570,6 @@
             session.update_job_result(job, result_list[-1])
 
     @classmethod
-    def _restore_SessionState_metadata(cls, session, session_repr):
-        """
-        Extract meta-data information from the representation of the session
-        and set it in the given session object
-        """
-        # Get the representation of the meta-data
-        metadata_repr = _validate(
-            session_repr, key='metadata', value_type=dict)
-        # Set each bit back to the session
-        session.metadata.title = _validate(
-            metadata_repr, key='title', value_type=str, value_none=True)
-        session.metadata.flags = set([
-            _validate(
-                flag, value_type=str,
-                value_type_msg=_("Each flag must be a string"))
-            for flag in _validate(
-                metadata_repr, key='flags', value_type=list)])
-        session.metadata.running_job_name = _validate(
-            metadata_repr, key='running_job_name', value_type=str,
-            value_none=True)
-        logger.debug(_("restored metadata %r"), session.metadata)
-
-    @classmethod
     def _restore_SessionState_desired_job_list(cls, session, session_repr):
         """
         Extract the representation of desired_job_list from the session and
@@ -512,6 +687,44 @@
         return IOLogRecord(delay, stream_name, data)
 
 
+class SessionResumeHelper2(MetaDataHelper2MixIn, SessionResumeHelper1):
+    """
+    Helper class for implementing session resume feature
+
+    This class works with data constructed by
+    :class:`~plainbox.impl.session.suspend.SessionSuspendHelper2` which has
+    been pre-processed by :class:`SessionResumeHelper` (to strip the initial
+    envelope).
+
+    Due to the constraints of what can be represented in a suspended session,
+    this class cannot work in isolation. It must operate with a list of know
+    jobs.
+
+    Since (most of the) jobs are being provided externally (as they represent
+    the non-serialized parts of checkbox or other job providers) several
+    failure modes are possible. Those are documented in :meth:`resume()`
+    """
+
+
+class SessionResumeHelper3(MetaDataHelper3MixIn, SessionResumeHelper2):
+    """
+    Helper class for implementing session resume feature
+
+    This class works with data constructed by
+    :class:`~plainbox.impl.session.suspend.SessionSuspendHelper3` which has
+    been pre-processed by :class:`SessionResumeHelper` (to strip the initial
+    envelope).
+
+    Due to the constraints of what can be represented in a suspended session,
+    this class cannot work in isolation. It must operate with a list of know
+    jobs.
+
+    Since (most of the) jobs are being provided externally (as they represent
+    the non-serialized parts of checkbox or other job providers) several
+    failure modes are possible. Those are documented in :meth:`resume()`
+    """
+
+
 def _validate(obj, **flags):
     """
     Multi-purpose extraction and validation function.
@@ -556,120 +769,3 @@
                     obj_name, value_choice))
             raise CorruptedSessionError(error_msg)
     return value
-
-
-class SessionResumeHelper2(SessionResumeHelper1):
-    """
-    Helper class for implementing session resume feature
-
-    This class works with data constructed by
-    :class:`~plainbox.impl.session.suspend.SessionSuspendHelper2` which has
-    been pre-processed by :class:`SessionResumeHelper` (to strip the initial
-    envelope).
-
-    Due to the constraints of what can be represented in a suspended session,
-    this class cannot work in isolation. It must operate with a list of know
-    jobs.
-
-    Since (most of the) jobs are being provided externally (as they represent
-    the non-serialized parts of checkbox or other job providers) several
-    failure modes are possible. Those are documented in :meth:`resume()`
-    """
-
-    @classmethod
-    def _restore_SessionState_metadata(cls, session, session_repr):
-        """
-        Extract meta-data information from the representation of the session
-        and set it in the given session object
-        """
-        # Get the representation of the meta-data
-        metadata_repr = _validate(
-            session_repr, key='metadata', value_type=dict)
-        # Set each bit back to the session
-        session.metadata.title = _validate(
-            metadata_repr, key='title', value_type=str, value_none=True)
-        session.metadata.flags = set([
-            _validate(
-                flag, value_type=str,
-                value_type_msg=_("Each flag must be a string"))
-            for flag in _validate(
-                metadata_repr, key='flags', value_type=list)])
-        session.metadata.running_job_name = _validate(
-            metadata_repr, key='running_job_name', value_type=str,
-            value_none=True)
-        app_blob = _validate(
-            metadata_repr, key='app_blob', value_type=str,
-            value_none=True)
-        if app_blob is not None:
-            try:
-                app_blob = app_blob.encode("ASCII")
-            except UnicodeEncodeError:
-                # TRANSLATORS: please don't translate app_blob
-                raise CorruptedSessionError(_("app_blob is not ASCII"))
-            try:
-                app_blob = base64.standard_b64decode(app_blob)
-            except binascii.Error:
-                # TRANSLATORS: please don't translate app_blob
-                raise CorruptedSessionError(_("Cannot base64 decode app_blob"))
-        session.metadata.app_blob = app_blob
-        logger.debug(_("restored metadata %r"), session.metadata)
-
-
-class SessionResumeHelper3(SessionResumeHelper2):
-    """
-    Helper class for implementing session resume feature
-
-    This class works with data constructed by
-    :class:`~plainbox.impl.session.suspend.SessionSuspendHelper3` which has
-    been pre-processed by :class:`SessionResumeHelper` (to strip the initial
-    envelope).
-
-    Due to the constraints of what can be represented in a suspended session,
-    this class cannot work in isolation. It must operate with a list of know
-    jobs.
-
-    Since (most of the) jobs are being provided externally (as they represent
-    the non-serialized parts of checkbox or other job providers) several
-    failure modes are possible. Those are documented in :meth:`resume()`
-    """
-
-    @classmethod
-    def _restore_SessionState_metadata(cls, session, session_repr):
-        """
-        Extract meta-data information from the representation of the session
-        and set it in the given session object
-        """
-        # Get the representation of the meta-data
-        metadata_repr = _validate(
-            session_repr, key='metadata', value_type=dict)
-        # Set each bit back to the session
-        session.metadata.title = _validate(
-            metadata_repr, key='title', value_type=str, value_none=True)
-        session.metadata.flags = set([
-            _validate(
-                flag, value_type=str,
-                value_type_msg=_("Each flag must be a string"))
-            for flag in _validate(
-                metadata_repr, key='flags', value_type=list)])
-        session.metadata.running_job_name = _validate(
-            metadata_repr, key='running_job_name', value_type=str,
-            value_none=True)
-        app_blob = _validate(
-            metadata_repr, key='app_blob', value_type=str,
-            value_none=True)
-        if app_blob is not None:
-            try:
-                app_blob = app_blob.encode("ASCII")
-            except UnicodeEncodeError:
-                # TRANSLATORS: please don't translate app_blob
-                raise CorruptedSessionError(_("app_blob is not ASCII"))
-            try:
-                app_blob = base64.standard_b64decode(app_blob)
-            except binascii.Error:
-                # TRANSLATORS: please don't translate app_blob
-                raise CorruptedSessionError(_("Cannot base64 decode app_blob"))
-        session.metadata.app_blob = app_blob
-        session.metadata.app_id = _validate(
-            metadata_repr, key='app_id', value_type=str,
-            value_none=True)
-        logger.debug(_("restored metadata %r"), session.metadata)
 
=== modified file 'plainbox/plainbox/impl/session/storage.py'
--- plainbox/plainbox/impl/session/storage.py	2014-02-20 21:43:55 +0000
+++ plainbox/plainbox/impl/session/storage.py	2014-04-30 19:25:48 +0000
@@ -206,6 +206,13 @@
         return self._location
 
     @property
+    def id(self):
+        """
+        identifier of the session storage (name of the random directory)
+        """
+        return os.path.splitext(os.path.basename(self.location))[0]
+
+    @property
     def session_file(self):
         """
         pathname of the session state file
@@ -404,6 +411,11 @@
                 # Close the session file
                 logger.debug(_("Closed descriptor %d"), session_fd)
                 os.close(session_fd)
+        except IOError as exc:
+            if exc.errno == errno.ENOENT:
+                # Treat lack of 'session' file as an empty file
+                return b''
+            raise
         finally:
             # Close the location directory
             logger.debug(_("Closed descriptor %d"), location_fd)
@@ -427,6 +439,11 @@
             finally:
                 # Close the session file
                 os.close(session_fd)
+        except IOError as exc:
+            if exc.errno == errno.ENOENT:
+                # Treat lack of 'session' file as an empty file
+                return b''
+            raise
         finally:
             # Close the location directory
             os.close(location_fd)
 
=== modified file 'plainbox/plainbox/impl/session/test_resume.py'
--- plainbox/plainbox/impl/session/test_resume.py	2014-03-26 20:01:03 +0000
+++ plainbox/plainbox/impl/session/test_resume.py	2014-04-30 19:25:48 +0000
@@ -957,7 +957,7 @@
         """
         with self.assertRaises(CorruptedSessionError) as boom:
             self.good_repr['metadata'] = 1
-            self.resume_fn(self.session, self.good_repr)
+            self.resume_fn(self.session.metadata, self.good_repr)
         self.assertEqual(
             str(boom.exception),
             "Value of key 'metadata' is of incorrect type int")
@@ -969,7 +969,7 @@
         """
         with self.assertRaises(CorruptedSessionError) as boom:
             self.good_repr['metadata']['title'] = 1
-            self.resume_fn(self.session, self.good_repr)
+            self.resume_fn(self.session.metadata, self.good_repr)
         self.assertEqual(
             str(boom.exception),
             "Value of key 'title' is of incorrect type int")
@@ -980,7 +980,7 @@
         ``title`` to be None
         """
         self.good_repr['metadata']['title'] = None
-        self.resume_fn(self.session, self.good_repr)
+        self.resume_fn(self.session.metadata, self.good_repr)
         self.assertEqual(self.session.metadata.title, None)
 
     def test_restore_SessionState_metadata_restores_title(self):
@@ -988,7 +988,7 @@
         verify that _restore_SessionState_metadata() restores ``title``
         """
         self.good_repr['metadata']['title'] = "a title"
-        self.resume_fn(self.session, self.good_repr)
+        self.resume_fn(self.session.metadata, self.good_repr)
         self.assertEqual(self.session.metadata.title, "a title")
 
     def test_restore_SessionState_metadata_checks_flags_type(self):
@@ -998,7 +998,7 @@
         """
         with self.assertRaises(CorruptedSessionError) as boom:
             self.good_repr['metadata']['flags'] = 1
-            self.resume_fn(self.session, self.good_repr)
+            self.resume_fn(self.session.metadata, self.good_repr)
         self.assertEqual(
             str(boom.exception),
             "Value of key 'flags' is of incorrect type int")
@@ -1010,7 +1010,7 @@
         """
         with self.assertRaises(CorruptedSessionError) as boom:
             self.good_repr['metadata']['flags'] = None
-            self.resume_fn(self.session, self.good_repr)
+            self.resume_fn(self.session.metadata, self.good_repr)
         self.assertEqual(
             str(boom.exception),
             "Value of key 'flags' cannot be None")
@@ -1022,7 +1022,7 @@
         """
         with self.assertRaises(CorruptedSessionError) as boom:
             self.good_repr['metadata']['flags'] = [1]
-            self.resume_fn(self.session, self.good_repr)
+            self.resume_fn(self.session.metadata, self.good_repr)
         self.assertEqual(
             str(boom.exception),
             "Each flag must be a string")
@@ -1032,7 +1032,7 @@
         verify that _restore_SessionState_metadata() restores ``flags``
         """
         self.good_repr['metadata']['flags'] = ["flag1", "flag2"]
-        self.resume_fn(self.session, self.good_repr)
+        self.resume_fn(self.session.metadata, self.good_repr)
         self.assertEqual(self.session.metadata.flags, set(['flag1', 'flag2']))
 
     def test_restore_SessionState_metadata_checks_running_job_name_type(self):
@@ -1042,7 +1042,7 @@
         """
         with self.assertRaises(CorruptedSessionError) as boom:
             self.good_repr['metadata']['running_job_name'] = 1
-            self.resume_fn(self.session, self.good_repr)
+            self.resume_fn(self.session.metadata, self.good_repr)
         self.assertEqual(
             str(boom.exception),
             "Value of key 'running_job_name' is of incorrect type int")
@@ -1053,7 +1053,7 @@
         ``running_job_name`` to be None
         """
         self.good_repr['metadata']['running_job_name'] = None
-        self.resume_fn(self.session, self.good_repr)
+        self.resume_fn(self.session.metadata, self.good_repr)
         self.assertEqual(self.session.metadata.running_job_name, None)
 
     def test_restore_SessionState_metadata_restores_running_job_name(self):
@@ -1062,7 +1062,7 @@
         the value of ``running_job_name``
         """
         self.good_repr['metadata']['running_job_name'] = "a job"
-        self.resume_fn(self.session, self.good_repr)
+        self.resume_fn(self.session.metadata, self.good_repr)
         self.assertEqual(self.session.metadata.running_job_name, "a job")
 
 
@@ -1093,7 +1093,7 @@
         with self.assertRaises(CorruptedSessionError) as boom:
             obj_repr = copy.copy(self.good_repr)
             obj_repr['metadata']['app_blob'] = 1
-            self.resume_fn(self.session, obj_repr)
+            self.resume_fn(self.session.metadata, obj_repr)
         self.assertEqual(
             str(boom.exception),
             "Value of key 'app_blob' is of incorrect type int")
@@ -1105,7 +1105,7 @@
         """
         obj_repr = copy.copy(self.good_repr)
         obj_repr['metadata']['app_blob'] = None
-        self.resume_fn(self.session, obj_repr)
+        self.resume_fn(self.session.metadata, obj_repr)
         self.assertEqual(self.session.metadata.app_blob, None)
 
     def test_restore_SessionState_metadata_restores_app_blob(self):
@@ -1114,7 +1114,7 @@
         """
         obj_repr = copy.copy(self.good_repr)
         obj_repr['metadata']['app_blob'] = "YmxvYg=="
-        self.resume_fn(self.session, obj_repr)
+        self.resume_fn(self.session.metadata, obj_repr)
         self.assertEqual(self.session.metadata.app_blob, b"blob")
 
     def test_restore_SessionState_metadata_non_ascii_app_blob(self):
@@ -1125,7 +1125,7 @@
         with self.assertRaises(CorruptedSessionError) as boom:
             obj_repr = copy.copy(self.good_repr)
             obj_repr['metadata']['app_blob'] = '\uFFFD'
-            self.resume_fn(self.session, obj_repr)
+            self.resume_fn(self.session.metadata, obj_repr)
         self.assertEqual(str(boom.exception), "app_blob is not ASCII")
         self.assertIsInstance(boom.exception.__context__, UnicodeEncodeError)
 
@@ -1137,7 +1137,7 @@
         with self.assertRaises(CorruptedSessionError) as boom:
             obj_repr = copy.copy(self.good_repr)
             obj_repr['metadata']['app_blob'] = '==broken'
-            self.resume_fn(self.session, obj_repr)
+            self.resume_fn(self.session.metadata, obj_repr)
         self.assertEqual(str(boom.exception), "Cannot base64 decode app_blob")
         # base64.standard_b64decode() raises binascii.Error
         self.assertIsInstance(boom.exception.__context__, binascii.Error)
@@ -1171,7 +1171,7 @@
         with self.assertRaises(CorruptedSessionError) as boom:
             obj_repr = copy.copy(self.good_repr)
             obj_repr['metadata']['app_id'] = 1
-            self.resume_fn(self.session, obj_repr)
+            self.resume_fn(self.session.metadata, obj_repr)
         self.assertEqual(
             str(boom.exception),
             "Value of key 'app_id' is of incorrect type int")
@@ -1183,7 +1183,7 @@
         """
         obj_repr = copy.copy(self.good_repr)
         obj_repr['metadata']['app_id'] = None
-        self.resume_fn(self.session, obj_repr)
+        self.resume_fn(self.session.metadata, obj_repr)
         self.assertEqual(self.session.metadata.app_id, None)
 
     def test_restore_SessionState_metadata_restores_app_id(self):
@@ -1192,7 +1192,7 @@
         """
         obj_repr = copy.copy(self.good_repr)
         obj_repr['metadata']['app_id'] = "id"
-        self.resume_fn(self.session, obj_repr)
+        self.resume_fn(self.session.metadata, obj_repr)
         self.assertEqual(self.session.metadata.app_id, "id")