diff --git a/swh/model/tests/fields/test_compound.py b/swh/model/tests/fields/test_compound.py --- a/swh/model/tests/fields/test_compound.py +++ b/swh/model/tests/fields/test_compound.py @@ -6,9 +6,7 @@ import datetime import unittest -from nose.tools import istest - -from swh.model.exceptions import ValidationError, NON_FIELD_ERRORS +from swh.model.exceptions import NON_FIELD_ERRORS, ValidationError from swh.model.fields import compound, simple @@ -63,8 +61,7 @@ self.present_keys = set(self.test_value) self.missing_keys = {'missingkey1', 'missingkey2'} - @istest - def validate_any_key(self): + def test_validate_any_key(self): self.assertTrue( compound.validate_any_key(self.test_value, self.present_keys)) @@ -72,8 +69,7 @@ compound.validate_any_key(self.test_value, self.present_keys | self.missing_keys)) - @istest - def validate_any_key_missing(self): + def test_validate_any_key_missing(self): with self.assertRaises(ValidationError) as cm: compound.validate_any_key(self.test_value, self.missing_keys) @@ -83,13 +79,11 @@ self.assertEqual(exc.params['missing_fields'], ', '.join(sorted(self.missing_keys))) - @istest - def validate_all_keys(self): + def test_validate_all_keys(self): self.assertTrue( compound.validate_all_keys(self.test_value, self.present_keys)) - @istest - def validate_all_keys_missing(self): + def test_validate_all_keys_missing(self): with self.assertRaises(ValidationError) as cm: compound.validate_all_keys(self.test_value, self.missing_keys) @@ -109,14 +103,12 @@ self.assertEqual(exc.params['missing_fields'], ', '.join(sorted(self.missing_keys))) - @istest - def validate_against_schema(self): + def test_validate_against_schema(self): self.assertTrue( compound.validate_against_schema(self.test_model, self.test_schema, self.test_value)) - @istest - def validate_against_schema_wrong_type(self): + def test_validate_against_schema_wrong_type(self): with self.assertRaises(ValidationError) as cm: compound.validate_against_schema(self.test_model, self.test_schema, self.test_value_wrong_type) @@ -128,8 +120,7 @@ self.assertEqual(exc.params['type'], self.test_value_wrong_type.__class__.__name__) - @istest - def validate_against_schema_mandatory_keys(self): + def test_validate_against_schema_mandatory_keys(self): with self.assertRaises(ValidationError) as cm: compound.validate_against_schema(self.test_model, self.test_schema, self.test_value_missing) @@ -150,8 +141,7 @@ self.assertEqual(nested.code, 'model-field-mandatory') self.assertEqual(nested.params['field'], key) - @istest - def validate_against_schema_whole_schema_shortcut_previous_error(self): + def test_validate_whole_schema_shortcut_previous_error(self): with self.assertRaises(ValidationError) as cm: compound.validate_against_schema( self.test_model, @@ -163,8 +153,7 @@ self.assertIsInstance(str(exc), str) self.assertNotIn(NON_FIELD_ERRORS, exc.error_dict) - @istest - def validate_against_schema_whole_schema(self): + def test_validate_whole_schema(self): with self.assertRaises(ValidationError) as cm: compound.validate_against_schema( self.test_model, @@ -191,8 +180,7 @@ self.assertEquals(nested.params['model'], self.test_model) self.assertEquals(nested.params['validator'], 'validate_never') - @istest - def validate_against_schema_field_error(self): + def test_validate_against_schema_field_error(self): with self.assertRaises(ValidationError) as cm: compound.validate_against_schema(self.test_model, self.test_schema, self.test_value_str_error) @@ -214,8 +202,7 @@ self.assertIsInstance(nested, ValidationError) self.assertEquals(nested.code, 'unexpected-type') - @istest - def validate_against_schema_field_failed(self): + def test_validate_against_schema_field_failed(self): with self.assertRaises(ValidationError) as cm: compound.validate_against_schema(self.test_model, self.test_schema_field_failed, diff --git a/swh/model/tests/fields/test_hashes.py b/swh/model/tests/fields/test_hashes.py --- a/swh/model/tests/fields/test_hashes.py +++ b/swh/model/tests/fields/test_hashes.py @@ -5,8 +5,6 @@ import unittest -from nose.tools import istest - from swh.model.exceptions import ValidationError from swh.model.fields import hashes @@ -32,18 +30,15 @@ self.bad_hash = object() - @istest - def valid_bytes_hash(self): + def test_valid_bytes_hash(self): for hash_type, value in self.valid_byte_hashes.items(): self.assertTrue(hashes.validate_hash(value, hash_type)) - @istest - def valid_str_hash(self): + def test_valid_str_hash(self): for hash_type, value in self.valid_str_hashes.items(): self.assertTrue(hashes.validate_hash(value, hash_type)) - @istest - def invalid_hash_type(self): + def test_invalid_hash_type(self): hash_type = 'unknown_hash_type' with self.assertRaises(ValidationError) as cm: hashes.validate_hash(self.valid_str_hashes['sha1'], hash_type) @@ -56,8 +51,7 @@ self.assertIn('Unexpected hash type', str(exc)) self.assertIn(hash_type, str(exc)) - @istest - def invalid_bytes_len(self): + def test_invalid_bytes_len(self): for hash_type, value in self.valid_byte_hashes.items(): value = value + b'\x00\x01' with self.assertRaises(ValidationError) as cm: @@ -72,8 +66,7 @@ self.assertIn('Unexpected length', str(exc)) self.assertIn(str(len(value)), str(exc)) - @istest - def invalid_str_len(self): + def test_invalid_str_len(self): for hash_type, value in self.valid_str_hashes.items(): value = value + '0001' with self.assertRaises(ValidationError) as cm: @@ -88,8 +81,7 @@ self.assertIn('Unexpected length', str(exc)) self.assertIn(str(len(value)), str(exc)) - @istest - def invalid_str_contents(self): + def test_invalid_str_contents(self): for hash_type, value in self.valid_str_hashes.items(): value = '\xa2' + value[1:-1] + '\xc3' with self.assertRaises(ValidationError) as cm: @@ -105,8 +97,7 @@ self.assertIn('\xc3', str(exc)) self.assertIn('\xa2', str(exc)) - @istest - def invalid_value_type(self): + def test_invalid_value_type(self): with self.assertRaises(ValidationError) as cm: hashes.validate_hash(self.bad_hash, 'sha1') @@ -118,8 +109,7 @@ self.assertIn('Unexpected type', str(exc)) self.assertIn(self.bad_hash.__class__.__name__, str(exc)) - @istest - def validate_sha1(self): + def test_validate_sha1(self): self.assertTrue(hashes.validate_sha1(self.valid_byte_hashes['sha1'])) self.assertTrue(hashes.validate_sha1(self.valid_str_hashes['sha1'])) @@ -131,8 +121,7 @@ self.assertEqual(exc.code, 'unexpected-hash-value-type') self.assertEqual(exc.params['type'], self.bad_hash.__class__.__name__) - @istest - def validate_sha1_git(self): + def test_validate_sha1_git(self): self.assertTrue( hashes.validate_sha1_git(self.valid_byte_hashes['sha1_git'])) self.assertTrue( @@ -146,8 +135,7 @@ self.assertEqual(exc.code, 'unexpected-hash-value-type') self.assertEqual(exc.params['type'], self.bad_hash.__class__.__name__) - @istest - def validate_sha256(self): + def test_validate_sha256(self): self.assertTrue( hashes.validate_sha256(self.valid_byte_hashes['sha256'])) self.assertTrue( diff --git a/swh/model/tests/fields/test_simple.py b/swh/model/tests/fields/test_simple.py --- a/swh/model/tests/fields/test_simple.py +++ b/swh/model/tests/fields/test_simple.py @@ -6,8 +6,6 @@ import datetime import unittest -from nose.tools import istest - from swh.model.exceptions import ValidationError from swh.model.fields import simple @@ -29,12 +27,10 @@ tzinfo=datetime.timezone.utc) self.invalid_datetime_notz = datetime.datetime(1999, 1, 1, 12, 0, 0) - @istest - def validate_int(self): + def test_validate_int(self): self.assertTrue(simple.validate_int(self.valid_int)) - @istest - def validate_int_invalid_type(self): + def test_validate_int_invalid_type(self): with self.assertRaises(ValidationError) as cm: simple.validate_int(self.valid_str) @@ -44,12 +40,10 @@ self.assertEqual(exc.params['expected_type'], 'Integral') self.assertEqual(exc.params['type'], 'str') - @istest - def validate_str(self): + def test_validate_str(self): self.assertTrue(simple.validate_str(self.valid_str)) - @istest - def validate_str_invalid_type(self): + def test_validate_str_invalid_type(self): with self.assertRaises(ValidationError) as cm: simple.validate_str(self.valid_int) @@ -68,12 +62,10 @@ self.assertEqual(exc.params['expected_type'], 'str') self.assertEqual(exc.params['type'], 'bytes') - @istest - def validate_bytes(self): + def test_validate_bytes(self): self.assertTrue(simple.validate_bytes(self.valid_bytes)) - @istest - def validate_bytes_invalid_type(self): + def test_validate_bytes_invalid_type(self): with self.assertRaises(ValidationError) as cm: simple.validate_bytes(self.valid_int) @@ -92,14 +84,12 @@ self.assertEqual(exc.params['expected_type'], 'bytes') self.assertEqual(exc.params['type'], 'str') - @istest - def validate_datetime(self): + def test_validate_datetime(self): self.assertTrue(simple.validate_datetime(self.valid_datetime)) self.assertTrue(simple.validate_datetime(self.valid_int)) self.assertTrue(simple.validate_datetime(self.valid_real)) - @istest - def validate_datetime_invalid_type(self): + def test_validate_datetime_invalid_type(self): with self.assertRaises(ValidationError) as cm: simple.validate_datetime(self.valid_str) @@ -109,8 +99,7 @@ self.assertEqual(exc.params['expected_type'], 'one of datetime, Real') self.assertEqual(exc.params['type'], 'str') - @istest - def validate_datetime_invalide_tz(self): + def test_validate_datetime_invalide_tz(self): with self.assertRaises(ValidationError) as cm: simple.validate_datetime(self.invalid_datetime_notz) @@ -118,13 +107,11 @@ self.assertIsInstance(str(exc), str) self.assertEqual(exc.code, 'datetime-without-tzinfo') - @istest - def validate_enum(self): + def test_validate_enum(self): for value in self.enum_values: self.assertTrue(simple.validate_enum(value, self.enum_values)) - @istest - def validate_enum_invalid_value(self): + def test_validate_enum_invalid_value(self): with self.assertRaises(ValidationError) as cm: simple.validate_enum(self.invalid_enum_value, self.enum_values) diff --git a/swh/model/tests/test_cli.py b/swh/model/tests/test_cli.py --- a/swh/model/tests/test_cli.py +++ b/swh/model/tests/test_cli.py @@ -11,8 +11,8 @@ from nose.plugins.attrib import attr from swh.model import cli -from swh.model.tests.test_from_disk import DataMixin from swh.model.hashutil import hash_to_hex +from swh.model.tests.test_from_disk import DataMixin @attr('fs') @@ -22,7 +22,7 @@ super().setUp() self.runner = CliRunner() - def assertPidOK(self, result, pid): + def assertPidOK(self, result, pid): # noqa: N802 self.assertEqual(result.exit_code, 0) self.assertEqual(result.output.split()[0], pid) diff --git a/swh/model/tests/test_from_disk.py b/swh/model/tests/test_from_disk.py --- a/swh/model/tests/test_from_disk.py +++ b/swh/model/tests/test_from_disk.py @@ -11,10 +11,9 @@ from nose.plugins.attrib import attr from swh.model import from_disk -from swh.model.from_disk import Content, Directory, DentryPerms +from swh.model.from_disk import Content, DentryPerms, Directory from swh.model.hashutil import DEFAULT_ALGORITHMS, hash_to_bytes, hash_to_hex - TEST_DATA = os.path.join(os.path.dirname(__file__), 'data') diff --git a/swh/model/tests/test_hashutil.py b/swh/model/tests/test_hashutil.py --- a/swh/model/tests/test_hashutil.py +++ b/swh/model/tests/test_hashutil.py @@ -8,8 +8,6 @@ import os import tempfile import unittest - -from nose.tools import istest from unittest.mock import patch from swh.model import hashutil @@ -55,14 +53,12 @@ class MultiHashTest(BaseHashutil): - @istest - def multi_hash_data(self): + def test_multi_hash_data(self): checksums = MultiHash.from_data(self.data).digest() self.assertEqual(checksums, self.checksums) self.assertFalse('length' in checksums) - @istest - def multi_hash_data_with_length(self): + def test_multi_hash_data_with_length(self): expected_checksums = self.checksums.copy() expected_checksums['length'] = len(self.data) @@ -72,45 +68,39 @@ self.assertEqual(checksums, expected_checksums) self.assertTrue('length' in checksums) - @istest - def multi_hash_data_unknown_hash(self): + def test_multi_hash_data_unknown_hash(self): with self.assertRaises(ValueError) as cm: MultiHash.from_data(self.data, ['unknown-hash']) self.assertIn('Unexpected hashing algorithm', cm.exception.args[0]) self.assertIn('unknown-hash', cm.exception.args[0]) - @istest - def multi_hash_file(self): + def test_multi_hash_file(self): fobj = io.BytesIO(self.data) checksums = MultiHash.from_file(fobj, length=len(self.data)).digest() self.assertEqual(checksums, self.checksums) - @istest - def multi_hash_file_hexdigest(self): + def test_multi_hash_file_hexdigest(self): fobj = io.BytesIO(self.data) length = len(self.data) checksums = MultiHash.from_file(fobj, length=length).hexdigest() self.assertEqual(checksums, self.hex_checksums) - @istest - def multi_hash_file_bytehexdigest(self): + def test_multi_hash_file_bytehexdigest(self): fobj = io.BytesIO(self.data) length = len(self.data) checksums = MultiHash.from_file(fobj, length=length).bytehexdigest() self.assertEqual(checksums, self.bytehex_checksums) - @istest - def multi_hash_file_missing_length(self): + def test_multi_hash_file_missing_length(self): fobj = io.BytesIO(self.data) with self.assertRaises(ValueError) as cm: MultiHash.from_file(fobj, hash_names=['sha1_git']) self.assertIn('Missing length', cm.exception.args[0]) - @istest - def multi_hash_path(self): + def test_multi_hash_path(self): with tempfile.NamedTemporaryFile(delete=False) as f: f.write(self.data) @@ -121,14 +111,12 @@ class Hashutil(BaseHashutil): - @istest - def hash_data(self): + def test_hash_data(self): checksums = hashutil.hash_data(self.data) self.assertEqual(checksums, self.checksums) self.assertFalse('length' in checksums) - @istest - def hash_data_with_length(self): + def test_hash_data_with_length(self): expected_checksums = self.checksums.copy() expected_checksums['length'] = len(self.data) @@ -138,16 +126,14 @@ self.assertEqual(checksums, expected_checksums) self.assertTrue('length' in checksums) - @istest - def hash_data_unknown_hash(self): + def test_hash_data_unknown_hash(self): with self.assertRaises(ValueError) as cm: hashutil.hash_data(self.data, ['unknown-hash']) self.assertIn('Unexpected hashing algorithm', cm.exception.args[0]) self.assertIn('unknown-hash', cm.exception.args[0]) - @istest - def hash_git_data(self): + def test_hash_git_data(self): checksums = { git_type: hashutil.hash_git_data(self.data, git_type) for git_type in self.git_checksums @@ -155,23 +141,20 @@ self.assertEqual(checksums, self.git_checksums) - @istest - def hash_git_data_unknown_git_type(self): + def test_hash_git_data_unknown_git_type(self): with self.assertRaises(ValueError) as cm: hashutil.hash_git_data(self.data, 'unknown-git-type') self.assertIn('Unexpected git object type', cm.exception.args[0]) self.assertIn('unknown-git-type', cm.exception.args[0]) - @istest - def hash_file(self): + def test_hash_file(self): fobj = io.BytesIO(self.data) checksums = hashutil.hash_file(fobj, length=len(self.data)) self.assertEqual(checksums, self.checksums) - @istest - def hash_file_missing_length(self): + def test_hash_file_missing_length(self): fobj = io.BytesIO(self.data) with self.assertRaises(ValueError) as cm: @@ -179,8 +162,7 @@ self.assertIn('Missing length', cm.exception.args[0]) - @istest - def hash_path(self): + def test_hash_path(self): with tempfile.NamedTemporaryFile(delete=False) as f: f.write(self.data) @@ -190,37 +172,32 @@ self.checksums['length'] = len(self.data) self.assertEquals(self.checksums, hashes) - @istest - def hash_to_hex(self): + def test_hash_to_hex(self): for type in self.checksums: hex = self.hex_checksums[type] hash = self.checksums[type] self.assertEquals(hashutil.hash_to_hex(hex), hex) self.assertEquals(hashutil.hash_to_hex(hash), hex) - @istest - def hash_to_bytes(self): + def test_hash_to_bytes(self): for type in self.checksums: hex = self.hex_checksums[type] hash = self.checksums[type] self.assertEquals(hashutil.hash_to_bytes(hex), hash) self.assertEquals(hashutil.hash_to_bytes(hash), hash) - @istest - def hash_to_bytehex(self): + def test_hash_to_bytehex(self): for algo in self.checksums: self.assertEqual(self.hex_checksums[algo].encode('ascii'), hashutil.hash_to_bytehex(self.checksums[algo])) - @istest - def bytehex_to_hash(self): + def test_bytehex_to_hash(self): for algo in self.checksums: self.assertEqual(self.checksums[algo], hashutil.bytehex_to_hash( self.hex_checksums[algo].encode())) - @istest - def new_hash_unsupported_hashing_algorithm(self): + def test_new_hash_unsupported_hashing_algorithm(self): try: hashutil._new_hash('blake2:10') except ValueError as e: @@ -230,8 +207,7 @@ 'sha1, sha1_git, sha256') @patch('hashlib.new') - @istest - def new_hash_blake2b_blake2b512_builtin(self, mock_hashlib_new): + def test_new_hash_blake2b_blake2b512_builtin(self, mock_hashlib_new): if 'blake2b512' not in hashlib.algorithms_available: self.skipTest('blake2b512 not built-in') mock_hashlib_new.return_value = sentinel = object() @@ -242,8 +218,7 @@ mock_hashlib_new.assert_called_with('blake2b512') @patch('hashlib.new') - @istest - def new_hash_blake2s_blake2s256_builtin(self, mock_hashlib_new): + def test_new_hash_blake2s_blake2s256_builtin(self, mock_hashlib_new): if 'blake2s256' not in hashlib.algorithms_available: self.skipTest('blake2s256 not built-in') mock_hashlib_new.return_value = sentinel = object() @@ -253,8 +228,7 @@ self.assertIs(h, sentinel) mock_hashlib_new.assert_called_with('blake2s256') - @istest - def new_hash_blake2b_builtin(self): + def test_new_hash_blake2b_builtin(self): removed_hash = False try: @@ -275,8 +249,7 @@ if removed_hash: hashlib.algorithms_available.add('blake2b512') - @istest - def new_hash_blake2s_builtin(self): + def test_new_hash_blake2s_builtin(self): removed_hash = False try: @@ -297,8 +270,7 @@ if removed_hash: hashlib.algorithms_available.add('blake2s256') - @istest - def new_hash_blake2b_pyblake2(self): + def test_new_hash_blake2b_pyblake2(self): if 'blake2b512' in hashlib.algorithms_available: self.skipTest('blake2b512 built in') if 'blake2b' in hashlib.algorithms_available: @@ -312,8 +284,7 @@ self.assertIs(h, sentinel) mock_blake2b.assert_called_with(digest_size=512//8) - @istest - def new_hash_blake2s_pyblake2(self): + def test_new_hash_blake2s_pyblake2(self): if 'blake2s256' in hashlib.algorithms_available: self.skipTest('blake2s256 built in') if 'blake2s' in hashlib.algorithms_available: @@ -368,15 +339,13 @@ 'e9e959f120'), } - @istest - def unknown_header_type(self): + def test_unknown_header_type(self): with self.assertRaises(ValueError) as cm: hashutil.hash_git_data(b'any-data', 'some-unknown-type') self.assertIn('Unexpected git object type', cm.exception.args[0]) - @istest - def hashdata_content(self): + def test_hashdata_content(self): # when actual_hash = hashutil.hash_git_data(self.blob_data, git_type='blob') @@ -384,8 +353,7 @@ self.assertEqual(actual_hash, self.checksums['blob_sha1_git']) - @istest - def hashdata_tree(self): + def test_hashdata_tree(self): # when actual_hash = hashutil.hash_git_data(self.tree_data, git_type='tree') @@ -393,8 +361,7 @@ self.assertEqual(actual_hash, self.checksums['tree_sha1_git']) - @istest - def hashdata_revision(self): + def test_hashdata_revision(self): # when actual_hash = hashutil.hash_git_data(self.commit_data, git_type='commit') @@ -403,8 +370,7 @@ self.assertEqual(actual_hash, self.checksums['commit_sha1_git']) - @istest - def hashdata_tag(self): + def test_hashdata_tag(self): # when actual_hash = hashutil.hash_git_data(self.tag_data, git_type='tag') diff --git a/swh/model/tests/test_identifiers.py b/swh/model/tests/test_identifiers.py --- a/swh/model/tests/test_identifiers.py +++ b/swh/model/tests/test_identifiers.py @@ -7,14 +7,11 @@ import datetime import unittest -from nose.tools import istest - from swh.model import hashutil, identifiers - from swh.model.exceptions import ValidationError -from swh.model.identifiers import SNAPSHOT, RELEASE, REVISION, DIRECTORY -from swh.model.identifiers import CONTENT, PERSISTENT_IDENTIFIER_TYPES -from swh.model.identifiers import PersistentId +from swh.model.identifiers import (CONTENT, DIRECTORY, + PERSISTENT_IDENTIFIER_TYPES, RELEASE, + REVISION, SNAPSHOT, PersistentId) class UtilityFunctionsIdentifier(unittest.TestCase): @@ -23,8 +20,7 @@ self.bytes_id = binascii.unhexlify(self.str_id) self.bad_type_id = object() - @istest - def identifier_to_bytes(self): + def test_identifier_to_bytes(self): for id in [self.str_id, self.bytes_id]: self.assertEqual(identifiers.identifier_to_bytes(id), self.bytes_id) @@ -40,8 +36,7 @@ self.assertIn('type', str(cm.exception)) - @istest - def identifier_to_str(self): + def test_identifier_to_str(self): for id in [self.str_id, self.bytes_id]: self.assertEqual(identifiers.identifier_to_str(id), self.str_id) @@ -84,19 +79,16 @@ 800: b'+1320', } - @istest - def format_date(self): + def test_format_date(self): for date_repr, date in self.dates.items(): self.assertEqual(identifiers.format_date(date), date_repr) - @istest - def format_date_fail(self): + def test_format_date_fail(self): for date in self.broken_dates: with self.assertRaises(ValueError): identifiers.format_date(date) - @istest - def format_offset(self): + def test_format_offset(self): for offset, res in self.offsets.items(): self.assertEqual(identifiers.format_offset(offset), res) @@ -113,8 +105,7 @@ self.content_id = hashutil.hash_data(self.content['data']) - @istest - def content_identifier(self): + def test_content_identifier(self): self.assertEqual(identifiers.content_identifier(self.content), self.content_id) @@ -216,14 +207,12 @@ 'entries': [], } - @istest - def dir_identifier(self): + def test_dir_identifier(self): self.assertEqual( identifiers.directory_identifier(self.directory), self.directory['id']) - @istest - def dir_identifier_empty_directory(self): + def test_dir_identifier_empty_directory(self): self.assertEqual( identifiers.directory_identifier(self.empty_directory), self.empty_directory['id']) @@ -460,29 +449,25 @@ } } - @istest - def revision_identifier(self): + def test_revision_identifier(self): self.assertEqual( identifiers.revision_identifier(self.revision), identifiers.identifier_to_str(self.revision['id']), ) - @istest - def revision_identifier_none_metadata(self): + def test_revision_identifier_none_metadata(self): self.assertEqual( identifiers.revision_identifier(self.revision_none_metadata), identifiers.identifier_to_str(self.revision_none_metadata['id']), ) - @istest - def revision_identifier_synthetic(self): + def test_revision_identifier_synthetic(self): self.assertEqual( identifiers.revision_identifier(self.synthetic_revision), identifiers.identifier_to_str(self.synthetic_revision['id']), ) - @istest - def revision_identifier_with_extra_headers(self): + def test_revision_identifier_with_extra_headers(self): self.assertEqual( identifiers.revision_identifier( self.revision_with_extra_headers), @@ -490,8 +475,7 @@ self.revision_with_extra_headers['id']), ) - @istest - def revision_identifier_with_gpgsig(self): + def test_revision_identifier_with_gpgsig(self): self.assertEqual( identifiers.revision_identifier( self.revision_with_gpgsig), @@ -499,8 +483,7 @@ self.revision_with_gpgsig['id']), ) - @istest - def revision_identifier_no_message(self): + def test_revision_identifier_no_message(self): self.assertEqual( identifiers.revision_identifier( self.revision_no_message), @@ -508,8 +491,7 @@ self.revision_no_message['id']), ) - @istest - def revision_identifier_empty_message(self): + def test_revision_identifier_empty_message(self): self.assertEqual( identifiers.revision_identifier( self.revision_empty_message), @@ -517,8 +499,7 @@ self.revision_empty_message['id']), ) - @istest - def revision_identifier_only_fullname(self): + def test_revision_identifier_only_fullname(self): self.assertEqual( identifiers.revision_identifier( self.revision_only_fullname), @@ -643,43 +624,37 @@ 'target_type': 'revision', } - @istest - def release_identifier(self): + def test_release_identifier(self): self.assertEqual( identifiers.release_identifier(self.release), identifiers.identifier_to_str(self.release['id']) ) - @istest - def release_identifier_no_author(self): + def test_release_identifier_no_author(self): self.assertEqual( identifiers.release_identifier(self.release_no_author), identifiers.identifier_to_str(self.release_no_author['id']) ) - @istest - def release_identifier_no_message(self): + def test_release_identifier_no_message(self): self.assertEqual( identifiers.release_identifier(self.release_no_message), identifiers.identifier_to_str(self.release_no_message['id']) ) - @istest - def release_identifier_empty_message(self): + def test_release_identifier_empty_message(self): self.assertEqual( identifiers.release_identifier(self.release_empty_message), identifiers.identifier_to_str(self.release_empty_message['id']) ) - @istest - def release_identifier_negative_utc(self): + def test_release_identifier_negative_utc(self): self.assertEqual( identifiers.release_identifier(self.release_negative_utc), identifiers.identifier_to_str(self.release_negative_utc['id']) ) - @istest - def release_identifier_newline_in_author(self): + def test_release_identifier_newline_in_author(self): self.assertEqual( identifiers.release_identifier(self.release_newline_in_author), identifiers.identifier_to_str(self.release_newline_in_author['id']) diff --git a/swh/model/tests/test_toposort.py b/swh/model/tests/test_toposort.py --- a/swh/model/tests/test_toposort.py +++ b/swh/model/tests/test_toposort.py @@ -4,6 +4,7 @@ # See top-level LICENSE file for more information import unittest + from swh.model.toposort import toposort diff --git a/swh/model/tests/test_validators.py b/swh/model/tests/test_validators.py --- a/swh/model/tests/test_validators.py +++ b/swh/model/tests/test_validators.py @@ -6,9 +6,7 @@ import datetime import unittest -from nose.tools import istest - -from swh.model import validators, hashutil, exceptions +from swh.model import exceptions, hashutil, validators class TestValidators(unittest.TestCase): @@ -38,16 +36,14 @@ self.invalid_content_hash_mismatch.update( hashutil.hash_data(b"this is not the data you're looking for")) - @istest - def validate_content(self): + def test_validate_content(self): self.assertTrue( validators.validate_content(self.valid_visible_content)) self.assertTrue( validators.validate_content(self.valid_absent_content)) - @istest - def validate_content_hash_mismatch(self): + def test_validate_content_hash_mismatch(self): with self.assertRaises(exceptions.ValidationError) as cm: validators.validate_content(self.invalid_content_hash_mismatch)