acts_as_span 0.0.5 → 1.2.0

data/spec/lib/span_instance/status_spec.rb

@@ -1,49 +1,36 @@
 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) { span_model.span }
-  
-  context "#span_status & #span_status_to_s" do
+
+  context "#span_status" do
     before(:each) do
-      span.stub!(:current?).and_return(false)
-      span.stub!(:future?).and_return(false)
-      span.stub!(:expired?).and_return(false)
+      allow(span).to receive(:current?).and_return(false)
+      allow(span).to receive(:future?).and_return(false)
+      allow(span).to receive(:expired?).and_return(false)
     end
-    
+
     it "should return :unknown when all_conditions == false" do
-      span.span_status.should == :unknown
-      span.span_status_to_s.should == 'Unknown'
+      expect(span.span_status).to eq(:unknown)
     end
-    
+
     it "should return :current when current? == true" do
-      span.should_receive(:current?).twice.and_return(true)
-      
-      span.span_status.should == :current
-      span.span_status_to_s.should == 'Current'
+      expect(span).to receive(:current?).once.and_return(true)
+
+      expect(span.span_status).to eq(:current)
     end
-    
+
     it "should return :current when future? == true" do
-      span.should_receive(:future?).twice.and_return(true)
-      
-      span.span_status.should == :future
-      span.span_status_to_s.should == 'Future'
+      expect(span).to receive(:future?).once.and_return(true)
+
+      expect(span.span_status).to eq(:future)
     end
-    
+
     it "should return :current when expired? == true" do
-      span.should_receive(:expired?).twice.and_return(true)
-      
-      span.span_status.should == :expired
-      span.span_status_to_s.should == 'Expired'
+      expect(span).to receive(:expired?).once.and_return(true)
+
+      expect(span.span_status).to eq(:expired)
     end
   end
-end
+end

data/spec/lib/span_instance/validations_spec.rb

@@ -1,54 +1,18 @@
 require 'spec_helper'
 
-describe "Span" do
-  before(:each) do
-    build_model :span_model do
-      date  :start_date
-      date  :end_date
-    end
-  end
-  
-  #let(:span_model) { SpanModel.new(:start_date => Date.today, :end_date => Date.today + 1) }
-  #let(:span) { span_model.span }
-  
+RSpec.describe "Span" do
   it "should be valid" do
     SpanModel.acts_as_span
     span_model = SpanModel.new(:start_date => nil, :end_date => nil)
-    
-    span_model.should be_valid
-  end
-  
-  context ":start_date_field_required => true" do
-    before do
-      SpanModel.acts_as_span :start_date_field_required => true
-    end
-    
-    it "should require a start_date" do
-      span_model = SpanModel.new(:start_date => nil, :end_date => Date.today + 1)
-      
-      span_model.should_not be_valid
-      span_model.errors[:start_date].should have(1).error
-    end
-  end
-  
-  context ":end_date_field_required => true" do
-    before do
-      SpanModel.acts_as_span :end_date_field_required => true
-    end
-    
-    it "should require an end_date" do
-     span_model = SpanModel.new(:start_date => Date.today, :end_date => nil)
-      
-      span_model.should_not be_valid
-      span_model.errors[:end_date].should have(1).error
-    end
+
+    expect(span_model).to be_valid
   end
-  
+
   it "should require a start_date before the end_date" do
     SpanModel.acts_as_span
-    span_model = SpanModel.new(:start_date => Date.today, :end_date => Date.today - 1)
-    
-    span_model.should_not be_valid
-    span_model.errors[:end_date].should have(1).error
+    span_model = SpanModel.new(:start_date => Date.current, :end_date => Date.current - 1)
+
+    expect(span_model).not_to be_valid
+    expect(span_model.errors[:end_date].size).to eq(1)
   end
 end

data/spec/lib/span_instance_spec.rb

@@ -1,41 +1,28 @@
 require 'spec_helper'
 
-#NOTE: we're also testing :start_date_field & :end_date_field options work
-
-describe "Span" do
-  before(:each) do
-    build_model :span_model do
-      date  :start_date_x
-      date  :end_date_x
-      
-      acts_as_span :start_date_field => :start_date_x,
-                   :end_date_field => :end_date_x
-    end
-  end
-  
-  context "#close!" do
-    let(:span_model) { SpanModel.new(:start_date_x => Date.today, :end_date_x => nil) }
-    let(:span) { span_model.span }
-    
-    it "should set end_date? to today" do
-      lambda { span.close! }.should change(span_model, :end_date_x).from(nil).to(Date.today)
-    end
-    
-    it "should set end_date? to the parameter" do
-      lambda { span.close_on!(Date.today + 1.day) }.should change(span_model, :end_date_x).from(nil).to(Date.today + 1.day)
-    end
-  end
-  
+RSpec.describe "Span" do
   context "start_date & end_date" do
-    let(:span_model) { SpanModel.new(:start_date_x => Date.today, :end_date_x => Date.today + 1) }
+    let(:span_model) { SpanModel.new(:start_date => Date.current, :end_date => Date.current + 1) }
     let(:span) { span_model.span }
 
     it "should return the start_date" do
-      span.start_date.should == span_model.start_date_x
+      expect(span.start_date).to eq(span_model.start_date)
     end
 
     it "should return the end_date" do
-      span.end_date.should == span_model.end_date_x
+      expect(span.end_date).to eq(span_model.end_date)
+    end
+
+    context "changed?" do
+      it 'returns true when start_date has changed' do
+        span_model.start_date = span_model.start_date + 5
+        expect(span.start_date_changed?).to eq(true)
+      end
+
+      it 'returns true when end_date has changed' do
+        span_model.end_date = span_model.end_date + 5
+        expect(span.end_date_changed?).to eq(true)
+      end
     end
   end
-end
+end

data/spec/lib/span_klass/status_spec.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe ActsAsSpan::SpanKlass::Status do
+  let(:span_klass) { ::SpanModel }
+
+  let!(:today) { Date.current }
+
+  describe '.current' do
+    let!(:record) do
+      span_klass.create(
+        start_date: today - 1.week,
+        end_date: today + 1.week,
+      )
+    end
+
+    subject { span_klass.current(query_date) }
+
+    context "when query_date is within the record's span" do
+      let(:query_date) { record.start_date + 3.days }
+
+      it { is_expected.not_to be_empty }
+    end
+
+    context "when query_date is before the record's span" do
+      let(:query_date) { record.start_date - 1.week }
+
+      it { is_expected.to be_empty }
+    end
+
+    context "when query_date is after the record's span" do
+      let(:query_date) { record.end_date + 1.week }
+
+      it { is_expected.to be_empty }
+    end
+  end
+end

data/spec/lib/within_parent_date_span_validator_spec.rb

@@ -0,0 +1,126 @@
+require 'spec_helper'
+
+RSpec.describe ActsAsSpan::WithinParentDateSpanValidator do
+  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(start_date: mama_start_date, end_date: mama_end_date) }
+  let!(:papa) { Papa.create(start_date: papa_start_date, end_date: papa_end_date) }
+
+  let(:thirty_years_ago) { Date.current - 30.years }
+  let(:seventy_years_in_the_future) { Date.current + 70.years }
+
+  let(:mama_start_date) { thirty_years_ago }
+  let(:mama_end_date) { seventy_years_in_the_future }
+
+  let(:papa_start_date) { thirty_years_ago + 1.year }
+  let(:papa_end_date) { seventy_years_in_the_future - 1.year }
+
+  describe 'an object that validates against a single parent' do
+    let(:child_class) { OneParentChild }
+
+    context 'inside parent date span' do
+      let(:new_child_start_date) { mama_start_date }
+      let(:new_child_end_date) { mama_end_date }
+
+      it do
+        expect(new_child).to be_valid
+      end
+    end
+
+    context 'child_record_without_start_date' do
+      let(:new_child_start_date) { nil }
+      let(:new_child_end_date) { mama_end_date }
+
+      it do
+        expect(new_child).to be_invalid
+      end
+    end
+
+    context 'child_record_without_start_date' do
+      let(:new_child_start_date) { mama_start_date }
+      let(:new_child_end_date) { nil }
+
+      it do
+        expect(new_child).to be_invalid
+      end
+    end
+
+    context 'child_record_started_before_parent_record' do
+      let(:new_child_start_date) { mama_start_date - 1 }
+      let(:new_child_end_date) { mama_end_date }
+
+      it do
+        expect(new_child).to be_invalid
+      end
+    end
+
+    context 'child_record_ended_after_parent_record' do
+      let(:new_child_start_date) { mama_start_date }
+      let(:new_child_end_date) { mama_end_date + 1 }
+
+      it do
+        expect(new_child).to be_invalid
+      end
+    end
+
+    context 'with unassigned parent start_date' do
+      let(:new_child_start_date) { thirty_years_ago }
+      let(:new_child_end_date) { mama_end_date }
+      let(:mama_start_date) { nil }
+
+      it do
+        expect(new_child).to be_valid
+      end
+    end
+
+    context 'with unassigned parent end_date' do
+      let(:new_child_start_date) { mama_start_date }
+      let(:new_child_end_date) { seventy_years_in_the_future }
+      let(:mama_end_date) { nil }
+
+      it do
+        expect(new_child).to be_valid
+      end
+    end
+  end
+
+  describe 'an object with multiple parents' do
+    let(:child_class) { TwoParentChild }
+
+    before { new_child.papa = papa }
+
+    context 'valid cases' do
+      let(:new_child_start_date) { papa_start_date }
+      let(:new_child_end_date) { papa_end_date }
+
+      it 'allows date spans that lie within all respective parental date spans' do
+        expect(new_child).to be_valid
+      end
+    end
+
+    context 'invalid cases' do
+      let(:new_child_start_date) { papa_start_date - 1 }
+      let(:new_child_end_date) { papa_end_date + 1 }
+
+      it 'does not allow date spans that lie outside of respective parental date spans' do
+        expect(new_child).not_to be_valid
+      end
+    end
+  end
+
+  describe 'error messages' do
+    let(:child_class) { OneParentChildCustom }
+    let(:new_child_start_date) { mama_start_date - 3.days }
+    let(:new_child_end_date) { mama_end_date + 5.days }
+
+    it 'allows using custom error messages' do
+      expect(new_child).not_to be_valid
+      expect(new_child.errors.messages[:base]).to include('Custom error message')
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,10 +1,23 @@
-require 'rubygems'
 require 'bundler/setup'
-require 'acts_as_fu'
-require 'active_support'
-
 require 'acts_as_span'
+require 'pry'
+
+require 'active_record'
+require 'active_support'
+require 'spec_models'
 
 RSpec.configure do |config|
-  config.include ActsAsFu
-end
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = ".rspec_status"
+
+  # Disable RSpec exposing methods globally on `Module` and `main`
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+
+  config.after do
+    Temping.cleanup
+  end
+end

data/spec/spec_models.rb

@@ -0,0 +1,226 @@
+require 'temping'
+require 'has_siblings'
+
+ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
+ActiveRecord::Base.logger = Logger.new(STDOUT) if ENV["DEBUG"]
+
+Temping.create :spannable_model do
+  with_columns do |t|
+    t.date :starting_date
+    t.date :ending_date
+
+    t.integer :unique_by_date_range
+  end
+end
+
+Temping.create :span_model do
+  with_columns do |t|
+    t.date :start_date
+    t.date :end_date
+  end
+
+  acts_as_span
+end
+
+Temping.create :one_parent_child do
+  with_columns do |t|
+    t.belongs_to :mama
+
+    t.date :start_date
+    t.date :end_date
+
+    # every one-parent child is a favorite! ...by default
+    t.boolean :favorite, default: true
+  end
+
+  acts_as_span
+
+  def favorite?
+    favorite
+  end
+
+  belongs_to :mama
+  has_siblings through: [:mama]
+
+  validates_with ActsAsSpan::NoOverlapValidator,
+    scope: proc { siblings }, instance_scope: proc { favorite? }
+  validates_with ActsAsSpan::WithinParentDateSpanValidator, parents: [:mama]
+end
+
+Temping.create :one_parent_child_custom do
+  with_columns do |t|
+    t.belongs_to :mama
+
+    t.date :start_date
+    t.date :end_date
+
+    # every one-parent child is a favorite! ...by default
+    t.boolean :favorite, default: true
+  end
+
+  acts_as_span
+
+  def favorite?
+    favorite
+  end
+
+  belongs_to :mama
+  has_siblings through: [:mama]
+
+  validates_with ActsAsSpan::NoOverlapValidator,
+    scope: proc { siblings }, instance_scope: proc { favorite? }, message: 'Custom error message'
+  validates_with ActsAsSpan::WithinParentDateSpanValidator, parents: [:mama], message: 'Custom error message'
+end
+
+
+Temping.create :two_parent_child do
+  with_columns do |t|
+    t.belongs_to :mama
+    t.belongs_to :papa
+
+    t.date :start_date
+    t.date :end_date
+  end
+
+  acts_as_span
+
+  belongs_to :mama
+  belongs_to :papa
+  has_siblings through: [:mama, :papa]
+
+  validates_with ActsAsSpan::NoOverlapValidator, scope: proc { siblings }
+  validates_with ActsAsSpan::WithinParentDateSpanValidator, parents: [:mama, :papa]
+end
+
+Temping.create :mama do
+  with_columns do |t|
+    t.date :start_date
+    t.date :end_date
+  end
+
+  acts_as_span
+
+  has_many :one_parent_children
+  has_many :two_parent_children
+  has_many :one_parent_child_customs
+end
+
+Temping.create :papa do
+  with_columns do |t|
+    t.date :start_date
+    t.date :end_date
+  end
+
+  acts_as_span
+
+  has_many :one_parent_children
+end
+
+# fulfill association requirements for EndDatePropagator
+Temping.create :base do
+  has_many :children, dependent: :destroy
+  has_many :dogs, dependent: :destroy
+  has_many :birds, through: :children
+  has_many :tales, dependent: :destroy
+
+  acts_as_span
+
+  with_columns do |t|
+    t.date :end_date
+    t.date :start_date
+  end
+end
+
+Temping.create :cat_owner do
+  has_many :cats, dependent: :destroy
+
+  acts_as_span
+
+  with_columns do |t|
+    t.date :start_date
+    t.date :end_date
+  end
+end
+
+Temping.create :cat do
+  belongs_to :cat_owner
+
+  with_columns do |t|
+    t.belongs_to :cat_owner
+  end
+end
+
+Temping.create :other_base do
+  has_many :children, dependent: :destroy
+
+  acts_as_span
+
+  with_columns do |t|
+    t.date :end_date
+    t.date :start_date
+  end
+end
+
+# has non-standard start_ and end_field names
+Temping.create :child do
+  belongs_to :base
+  belongs_to :other_base
+  has_many :birds, dependent: :destroy
+
+  validates_with ActsAsSpan::WithinParentDateSpanValidator,
+    parents: [:base]
+
+  acts_as_span(
+    start_field: :date_of_birth,
+    end_field: :emancipation_date
+  )
+
+  with_columns do |t|
+    t.date :date_of_birth
+    t.date :emancipation_date
+    t.string :manual_invalidation
+    t.belongs_to :base
+  end
+end
+
+Temping.create :dog do
+  belongs_to :base
+
+  acts_as_span
+
+  with_columns do |t|
+    t.date :start_date
+    t.date :end_date
+    t.belongs_to :base
+  end
+end
+
+
+Temping.create :bird do
+  belongs_to :child
+
+  validates_with ActsAsSpan::WithinParentDateSpanValidator,
+    parents: [:child]
+
+  acts_as_span
+
+  with_columns do |t|
+    t.date :end_date
+    t.date :start_date
+    t.belongs_to :child
+  end
+end
+
+Temping.create :tale do
+  belongs_to :base
+
+  acts_as_span
+
+  with_columns do |t|
+    t.date :end_date
+    t.date :start_date
+    t.belongs_to :base
+  end
+end
+
+