active_record_extended 2.0.3 → 2.2.0

data/spec/query_methods/either_spec.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.describe "Active Record Either Methods" do
-  let!(:one)       { User.create! }
-  let!(:two)       { User.create! }
-  let!(:three)     { User.create! }
-  let!(:profile_l) { ProfileL.create!(user_id: one.id, likes: 100) }
-  let!(:profile_r) { ProfileR.create!(user_id: two.id, dislikes: 50) }
-
-  describe ".either_join/2" do
-    it "Should only only return records that belong to profile L or profile R" do
-      query = User.either_join(:profile_l, :profile_r)
-      expect(query).to include(one, two)
-      expect(query).to_not include(three)
-    end
-
-    context "Alias .either_joins/2" do
-      it "Should only only return records that belong to profile L or profile R" do
-        query = User.either_joins(:profile_l, :profile_r)
-        expect(query).to include(one, two)
-        expect(query).to_not include(three)
-      end
-    end
-
-    context "Through association .either_joins/2" do
-      let!(:four) { User.create! }
-      let!(:group) { Group.create!(users: [four]) }
-
-      it "Should only only return records that belong to profile L or has group" do
-        query = User.either_joins(:profile_l, :groups)
-        expect(query).to include(one, four)
-        expect(query).to_not include(three, two)
-      end
-    end
-  end
-
-  describe ".either_order/2" do
-    it "Should not exclude anyone who does not have a relationship" do
-      query = User.either_order(:asc, profile_l: :likes, profile_r: :dislikes)
-      expect(query.count).to eq(3)
-      expect(query[0]).to eq(two)
-      expect(query[1]).to eq(one)
-      expect(query[2]).to eq(three)
-    end
-
-    it "Should order users based on their likes and dislikes in ascended order" do
-      query = User.either_order(:asc, profile_l: :likes, profile_r: :dislikes).where(id: [one.id, two.id])
-      expect(query.count).to eq(2)
-      expect(query.first).to eq(two)
-      expect(query.last).to eq(one)
-    end
-
-    it "Should order users based on their likes and dislikes in descending order" do
-      query = User.either_order(:desc, profile_l: :likes, profile_r: :dislikes).where(id: [one.id, two.id])
-      expect(query.first).to eq(one)
-      expect(query.last).to eq(two)
-    end
-
-    context "Alias .either_order/2" do
-      it "Should order users based on their likes and dislikes in ascended order" do
-        query = User.either_orders(:asc, profile_l: :likes, profile_r: :dislikes).where(id: [one.id, two.id])
-        expect(query.count).to eq(2)
-        expect(query.first).to eq(two)
-        expect(query.last).to eq(one)
-      end
-    end
-  end
-end

data/spec/query_methods/hash_query_spec.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.describe "Active Record Hash Related Query Methods" do
-  let!(:one)   { User.create!(data: { nickname: "george" }, jsonb_data: { payment: "zip" }) }
-  let!(:two)   { User.create!(data: { nickname: "dan"    }, jsonb_data: { payment: "zipper" }) }
-  let!(:three) { User.create!(data: { nickname: "georgey" }) }
-
-  describe "#contains" do
-    context "HStore Column Type" do
-      it "returns records that contain hash elements in joined tables" do
-        tag_one = Tag.create!(user_id: one.id)
-        tag_two = Tag.create!(user_id: two.id)
-
-        query = Tag.joins(:user).where.contains(users: { data: { nickname: "george" } })
-        expect(query).to include(tag_one)
-        expect(query).to_not include(tag_two)
-      end
-
-      it "returns records that contain hash value" do
-        query = User.where.contains(data: { nickname: "george" })
-        expect(query).to include(one)
-        expect(query).to_not include(two, three)
-      end
-    end
-
-    context "JSONB Column Type" do
-      it "returns records that contains a json hashed value" do
-        query = User.where.contains(jsonb_data: { payment: "zip" })
-        expect(query).to include(one)
-        expect(query).to_not include(two, three)
-      end
-
-      it "returns records that contain jsonb elements in joined tables" do
-        tag_one = Tag.create!(user_id: one.id)
-        tag_two = Tag.create!(user_id: two.id)
-
-        query = Tag.joins(:user).where.contains(users: { jsonb_data: { payment: "zip" } })
-        expect(query).to include(tag_one)
-        expect(query).to_not include(tag_two)
-      end
-    end
-  end
-end

data/spec/query_methods/inet_query_spec.rb

@@ -1,112 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.describe "Active Record Inet Query Methods" do
-  before { stub_const("User", Namespaced::Record) }
-
-  describe "#inet_contained_within" do
-    let!(:local_1)     { User.create!(ip: "127.0.0.1") }
-    let!(:local_44)    { User.create!(ip: "127.0.0.44") }
-    let!(:local_99_1)  { User.create!(ip: "127.0.99.1") }
-    let!(:local_range) { User.create!(ip: "127.0.0.1/10") }
-
-    it "Should return users who have an IP within the 127.0.0.1/24 range" do
-      query = User.where.inet_contained_within(ip: "127.0.0.1/24")
-      expect(query).to include(local_1, local_44)
-      expect(query).to_not include(local_99_1, local_range)
-    end
-
-    it "Should return all users who have an IP within the 127.0.0.1/16 range" do
-      query = User.where.inet_contained_within(ip: "127.0.0.1/16")
-      expect(query).to include(local_1, local_44, local_99_1)
-      expect(query).to_not include(local_range)
-    end
-  end
-
-  describe "inet_contained_within_or_equals" do
-    let!(:local_1)    { User.create!(ip: "127.0.0.1/10") }
-    let!(:local_44)   { User.create!(ip: "127.0.0.44/32") }
-    let!(:local_99_1) { User.create!(ip: "127.0.99.1") }
-
-    it "Should find records that contain a matching submask" do
-      query = User.where.inet_contained_within_or_equals(ip: "127.0.0.44/32")
-      expect(query).to include(local_44)
-      expect(query).to_not include(local_1, local_99_1)
-    end
-
-    it "Should find records that are within range of a given submask" do
-      query = User.where.inet_contained_within_or_equals(ip: "127.0.0.1/16")
-      expect(query).to include(local_44, local_99_1)
-      expect(query).to_not include(local_1)
-
-      query = User.where.inet_contained_within_or_equals(ip: "127.0.0.1/8")
-      expect(query).to include(local_1, local_44, local_99_1)
-    end
-  end
-
-  describe "#inet_contains_or_equals" do
-    let!(:local_1)    { User.create!(ip: "127.0.0.1/10") }
-    let!(:local_44)   { User.create!(ip: "127.0.0.44/24") }
-    let!(:local_99_1) { User.create!(ip: "127.0.99.1") }
-
-    it "Should find records with submask ranges that contain a given IP" do
-      query = User.where.inet_contains_or_equals(ip: "127.0.255.255")
-      expect(query).to include(local_1)
-      expect(query).to_not include(local_44, local_99_1)
-
-      query = User.where.inet_contains_or_equals(ip: "127.0.0.255")
-      expect(query).to include(local_1, local_44)
-      expect(query).to_not include(local_99_1)
-    end
-
-    it "Finds records when querying with a submasked value" do
-      query = User.where.inet_contains_or_equals(ip: "127.0.0.1/10")
-      expect(query).to include(local_1)
-      expect(query).to_not include(local_44, local_99_1)
-
-      query = User.where.inet_contains_or_equals(ip: "127.0.0.1/32")
-      expect(query).to include(local_1, local_44)
-      expect(query).to_not include(local_99_1)
-    end
-  end
-
-  describe "#inet_contains" do
-    let!(:local_1)    { User.create!(ip: "127.0.0.1/10") }
-    let!(:local_44)   { User.create!(ip: "127.0.0.44/24") }
-
-    it "Should find records that the given IP falls within" do
-      query = User.where.inet_contains(ip: "127.0.0.1")
-      expect(query).to include(local_1, local_44)
-    end
-
-    it "Should not find records when querying with a submasked value" do
-      query = User.where.inet_contains(ip: "127.0.0.0/8")
-      expect(query).to be_empty
-    end
-  end
-
-  describe "#inet_contains_or_is_contained_within" do
-    let!(:local_1)    { User.create!(ip: "127.0.0.1/24") }
-    let!(:local_44)   { User.create!(ip: "127.0.22.44/8") }
-    let!(:local_99_1) { User.create!(ip: "127.0.99.1") }
-
-    it "should find records where the records contain the given IP" do
-      query = User.where.inet_contains_or_is_contained_within(ip: "127.0.255.80")
-      expect(query).to include(local_44)
-      expect(query).to_not include(local_1, local_99_1)
-
-      query = User.where.inet_contains_or_is_contained_within(ip: "127.0.0.80")
-      expect(query).to include(local_1, local_44)
-      expect(query).to_not include(local_99_1)
-    end
-
-    it "Should find records that the where query contains a valid range" do
-      query = User.where.inet_contains_or_is_contained_within(ip: "127.0.0.80/8")
-      expect(query).to include(local_1, local_44, local_99_1)
-
-      query = User.where.inet_contains_or_is_contained_within(ip: "127.0.0.80/16")
-      expect(query).to include(local_1, local_44, local_99_1)
-    end
-  end
-end

data/spec/query_methods/json_spec.rb

@@ -1,157 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe "Active Record JSON methods" do
-  let!(:user_one) { User.create! }
-  let!(:user_two) { User.create! }
-
-  describe ".select_row_to_json" do
-    let!(:tag_one)    { Tag.create!(user: user_one, tag_number: 2) }
-    let!(:tag_two)    { Tag.create!(user: user_two, tag_number: 5) }
-    let(:sub_query)   { Tag.select(:tag_number).where("tags.user_id = users.id") }
-
-    it "should nest a json object in the query results" do
-      query = User.select(:id).select_row_to_json(sub_query, as: :results).where(id: user_one.id)
-      expect(query.size).to eq(1)
-      expect(query.take.results).to be_a(Hash).and(match("tag_number" => 2))
-    end
-
-    # ugh wording here sucks, brain is fried.
-    it "accepts a block for appending additional scopes to the middle-top level" do
-      query = User.select(:id).select_row_to_json(sub_query, key: :tag_row, as: :results) do |scope|
-        scope.where("tag_row.tag_number = 5")
-      end
-
-      expect(query.size).to eq(2)
-      query.each do |result|
-        if result.id == user_one.id
-          expect(result.results).to be_blank
-        else
-          expect(result.results).to be_present.and(match("tag_number" => 5))
-        end
-      end
-    end
-
-    it "accepts a scope-block without arguments" do
-      query = User.select(:id).select_row_to_json(sub_query, key: :tag_row, as: :results) do
-        where("tag_row.tag_number = 5")
-      end
-
-      expect(query.size).to eq(2)
-      query.each do |result|
-        if result.id == user_one.id
-          expect(result.results).to be_blank
-        else
-          expect(result.results).to be_present.and(match("tag_number" => 5))
-        end
-      end
-    end
-
-    it "allows for casting results in an aggregate-able Array function" do
-      query = User.select(:id).select_row_to_json(sub_query, key: :tag_row, as: :results, cast_with: :array)
-      expect(query.take.results).to be_a(Array).and(be_present)
-      expect(query.take.results.first).to be_a(Hash)
-    end
-
-    it "raises an error if a from clause key is missing" do
-      expect do
-        User.select(:id).select_row_to_json(key: :tag_row, as: :results)
-      end.to raise_error(ArgumentError)
-    end
-  end
-
-  describe ".json_build_object" do
-    let(:sub_query) do
-      User.select_row_to_json(from: User.select(:id), cast_with: :array, as: :ids).where(id: user_one.id)
-    end
-
-    it "defaults the column alias if one is not provided" do
-      query = User.json_build_object(:personal, sub_query)
-      expect(query.size).to eq(1)
-      expect(query.take.results).to match(
-        "personal" => match("ids" => match_array([{ "id" => user_one.id }, { "id" => user_two.id }]))
-      )
-    end
-
-    it "allows for re-aliasing the default 'results' column" do
-      query = User.json_build_object(:personal, sub_query, as: :cool_dudes)
-      expect(query.take).to respond_to(:cool_dudes)
-    end
-  end
-
-  describe ".jsonb_build_object" do
-    let(:sub_query) { User.select(:id, :number).where(id: user_one.id) }
-
-    it "defaults the column alias if one is not provided" do
-      query = User.jsonb_build_object(:personal, sub_query)
-      expect(query.size).to eq(1)
-      expect(query.take.results).to be_a(Hash).and(be_present)
-      expect(query.take.results).to match("personal" => match("id" => user_one.id, "number" => user_one.number))
-    end
-
-    it "allows for re-aliasing the default 'results' column" do
-      query = User.jsonb_build_object(:personal, sub_query, as: :cool_dudes)
-      expect(query.take).to respond_to(:cool_dudes)
-    end
-
-    it "allows for custom value statement" do
-      query = User.jsonb_build_object(
-        :personal,
-        sub_query.where.not(id: user_one),
-        value: "COALESCE(array_agg(\"personal\"), '{}')",
-        as:    :cool_dudes
-      )
-
-      expect(query.take.cool_dudes["personal"]).to be_a(Array).and(be_empty)
-    end
-
-    it "will raise a warning if the value doesn't include a double quoted input" do
-      expect do
-        User.jsonb_build_object(
-          :personal,
-          sub_query.where.not(id: user_one),
-          value: "COALESCE(array_agg(personal), '{}')",
-          as:    :cool_dudes
-        )
-      end.to output.to_stderr
-    end
-  end
-
-  describe "Json literal builds" do
-    let(:original_hash)      { { p: 1, b: "three", x: 3.14 } }
-    let(:hash_as_array_objs) { original_hash.to_a.flatten }
-
-    shared_examples_for "literal builds" do
-      let(:method) { raise "You are expected to over ride this!" }
-
-      it "will accept a hash arguments that will return itself" do
-        query = User.send(method.to_sym, original_hash)
-        expect(query.take.results).to be_a(Hash).and(be_present)
-        expect(query.take.results).to match(original_hash.stringify_keys)
-      end
-
-      it "will accept a standard array of key values" do
-        query = User.send(method.to_sym, hash_as_array_objs)
-        expect(query.take.results).to be_a(Hash).and(be_present)
-        expect(query.take.results).to match(original_hash.stringify_keys)
-      end
-
-      it "will accept a splatted array of key-values" do
-        query = User.send(method.to_sym, *hash_as_array_objs)
-        expect(query.take.results).to be_a(Hash).and(be_present)
-        expect(query.take.results).to match(original_hash.stringify_keys)
-      end
-    end
-
-    describe ".json_build_literal" do
-      it_behaves_like "literal builds" do
-        let!(:method) { :json_build_literal }
-      end
-    end
-
-    describe ".jsonb_build_literal" do
-      it_behaves_like "literal builds" do
-        let!(:method) { :jsonb_build_literal }
-      end
-    end
-  end
-end

data/spec/query_methods/select_spec.rb

@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.describe "Active Record Select Methods" do
-  let(:numbers) { (1..10).to_a }
-
-  describe ".foster_select" do
-    context "with an aggregate function" do
-      context "agg_array" do
-        let(:number_set) { numbers.sample(6).to_enum }
-        let!(:users) { Array.new(6) { User.create!(number: number_set.next, ip: "127.0.0.1") } }
-        let!(:tags) { users.flat_map { |u| Array.new(2) { Tag.create!(user: u, tag_number: numbers.sample) } } }
-
-        it "can accept a subquery" do
-          subquery = Tag.select("count(*)").joins("JOIN users u ON tags.user_id = u.id").where("u.ip = users.ip")
-          query    =
-            User.foster_select(tag_count: [subquery, { cast_with: :array_agg, distinct: true }])
-                .joins(:hm_tags)
-                .group(:ip)
-                .take
-
-          expect(query.tag_count).to eq([tags.size])
-        end
-
-        it "can be ordered" do
-          query = User.foster_select(
-            asc_ordered_numbers:  [:number, { cast_with: :array_agg, order_by: { number: :asc } }],
-            desc_ordered_numbers: [:number, { cast_with: :array_agg, order_by: { number: :desc } }]
-          ).take
-
-          expect(query.asc_ordered_numbers).to eq(number_set.to_a.sort)
-          expect(query.desc_ordered_numbers).to eq(number_set.to_a.sort.reverse)
-        end
-
-        it "works with joined relations" do
-          query =
-            User.foster_select(tag_numbers: { tags: :tag_number, cast_with: :array_agg })
-                .joins(:hm_tags)
-                .take
-          expect(query.tag_numbers).to match_array(Tag.pluck(:tag_number))
-        end
-      end
-
-      context "bool_[and|or]" do
-        let!(:users) do
-          enum_numbers = numbers.to_enum
-          Array.new(6) { User.create!(number: enum_numbers.next, ip: "127.0.0.1") }
-        end
-
-        it "will return a boolean expression" do
-          query = User.foster_select(
-            truthly_expr:     ["users.number > 0",   { cast_with: :bool_and }],
-            falsey_expr:      ["users.number > 200", { cast_with: :bool_and }],
-            other_true_expr:  ["users.number > 4",   { cast_with: :bool_or }],
-            other_false_expr: ["users.number > 6",   { cast_with: :bool_or }]
-          ).take
-
-          expect(query.truthly_expr).to be_truthy
-          expect(query.falsey_expr).to be_falsey
-          expect(query.other_true_expr).to be_truthy
-          expect(query.other_false_expr).to be_falsey
-        end
-      end
-
-      context "with math functions: sum|max|min|avg" do
-        before { 2.times.flat_map { |i| Array.new(2) { |j| User.create!(number: (i + 1) * j + 3) } } }
-
-        it "max" do
-          query = User.foster_select(max_num: [:number, { cast_with: :max }]).take
-          expect(query.max_num).to eq(5)
-        end
-
-        it "min" do
-          query = User.foster_select(max_num: [:number, { cast_with: :min }]).take
-          expect(query.max_num).to eq(3)
-        end
-
-        it "sum" do
-          query = User.foster_select(
-            num_sum:      [:number, { cast_with: :sum }],
-            distinct_sum: [:number, { cast_with: :sum, distinct: true }]
-          ).take
-
-          expect(query.num_sum).to eq(15)
-          expect(query.distinct_sum).to eq(12)
-        end
-
-        it "avg" do
-          query = User.foster_select(
-            num_avg:      [:number, { cast_with: :avg }],
-            distinct_avg: [:number, { cast_with: :avg, distinct: true }]
-          ).take
-
-          expect(query.num_avg).to eq(3.75)
-          expect(query.distinct_avg).to eq(4.0)
-        end
-      end
-    end
-
-    context "with standard select items" do
-      let!(:user) { User.create!(name: "Test") }
-
-      it "works with no alias" do
-        query = User.foster_select(:name).take
-        expect(query.name).to eq(user.name)
-      end
-
-      it "works with alias" do
-        query = User.foster_select(my_name: :name).take
-        expect(query.my_name).to eq(user.name)
-      end
-    end
-  end
-end

data/spec/query_methods/unionize_spec.rb

@@ -1,165 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.describe "Active Record Union Methods" do
-  let!(:user_one)     { User.create!(number: 8) }
-  let!(:user_two)     { User.create!(number: 10) }
-  let!(:user_three)   { User.create!(number: 1) }
-  let!(:user_one_pl)  { ProfileL.create!(user: user_one, likes: 100) }
-  let!(:user_two_pl)  { ProfileL.create!(user: user_two, likes: 200) }
-
-  shared_examples_for "standard set of errors" do
-    let(:user_one_query)  { User.select(:id).where(id: user_one.id) }
-    let(:user_two_query)  { User.select(:id, :tags).where(id: user_two.id) }
-    let(:misaligned_cmd)    { raise("required to override this 'let' statement") }
-    let(:lacking_union_cmd) { raise("required to override this 'let' statement") }
-
-    it "should raise an error if the select statements do not align" do
-      expect { misaligned_cmd.to_a }.to(
-        raise_error(ActiveRecord::StatementInvalid, /each [[:alpha:]]+ query must have the same number of columns/)
-      )
-    end
-
-    it "should raise an argument error if there are less then two union statements" do
-      expect { lacking_union_cmd.to_a }.to(
-        raise_error(ArgumentError, "You are required to provide 2 or more unions to join!")
-      )
-    end
-  end
-
-  describe ".union" do
-    it_behaves_like "standard set of errors" do
-      let!(:misaligned_cmd)    { User.union(user_one_query, user_two_query) }
-      let!(:lacking_union_cmd) { User.union(user_one_query) }
-    end
-
-    it "should return two users that match the where conditions" do
-      query = User.union(User.where(id: user_one.id), User.where(id: user_three.id))
-      expect(query).to match_array([user_one, user_three])
-    end
-
-    it "should allow joins on union statements" do
-      query = User.union(User.where(id: user_one.id), User.joins(:profile_l).where.not(id: user_one.id))
-      expect(query).to match_array([user_one, user_two])
-    end
-
-    it "should eliminate duplicate results" do
-      expected_ids = User.pluck(:id)
-      query        = User.union(User.select(:id), User.select(:id))
-      expect(query.pluck(:id)).to have_attributes(size: expected_ids.size).and(match_array(expected_ids))
-    end
-  end
-
-  describe ".union.all" do
-    it_behaves_like "standard set of errors" do
-      let!(:misaligned_cmd)    { User.union.all(user_one_query, user_two_query) }
-      let!(:lacking_union_cmd) { User.union.all(user_one_query) }
-    end
-
-    it "should keep duplicate results from each union statement" do
-      expected_ids = User.pluck(:id) * 2
-      query        = User.union.all(User.select(:id), User.select(:id))
-      expect(query.pluck(:id)).to have_attributes(size: expected_ids.size).and(match_array(expected_ids))
-    end
-  end
-
-  describe ".union.except" do
-    it_behaves_like "standard set of errors" do
-      let!(:misaligned_cmd)    { User.union.except(user_one_query, user_two_query) }
-      let!(:lacking_union_cmd) { User.union.except(user_one_query) }
-    end
-
-    it "should eliminate records that match a given except statement" do
-      query = User.union.except(User.select(:id), User.select(:id).where(id: user_one.id))
-      expect(query).to match_array([user_two, user_three])
-    end
-  end
-
-  describe "union.intersect" do
-    it_behaves_like "standard set of errors" do
-      let!(:misaligned_cmd)    { User.union.intersect(user_one_query, user_two_query) }
-      let!(:lacking_union_cmd) { User.union.intersect(user_one_query) }
-    end
-
-    it "should find records with similar attributes" do
-      ProfileL.create!(user: user_three, likes: 120)
-
-      query =
-        User.union.intersect(
-          User.select(:id, "profile_ls.likes").joins(:profile_l).where(profile_ls: { likes: 100 }),
-          User.select(:id, "profile_ls.likes").joins(:profile_l).where("profile_ls.likes < 150")
-        )
-
-      expect(query.pluck(:id)).to have_attributes(size: 1).and(eq([user_one_pl.id]))
-      expect(query.first.likes).to eq(user_one_pl.likes)
-    end
-  end
-
-  describe "union.as" do
-    let(:query) do
-      User
-        .select("happy_users.id")
-        .union(User.where(id: user_one.id), User.where(id: user_three.id))
-        .union_as(:happy_users)
-    end
-
-    it "should return two users" do
-      expect(query.size).to eq(2)
-    end
-
-    it "should return two userss id's" do
-      expect(query.map(&:id)).to match_array([user_one.id, user_three.id])
-    end
-
-    it "should alias the tables being union'd but still allow for accessing table methods" do
-      query.each do |happy_person|
-        expect(happy_person).to respond_to(:profile_l)
-      end
-    end
-  end
-
-  describe "union.order_union" do
-    it "should order the .union commands" do
-      query = User.union(User.where(id: user_one.id), User.where(id: user_three.id)).order_union(id: :desc)
-      expect(query).to eq([user_three, user_one])
-    end
-
-    it "should order the .union.all commands" do
-      query =
-        User.union.all(
-          User.where(id: user_one.id),
-          User.where(id: user_three.id)
-        ).order_union(id: :desc)
-
-      expect(query).to eq([user_three, user_one])
-    end
-
-    it "should order the union.except commands" do
-      query = User.union.except(User.order(id: :asc), User.where(id: user_one.id)).order_union(id: :desc)
-      expect(query).to eq([user_three, user_two])
-    end
-
-    it "should order the .union.intersect commands" do
-      query =
-        User.union.intersect(
-          User.where("id < ?", user_three.id),
-          User.where("id >= ?", user_one.id)
-        ).order_union(id: :desc)
-
-      expect(query).to eq([user_two, user_one])
-    end
-  end
-
-  describe "union.reorder_union" do
-    it "should replace the ordering with the new parameters" do
-      user_a           = User.create!(number: 1)
-      user_b           = User.create!(number: 10)
-      initial_ordering = [user_b, user_a]
-      query            = User.union(User.where(id: user_a.id), User.where(id: user_b.id)).order_union(id: :desc)
-
-      expect(query).to eq(initial_ordering)
-      expect(query.reorder_union(number: :asc)).to eq(initial_ordering.reverse)
-    end
-  end
-end