def test_function_invocation():
ast = FunctionInvocation(
Expression("foo"),
expressions=NonEmptySequence[Expression](Expression("bar"), ),
)
assert_that(
str(ast),
is_(equal_to("foo(bar)")),
)
assert_that(
dict(ast),
is_(equal_to(dict())),
)
def test_merge(action_types, query, parameters):
ast = Merge(
pattern_part=PatternPart(),
actions=[
MergeAction(
action_type=action_type,
then=Set(
items=SetItems(
SetVariableItem(
target="foo",
value=Expression("bar"),
),
),
),
)
for action_type in action_types or []
]
)
assert_that(
str(ast),
is_(equal_to(query)),
)
assert_that(
dict(ast),
is_(equal_to(parameters)),
)
def test_expression():
ast = Expression("foo")
assert_that(
str(ast),
is_(equal_to("foo")),
)
assert_that(
dict(ast),
is_(equal_to(dict())),
)
def test_delete():
ast = Delete(items=NonEmptySequence[Expression](Expression("foo"), ), )
assert_that(
str(ast),
is_(equal_to("DELETE foo")),
)
assert_that(
dict(ast),
is_(equal_to(dict())),
)
def test_expression_parameter():
ast = Expression(
Parameter("key", "name", "value"),
)
assert_that(
str(ast),
is_(equal_to("$name")),
)
assert_that(
dict(ast),
is_(equal_to(dict(name="value"))),
)
def test_order():
ast = Order(
items=NonEmptySequence[SortItem](
SortItem(
expression=Expression("foo"),
order=SortOrder.DESCENDING,
),
),
)
assert_that(
str(ast),
is_(equal_to("ORDER BY foo DESCENDING")),
)
def test_expression_alias():
ast = ExpressionAlias(
Expression("foo"),
Variable("bar"),
)
assert_that(
str(ast),
is_(equal_to("foo AS bar")),
)
assert_that(
dict(ast),
is_(equal_to(dict())),
)
def test_match(expression, variable, query, parameters):
ast = Unwind(
expression=Expression(expression),
variable=Variable(variable),
)
assert_that(
str(ast),
is_(equal_to(query)),
)
assert_that(
dict(ast),
is_(equal_to(parameters)),
)
def test_match(optional, where, query, parameters):
ast = Match(
pattern=Pattern(items=NonEmptySequence[PatternPart](PatternPart(), )),
optional=optional,
where=Where(Expression(where)) if where is not None else None,
)
assert_that(
str(ast),
is_(equal_to(query)),
)
assert_that(
dict(ast),
is_(equal_to(parameters)),
)
def test_set_variable_item(variable, expression, mutate, query, parameters):
ast = SetVariableItem(
target=Variable(variable),
value=Expression(expression),
mutate=mutate,
)
assert_that(
str(ast),
is_(equal_to(query)),
)
assert_that(
dict(ast),
is_(equal_to(parameters)),
)
def test_read(reading_clause, query, parameters):
ast = Cypher(statement=RegularQuery(query=SinglePartReadQuery(
return_=Return(body=ReturnBody(items=NonEmptySequence[ReturnItem](
Expression("foo"), ), ), ),
reading_clauses=[
reading_clause,
] if reading_clause else [],
), ), )
assert_that(
str(ast),
is_(equal_to(query)),
)
assert_that(
dict(ast),
is_(equal_to(parameters)),
)
def test_set_property_item():
ast = SetPropertyItem(
target=PropertyExpression(
value="foo",
properties=NonEmptySequence[PropertyLookup](
PropertyLookup("bar"), ),
),
value=Expression("baz"),
)
assert_that(
str(ast),
is_(equal_to("foo.bar = baz")),
)
assert_that(
dict(ast),
is_(equal_to(dict())),
)
def test_write(value, reading_clause, query, parameters):
ast = Cypher(statement=RegularQuery(query=SinglePartWriteQuery(
return_=Return(body=ReturnBody(items=NonEmptySequence[ReturnItem](
Expression(value), ), ), ) if value else None,
reading_clauses=[
reading_clause,
] if reading_clause else [],
updating_clauses=[
Merge(pattern_part=PatternPart()),
],
), ), )
assert_that(
str(ast),
is_(equal_to(query)),
)
assert_that(
dict(ast),
is_(equal_to(parameters)),
)
def test_union(values, all, query, parameters):
queries = [
SinglePartReadQuery(return_=Return(body=ReturnBody(
items=NonEmptySequence[ReturnItem](Expression(value), ), ), ), )
for value in values
]
ast = Cypher(statement=RegularQuery(
query=queries[0],
items=NonEmptySequence[Union](*(Union(
query=query,
all=all,
) for query in queries[1:])),
), )
assert_that(
str(ast),
is_(equal_to(query)),
)
assert_that(
dict(ast),
is_(equal_to(parameters)),
)
def test_set():
ast = Set(items=SetItems(
SetVariableNodeLabelsItem(
target=Variable("foo"),
value=NodeLabels(NodeLabel("Bar"), ),
),
*(SetPropertyItem(
target=PropertyExpression(
value="foo",
properties=NonEmptySequence[PropertyLookup](
PropertyLookup("bar"), ),
),
value=Expression("baz"),
), ),
), )
assert_that(
str(ast),
is_(equal_to("SET foo:Bar, foo.bar = baz")),
)
assert_that(
dict(ast),
is_(equal_to(dict())),
)
def test_skip():
ast = Skip(Expression(1))
assert_that(
str(ast),
is_(equal_to("SKIP 1")),
)
def test_limit():
ast = Limit(Expression(1))
assert_that(
str(ast),
is_(equal_to("LIMIT 1")),
)