Merge lp:~robru/cupstream2distro/exception-tweaks into lp:cupstream2distro

[Robert Bruce Park]

Improve consistency of error handling & logging.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:1195
http://jenkins.qa.ubuntu.com/job/cu2d-choo-choo-ci/889/
Executed test runs:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/cu2d-choo-choo-ci/889/rebuild

review: Approve (continuous-integration)

[lp:~robru/cupstream2distro/exception-tweaks]

1196. By Robert Bruce Park on 2015-11-06

Support NoStatusError everywhere.

1197. By Robert Bruce Park on 2015-11-06

New test.

1198. By Robert Bruce Park on 2015-11-06

Pass the err to status.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1198
http://jenkins.qa.ubuntu.com/job/cu2d-choo-choo-ci/890/
Executed test runs:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/cu2d-choo-choo-ci/890/rebuild

review: Needs Fixing (continuous-integration)

[lp:~robru/cupstream2distro/exception-tweaks]

1199. By Robert Bruce Park on 2015-11-06

Logging tweaks.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1199
http://jenkins.qa.ubuntu.com/job/cu2d-choo-choo-ci/891/
Executed test runs:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/cu2d-choo-choo-ci/891/rebuild

review: Needs Fixing (continuous-integration)

[lp:~robru/cupstream2distro/exception-tweaks]

1200. By Robert Bruce Park on 2015-11-06

Unify merge_clean.main and publisher.main.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:1200
http://jenkins.qa.ubuntu.com/job/cu2d-choo-choo-ci/892/
Executed test runs:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/cu2d-choo-choo-ci/892/rebuild

review: Approve (continuous-integration)

[lp:~robru/cupstream2distro/exception-tweaks]

1201. By Robert Bruce Park on 2015-11-06

Stop hard-coding return codes.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:1201
http://jenkins.qa.ubuntu.com/job/cu2d-choo-choo-ci/893/
Executed test runs:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/cu2d-choo-choo-ci/893/rebuild

review: Approve (continuous-integration)

[lp:~robru/cupstream2distro/exception-tweaks]

1202. By Robert Bruce Park on 2015-11-06

Func name/docstring cleanup.

=== modified file 'citrain/build.py'
--- citrain/build.py	2015-10-28 19:46:24 +0000
+++ citrain/build.py	2015-11-06 15:09:47 +0000
@@ -86,8 +86,7 @@
         Manager(silo_state).do('watch', 'diff')
         silo_state.status = 'Packages built.'
     except CITrainError as err:
-        logging.error(str(err))
-        silo_state.status = 'Build failed: ' + str(err)
+        silo_state.status = err
         silo_state.mark_dirty()
         silo_state.save_config()
         return 1

=== modified file 'citrain/merge_clean.py'
--- citrain/merge_clean.py	2015-10-28 19:46:24 +0000
+++ citrain/merge_clean.py	2015-11-06 15:09:47 +0000
@@ -31,31 +31,16 @@
     Enable debug infos
 """
 
-import logging
-
 from citrain.recipes.manager import Manager
-from cupstream2distro.errors import CITrainError
-from cupstream2distro.utils import env, run_script
-from cupstream2distro.silomanager import SiloState
-
-
-def main():
-    """Execute the merge & clean phases, logging & saving any errors.
-
-    :returns: 0 on success, 1 on any failure.
-    """
-    try:
-        silo_state = SiloState(env.SILONAME, primary=True)
-        Manager(silo_state).do(
-            'validate', 'enumeration', 'merge', 'push', 'nuke')
-        silo_state.status = 'Landed'
-    except CITrainError as err:
-        logging.error(str(err))
-        silo_state.status = 'Merge&Clean failed: ' + str(err)
-        silo_state.save_config()
-        return 1
-    silo_state.save_config()
-    return 0
-
-
-run_script(__name__, __doc__, main)
+from cupstream2distro.utils import run_script
+from cupstream2distro.silomanager import stock_main
+
+
+def merge(silo_state):
+    """Do the steps specific to merging & cleaning."""
+    Manager(silo_state).do(
+        'validate', 'enumeration', 'merge', 'push', 'nuke')
+    silo_state.status = 'Landed'
+
+
+run_script(__name__, __doc__, lambda: stock_main(merge, mark_dirty=True))

=== modified file 'citrain/migration.py'
--- citrain/migration.py	2015-11-04 15:43:33 +0000
+++ citrain/migration.py	2015-11-06 15:09:47 +0000
@@ -31,8 +31,8 @@
 from citrain.recipes.manager import Manager
 from cupstream2distro.errors import CITrainError
 from cupstream2distro.utils import env, run_script
-from cupstream2distro.silomanager import SiloState
-from citrain.merge_clean import main as merge_main
+from cupstream2distro.silomanager import SiloState, stock_main
+from citrain.merge_clean import merge
 
 
 def main():
@@ -57,11 +57,10 @@
                 manager.do('unbuilt')
                 if silo_state.is_published:
                     manager.do('migration')
-                    merge_main()
+                    stock_main(merge, mark_dirty=True)
             except CITrainError as err:
-                logging.info(str(err) + '\n')
-                if not silo_state.mark_dirty():
-                    silo_state.status = 'Migration: ' + str(err)
+                silo_state.status = err
+                silo_state.mark_dirty()
                 silo_state.save_config()
     return 0
 

=== modified file 'citrain/publisher.py'
--- citrain/publisher.py	2015-11-04 15:04:26 +0000
+++ citrain/publisher.py	2015-11-06 15:09:47 +0000
@@ -35,44 +35,23 @@
     Enable debug infos
 """
 
-import logging
-
 from citrain.recipes.manager import Manager
-from cupstream2distro.errors import CITrainError, PublishError
-from cupstream2distro.utils import env, run_script
-from cupstream2distro.silomanager import SiloState
-
-
-def main():
-    """Conduct a beautiful orchestra of publication."""
-    try:
-        silo_state = SiloState(env.SILONAME, primary=True)
-        if silo_state._series in ('wily+vivid', 'dual'):
-            raise PublishError(
-                'This silo must be transitioned to xenial before publishing.')
-        mgr = Manager(silo_state)
-        mgr.do('checkstatus', 'validate', 'diff', 'checkupload', 'ackaging')
-        silo_state.status = 'Publishing.'
-        silo_state.save_config()
-        mgr.do('dest_version_check', 'unapproved', 'unbuilt', 'publish')
-        silo_state.set_published()
-    except CITrainError as err:
-        logging.error(str(err))
-        if err.loud:
-            silo_state.status = 'Publish failed: ' + str(err)
-        silo_state.save_config()
-        return 1
+from cupstream2distro.errors import PublishError
+from cupstream2distro.utils import run_script
+from cupstream2distro.silomanager import stock_main
+
+
+def publish(silo_state):
+    """Do the actual specific steps required to publish."""
+    if silo_state._series in ('wily+vivid', 'dual'):
+        raise PublishError(
+            'This silo must be transitioned to xenial before publishing.')
+    mgr = Manager(silo_state)
+    mgr.do('checkstatus', 'validate', 'diff', 'checkupload', 'ackaging')
+    silo_state.status = 'Publishing.'
     silo_state.save_config()
-    # This bit needs to be in a separate block because it's so slow that it
-    # makes the last call to save_config() end up losing races with
-    # check-publication-migration. Then you get logs that say
-    # 'Publishing. Migration:... Publishing. Migration:...'
-    try:
-        silo_state.mark_others_dirty()
-    except Exception as err:
-        logging.warning('Had trouble marking other silos dirty:')
-        logging.warning(err)
-    return 0
-
-
-run_script(__name__, __doc__, main)
+    mgr.do('dest_version_check', 'unapproved', 'unbuilt', 'publish')
+    silo_state.set_published()
+
+
+run_script(__name__, __doc__, lambda: stock_main(publish, mark_dirty=True))

=== modified file 'citrain/recipes/base.py'
--- citrain/recipes/base.py	2015-11-04 15:43:33 +0000
+++ citrain/recipes/base.py	2015-11-06 15:09:47 +0000
@@ -507,11 +507,6 @@
         silo_state.save_config()
 
     @staticmethod
-    def post_push_phase(silo_state):
-        """Mark other silos dirty once pushing is successful."""
-        silo_state.mark_others_dirty()
-
-    @staticmethod
     def post_nuke_phase(silo_state):
         """Delete all packages from PPA and remove local silo dir."""
         logging.info('Cleaning %s ppa.', silo_state.ppa.web_link)

=== modified file 'cupstream2distro/errors.py'
--- cupstream2distro/errors.py	2015-11-04 15:04:26 +0000
+++ cupstream2distro/errors.py	2015-11-06 15:09:47 +0000
@@ -17,56 +17,78 @@
 """Exceptions raised by CI Train in various situations."""
 
 
+COUNTER = iter(range(1, 100))
+
+
 class CITrainError(Exception):
     """Base Exception class for all CI Train error conditions."""
+    prefix = 'Unknown error: '
+    code = next(COUNTER)
     loud = True
+    error = True
+
+    def __str__(self):
+        """Stringify this exception."""
+        return self.prefix + super().__str__()
+
+
+class NoStatusError(CITrainError):
+    """Special Exception that when raised won't set status."""
+    code = next(COUNTER)
+    loud = False
+    prefix = ''
 
 
 class ArchiveError(CITrainError):
     """Exception raised when there's a problem with a Launchpad archive."""
-    pass
+    prefix = 'Launchpad error: '
+    code = next(COUNTER)
 
 
 class BranchError(CITrainError):
     """Exception raised when there's a problem with a Bzr branch."""
-    pass
+    prefix = 'Branch error: '
+    code = next(COUNTER)
 
 
 class PackageError(CITrainError):
     """Exception raised when there's a problem with a debian package."""
-    pass
+    prefix = 'Package error: '
+    code = next(COUNTER)
 
 
 class PrepError(CITrainError):
     """Exception raised when there's a problem during preparation."""
-    pass
+    prefix = 'Prepare failed: '
+    code = next(COUNTER)
 
 
 class PublishError(CITrainError):
     """Exception raised when there's a problem during publishing."""
-    pass
+    prefix = 'Publish failed: '
+    code = next(COUNTER)
 
 
 class BuildError(CITrainError):
     """Exception raised when there's a problem with building."""
-    pass
+    prefix = 'Build failed: '
+    code = next(COUNTER)
 
 
 class MergeError(CITrainError):
     """Exception raised when there's a problem with merging."""
-    pass
+    prefix = 'Merge&Clean failed: '
+    code = next(COUNTER)
 
 
 class MigrationError(CITrainError):
     """Exception raised to report on the silo migration status."""
-    pass
+    prefix = 'Migration: '
+    code = next(COUNTER)
+    error = False
 
 
 class RevertError(CITrainError):
     """Exception raised when there's a problem with reverting."""
-    pass
-
-
-class NoStatusError(PublishError):
-    """Special Exception that when raised won't set status."""
-    loud = False
+    prefix = 'Revert failed: '
+    code = next(COUNTER)

=== modified file 'cupstream2distro/silomanager.py'
--- cupstream2distro/silomanager.py	2015-11-05 16:23:09 +0000
+++ cupstream2distro/silomanager.py	2015-11-06 15:09:47 +0000
@@ -36,7 +36,7 @@
 from lazr.restfulclient.errors import PreconditionFailed, NotFound
 
 from cupstream2distro.branchhandling import Branch
-from cupstream2distro.errors import PrepError
+from cupstream2distro.errors import CITrainError, PrepError
 from cupstream2distro.launchpadmanager import lp
 from cupstream2distro.settings import (
     BILETO_API,
@@ -152,6 +152,31 @@
     _bileto(COMMENT_API, **kwargs)
 
 
+def stock_main(body, mark_dirty=False):
+    """Generic error handling for CI Train scripts."""
+    silo_state = SiloState(env.SILONAME, primary=True)
+    try:
+        body(silo_state)
+    except CITrainError as err:
+        silo_state.status = err
+        silo_state.mark_dirty()
+        silo_state.save_config()
+        return err.code
+    silo_state.mark_dirty()
+    silo_state.save_config()
+    # This bit needs to be in a separate block because it's so slow that it
+    # makes the last call to save_config() end up losing races with
+    # check-publication-migration. Then you get logs that say
+    # 'Publishing. Migration:... Publishing. Migration:...'
+    if mark_dirty:
+        try:
+            silo_state.mark_others_dirty()
+        except Exception as err:
+            logging.warning('Had trouble marking other silos dirty:')
+            logging.warning(err)
+    return 0
+
+
 class SiloState(object):
     """This class stores and manipulates the silo config json blob."""
     REQUEST_ID_FILE = 'request_id_{}'
@@ -212,7 +237,12 @@
     def __setattr__(self, key, value):
         """Set Bileto attributes in Bileto."""
         if key in ('status', 'job_log', 'published_versions'):
-            self._bileto[key] = scrub(value)
+            scrubbed = scrub(str(value))
+            if key == 'status':
+                err = getattr(value, 'error', False)
+                (logging.error if err else logging.info)(scrubbed)
+            if getattr(value, 'loud', True):
+                self._bileto[key] = scrubbed
         else:
             super().__setattr__(key, value)
 

=== modified file 'tests/unit/__init__.py'
--- tests/unit/__init__.py	2015-11-04 01:46:45 +0000
+++ tests/unit/__init__.py	2015-11-06 15:09:47 +0000
@@ -174,8 +174,3 @@
                 'ubuntu/landing-{:03d}'.format(x) for x in range(0, 10)]
             self.script.SILO_NAME_LIST = dict(
                 ubuntu=self.script.ALL_SILO_NAMES)
-
-    def test_existence(self):
-        """CI Train script has a main() func without SyntaxErrors."""
-        if self.script:
-            self.assertTrue(self.script.main)

=== modified file 'tests/unit/test_recipe_base.py'
--- tests/unit/test_recipe_base.py	2015-11-04 01:46:45 +0000
+++ tests/unit/test_recipe_base.py	2015-11-06 15:09:47 +0000
@@ -772,12 +772,6 @@
         self.assertEqual(silo_state.status, 'Merging.')
         silo_state.save_config.assert_called_once_with()
 
-    def test_buildbase_post_push_phase(self):
-        """Mark other silos dirty after silo has merged."""
-        silo_state = Mock()
-        BuildBase.post_push_phase(silo_state)
-        silo_state.mark_others_dirty.assert_called_once_with()
-
     @patch('citrain.recipes.base.mkdir')
     @patch('citrain.recipes.base.shutil')
     @patch('citrain.recipes.base.SILO_DIR')

=== modified file 'tests/unit/test_script_build.py'
--- tests/unit/test_script_build.py	2015-11-04 02:19:56 +0000
+++ tests/unit/test_script_build.py	2015-11-06 15:09:47 +0000
@@ -168,5 +168,5 @@
             bman.return_value.mock_calls, [
                 call.do('validate'),
             ])
-        self.assertEqual(silo_state.status, 'Build failed: It asploded!')
+        self.assertEqual(str(silo_state.status), 'Build failed: It asploded!')
         silo_state.save_config.assert_called_once_with()

=== modified file 'tests/unit/test_script_merge_clean.py'
--- tests/unit/test_script_merge_clean.py	2015-11-04 02:19:56 +0000
+++ tests/unit/test_script_merge_clean.py	2015-11-06 15:09:47 +0000
@@ -31,31 +31,25 @@
     """Test CI Train Merge & Clean script."""
     scriptname = 'merge_clean.py'
 
-    def test_main(self):
-        """main() succeeds in the primary case."""
-        self.script.env.SILONAME = 'fred'
+    def test_merge(self):
+        """merge() succeeds in the primary case."""
+        silo_state = Mock()
         self.script.Manager = Mock()
         mergemanager = self.script.Manager.return_value
-        self.assertEqual(self.script.main(), 0)
-        self.script.SiloState.assert_called_once_with('fred', primary=True)
-        self.script.Manager.assert_called_once_with(
-            self.script.SiloState.return_value)
+        self.assertIsNone(self.script.merge(silo_state))
+        self.script.Manager.assert_called_once_with(silo_state)
         mergemanager.do.assert_called_once_with(
             'validate', 'enumeration', 'merge', 'push', 'nuke')
 
-    def test_main_failed(self):
-        """main() returns 1 when a phase raises an exception."""
-        self.script.env.SILONAME = 'fred'
+    def test_merge_failed(self):
+        """merge() doesn't catch exceptions."""
+        silo_state = Mock()
         self.script.Manager = Mock()
         mergemanager = self.script.Manager.return_value
         mergemanager.do.side_effect = MergeError('whoa buddy!')
         silo_state = self.script.SiloState.return_value
-        self.assertEqual(self.script.main(), 1)
-        self.script.SiloState.assert_called_once_with('fred', primary=True)
-        self.script.Manager.assert_called_once_with(
-            self.script.SiloState.return_value)
+        with self.assertRaisesRegexp(MergeError, 'Merge&Clean failed: whoa'):
+            self.script.merge(silo_state)
+        self.script.Manager.assert_called_once_with(silo_state)
         mergemanager.do.assert_called_once_with(
             'validate', 'enumeration', 'merge', 'push', 'nuke')
-        self.script.logging.error.assert_called_once_with('whoa buddy!')
-        self.assertEqual(silo_state.status, 'Merge&Clean failed: whoa buddy!')
-        silo_state.save_config.assert_called_once_with()

=== modified file 'tests/unit/test_script_migration.py'
--- tests/unit/test_script_migration.py	2015-11-04 02:19:56 +0000
+++ tests/unit/test_script_migration.py	2015-11-06 15:09:47 +0000
@@ -36,7 +36,7 @@
     def setUp(self):
         super().setUp()
         self.script.Manager = Mock()
-        self.script.merge_main = Mock()
+        self.script.stock_main = Mock()
         self.script.glob.return_value = [
             join(SILOS_DIR, 'ubuntu', 'landing-00{}'.format(x))
             for x in range(3)]
@@ -64,14 +64,16 @@
             call().do('unbuilt'),
             call().do('migration'),
         ])
-        self.assertEqual(self.script.merge_main.mock_calls, [call()] * 3)
+        self.assertEqual(self.script.stock_main.mock_calls, [
+            call(self.script.merge, mark_dirty=True)
+        ] * 3)
 
     def test_main_skip_empty_silos(self):
         """Don't check silos that are empty."""
         self.script.SiloState.iterate.return_value = []
         self.assertEqual(self.script.main(), 0)
         self.assertEqual(self.script.Manager.mock_calls, [])
-        self.assertEqual(self.script.merge_main.mock_calls, [])
+        self.assertEqual(self.script.stock_main.mock_calls, [])
 
     def test_main_skip_locked_silos(self):
         """Skip over silos that are currently used by other processes."""
@@ -79,7 +81,7 @@
         states[0].enforce_lock.side_effect = BlockingIOError
         self.assertEqual(self.script.main(), 0)
         self.assertEqual(self.script.Manager.mock_calls, [])
-        self.assertEqual(self.script.merge_main.mock_calls, [])
+        self.assertEqual(self.script.stock_main.mock_calls, [])
         self.assertEqual(states[0].mock_calls, [call.enforce_lock()])
 
     def test_main_skip_unpublished_silos(self):
@@ -96,7 +98,7 @@
             call(states[2]),
             call().do('unbuilt'),
         ])
-        self.assertEqual(self.script.merge_main.mock_calls, [])
+        self.assertEqual(self.script.stock_main.mock_calls, [])
         for state in states:
             self.assertEqual(state.set_migrating.mock_calls, [])
             self.assertEqual(state.save_config.mock_calls, [])
@@ -115,7 +117,7 @@
         self.script.Manager.return_value.do.side_effect = set_side_effect
         self.assertEqual(self.script.main(), 0)
         self.assertEqual(
-            states[0].status, 'Migration: foo is in the Proposed pocket.')
+            str(states[0].status), 'Migration: foo is in the Proposed pocket.')
         self.assertEqual(states[0].mock_calls, [
             call.enforce_lock(),
             call.lock_fd.close(),
@@ -128,4 +130,4 @@
             call().do('unbuilt'),
             call().do('migration'),
         ])
-        self.assertEqual(self.script.merge_main.mock_calls, [])
+        self.assertEqual(self.script.stock_main.mock_calls, [])

=== modified file 'tests/unit/test_script_publisher.py'
--- tests/unit/test_script_publisher.py	2015-10-28 19:40:12 +0000
+++ tests/unit/test_script_publisher.py	2015-11-06 15:09:47 +0000
@@ -21,10 +21,7 @@
 from tests.unit import CITrainScriptTestCase
 
 from cupstream2distro.utils import env
-from cupstream2distro.errors import PublishError, NoStatusError
-
-
-N = '\n'
+from cupstream2distro.errors import PublishError
 
 
 class PublisherTestCase(CITrainScriptTestCase):
@@ -37,67 +34,37 @@
         env.DISTRO = 'ubuntu'
         env.SERIES = 'vivid'
 
-    def mock_main(self):
-        """Ensure enough of the publisher is mocked out for testing main()."""
+    def test_publish_success(self):
+        """publisher.publish() should call the right functions."""
+        silo_state = Mock()
         self.script.Manager = Mock()
-        self.script.SiloState.return_value.series = \
-            'https://api.launchpad.net/devel/ubuntu/vivid'
-
-    def test_main_success(self):
-        """publisher.main() should call the right functions."""
-        self.mock_main()
-        state = self.script.SiloState()
-        self.assertEqual(self.script.main(), 0)
-        self.script.Manager.assert_called_once_with(state)
+        self.assertIsNone(self.script.publish(silo_state))
+        self.script.Manager.assert_called_once_with(silo_state)
         self.assertEqual(self.script.Manager.return_value.do.mock_calls, [
             call('checkstatus', 'validate', 'diff', 'checkupload', 'ackaging'),
             call('dest_version_check', 'unapproved', 'unbuilt', 'publish'),
         ])
-        self.assertEqual(state.status, 'Publishing.')
-        state.set_published.assert_called_once_with()
-        self.assertEqual(state.save_config.mock_calls, [call(), call()])
-        state.mark_others_dirty.assert_called_once_with()
-
-    def test_main_failure(self):
-        """publisher.main() should handle errors."""
-        self.mock_main()
-        state = self.script.SiloState()
-        self.script.Manager.return_value.do.side_effect = PublishError('Oops')
-        self.assertEqual(self.script.main(), 1)
-        self.assertEqual(state.status, "Publish failed: Oops")
-        self.assertEqual(state.set_published.call_count, 0)
-        self.script.logging.error.assert_called_once_with('Oops')
-        self.assertEqual(state.save_config.mock_calls, [call()])
-        self.assertEqual(state.mark_others_dirty.mock_calls, [])
-
-    def test_main_failure_nostatus(self):
-        """publisher.main() shouldn't set status inappropriately."""
-        self.mock_main()
-        state = self.script.SiloState()
-        state.status = 'Preserved'
-        self.script.Manager.return_value.do = Mock(
-            side_effect=NoStatusError('Whoops'))
-        self.assertEqual(self.script.main(), 1)
-        self.assertEqual(state.status, 'Preserved')
-
-    def test_main_failure_dirty(self):
-        """publisher.main() should call save_config sooner."""
-        self.mock_main()
-        state = self.script.SiloState()
-        state.status = 'Packages built.'
-        self.script.SiloState.return_value.mark_others_dirty = Mock(
-            side_effect=Exception('Whoops'))
-        self.assertEqual(self.script.main(), 0)
-        self.assertEqual(state.status, 'Publishing.')
-
-    def test_main_failure_wily(self):
+        self.assertEqual(silo_state.status, 'Publishing.')
+        self.assertEqual(silo_state.mock_calls, [
+            call.save_config(),
+            call.set_published(),
+        ])
+
+    def test_publish_failure(self):
+        """publisher.publish() should raise errors."""
+        silo_state = Mock()
+        self.script.Manager = Mock()
+        err = PublishError('Oops')
+        self.script.Manager.return_value.do.side_effect = err
+        with self.assertRaisesRegexp(PublishError, 'Publish failed: Oops'):
+            self.script.publish(silo_state)
+        self.assertEqual(silo_state.mock_calls, [])
+
+    def test_publish_failure_wily(self):
         """Prevent publishing dual silos to wily."""
-        self.mock_main()
-        state = self.script.SiloState()
-        state.status = 'Packages built.'
-        state._series = 'dual'
-        self.assertEqual(self.script.main(), 1)
-        self.assertEqual(
-            state.status,
-            'Publish failed: This silo must be transitioned to xenial '
-            'before publishing.')
+        silo_state = Mock()
+        silo_state.status = 'Packages built.'
+        silo_state._series = 'dual'
+        self.script.Manager = Mock()
+        with self.assertRaisesRegexp(PublishError, 'must be transitioned'):
+            self.script.publish(silo_state)

=== modified file 'tests/unit/test_silomanager.py'
--- tests/unit/test_silomanager.py	2015-11-05 16:32:14 +0000
+++ tests/unit/test_silomanager.py	2015-11-06 15:09:47 +0000
@@ -28,9 +28,9 @@
 from tests.unit import DirectoryAwareTestCase
 
 from cupstream2distro import silomanager
-from cupstream2distro.silomanager import SiloState, splitter
+from cupstream2distro.silomanager import SiloState, splitter, stock_main
 from cupstream2distro.utils import env, utf8_open
-from cupstream2distro.errors import PrepError
+from cupstream2distro.errors import PrepError, NoStatusError
 
 
 SOURCES = 'bar bat foo zing'.split()
@@ -114,6 +114,42 @@
         expected = [['robru', 'sil2100']] * 7 + [[]]
         self.assertEqual([splitter(case) for case in cases], expected)
 
+    @patch('cupstream2distro.silomanager.SiloState')
+    def test_stock_main(self, state_mock):
+        """Ensure that the stock main() function works."""
+        self.assertEqual(stock_main(lambda state: state, True), 0)
+        self.assertEqual(state_mock.mock_calls, [
+            call(self.tempdir, primary=True),
+            call().mark_dirty(),
+            call().save_config(),
+            call().mark_others_dirty(),
+        ])
+
+    @patch('cupstream2distro.silomanager.SiloState')
+    def test_stock_main_fail(self, state_mock):
+        """Ensure that the stock main() function handles exceptions."""
+        def body(silo_state):
+            """Raise a little hell."""
+            raise PrepError('Boo!')
+        self.assertEqual(stock_main(body, True), PrepError.code)
+        self.assertEqual(state_mock.mock_calls, [
+            call(self.tempdir, primary=True),
+            call().mark_dirty(),
+            call().save_config(),
+        ])
+
+    @patch('cupstream2distro.silomanager.SiloState')
+    def test_stock_main_dirty_fail(self, state_mock):
+        """Ensure that the stock main() function handles dirty exceptions."""
+        state_mock.return_value.mark_others_dirty.side_effect = Exception('Oh')
+        self.assertEqual(stock_main(lambda state: state, True), 0)
+        self.assertEqual(state_mock.mock_calls, [
+            call(self.tempdir, primary=True),
+            call().mark_dirty(),
+            call().save_config(),
+            call().mark_others_dirty(),
+        ])
+
     def test_silostate_init(self):
         """Ensure that init is sensible."""
         state = SiloState('ubuntu/landing-123')
@@ -375,6 +411,12 @@
         self.assertEqual(self.state.landers, 'm')
         self.state.load_bileto.assert_called_once_with()
 
+    def test_silostate_setattr_nostateerror(self):
+        """Don't set status with NoStatusError."""
+        self.state.status = 'Preserved'
+        self.state.status = NoStatusError('No')
+        self.assertEquals(self.state.status, 'Preserved')
+
     @patch('cupstream2distro.silomanager.SiloState.series')
     @patch('cupstream2distro.silomanager.SiloState.iterate')
     @patch('cupstream2distro.silomanager.SiloState.all_projects', ['qtmir'])