CypherQueryTests.cs

namespace CypherNet.UnitTests
{
    #region

    using System;
    using System.Linq;
    using System.Linq.Expressions;
    using Dynamic4Neo.Tests;
    using Microsoft.VisualStudio.TestTools.UnitTesting;
    using Moq;
    using Queries;
    using Transaction;

    #endregion

    [TestClass]
    public class CypherQueryTests
    {
        [TestMethod]
        public void BuildCypherQuery_WithStartAndMatch_ExecutesCorrectQuery()
        {
            FluentCypherQueryBuilder<TestCypherClause> query;
            var cypher = SetupMocks(out query);

            var results = query
                .Start(ctx => ctx.StartAtId(ctx.Vars.movie, 1))
                .Match(ctx => ctx.Node(ctx.Vars.movie).Incoming("STARED_IN", 1, 5).From(ctx.Vars.actor))
                .Return(ctx => new { ctx.Vars.actor, ctx.Vars.movie })
                .Fetch();

            VerifyCypher(cypher, results.FirstOrDefault(),
                         "START movie=node(1) MATCH (movie)<-[:STARED_IN*1..5]-(actor) RETURN actor as actor, id(actor) as actor__Id, labels(actor) as actor__Labels, movie as movie, id(movie) as movie__Id, labels(movie) as movie__Labels");
        }

        [TestMethod]
        public void BuildCypherQuery_WithSimpleReturn_ExecutesCorrectQuery()
        {
            FluentCypherQueryBuilder<TestCypherClause> query;
            var cypher = SetupMocks(out query);

            var results = query
                .Start(ctx => ctx.StartAtId(ctx.Vars.movie, 1))
                .Return(ctx => ctx.Vars.movie)
                .Fetch();

            VerifyCypher(cypher, results.FirstOrDefault(),
                         "START movie=node(1) RETURN movie as movie, id(movie) as movie__Id, labels(movie) as movie__Labels");
        }


        [TestMethod]
        public void BuildCypherQuery_ReturnsScalarValues_ExecutesCorrectQuery()
        {
            FluentCypherQueryBuilder<TestCypherClause> query;
            var cypher = SetupMocks(out query);

            var results = query
                .Start(ctx => ctx.StartAtId(ctx.Vars.movie, 1))
                .Return(ctx => new { ctx.Vars.movie, someVal = 1 })
                .Fetch();

            VerifyCypher(cypher, results.FirstOrDefault(),
                         "START movie=node(1) RETURN movie as movie, id(movie) as movie__Id, labels(movie) as movie__Labels, 1 as someVal");
        }

        [TestMethod]
        public void BuildCypherQuery_WithSimpleDelete_ExecutesCorrectQuery()
        {
            FluentCypherQueryBuilder<TestCypherClause> query;
            var cypher = SetupMocks(out query);
           
            query
                .Start(ctx => ctx.StartAtId(ctx.Vars.movie, 1))
                .Match(ctx => ctx.Node(ctx.Vars.movie).Incoming("STARED_IN", 1, 5).From(ctx.Vars.actor))
                .Delete(v => v.actor)
                .Execute();

            VerifyCypher(cypher, "START movie=node(1) MATCH (movie)<-[:STARED_IN*1..5]-(actor) DELETE actor");
        }

        [TestMethod]
        public void BuildCypherQuery_WithComplexDelete_ExecutesCorrectQuery()
        {
            FluentCypherQueryBuilder<TestCypherClause> query;
            var cypher = SetupMocks(out query);

            query
                .Start(ctx => ctx.StartAtId(ctx.Vars.movie, 1))
                .Match(ctx => ctx.Node(ctx.Vars.movie).Incoming("STARED_IN", 1, 5).From(ctx.Vars.actor))
                .Delete(v => new { v.actor, v.movie })
                .Execute();

            VerifyCypher(cypher, "START movie=node(1) MATCH (movie)<-[:STARED_IN*1..5]-(actor) DELETE actor, movie");
        }

        [TestMethod]
        public void BuildCypherQuery_UsingSetMethod_ExecutesCorrectQuery()
        {
            FluentCypherQueryBuilder<TestCypherClause> query;
            var cypher = SetupMocks(out query);

            var results = query
                .Match(ctx => ctx.NodeLabelled(ctx.Vars.movie, "arthouse"))
                .Update(ctx => ctx.Set(ctx.Vars.movie, "requiresSubtitles", "yes"))
                .Return(ctx => new {ctx.Vars.actor, ctx.Vars.movie})
                .Fetch();

            VerifyCypher(cypher, results.FirstOrDefault(),
                         @"MATCH (movie:arthouse) SET movie.requiresSubtitles = ""yes"" RETURN actor as actor, id(actor) as actor__Id, labels(actor) as actor__Labels, movie as movie, id(movie) as movie__Id, labels(movie) as movie__Labels");
        }

        [TestMethod]
        public void BuildCypherQuery_CreateRelationship_ExecutesCorrectQuery()
        {
            FluentCypherQueryBuilder<TestCypherClause> query;
            var cypher = SetupMocks(out query);

            var results = query
                .Start(ctx => ctx.StartAtId(ctx.Vars.actor, 1).StartAtId(ctx.Vars.movie, 2))
                .Create(ctx => ctx.CreateRel(ctx.Vars.actor, ctx.Vars.actedIn, "ACTED_IN", ctx.Vars.movie))
                .Return(ctx => ctx.Vars.actedIn)
                .Fetch();

            VerifyCypher(cypher, results.FirstOrDefault(),
                         "START actor=node(1), movie=node(2) CREATE (actor)-[actedIn:ACTED_IN]->(movie) RETURN actedIn as actedIn, id(actedIn) as actedIn__Id, type(actedIn) as actedIn__Type");
        }

        [TestMethod]
        public void BuildCypherQuery_ReturnScalarProperty_ExecutesCorrectQuery()
        {
            FluentCypherQueryBuilder<TestCypherClause> query;
            var cypher = SetupMocks(out query);

            var results = query
                .Start(ctx => ctx.StartAtId(ctx.Vars.movie, 2))
                .Return(ctx => new { movieName = ctx.Prop(ctx.Vars.movie, "movieName") })
                .Fetch();

            VerifyCypher(cypher, results.FirstOrDefault(),
                         "START movie=node(2) RETURN movie.movieName as movieName");
        }

        [TestMethod]
        public void BuildCypherQuery_CreateRelationshipWithProperties_ExecutesCorrectQuery()
        {
            FluentCypherQueryBuilder<TestCypherClause> query;
            var cypher = SetupMocks(out query);
            var results = query
                .Start(ctx => ctx.StartAtId(ctx.Vars.actor, 1).StartAtId(ctx.Vars.movie, 2))
                .Create(ctx => ctx.CreateRel(ctx.Vars.actor, ctx.Vars.actedIn, "ACTED_IN", new { name = "mark" }, ctx.Vars.movie))
                .Return(ctx => new { ctx.Vars.actedIn })
                .Fetch();

            VerifyCypher(cypher, results.FirstOrDefault(),
                         @"START actor=node(1), movie=node(2) CREATE (actor)-[actedIn:ACTED_IN {name:""mark""}]->(movie) RETURN actedIn as actedIn, id(actedIn) as actedIn__Id, type(actedIn) as actedIn__Type");
        }

        [TestMethod]
        public void BuildCypherQuery_CreateRelationshipWithFloatProperty_SerializesValueWithDotNotComma()
        {
            FluentCypherQueryBuilder<TestCypherClause> query;
            var cypher = SetupMocks(out query);
            var results = query
                .Start(ctx => ctx
                    .StartAtId(ctx.Vars.actor, 1)
                    .StartAtId(ctx.Vars.movie, 2))
                .Create(ctx => ctx.CreateRel(ctx.Vars.actor, ctx.Vars.actedIn, "HAS_RATE", new { rate = 4.56 }, ctx.Vars.movie))
                .Return(ctx => new { ctx.Vars.actedIn })
                .Fetch();

            VerifyCypher(cypher, results.FirstOrDefault(), 
                @"START actor=node(1), movie=node(2) CREATE (actor)-[actedIn:HAS_RATE {rate:4.56}]->(movie) RETURN actedIn as actedIn, id(actedIn) as actedIn__Id, type(actedIn) as actedIn__Type");
        }

        [TestMethod]
        public void BuildCypherQuery_WithStartMatchWhere_ExecutesCorrectQuery()
        {
            FluentCypherQueryBuilder<TestCypherClause> query;
            var cypher = SetupMocks(out query);

            var results = query
                .Start(ctx => ctx.StartAtAny(ctx.Vars.movie))
                .Match(ctx => ctx.Node(ctx.Vars.movie).Incoming("STARED_IN").From(ctx.Vars.actor))
                .Where(ctx => ctx.Prop(ctx.Vars.actor, "name") == "Bob Dinero" || ctx.Prop(ctx.Vars.actor, "role") == "Keyser Söze")
                .Return(ctx => new { ctx.Vars.actor, ctx.Vars.movie })
                .Fetch();

            VerifyCypher(cypher, results.FirstOrDefault(),
                         "START movie=node(*) MATCH (movie)<-[:STARED_IN]-(actor) WHERE ((actor.name = 'Bob Dinero') OR (actor.role = 'Keyser Söze')) RETURN actor as actor, id(actor) as actor__Id, labels(actor) as actor__Labels, movie as movie, id(movie) as movie__Id, labels(movie) as movie__Labels");
        }

        [TestMethod]
        public void BuildCypherQuery_MatchByLabel_ExecutesCorrectQuery()
        {
            FluentCypherQueryBuilder<TestCypherClause> query;
            var cypher = SetupMocks(out query);
            var results = query
                .Match(ctx =>
                       ctx.NodeLabelled(ctx.Vars.actor, "METHOD_ACTOR")
                              .Outgoing("STARED_IN")
                              .To()
                              .Outgoing(ctx.Vars.directedBy, "DIRECTED_BY")
                              .To(ctx.Vars.director))
                .Return(ctx => new { ctx.Vars.actor, ctx.Vars.director })
                .Fetch();

            VerifyCypher(cypher, results.FirstOrDefault(),
                         "MATCH (actor:METHOD_ACTOR)-[:STARED_IN]->()-[directedBy:DIRECTED_BY]->(director) RETURN actor as actor, id(actor) as actor__Id, labels(actor) as actor__Labels, director as director, id(director) as director__Id, labels(director) as director__Labels");
        }

        [TestMethod]
        public void BuildCypherQuery_StartAtNodeN_ExecutesCorrectQuery()
        {
            FluentCypherQueryBuilder<TestCypherClause> query;
            var cypher = SetupMocks(out query);
            var results = query
                .Start(ctx => ctx.StartAtId(ctx.Vars.actor, 1))
                .Return(ctx => new { ctx.Vars.actor })
                .OrderBy(p => p.actedIn.Get<int>("fgds"), p => p.actedIn.Get<string>("name"))
                .Skip(2)
                .Limit(1)
                .Fetch();

            VerifyCypher(cypher, results.FirstOrDefault(),
                         "START actor=node(1) RETURN actor as actor, id(actor) as actor__Id, labels(actor) as actor__Labels ORDER BY actedIn.fgds, actedIn.name SKIP 2 LIMIT 1");
        }

        [TestMethod]
        public void BuildCypherQuery_WhereNot_ExecutesCorrectQuery()
        {
            FluentCypherQueryBuilder<TestCypherClause> query;
            var cypher = SetupMocks(out query);
            var results = query
                .Start(ctx => ctx.StartAtId(ctx.Vars.actor, 1))
                .Match(ctx => ctx.Node(ctx.Vars.actor).Outgoing("STARED_IN", 0).To(ctx.Vars.movie))
                ////.Where(ctx => ctx.Not(ctx.Node(ctx.Vars.movie).Outgoing("DIRECTED_BY").To(ctx.Vars.director)))
                .Where(ctx => ctx.Clause("not movie-[:DIRECTED_BY]->director"))
                .Return(ctx => ctx.Vars.movie)
                .Fetch();

            VerifyCypher(cypher, results.FirstOrDefault(),
                         "START actor=node(1) MATCH (actor)-[:STARED_IN*0..]->(movie) WHERE not movie-[:DIRECTED_BY]->director RETURN movie as movie, id(movie) as movie__Id, labels(movie) as movie__Labels");
        }

        [TestMethod]
        public void BuildCypherQuery_OptionalMatch_ExecutesCorrectQuery()
        {
            FluentCypherQueryBuilder<TestCypherClause> query;
            var cypher = SetupMocks(out query);
            var results = query
                .Start(ctx => ctx.StartAtId(ctx.Vars.actor, 1))
                .Match(ctx => ctx.Node(ctx.Vars.actor).Outgoing("STARED_IN", 0).To(ctx.Vars.movie))
                .OptionalMatch(ctx => ctx.Node(ctx.Vars.movie).Incoming("DIRECTED_BY").From(ctx.Vars.director))
                .Return(ctx => new { ctx.Vars.movie })
                .Fetch();

            VerifyCypher(cypher, results.FirstOrDefault(),
                         "START actor=node(1) MATCH (actor)-[:STARED_IN*0..]->(movie) OPTIONAL MATCH (movie)<-[:DIRECTED_BY]-(director) RETURN movie as movie, id(movie) as movie__Id, labels(movie) as movie__Labels");
        }

        private static Mock<ICypherClient> SetupMocks(out FluentCypherQueryBuilder<TestCypherClause> query)
        {
            var cypher = new Mock<ICypherClient>();
            cypher.Setup(c => c.ExecuteQuery<TestCypherClause>(It.IsAny<string>())).Returns(() => null);
            var factory = new Mock<ICypherClientFactory>();
            factory.Setup(f => f.Create()).Returns(cypher.Object);
            query = new FluentCypherQueryBuilder<TestCypherClause>(factory.Object);
            return cypher;
        }

        private void VerifyCypher<TResult>(Mock<ICypherClient> mock, TResult proto, string query)
        {
            mock.Verify(
                        c =>
                        c.ExecuteQuery<TResult>(query));
        }

        private void VerifyCypher(Mock<ICypherClient> mock, string query)
        {
            mock.Verify(
                        c =>
                        c.ExecuteCommand(query));
        }
    }
}