Replace unitttest assertRaises with pytest.raises

Replaces all uses of self.assertRaises and self.assertRaisesRegex with
pytest.raises.
I started this commit with command `unittest2pytest -f self_assert
./tests -w -n`. After it finished, I manually reviewed all differences,
and performed fixes where necessary / useful. There were two types of
fixes:
- When using output value of context manager (with ... as X), unittest
exposes the thrown exception as X.exception, while pytest as X.value.
- In few places there were calls like `self.assertRaises(T, func,
**{'arg': val, ...}`. Passing args as dict with ** is not pretty, so I
desugared this into directly passing named args.

Author: Lorak-mmk

tests/integration/cqlengine/columns/test_container_columns.py

@@ -73,7 +73,8 @@ def tearDownClass(cls):
         drop_table(TestSetModel)
 
     def test_add_none_fails(self):
-        self.assertRaises(ValidationError, TestSetModel.create, **{'int_set': set([None])})
+        with pytest.raises(ValidationError):
+            TestSetModel.create(int_set=set([None]))
 
     def test_empty_set_initial(self):
         """
@@ -127,7 +128,8 @@ def test_type_validation(self):
         """
         Tests that attempting to use the wrong types will raise an exception
         """
-        self.assertRaises(ValidationError, TestSetModel.create, **{'int_set': set(('string', True)), 'text_set': set((1, 3.0))})
+        with pytest.raises(ValidationError):
+            TestSetModel.create(int_set=set(('string', True)), text_set=set((1, 3.0)))
 
     def test_element_count_validation(self):
         """
@@ -144,7 +146,8 @@ def test_element_count_validation(self):
             except OperationTimedOut:
                 #This will happen if the host is remote
                 assert not CASSANDRA_IP.startswith("127.0.0.")
-        self.assertRaises(ValidationError, TestSetModel.create, **{'text_set': set(str(uuid4()) for i in range(65536))})
+        with pytest.raises(ValidationError):
+            TestSetModel.create(text_set=set(str(uuid4()) for i in range(65536)))
 
     def test_partial_updates(self):
         """ Tests that partial udpates work as expected """
@@ -244,7 +247,8 @@ def test_type_validation(self):
         """
         Tests that attempting to use the wrong types will raise an exception
         """
-        self.assertRaises(ValidationError, TestListModel.create, **{'int_list': ['string', True], 'text_list': [1, 3.0]})
+        with pytest.raises(ValidationError):
+            TestListModel.create(int_list=['string', True], text_list=[1, 3.0])
 
     def test_element_count_validation(self):
         """
@@ -258,7 +262,8 @@ def test_element_count_validation(self):
                 ex_type, ex, tb = sys.exc_info()
                 log.warning("{0}: {1} Backtrace: {2}".format(ex_type.__name__, ex, traceback.extract_tb(tb)))
                 del tb
-        self.assertRaises(ValidationError, TestListModel.create, **{'text_list': [str(uuid4()) for _ in range(65536)]})
+        with pytest.raises(ValidationError):
+            TestListModel.create(text_list=[str(uuid4()) for _ in range(65536)])
 
     def test_partial_updates(self):
         """ Tests that partial udpates work as expected """
@@ -332,7 +337,8 @@ def test_update_from_non_empty_to_empty(self):
 
     def test_insert_none(self):
         pkey = uuid4()
-        self.assertRaises(ValidationError, TestListModel.create, **{'partition': pkey, 'int_list': [None]})
+        with pytest.raises(ValidationError):
+            TestListModel.create(partition=pkey, int_list=[None])
 
     def test_blind_list_updates_from_none(self):
         """ Tests that updates from None work as expected """
@@ -374,7 +380,8 @@ def test_empty_default(self):
         tmp.int_map['blah'] = 1
 
     def test_add_none_as_map_key(self):
-        self.assertRaises(ValidationError, TestMapModel.create, **{'int_map': {None: uuid4()}})
+        with pytest.raises(ValidationError):
+            TestMapModel.create(int_map={None: uuid4()})
 
     def test_empty_retrieve(self):
         tmp = TestMapModel.create()
@@ -416,7 +423,8 @@ def test_type_validation(self):
         """
         Tests that attempting to use the wrong types will raise an exception
         """
-        self.assertRaises(ValidationError, TestMapModel.create, **{'int_map': {'key': 2, uuid4(): 'val'}, 'text_map': {2: 5}})
+        with pytest.raises(ValidationError):
+            TestMapModel.create(int_map={'key': 2, uuid4(): 'val'}, text_map={2: 5})
 
     def test_element_count_validation(self):
         """
@@ -430,7 +438,8 @@ def test_element_count_validation(self):
                 ex_type, ex, tb = sys.exc_info()
                 log.warning("{0}: {1} Backtrace: {2}".format(ex_type.__name__, ex, traceback.extract_tb(tb)))
                 del tb
-        self.assertRaises(ValidationError, TestMapModel.create, **{'text_map': dict((str(uuid4()), i) for i in range(65536))})
+        with pytest.raises(ValidationError):
+            TestMapModel.create(text_map=dict((str(uuid4()), i) for i in range(65536)))
 
     def test_partial_updates(self):
         """ Tests that partial udpates work as expected """
@@ -636,9 +645,12 @@ def test_type_validation(self):
 
         @test_category object_mapper
         """
-        self.assertRaises(ValidationError, TestTupleModel.create, **{'int_tuple': ('string', True), 'text_tuple': ('test', 'test'), 'mixed_tuple': ('one', 2, 'three')})
-        self.assertRaises(ValidationError, TestTupleModel.create, **{'int_tuple': ('string', 'string'), 'text_tuple': (1, 3.0), 'mixed_tuple': ('one', 2, 'three')})
-        self.assertRaises(ValidationError, TestTupleModel.create, **{'int_tuple': ('string', 'string'), 'text_tuple': ('test', 'test'), 'mixed_tuple': (1, "two", 3)})
+        with pytest.raises(ValidationError):
+            TestTupleModel.create(int_tuple=('string', True), text_tuple=('test', 'test'), mixed_tuple=('one', 2, 'three'))
+        with pytest.raises(ValidationError):
+            TestTupleModel.create(int_tuple=('string', 'string'), text_tuple=(1, 3.0), mixed_tuple=('one', 2, 'three'))
+        with pytest.raises(ValidationError):
+            TestTupleModel.create(int_tuple=('string', 'string'), text_tuple=('test', 'test'), mixed_tuple=(1, "two", 3))
 
     def test_instantiation_with_column_class(self):
         """
@@ -854,12 +866,18 @@ def test_type_validation(self):
         set_tuple_bad_tuple_value = set((("text", "text"), ("text", "text"), ("text", "text")))
         set_tuple_not_set = ['This', 'is', 'not', 'a', 'set']
 
-        self.assertRaises(ValidationError, TestNestedModel.create, **{'list_list': list_list_bad_list_context})
-        self.assertRaises(ValidationError, TestNestedModel.create, **{'list_list': list_list_no_list})
-        self.assertRaises(ValidationError, TestNestedModel.create, **{'map_list': map_list_bad_value})
-        self.assertRaises(ValidationError, TestNestedModel.create, **{'map_list': map_list_bad_key})
-        self.assertRaises(ValidationError, TestNestedModel.create, **{'set_tuple': set_tuple_bad_tuple_value})
-        self.assertRaises(ValidationError, TestNestedModel.create, **{'set_tuple': set_tuple_not_set})
+        with pytest.raises(ValidationError):
+            TestNestedModel.create(list_list=list_list_bad_list_context)
+        with pytest.raises(ValidationError):
+            TestNestedModel.create(list_list=list_list_no_list)
+        with pytest.raises(ValidationError):
+            TestNestedModel.create(map_list=map_list_bad_value)
+        with pytest.raises(ValidationError):
+            TestNestedModel.create(map_list=map_list_bad_key)
+        with pytest.raises(ValidationError):
+            TestNestedModel.create(set_tuple=set_tuple_bad_tuple_value)
+        with pytest.raises(ValidationError):
+            TestNestedModel.create(set_tuple=set_tuple_not_set)
 
     def test_instantiation_with_column_class(self):
         """

tests/integration/cqlengine/columns/test_validation.py

@@ -33,6 +33,7 @@
 
 from tests.integration import PROTOCOL_VERSION, CASSANDRA_VERSION, greaterthanorequalcass30, greaterthanorequalcass3_11
 from tests.integration.cqlengine.base import BaseCassEngTestCase
+import pytest
 
 
 class TestDatetime(BaseCassEngTestCase):
@@ -90,7 +91,7 @@ def test_datetime_none(self):
 
     def test_datetime_invalid(self):
         dt_value= 'INVALID'
-        with self.assertRaises(TypeError):
+        with pytest.raises(TypeError):
             self.DatetimeTest.objects.create(test_id=4, created_at=dt_value)
 
     def test_datetime_timestamp(self):
@@ -185,7 +186,7 @@ def test_varint_io(self):
         int2 = self.VarIntTest.objects(test_id=0).first()
         assert int1.bignum == int2.bignum
 
-        with self.assertRaises(ValidationError):
+        with pytest.raises(ValidationError):
             self.VarIntTest.objects.create(test_id=0, bignum="not_a_number")
 
 
@@ -541,22 +542,22 @@ def test_min_length(self):
         Ascii(min_length=5).validate('kevin')
         Ascii(min_length=5).validate('kevintastic')
 
-        with self.assertRaises(ValidationError):
+        with pytest.raises(ValidationError):
             Ascii(min_length=1).validate('')
 
-        with self.assertRaises(ValidationError):
+        with pytest.raises(ValidationError):
             Ascii(min_length=1).validate(None)
 
-        with self.assertRaises(ValidationError):
+        with pytest.raises(ValidationError):
             Ascii(min_length=6).validate('')
 
-        with self.assertRaises(ValidationError):
+        with pytest.raises(ValidationError):
             Ascii(min_length=6).validate(None)
 
-        with self.assertRaises(ValidationError):
+        with pytest.raises(ValidationError):
             Ascii(min_length=6).validate('kevin')
 
-        with self.assertRaises(ValueError):
+        with pytest.raises(ValueError):
             Ascii(min_length=-1)
 
     def test_max_length(self):
@@ -573,13 +574,13 @@ def test_max_length(self):
         Ascii(max_length=5).validate('b')
         Ascii(max_length=5).validate('blake')
 
-        with self.assertRaises(ValidationError):
+        with pytest.raises(ValidationError):
             Ascii(max_length=0).validate('b')
 
-        with self.assertRaises(ValidationError):
+        with pytest.raises(ValidationError):
             Ascii(max_length=5).validate('blaketastic')
 
-        with self.assertRaises(ValueError):
+        with pytest.raises(ValueError):
             Ascii(max_length=-1)
 
     def test_length_range(self):
@@ -588,30 +589,30 @@ def test_length_range(self):
         Ascii(min_length=10, max_length=10)
         Ascii(min_length=10, max_length=11)
 
-        with self.assertRaises(ValueError):
+        with pytest.raises(ValueError):
             Ascii(min_length=10, max_length=9)
 
-        with self.assertRaises(ValueError):
+        with pytest.raises(ValueError):
             Ascii(min_length=1, max_length=0)
 
     def test_type_checking(self):
         Ascii().validate('string')
         Ascii().validate(u'unicode')
         Ascii().validate(bytearray('bytearray', encoding='ascii'))
 
-        with self.assertRaises(ValidationError):
+        with pytest.raises(ValidationError):
             Ascii().validate(5)
 
-        with self.assertRaises(ValidationError):
+        with pytest.raises(ValidationError):
             Ascii().validate(True)
 
         Ascii().validate("!#$%&\'()*+,-./")
 
-        with self.assertRaises(ValidationError):
+        with pytest.raises(ValidationError):
             Ascii().validate('Beyonc' + chr(233))
 
         if sys.version_info < (3, 1):
-            with self.assertRaises(ValidationError):
+            with pytest.raises(ValidationError):
                 Ascii().validate(u'Beyonc' + unichr(233))
 
     def test_unaltering_validation(self):
@@ -629,26 +630,26 @@ def test_required_validation(self):
         """ Tests that validation raise on none and blank values if value required. """
         Ascii(required=True).validate('k')
 
-        with self.assertRaises(ValidationError):
+        with pytest.raises(ValidationError):
             Ascii(required=True).validate('')
 
-        with self.assertRaises(ValidationError):
+        with pytest.raises(ValidationError):
             Ascii(required=True).validate(None)
 
         # With min_length set.
         Ascii(required=True, min_length=0).validate('k')
         Ascii(required=True, min_length=1).validate('k')
 
-        with self.assertRaises(ValidationError):
+        with pytest.raises(ValidationError):
             Ascii(required=True, min_length=2).validate('k')
 
         # With max_length set.
         Ascii(required=True, max_length=1).validate('k')
 
-        with self.assertRaises(ValidationError):
+        with pytest.raises(ValidationError):
             Ascii(required=True, max_length=2).validate('kevin')
 
-        with self.assertRaises(ValueError):
+        with pytest.raises(ValueError):
             Ascii(required=True, max_length=0)
 
 
@@ -668,22 +669,22 @@ def test_min_length(self):
         Text(min_length=5).validate('blake')
         Text(min_length=5).validate('blaketastic')
 
-        with self.assertRaises(ValidationError):
+        with pytest.raises(ValidationError):
             Text(min_length=1).validate('')
 
-        with self.assertRaises(ValidationError):
+        with pytest.raises(ValidationError):
             Text(min_length=1).validate(None)
 
-        with self.assertRaises(ValidationError):
+        with pytest.raises(ValidationError):
             Text(min_length=6).validate('')
 
-        with self.assertRaises(ValidationError):
+        with pytest.raises(ValidationError):
             Text(min_length=6).validate(None)
 
-        with self.assertRaises(ValidationError):
+        with pytest.raises(ValidationError):
             Text(min_length=6).validate('blake')
 
-        with self.assertRaises(ValueError):
+        with pytest.raises(ValueError):
             Text(min_length=-1)
 
     def test_max_length(self):
@@ -700,13 +701,13 @@ def test_max_length(self):
         Text(max_length=5).validate('b')
         Text(max_length=5).validate('blake')
 
-        with self.assertRaises(ValidationError):
+        with pytest.raises(ValidationError):
             Text(max_length=0).validate('b')
 
-        with self.assertRaises(ValidationError):
+        with pytest.raises(ValidationError):
             Text(max_length=5).validate('blaketastic')
 
-        with self.assertRaises(ValueError):
+        with pytest.raises(ValueError):
             Text(max_length=-1)
 
     def test_length_range(self):
@@ -715,21 +716,21 @@ def test_length_range(self):
         Text(min_length=10, max_length=10)
         Text(min_length=10, max_length=11)
 
-        with self.assertRaises(ValueError):
+        with pytest.raises(ValueError):
             Text(min_length=10, max_length=9)
 
-        with self.assertRaises(ValueError):
+        with pytest.raises(ValueError):
             Text(min_length=1, max_length=0)
 
     def test_type_checking(self):
         Text().validate('string')
         Text().validate(u'unicode')
         Text().validate(bytearray('bytearray', encoding='ascii'))
 
-        with self.assertRaises(ValidationError):
+        with pytest.raises(ValidationError):
             Text().validate(5)
 
-        with self.assertRaises(ValidationError):
+        with pytest.raises(ValidationError):
             Text().validate(True)
 
         Text().validate("!#$%&\'()*+,-./")
@@ -752,26 +753,26 @@ def test_required_validation(self):
         """ Tests that validation raise on none and blank values if value required. """
         Text(required=True).validate('b')
 
-        with self.assertRaises(ValidationError):
+        with pytest.raises(ValidationError):
             Text(required=True).validate('')
 
-        with self.assertRaises(ValidationError):
+        with pytest.raises(ValidationError):
             Text(required=True).validate(None)
 
         # With min_length set.
         Text(required=True, min_length=0).validate('b')
         Text(required=True, min_length=1).validate('b')
 
-        with self.assertRaises(ValidationError):
+        with pytest.raises(ValidationError):
             Text(required=True, min_length=2).validate('b')
 
         # With max_length set.
         Text(required=True, max_length=1).validate('b')
 
-        with self.assertRaises(ValidationError):
+        with pytest.raises(ValidationError):
             Text(required=True, max_length=2).validate('blake')
 
-        with self.assertRaises(ValueError):
+        with pytest.raises(ValueError):
             Text(required=True, max_length=0)
 
 
@@ -781,7 +782,7 @@ class TestModel(Model):
         id = UUID(primary_key=True, default=uuid4)
 
     def test_extra_field(self):
-        with self.assertRaises(ValidationError):
+        with pytest.raises(ValidationError):
             self.TestModel.create(bacon=5000)
 
 
@@ -834,5 +835,5 @@ def test_inet_saves(self):
 
     def test_non_address_fails(self):
         # TODO: presently this only tests that the server blows it up. Is there supposed to be local validation?
-        with self.assertRaises(InvalidRequest):
+        with pytest.raises(InvalidRequest):
             self.InetTestModel.create(address="what is going on here?")