Merge lp:~kissiel/checkbox/sa-in-cbt into lp:checkbox

[Maciej Kisielewski]

This MR brings a small revolution to Checkbox {Touch,Converged}.

It replaces all the internal logic related to running plainbox core with calls to SessionAssistant.
It also smuggles some fixes to SessionAssistant along the way.
Then, it makes Autopilot happy with the New Order,
to finally clean up pep8 issues, embetter existing and add missing docstrings.

a6b1280 checkbox-touch: run run_test_activity for ALL plugins
e30f8f1 checkbox-touch: [move2SA] use SA in __init__
7de6bda checkbox-touch: [move2SA] use SA in start_session
861c36a checkbox-touch: [move2SA] use SA in is_session_resumable
bedf971 checkbox-touch: [move2SA] use SA in get_testplans
7e1e3a2 checkbox-touch: [move2SA] use SA in remember_testplan
037f79a checkbox-touch: [move2SA] use SA in get_categories
a853d86 checkbox-touch: [move2SA] use SA in remember_categories
9e08a76 checkbox-touch: [move2SA] use SA in get_available tests
2fe8eeb checkbox-touch: [move2SA] use SA in get_rerun_candidates
2fcc534 checkbox-touch: [move2SA] use SA in remember_tests
3a6c5cb checkbox-touch: [move2SA] use SA in get_next_test
d8fc496 checkbox-touch: [move2SA] use SA in register_test_result
2fd2af9 checkbox-touch: [move2SA] use SA in run_test_activity
952d973 checkbox-touch: [move2SA] use SA in get_results
225b491 checkbox-touch: [move2SA] use SA in export_results
f66a3b6 checkbox-touch: add timestamp to app_blob
dfce594 checkbox-touch: [move2SA] remove _checkpoint method
d3f7f14 checkbox-touch: add a method for loading embedded providers
85e9416 checkbox-touch:autopilot: rearrange order of full-scenario to match SA sorting
e507f79 plainbox:session:assistant: correct UsageExpectations after session is started
a0e3297 plainbox:session:assistant: allow export_to_file call in 'normal' state
37153b4 checkbox-touch: move embedded providers stuff to CBTApp.__init__
41c813e plainbox:session:assistant: require select_test_plan after resume
73adaa6 plainbox:session:assistant: add finalize_session method
db9146c checkbox-touch:[move2SA] use SA in clear_session
d24664e checkbox-touch: remove unnecessary methods
e45942c checkbox-touch: remove import of no longer used modules
dc61ce2 checkbox-touch: fix PEP8 issues
70148a8 checkbox-touch: upgrade docstrings

[Zygmunt Krynicki (zyga)]

let there be light

review: Approve

=== modified file 'checkbox-touch/checkbox-touch.qml'
--- checkbox-touch/checkbox-touch.qml	2015-08-18 12:59:01 +0000
+++ checkbox-touch/checkbox-touch.qml	2015-08-31 12:00:21 +0000
@@ -155,7 +155,7 @@
                 "checkbox_touch" : applicationVersion,
                 "plainbox" : plainboxVersion
             };
-            resumeOrStartSession(appSettings["providersDir"]);
+            resumeOrStartSession();
         }
         onSessionReady: {
             welcomePage.enableButton()
@@ -163,7 +163,8 @@
         Component.onCompleted: {
             // register to py.initiated signal
             py.onInitiated.connect(function() {
-                construct("checkbox_touch.create_app_object", []);
+                construct("checkbox_touch.create_app_object", [
+                    appSettings["providersDir"]]);
             });
         }
     }
@@ -267,14 +268,14 @@
 
     ResumeSessionPage {
         id: resumeSessionPage
-        onRerunLast: app.resumeSession(true, appSettings["providersDir"], processNextTest)
-        onContinueSession: app.resumeSession(false, appSettings["providersDir"], processNextTest)
+        onRerunLast: app.resumeSession(true, processNextTest)
+        onContinueSession: app.resumeSession(false, processNextTest)
         resumeText: i18n.tr("Checkbox did not finish completely.\nDo you want \
  to rerun last test, continue to the next test, or restart from the beginning?")
         onRestartSession: {
             pageStack.clear();
             pageStack.push(welcomePage);
-            app.startSession(appSettings["providersDir"]);
+            app.startSession();
         }
     }
 
@@ -407,10 +408,10 @@
             } else {
                 if (result.errors_encountered) {
                     ErrorLogic.showError(mainView, i18n.tr("Could not resume session."),
-                                         app.startSession(appSettings["providersDir"]),
+                                         app.startSession(),
                                          i18n.tr("Start new session"));
                 } else {
-                    app.startSession(appSettings["providersDir"]);
+                    app.startSession();
                 }
             }
         });
@@ -502,7 +503,7 @@
             resultsPage.endTesting.connect(function() {
                 pageStack.clear();
                 app.clearSession(function() {
-                    app.startSession(appSettings["providersDir"]);
+                    app.startSession();
                     pageStack.push(welcomePage);
                 });
             });
@@ -535,13 +536,15 @@
     }
 
     function performManualTest(test) {
-        var manualIntroPage = Qt.createComponent(Qt.resolvedUrl("components/ManualIntroPage.qml")).createObject();
-        manualIntroPage.test = test
-        manualIntroPage.testDone.connect(completeTest);
-        manualIntroPage.continueClicked.connect(function() { showVerificationScreen(test); });
-        manualIntroPage.__customHeaderContents = progressHeader;
-        progressHeader.update(test);
-        pageStack.push(manualIntroPage);
+        runTestActivity(test, function(test) {
+            var manualIntroPage = Qt.createComponent(Qt.resolvedUrl("components/ManualIntroPage.qml")).createObject();
+            manualIntroPage.test = test
+            manualIntroPage.testDone.connect(completeTest);
+            manualIntroPage.continueClicked.connect(function() { showVerificationScreen(test); });
+            manualIntroPage.__customHeaderContents = progressHeader;
+            progressHeader.update(test);
+            pageStack.push(manualIntroPage);
+        });
     }
 
     function performUserInteractVerifyTest(test) {
@@ -592,25 +595,29 @@
     }
 
     function performQmlTest(test) {
-        var comp = Qt.createComponent(Qt.resolvedUrl("components/QmlNativePage.qml"))
-        console.log(comp.errorString());
-        var qmlNativePage = comp.createObject();
-        qmlNativePage.test = test
-        qmlNativePage.testDone.connect(completeTest);
-        qmlNativePage.__customHeaderContents = progressHeader;
-        progressHeader.update(test);
-        pageStack.push(qmlNativePage);
+        runTestActivity(test, function(test) {
+            var comp = Qt.createComponent(Qt.resolvedUrl("components/QmlNativePage.qml"))
+            console.log(comp.errorString());
+            var qmlNativePage = comp.createObject();
+            qmlNativePage.test = test
+            qmlNativePage.testDone.connect(completeTest);
+            qmlNativePage.__customHeaderContents = progressHeader;
+            progressHeader.update(test);
+            pageStack.push(qmlNativePage);
+        });
     }
     function performConfinedQmlTest(test) {
-        var comp = Qt.createComponent(Qt.resolvedUrl("components/QmlConfinedPage.qml"))
-        console.log(comp.errorString());
-        var qmlNativePage = comp.createObject();
-        qmlNativePage.test = test
-        qmlNativePage.applicationVersion = app.applicationVersion;
-        qmlNativePage.testDone.connect(completeTest);
-        qmlNativePage.__customHeaderContents = progressHeader;
-        progressHeader.update(test);
-        pageStack.push(qmlNativePage);
+        runTestActivity(test, function(test) {
+            var comp = Qt.createComponent(Qt.resolvedUrl("components/QmlConfinedPage.qml"))
+            console.log(comp.errorString());
+            var qmlNativePage = comp.createObject();
+            qmlNativePage.test = test
+            qmlNativePage.applicationVersion = app.applicationVersion;
+            qmlNativePage.testDone.connect(completeTest);
+            qmlNativePage.__customHeaderContents = progressHeader;
+            progressHeader.update(test);
+            pageStack.push(qmlNativePage);
+        });
     }
 
     function showVerificationScreen(test) {
 
=== modified file 'checkbox-touch/components/CheckboxTouchApplication.qml'
--- checkbox-touch/components/CheckboxTouchApplication.qml	2015-07-29 20:50:05 +0000
+++ checkbox-touch/components/CheckboxTouchApplication.qml	2015-08-31 12:00:21 +0000
@@ -45,8 +45,8 @@
     // Starts session in plainbox and runs all necessary setup actions.
     // Calling this function will signal sessionReady() once it's finished
     // doing setup.
-    function startSession(providersDir) {
-        request("start_session", [providersDir], function(result) {
+    function startSession() {
+        request("start_session", [], function(result) {
             sessionDir = result['session_dir'];
             sessionReady();
         }, function(error) {
@@ -57,8 +57,8 @@
                                  i18n.tr("Quit"));
         });
     }
-    function resumeSession(rerunLastTest, providersDir, continuation) {
-        request("resume_session", [rerunLastTest, providersDir], function(result) {
+    function resumeSession(rerunLastTest, continuation) {
+        request("resume_session", [rerunLastTest], function(result) {
             if (!result["session_id"]) {
                 pageStack.pop();
                 ErrorLogic.showError(mainView,
 
=== modified file 'checkbox-touch/py/checkbox_touch.py'
--- checkbox-touch/py/checkbox_touch.py	2015-07-31 13:07:18 +0000
+++ checkbox-touch/py/checkbox_touch.py	2015-08-31 12:00:21 +0000
@@ -32,7 +32,6 @@
 import abc
 import collections
 import datetime
-import itertools
 import json
 import logging
 import os
@@ -43,23 +42,10 @@
 
 from plainbox.abc import IJobResult
 from plainbox.impl import pod
-from plainbox.impl.applogic import PlainBoxConfig
 from plainbox.impl.clitools import ToolBase
 from plainbox.impl.commands.inv_run import SilentUI
 from plainbox.impl.result import JobResultBuilder
-from plainbox.impl.runner import JobRunner
-from plainbox.impl.secure.origin import Origin
-from plainbox.impl.secure.qualifiers import FieldQualifier
-from plainbox.impl.secure.qualifiers import OperatorMatcher
-from plainbox.impl.secure.qualifiers import select_jobs
-from plainbox.impl.session import SessionManager
-from plainbox.impl.session import SessionMetaData
-from plainbox.impl.session import SessionPeekHelper
-from plainbox.impl.session import SessionResumeError
-from plainbox.impl.session.storage import SessionStorageRepository
-from plainbox.impl.unit.job import JobDefinition
-from plainbox.impl.unit.validators import compute_value_map
-from plainbox.public import get_providers
+from plainbox.impl.session.assistant import SessionAssistant
 import plainbox
 
 from embedded_providers import EmbeddedProvider1PlugInCollection
@@ -149,25 +135,22 @@
 
     __version__ = (1, 2, 1, 'final', 0)
 
-    def __init__(self):
+    def __init__(self, providers_dir):
         if plainbox.__version__ < (0, 22):
             raise SystemExit("plainbox 0.22 required, you have {}".format(
                 ToolBase.format_version_tuple(plainbox.__version__)))
-        # adjust_logging(logging.INFO, ['checkbox.touch'], True)
-        self.manager = None
-        self.context = None
-        self.runner = None
-        self.index = 0  # NOTE: next test index
-        # NOTE: This may also have "" representing None
-        self.desired_category_ids = frozenset()
-        self.desired_test_ids = frozenset()
-        self.test_plan_id = ""
-        self.resume_candidate_storage = None
-        self.session_storage_repo = None
-        self.timestamp = datetime.datetime.utcnow().isoformat()
-        self.config = PlainBoxConfig()
+        self.assistant = SessionAssistant('checkbox-converged')
+        self.ui = CheckboxTouchUI()
+        self.index = 0
         self._password = None
-        self.ui = CheckboxTouchUI()
+        self._timestamp = None
+        self._latest_session = None
+        self.resume_candidate_storage = None
+        self.assistant.use_alternate_repository(
+            self._get_app_cache_directory())
+        self.assistant.select_providers(
+            '*',
+            additional_providers=self._get_embedded_providers(providers_dir))
 
     def __repr__(self):
         return "app"
@@ -182,186 +165,101 @@
         }
 
     @view
-    def start_session(self, providers_dir):
-        if self.manager is not None:
-            _logger.warning("start_session() should not be called twice!")
-        else:
-            self._init_session_storage_repo()
-            self.manager = SessionManager.create(self.session_storage_repo)
-            self.manager.add_local_device_context()
-            self.context = self.manager.default_device_context
-            # Add some all providers into the context
-            for provider in self._get_default_providers(providers_dir):
-                self.context.add_provider(provider)
-            # Fill in the meta-data
-            self.context.state.metadata.app_id = 'checkbox-touch'
-            self.context.state.metadata.title = 'Checkbox Touch Session'
-            self.context.state.metadata.flags.add('bootstrapping')
-            # Checkpoint the session so that we have something to see
-            self._checkpoint()
-
-            # Prepare custom execution controller list
-            from plainbox.impl.ctrl import UserJobExecutionController
-            from sudo_with_pass_ctrl import \
-                RootViaSudoWithPassExecutionController
-            controllers = [
-                RootViaSudoWithPassExecutionController(
-                    self.context.provider_list, self._password_provider),
-                UserJobExecutionController(self.context.provider_list),
-            ]
-            self.runner = JobRunner(
-                self.manager.storage.location,
-                self.context.provider_list,
-                # TODO: tie this with well-known-dirs helper
-                os.path.join(self.manager.storage.location, 'io-logs'),
-                execution_ctrl_list=controllers)
-        app_cache_dir = self._get_app_cache_directory()
-        if not os.path.exists(app_cache_dir):
-            os.makedirs(app_cache_dir)
-        with open(os.path.join(app_cache_dir, 'session_id'),
-                  'w') as f:
-            f.write(self.manager.storage.id)
+    def start_session(self):
+        """Start a new session."""
+        self.assistant.start_new_session('Checkbox Converged session')
+        self._timestamp = datetime.datetime.utcnow().isoformat()
         return {
-            'session_id': self.manager.storage.id,
-            'session_dir': self.manager.storage.location
+            'session_id': self.assistant.get_session_id(),
+            'session_dir': self.assistant.get_session_dir()
         }
 
     @view
-    def resume_session(self, rerun_last_test, providers_dir):
-        all_units = list(itertools.chain(
-            *[p.unit_list for p in self._get_default_providers(
-                providers_dir)]))
-        try:
-            self.manager = SessionManager.load_session(
-                all_units, self.resume_candidate_storage)
-        except IOError as exc:
-            _logger.info("Exception raised when trying to resume"
-                         "session: %s", str(exc))
-            return {
-                'session_id': None
-            }
-        self.context = self.manager.default_device_context
-        metadata = self.context.state.metadata
+    def resume_session(self, rerun_last_test):
+        """
+        Resume latest sesssion.
+
+        :param rerun_last_test:
+            A bool stating whether runtime should repeat the test, that the app
+            was executing when it was interrupted.
+        """
+        metadata = self.assistant.resume_session(self._latest_session)
         app_blob = json.loads(metadata.app_blob.decode("UTF-8"))
-        self.runner = JobRunner(
-            self.manager.storage.location,
-            self.context.provider_list,
-            os.path.join(self.manager.storage.location, 'io-logs'))
         self.index = app_blob['index_in_run_list']
-        self._init_test_plan_id(app_blob['test_plan_id'])
-        _logger.error(self.context.state.run_list)
-        _logger.error(self.index)
+        self.test_plan_id = app_blob['test_plan_id']
+        self.assistant.select_test_plan(self.test_plan_id)
+        self.assistant.bootstrap()
+
         if not rerun_last_test:
             # Skip current test
             test = self.get_next_test()['result']
             test['outcome'] = 'skip'
             self.register_test_result(test)
         return {
-            'session_id': self.manager.storage.id
+            'session_id': self._latest_session
         }
 
     @view
     def clear_session(self):
-        self.manager = None
-        self.context = None
-        self.runner = None
+        """Reset app-custom state info about the session."""
         self.index = 0
-        self.timestamp = datetime.datetime.utcnow().isoformat()
-        self.desired_category_ids = frozenset()
-        self.desired_test_ids = frozenset()
-        self.resume_candidate_storage = None
-        self.session_storage_repo = None
-        os.unlink(os.path.join(self._get_app_cache_directory(), 'session_id'))
+        self._timestamp = datetime.datetime.utcnow().isoformat()
 
     @view
     def is_session_resumable(self):
-        """
-        Checks whether given session is resumable
-        """
-        resumable = False
-        try:
-            with open(os.path.join(self._get_app_cache_directory(),
-                      'session_id')) as f:
-                session_id = f.readline().rstrip('\n')
-        except (OSError, IOError):
-            session_id = None
-        self._init_session_storage_repo()
-        for storage in self.session_storage_repo.get_storage_list():
-            data = storage.load_checkpoint()
-            if len(data) == 0:
-                continue
-            try:
-                metadata = SessionPeekHelper().peek(data)
-                if (metadata.app_id == 'checkbox-touch'
-                        and storage.id == session_id
-                        and SessionMetaData.FLAG_INCOMPLETE in
-                        metadata.flags):
-                    self.resume_candidate_storage = storage
-                    resumable = True
-            except SessionResumeError as exc:
-                _logger.info("Exception raised when trying to resume"
-                             "session: %s", str(exc))
-                return {
-                    'resumable': False,
-                    'errors_encountered': True
-                }
-        return {
-            'resumable': resumable,
-            'errors_encountered': False
-        }
+        """Check whether there is a session that can be resumed."""
+        for session_id, session_md in self.assistant.get_resumable_sessions():
+            # we're interested in the latest session only, this is why we
+            # return early
+            self._latest_session = session_id
+            return {
+                'resumable': True,
+                'error_encountered': False,
+            }
+        else:
+            return {
+                'resumable': False,
+                'error_encountered': False,
+            }
 
     @view
     def get_testplans(self):
-        all_units = self.manager.default_device_context.unit_list
+        """Get the list of available test plans."""
+        test_plan_units = [self.assistant.get_test_plan(tp_id) for tp_id in
+                           self.assistant.get_test_plans()]
         return {
             'testplan_info_list': [{
-                "mod_id": unit.id,
-                "mod_name": unit.name,
+                "mod_id": tp.id,
+                "mod_name": tp.name,
                 "mod_selected": False,
-            } for unit in all_units if unit.Meta.name == 'test plan']
+            } for tp in test_plan_units]
         }
 
     @view
     def remember_testplan(self, test_plan_id):
-        self.context.invalidate_shared('potential_job_list')
-        self.context.invalidate_shared('potential_category_map')
-        self._init_test_plan_id(test_plan_id)
+        """Pick the test plan as the one in force."""
+        self.test_plan_id = test_plan_id
+        self.assistant.select_test_plan(test_plan_id)
+        self.assistant.bootstrap()
 
     @view
     def get_categories(self):
-        """
-        Get categories selection data.
-        """
-        potential_job_list = self.context.compute_shared(
-            'potential_job_list', select_jobs,
-            self.context.state.job_list, [self.test_plan.get_qualifier()])
-        potential_category_map = self.context.compute_shared(
-            'potential_category_map',
-            self.test_plan.get_effective_category_map, potential_job_list)
-        id_map = self.context.compute_shared(
-            'id_map', compute_value_map, self.context, 'id')
+        """Get categories selection data."""
         category_info_list = [{
             "mod_id": category.id,
             "mod_name": category.name,
             "mod_selected": True,
         } for category in (
-            id_map[category_id][0]
-            for category_id in set(potential_category_map.values())
+            self.assistant.get_category(category_id)
+            for category_id in self.assistant.get_participating_categories()
         )]
-        category_info_list.sort(key=lambda ci: ci['mod_name'])
-        return {
-            'category_info_list': category_info_list
-        }
+        return {'category_info_list': category_info_list}
 
     @view
     def remember_categories(self, selected_id_list):
-        """
-        Save category selection
-        """
-        self.desired_category_ids = frozenset(selected_id_list)
-        self.context.invalidate_shared('subset_job_list')
-        self.context.invalidate_shared('effective_category_map')
-        _logger.info("Selected categories: %s", self.desired_category_ids)
+        """Save category selection."""
+        _logger.info("Selected categories: %s", selected_id_list)
+        self.assistant.filter_jobs_by_categories(selected_id_list)
 
     @view
     def get_available_tests(self):
@@ -371,89 +269,65 @@
         The response object will contain only tests with category matching
         previously set list. Tests are sorted by (category, name)
         """
-        subset_job_list = self.context.compute_shared(
-            'subset_job_list', select_jobs,
-            self.context.state.job_list, [
-                # Select everything the test plan selected
-                self.test_plan.get_qualifier(),
-                # Except jobs not matching the selected group of categories
-                FieldQualifier(
-                    JobDefinition.Meta.fields.category_id,
-                    OperatorMatcher(not_contains, self.desired_category_ids),
-                    Origin.get_caller_origin(), inclusive=False),
-            ])
-        effective_category_map = self.context.compute_shared(
-            'effective_category_map',
-            self.test_plan.get_effective_category_map, subset_job_list)
-        for job_id, effective_category_id in effective_category_map.items():
-            job_state = self.context.state.job_state_map[job_id]
-            job_state.effective_category_id = effective_category_id
-        id_map = self.context.compute_shared(
-            'id_map', compute_value_map, self.context, 'id')
+        category_names = {
+            cat_id: self.assistant.get_category(cat_id).tr_name() for
+            cat_id in self.assistant.get_participating_categories()}
+        job_units = [self.assistant.get_job(job_id) for job_id in
+                     self.assistant.get_static_todo_list()]
         test_info_list = [{
-            "mod_id": job_id,
-            "mod_name": id_map[job_id][0].tr_summary(),
-            "mod_group": id_map[category_id][0].tr_name(),
+            "mod_id": job.id,
+            "mod_name": job.tr_summary(),
+            "mod_group": category_names[job.category_id],
             "mod_selected": True,
-        } for job_id, category_id in effective_category_map.items()]
+        } for job in job_units]
         test_info_list.sort(key=lambda ti: (ti['mod_group'], ti['mod_name']))
-        return {
-            'test_info_list': test_info_list
-        }
+        return {'test_info_list': test_info_list}
+
     @view
     def get_rerun_candidates(self):
+        """Get all the tests that might be selected for rerunning."""
         def rerun_predicate(job_state):
             return job_state.result.outcome in (
                 IJobResult.OUTCOME_FAIL, IJobResult.OUTCOME_CRASH)
-        id_map = self.context.compute_shared(
-            'id_map', compute_value_map, self.context, 'id')
         rerun_candidates = []
-        for job in self.manager.state.run_list:
-            if rerun_predicate(self.manager.state.job_state_map[job.id]):
+        todo_list = self.assistant.get_static_todo_list()
+        job_units = {job_id: self.assistant.get_job(job_id) for job_id
+                     in todo_list}
+        job_states = {job_id: self.assistant.get_job_state(job_id) for job_id
+                      in todo_list}
+        category_names = {
+            cat_id: self.assistant.get_category(cat_id).tr_name() for cat_id
+            in self.assistant.get_participating_categories()}
+        for job_id, job_state in job_states.items():
+            if rerun_predicate(job_state):
                 rerun_candidates.append({
-                    "mod_id": job.id,
-                    "mod_name": job.tr_summary(),
-                    "mod_group": id_map[job.category_id][0].tr_name(),
+                    "mod_id": job_id,
+                    "mod_name": job_units[job_id].tr_summary(),
+                    "mod_group": category_names[job_units[job_id].category_id],
                     "mod_selected": False
-
                     })
         return rerun_candidates
 
     @view
     def remember_tests(self, selected_id_list):
-        """
-        Save test selection
-        """
-        self.desired_test_ids = frozenset(selected_id_list)
-        _logger.info("Selected tests: %s", self.desired_test_ids)
+        """Save test selection."""
         self.index = 0
-        self.context.invalidate_shared('desired_job_list')
-        desired_job_list = self.context.compute_shared(
-            'desired_job_list', select_jobs,
-            self.context.state.job_list, [
-                # Select everything the test plan selected
-                self.test_plan.get_qualifier(),
-                # Except all the jobs that weren't marked by the user
-                FieldQualifier(
-                    JobDefinition.Meta.fields.id,
-                    OperatorMatcher(not_contains, self.desired_test_ids),
-                    Origin.get_caller_origin(), inclusive=False)])
-        _logger.info("Desired job list: %s", desired_job_list)
-        self.context.state.update_desired_job_list(desired_job_list)
-        _logger.info("Run job list: %s", self.context.state.run_list)
-        self.context.state.metadata.flags.add('incomplete')
-        self._checkpoint()
+        self.assistant.use_alternate_selection(selected_id_list)
+        self.assistant.update_app_blob(self._get_app_blob())
+        _logger.info("Selected tests: %s", selected_id_list)
+        return
 
     @view
     def get_next_test(self):
         """
-        Get next text that is scheduled to run
-        Returns test object or None if all tests are completed
+        Get next text that is scheduled to run.
+
+        :returns:
+        Dictionary resembling JobDefinition or None if all tests are completed
         """
-        if self.index < len(self.context.state.run_list):
-            job = self.context.state.run_list[self.index]
-            job_state = self.context.state.job_state_map[job.id]
-            # support for description field splitted into 3 subfields
+        todo_list = self.assistant.get_static_todo_list()
+        if self.index < len(todo_list):
+            job = self.assistant.get_job(todo_list[self.index])
             description = ""
             if job.tr_purpose() is not None:
                 description = job.tr_purpose() + "\n"
@@ -472,97 +346,65 @@
                 "user": job.user,
                 "qml_file": job.qml_file,
                 "start_time": time.time(),
-                "test_number": self.index,
-                "tests_count": len(self.context.state.run_list),
+                "test_number": todo_list.index(job.id),
+                "tests_count": len(todo_list),
                 "command": job.command,
                 "flags": job.get_flag_set()
             }
-            if not job_state.can_start():
-                test["outcome"] = "skip"
-                test["comments"] = job_state.get_readiness_description()
-                self.register_test_result(test)
-                return self.get_next_test()["result"]
             return test
         else:
             return {}
 
     @view
     def register_test_result(self, test):
-        """
-        Registers outcome of a test
-        """
+        """Registers outcome of a test."""
         _logger.info("Storing test result: %s", test)
         job_id = test['id']
-        job = self.context.state.job_state_map[job_id].job
         builder_kwargs = {
             'outcome': test['outcome'],
-            'comments': test.get('comments', pod.UNSET)
+            'comments': test.get('comments', pod.UNSET),
+            'execution_duration': time.time() - test['start_time']
         }
-        # some result may already have been saved if the job had some activity
-        # to run, i.e. result object is available in the test object
         try:
+            # if we're registering skipped test as an outcome of resuming
+            # session, the result field of the test object will be missing
             builder_kwargs['io_log_filename'] = test['result'].io_log_filename
         except KeyError:
-            builder_kwargs['execution_duration'] = (
-                time.time() - test['start_time'])
+            pass
+
         result = JobResultBuilder(**builder_kwargs).get_result()
-        self.context.state.update_job_result(job, result)
+        self.assistant.use_job_result(job_id, result)
         self.index += 1
-        self._checkpoint()
+        self.assistant.update_app_blob(self._get_app_blob())
 
     @view
     def run_test_activity(self, test):
-        """
-        Run command associated with given test
-        """
-        job_id = test['id']
-        job_state = self.context.state.job_state_map[job_id]
-        job = job_state.job
-        self.context.state.running_job_name = job_id
-        self._checkpoint()
-        try:
-            result = self.runner.run_job(job, job_state, self.config, self.ui)
-        except OSError as exc:
-            result = JobResultBuilder(
-                outcome='fail',
-                comment=str(exc),
-            ).get_result()
-        self.context.state.running_job_name = None
-        self._checkpoint()
-        test['outcome'] = result.outcome
-        test['result'] = result
+        """Run command associated with given test."""
+        plugins_handled_natively = ['qml']
+        res_builder = self.assistant.run_job(
+            test['id'], self.ui, test['plugin'] in plugins_handled_natively)
+        test['outcome'] = res_builder.outcome
+        test['result'] = res_builder
         return test
 
     @view
     def get_results(self):
-        """
-        Get results object
-        """
-        self.context.state.metadata.flags.remove('incomplete')
-        self._checkpoint()
-        stats = collections.defaultdict(int)
-        for job_state in self.context.state.job_state_map.values():
-            stats[job_state.result.outcome] += 1
+        """Get results object."""
+        self.assistant.finalize_session()
+        stats = self.assistant.get_summary()
         return {
             'totalPassed': stats[IJobResult.OUTCOME_PASS],
             'totalFailed': stats[IJobResult.OUTCOME_FAIL],
-            'totalSkipped': stats[IJobResult.OUTCOME_SKIP],
+            'totalSkipped': stats[IJobResult.OUTCOME_SKIP] +
+            stats[IJobResult.OUTCOME_NOT_SUPPORTED]
         }
 
     @view
     def export_results(self, output_format, option_list):
-        """
-        Export results to file
-        """
-        # Export results in the user's Documents directory
+        """Export results to file(s) in the user's 'Documents' directory.."""
         dirname = self._get_user_directory_documents()
-        exporter = self.manager.create_exporter(output_format, option_list)
-        extension = exporter.unit.file_extension
-        filename = ''.join(['submission_', self.timestamp, '.', extension])
-        output_file = os.path.join(dirname, filename)
-        with open(output_file, 'wb') as stream:
-            exporter.dump_from_session_manager(self.manager, stream)
-        return output_file
+        return self.assistant.export_to_file(
+            output_format, option_list, dirname)
 
     def _get_user_directory_documents(self):
         xdg_config_home = os.environ.get('XDG_CONFIG_HOME') or \
@@ -601,11 +443,6 @@
                 raise IOError("{} exists and is not a directory".format(path))
             return path
 
-
-    def _checkpoint(self):
-        self.context.state.metadata.app_blob = self._get_app_blob()
-        self.manager.checkpoint()
-
     def _get_app_blob(self):
         """
         Get json dump of with app-specific blob
@@ -615,51 +452,22 @@
                 'version': 1,
                 'test_plan_id': self.test_plan_id,
                 'index_in_run_list': self.index,
+                'session_timestamp': self._timestamp,
             }).encode("UTF-8")
 
-    def _init_test_plan_id(self, test_plan_id):
-        """
-        Validates and stores test_plan_id
-        """
-        if not isinstance(test_plan_id, str):
-            raise TypeError("test_plan_id must be a string")
-        # Look up the test plan with the specified identifier
-        id_map = self.context.compute_shared(
-            'id_map', compute_value_map, self.context, 'id')
-        try:
-            test_plan = id_map[test_plan_id][0]
-        except KeyError:
-            raise ValueError(
-                "cannot find any unit with id: {!r}".format(test_plan_id))
-        if test_plan.Meta.name != 'test plan':
-            raise ValueError(
-                "unit {!r} is not a test plan".format(test_plan_id))
-        self.test_plan_id = test_plan_id
-        self.test_plan = test_plan
-
-    def _init_session_storage_repo(self):
-        """
-        Init storage repository.
-        """
-        self.session_storage_repo = SessionStorageRepository(
-            self._get_app_cache_directory())
-
-    def _get_default_providers(self, providers_dir):
-        """
-        Get providers
+    def _get_embedded_providers(self, providers_dir):
+        """
+        Get providers included with the app
 
         :param providers_dir:
             Path within application tree from which to load providers
         :returns:
             list of loaded providers
         """
-        provider_list = get_providers()
-        # when running on ubuntu-touch device, APP_DIR env var is present
-        # and points to touch application top directory
+        provider_list = []
         app_root_dir = os.path.normpath(os.getenv(
             'APP_DIR', os.path.join(os.path.dirname(__file__), '..')))
-        path = os.path.join(app_root_dir,
-                            os.path.normpath(providers_dir))
+        path = os.path.join(app_root_dir, os.path.normpath(providers_dir))
         _logger.info("Loading all providers from %s", path)
         if os.path.exists(path):
             embedded_providers = EmbeddedProvider1PlugInCollection(path)
@@ -683,7 +491,7 @@
 
 
 def get_qml_logger(default_level):
-    logging_level = collections.defaultdict(lambda:logging.INFO, {
+    logging_level = collections.defaultdict(lambda: logging.INFO, {
         "debug": logging.DEBUG,
         "warning": logging.WARNING,
         "warn": logging.WARN,
 
=== modified file 'checkbox-touch/tests/autopilot/checkbox_touch/test_checkbox_touch.py'
--- checkbox-touch/tests/autopilot/checkbox_touch/test_checkbox_touch.py	2015-07-23 08:25:48 +0000
+++ checkbox-touch/tests/autopilot/checkbox_touch/test_checkbox_touch.py	2015-08-31 12:00:21 +0000
@@ -62,41 +62,44 @@
         ]
         self.process_sequence_of_clicks_on_pages(next_steps)
         self.skip_test('manualIntroPage')
-        next_steps = [
-            ('userInteractVerifyIntroPage', 'startTestButton'),
-            ('testVerificationPage', 'passButton'),
-            ('userInteractVerifyIntroPage', 'startTestButton'),
-            ('testVerificationPage', 'failButton')
-        ]
-        self.process_sequence_of_clicks_on_pages(next_steps)
-        self.skip_test('userInteractVerifyIntroPage')
-        next_steps = [
-            ('userInteractVerifyIntroPage', 'startTestButton'),
-            ('testVerificationPage', 'passButton'),
-            ('userInteractVerifyIntroPage', 'startTestButton'),
-            ('testVerificationPage', 'failButton')
-        ]
-        self.process_sequence_of_clicks_on_pages(next_steps)
-        self.skip_test('userInteractVerifyIntroPage')
-        next_steps = [
-            ('userInteractVerifyIntroPage', 'startTestButton'),
-            ('userInteractSummary', 'continueButton'),
-            ('userInteractVerifyIntroPage', 'startTestButton'),
-            ('userInteractSummary', 'continueButton'),
-        ]
-        self.process_sequence_of_clicks_on_pages(next_steps)
-        self.skip_test('userInteractVerifyIntroPage')
-        next_steps = [
-            ('userInteractVerifyIntroPage', 'startTestButton'),
-            ('testVerificationPage', 'passButton'),
-        ]
-        self.process_sequence_of_clicks_on_pages(next_steps)
         # now we use long_wait because we have a long test to wait for (>10s)
         self.long_wait_select_single(
-            self.app, objectName='qmlNativePage', visible=True)
+            self.app, objectName='userInteractVerifyIntroPage', visible=True)
+        next_steps = [
+            ('userInteractVerifyIntroPage', 'startTestButton'),
+            ('testVerificationPage', 'passButton'),
+        ]
+        self.process_sequence_of_clicks_on_pages(next_steps)
         next_steps = [
             ('qmlNativePage', 'continueButton'),
             ('qmlTestPage', 'passButton'),
+        ]
+        self.process_sequence_of_clicks_on_pages(next_steps)
+        next_steps = [
+            ('userInteractVerifyIntroPage', 'startTestButton'),
+            ('userInteractSummary', 'continueButton'),
+            ('userInteractVerifyIntroPage', 'startTestButton'),
+            ('userInteractSummary', 'continueButton'),
+        ]
+        self.process_sequence_of_clicks_on_pages(next_steps)
+        self.skip_test('userInteractVerifyIntroPage')
+        next_steps = [
+            ('userInteractVerifyIntroPage', 'startTestButton'),
+            ('testVerificationPage', 'passButton'),
+            ('userInteractVerifyIntroPage', 'startTestButton'),
+            ('testVerificationPage', 'failButton')
+        ]
+        self.process_sequence_of_clicks_on_pages(next_steps)
+        self.skip_test('userInteractVerifyIntroPage')
+        next_steps = [
+            ('userInteractVerifyIntroPage', 'startTestButton'),
+            ('testVerificationPage', 'passButton'),
+            ('userInteractVerifyIntroPage', 'startTestButton'),
+            ('testVerificationPage', 'failButton')
+        ]
+        self.process_sequence_of_clicks_on_pages(next_steps)
+        self.skip_test('userInteractVerifyIntroPage')
+        next_steps = [
             ('rerunSelectionPage', 'continueButton')
         ]
         self.process_sequence_of_clicks_on_pages(next_steps)
 
=== modified file 'plainbox/plainbox/impl/session/assistant.py'
--- plainbox/plainbox/impl/session/assistant.py	2015-08-28 13:11:25 +0000
+++ plainbox/plainbox/impl/session/assistant.py	2015-08-31 12:00:21 +0000
@@ -371,7 +371,10 @@
         self.session_available(self._manager.storage.id)
         _logger.debug("New session created: %s", title)
         UsageExpectation.of(self).allowed_calls = {
-            self.select_test_plan: "select the test plan to execute"
+            self.select_test_plan: "select the test plan to execute",
+            self.get_session_id: "to get the id of currently running session",
+            self.get_session_dir: ("to get the path where current session is"
+                                   "stored"),
         }
 
     @raises(KeyError, UnexpectedMethodCall)
@@ -412,8 +415,9 @@
             execution_ctrl_list=self._execution_ctrl_list)
         self.session_available(self._manager.storage.id)
         _logger.debug("Session resumed: %s", session_id)
-        UsageExpectation.of(self).allowed_calls = (
-            self._get_allowed_calls_in_normal_state())
+        UsageExpectation.of(self).allowed_calls = {
+            self.select_test_plan: "to save test plan selection",
+        }
         return self._resume_candidates[session_id][1]
 
     @raises(UnexpectedMethodCall)
@@ -556,6 +560,8 @@
         to actually allowing the user to know what jobs are available.
         """
         UsageExpectation.of(self).enforce()
+        UsageExpectation.of(self).allowed_calls = (
+            self._get_allowed_calls_in_normal_state())
         return [unit.id for unit in self._context.unit_list
                 if unit.Meta.name == 'test plan']
 
@@ -1036,6 +1042,32 @@
 
         return stats
 
+    @raises(UnexpectedMethodCall)
+    def finalize_session(self) -> None:
+        """
+        Finish the execution of the current session.
+
+        :raises UnexpectedMethodCall:
+            If the call is made at an unexpected time. Do not catch this error.
+            It is a bug in your program. The error message will indicate what
+            is the likely cause.
+
+        Mark the session as complete, which prohibits running (or rerunning)
+        any job.
+        """
+        UsageExpectation.of(self).enforce()
+        if SessionMetaData.FLAG_SUBMITTED not in self._metadata.flags:
+            _logger.warning("Finalizing session that hasn't been submitted "
+                            "anywhere: %s", self._manager.storage.id)
+        self._metadata.flags.remove(SessionMetaData.FLAG_INCOMPLETE)
+        self._manager.checkpoint()
+        UsageExpectation.of(self).allowed_calls = {
+            self.export_to_transport: "to export the results and send them",
+            self.export_to_file: "to export the results to a file",
+            self.get_resumable_sessions: "to get resume candidates",
+            self.start_new_session: "to create a new session",
+        }
+
     @raises(KeyError, TransportError, UnexpectedMethodCall)
     def export_to_transport(
         self, exporter_id: str, transport: ISessionStateTransport
@@ -1186,6 +1218,8 @@
             # XXX: should this be available right off the bat or should we wait
             # until all of the mandatory jobs have been executed.
             self.export_to_transport: "to export the results and send them",
+            self.export_to_file: "to export the results to a file",
+            self.finalize_session: "to mark the session as complete",
         }