From fec66942d469188fcd1ccfbd6e14f4e8334056b4 Mon Sep 17 00:00:00 2001 From: Stanislav Levin Date: Tue, 15 Oct 2019 13:24:11 +0300 Subject: [PATCH] pytest: Migrate unittest/nose to Pytest fixtures Even though Pytest supports xunit style setups, unittest and nose tests, this support is limited and may be dropped in the future releases. Worst of all is that the mixing of various test frameworks results in weird conflicts and of course, is not widely tested. This is a part of work to remove the mixing of test idioms in the IPA's test suite: 1) replace unittest.TestCase subclasses 2) replace unittest test controls (SkipTest, fail, etc.) 3) replace unittest assertions Related: https://pagure.io/freeipa/issue/7989 Signed-off-by: Stanislav Levin Reviewed-By: Christian Heimes --- ipatests/test_cmdline/cmdline.py | 3 +- ipatests/test_cmdline/test_cli.py | 11 +- ipatests/test_install/test_updates.py | 98 +- .../test_integration/test_legacy_clients.py | 45 +- ipatests/test_integration/test_trust.py | 7 +- ipatests/test_ipalib/test_rpc.py | 9 +- ipatests/test_ipalib/test_text.py | 7 +- ipatests/test_ipapython/test_cookie.py | 466 ++++----- ipatests/test_ipapython/test_dn.py | 889 +++++++++--------- ipatests/test_ipapython/test_ipavalidate.py | 88 +- .../test_ipaserver/test_adtrust_mockup.py | 19 +- ipatests/test_ipaserver/test_changepw.py | 4 +- ipatests/test_ipaserver/test_ldap.py | 7 +- ipatests/test_ipaserver/test_secrets.py | 19 +- ipatests/test_webui/ui_driver.py | 22 +- .../test_xmlrpc/test_automember_plugin.py | 7 +- ipatests/test_xmlrpc/test_cert_plugin.py | 11 +- ipatests/test_xmlrpc/test_dns_plugin.py | 32 +- ipatests/test_xmlrpc/test_external_members.py | 4 +- ipatests/test_xmlrpc/test_netgroup_plugin.py | 2 +- .../test_xmlrpc/test_permission_plugin.py | 3 +- ipatests/test_xmlrpc/test_stageuser_plugin.py | 3 +- ipatests/test_xmlrpc/test_trust_plugin.py | 4 +- ipatests/test_xmlrpc/test_vault_plugin.py | 4 +- ipatests/test_xmlrpc/xmlrpc_test.py | 11 +- 25 files changed, 887 insertions(+), 888 deletions(-) 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__'):