acts_as_span 0.0.5 → 0.0.6

data/spec/lib/no_overlap_validator_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+require 'has_siblings'
+
+RSpec.describe ActsAsSpan::NoOverlapValidator do
+  let!(:brother) do
+    child_class.create(
+      start_date: brother_start_date,
+      end_date: brother_end_date,
+      mama: mama)
+  end
+
+  let!(:sister) do
+    child_class.create(
+      start_date: sister_start_date,
+      end_date: sister_end_date,
+      mama: mama)
+  end
+
+  let!(:brother_from_another_mother) do
+    child_class.create(
+      start_date: new_child_start_date,
+      end_date: new_child_end_date,
+      mama: other_mama)
+  end
+
+  let(:new_child) do
+    child_class.new(
+      start_date: new_child_start_date,
+      end_date: new_child_end_date,
+      mama: mama)
+  end
+
+  let(:mama) { Mama.create }
+  let(:other_mama) { Mama.create }
+  let(:papa) { Papa.create }
+
+  let(:brother_start_date) { Date.current - 2 }
+  let(:brother_end_date) { Date.current - 1  }
+
+  let(:sister_start_date) { Date.current + 2 }
+  let(:sister_end_date) { Date.current + 3 }
+
+  let(:all_siblings) { [brother, sister, brother_from_another_mother] }
+
+  describe 'an object with a single parent' do
+    let(:child_class) { OneParentChild }
+
+    context 'valid cases' do
+      let(:new_child_start_date) { Date.current }
+      let(:new_child_end_date) { Date.current + 1 }
+
+      it 'allows overlapping spans on for associated records with different parents' do
+        expect(new_child).to be_valid
+      end
+    end
+
+    context 'invalid cases' do
+      let(:new_child_start_date) { Date.current - 2 }
+      let(:new_child_end_date) { Date.current + 3 }
+
+      it 'does not allow overlapping spans siblings with same parents' do
+        expect(new_child).not_to be_valid
+      end
+    end
+  end
+
+  describe 'an object with multiple parents' do
+    let(:child_class) { TwoParentChild }
+
+    before do
+      all_siblings.each do |sibling|
+        sibling.update_attributes(papa: papa)
+      end
+
+      new_child.papa = papa
+    end
+
+    context 'valid cases' do
+      let(:new_child_start_date) { brother_end_date + 1 }
+      let(:new_child_end_date) { sister_start_date - 1 }
+
+      it 'allows overlapping spans on for associated records with different parents' do
+        expect(new_child).to be_valid
+      end
+    end
+
+    context 'invalid cases' do
+      let(:new_child_start_date) { brother_start_date }
+      let(:new_child_end_date) { sister_end_date }
+
+      it 'does not allow overlapping spans siblings with same parents' do
+        expect(new_child).not_to be_valid
+      end
+    end
+  end
+end

data/spec/lib/span_instance/named_scopes_on_spec.rb

@@ -1,304 +1,304 @@
 require 'spec_helper'
 
-describe "a basic model using acts_as_span" do
-  before(:all) do 
-    build_model :span_model do
-      string   :description
-      date     :start_date
-      date     :end_date
-      
-      acts_as_span
-    end
-    
-    @query_date = Date.today + 1.month
-  end
-  
+RSpec.describe "a basic model using acts_as_span" do
   context "named_scopes and current_on?, expired_on?, and future_on?" do
     #    -2  -1   Q  +1  +2      C F E
     # A   |---|                      E
-    # B   |-------|              C    
-    # C   |--------------|       C    
-    # D           |              C    
-    # E           |------|       C    
-    # F               |--|         F  
-    # G   |->                    C    
-    # H           |->            C    
-    # I               |->          F  
+    # B   |-------|              C
+    # C   |--------------|       C
+    # D           |              C
+    # E           |------|       C
+    # F               |--|         F
+    # G   |->                    C
+    # H           |->            C
+    # I               |->          F
     # J     <-|                      E
-    # K         <-|              C    
-    # L                <-|       C    
-    # M           <->            C    
+    # K         <-|              C
+    # L                <-|       C
+    # M           <->            C
+    let(:span_a) {[ - 2.days, - 1.day  ]}
+    let(:span_b) {[ - 2.days,   0.days ]}
+    let(:span_c) {[ - 2.days,   2.days ]}
+    let(:span_d) {[   0.days,   0.days ]}
+    let(:span_e) {[   0.days,   2.days ]}
+    let(:span_f) {[   1.day,    2.days ]}
+    let(:span_g) {[ - 2.days, nil      ]}
+    let(:span_h) {[   0.days, nil      ]}
+    let(:span_i) {[   1.day,  nil      ]}
+    let(:span_j) {[ nil,      - 1.day  ]}
+    let(:span_k) {[ nil,        0.days ]}
+    let(:span_l) {[ nil,        2.days ]}
+    let(:span_m) {[ nil,      nil      ]}
+
+    let(:query_date) { Date.current + (-24..24).to_a.sample.month }
+
+    let!(:span_model) do
+      current_start_date = start_date.nil? ? nil : query_date + start_date
+      current_end_date = end_date.nil? ? nil : query_date + end_date
+
+      SpanModel.create!(
+        start_date: current_start_date,
+        end_date: current_end_date)
+    end
+
     context "A) start_date < query_date & end_date < query_date" do
-      before(:all) do
-        @span_model = SpanModel.create!(:start_date => @query_date - 2.days, :end_date => @query_date - 1.day)
-      end
-      
+      let(:start_date) { span_a[0] }
+      let(:end_date) { span_a[1] }
+
       it "should NOT be included in #current" do
-        SpanModel.current_on(@query_date).should_not include(@span_model)
-        @span_model.current_on?(@query_date).should be_false
+        expect(SpanModel.current_on(query_date)).not_to include(span_model)
+        expect(span_model.current_on?(query_date)).to be_falsey
       end
-      
+
       it "should NOT be included in #future" do
-        SpanModel.future_on(@query_date).should_not include(@span_model)
-        @span_model.future_on?(@query_date).should be_false
+        expect(SpanModel.future_on(query_date)).not_to include(span_model)
+        expect(span_model.future_on?(query_date)).to be_falsey
       end
-      
+
       it "should be included in #expired" do
-        SpanModel.expired_on(@query_date).should include(@span_model)
-        @span_model.expired_on?(@query_date).should be_true
+        expect(SpanModel.expired_on(query_date)).to include(span_model)
+        expect(span_model.expired_on?(query_date)).to be_truthy
       end
     end
-    
+
     context "B) start_date < query_date & end_date == query_date" do
-      before(:all) do
-        @span_model = SpanModel.create!(:start_date => @query_date - 2.day, :end_date => @query_date)
-      end
-      
+      let(:start_date) { span_b[0] }
+      let(:end_date) { span_b[1] }
+
       it "should be included in #current" do
-        SpanModel.current_on(@query_date).should include(@span_model)
-        @span_model.current_on?(@query_date).should be_true
+        expect(SpanModel.current_on(query_date)).to include(span_model)
+        expect(span_model.current_on?(query_date)).to be_truthy
       end
-      
+
       it "should NOT be included in #future" do
-        SpanModel.future_on(@query_date).should_not include(@span_model)
-        @span_model.future_on?(@query_date).should be_false
+        expect(SpanModel.future_on(query_date)).not_to include(span_model)
+        expect(span_model.future_on?(query_date)).to be_falsey
       end
-      
+
       it "should NOT be included in #expired" do
-        SpanModel.expired_on(@query_date).should_not include(@span_model)
-        @span_model.expired_on?(@query_date).should be_false
+        expect(SpanModel.expired_on(query_date)).not_to include(span_model)
+        expect(span_model.expired_on?(query_date)).to be_falsey
       end
     end
-    
+
     context "C) start_date < query_date & end_date > query_date" do
-      before(:all) do
-        @span_model = SpanModel.create!(:start_date => @query_date - 2.day, :end_date => @query_date + 2.day)
-      end
-      
+      let(:start_date) { span_c[0] }
+      let(:end_date) { span_c[1] }
+
       it "should be included in #current" do
-        SpanModel.current_on(@query_date).should include(@span_model)
-        @span_model.current_on?(@query_date).should be_true
+        expect(SpanModel.current_on(query_date)).to include(span_model)
+        expect(span_model.current_on?(query_date)).to be_truthy
       end
-      
+
       it "should NOT be included in #future" do
-        SpanModel.future_on(@query_date).should_not include(@span_model)
-        @span_model.future_on?(@query_date).should be_false
+        expect(SpanModel.future_on(query_date)).not_to include(span_model)
+        expect(span_model.future_on?(query_date)).to be_falsey
       end
-      
+
       it "should NOT be included in #expired" do
-        SpanModel.expired_on(@query_date).should_not include(@span_model)
-        @span_model.expired_on?(@query_date).should be_false
+        expect(SpanModel.expired_on(query_date)).not_to include(span_model)
+        expect(span_model.expired_on?(query_date)).to be_falsey
       end
     end
-    
+
     context "D) start_date == query_date & end_date == query_date" do
-      before(:all) do
-        @span_model = SpanModel.create!(:start_date => @query_date, :end_date => @query_date)
-      end
-      
+      let(:start_date) { span_d[0] }
+      let(:end_date) { span_d[1] }
+
       it "should be included in #current" do
-        SpanModel.current_on(@query_date).should include(@span_model)
-        @span_model.current_on?(@query_date).should be_true
+        expect(SpanModel.current_on(query_date)).to include(span_model)
+        expect(span_model.current_on?(query_date)).to be_truthy
       end
-      
+
       it "should NOT be included in #future" do
-        SpanModel.future_on(@query_date).should_not include(@span_model)
-        @span_model.future_on?(@query_date).should be_false
+        expect(SpanModel.future_on(query_date)).not_to include(span_model)
+        expect(span_model.future_on?(query_date)).to be_falsey
       end
-      
+
       it "should NOT be included in #expired" do
-        SpanModel.expired_on(@query_date).should_not include(@span_model)
-        @span_model.expired_on?(@query_date).should be_false
+        expect(SpanModel.expired_on(query_date)).not_to include(span_model)
+        expect(span_model.expired_on?(query_date)).to be_falsey
       end
     end
-    
+
     context "E) start_date == query_date & end_date > query_date" do
-      before(:all) do
-        @span_model = SpanModel.create!(:start_date => @query_date, :end_date => @query_date + 2.day)
-      end
-      
+      let(:start_date) { span_e[0] }
+      let(:end_date) { span_e[1] }
+
       it "should be included in #current" do
-        SpanModel.current_on(@query_date).should include(@span_model)
-        @span_model.current_on?(@query_date).should be_true
+        expect(SpanModel.current_on(query_date)).to include(span_model)
+        expect(span_model.current_on?(query_date)).to be_truthy
       end
-      
+
       it "should NOT be included in #future" do
-        SpanModel.future_on(@query_date).should_not include(@span_model)
-        @span_model.future_on?(@query_date).should be_false
+        expect(SpanModel.future_on(query_date)).not_to include(span_model)
+        expect(span_model.future_on?(query_date)).to be_falsey
       end
-      
+
       it "should NOT be included in #expired" do
-        SpanModel.expired_on(@query_date).should_not include(@span_model)
-        @span_model.expired_on?(@query_date).should be_false
+        expect(SpanModel.expired_on(query_date)).not_to include(span_model)
+        expect(span_model.expired_on?(query_date)).to be_falsey
       end
     end
-    
+
     context "F) start_date > query_date & end_date > query_date" do
-      before(:all) do
-        @span_model = SpanModel.create!(:start_date => @query_date + 1.day, :end_date => @query_date + 2.days)
-      end
-      
+      let(:start_date) { span_f[0] }
+      let(:end_date) { span_f[1] }
+
       it "should NOT be included in #current" do
-        SpanModel.current_on(@query_date).should_not include(@span_model)
-        @span_model.current_on?(@query_date).should be_false
+        expect(SpanModel.current_on(query_date)).not_to include(span_model)
+        expect(span_model.current_on?(query_date)).to be_falsey
       end
-      
+
       it "should be included in #future" do
-        SpanModel.future_on(@query_date).should include(@span_model)
-        @span_model.future_on?(@query_date).should be_true
+        expect(SpanModel.future_on(query_date)).to include(span_model)
+        expect(span_model.future_on?(query_date)).to be_truthy
       end
-      
+
       it "should NOT be included in #expired" do
-        SpanModel.expired_on(@query_date).should_not include(@span_model)
-        @span_model.expired_on?(@query_date).should be_false
+        expect(SpanModel.expired_on(query_date)).not_to include(span_model)
+        expect(span_model.expired_on?(query_date)).to be_falsey
       end
     end
-    
+
     context "G) start_date < query_date & end_date == nil" do
-      before(:all) do
-        @span_model = SpanModel.create!(:start_date => @query_date - 2.day, :end_date => nil)
-      end
-      
+      let(:start_date) { span_g[0] }
+      let(:end_date) { span_g[1] }
+
       it "should be included in #current" do
-        SpanModel.current_on(@query_date).should include(@span_model)
-        @span_model.current_on?(@query_date).should be_true
+        expect(SpanModel.current_on(query_date)).to include(span_model)
+        expect(span_model.current_on?(query_date)).to be_truthy
       end
-      
+
       it "should NOT be included in #future" do
-        SpanModel.future_on(@query_date).should_not include(@span_model)
-        @span_model.future_on?(@query_date).should be_false
+        expect(SpanModel.future_on(query_date)).not_to include(span_model)
+        expect(span_model.future_on?(query_date)).to be_falsey
       end
-      
+
       it "should NOT be included in #expired" do
-        SpanModel.expired_on(@query_date).should_not include(@span_model)
-        @span_model.expired_on?(@query_date).should be_false
+        expect(SpanModel.expired_on(query_date)).not_to include(span_model)
+        expect(span_model.expired_on?(query_date)).to be_falsey
       end
     end
-    
+
     context "H) start_date == query_date & end_date == nil" do
-      before(:all) do
-        @span_model = SpanModel.create!(:start_date => @query_date, :end_date => nil)   
-      end
-      
+      let(:start_date) { span_h[0] }
+      let(:end_date) { span_h[1] }
+
       it "should be included in #current" do
-        SpanModel.current_on(@query_date).should include(@span_model)
-        @span_model.current_on?(@query_date).should be_true
+        expect(SpanModel.current_on(query_date)).to include(span_model)
+        expect(span_model.current_on?(query_date)).to be_truthy
       end
-      
+
       it "should NOT be included in #future" do
-        SpanModel.future_on(@query_date).should_not include(@span_model)
-        @span_model.future_on?(@query_date).should be_false
+        expect(SpanModel.future_on(query_date)).not_to include(span_model)
+        expect(span_model.future_on?(query_date)).to be_falsey
       end
-      
+
       it "should NOT be included in #expired" do
-        SpanModel.expired_on(@query_date).should_not include(@span_model)
-        @span_model.expired_on?(@query_date).should be_false
+        expect(SpanModel.expired_on(query_date)).not_to include(span_model)
+        expect(span_model.expired_on?(query_date)).to be_falsey
       end
     end
-    
+
     context "I) start_date > query_date & end_date == nil" do
-      before(:all) do
-        @span_model = SpanModel.create!(:start_date => @query_date + 1.day, :end_date => nil)
-      end
-      
+      let(:start_date) { span_i[0] }
+      let(:end_date) { span_i[1] }
+
       it "should NOT be included in #current" do
-        SpanModel.current_on(@query_date).should_not include(@span_model)
-        @span_model.current_on?(@query_date).should be_false
+        expect(SpanModel.current_on(query_date)).not_to include(span_model)
+        expect(span_model.current_on?(query_date)).to be_falsey
       end
-      
+
       it "should be included in #future" do
-        SpanModel.future_on(@query_date).should include(@span_model)
-        @span_model.future_on?(@query_date).should be_true
+        expect(SpanModel.future_on(query_date)).to include(span_model)
+        expect(span_model.future_on?(query_date)).to be_truthy
       end
-      
+
       it "should NOT be included in #expired" do
-        SpanModel.expired_on(@query_date).should_not include(@span_model)
-        @span_model.expired_on?(@query_date).should be_false
+        expect(SpanModel.expired_on(query_date)).not_to include(span_model)
+        expect(span_model.expired_on?(query_date)).to be_falsey
       end
     end
-    
+
     context "J) start_date == nil & end_date < query_date" do
-      before(:all) do
-        @span_model = SpanModel.create!(:start_date => nil, :end_date => @query_date - 1.day)
-      end
-      
+      let(:start_date) { span_j[0] }
+      let(:end_date) { span_j[1] }
+
       it "should NOT be included in #current" do
-        SpanModel.current_on(@query_date).should_not include(@span_model)
-        @span_model.current_on?(@query_date).should be_false
+        expect(SpanModel.current_on(query_date)).not_to include(span_model)
+        expect(span_model.current_on?(query_date)).to be_falsey
       end
-      
+
       it "should NOT be included in #future" do
-        SpanModel.future_on(@query_date).should_not include(@span_model)
-        @span_model.future_on?(@query_date).should be_false
+        expect(SpanModel.future_on(query_date)).not_to include(span_model)
+        expect(span_model.future_on?(query_date)).to be_falsey
       end
-      
+
       it "should be included in #expired" do
-        SpanModel.expired_on(@query_date).should include(@span_model)
-        @span_model.expired_on?(@query_date).should be_true
+        expect(SpanModel.expired_on(query_date)).to include(span_model)
+        expect(span_model.expired_on?(query_date)).to be_truthy
       end
     end
-    
+
     context "K) start_date == nil & end_date == query_date" do
-      before(:all) do
-        @span_model = SpanModel.create!(:start_date => nil, :end_date => @query_date)
-      end
-      
+      let(:start_date) { span_k[0] }
+      let(:end_date) { span_k[1] }
+
       it "should be included in #current" do
-        SpanModel.current_on(@query_date).should include(@span_model)
-        @span_model.current_on?(@query_date).should be_true
+        expect(SpanModel.current_on(query_date)).to include(span_model)
+        expect(span_model.current_on?(query_date)).to be_truthy
       end
-      
+
       it "should NOT be included in #future" do
-        SpanModel.future_on(@query_date).should_not include(@span_model)
-        @span_model.future_on?(@query_date).should be_false
+        expect(SpanModel.future_on(query_date)).not_to include(span_model)
+        expect(span_model.future_on?(query_date)).to be_falsey
       end
-      
+
       it "should NOT be included in #expired" do
-        SpanModel.expired_on(@query_date).should_not include(@span_model)
-        @span_model.expired_on?(@query_date).should be_false
+        expect(SpanModel.expired_on(query_date)).not_to include(span_model)
+        expect(span_model.expired_on?(query_date)).to be_falsey
       end
     end
-    
+
     context "L) start_date == nil & end_date > query_date" do
-      before(:all) do
-        @span_model = SpanModel.create!(:start_date => nil, :end_date => @query_date + 2.day)
-      end
-      
+      let(:start_date) { span_l[0] }
+      let(:end_date) { span_l[1] }
+
       it "should be included in #current" do
-        SpanModel.current_on(@query_date).should include(@span_model)
-        @span_model.current_on?(@query_date).should be_true
+        expect(SpanModel.current_on(query_date)).to include(span_model)
+        expect(span_model.current_on?(query_date)).to be_truthy
       end
-      
+
       it "should NOT be included in #future" do
-        SpanModel.future_on(@query_date).should_not include(@span_model)
-        @span_model.future_on?(@query_date).should be_false
+        expect(SpanModel.future_on(query_date)).not_to include(span_model)
+        expect(span_model.future_on?(query_date)).to be_falsey
       end
-      
+
       it "should NOT be included in #expired" do
-        SpanModel.expired_on(@query_date).should_not include(@span_model)
-        @span_model.expired_on?(@query_date).should be_false
+        expect(SpanModel.expired_on(query_date)).not_to include(span_model)
+        expect(span_model.expired_on?(query_date)).to be_falsey
       end
     end
-    
+
     context "M) start_date == nil & end_date == nil" do
-      before(:all) do
-        @span_model = SpanModel.create!(:start_date => nil, :end_date => nil)
-      end
-      
+      let(:start_date) { span_m[0] }
+      let(:end_date) { span_m[1] }
+
       it "should be included in #current" do
-        SpanModel.current_on(@query_date).should include(@span_model)
-        @span_model.current_on?(@query_date).should be_true
+        expect(SpanModel.current_on(query_date)).to include(span_model)
+        expect(span_model.current_on?(query_date)).to be_truthy
       end
-      
+
       it "should NOT be included in #future" do
-        SpanModel.future_on(@query_date).should_not include(@span_model)
-        @span_model.future_on?(@query_date).should be_false
+        expect(SpanModel.future_on(query_date)).not_to include(span_model)
+        expect(span_model.future_on?(query_date)).to be_falsey
       end
-      
+
       it "should NOT be included in #expired" do
-        SpanModel.expired_on(@query_date).should_not include(@span_model)
-        @span_model.expired_on?(@query_date).should be_false
+        expect(SpanModel.expired_on(query_date)).not_to include(span_model)
+        expect(span_model.expired_on?(query_date)).to be_falsey
       end
     end
   end
-end
+end