Test easy query DSL

easy_query_test.exs

defmodule DynaQuery.EasyTest do
  use ExUnit.Case, async: true
  require Ecto.Query
  alias Ecto.Query, as: Q

  alias Haas.HomeAssessment
  alias Haas.HomeAssessmentSponsor
  alias Haas.HomePaint
  alias DynaQuery.Easy
  alias DynaQuery.Easy.Table

  test "query with FROM" do
    query_state = Easy.from({HomeAssessment, :ha})

    assert query_state.tables == [%Table{schema: HomeAssessment, name: "home_assessments", table_alias: :ha}]
    query = Easy.build_query(query_state)
    assert query == Q.from(ha in HomeAssessment)
  end

  test "query with WHERE" do
    query =
      Easy.from({HomeAssessment, :ha})
      |> Easy.where({:==, [ha: :id], 2})
      |> Easy.build_query
    assert inspect(query) == inspect(Q.from(ha in HomeAssessment, where: ha.id == 2))
  end

  test "query with WHERE and placeholder value" do
    query =
      Easy.from({HomeAssessment, :ha})
      |> Easy.where({:==, [ha: :id], {:^, 2}})
      |> Easy.build_query
    id = 2
    expected = Q.from(ha in HomeAssessment, where: ha.id == ^id)
    assert inspect(query) == inspect(expected)
  end

  test "query with multiple WHEREs" do
    query =
      Easy.from({HomeAssessment, :ha})
      |> Easy.where({:>=, [ha: :id], 1})
      |> Easy.where({:<=, [ha: :id], 10})
      |> Easy.build_query
    assert inspect(query) == inspect(Q.from(ha in HomeAssessment, where: ha.id >= 1, where: ha.id <= 10))
  end

  test "query with JOIN" do
    query =
      Easy.from({HomeAssessment, :ha})
      |> Easy.join({HomeAssessmentSponsor, :s}, on: {:==, [s: :home_assessment_id], [ha: :id]})
      |> Easy.build_query
    expected_query = Q.from(
      ha in HomeAssessment,
      join: s in HomeAssessmentSponsor,
      on: s.home_assessment_id == ha.id)
    assert inspect(query) == inspect(expected_query)
  end

  test "query with multiple JOINs" do
    query =
      Easy.from({HomeAssessment, :ha})
      |> Easy.join({HomeAssessmentSponsor, :s}, on: {:==, [s: :home_assessment_id], [ha: :id]})
      |> Easy.join({HomePaint, :p}, on: {:==, [p: :home_assessment_id], [ha: :id]})
      |> Easy.build_query
    expected_query = Q.from(
      ha in HomeAssessment,
      join: s in HomeAssessmentSponsor,
      on: s.home_assessment_id == ha.id,
      join: p in HomePaint,
      on: p.home_assessment_id == ha.id)
    assert inspect(query) == inspect(expected_query)
  end

  test "with assoc JOIN" do
    query =
      Easy.from({HomeAssessment, :ha})
      |> Easy.join({HomeAssessmentSponsor, :s}, assoc: {:ha, :home_assessment_sponsors})
      |> Easy.build_query
    expected_query = Q.from(
      ha in HomeAssessment,
      join: assoc(ha, :home_assessment_sponsors))
    assert inspect(query) == inspect(expected_query)
  end

  test "clause, with FROM clause" do
    clause = [:from, {HomeAssessment, :ha}]
    query =
      Easy.start_query
      |> Easy.clause(clause)
      |> Easy.build_query
    expected_query = Q.from(ha in HomeAssessment)
    assert inspect(query) == inspect(expected_query)
  end

  test "clause, with JOIN clauses" do
    query =
      Easy.start_query
      |> Easy.clause([:from, {HomeAssessment, :ha}])
      |> Easy.clause([:join, {HomeAssessmentSponsor, :s}, [on: {:==, [s: :home_assessment_id], [ha: :id]}]])
      |> Easy.clause([:join, {HomePaint, :p}, [on: {:==, [p: :home_assessment_id], [ha: :id]}]])
      |> Easy.build_query
    expected_query = Q.from(ha in HomeAssessment,
      join: s in HomeAssessmentSponsor,
      on: s.home_assessment_id == ha.id,
      join: p in HomePaint,
      on: p.home_assessment_id == ha.id)
    assert inspect(query) == inspect(expected_query)
  end

  test "clause, with WHERE clause" do
    query =
      Easy.start_query
      |> Easy.clause([:from, {HomeAssessment, :ha}])
      |> Easy.clause([:where, {:==, [ha: :id], 2}])
      |> Easy.build_query
    expected_query = Q.from(
      ha in HomeAssessment,
      where: ha.id == 2)
    assert inspect(query) == inspect(expected_query)
  end

  test "build_query with multiple clauses" do
    query =
      Easy.build_query([
        [:from, {HomeAssessment, :ha}],
        [:where, {:>=, [ha: :id], 1}],
        [
          :join,
          {HomeAssessmentSponsor, :s},
          [on: {:==, [s: :home_assessment_id], [ha: :id]}]
        ]
      ])
    expected_query = Q.from(
      ha in HomeAssessment,
      join: s in HomeAssessmentSponsor, on: s.home_assessment_id == ha.id,
      where: ha.id >= 1)
    assert inspect(query) == inspect(expected_query)
  end
end