diff --git a/docs/CHANGES.rst b/docs/CHANGES.rst
index 8ee8cfab..a36aadfc 100644
--- a/docs/CHANGES.rst
+++ b/docs/CHANGES.rst
@@ -9,6 +9,9 @@ Changes
 - Add plone.recipe.codeanalysis to our buildout.
   [flohcim]
 
+- Make all assertRaise() calls use the `with` keyword.
+  [winstonf88]
+
 - Amend user.get method to accept a userid parameter, refs #112.
   [cewing, xiru, winstonf88]
 
diff --git a/src/plone/api/tests/test_content.py b/src/plone/api/tests/test_content.py
index fba503a4..bf3ce4df 100644
--- a/src/plone/api/tests/test_content.py
+++ b/src/plone/api/tests/test_content.py
@@ -71,28 +71,25 @@ def test_create_constraints(self):
             api.content.create()
 
         # Check the contraints for the type container
-        self.assertRaises(
-            MissingParameterError,
-            api.content.create,
-            type='Document',
-            id='test-doc',
-        )
+        with self.assertRaises(MissingParameterError):
+            api.content.create(
+                type='Document',
+                id='test-doc',
+            )
 
         # Check the contraints for the type parameter
         container = mock.Mock()
-        self.assertRaises(
-            MissingParameterError,
-            api.content.create,
-            container=container,
-            id='test-doc',
-        )
+        with self.assertRaises(MissingParameterError):
+            api.content.create(
+                container=container,
+                id='test-doc',
+            )
 
         # Check the contraints for id and title parameters
-        self.assertRaises(
-            MissingParameterError,
-            api.content.create,
-            container=container, type='Document'
-        )
+        with self.assertRaises(MissingParameterError):
+            api.content.create(
+                container=container, type='Document'
+            )
 
         # Check the contraints for allowed types in the container
         container = self.events
@@ -128,13 +125,12 @@ def test_create_constraints(self):
         # Constraint the allowed types
         folder.setConstrainTypesMode(1)
         folder.setLocallyAllowedTypes(('News Item',))
-        self.assertRaises(
-            InvalidParameterError,
-            api.content.create,
-            container=folder,
-            type='Document',
-            id='test-doc'
-        )
+        with self.assertRaises(InvalidParameterError):
+            api.content.create(
+                container=folder,
+                type='Document',
+                id='test-doc'
+            )
 
     @unittest.skipUnless(
         HAS_DEXTERITY,
@@ -170,13 +166,12 @@ def test_create_dexterity(self):
         self.assertEqual(page.portal_type, 'Dexterity Item')
 
         # Try to create another item with same id, this should fail
-        self.assertRaises(
-            BadRequest,
-            api.content.create,
-            container=folder,
-            type='Dexterity Item',
-            id='test-item',
-        )
+        with self.assertRaises(BadRequest):
+            api.content.create(
+                container=folder,
+                type='Dexterity Item',
+                id='test-item',
+            )
 
     def test_create_archetypes(self):
         """Test creating content based on Archetypes."""
@@ -206,13 +201,12 @@ def test_create_archetypes(self):
         self.assertEqual(page.portal_type, 'Document')
 
         # Try to create another page with same id, this should fail
-        self.assertRaises(
-            BadRequest,
-            api.content.create,
-            container=folder,
-            type='Document',
-            id='test-document',
-        )
+        with self.assertRaises(BadRequest):
+            api.content.create(
+                container=folder,
+                type='Document',
+                id='test-document',
+            )
 
     def test_create_with_safe_id(self):
         """Test the content creating with safe_id mode."""
@@ -244,12 +238,16 @@ def test_get_constraints(self):
 
         # Path and UID parameter can not be given together
         from plone.api.exc import InvalidParameterError
-        self.assertRaises(
-            InvalidParameterError, api.content.get, path='/', UID='dummy')
+        with self.assertRaises(InvalidParameterError):
+            api.content.get(
+                path='/',
+                UID='dummy'
+            )
 
         # Either a path or UID must be given
         from plone.api.exc import MissingParameterError
-        self.assertRaises(MissingParameterError, api.content.get)
+        with self.assertRaises(MissingParameterError):
+            api.content.get()
 
     def test_get(self):
         """Test the getting of content in varios ways."""
@@ -280,17 +278,18 @@ def test_move_constraints(self):
         from plone.api.exc import MissingParameterError
 
         # When no parameters are given an error is raised
-        self.assertRaises(MissingParameterError, api.content.move)
+        with self.assertRaises(MissingParameterError):
+            api.content.move()
 
         container = mock.Mock()
 
         # Source is missing an should raise an error
-        self.assertRaises(
-            MissingParameterError, api.content.move, source=container)
+        with self.assertRaises(MissingParameterError):
+            api.content.move(source=container)
 
         # Target is missing an should raise an error
-        self.assertRaises(
-            MissingParameterError, api.content.move, target=container)
+        with self.assertRaises(MissingParameterError):
+            api.content.move(target=container)
 
     def test_move(self):
         """Test moving of content."""
@@ -337,15 +336,13 @@ def test_rename_constraints(self):
         from plone.api.exc import MissingParameterError
 
         # When no parameters are given an error is raised
-        self.assertRaises(MissingParameterError, api.content.rename)
+        with self.assertRaises(MissingParameterError):
+            api.content.rename()
 
         container = mock.Mock()
         # Source is missing an should raise an error
-        self.assertRaises(
-            MissingParameterError,
-            api.content.rename,
-            obj=container,
-        )
+        with self.assertRaises(MissingParameterError):
+            api.content.rename(obj=container)
 
     def test_rename(self):
         """Test renaming of content."""
@@ -371,12 +368,11 @@ def test_rename(self):
         # Rename to existing id
         api.content.create(
             container=self.about, type='Link', id='link-to-blog')
-        self.assertRaises(
-            CopyError,
-            api.content.rename,
-            obj=container['about']['link-to-blog'],
-            new_id='link-to-blog-1',
-        )
+        with self.assertRaises(CopyError):
+            api.content.rename(
+                obj=container['about']['link-to-blog'],
+                new_id='link-to-blog-1',
+            )
         api.content.rename(
             obj=container['about']['link-to-blog'],
             new_id='link-to-blog-1',
@@ -390,12 +386,13 @@ def test_copy_constraints(self):
         from plone.api.exc import MissingParameterError
 
         # When no parameters are given an error is raised
-        self.assertRaises(MissingParameterError, api.content.copy)
+        with self.assertRaises(MissingParameterError):
+            api.content.copy()
 
         container = mock.Mock()
         # Source is missing and should raise an error
-        self.assertRaises(
-            MissingParameterError, api.content.copy, source=container)
+        with self.assertRaises(MissingParameterError):
+            api.content.copy(source=container)
 
     def test_copy(self):
         """Test the copying of content."""
@@ -436,7 +433,8 @@ def test_delete_constraints(self):
 
         # When no parameters are given an error is raised
         from plone.api.exc import MissingParameterError
-        self.assertRaises(MissingParameterError, api.content.delete)
+        with self.assertRaises(MissingParameterError):
+            api.content.delete()
 
     def test_delete(self):
         """Test deleting a content item."""
@@ -445,7 +443,8 @@ def test_delete(self):
 
         # The content item must be given as parameter
         from plone.api.exc import MissingParameterError
-        self.assertRaises(MissingParameterError, api.content.delete)
+        with self.assertRaises(MissingParameterError):
+            api.content.delete()
 
         # Delete the contact page
         api.content.delete(self.contact)
@@ -456,7 +455,8 @@ def test_get_state(self):
 
         # This should fail because an content item is mandatory
         from plone.api.exc import MissingParameterError
-        self.assertRaises(MissingParameterError, api.content.get_state)
+        with self.assertRaises(MissingParameterError):
+            api.content.get_state()
 
         review_state = api.content.get_state(obj=self.blog)
         self.assertEqual(review_state, 'private')
@@ -466,20 +466,14 @@ def test_transition(self):
         from plone.api.exc import InvalidParameterError
         from plone.api.exc import MissingParameterError
 
-        self.assertRaises(
-            MissingParameterError,
-            api.content.transition,
-        )
-        self.assertRaises(
-            MissingParameterError,
-            api.content.transition,
-            obj=mock.Mock(),
-        )
-        self.assertRaises(
-            MissingParameterError,
-            api.content.transition,
-            transition='publish',
-        )
+        with self.assertRaises(MissingParameterError):
+            api.content.transition()
+
+        with self.assertRaises(MissingParameterError):
+            api.content.transition(obj=mock.Mock())
+
+        with self.assertRaises(MissingParameterError):
+            api.content.transition(transition='publish')
 
         api.content.transition(obj=self.blog, transition='publish')
         review_state = api.content.get_state(obj=self.blog)
@@ -505,31 +499,29 @@ def test_get_view_constraints(self):
         request = self.layer['request']
 
         # When no parameters are given an error is raised
-        self.assertRaises(MissingParameterError, api.content.get_view)
+        with self.assertRaises(MissingParameterError):
+            api.content.get_view()
 
         # name is required
-        self.assertRaises(
-            MissingParameterError,
-            api.content.get_view,
-            context=self.blog,
-            request=request,
-        )
+        with self.assertRaises(MissingParameterError):
+            api.content.get_view(
+                context=self.blog,
+                request=request,
+            )
 
         # context is required
-        self.assertRaises(
-            MissingParameterError,
-            api.content.get_view,
-            name='plone',
-            request=request,
-        )
+        with self.assertRaises(MissingParameterError):
+            api.content.get_view(
+                name='plone',
+                request=request,
+            )
 
         # request is required
-        self.assertRaises(
-            MissingParameterError,
-            api.content.get_view,
-            name='plone',
-            context=self.blog,
-        )
+        with self.assertRaises(MissingParameterError):
+            api.content.get_view(
+                name='plone',
+                context=self.blog,
+            )
 
     def test_get_view(self):
         """Test the view."""
@@ -560,7 +552,8 @@ def test_get_uuid(self):
         container = self.portal
 
         # The content item must be given as parameter
-        self.assertRaises(MissingParameterError, api.content.get_uuid)
+        with self.assertRaises(MissingParameterError):
+            api.content.get_uuid()
 
         generator = getUtility(IUUIDGenerator)
 
diff --git a/src/plone/api/tests/test_group.py b/src/plone/api/tests/test_group.py
index d20fe9bf..e59a6e1a 100644
--- a/src/plone/api/tests/test_group.py
+++ b/src/plone/api/tests/test_group.py
@@ -24,7 +24,8 @@ def setUp(self):
     def test_create_contraints(self):
         """Test the contraints for creating a group."""
         from plone.api.exc import MissingParameterError
-        self.assertRaises(MissingParameterError, api.group.create)
+        with self.assertRaises(MissingParameterError):
+            api.group.create()
 
     def test_create(self):
         """Test adding of a group, groupname is mandatory."""
@@ -70,19 +71,22 @@ def test_create_with_roles_and_groups(self):
     def test_get_constraints(self):
         """Test the constraints for geting a group."""
         from plone.api.exc import MissingParameterError
-        self.assertRaises(MissingParameterError, api.group.get)
+        with self.assertRaises(MissingParameterError):
+            api.group.get()
 
     def test_get_no_groupname(self):
         """Test getting a group without passing a groupname."""
         from plone.api.exc import MissingParameterError
-        self.assertRaises(MissingParameterError, api.group.create)
+        with self.assertRaises(MissingParameterError):
+            api.group.create()
 
     def test_get(self):
         """Test getting a group."""
         from plone.api.exc import MissingParameterError
 
         # This should fail because the groupname is mandatory
-        self.assertRaises(MissingParameterError, api.group.create)
+        with self.assertRaises(MissingParameterError):
+            api.group.create()
 
         # Create a group and retrieve it
         api.group.create(groupname='bacon')
@@ -104,11 +108,11 @@ def test_get_groups_constraints(self):
 
         # username and user are mutually exclusive
         from plone.api.exc import InvalidParameterError
-        self.assertRaises(
-            InvalidParameterError,
-            api.group.get_groups,
-            username='chuck', user=mock.Mock(),
-        )
+        with self.assertRaises(InvalidParameterError):
+            api.group.get_groups(
+                username='chuck',
+                user=mock.Mock(),
+            )
 
     def test_get_groups_user(self):
         """Test retrieving of groups that the user is member of."""
@@ -136,26 +140,23 @@ def test_get_groups_username(self):
     def test_get_groups_nonexistant_user(self):
         """Test retrieving of groups for a user that does not exist."""
         from plone.api.exc import UserNotFoundError
-        self.assertRaises(
-            UserNotFoundError,
-            api.group.get_groups,
-            username='theurbanspaceman',
-        )
+        with self.assertRaises(UserNotFoundError):
+            api.group.get_groups(username='theurbanspaceman')
 
     def test_delete_contraints(self):
         """Test deleting a group without passing parameters."""
         from plone.api.exc import MissingParameterError
-        self.assertRaises(MissingParameterError, api.group.delete)
+        with self.assertRaises(MissingParameterError):
+            api.group.delete()
 
     def test_delete_groupname_and_group(self):
         """Test deleting a group passing both groupname and group."""
         from plone.api.exc import InvalidParameterError
-        self.assertRaises(
-            InvalidParameterError,
-            api.group.delete,
-            groupname='bacon',
-            group=mock.Mock(),
-        )
+        with self.assertRaises(InvalidParameterError):
+            api.group.delete(
+                groupname='bacon',
+                group=mock.Mock(),
+            )
 
     def test_delete_group_groupname(self):
         """Test deleting a group by groupname."""
@@ -178,25 +179,25 @@ def test_delete_group_group(self):
     def test_add_user_contraints(self):
         """Test the constraints when a user is added to a group."""
         from plone.api.exc import InvalidParameterError
-        self.assertRaises(
-            InvalidParameterError,
-            api.group.add_user,
-            groupname='staff', group=mock.Mock(),
-        )
+        with self.assertRaises(InvalidParameterError):
+            api.group.add_user(
+                groupname='staff',
+                group=mock.Mock(),
+            )
 
     def test_add_user_username_and_user(self):
         """Test adding a user to a group passing both username and user."""
         from plone.api.exc import InvalidParameterError
-        self.assertRaises(
-            InvalidParameterError,
-            api.group.add_user,
-            groupname='staff',
-            username='staff',
-            user=mock.Mock()
-        )
+        with self.assertRaises(InvalidParameterError):
+            api.group.add_user(
+                groupname='staff',
+                username='staff',
+                user=mock.Mock()
+            )
 
     def test_add_user_with_nonexistant_group(self):
         """Test adding a user to a group that does not exist."""
+
         self.assertRaises(
             KeyError,
             api.group.add_user,
@@ -245,33 +246,25 @@ def test_remove_user_contraints(self):
         from plone.api.exc import MissingParameterError
 
         # Arguments ``groupname`` and ``group`` are mutually exclusive.
-        self.assertRaises(
-            InvalidParameterError,
-            api.group.remove_user,
-            username='jane',
-            groupname='staff',
-            group=mock.Mock(),
-        )
+        with self.assertRaises(InvalidParameterError):
+            api.group.remove_user(
+                username='jane',
+                groupname='staff',
+                group=mock.Mock(),
+            )
         # Arguments ``username`` and ``user`` are mutually exclusive.
-        self.assertRaises(
-            InvalidParameterError,
-            api.group.remove_user,
-            groupname='staff',
-            username='jane',
-            user=mock.Mock(),
-        )
+        with self.assertRaises(InvalidParameterError):
+            api.group.remove_user(
+                groupname='staff',
+                username='jane',
+                user=mock.Mock(),
+            )
         # At least one of ``username`` and ``user`` must be provided
-        self.assertRaises(
-            MissingParameterError,
-            api.group.remove_user,
-            groupname='staff',
-        )
+        with self.assertRaises(MissingParameterError):
+            api.group.remove_user(groupname='staff')
         # At least one of ``groupname`` and ``group`` must be provided
-        self.assertRaises(
-            MissingParameterError,
-            api.group.remove_user,
-            username='jane',
-        )
+        with self.assertRaises(MissingParameterError):
+            api.group.remove_user(username='jane')
 
     def test_remove_user(self):
         """Test removing a user from a group."""
@@ -312,36 +305,30 @@ def test_grant_roles(self):
         group = api.group.create(groupname='foo')
 
         # You can't grant Anonymous
-        self.assertRaises(
-            ValueError,
-            api.group.grant_roles,
-            groupname='foo',
-            roles=['Anonymous'],
-        )
+        with self.assertRaises(ValueError):
+            api.group.grant_roles(
+                groupname='foo',
+                roles=['Anonymous'],
+            )
 
         # You can't grant Authenticated
-        self.assertRaises(
-            ValueError,
-            api.group.grant_roles,
-            groupname='foo',
-            roles=['Authenticated'],
-        )
+        with self.assertRaises(ValueError):
+            api.group.grant_roles(
+                groupname='foo',
+                roles=['Authenticated'],
+            )
 
         # Roles are required
-        self.assertRaises(
-            MissingParameterError,
-            api.group.grant_roles,
-            groupname='foo',
-        )
+        with self.assertRaises(MissingParameterError):
+            api.group.grant_roles(groupname='foo')
 
         # Groupname and group are mutually exclusive
-        self.assertRaises(
-            InvalidParameterError,
-            api.group.grant_roles,
-            groupname='foo',
-            group=group,
-            roles=['Reviewer'],
-        )
+        with self.assertRaises(InvalidParameterError):
+            api.group.grant_roles(
+                groupname='foo',
+                group=group,
+                roles=['Reviewer'],
+            )
 
         api.group.grant_roles(groupname='foo', roles=['Editor'])
         self.assertIn('Editor', api.group.get_roles(groupname='foo'))
@@ -363,36 +350,30 @@ def test_revoke_roles(self):
         group = api.group.create(groupname='bar')
 
         # You can't revoke Anonymous
-        self.assertRaises(
-            ValueError,
-            api.group.revoke_roles,
-            groupname='bar',
-            roles=['Anonymous'],
-        )
+        with self.assertRaises(ValueError):
+            api.group.revoke_roles(
+                groupname='bar',
+                roles=['Anonymous'],
+            )
 
         # You can't revoke Authenticated
-        self.assertRaises(
-            ValueError,
-            api.group.revoke_roles,
-            groupname='bar',
-            roles=['Authenticated'],
-        )
+        with self.assertRaises(ValueError):
+            api.group.revoke_roles(
+                groupname='bar',
+                roles=['Authenticated'],
+            )
 
         # Roles are required
-        self.assertRaises(
-            MissingParameterError,
-            api.group.revoke_roles,
-            groupname='foo',
-        )
+        with self.assertRaises(MissingParameterError):
+            api.group.revoke_roles(groupname='foo')
 
         # Groupname and group are mutually exclusive
-        self.assertRaises(
-            InvalidParameterError,
-            api.group.revoke_roles,
-            groupname='foo',
-            group=group,
-            roles=['Reviewer'],
-        )
+        with self.assertRaises(InvalidParameterError):
+            api.group.revoke_roles(
+                groupname='foo',
+                group=group,
+                roles=['Reviewer'],
+            )
 
         api.group.grant_roles(groupname='bar', roles=['Reviewer', 'Editor'])
 
diff --git a/src/plone/api/tests/test_portal.py b/src/plone/api/tests/test_portal.py
index 7b7c1a22..1474f012 100644
--- a/src/plone/api/tests/test_portal.py
+++ b/src/plone/api/tests/test_portal.py
@@ -73,14 +73,16 @@ def test_get_no_site(self, getSite):
         """Test error msg when getSite() returns None."""
         getSite.return_value = None
         from plone.api.exc import CannotGetPortalError
-        self.assertRaises(CannotGetPortalError, portal.get)
+        with self.assertRaises(CannotGetPortalError):
+            portal.get()
 
     def test_get_tool_constraints(self):
         """Test the constraints for getting a tool."""
 
         # When no parameters are given an error is raised
         from plone.api.exc import MissingParameterError
-        self.assertRaises(MissingParameterError, portal.get_tool)
+        with self.assertRaises(MissingParameterError):
+            portal.get_tool()
 
     def test_get_tool_tool_not_found(self):
         """Test that error msg lists available tools if a tool is not found."""
@@ -147,27 +149,25 @@ def test_send_email_constraints(self):
         from plone.api.exc import MissingParameterError
 
         # When no parameters are given an error is raised
-        self.assertRaises(MissingParameterError, portal.send_email)
+        with self.assertRaises(MissingParameterError):
+            portal.send_email()
 
         # recipient, subject and body are required
-        self.assertRaises(
-            MissingParameterError,
-            portal.send_email,
-            subject='Beer',
-            body="To beer or not to beer, that is the question",
-        )
-        self.assertRaises(
-            MissingParameterError,
-            portal.send_email,
-            recipient='joe@example.org',
-            subject='Beer',
-        )
-        self.assertRaises(
-            MissingParameterError,
-            portal.send_email,
-            recipient='joe@example.org',
-            body="To beer or not to beer, that is the question",
-        )
+        with self.assertRaises(MissingParameterError):
+            portal.send_email(
+                subject='Beer',
+                body="To beer or not to beer, that is the question",
+            )
+        with self.assertRaises(MissingParameterError):
+            portal.send_email(
+                recipient='joe@example.org',
+                subject='Beer',
+            )
+        with self.assertRaises(MissingParameterError):
+            portal.send_email(
+                recipient='joe@example.org',
+                body="To beer or not to beer, that is the question",
+            )
 
     def test_send_email(self):
         """Test sending mail."""
@@ -205,14 +205,13 @@ def test_send_email_without_configured_mailhost(self):
         send email.
         """
         self.portal._updateProperty('email_from_address', None)
-        self.assertRaises(
-            ValueError,
-            portal.send_email,
-            recipient="bob@plone.org",
-            sender="noreply@plone.org",
-            subject="Trappist",
-            body=u"One for you Bob!",
-        )
+        with self.assertRaises(ValueError):
+            portal.send_email(
+                recipient="bob@plone.org",
+                sender="noreply@plone.org",
+                subject="Trappist",
+                body=u"One for you Bob!",
+            )
 
     @mock.patch('plone.api.portal.parseaddr')
     def test_send_email_parseaddr(self, mock_parseaddr):
@@ -234,7 +233,8 @@ def test_get_localized_time_constraints(self):
 
         # When no parameters are given an error is raised
         from plone.api.exc import MissingParameterError
-        self.assertRaises(MissingParameterError, portal.get_localized_time)
+        with self.assertRaises(MissingParameterError):
+            portal.get_localized_time()
 
     def test_get_localized_time(self):
         """Test getting the localized time."""
@@ -289,19 +289,15 @@ def test_show_message_constraints(self):
         from plone.api.exc import MissingParameterError
 
         # When no parameters are given an error is raised
-        self.assertRaises(MissingParameterError, portal.show_message)
+        with self.assertRaises(MissingParameterError):
+            portal.show_message()
 
         # message and request are required
-        self.assertRaises(
-            MissingParameterError,
-            portal.show_message,
-            request=self.layer['request'],
-        )
-        self.assertRaises(
-            MissingParameterError,
-            portal.show_message,
-            message='Beer is brewing.',
-        )
+        with self.assertRaises(MissingParameterError):
+            portal.show_message(request=self.layer['request'])
+
+        with self.assertRaises(MissingParameterError):
+            portal.show_message(message='Beer is brewing.')
 
     def test_show_message(self):
         """Test to see if message appears."""
@@ -328,7 +324,8 @@ def test_get_navigation_root(self):
         self.assertTrue(INavigationRoot.providedBy(navigation_root))
 
         from plone.api.exc import MissingParameterError
-        self.assertRaises(MissingParameterError, portal.get_navigation_root)
+        with self.assertRaises(MissingParameterError):
+            portal.get_navigation_root()
 
     def test_get_existing_registry_record(self):
         """Test that existing registry records are returned correctly."""
@@ -401,19 +398,19 @@ def test_set_missing_param_registry_record(self):
         parameters, a MissingParameterError exception is raised.
         """
         from plone.api.exc import MissingParameterError
-        self.assertRaises(MissingParameterError, portal.set_registry_record)
+        with self.assertRaises(MissingParameterError):
+            portal.set_registry_record()
 
     def test_set_non_existing_record_value(self):
         """Test that setting the value of a non existent record raises
         an Exception.
         """
         from plone.api.exc import InvalidParameterError
-        self.assertRaises(
-            InvalidParameterError,
-            portal.set_registry_record,
-            name='nonexistent.sharepoint.power',
-            value=u'Zero',
-        )
+        with self.assertRaises(InvalidParameterError):
+            portal.set_registry_record(
+                name='nonexistent.sharepoint.power',
+                value=u'Zero',
+            )
 
     def test_set_no_value_param_for_existing_record(self):
         """Test that calling portal.set_registry_record with a name
@@ -425,18 +422,16 @@ def test_set_no_value_param_for_existing_record(self):
             field.TextLine(title=u"Plone's Power"))
 
         from plone.api.exc import MissingParameterError
-        self.assertRaises(
-            MissingParameterError, portal.set_registry_record,
-            name='plone.api.plone_power',
-        )
+        with self.assertRaises(MissingParameterError):
+            portal.set_registry_record(name='plone.api.plone_power')
 
     def test_set_invalid_key_type_record(self):
         """Test that trying to set the value of a record by passing a
         list for the record name instead of a string, raises an error.
         """
         from plone.api.exc import InvalidParameterError
-        self.assertRaises(
-            InvalidParameterError, portal.set_registry_record,
-            name=['foo', 'bar'],
-            value=u"baz",
-        )
+        with self.assertRaises(InvalidParameterError):
+            portal.set_registry_record(
+                name=['foo', 'bar'],
+                value=u"baz",
+            )
diff --git a/src/plone/api/tests/test_user.py b/src/plone/api/tests/test_user.py
index 2c26f68a..e7a43633 100644
--- a/src/plone/api/tests/test_user.py
+++ b/src/plone/api/tests/test_user.py
@@ -42,11 +42,11 @@ def test_create_no_email(self):
         self.portal.portal_properties.site_properties.use_email_as_login = True
 
         from plone.api.exc import MissingParameterError
-        self.assertRaises(
-            MissingParameterError,
-            api.user.create,
-            username='chuck', password='secret'
-        )
+        with self.assertRaises(MissingParameterError):
+            api.user.create(
+                username='chuck',
+                password='secret',
+            )
 
     def test_get_user_userid_username(self):
         """Enforce user.get works with username and userid."""
@@ -89,11 +89,11 @@ def test_create_no_username(self):
         properties.manage_changeProperties(use_email_as_login=False)
 
         from plone.api.exc import InvalidParameterError
-        self.assertRaises(
-            InvalidParameterError,
-            api.user.create,
-            email='chuck@norris.org', password='secret'
-        )
+        with self.assertRaises(InvalidParameterError):
+            api.user.create(
+                email='chuck@norris.org',
+                password='secret',
+            )
 
     def test_create_with_username(self):
         """Test if the correct username if used."""
@@ -161,10 +161,8 @@ def test_get_constraints(self):
         the user.
         """
         from plone.api.exc import MissingParameterError
-        self.assertRaises(
-            MissingParameterError,
-            api.user.get
-        )
+        with self.assertRaises(MissingParameterError):
+            api.user.get()
 
     def test_get(self):
         """Test getting the user."""
@@ -212,20 +210,18 @@ def test_get_users_groupname_and_group(self):
         bacon = api.group.get(groupname='bacon')
 
         from plone.api.exc import InvalidParameterError
-        self.assertRaises(
-            InvalidParameterError,
-            api.user.get_users,
-            groupname='bacon',
-            group=bacon)
+        with self.assertRaises(InvalidParameterError):
+            api.user.get_users(
+                groupname='bacon',
+                group=bacon,
+            )
 
     def test_get_users_nonexistent_group(self):
         """Test getting users for a group that does not exist."""
 
         from plone.api.exc import GroupNotFoundError
-        self.assertRaises(
-            GroupNotFoundError,
-            api.user.get_users,
-            groupname='bacon')
+        with self.assertRaises(GroupNotFoundError):
+            api.user.get_users(groupname='bacon')
 
     def test_delete_no_username(self):
         """Test deleting of a member with email login."""
@@ -234,11 +230,15 @@ def test_delete_no_username(self):
 
         # This should fail either an username or user object should be given
         from plone.api.exc import MissingParameterError
-        self.assertRaises(MissingParameterError, api.user.delete)
+        with self.assertRaises(MissingParameterError):
+            api.user.delete()
 
         from plone.api.exc import InvalidParameterError
-        self.assertRaises(InvalidParameterError, api.user.delete,
-                          username='chuck@norris.org', user=mock.Mock())
+        with self.assertRaises(InvalidParameterError):
+            api.user.delete(
+                username='chuck@norris.org',
+                user=mock.Mock()
+            )
 
         api.user.create(email='chuck@norris.org', password='secret')
         api.user.delete(username='unwanted@norris.org')
@@ -299,11 +299,11 @@ def test_get_roles_username_and_user(self):
         )
 
         from plone.api.exc import InvalidParameterError
-        self.assertRaises(
-            InvalidParameterError,
-            api.user.get_roles,
-            username='chuck',
-            user=user)
+        with self.assertRaises(InvalidParameterError):
+            api.user.get_roles(
+                username='chuck',
+                user=user
+            )
 
     def test_get_roles_no_parameters(self):
         """Test get roles without any parameters."""
@@ -320,11 +320,8 @@ def test_get_permissions_no_parameters(self):
     def test_get_roles_nonexistant_user(self):
         """Test get roles for a user that does not exist."""
         from plone.api.exc import UserNotFoundError
-        self.assertRaises(
-            UserNotFoundError,
-            api.user.get_roles,
-            username='theurbanspaceman',
-        )
+        with self.assertRaises(UserNotFoundError):
+            api.user.get_roles(username='theurbanspaceman')
 
     def test_get_permissions_root(self):
         """Test get permissions on site root."""
@@ -337,11 +334,11 @@ def test_get_permissions_root(self):
         )
 
         from plone.api.exc import InvalidParameterError
-        self.assertRaises(
-            InvalidParameterError,
-            api.user.get_permissions,
-            username='chuck',
-            user=user)
+        with self.assertRaises(InvalidParameterError):
+            api.user.get_permissions(
+                username='chuck',
+                user=user
+            )
 
         PERMISSIONS = {
             'View': True,
@@ -364,11 +361,8 @@ def test_get_permissions_nonexistant_user(self):
         """Test get_permissions for a user that does not exist."""
 
         from plone.api.exc import UserNotFoundError
-        self.assertRaises(
-            UserNotFoundError,
-            api.user.get_permissions,
-            username='ming',
-        )
+        with self.assertRaises(UserNotFoundError):
+            api.user.get_permissions(username='ming')
 
     def test_get_permissions_context(self):
         """Test get permissions on some context."""
@@ -381,12 +375,11 @@ def test_get_permissions_context(self):
         )
 
         from plone.api.exc import InvalidParameterError
-        self.assertRaises(
-            InvalidParameterError,
-            api.user.get_permissions,
-            username='chuck',
-            user=user,
-        )
+        with self.assertRaises(InvalidParameterError):
+            api.user.get_permissions(
+                username='chuck',
+                user=user,
+            )
 
         PERMISSIONS = {
             'View': False,
@@ -446,40 +439,33 @@ def test_grant_roles_username_and_user(self):
         )
 
         from plone.api.exc import MissingParameterError
-        self.assertRaises(
-            MissingParameterError,
-            api.user.grant_roles,
-            username=user,
-        )
+        with self.assertRaises(MissingParameterError):
+            api.user.grant_roles(username=user)
 
     def test_grant_roles_anonymous(self):
         """Test granting Anonymous role."""
 
         from plone.api.exc import InvalidParameterError
-        self.assertRaises(
-            InvalidParameterError,
-            api.user.grant_roles,
-            username='chuck',
-            roles=['Anonymous'],
-        )
+        with self.assertRaises(InvalidParameterError):
+            api.user.grant_roles(
+                username='chuck',
+                roles=['Anonymous'],
+            )
 
     def test_grant_roles_authenticated(self):
         """Test granting Authenticated role."""
         from plone.api.exc import InvalidParameterError
-        self.assertRaises(
-            InvalidParameterError,
-            api.user.grant_roles,
-            username='chuck',
-            roles=['Authenticated'],
-        )
+        with self.assertRaises(InvalidParameterError):
+            api.user.grant_roles(
+                username='chuck',
+                roles=['Authenticated'],
+            )
 
     def test_grant_roles_no_parameters(self):
         """Test grant roles without passing parameters."""
         from plone.api.exc import MissingParameterError
-        self.assertRaises(
-            MissingParameterError,
-            api.user.grant_roles,
-        )
+        with self.assertRaises(MissingParameterError):
+            api.user.grant_roles()
 
     def test_revoke_roles(self):
         """Test revoke roles."""
@@ -512,42 +498,35 @@ def test_revoke_roles_username_and_user(self):
         )
 
         from plone.api.exc import MissingParameterError
-        self.assertRaises(
-            MissingParameterError,
-            api.user.revoke_roles,
-            user=user,
-        )
+        with self.assertRaises(MissingParameterError):
+            api.user.revoke_roles(user=user)
 
     def test_revoke_roles_anonymous(self):
         """Test revoking Anonymous role."""
 
         from plone.api.exc import InvalidParameterError
-        self.assertRaises(
-            InvalidParameterError,
-            api.user.revoke_roles,
-            username='chuck',
-            roles=['Anonymous'],
-        )
+        with self.assertRaises(InvalidParameterError):
+            api.user.revoke_roles(
+                username='chuck',
+                roles=['Anonymous'],
+            )
 
     def test_revoke_roles_authenticated(self):
         """Test revoking Authenticated role."""
 
         from plone.api.exc import InvalidParameterError
-        self.assertRaises(
-            InvalidParameterError,
-            api.user.revoke_roles,
-            username='chuck',
-            roles=['Authenticated'],
-        )
+        with self.assertRaises(InvalidParameterError):
+            api.user.revoke_roles(
+                username='chuck',
+                roles=['Authenticated'],
+            )
 
     def test_revoke_roles_no_parameters(self):
         """Test revoke roles without passing parameters."""
 
         from plone.api.exc import MissingParameterError
-        self.assertRaises(
-            MissingParameterError,
-            api.user.revoke_roles,
-        )
+        with self.assertRaises(MissingParameterError):
+            api.user.revoke_roles()
 
     @unittest.skip("Getting the Anonymous user does not work like this.")
     def test_revoke_roles_from_anonymous(self):
diff --git a/src/plone/api/tests/test_validation.py b/src/plone/api/tests/test_validation.py
index a00069ef..218d8b0f 100644
--- a/src/plone/api/tests/test_validation.py
+++ b/src/plone/api/tests/test_validation.py
@@ -43,15 +43,17 @@ def test_non_existant_required_arg(self):
         """Test that ValueError is returned if the decorator requires
         a parameter that doesn't exist in the function signature.
         """
-        self.assertRaises(
-            ValueError,
-            required_parameters('arg1', 'wibble', 'wobble'),
-            undecorated_func)
-
-        self.assertRaises(
-            ValueError,
-            mutually_exclusive_parameters('arg1', 'wibble', 'wobble'),
-            undecorated_func)
+        with self.assertRaises(ValueError):
+            _func = required_parameters('arg1', 'wibble', 'wobble')
+            _func(undecorated_func)
+
+        with self.assertRaises(ValueError):
+            _func = mutually_exclusive_parameters(
+                'arg1',
+                'wibble',
+                'wobble'
+            )
+            _func(undecorated_func)
 
     def test_get_supplied_args(self):
         """Test that positional and keyword args are recognised correctly."""
@@ -101,7 +103,8 @@ def test_single_arg_missing(self):
         """
         from plone.api.exc import MissingParameterError
         _func = required_parameters('arg1')(undecorated_func)
-        self.assertRaises(MissingParameterError, _func)
+        with self.assertRaises(MissingParameterError):
+            _func()
 
     def test_one_missing_one_provided(self):
         """Test that MissingParameterError is raised if only one of the
@@ -109,7 +112,8 @@ def test_one_missing_one_provided(self):
         """
         from plone.api.exc import MissingParameterError
         _func = required_parameters('arg1', 'arg2')(undecorated_func)
-        self.assertRaises(MissingParameterError, _func, 'hello')
+        with self.assertRaises(MissingParameterError):
+            _func('hello')
 
     def test_no_mutually_exclusive_args_provided(self):
         """Test for passing no args (valid) to a function that specifies
@@ -134,9 +138,11 @@ def test_two_mutually_exclusive_args_provided(self):
         """
         from plone.api.exc import InvalidParameterError
         _func = mutually_exclusive_parameters('arg1', 'arg2')(undecorated_func)
-        self.assertRaises(InvalidParameterError, _func, 'ahoy', 'there')
-        self.assertRaises(
-            InvalidParameterError, _func, arg1='ahoy', arg2='there')
+        with self.assertRaises(InvalidParameterError):
+            _func('ahoy', 'there')
+
+        with self.assertRaises(InvalidParameterError):
+            _func(arg1='ahoy', arg2='there')
 
     def test_require_at_least_one_but_none_provided(self):
         """Test that MissingParameterError is raised if no argument is supplied
@@ -144,7 +150,8 @@ def test_require_at_least_one_but_none_provided(self):
         """
         from plone.api.exc import MissingParameterError
         _func = at_least_one_of('arg1', 'arg2')(undecorated_func)
-        self.assertRaises(MissingParameterError, _func)
+        with self.assertRaises(MissingParameterError):
+            _func()
 
     def test_require_at_least_one_and_one_provided(self):
         """Test for passing one argument when at least one is required."""
@@ -170,27 +177,25 @@ def _func1_decorated(arg1=None, arg2=None, arg3=None):
         from plone.api.exc import MissingParameterError
 
         # test that the required parameter error works (missing arg1)
-        self.assertRaises(
-            MissingParameterError, _func1_decorated, arg2='ahoy')
+        with self.assertRaises(MissingParameterError):
+            _func1_decorated(arg2='ahoy')
 
         # test that the mutually exclusive decorator works
         # (arg2 and arg3 should not be there)
-        self.assertRaises(
-            InvalidParameterError,
-            _func1_decorated,
-            arg1='ahoy',
-            arg2='there',
-            arg3='matey',
-        )
+        with self.assertRaises(InvalidParameterError):
+            _func1_decorated(
+                arg1='ahoy',
+                arg2='there',
+                arg3='matey',
+            )
 
         # test that they both work.  Making no assumptions here about the order
         # in which they fire.
-        self.assertRaises(
-            (InvalidParameterError, MissingParameterError),
-            _func1_decorated,
-            arg2='ahoy',
-            arg3='there',
-        )
+        with self.assertRaises((InvalidParameterError, MissingParameterError)):
+            _func1_decorated(
+                arg2='ahoy',
+                arg3='there',
+            )
 
         # everything ok
         self.assertEqual(_func1_decorated('ahoy', arg3='there'), 'foo')
@@ -209,12 +214,12 @@ def _func1_decorated(arg1=None, arg2=None, arg3=None):
         from plone.api.exc import MissingParameterError
 
         # test it errors if you provide none
-        self.assertRaises(
-            MissingParameterError, _func1_decorated)
+        with self.assertRaises(MissingParameterError):
+            _func1_decorated()
 
         # test that it errors if you provide both
-        self.assertRaises(
-            InvalidParameterError, _func1_decorated, 'ahoy', 'there')
+        with self.assertRaises(InvalidParameterError):
+            _func1_decorated('ahoy', 'there')
 
         # everything ok
         self.assertEqual(_func1_decorated('ahoy'), 'foo')