bootstraparse/tests/modules/test_syntax.py

217 lines
7.7 KiB
Python

import pyparsing
import pytest
import bootstraparse.modules.syntax as sy
# Dictionary of all label and associated token used in the language
list_of_token_types = {
"alias": sy.AliasToken,
"image": sy.ImageToken,
}
# Dictionary of all lexical elements and a list of matching strings
expressions_to_match = {
# Base elements
"quotes": ["'hi, there'", "'hi, there'"],
"value": ["0.1", "'hello'"],
"assignation": ["a=1", "a=1.33", "tr2='hu'"],
# Composite elements
"var": ['["a"]',
'[a=12]',
'[a=12, b=13]',
'[12,"a",1.1,a=12, b=13, c=14]',
],
# Specific elements
"image_element": ["@{image}", "@{image123_456}"],
"alias_element": ["@[alias]", "@[alias123_456]"],
"expression": ["a+b+c"],
"html_insert": ['{test=12, 22=3, "=5}', "{testing=12, 22=3, 4=5, 6='7'}"],
# Optional elements
"optional": ["a=1", "a=1.33", "tr2='hu'"],
# Pre_parser elements
"image": ["@{image}{test=22}[a=12,22,c,d,ERE,r,3]", "@{image123_456}{a=12,22,c,d,ERE,r,3}",
"@{image123_456}[a=12,22,c,d,ERE,r,3]"],
"alias": ["@[alias]{test=22}[a=12,22,c,d,ERE,r,3]", "@[alias123_456]{a=12,22,c,d,ERE,r,3}",
"@[alias123_456]{a=12,22,c,d,ERE,r,3]"],
# Syntax elements
"line_to_replace": ["@{image}",
"@{image}{é=12}",
"@{image}{test=22}",
"@{image}{test=22}[a=12,22,c,d,ERE,r,3]",
"@[alias]{test=22}[a=12,22,c,d,ERE,r,3]",
],
}
dict_advanced_syntax_input_and_expected_output = {
# Enhanced text # TODO : Test optional inline args
"et_em": [
("*", (sy.EtEmToken("*"), )),
],
"et_strong": [
("**", sy.EtEmToken("**"), ),
],
"et_underline": [
("__", (sy.EtUnderlineToken("__"), )),
],
"et_strikethrough": [
("~~", (sy.EtStrikethroughToken("~~"), )),
],
"et_custom_span": [
("(#12345)", (sy.EtCustomSpanToken("#12345"), )),
],
# Enhanced Text
"enhanced_text": [
("*test*", (sy.EtEmToken("*"), sy.TextToken("test"), sy.EtEmToken("*"))),
("**test**", (sy.EtEmToken("**"), sy.TextToken("test"), sy.EtEmToken("**"))),
("__test__", (sy.EtUnderlineToken("__"), sy.TextToken("test"), sy.EtUnderlineToken("__"))),
("~~test~~", (sy.EtStrikethroughToken("~~"), sy.TextToken("test"), sy.EtStrikethroughToken("~~"))),
("(#12345)", (sy.EtCustomSpanToken("#12345"), )),
("*test*test*", (sy.EtEmToken("*"), sy.TextToken("test"), sy.EtEmToken("*"), sy.TextToken("test"),
sy.EtEmToken("*"))),
("**test**test**", (sy.EtEmToken("**"), sy.TextToken("test"), sy.EtEmToken("**"), sy.TextToken("test"),
sy.EtEmToken("**"))),
("__test__test__", (sy.EtUnderlineToken("__"), sy.TextToken("test"), sy.EtUnderlineToken("__"),
sy.TextToken("test"), sy.EtUnderlineToken("__"))),
("~~test~~test~~", (sy.EtStrikethroughToken("~~"), sy.TextToken("test"), sy.EtStrikethroughToken("~~"),
sy.TextToken("test"), sy.EtStrikethroughToken("~~"))),
("(#12345)test(#12345)", (sy.EtCustomSpanToken("#12345"), sy.TextToken("test"),
sy.EtCustomSpanToken("#12345"))),
("__test(#12)test**test__test~~", (sy.EtUnderlineToken("__"), sy.TextToken("test"),
sy.EtCustomSpanToken("#12"), sy.TextToken("test"),
sy.EtEmToken("**"), sy.TextToken("test"), sy.EtStrikethroughToken("~~"))),
("12. List", (sy.TextToken("12."), sy.TextToken(" List"))),
],
# Divs
"et_div": [
("<<div", (sy.UnimplementedToken("<<"), sy.TextToken("div"))),
("div>>", (sy.TextToken("div"), sy.UnimplementedToken(">>"))),
],
# Elements
"il_link": [
("[text_link]('text://www.website.com/link.html')",
sy.UnimplementedToken("[text_link]('text://www.website.com/link.html')"))
],
"one_olist": [
("12. Text", (sy.TextToken("12."), sy.TextToken(" Text"))),
],
"one_ulist": [
("- Text", (sy.TextToken("- "), sy.TextToken("Text"))),
],
}
@pytest.mark.parametrize("token_name,token_class", list_of_token_types.items())
def test_token_type_exists(token_name, token_class):
"""
Test that the token type exists.
:param token_name: The name of the token type.
:param token_class: The class of the token type.
:type token_name: str
:type token_class: sy.SemanticType
"""
assert token_class.label == token_name
def test_token_type_exists_fail():
"""
Test that the token type does not exist.
"""
with pytest.raises(AttributeError):
# noinspection PyUnresolvedReferences, PyStatementEffect
sy.UnexistingTypeToken.label == "non_existing_token" # pylint: disable=pointless-statement
@pytest.mark.parametrize("token_class", list_of_token_types.values())
def test_of_type_creator(token_class):
"""
Test that the of_type_creator function returns the correct type.
:param token_class: The class of the token type.
:type token_class: sy.SemanticType
"""
fcr = sy.of_type(token_class)
tnk = fcr(None, None, None)
# noinspection PyTypeChecker
assert isinstance(tnk, token_class) # pylint: disable=unidiomatic-typecheck
assert tnk.label == token_class.label
def strings_in_token(token, string_list):
token_str = str(token)
for string in string_list:
if string not in token_str:
return False
return True
def test_semantic_type():
"""
Test that the semantic type is correctly created.
"""
st = sy.SemanticType("test")
assert st.label is None
assert strings_in_token(st, ["test", "None"])
assert strings_in_token(repr(st), ["test", "None"])
st = sy.SemanticType([1, 2, 3])
assert st.label is None
st.label = "test"
assert strings_in_token(st, ["[1, 2, 3]", "test"])
def find_expression_from_str(expression_str):
"""
Find the expression from its string representation.
Just trust on this one.
:param expression_str: The string representation of the expression.
:type expression_str: str
:return: The expression.
:rtype: pyparsing.ParserElement
"""
# noinspection PyUnresolvedReferences
return sy.__getattribute__(expression_str) # pylint: disable=no-member
@pytest.mark.parametrize("expression,to_parse", expressions_to_match.items())
def test_expression_matching(expression, to_parse):
"""
Test that the expression is correctly parsed.
:param expression: The expression to test.
:param to_parse: A list of string that should be matched by the expression.
:type expression: str
:type to_parse: list
"""
expr = find_expression_from_str(expression)
assert isinstance(expr, pyparsing.ParserElement)
for string in to_parse:
assert expr.parse_string(string) is not None
@pytest.mark.parametrize("expression, tokens", dict_advanced_syntax_input_and_expected_output.items())
def test_advanced_expression_and_token_creation(expression, tokens):
"""
Test that the advanced syntax is correctly parsed and returns the correct tokens.
:param expression: The expression to test.
:param tokens: The expected tokens.
:type expression: str
:type tokens: list
"""
expr = find_expression_from_str(expression)
assert isinstance(expr, pyparsing.ParserElement)
for string_to_test, expected_tokens in tokens:
result = expr.parse_string(string_to_test)
print(result)
# assert result is not None
# for token, expected_token in zip(result, expected_tokens):
# assert token == expected_token
assert False