torque-postgresql 1.1.1 → 2.0.1

data/spec/tests/interval_spec.rb

@@ -0,0 +1,167 @@
+require 'spec_helper'
+
+RSpec.describe 'Interval' do
+  let(:connection) { ActiveRecord::Base.connection }
+
+  context 'on settings' do
+    it 'must be set to ISO 8601' do
+      expect(connection.select_value('SHOW IntervalStyle')).to eql('iso_8601')
+    end
+  end
+
+  context 'on table definition' do
+    subject { ActiveRecord::ConnectionAdapters::PostgreSQL::TableDefinition.new('articles') }
+
+    it 'has the interval method' do
+      expect(subject).to respond_to(:interval)
+    end
+
+    it 'can define an interval column' do
+      subject.interval('duration')
+      expect(subject['duration'].name).to eql('duration')
+      expect(subject['duration'].type).to eql(:interval)
+    end
+  end
+
+  context 'on schema' do
+    it 'can be used on tables too' do
+      dump_io = StringIO.new
+      ActiveRecord::SchemaDumper.dump(connection, dump_io)
+      expect(dump_io.string).to match /t\.interval +"duration"/
+    end
+  end
+
+  context 'on OID' do
+    let(:reference) { 1.year + 2.months + 3.days + 4.hours + 5.minutes + 6.seconds }
+    subject { Torque::PostgreSQL::Adapter::OID::Interval.new }
+
+    context 'on deserialize' do
+      it 'returns nil' do
+        expect(subject.deserialize(nil)).to be_nil
+      end
+
+      it 'returns duration' do
+        value = subject.deserialize('P1Y2M3DT4H5M6S')
+
+        expect(value).to be_a(ActiveSupport::Duration)
+        expect(value).to eq(reference)
+      end
+    end
+
+    context 'on serialize' do
+      it 'returns nil' do
+        expect(subject.serialize(nil)).to be_nil
+      end
+
+      it 'returns seconds as string' do
+        expect(subject.serialize(3600.seconds)).to eq('PT3600S')
+      end
+
+      it 'retruns sample as string' do
+        expect(subject.serialize(reference)).to eq('P1Y2M3DT4H5M6S')
+      end
+
+      it 'transforms weeks into days' do
+        reference = subject.cast(1000000)
+        expect(subject.serialize(reference)).to eq('P11DT13H46M40S')
+      end
+    end
+
+    context 'on cast' do
+      it 'accepts nil' do
+        expect(subject.cast(nil)).to be_nil
+      end
+
+      it 'accepts string' do
+        value = subject.cast('P1Y2M3DT4H5M6S')
+        expect(value).to be_a(ActiveSupport::Duration)
+        expect(value).to eq(reference)
+      end
+
+      it 'accepts duration' do
+        value = subject.cast(5.days)
+        expect(value).to be_a(ActiveSupport::Duration)
+        expect(value).to eql(value)
+      end
+
+      it 'accepts small seconds numeric' do
+        value = subject.cast(30)
+        expect(value).to be_a(ActiveSupport::Duration)
+        expect(value).to eq(30)
+      end
+
+      it 'accepts long seconds numeric' do
+        value = subject.cast(reference.to_i)
+        expect(value).to be_a(ActiveSupport::Duration)
+        expect(value).to eq(reference)
+      end
+
+      it 'accepts array with Y-M-D H:M:S format' do
+        value = subject.cast([1, 2, 3, 4, 5, 6])
+        expect(value).to be_a(ActiveSupport::Duration)
+        expect(value).to eq(reference)
+      end
+
+      it 'accepts array with empty values' do
+        value = subject.cast([nil, 0, 12, 30, 0])
+        sample = 12.hours + 30.minutes
+        expect(value).to be_a(ActiveSupport::Duration)
+        expect(value.inspect).to eq(sample.inspect)
+        expect(value).to eq(sample)
+      end
+
+      it 'accepts array with string' do
+        value = subject.cast(['45', '15'])
+        sample = 45.minutes + 15.seconds
+        expect(value).to be_a(ActiveSupport::Duration)
+        expect(value.inspect).to eq(sample.inspect)
+        expect(value).to eq(sample)
+      end
+
+      it 'accepts hash' do
+        value = subject.cast({years: 1, months: 2, days: 3, hours: 4, minutes: 5, seconds: 6})
+        expect(value).to be_a(ActiveSupport::Duration)
+        expect(value).to eq(reference)
+      end
+
+      it 'accepts hash with extra elements' do
+        value = subject.cast({extra: 1, hours: 12, minutes: 30})
+        sample = 12.hours + 30.minutes
+        expect(value).to be_a(ActiveSupport::Duration)
+        expect(value).to eq(sample)
+      end
+
+      it 'returns any other type of value as it is' do
+        value = subject.cast(true)
+        expect(value).to eql(true)
+      end
+    end
+  end
+
+  context 'on I18n' do
+    it 'transforms the value into singular text' do
+      expect(I18n.l 1.year).to eql('1 year')
+      expect(I18n.l 1.months).to eql('1 month')
+      expect(I18n.l 1.weeks).to eql('1 week')
+      expect(I18n.l 1.days).to eql('1 day')
+      expect(I18n.l 1.hours).to eql('1 hour')
+      expect(I18n.l 1.minutes).to eql('1 minute')
+      expect(I18n.l 1.seconds).to eql('1 second')
+    end
+
+    it 'transforms the value into plural text' do
+      expect(I18n.l 2.year).to eql('2 years')
+      expect(I18n.l 2.months).to eql('2 months')
+      expect(I18n.l 2.weeks).to eql('2 weeks')
+      expect(I18n.l 2.days).to eql('2 days')
+      expect(I18n.l 2.hours).to eql('2 hours')
+      expect(I18n.l 2.minutes).to eql('2 minutes')
+      expect(I18n.l 2.seconds).to eql('2 seconds')
+    end
+
+    it 'transforms multiple values' do
+      value = 1.year + 2.months + 3.days + 4.hours + 5.minutes + 6.seconds
+      expect(I18n.l value).to eql('1 year, 2 months, 3 days, 4 hours, 5 minutes, and 6 seconds')
+    end
+  end
+end

data/spec/tests/lazy_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+RSpec.describe 'Lazy', type: :helper do
+  subject { Torque::PostgreSQL::Attributes::Lazy }
+
+  it 'is consider nil' do
+    expect(subject.new(String, '')).to be_nil
+  end
+
+  it 'inspects as nil' do
+    expect(subject.new(String, '').inspect).to be_eql('nil')
+  end
+
+  it 'compares to nil only' do
+    expect(subject.new(String, '') == nil).to be_truthy
+    expect(subject.new(String, '') == '').to be_falsey
+    expect(subject.new(String, '') == 0).to be_falsey
+  end
+
+  it 'starts the object only on method call' do
+    expect(subject.new(String, '').to_s).to be_a(String)
+    expect(subject.new(String, '')).to respond_to(:chop)
+  end
+end

data/spec/tests/period_spec.rb

@@ -0,0 +1,954 @@
+require 'spec_helper'
+
+# TODO: Convert to shared examples
+RSpec.describe 'Period' do
+  let(:model) { Class.new(TimeKeeper) }
+  let(:instance) { model.new }
+  let(:fields) { %i[available period tzperiod] }
+  let(:method_names) { Torque::PostgreSQL::config.period.method_names }
+  let(:attribute_klass) { Torque::PostgreSQL::Attributes::Period }
+
+  let(:true_value) { 'TRUE' }
+  let(:false_value) { 'FALSE' }
+
+  let(:klass_methods_range) { (0..22) }
+  let(:instance_methods_range) { (23..29) }
+
+  let(:klass_method_names) { method_names.to_a[klass_methods_range].to_h }
+  let(:instance_method_names) { method_names.to_a[instance_methods_range].to_h }
+
+  before { Time.zone = 'UTC' }
+
+  def decorate(model, field, options = {})
+    attribute_klass.include_on(model, :period_for)
+    model.period_for(field, **options)
+  end
+
+  context 'on config' do
+    let(:direct_method_names) do
+      list = method_names.dup
+      list.merge!(Torque::PostgreSQL::config.period.direct_method_names)
+      list.values.map { |v| v.gsub(/_?%s_?/, '') }
+    end
+
+    let(:other_method_names) do
+      method_names.transform_values.with_index { |_, idx| "p__#{idx}" }
+    end
+
+    it 'has definition method on the model' do
+      attribute_klass.include_on(ActiveRecord::Base, :period_for)
+      expect(model).to respond_to(:period_for)
+      ActiveRecord::Base.singleton_class.send(:undef_method, :period_for)
+    end
+
+    it 'create the methods with custom names' do
+      decorate(model, :tzperiod, threshold: 5.minutes, methods: other_method_names)
+
+      klass_method_names.size.times do |i|
+        expect(model).to respond_to("p__#{i}")
+      end
+
+      initial = instance_methods_range.min
+      instance_method_names.size.times do |i|
+        expect(instance).to respond_to("p__#{initial + i}")
+      end
+    end
+
+    it 'creates non prefixed methods if requested' do
+      decorate(model, :tzperiod, prefixed: false, threshold: 5.minutes)
+
+      direct_method_names[klass_methods_range].each do |m|
+        expect(model).to respond_to(m)
+      end
+
+      direct_method_names[instance_methods_range].each do |m|
+        expect(instance).to respond_to(m)
+      end
+    end
+  end
+
+  context 'on tsrange' do
+    let(:type) { :tsrange }
+    let(:value) { Time.zone.now.beginning_of_minute }
+    let(:db_field) { '"time_keepers"."period"' }
+    let(:db_value) { "'#{value.strftime('%F %T')}'" }
+
+    let(:cast_type) { '::timestamp' }
+    let(:cast_db_value) { "#{db_value}#{cast_type}" }
+    let(:empty_condition) { "#{type}(NULL, NULL)" }
+    let(:nullif_condition) { "nullif(#{db_field}, #{empty_condition})" }
+
+    let(:date_type) { :daterange }
+    let(:lower_date) { "lower(#{db_field})::date" }
+    let(:upper_date) { "upper(#{db_field})::date" }
+    let(:date_db_field) { "#{date_type}(#{lower_date}, #{upper_date}, '[]')" }
+
+    context 'on model' do
+      before { decorate(model, :period) }
+
+      it 'queries current on period' do
+        expect(model.period_on(value).to_sql).to include(<<-SQL.squish)
+          coalesce(#{nullif_condition} @> #{cast_db_value}, #{true_value})
+        SQL
+      end
+
+      it 'queries current period' do
+        expect(model.current_period.to_sql).to include(<<-SQL.squish)
+          coalesce(#{nullif_condition} @>
+        SQL
+
+        expect(model.current_period.to_sql).to include(<<-SQL.squish)
+          #{cast_type}, #{true_value})
+        SQL
+      end
+
+      it 'queries not current period' do
+        expect(model.not_current_period.to_sql).to include(<<-SQL.squish)
+          NOT (coalesce(#{nullif_condition} @>
+        SQL
+
+        expect(model.not_current_period.to_sql).to include(<<-SQL.squish)
+          #{cast_type}, #{true_value})
+        SQL
+      end
+
+      it 'queries containing period' do
+        expect(model.period_containing(:test).to_sql).to include(<<-SQL.squish)
+          #{db_field} @> "time_keepers"."test"
+        SQL
+
+        expect(model.period_containing(value).to_sql).to include(<<-SQL.squish)
+          #{db_field} @> #{db_value}
+        SQL
+      end
+
+      it 'queries not containing period' do
+        expect(model.period_not_containing(:test).to_sql).to include(<<-SQL.squish)
+          NOT (#{db_field} @> "time_keepers"."test")
+        SQL
+
+        expect(model.period_not_containing(value).to_sql).to include(<<-SQL.squish)
+          NOT (#{db_field} @> #{db_value})
+        SQL
+      end
+
+      it 'queries overlapping period' do
+        expect(model.period_overlapping(:test).to_sql).to include(<<-SQL.squish)
+          #{db_field} && "time_keepers"."test"
+        SQL
+
+        expect(model.period_overlapping(value, value).to_sql).to include(<<-SQL.squish)
+          #{db_field} && #{type}(#{db_value}, #{db_value})
+        SQL
+      end
+
+      it 'queries not overlapping period' do
+        expect(model.period_not_overlapping(:test).to_sql).to include(<<-SQL.squish)
+          NOT (#{db_field} && "time_keepers"."test")
+        SQL
+
+        expect(model.period_not_overlapping(value, value).to_sql).to include(<<-SQL.squish)
+          NOT (#{db_field} && #{type}(#{db_value}, #{db_value}))
+        SQL
+      end
+
+      it 'queries starting after period' do
+        expect(model.period_starting_after(:test).to_sql).to include(<<-SQL.squish)
+          lower(#{db_field}) > "time_keepers"."test"
+        SQL
+
+        expect(model.period_starting_after(value).to_sql).to include(<<-SQL.squish)
+          lower(#{db_field}) > #{db_value}
+        SQL
+      end
+
+      it 'queries starting before period' do
+        expect(model.period_starting_before(:test).to_sql).to include(<<-SQL.squish)
+          lower(#{db_field}) < "time_keepers"."test"
+        SQL
+
+        expect(model.period_starting_before(value).to_sql).to include(<<-SQL.squish)
+          lower(#{db_field}) < #{db_value}
+        SQL
+      end
+
+      it 'queries finishing after period' do
+        expect(model.period_finishing_after(:test).to_sql).to include(<<-SQL.squish)
+          upper(#{db_field}) > "time_keepers"."test"
+        SQL
+
+        expect(model.period_finishing_after(value).to_sql).to include(<<-SQL.squish)
+          upper(#{db_field}) > #{db_value}
+        SQL
+      end
+
+      it 'queries finishing before period' do
+        expect(model.period_finishing_before(:test).to_sql).to include(<<-SQL.squish)
+          upper(#{db_field}) < "time_keepers"."test"
+        SQL
+
+        expect(model.period_finishing_before(value).to_sql).to include(<<-SQL.squish)
+          upper(#{db_field}) < #{db_value}
+        SQL
+      end
+
+      it 'does not have real starting after for period' do
+        expect(model.all).not_to respond_to(:real_starting_after)
+      end
+
+      it 'does not have real starting before for period' do
+        expect(model.all).not_to respond_to(:real_starting_before)
+      end
+
+      it 'does not have real finishing after for period' do
+        expect(model.all).not_to respond_to(:real_finishing_after)
+      end
+
+      it 'does not have real finishing before for period' do
+        expect(model.all).not_to respond_to(:real_finishing_before)
+      end
+
+      it 'queries containing date period' do
+        expect(model.period_containing_date(:test).to_sql).to include(<<-SQL.squish)
+          #{date_db_field} @> "time_keepers"."test"
+        SQL
+
+        expect(model.period_containing_date(value).to_sql).to include(<<-SQL.squish)
+          #{date_db_field} @> #{db_value}::date
+        SQL
+      end
+
+      it 'queries not containing date period' do
+        expect(model.period_not_containing_date(:test).to_sql).to include(<<-SQL.squish)
+          NOT (#{date_db_field} @> "time_keepers"."test")
+        SQL
+
+        expect(model.period_not_containing_date(value).to_sql).to include(<<-SQL.squish)
+          NOT (#{date_db_field} @> #{db_value}::date)
+        SQL
+      end
+
+      it 'queries overlapping date period' do
+        expect(model.period_overlapping_date(:test).to_sql).to include(<<-SQL.squish)
+          #{date_db_field} && "time_keepers"."test"
+        SQL
+
+        expect(model.period_overlapping_date(value, value).to_sql).to include(<<-SQL.squish)
+          #{date_db_field} && #{date_type}(#{db_value}::date, #{db_value}::date)
+        SQL
+      end
+
+      it 'queries not overlapping date period' do
+        expect(model.period_not_overlapping_date(:test).to_sql).to include(<<-SQL.squish)
+          NOT (#{date_db_field} && "time_keepers"."test")
+        SQL
+
+        expect(model.period_not_overlapping_date(value, value).to_sql).to include(<<-SQL.squish)
+          NOT (#{date_db_field} && #{date_type}(#{db_value}::date, #{db_value}::date))
+        SQL
+      end
+
+      it 'does not have real containing date period' do
+        expect(model.all).not_to respond_to(:period_real_containing_date)
+      end
+
+      it 'does not have real overlapping date period' do
+        expect(model.all).not_to respond_to(:period_real_overlapping_date)
+      end
+    end
+
+    context 'on instance' do
+      before { decorate(model, :period) }
+
+      it 'checks for current value' do
+        instance.period = 1.hour.ago.utc..1.hour.from_now.utc
+        expect(instance).to be_current_period
+
+        instance.period = 4.hour.from_now.utc..6.hour.from_now.utc
+        expect(instance).not_to be_current_period
+      end
+
+      it 'checks fro current based on a value' do
+        instance.period = 1.hour.ago.utc..1.hour.from_now.utc
+        expect(instance).to be_current_period_on(5.minutes.from_now.utc)
+
+        instance.period = 4.hour.from_now.utc..6.hour.from_now.utc
+        expect(instance).not_to be_current_period_on(5.minutes.from_now.utc)
+      end
+
+      it 'returns the start time' do
+        instance.period = 1.hour.ago.utc..1.hour.from_now.utc
+        expect(instance.period_start).to be_eql(instance.period.min)
+
+        instance.period = 4.hour.from_now.utc..6.hour.from_now.utc
+        expect(instance.period_start).to be_eql(instance.period.min)
+      end
+
+      it 'returns the finish time' do
+        instance.period = 1.hour.ago.utc..1.hour.from_now.utc
+        expect(instance.period_finish).to be_eql(instance.period.max)
+
+        instance.period = 4.hour.from_now.utc..6.hour.from_now.utc
+        expect(instance.period_finish).to be_eql(instance.period.max)
+      end
+    end
+
+    context 'with field threshold' do
+      before { decorate(model, :period, threshold: :th) }
+
+      let(:lower_db_field) { "(lower(#{db_field}) - #{threshold_value})" }
+      let(:upper_db_field) { "(upper(#{db_field}) + #{threshold_value})" }
+      let(:threshold_value) { '"time_keepers"."th"' }
+      let(:threshold_db_field) { "#{type}(#{lower_db_field}, #{upper_db_field})" }
+      let(:nullif_condition) { "nullif(#{threshold_db_field}, #{empty_condition})" }
+      let(:threshold_date_db_field) do
+        "daterange(#{lower_db_field}::date, #{upper_db_field}::date, '[]')"
+      end
+
+      context 'on model' do
+        it 'queries current on period' do
+          expect(model.period_on(value).to_sql).to include(<<-SQL.squish)
+            coalesce(#{nullif_condition} @> #{cast_db_value}, #{true_value})
+          SQL
+        end
+
+        it 'queries current period' do
+          expect(model.current_period.to_sql).to include(<<-SQL.squish)
+            coalesce(#{nullif_condition} @>
+          SQL
+
+          expect(model.current_period.to_sql).to include(<<-SQL.squish)
+            #{cast_type}, #{true_value})
+          SQL
+        end
+
+        it 'queries not current period' do
+          expect(model.not_current_period.to_sql).to include(<<-SQL.squish)
+            NOT (coalesce(#{nullif_condition} @>
+          SQL
+
+          expect(model.not_current_period.to_sql).to include(<<-SQL.squish)
+            #{cast_type}, #{true_value})
+          SQL
+        end
+
+        it 'queries real containing period' do
+          expect(model.period_real_containing(:test).to_sql).to include(<<-SQL.squish)
+            #{threshold_db_field} @> "time_keepers"."test"
+          SQL
+
+          expect(model.period_real_containing(value).to_sql).to include(<<-SQL.squish)
+            #{threshold_db_field} @> #{db_value}
+          SQL
+        end
+
+        it 'queries real overlapping period' do
+          expect(model.period_real_overlapping(:test).to_sql).to include(<<-SQL.squish)
+            #{threshold_db_field} && "time_keepers"."test"
+          SQL
+
+          expect(model.period_real_overlapping(value, value).to_sql).to include(<<-SQL.squish)
+            #{threshold_db_field} && #{type}(#{db_value}, #{db_value})
+          SQL
+        end
+
+        it 'queries real starting after for period' do
+          expect(model.period_real_starting_after(:test).to_sql).to include(<<-SQL.squish)
+            #{lower_db_field} > "time_keepers"."test"
+          SQL
+
+          expect(model.period_real_starting_after(value).to_sql).to include(<<-SQL.squish)
+            #{lower_db_field} > #{db_value}
+          SQL
+        end
+
+        it 'queries real starting before for period' do
+          expect(model.period_real_starting_before(:test).to_sql).to include(<<-SQL.squish)
+            #{lower_db_field} < "time_keepers"."test"
+          SQL
+
+          expect(model.period_real_starting_before(value).to_sql).to include(<<-SQL.squish)
+            #{lower_db_field} < #{db_value}
+          SQL
+        end
+
+        it 'queries real finishing after for period' do
+          expect(model.period_real_finishing_after(:test).to_sql).to include(<<-SQL.squish)
+            #{upper_db_field} > "time_keepers"."test"
+          SQL
+
+          expect(model.period_real_finishing_after(value).to_sql).to include(<<-SQL.squish)
+            #{upper_db_field} > #{db_value}
+          SQL
+        end
+
+        it 'queries real finishing before for period' do
+          expect(model.period_real_finishing_before(:test).to_sql).to include(<<-SQL.squish)
+            #{upper_db_field} < "time_keepers"."test"
+          SQL
+
+          expect(model.period_real_finishing_before(value).to_sql).to include(<<-SQL.squish)
+            #{upper_db_field} < #{db_value}
+          SQL
+        end
+
+        it 'queries containing date period' do
+          expect(model.period_containing_date(:test).to_sql).to include(<<-SQL.squish)
+            #{date_db_field} @> "time_keepers"."test"
+          SQL
+
+          expect(model.period_containing_date(value).to_sql).to include(<<-SQL.squish)
+            #{date_db_field} @> #{db_value}::date
+          SQL
+        end
+
+        it 'queries not containing date period' do
+          expect(model.period_not_containing_date(:test).to_sql).to include(<<-SQL.squish)
+            NOT (#{date_db_field} @> "time_keepers"."test")
+          SQL
+
+          expect(model.period_not_containing_date(value).to_sql).to include(<<-SQL.squish)
+            NOT (#{date_db_field} @> #{db_value}::date)
+          SQL
+        end
+
+        it 'queries overlapping date period' do
+          expect(model.period_overlapping_date(:test).to_sql).to include(<<-SQL.squish)
+            #{date_db_field} && "time_keepers"."test"
+          SQL
+
+          expect(model.period_overlapping_date(value, value).to_sql).to include(<<-SQL.squish)
+            #{date_db_field} && #{date_type}(#{db_value}::date, #{db_value}::date)
+          SQL
+        end
+
+        it 'queries not overlapping date period' do
+          expect(model.period_not_overlapping_date(:test).to_sql).to include(<<-SQL.squish)
+            NOT (#{date_db_field} && "time_keepers"."test")
+          SQL
+
+          expect(model.period_not_overlapping_date(value, value).to_sql).to include(<<-SQL.squish)
+            NOT (#{date_db_field} && #{date_type}(#{db_value}::date, #{db_value}::date))
+          SQL
+        end
+
+        it 'queries real containing date period' do
+          expect(model.period_real_containing_date(:test).to_sql).to include(<<-SQL.squish)
+            #{threshold_date_db_field} @> "time_keepers"."test"
+          SQL
+
+          expect(model.period_real_containing_date(value).to_sql).to include(<<-SQL.squish)
+            #{threshold_date_db_field} @> #{db_value}::date
+          SQL
+        end
+
+        it 'queries real overlapping date period' do
+          expect(model.period_real_overlapping_date(:test).to_sql).to include(<<-SQL.squish)
+            #{threshold_date_db_field} && "time_keepers"."test"
+          SQL
+
+          expect(model.period_real_overlapping_date(value, value).to_sql).to include(<<-SQL.squish)
+            #{threshold_date_db_field} && #{date_type}(#{db_value}::date, #{db_value}::date)
+          SQL
+        end
+      end
+
+      context 'on instance' do
+        before { decorate(model, :period, threshold: :th) }
+        before { instance.th = 1.hour }
+
+        it 'checks for current value' do
+          instance.period = nil
+          expect(instance).to be_current_period
+
+          instance.period = (Time.zone.now - 1.hour)..(Time.zone.now + 1.hour)
+          expect(instance).to be_current_period
+
+          instance.period = (Time.zone.now + 90.minutes)..(Time.zone.now + 3.hour)
+          expect(instance).not_to be_current_period
+        end
+
+        it 'checks for current based on a value' do
+          instance.period = nil
+          expect(instance).to be_current_period_on(5.minutes.from_now.utc)
+
+          instance.period = (Time.zone.now - 1.hour)..(Time.zone.now + 1.hour)
+          expect(instance).to be_current_period_on(5.minutes.from_now.utc)
+
+          instance.period = 90.minutes.from_now.utc..3.hour.from_now.utc
+          expect(instance).not_to be_current_period_on(5.minutes.from_now.utc)
+        end
+
+        it 'returns the real range' do
+          value = (Time.zone.now - 1.hour)..(Time.zone.now + 1.hour)
+          instance.period = value
+          expect(instance.real_period.min).to be_eql(value.min - 1.hour)
+          expect(instance.real_period.max).to be_eql(value.max + 1.hour)
+        end
+
+        it 'returns the real start' do
+          value = (Time.zone.now - 1.hour)..(Time.zone.now + 1.hour)
+          instance.period = value
+          expect(instance.period_real_start).to be_eql(value.min - 1.hour)
+        end
+
+        it 'returns the real finish' do
+          value = (Time.zone.now - 1.hour)..(Time.zone.now + 1.hour)
+          instance.period = value
+          expect(instance.period_real_finish).to be_eql(value.max + 1.hour)
+        end
+      end
+    end
+
+    context 'with value threshold' do
+      before { decorate(model, :period, threshold: 5.minutes) }
+
+      let(:lower_db_field) { "(lower(#{db_field}) - #{threshold_value})" }
+      let(:upper_db_field) { "(upper(#{db_field}) + #{threshold_value})" }
+      let(:threshold_value) { "'300 seconds'::interval" }
+      let(:threshold_db_field) { "#{type}(#{lower_db_field}, #{upper_db_field})" }
+      let(:nullif_condition) { "nullif(#{threshold_db_field}, #{empty_condition})" }
+
+      context 'on model' do
+        it 'queries current on period' do
+          expect(model.period_on(value).to_sql).to include(<<-SQL.squish)
+            coalesce(#{nullif_condition} @> #{cast_db_value}, #{true_value})
+          SQL
+        end
+
+        it 'queries current period' do
+          expect(model.current_period.to_sql).to include(<<-SQL.squish)
+            coalesce(#{nullif_condition} @>
+          SQL
+
+          expect(model.current_period.to_sql).to include(<<-SQL.squish)
+            #{cast_type}, #{true_value})
+          SQL
+        end
+
+        it 'queries not current period' do
+          expect(model.not_current_period.to_sql).to include(<<-SQL.squish)
+            NOT (coalesce(#{nullif_condition} @>
+          SQL
+
+          expect(model.not_current_period.to_sql).to include(<<-SQL.squish)
+            #{cast_type}, #{true_value})
+          SQL
+        end
+
+        it 'queries real containing period' do
+          expect(model.period_real_containing(:test).to_sql).to include(<<-SQL.squish)
+            #{threshold_db_field} @> "time_keepers"."test"
+          SQL
+
+          expect(model.period_real_containing(value).to_sql).to include(<<-SQL.squish)
+            #{threshold_db_field} @> #{db_value}
+          SQL
+        end
+
+        it 'queries real overlapping period' do
+          expect(model.period_real_overlapping(:test).to_sql).to include(<<-SQL.squish)
+            #{threshold_db_field} && "time_keepers"."test"
+          SQL
+
+          expect(model.period_real_overlapping(value, value).to_sql).to include(<<-SQL.squish)
+            #{threshold_db_field} && #{type}(#{db_value}, #{db_value})
+          SQL
+        end
+
+        it 'queries real starting after for period' do
+          expect(model.period_real_starting_after(:test).to_sql).to include(<<-SQL.squish)
+            #{lower_db_field} > "time_keepers"."test"
+          SQL
+
+          expect(model.period_real_starting_after(value).to_sql).to include(<<-SQL.squish)
+            #{lower_db_field} > #{db_value}
+          SQL
+        end
+
+        it 'queries real starting before for period' do
+          expect(model.period_real_starting_before(:test).to_sql).to include(<<-SQL.squish)
+            #{lower_db_field} < "time_keepers"."test"
+          SQL
+
+          expect(model.period_real_starting_before(value).to_sql).to include(<<-SQL.squish)
+            #{lower_db_field} < #{db_value}
+          SQL
+        end
+
+        it 'queries real finishing after for period' do
+          expect(model.period_real_finishing_after(:test).to_sql).to include(<<-SQL.squish)
+            #{upper_db_field} > "time_keepers"."test"
+          SQL
+
+          expect(model.period_real_finishing_after(value).to_sql).to include(<<-SQL.squish)
+            #{upper_db_field} > #{db_value}
+          SQL
+        end
+
+        it 'queries real finishing before for period' do
+          expect(model.period_real_finishing_before(:test).to_sql).to include(<<-SQL.squish)
+            #{upper_db_field} < "time_keepers"."test"
+          SQL
+
+          expect(model.period_real_finishing_before(value).to_sql).to include(<<-SQL.squish)
+            #{upper_db_field} < #{db_value}
+          SQL
+        end
+
+        it 'queries containing date period' do
+          expect(model.period_containing_date(:test).to_sql).to include(<<-SQL.squish)
+            #{date_db_field} @> "time_keepers"."test"
+          SQL
+
+          expect(model.period_containing_date(value).to_sql).to include(<<-SQL.squish)
+            #{date_db_field} @> #{db_value}
+          SQL
+        end
+
+        it 'queries not containing date period' do
+          expect(model.period_not_containing_date(:test).to_sql).to include(<<-SQL.squish)
+            NOT (#{date_db_field} @> "time_keepers"."test")
+          SQL
+
+          expect(model.period_not_containing_date(value).to_sql).to include(<<-SQL.squish)
+            NOT (#{date_db_field} @> #{db_value}::date)
+          SQL
+        end
+
+        it 'queries overlapping date period' do
+          expect(model.period_overlapping_date(:test).to_sql).to include(<<-SQL.squish)
+            #{date_db_field} && "time_keepers"."test"
+          SQL
+
+          expect(model.period_overlapping_date(value, value).to_sql).to include(<<-SQL.squish)
+            #{date_db_field} && #{date_type}(#{db_value}::date, #{db_value}::date)
+          SQL
+        end
+
+        it 'queries not overlapping date period' do
+          expect(model.period_not_overlapping_date(:test).to_sql).to include(<<-SQL.squish)
+            NOT (#{date_db_field} && "time_keepers"."test")
+          SQL
+
+          expect(model.period_not_overlapping_date(value, value).to_sql).to include(<<-SQL.squish)
+            NOT (#{date_db_field} && #{date_type}(#{db_value}::date, #{db_value}::date))
+          SQL
+        end
+      end
+
+      context 'on instance' do
+        before { decorate(model, :period, threshold: 45.minutes) }
+
+        it 'checks for current value' do
+          instance.period = nil
+          expect(instance).to be_current_period
+
+          instance.period = (Time.zone.now - 1.hour)..(Time.zone.now + 1.hour)
+          expect(instance).to be_current_period
+
+          instance.period = (Time.zone.now + 90.minutes)..(Time.zone.now + 3.hour)
+          expect(instance).not_to be_current_period
+        end
+
+        it 'checks for current based on a value' do
+          instance.period = nil
+          expect(instance).to be_current_period_on(5.minutes.from_now.utc)
+
+          instance.period = (Time.zone.now - 1.hour)..(Time.zone.now + 1.hour)
+          expect(instance).to be_current_period_on(5.minutes.from_now.utc)
+
+          instance.period = 90.minutes.from_now.utc..3.hour.from_now.utc
+          expect(instance).not_to be_current_period_on(5.minutes.from_now.utc)
+        end
+
+        it 'returns the real range' do
+          value = (Time.zone.now - 1.hour)..(Time.zone.now + 1.hour)
+          instance.period = value
+          expect(instance.real_period.min).to be_eql(value.min - 45.minutes)
+          expect(instance.real_period.max).to be_eql(value.max + 45.minutes)
+        end
+
+        it 'returns the real start' do
+          value = (Time.zone.now - 1.hour)..(Time.zone.now + 1.hour)
+          instance.period = value
+          expect(instance.period_real_start).to be_eql(value.min - 45.minutes)
+        end
+
+        it 'returns the real finish' do
+          value = (Time.zone.now - 1.hour)..(Time.zone.now + 1.hour)
+          instance.period = value
+          expect(instance.period_real_finish).to be_eql(value.max + 45.minutes)
+        end
+      end
+    end
+  end
+
+  context 'on daterange' do
+    let(:type) { :daterange }
+    let(:value) { Date.today }
+    let(:db_field) { '"time_keepers"."available"' }
+    let(:db_value) { "'#{value.strftime('%F')}'" }
+
+    let(:cast_type) { '::date' }
+    let(:cast_db_value) { "#{db_value}#{cast_type}" }
+    let(:empty_condition) { "#{type}(NULL, NULL)" }
+    let(:nullif_condition) { "nullif(#{threshold_db_field}, #{empty_condition})" }
+
+    let(:lower_db_field) { "(lower(#{db_field}) - #{threshold_value})::date" }
+    let(:upper_db_field) { "(upper(#{db_field}) + #{threshold_value})::date" }
+    let(:threshold_value) { "'86400 seconds'::interval" }
+    let(:threshold_db_field) { "#{type}(#{lower_db_field}, #{upper_db_field})" }
+
+    before { decorate(model, :available, pessimistic: true, threshold: 1.day) }
+
+    context 'on model' do
+      it 'queries current on available' do
+        expect(model.available_on(value).to_sql).to include(<<-SQL.squish)
+          coalesce(#{nullif_condition} @> #{cast_db_value}, #{false_value})
+        SQL
+      end
+
+      it 'queries current available' do
+        expect(model.current_available.to_sql).to include(<<-SQL.squish)
+          coalesce(#{nullif_condition} @>
+        SQL
+
+        expect(model.current_available.to_sql).to include(<<-SQL.squish)
+          #{cast_type}, #{false_value})
+        SQL
+      end
+
+      it 'queries not current available' do
+        expect(model.not_current_available.to_sql).to include(<<-SQL.squish)
+          NOT (coalesce(#{nullif_condition} @>
+        SQL
+
+        expect(model.not_current_available.to_sql).to include(<<-SQL.squish)
+          #{cast_type}, #{false_value})
+        SQL
+      end
+
+      it 'queries containing available' do
+        expect(model.available_containing(:test).to_sql).to include(<<-SQL.squish)
+          #{db_field} @> "time_keepers"."test"
+        SQL
+
+        expect(model.available_containing(value).to_sql).to include(<<-SQL.squish)
+          #{db_field} @> #{db_value}
+        SQL
+      end
+
+      it 'queries not containing available' do
+        expect(model.available_not_containing(:test).to_sql).to include(<<-SQL.squish)
+          NOT (#{db_field} @> "time_keepers"."test")
+        SQL
+
+        expect(model.available_not_containing(value).to_sql).to include(<<-SQL.squish)
+          NOT (#{db_field} @> #{db_value})
+        SQL
+      end
+
+      it 'queries overlapping available' do
+        expect(model.available_overlapping(:test).to_sql).to include(<<-SQL.squish)
+          #{db_field} && "time_keepers"."test"
+        SQL
+
+        expect(model.available_overlapping(value, value).to_sql).to include(<<-SQL.squish)
+          #{db_field} && #{type}(#{db_value}, #{db_value})
+        SQL
+      end
+
+      it 'queries not overlapping available' do
+        expect(model.available_not_overlapping(:test).to_sql).to include(<<-SQL.squish)
+          NOT (#{db_field} && "time_keepers"."test")
+        SQL
+
+        expect(model.available_not_overlapping(value, value).to_sql).to include(<<-SQL.squish)
+          NOT (#{db_field} && #{type}(#{db_value}, #{db_value}))
+        SQL
+      end
+
+      it 'queries starting after available' do
+        expect(model.available_starting_after(:test).to_sql).to include(<<-SQL.squish)
+          lower(#{db_field}) > "time_keepers"."test"
+        SQL
+
+        expect(model.available_starting_after(value).to_sql).to include(<<-SQL.squish)
+          lower(#{db_field}) > #{db_value}
+        SQL
+      end
+
+      it 'queries starting before available' do
+        expect(model.available_starting_before(:test).to_sql).to include(<<-SQL.squish)
+          lower(#{db_field}) < "time_keepers"."test"
+        SQL
+
+        expect(model.available_starting_before(value).to_sql).to include(<<-SQL.squish)
+          lower(#{db_field}) < #{db_value}
+        SQL
+      end
+
+      it 'queries finishing after available' do
+        expect(model.available_finishing_after(:test).to_sql).to include(<<-SQL.squish)
+          upper(#{db_field}) > "time_keepers"."test"
+        SQL
+
+        expect(model.available_finishing_after(value).to_sql).to include(<<-SQL.squish)
+          upper(#{db_field}) > #{db_value}
+        SQL
+      end
+
+      it 'queries finishing before available' do
+        expect(model.available_finishing_before(:test).to_sql).to include(<<-SQL.squish)
+          upper(#{db_field}) < "time_keepers"."test"
+        SQL
+
+        expect(model.available_finishing_before(value).to_sql).to include(<<-SQL.squish)
+          upper(#{db_field}) < #{db_value}
+        SQL
+      end
+
+      it 'queries real containing available' do
+        expect(model.available_real_containing(:test).to_sql).to include(<<-SQL.squish)
+          #{threshold_db_field} @> "time_keepers"."test"
+        SQL
+
+        expect(model.available_real_containing(value).to_sql).to include(<<-SQL.squish)
+          #{threshold_db_field} @> #{db_value}
+        SQL
+      end
+
+      it 'queries real overlapping available' do
+        expect(model.available_real_overlapping(:test).to_sql).to include(<<-SQL.squish)
+          #{threshold_db_field} && "time_keepers"."test"
+        SQL
+
+        expect(model.available_real_overlapping(value, value).to_sql).to include(<<-SQL.squish)
+          #{threshold_db_field} && #{type}(#{db_value}, #{db_value})
+        SQL
+      end
+
+      it 'queries real starting after for available' do
+        expect(model.available_real_starting_after(:test).to_sql).to include(<<-SQL.squish)
+          #{lower_db_field} > "time_keepers"."test"
+        SQL
+
+        expect(model.available_real_starting_after(value).to_sql).to include(<<-SQL.squish)
+          #{lower_db_field} > #{db_value}
+        SQL
+      end
+
+      it 'queries real starting before for available' do
+        expect(model.available_real_starting_before(:test).to_sql).to include(<<-SQL.squish)
+          #{lower_db_field} < "time_keepers"."test"
+        SQL
+
+        expect(model.available_real_starting_before(value).to_sql).to include(<<-SQL.squish)
+          #{lower_db_field} < #{db_value}
+        SQL
+      end
+
+      it 'queries real finishing after for available' do
+        expect(model.available_real_finishing_after(:test).to_sql).to include(<<-SQL.squish)
+          #{upper_db_field} > "time_keepers"."test"
+        SQL
+
+        expect(model.available_real_finishing_after(value).to_sql).to include(<<-SQL.squish)
+          #{upper_db_field} > #{db_value}
+        SQL
+      end
+
+      it 'queries real finishing before for available' do
+        expect(model.available_real_finishing_before(:test).to_sql).to include(<<-SQL.squish)
+          #{upper_db_field} < "time_keepers"."test"
+        SQL
+
+        expect(model.available_real_finishing_before(value).to_sql).to include(<<-SQL.squish)
+          #{upper_db_field} < #{db_value}
+        SQL
+      end
+
+      it 'does not query containing date available' do
+        expect(model.all).not_to respond_to(:available_containing_date)
+      end
+
+      it 'does not query not containing date available' do
+        expect(model.all).not_to respond_to(:available_not_containing_date)
+      end
+
+      it 'does not query overlapping date available' do
+        expect(model.all).not_to respond_to(:available_overlapping_date)
+      end
+
+      it 'does not query not overlapping date available' do
+        expect(model.all).not_to respond_to(:available_not_overlapping_date)
+      end
+
+      it 'does not query real containing date available' do
+        expect(model.all).not_to respond_to(:available_real_containing_date)
+      end
+
+      it 'does not query real overlapping date available' do
+        expect(model.all).not_to respond_to(:available_real_overlapping_date)
+      end
+    end
+
+    context 'on instance' do
+      it 'checks for current value' do
+        instance.available = nil
+        expect(instance).not_to be_current_available
+
+        instance.available = Date.yesterday..Date.tomorrow
+        expect(instance).to be_current_available
+
+        instance.available = Date.new.prev_month..Date.new.next_month
+        expect(instance).not_to be_current_available
+      end
+
+      it 'checks fro current based on a value' do
+        instance.available = nil
+        expect(instance).not_to be_current_available_on(Date.tomorrow)
+
+        instance.available = Date.yesterday..Date.tomorrow
+        expect(instance).to be_current_available_on(Date.tomorrow)
+
+        instance.available = Date.new.prev_month..Date.new.next_month
+        expect(instance).to be_current_available_on(Date.new.next_month)
+      end
+
+      it 'returns the start date' do
+        instance.available = Date.yesterday..Date.tomorrow
+        expect(instance.available_start).to be_eql(instance.available.min)
+
+        instance.available = Date.new.prev_month..Date.new.next_month
+        expect(instance.available_start).to be_eql(instance.available.min)
+      end
+
+      it 'returns the finish date' do
+        instance.available = Date.yesterday..Date.tomorrow
+        expect(instance.available_finish).to be_eql(instance.available.max)
+
+        instance.available = Date.new.prev_month..Date.new.next_month
+        expect(instance.available_finish).to be_eql(instance.available.max)
+      end
+
+      it 'returns the real range' do
+        value = Date.yesterday..Date.tomorrow
+        instance.available = value
+        expect(instance.real_available.min).to be_eql(value.min.prev_day)
+        expect(instance.real_available.max).to be_eql(value.max.next_day)
+      end
+
+      it 'returns the real start date' do
+        instance.available = Date.yesterday..Date.tomorrow
+        expect(instance.available_real_start).to be_eql(instance.available.min.prev_day)
+      end
+
+      it 'returns the real finish date' do
+        instance.available = Date.yesterday..Date.tomorrow
+        expect(instance.available_real_finish).to be_eql(instance.available.max.next_day)
+      end
+    end
+  end
+end