public void MultipleMatchClausesWithPairedWhereClauses()
        {
            // MATCH (n)
            // WHERE n.Foo = {p0}
            // OPTIONAL MATCH (n)--(x)
            // WHERE x.Bar = {p1}
            // OPTIONAL MATCH (x)--(a)
            // WHERE a.Baz = {p2}
            // RETURN n, x

            var client = Substitute.For<IRawGraphClient>();
            var query = new CypherFluentQuery(client)
                .Match("(n)")
                .Where((FooBarBaz n) => n.Foo == "abc")
                .OptionalMatch("(n)--(x)")
                .Where((FooBarBaz x) => x.Bar == "def")
                .OptionalMatch("(x)--(a)")
                .Where((FooBarBaz a) => a.Baz == "ghi")
                .Query;

            const string expected = "MATCH (n)\r\nWHERE (n.Foo = {p0})\r\nOPTIONAL MATCH (n)--(x)\r\nWHERE (x.Bar = {p1})\r\nOPTIONAL MATCH (x)--(a)\r\nWHERE (a.Baz = {p2})";

            Assert.AreEqual(expected, query.QueryText);
            Assert.AreEqual(3, query.QueryParameters.Count());
        }

        public void ThrowsInvalidOperationException_WhenClientVersionIsLessThan_30()
        {
            var client = GraphClient_30;
            client.CypherCapabilities.Returns(CypherCapabilities.Cypher23);

            Assert.Throws<InvalidOperationException>(() => { var query = new CypherFluentQuery(client).Yield("uuid").Query; });
        }

        public void ThrowsExceptionWhenUriIsNull()
        {
            var client = Substitute.For<IRawGraphClient>();
            var query = new CypherFluentQuery(client);

            Assert.Throws<ArgumentException>(() => query.LoadCsv(null, "row"));
        }

        public void UsesJsonPropertyNameOverPropertyName()
        {
            var client = Substitute.For<IRawGraphClient>();
            var query = new CypherFluentQuery(client).Where((FooWithJsonProperties foo) => foo.Bar == "Bar").Query;

            Assert.AreEqual("WHERE (foo.bar = {p0})", query.QueryText);
        }

 public CypherExtensionTestHelper SetupGraphClient()
 {
     GraphClient = new Mock<IRawGraphClient>();
     GraphClient.Setup(x => x.JsonContractResolver).Returns(new DefaultContractResolver());
     Query = new CypherFluentQuery(GraphClient.Object);
     return this;
 }

        public void ExecutingQueryMultipleTimesShouldResetParameters()
        {
            var client = Substitute.For<IRawGraphClient>();

            client
                .ExecuteGetCypherResults<ReturnPropertyQueryResult>(Arg.Any<CypherQuery>())
                .Returns(Enumerable.Empty<ReturnPropertyQueryResult>());

            var cypher = new CypherFluentQuery(client);
            var query1 = cypher
                .Start("a", (NodeReference)1)
                .Return<object>("a.Name")
                .Query;

            Assert.AreEqual(1, query1.QueryParameters.Count());
            Assert.AreEqual(1, query1.QueryParameters["p0"]);

            var query2 = cypher
                .Start("b", (NodeReference)2)
                .Return<object>("a.Name")
                .Query;

            Assert.AreEqual(1, query2.QueryParameters.Count());
            Assert.AreEqual(2, query2.QueryParameters["p0"]);
        }

        public void ComplexObjectInWithParam()
        {
            // Arrange
            var client = Substitute.For<IRawGraphClient>();

            // Act
            var query = new CypherFluentQuery(client)
                .Start("n", (NodeReference) 3)
                .CreateUnique("n-[:X]-(leaf {obj})")
                .WithParam("obj", new ComplexObjForWithParamTest
                                  {
                                      Id = 123,
                                      Name = "Bar",
                                      Currency = (decimal) 12.143
                                  })
                .Query;

            // Assert
            Assert.AreEqual("START n=node(3)" +
                            "\r\nCREATE UNIQUE n-[:X]-(leaf {" +
                            "\r\n  \"Id\": 123," +
                            "\r\n  \"Name\": \"Bar\"," +
                            "\r\n  \"Currency\": 12.143" +
                            "\r\n})", query.DebugQueryText);
            Assert.AreEqual(2, query.QueryParameters.Count);
        }

 public void ThrowInvalidOperationException_WhenAttemptingToDeleteProperty()
 {
     var client = GraphClient_230;
     var query = new CypherFluentQuery(client)
         .DetachDelete("andres.age")
         .Return<Node<object>>("andres")
         .Query;
 }

 public void ThrowArgumentException_WhenNoStoredProcedureIsGiven()
 {
     var client = GraphClient_30;
     Assert.Throws<ArgumentException>(() =>
     {
         var query = new CypherFluentQuery(client).Yield(null).Query;
     });
 }

        public void TestUnwindConstruction()
        {
            var client = Substitute.For<IRawGraphClient>();
            var query = new CypherFluentQuery(client)
                .Unwind("collection", "column")
                .Query;

            Assert.AreEqual("UNWIND collection AS column", query.QueryText);
        }

        public void ShouldReturnSpecificPropertyTakingIntoAccountJsonProperty()
        {
            var client = Substitute.For<IRawGraphClient>();
            var query = new CypherFluentQuery(client)
                .With(a => a.As<Cypher.FooWithJsonProperties>().Bar)
                .Query;

            Assert.AreEqual("WITH a.bar", query.QueryText);
        }

        public void CallsStoredProcedureGiven()
        {
            var client = GraphClient_30;
            var query = new CypherFluentQuery(client)
                .Call("apoc.sp()")
                .Query;

            Assert.AreEqual("CALL apoc.sp()", query.QueryText);
        }

        public void ShouldReturnSpecificPropertyOnItsOwn()
        {
            var client = Substitute.For<IRawGraphClient>();
            var query = new CypherFluentQuery(client)
                .With(a => a.As<Commodity>().Name)
                .Query;

            Assert.AreEqual("WITH a.Name", query.QueryText);
        }

        public void ShouldTranslateAnonymousObjectWithImplicitPropertyNames()
        {
            var client = Substitute.For<IRawGraphClient>();
            var query = new CypherFluentQuery(client)
                .With(a => new { a })
                .Query;

            Assert.AreEqual("WITH a", query.QueryText);
        }

        public void ShouldReturnCountOnItsOwn()
        {
            var client = Substitute.For<IRawGraphClient>();
            var query = new CypherFluentQuery(client)
                .With(item => item.Count())
                .Query;

            Assert.AreEqual("WITH count(item)", query.QueryText);
        }

        public void ShouldReturnCustomFunctionCall()
        {
            var client = Substitute.For<IRawGraphClient>();
            var query = new CypherFluentQuery(client)
                .With(() => new { baz = "sum(foo.bar)" })
                .Query;

            Assert.AreEqual("WITH sum(foo.bar) AS baz", query.QueryText);
        }

        public void ThrowsInvalidOperationException_WhenNeo4jVersionIsLessThan22()
        {
            var client = Substitute.For<IRawGraphClient>();
            client.CypherCapabilities.Returns(CypherCapabilities.Cypher19);

            var _ = new CypherFluentQuery(client)
                .Planner("FreePlanner")
                .Query;
        }

        public void YieldsGivenText()
        {
            var client = GraphClient_30;
            var query = new CypherFluentQuery(client)
                .Yield("uuid")
                .Query;

            Assert.AreEqual("YIELD uuid", query.QueryText);
        }

        public void BinaryExpressionIsNull()
        {
            var client = Substitute.For<IRawGraphClient>();
            var query = new CypherFluentQuery(client)
                .Match("(a)")
                .Return(a => new { IsNull = a == null })
                .Query;

            Assert.AreEqual("MATCH (a)\r\nRETURN a IS NULL AS IsNull", query.QueryText);
        }

        public void ShouldReturnSpecificPropertyOnItsOwnCamelAs()
        {
            var client = Substitute.For<IRawGraphClient>();
            client.JsonContractResolver = new CamelCasePropertyNamesContractResolver();
            var query = new CypherFluentQuery(client)
                .With(a => new Commodity(){ Name = a.As<Commodity>().Name})
                .Query;

            Assert.AreEqual("WITH a.name? AS Name", query.QueryText);
        }