Switch to py.test #604

conftest.py

@@ -0,0 +1,21 @@
+
+# Configuration for the tests.
+# Use `py.test` to run the tests.
+
+# (This file needs to be in or above the directory where py.test is called)
+
+import pytest
+import os
+
+def pytest_addoption(parser):
+    parser.addoption("--media-root", action="store",
+        default=None,
+        help="Root for the media files (if not specified and pokedex/data/media doesn't exist, tests are skipped)")
+    parser.addoption("--all", action="store_true", default=False,
+        help="Run all tests, even those that take a lot of time")
+
+def pytest_generate_tests(metafunc):
+    for funcargs in getattr(metafunc.function, 'funcarglist', ()):
+        metafunc.addcall(funcargs=funcargs)
+    for posargs in getattr(metafunc.function, 'posarglist', ()):
+        metafunc.addcall(funcargs=dict(zip(metafunc.funcargnames, posargs)))

pokedex/tests/__init__.py

@@ -1,6 +1,45 @@
-def setup():
-    # XXX This needs to recreate the database, someday.  :(
-    pass
 
-def teardown():
+import inspect
-    pass
+from functools import wraps
+
+# test support code
+def params(funcarglist):
+    """Basic list-of-dicts test parametrization
+
+    From: http://pytest.org/funcargs.html
+
+    Example:
+    @params([dict(a=1, b=2), dict(a=3, b=4)])
+    def test_lt(a, b):
+        assert a < b
+    """
+    def decorator(function):
+        function.funcarglist = funcarglist
+        return function
+    return decorator
+
+def positional_params(*paramlist):
+    """Magic list-of-lists parametrization
+
+    Example:
+    @params([(1, 2), (3, 4)])
+    def test_lt(a, b):
+        assert a < b
+    """
+    def decorator(function):
+        function.posarglist = paramlist
+        return function
+    return decorator
+
+def single_params(*paramlist):
+    """Magic list-of-lists parametrization
+
+    Example:
+    @params('1', '2', '3', '4'])
+    def test_int(k):
+        assert int(k)
+    """
+    def decorator(function):
+        function.posarglist = [[param] for param in paramlist]
+        return function
+    return decorator

pokedex/tests/test_database_sanity.py

@@ -1,5 +1,6 @@
-from nose.tools import *
+
-import unittest
+import pytest
+
 from sqlalchemy.orm import aliased
 from sqlalchemy.orm.exc import NoResultFound
 
@@ -21,8 +22,8 @@ def test_encounter_slots():
         .join((version_group_b, tables.Version.version_group)) \
         .filter(version_group_a.id != version_group_b.id)
 
-    assert_equal(sanity_q.count(), 0,
+    # Encounter slots all match the encounters they belong to
-        "Encounter slots all match the encounters they belong to")
+    assert sanity_q.count() == 0
 
 def test_nonzero_autoincrement_ids():
     """Check that autoincrementing ids don't contain zeroes
@@ -34,8 +35,8 @@ def test_nonzero_autoincrement_ids():
     for cls in tables.mapped_classes:
         if 'id' in cls.__table__.c:
             if cls.__table__.c.id.autoincrement:
-                @raises(NoResultFound)
                 def nonzero_id(cls):
+                    with pytest.raises(NoResultFound):
                         util.get(session, cls, id=0)
                 nonzero_id.description = "No zero id in %s" % cls.__name__
                 yield nonzero_id, cls

pokedex/tests/test_lookup.py

@@ -1,18 +1,12 @@
-# encoding: utf8
+# Encoding: UTF-8
-from nose.tools import *
+
-import unittest
+from pokedex.tests import *
 
 from pokedex.lookup import PokedexLookup
 
-lookup = None
+lookup = PokedexLookup()
 
-def setup():
+@positional_params(
-    # Recreate data
-    global lookup
-    lookup = PokedexLookup()
-
-def test_exact_lookup():
-    tests = [
         # Simple lookups
         (u'Eevee',          'pokemon_species',133),
         (u'Scratch',        'moves',        10),
@@ -37,68 +31,61 @@ def test_exact_lookup():
         (u'이브이',         'pokemon_species', 133),
         (u'伊布',           'pokemon_species', 133),
         (u'Evoli',          'pokemon_species', 133),
-    ]
+    )
-
+def test_exact_lookup(input, table, id):
-    for input, table, id in tests:
     results = lookup.lookup(input)
-        assert_equal(len(results), 1,           u"'%s' returns one result" % input)
+    assert len(results) == 1
-        assert_equal(results[0].exact, True,    u"'%s' match exactly" % input)
+    assert results[0].exact == True
 
     row = results[0].object
-        assert_equal(row.__tablename__, table,  u"'%s' is in the right table" % input)
+    assert row.__tablename__ == table
-        assert_equal(row.id, id,                u"'%s' returns the right id" % input)
+    assert row.id == id
 
 
 def test_id_lookup():
     results = lookup.lookup(u'1')
-    assert_true(len(results) >= 5,              u'At least five things have id 1')
+    assert len(results) >= 5
-    assert_true(all(_.object.id == 1 for _ in results),
+    assert all(result.object.id == 1 for result in results)
-                                                u'All results have id 1')
+
 
 def test_multi_lookup():
     results = lookup.lookup(u'Metronome')
-    assert_equal(len(results), 2,               u'Two things called "Metronome"')
+    assert len(results) == 2
-    assert_true(results[0].exact,               u'Metronome matches are exact')
+    assert results[0].exact
 
 
 def test_type_lookup():
     results = lookup.lookup(u'pokemon:1')
-    assert_equal(results[0].object.__tablename__, 'pokemon_species',
+    assert results[0].object.__tablename__ == 'pokemon_species'
-                                                u'Type restriction works correctly')
+    assert len(results) == 1
-    assert_equal(len(results), 1,               u'Only one id result when type is specified')
+    assert results[0].object.name == u'Bulbasaur'
-    assert_equal(results[0].object.name, u'Bulbasaur',
-                                                u'Type + id returns the right result')
 
     results = lookup.lookup(u'1', valid_types=['pokemon_species'])
-    assert_equal(results[0].object.name, u'Bulbasaur',
+    assert results[0].object.name == u'Bulbasaur'
-                                                u'valid_types works as well as type: prefix')
+
 
 def test_language_lookup():
     # There are two objects named "charge": the move Charge, and the move
     # Tackle, which is called "Charge" in French.
     results = lookup.lookup(u'charge')
-    assert_true(len(results) > 1,               u'There are multiple "charge"s')
+    assert len(results) > 1
 
     results = lookup.lookup(u'@fr:charge')
-    assert_equal(results[0].iso639, u'fr',      u'Language restriction works correctly')
+    assert results[0].iso639 == u'fr'
-    assert_equal(len(results), 1,               u'Only one "charge" result when language is specified')
+    assert len(results) == 1
-    assert_equal(results[0].object.name, u'Tackle',
+    assert results[0].object.name == u'Tackle'
-                                                u'Language + vague name returns the right result')
 
     results = lookup.lookup(u'charge', valid_types=['@fr'])
-    assert_equal(results[0].object.name, u'Tackle',
+    assert results[0].object.name == u'Tackle'
-                                                u'valid_types works as well as @lang: prefix')
 
     results = lookup.lookup(u'@fr,move:charge')
-    assert_equal(results[0].object.name, u'Tackle',
+    assert results[0].object.name == u'Tackle'
-                                                u'Languages and types both work together')
 
     results = lookup.lookup(u'@fr:charge', valid_types=['move'])
-    assert_equal(results[0].object.name, u'Tackle',
+    assert results[0].object.name, u'Tackle'
-                                                u'valid_types and language prefixes get along')
 
-def test_fuzzy_lookup():
+
-    tests = [
+@positional_params(
         # Regular English names
         (u'chamander',          u'Charmander'),
         (u'pokeball',           u'Poké Ball'),
@@ -110,44 +97,51 @@ def test_fuzzy_lookup():
         # Sufficiently long foreign names
         (u'カクレオ',           u'Kecleon'),
         (u'Yamikrasu',          u'Murkrow'),
-    ]
+    )
-
+def test_fuzzy_lookup(misspelling, name):
-    for misspelling, name in tests:
     results = lookup.lookup(misspelling)
     first_result = results[0]
-        assert_equal(first_result.object.name, name,
+    assert first_result.object.name == name
-                                                u'Simple misspellings are corrected')
 
+
+def test_nidoran():
     results = lookup.lookup(u'Nidoran')
-    top_names = [_.object.name for _ in results[0:2]]
+    top_names = [result.object.name for result in results[0:2]]
-    assert_true(u'Nidoran♂' in top_names,       u'Nidoran♂ is a top result for "Nidoran"')
+    assert u'Nidoran♂' in top_names
-    assert_true(u'Nidoran♀' in top_names,       u'Nidoran♀ is a top result for "Nidoran"')
+    assert u'Nidoran♀' in top_names
 
-def test_wildcard_lookup():
+
-    tests = [
+@positional_params(
         (u'pokemon:*meleon',    u'Charmeleon'),
         (u'item:master*',       u'Master Ball'),
         (u'ee?ee',              u'Eevee'),
-    ]
+    )
-
+def test_wildcard_lookup(wildcard, name):
-    for wildcard, name in tests:
     results = lookup.lookup(wildcard)
     first_result = results[0]
-        assert_equal(first_result.object.name, name,
+    assert first_result.object.name == name
-                                                u'Wildcards work correctly')
 
-def test_random_lookup():
+
-    for _ in xrange(5):
+def test_bare_random():
+    for i in range(5):
         results = lookup.lookup(u'random')
-        assert_equal(len(results), 1,           u'Random returns one result')
+        assert len(results) == 1
 
-    for table_name in [u'pokemon_species', u'moves', u'items', u'abilities', u'types']:
+
+@positional_params(
+        [u'pokemon_species'],
+        [u'moves'],
+        [u'items'],
+        [u'abilities'],
+        [u'types'],
+    )
+def test_qualified_random(table_name):
     results = lookup.lookup(u'random', valid_types=[table_name])
-        assert_equal(len(results), 1,           u'Constrained random returns one result')
+    assert len(results) == 1
-        assert_equal(results[0].object.__tablename__, table_name,
+    assert results[0].object.__tablename__ == table_name
-                                                u'Constrained random returns result from the right table')
+
 
 def test_crash_empty_prefix():
     """Searching for ':foo' used to crash, augh!"""
     results = lookup.lookup(u':Eevee')
-    assert_equal(results[0].object.name, u'Eevee', u'Empty prefix dun crash')
+    assert results[0].object.name == u'Eevee'

pokedex/tests/test_media.py

@@ -1,4 +1,3 @@
-
 """Test the media accessors.
 
 If run directly from the command line, also tests the accessors and the names
@@ -6,45 +5,33 @@ of all the media by getting just about everything in a naive brute-force way.
 This, of course, takes a lot of time to run.
 """
 
+import pytest
+
 import os
 import re
-from functools import wraps
-
-from nose.tools import *
-from nose.plugins.skip import SkipTest
-import nose
-import pkg_resources
 
 from pokedex.db import tables, connect
 from pokedex.util import media
 
+def pytest_funcarg__root(request):
+    root = request.config.option.media_root
+    if not root:
+        root = os.path.join(os.path.dirname(__file__), *'../data/media'.split('/'))
+        if not media.BaseMedia(root).available:
+            raise pytest.skip("Media unavailable")
+    return root
+
 session = connect()
-basedir = pkg_resources.resource_filename('pokedex', 'data/media')
 
 path_re = re.compile('^[-a-z0-9./]*$')
 
-root = pkg_resources.resource_filename('pokedex', 'data/media')
+def test_totodile(root):
-
-media_available = media.BaseMedia(root).available
-
-def if_available(func):
-    @wraps(func)
-    def if_available_wrapper(*args, **kwargs):
-        if not media_available:
-            raise SkipTest('Media not available at %s' % root)
-        else:
-            func(*args, **kwargs)
-    return if_available_wrapper
-
-@if_available
-def test_totodile():
     """Totodile's female sprite -- same as male"""
     totodile = session.query(tables.PokemonSpecies).filter_by(identifier=u'totodile').one()
     accessor = media.PokemonSpeciesMedia(root, totodile)
     assert accessor.sprite() == accessor.sprite(female=True)
 
-@if_available
+def test_chimecho(root):
-def test_chimecho():
     """Chimecho's Platinum female backsprite -- diffeent from male"""
     chimecho = session.query(tables.PokemonSpecies).filter_by(identifier=u'chimecho').one()
     accessor = media.PokemonSpeciesMedia(root, chimecho)
@@ -52,15 +39,13 @@ def test_chimecho():
     female = accessor.sprite('platinum', back=True, female=True, frame=2)
     assert male != female
 
-@if_available
+def test_venonat(root):
-def test_venonat():
     """Venonat's shiny Yellow sprite -- same as non-shiny"""
     venonat = session.query(tables.PokemonSpecies).filter_by(identifier=u'venonat').one()
     accessor = media.PokemonSpeciesMedia(root, venonat)
     assert accessor.sprite('yellow') == accessor.sprite('yellow', shiny=True)
 
-@if_available
+def test_arceus_icon(root):
-def test_arceus_icon():
     """Arceus fire-form icon -- same as base icon"""
     arceus = session.query(tables.PokemonSpecies).filter_by(identifier=u'arceus').one()
     accessor = media.PokemonSpeciesMedia(root, arceus)
@@ -68,32 +53,28 @@ def test_arceus_icon():
     fire_accessor = media.PokemonFormMedia(root, fire_arceus)
     assert accessor.icon() == fire_accessor.icon()
 
-@if_available
+def test_strict_castform(root):
-@raises(ValueError)
-def test_strict_castform():
     """Castform rainy form overworld with strict -- unavailable"""
+    with pytest.raises(ValueError):
         castform = session.query(tables.PokemonSpecies).filter_by(identifier=u'castform').first()
         rainy_castform = [f for f in castform.forms if f.form_identifier == 'rainy'][0]
         print rainy_castform
         rainy_castform = media.PokemonFormMedia(root, rainy_castform)
         rainy_castform.overworld('up', strict=True)
 
-@if_available
+def test_strict_exeggcute(root):
-@raises(ValueError)
-def test_strict_exeggcute():
     """Exeggcutes's female backsprite, with strict -- unavailable"""
+    with pytest.raises(ValueError):
         exeggcute = session.query(tables.PokemonSpecies).filter_by(identifier=u'exeggcute').one()
         accessor = media.PokemonSpeciesMedia(root, exeggcute)
         accessor.sprite(female=True, strict=True)
 
 
 
-def get_all_filenames():
+def get_all_filenames(root):
-    print 'Reading all filenames...'
-
     all_filenames = set()
 
-    for dirpath, dirnames, filenames in os.walk(basedir):
+    for dirpath, dirnames, filenames in os.walk(root):
         dirnames[:] = [dirname for dirname in dirnames if dirname != '.git']
         for filename in filenames:
             path = os.path.join(dirpath, filename)
@@ -123,8 +104,8 @@ def hit(filenames, method, *args, **kwargs):
         pass
     return True
 
-@if_available
+@pytest.mark.skipif("not config.getvalue('all')", reason='`--all` not specified')
-def check_get_everything():
+def test_get_everything(root, pytestconfig):
     """
     For every the accessor method, loop over the Cartesian products of all
     possible values for its arguments.
@@ -133,13 +114,14 @@ def check_get_everything():
 
     Well, there are exceptions of course.
     """
+    assert pytestconfig.getvalue('all')
 
     versions = list(session.query(tables.Version).all())
     versions.append('red-green')
 
     black = session.query(tables.Version).filter_by(identifier=u'black').one()
 
-    filenames = get_all_filenames()
+    filenames = get_all_filenames(root)
 
     # Some small stuff first
 
@@ -252,26 +234,21 @@ def check_get_everything():
                                         assert success
 
     # Remove exceptions
-    exceptions = [os.path.join(basedir, dirname) for dirname in
+    exceptions = [os.path.join(root, dirname) for dirname in
             'chrome fonts ribbons'.split()]
-    exceptions.append(os.path.join(basedir, 'items', 'hm-'))
+    exceptions.append(os.path.join(root, 'items', 'hm-'))
     exceptions = tuple(exceptions)
 
-    for filename in tuple(filenames):
+    unaccessed_filenames = set(filenames)
+    for filename in filenames:
         if filename.startswith(exceptions):
-            filenames.remove(filename)
+            unaccessed_filenames.remove(filename)
 
-    if len(filenames):
+    if unaccessed_filenames:
-        print
+        print 'Unaccessed files:'
-        print '-----------------'
+        for filename in unaccessed_filenames:
-        print 'Unaccessed stuff:'
-        for filename in sorted(filenames):
             print filename
-        print len(filenames), 'unaccessed files :('
+
+    assert unaccessed_filenames == set()
 
     return (not filenames)
-
-if __name__ == '__main__':
-    result = nose.run(defaultTest=__file__)
-    result = result and check_get_everything()
-    exit(not result)

pokedex/tests/test_roomaji.py

@@ -1,12 +1,9 @@
 # encoding: utf8
-from nose.tools import *
-import unittest
 
 import pokedex.roomaji
+from pokedex.tests import positional_params
 
-
+@positional_params(
-def test_roomaji():
-    tests = [
         (u'ヤミカラス',         'yamikarasu'),
 
         # Elongated vowel
@@ -24,14 +21,13 @@ def test_roomaji():
         (u'ラティアス',         'ratiasu'),
         (u'ウィー',             'wii'),
         (u'セレビィ',           'sereby'),
-    ]
+    )
-
+def test_roomaji(kana, roomaji):
-    for kana, roomaji in tests:
     result = pokedex.roomaji.romanize(kana)
-        assert_equal(result, roomaji, u"'%s' romanizes correctly" % roomaji)
+    assert result == roomaji
 
-def test_roomaji_cs():
+
-    tests = [
+@positional_params(
         (u'ヤミカラス',         u'jamikarasu'),
 
         # Elongated vowel
@@ -49,8 +45,7 @@ def test_roomaji_cs():
         (u'ラティアス',         u'ratiasu'),
         (u'ウィー',             u'wí'),
         (u'セレビィ',           u'serebí'),
-    ]
+    )
-
+def test_roomaji_cs(kana, roomaji):
-    for kana, roomaji in tests:
     result = pokedex.roomaji.romanize(kana, 'cs')
-        assert_equal(result, roomaji, u"'%s' romanizes correctly for Czech" % roomaji)
+    assert result == roomaji

pokedex/tests/test_schema.py

@@ -1,6 +1,7 @@
 # encoding: utf8
-from nose.tools import *
+
-import unittest
+from pokedex.tests import single_params
+
 from sqlalchemy import Column, Integer, String, create_engine
 from sqlalchemy.orm import class_mapper, joinedload, sessionmaker
 from sqlalchemy.orm.session import Session
@@ -10,21 +11,22 @@ from pokedex.db import tables, markdown
 from pokedex.db.multilang import MultilangScopedSession, MultilangSession, \
     create_translation_table
 
-def test_variable_names():
+@single_params(*dir(tables))
+def test_variable_names(varname):
     """We want pokedex.db.tables to export tables using the class name"""
-    for varname in dir(tables):
-        if not varname[0].isupper():
-            continue
     table = getattr(tables, varname)
     try:
         if not issubclass(table, tables.TableBase) or table is tables.TableBase:
-                continue
+            return
     except TypeError:
-            continue
+        return
     classname = table.__name__
     if classname and varname[0].isupper():
         assert varname == classname, '%s refers to %s' % (varname, classname)
-    for table in tables.mapped_classes:
+
+@single_params(*tables.mapped_classes)
+def test_variable_names_2(table):
+    """We also want all of the tables exported"""
     assert getattr(tables, table.__name__) is table
 
 def test_class_order():
@@ -156,17 +158,17 @@ def test_i18n_table_creation():
     assert foo.name_map[lang_en] == 'different english'
     assert foo.name_map[lang_ru] == 'new russian'
 
-def test_texts():
+classes = []
+for cls in tables.mapped_classes:
+    classes.append(cls)
+    classes += cls.translation_classes
+@single_params(*classes)
+def test_texts(cls):
     """Check DB schema for integrity of text columns & translations.
 
     Mostly protects against copy/paste oversights and rebase hiccups.
     If there's a reason to relax the tests, do it
     """
-    classes = []
-    for cls in tables.mapped_classes:
-        classes.append(cls)
-        classes += cls.translation_classes
-    for cls in classes:
     if hasattr(cls, 'local_language') or hasattr(cls, 'language'):
         good_formats = 'markdown plaintext gametext'.split()
         assert_text = '%s is language-specific'
@@ -198,10 +200,10 @@ def test_texts():
         for column in text_columns:
             assert column.nullable
 
-def test_identifiers_with_names():
+@single_params(*tables.mapped_classes)
+def test_identifiers_with_names(table):
     """Test that named tables have identifiers
     """
-    for table in sorted(tables.mapped_classes, key=lambda t: t.__name__):
     for translation_class in table.translation_classes:
         if hasattr(translation_class, 'name'):
             assert hasattr(table, 'identifier'), table

pokedex/tests/test_strings.py

@@ -1,24 +1,20 @@
 # Encoding: UTF-8
 
-from nose.tools import *
+import pytest
-from sqlalchemy.orm.exc import NoResultFound
+
+from pokedex.tests import positional_params
 
 from pokedex.db import tables, connect, util, markdown
 
-class TestStrings(object):
+connection = connect()
-    def setup(self):
-        self.connection = connect()
 
-    def teardown(self):
+def test_filter():
-        self.connection.rollback()
+    q = connection.query(tables.PokemonSpecies).filter(
-
-    def test_filter(self):
-        q = self.connection.query(tables.PokemonSpecies).filter(
             tables.PokemonSpecies.name == u"Marowak")
     assert q.one().identifier == 'marowak'
 
-    def test_languages(self):
+def test_languages():
-        q = self.connection.query(tables.PokemonSpecies).filter(
+    q = connection.query(tables.PokemonSpecies).filter(
             tables.PokemonSpecies.name == u"Mightyena")
     pkmn = q.one()
     for lang, name in (
@@ -27,35 +23,35 @@ class TestStrings(object):
             ('roomaji', u'Guraena'),
             ('fr', u'Grahyèna'),
         ):
-            language = self.connection.query(tables.Language).filter_by(
+        language = connection.query(tables.Language).filter_by(
                 identifier=lang).one()
         assert pkmn.name_map[language] == name
 
-    @raises(KeyError)
+def test_bad_lang():
-    def test_bad_lang(self):
+    with pytest.raises(KeyError):
-        q = self.connection.query(tables.PokemonSpecies).filter(
+        q = connection.query(tables.PokemonSpecies).filter(
                 tables.PokemonSpecies.name == u"Mightyena")
         pkmn = q.one()
         pkmn.names["identifier of a language that doesn't exist"]
 
-    def test_mutating(self):
+def test_mutating():
-        item = self.connection.query(tables.Item).filter_by(
+    item = connection.query(tables.Item).filter_by(
             identifier=u"jade-orb").one()
-        language = self.connection.query(tables.Language).filter_by(
+    language = connection.query(tables.Language).filter_by(
             identifier=u"de").one()
     item.name_map[language] = u"foo"
     assert item.name_map[language] == "foo"
     item.name_map[language] = u"xyzzy"
     assert item.name_map[language] == "xyzzy"
 
-    def test_mutating_default(self):
+def test_mutating_default():
-        item = self.connection.query(tables.Item).filter_by(
+    item = connection.query(tables.Item).filter_by(
             identifier=u"jade-orb").one()
     item.name = u"foo"
     assert item.name == "foo"
 
-    def test_string_mapping(self):
+def test_string_mapping():
-        item = self.connection.query(tables.Item).filter_by(
+    item = connection.query(tables.Item).filter_by(
             identifier=u"jade-orb").one()
     assert len(item.name_map) == len(item.names)
     for lang in item.names:
@@ -64,25 +60,25 @@ class TestStrings(object):
     assert "language that doesn't exist" not in item.name_map
     assert tables.Language() not in item.name_map
 
-    def test_new_language(self):
+def test_new_language():
-        item = self.connection.query(tables.Item).filter_by(
+    item = connection.query(tables.Item).filter_by(
             identifier=u"jade-orb").one()
     language = tables.Language()
     language.id = -1
     language.identifier = u'test'
     language.iso639 = language.iso3166 = u'--'
     language.official = False
-        self.connection.add(language)
+    connection.add(language)
     item.name_map[language] = u"foo"
     assert item.name_map[language] == "foo"
     assert language in item.name_map
     item.name_map[language] = u"xyzzy"
     assert item.name_map[language] == "xyzzy"
 
-    def test_markdown(self):
+def test_markdown():
-        move = self.connection.query(tables.Move).filter_by(
+    move = connection.query(tables.Move).filter_by(
             identifier=u"thunderbolt").one()
-        language = self.connection.query(tables.Language).filter_by(
+    language = connection.query(tables.Language).filter_by(
             identifier=u"en").one()
     assert '10%' in move.effect.as_text()
     assert '10%' in move.effect_map[language].as_text()
@@ -93,9 +89,9 @@ class TestStrings(object):
     assert '10%' in move.effect.__html__()
     assert '10%' in move.effect_map[language].__html__()
 
-    def test_markdown_string(self):
+def test_markdown_string():
-        en = util.get(self.connection, tables.Language, 'en')
+    en = util.get(connection, tables.Language, 'en')
-        md = markdown.MarkdownString('[]{move:thunderbolt} [paralyzes]{mechanic:paralysis}', self.connection, en)
+    md = markdown.MarkdownString('[]{move:thunderbolt} [paralyzes]{mechanic:paralysis}', connection, en)
     assert unicode(md) == 'Thunderbolt paralyzes'
     assert md.as_html() == '<p><span>Thunderbolt</span> <span>paralyzes</span></p>'
     assert md.as_html(object_url=lambda category, obj: "%s/%s" % (category, obj.identifier)) == (
@@ -104,7 +100,7 @@ class TestStrings(object):
     assert md.as_html(identifier_url=lambda category, ident: "%s/%s" % (category, ident)) == (
             '<p><a href="move/thunderbolt">Thunderbolt</a> <a href="mechanic/paralysis">paralyzes</a></p>')
 
-    def test_markdown_values(self):
+def markdown_column_params():
     """Check all markdown values
 
     Scans the database schema for Markdown columns, runs through every value
@@ -112,18 +108,19 @@ class TestStrings(object):
     """
 
     # Move effects have their own special wrappers.  Explicitly test them separately
-        yield self.check_markdown_column, tables.Move, None, 'effect'
+    yield tables.Move, None, 'effect'
-        yield self.check_markdown_column, tables.Move, None, 'short_effect'
+    yield tables.Move, None, 'short_effect'
 
     for cls in tables.mapped_classes:
         for translation_cls in cls.translation_classes:
             for column in translation_cls.__table__.c:
                 if column.info.get('string_getter') == markdown.MarkdownString:
-                        yield self.check_markdown_column, cls, translation_cls, column.name
+                    yield cls, translation_cls, column.name
 
-    def check_markdown_column(self, parent_class, translation_class, column_name):
+@positional_params(*markdown_column_params())
+def test_markdown_values(parent_class, translation_class, column_name):
     """Implementation for the above"""
-        query = self.connection.query(parent_class)
+    query = connection.query(parent_class)
     if translation_class:
         query = query.join(translation_class)
     for item in query:
@@ -147,4 +144,4 @@ class TestStrings(object):
             error_message = u"{0} leaves syntax cruft:\n{1}"
             error_message = error_message.format(key, text)
 
-                ok_(not any(char in text for char in '[]{}'), error_message)
+            assert not any(char in text for char in '[]{}'), error_message

pokedex/tests/test_translations.py

@@ -2,7 +2,7 @@
 
 import csv
 
-from nose.tools import *
+import pytest
 
 from pokedex.db import translations, tables
 

pokedex/tests/test_util.py

@@ -1,7 +1,8 @@
-# encoding: utf8
+# Encoding: utf8
-from nose.tools import *
-import unittest
 
+import pytest
+
+from pokedex.tests import single_params
 from pokedex.db import connect, tables, util
 
 session = connect()
@@ -18,19 +19,19 @@ def test_get_english_by_identifier():
     language = util.get(session, tables.Language, 'en')
     assert language.name == 'English'
 
-def test_get_pokemon_identifier():
+@single_params(*'burmy shaymin unown cresselia'.split())
-    for identifier in 'burmy shaymin unown cresselia'.split():
+def test_get_pokemon_identifier(identifier):
     poke = util.get(session, tables.PokemonSpecies, identifier=identifier)
     assert poke.identifier == identifier
 
-def test_get_pokemon_name():
+@single_params(*'Burmy Shaymin Unown Cresselia'.split())
-    for name in 'Burmy Shaymin Unown Cresselia'.split():
+def test_get_pokemon_name(name):
     poke = util.get(session, tables.PokemonSpecies, name=name)
     assert poke.name == name
 
-def test_get_pokemon_name_explicit_language():
+@single_params(*'Cheniti Shaymin Zarbi Cresselia'.split())
+def test_get_pokemon_name_explicit_language(name):
     french = util.get(session, tables.Language, 'fr')
-    for name in 'Cheniti Shaymin Zarbi Cresselia'.split():
     poke = util.get(session, tables.PokemonSpecies, name=name, language=french)
     assert poke.name_map[french] == name, poke.name_map[french]
 
@@ -40,3 +41,9 @@ def test_types_french_order():
     types = list(util.order_by_name(types, tables.Type, language=french))
     assert types[0].name_map[french] == 'Acier', types[0].name_map[french]
     assert types[-1].name_map[french] == 'Vol', types[-1].name_map[french]
+
+@single_params(*range(1, 10) * 2)
+def test_get_pokemon_id(id):
+    result = util.get(session, tables.Pokemon, id=id)
+    assert result.id == id
+    assert result.__tablename__ == 'pokemon'