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_create():
ast = Create(pattern=Pattern(items=NonEmptySequence[PatternPart](
PatternPart(), ), ), )
assert_that(
str(ast),
is_(equal_to("CREATE ()")),
)
assert_that(
dict(ast),
is_(equal_to(dict())),
)
def test_pattern():
ast = Pattern(items=NonEmptySequence[PatternPart](PatternPart(
pattern_element=PatternElement(items=[], ),
variable=Variable("foo"),
), ), )
assert_that(
str(ast),
is_(equal_to("foo = ()")),
)
assert_that(
dict(ast),
is_(equal_to(dict())),
)
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_pattern_chain():
ast = Pattern(items=NonEmptySequence[PatternPart](PatternPart(
pattern_element=PatternElement(items=[
PatternElementChain(),
PatternElementChain(),
PatternElementChain(relationship_pattern=RelationshipPattern(
detail=RelationshipDetail(), )),
], ), ), ), )
assert_that(
str(ast),
is_(equal_to("()--()--()-[]-()")),
)
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 merge(cls, pattern_element: PatternElement) -> Merge:
return Merge(pattern_part=PatternPart(pattern_element), )
def match(cls, pattern_element: PatternElement) -> Match:
return Match(pattern=Pattern(items=NonEmptySequence[PatternPart](
PatternPart(pattern_element), ), ), )
def create(cls, pattern_element: PatternElement) -> Create:
return Create(pattern=Pattern(items=NonEmptySequence[PatternPart](
PatternPart(pattern_element), ), ), )
NodePattern,
NonEmptySequence,
Pattern,
PatternElement,
PatternPart,
SinglePartReadQuery,
SinglePartWriteQuery,
RegularQuery,
Return,
ReturnBody,
ReturnItem,
Union,
)
MATCH = Match(
Pattern(items=NonEmptySequence[PatternPart](PatternPart(
PatternElement(NodePattern(), ), ), ), ), )
@parameterized([
(
None,
"RETURN foo",
dict(),
),
(
MATCH,
"MATCH () RETURN foo",
dict(),
),
])
def test_read(reading_clause, query, parameters):