query_spec.exs

defmodule Neo.QueryTest do
  use ExUnit.Case

  import Neo.Query

  test "generates a simple match + return query" do
    query = new_query
            |> labels(yo: "yeah/man", dude: "nah")
            |> return([:yo])

    {cypher, params} = to_cypher(query)

    expected_cypher = """
    MATCH
      (yo: `yeah/man`),
      (dude: `nah`)
    RETURN yo
    """ |> String.strip

    assert cypher == expected_cypher
    assert params == %{}
  end

  test "adding set clauses" do
    query = new_query
            |> labels(user: "user")
            |> where("user.uuid = {uuid}", uuid: 123)
            |> return(:user)
            |> set("user.email = {email}", email: "john@hotmail.com")

    {cypher, params} = to_cypher(query)

    expected_cypher = """
    MATCH
      (user: `user`)
    WHERE
      user.uuid = {uuid}
    SET
      user.email = {email}
    RETURN user
    """ |> String.strip

    assert cypher == expected_cypher
    assert params == %{uuid: 123, email: "john@hotmail.com"}
  end

  test "ordering queries" do
    query = new_query
            |> labels(user: "user")
            |> return(:user)
            |> order("user.age")

    {cypher, _} = to_cypher(query)

    expected_cypher = """
    MATCH
      (user: `user`)
    RETURN user
    ORDER BY user.age
    """ |> String.strip

    assert cypher == expected_cypher
  end

  test "adding a limit" do
    query = new_query
            |> labels(user: "user")
            |> return(:user)
            |> limit(5)
            |> order("user.age")

    {cypher, _} = to_cypher(query)

    expected_cypher = """
    MATCH
      (user: `user`)
    RETURN user
    ORDER BY user.age
    LIMIT 5
    """ |> String.strip

    assert cypher == expected_cypher
  end

  test "match and where conditions" do
    query = new_query
            |> labels(user: "user", enemy: "user")
            |> where("user.uuid = {user_uuid}", user_uuid: "abc123")
            |> match("(user)-[r:hates]->(enemy)")
            |> match("(enemy)-[:loves]->(user)")
            |> return([:user, :r, :enemy])

    {cypher, params} = to_cypher(query)

    expected_cypher = """
    MATCH
      (user: `user`),
      (enemy: `user`),
      (user)-[r:hates]->(enemy),
      (enemy)-[:loves]->(user)
    WHERE
      user.uuid = {user_uuid}
    RETURN user, r, enemy
    """ |> String.strip

    assert cypher == expected_cypher
    assert params == %{user_uuid: "abc123"}
  end

  test "where conditions with no params" do
    query = new_query
            |> labels(user: "user")
            |> where("user.age = 99")
            |> return(:user)

    {cypher, params} = to_cypher(query)

    expected_cypher = """
    MATCH
      (user: `user`)
    WHERE
      user.age = 99
    RETURN user
    """ |> String.strip

    assert cypher == expected_cypher
    assert params == %{}
  end

  test "create statement" do
    query = new_query
            |> create("(n {attrs})", attrs: %{name: "bob", age: 25})
            |> return(:n)

    {cypher, params} = to_cypher(query)

    expected_cypher = """
    CREATE
      (n {attrs})
    RETURN n
    """ |> String.strip

    assert cypher == expected_cypher
    assert params == %{attrs: %{name: "bob", age: 25}}
  end

  test "delete clause" do
    query = new_query
            |> labels(user: "user")
            |> where("user.uuid = {user_uuid}", user_uuid: "abc123")
            |> delete("user")

    {cypher, params} = to_cypher(query)

    expected_cypher = """
    MATCH
      (user: `user`)
    WHERE
      user.uuid = {user_uuid}
    DELETE
      user
    """ |> String.strip

    assert cypher == expected_cypher
    assert params == %{user_uuid: "abc123"}
  end

  test "optional matches" do
    user_query = new_query
               |> labels(user: "user")
               |> where("user.uuid = {user_uuid}", user_uuid: "abc123")
               |> return(:user)

    friend_query = new_query
               |> labels(friend: "user")
               |> match("(user)-[:friends_with]->(friend)")
               |> where("friend.status = {friend_status}", friend_status: "active")
               |> return(:friend)

    combined_query = optional_match(user_query, friend_query)

    {cypher, params} = to_cypher(combined_query)

    expected_cypher = """
    MATCH
      (user: `user`)
    WHERE
      user.uuid = {user_uuid}
    OPTIONAL MATCH
      (friend: `user`),
      (user)-[:friends_with]->(friend)
    WHERE
      friend.status = {friend_status}
    RETURN user, friend
    """ |> String.strip

    assert cypher == expected_cypher
    assert params == %{friend_status: "active", user_uuid: "abc123"}
  end

end