dbee-active_record 2.0.3 → 2.1.2

data/lib/dbee/providers/active_record_provider/makers/where.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2019-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Dbee
+  module Providers
+    class ActiveRecordProvider
+      module Makers # :nodoc: all
+        # Derives Arel#where predicates.
+        class Where
+          include Singleton
+
+          def make(filter, arel_column)
+            # If the filter has a value of nil, then simply return an IS (NOT) NULL predicate
+            return make_is_null_predicate(arel_column, filter.class) if filter.value.nil?
+
+            values = Array(filter.value).flatten
+
+            # This logic helps ensure that if a null exists that it translates to an IS NULL
+            # predicate and does not get put into an in or not_in clause.
+            predicates =
+              if values.include?(nil)
+                [make_is_null_predicate(arel_column, filter.class)]
+              else
+                []
+              end
+
+            predicates += make_predicates(filter, arel_column, values - [nil])
+
+            # Chain all predicates together
+            predicates.inject(predicates.shift) do |memo, predicate|
+              memo.or(predicate)
+            end
+          end
+
+          private
+
+          FILTER_EVALUATORS = {
+            Query::Filters::Contains => ->(node, val) { node.matches("%#{val}%") },
+            Query::Filters::Equals => ->(node, val) { node.eq(val) },
+            Query::Filters::GreaterThan => ->(node, val) { node.gt(val) },
+            Query::Filters::GreaterThanOrEqualTo => ->(node, val) { node.gteq(val) },
+            Query::Filters::LessThan => ->(node, val) { node.lt(val) },
+            Query::Filters::LessThanOrEqualTo => ->(node, val) { node.lteq(val) },
+            Query::Filters::NotContain => ->(node, val) { node.does_not_match("%#{val}%") },
+            Query::Filters::NotEquals => ->(node, val) { node.not_eq(val) },
+            Query::Filters::NotStartWith => ->(node, val) { node.does_not_match("#{val}%") },
+            Query::Filters::StartsWith => ->(node, val) { node.matches("#{val}%") }
+          }.freeze
+
+          NULL_PREDICATE_MAP = {
+            Query::Filters::Contains => Query::Filters::Equals,
+            Query::Filters::Equals => Query::Filters::Equals,
+            Query::Filters::GreaterThan => Query::Filters::Equals,
+            Query::Filters::GreaterThanOrEqualTo => Query::Filters::Equals,
+            Query::Filters::LessThan => Query::Filters::Equals,
+            Query::Filters::LessThanOrEqualTo => Query::Filters::Equals,
+            Query::Filters::NotContain => Query::Filters::NotEquals,
+            Query::Filters::NotEquals => Query::Filters::NotEquals,
+            Query::Filters::NotStartWith => Query::Filters::NotEquals,
+            Query::Filters::StartsWith => Query::Filters::Equals
+          }.freeze
+
+          private_constant :FILTER_EVALUATORS, :NULL_PREDICATE_MAP
+
+          def make_predicates(filter, arel_column, values)
+            if use_in?(filter, values)
+              [arel_column.in(values)]
+            elsif use_not_in?(filter, values)
+              [arel_column.not_in(values)]
+            else
+              make_or_predicates(filter, arel_column, values)
+            end
+          end
+
+          def use_in?(filter, values)
+            filter.is_a?(Query::Filters::Equals) && values.length > 1
+          end
+
+          def use_not_in?(filter, values)
+            filter.is_a?(Query::Filters::NotEquals) && values.length > 1
+          end
+
+          def make_or_predicates(filter, arel_column, values)
+            values.map do |value|
+              make_predicate(arel_column, filter.class, value)
+            end
+          end
+
+          def make_predicate(arel_column, filter_class, value)
+            method = FILTER_EVALUATORS[filter_class]
+
+            raise ArgumentError, "cannot compile filter: #{filter}" unless method
+
+            method.call(arel_column, value)
+          end
+
+          def make_is_null_predicate(arel_column, requested_filter_class)
+            actual_filter_class = NULL_PREDICATE_MAP[requested_filter_class]
+            make_predicate(arel_column, actual_filter_class, nil)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dbee/providers/active_record_provider/version.rb

@@ -10,7 +10,7 @@
 module Dbee
   module Providers
     class ActiveRecordProvider
-      VERSION = '2.0.3'
+      VERSION = '2.1.2'
     end
   end
 end

data/spec/db_helper.rb

@@ -10,6 +10,27 @@
 # Enable logging using something like:
 # ActiveRecord::Base.logger = Logger.new(STDERR)
 
+class Field < ActiveRecord::Base
+  has_many :patient_field_values
+end
+
+class Patient < ActiveRecord::Base
+  has_many :patient_field_values
+  has_many :patient_payments
+
+  accepts_nested_attributes_for :patient_field_values
+  accepts_nested_attributes_for :patient_payments
+end
+
+class PatientFieldValue < ActiveRecord::Base
+  belongs_to :patient
+  belongs_to :field
+end
+
+class PatientPayment < ActiveRecord::Base
+  belongs_to :patient
+end
+
 def connect_to_db(name)
   config = yaml_file_read('spec', 'config', 'database.yaml')[name.to_s]
   ActiveRecord::Base.establish_connection(config)
@@ -17,39 +38,40 @@ end
 
 def load_schema
   ActiveRecord::Schema.define do
+    # Movie Theater Schema
     create_table :theaters do |t|
-      t.column :name, :string
+      t.column :name,      :string
       t.column :partition, :string
-      t.column :active, :boolean
+      t.column :active,    :boolean
       t.column :inspected, :boolean
       t.timestamps
     end
 
     create_table :members do |t|
-      t.column :tid, :integer
+      t.column :tid,            :integer
       t.column :account_number, :string
-      t.column :partition, :string
+      t.column :partition,      :string
       t.timestamps
     end
 
     create_table :demographics do |t|
       t.column :member_id, :integer
-      t.column :name, :string
+      t.column :name,      :string
       t.timestamps
     end
 
     create_table :phone_numbers do |t|
       t.column :demographic_id, :integer
-      t.column :phone_type, :string
-      t.column :phone_number, :string
+      t.column :phone_type,     :string
+      t.column :phone_number,   :string
       t.timestamps
     end
 
     create_table :movies do |t|
       t.column :member_id, :integer
-      t.column :name, :string
-      t.column :genre, :string
-      t.column :favorite, :boolean, default: false, null: false
+      t.column :name,      :string
+      t.column :genre,     :string
+      t.column :favorite,  :boolean, default: false, null: false
       t.timestamps
     end
 
@@ -60,10 +82,10 @@ def load_schema
 
     create_table :animals do |t|
       t.column :owner_id, :integer
-      t.column :toy_id, :integer
-      t.column :type, :string
-      t.column :name, :string
-      t.column :deleted, :boolean
+      t.column :toy_id,   :integer
+      t.column :type,     :string
+      t.column :name,     :string
+      t.column :deleted,  :boolean
       t.timestamps
     end
 
@@ -76,5 +98,103 @@ def load_schema
       t.column :laser, :boolean
       t.timestamps
     end
+
+    # Patient Schema
+    create_table :fields do |t|
+      t.column :section, :string
+      t.column :key,     :string
+      t.timestamps
+    end
+
+    add_index :fields, %i[section key], unique: true
+
+    create_table :patients do |t|
+      t.column :first,  :string
+      t.column :middle, :string
+      t.column :last,   :string
+      t.timestamps
+    end
+
+    create_table :patient_field_values do |t|
+      t.column :patient_id, :integer, foreign_key: true
+      t.column :field_id,   :integer, foreign_key: true
+      t.column :value,      :string
+      t.timestamps
+    end
+
+    add_index :patient_field_values, %i[patient_id field_id], unique: true
+
+    create_table :patient_payments do |t|
+      t.column :patient_id, :integer, foreign_key: true
+      t.column :amount,     :decimal
+      t.timestamps
+    end
   end
 end
+
+def load_data
+  demo_dob_field              = Field.create!(section: 'demographics', key: 'dob')
+  demo_drivers_license_field  = Field.create!(section: 'demographics', key: 'drivers_license')
+  demo_notes_field            = Field.create!(section: 'demographics', key: 'notes')
+
+  contact_phone_number_field  = Field.create!(section: 'contact', key: 'phone_number')
+  contact_notes_field         = Field.create!(section: 'contact', key: 'notes')
+
+  Patient.create!(
+    first: 'Bozo',
+    middle: 'The',
+    last: 'Clown',
+    patient_field_values_attributes: [
+      {
+        field: demo_dob_field,
+        value: '1904-04-04'
+      },
+      {
+        field: demo_notes_field,
+        value: 'The patient is funny!'
+      },
+      {
+        field: demo_drivers_license_field,
+        value: '82-54-hut-hut-hike!'
+      },
+      {
+        field: contact_phone_number_field,
+        value: '555-555-5555'
+      },
+      {
+        field: contact_notes_field,
+        value: 'Do not call this patient at night!'
+      }
+    ],
+    patient_payments_attributes: [
+      { amount: 5 },
+      { amount: 10 },
+      { amount: 15 }
+    ]
+  )
+
+  Patient.create!(
+    first: 'Frank',
+    last: 'Rizzo',
+    patient_payments_attributes: [
+      { amount: 50 },
+      { amount: 150 }
+    ]
+  )
+
+  Patient.create!(
+    first: 'Bugs',
+    middle: 'The',
+    last: 'Bunny',
+    patient_field_values_attributes: [
+      {
+        field: demo_dob_field,
+        value: '2040-01-01'
+      },
+      {
+        field: contact_notes_field,
+        value: 'Call anytime!!'
+      }
+    ]
+  )
+end

data/spec/dbee/providers/active_record_provider/expression_builder_spec.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2019-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require 'spec_helper'
+require 'db_helper'
+
+describe Dbee::Providers::ActiveRecordProvider::ExpressionBuilder do
+  let(:model)       { Dbee::Model.make(models['Patients']) }
+  let(:alias_maker) { Dbee::Providers::ActiveRecordProvider::SafeAliasMaker.new }
+
+  let(:id_and_average_query) do
+    Dbee::Query.make(
+      fields: [
+        {
+          key_path: :id,
+          display: 'ID #'
+        },
+        {
+          key_path: 'patient_payments.amount',
+          display: 'Ave Payment',
+          aggregator: :ave
+        }
+      ],
+      sorters: [
+        {
+          key_path: :id
+        }
+      ],
+      filters: [
+        {
+          key_path: :id,
+          value: 123
+        }
+      ]
+    )
+  end
+
+  let(:first_and_count_query) do
+    Dbee::Query.make(
+      fields: [
+        {
+          key_path: :first,
+          display: 'First Name'
+        },
+        {
+          key_path: 'patient_payments.amount',
+          display: 'Number of Payments',
+          aggregator: :count
+        }
+      ]
+    )
+  end
+
+  subject { described_class.new(model, alias_maker, alias_maker) }
+
+  before(:all) do
+    connect_to_db(:sqlite)
+  end
+
+  describe '#clear' do
+    it 'provides fluent interface (returns self)' do
+      expect(subject.clear).to eq(subject)
+    end
+
+    it 'resets selecting, grouping, sorting, and filtering' do
+      subject.add(id_and_average_query)
+
+      sql = subject.to_sql
+
+      expect(sql).not_to include('*')
+      expect(sql).to     include('GROUP')
+      expect(sql).to     include('WHERE')
+      expect(sql).to     include('ORDER')
+
+      sql = subject.clear.to_sql
+
+      expect(sql).to     include('*')
+      expect(sql).not_to include('GROUP')
+      expect(sql).not_to include('WHERE')
+      expect(sql).not_to include('ORDER')
+    end
+  end
+
+  describe '#to_sql' do
+    specify 'when called with no fields, then called with fields removes star select' do
+      expect(subject.to_sql).to include('*')
+
+      subject.add(id_and_average_query)
+
+      expect(subject.to_sql).not_to include('*')
+    end
+
+    context 'with aggregation' do
+      it 'generates the same sql when called multiple times' do
+        subject.add(id_and_average_query)
+
+        first_sql  = subject.to_sql
+        second_sql = subject.to_sql
+
+        expect(first_sql).to eq(second_sql)
+
+        subject.add(first_and_count_query)
+
+        first_sql  = subject.to_sql
+        second_sql = subject.to_sql
+
+        expect(first_sql).to eq(second_sql)
+      end
+    end
+  end
+end

data/spec/dbee/providers/active_record_provider/makers/where_spec.rb

@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require 'spec_helper'
+require 'db_helper'
+
+# rubocop:disable Layout/LineLength
+# Disable the line length cop beause there are some lengthy 'expected' SQL strings in spec which
+# cannot be shortened.
+describe Dbee::Providers::ActiveRecordProvider::Makers::Where do
+  before(:all) { connect_to_db(:sqlite) }
+
+  let(:subject) { described_class.instance }
+  let(:column) { Arel::Table.new(:test)[:foo] }
+
+  describe 'equals' do
+    specify 'a string value' do
+      filter = Dbee::Query::Filters::Equals.new(key_path: :foo, value: 'bar')
+      expect(subject.make(filter, column).to_sql).to eq %q("test"."foo" = 'bar')
+    end
+
+    specify 'a null value' do
+      filter = Dbee::Query::Filters::Equals.new(key_path: :foo, value: nil)
+      expect(subject.make(filter, column).to_sql).to eq '"test"."foo" IS NULL'
+    end
+
+    specify 'a set with a null value' do
+      filter = Dbee::Query::Filters::Equals.new(key_path: :foo, value: ['a', nil, 'c'])
+      expected = %q[("test"."foo" IS NULL OR "test"."foo" IN ('a', 'c'))]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+
+    specify 'a set without a null value' do
+      filter = Dbee::Query::Filters::Equals.new(key_path: :foo, value: %w[a b c])
+      expect(subject.make(filter, column).to_sql).to eq %q["test"."foo" IN ('a', 'b', 'c')]
+    end
+  end
+
+  describe 'not equals' do
+    specify 'a string value' do
+      filter = Dbee::Query::Filters::NotEquals.new(key_path: :foo, value: 'bar')
+      expect(subject.make(filter, column).to_sql).to eq %q("test"."foo" != 'bar')
+    end
+
+    specify 'a null value' do
+      filter = Dbee::Query::Filters::NotEquals.new(key_path: :foo, value: nil)
+      expect(subject.make(filter, column).to_sql).to eq '"test"."foo" IS NOT NULL'
+    end
+
+    specify 'a set with a null value' do
+      filter = Dbee::Query::Filters::NotEquals.new(key_path: :foo, value: ['a', nil, 'c'])
+      expected = %q[("test"."foo" IS NOT NULL OR "test"."foo" NOT IN ('a', 'c'))]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+
+    specify 'a set without a null value' do
+      filter = Dbee::Query::Filters::NotEquals.new(key_path: :foo, value: %w[a b c])
+      expect(subject.make(filter, column).to_sql).to eq %q["test"."foo" NOT IN ('a', 'b', 'c')]
+    end
+  end
+
+  describe 'contains' do
+    specify 'a string value' do
+      filter = Dbee::Query::Filters::Contains.new(key_path: :foo, value: 'bar')
+      expect(subject.make(filter, column).to_sql).to eq %q("test"."foo" LIKE '%bar%')
+    end
+
+    specify 'a null value' do
+      filter = Dbee::Query::Filters::Contains.new(key_path: :foo, value: nil)
+      expect(subject.make(filter, column).to_sql).to eq '"test"."foo" IS NULL'
+    end
+
+    specify 'a set with a null value' do
+      filter = Dbee::Query::Filters::Contains.new(key_path: :foo, value: ['a', nil, 'c'])
+      expected = %q[(("test"."foo" IS NULL OR "test"."foo" LIKE '%a%') OR "test"."foo" LIKE '%c%')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+
+    specify 'a set without a null value' do
+      filter = Dbee::Query::Filters::Contains.new(key_path: :foo, value: %w[a b c])
+      expected = %q[(("test"."foo" LIKE '%a%' OR "test"."foo" LIKE '%b%') OR "test"."foo" LIKE '%c%')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+  end
+
+  describe 'not contains' do
+    specify 'a string value' do
+      filter = Dbee::Query::Filters::NotContain.new(key_path: :foo, value: 'bar')
+      expect(subject.make(filter, column).to_sql).to eq %q("test"."foo" NOT LIKE '%bar%')
+    end
+
+    specify 'a null value' do
+      filter = Dbee::Query::Filters::NotContain.new(key_path: :foo, value: nil)
+      expect(subject.make(filter, column).to_sql).to eq '"test"."foo" IS NOT NULL'
+    end
+
+    specify 'a set with a null value' do
+      filter = Dbee::Query::Filters::NotContain.new(key_path: :foo, value: ['a', nil, 'c'])
+      expected = %q[(("test"."foo" IS NOT NULL OR "test"."foo" NOT LIKE '%a%') OR "test"."foo" NOT LIKE '%c%')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+
+    specify 'a set without a null value' do
+      filter = Dbee::Query::Filters::NotContain.new(key_path: :foo, value: %w[a b c])
+      expected = %q[(("test"."foo" NOT LIKE '%a%' OR "test"."foo" NOT LIKE '%b%') OR "test"."foo" NOT LIKE '%c%')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+  end
+
+  describe 'starts with' do
+    specify 'a string value' do
+      filter = Dbee::Query::Filters::StartsWith.new(key_path: :foo, value: 'bar')
+      expect(subject.make(filter, column).to_sql).to eq %q("test"."foo" LIKE 'bar%')
+    end
+
+    specify 'a null value' do
+      filter = Dbee::Query::Filters::StartsWith.new(key_path: :foo, value: nil)
+      expect(subject.make(filter, column).to_sql).to eq '"test"."foo" IS NULL'
+    end
+
+    specify 'a set with a null value' do
+      filter = Dbee::Query::Filters::StartsWith.new(key_path: :foo, value: ['a', nil, 'c'])
+      expected = %q[(("test"."foo" IS NULL OR "test"."foo" LIKE 'a%') OR "test"."foo" LIKE 'c%')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+
+    specify 'a set without a null value' do
+      filter = Dbee::Query::Filters::StartsWith.new(key_path: :foo, value: %w[a b c])
+      expected = %q[(("test"."foo" LIKE 'a%' OR "test"."foo" LIKE 'b%') OR "test"."foo" LIKE 'c%')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+  end
+
+  describe 'not start with' do
+    specify 'a string value' do
+      filter = Dbee::Query::Filters::NotStartWith.new(key_path: :foo, value: 'bar')
+      expect(subject.make(filter, column).to_sql).to eq %q("test"."foo" NOT LIKE 'bar%')
+    end
+
+    specify 'a null value' do
+      filter = Dbee::Query::Filters::NotStartWith.new(key_path: :foo, value: nil)
+      expect(subject.make(filter, column).to_sql).to eq '"test"."foo" IS NOT NULL'
+    end
+
+    specify 'a set with a null value' do
+      filter = Dbee::Query::Filters::NotStartWith.new(key_path: :foo, value: ['a', nil, 'c'])
+      expected = %q[(("test"."foo" IS NOT NULL OR "test"."foo" NOT LIKE 'a%') OR "test"."foo" NOT LIKE 'c%')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+
+    specify 'a set without a null value' do
+      filter = Dbee::Query::Filters::NotStartWith.new(key_path: :foo, value: %w[a b c])
+      expected = %q[(("test"."foo" NOT LIKE 'a%' OR "test"."foo" NOT LIKE 'b%') OR "test"."foo" NOT LIKE 'c%')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+  end
+
+  describe 'greater than' do
+    specify 'a string value' do
+      filter = Dbee::Query::Filters::GreaterThan.new(key_path: :foo, value: 'bar')
+      expect(subject.make(filter, column).to_sql).to eq %q("test"."foo" > 'bar')
+    end
+
+    specify 'a null value' do
+      filter = Dbee::Query::Filters::GreaterThan.new(key_path: :foo, value: nil)
+      expect(subject.make(filter, column).to_sql).to eq '"test"."foo" IS NULL'
+    end
+
+    specify 'a set with a null value' do
+      filter = Dbee::Query::Filters::GreaterThan.new(key_path: :foo, value: ['a', nil, 'c'])
+      expected = %q[(("test"."foo" IS NULL OR "test"."foo" > 'a') OR "test"."foo" > 'c')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+
+    specify 'a set without a null value' do
+      filter = Dbee::Query::Filters::GreaterThan.new(key_path: :foo, value: %w[a b c])
+      expected = %q[(("test"."foo" > 'a' OR "test"."foo" > 'b') OR "test"."foo" > 'c')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+  end
+
+  describe 'greater than or equal to' do
+    specify 'a string value' do
+      filter = Dbee::Query::Filters::GreaterThanOrEqualTo.new(key_path: :foo, value: 'bar')
+      expect(subject.make(filter, column).to_sql).to eq %q("test"."foo" >= 'bar')
+    end
+
+    specify 'a null value' do
+      filter = Dbee::Query::Filters::GreaterThanOrEqualTo.new(key_path: :foo, value: nil)
+      expect(subject.make(filter, column).to_sql).to eq '"test"."foo" IS NULL'
+    end
+
+    specify 'a set with a null value' do
+      filter = Dbee::Query::Filters::GreaterThanOrEqualTo.new(key_path: :foo, value: ['a', nil, 'c'])
+      expected = %q[(("test"."foo" IS NULL OR "test"."foo" >= 'a') OR "test"."foo" >= 'c')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+
+    specify 'a set without a null value' do
+      filter = Dbee::Query::Filters::GreaterThanOrEqualTo.new(key_path: :foo, value: %w[a b c])
+      expected = %q[(("test"."foo" >= 'a' OR "test"."foo" >= 'b') OR "test"."foo" >= 'c')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+  end
+
+  describe 'less than' do
+    specify 'a string value' do
+      filter = Dbee::Query::Filters::LessThan.new(key_path: :foo, value: 'bar')
+      expect(subject.make(filter, column).to_sql).to eq %q("test"."foo" < 'bar')
+    end
+
+    specify 'a null value' do
+      filter = Dbee::Query::Filters::LessThan.new(key_path: :foo, value: nil)
+      expect(subject.make(filter, column).to_sql).to eq '"test"."foo" IS NULL'
+    end
+
+    specify 'a set with a null value' do
+      filter = Dbee::Query::Filters::LessThan.new(key_path: :foo, value: ['a', nil, 'c'])
+      expected = %q[(("test"."foo" IS NULL OR "test"."foo" < 'a') OR "test"."foo" < 'c')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+
+    specify 'a set without a null value' do
+      filter = Dbee::Query::Filters::LessThan.new(key_path: :foo, value: %w[a b c])
+      expected = %q[(("test"."foo" < 'a' OR "test"."foo" < 'b') OR "test"."foo" < 'c')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+  end
+
+  describe 'less than or equal to' do
+    specify 'a string value' do
+      filter = Dbee::Query::Filters::LessThanOrEqualTo.new(key_path: :foo, value: 'bar')
+      expect(subject.make(filter, column).to_sql).to eq %q("test"."foo" <= 'bar')
+    end
+
+    specify 'a null value' do
+      filter = Dbee::Query::Filters::LessThanOrEqualTo.new(key_path: :foo, value: nil)
+      expect(subject.make(filter, column).to_sql).to eq '"test"."foo" IS NULL'
+    end
+
+    specify 'a set with a null value' do
+      filter = Dbee::Query::Filters::LessThanOrEqualTo.new(key_path: :foo, value: ['a', nil, 'c'])
+      expected = %q[(("test"."foo" IS NULL OR "test"."foo" <= 'a') OR "test"."foo" <= 'c')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+
+    specify 'a set without a null value' do
+      filter = Dbee::Query::Filters::LessThanOrEqualTo.new(key_path: :foo, value: %w[a b c])
+      expected = %q[(("test"."foo" <= 'a' OR "test"."foo" <= 'b') OR "test"."foo" <= 'c')]
+      expect(subject.make(filter, column).to_sql).to eq expected
+    end
+  end
+end
+# rubocop:enable Layout/LineLength