has_helpers 5.0.2

data/spec/lib/flattener/column/types_spec.rb

@@ -0,0 +1,65 @@
+require "rails_helper"
+
+describe ::Flattener::Column::Types do
+  describe ".sql_type_to_type" do  # Just testing cases which are more complicated than a 1-to-1 mapping
+    it "matches all varchars as string type" do
+      aggregate_failures do
+        expect(subject.sql_type_to_type("character varying")).to eq(described_class::STRING)
+        expect(subject.sql_type_to_type("character varying(255)")).to eq(described_class::STRING)
+      end
+    end
+
+    it "matches string type" do
+      aggregate_failures do
+        expect(subject.sql_type_to_type("string")).to eq(described_class::STRING)
+      end
+    end
+
+    describe "numerics" do
+      it "matches currency type" do
+        aggregate_failures do
+          expect(subject.sql_type_to_type("numeric(7,2)")).to eq(described_class::CURRENCY)
+          expect(subject.sql_type_to_type("numeric(12,2)")).to eq(described_class::CURRENCY)
+          expect(subject.sql_type_to_type("numeric(20,5)")).to eq(described_class::CURRENCY)
+        end
+      end
+
+      it "matches percent type" do
+        aggregate_failures do
+          expect(subject.sql_type_to_type("numeric(6,3)")).to eq(described_class::PERCENT)
+          expect(subject.sql_type_to_type("numeric(9,6)")).to eq(described_class::PERCENT)
+        end
+      end
+
+      it "matches plain jane decimal type" do
+        aggregate_failures do
+          expect(subject.sql_type_to_type("numeric(4,2)")).to eq(described_class::DECIMAL)
+          expect(subject.sql_type_to_type("numeric(5,3)")).to eq(described_class::DECIMAL)
+        end
+      end
+
+      it "matches numeric without scale and precision" do
+        # FIXME: Remove this spec once all numeric columns have scale and precision set. *
+        expect(subject.sql_type_to_type("numeric")).to eq(described_class::DECIMAL)
+      end
+    end
+
+    describe "matches array type" do
+      it { expect(subject.sql_type_to_type("Array")).to eq(described_class::ARRAY) }
+      it { expect(subject.sql_type_to_type("ARRAY")).to eq(described_class::ARRAY) }
+      it { expect(subject.sql_type_to_type("array")).to eq(described_class::ARRAY) }
+      it { expect(subject.sql_type_to_type(:array)).to eq(described_class::ARRAY) }
+    end
+
+    it "errors like a boss when no type is matched" do
+      aggregate_failures do
+        # FIXME: Revert this once all numeric columns have scale and precision set. *
+        # expect { subject.sql_type_to_type("numeric") }.to raise_error(::ArgumentError, /No type matches SQL type/)  # decimal is missing scale qualification
+        expect { subject.sql_type_to_type("numeric(9)") }.to raise_error(::ArgumentError, /No type matches SQL type/)  # decimal is missing precision qualification
+
+        expect { subject.sql_type_to_type("varchar") }.to raise_error(::ArgumentError, /No type matches SQL type/)  # varchar is specified differently
+        expect { subject.sql_type_to_type("invalid") }.to raise_error(::ArgumentError, /No type matches SQL type/)
+      end
+    end
+  end
+end

data/spec/lib/has_helpers/active_record/base_spec.rb

@@ -0,0 +1,53 @@
+require "rails_helper"
+
+describe ::HasHelpers::ActiveRecord::Base do
+  subject { FactoryBot.create(:organization) }
+  let(:nested_resource) { FactoryBot.create(:event) }
+
+  describe "#to_service" do
+    it { expect(subject.to_service).to be_a(::Service) }
+    it { expect(subject.to_service.url).to eq("/organizations/#{ subject.id }") }
+    it { expect(::Organization.new.to_service.to_s).to eq("") }
+
+    context "nested resource" do
+      it { expect { nested_resource.to_service }.to raise_error(::HasHelpers::ActiveRecord::ServiceError, /event_path/) }
+    end
+  end
+
+  describe "#to_renderable" do
+    it { expect(subject.to_renderable).to eq(subject.to_service) }
+    it { expect(::Event.new.to_renderable).to eq(::HasHelpers::TextNode.new("")) }
+
+    context "nested resource" do
+      it { expect(nested_resource.to_renderable).to eq(nested_resource.name.to_text_node) }
+    end
+
+    context "with renderable proc" do
+      before(:all) do
+        @stashed_renderable_proc = described_class.to_renderable_proc
+        described_class.set_renderable_proc do |record|
+          case record
+          when ::Event
+            record.name.to_s.to_service
+          when ::Organization
+            record.name.to_s.to_text_node
+          end
+        end
+      end
+
+      after(:all) do
+        described_class.set_renderable_proc(@stashed_renderable_proc)
+      end
+
+      context "for explicitly handled cases" do
+        it { expect(::Event.new.to_renderable).to be_a(::Service) }
+        it { expect(::Organization.new.to_renderable).to be_a(::HasHelpers::TextNode) }
+      end
+
+      it "defaults to the normal behavior" do
+        expect(::User.new.to_renderable).to be_a(::Service)  # has matching route
+        expect(::Meetup.new.to_renderable).to be_a(::HasHelpers::TextNode)  # no matching route
+      end
+    end
+  end
+end

data/spec/lib/has_helpers/active_record/date_range_spec.rb

@@ -0,0 +1,498 @@
+require "rails_helper"
+
+# TODO: Set up and test against database triggers which correspond to the date range model validations *
+describe ::HasHelpers::ActiveRecord::DateRange do
+  describe "#has_valid_date_range" do
+    subject { FactoryBot.build(:basic_schedule) }
+
+    context "end_date sanity check" do
+      it "validates when end_date is nil" do
+        subject.end_date = nil
+        subject.validate
+        expect(subject.errors[:end_date]).to be_empty
+      end
+
+      it "validates when end_date is after start_date" do
+        subject.end_date = subject.start_date + 1.day
+        subject.validate
+        expect(subject.errors[:end_date]).to be_empty
+      end
+
+      it "validates when end_date equals start_date" do
+        subject.end_date = subject.start_date
+        subject.validate
+        expect(subject.errors[:end_date]).to be_empty
+      end
+
+      it "fails when end_date is before start_date" do
+        subject.end_date = subject.start_date - 1.day
+        subject.validate
+        expect(subject.errors[:end_date]).to include(described_class::END_DATE_SANITY_ERR_MSG % ["End Date", "Start Date"])
+      end
+    end
+
+    context "adds date range accessor method" do
+      context "returns date range" do
+        it do
+          start_date = FactoryBot.generate(:past_date)
+          end_date = FactoryBot.generate(:future_date)
+          subject.start_date = start_date
+          subject.end_date = end_date
+          expect(subject.date_range).to eq(start_date..end_date)
+        end
+
+        it "with no end date" do
+          start_date = FactoryBot.generate(:past_date)
+          subject.start_date = start_date
+          subject.end_date = nil
+          expect(subject.date_range).to eq(start_date..Date::Infinity.new)
+        end
+
+        it "with no start date" do
+          end_date = FactoryBot.generate(:future_date)
+          subject.start_date = nil
+          subject.end_date = end_date
+          expect(subject.date_range).to eq(-Date::Infinity.new..end_date)
+        end
+
+        it "with no dates" do
+          subject.start_date = nil
+          subject.end_date = nil
+          expect(subject.date_range).to eq(-Date::Infinity.new..Date::Infinity.new)
+        end
+      end
+
+      context "with name set by :as option" do
+        it do
+          start_date = FactoryBot.generate(:past_date)
+          end_date = FactoryBot.generate(:future_date)
+          subject.start_date = start_date
+          subject.end_date = end_date
+          expect(subject.epoch).to eq(start_date..end_date)
+        end
+
+        it "with no end date" do
+          start_date = FactoryBot.generate(:past_date)
+          subject.start_date = start_date
+          subject.end_date = nil
+          expect(subject.epoch).to eq(start_date..Date::Infinity.new)
+        end
+
+        it "with no start date" do
+          end_date = FactoryBot.generate(:future_date)
+          subject.start_date = nil
+          subject.end_date = end_date
+          expect(subject.epoch).to eq(-Date::Infinity.new..end_date)
+        end
+
+        it "with no dates" do
+          subject.start_date = nil
+          subject.end_date = nil
+          expect(subject.epoch).to eq(-Date::Infinity.new..Date::Infinity.new)
+        end
+      end
+    end
+  end
+
+  describe "#has_distinct_date_range" do
+    let(:user) { FactoryBot.build(:user) }
+    let(:a) { user.schedules.build(FactoryBot.attributes_for(:schedule, :with_end_date).except(:user_id)) }
+    let(:b) { user.schedules.build(FactoryBot.attributes_for(:schedule, :with_end_date).except(:user_id)) }
+
+    ## case 1: <--- [A] --->
+    ##         (don't care about B; always overlaps)
+    describe "when A is open-ended on both ends" do
+      it "should overlap" do
+        a.start_date = a.end_date = nil
+        aggregate_failures do
+          expect(a.date_range_overlaps?(b)).to be_truthy
+          expect(b.date_range_overlaps?(a)).to be_truthy
+        end
+      end
+    end
+
+
+    describe "when A is open-ended on the left" do
+      ## case 2a: <--- [A] ------|
+      ##          <--- [B] ---|
+      ## case 2b: <--- [A] ------|
+      ##          <--- [B] ---------|
+      describe "and B is open-ended on the left" do
+        it "should overlap" do
+          a.start_date = b.start_date = nil
+          aggregate_failures do
+            expect(a.date_range_overlaps?(b)).to be_truthy
+            expect(b.date_range_overlaps?(a)).to be_truthy
+          end
+        end
+      end
+      describe "and B's start date" do
+        ## case 3: <--- [A] ------|
+        ##                    |--- [B] ---|
+        describe "is before A's end date" do
+          it "should overlap" do
+            a.start_date = nil
+            b.start_date = a.end_date - (rand(5) + 1).days
+            # b.end_date = b.start_date + FactoryBot.generate(:little_interval) unless b.end_date.nil?
+            b.end_date = b.start_date + (rand(5) + 1).days unless b.end_date.nil?
+            aggregate_failures do
+              expect(a.date_range_overlaps?(b)).to be_truthy
+              expect(b.date_range_overlaps?(a)).to be_truthy
+            end
+          end
+        end
+        ## case 4: <--- [A] ------|
+        ##                            |--- [B] ---|
+        describe "is after A's end date" do
+          it "should not overlap" do
+            a.start_date = nil
+            b.start_date = a.end_date + (rand(5) + 1).days
+            # b.end_date = b.start_date + FactoryBot.generate(:little_interval) unless b.end_date.nil?
+            b.end_date = b.start_date + (rand(5) + 1).days unless b.end_date.nil?
+            aggregate_failures do
+              expect(a.date_range_overlaps?(b)).to be_falsey
+              expect(b.date_range_overlaps?(a)).to be_falsey
+            end
+          end
+        end
+      end
+    end
+
+    describe "when A is open-ended on the right" do
+      ## case 5a:    |------ [A] --->
+      ##          |--------- [B] --->
+      ## case 5b:    |------ [A] --->
+      ##                |--- [B] --->
+      describe "and B is open-ended on the right" do
+        it "should overlap" do
+          a.end_date = b.end_date = nil
+          expect(a.date_range_overlaps?(b)).to be_truthy
+          expect(b.date_range_overlaps?(a)).to be_truthy
+        end
+      end
+      describe "and B's end date" do
+        ## case 6:                |--- [A] --->
+        ##         |--- [B] ---|
+        describe "is before A's start date" do
+          it "should not overlap" do
+            a.end_date = nil
+            b.end_date = a.start_date - (rand(5) + 1).days
+            # b.start_date = b.end_date - FactoryBot.generate(:little_interval) unless b.start_date.nil?
+            b.start_date = b.end_date - (rand(5) + 1).days
+            aggregate_failures do
+              expect(a.date_range_overlaps?(b)).to be_falsey
+              expect(b.date_range_overlaps?(a)).to be_falsey
+            end
+          end
+        end
+        ## case 7:          |--- [A] --->
+        ##         |--- [B] ---|
+        describe "is after A's start date" do
+          it "should overlap" do
+            a.end_date = nil
+            b.end_date = a.start_date + (rand(5) + 1).days
+            # b.start_date = b.end_date - FactoryBot.generate(:little_interval) unless b.start_date.nil?
+            b.start_date = b.end_date - (rand(5) + 1).days
+            aggregate_failures do
+              expect(a.date_range_overlaps?(b)).to be_truthy
+              expect(b.date_range_overlaps?(a)).to be_truthy
+            end
+          end
+        end
+      end
+    end
+
+    describe "when A is bounded" do
+      ## case 8: |------ [A] ------|
+      ##            |--- [B] ---|
+      describe "and B is entirely within A" do
+        it "should overlap" do
+          a.start_date = b.start_date - (rand(5) + 1).days
+          a.end_date = b.end_date + (rand(5) + 1).days
+          aggregate_failures do
+            expect(a.date_range_overlaps?(b)).to be_truthy
+            expect(b.date_range_overlaps?(a)).to be_truthy
+          end
+        end
+      end
+      ## case 9:    |--- [A] ------|
+      ##         |------ [B] ---|
+      describe "and B overlaps A" do
+        it "should overlap" do
+          b.start_date = a.start_date - (rand(5) + 1).days
+          # a.end_date = b.end_date + (rand(5) + 1).days
+          aggregate_failures do
+            expect(a.date_range_overlaps?(b)).to be_truthy
+            expect(b.date_range_overlaps?(a)).to be_truthy
+          end
+        end
+      end
+    end
+  end
+
+  describe "date range validation" do
+    context do
+      # Set up a schedule (subject) which has the same attributes as another
+      # schedule (other) and the same owner (user).
+      let(:user) { FactoryBot.build(:user) }
+      let(:schedule_attrs) { FactoryBot.attributes_for(:schedule, :with_end_date) }
+      let!(:other) { user.schedules.build(schedule_attrs.except(:user_id)) }
+      subject! { user.schedules.build(schedule_attrs.except(:user_id)) }
+
+      it "fails when date ranges overlap" do
+        subject.validate
+        other.validate
+        aggregate_failures do
+          expect(subject.errors[:start_date]).to include(/must be unique within the given date range/)
+          expect(other.errors[:start_date]).to include(/must be unique within the given date range/)
+        end
+      end
+
+      it "succeeds when date ranges do NOT overlap" do
+        subject.start_date = other.end_date + 1
+        subject.end_date = nil
+        subject.validate
+        other.validate
+        aggregate_failures do
+          expect(subject.errors[:start_date]).to_not include(/must be unique within the given date range/)
+          expect(other.errors[:start_date]).to_not include(/must be unique within the given date range/)
+        end
+      end
+
+      it "does not add errors if the object is marked for destruction" do
+        subject.mark_for_destruction
+        subject.validate
+        expect(subject.errors[:start_date]).to_not include(/must be unique within the given date range/)
+      end
+    end
+
+    context do
+      # Set up an event (subject) which has the same attributes as another
+      # event (other) and the same owner (user).
+      let(:user) { FactoryBot.build(:user) }
+      let(:event_attrs) { FactoryBot.attributes_for(:event, :with_end_date, :with_manager, :with_schedule_type) }
+      let!(:other) { user.events.build(event_attrs.except(:user_id)) }
+      subject! { user.events.build(event_attrs.except(:user_id)) }
+
+      it "fails when date ranges overlap" do
+        subject.validate
+        other.validate
+        aggregate_failures do
+          expect(subject.errors[:start_date]).to include(/must be unique within the given date range/)
+          expect(other.errors[:start_date]).to include(/must be unique within the given date range/)
+        end
+      end
+
+      context "when strict scopes" do
+        it "differ it succeeds" do
+          subject.manager = other.manager.next
+          subject.validate
+          other.validate
+          aggregate_failures do
+            expect(subject.errors[:start_date]).to_not include(/must be unique within the given date range/)
+            expect(other.errors[:start_date]).to_not include(/must be unique within the given date range/)
+          end
+        end
+
+        it "differ, and one is nil, it succeeds" do
+          aggregate_failures do
+            subject.manager = nil
+            subject.validate
+            other.validate
+            expect(subject.errors[:start_date]).to_not include(/must be unique within the given date range/)
+            expect(other.errors[:start_date]).to_not include(/must be unique within the given date range/)
+
+            subject.manager = other.manager
+            other.manager = nil
+            subject.validate
+            other.validate
+            expect(subject.errors[:start_date]).to_not include(/must be unique within the given date range/)
+            expect(other.errors[:start_date]).to_not include(/must be unique within the given date range/)
+          end
+        end
+
+        it "are equally nil it fails" do
+          subject.manager = other.manager = nil
+          subject.validate
+          other.validate
+          aggregate_failures do
+            expect(subject.errors[:start_date]).to include(/must be unique within the given date range/)
+            expect(other.errors[:start_date]).to include(/must be unique within the given date range/)
+          end
+        end
+      end
+
+      context "when nullable scopes" do
+        it "differ, but are not nil, it succeeds" do
+          subject.schedule_type = ::Event::SCHEDULE_TYPES.reject { |t| t == other.schedule_type }.sample
+          subject.validate
+          other.validate
+          aggregate_failures do
+            expect(subject.errors[:start_date]).to_not include(/must be unique within the given date range/)
+            expect(other.errors[:start_date]).to_not include(/must be unique within the given date range/)
+          end
+        end
+
+        it "differ and at least one is nil, it fails" do
+          aggregate_failures do
+            subject.schedule_type = nil
+            subject.validate
+            other.validate
+            expect(subject.errors[:start_date]).to include(/must be unique within the given date range/)
+            expect(other.errors[:start_date]).to include(/must be unique within the given date range/)
+
+            subject.schedule_type = other.schedule_type
+            other.schedule_type = nil
+            subject.validate
+            other.validate
+            expect(subject.errors[:start_date]).to include(/must be unique within the given date range/)
+            expect(other.errors[:start_date]).to include(/must be unique within the given date range/)
+
+            subject.schedule_type = other.schedule_type = nil
+            subject.validate
+            other.validate
+            expect(subject.errors[:start_date]).to include(/must be unique within the given date range/)
+            expect(other.errors[:start_date]).to include(/must be unique within the given date range/)
+          end
+        end
+      end
+
+      it "does not add errors if the object is marked for destruction" do
+        subject.mark_for_destruction
+        subject.validate
+        expect(subject.errors[:start_date]).to_not include(/must be unique within the given date range/)
+      end
+    end
+
+    context "with scoped association" do
+      # Set up an meetup (subject) which has the same attributes as another
+      # meetup (other) and the same owner (user).
+      let(:user) { FactoryBot.build(:user) }
+      let(:meetup_attrs) { FactoryBot.attributes_for(:meetup, :with_end_date) }
+      context do
+        let!(:other) { user.meetups.build(meetup_attrs.except(:user_id)) }
+
+        context "records built on different associations" do
+          subject! { user.current_meetups.build(meetup_attrs.except(:user_id)) }
+
+          it "fails for both siblings" do
+            subject.validate
+            other.validate
+            aggregate_failures do
+              expect(subject.errors[:start_date]).to include(/must be unique within the given date range/)
+              expect(other.errors[:start_date]).to include(/must be unique within the given date range/)
+            end
+          end
+        end
+
+        context "records built on the base association" do
+          subject! { user.meetups.build(meetup_attrs.except(:user_id)) }
+
+          it "fails for both siblings" do
+            subject.validate
+            other.validate
+            aggregate_failures do
+              expect(subject.errors[:start_date]).to include(/must be unique within the given date range/)
+              expect(other.errors[:start_date]).to include(/must be unique within the given date range/)
+            end
+          end
+        end
+      end
+
+      context "records built on the scoped association" do
+        let!(:other) { user.current_meetups.build(meetup_attrs.except(:user_id)) }
+        subject! { user.current_meetups.build(meetup_attrs.except(:user_id)) }
+
+        it "fails for both siblings" do
+          subject.validate
+          other.validate
+          aggregate_failures do
+            expect(subject.errors[:start_date]).to include(/must be unique within the given date range/)
+            expect(other.errors[:start_date]).to include(/must be unique within the given date range/)
+          end
+        end
+      end
+    end
+
+    it "the default siblings proc does not throw an exception if owner is nil" do
+      subject = FactoryBot.build(:schedule, user: nil)
+      expect{ subject.validate }.to_not raise_error
+    end
+  end
+
+  before(:each) do
+    Schedule.all.delete_all
+  end
+
+  describe "generated scope" do
+    let!(:schedule_user) { FactoryBot.create(:user) }
+    let!(:schedule_a) { FactoryBot.build(:schedule, user: schedule_user, start_date: "2015-01-01", end_date: "2015-11-19").tap { |s| s.save!(validate: false) } }
+    let!(:schedule_b) { FactoryBot.build(:schedule, user: schedule_user, start_date: "2015-10-15", end_date: "2015-11-21").tap { |s| s.save!(validate: false) } }
+    let!(:schedule_c) { FactoryBot.build(:schedule, user: schedule_user, start_date: "2015-11-16", end_date: nil).tap { |s| s.save!(validate: false) } }
+
+    it do
+      aggregate_failures do
+        Timecop.freeze("2015-11-19") do
+          expect(Schedule.current).to contain_exactly(schedule_a, schedule_b, schedule_c)
+        end
+        expect(Schedule.current("2014-11-19")).to be_empty
+        expect(Schedule.current("2015-01-01")).to contain_exactly(schedule_a)
+        expect(Schedule.current("2015-11-08")).to contain_exactly(schedule_a, schedule_b)
+        expect(Schedule.current("2015-11-17")).to contain_exactly(schedule_a, schedule_b, schedule_c)
+        expect(Schedule.current("2015-11-21")).to contain_exactly(schedule_b, schedule_c)
+        expect(Schedule.current("2015-12-09")).to contain_exactly(schedule_c)
+      end
+    end
+
+    it "is named using the +:as+ option" do
+      aggregate_failures do
+        Timecop.freeze("2015-11-19") do
+          expect(Schedule.current_for_epoch).to contain_exactly(schedule_a, schedule_b, schedule_c)
+        end
+        expect(Schedule.current_for_epoch("2014-11-19")).to be_empty
+        expect(Schedule.current_for_epoch("2015-01-01")).to contain_exactly(schedule_a)
+        expect(Schedule.current_for_epoch("2015-11-08")).to contain_exactly(schedule_a, schedule_b)
+        expect(Schedule.current_for_epoch("2015-11-17")).to contain_exactly(schedule_a, schedule_b, schedule_c)
+        expect(Schedule.current_for_epoch("2015-11-21")).to contain_exactly(schedule_b, schedule_c)
+        expect(Schedule.current_for_epoch("2015-12-09")).to contain_exactly(schedule_c)
+      end
+    end
+
+    it "is named using the +:scope_name+ option" do
+      aggregate_failures do
+        Timecop.freeze("2015-11-19") do
+          expect(Schedule.range_in).to contain_exactly(schedule_a, schedule_b, schedule_c)
+        end
+        expect(Schedule.range_in("2014-11-19")).to be_empty
+        expect(Schedule.range_in("2015-01-01")).to contain_exactly(schedule_a)
+        expect(Schedule.range_in("2015-11-08")).to contain_exactly(schedule_a, schedule_b)
+        expect(Schedule.range_in("2015-11-17")).to contain_exactly(schedule_a, schedule_b, schedule_c)
+        expect(Schedule.range_in("2015-11-21")).to contain_exactly(schedule_b, schedule_c)
+        expect(Schedule.range_in("2015-12-09")).to contain_exactly(schedule_c)
+      end
+    end
+  end
+
+  describe "normalization" do
+    it "sets start_date to current date when nil" do
+      subject = FactoryBot.build(:meetup, start_date: nil)
+      aggregate_failures do
+        expect(subject.start_date).to be_nil
+        Timecop.freeze do
+          subject.validate  # Runs before-validation normalizations
+          expect(subject.start_date).to eq(Date.current)
+        end
+      end
+    end
+
+    it "does not overwrite a set value for current_date" do
+      date = Date.new(2001, 11, 19)
+      subject = FactoryBot.build(:meetup, start_date: date)
+      aggregate_failures do
+        expect(subject.start_date).to eq(date)
+        subject.validate  # Runs before-validation normalizations
+        expect(subject.start_date).to eq(date)
+      end
+    end
+  end
+end