finn/dominiontabs
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Test language tool run (#192)

Browse Source 
* switch to pytest
* add language tool test
This commit is contained in:
Peter 2018-02-19 13:38:30 -08:00 committed by GitHub
parent 1ddb09bd54
commit 0ffa111025
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 443 additions and 377 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.travis.yml
View File

@ -7,4 +7,4 @@ install:
- pip install -U pycodestyle - pip install -U pycodestyle
- pip install . - pip install .
# command to run tests # command to run tests
script: nosetests script: py.test

138
domdiv/tests/carddb_tests.py
View File

@ -1,58 +1,96 @@
import unittest from __future__ import print_function
import subprocess
import shutil
import os
import contextlib
import pytest
from .. import main from .. import main
from .. import cards as domdiv_cards from .. import cards as domdiv_cards
class TestCardDB(unittest.TestCase): @pytest.fixture
def rmtestcardb(request):
def test_cardread(self): def rmd():
options = main.parse_opts([]) testcardb_dir = os.path.join(str(request.config.rootdir), 'tools/card_db')
if os.path.exists(testcardb_dir):
print('removing {}'.format(testcardb_dir))
shutil.rmtree(testcardb_dir)
request.addfinalizer(rmd)
def test_cardread():
options = main.parse_opts([])
options.data_path = '.'
cards = main.read_card_data(options)
assert len(cards) == 524
valid_cardsets = {
u'base',
u'dominion1stEdition',
u'dominion2ndEdition',
u'dominion2ndEditionUpgrade',
u'intrigue1stEdition',
u'intrigue2ndEdition',
u'intrigue2ndEditionUpgrade',
u'seaside',
u'alchemy',
u'prosperity',
u'cornucopia extras',
u'cornucopia',
u'hinterlands',
u'dark ages',
u'dark ages extras',
u'guilds',
u'adventures',
u'adventures extras',
u'empires',
u'empires extras',
u'nocturne',
u'nocturne extras',
u'promo',
u'extras',
u'animals'
}
for c in cards:
assert isinstance(c, domdiv_cards.Card)
assert c.cardset_tag in valid_cardsets
def test_languages():
languages = main.get_languages('card_db')
for lang in languages:
print('checking ' + lang)
# for now, just test that they load
options = main.parse_opts(['--language', lang])
options.data_path = '.' options.data_path = '.'
cards = main.read_card_data(options) cards = main.read_card_data(options)
self.assertEquals(len(cards), 524) assert cards, '"{}" cards did not read properly'.format(lang)
valid_cardsets = { cards = main.add_card_text(options, cards, 'en_us')
u'base', cards = main.add_card_text(options, cards, lang)
u'dominion1stEdition', if lang == 'it':
u'dominion2ndEdition', assert "Maledizione" in [card.name for card in cards]
u'dominion2ndEditionUpgrade', elif lang == 'de':
u'intrigue1stEdition', assert "Fluch" in [card.name for card in cards]
u'intrigue2ndEdition',
u'intrigue2ndEditionUpgrade',
u'seaside',
u'alchemy',
u'prosperity',
u'cornucopia extras',
u'cornucopia',
u'hinterlands',
u'dark ages',
u'dark ages extras',
u'guilds',
u'adventures',
u'adventures extras',
u'empires',
u'empires extras',
u'nocturne',
u'nocturne extras',
u'promo',
u'extras',
u'animals'
}
for c in cards:
self.assertIsInstance(c, domdiv_cards.Card)
self.assertIn(c.cardset_tag, valid_cardsets)
def test_languages(self):
languages = main.get_languages('card_db') @contextlib.contextmanager
for lang in languages: def change_cwd(d):
print('checking ' + lang) curdir = os.getcwd()
# for now, just test that they load try:
options = main.parse_opts(['--language', lang]) os.chdir(d)
options.data_path = '.' yield
cards = main.read_card_data(options) finally:
self.assertTrue(cards, '"{}" cards did not read properly'.format(lang)) os.chdir(curdir)
cards = main.add_card_text(options, cards, 'en_us')
cards = main.add_card_text(options, cards, lang)
if lang == 'it': def test_languagetool_run(pytestconfig):
self.assertIn("Maledizione", [card.name for card in cards]) with change_cwd(str(pytestconfig.rootdir)):
elif lang == 'de': cmd = 'python tools/update_language.py'
self.assertIn("Fluch", [card.name for card in cards]) print(cmd)
assert subprocess.check_call(cmd.split()) == 0
cmd = 'diff -rw domdiv/card_db tools/card_db'
out = subprocess.check_output(cmd.split(), stderr=subprocess.STDOUT)
print(out)
assert out == ''

15
domdiv/tests/codestyle_tests.py
View File

@ -1,13 +1,10 @@
import unittest
import pycodestyle
import glob import glob
import pycodestyle
class TestCodeFormat(unittest.TestCase):
def test_conformance(self): def test_conformance():
"""Test that we conform to PEP-8.""" """Test that we conform to PEP-8."""
style = pycodestyle.StyleGuide(max_line_length=120) style = pycodestyle.StyleGuide(max_line_length=120)
result = style.check_files(glob.glob('*.py') + glob.glob('domdiv/*.py') + glob.glob('tests/*.py')) result = style.check_files(glob.glob('*.py') + glob.glob('domdiv/*.py') + glob.glob('tests/*.py'))
self.assertEqual(result.total_errors, 0, assert result.total_errors == 0, "Found code style errors (and warnings)."
"Found code style errors (and warnings).")

56
domdiv/tests/layout_tests.py
View File

@ -1,34 +1,34 @@
import unittest
from .. import main
from reportlab.lib.units import cm from reportlab.lib.units import cm
from .. import main
class TestLayout(unittest.TestCase):
def test_horizontal(self): def test_horizontal():
# should be the default # should be the default
options = main.parse_opts([]) options = main.parse_opts([])
self.assertEquals(options.orientation, 'horizontal') assert options.orientation == 'horizontal'
main.calculate_layout(options) main.calculate_layout(options)
self.assertEquals(options.numDividersHorizontal, 2) assert options.numDividersHorizontal == 2
self.assertEquals(options.numDividersVertical, 3) assert options.numDividersVertical == 3
self.assertEquals(options.dividerWidth, 9.1 * cm) assert options.dividerWidth == 9.1 * cm
self.assertEquals(options.labelHeight, 0.9 * cm) assert options.labelHeight == 0.9 * cm
self.assertEquals(options.dividerHeight, 5.9 * cm + options.labelHeight) assert options.dividerHeight == 5.9 * cm + options.labelHeight
def test_vertical(self):
options = main.parse_opts(['--orientation', 'vertical'])
self.assertEquals(options.orientation, 'vertical')
main.calculate_layout(options)
self.assertEquals(options.numDividersHorizontal, 3)
self.assertEquals(options.numDividersVertical, 2)
self.assertEquals(options.dividerWidth, 5.9 * cm)
self.assertEquals(options.labelHeight, 0.9 * cm)
self.assertEquals(options.dividerHeight, 9.1 * cm + options.labelHeight)
def test_sleeved(self): def test_vertical():
options = main.parse_opts(['--size', 'sleeved']) options = main.parse_opts(['--orientation', 'vertical'])
main.calculate_layout(options) assert options.orientation == 'vertical'
self.assertEquals(options.dividerWidth, 9.4 * cm) main.calculate_layout(options)
self.assertEquals(options.labelHeight, 0.9 * cm) assert options.numDividersHorizontal == 3
self.assertEquals(options.dividerHeight, 6.15 * cm + options.labelHeight) assert options.numDividersVertical == 2
assert options.dividerWidth == 5.9 * cm
assert options.labelHeight == 0.9 * cm
assert options.dividerHeight == 9.1 * cm + options.labelHeight
def test_sleeved():
options = main.parse_opts(['--size', 'sleeved'])
main.calculate_layout(options)
assert options.dividerWidth == 9.4 * cm
assert options.labelHeight == 0.9 * cm
assert options.dividerHeight == 6.15 * cm + options.labelHeight

547
domdiv/tests/text_tab_tests.py
View File

@ -1,300 +1,321 @@
import unittest
from .. import main from .. import main
class TestTextTabs(unittest.TestCase): ####################
# Card Text and Tab Default Test
####################
def test_text_tabs_default():
# should be the default
options = main.parse_opts([])
assert options.text_front == 'card'
assert options.text_back == 'rules'
assert options.tab_name_align == 'left'
assert options.tab_side == 'right-alternate'
main.calculate_layout(options)
assert options.tab_name_align == 'left'
#################### ####################
# Card Text and Tab Default Test # Card Text Tests
#################### ####################
def test_text_tabs_default(self):
# should be the default
options = main.parse_opts([])
self.assertEquals(options.text_front, 'card')
self.assertEquals(options.text_back, 'rules')
self.assertEquals(options.tab_name_align, 'left')
self.assertEquals(options.tab_side, 'right-alternate')
main.calculate_layout(options)
self.assertEquals(options.tab_name_align, 'left')
####################
# Card Text Tests
####################
def test_text_card_rules(self):
options = main.parse_opts(
['--front', 'card', '--back', 'rules'])
self.assertEquals(options.text_front, 'card')
self.assertEquals(options.text_back, 'rules')
def test_text_card_blank(self): def test_text_card_rules():
options = main.parse_opts( options = main.parse_opts(
['--front', 'card', '--back', 'blank']) ['--front', 'card', '--back', 'rules'])
self.assertEquals(options.text_front, 'card') assert options.text_front == 'card'
self.assertEquals(options.text_back, 'blank') assert options.text_back == 'rules'
def test_text_card_card(self):
options = main.parse_opts(
['--front', 'card', '--back', 'card'])
self.assertEquals(options.text_front, 'card')
self.assertEquals(options.text_back, 'card')
def test_text_card_none(self): def test_text_card_blank():
options = main.parse_opts( options = main.parse_opts(
['--front', 'card', '--back', 'none']) ['--front', 'card', '--back', 'blank'])
self.assertEquals(options.text_front, 'card') assert options.text_front == 'card'
self.assertEquals(options.text_back, 'none') assert options.text_back == 'blank'
def test_text_rules_rules(self):
options = main.parse_opts(
['--front', 'rules', '--back', 'rules'])
self.assertEquals(options.text_front, 'rules')
self.assertEquals(options.text_back, 'rules')
def test_text_rules_blank(self): def test_text_card_card():
options = main.parse_opts( options = main.parse_opts(
['--front', 'rules', '--back', 'blank']) ['--front', 'card', '--back', 'card'])
self.assertEquals(options.text_front, 'rules') assert options.text_front == 'card'
self.assertEquals(options.text_back, 'blank') assert options.text_back == 'card'
def test_text_rules_card(self):
options = main.parse_opts(
['--front', 'rules', '--back', 'card'])
self.assertEquals(options.text_front, 'rules')
self.assertEquals(options.text_back, 'card')
def test_text_rules_none(self): def test_text_card_none():
options = main.parse_opts( options = main.parse_opts(
['--front', 'rules', '--back', 'none']) ['--front', 'card', '--back', 'none'])
self.assertEquals(options.text_front, 'rules') assert options.text_front == 'card'
self.assertEquals(options.text_back, 'none') assert options.text_back == 'none'
def test_text_blank_rules(self):
options = main.parse_opts(
['--front', 'blank', '--back', 'rules'])
self.assertEquals(options.text_front, 'blank')
self.assertEquals(options.text_back, 'rules')
def test_text_blank_blank(self): def test_text_rules_rules():
options = main.parse_opts( options = main.parse_opts(
['--front', 'blank', '--back', 'blank']) ['--front', 'rules', '--back', 'rules'])
self.assertEquals(options.text_front, 'blank') assert options.text_front == 'rules'
self.assertEquals(options.text_back, 'blank') assert options.text_back == 'rules'
def test_text_blank_card(self):
options = main.parse_opts(
['--front', 'blank', '--back', 'card'])
self.assertEquals(options.text_front, 'blank')
self.assertEquals(options.text_back, 'card')
def test_text_blank_none(self): def test_text_rules_blank():
options = main.parse_opts( options = main.parse_opts(
['--front', 'blank', '--back', 'none']) ['--front', 'rules', '--back', 'blank'])
self.assertEquals(options.text_front, 'blank') assert options.text_front == 'rules'
self.assertEquals(options.text_back, 'none') assert options.text_back == 'blank'
####################
# Card Tab Tests
####################
# --tab_name_align left
def test_tab_left_left(self):
options = main.parse_opts(
['--tab-name-align', 'left', '--tab-side', 'left'])
self.assertEquals(options.tab_name_align, 'left')
self.assertEquals(options.tab_side, 'left')
main.calculate_layout(options)
self.assertEquals(options.tab_name_align, 'left')
self.assertEquals(options.tab_side, 'left')
def test_tab_left_right(self): def test_text_rules_card():
options = main.parse_opts( options = main.parse_opts(
['--tab-name-align', 'left', '--tab-side', 'right']) ['--front', 'rules', '--back', 'card'])
self.assertEquals(options.tab_name_align, 'left') assert options.text_front == 'rules'
self.assertEquals(options.tab_side, 'right') assert options.text_back == 'card'
main.calculate_layout(options)
self.assertEquals(options.tab_name_align, 'left')
self.assertEquals(options.tab_side, 'right')
def test_tab_left_leftalt(self):
options = main.parse_opts(
['--tab-name-align', 'left', '--tab-side',
'left-alternate'])
self.assertEquals(options.tab_name_align, 'left')
self.assertEquals(options.tab_side, 'left-alternate')
main.calculate_layout(options)
self.assertEquals(options.tab_name_align, 'left')
self.assertEquals(options.tab_side, 'left-alternate')
def test_tab_left_rightalt(self): def test_text_rules_none():
options = main.parse_opts( options = main.parse_opts(
['--tab-name-align', 'left', '--tab-side', ['--front', 'rules', '--back', 'none'])
'right-alternate']) assert options.text_front == 'rules'
self.assertEquals(options.tab_name_align, 'left') assert options.text_back == 'none'
self.assertEquals(options.tab_side, 'right-alternate')
main.calculate_layout(options)
self.assertEquals(options.tab_name_align, 'left')
self.assertEquals(options.tab_side, 'right-alternate')
def test_tab_left_full(self):
options = main.parse_opts(
['--tab-name-align', 'left', '--tab-side', 'full'])
self.assertEquals(options.tab_name_align, 'left')
self.assertEquals(options.tab_side, 'full')
main.calculate_layout(options)
self.assertEquals(options.tab_name_align, 'left')
self.assertEquals(options.tab_side, 'full')
# --tab_name_align right def test_text_blank_rules():
def test_tab_right_left(self): options = main.parse_opts(
options = main.parse_opts( ['--front', 'blank', '--back', 'rules'])
['--tab-name-align', 'right', '--tab-side', 'left']) assert options.text_front == 'blank'
self.assertEquals(options.tab_name_align, 'right') assert options.text_back == 'rules'
self.assertEquals(options.tab_side, 'left')
main.calculate_layout(options)
self.assertEquals(options.tab_name_align, 'right')
self.assertEquals(options.tab_side, 'left')
def test_tab_right_right(self):
options = main.parse_opts(['--tab-name-align',
'right', '--tab-side', 'right'])
self.assertEquals(options.tab_name_align, 'right')
self.assertEquals(options.tab_side, 'right')
main.calculate_layout(options)
self.assertEquals(options.tab_name_align, 'right')
self.assertEquals(options.tab_side, 'right')
def test_tab_right_leftalt(self): def test_text_blank_blank():
options = main.parse_opts( options = main.parse_opts(
['--tab-name-align', 'right', '--tab-side', ['--front', 'blank', '--back', 'blank'])
'left-alternate']) assert options.text_front == 'blank'
self.assertEquals(options.tab_name_align, 'right') assert options.text_back == 'blank'
self.assertEquals(options.tab_side, 'left-alternate')
main.calculate_layout(options)
self.assertEquals(options.tab_name_align, 'right')
self.assertEquals(options.tab_side, 'left-alternate')
def test_tab_right_rightalt(self):
options = main.parse_opts(
['--tab-name-align', 'right', '--tab-side',
'right-alternate'])
self.assertEquals(options.tab_name_align, 'right')
self.assertEquals(options.tab_side, 'right-alternate')
main.calculate_layout(options)
self.assertEquals(options.tab_name_align, 'right')
self.assertEquals(options.tab_side, 'right-alternate')
def test_tab_right_full(self): def test_text_blank_card():
options = main.parse_opts( options = main.parse_opts(
['--tab-name-align', 'right', '--tab-side', 'full']) ['--front', 'blank', '--back', 'card'])
self.assertEquals(options.tab_name_align, 'right') assert options.text_front == 'blank'
self.assertEquals(options.tab_side, 'full') assert options.text_back == 'card'
main.calculate_layout(options)
self.assertEquals(options.tab_name_align, 'right')
self.assertEquals(options.tab_side, 'full')
# --tab_name_align edge
def test_tab_edge_left(self):
options = main.parse_opts(
['--tab-name-align', 'edge', '--tab-side', 'left'])
self.assertEquals(options.tab_name_align, 'edge')
self.assertEquals(options.tab_side, 'left')
main.calculate_layout(options)
self.assertEquals(options.tab_name_align, 'edge')
self.assertEquals(options.tab_side, 'left')
def test_tab_edge_right(self): def test_text_blank_none():
options = main.parse_opts( options = main.parse_opts(
['--tab-name-align', 'edge', '--tab-side', 'right']) ['--front', 'blank', '--back', 'none'])
self.assertEquals(options.tab_name_align, 'edge') assert options.text_front == 'blank'
self.assertEquals(options.tab_side, 'right') assert options.text_back == 'none'
main.calculate_layout(options)
self.assertEquals(options.tab_name_align, 'edge')
self.assertEquals(options.tab_side, 'right')
def test_tab_edge_leftalt(self): ####################
options = main.parse_opts( # Card Tab Tests
['--tab-name-align', 'edge', '--tab-side', ####################
'left-alternate']) # --tab_name_align left
self.assertEquals(options.tab_name_align, 'edge')
self.assertEquals(options.tab_side, 'left-alternate')
main.calculate_layout(options)
self.assertEquals(options.tab_name_align, 'edge')
self.assertEquals(options.tab_side, 'left-alternate')
def test_tab_edge_rightalt(self):
options = main.parse_opts(
['--tab-name-align', 'edge', '--tab-side',
'right-alternate'])
self.assertEquals(options.tab_name_align, 'edge')
self.assertEquals(options.tab_side, 'right-alternate')
main.calculate_layout(options)
self.assertEquals(options.tab_name_align, 'edge')
self.assertEquals(options.tab_side, 'right-alternate')
def test_tab_edge_full(self): def test_tab_left_left():
options = main.parse_opts( options = main.parse_opts(
['--tab-name-align', 'edge', '--tab-side', 'full']) ['--tab-name-align', 'left', '--tab-side', 'left'])
self.assertEquals(options.tab_name_align, 'edge') assert options.tab_name_align == 'left'
self.assertEquals(options.tab_side, 'full') assert options.tab_side == 'left'
main.calculate_layout(options) main.calculate_layout(options)
self.assertEquals(options.tab_name_align, assert options.tab_name_align == 'left'
'left') # special check for odd condition assert options.tab_side == 'left'
self.assertEquals(options.tab_side, 'full')
# --tab_name_align centre
def test_tab_centre_left(self):
options = main.parse_opts(['--tab-name-align',
'centre', '--tab-side', 'left'])
self.assertEquals(options.tab_name_align, 'centre')
self.assertEquals(options.tab_side, 'left')
main.calculate_layout(options)
self.assertEquals(options.tab_name_align, 'centre')
self.assertEquals(options.tab_side, 'left')
def test_tab_centre_right(self): def test_tab_left_right():
options = main.parse_opts(['--tab-name-align', options = main.parse_opts(
'centre', '--tab-side', 'right']) ['--tab-name-align', 'left', '--tab-side', 'right'])
self.assertEquals(options.tab_name_align, 'centre') assert options.tab_name_align == 'left'
self.assertEquals(options.tab_side, 'right') assert options.tab_side == 'right'
main.calculate_layout(options) main.calculate_layout(options)
self.assertEquals(options.tab_name_align, 'centre') assert options.tab_name_align == 'left'
self.assertEquals(options.tab_side, 'right') assert options.tab_side == 'right'
def test_tab_centre_leftalt(self):
options = main.parse_opts(
['--tab-name-align', 'centre', '--tab-side',
'left-alternate'])
self.assertEquals(options.tab_name_align, 'centre')
self.assertEquals(options.tab_side, 'left-alternate')
main.calculate_layout(options)
self.assertEquals(options.tab_name_align, 'centre')
self.assertEquals(options.tab_side, 'left-alternate')
def test_tab_centre_rightalt(self): def test_tab_left_leftalt():
options = main.parse_opts( options = main.parse_opts(
['--tab-name-align', 'centre', '--tab-side', ['--tab-name-align', 'left', '--tab-side', 'left-alternate'])
'right-alternate']) assert options.tab_name_align == 'left'
self.assertEquals(options.tab_name_align, 'centre') assert options.tab_side == 'left-alternate'
self.assertEquals(options.tab_side, 'right-alternate') main.calculate_layout(options)
main.calculate_layout(options) assert options.tab_name_align == 'left'
self.assertEquals(options.tab_name_align, 'centre') assert options.tab_side == 'left-alternate'
self.assertEquals(options.tab_side, 'right-alternate')
def test_tab_centre_full(self):
options = main.parse_opts(['--tab-name-align',
'centre', '--tab-side', 'full'])
self.assertEquals(options.tab_name_align, 'centre')
self.assertEquals(options.tab_side, 'full')
main.calculate_layout(options)
self.assertEquals(options.tab_name_align, 'centre')
self.assertEquals(options.tab_side, 'full')
# --tab_name_align center. Just do one since this is an alias to centre def test_tab_left_rightalt():
def test_tab_center_left(self): options = main.parse_opts(
options = main.parse_opts(['--tab-name-align', ['--tab-name-align', 'left', '--tab-side', 'right-alternate'])
'center', '--tab-side', 'left']) assert options.tab_name_align == 'left'
self.assertEquals(options.tab_name_align, 'center') assert options.tab_side == 'right-alternate'
self.assertEquals(options.tab_side, 'left') main.calculate_layout(options)
main.calculate_layout(options) assert options.tab_name_align == 'left'
self.assertEquals(options.tab_name_align, assert options.tab_side == 'right-alternate'
'centre') # check for change in value
self.assertEquals(options.tab_side, 'left')
def test_tab_left_full():
options = main.parse_opts(
['--tab-name-align', 'left', '--tab-side', 'full'])
assert options.tab_name_align == 'left'
assert options.tab_side == 'full'
main.calculate_layout(options)
assert options.tab_name_align == 'left'
assert options.tab_side == 'full'
# --tab_name_align right
def test_tab_right_left():
options = main.parse_opts(
['--tab-name-align', 'right', '--tab-side', 'left'])
assert options.tab_name_align == 'right'
assert options.tab_side == 'left'
main.calculate_layout(options)
assert options.tab_name_align == 'right'
assert options.tab_side == 'left'
def test_tab_right_right():
options = main.parse_opts(['--tab-name-align', 'right', '--tab-side', 'right'])
assert options.tab_name_align == 'right'
assert options.tab_side == 'right'
main.calculate_layout(options)
assert options.tab_name_align == 'right'
assert options.tab_side == 'right'
def test_tab_right_leftalt():
options = main.parse_opts(
['--tab-name-align', 'right', '--tab-side', 'left-alternate'])
assert options.tab_name_align == 'right'
assert options.tab_side == 'left-alternate'
main.calculate_layout(options)
assert options.tab_name_align == 'right'
assert options.tab_side == 'left-alternate'
def test_tab_right_rightalt():
options = main.parse_opts(
['--tab-name-align', 'right', '--tab-side', 'right-alternate'])
assert options.tab_name_align == 'right'
assert options.tab_side == 'right-alternate'
main.calculate_layout(options)
assert options.tab_name_align == 'right'
assert options.tab_side == 'right-alternate'
def test_tab_right_full():
options = main.parse_opts(
['--tab-name-align', 'right', '--tab-side', 'full'])
assert options.tab_name_align == 'right'
assert options.tab_side == 'full'
main.calculate_layout(options)
assert options.tab_name_align == 'right'
assert options.tab_side == 'full'
# --tab_name_align edge
def test_tab_edge_left():
options = main.parse_opts(
['--tab-name-align', 'edge', '--tab-side', 'left'])
assert options.tab_name_align == 'edge'
assert options.tab_side == 'left'
main.calculate_layout(options)
assert options.tab_name_align == 'edge'
assert options.tab_side == 'left'
def test_tab_edge_right():
options = main.parse_opts(
['--tab-name-align', 'edge', '--tab-side', 'right'])
assert options.tab_name_align == 'edge'
assert options.tab_side == 'right'
main.calculate_layout(options)
assert options.tab_name_align == 'edge'
assert options.tab_side == 'right'
def test_tab_edge_leftalt():
options = main.parse_opts(
['--tab-name-align', 'edge', '--tab-side', 'left-alternate'])
assert options.tab_name_align == 'edge'
assert options.tab_side == 'left-alternate'
main.calculate_layout(options)
assert options.tab_name_align == 'edge'
assert options.tab_side == 'left-alternate'
def test_tab_edge_rightalt():
options = main.parse_opts(
['--tab-name-align', 'edge', '--tab-side', 'right-alternate'])
assert options.tab_name_align == 'edge'
assert options.tab_side == 'right-alternate'
main.calculate_layout(options)
assert options.tab_name_align == 'edge'
assert options.tab_side == 'right-alternate'
def test_tab_edge_full():
options = main.parse_opts(
['--tab-name-align', 'edge', '--tab-side', 'full'])
assert options.tab_name_align == 'edge'
assert options.tab_side == 'full'
main.calculate_layout(options)
assert options.tab_name_align == 'left' # special check for odd condition
assert options.tab_side == 'full'
# --tab_name_align centre
def test_tab_centre_left():
options = main.parse_opts(['--tab-name-align', 'centre', '--tab-side', 'left'])
assert options.tab_name_align == 'centre'
assert options.tab_side == 'left'
main.calculate_layout(options)
assert options.tab_name_align == 'centre'
assert options.tab_side == 'left'
def test_tab_centre_right():
options = main.parse_opts(['--tab-name-align', 'centre', '--tab-side', 'right'])
assert options.tab_name_align == 'centre'
assert options.tab_side == 'right'
main.calculate_layout(options)
assert options.tab_name_align == 'centre'
assert options.tab_side == 'right'
def test_tab_centre_leftalt():
options = main.parse_opts(
['--tab-name-align', 'centre', '--tab-side', 'left-alternate'])
assert options.tab_name_align == 'centre'
assert options.tab_side == 'left-alternate'
main.calculate_layout(options)
assert options.tab_name_align == 'centre'
assert options.tab_side == 'left-alternate'
def test_tab_centre_rightalt():
options = main.parse_opts(
['--tab-name-align', 'centre', '--tab-side', 'right-alternate'])
assert options.tab_name_align == 'centre'
assert options.tab_side == 'right-alternate'
main.calculate_layout(options)
assert options.tab_name_align == 'centre'
assert options.tab_side == 'right-alternate'
def test_tab_centre_full():
options = main.parse_opts(['--tab-name-align', 'centre', '--tab-side', 'full'])
assert options.tab_name_align == 'centre'
assert options.tab_side == 'full'
main.calculate_layout(options)
assert options.tab_name_align == 'centre'
assert options.tab_side == 'full'
# --tab_name_align center. Just do one since this is an alias to centre
def test_tab_center_left():
options = main.parse_opts(['--tab-name-align', 'center', '--tab-side', 'left'])
assert options.tab_name_align == 'center'
assert options.tab_side == 'left'
main.calculate_layout(options)
assert options.tab_name_align == 'centre' # check for change in value
assert options.tab_side == 'left'

1
setup.py
View File

@ -13,6 +13,7 @@ setup(
packages=find_packages(exclude=['tests']), packages=find_packages(exclude=['tests']),
install_requires=["reportlab>=3.4.0", install_requires=["reportlab>=3.4.0",
"Pillow>=4.1.0"], "Pillow>=4.1.0"],
tests_require=["pytest", "pycodestyle"],
url='http://domtabs.sandflea.org', url='http://domtabs.sandflea.org',
include_package_data=True, include_package_data=True,
author="Peter Gorniak", author="Peter Gorniak",

61
tools/update_language.py
View File

@ -11,15 +11,15 @@
# All output is in the designated output directory. Original files are not overwritten. # All output is in the designated output directory. Original files are not overwritten.
########################################################################### ###########################################################################
import os import os
import os.path
import io import io
import codecs import codecs
import json import json
from shutil import copyfile from shutil import copyfile
import argparse
LANGUAGE_DEFAULT = 'en_us' # default language, which takes priority LANGUAGE_DEFAULT = 'en_us' # default language, which takes priority
LANGUAGE_XX = 'xx' # language for starting a translation LANGUAGE_XX = 'xx' # language for starting a translation
card_db_dir = os.path.join("..", "domdiv", "card_db") # directory of card data
output_dir = os.path.join(".", "card_db") # directory for output data
def get_lang_dirs(path): def get_lang_dirs(path):
@ -72,11 +72,11 @@ def multikeysort(items, columns):
return sorted(items, cmp=comparer) return sorted(items, cmp=comparer)
def main(): def main(args):
########################################################################### ###########################################################################
# Get all the languages, and place the default language first in the list # Get all the languages, and place the default language first in the list
########################################################################### ###########################################################################
languages = get_lang_dirs(card_db_dir) languages = get_lang_dirs(args.card_db_dir)
languages.remove(LANGUAGE_DEFAULT) languages.remove(LANGUAGE_DEFAULT)
languages.insert(0, LANGUAGE_DEFAULT) languages.insert(0, LANGUAGE_DEFAULT)
if LANGUAGE_XX not in languages: if LANGUAGE_XX not in languages:
@ -90,13 +90,13 @@ def main():
########################################################################### ###########################################################################
# main output directory # main output directory
if not os.path.exists(output_dir): if not os.path.exists(args.output_dir):
os.makedirs(output_dir) os.makedirs(args.output_dir)
# each language directory # each language directory
for lang in languages: for lang in languages:
# Make sure the directory is there to hold the file # Make sure the directory is there to hold the file
lang_dir = os.path.join(output_dir, lang) lang_dir = os.path.join(args.output_dir, lang)
if not os.path.exists(lang_dir): if not os.path.exists(lang_dir):
os.makedirs(lang_dir) os.makedirs(lang_dir)
@ -108,13 +108,13 @@ def main():
type_parts = [] type_parts = []
# Get the card data # Get the card data
type_data = get_json_data(os.path.join(card_db_dir, "types_db.json")) type_data = get_json_data(os.path.join(args.card_db_dir, "types_db.json"))
# Sort the cards by cardset_tags, then card_tag # Sort the cards by cardset_tags, then card_tag
sorted_type_data = multikeysort(type_data, ['card_type']) sorted_type_data = multikeysort(type_data, ['card_type'])
with io.open( with io.open(
os.path.join(output_dir, "types_db.json"), 'w', os.path.join(args.output_dir, "types_db.json"), 'w',
encoding='utf-8') as lang_out: encoding='utf-8') as lang_out:
lang_out.write(unicode("[")) # Start of list lang_out.write(unicode("[")) # Start of list
sep = "" sep = ""
@ -142,14 +142,14 @@ def main():
########################################################################### ###########################################################################
for lang in languages: for lang in languages:
lang_file = "types_" + lang + ".json" lang_file = "types_" + lang + ".json"
fname = os.path.join(card_db_dir, lang, lang_file) fname = os.path.join(args.card_db_dir, lang, lang_file)
if os.path.isfile(fname): if os.path.isfile(fname):
lang_type_data = get_json_data(fname) lang_type_data = get_json_data(fname)
else: else:
lang_type_data = {} lang_type_data = {}
with io.open( with io.open(
os.path.join(output_dir, lang, lang_file), 'w', os.path.join(args.output_dir, lang, lang_file), 'w',
encoding='utf-8') as lang_out: encoding='utf-8') as lang_out:
lang_out.write(unicode("{")) # Start of types lang_out.write(unicode("{")) # Start of types
sep = "" sep = ""
@ -191,7 +191,7 @@ def main():
super_groups = [u'events', u'landmarks'] super_groups = [u'events', u'landmarks']
# Get the card data # Get the card data
card_data = get_json_data(os.path.join(card_db_dir, "cards_db.json")) card_data = get_json_data(os.path.join(args.card_db_dir, "cards_db.json"))
# Sort the cardset_tags # Sort the cardset_tags
for card in card_data: for card in card_data:
@ -205,7 +205,7 @@ def main():
sorted_card_data = multikeysort(card_data, ['cardset_tags', 'card_tag']) sorted_card_data = multikeysort(card_data, ['cardset_tags', 'card_tag'])
with io.open( with io.open(
os.path.join(output_dir, "cards_db.json"), 'w', os.path.join(args.output_dir, "cards_db.json"), 'w',
encoding='utf-8') as lang_out: encoding='utf-8') as lang_out:
lang_out.write(unicode("[")) # Start of list lang_out.write(unicode("[")) # Start of list
sep = "" sep = ""
@ -240,7 +240,7 @@ def main():
# contruct the cards json file name # contruct the cards json file name
lang_file = "cards_" + lang + ".json" lang_file = "cards_" + lang + ".json"
fname = os.path.join(card_db_dir, lang, lang_file) fname = os.path.join(args.card_db_dir, lang, lang_file)
if os.path.isfile(fname): if os.path.isfile(fname):
lang_data = get_json_data(fname) lang_data = get_json_data(fname)
else: else:
@ -248,7 +248,7 @@ def main():
# Process the file # Process the file
with io.open( with io.open(
os.path.join(output_dir, lang, lang_file), 'w', os.path.join(args.output_dir, lang, lang_file), 'w',
encoding='utf-8') as lang_out: encoding='utf-8') as lang_out:
lang_out.write(unicode("{")) # Start of set lang_out.write(unicode("{")) # Start of set
sep = "" sep = ""
@ -320,10 +320,10 @@ def main():
# Place entries in alphabetical order # Place entries in alphabetical order
########################################################################### ###########################################################################
lang_file = "sets_db.json" lang_file = "sets_db.json"
set_data = get_json_data(os.path.join(card_db_dir, lang_file)) set_data = get_json_data(os.path.join(args.card_db_dir, lang_file))
with io.open( with io.open(
os.path.join(output_dir, lang_file), 'w', os.path.join(args.output_dir, lang_file), 'w',
encoding='utf-8') as lang_out: encoding='utf-8') as lang_out:
lang_out.write(unicode("{")) # Start of set lang_out.write(unicode("{")) # Start of set
sep = "" sep = ""
@ -351,13 +351,13 @@ def main():
########################################################################### ###########################################################################
for lang in languages: for lang in languages:
lang_file = "sets_" + lang + ".json" lang_file = "sets_" + lang + ".json"
fname = os.path.join(card_db_dir, lang, lang_file) fname = os.path.join(args.card_db_dir, lang, lang_file)
if os.path.isfile(fname): if os.path.isfile(fname):
lang_set_data = get_json_data(fname) lang_set_data = get_json_data(fname)
else: else:
lang_set_data = {} lang_set_data = {}
with io.open( with io.open(
os.path.join(output_dir, lang, lang_file), 'w', os.path.join(args.output_dir, lang, lang_file), 'w',
encoding='utf-8') as lang_out: encoding='utf-8') as lang_out:
lang_out.write(unicode("{")) # Start of set lang_out.write(unicode("{")) # Start of set
sep = "" sep = ""
@ -417,22 +417,31 @@ def main():
fromLanguage = LANGUAGE_DEFAULT fromLanguage = LANGUAGE_DEFAULT
copyfile( copyfile(
os.path.join(card_db_dir, fromLanguage, "bonuses_" + fromLanguage + ".json"), os.path.join(args.card_db_dir, fromLanguage, "bonuses_" + fromLanguage + ".json"),
os.path.join(output_dir, lang, "bonuses_" + lang + ".json")) os.path.join(args.output_dir, lang, "bonuses_" + lang + ".json"))
########################################################################### ###########################################################################
# translation.txt # translation.txt
########################################################################### ###########################################################################
copyfile( copyfile(
os.path.join(card_db_dir, "translation.md"), os.path.join(args.card_db_dir, "translation.md"),
os.path.join(output_dir, "translation.md")) os.path.join(args.output_dir, "translation.md"))
# Since xx is the starting point for new translations, # Since xx is the starting point for new translations,
# make sure xx has the latest copy of translation.txt # make sure xx has the latest copy of translation.txt
copyfile( copyfile(
os.path.join(card_db_dir, LANGUAGE_XX, "translation.txt"), os.path.join(args.card_db_dir, LANGUAGE_XX, "translation.txt"),
os.path.join(output_dir, LANGUAGE_XX, "translation.txt")) os.path.join(args.output_dir, LANGUAGE_XX, "translation.txt"))
if __name__ == '__main__': if __name__ == '__main__':
main() parser = argparse.ArgumentParser()
parser.add_argument('--card_db_dir', default=os.path.join(os.path.dirname(os.path.abspath(__file__)),
"..", "domdiv", "card_db"),
help='directory of card data')
parser.add_argument('--output_dir',
default=os.path.join(os.path.dirname(os.path.abspath(__file__)), ".", "card_db"),
help='directory for output data')
args = parser.parse_args()
main(args)