def param_split_words():
"""Parametrize `test_split_words`"""
names = 'samp'
vals = get_samples(('empty', 'sentence_1word', 'sentence_medium'))
ids = ('empty_string', 'one_word', 'medium_sent',)
return parametrize(names, vals, ids)
def param_strip_strs():
"""Parametrize `test_strip_strs`"""
names = 'str_list,expected'
vals = [([SPAM, ' eggs', 'bacon ', ' spam '], [SPAM, EGGS, BACON, SPAM])]
ids = [SPAM]
return parametrize(names, vals, ids)
def param___repr__():
"""Parametrize `test___repr__`"""
names = 'args'
vals = (('div', ), )
ids = ('basic', )
return parametrize(names, vals, ids)
def param_get_config_path():
"""Parametrize `test_get_config_path`"""
names = 'root,idiom,expected'
vals = ((IDIOM_PATH, TEST_IDIOM_NAME, TEST_IDIOM_JSON), )
ids = ('test path', )
return parametrize(names, vals, ids)
def param_compare_word():
"""Parametrize `test_compare_word`"""
names = 'word_a,word_b,expected'
vals = (('spal', 'spam', -1), ('spam', 'spam', 0), ('span', 'spam', 1))
ids = ('lt', 'eq', 'gt')
return parametrize(names, vals, ids)
def param_compare_keywords():
"""Parametrize `test_compare_keywords`"""
names = 'kw_a,kw_b,is_lt,is_eq,reason'
vals = (
(gen_sk_inst(1, 2), gen_sk_inst(1, 1), True, False, 's'),
(gen_sk_inst(1, 2), gen_sk_inst(1, 2), False, True, 's'),
(gen_sk_inst(1, 2), gen_sk_inst(1, 3), False, False, 's'),
(gen_sk_inst(1, 2, 'ham'), gen_sk_inst(1, 2), True, False, 'l'),
(gen_sk_inst(1, 2, 'eggs'), gen_sk_inst(1, 2), True, False, 'l'),
(gen_sk_inst(1, 2, 'bacon'), gen_sk_inst(1, 2), False, False, 'l'),
(gen_sk_inst(1, 2, 'spal'), gen_sk_inst(1, 2), True, False, 'w'),
(gen_sk_inst(1, 2, 'spam'), gen_sk_inst(1, 2), False, True, 'w'),
(gen_sk_inst(1, 2, 'span'), gen_sk_inst(1, 2), False, False, 'w'),
)
ids = (
'score-lt_b',
'score-eq_b',
'score-gt_b',
'length-lt_b',
'length-eq_b',
'length-gt_b',
'string-lt_b',
'string-eq_b',
'string-gt_b',
)
return parametrize(names, vals, ids)
def param_samples(sample_names: StringList = SAMPLES):
"""Parametrize with list of samples"""
names = 'samp'
vals = get_samples(sample_names)
ids = sample_names
return parametrize(names, vals, ids)
def param_norm_text():
"""Parametrize `test_norm_text`"""
names = 'text,expected'
vals = ((None, ''), (SPAM, SPAM), (' ham ', 'ham'))
ids = ('None', SPAM, 'sloppy')
return parametrize(names, vals, ids)
def param_get_keywords():
"""Parametrize `test_get_keywords`"""
names = 'samp'
vals = get_samples(('empty', 'essay_snark'))
ids = ('empty_string', 'snark_essay')
return parametrize(names, vals, ids)
def param_split_sentences():
"""Parametrize `test_split_sentences`"""
names = 'samp'
vals = get_samples(['sentence_short', 'sentence_list', ] + SAMPLES)
ids = get_sample_ids(['sentence_short', 'sentence_list', ] + SAMPLES)
return parametrize(names, vals, ids)
def param_remove_punctuations():
"""Parametrize `test_remove_punctuations`"""
names = 'samp'
vals = get_samples(('empty', 'sentence_1word', 'sentence_list', ))
ids = ('empty string', 'one word', 'list of sentences', )
return parametrize(names, vals, ids)
def param_get_all_words():
"""Parametrize `test_get_all_words`"""
names = 'samp'
vals = get_samples(('sentence_1word', 'sentence_overlong'))
ids = ('one ', 'a long sentence')
return parametrize(names, vals, ids)
def param_parser_config_init():
"""Parametrize ParserConfig init"""
names = 'root,idiom,expected'
vals = ((BUILTIN, DEFAULT_IDIOM, DEFAULT_IDIOM_EXPECTED), )
ids = ('defaults', )
return parametrize(names, vals, ids)
def param_scored_sentence__str__():
"""Parametrize `TestScoredSentence.test___str__`"""
names = 'init,expected'
vals = ((SPAM_PARAMS, SPAM), )
ids = (SPAM, )
return parametrize(names, vals, ids)
def param_norm_path():
"""Parametrize `test_norm_path`"""
names = 'path,expected'
vals = ((__file__, __file__), (Path(__file__), __file__))
ids = ('str', 'Path')
return parametrize(names, vals, ids)
def param_get_stop_words():
"""Parametrize `test_get_stop_words`"""
names = 'spec,expected'
vals = (
({}, -1,),
({'nltk': False}, 0),
({'nltk': True}, -10),
({'user': []}, -10),
({'user': ['foo']}, -10),
({'nltk': False, 'user': []}, 0),
({'nltk': False, 'user': ['foo']}, 1),
({'nltk': True, 'user': []}, -10),
({'nltk': True, 'user': ['foo']}, -10),
)
ids = (
'nltk: default, user: default',
'nltk: False, user: default',
'nltk: True, user: default',
'nltk: default, user: 0',
'nltk: default, user: 1',
'nltk: False, user: 0',
'nltk: False, user: 1',
'nltk: True, user: 0',
'nltk: True, user: 1',
)
return parametrize(names, vals, ids)
def param_sentences():
"""Parametrize for a `ScoredSentence` and its `Sample`"""
names = 'sample,sentence'
vals = get_sample_sentences(SAMPLES)
ids = get_sample_sentence_ids(SAMPLES)
return parametrize(names, vals, ids)
def param_scored_sentence__repr__():
"""Parametrize `TestScoredSentence.test___repr___`"""
names = 'init,expected'
vals = ((SPAM_PARAMS,
'ScoredSentence(\'spam\', 1, 3, 4.0, 5.0, 6.0, 7.0)'), )
ids = (SPAM, )
return parametrize(names, vals, ids)
def param_scored_sentence__init_():
"""Parametrize `TestScoredSentence.test__init_`"""
names = 'init,expected'
vals = ((SPAM_PARAMS,
SPAM_RESULT[:-3] + list(float(x) for x in range(8, 11))), )
ids = (SPAM, )
return parametrize(names, vals, ids)
def parametrize_basic(expected='Basic body'):
"""Parametrize tests for basic PDF
Keyword Arguments:
expected {str} -- expected body (default: {'Basic body'})
Returns:
test params -- test params
"""
return parametrize('stem,expected', (('basic', expected), ), ('basic', ))
def param_content(has_path: bool = False):
"""Parametrize for Content initialization
Keyword Arguments:
has_path {bool} -- add document path (default: {False})
"""
names = 'params,expected'
vals, ids = get_test_tuples(has_path)
return parametrize(names, vals, ids)
def param_get_document():
"""Parametrize `test_get_document`"""
param_names = 'path,ext,expected'
param_vals = (
get_info('basic', 'html'),
get_info('basic', 'pdf'),
get_info('basic', 'php', 'html'),
)
ids = ('basic.htm', 'basic.pdf', 'basic.php')
return parametrize(param_names, param_vals, ids)
def param_get_text():
"""Parametrize `test_get_text`"""
names = 'tag,expected'
vals = (
('header', 'Header'),
('main', DOC['body']),
('footer', 'Footer'),
)
ids = ('header', 'main', 'footer')
return parametrize(names, vals, ids)
def parametrize_words():
"""Parametrize word tests
Returns:
typing.List[tuple] -- test parameters
"""
names = 'word,count,total'
vals = (('ham', 1, 1), ('spam', 1, 1), ('eggs', 1, 1), ('bacon', 1, 1), )
ids = ('ham', 'spam', 'eggs', 'bacon')
return parametrize(names, vals, ids)
def param_pipe():
"""Parametrize `test_pipe`"""
names = 'init,pipeline,expected'
vals = (
(0, (return_false, ), False),
(0, (return_false, return_true), True),
(0, (return_false, return_true, noop) * 100, True),
)
ids = ('one', 'two', 'lots')
return parametrize(names, vals, ids)
def param_comp():
"""Parametrize `ScoredSentence` comparisons"""
names = 'sent_a,sent_b,is_lt,is_eq'
vals = permute_sentences()
ids = (
'lt',
'eq',
'gt',
)
return parametrize(names, vals, ids)
def param_repr():
"""Parametrize `test__repr_`"""
names = 'args,kwargs,expected'
vals = (
([], {}, 'ReprAble()'),
(['one', 'two'], {}, 'ReprAble(\'one\', \'two\')'),
([], {'one': 1, 'two': 2}, 'ReprAble(one=1, two=2)'),
(['one'], {'two': 2}, 'ReprAble(\'one\', two=2)'),
)
ids = ('empty', 'args', 'kwargs', 'both')
return parametrize(names, vals, ids)
def param_score_keyword():
"""Parametrize `test_score_keyword`"""
names = 'count,total,expected'
vals = (
(1, 1, KEYWORD_SCORE_K),
(-1, 1, ValueError),
(1, 0, ValueError),
(2, 1, ValueError),
)
ids = ('normal', 'sub0', 'div0/neg', 'overmax', )
return parametrize(names, vals, ids)
def param__float_len():
"""Parametrize `test__float_len`"""
names = 'item_list,expected'
vals = (([], 0.0), ([1], 1.0), (range(10), 10.0), (range(10000), 10000.0))
ids = (
' 0',
' 1',
' 10',
'10000',
)
return parametrize(names, vals, ids)
def param_content_init(cls: Content):
"""Parametrize with initialized `cls` and expected properties
Arguments:
cls {Content} -- class to initialize
"""
test_data, ids = get_test_tuples(False)
names = 'inst,expected'
vals = [(get_content(cls, test_data[i][0]), test_data[i][1])
for i in range(len(test_data))]
return parametrize(names, vals, ids)
