Switch to py.test #604

This commit is contained in:
Petr Viktorin 2011-05-02 10:20:28 +03:00
parent c710457717
commit 332647c362
10 changed files with 392 additions and 359 deletions

21
conftest.py Normal file
View file

@ -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)))

View file

@ -1,6 +1,45 @@
def setup():
# XXX This needs to recreate the database, someday. :(
pass
def teardown():
pass
import inspect
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

View file

@ -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

View file

@ -1,18 +1,12 @@
# encoding: utf8
from nose.tools import *
import unittest
# Encoding: UTF-8
from pokedex.tests import *
from pokedex.lookup import PokedexLookup
lookup = None
def setup():
# Recreate data
global lookup
lookup = PokedexLookup()
def test_exact_lookup():
tests = [
@positional_params(
# 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),
]
for input, table, id in tests:
)
def test_exact_lookup(input, table, id):
results = lookup.lookup(input)
assert_equal(len(results), 1, u"'%s' returns one result" % input)
assert_equal(results[0].exact, True, u"'%s' match exactly" % input)
assert len(results) == 1
assert results[0].exact == True
row = results[0].object
assert_equal(row.__tablename__, table, u"'%s' is in the right table" % input)
assert_equal(row.id, id, u"'%s' returns the right id" % input)
assert row.__tablename__ == table
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_true(all(_.object.id == 1 for _ in results),
u'All results have id 1')
assert len(results) >= 5
assert all(result.object.id == 1 for result in results)
def test_multi_lookup():
results = lookup.lookup(u'Metronome')
assert_equal(len(results), 2, u'Two things called "Metronome"')
assert_true(results[0].exact, u'Metronome matches are exact')
assert len(results) == 2
assert results[0].exact
def test_type_lookup():
results = lookup.lookup(u'pokemon:1')
assert_equal(results[0].object.__tablename__, 'pokemon_species',
u'Type restriction works correctly')
assert_equal(len(results), 1, u'Only one id result when type is specified')
assert_equal(results[0].object.name, u'Bulbasaur',
u'Type + id returns the right result')
assert results[0].object.__tablename__ == 'pokemon_species'
assert len(results) == 1
assert results[0].object.name == u'Bulbasaur'
results = lookup.lookup(u'1', valid_types=['pokemon_species'])
assert_equal(results[0].object.name, u'Bulbasaur',
u'valid_types works as well as type: prefix')
assert results[0].object.name == u'Bulbasaur'
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_equal(len(results), 1, u'Only one "charge" result when language is specified')
assert_equal(results[0].object.name, u'Tackle',
u'Language + vague name returns the right result')
assert results[0].iso639 == u'fr'
assert len(results) == 1
assert results[0].object.name == u'Tackle'
results = lookup.lookup(u'charge', valid_types=['@fr'])
assert_equal(results[0].object.name, u'Tackle',
u'valid_types works as well as @lang: prefix')
assert results[0].object.name == u'Tackle'
results = lookup.lookup(u'@fr,move:charge')
assert_equal(results[0].object.name, u'Tackle',
u'Languages and types both work together')
assert results[0].object.name == u'Tackle'
results = lookup.lookup(u'@fr:charge', valid_types=['move'])
assert_equal(results[0].object.name, u'Tackle',
u'valid_types and language prefixes get along')
assert results[0].object.name, u'Tackle'
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'),
]
for misspelling, name in tests:
)
def test_fuzzy_lookup(misspelling, name):
results = lookup.lookup(misspelling)
first_result = results[0]
assert_equal(first_result.object.name, name,
u'Simple misspellings are corrected')
assert first_result.object.name == name
def test_nidoran():
results = lookup.lookup(u'Nidoran')
top_names = [_.object.name for _ in results[0:2]]
assert_true(u'Nidoran♂' in top_names, u'Nidoran♂ is a top result for "Nidoran"')
assert_true(u'Nidoran♀' in top_names, u'Nidoran♀ is a top result for "Nidoran"')
top_names = [result.object.name for result in results[0:2]]
assert u'Nidoran♂' in top_names
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'),
]
for wildcard, name in tests:
)
def test_wildcard_lookup(wildcard, name):
results = lookup.lookup(wildcard)
first_result = results[0]
assert_equal(first_result.object.name, name,
u'Wildcards work correctly')
assert first_result.object.name == name
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_equal(results[0].object.__tablename__, table_name,
u'Constrained random returns result from the right table')
assert len(results) == 1
assert results[0].object.__tablename__ == table_name
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'

View file

@ -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')
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():
def test_totodile(root):
"""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():
def test_chimecho(root):
"""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():
def test_venonat(root):
"""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():
def test_arceus_icon(root):
"""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
@raises(ValueError)
def test_strict_castform():
def test_strict_castform(root):
"""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
@raises(ValueError)
def test_strict_exeggcute():
def test_strict_exeggcute(root):
"""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():
print 'Reading all filenames...'
def get_all_filenames(root):
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
def check_get_everything():
@pytest.mark.skipif("not config.getvalue('all')", reason='`--all` not specified')
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):
print
print '-----------------'
print 'Unaccessed stuff:'
for filename in sorted(filenames):
if unaccessed_filenames:
print 'Unaccessed files:'
for filename in unaccessed_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)

View file

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

View file

@ -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

View file

@ -1,24 +1,20 @@
# Encoding: UTF-8
from nose.tools import *
from sqlalchemy.orm.exc import NoResultFound
import pytest
from pokedex.tests import positional_params
from pokedex.db import tables, connect, util, markdown
class TestStrings(object):
def setup(self):
self.connection = connect()
connection = connect()
def teardown(self):
self.connection.rollback()
def test_filter(self):
q = self.connection.query(tables.PokemonSpecies).filter(
def test_filter():
q = connection.query(tables.PokemonSpecies).filter(
tables.PokemonSpecies.name == u"Marowak")
assert q.one().identifier == 'marowak'
def test_languages(self):
q = self.connection.query(tables.PokemonSpecies).filter(
def test_languages():
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(self):
q = self.connection.query(tables.PokemonSpecies).filter(
def test_bad_lang():
with pytest.raises(KeyError):
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):
item = self.connection.query(tables.Item).filter_by(
def test_mutating():
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):
item = self.connection.query(tables.Item).filter_by(
def test_mutating_default():
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):
item = self.connection.query(tables.Item).filter_by(
def test_string_mapping():
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):
item = self.connection.query(tables.Item).filter_by(
def test_new_language():
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):
move = self.connection.query(tables.Move).filter_by(
def test_markdown():
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):
en = util.get(self.connection, tables.Language, 'en')
md = markdown.MarkdownString('[]{move:thunderbolt} [paralyzes]{mechanic:paralysis}', self.connection, en)
def test_markdown_string():
en = util.get(connection, tables.Language, '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 self.check_markdown_column, tables.Move, None, 'short_effect'
yield tables.Move, None, '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

View file

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

View file

@ -1,7 +1,8 @@
# encoding: utf8
from nose.tools import *
import unittest
# Encoding: utf8
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():
for identifier in 'burmy shaymin unown cresselia'.split():
@single_params(*'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():
for name in 'Burmy Shaymin Unown Cresselia'.split():
@single_params(*'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'