has_helpers 5.0.2

data/spec/lib/has_helpers/constant_spec.rb

@@ -0,0 +1,432 @@
+require "rails_helper"
+
+describe ::HasHelpers::Constant do
+  describe ".define_constants" do
+    let(:constants) { ["Joe", "Bob", "Mary", "Boys".to_constant {}] }
+    subject { __constants__ = constants; Class.new { include ::HasHelpers::Constant; define_constants *__constants__ } }
+
+    it { expect(subject.send(:__constants__).values.all? { |d| d.class == ::HasHelpers::Constant::Definition }).to be_truthy }
+    it { expect(subject.constant_names).to contain_exactly(*%w[Joe Bob Mary]) }  # Excludes lazy (group) constants, in this case "Boys"
+    it { expect(CatEgory.send(:__constants__)[:SIAMESE].attrs(force_eval: true).except("cat_type")).to eq({:name => "Siamese", :likelihood_that_it_eats_me => CatEgory::MODERATE_LIKELIHOOD}) }
+
+    context "with prefix" do
+      subject {
+        __constants__ = constants
+        Class.new do
+          include ::HasHelpers::Constant
+          define_constants *__constants__, key_prefix: "PERSON"
+        end
+      }
+
+      it { expect(subject.constant_names).to contain_exactly(*%w[Joe Bob Mary]) }
+    end
+
+    context "include group_id null constants" do
+      subject {
+        __constants__ = constants
+        Class.new do
+          include ::HasHelpers::Constant
+          define_constants *__constants__
+        end
+      }
+
+      it { expect(subject.constant_names).to contain_exactly(*%w[Joe Bob Mary]) }
+    end
+
+    context "exclude group_id null constants" do
+      it { expect(ExcludeGroupNilConstant.all).to contain_exactly(*%w[]) }
+      it { expect(ExcludeGroupNilConstant.constant_names).to contain_exactly(*%w[One Two Three]) }
+    end
+
+    context do
+      let!(:both) { Color.where(:name => "Cyan").first_or_create! }
+
+      before do
+        Object.const_set(:CYAN, "shouldn't access me")
+        Color.define_constant "Cyan"
+      end
+
+      after do
+        Color.send(:__constants__).delete(:CYAN)  # Clean up, so this does not affect other specs
+      end
+
+      it "avoids constant lookup in ancestors" do
+        # Initial lookup
+        subject = Color::CYAN
+        expect(subject.is_a?(Color)).to be true
+        expect(subject.class).to eq(Color)
+        expect(subject).to eq(both)
+
+        # Subsequent lookups
+        expect(subject).to eq(Color::CYAN)
+        expect(subject.object_id).to eq(Color::CYAN.object_id)
+      end
+    end
+  end
+
+  context do
+    before do
+      ::Color.seed!
+    end
+
+    # Set up constant database records
+    let!(:blue) { ::Color.where(name: 'Blue').first_or_create! }
+    let!(:goldenrod) { ::Color.where(name: 'Goldenrod').first_or_create! }
+    let!(:indigo) { ::Color.where(name: 'Indigo').first_or_create! }
+    let!(:lemon) { ::Color.where(name: 'Lemon').first_or_create! }
+    let!(:purple) { ::Color.where(name: 'Red Blue').first_or_create! }
+    let!(:red) { ::Color.where(name: 'Red').first_or_create! }
+    let!(:teal) { ::Color.where(name: 'Teal').first_or_create! }
+    let!(:yellow) { ::Color.where(name: 'Yellow').first_or_create!}
+    let!(:green) { ::Color.where(name: 'Green').first_or_create!}
+    let!(:grey) { ::Color.where(name: 'Grey').first_or_create!}
+
+    it "looks up constant records" do
+      expect(::Color::BLUE).to eq(blue)
+      expect(::Color::GOLDENROD).to eq(goldenrod)
+      expect(::Color::INDIGO).to eq(indigo)
+      expect(::Color::LEMON).to eq(lemon)
+      expect(::Color::RED).to eq(red)
+      expect(::Color::PURPLE).to eq(purple)
+      expect(::Color::TEAL).to eq(teal)
+      expect(::Color::YELLOW).to eq(yellow)
+    end
+
+    it "set the constant" do
+      Color.send(:remove_const, :RED) if Color.const_defined?(:RED)  # Ensure that ::RED is not set
+      expect(Color.const_defined?(:RED)).to be_falsey
+      Color::RED  # Should load the constant
+      expect(Color.const_defined?(:RED)).to be_truthy
+    end
+
+    context "errors" do  # Wrap errors in their own context to prevent them from messing up other specs.
+      it "uses the key attribute when present" do
+        expect(Color::PURPLE).to eq(purple)
+        expect { Color::RED_BLUE }.to raise_error(NameError, /uninitialized constant/)
+      end
+
+      it "raises an error when the constant record is not defined" do
+        expect{ Color::FUSCHIA }.to raise_error(NameError, /uninitialized constant/)
+      end
+    end
+
+    context "all" do
+      it "returns all non-group constants" do
+        expect(Color::ALL).to contain_exactly(blue, goldenrod, indigo, lemon, purple, red, teal, yellow, green, grey)
+      end
+
+      it "set the ::ALL constant" do
+        Color.send(:remove_const, :ALL) if Color.const_defined?(:ALL)  # Ensure that ::ALL is not set
+        expect(Color.const_defined?(:ALL)).to be_falsey
+        Color::ALL  # Should load the constant
+        expect(Color.const_defined?(:ALL)).to be_truthy
+      end
+
+      it "should raise if it is an abstract constant class" do
+        expect{Option::ALL}.to raise_error(NameError)
+      end
+
+      it "uses the same objects individually as it" do
+        Color.send(:remove_const, :ALL) if Color.const_defined?(:ALL)  # Ensure that ::ALL is not set
+        Color.send(:remove_const, :RED) if Color.const_defined?(:RED)  # Ensure that ::RED is not set
+        red_from_all = Color::ALL.detect { |g| g.name == "Red" }
+        red_individual = Color::RED
+        expect(red_from_all.object_id).to eq(red_individual.object_id)
+      end
+    end
+  end
+
+  context "scoped constants" do
+    before(:each) do
+      CatEgory.seed!
+    end
+
+    # Set up constant database records
+    let(:persian) { CatEgory.find_by(:name => "Persian", :likelihood_that_it_eats_me => CatEgory::LOW_LIKELIHOOD) }
+    let(:siamese) { CatEgory.find_by(:name => "Siamese", :likelihood_that_it_eats_me => CatEgory::MODERATE_LIKELIHOOD) }
+    let(:cougar) { CatEgory.find_by(:name => "Cougar", :likelihood_that_it_eats_me => CatEgory::MODERATE_LIKELIHOOD) }
+    let(:puma) { CatEgory.find_by(:name => "Puma", :likelihood_that_it_eats_me => CatEgory::HIGH_LIKELIHOOD) }
+    let(:tiger) { CatEgory.find_by(:name => "Tiger", :likelihood_that_it_eats_me => CatEgory::HIGH_LIKELIHOOD) }
+    let(:bengal) { CatEgory.find_by(:name => "Bengal", :likelihood_that_it_eats_me => CatEgory::HIGH_LIKELIHOOD) }
+    let(:big_cat) { CatEgory.find_by(name: "Big Cat") }
+    let(:small_cat) { CatEgory.find_by(name: "Small Cat") }
+
+    it "looks up constant records" do
+      expect(CatEgory::PERSIAN).to eq(persian)
+      expect(CatEgory::PERSIAN.likelihood_that_it_eats_me).to eq(CatEgory::LOW_LIKELIHOOD)
+      expect(CatEgory::SIAMESE).to eq(siamese)
+      expect(CatEgory::SIAMESE.likelihood_that_it_eats_me).to eq(CatEgory::MODERATE_LIKELIHOOD)
+      expect(CatEgory::COUGAR).to eq(cougar)
+      expect(CatEgory::COUGAR.likelihood_that_it_eats_me).to eq(CatEgory::MODERATE_LIKELIHOOD)
+      expect(CatEgory::POOOOOMA).to eq(puma)
+      expect(CatEgory::POOOOOMA.likelihood_that_it_eats_me).to eq(CatEgory::HIGH_LIKELIHOOD)
+      expect(CatEgory::TIGER).to eq(tiger)
+      expect(CatEgory::TIGER.likelihood_that_it_eats_me).to eq(CatEgory::HIGH_LIKELIHOOD)
+      expect(CatEgory::BIG_CAT).to eq(big_cat)
+      expect(CatEgory::BIG_CAT.likelihood_that_it_eats_me).to eq(CatEgory::HIGH_LIKELIHOOD)
+      expect(CatEgory::SMALL_CAT).to eq(small_cat)
+      expect(CatEgory::SMALL_CAT.likelihood_that_it_eats_me).to eq(CatEgory::MODERATE_LIKELIHOOD)
+    end
+
+    it { expect { CatEgory::PUMA }.to raise_error(NameError, /uninitialized constant/) }
+
+    context "all" do
+      it "returns all non-group constants" do
+        expect(CatEgory::ALL).to contain_exactly(persian, siamese, cougar, puma, tiger, big_cat, small_cat, bengal)
+      end
+    end
+
+    it "raises an error when the scope does not match the name" do
+      # Update Tiger record so that it does _not_ match the constant definition (mismatched values for likelihood)
+      bengal.reload.update_attribute :likelihood_that_it_eats_me, CatEgory::LOW_LIKELIHOOD
+      CatEgory.send :remove_const, :BENGAL if CatEgory.const_defined?(:BENGAL) # Clear out any previous definition from other specs.
+      expect { CatEgory::BENGAL }.to raise_error(NameError, /the constant CatEgory::BENGAL does not exist/)
+    end
+
+    it "raises an error when the constant record is not defined" do
+      expect { CatEgory::LION }.to raise_error(NameError, /uninitialized constant/)
+    end
+  end
+
+  context "simple constants" do
+    before(:each) do
+      SimpleOption.seed!
+    end
+
+    it do
+      aggregate_failures do
+        expect(SimpleOption::SIMPLE_TWO.is_parent?).to be true
+        expect(SimpleOption::SIMPLE_THREE.is_parent?).to be false
+        expect(SimpleOption::SIMPLE_FOUR.is_parent?).to be true
+        expect(SimpleOption::SIMPLE_FIVE.is_parent?).to be false
+
+        expect(SimpleOption::SIMPLE_TWO.group_children).to contain_exactly(::SimpleOption::SIMPLE_TWO, ::SimpleOption::SIMPLE_THREE)
+        expect(SimpleOption::SIMPLE_THREE.group_parent).to eq SimpleOption::SIMPLE_TWO
+        expect(SimpleOption::SIMPLE_FOUR.group_children).to contain_exactly(::SimpleOption::SIMPLE_FIVE)
+        expect(SimpleOption::SIMPLE_FOUR.group_parent).to eq SimpleOption::SIMPLE_FOUR
+        expect(SimpleOption::SIMPLE_FIVE.group_parent).to eq SimpleOption::SIMPLE_FOUR
+
+        expect(SimpleOption.is_parent?(SimpleOption::SIMPLE_TWO)).to be true
+        expect(SimpleOption.is_parent?(SimpleOption::SIMPLE_THREE)).to be false
+        expect(SimpleOption.is_parent?(SimpleOption::SIMPLE_FOUR)).to be true
+        expect(SimpleOption.is_parent?(SimpleOption::SIMPLE_FIVE)).to be false
+
+        simple_two = SimpleOption.find_by(name: "Simple Two")
+        simple_three = SimpleOption.find_by(name: "Simple Three")
+        simple_four = SimpleOption.find_by(name: "Simple Four")
+        simple_five = SimpleOption.find_by(name: "Simple Five")
+
+        expect(simple_two.is_parent?).to be true
+        expect(simple_three.is_parent?).to be false
+        expect(simple_four.is_parent?).to be true
+        expect(simple_five.is_parent?).to be false
+
+        expect(simple_two.group_children).to contain_exactly(simple_two, simple_three)
+        expect(simple_three.group_parent).to eq simple_two
+        expect(simple_four.group_children).to contain_exactly(simple_five)
+        expect(simple_five.group_parent).to eq simple_four
+
+        expect(simple_two.group_id).to eq simple_two.id
+        expect(simple_four.group_id).to_not eq simple_four.id
+      end
+    end
+  end
+
+  before(:each) do
+    Product.all.delete_all
+  end
+
+  describe ".seed!" do
+    before :all do
+      Product.define_constant "Hair Gel".to_constant(:code => "EW12")
+      Product.define_constant "Hair Spray".to_constant(:code => "HS01")
+      Product.define_constant "Pomade".to_constant(:code => "DD99")
+    end
+
+    it "seeds each constant" do
+      expect(Product.where(:name => "Hair Gel", :code => "EW12").exists?).to be_falsey
+      expect(Product.where(:name => "Hair Spray", :code => "HS01").exists?).to be_falsey
+      expect(Product.where(:name => "Pomade", :code => "DD99").exists?).to be_falsey
+
+      Product.seed!
+
+      expect(Product.where(:name => "Hair Gel", :code => "EW12").first).to be_a(Product)
+      expect(Product.where(:name => "Hair Spray", :code => "HS01").first).to be_a(Product)
+      expect(Product.where(:name => "Pomade", :code => "DD99").first).to be_a(Product)
+    end
+
+    it "Returns nil" do
+      expect(Product.seed!).to be_nil
+    end
+  end
+
+  describe ".define_constant_group" do
+    before do
+      ::CatEgory.seed!
+      ::Color.seed!
+    end
+
+    let(:big_cat) { ::CatEgory.find_by(name: "Big Cat") }
+    let(:cougar) { ::CatEgory.find_by(name: 'Cougar') }
+    let(:persian) { ::CatEgory.find_by(name: 'Persian') }
+    let(:puma) { ::CatEgory.find_by(name: 'Puma') }
+    let(:siamese) { ::CatEgory.find_by(name: 'Siamese') }
+    let(:small_cat) { ::CatEgory.find_by(name: "Small Cat") }
+    let(:tiger) { ::CatEgory.find_by(name: 'Tiger') }
+
+    it { expect(::Foo.supports_grouping?).to be false }
+    it { expect(::CatEgory.supports_grouping?).to be true }
+    it { expect(::CatEgory::SNUGGLEABLE).to contain_exactly(::CatEgory::PERSIAN, ::CatEgory::SIAMESE) }
+
+    context 'without the parent being persisted' do
+      it "returns grouped records when evaluating the parent constant" do
+        expect(CatEgory::UNLIKELY_TO_EAT_ME).to contain_exactly(persian)
+        expect(CatEgory::MODERATELY_LIKELY_TO_EAT_ME).to contain_exactly(siamese, cougar)
+        expect(CatEgory::LIKELY_TO_EAT_ME).to contain_exactly(puma, tiger)
+      end
+    end
+
+    context 'with the parent being persisted' do
+      it 'should not include the parent twice in the group' do
+        expect(::Color::BLUE_COLORS).to contain_exactly(::Color::BLUE, ::Color::INDIGO, ::Color::TEAL)
+      end
+
+      it 'should return the parent record rather than the group when evaluating the parent constant' do
+        expect(::CatEgory::BIG_CAT).to eq(big_cat)
+        expect(::CatEgory::SMALL_CAT).to eq(small_cat)
+      end
+
+      it 'should return groups when evaluating the group name constant' do
+        expect(::CatEgory::BIG_CAT_GROUP).to contain_exactly(cougar, puma, tiger, big_cat)
+        [big_cat, cougar, puma, tiger].each do |cat|
+          expect(cat.cat_type).to eq(big_cat.id), "cat_type != big_cat.id! (#{cat.cat_type || "nil"} != #{big_cat.id}) Failing constant: #{cat.name}"
+        end
+      end
+
+      it 'should handle assigning a custom group name' do
+        expect { ::CatEgory::SMALL_CAT_GROUP }.to raise_error(NameError, /uninitialized constant/)
+        expect(::CatEgory::SMOL_KITTERS).to contain_exactly(persian, siamese, small_cat)
+        [persian, siamese, small_cat].each do |cat|
+          expect(cat.cat_type).to eq(small_cat.id), "cat_type != small_cat.id! (#{cat.cat_type || "nil"} != #{small_cat.id}) Failing constant: #{cat.name}"
+        end
+      end
+
+      it 'should set a has_many/belongs to association on the model' do
+        expect(::CatEgory.reflect_on_association(:group_parent)).to be_truthy
+        expect(::CatEgory.reflect_on_association(:group_children)).to be_truthy
+        expect(::CatEgory::SMALL_CAT.group_children).to contain_exactly(persian, siamese, small_cat)
+        [persian, siamese, small_cat].each do |cat|
+          expect(cat.group_parent).to eq(small_cat)
+        end
+        expect(::CatEgory::BIG_CAT.group_children).to contain_exactly(cougar, puma, tiger, big_cat)
+        [cougar, puma, tiger, big_cat].each do |cat|
+          expect(cat.group_parent).to eq(big_cat)
+        end
+      end
+
+    end
+  end
+
+  describe ".lookup" do
+    context do
+      before { CatEgory.seed! }
+      it "returns the record matching the specified query" do
+        expect(CatEgory.lookup("Siamese")).to eq(CatEgory::SIAMESE)
+      end
+
+      it "returns nil if no matching record is found" do
+        expect(CatEgory.lookup("Liger")).to be_nil
+      end
+
+      it "returns nil if given name is nil" do
+        expect(CatEgory.lookup(nil)).to be_nil
+      end
+
+      describe "options" do
+        describe "case_sensitive" do
+          it "is disabled by default" do
+            expect(CatEgory.lookup("siamese")).to eq(CatEgory::SIAMESE)
+          end
+
+          it "matches with case-sensitivity" do
+            aggregate_failures do
+              expect(CatEgory.lookup("siamese", case_sensitive: true)).to be_nil
+              expect(CatEgory.lookup("Siamese", case_sensitive: true)).to eq(CatEgory::SIAMESE)
+            end
+          end
+
+          it "matches without case-sensitivity" do
+            aggregate_failures do
+              expect(CatEgory.lookup("siamese", case_sensitive: false)).to eq(CatEgory::SIAMESE)
+              expect(CatEgory.lookup("Siamese", case_sensitive: false)).to eq(CatEgory::SIAMESE)
+            end
+          end
+        end
+      end
+
+      describe "attributes" do
+        before :all do
+          Color.seed!
+          ShirtSize.seed!
+        end
+
+        it "matches with attributes before constant is loaded in memory" do
+          # There is a need to test ShirtSize _before_ constants are loaded into memory,
+          # so we need to "reset" the constant, done by reloading the source file.
+          # There was a bug which caused attributes to not be match correctly until
+          # the matching constant record was loaded. More specifically, lazy attributes
+          # were not being evaluated when compared in the lookup method.
+          load Rails.root.join("app/constants/shirt_size.rb")
+
+          shirt_size = ShirtSize.lookup("M", color_id: Color::RED.id)
+          expect(shirt_size.is_a?(ShirtSize)).to be true  # Check for a failed lookup, which will return nil
+
+          aggregate_failures do
+            expect(shirt_size.name).to eq("M")
+            expect(shirt_size.color_id).to eq(Color::RED.id)
+          end
+        end
+      end
+
+      describe "id" do
+        it "returns the record with the matching id" do
+          expect(CatEgory.lookup(id: CatEgory::SMALL_CAT.id)).to eq(CatEgory::SMALL_CAT)
+        end
+
+        it "supports matching by string" do
+          expect(CatEgory.lookup(id: CatEgory::SMALL_CAT.id.to_s)).to eq(CatEgory::SMALL_CAT)
+        end
+      end
+    end
+
+    context do
+      before do
+        Foo.seed!
+      end
+
+      it "raises an exception if the query matches more than one record" do
+        expect { Foo.lookup("Derp") }.to raise_error.with_message(/Lookup matched more than one record/)
+      end
+
+      context "returns the record matching the specified query, key and/or attributes" do
+        it { expect(Foo.lookup("Derp", key: "DERP")).to eq(Foo::DERP) }
+        it { expect(Foo.lookup("Derp", key: "NERP")).to eq(Foo::NERP) }
+        it { expect(Foo.lookup(key: :NERP)).to eq(Foo::NERP) }
+        it { expect(Foo.lookup(key: :BERP)).to be_nil }
+        it { expect(Foo.lookup(scope: "perry")).to eq(Foo::NERP) }
+        it { expect(Foo.lookup("Derp", scope: "perry")).to eq(Foo::NERP) }
+        it { expect(Foo.lookup("Nerp", scope: "perry")).to be_nil }
+      end
+    end
+  end
+
+  describe "#definition" do
+    before { Color.seed! }
+    it { expect(Color::PURPLE.definition).to be_a(described_class::Definition) }
+  end
+
+  describe "#meta" do
+    before { Color.seed! }
+    it { expect(Color::PURPLE.meta.secondary_color).to be_truthy }
+  end
+end

data/spec/lib/has_helpers/core_ext/array_spec.rb

@@ -0,0 +1,22 @@
+require "rails_helper"
+
+describe ::HasHelpers::CoreExt::Array do
+  describe "#to_constant" do
+    let(:name1) { "Test1" }
+    let(:name2) { "Test2" }
+    let(:names) { [name1, name2] }
+    subject { names.to_constant }
+
+    it { expect(subject.all? { |element| element.class == ::HasHelpers::Constant::Definition }).to be_truthy }
+    it { expect(subject.map(&:name)).to eq(names) }
+
+    context "with options" do
+      let(:type) { "Tupe" }
+      subject { [*names, :type => type].to_constant }
+
+      it { expect(subject.all? { |element| element.class == ::HasHelpers::Constant::Definition }).to be_truthy }
+      it { expect(subject.map(&:name)).to eq(names) }
+      it { expect(subject.all? { |element| element.attrs[:type] == type }).to be_truthy }
+    end
+  end
+end

data/spec/lib/has_helpers/core_ext/date/infinity_spec.rb

@@ -0,0 +1,67 @@
+require "rails_helper"
+
+describe ::HasHelpers::CoreExt::Date::Infinity do
+  context "comparisons with Date instance" do
+    context "on left side" do
+      context "with positive Infinity" do
+        it { expect(Date.current < Date::Infinity.new).to be_truthy }
+        it { expect(Date.current > Date::Infinity.new).to be_falsey }
+        it { expect(Date.current == Date::Infinity.new).to be_falsey }
+        it { expect(Date.current <=> Date::Infinity.new).to eq(-1) }
+      end
+
+      context "with negative Infinity" do
+        it { expect(Date.current < -Date::Infinity.new).to be_falsey }
+        it { expect(Date.current > -Date::Infinity.new).to be_truthy }
+        it { expect(Date.current == -Date::Infinity.new).to be_falsey }
+        it { expect(Date.current <=> -Date::Infinity.new).to eq(1) }
+      end
+    end
+
+    context "on right side" do
+      context "with positive Infinity" do
+        it { expect(Date::Infinity.new < Date.current).to be_falsey }
+        it { expect(Date::Infinity.new > Date.current).to be_truthy }
+        it { expect(Date::Infinity.new == Date.current).to be_falsey }
+        it { expect(Date::Infinity.new <=> Date.current).to eq(1) }
+      end
+
+      context "with negative Infinity" do
+        it { expect(-Date::Infinity.new < Date.current).to be_truthy }
+        it { expect(-Date::Infinity.new > Date.current).to be_falsey }
+        it { expect(-Date::Infinity.new == Date.current).to be_falsey }
+        it { expect(-Date::Infinity.new <=> Date.current).to eq(-1) }
+      end
+    end
+  end
+
+  context "comparisons with Date::Infinity instance" do
+    context "<" do
+      it { expect(Date::Infinity.new < Date::Infinity.new).to be_falsey }
+      it { expect(-Date::Infinity.new < Date::Infinity.new).to be_truthy }
+      it { expect(-Date::Infinity.new < -Date::Infinity.new).to be_falsey }
+      it { expect(Date::Infinity.new < -Date::Infinity.new).to be_falsey }
+    end
+
+    context ">" do
+      it { expect(Date::Infinity.new > Date::Infinity.new).to be_falsey }
+      it { expect(-Date::Infinity.new > Date::Infinity.new).to be_falsey }
+      it { expect(-Date::Infinity.new > -Date::Infinity.new).to be_falsey }
+      it { expect(Date::Infinity.new > -Date::Infinity.new).to be_truthy }
+    end
+
+    context "==" do
+      it { expect(Date::Infinity.new == Date::Infinity.new).to be_truthy }
+      it { expect(-Date::Infinity.new == Date::Infinity.new).to be_falsey }
+      it { expect(-Date::Infinity.new == -Date::Infinity.new).to be_truthy }
+      it { expect(Date::Infinity.new == -Date::Infinity.new).to be_falsey }
+    end
+
+    context "<=>" do
+      it { expect(Date::Infinity.new <=> Date::Infinity.new).to eq(0) }
+      it { expect(-Date::Infinity.new <=> Date::Infinity.new).to eq(-1) }
+      it { expect(-Date::Infinity.new <=> -Date::Infinity.new).to eq(0) }
+      it { expect(Date::Infinity.new <=> -Date::Infinity.new).to eq(1) }
+    end
+  end
+end

data/spec/lib/has_helpers/core_ext/date_spec.rb

@@ -0,0 +1,27 @@
+require "rails_helper"
+
+RSpec.describe ::HasHelpers::CoreExt::Date do
+  describe ".next_business_day" do
+    it "should not include weekends" do
+      # Friday, January 1st, 2016
+      starting_date = Date.civil(2016, 1, 1)
+
+      # Monday, January 4, 2016
+      expect(starting_date.next_business_day).to eq(Date.civil(2016, 1, 4))
+    end
+
+    it "should not include christmas" do
+      # Monday, December 25th, 2017
+      starting_date = Date.civil(2017, 12, 25)
+
+      # Tuesday, December 26th, 2016
+      expect(starting_date.next_business_day).to eq(Date.civil(2017, 12, 26))
+    end
+
+    it "should allow argument for multiple days" do
+      starting_date = Date.civil(2016, 1, 1)
+
+      expect(starting_date.next_business_day(3)).to eq(Date.civil(2016, 1, 6))
+    end
+  end
+end

data/spec/lib/has_helpers/core_ext/false_class_spec.rb

@@ -0,0 +1,7 @@
+require "rails_helper"
+
+RSpec.describe ::HasHelpers::CoreExt::FalseClass do
+  describe "#to_bool" do
+    it { expect(false.to_bool).to be(false) }
+  end
+end

data/spec/lib/has_helpers/core_ext/float_spec.rb

@@ -0,0 +1,9 @@
+require "rails_helper"
+
+RSpec.describe ::HasHelpers::CoreExt::Integer do
+  describe "#to_renderable" do
+    subject { 3.141592 }
+    it { expect(subject.to_renderable).to be_a(::HasHelpers::TextNode) }
+    it { expect(subject.to_renderable.str).to eq(subject.to_s) }
+  end
+end

data/spec/lib/has_helpers/core_ext/hash_spec.rb

@@ -0,0 +1,48 @@
+require "rails_helper"
+
+RSpec.describe ::HasHelpers::CoreExt::Hash do
+  describe "#with_nested_access" do
+    it { expect({}.with_nested_access[:a][:b][:c]).to eq({}) }
+  end
+
+  describe "#camelize_keys!" do
+    it { expect({ first_name: "Brendan"}.camelize_keys!).to eq({firstName: "Brendan"})}
+    it "doesn't change strings to symbols" do
+      expect({ "last_name" => "Carney"}.camelize_keys!).to eq({"lastName" => "Carney"})
+    end
+  end
+
+  describe "#to_icon" do
+    it "returns an icon instance using the current hash as parameters" do
+      hash = { name: :clock, orientation: :upside_down }
+      icon = hash.to_icon
+      aggregate_failures do
+        expect(icon).to be_an(::HasHelpers::Icon)
+        expect(icon.instance_variable_get(:@name)).to eq(:clock)
+        expect(icon.orientation).to eq(:upside_down)
+      end
+    end
+  end
+
+  describe "#to_input" do
+    it "returns an input instance using the current hash as parameters" do
+      expect({ name: :submit, value: :save }.to_input).to be_an(Input)
+    end
+  end
+
+  describe "#to_action" do
+    it "returns an action instance using the current hash as parameters" do
+      expect({ label: "Look here" }.to_action).to be_an(Action)
+    end
+  end
+
+  describe "#to_html_attrs" do
+    it "returns an html_attrs instance using the current hash as parameters" do
+      expect({ class: "btn btn-default" }.to_html_attrs).to be_an(::HasHelpers::UIAttributes::HTMLAttributes::HTMLAttrs)
+    end
+  end
+
+  describe "#to_renderable" do
+    it { expect({}.to_renderable).to be_a(::RenderObject) }
+  end
+end

data/spec/lib/has_helpers/core_ext/integer_spec.rb

@@ -0,0 +1,9 @@
+require "rails_helper"
+
+RSpec.describe ::HasHelpers::CoreExt::Integer do
+  describe "#to_renderable" do
+    subject { 15 }
+    it { expect(subject.to_renderable).to be_a(::HasHelpers::TextNode) }
+    it { expect(subject.to_renderable.str).to eq(subject.to_s) }
+  end
+end

data/spec/lib/has_helpers/core_ext/nil_class_spec.rb

@@ -0,0 +1,17 @@
+require "rails_helper"
+
+RSpec.describe ::HasHelpers::CoreExt::NilClass do
+  describe "#to_bool" do
+    it { expect(nil.to_bool).to be(false) }
+  end
+
+  describe "#to_d" do
+    it { expect(nil.to_d).to eq(BigDecimal(0)) }
+  end
+
+  describe "#to_renderable" do
+    subject { nil }
+    it { expect(subject.to_renderable).to be_a(::HasHelpers::TextNode) }
+    it { expect(subject.to_renderable.str).to eq("NIL") }
+  end
+end