Example #1
0
def check_compiles(dsl_expr, code):
    types = graph_types(ENV)

    expr, functions = to_expr(dsl_expr)
    env = fn_types(functions)
    env.update(types['__root__'].__field_types__)

    expr = check(expr, types, env)

    # test eval
    lambda_expr = ExpressionCompiler.compile_lambda_expr(expr)
    eval(compile(lambda_expr, '<expr>', 'eval'))

    # test compile
    py_expr = ExpressionCompiler.compile_expr(expr)

    first = astor.to_source(py_expr).strip()
    if not PY3:
        first = first.replace("u'", "'")
    second = dedent(code).strip()
    if first != second:
        msg = ('Compiled code is not equal:\n\n{}'
               .format('\n'.join(difflib.ndiff(first.splitlines(),
                                               second.splitlines()))))
        raise AssertionError(msg)
Example #2
0
    def assertCompiles(self, dsl_expr, code):
        expr, functions = to_expr(dsl_expr)

        types = graph_types(ENV)
        types.update(fn_types(functions))

        expr = check(expr, types)

        py_expr = ExpressionCompiler.compile_expr(expr)

        first = astor.to_source(py_expr)
        if not PY3:
            first = first.replace("u'", "'")
        second = dedent(code).strip()
        if first != second:
            msg = ('Compiled code is not equal:\n\n{}'
                   .format('\n'.join(difflib.ndiff(first.splitlines(),
                                                   second.splitlines()))))
            raise self.failureException(msg)

        # test eval
        lambda_expr = ExpressionCompiler.compile_lambda_expr(expr)
        eval(compile(lambda_expr, '<expr>', 'eval'))
Example #3
0
        g.Field('sailed', None, _),
        g.Node('malatya', [
            g.Field('bartok', None, _),
            g.Field('rotifer', None, _),
            g.Link('teling', TypeRef['patens'], _, requires=None),
            g.Link('wandy', Sequence[TypeRef['patens']], _, requires=None),
        ]),
        g.Link('civics', Optional[TypeRef['patens']], _, requires=None),
        g.Link('weigh', TypeRef['patens'], _, requires=None),
        g.Link('comped', Sequence[TypeRef['patens']], _, requires=None),
        g.Field('dilo', Sequence[String], _),
    ]),
])


TYPES = graph_types(GRAPH)
ROOT_TYPES = TYPES['__root__'].__field_types__


def check_req(ref, req, add_req=None):
    with reqs_eq_patcher():
        assert ref_to_req(TYPES, ref, add_req) == req


def check_query(dsl_expr, query):
    expr, functions = to_expr(dsl_expr)
    env = fn_types(functions)
    env.update(ROOT_TYPES)
    expr = check(expr, TYPES, env)
    expr_reqs = RequirementsExtractor.extract(TYPES, expr)
    with reqs_eq_patcher():
Example #4
0
    g.Root([
        g.Field('sailed', None, _),
        g.Node('malatya', [
            g.Field('bartok', None, _),
            g.Field('rotifer', None, _),
            g.Link('teling', TypeRef['patens'], _, requires=None),
            g.Link('wandy', Sequence[TypeRef['patens']], _, requires=None),
        ]),
        g.Link('civics', Optional[TypeRef['patens']], _, requires=None),
        g.Link('weigh', TypeRef['patens'], _, requires=None),
        g.Link('comped', Sequence[TypeRef['patens']], _, requires=None),
    ]),
])


TYPES = graph_types(GRAPH)


def check_req(ref, req, add_req=None):
    with reqs_eq_patcher():
        assert ref_to_req(TYPES, ref, add_req) == req


def check_query(dsl_expr, query):
    expr, functions = to_expr(dsl_expr)
    types = TYPES.copy()
    types.update(fn_types(functions))
    expr = check(expr, types)
    expr_reqs = RequirementsExtractor.extract(types, expr)
    with reqs_eq_patcher():
        assert expr_reqs == query