import pyparsing import pytest import bootstraparse.modules.syntax as sy # Dictionnary of all label and assotiated token used in the language list_of_token_types = { "alias": sy.AliasToken, "image": sy.ImageToken, } # Dictionnary 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": ['{zeaioep=12, 22=3, "=5}', "{zeaioep=12, 22=3, 4=5, 6='7'}"], # Optional elements "optional": ["a=1", "a=1.33", "tr2='hu'"], # Preparser 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}{testé}", "@{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 "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": [ ("*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"))), # ("<>", (sy.TextToken("div"), sy.EtDivCloseToken(">>"))), # ], } @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 returs 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