acts_as_span 0.0.5 → 1.2.0

data/spec/lib/acts_as_span_spec.rb

@@ -1,64 +1,67 @@
 require 'spec_helper'
 
-describe "acts_as_span" do
-  before(:each) do
-    build_model :span_model do
-      acts_as_span
-    end
+RSpec.describe "acts_as_span" do
+  it 'raises an ArgumentError when unsupported arguments are passed' do
+    expect do
+      SpannableModel.acts_as_span(
+        start_field: :starting_date,
+        end_field: :ending_date,
+        span_overlap_scope: [:unique_by_date_range]
+      )
+    end.to raise_error(
+      ArgumentError, "Unsupported option(s): 'span_overlap_scope'"
+    )
+  end
+
+  it "doesn't raise an ArgumentError when valid arguments are passed" do
+    expect do
+      SpannableModel.acts_as_span(
+        start_field: :starting_date,
+        end_field: :ending_date
+      )
+    end.not_to raise_error
   end
-  
+
   context "ClassMethods" do
-    it "should return true for acts_as_span?" do
-      SpanModel.acts_as_span?.should be_true
-    end
-    
     it "should have 1 acts_as_span_definition" do
-      SpanModel.should have(1).acts_as_span_definitions
+      expect(SpanModel.acts_as_span_definitions.size).to eq(1)
     end
-    
+
     it "should set default options for acts_as_span_definition" do
       span_definition = SpanModel.acts_as_span_definitions[:default]
-      
-      span_definition.start_date_field.should == :start_date
-      span_definition.end_date_field.should == :end_date
-      span_definition.start_date_field_required.should be_false
-      span_definition.end_date_field_required.should be_false
-      span_definition.exclude_end.should be_false
-      span_definition.span_overlap_scope.should be_nil
-      span_definition.span_overlap_count.should be_nil
-      span_definition.name.should == :default
+
+      expect(span_definition.start_field).to eq(:start_date)
+      expect(span_definition.end_field).to eq(:end_date)
+      expect(span_definition.exclude_end).to be_falsey
+      expect(span_definition.name).to eq(:default)
     end
-    
+
     it "should return a SpanKlass w/ span" do
-      SpanModel.span.should be_instance_of(ActsAsSpan::SpanKlass)
+      expect(SpanModel.span).to be_instance_of(ActsAsSpan::SpanKlass)
     end
 
     it "should return a SpanKlass w/ span_for(:default)" do
-      SpanModel.span_for(:default).should be_instance_of(ActsAsSpan::SpanKlass)
+      expect(SpanModel.span_for(:default)).to be_instance_of(ActsAsSpan::SpanKlass)
     end
-    
+
     it "should have (1) spans" do
-      SpanModel.spans.should have(1).span
+      expect(SpanModel.spans.size).to eq(1)
     end
   end
-  
+
   context "InstanceMethods" do
     let(:span_model) { SpanModel.new }
-    
-    it "should return true for acts_as_span?" do
-      span_model.acts_as_span?.should be_true
-    end
 
     it "should return a SpanInstance w/ span" do
-      span_model.span.should be_instance_of(ActsAsSpan::SpanInstance)
+      expect(span_model.span).to be_instance_of(ActsAsSpan::SpanInstance)
     end
 
     it "should return a SpanInstance w/ span_for(:default)" do
-      span_model.span_for(:default).should be_instance_of(ActsAsSpan::SpanInstance)
+      expect(span_model.span_for(:default)).to be_instance_of(ActsAsSpan::SpanInstance)
     end
-    
+
     it "should have (1) spans" do
-      span_model.spans.should have(1).span
+      expect(span_model.spans.size).to eq(1)
     end
   end
 end

data/spec/lib/delegation_spec.rb

@@ -1,128 +1,95 @@
 require 'spec_helper'
 
-describe "Span" do
-  before(:each) do
-    build_model :span_model do
-      date  :start_date
-      date  :end_date
-      
-      acts_as_span
-    end
-  end
-  
-  let(:span_model) { SpanModel.new(:start_date => Date.today, :end_date => nil) }
+RSpec.describe "Span" do
+  let(:span_model) { SpanModel.new(:start_date => Date.current, :end_date => nil) }
   let(:span_klass) { SpanModel.span }
   let(:span_instance) { span_model.span }
-  
+
   context "ClassMethods" do
     it "should delegate current" do
-      span_klass.should_receive(:current).and_return(true)
-      
+      expect(span_klass).to receive(:current).and_return(true)
+
       SpanModel.current
     end
-    
+
     it "should delegate current_on" do
-      span_klass.should_receive(:current_on).and_return(true)
-      
+      expect(span_klass).to receive(:current_on).and_return(true)
+
       SpanModel.current_on
     end
-    
+
     it "should delegate future" do
-      span_klass.should_receive(:future).and_return(true)
-      
+      expect(span_klass).to receive(:future).and_return(true)
+
       SpanModel.future
     end
-    
+
     it "should delegate future_on" do
-      span_klass.should_receive(:future_on).and_return(true)
-      
+      expect(span_klass).to receive(:future_on).and_return(true)
+
       SpanModel.future_on
     end
-    
+
     it "should delegate expired" do
-      span_klass.should_receive(:expired).and_return(true)
-      
+      expect(span_klass).to receive(:expired).and_return(true)
+
       SpanModel.expired
     end
-    
+
     it "should delegate expired_on" do
-      span_klass.should_receive(:expired_on).and_return(true)
-      
+      expect(span_klass).to receive(:expired_on).and_return(true)
+
       SpanModel.expired_on
     end
   end
-  
+
   context "InstanceMethods" do
-    it "should delegate close!" do
-      span_instance.should_receive(:close!).and_return(true)
-      
-      span_model.close!
-    end
-    
-    it "should delegate close_on!" do
-      span_instance.should_receive(:close_on!).and_return(true)
-      
-      span_model.close_on!
-    end
-    
     it "should delegate span_status" do
-      span_instance.should_receive(:span_status).and_return(true)
-      
+      expect(span_instance).to receive(:span_status).and_return(true)
+
       span_model.span_status
     end
-    
+
     it "should delegate span_status_on" do
-      span_instance.should_receive(:span_status_on).and_return(true)
-      
+      expect(span_instance).to receive(:span_status_on).and_return(true)
+
       span_model.span_status_on
     end
-    
-    it "should delegate span_status_to_s" do
-      span_instance.should_receive(:span_status_to_s).and_return(true)
-      
-      span_model.span_status_to_s
-    end
-    
-    it "should delegate span_status_to_s_on" do
-      span_instance.should_receive(:span_status_to_s_on).and_return(true)
-      
-      span_model.span_status_to_s_on
-    end
-    
+
     it "should delegate current?" do
-      span_instance.should_receive(:current?).and_return(true)
-      
+      expect(span_instance).to receive(:current?).and_return(true)
+
       span_model.current?
     end
-    
+
     it "should delegate current_on?" do
-      span_instance.should_receive(:current_on?).and_return(true)
-      
+      expect(span_instance).to receive(:current_on?).and_return(true)
+
       span_model.current_on?
     end
-    
+
     it "should delegate future?" do
-      span_instance.should_receive(:future?).and_return(true)
-      
+      expect(span_instance).to receive(:future?).and_return(true)
+
       span_model.future?
     end
-    
+
     it "should delegate future_on?" do
-      span_instance.should_receive(:future_on?).and_return(true)
-      
+      expect(span_instance).to receive(:future_on?).and_return(true)
+
       span_model.future_on?
     end
-    
+
     it "should delegate expired?" do
-      span_instance.should_receive(:expired?).and_return(true)
-      
+      expect(span_instance).to receive(:expired?).and_return(true)
+
       span_model.expired?
     end
-    
+
     it "should delegate expired_on?" do
-      span_instance.should_receive(:expired_on?).and_return(true)
-      
+      expect(span_instance).to receive(:expired_on?).and_return(true)
+
       span_model.expired_on?
     end
   end
-end
+end

data/spec/lib/end_date_propagator_spec.rb

@@ -0,0 +1,319 @@
+require 'spec_helper'
+
+RSpec.describe ActsAsSpan::EndDatePropagator do
+  let(:end_date_propagator) do
+    ActsAsSpan::EndDatePropagator.new(
+      base_instance, skipped_classes: skipped_classes,
+      include_errors: include_errors
+    )
+  end
+
+  let(:base_instance) do
+    Base.create(end_date: initial_end_date)
+  end
+
+  let(:include_errors) { true }
+  let(:initial_end_date) { nil }
+
+  let(:other_base_instance) do
+    OtherBase.create(end_date: other_end_date)
+  end
+  let(:other_end_date) { nil }
+
+  let(:skipped_classes) { [] }
+
+  let!(:child_instance) do
+    Child.create(
+      base: base_instance,
+      emancipation_date: child_end_date
+    )
+  end
+  let(:child_end_date) { nil }
+
+  let!(:dog_instance) do
+    Dog.create(
+      base: base_instance,
+      end_date: dog_end_date
+    )
+  end
+  let(:dog_end_date) { nil }
+
+  let!(:bird_instance) do
+    Bird.create(
+      child: child_instance,
+      end_date: child_end_date
+    )
+  end
+  let(:bird_end_date) { nil }
+
+  let(:tale_instance) do
+    base_instance.tales.create(start_date: Date.current, end_date: nil)
+  end
+
+  describe '@errors_cache' do
+    let(:base_start_date) { Date.current - 7 }
+    let(:initial_end_date) { nil }
+    let(:end_date) { Date.current }
+
+    let(:child_start_date) { base_start_date + 1 }
+    let!(:child_instance) do
+      Child.create(
+        base: base_instance,
+        date_of_birth: child_start_date,
+        emancipation_date: child_end_date
+      )
+    end
+    let(:bird_start_date) { child_start_date + 1 }
+    let!(:bird_instance) do
+      Bird.create(
+        child: child_instance,
+        start_date: bird_start_date,
+        end_date: bird_end_date
+      )
+    end
+
+    before do
+      base_instance.start_date = base_start_date
+      base_instance.save!
+      base_instance.end_date = end_date
+    end
+
+    context 'when all child records are successfully saved' do
+      it 'the parent record does not have any errors' do
+        expect(
+          end_date_propagator.call.errors.full_messages
+        ).to be_empty
+      end
+    end
+
+    context 'when one grandchild record is not valid' do
+      before do
+        bird_instance.start_date = child_start_date - 1
+        bird_instance.save(validate: false)
+      end
+      it "the parent shows that grandchild's errors" do
+        expect(
+          end_date_propagator.call.errors.values.join
+        ).to include(
+          I18n.t(
+            'not_within_parent_date_span',
+            parent: 'Child',
+            scope: %i[activerecord errors messages]
+          )
+        )
+      end
+    end
+
+    context 'when multiple child records are not valid' do
+      context 'when include_errors = true (default)' do
+        before do
+          child_instance.date_of_birth = base_instance.span.start_date - 1
+          child_instance.save(validate: false)
+          bird_instance.start_date = child_instance.span.start_date - 1
+          bird_instance.save(validate: false)
+        end
+        it "the parent gains all children's errors" do
+          expect(
+            end_date_propagator.call.errors.values.join
+          ).to include(
+            I18n.t(
+              'not_within_parent_date_span',
+              parent: 'Child',
+              scope: %i[activerecord errors messages]
+            )
+          ).and include(
+            I18n.t(
+              'not_within_parent_date_span',
+              parent: 'Base',
+              scope: %i[activerecord errors messages]
+            )
+          )
+        end
+      end
+
+      context 'when include_errors = false' do
+        let(:include_errors) { false }
+
+        it 'does not push any child errors' do
+          expect(end_date_propagator.call.errors.values).to be_empty
+        end
+      end
+    end
+  end
+
+  describe '.call' do
+    subject(:result) do
+      ActsAsSpan::EndDatePropagator.call(obj, call_options)
+    end
+    let(:obj) { base_instance }
+
+    context 'when no skipped classes are passed' do
+      let(:call_options) { {} }
+
+      it 'forwards the correct arguments to :new' do
+        expect(ActsAsSpan::EndDatePropagator)
+          .to receive(:new).with(obj, call_options).and_call_original
+        expect(result).to eq(obj)
+      end
+    end
+
+    context 'when skipped classes are passed' do
+      let(:call_options) { { skipped_classes: ['bungus'] } }
+
+      it 'forwards the correct arguments to :new' do
+        expect(ActsAsSpan::EndDatePropagator)
+          .to receive(:new).with(obj, call_options).and_call_original
+        expect(result).to eq(obj)
+      end
+    end
+  end
+
+  describe '#call' do
+    context 'without an end_date' do
+      let(:object_instance) { SpannableModel.new }
+
+      it 'does not raise an error' do
+        expect do
+          ActsAsSpan::EndDatePropagator.new(object_instance).call
+        end.not_to raise_error
+      end
+    end
+
+    context 'updates children' do
+      before do
+        base_instance
+        base_instance.end_date = end_date
+      end
+
+      context 'base_instance.end_date nil -> !nil' do
+        let(:initial_end_date) { nil }
+        let(:end_date) { Date.current }
+
+        context 'child_end_date == initial_end_date' do
+          let(:child_end_date) { initial_end_date }
+
+          it 'propagates to the child_instance' do
+            expect{ end_date_propagator.call }.to change{
+              child_instance.reload.emancipation_date }
+              .from(child_end_date).to(base_instance.end_date)
+          end
+        end
+
+        context 'child_end_date >= initial_end_date' do
+          let(:child_end_date) { end_date + 3 }
+
+          it 'propagates to the child_instance' do
+            expect{ end_date_propagator.call }.to change{
+              child_instance.reload.emancipation_date}
+              .from(child_end_date).to(base_instance.end_date)
+          end
+        end
+
+        context 'child_end_date <= initial_end_date' do
+          let(:child_end_date) { end_date - 3 }
+
+          it 'does not propagate to the child_instance' do
+            expect{ end_date_propagator.call }.not_to change{
+              child_instance.reload.emancipation_date}
+          end
+        end
+
+        context 'when a child cannot have its end date updated' do
+          before do
+            # add a "within parent date span" error to child
+            base_instance.start_date = Date.current - 1
+            child_instance.date_of_birth = Date.current - 2
+            child_instance.save(validate: false)
+          end
+
+          it "the parent's end date is not updated" do
+            expect{ end_date_propagator.call }.to change{
+              base_instance.errors[:base]
+            }.from([])
+          end
+
+          context 'and the child is the child of a child' do
+            before do
+            end
+
+            it "the parent's end date is not updated" do
+              expect{ end_date_propagator.call }.not_to change{
+                base_instance.reload.end_date
+              }
+            end
+          end
+        end
+      end
+
+      context 'base_instance.end_date !nil -> nil' do
+        let(:initial_end_date) { Date.current }
+        let(:end_date) { nil }
+        let(:child_end_date) { initial_end_date }
+
+        it 'does not propagate to the child_instance' do
+          expect{ end_date_propagator.call }.not_to change{
+            child_instance.reload.emancipation_date }
+        end
+      end
+
+      context 'base_instance.end_date not changed' do
+        let(:end_date) { initial_end_date }
+
+        it 'does not propagate to the child_instance' do
+          expect{ end_date_propagator.call }.not_to change{
+            child_instance.reload.emancipation_date }
+        end
+      end
+
+      context 'has access to all children via has_many associations' do
+        let(:end_date) { Date.current }
+
+        it 'changes the end_date of all child associations' do
+          expect{ end_date_propagator.call }.to change{
+            child_instance.reload.emancipation_date }.
+            from(child_instance.emancipation_date).to(base_instance.end_date)
+            .and change{ dog_instance.reload.end_date }
+            .from(dog_instance.end_date).to(base_instance.end_date)
+            .and change{ bird_instance.reload.end_date }
+            .from(bird_instance.end_date).to(base_instance.end_date)
+        end
+      end
+    end
+
+    context 'when child record does not have end_date to update' do
+      let!(:cat_owner_instance) do
+        CatOwner.create(end_date: initial_end_date)
+      end
+      let!(:cat_instance) do
+        Cat.create(cat_owner: cat_owner_instance)
+      end
+      let(:cat_end_date) { nil }
+      let(:end_date) { Date.current }
+
+      before do
+        cat_owner_instance.end_date = end_date
+      end
+
+      it 'does not throw an error' do
+        expect(cat_instance).not_to respond_to(:end_date)
+        expect{ end_date_propagator.call }.not_to raise_error
+      end
+    end
+
+    context 'when a class is skipped' do
+      let(:end_date) { Date.current }
+      let(:skipped_classes) { [Tale] }
+
+      before do
+        base_instance
+        tale_instance.save!
+        base_instance.end_date = end_date
+      end
+
+      it 'does not propagate to that class' do
+        expect{ end_date_propagator.call }.not_to change{
+          tale_instance.reload.end_date }
+      end
+    end
+  end
+end