diff --git a/ipatests/test_cmdline/cmdline.py b/ipatests/test_cmdline/cmdline.py index 11bde1061..478231eb5 100644 --- a/ipatests/test_cmdline/cmdline.py +++ b/ipatests/test_cmdline/cmdline.py @@ -25,7 +25,6 @@ from __future__ import absolute_import import distutils.spawn import os -import unittest import pytest @@ -69,6 +68,6 @@ class cmdline_test(XMLRPC_test): 'Command %r not available' % original_command ) if not server_available: - raise unittest.SkipTest( + pytest.skip( 'Server not available: %r' % api.env.xmlrpc_uri ) diff --git a/ipatests/test_cmdline/test_cli.py b/ipatests/test_cmdline/test_cli.py index f1d073cf1..ae0d059ce 100644 --- a/ipatests/test_cmdline/test_cli.py +++ b/ipatests/test_cmdline/test_cli.py @@ -5,7 +5,6 @@ import shlex import subprocess import sys import tempfile -import unittest import six @@ -45,8 +44,8 @@ class TestCLIParsing: try: api.Command[command_name](**kw) except errors.NetworkError: - raise unittest.SkipTest('%r: Server not available: %r' % - (self.__module__, api.env.xmlrpc_uri)) + pytest.skip('%r: Server not available: %r' % + (self.__module__, api.env.xmlrpc_uri)) @contextlib.contextmanager def fake_stdin(self, string_in): @@ -124,7 +123,7 @@ class TestCLIParsing: try: self.run_command('dnszone_add', idnsname=TEST_ZONE) except errors.NotFound: - raise unittest.SkipTest('DNS is not configured') + pytest.skip('DNS is not configured') try: self.run_command('dnsrecord_add', dnszoneidnsname=TEST_ZONE, @@ -152,7 +151,7 @@ class TestCLIParsing: try: self.run_command('dnszone_add', idnsname=TEST_ZONE) except errors.NotFound: - raise unittest.SkipTest('DNS is not configured') + pytest.skip('DNS is not configured') try: records = (u'1 1 E3B72BA346B90570EED94BE9334E34AA795CED23', u'2 1 FD2693C1EFFC11A8D2BE57229212A04B45663791') @@ -232,7 +231,7 @@ class TestCLIParsing: self.run_command( 'dnszone_add', idnsname=TEST_ZONE) except errors.NotFound: - raise unittest.SkipTest('DNS is not configured') + pytest.skip('DNS is not configured') try: self.run_command( 'dnsrecord_add', diff --git a/ipatests/test_install/test_updates.py b/ipatests/test_install/test_updates.py index 0fd54fe52..1c9ba90aa 100644 --- a/ipatests/test_install/test_updates.py +++ b/ipatests/test_install/test_updates.py @@ -23,7 +23,6 @@ Test the `ipaserver/install/ldapupdate.py` module. from __future__ import absolute_import import os -import unittest import pytest @@ -50,20 +49,20 @@ The DM password needs to be set in ~/.ipa/.dmpw @pytest.mark.tier0 @pytest.mark.needs_ipaapi -class test_update(unittest.TestCase): +class TestUpdate: """ Test the LDAP updater. """ - def setUp(self): + @pytest.fixture(autouse=True) + def update_setup(self, request): fqdn = installutils.get_fqdn() pwfile = api.env.dot_ipa + os.sep + ".dmpw" if os.path.isfile(pwfile): - fp = open(pwfile, "r") - self.dm_password = fp.read().rstrip() - fp.close() + with open(pwfile, "r") as fp: + self.dm_password = fp.read().rstrip() else: - raise unittest.SkipTest("No directory manager password") + pytest.skip("No directory manager password") self.updater = LDAPUpdate(dm_password=self.dm_password, sub_dict={}) self.ld = ipaldap.LDAPClient.from_hostname_secure(fqdn) self.ld.simple_bind(bind_dn=ipaldap.DIRMAN_DN, @@ -71,14 +70,15 @@ class test_update(unittest.TestCase): self.testdir = os.path.abspath(os.path.dirname(__file__)) if not os.path.isfile(os.path.join(self.testdir, "0_reset.update")): - raise unittest.SkipTest("Unable to find test update files") + pytest.skip("Unable to find test update files") self.container_dn = DN(self.updater._template_str('cn=test, cn=accounts, $SUFFIX')) self.user_dn = DN(self.updater._template_str('uid=tuser, cn=test, cn=accounts, $SUFFIX')) - def tearDown(self): - if self.ld: - self.ld.unbind() + def fin(): + if self.ld: + self.ld.unbind() + request.addfinalizer(fin) def test_0_reset(self): """ @@ -91,13 +91,13 @@ class test_update(unittest.TestCase): # Just means the entry doesn't exist yet modified = True - self.assertTrue(modified) + assert modified - with self.assertRaises(errors.NotFound): + with pytest.raises(errors.NotFound): self.ld.get_entries( self.container_dn, self.ld.SCOPE_BASE, 'objectclass=*', ['*']) - with self.assertRaises(errors.NotFound): + with pytest.raises(errors.NotFound): self.ld.get_entries( self.user_dn, self.ld.SCOPE_BASE, 'objectclass=*', ['*']) @@ -108,33 +108,33 @@ class test_update(unittest.TestCase): modified = self.updater.update([os.path.join(self.testdir, "1_add.update")]) - self.assertTrue(modified) + assert modified entries = self.ld.get_entries( self.container_dn, self.ld.SCOPE_BASE, 'objectclass=*', ['*']) - self.assertEqual(len(entries), 1) + assert len(entries) == 1 entry = entries[0] objectclasses = entry.get('objectclass') for item in ('top', 'nsContainer'): - self.assertTrue(item in objectclasses) + assert item in objectclasses - self.assertEqual(entry.single_value['cn'], 'test') + assert entry.single_value['cn'] == 'test' entries = self.ld.get_entries( self.user_dn, self.ld.SCOPE_BASE, 'objectclass=*', ['*']) - self.assertEqual(len(entries), 1) + assert len(entries) == 1 entry = entries[0] objectclasses = entry.get('objectclass') for item in ('top', 'person', 'posixaccount', 'krbprincipalaux', 'inetuser'): - self.assertTrue(item in objectclasses) + assert item in objectclasses - self.assertEqual(entry.single_value['loginshell'], - platformconstants.DEFAULT_ADMIN_SHELL) - self.assertEqual(entry.single_value['sn'], 'User') - self.assertEqual(entry.single_value['uid'], 'tuser') - self.assertEqual(entry.single_value['cn'], 'Test User') + actual = entry.single_value['loginshell'] + assert actual == platformconstants.DEFAULT_ADMIN_SHELL + assert entry.single_value['sn'] == 'User' + assert entry.single_value['uid'] == 'tuser' + assert entry.single_value['cn'] == 'Test User' def test_2_update(self): @@ -143,13 +143,13 @@ class test_update(unittest.TestCase): """ modified = self.updater.update([os.path.join(self.testdir, "2_update.update")]) - self.assertTrue(modified) + assert modified entries = self.ld.get_entries( self.user_dn, self.ld.SCOPE_BASE, 'objectclass=*', ['*']) - self.assertEqual(len(entries), 1) + assert len(entries) == 1 entry = entries[0] - self.assertEqual(entry.single_value['gecos'], 'Test User') + assert entry.single_value['gecos'] == 'Test User' def test_3_update(self): """ @@ -157,13 +157,13 @@ class test_update(unittest.TestCase): """ modified = self.updater.update([os.path.join(self.testdir, "3_update.update")]) - self.assertTrue(modified) + assert modified entries = self.ld.get_entries( self.user_dn, self.ld.SCOPE_BASE, 'objectclass=*', ['*']) - self.assertEqual(len(entries), 1) + assert len(entries) == 1 entry = entries[0] - self.assertEqual(entry.single_value['gecos'], 'Test User New') + assert entry.single_value['gecos'] == 'Test User New' def test_4_update(self): """ @@ -171,13 +171,13 @@ class test_update(unittest.TestCase): """ modified = self.updater.update([os.path.join(self.testdir, "4_update.update")]) - self.assertTrue(modified) + assert modified entries = self.ld.get_entries( self.user_dn, self.ld.SCOPE_BASE, 'objectclass=*', ['*']) - self.assertEqual(len(entries), 1) + assert len(entries) == 1 entry = entries[0] - self.assertEqual(entry.single_value['gecos'], 'Test User New2') + assert entry.single_value['gecos'] == 'Test User New2' def test_5_update(self): """ @@ -185,13 +185,15 @@ class test_update(unittest.TestCase): """ modified = self.updater.update([os.path.join(self.testdir, "5_update.update")]) - self.assertTrue(modified) + assert modified entries = self.ld.get_entries( self.user_dn, self.ld.SCOPE_BASE, 'objectclass=*', ['*']) - self.assertEqual(len(entries), 1) + assert len(entries) == 1 entry = entries[0] - self.assertEqual(sorted(entry.get('cn')), sorted(['Test User', 'Test User New'])) + actual = sorted(entry.get('cn')) + expected = sorted(['Test User', 'Test User New']) + assert actual == expected def test_6_update(self): """ @@ -199,13 +201,13 @@ class test_update(unittest.TestCase): """ modified = self.updater.update([os.path.join(self.testdir, "6_update.update")]) - self.assertTrue(modified) + assert modified entries = self.ld.get_entries( self.user_dn, self.ld.SCOPE_BASE, 'objectclass=*', ['*']) - self.assertEqual(len(entries), 1) + assert len(entries) == 1 entry = entries[0] - self.assertEqual(sorted(entry.get('cn')), sorted(['Test User'])) + assert sorted(entry.get('cn')) == sorted(['Test User']) def test_6_update_1(self): """ @@ -213,13 +215,13 @@ class test_update(unittest.TestCase): """ modified = self.updater.update([os.path.join(self.testdir, "6_update.update")]) - self.assertFalse(modified) + assert not modified entries = self.ld.get_entries( self.user_dn, self.ld.SCOPE_BASE, 'objectclass=*', ['*']) - self.assertEqual(len(entries), 1) + assert len(entries) == 1 entry = entries[0] - self.assertEqual(sorted(entry.get('cn')), sorted(['Test User'])) + assert sorted(entry.get('cn')) == sorted(['Test User']) def test_7_cleanup(self): """ @@ -232,13 +234,13 @@ class test_update(unittest.TestCase): # Just means the entry doesn't exist yet modified = True - self.assertTrue(modified) + assert modified - with self.assertRaises(errors.NotFound): + with pytest.raises(errors.NotFound): self.ld.get_entries( self.container_dn, self.ld.SCOPE_BASE, 'objectclass=*', ['*']) - with self.assertRaises(errors.NotFound): + with pytest.raises(errors.NotFound): self.ld.get_entries( self.user_dn, self.ld.SCOPE_BASE, 'objectclass=*', ['*']) @@ -246,7 +248,7 @@ class test_update(unittest.TestCase): """ Test the updater with an unknown keyword (test_8_badsyntax) """ - with self.assertRaises(BadSyntax): + with pytest.raises(BadSyntax): self.updater.update( [os.path.join(self.testdir, "8_badsyntax.update")]) @@ -254,6 +256,6 @@ class test_update(unittest.TestCase): """ Test the updater with an incomplete line (test_9_badsyntax) """ - with self.assertRaises(BadSyntax): + with pytest.raises(BadSyntax): self.updater.update( [os.path.join(self.testdir, "9_badsyntax.update")]) diff --git a/ipatests/test_integration/test_legacy_clients.py b/ipatests/test_integration/test_legacy_clients.py index 830717d96..cc0068243 100644 --- a/ipatests/test_integration/test_legacy_clients.py +++ b/ipatests/test_integration/test_legacy_clients.py @@ -24,7 +24,8 @@ from __future__ import absolute_import import os import re -import unittest + +import pytest from ipaplatform.constants import constants as platformconstants from ipaplatform.paths import paths @@ -166,8 +167,8 @@ class BaseTestLegacyClient: def test_login_ipa_user(self): if not self.master.transport.file_exists('/usr/bin/sshpass'): - raise unittest.SkipTest('Package sshpass not available on %s' - % self.master.hostname) + pytest.skip('Package sshpass not available on %s' + % self.master.hostname) result = self.master.run_command( 'sshpass -p %s ' @@ -183,8 +184,8 @@ class BaseTestLegacyClient: def test_login_ad_user(self): if not self.master.transport.file_exists('/usr/bin/sshpass'): - raise unittest.SkipTest('Package sshpass not available on %s' - % self.master.hostname) + pytest.skip('Package sshpass not available on %s' + % self.master.hostname) testuser = 'testuser@%s' % self.ad.domain.name result = self.master.run_command( @@ -200,8 +201,8 @@ class BaseTestLegacyClient: def test_login_disabled_ipa_user(self): if not self.master.transport.file_exists('/usr/bin/sshpass'): - raise unittest.SkipTest('Package sshpass not available on %s' - % self.master.hostname) + pytest.skip('Package sshpass not available on %s' + % self.master.hostname) self.clear_sssd_caches() @@ -220,7 +221,7 @@ class BaseTestLegacyClient: def test_login_disabled_ad_user(self): if not self.master.transport.file_exists('/usr/bin/sshpass'): - raise unittest.SkipTest('Package sshpass not available on %s' + pytest.skip('Package sshpass not available on %s' % self.master.hostname) testuser = 'disabledaduser@%s' % self.ad.domain.name @@ -238,7 +239,7 @@ class BaseTestLegacyClient: def test_getent_subdomain_ad_user(self): if not self.ad_subdomain: - raise unittest.SkipTest('AD for the subdomain is not available.') + pytest.skip('AD for the subdomain is not available.') self.clear_sssd_caches() testuser = 'subdomaintestuser@%s' % self.ad_subdomain @@ -260,7 +261,7 @@ class BaseTestLegacyClient: def test_getent_subdomain_ad_group(self): if not self.ad_subdomain: - raise unittest.SkipTest('AD for the subdomain is not available.') + pytest.skip('AD for the subdomain is not available.') self.clear_sssd_caches() testgroup = 'subdomaintestgroup@%s' % self.ad_subdomain @@ -272,7 +273,7 @@ class BaseTestLegacyClient: def test_id_subdomain_ad_user(self): if not self.ad_subdomain: - raise unittest.SkipTest('AD for the subdomain is not available.') + pytest.skip('AD for the subdomain is not available.') self.clear_sssd_caches() testuser = 'subdomaintestuser@%s' % self.ad_subdomain @@ -297,11 +298,11 @@ class BaseTestLegacyClient: def test_login_subdomain_ad_user(self): if not self.ad_subdomain: - raise unittest.SkipTest('AD for the subdomain is not available.') + pytest.skip('AD for the subdomain is not available.') if not self.master.transport.file_exists('/usr/bin/sshpass'): - raise unittest.SkipTest('Package sshpass not available on %s' - % self.master.hostname) + pytest.skip('Package sshpass not available on %s' + % self.master.hostname) testuser = 'subdomaintestuser@%s' % self.ad_subdomain result = self.master.run_command( @@ -317,11 +318,11 @@ class BaseTestLegacyClient: def test_login_disabled_subdomain_ad_user(self): if not self.ad_subdomain: - raise unittest.SkipTest('AD for the subdomain is not available.') + pytest.skip('AD for the subdomain is not available.') if not self.master.transport.file_exists('/usr/bin/sshpass'): - raise unittest.SkipTest('Package sshpass not available on %s' - % self.master.hostname) + pytest.skip('Package sshpass not available on %s' + % self.master.hostname) testuser = 'subdomaindisabledaduser@%s' % self.ad_subdomain result = self.master.run_command( @@ -338,7 +339,7 @@ class BaseTestLegacyClient: def test_getent_treedomain_ad_user(self): if not self.ad_treedomain: - raise unittest.SkipTest('AD tree root domain is not available.') + pytest.skip('AD tree root domain is not available.') self.clear_sssd_caches() testuser = 'treetestuser@{0}'.format(self.ad_treedomain) @@ -356,7 +357,7 @@ class BaseTestLegacyClient: def test_getent_treedomain_ad_group(self): if not self.ad_treedomain: - raise unittest.SkipTest('AD tree root domain is not available') + pytest.skip('AD tree root domain is not available') self.clear_sssd_caches() testgroup = 'treetestgroup@{0}'.format(self.ad_treedomain) @@ -369,7 +370,7 @@ class BaseTestLegacyClient: def test_id_treedomain_ad_user(self): if not self.ad_treedomain: - raise unittest.SkipTest('AD tree root domain is not available') + pytest.skip('AD tree root domain is not available') self.clear_sssd_caches() @@ -398,10 +399,10 @@ class BaseTestLegacyClient: def test_login_treedomain_ad_user(self): if not self.ad_treedomain: - raise unittest.SkipTest('AD tree root domain is not available.') + pytest.skip('AD tree root domain is not available.') if not self.master.transport.file_exists('/usr/bin/sshpass'): - raise unittest.SkipTest( + pytest.skip( 'Package sshpass not available on {}'.format( self.master.hostname) ) diff --git a/ipatests/test_integration/test_trust.py b/ipatests/test_integration/test_trust.py index 505a32974..97fde4357 100644 --- a/ipatests/test_integration/test_trust.py +++ b/ipatests/test_integration/test_trust.py @@ -3,9 +3,10 @@ from __future__ import absolute_import import re -import unittest import textwrap +import pytest + from ipaplatform.constants import constants as platformconstants from ipaplatform.paths import paths @@ -33,8 +34,8 @@ class BaseTestTrust(IntegrationTest): @classmethod def install(cls, mh): if not cls.master.transport.file_exists('/usr/bin/rpcclient'): - raise unittest.SkipTest("Package samba-client not available " - "on {}".format(cls.master.hostname)) + raise pytest.skip("Package samba-client not available " + "on {}".format(cls.master.hostname)) super(BaseTestTrust, cls).install(mh) cls.ad = cls.ads[0] # pylint: disable=no-member cls.ad_domain = cls.ad.domain.name diff --git a/ipatests/test_ipalib/test_rpc.py b/ipatests/test_ipalib/test_rpc.py index a6e6122b5..cf1aea4fe 100644 --- a/ipatests/test_ipalib/test_rpc.py +++ b/ipatests/test_ipalib/test_rpc.py @@ -22,7 +22,6 @@ Test the `ipalib.rpc` module. """ from __future__ import print_function -import unittest from xmlrpc.client import Binary, Fault, dumps, loads import urllib @@ -266,8 +265,8 @@ class test_xml_introspection: try: api.Backend.xmlclient.connect() except (errors.NetworkError, IOError): - raise unittest.SkipTest('%r: Server not available: %r' % - (__name__, api.env.xmlrpc_uri)) + pytest.skip('%r: Server not available: %r' % + (__name__, api.env.xmlrpc_uri)) def fin(): ipa_request.destroy_context() @@ -356,8 +355,8 @@ class test_rpcclient_context(PluginTester): try: api.Backend.rpcclient.connect(ca_certfile='foo') except (errors.NetworkError, IOError): - raise unittest.SkipTest('%r: Server not available: %r' % - (__name__, api.env.xmlrpc_uri)) + pytest.skip('%r: Server not available: %r' % + (__name__, api.env.xmlrpc_uri)) def fin(): if api.Backend.rpcclient.isconnected(): diff --git a/ipatests/test_ipalib/test_text.py b/ipatests/test_ipalib/test_text.py index f96f118b8..399b3734c 100644 --- a/ipatests/test_ipalib/test_text.py +++ b/ipatests/test_ipalib/test_text.py @@ -25,7 +25,6 @@ from __future__ import print_function import os import shutil import tempfile -import unittest import six import pytest @@ -103,17 +102,17 @@ class test_TestLang: result = create_po(self.pot_file, self.po_file, self.mo_file) if result: - raise unittest.SkipTest( + pytest.skip( 'Unable to create po file "%s" & mo file "%s" from pot ' 'file "%s"' % (self.po_file, self.mo_file, self.pot_file) ) if not os.path.isfile(self.po_file): - raise unittest.SkipTest( + pytest.skip( 'Test po file unavailable: {}'.format(self.po_file)) if not os.path.isfile(self.mo_file): - raise unittest.SkipTest( + pytest.skip( 'Test mo file unavailable: {}'.format(self.mo_file)) self.po_file_iterate = po_file_iterate diff --git a/ipatests/test_ipapython/test_cookie.py b/ipatests/test_ipapython/test_cookie.py index 57233b7b0..031eec15e 100644 --- a/ipatests/test_ipapython/test_cookie.py +++ b/ipatests/test_ipapython/test_cookie.py @@ -17,7 +17,6 @@ # You should have received a copy of the GNU General Public License # along with this program. If not, see . -import unittest import datetime import email.utils import calendar @@ -27,125 +26,127 @@ import pytest pytestmark = pytest.mark.tier0 -class TestParse(unittest.TestCase): + +class TestParse: def test_parse(self): # Empty string s = '' cookies = Cookie.parse(s) - self.assertEqual(len(cookies), 0) + assert len(cookies) == 0 # Invalid single token s = 'color' - with self.assertRaises(ValueError): + with pytest.raises(ValueError): cookies = Cookie.parse(s) # Invalid single token that's keyword s = 'HttpOnly' - with self.assertRaises(ValueError): + with pytest.raises(ValueError): cookies = Cookie.parse(s) # Invalid key/value pair whose key is a keyword s = 'domain=example.com' - with self.assertRaises(ValueError): + with pytest.raises(ValueError): cookies = Cookie.parse(s) # 1 cookie with empty value s = 'color=' cookies = Cookie.parse(s) - self.assertEqual(len(cookies), 1) + assert len(cookies) == 1 cookie = cookies[0] - self.assertEqual(cookie.key, 'color') - self.assertEqual(cookie.value, '') - self.assertEqual(cookie.domain, None) - self.assertEqual(cookie.path, None) - self.assertEqual(cookie.max_age, None) - self.assertEqual(cookie.expires, None) - self.assertEqual(cookie.secure, None) - self.assertEqual(cookie.httponly, None) - self.assertEqual(str(cookie), "color=") - self.assertEqual(cookie.http_cookie(), "color=;") + assert cookie.key == 'color' + assert cookie.value == '' + assert cookie.domain is None + assert cookie.path is None + assert cookie.max_age is None + assert cookie.expires is None + assert cookie.secure is None + assert cookie.httponly is None + assert str(cookie) == "color=" + assert cookie.http_cookie() == "color=;" # 1 cookie with name/value s = 'color=blue' cookies = Cookie.parse(s) - self.assertEqual(len(cookies), 1) + assert len(cookies) == 1 cookie = cookies[0] - self.assertEqual(cookie.key, 'color') - self.assertEqual(cookie.value, 'blue') - self.assertEqual(cookie.domain, None) - self.assertEqual(cookie.path, None) - self.assertEqual(cookie.max_age, None) - self.assertEqual(cookie.expires, None) - self.assertEqual(cookie.secure, None) - self.assertEqual(cookie.httponly, None) - self.assertEqual(str(cookie), "color=blue") - self.assertEqual(cookie.http_cookie(), "color=blue;") + assert cookie.key == 'color' + assert cookie.value == 'blue' + assert cookie.domain is None + assert cookie.path is None + assert cookie.max_age is None + assert cookie.expires is None + assert cookie.secure is None + assert cookie.httponly is None + assert str(cookie) == "color=blue" + assert cookie.http_cookie() == "color=blue;" # 1 cookie with whose value is quoted # Use "get by name" utility to extract specific cookie s = 'color="blue"' cookie = Cookie.get_named_cookie_from_string(s, 'color') - self.assertIsNotNone(cookie) - self.assertIsNotNone(cookie, Cookie) - self.assertEqual(cookie.key, 'color') - self.assertEqual(cookie.value, 'blue') - self.assertEqual(cookie.domain, None) - self.assertEqual(cookie.path, None) - self.assertEqual(cookie.max_age, None) - self.assertEqual(cookie.expires, None) - self.assertEqual(cookie.secure, None) - self.assertEqual(cookie.httponly, None) - self.assertEqual(str(cookie), "color=blue") - self.assertEqual(cookie.http_cookie(), "color=blue;") + assert cookie is not None, Cookie + assert cookie.key == 'color' + assert cookie.value == 'blue' + assert cookie.domain is None + assert cookie.path is None + assert cookie.max_age is None + assert cookie.expires is None + assert cookie.secure is None + assert cookie.httponly is None + assert str(cookie) == "color=blue" + assert cookie.http_cookie() == "color=blue;" # 1 cookie with name/value and domain, path attributes. # Change up the whitespace a bit. s = 'color =blue; domain= example.com ; path = /toplevel ' cookies = Cookie.parse(s) - self.assertEqual(len(cookies), 1) + assert len(cookies) == 1 cookie = cookies[0] - self.assertEqual(cookie.key, 'color') - self.assertEqual(cookie.value, 'blue') - self.assertEqual(cookie.domain, 'example.com') - self.assertEqual(cookie.path, '/toplevel') - self.assertEqual(cookie.max_age, None) - self.assertEqual(cookie.expires, None) - self.assertEqual(cookie.secure, None) - self.assertEqual(cookie.httponly, None) - self.assertEqual(str(cookie), "color=blue; Domain=example.com; Path=/toplevel") - self.assertEqual(cookie.http_cookie(), "color=blue;") + assert cookie.key == 'color' + assert cookie.value == 'blue' + assert cookie.domain == 'example.com' + assert cookie.path == '/toplevel' + assert cookie.max_age is None + assert cookie.expires is None + assert cookie.secure is None + assert cookie.httponly is None + assert str(cookie) == "color=blue; Domain=example.com; Path=/toplevel" + assert cookie.http_cookie() == "color=blue;" # 2 cookies, various attributes s = 'color=blue; Max-Age=3600; temperature=hot; HttpOnly' cookies = Cookie.parse(s) - self.assertEqual(len(cookies), 2) + assert len(cookies) == 2 cookie = cookies[0] - self.assertEqual(cookie.key, 'color') - self.assertEqual(cookie.value, 'blue') - self.assertEqual(cookie.domain, None) - self.assertEqual(cookie.path, None) - self.assertEqual(cookie.max_age, 3600) - self.assertEqual(cookie.expires, None) - self.assertEqual(cookie.secure, None) - self.assertEqual(cookie.httponly, None) - self.assertEqual(str(cookie), "color=blue; Max-Age=3600") - self.assertEqual(cookie.http_cookie(), "color=blue;") + assert cookie.key == 'color' + assert cookie.value == 'blue' + assert cookie.domain is None + assert cookie.path is None + assert cookie.max_age == 3600 + assert cookie.expires is None + assert cookie.secure is None + assert cookie.httponly is None + assert str(cookie) == "color=blue; Max-Age=3600" + assert cookie.http_cookie() == "color=blue;" cookie = cookies[1] - self.assertEqual(cookie.key, 'temperature') - self.assertEqual(cookie.value, 'hot') - self.assertEqual(cookie.domain, None) - self.assertEqual(cookie.path, None) - self.assertEqual(cookie.max_age, None) - self.assertEqual(cookie.expires, None) - self.assertEqual(cookie.secure, None) - self.assertEqual(cookie.httponly, True) - self.assertEqual(str(cookie), "temperature=hot; HttpOnly") - self.assertEqual(cookie.http_cookie(), "temperature=hot;") + assert cookie.key == 'temperature' + assert cookie.value == 'hot' + assert cookie.domain is None + assert cookie.path is None + assert cookie.max_age is None + assert cookie.expires is None + assert cookie.secure is None + assert cookie.httponly is True + assert str(cookie) == "temperature=hot; HttpOnly" + assert cookie.http_cookie() == "temperature=hot;" -class TestExpires(unittest.TestCase): - def setUp(self): +class TestExpires: + + @pytest.fixture(autouse=True) + def expires_setup(self): # Force microseconds to zero because cookie timestamps only have second resolution self.now = datetime.datetime.utcnow().replace(microsecond=0) self.now_timestamp = calendar.timegm(self.now.utctimetuple()) @@ -164,233 +165,237 @@ class TestExpires(unittest.TestCase): # 1 cookie with name/value and no Max-Age and no Expires s = 'color=blue;' cookies = Cookie.parse(s) - self.assertEqual(len(cookies), 1) + assert len(cookies) == 1 cookie = cookies[0] # Force timestamp to known value cookie.timestamp = self.now - self.assertEqual(cookie.key, 'color') - self.assertEqual(cookie.value, 'blue') - self.assertEqual(cookie.domain, None) - self.assertEqual(cookie.path, None) - self.assertEqual(cookie.max_age, None) - self.assertEqual(cookie.expires, None) - self.assertEqual(cookie.secure, None) - self.assertEqual(cookie.httponly, None) - self.assertEqual(str(cookie), "color=blue") - self.assertEqual(cookie.get_expiration(), None) + assert cookie.key == 'color' + assert cookie.value == 'blue' + assert cookie.domain is None + assert cookie.path is None + assert cookie.max_age is None + assert cookie.expires is None + assert cookie.secure is None + assert cookie.httponly is None + assert str(cookie) == "color=blue" + assert cookie.get_expiration() is None # Normalize - self.assertEqual(cookie.normalize_expiration(), None) - self.assertEqual(cookie.max_age, None) - self.assertEqual(cookie.expires, None) - self.assertEqual(str(cookie), "color=blue") + assert cookie.normalize_expiration() is None + assert cookie.max_age is None + assert cookie.expires is None + assert str(cookie) == "color=blue" # 1 cookie with name/value and Max-Age s = 'color=blue; max-age=%d' % (self.max_age) cookies = Cookie.parse(s) - self.assertEqual(len(cookies), 1) + assert len(cookies) == 1 cookie = cookies[0] # Force timestamp to known value cookie.timestamp = self.now - self.assertEqual(cookie.key, 'color') - self.assertEqual(cookie.value, 'blue') - self.assertEqual(cookie.domain, None) - self.assertEqual(cookie.path, None) - self.assertEqual(cookie.max_age, self.max_age) - self.assertEqual(cookie.expires, None) - self.assertEqual(cookie.secure, None) - self.assertEqual(cookie.httponly, None) - self.assertEqual(str(cookie), "color=blue; Max-Age=%d" % (self.max_age)) - self.assertEqual(cookie.get_expiration(), self.age_expiration) + assert cookie.key == 'color' + assert cookie.value == 'blue' + assert cookie.domain is None + assert cookie.path is None + assert cookie.max_age == self.max_age + assert cookie.expires is None + assert cookie.secure is None + assert cookie.httponly is None + assert str(cookie) == "color=blue; Max-Age=%d" % (self.max_age) + assert cookie.get_expiration() == self.age_expiration # Normalize - self.assertEqual(cookie.normalize_expiration(), self.age_expiration) - self.assertEqual(cookie.max_age, None) - self.assertEqual(cookie.expires, self.age_expiration) - self.assertEqual(str(cookie), "color=blue; Expires=%s" % (self.age_string)) + assert cookie.normalize_expiration() == self.age_expiration + assert cookie.max_age is None + assert cookie.expires == self.age_expiration + assert str(cookie) == "color=blue; Expires=%s" % (self.age_string) # 1 cookie with name/value and Expires s = 'color=blue; Expires=%s' % (self.expires_string) cookies = Cookie.parse(s) - self.assertEqual(len(cookies), 1) + assert len(cookies) == 1 cookie = cookies[0] # Force timestamp to known value cookie.timestamp = self.now - self.assertEqual(cookie.key, 'color') - self.assertEqual(cookie.value, 'blue') - self.assertEqual(cookie.domain, None) - self.assertEqual(cookie.path, None) - self.assertEqual(cookie.max_age, None) - self.assertEqual(cookie.expires, self.expires) - self.assertEqual(cookie.secure, None) - self.assertEqual(cookie.httponly, None) - self.assertEqual(str(cookie), "color=blue; Expires=%s" % (self.expires_string)) - self.assertEqual(cookie.get_expiration(), self.expires) + assert cookie.key == 'color' + assert cookie.value == 'blue' + assert cookie.domain is None + assert cookie.path is None + assert cookie.max_age is None + assert cookie.expires == self.expires + assert cookie.secure is None + assert cookie.httponly is None + assert str(cookie) == "color=blue; Expires=%s" % (self.expires_string) + assert cookie.get_expiration() == self.expires # Normalize - self.assertEqual(cookie.normalize_expiration(), self.expires) - self.assertEqual(cookie.max_age, None) - self.assertEqual(cookie.expires, self.expires) - self.assertEqual(str(cookie), "color=blue; Expires=%s" % (self.expires_string)) + assert cookie.normalize_expiration() == self.expires + assert cookie.max_age is None + assert cookie.expires == self.expires + assert str(cookie) == "color=blue; Expires=%s" % (self.expires_string) # 1 cookie with name/value witht both Max-Age and Expires, Max-Age takes precedence s = 'color=blue; Expires=%s; max-age=%d' % (self.expires_string, self.max_age) cookies = Cookie.parse(s) - self.assertEqual(len(cookies), 1) + assert len(cookies) == 1 cookie = cookies[0] # Force timestamp to known value cookie.timestamp = self.now - self.assertEqual(cookie.key, 'color') - self.assertEqual(cookie.value, 'blue') - self.assertEqual(cookie.domain, None) - self.assertEqual(cookie.path, None) - self.assertEqual(cookie.max_age, self.max_age) - self.assertEqual(cookie.expires, self.expires) - self.assertEqual(cookie.secure, None) - self.assertEqual(cookie.httponly, None) - self.assertEqual(str(cookie), "color=blue; Max-Age=%d; Expires=%s" % (self.max_age, self.expires_string)) - self.assertEqual(cookie.get_expiration(), self.age_expiration) + assert cookie.key == 'color' + assert cookie.value == 'blue' + assert cookie.domain is None + assert cookie.path is None + assert cookie.max_age == self.max_age + assert cookie.expires == self.expires + assert cookie.secure is None + assert cookie.httponly is None + expected = "color=blue; Max-Age={}; Expires={}".format( + self.max_age, self.expires_string) + assert str(cookie) == expected + assert cookie.get_expiration() == self.age_expiration # Normalize - self.assertEqual(cookie.normalize_expiration(), self.age_expiration) - self.assertEqual(cookie.max_age, None) - self.assertEqual(cookie.expires, self.age_expiration) - self.assertEqual(str(cookie), "color=blue; Expires=%s" % (self.age_string)) + assert cookie.normalize_expiration() == self.age_expiration + assert cookie.max_age is None + assert cookie.expires == self.age_expiration + assert str(cookie) == "color=blue; Expires=%s" % (self.age_string) # Verify different types can be assigned to the timestamp and # expires attribute. cookie = Cookie('color', 'blue') cookie.timestamp = self.now - self.assertEqual(cookie.timestamp, self.now) + assert cookie.timestamp == self.now cookie.timestamp = self.now_timestamp - self.assertEqual(cookie.timestamp, self.now) + assert cookie.timestamp == self.now cookie.timestamp = self.now_string - self.assertEqual(cookie.timestamp, self.now) + assert cookie.timestamp == self.now - self.assertEqual(cookie.expires, None) + assert cookie.expires is None cookie.expires = self.expires - self.assertEqual(cookie.expires, self.expires) + assert cookie.expires == self.expires cookie.expires = self.expires_timestamp - self.assertEqual(cookie.expires, self.expires) + assert cookie.expires == self.expires cookie.expires = self.expires_string - self.assertEqual(cookie.expires, self.expires) + assert cookie.expires == self.expires -class TestInvalidAttributes(unittest.TestCase): + +class TestInvalidAttributes: def test_invalid(self): # Invalid Max-Age s = 'color=blue; Max-Age=over-the-hill' - with self.assertRaises(ValueError): + with pytest.raises(ValueError): Cookie.parse(s) cookie = Cookie('color', 'blue') - with self.assertRaises(ValueError): + with pytest.raises(ValueError): cookie.max_age = 'over-the-hill' # Invalid Expires s = 'color=blue; Expires=Sun, 06 Xxx 1994 08:49:37 GMT' - with self.assertRaises(ValueError): + with pytest.raises(ValueError): Cookie.parse(s) cookie = Cookie('color', 'blue') - with self.assertRaises(ValueError): + with pytest.raises(ValueError): cookie.expires = 'Sun, 06 Xxx 1994 08:49:37 GMT' -class TestAttributes(unittest.TestCase): +class TestAttributes: def test_attributes(self): cookie = Cookie('color', 'blue') - self.assertEqual(cookie.key, 'color') - self.assertEqual(cookie.value, 'blue') - self.assertEqual(cookie.domain, None) - self.assertEqual(cookie.path, None) - self.assertEqual(cookie.max_age, None) - self.assertEqual(cookie.expires, None) - self.assertEqual(cookie.secure, None) - self.assertEqual(cookie.httponly, None) + assert cookie.key == 'color' + assert cookie.value == 'blue' + assert cookie.domain is None + assert cookie.path is None + assert cookie.max_age is None + assert cookie.expires is None + assert cookie.secure is None + assert cookie.httponly is None cookie.domain = 'example.com' - self.assertEqual(cookie.domain, 'example.com') + assert cookie.domain == 'example.com' cookie.domain = None - self.assertEqual(cookie.domain, None) + assert cookie.domain is None cookie.path = '/toplevel' - self.assertEqual(cookie.path, '/toplevel') + assert cookie.path == '/toplevel' cookie.path = None - self.assertEqual(cookie.path, None) + assert cookie.path is None cookie.max_age = 400 - self.assertEqual(cookie.max_age, 400) + assert cookie.max_age == 400 cookie.max_age = None - self.assertEqual(cookie.max_age, None) + assert cookie.max_age is None cookie.expires = 'Sun, 06 Nov 1994 08:49:37 GMT' - self.assertEqual(cookie.expires, datetime.datetime(1994, 11, 6, 8, 49, 37)) + assert cookie.expires == datetime.datetime(1994, 11, 6, 8, 49, 37) cookie.expires = None - self.assertEqual(cookie.expires, None) + assert cookie.expires is None cookie.secure = True - self.assertEqual(cookie.secure, True) - self.assertEqual(str(cookie), "color=blue; Secure") + assert cookie.secure is True + assert str(cookie) == "color=blue; Secure" cookie.secure = False - self.assertEqual(cookie.secure, False) - self.assertEqual(str(cookie), "color=blue") + assert cookie.secure is False + assert str(cookie) == "color=blue" cookie.secure = None - self.assertEqual(cookie.secure, None) - self.assertEqual(str(cookie), "color=blue") + assert cookie.secure is None + assert str(cookie) == "color=blue" cookie.httponly = True - self.assertEqual(cookie.httponly, True) - self.assertEqual(str(cookie), "color=blue; HttpOnly") + assert cookie.httponly is True + assert str(cookie) == "color=blue; HttpOnly" cookie.httponly = False - self.assertEqual(cookie.httponly, False) - self.assertEqual(str(cookie), "color=blue") + assert cookie.httponly is False + assert str(cookie) == "color=blue" cookie.httponly = None - self.assertEqual(cookie.httponly, None) - self.assertEqual(str(cookie), "color=blue") + assert cookie.httponly is None + assert str(cookie) == "color=blue" -class TestHTTPReturn(unittest.TestCase): - def setUp(self): +class TestHTTPReturn: + @pytest.fixture(autouse=True) + def http_return_setup(self): self.url = 'http://www.foo.bar.com/one/two' def test_no_attributes(self): cookie = Cookie('color', 'blue') - self.assertTrue(cookie.http_return_ok(self.url)) + assert cookie.http_return_ok(self.url) def test_domain(self): cookie = Cookie('color', 'blue', domain='www.foo.bar.com') - self.assertTrue(cookie.http_return_ok(self.url)) + assert cookie.http_return_ok(self.url) cookie = Cookie('color', 'blue', domain='.foo.bar.com') - self.assertTrue(cookie.http_return_ok(self.url)) + assert cookie.http_return_ok(self.url) cookie = Cookie('color', 'blue', domain='.bar.com') - self.assertTrue(cookie.http_return_ok(self.url)) + assert cookie.http_return_ok(self.url) cookie = Cookie('color', 'blue', domain='bar.com') - with self.assertRaises(Cookie.URLMismatch): - self.assertTrue(cookie.http_return_ok(self.url)) + with pytest.raises(Cookie.URLMismatch): + assert cookie.http_return_ok(self.url) cookie = Cookie('color', 'blue', domain='bogus.com') - with self.assertRaises(Cookie.URLMismatch): - self.assertTrue(cookie.http_return_ok(self.url)) + with pytest.raises(Cookie.URLMismatch): + assert cookie.http_return_ok(self.url) cookie = Cookie('color', 'blue', domain='www.foo.bar.com') - with self.assertRaises(Cookie.URLMismatch): - self.assertTrue(cookie.http_return_ok('http://192.168.1.1/one/two')) + with pytest.raises(Cookie.URLMismatch): + assert cookie.http_return_ok('http://192.168.1.1/one/two') def test_path(self): cookie = Cookie('color', 'blue') - self.assertTrue(cookie.http_return_ok(self.url)) + assert cookie.http_return_ok(self.url) cookie = Cookie('color', 'blue', path='/') - self.assertTrue(cookie.http_return_ok(self.url)) + assert cookie.http_return_ok(self.url) cookie = Cookie('color', 'blue', path='/one') - self.assertTrue(cookie.http_return_ok(self.url)) + assert cookie.http_return_ok(self.url) cookie = Cookie('color', 'blue', path='/oneX') - with self.assertRaises(Cookie.URLMismatch): - self.assertTrue(cookie.http_return_ok(self.url)) + with pytest.raises(Cookie.URLMismatch): + assert cookie.http_return_ok(self.url) def test_expires(self): now = datetime.datetime.utcnow().replace(microsecond=0) @@ -399,32 +404,34 @@ class TestHTTPReturn(unittest.TestCase): expires = now + datetime.timedelta(days=1) cookie = Cookie('color', 'blue', expires=expires) - self.assertTrue(cookie.http_return_ok(self.url)) + assert cookie.http_return_ok(self.url) # expired 1 day ago expires = now + datetime.timedelta(days=-1) cookie = Cookie('color', 'blue', expires=expires) - with self.assertRaises(Cookie.Expired): - self.assertTrue(cookie.http_return_ok(self.url)) + with pytest.raises(Cookie.Expired): + assert cookie.http_return_ok(self.url) def test_httponly(self): cookie = Cookie('color', 'blue', httponly=True) - self.assertTrue(cookie.http_return_ok('http://example.com')) - self.assertTrue(cookie.http_return_ok('https://example.com')) + assert cookie.http_return_ok('http://example.com') + assert cookie.http_return_ok('https://example.com') - with self.assertRaises(Cookie.URLMismatch): - self.assertTrue(cookie.http_return_ok('ftp://example.com')) + with pytest.raises(Cookie.URLMismatch): + assert cookie.http_return_ok('ftp://example.com') def test_secure(self): cookie = Cookie('color', 'blue', secure=True) - self.assertTrue(cookie.http_return_ok('https://Xexample.com')) + assert cookie.http_return_ok('https://Xexample.com') - with self.assertRaises(Cookie.URLMismatch): - self.assertTrue(cookie.http_return_ok('http://Xexample.com')) + with pytest.raises(Cookie.URLMismatch): + assert cookie.http_return_ok('http://Xexample.com') -class TestNormalization(unittest.TestCase): - def setUp(self): + +class TestNormalization: + @pytest.fixture(autouse=True) + def normalization_setup(self): # Force microseconds to zero because cookie timestamps only have second resolution self.now = datetime.datetime.utcnow().replace(microsecond=0) self.now_timestamp = calendar.timegm(self.now.utctimetuple()) @@ -440,58 +447,53 @@ class TestNormalization(unittest.TestCase): self.expires_string = email.utils.formatdate(self.expires_timestamp, usegmt=True) def test_path_normalization(self): - self.assertEqual(Cookie.normalize_url_path(''), '/') - self.assertEqual(Cookie.normalize_url_path('foo'), '/') - self.assertEqual(Cookie.normalize_url_path('foo/'), '/') - self.assertEqual(Cookie.normalize_url_path('/foo'), '/') - self.assertEqual(Cookie.normalize_url_path('/foo/'), '/foo') - self.assertEqual(Cookie.normalize_url_path('/Foo/bar'), '/foo') - self.assertEqual(Cookie.normalize_url_path('/foo/baR/'), '/foo/bar') + assert Cookie.normalize_url_path('') == '/' + assert Cookie.normalize_url_path('foo') == '/' + assert Cookie.normalize_url_path('foo/') == '/' + assert Cookie.normalize_url_path('/foo') == '/' + assert Cookie.normalize_url_path('/foo/') == '/foo' + assert Cookie.normalize_url_path('/Foo/bar') == '/foo' + assert Cookie.normalize_url_path('/foo/baR/') == '/foo/bar' def test_normalization(self): cookie = Cookie('color', 'blue', expires=self.expires) cookie.timestamp = self.now_timestamp - self.assertEqual(cookie.domain, None) - self.assertEqual(cookie.path, None) + assert cookie.domain is None + assert cookie.path is None url = 'http://example.COM/foo' cookie.normalize(url) - self.assertEqual(cookie.domain, 'example.com') - self.assertEqual(cookie.path, '/') - self.assertEqual(cookie.expires, self.expires) + assert cookie.domain == 'example.com' + assert cookie.path == '/' + assert cookie.expires == self.expires cookie = Cookie('color', 'blue', max_age=self.max_age) cookie.timestamp = self.now_timestamp - self.assertEqual(cookie.domain, None) - self.assertEqual(cookie.path, None) + assert cookie.domain is None + assert cookie.path is None url = 'http://example.com/foo/' cookie.normalize(url) - self.assertEqual(cookie.domain, 'example.com') - self.assertEqual(cookie.path, '/foo') - self.assertEqual(cookie.expires, self.age_expiration) + assert cookie.domain == 'example.com' + assert cookie.path == '/foo' + assert cookie.expires == self.age_expiration cookie = Cookie('color', 'blue') url = 'http://example.com/foo' cookie.normalize(url) - self.assertEqual(cookie.domain, 'example.com') - self.assertEqual(cookie.path, '/') + assert cookie.domain == 'example.com' + assert cookie.path == '/' cookie = Cookie('color', 'blue') url = 'http://example.com/foo/bar' cookie.normalize(url) - self.assertEqual(cookie.domain, 'example.com') - self.assertEqual(cookie.path, '/foo') + assert cookie.domain == 'example.com' + assert cookie.path == '/foo' cookie = Cookie('color', 'blue') url = 'http://example.com/foo/bar/' cookie.normalize(url) - self.assertEqual(cookie.domain, 'example.com') - self.assertEqual(cookie.path, '/foo/bar') - - -#------------------------------------------------------------------------------- -if __name__ == '__main__': - unittest.main() + assert cookie.domain == 'example.com' + assert cookie.path == '/foo/bar' diff --git a/ipatests/test_ipapython/test_dn.py b/ipatests/test_ipapython/test_dn.py index 7e3f8cb02..ae7c68573 100644 --- a/ipatests/test_ipapython/test_dn.py +++ b/ipatests/test_ipapython/test_dn.py @@ -1,6 +1,5 @@ import contextlib -import unittest import pytest from cryptography import x509 @@ -59,8 +58,9 @@ def expected_class(klass, component): raise ValueError("class %s with component '%s' unknown" % (klass.__name__, component)) -class TestAVA(unittest.TestCase): - def setUp(self): +class TestAVA: + @pytest.fixture(autouse=True) + def ava_setup(self): self.attr1 = 'cn' self.value1 = 'Bob' self.str_ava1 = '%s=%s' % (self.attr1, self.value1) @@ -77,159 +77,159 @@ class TestAVA(unittest.TestCase): self.ava3 = AVA(self.attr3, self.value3) def assertExpectedClass(self, klass, obj, component): - self.assertIs(obj.__class__, expected_class(klass, component)) + assert obj.__class__ is expected_class(klass, component) def test_create(self): # Create with attr,value pair ava1 = AVA(self.attr1, self.value1) self.assertExpectedClass(AVA, ava1, 'self') - self.assertEqual(ava1, self.ava1) + assert ava1 == self.ava1 # Create with "attr=value" string ava1 = AVA(self.str_ava1) self.assertExpectedClass(AVA, ava1, 'self') - self.assertEqual(ava1, self.ava1) + assert ava1 == self.ava1 # Create with tuple (attr, value) ava1 = AVA((self.attr1, self.value1)) self.assertExpectedClass(AVA, ava1, 'self') - self.assertEqual(ava1, self.ava1) + assert ava1 == self.ava1 # Create with list [attr, value] ava1 = AVA([self.attr1, self.value1]) self.assertExpectedClass(AVA, ava1, 'self') - self.assertEqual(ava1, self.ava1) + assert ava1 == self.ava1 # Create with no args should fail - with self.assertRaises(TypeError): + with pytest.raises(TypeError): AVA() # Create with more than 3 args should fail - with self.assertRaises(TypeError): + with pytest.raises(TypeError): AVA(self.attr1, self.value1, self.attr1, self.attr1) # Create with 1 arg which is not string should fail - with self.assertRaises(TypeError): + with pytest.raises(TypeError): AVA(1) # Create with malformed AVA string should fail - with self.assertRaises(ValueError): + with pytest.raises(ValueError): AVA("cn") # Create with non-string parameters, should convert ava1 = AVA(1, self.value1) self.assertExpectedClass(AVA, ava1, 'self') - self.assertEqual(ava1.attr, u'1') + assert ava1.attr == u'1' ava1 = AVA((1, self.value1)) self.assertExpectedClass(AVA, ava1, 'self') - self.assertEqual(ava1.attr, u'1') + assert ava1.attr == u'1' ava1 = AVA(self.attr1, 1) self.assertExpectedClass(AVA, ava1, 'self') - self.assertEqual(ava1.value, u'1') + assert ava1.value == u'1' ava1 = AVA((self.attr1, 1)) self.assertExpectedClass(AVA, ava1, 'self') - self.assertEqual(ava1.value, u'1') + assert ava1.value == u'1' def test_indexing(self): ava1 = AVA(self.ava1) - self.assertEqual(ava1[self.attr1], self.value1) + assert ava1[self.attr1] == self.value1 - self.assertEqual(ava1[0], self.attr1) - self.assertEqual(ava1[1], self.value1) + assert ava1[0] == self.attr1 + assert ava1[1] == self.value1 - with self.assertRaises(KeyError): + with pytest.raises(KeyError): ava1['foo'] # pylint: disable=pointless-statement - with self.assertRaises(KeyError): + with pytest.raises(KeyError): ava1[3] # pylint: disable=pointless-statement def test_properties(self): ava1 = AVA(self.ava1) - self.assertEqual(ava1.attr, self.attr1) - self.assertIsInstance(ava1.attr, unicode) + assert ava1.attr == self.attr1 + assert isinstance(ava1.attr, unicode) - self.assertEqual(ava1.value, self.value1) - self.assertIsInstance(ava1.value, unicode) + assert ava1.value == self.value1 + assert isinstance(ava1.value, unicode) def test_str(self): ava1 = AVA(self.ava1) - self.assertEqual(str(ava1), self.str_ava1) - self.assertIsInstance(str(ava1), str) + assert str(ava1) == self.str_ava1 + assert isinstance(str(ava1), str) def test_cmp(self): # Equality ava1 = AVA(self.attr1, self.value1) - self.assertTrue(ava1 == self.ava1) - self.assertFalse(ava1 != self.ava1) + assert ava1 == self.ava1 + assert ava1 == self.ava1 - self.assertTrue(ava1 == self.str_ava1) - self.assertFalse(ava1 != self.str_ava1) + assert ava1 == self.str_ava1 + assert ava1 == self.str_ava1 result = cmp(ava1, self.ava1) - self.assertEqual(result, 0) + assert result == 0 # Upper case attr should still be equal ava1 = AVA(self.attr1.upper(), self.value1) - self.assertFalse(ava1.attr == self.attr1) - self.assertTrue(ava1.value == self.value1) - self.assertTrue(ava1 == self.ava1) - self.assertFalse(ava1 != self.ava1) + assert ava1.attr != self.attr1 + assert ava1.value == self.value1 + assert ava1 == self.ava1 + assert ava1 == self.ava1 result = cmp(ava1, self.ava1) - self.assertEqual(result, 0) + assert result == 0 # Upper case value should still be equal ava1 = AVA(self.attr1, self.value1.upper()) - self.assertTrue(ava1.attr == self.attr1) - self.assertFalse(ava1.value == self.value1) - self.assertTrue(ava1 == self.ava1) - self.assertFalse(ava1 != self.ava1) + assert ava1.attr == self.attr1 + assert ava1.value != self.value1 + assert ava1 == self.ava1 + assert ava1 == self.ava1 result = cmp(ava1, self.ava1) - self.assertEqual(result, 0) + assert result == 0 # Make ava1's attr greater - with self.assertRaises(AttributeError): + with pytest.raises(AttributeError): ava1.attr = self.attr1 + "1" ava1 = AVA(self.attr1 + "1", self.value1.upper()) - self.assertFalse(ava1 == self.ava1) - self.assertTrue(ava1 != self.ava1) + assert ava1 != self.ava1 + assert ava1 != self.ava1 result = cmp(ava1, self.ava1) - self.assertEqual(result, 1) + assert result == 1 result = cmp(self.ava1, ava1) - self.assertEqual(result, -1) + assert result == -1 # Reset ava1's attr, should be equal again - with self.assertRaises(AttributeError): + with pytest.raises(AttributeError): ava1.attr = self.attr1 ava1 = AVA(self.attr1, self.value1.upper()) result = cmp(ava1, self.ava1) - self.assertEqual(result, 0) + assert result == 0 # Make ava1's value greater # attr will be equal, this tests secondary comparision component - with self.assertRaises(AttributeError): + with pytest.raises(AttributeError): ava1.value = self.value1 + "1" ava1 = AVA(self.attr1, self.value1 + "1") result = cmp(ava1, self.ava1) - self.assertEqual(result, 1) + assert result == 1 result = cmp(self.ava1, ava1) - self.assertEqual(result, -1) + assert result == -1 def test_hashing(self): # create AVA's that are equal but differ in case @@ -237,8 +237,8 @@ class TestAVA(unittest.TestCase): ava2 = AVA((self.attr1.upper(), self.value1.lower())) # AVAs that are equal should hash to the same value. - self.assertEqual(ava1, ava2) - self.assertEqual(hash(ava1), hash(ava2)) + assert ava1 == ava2 + assert hash(ava1) == hash(ava2) # Different AVA objects with the same value should # map to 1 common key and 1 member in a set. The key and @@ -253,9 +253,9 @@ class TestAVA(unittest.TestCase): ava3_a = AVA(self.ava3) ava3_b = AVA(self.ava3) - self.assertEqual(ava1_a, ava1_b) - self.assertEqual(ava2_a, ava2_b) - self.assertEqual(ava3_a, ava3_b) + assert ava1_a == ava1_b + assert ava2_a == ava2_b + assert ava3_a == ava3_b d = dict() s = set() @@ -270,28 +270,29 @@ class TestAVA(unittest.TestCase): s.add(ava2_a) s.add(ava2_b) - self.assertEqual(len(d), 2) - self.assertEqual(len(s), 2) - self.assertEqual(sorted(d), sorted([ava1_a, ava2_a])) - self.assertEqual(sorted(s), sorted([ava1_a, ava2_a])) + assert len(d) == 2 + assert len(s) == 2 + assert sorted(d) == sorted([ava1_a, ava2_a]) + assert sorted(s) == sorted([ava1_a, ava2_a]) - self.assertTrue(ava1_a in d) - self.assertTrue(ava1_b in d) - self.assertTrue(ava2_a in d) - self.assertTrue(ava2_b in d) - self.assertFalse(ava3_a in d) - self.assertFalse(ava3_b in d) + assert ava1_a in d + assert ava1_b in d + assert ava2_a in d + assert ava2_b in d + assert ava3_a not in d + assert ava3_b not in d - self.assertTrue(ava1_a in s) - self.assertTrue(ava1_b in s) - self.assertTrue(ava2_a in s) - self.assertTrue(ava2_b in s) - self.assertFalse(ava3_a in s) - self.assertFalse(ava3_b in s) + assert ava1_a in s + assert ava1_b in s + assert ava2_a in s + assert ava2_b in s + assert ava3_a not in s + assert ava3_b not in s -class TestRDN(unittest.TestCase): - def setUp(self): +class TestRDN: + @pytest.fixture(autouse=True) + def rdn_setup(self): # ava1 must sort before ava2 self.attr1 = 'cn' self.value1 = 'Bob' @@ -315,222 +316,221 @@ class TestRDN(unittest.TestCase): self.rdn3 = RDN(self.ava1, self.ava2) def assertExpectedClass(self, klass, obj, component): - self.assertIs(obj.__class__, expected_class(klass, component)) + assert obj.__class__ is expected_class(klass, component) def test_create(self): # Create with single attr,value pair rdn1 = RDN((self.attr1, self.value1)) - - self.assertEqual(len(rdn1), 1) - self.assertEqual(rdn1, self.rdn1) + assert len(rdn1) == 1 + assert rdn1 == self.rdn1 self.assertExpectedClass(RDN, rdn1, 'self') for i in range(0, len(rdn1)): self.assertExpectedClass(RDN, rdn1[i], 'AVA') - self.assertEqual(rdn1[0], self.ava1) + assert rdn1[0] == self.ava1 # Create with multiple attr,value pairs rdn3 = RDN((self.attr1, self.value1), (self.attr2, self.value2)) - self.assertEqual(len(rdn3), 2) - self.assertEqual(rdn3, self.rdn3) + assert len(rdn3) == 2 + assert rdn3 == self.rdn3 self.assertExpectedClass(RDN, rdn3, 'self') for i in range(0, len(rdn3)): self.assertExpectedClass(RDN, rdn3[i], 'AVA') - self.assertEqual(rdn3[0], self.ava1) - self.assertEqual(rdn3[1], self.ava2) + assert rdn3[0] == self.ava1 + assert rdn3[1] == self.ava2 # Create with multiple attr,value pairs passed as lists rdn3 = RDN([self.attr1, self.value1], [self.attr2, self.value2]) - self.assertEqual(len(rdn3), 2) - self.assertEqual(rdn3, self.rdn3) + assert len(rdn3) == 2 + assert rdn3 == self.rdn3 self.assertExpectedClass(RDN, rdn3, 'self') for i in range(0, len(rdn3)): self.assertExpectedClass(RDN, rdn3[i], 'AVA') - self.assertEqual(rdn3[0], self.ava1) - self.assertEqual(rdn3[1], self.ava2) + assert rdn3[0] == self.ava1 + assert rdn3[1] == self.ava2 # Create with multiple attr,value pairs but reverse # constructor parameter ordering. RDN canonical ordering # should remain the same rdn3 = RDN((self.attr2, self.value2), (self.attr1, self.value1)) - self.assertEqual(len(rdn3), 2) - self.assertEqual(rdn3, self.rdn3) + assert len(rdn3) == 2 + assert rdn3 == self.rdn3 self.assertExpectedClass(RDN, rdn3, 'self') for i in range(0, len(rdn3)): self.assertExpectedClass(RDN, rdn3[i], 'AVA') - self.assertEqual(rdn3[0], self.ava1) - self.assertEqual(rdn3[1], self.ava2) + assert rdn3[0] == self.ava1 + assert rdn3[1] == self.ava2 # Create with single AVA object rdn1 = RDN(self.ava1) - self.assertEqual(len(rdn1), 1) - self.assertEqual(rdn1, self.rdn1) + assert len(rdn1) == 1 + assert rdn1 == self.rdn1 self.assertExpectedClass(RDN, rdn1, 'self') for i in range(0, len(rdn1)): self.assertExpectedClass(RDN, rdn1[i], 'AVA') - self.assertEqual(rdn1[0], self.ava1) + assert rdn1[0] == self.ava1 # Create with multiple AVA objects rdn3 = RDN(self.ava1, self.ava2) - self.assertEqual(len(rdn3), 2) - self.assertEqual(rdn3, self.rdn3) + assert len(rdn3) == 2 + assert rdn3 == self.rdn3 self.assertExpectedClass(RDN, rdn3, 'self') for i in range(0, len(rdn3)): self.assertExpectedClass(RDN, rdn3[i], 'AVA') - self.assertEqual(rdn3[0], self.ava1) - self.assertEqual(rdn3[1], self.ava2) + assert rdn3[0] == self.ava1 + assert rdn3[1] == self.ava2 # Create with multiple AVA objects but reverse constructor # parameter ordering. RDN canonical ordering should remain # the same rdn3 = RDN(self.ava2, self.ava1) - self.assertEqual(len(rdn3), 2) - self.assertEqual(rdn3, self.rdn3) + assert len(rdn3) == 2 + assert rdn3 == self.rdn3 self.assertExpectedClass(RDN, rdn3, 'self') for i in range(0, len(rdn3)): self.assertExpectedClass(RDN, rdn3[i], 'AVA') - self.assertEqual(rdn3[0], self.ava1) - self.assertEqual(rdn3[1], self.ava2) + assert rdn3[0] == self.ava1 + assert rdn3[1] == self.ava2 # Create with single string with 1 AVA rdn1 = RDN(self.str_rdn1) - self.assertEqual(len(rdn1), 1) - self.assertEqual(rdn1, self.rdn1) + assert len(rdn1) == 1 + assert rdn1 == self.rdn1 self.assertExpectedClass(RDN, rdn1, 'self') for i in range(0, len(rdn1)): self.assertExpectedClass(RDN, rdn1[i], 'AVA') - self.assertEqual(rdn1[0], self.ava1) + assert rdn1[0] == self.ava1 # Create with single string with 2 AVA's rdn3 = RDN(self.str_rdn3) - self.assertEqual(len(rdn3), 2) - self.assertEqual(rdn3, self.rdn3) + assert len(rdn3) == 2 + assert rdn3 == self.rdn3 self.assertExpectedClass(RDN, rdn3, 'self') for i in range(0, len(rdn3)): self.assertExpectedClass(RDN, rdn3[i], 'AVA') - self.assertEqual(rdn3[0], self.ava1) - self.assertEqual(rdn3[1], self.ava2) + assert rdn3[0] == self.ava1 + assert rdn3[1] == self.ava2 def test_properties(self): rdn1 = RDN(self.rdn1) rdn2 = RDN(self.rdn2) rdn3 = RDN(self.rdn3) - self.assertEqual(rdn1.attr, self.attr1) - self.assertIsInstance(rdn1.attr, unicode) + assert rdn1.attr == self.attr1 + assert isinstance(rdn1.attr, unicode) - self.assertEqual(rdn1.value, self.value1) - self.assertIsInstance(rdn1.value, unicode) + assert rdn1.value == self.value1 + assert isinstance(rdn1.value, unicode) - self.assertEqual(rdn2.attr, self.attr2) - self.assertIsInstance(rdn2.attr, unicode) + assert rdn2.attr == self.attr2 + assert isinstance(rdn2.attr, unicode) - self.assertEqual(rdn2.value, self.value2) - self.assertIsInstance(rdn2.value, unicode) + assert rdn2.value == self.value2 + assert isinstance(rdn2.value, unicode) - self.assertEqual(rdn3.attr, self.attr1) - self.assertIsInstance(rdn3.attr, unicode) + assert rdn3.attr == self.attr1 + assert isinstance(rdn3.attr, unicode) - self.assertEqual(rdn3.value, self.value1) - self.assertIsInstance(rdn3.value, unicode) + assert rdn3.value == self.value1 + assert isinstance(rdn3.value, unicode) def test_str(self): rdn1 = RDN(self.rdn1) rdn2 = RDN(self.rdn2) rdn3 = RDN(self.rdn3) - self.assertEqual(str(rdn1), self.str_rdn1) - self.assertIsInstance(str(rdn1), str) + assert str(rdn1) == self.str_rdn1 + assert isinstance(str(rdn1), str) - self.assertEqual(str(rdn2), self.str_rdn2) - self.assertIsInstance(str(rdn2), str) + assert str(rdn2) == self.str_rdn2 + assert isinstance(str(rdn2), str) - self.assertEqual(str(rdn3), self.str_rdn3) - self.assertIsInstance(str(rdn3), str) + assert str(rdn3) == self.str_rdn3 + assert isinstance(str(rdn3), str) def test_cmp(self): # Equality rdn1 = RDN((self.attr1, self.value1)) - self.assertTrue(rdn1 == self.rdn1) - self.assertFalse(rdn1 != self.rdn1) + assert rdn1 == self.rdn1 + assert rdn1 == self.rdn1 - self.assertTrue(rdn1 == self.str_rdn1) - self.assertFalse(rdn1 != self.str_rdn1) + assert rdn1 == self.str_rdn1 + assert rdn1 == self.str_rdn1 result = cmp(rdn1, self.rdn1) - self.assertEqual(result, 0) + assert result == 0 # Make rdn1's attr greater rdn1 = RDN((self.attr1 + "1", self.value1)) - self.assertFalse(rdn1 == self.rdn1) - self.assertTrue(rdn1 != self.rdn1) + assert rdn1 != self.rdn1 + assert rdn1 != self.rdn1 result = cmp(rdn1, self.rdn1) - self.assertEqual(result, 1) + assert result == 1 result = cmp(self.rdn1, rdn1) - self.assertEqual(result, -1) + assert result == -1 # Reset rdn1's attr, should be equal again rdn1 = RDN((self.attr1, self.value1)) result = cmp(rdn1, self.rdn1) - self.assertEqual(result, 0) + assert result == 0 # Make rdn1's value greater # attr will be equal, this tests secondary comparision component rdn1 = RDN((self.attr1, self.value1 + "1")) result = cmp(rdn1, self.rdn1) - self.assertEqual(result, 1) + assert result == 1 result = cmp(self.rdn1, rdn1) - self.assertEqual(result, -1) + assert result == -1 # Make sure rdn's with more ava's are greater result = cmp(self.rdn1, self.rdn3) - self.assertEqual(result, -1) + assert result == -1 result = cmp(self.rdn3, self.rdn1) - self.assertEqual(result, 1) + assert result == 1 def test_indexing(self): rdn1 = RDN(self.rdn1) rdn2 = RDN(self.rdn2) rdn3 = RDN(self.rdn3) - self.assertEqual(rdn1[0], self.ava1) - self.assertEqual(rdn1[self.ava1.attr], self.ava1.value) - with self.assertRaises(KeyError): + assert rdn1[0] == self.ava1 + assert rdn1[self.ava1.attr] == self.ava1.value + with pytest.raises(KeyError): rdn1['foo'] # pylint: disable=pointless-statement - self.assertEqual(rdn2[0], self.ava2) - self.assertEqual(rdn2[self.ava2.attr], self.ava2.value) - with self.assertRaises(KeyError): + assert rdn2[0] == self.ava2 + assert rdn2[self.ava2.attr] == self.ava2.value + with pytest.raises(KeyError): rdn2['foo'] # pylint: disable=pointless-statement - self.assertEqual(rdn3[0], self.ava1) - self.assertEqual(rdn3[self.ava1.attr], self.ava1.value) - self.assertEqual(rdn3[1], self.ava2) - self.assertEqual(rdn3[self.ava2.attr], self.ava2.value) - with self.assertRaises(KeyError): + assert rdn3[0] == self.ava1 + assert rdn3[self.ava1.attr] == self.ava1.value + assert rdn3[1] == self.ava2 + assert rdn3[self.ava2.attr] == self.ava2.value + with pytest.raises(KeyError): rdn3['foo'] # pylint: disable=pointless-statement - self.assertEqual(rdn1.attr, self.attr1) - self.assertEqual(rdn1.value, self.value1) + assert rdn1.attr == self.attr1 + assert rdn1.value == self.value1 - with self.assertRaises(TypeError): + with pytest.raises(TypeError): rdn3[1.0] # pylint: disable=pointless-statement # Slices - self.assertEqual(rdn3[0:1], [self.ava1]) - self.assertEqual(rdn3[:], [self.ava1, self.ava2]) + assert rdn3[0:1] == [self.ava1] + assert rdn3[:] == [self.ava1, self.ava2] def test_assignments(self): rdn = RDN((self.attr1, self.value1)) - with self.assertRaises(TypeError): + with pytest.raises(TypeError): # pylint: disable=unsupported-assignment-operation rdn[0] = self.ava2 @@ -539,31 +539,34 @@ class TestRDN(unittest.TestCase): rdn2 = RDN(self.rdn2) rdn3 = RDN(self.rdn3) - self.assertEqual(len(rdn1), 1) - self.assertEqual(rdn1[:], [self.ava1]) + assert len(rdn1) == 1 + assert rdn1[:] == [self.ava1] for i, ava in enumerate(rdn1): if i == 0: - self.assertEqual(ava, self.ava1) + assert ava == self.ava1 else: - self.fail("got iteration index %d, but len=%d" % (i, len(rdn1))) + pytest.fail( + "got iteration index %d, but len=%d" % (i, len(rdn1))) - self.assertEqual(len(rdn2), 1) - self.assertEqual(rdn2[:], [self.ava2]) + assert len(rdn2) == 1 + assert rdn2[:] == [self.ava2] for i, ava in enumerate(rdn2): if i == 0: - self.assertEqual(ava, self.ava2) + assert ava == self.ava2 else: - self.fail("got iteration index %d, but len=%d" % (i, len(rdn2))) + pytest.fail( + "got iteration index %d, but len=%d" % (i, len(rdn2))) - self.assertEqual(len(rdn3), 2) - self.assertEqual(rdn3[:], [self.ava1, self.ava2]) + assert len(rdn3) == 2 + assert rdn3[:] == [self.ava1, self.ava2] for i, ava in enumerate(rdn3): if i == 0: - self.assertEqual(ava, self.ava1) + assert ava == self.ava1 elif i == 1: - self.assertEqual(ava, self.ava2) + assert ava == self.ava2 else: - self.fail("got iteration index %d, but len=%d" % (i, len(rdn3))) + pytest.fail( + "got iteration index %d, but len=%d" % (i, len(rdn3))) def test_concat(self): @@ -572,21 +575,21 @@ class TestRDN(unittest.TestCase): # in-place addtion rdn1 += rdn2 - self.assertEqual(rdn1, self.rdn3) + assert rdn1 == self.rdn3 self.assertExpectedClass(RDN, rdn1, 'self') for i in range(0, len(rdn1)): self.assertExpectedClass(RDN, rdn1[i], 'AVA') rdn1 = RDN((self.attr1, self.value1)) rdn1 += self.ava2 - self.assertEqual(rdn1, self.rdn3) + assert rdn1 == self.rdn3 self.assertExpectedClass(RDN, rdn1, 'self') for i in range(0, len(rdn1)): self.assertExpectedClass(RDN, rdn1[i], 'AVA') rdn1 = RDN((self.attr1, self.value1)) rdn1 += self.str_ava2 - self.assertEqual(rdn1, self.rdn3) + assert rdn1 == self.rdn3 self.assertExpectedClass(RDN, rdn1, 'self') for i in range(0, len(rdn1)): self.assertExpectedClass(RDN, rdn1[i], 'AVA') @@ -594,19 +597,19 @@ class TestRDN(unittest.TestCase): # concatenation rdn1 = RDN((self.attr1, self.value1)) rdn3 = rdn1 + rdn2 - self.assertEqual(rdn3, self.rdn3) + assert rdn3 == self.rdn3 self.assertExpectedClass(RDN, rdn3, 'self') for i in range(0, len(rdn3)): self.assertExpectedClass(RDN, rdn3[i], 'AVA') rdn3 = rdn1 + self.ava2 - self.assertEqual(rdn3, self.rdn3) + assert rdn3 == self.rdn3 self.assertExpectedClass(RDN, rdn3, 'self') for i in range(0, len(rdn3)): self.assertExpectedClass(RDN, rdn3[i], 'AVA') rdn3 = rdn1 + self.str_ava2 - self.assertEqual(rdn3, self.rdn3) + assert rdn3 == self.rdn3 self.assertExpectedClass(RDN, rdn3, 'self') for i in range(0, len(rdn3)): self.assertExpectedClass(RDN, rdn3[i], 'AVA') @@ -618,12 +621,13 @@ class TestRDN(unittest.TestCase): rdn2 = RDN((self.attr1.upper(), self.value1.lower())) # RDNs that are equal should hash to the same value. - self.assertEqual(rdn1, rdn2) - self.assertEqual(hash(rdn1), hash(rdn2)) + assert rdn1 == rdn2 + assert hash(rdn1) == hash(rdn2) -class TestDN(unittest.TestCase): - def setUp(self): +class TestDN: + @pytest.fixture(autouse=True) + def dn_setup(self): # ava1 must sort before ava2 self.attr1 = 'cn' self.value1 = u'Bob' @@ -678,326 +682,324 @@ class TestDN(unittest.TestCase): ]) def assertExpectedClass(self, klass, obj, component): - self.assertIs(obj.__class__, expected_class(klass, component)) + assert obj.__class__ is expected_class(klass, component) def test_create(self): # Create with single attr,value pair dn1 = DN((self.attr1, self.value1)) - self.assertEqual(len(dn1), 1) + assert len(dn1) == 1 self.assertExpectedClass(DN, dn1, 'self') for i in range(0, len(dn1)): self.assertExpectedClass(DN, dn1[i], 'RDN') for j in range(0, len(dn1[i])): self.assertExpectedClass(DN, dn1[i][j], 'AVA') - self.assertIsInstance(dn1[0].attr, unicode) - self.assertIsInstance(dn1[0].value, unicode) - self.assertEqual(dn1[0], self.rdn1) + assert isinstance(dn1[0].attr, unicode) + assert isinstance(dn1[0].value, unicode) + assert dn1[0] == self.rdn1 # Create with single attr,value pair passed as a tuple dn1 = DN((self.attr1, self.value1)) - self.assertEqual(len(dn1), 1) + assert len(dn1) == 1 self.assertExpectedClass(DN, dn1, 'self') for i in range(0, len(dn1)): self.assertExpectedClass(DN, dn1[i], 'RDN') for j in range(0, len(dn1[i])): self.assertExpectedClass(DN, dn1[i][j], 'AVA') - self.assertIsInstance(dn1[i].attr, unicode) - self.assertIsInstance(dn1[i].value, unicode) - self.assertEqual(dn1[0], self.rdn1) + assert isinstance(dn1[i].attr, unicode) + assert isinstance(dn1[i].value, unicode) + assert dn1[0] == self.rdn1 # Creation with multiple attr,value string pairs should fail - with self.assertRaises(ValueError): + with pytest.raises(ValueError): dn1 = DN(self.attr1, self.value1, self.attr2, self.value2) # Create with multiple attr,value pairs passed as tuples & lists dn1 = DN((self.attr1, self.value1), [self.attr2, self.value2]) - self.assertEqual(len(dn1), 2) + assert len(dn1) == 2 self.assertExpectedClass(DN, dn1, 'self') for i in range(0, len(dn1)): self.assertExpectedClass(DN, dn1[i], 'RDN') for j in range(0, len(dn1[i])): self.assertExpectedClass(DN, dn1[i][j], 'AVA') - self.assertIsInstance(dn1[i].attr, unicode) - self.assertIsInstance(dn1[i].value, unicode) - self.assertEqual(dn1[0], self.rdn1) - self.assertEqual(dn1[1], self.rdn2) + assert isinstance(dn1[i].attr, unicode) + assert isinstance(dn1[i].value, unicode) + assert dn1[0] == self.rdn1 + assert dn1[1] == self.rdn2 # Create with multiple attr,value pairs passed as tuple and RDN dn1 = DN((self.attr1, self.value1), RDN((self.attr2, self.value2))) - self.assertEqual(len(dn1), 2) + assert len(dn1) == 2 self.assertExpectedClass(DN, dn1, 'self') for i in range(0, len(dn1)): self.assertExpectedClass(DN, dn1[i], 'RDN') for j in range(0, len(dn1[i])): self.assertExpectedClass(DN, dn1[i][j], 'AVA') - self.assertIsInstance(dn1[i].attr, unicode) - self.assertIsInstance(dn1[i].value, unicode) - self.assertEqual(dn1[0], self.rdn1) - self.assertEqual(dn1[1], self.rdn2) + assert isinstance(dn1[i].attr, unicode) + assert isinstance(dn1[i].value, unicode) + assert dn1[0] == self.rdn1 + assert dn1[1] == self.rdn2 # Create with multiple attr,value pairs but reverse # constructor parameter ordering. RDN ordering should also be # reversed because DN's are a ordered sequence of RDN's dn1 = DN((self.attr2, self.value2), (self.attr1, self.value1)) - self.assertEqual(len(dn1), 2) + assert len(dn1) == 2 self.assertExpectedClass(DN, dn1, 'self') for i in range(0, len(dn1)): self.assertExpectedClass(DN, dn1[i], 'RDN') for j in range(0, len(dn1[i])): self.assertExpectedClass(DN, dn1[i][j], 'AVA') - self.assertIsInstance(dn1[i].attr, unicode) - self.assertIsInstance(dn1[i].value, unicode) - self.assertEqual(dn1[0], self.rdn2) - self.assertEqual(dn1[1], self.rdn1) + assert isinstance(dn1[i].attr, unicode) + assert isinstance(dn1[i].value, unicode) + assert dn1[0] == self.rdn2 + assert dn1[1] == self.rdn1 # Create with single RDN object dn1 = DN(self.rdn1) - self.assertEqual(len(dn1), 1) + assert len(dn1) == 1 self.assertExpectedClass(DN, dn1, 'self') for i in range(0, len(dn1)): self.assertExpectedClass(DN, dn1[i], 'RDN') for j in range(0, len(dn1[i])): self.assertExpectedClass(DN, dn1[i][j], 'AVA') - self.assertIsInstance(dn1[i].attr, unicode) - self.assertIsInstance(dn1[i].value, unicode) - self.assertEqual(dn1[0], self.rdn1) + assert isinstance(dn1[i].attr, unicode) + assert isinstance(dn1[i].value, unicode) + assert dn1[0] == self.rdn1 # Create with multiple RDN objects, assure ordering is preserved. dn1 = DN(self.rdn1, self.rdn2) - self.assertEqual(len(dn1), 2) + assert len(dn1) == 2 self.assertExpectedClass(DN, dn1, 'self') for i in range(0, len(dn1)): self.assertExpectedClass(DN, dn1[i], 'RDN') for j in range(0, len(dn1[i])): self.assertExpectedClass(DN, dn1[i][j], 'AVA') - self.assertIsInstance(dn1[i].attr, unicode) - self.assertIsInstance(dn1[i].value, unicode) - self.assertEqual(dn1[0], self.rdn1) - self.assertEqual(dn1[1], self.rdn2) + assert isinstance(dn1[i].attr, unicode) + assert isinstance(dn1[i].value, unicode) + assert dn1[0] == self.rdn1 + assert dn1[1] == self.rdn2 # Create with multiple RDN objects in different order, assure # ordering is preserved. dn1 = DN(self.rdn2, self.rdn1) - self.assertEqual(len(dn1), 2) + assert len(dn1) == 2 self.assertExpectedClass(DN, dn1, 'self') for i in range(0, len(dn1)): self.assertExpectedClass(DN, dn1[i], 'RDN') for j in range(0, len(dn1[i])): self.assertExpectedClass(DN, dn1[i][j], 'AVA') - self.assertIsInstance(dn1[i].attr, unicode) - self.assertIsInstance(dn1[i].value, unicode) - self.assertEqual(dn1[0], self.rdn2) - self.assertEqual(dn1[1], self.rdn1) + assert isinstance(dn1[i].attr, unicode) + assert isinstance(dn1[i].value, unicode) + assert dn1[0] == self.rdn2 + assert dn1[1] == self.rdn1 # Create with single string with 1 RDN dn1 = DN(self.str_rdn1) - self.assertEqual(len(dn1), 1) + assert len(dn1) == 1 self.assertExpectedClass(DN, dn1, 'self') for i in range(0, len(dn1)): self.assertExpectedClass(DN, dn1[i], 'RDN') for j in range(0, len(dn1[i])): self.assertExpectedClass(DN, dn1[i][j], 'AVA') - self.assertIsInstance(dn1[i].attr, unicode) - self.assertIsInstance(dn1[i].value, unicode) - self.assertEqual(dn1[0], self.rdn1) + assert isinstance(dn1[i].attr, unicode) + assert isinstance(dn1[i].value, unicode) + assert dn1[0] == self.rdn1 # Create with single string with 2 RDN's dn1 = DN(self.str_dn3) - self.assertEqual(len(dn1), 2) + assert len(dn1) == 2 self.assertExpectedClass(DN, dn1, 'self') for i in range(0, len(dn1)): self.assertExpectedClass(DN, dn1[i], 'RDN') for j in range(0, len(dn1[i])): self.assertExpectedClass(DN, dn1[i][j], 'AVA') - self.assertIsInstance(dn1[i].attr, unicode) - self.assertIsInstance(dn1[i].value, unicode) - self.assertEqual(dn1[0], self.rdn1) - self.assertEqual(dn1[1], self.rdn2) + assert isinstance(dn1[i].attr, unicode) + assert isinstance(dn1[i].value, unicode) + assert dn1[0] == self.rdn1 + assert dn1[1] == self.rdn2 # Create with a python-cryptography 'Name' dn1 = DN(self.x500name) - self.assertEqual(len(dn1), 2) + assert len(dn1) == 2 self.assertExpectedClass(DN, dn1, 'self') for i in range(0, len(dn1)): self.assertExpectedClass(DN, dn1[i], 'RDN') for j in range(0, len(dn1[i])): self.assertExpectedClass(DN, dn1[i][j], 'AVA') - self.assertIsInstance(dn1[i].attr, unicode) - self.assertIsInstance(dn1[i].value, unicode) - self.assertEqual(dn1[0], self.rdn1) - self.assertEqual(dn1[1], self.rdn2) + assert isinstance(dn1[i].attr, unicode) + assert isinstance(dn1[i].value, unicode) + assert dn1[0] == self.rdn1 + assert dn1[1] == self.rdn2 # Create from 'Name' with multi-valued RDN dn1 = DN(self.x500nameMultiRDN) - self.assertEqual(len(dn1), 2) - self.assertEqual(len(dn1[1]), 2) - self.assertIn(AVA('c', 'au'), dn1[1]) - self.assertIn(AVA('st', 'queensland'), dn1[1]) - self.assertEqual(len(dn1[0]), 1) - self.assertIn(self.ava1, dn1[0]) + assert len(dn1) == 2 + assert len(dn1[1]) == 2 + assert AVA('c', 'au') in dn1[1] + assert AVA('st', 'queensland') in dn1[1] + assert len(dn1[0]) == 1 + assert self.ava1 in dn1[0] # Create with RDN, and 2 DN's (e.g. attr + container + base) dn1 = DN((self.attr1, self.value1), self.container_dn, self.base_dn) - self.assertEqual(len(dn1), 5) + assert len(dn1) == 5 dn_str = ','.join([str(self.rdn1), str(self.container_rdn1), str(self.container_rdn2), str(self.base_rdn1), str(self.base_rdn2)]) - self.assertEqual(str(dn1), dn_str) + assert str(dn1) == dn_str def test_str(self): dn1 = DN(self.dn1) dn2 = DN(self.dn2) dn3 = DN(self.dn3) - self.assertEqual(str(dn1), self.str_dn1) - self.assertIsInstance(str(dn1), str) + assert str(dn1) == self.str_dn1 + assert isinstance(str(dn1), str) - self.assertEqual(str(dn2), self.str_dn2) - self.assertIsInstance(str(dn2), str) + assert str(dn2) == self.str_dn2 + assert isinstance(str(dn2), str) - self.assertEqual(str(dn3), self.str_dn3) - self.assertIsInstance(str(dn3), str) + assert str(dn3) == self.str_dn3 + assert isinstance(str(dn3), str) def test_cmp(self): # Equality dn1 = DN((self.attr1, self.value1)) - self.assertTrue(dn1 == self.dn1) - self.assertFalse(dn1 != self.dn1) + assert dn1 == self.dn1 + assert dn1 == self.dn1 - self.assertTrue(dn1 == self.str_dn1) - self.assertFalse(dn1 != self.str_dn1) + assert dn1 == self.str_dn1 + assert dn1 == self.str_dn1 result = cmp(dn1, self.dn1) - self.assertEqual(result, 0) + assert result == 0 # Make dn1's attr greater - with self.assertRaises(AttributeError): + with pytest.raises(AttributeError): dn1[0].attr = self.attr1 + "1" dn1 = DN((self.attr1 + "1", self.value1)) - self.assertFalse(dn1 == self.dn1) - self.assertTrue(dn1 != self.dn1) + assert dn1 != self.dn1 + assert dn1 != self.dn1 result = cmp(dn1, self.dn1) - self.assertEqual(result, 1) + assert result == 1 result = cmp(self.dn1, dn1) - self.assertEqual(result, -1) + assert result == -1 # Reset dn1's attr, should be equal again - with self.assertRaises(AttributeError): + with pytest.raises(AttributeError): dn1[0].attr = self.attr1 dn1 = DN((self.attr1, self.value1)) result = cmp(dn1, self.dn1) - self.assertEqual(result, 0) + assert result == 0 # Make dn1's value greater # attr will be equal, this tests secondary comparision component - with self.assertRaises(AttributeError): + with pytest.raises(AttributeError): dn1[0].value = self.value1 + "1" dn1 = DN((self.attr1, self.value1 + "1")) result = cmp(dn1, self.dn1) - self.assertEqual(result, 1) + assert result == 1 result = cmp(self.dn1, dn1) - self.assertEqual(result, -1) + assert result == -1 # Make sure dn's with more rdn's are greater result = cmp(self.dn1, self.dn3) - self.assertEqual(result, -1) + assert result == -1 result = cmp(self.dn3, self.dn1) - self.assertEqual(result, 1) + assert result == 1 # Test startswith, endswith container_dn = DN(self.container_dn) base_container_dn = DN(self.base_container_dn) - self.assertTrue(base_container_dn.startswith(self.rdn1)) - self.assertTrue(base_container_dn.startswith(self.dn1)) - self.assertTrue(base_container_dn.startswith(self.dn1 + container_dn)) - self.assertFalse(base_container_dn.startswith(self.dn2)) - self.assertFalse(base_container_dn.startswith(self.rdn2)) - self.assertTrue(base_container_dn.startswith((self.dn1))) - self.assertTrue(base_container_dn.startswith((self.rdn1))) - self.assertFalse(base_container_dn.startswith((self.rdn2))) - self.assertTrue(base_container_dn.startswith((self.rdn2, self.rdn1))) - self.assertTrue(base_container_dn.startswith((self.dn1, self.dn2))) + assert base_container_dn.startswith(self.rdn1) + assert base_container_dn.startswith(self.dn1) + assert base_container_dn.startswith(self.dn1 + container_dn) + assert not base_container_dn.startswith(self.dn2) + assert not base_container_dn.startswith(self.rdn2) + assert base_container_dn.startswith((self.dn1)) + assert base_container_dn.startswith((self.rdn1)) + assert not base_container_dn.startswith((self.rdn2)) + assert base_container_dn.startswith((self.rdn2, self.rdn1)) + assert base_container_dn.startswith((self.dn1, self.dn2)) - self.assertTrue(base_container_dn.endswith(self.base_dn)) - self.assertTrue(base_container_dn.endswith(container_dn + self.base_dn)) - self.assertFalse(base_container_dn.endswith(DN(self.base_rdn1))) - self.assertTrue(base_container_dn.endswith(DN(self.base_rdn2))) - self.assertTrue(base_container_dn.endswith((DN(self.base_rdn1), DN(self.base_rdn2)))) + assert base_container_dn.endswith(self.base_dn) + assert base_container_dn.endswith(container_dn + self.base_dn) + assert not base_container_dn.endswith(DN(self.base_rdn1)) + assert base_container_dn.endswith(DN(self.base_rdn2)) + assert base_container_dn.endswith( + (DN(self.base_rdn1), DN(self.base_rdn2))) # Test "in" membership - self.assertTrue(self.container_rdn1 in container_dn) + assert self.container_rdn1 in container_dn # pylint: disable=comparison-with-itself - self.assertTrue(container_dn in container_dn) - self.assertFalse(self.base_rdn1 in container_dn) + assert container_dn in container_dn + assert self.base_rdn1 not in container_dn - self.assertTrue(self.container_rdn1 in base_container_dn) - self.assertTrue(container_dn in base_container_dn) - self.assertTrue(container_dn + self.base_dn in - base_container_dn) - self.assertTrue(self.dn1 + container_dn + self.base_dn in - base_container_dn) - self.assertTrue(self.dn1 + container_dn + self.base_dn == - base_container_dn) + assert self.container_rdn1 in base_container_dn + assert container_dn in base_container_dn + assert container_dn + self.base_dn in base_container_dn + assert self.dn1 + container_dn + self.base_dn in base_container_dn + assert self.dn1 + container_dn + self.base_dn == base_container_dn - self.assertFalse(self.container_rdn1 in self.base_dn) + assert self.container_rdn1 not in self.base_dn def test_eq_multi_rdn(self): dn1 = DN(self.ava1, 'ST=Queensland+C=AU') dn2 = DN(self.ava1, 'C=AU+ST=Queensland') - self.assertEqual(dn1, dn2) + assert dn1 == dn2 # ensure AVAs get sorted when constructing from x509.Name dn3 = DN(self.x500nameMultiRDN) dn4 = DN(self.x500nameMultiRDN2) - self.assertEqual(dn3, dn4) + assert dn3 == dn4 # ensure AVAs get sorted in the same way regardless of what # the DN was constructed from - self.assertEqual(dn1, dn3) - self.assertEqual(dn1, dn4) - self.assertEqual(dn2, dn3) - self.assertEqual(dn2, dn4) + assert dn1 == dn3 + assert dn1 == dn4 + assert dn2 == dn3 + assert dn2 == dn4 def test_indexing(self): dn1 = DN(self.dn1) dn2 = DN(self.dn2) dn3 = DN(self.dn3) - self.assertEqual(dn1[0], self.rdn1) - self.assertEqual(dn1[self.rdn1.attr], self.rdn1.value) - with self.assertRaises(KeyError): + assert dn1[0] == self.rdn1 + assert dn1[self.rdn1.attr] == self.rdn1.value + with pytest.raises(KeyError): dn1['foo'] # pylint: disable=pointless-statement - self.assertEqual(dn2[0], self.rdn2) - self.assertEqual(dn2[self.rdn2.attr], self.rdn2.value) - with self.assertRaises(KeyError): + assert dn2[0] == self.rdn2 + assert dn2[self.rdn2.attr] == self.rdn2.value + with pytest.raises(KeyError): dn2['foo'] # pylint: disable=pointless-statement - self.assertEqual(dn3[0], self.rdn1) - self.assertEqual(dn3[self.rdn1.attr], self.rdn1.value) - self.assertEqual(dn3[1], self.rdn2) - self.assertEqual(dn3[self.rdn2.attr], self.rdn2.value) - with self.assertRaises(KeyError): + assert dn3[0] == self.rdn1 + assert dn3[self.rdn1.attr] == self.rdn1.value + assert dn3[1] == self.rdn2 + assert dn3[self.rdn2.attr] == self.rdn2.value + with pytest.raises(KeyError): dn3['foo'] # pylint: disable=pointless-statement - with self.assertRaises(TypeError): + with pytest.raises(TypeError): dn3[1.0] # pylint: disable=pointless-statement def test_assignments(self): dn = DN('t=0,t=1,t=2,t=3,t=4,t=5,t=6,t=7,t=8,t=9') - with self.assertRaises(TypeError): + with pytest.raises(TypeError): # pylint: disable=unsupported-assignment-operation dn[0] = RDN('t=a') - with self.assertRaises(TypeError): + with pytest.raises(TypeError): # pylint: disable=unsupported-assignment-operation dn[0:1] = [RDN('t=a'), RDN('t=b')] @@ -1006,31 +1008,34 @@ class TestDN(unittest.TestCase): dn2 = DN(self.dn2) dn3 = DN(self.dn3) - self.assertEqual(len(dn1), 1) - self.assertEqual(dn1[:], self.rdn1) + assert len(dn1) == 1 + assert dn1[:] == self.rdn1 for i, ava in enumerate(dn1): if i == 0: - self.assertEqual(ava, self.rdn1) + assert ava == self.rdn1 else: - self.fail("got iteration index %d, but len=%d" % (i, len(self.rdn1))) + pytest.fail( + "got iteration index %d, but len=%d" % (i, len(self.rdn1))) - self.assertEqual(len(dn2), 1) - self.assertEqual(dn2[:], self.rdn2) + assert len(dn2) == 1 + assert dn2[:] == self.rdn2 for i, ava in enumerate(dn2): if i == 0: - self.assertEqual(ava, self.rdn2) + assert ava == self.rdn2 else: - self.fail("got iteration index %d, but len=%d" % (i, len(self.rdn2))) + pytest.fail( + "got iteration index %d, but len=%d" % (i, len(self.rdn2))) - self.assertEqual(len(dn3), 2) - self.assertEqual(dn3[:], DN(self.rdn1, self.rdn2)) + assert len(dn3) == 2 + assert dn3[:] == DN(self.rdn1, self.rdn2) for i, ava in enumerate(dn3): if i == 0: - self.assertEqual(ava, self.rdn1) + assert ava == self.rdn1 elif i == 1: - self.assertEqual(ava, self.rdn2) + assert ava == self.rdn2 else: - self.fail("got iteration index %d, but len=%d" % (i, len(dn3))) + pytest.fail( + "got iteration index %d, but len=%d" % (i, len(dn3))) def test_concat(self): dn1 = DN((self.attr1, self.value1)) @@ -1039,7 +1044,7 @@ class TestDN(unittest.TestCase): # in-place addtion dn1 += dn2 - self.assertEqual(dn1, self.dn3) + assert dn1 == self.dn3 self.assertExpectedClass(DN, dn1, 'self') for i in range(0, len(dn1)): self.assertExpectedClass(DN, dn1[i], 'RDN') @@ -1049,7 +1054,7 @@ class TestDN(unittest.TestCase): dn1 = DN((self.attr1, self.value1)) dn1 += self.rdn2 - self.assertEqual(dn1, self.dn3) + assert dn1 == self.dn3 self.assertExpectedClass(DN, dn1, 'self') for i in range(0, len(dn1)): self.assertExpectedClass(DN, dn1[i], 'RDN') @@ -1059,7 +1064,7 @@ class TestDN(unittest.TestCase): dn1 = DN((self.attr1, self.value1)) dn1 += self.dn2 - self.assertEqual(dn1, self.dn3) + assert dn1 == self.dn3 self.assertExpectedClass(DN, dn1, 'self') for i in range(0, len(dn1)): self.assertExpectedClass(DN, dn1[i], 'RDN') @@ -1069,7 +1074,7 @@ class TestDN(unittest.TestCase): dn1 = DN((self.attr1, self.value1)) dn1 += self.str_dn2 - self.assertEqual(dn1, self.dn3) + assert dn1 == self.dn3 self.assertExpectedClass(DN, dn1, 'self') for i in range(0, len(dn1)): self.assertExpectedClass(DN, dn1[i], 'RDN') @@ -1080,7 +1085,7 @@ class TestDN(unittest.TestCase): # concatenation dn1 = DN((self.attr1, self.value1)) dn3 = dn1 + dn2 - self.assertEqual(dn3, self.dn3) + assert dn3 == self.dn3 self.assertExpectedClass(DN, dn3, 'self') for i in range(0, len(dn3)): self.assertExpectedClass(DN, dn3[i], 'RDN') @@ -1090,7 +1095,7 @@ class TestDN(unittest.TestCase): dn1 = DN((self.attr1, self.value1)) dn3 = dn1 + self.rdn2 - self.assertEqual(dn3, self.dn3) + assert dn3 == self.dn3 self.assertExpectedClass(DN, dn3, 'self') for i in range(0, len(dn3)): self.assertExpectedClass(DN, dn3[i], 'RDN') @@ -1098,14 +1103,14 @@ class TestDN(unittest.TestCase): self.assertExpectedClass(DN, dn3[i][j], 'AVA') dn3 = dn1 + self.str_rdn2 - self.assertEqual(dn3, self.dn3) + assert dn3 == self.dn3 self.assertExpectedClass(DN, dn3, 'self') for i in range(0, len(dn3)): self.assertExpectedClass(DN, dn3[i], 'RDN') self.assertExpectedClass(DN, dn3[i][0], 'AVA') dn3 = dn1 + self.str_dn2 - self.assertEqual(dn3, self.dn3) + assert dn3 == self.dn3 self.assertExpectedClass(DN, dn3, 'self') self.assertExpectedClass(DN, dn3, 'self') for i in range(0, len(dn3)): @@ -1114,7 +1119,7 @@ class TestDN(unittest.TestCase): self.assertExpectedClass(DN, dn3[i][j], 'AVA') dn3 = dn1 + self.dn2 - self.assertEqual(dn3, self.dn3) + assert dn3 == self.dn3 self.assertExpectedClass(DN, dn3, 'self') self.assertExpectedClass(DN, dn3, 'self') for i in range(0, len(dn3)): @@ -1128,42 +1133,42 @@ class TestDN(unittest.TestCase): pat = DN('cn=bob') # forward - self.assertEqual(dn.find(pat), 2) - self.assertEqual(dn.find(pat, 1), 2) - self.assertEqual(dn.find(pat, 1, 3), 2) - self.assertEqual(dn.find(pat, 2, 3), 2) - self.assertEqual(dn.find(pat, 6), 6) + assert dn.find(pat) == 2 + assert dn.find(pat, 1) == 2 + assert dn.find(pat, 1, 3) == 2 + assert dn.find(pat, 2, 3) == 2 + assert dn.find(pat, 6) == 6 - self.assertEqual(dn.find(pat, 7), -1) - self.assertEqual(dn.find(pat, 1, 2), -1) + assert dn.find(pat, 7) == -1 + assert dn.find(pat, 1, 2) == -1 - with self.assertRaises(ValueError): - self.assertEqual(dn.index(pat, 7), -1) - with self.assertRaises(ValueError): - self.assertEqual(dn.index(pat, 1, 2), -1) + with pytest.raises(ValueError): + assert dn.index(pat, 7) == -1 + with pytest.raises(ValueError): + assert dn.index(pat, 1, 2) == -1 # reverse - self.assertEqual(dn.rfind(pat), 6) - self.assertEqual(dn.rfind(pat, -4), 6) - self.assertEqual(dn.rfind(pat, 6), 6) - self.assertEqual(dn.rfind(pat, 6, 8), 6) - self.assertEqual(dn.rfind(pat, 6, 8), 6) - self.assertEqual(dn.rfind(pat, -8), 6) - self.assertEqual(dn.rfind(pat, -8, -4), 6) - self.assertEqual(dn.rfind(pat, -8, -5), 2) + assert dn.rfind(pat) == 6 + assert dn.rfind(pat, -4) == 6 + assert dn.rfind(pat, 6) == 6 + assert dn.rfind(pat, 6, 8) == 6 + assert dn.rfind(pat, 6, 8) == 6 + assert dn.rfind(pat, -8) == 6 + assert dn.rfind(pat, -8, -4) == 6 + assert dn.rfind(pat, -8, -5) == 2 - self.assertEqual(dn.rfind(pat, 7), -1) - self.assertEqual(dn.rfind(pat, -3), -1) + assert dn.rfind(pat, 7) == -1 + assert dn.rfind(pat, -3) == -1 - with self.assertRaises(ValueError): - self.assertEqual(dn.rindex(pat, 7), -1) - with self.assertRaises(ValueError): - self.assertEqual(dn.rindex(pat, -3), -1) + with pytest.raises(ValueError): + assert dn.rindex(pat, 7) == -1 + with pytest.raises(ValueError): + assert dn.rindex(pat, -3) == -1 def test_replace(self): # pylint: disable=no-member dn = DN('t=0,t=1,t=2,t=3,t=4,t=5,t=6,t=7,t=8,t=9') - with self.assertRaises(AttributeError): + with pytest.raises(AttributeError): dn.replace # pylint: disable=pointless-statement def test_hashing(self): @@ -1172,11 +1177,11 @@ class TestDN(unittest.TestCase): dn2 = DN((self.attr1.upper(), self.value1.lower())) # DNs that are equal should hash to the same value. - self.assertEqual(dn1, dn2) + assert dn1 == dn2 # Good, everyone's equal, now verify their hash values - self.assertEqual(hash(dn1), hash(dn2)) + assert hash(dn1) == hash(dn2) # Different DN objects with the same value should # map to 1 common key and 1 member in a set. The key and @@ -1191,9 +1196,9 @@ class TestDN(unittest.TestCase): dn3_a = DN(self.dn3) dn3_b = DN(self.dn3) - self.assertEqual(dn1_a, dn1_b) - self.assertEqual(dn2_a, dn2_b) - self.assertEqual(dn3_a, dn3_b) + assert dn1_a == dn1_b + assert dn2_a == dn2_b + assert dn3_a == dn3_b d = dict() s = set() @@ -1208,63 +1213,66 @@ class TestDN(unittest.TestCase): s.add(dn2_a) s.add(dn2_b) - self.assertEqual(len(d), 2) - self.assertEqual(len(s), 2) - self.assertEqual(sorted(d), sorted([dn1_a, dn2_a])) - self.assertEqual(sorted(s), sorted([dn1_a, dn2_a])) + assert len(d) == 2 + assert len(s) == 2 + assert sorted(d) == sorted([dn1_a, dn2_a]) + assert sorted(s) == sorted([dn1_a, dn2_a]) - self.assertTrue(dn1_a in d) - self.assertTrue(dn1_b in d) - self.assertTrue(dn2_a in d) - self.assertTrue(dn2_b in d) - self.assertFalse(dn3_a in d) - self.assertFalse(dn3_b in d) + assert dn1_a in d + assert dn1_b in d + assert dn2_a in d + assert dn2_b in d + assert dn3_a not in d + assert dn3_b not in d - self.assertTrue(dn1_a in s) - self.assertTrue(dn1_b in s) - self.assertTrue(dn2_a in s) - self.assertTrue(dn2_b in s) - self.assertFalse(dn3_a in s) - self.assertFalse(dn3_b in s) + assert dn1_a in s + assert dn1_b in s + assert dn2_a in s + assert dn2_b in s + assert dn3_a not in s + assert dn3_b not in s def test_x500_text(self): # null DN x500 ordering and LDAP ordering are the same nulldn = DN() - self.assertEqual(nulldn.ldap_text(), nulldn.x500_text()) + assert nulldn.ldap_text() == nulldn.x500_text() # reverse a DN with a single RDN - self.assertEqual(self.dn1.ldap_text(), self.dn1.x500_text()) + assert self.dn1.ldap_text() == self.dn1.x500_text() # reverse a DN with 2 RDNs dn3_x500 = self.dn3.x500_text() dn3_rev = DN(self.rdn2, self.rdn1) - self.assertEqual(dn3_rev.ldap_text(), dn3_x500) + assert dn3_rev.ldap_text() == dn3_x500 # reverse a longer DN longdn_x500 = self.base_container_dn.x500_text() longdn_rev = DN(longdn_x500) l = len(self.base_container_dn) for i in range(l): - self.assertEqual(longdn_rev[i], self.base_container_dn[l-1-i]) + assert longdn_rev[i] == self.base_container_dn[l - 1 - i] -class TestEscapes(unittest.TestCase): - def setUp(self): +class TestEscapes: + @pytest.fixture(autouse=True) + def escapes_setup(self): self.privilege = 'R,W privilege' self.dn_str_hex_escape = 'cn=R\\2cW privilege,cn=privileges,cn=pbac,dc=idm,dc=lab,dc=bos,dc=redhat,dc=com' self.dn_str_backslash_escape = 'cn=R\\,W privilege,cn=privileges,cn=pbac,dc=idm,dc=lab,dc=bos,dc=redhat,dc=com' def test_escape(self): dn = DN(self.dn_str_hex_escape) - self.assertEqual(dn['cn'], self.privilege) - self.assertEqual(dn[0].value, self.privilege) + assert dn['cn'] == self.privilege + assert dn[0].value == self.privilege dn = DN(self.dn_str_backslash_escape) - self.assertEqual(dn['cn'], self.privilege) - self.assertEqual(dn[0].value, self.privilege) + assert dn['cn'] == self.privilege + assert dn[0].value == self.privilege -class TestInternationalization(unittest.TestCase): - def setUp(self): + +class TestInternationalization: + @pytest.fixture(autouse=True) + def i18n_setup(self): # Hello in Arabic self.arabic_hello_utf8 = (b'\xd9\x85\xd9\x83\xd9\x8a\xd9\x84' + b'\xd8\xb9\x20\xd9\x85\xd8\xa7\xd9' + @@ -1274,9 +1282,9 @@ class TestInternationalization(unittest.TestCase): def assert_equal_utf8(self, obj, b): if six.PY2: - self.assertEqual(str(obj), b) + assert str(obj) == b else: - self.assertEqual(str(obj), b.decode('utf-8')) + assert str(obj) == b.decode('utf-8') @contextlib.contextmanager def fail_py3(self, exception_type): @@ -1287,101 +1295,102 @@ class TestInternationalization(unittest.TestCase): raise def test_i18n(self): - self.assertEqual(self.arabic_hello_utf8, - self.arabic_hello_unicode.encode('utf-8')) + actual = self.arabic_hello_unicode.encode('utf-8') + expected = self.arabic_hello_utf8 + assert actual == expected # AVA's # test attr i18n ava1 = AVA(self.arabic_hello_unicode, 'foo') - self.assertIsInstance(ava1.attr, unicode) - self.assertIsInstance(ava1.value, unicode) - self.assertEqual(ava1.attr, self.arabic_hello_unicode) + assert isinstance(ava1.attr, unicode) + assert isinstance(ava1.value, unicode) + assert ava1.attr == self.arabic_hello_unicode self.assert_equal_utf8(ava1, self.arabic_hello_utf8 + b'=foo') with self.fail_py3(TypeError): ava1 = AVA(self.arabic_hello_utf8, 'foo') if six.PY2: - self.assertIsInstance(ava1.attr, unicode) - self.assertIsInstance(ava1.value, unicode) - self.assertEqual(ava1.attr, self.arabic_hello_unicode) + assert isinstance(ava1.attr, unicode) + assert isinstance(ava1.value, unicode) + assert ava1.attr == self.arabic_hello_unicode self.assert_equal_utf8(ava1, self.arabic_hello_utf8 + b'=foo') # test value i18n ava1 = AVA('cn', self.arabic_hello_unicode) - self.assertIsInstance(ava1.attr, unicode) - self.assertIsInstance(ava1.value, unicode) - self.assertEqual(ava1.value, self.arabic_hello_unicode) + assert isinstance(ava1.attr, unicode) + assert isinstance(ava1.value, unicode) + assert ava1.value == self.arabic_hello_unicode self.assert_equal_utf8(ava1, b'cn=' + self.arabic_hello_utf8) with self.fail_py3(TypeError): ava1 = AVA('cn', self.arabic_hello_utf8) if six.PY2: - self.assertIsInstance(ava1.attr, unicode) - self.assertIsInstance(ava1.value, unicode) - self.assertEqual(ava1.value, self.arabic_hello_unicode) + assert isinstance(ava1.attr, unicode) + assert isinstance(ava1.value, unicode) + assert ava1.value == self.arabic_hello_unicode self.assert_equal_utf8(ava1, b'cn=' + self.arabic_hello_utf8) # RDN's # test attr i18n rdn1 = RDN((self.arabic_hello_unicode, 'foo')) - self.assertIsInstance(rdn1.attr, unicode) - self.assertIsInstance(rdn1.value, unicode) - self.assertEqual(rdn1.attr, self.arabic_hello_unicode) + assert isinstance(rdn1.attr, unicode) + assert isinstance(rdn1.value, unicode) + assert rdn1.attr == self.arabic_hello_unicode self.assert_equal_utf8(rdn1, self.arabic_hello_utf8 + b'=foo') with self.fail_py3(TypeError): rdn1 = RDN((self.arabic_hello_utf8, 'foo')) if six.PY2: - self.assertIsInstance(rdn1.attr, unicode) - self.assertIsInstance(rdn1.value, unicode) - self.assertEqual(rdn1.attr, self.arabic_hello_unicode) - self.assertEqual(str(rdn1), self.arabic_hello_utf8 + b'=foo') + assert isinstance(rdn1.attr, unicode) + assert isinstance(rdn1.value, unicode) + assert rdn1.attr == self.arabic_hello_unicode + assert str(rdn1) == self.arabic_hello_utf8 + b'=foo' # test value i18n rdn1 = RDN(('cn', self.arabic_hello_unicode)) - self.assertIsInstance(rdn1.attr, unicode) - self.assertIsInstance(rdn1.value, unicode) - self.assertEqual(rdn1.value, self.arabic_hello_unicode) + assert isinstance(rdn1.attr, unicode) + assert isinstance(rdn1.value, unicode) + assert rdn1.value == self.arabic_hello_unicode self.assert_equal_utf8(rdn1, b'cn=' + self.arabic_hello_utf8) with self.fail_py3(TypeError): rdn1 = RDN(('cn', self.arabic_hello_utf8)) if six.PY2: - self.assertIsInstance(rdn1.attr, unicode) - self.assertIsInstance(rdn1.value, unicode) - self.assertEqual(rdn1.value, self.arabic_hello_unicode) - self.assertEqual(str(rdn1), b'cn=' + self.arabic_hello_utf8) + assert isinstance(rdn1.attr, unicode) + assert isinstance(rdn1.value, unicode) + assert rdn1.value == self.arabic_hello_unicode + assert str(rdn1) == b'cn=' + self.arabic_hello_utf8 # DN's # test attr i18n dn1 = DN((self.arabic_hello_unicode, 'foo')) - self.assertIsInstance(dn1[0].attr, unicode) - self.assertIsInstance(dn1[0].value, unicode) - self.assertEqual(dn1[0].attr, self.arabic_hello_unicode) + assert isinstance(dn1[0].attr, unicode) + assert isinstance(dn1[0].value, unicode) + assert dn1[0].attr == self.arabic_hello_unicode self.assert_equal_utf8(dn1, self.arabic_hello_utf8 + b'=foo') with self.fail_py3(TypeError): dn1 = DN((self.arabic_hello_utf8, 'foo')) if six.PY2: - self.assertIsInstance(dn1[0].attr, unicode) - self.assertIsInstance(dn1[0].value, unicode) - self.assertEqual(dn1[0].attr, self.arabic_hello_unicode) - self.assertEqual(str(dn1), self.arabic_hello_utf8 + b'=foo') + assert isinstance(dn1[0].attr, unicode) + assert isinstance(dn1[0].value, unicode) + assert dn1[0].attr == self.arabic_hello_unicode + assert str(dn1) == self.arabic_hello_utf8 + b'=foo' # test value i18n dn1 = DN(('cn', self.arabic_hello_unicode)) - self.assertIsInstance(dn1[0].attr, unicode) - self.assertIsInstance(dn1[0].value, unicode) - self.assertEqual(dn1[0].value, self.arabic_hello_unicode) + assert isinstance(dn1[0].attr, unicode) + assert isinstance(dn1[0].value, unicode) + assert dn1[0].value == self.arabic_hello_unicode self.assert_equal_utf8(dn1, b'cn=' + self.arabic_hello_utf8) with self.fail_py3(TypeError): dn1 = DN(('cn', self.arabic_hello_utf8)) if six.PY2: - self.assertIsInstance(dn1[0].attr, unicode) - self.assertIsInstance(dn1[0].value, unicode) - self.assertEqual(dn1[0].value, self.arabic_hello_unicode) - self.assertEqual(str(dn1), b'cn=' + self.arabic_hello_utf8) + assert isinstance(dn1[0].attr, unicode) + assert isinstance(dn1[0].value, unicode) + assert dn1[0].value == self.arabic_hello_unicode + assert str(dn1) == b'cn=' + self.arabic_hello_utf8 # 1: LDAP_AVA_STRING @@ -1435,7 +1444,3 @@ def test_dn2str_special(): assert dn2str(dn) == dnstring2 assert dn_ctypes.str2dn(dnstring) == dn assert dn_ctypes.dn2str(dn) == dnstring2 - - -if __name__ == '__main__': - unittest.main() diff --git a/ipatests/test_ipapython/test_ipavalidate.py b/ipatests/test_ipapython/test_ipavalidate.py index fcf7c73f9..4b7c0b825 100644 --- a/ipatests/test_ipapython/test_ipavalidate.py +++ b/ipatests/test_ipapython/test_ipavalidate.py @@ -19,72 +19,72 @@ import sys sys.path.insert(0, ".") -import unittest import pytest from ipapython import ipavalidate pytestmark = pytest.mark.tier0 -class TestValidate(unittest.TestCase): + +class TestValidate: def test_validEmail(self): - self.assertEqual(True, ipavalidate.Email("test@freeipa.org")) - self.assertEqual(True, ipavalidate.Email("", notEmpty=False)) + assert ipavalidate.Email("test@freeipa.org") is True + assert ipavalidate.Email("", notEmpty=False) is True def test_invalidEmail(self): - self.assertEqual(False, ipavalidate.Email("test")) - self.assertEqual(False, ipavalidate.Email("test@freeipa")) - self.assertEqual(False, ipavalidate.Email("test@.com")) - self.assertEqual(False, ipavalidate.Email("")) - self.assertEqual(False, ipavalidate.Email(None)) + assert ipavalidate.Email("test") is False + assert ipavalidate.Email("test@freeipa") is False + assert ipavalidate.Email("test@.com") is False + assert ipavalidate.Email("") is False + assert ipavalidate.Email(None) is False def test_validPlain(self): - self.assertEqual(True, ipavalidate.Plain("Joe User")) - self.assertEqual(True, ipavalidate.Plain("Joe O'Malley")) - self.assertEqual(True, ipavalidate.Plain("", notEmpty=False)) - self.assertEqual(True, ipavalidate.Plain(None, notEmpty=False)) - self.assertEqual(True, ipavalidate.Plain("JoeUser", allowSpaces=False)) - self.assertEqual(True, ipavalidate.Plain("JoeUser", allowSpaces=True)) + assert ipavalidate.Plain("Joe User") is True + assert ipavalidate.Plain("Joe O'Malley") is True + assert ipavalidate.Plain("", notEmpty=False) is True + assert ipavalidate.Plain(None, notEmpty=False) is True + assert ipavalidate.Plain("JoeUser", allowSpaces=False) is True + assert ipavalidate.Plain("JoeUser", allowSpaces=True) is True def test_invalidPlain(self): - self.assertEqual(False, ipavalidate.Plain("Joe (User)")) - self.assertEqual(False, ipavalidate.Plain("Joe C. User")) - self.assertEqual(False, ipavalidate.Plain("", notEmpty=True)) - self.assertEqual(False, ipavalidate.Plain(None, notEmpty=True)) - self.assertEqual(False, ipavalidate.Plain("Joe User", allowSpaces=False)) - self.assertEqual(False, ipavalidate.Plain("Joe C. User")) + assert ipavalidate.Plain("Joe (User)") is False + assert ipavalidate.Plain("Joe C. User") is False + assert ipavalidate.Plain("", notEmpty=True) is False + assert ipavalidate.Plain(None, notEmpty=True) is False + assert ipavalidate.Plain("Joe User", allowSpaces=False) is False + assert ipavalidate.Plain("Joe C. User") is False def test_validString(self): - self.assertEqual(True, ipavalidate.String("Joe User")) - self.assertEqual(True, ipavalidate.String("Joe O'Malley")) - self.assertEqual(True, ipavalidate.String("", notEmpty=False)) - self.assertEqual(True, ipavalidate.String(None, notEmpty=False)) - self.assertEqual(True, ipavalidate.String("Joe C. User")) + assert ipavalidate.String("Joe User") is True + assert ipavalidate.String("Joe O'Malley") is True + assert ipavalidate.String("", notEmpty=False) is True + assert ipavalidate.String(None, notEmpty=False) is True + assert ipavalidate.String("Joe C. User") is True def test_invalidString(self): - self.assertEqual(False, ipavalidate.String("", notEmpty=True)) - self.assertEqual(False, ipavalidate.String(None, notEmpty=True)) + assert ipavalidate.String("", notEmpty=True) is False + assert ipavalidate.String(None, notEmpty=True) is False def test_validPath(self): - self.assertEqual(True, ipavalidate.Path("/")) - self.assertEqual(True, ipavalidate.Path("/home/user")) - self.assertEqual(True, ipavalidate.Path("../home/user")) - self.assertEqual(True, ipavalidate.Path("", notEmpty=False)) - self.assertEqual(True, ipavalidate.Path(None, notEmpty=False)) + assert ipavalidate.Path("/") is True + assert ipavalidate.Path("/home/user") is True + assert ipavalidate.Path("../home/user") is True + assert ipavalidate.Path("", notEmpty=False) is True + assert ipavalidate.Path(None, notEmpty=False) is True def test_invalidPath(self): - self.assertEqual(False, ipavalidate.Path("(foo)")) - self.assertEqual(False, ipavalidate.Path("", notEmpty=True)) - self.assertEqual(False, ipavalidate.Path(None, notEmpty=True)) + assert ipavalidate.Path("(foo)") is False + assert ipavalidate.Path("", notEmpty=True) is False + assert ipavalidate.Path(None, notEmpty=True) is False def test_validName(self): - self.assertEqual(True, ipavalidate.GoodName("foo")) - self.assertEqual(True, ipavalidate.GoodName("1foo")) - self.assertEqual(True, ipavalidate.GoodName("foo.bar")) - self.assertEqual(True, ipavalidate.GoodName("foo.bar$")) + assert ipavalidate.GoodName("foo") is True + assert ipavalidate.GoodName("1foo") is True + assert ipavalidate.GoodName("foo.bar") is True + assert ipavalidate.GoodName("foo.bar$") is True def test_invalidName(self): - self.assertEqual(False, ipavalidate.GoodName("foo bar")) - self.assertEqual(False, ipavalidate.GoodName("foo%bar")) - self.assertEqual(False, ipavalidate.GoodName("*foo")) - self.assertEqual(False, ipavalidate.GoodName("$foo.bar$")) + assert ipavalidate.GoodName("foo bar") is False + assert ipavalidate.GoodName("foo%bar") is False + assert ipavalidate.GoodName("*foo") is False + assert ipavalidate.GoodName("$foo.bar$") is False diff --git a/ipatests/test_ipaserver/test_adtrust_mockup.py b/ipatests/test_ipaserver/test_adtrust_mockup.py index a8248e0f8..b26c2c567 100644 --- a/ipatests/test_ipaserver/test_adtrust_mockup.py +++ b/ipatests/test_ipaserver/test_adtrust_mockup.py @@ -4,9 +4,11 @@ from __future__ import print_function import ipaserver.install.adtrust as adtr from ipaserver.install.adtrust import set_and_check_netbios_name from collections import namedtuple -from unittest import TestCase, mock +from unittest import mock from io import StringIO +import pytest + class ApiMockup: Backend = namedtuple('Backend', 'ldap2') @@ -14,9 +16,12 @@ class ApiMockup: env = namedtuple('Environment', 'domain') -class TestNetbiosName(TestCase): - @classmethod - def setUpClass(cls): +class TestNetbiosName: + api = None + + @pytest.fixture(autouse=True, scope="class") + def netbiosname_setup(self, request): + cls = request.cls api = ApiMockup() ldap2 = namedtuple('LDAP', 'isconnected') ldap2.isconnected = mock.MagicMock(return_value=True) @@ -25,9 +30,9 @@ class TestNetbiosName(TestCase): adtr.retrieve_netbios_name = mock.MagicMock(return_value=None) cls.api = api - @classmethod - def tearDownClass(cls): - adtr.retrieve_netbios_name = cls.api.Calls.retrieve_netbios_name + def fin(): + adtr.retrieve_netbios_name = cls.api.Calls.retrieve_netbios_name + request.addfinalizer(fin) def test_NetbiosName(self): """ diff --git a/ipatests/test_ipaserver/test_changepw.py b/ipatests/test_ipaserver/test_changepw.py index 1914af092..c3a47ab26 100644 --- a/ipatests/test_ipaserver/test_changepw.py +++ b/ipatests/test_ipaserver/test_changepw.py @@ -17,8 +17,6 @@ # You should have received a copy of the GNU General Public License # along with this program. If not, see . -import unittest - import pytest from ipatests.test_ipaserver.httptest import Unauthorized_HTTP_test @@ -43,7 +41,7 @@ class test_changepw(XMLRPC_test, Unauthorized_HTTP_test): api.Command['user_add'](uid=testuser, givenname=u'Test', sn=u'User') api.Command['passwd'](testuser, password=u'old_password') except errors.ExecutionError as e: - raise unittest.SkipTest( + pytest.skip( 'Cannot set up test user: %s' % e ) diff --git a/ipatests/test_ipaserver/test_ldap.py b/ipatests/test_ipaserver/test_ldap.py index 5ffb2d4f9..44f65fb0a 100644 --- a/ipatests/test_ipaserver/test_ldap.py +++ b/ipatests/test_ipaserver/test_ldap.py @@ -29,7 +29,6 @@ from __future__ import absolute_import import os import sys -import unittest import pytest import six @@ -92,7 +91,7 @@ class test_ldap: with open(pwfile, "r") as fp: dm_password = fp.read().rstrip() else: - raise unittest.SkipTest( + pytest.skip( "No directory manager password in %s" % pwfile ) self.conn = ldap2(api) @@ -118,7 +117,7 @@ class test_ldap: with open(pwfile, "r") as fp: dm_password = fp.read().rstrip() else: - raise unittest.SkipTest( + pytest.skip( "No directory manager password in %s" % pwfile ) myapi.Backend.ldap2.connect(bind_dn=DN(('cn', 'Directory Manager')), bind_pw=dm_password) @@ -136,7 +135,7 @@ class test_ldap: try: self.conn.connect(autobind=True) except errors.ACIError: - raise unittest.SkipTest("Only executed as root") + pytest.skip("Only executed as root") entry_attrs = self.conn.get_entry(self.dn, ['usercertificate']) cert = entry_attrs.get('usercertificate')[0] assert cert.serial_number is not None diff --git a/ipatests/test_ipaserver/test_secrets.py b/ipatests/test_ipaserver/test_secrets.py index a9b87e37b..3e2ea17d4 100644 --- a/ipatests/test_ipaserver/test_secrets.py +++ b/ipatests/test_ipaserver/test_secrets.py @@ -6,7 +6,8 @@ import os import shutil import subprocess import tempfile -import unittest + +import pytest def _test_password_callback(): @@ -15,9 +16,13 @@ def _test_password_callback(): return password -class TestiSecStore(unittest.TestCase): - @classmethod - def setUpClass(cls): +class TestiSecStore: + certdb = None + cert2db = None + + @pytest.fixture(autouse=True, scope="class") + def isec_store_setup(self, request): + cls = request.cls cls.testdir = tempfile.mkdtemp(suffix='ipa-sec-store') pwfile = os.path.join(cls.testdir, 'pwfile') with open(pwfile, 'w') as f: @@ -45,9 +50,9 @@ class TestiSecStore(unittest.TestCase): cwd=cls.testdir ) - @classmethod - def tearDownClass(cls): - shutil.rmtree(cls.testdir) + def fin(): + shutil.rmtree(cls.testdir) + request.addfinalizer(fin) def test_iSecStore(self): iss = iSecStore({}) diff --git a/ipatests/test_webui/ui_driver.py b/ipatests/test_webui/ui_driver.py index 218d3a451..4f98741f0 100644 --- a/ipatests/test_webui/ui_driver.py +++ b/ipatests/test_webui/ui_driver.py @@ -28,8 +28,8 @@ from datetime import datetime import time import re import os + from functools import wraps -import unittest from urllib.error import URLError import paramiko @@ -102,8 +102,6 @@ def screenshot(fn): def screenshot_wrapper(*args, **kwargs): try: return fn(*args, **kwargs) - except unittest.SkipTest: - raise except Exception: self = args[0] name = '%s_%s_%s' % ( @@ -166,7 +164,7 @@ class UI_driver: def ui_driver_setup(self, request): cls = request.cls if NO_SELENIUM: - raise unittest.SkipTest('Selenium not installed') + pytest.skip('Selenium not installed') cls.load_config() @pytest.fixture(autouse=True) @@ -195,9 +193,9 @@ class UI_driver: with open(path, 'r') as conf: cls.config = yaml.load(conf) except yaml.YAMLError as e: - raise unittest.SkipTest("Invalid Web UI config.\n%s" % e) + pytest.skip("Invalid Web UI config.\n%s" % e) except IOError as e: - raise unittest.SkipTest( + pytest.skip( "Can't load Web UI test config: %s" % e ) else: @@ -236,7 +234,7 @@ class UI_driver: if driver_type == 'remote': if 'host' not in cls.config: - raise unittest.SkipTest('Selenium server host not configured') + pytest.skip('Selenium server host not configured') host = cls.config["host"] if browser == 'chrome': @@ -252,11 +250,11 @@ class UI_driver: command_executor='http://%s:%d/wd/hub' % (host, port), desired_capabilities=capabilities) except URLError as e: - raise unittest.SkipTest( + pytest.skip( 'Error connecting to selenium server: %s' % e ) except RuntimeError as e: - raise unittest.SkipTest( + pytest.skip( 'Error while establishing webdriver: %s' % e ) else: @@ -272,11 +270,11 @@ class UI_driver: ff_log_path = cls.config.get("geckodriver_log_path") driver = webdriver.Firefox(fp, log_path=ff_log_path) except URLError as e: - raise unittest.SkipTest( + pytest.skip( 'Error connecting to selenium server: %s' % e ) except RuntimeError as e: - raise unittest.SkipTest( + pytest.skip( 'Error while establishing webdriver: %s' % e ) @@ -2019,7 +2017,7 @@ class UI_driver: """ Skip tests """ - raise unittest.SkipTest(reason) + pytest.skip(reason) def assert_text(self, selector, value, parent=None): """ diff --git a/ipatests/test_xmlrpc/test_automember_plugin.py b/ipatests/test_xmlrpc/test_automember_plugin.py index 3d975a3fc..3785c3f9d 100644 --- a/ipatests/test_xmlrpc/test_automember_plugin.py +++ b/ipatests/test_xmlrpc/test_automember_plugin.py @@ -36,7 +36,6 @@ from ipaserver.plugins.automember import REBUILD_TASK_CONTAINER import time import pytest import re -import unittest from pkg_resources import parse_version try: @@ -263,7 +262,7 @@ def set_automember_process_modify_ops(value): :param value: can be either on or off """ if not have_ldap2: - raise unittest.SkipTest('server plugin not available') + pytest.skip('server plugin not available') ldap = ldap2(api) ldap.connect() plugin_entry = ldap.get_entry( @@ -287,7 +286,7 @@ def wait_automember_rebuild(): If no task is found assume that the task is already finished. """ if not have_ldap2: - raise unittest.SkipTest('server plugin not available') + pytest.skip('server plugin not available') ldap = ldap2(api) ldap.connect() @@ -897,7 +896,7 @@ class TestAutomemberFindOrphans(XMLRPC_test): # rebuild fails if 389-ds is older than 1.4.0.22 where unmembering # feature was implemented: https://pagure.io/389-ds-base/issue/50077 if not have_ldap2: - raise unittest.SkipTest('server plugin not available') + pytest.skip('server plugin not available') ldap = ldap2(api) ldap.connect() rootdse = ldap.get_entry(DN(''), ['vendorVersion']) diff --git a/ipatests/test_xmlrpc/test_cert_plugin.py b/ipatests/test_xmlrpc/test_cert_plugin.py index 7d630f377..6a321deb1 100644 --- a/ipatests/test_xmlrpc/test_cert_plugin.py +++ b/ipatests/test_xmlrpc/test_cert_plugin.py @@ -23,7 +23,6 @@ from __future__ import print_function, absolute_import import base64 import os -import unittest import pytest import six @@ -57,7 +56,7 @@ def is_db_configured(): if (api.env.xmlrpc_uri == u'http://localhost:8888/ipa/xml' and not os.path.isfile(aliasdir)): - raise unittest.SkipTest('developer CA not configured in %s' % aliasdir) + pytest.skip('developer CA not configured in %s' % aliasdir) # Test setup # @@ -86,9 +85,9 @@ class BaseCert(XMLRPC_test): @pytest.fixture(autouse=True, scope="class") def basecert_setup(self, request, xmlrpc_setup): if 'cert_request' not in api.Command: - raise unittest.SkipTest('cert_request not registered') + pytest.skip('cert_request not registered') if 'cert_show' not in api.Command: - raise unittest.SkipTest('cert_show not registered') + pytest.skip('cert_show not registered') is_db_configured() @@ -275,10 +274,10 @@ class test_cert_find(XMLRPC_test): @pytest.fixture(autouse=True, scope="class") def certfind_setup(self, request, xmlrpc_setup): if 'cert_find' not in api.Command: - raise unittest.SkipTest('cert_find not registered') + pytest.skip('cert_find not registered') if api.env.ra_plugin != 'dogtag': - raise unittest.SkipTest('cert_find for dogtag CA only') + pytest.skip('cert_find for dogtag CA only') is_db_configured() diff --git a/ipatests/test_xmlrpc/test_dns_plugin.py b/ipatests/test_xmlrpc/test_dns_plugin.py index 80a198997..5818d252a 100644 --- a/ipatests/test_xmlrpc/test_dns_plugin.py +++ b/ipatests/test_xmlrpc/test_dns_plugin.py @@ -20,8 +20,6 @@ Test the `ipaserver/plugins/dns.py` module. """ -import unittest - from ipalib import api, errors from ipalib.util import normalize_zone from ipapython.dnsutil import DNSName @@ -432,10 +430,10 @@ class test_dns(Declarative): api.Backend.rpcclient.connect() if not have_ldap2: - raise unittest.SkipTest('server plugin not available') + pytest.skip('server plugin not available') if get_nameservers_error is not None: - raise unittest.SkipTest( + pytest.skip( 'unable to get list of nameservers (%s)' % get_nameservers_error ) @@ -446,7 +444,7 @@ class test_dns(Declarative): ) api.Command['dnszone_del'](zone1) except errors.NotFound: - raise unittest.SkipTest('DNS is not configured') + pytest.skip('DNS is not configured') except errors.DuplicateEntry: pass @@ -3342,10 +3340,10 @@ class test_root_zone(Declarative): api.Backend.rpcclient.connect() if not have_ldap2: - raise unittest.SkipTest('server plugin not available') + pytest.skip('server plugin not available') if get_nameservers_error is not None: - raise unittest.SkipTest( + pytest.skip( 'unable to get list of nameservers (%s)' % get_nameservers_error ) @@ -3354,7 +3352,7 @@ class test_root_zone(Declarative): api.Command['dnszone_add'](zone1, idnssoarname=zone1_rname,) api.Command['dnszone_del'](zone1) except errors.NotFound: - raise unittest.SkipTest('DNS is not configured') + pytest.skip('DNS is not configured') except errors.DuplicateEntry: pass @@ -3426,13 +3424,13 @@ class test_forward_zones(Declarative): api.Backend.rpcclient.connect() if not have_ldap2: - raise unittest.SkipTest('server plugin not available') + pytest.skip('server plugin not available') try: api.Command['dnszone_add'](zone1, idnssoarname=zone1_rname,) api.Command['dnszone_del'](zone1) except errors.NotFound: - raise unittest.SkipTest('DNS is not configured') + pytest.skip('DNS is not configured') except errors.DuplicateEntry: pass @@ -4633,13 +4631,13 @@ class test_forward_master_zones_mutual_exlusion(Declarative): api.Backend.rpcclient.connect() if not have_ldap2: - raise unittest.SkipTest('server plugin not available') + pytest.skip('server plugin not available') try: api.Command['dnszone_add'](zone1, idnssoarname=zone1_rname,) api.Command['dnszone_del'](zone1) except errors.NotFound: - raise unittest.SkipTest('DNS is not configured') + pytest.skip('DNS is not configured') except errors.DuplicateEntry: pass @@ -5011,13 +5009,13 @@ class test_forwardzone_delegation_warnings(Declarative): api.Backend.rpcclient.connect() if not have_ldap2: - raise unittest.SkipTest('server plugin not available') + pytest.skip('server plugin not available') try: api.Command['dnszone_add'](zone1, idnssoarname=zone1_rname,) api.Command['dnszone_del'](zone1) except errors.NotFound: - raise unittest.SkipTest('DNS is not configured') + pytest.skip('DNS is not configured') except errors.DuplicateEntry: pass @@ -5520,17 +5518,17 @@ class test_dns_soa(Declarative): api.Backend.rpcclient.connect() if not have_ldap2: - raise unittest.SkipTest('server plugin not available') + pytest.skip('server plugin not available') if get_nameservers_error is not None: - raise unittest.SkipTest('unable to get list of nameservers (%s)' % + pytest.skip('unable to get list of nameservers (%s)' % get_nameservers_error) try: api.Command['dnszone_add'](zone1, idnssoarname=zone1_rname,) api.Command['dnszone_del'](zone1) except errors.NotFound: - raise unittest.SkipTest('DNS is not configured') + pytest.skip('DNS is not configured') except errors.DuplicateEntry: pass diff --git a/ipatests/test_xmlrpc/test_external_members.py b/ipatests/test_xmlrpc/test_external_members.py index e71bf697f..492b7ec48 100644 --- a/ipatests/test_xmlrpc/test_external_members.py +++ b/ipatests/test_xmlrpc/test_external_members.py @@ -21,8 +21,6 @@ Test adding/removing external members (trusted domain objects) to IPA groups. These tests are skipped if trust is not established. """ -import unittest - from ipalib import api from ipapython.dn import DN from ipatests.test_xmlrpc import objectclasses @@ -53,7 +51,7 @@ class test_external_members(Declarative): trusts = api.Command['trust_find']() if trusts['count'] == 0: - raise unittest.SkipTest('Trust is not established') + pytest.skip('Trust is not established') cleanup_commands = [ ('group_del', [group_name], {}), diff --git a/ipatests/test_xmlrpc/test_netgroup_plugin.py b/ipatests/test_xmlrpc/test_netgroup_plugin.py index 8cb111008..0bfaf45ff 100644 --- a/ipatests/test_xmlrpc/test_netgroup_plugin.py +++ b/ipatests/test_xmlrpc/test_netgroup_plugin.py @@ -1400,7 +1400,7 @@ class test_netgroup(Declarative): # entries = conn.find_entries('cn=%s' % self.ng_cn, # base_dn='cn=ng,cn=compat,%s' % api.env.basedn) # except errors.NotFound: -# raise unittest.SkipTest( +# pytest.skip( # 'compat and nis are not enabled, skipping test' # ) # finally: diff --git a/ipatests/test_xmlrpc/test_permission_plugin.py b/ipatests/test_xmlrpc/test_permission_plugin.py index a7c0a5add..04654d0e2 100644 --- a/ipatests/test_xmlrpc/test_permission_plugin.py +++ b/ipatests/test_xmlrpc/test_permission_plugin.py @@ -24,7 +24,6 @@ Test the `ipaserver/plugins/permission.py` module. from __future__ import print_function import os -import unittest from ipalib import api, errors from ipatests.test_xmlrpc import objectclasses @@ -3445,7 +3444,7 @@ class test_managed_permissions(Declarative): @pytest.fixture(autouse=True, scope="class") def managed_perm_setup(self, declarative_setup): if not have_ldap2: - raise unittest.SkipTest('server plugin not available') + pytest.skip('server plugin not available') def add_managed_permission(self): """Add a managed permission and the corresponding ACI""" diff --git a/ipatests/test_xmlrpc/test_stageuser_plugin.py b/ipatests/test_xmlrpc/test_stageuser_plugin.py index 1c12f0d95..5586fc607 100644 --- a/ipatests/test_xmlrpc/test_stageuser_plugin.py +++ b/ipatests/test_xmlrpc/test_stageuser_plugin.py @@ -9,7 +9,6 @@ Test the `ipaserver/plugins/stageuser.py` module. import pytest import six -import unittest from collections import OrderedDict from ipalib import api, errors @@ -327,7 +326,7 @@ class TestStagedUser(XMLRPC_test): # Directly create the user using ldapmod # without the posixaccount objectclass if not have_ldap2: - raise unittest.SkipTest('server plugin not available') + pytest.skip('server plugin not available') ldap = ldap2(api) ldap.connect() ldap.create( diff --git a/ipatests/test_xmlrpc/test_trust_plugin.py b/ipatests/test_xmlrpc/test_trust_plugin.py index f90ae753a..21c170943 100644 --- a/ipatests/test_xmlrpc/test_trust_plugin.py +++ b/ipatests/test_xmlrpc/test_trust_plugin.py @@ -20,8 +20,6 @@ Test the `ipaserver/plugins/trust.py` module. """ -import unittest - import six from ipalib import api, errors @@ -54,7 +52,7 @@ class test_trustconfig(Declarative): try: api.Command['trustconfig_show'](trust_type=u'ad') except errors.NotFound: - raise unittest.SkipTest('Trusts are not configured') + pytest.skip('Trusts are not configured') cleanup_commands = [ ('group_del', [testgroup], {}), diff --git a/ipatests/test_xmlrpc/test_vault_plugin.py b/ipatests/test_xmlrpc/test_vault_plugin.py index 5edce2e68..bec996f8a 100644 --- a/ipatests/test_xmlrpc/test_vault_plugin.py +++ b/ipatests/test_xmlrpc/test_vault_plugin.py @@ -21,8 +21,6 @@ Test the `ipaserver/plugins/vault.py` module. """ -import unittest - import pytest import six @@ -140,7 +138,7 @@ class test_vault_plugin(Declarative): api.Backend.rpcclient.connect() if not api.Command.kra_is_enabled()['result']: - raise unittest.SkipTest('KRA service is not enabled') + pytest.skip('KRA service is not enabled') cleanup_commands = [ ('vault_del', [vault_name], {'continue': True}), diff --git a/ipatests/test_xmlrpc/xmlrpc_test.py b/ipatests/test_xmlrpc/xmlrpc_test.py index 2a2d4cb34..de2357237 100644 --- a/ipatests/test_xmlrpc/xmlrpc_test.py +++ b/ipatests/test_xmlrpc/xmlrpc_test.py @@ -24,7 +24,6 @@ from __future__ import print_function import datetime import inspect -import unittest import contextlib import pytest @@ -211,9 +210,9 @@ class XMLRPC_test: @pytest.fixture(autouse=True, scope="class") def xmlrpc_setup(self, request): if not server_available: - raise unittest.SkipTest('%r: Server not available: %r' % - (request.cls.__module__, - api.env.xmlrpc_uri)) + pytest.skip('%r: Server not available: %r' % + (request.cls.__module__, + api.env.xmlrpc_uri)) if not api.Backend.rpcclient.isconnected(): api.Backend.rpcclient.connect() @@ -320,7 +319,7 @@ class Declarative(XMLRPC_test): (cmd, args, options) = command print('Cleanup:', cmd, args, options) if cmd not in api.Command: - raise unittest.SkipTest( + pytest.skip( 'cleanup command %r not in api.Command' % cmd ) try: @@ -342,7 +341,7 @@ class Declarative(XMLRPC_test): (cmd, args, options) = command options.setdefault('version', self.default_version) if cmd not in api.Command: - raise unittest.SkipTest('%r not in api.Command' % cmd) + pytest.skip('%r not in api.Command' % cmd) if isinstance(expected, errors.PublicError): self.check_exception(nice, cmd, args, options, expected) elif hasattr(expected, '__call__'):