Merge branch 'assertFailure'

* assertFailure:
  be explicit in the errors expected from an integrity error
  use addFailure instead of a longer addCallbacks form

master/buildbot/test/regressions/test_import_unicode_changes.py

@@ -64,12 +64,7 @@ def testNonUnicodeChange(self):
                     revision=12345))
 
         d = self.db.model.upgrade()
-        def eb(f):
-            self.failUnless("UnicodeError" in str(f))
-        def cb(r):
-            self.fail("upgrade did not fail for non-unicode changes")
-        d.addCallbacks(cb, eb)
-        return d
+        return self.assertFailure(d, UnicodeError)
 
     def testAsciiChange(self):
         self.make_pickle(

master/buildbot/test/unit/test_changes_p4poller.py

@@ -201,13 +201,7 @@ def test_poll_failed_changes(self):
 
         # call _poll, so we can catch the failure
         d = self.changesource._poll()
-        def cb(_):
-            self.fail("_poll should have failed")
-        def eb(f):
-            f.trap(P4PollerError)
-            self.assertEquals(self.changesource.last_change, None)
-        d.addCallbacks(cb, eb)
-        return d
+        return self.assertFailure(d, P4PollerError)
 
     def test_poll_failed_describe(self):
         self.attachChangeSource(
@@ -222,12 +216,11 @@ def test_poll_failed_describe(self):
 
         # call _poll, so we can catch the failure
         d = self.changesource._poll()
-        def cb(_):
-            self.fail("_poll should have failed")
-        def eb(f):
-            f.trap(P4PollerError)
-            self.assertEquals(self.changesource.last_change, 2) # 2 was processed OK
-        d.addCallbacks(cb, eb)
+        self.assertFailure(d, P4PollerError)
+        @d.addCallback
+        def check(_):
+            # check that 2 was processed OK
+            self.assertEquals(self.changesource.last_change, 2)
         return d
 
     def test_poll_split_file(self):

master/buildbot/test/unit/test_db_buildsets.py

@@ -330,24 +330,12 @@ def test_completeBuildset_already_completed(self):
         d.addCallback(lambda _ :
                 self.db.buildsets.completeBuildset(bsid=92, results=6,
                                                    _reactor=self.clock))
-        def cb(_):
-            self.fail("should not succeed")
-        def eb(f):
-            f.trap(KeyError)
-            # pass
-        d.addCallbacks(cb, eb)
-        return d
+        return self.assertFailure(d, KeyError)
 
     def test_completeBuildset_missing(self):
         d = self.insert_test_getBuildsets_data()
         d.addCallback(lambda _ :
                 self.db.buildsets.completeBuildset(bsid=93, results=6,
                                                    _reactor=self.clock))
-        def cb(_):
-            self.fail("should not succeed")
-        def eb(f):
-            f.trap(KeyError)
-            # pass
-        d.addCallbacks(cb, eb)
-        return d
+        return self.assertFailure(d, KeyError)
 

master/buildbot/test/unit/test_db_connector.py

@@ -80,12 +80,7 @@ def check(_):
 
     def test_setup_check_version_bad(self):
         d = self.startService(check_version=True)
-        def eb(f):
-            f.trap(connector.DatabaseNotReadyError)
-        def cb(_):
-            self.fail("startService unexpectedly succeeded")
-        d.addCallbacks(cb, eb)
-        return d
+        return self.assertFailure(d, connector.DatabaseNotReadyError)
 
     def test_setup_check_version_good(self):
         self.db.model.is_current = lambda : defer.succeed(True)

master/buildbot/test/unit/test_db_pool.py

@@ -48,24 +48,13 @@ def fail(conn):
             rp = conn.execute("EAT COOKIES")
             return rp.scalar()
         d = self.pool.do(fail)
-        def eb(f):
-            pass
-        def cb(r):
-            self.fail("no exception propagated")
-        d.addCallbacks(cb, eb)
-        return d
+        return self.assertFailure(d, sa.exc.OperationalError)
 
     def test_do_exception(self):
         def raise_something(conn):
             raise RuntimeError("oh noes")
         d = self.pool.do(raise_something)
-        def eb(f):
-            f.trap(RuntimeError) # make sure it gets the *right* exception
-            pass
-        def cb(r):
-            self.fail("no exception propagated")
-        d.addCallbacks(cb, eb)
-        return d
+        return self.assertFailure(d, RuntimeError)
 
     def test_do_with_engine(self):
         def add(engine, addend1, addend2):
@@ -82,12 +71,7 @@ def fail(engine):
             rp = engine.execute("EAT COOKIES")
             return rp.scalar()
         d = self.pool.do_with_engine(fail)
-        def eb(f):
-            pass
-        def cb(r):
-            self.fail("no exception propagated")
-        d.addCallbacks(cb, eb)
-        return d
+        return self.assertFailure(d, sa.exc.OperationalError)
 
     def test_persistence_across_invocations(self):
         # NOTE: this assumes that both methods are called with the same

master/buildbot/test/unit/test_db_state.py

@@ -79,12 +79,7 @@ def check(objectid):
 
     def test_getState_missing(self):
         d = self.db.state.getState(10, 'nosuch')
-        def cb(_):
-            self.fail("should not have succeeded!")
-        def eb(f):
-            f.trap(KeyError)
-        d.addCallbacks(cb, eb)
-        return d
+        return self.assertFailure(d, KeyError)
 
     def test_getState_missing_default(self):
         d = self.db.state.getState(10, 'nosuch', 'abc')
@@ -119,12 +114,7 @@ def test_getState_badjson(self):
         ])
         d.addCallback(lambda _ :
             self.db.state.getState(10, 'x'))
-        def cb(_):
-            self.fail("should not have succeeded!")
-        def eb(f):
-            f.trap(TypeError)
-        d.addCallbacks(cb, eb)
-        return d
+        return self.assertFailure(d, TypeError)
 
     def test_setState(self):
         d = self.insertTestData([
@@ -149,12 +139,7 @@ def test_setState_badjson(self):
         ])
         d.addCallback(lambda _ :
             self.db.state.setState(10, 'x', self)) # self is not JSON-able..
-        def cb(_):
-            self.fail("should not have succeeded!")
-        def eb(f):
-            f.trap(TypeError)
-        d.addCallbacks(cb, eb)
-        return d
+        return self.assertFailure(d, TypeError)
 
     def test_setState_existing(self):
         d = self.insertTestData([

master/buildbot/test/unit/test_db_users.py

@@ -194,13 +194,8 @@ def test_addUser_existing_identifier(self):
                                   identifier='soap',
                                   attr_type='telepathIO(tm)',
                                   attr_data='hmm,lye'))
-        def cb(_):
-            self.fail("shouldn't get here")
-        def eb(f):
-            f.trap(sa.exc.IntegrityError, sa.exc.ProgrammingError)
-            pass # expected
-        d.addCallbacks(cb, eb)
-        return d
+        return self.assertFailure(d, sa.exc.IntegrityError,
+                                     sa.exc.ProgrammingError)
 
     def test_getUser(self):
         d = self.insertTestData(self.user1_rows)

master/buildbot/test/unit/test_process_users_manual.py

@@ -276,24 +276,12 @@ def setUp(self):
 
     def test_no_userpass(self):
         d = defer.maybeDeferred(lambda : manual.CommandlineUserManager())
-        def cb(_):
-            self.fail("shouldn't succeed")
-        def eb(f):
-            f.trap(AssertionError)
-            pass # A-OK
-        d.addCallbacks(cb, eb)
-        return d
+        return self.assertFailure(d, AssertionError)
 
     def test_no_port(self):
         d = defer.maybeDeferred(lambda : manual.CommandlineUserManager(username="x",
                                                                   passwd="y"))
-        def cb(_):
-            self.fail("shouldn't succeed")
-        def eb(f):
-            f.trap(AssertionError)
-            pass # A-OK
-        d.addCallbacks(cb, eb)
-        return d
+        return self.assertFailure(d, AssertionError)
 
     def test_service(self):
         # patch out the pbmanager's 'register' command both to be sure