Change forget_policy to use StructuredError

4 files changed, 34 insertions, 10 deletions

diff --git a/obnamlib/__init__.py b/obnamlib/__init__.py
index 369d6f26..dd09de1b 100644
--- a/obnamlib/__init__.py
+++ b/obnamlib/__init__.py
@@ -36,8 +36,16 @@ except ImportError:
 from pluginmgr import PluginManager
 
 
+# Exceptions defined by Obnam itself. They should all be a subclass
+# of obnamlib.ObnamError. The obnamlib.Error class is a remnant of
+# an old way of doing things, and will be retired.
+
 from structurederror import StructuredError
 
+class ObnamError(StructuredError):
+
+    pass
+
 
 class Error(cliapp.AppException):
     pass
diff --git a/obnamlib/forget_policy.py b/obnamlib/forget_policy.py
index 8b8b2c6b..482a49c0 100644
--- a/obnamlib/forget_policy.py
+++ b/obnamlib/forget_policy.py
@@ -19,6 +19,24 @@ import re
 import obnamlib
 
 
+class ForgetPolicySyntaxError(obnamlib.ObnamError):
+
+    msg = 'Forget policy syntax error: {policy}'
+
+
+class DuplicatePeriodError(obnamlib.ObnamError):
+
+    msg = 'Forget policy may not duplicate period ({period}): {policy}'
+
+
+class SeparatorError(obnamlib.ObnamError):
+
+    msg = ('Forget policy must have rules separated by commas, '
+           'see position {position}: {policy}')
+
+
+
+
 class ForgetPolicy(object):
 
     '''Parse and interpret a policy for what to forget and what to keep.
@@ -49,23 +67,21 @@ class ForgetPolicy(object):
         remaining = optarg
         m = self.rule_pat.match(remaining)
         if not m:
-            raise obnamlib.Error('Forget policy syntax error: %s' % optarg)
+            raise ForgetPolicySyntaxError(policy=optarg)
 
         result = dict((y, None) for x, y in self.periods.iteritems())
         while m:
             count = int(m.group('count'))
             period = self.periods[m.group('period')]
             if result[period] is not None:
-                raise obnamlib.Error('Forget policy may not '
-                                     'duplicate period (%s): %s' %
-                                     (period, optarg))
+                raise DuplicatePeriodError(period=period, policy=optarg)
             result[period] = count
             remaining = remaining[m.end():]
             if not remaining:
                 break
             if not remaining.startswith(','):
-                raise obnamlib.Error('Forget policy must have rules '
-                                     'separated by commas: %s' % optarg)
+                position = len(optarg) - len(remaining) + 1
+                raise SeparatorError(position=position, policy=optarg)
             remaining = remaining[1:]
             m = self.rule_pat.match(remaining)
 
diff --git a/obnamlib/forget_policy_tests.py b/obnamlib/forget_policy_tests.py
index be65dd0b..24eb0134 100644
--- a/obnamlib/forget_policy_tests.py
+++ b/obnamlib/forget_policy_tests.py
@@ -26,16 +26,16 @@ class ForgetPolicyParseTests(unittest.TestCase):
         self.fp = obnamlib.ForgetPolicy()
 
     def test_raises_error_for_empty_string(self):
-        self.assertRaises(obnamlib.Error, self.fp.parse, '')
+        self.assertRaises(obnamlib.ObnamError, self.fp.parse, '')
 
     def test_raises_error_for_unknown_period(self):
-        self.assertRaises(obnamlib.Error, self.fp.parse, '7x')
+        self.assertRaises(obnamlib.ObnamError, self.fp.parse, '7x')
 
     def test_raises_error_if_period_is_duplicated(self):
-        self.assertRaises(obnamlib.Error, self.fp.parse, '1h,2h')
+        self.assertRaises(obnamlib.ObnamError, self.fp.parse, '1h,2h')
 
     def test_raises_error_rules_not_separated_by_comma(self):
-        self.assertRaises(obnamlib.Error, self.fp.parse, '1h 2d')
+        self.assertRaises(obnamlib.ObnamError, self.fp.parse, '1h 2d')
 
     def test_parses_single_rule(self):
         self.assertEqual(self.fp.parse('7d'),
diff --git a/test-gpghome/random_seed b/test-gpghome/random_seed
index d5b69b86..a9ab9acd 100644
--- a/test-gpghome/random_seed
+++ b/test-gpghome/random_seed