From 7af882adf111ef5c2d4a9e32bb2005643806c751 Mon Sep 17 00:00:00 2001
From: Nicolas Dandrimont <nicolas@dandrimont.eu>
Date: Fri, 12 Oct 2018 11:46:31 +0200
Subject: [PATCH] Rename test methods to test_ to allow py.test collection

Summary: Related to T1261

Test Plan: before and after: 138 tests passed (2 skipped)

Reviewers: #reviewers!

Differential Revision: https://forge.softwareheritage.org/D520
---
 swh/model/tests/fields/test_compound.py | 37 +++-------
 swh/model/tests/fields/test_hashes.py   | 32 +++-----
 swh/model/tests/fields/test_simple.py   | 35 +++------
 swh/model/tests/test_cli.py             |  4 +-
 swh/model/tests/test_from_disk.py       |  3 +-
 swh/model/tests/test_hashutil.py        | 98 ++++++++-----------------
 swh/model/tests/test_identifiers.py     | 75 +++++++------------
 swh/model/tests/test_toposort.py        |  1 +
 swh/model/tests/test_validators.py      | 10 +--
 9 files changed, 97 insertions(+), 198 deletions(-)

diff --git a/swh/model/tests/fields/test_compound.py b/swh/model/tests/fields/test_compound.py
index b6e13b6c..d89a3e12 100644
--- 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 @@ class ValidateCompound(unittest.TestCase):
         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 @@ class ValidateCompound(unittest.TestCase):
             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 @@ class ValidateCompound(unittest.TestCase):
         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 @@ class ValidateCompound(unittest.TestCase):
         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 @@ class ValidateCompound(unittest.TestCase):
         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 @@ class ValidateCompound(unittest.TestCase):
             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 @@ class ValidateCompound(unittest.TestCase):
         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 @@ class ValidateCompound(unittest.TestCase):
         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 @@ class ValidateCompound(unittest.TestCase):
         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
index 0ef303f0..7ce0b78b 100644
--- 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 @@ class ValidateHashes(unittest.TestCase):
 
         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 @@ class ValidateHashes(unittest.TestCase):
         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 @@ class ValidateHashes(unittest.TestCase):
             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 @@ class ValidateHashes(unittest.TestCase):
             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 @@ class ValidateHashes(unittest.TestCase):
             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 @@ class ValidateHashes(unittest.TestCase):
         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 @@ class ValidateHashes(unittest.TestCase):
         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 @@ class ValidateHashes(unittest.TestCase):
         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
index 6fa2918d..ab5e262e 100644
--- 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 @@ class ValidateSimple(unittest.TestCase):
                                                 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 @@ class ValidateSimple(unittest.TestCase):
         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 @@ class ValidateSimple(unittest.TestCase):
         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 @@ class ValidateSimple(unittest.TestCase):
         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 @@ class ValidateSimple(unittest.TestCase):
         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 @@ class ValidateSimple(unittest.TestCase):
         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
index 9e31a4a3..5d20874e 100644
--- a/swh/model/tests/test_cli.py
+++ b/swh/model/tests/test_cli.py
@@ -11,8 +11,8 @@ from click.testing import CliRunner
 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 @@ class TestIdentify(DataMixin, unittest.TestCase):
         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
index 432b1934..2e6c3952 100644
--- a/swh/model/tests/test_from_disk.py
+++ b/swh/model/tests/test_from_disk.py
@@ -11,10 +11,9 @@ import unittest
 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
index 94a66ddc..a7796efc 100644
--- a/swh/model/tests/test_hashutil.py
+++ b/swh/model/tests/test_hashutil.py
@@ -8,8 +8,6 @@ import io
 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 BaseHashutil(unittest.TestCase):
 
 
 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 @@ class MultiHashTest(BaseHashutil):
         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 MultiHashTest(BaseHashutil):
 
 
 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 @@ class Hashutil(BaseHashutil):
         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 @@ class Hashutil(BaseHashutil):
 
         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 @@ class Hashutil(BaseHashutil):
 
         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 @@ class Hashutil(BaseHashutil):
         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 @@ class Hashutil(BaseHashutil):
                               '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 @@ class Hashutil(BaseHashutil):
         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 @@ class Hashutil(BaseHashutil):
         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 @@ class Hashutil(BaseHashutil):
             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 @@ class Hashutil(BaseHashutil):
             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 @@ class Hashutil(BaseHashutil):
             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 @@ blah
                                           '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 @@ blah
         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 @@ blah
         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 @@ blah
         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
index 66586085..6496f06e 100644
--- a/swh/model/tests/test_identifiers.py
+++ b/swh/model/tests/test_identifiers.py
@@ -7,14 +7,11 @@ import binascii
 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 @@ class UtilityFunctionsIdentifier(unittest.TestCase):
         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 @@ class UtilityFunctionsIdentifier(unittest.TestCase):
 
         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 @@ class UtilityFunctionsDateOffset(unittest.TestCase):
             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 @@ class ContentIdentifier(unittest.TestCase):
 
         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 @@ class DirectoryIdentifier(unittest.TestCase):
             '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 @@ dg1KdHOa34shrKDaOVzW
             }
         }
 
-    @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 @@ dg1KdHOa34shrKDaOVzW
                 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 @@ dg1KdHOa34shrKDaOVzW
                 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 @@ dg1KdHOa34shrKDaOVzW
                 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 @@ dg1KdHOa34shrKDaOVzW
                 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 @@ o6X/3T+vm8K3bf3driRr34c=
             '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
index 66a8ee1c..174368f5 100644
--- 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
index 60a1de42..cb9a8d4c 100644
--- 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 @@ class TestValidators(unittest.TestCase):
         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)
 
-- 
GitLab