Switch to pytest-style asserts

Author: rliebz

dataverse/test/test_dataverse.py

@@ -1,4 +1,4 @@
-import unittest
+import pytest
 
 import httpretty
 
@@ -13,59 +13,65 @@
 logging.basicConfig(level=logging.ERROR)
 
 
-class TestUtils(unittest.TestCase):
+class TestUtils(object):
 
     def test_get_element(self):
         with open(ATOM_DATASET) as f:
             entry = f.read()
+
         # One value
         title = utils.get_element(entry, 'title', 'dcterms').text
-        self.assertEqual(title, 'Roasting at Home')
+        assert title == 'Roasting at Home'
+
         # Two values
         creator = utils.get_element(entry, 'creator', 'dcterms').text
-        self.assertEqual(creator, 'Peets, John')
+        assert creator == 'Peets, John'
+
         # No values
         nonsense = utils.get_element(entry, 'nonsense', 'booga')
-        self.assertIsNone(nonsense)
+        assert nonsense is None
 
     def test_get_elements(self):
         with open(ATOM_DATASET) as f:
             entry = f.read()
+
         # One value
         titles = utils.get_elements(entry, 'title', 'dcterms')
-        self.assertEqual(len(titles), 1)
-        self.assertEqual(titles[0].text, 'Roasting at Home')
+        assert len(titles) == 1
+        assert titles[0].text == 'Roasting at Home'
+
         # Two values
         creators = utils.get_elements(entry, 'creator', 'dcterms')
-        self.assertEqual(len(creators), 2)
-        self.assertEqual(creators[0].text, 'Peets, John')
-        self.assertEqual(creators[1].text, 'Stumptown, Jane')
+        assert len(creators) == 2
+        assert creators[0].text == 'Peets, John'
+        assert creators[1].text == 'Stumptown, Jane'
+
         # No values
         nonsense = utils.get_elements(entry, 'nonsense', 'booga')
-        self.assertEqual(nonsense, [])
+        assert nonsense == []
 
     def test_format_term(self):
         # A term not in the replacement dict
         formatted_term = utils.format_term('title', namespace='dcterms')
-        self.assertEqual(formatted_term, '{http://purl.org/dc/terms/}title')
+        assert formatted_term == '{http://purl.org/dc/terms/}title'
 
     def test_format_term_replace(self):
         # A term in the replacement dict
         formatted_term = utils.format_term('id', namespace='dcterms')
-        self.assertEqual(formatted_term, '{http://purl.org/dc/terms/}identifier')
+        assert formatted_term == '{http://purl.org/dc/terms/}identifier'
 
 
-class TestConnection(unittest.TestCase):
+class TestConnection(object):
 
     def test_connect(self):
         c = Connection(TEST_HOST, TEST_TOKEN)
 
-        self.assertEqual(c.host, TEST_HOST)
-        self.assertEqual(c.token, TEST_TOKEN)
-        self.assertTrue(c.service_document)
+        assert c.host == TEST_HOST
+        assert c.token == TEST_TOKEN
+        assert c.service_document
 
     def test_connect_unauthorized(self):
-        with self.assertRaises(exceptions.UnauthorizedError):
+        with pytest.raises(exceptions.UnauthorizedError):
             Connection(TEST_HOST, 'wrong-token')
 
     @httpretty.activate
@@ -76,11 +82,11 @@ def test_connect_unknown_failure(self):
             status=400,
         )
 
-        with self.assertRaises(exceptions.ConnectionError):
+        with pytest.raises(exceptions.ConnectionError):
             Connection(TEST_HOST, TEST_TOKEN)
 
 
-class TestDataset(unittest.TestCase):
+class TestDataset(object):
 
     def test_init(self):
         dataset = Dataset(title='My Dataset', publisher='Mr. Pub Lisher')
@@ -94,9 +100,9 @@ def test_init(self):
             namespace='dcterms',
             tag='publisher'
         ).text
-        self.assertEqual(title, 'My Dataset')
-        self.assertEqual(title, dataset.title)
-        self.assertEqual(publisher, 'Mr. Pub Lisher')
+        assert title == 'My Dataset'
+        assert title == dataset.title
+        assert publisher == 'Mr. Pub Lisher'
 
     def test_init_from_xml(self):
         dataset = Dataset.from_xml_file(ATOM_DATASET)
@@ -110,45 +116,41 @@ def test_init_from_xml(self):
             namespace='dcterms',
             tag='rights'
         ).text
-        self.assertEqual(title, 'Roasting at Home')
-        self.assertEqual(publisher, 'Creative Commons CC-BY 3.0 (unported) http://creativecommons.org/licenses/by/3.0/')
+        assert title == 'Roasting at Home'
+        assert publisher == 'Creative Commons CC-BY 3.0 (unported) http://creativecommons.org/licenses/by/3.0/'
 
 
-class TestDatasetOperations(unittest.TestCase):
+class TestDatasetOperations(object):
 
     @classmethod
-    def setUpClass(self):
+    def setup_class(cls):
         print "Connecting to DVN."
-        self.dvc = Connection(TEST_HOST, TEST_TOKEN)
+        cls.dvc = Connection(TEST_HOST, TEST_TOKEN)
 
         print "Getting Dataverse"
-        dataverses = self.dvc.get_dataverses()
+        dataverses = cls.dvc.get_dataverses()
         if not dataverses:
             raise exceptions.DataverseError(
                 'You must have a Dataverse to run these tests.'
             )
 
-        self.dv = dataverses[0]
+        cls.dv = dataverses[0]
 
         print "Removing any existing datasets."
-        datasets = self.dv.get_datasets()
+        datasets = cls.dv.get_datasets()
         for dataset in datasets:
             if dataset.get_state() != 'DEACCESSIONED':
-                self.dv.delete_dataset(dataset)
+                cls.dv.delete_dataset(dataset)
         print 'Dataverse emptied.'
 
-    def setUp(self):
-        # runs before each test method
+    def setup_method(self, method):
 
         # create a dataset for each test
         s = Dataset(**PICS_OF_CATS_DATASET)
         self.dv.add_dataset(s)
-        doi = s.doi
-        self.s = self.dv.get_dataset_by_doi(doi)
-        self.assertEqual(doi, self.s.doi)
-        return
+        self.s = self.dv.get_dataset_by_doi(s.doi)
 
-    def tearDown(self):
+    def teardown_method(self, method):
         try:
             self.dv.delete_dataset(self.s)
         finally:
@@ -158,71 +160,69 @@ def test_create_dataset_from_xml(self):
         new_dataset = Dataset.from_xml_file(ATOM_DATASET)
         self.dv.add_dataset(new_dataset)
         retrieved_dataset = self.dv.get_dataset_by_title("Roasting at Home")
-        self.assertTrue(retrieved_dataset)
+        assert retrieved_dataset
         self.dv.delete_dataset(retrieved_dataset)
 
     def test_add_files(self):
         self.s.add_files(EXAMPLE_FILES)
         actual_files = [f.name for f in self.s.get_files()]
 
-        self.assertIn('__init__.py', actual_files)
-        self.assertIn('config.py', actual_files)
+        assert '__init__.py' in actual_files
+        assert 'config.py' in actual_files
 
     def test_upload_file(self):
         self.s.upload_file('file.txt', 'This is a simple text file!')
         self.s.upload_file('file2.txt', 'This is the second simple text file!')
         actual_files = [f.name for f in self.s.get_files()]
 
-        self.assertIn('file.txt', actual_files)
-        self.assertIn('file2.txt', actual_files)
+        assert 'file.txt' in actual_files
+        assert 'file2.txt' in actual_files
 
     def test_display_atom_entry(self):
         # this just tests we can get an entry back, but does
         # not do anything with that xml yet. however, we do use get_entry
         # in other methods so this test case is probably covered
-        self.assertTrue(self.s.get_entry())
+        assert self.s.get_entry()
 
     def test_display_dataset_statement(self):
         # this just tests we can get an entry back, but does
         # not do anything with that xml yet. however, we do use get_statement
         # in other methods so this test case is probably covered
-        self.assertTrue(self.s.get_statement())
+        assert self.s.get_statement()
 
     def test_delete_a_file(self):
         self.s.upload_file('cat.jpg', b'Whatever a cat looks like goes here.')
 
-        #add file and confirm
+        # Add file and confirm
         files = self.s.get_files()
-        cat_file = [f for f in files if f.name == 'cat.jpg']
-        self.assertTrue(len(cat_file) == 1)
+        assert len(files) == 1
+        assert files[0].name == 'cat.jpg'
 
-        #delete file and confirm
-        self.s.delete_file(cat_file[0])
+        # Delete file and confirm
+        self.s.delete_file(files[0])
         files = self.s.get_files()
-        cat_file = [f for f in files if f.name == "cat.jpg"]
-        self.assertTrue(len(cat_file) == 0)
+        assert not files
 
     def test_delete_a_dataset(self):
         xmlDataset = Dataset.from_xml_file(ATOM_DATASET)
         self.dv.add_dataset(xmlDataset)
         atomDataset = self.dv.get_dataset_by_title("Roasting at Home")
-        self.assertTrue(atomDataset)
-
         num_datasets = len(self.dv.get_datasets())
-        self.assertTrue(num_datasets > 0)
+
+        assert num_datasets > 0
         self.dv.delete_dataset(atomDataset)
-        self.assertEqual(atomDataset.get_state(refresh=True), 'DEACCESSIONED')
-        self.assertEqual(len(self.dv.get_datasets()), num_datasets - 1)
+        assert atomDataset.get_state(refresh=True) == 'DEACCESSIONED'
+        assert len(self.dv.get_datasets()) == num_datasets - 1
 
-    @unittest.skip('Published datasets can no longer be deaccessioned via API')
+    @pytest.mark.skipif(True, reason='Published datasets can no longer be deaccessioned via API')
     def test_publish_dataset(self):
-        self.assertTrue(self.s.get_state() == "DRAFT")
+        assert self.s.get_state() == "DRAFT"
         self.s.publish()
-        self.assertTrue(self.s.get_state() == "PUBLISHED")
+        assert self.s.get_state() == "PUBLISHED"
         self.dv.delete_dataset(self.s)
-        self.assertTrue(self.s.get_state(refresh=True) == "DEACCESSIONED")
+        assert self.s.get_state(refresh=True) == "DEACCESSIONED"
 
 
 if __name__ == '__main__':
-    unittest.main()
+    pytest.main()