ninoxe 1.2.2 → 1.2.3

data/spec/models/chouette/time_table_period_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe Chouette::TimeTablePeriod, :type => :model do
+
+  let!(:time_table) { create(:time_table)}
+  subject { create(:time_table_period ,:time_table => time_table, :period_start => Date.new(2014,6,30), :period_end => Date.new(2014,7,6) ) }
+  let!(:p2) {create(:time_table_period ,:time_table => time_table, :period_start => Date.new(2014,7,6), :period_end => Date.new(2014,7,14) ) } 
+
+  it { is_expected.to validate_presence_of :period_start }
+  it { is_expected.to validate_presence_of :period_end }
+  
+  describe "#overlap" do
+    context "when periods intersect, " do
+      it "should detect period overlap" do
+         expect(subject.overlap?(p2)).to be_truthy
+         expect(p2.overlap?(subject)).to be_truthy
+      end
+    end
+    context "when periods don't intersect, " do
+      before(:each) do
+        p2.period_start = Date.new(2014,7,7)
+      end
+      it "should not detect period overlap" do
+         expect(subject.overlap?(p2)).to be_falsey
+         expect(p2.overlap?(subject)).to be_falsey
+      end
+    end
+    context "when period 1 contains period 2, " do
+      before(:each) do
+        p2.period_start = Date.new(2014,7,1)
+        p2.period_end = Date.new(2014,7,6)
+      end
+      it "should detect period overlap" do
+         expect(subject.overlap?(p2)).to be_truthy
+         expect(p2.overlap?(subject)).to be_truthy
+      end
+    end
+  end
+  describe "#contains" do
+    context "when periods intersect, " do
+      it "should not detect period inclusion" do
+         expect(subject.contains?(p2)).to be_falsey
+         expect(p2.contains?(subject)).to be_falsey
+      end
+    end
+    context "when periods don't intersect, " do
+      before(:each) do
+        p2.period_start = Date.new(2014,7,7)
+      end
+      it "should not detect period inclusion" do
+         expect(subject.contains?(p2)).to be_falsey
+         expect(p2.contains?(subject)).to be_falsey
+      end
+    end
+    context "when period 1 contains period 2, " do
+      before(:each) do
+        p2.period_start = Date.new(2014,7,1)
+        p2.period_end = Date.new(2014,7,6)
+      end
+      it "should detect period inclusion" do
+         expect(subject.contains?(p2)).to be_truthy
+         expect(p2.contains?(subject)).to be_falsey
+      end
+    end
+  end
+end

data/spec/models/chouette/time_table_spec.rb

@@ -0,0 +1,1266 @@
+require 'spec_helper'
+
+describe Chouette::TimeTable, :type => :model do
+
+  subject { create(:time_table) }
+
+  it { is_expected.to validate_presence_of :comment }
+  it { is_expected.to validate_uniqueness_of :objectid }
+
+  describe "#periods_max_date" do
+    context "when all period extends from 04/10/2013 to 04/15/2013," do
+      before(:each) do
+        p1 = Chouette::TimeTablePeriod.new( :period_start => Date.strptime("04/10/2013", '%m/%d/%Y'), :period_end => Date.strptime("04/12/2013", '%m/%d/%Y'))
+        p2 = Chouette::TimeTablePeriod.new( :period_start => Date.strptime("04/13/2013", '%m/%d/%Y'), :period_end => Date.strptime("04/15/2013", '%m/%d/%Y'))
+        subject.periods = [ p1, p2]
+        subject.save
+      end
+
+      it "should retreive 04/15/2013" do
+        expect(subject.periods_max_date).to eq(Date.strptime("04/15/2013", '%m/%d/%Y'))
+      end
+      context "when 04/15/2013 is excluded, periods_max_dates selects the day before" do
+        before(:each) do
+          excluded_date = Date.strptime("04/15/2013", '%m/%d/%Y')
+          subject.dates = [ Chouette::TimeTableDate.new( :date => excluded_date, :in_out => false)]
+          subject.save
+        end
+        it "should retreive 04/14/2013" do
+          expect(subject.periods_max_date).to eq(Date.strptime("04/14/2013", '%m/%d/%Y'))
+        end
+      end
+      context "when day_types select only sunday and saturday," do
+        before(:each) do
+          # jeudi, vendredi
+          subject.update_attributes( :int_day_types => (2**(1+6) + 2**(1+7)))
+        end
+        it "should retreive 04/14/2013" do
+          expect(subject.periods_max_date).to eq(Date.strptime("04/14/2013", '%m/%d/%Y'))
+        end
+      end
+      context "when day_types select only friday," do
+        before(:each) do
+          # jeudi, vendredi
+          subject.update_attributes( :int_day_types => (2**(1+6)))
+        end
+        it "should retreive 04/12/2013" do
+          expect(subject.periods_max_date).to eq(Date.strptime("04/13/2013", '%m/%d/%Y'))
+        end
+      end
+      context "when day_types select only thursday," do
+        before(:each) do
+          # mardi
+          subject.update_attributes( :int_day_types => (2**(1+2)))
+        end
+        it "should retreive 04/12/2013" do
+          # 04/15/2013 is monday !
+          expect(subject.periods_max_date).to be_nil
+        end
+      end
+    end
+  end
+
+describe "update_attributes on periods and dates" do
+
+    context "update days selection" do
+        it "should update start_date and end_end" do
+            days_hash = {}.tap do |hash|
+                [ :monday,:tuesday,:wednesday,:thursday,:friday,:saturday,:sunday ].each { |d| hash[d] = false }
+            end
+            subject.update_attributes( days_hash)
+
+            read = Chouette::TimeTable.find( subject.id )
+            expect(read.start_date).to eq(read.dates.select{|d| d.in_out}.map(&:date).compact.min)
+            expect(read.end_date).to eq(read.dates.select{|d| d.in_out}.map(&:date).compact.max)
+
+        end
+    end
+    context "add a new period" do
+        let!( :new_start_date ){ subject.start_date - 20.days }
+        let!( :new_end_date ){ subject.end_date + 20.days }
+        let!( :new_period_attributes ) {
+            pa = periods_attributes
+            pa[ "11111111111" ] = { "period_end" => new_end_date, "period_start" => new_start_date, "_destroy" => "", "position" => pa.size.to_s, "id" => "", "time_table_id" => subject.id.to_s}
+            pa
+        }
+        it "should update start_date and end_end" do
+            subject.update_attributes( :periods_attributes => new_period_attributes)
+
+            read = Chouette::TimeTable.find( subject.id )
+            expect(read.start_date).to eq(new_start_date)
+            expect(read.end_date).to eq(new_end_date)
+        end
+    end
+    context "update period end" do
+        let!( :new_end_date ){ subject.end_date + 20.days }
+        let!( :new_period_attributes ) {
+            pa = periods_attributes
+            pa[ "0" ].merge! "period_end" => new_end_date
+            pa
+        }
+        it "should update end_date" do
+            subject.update_attributes :periods_attributes => new_period_attributes
+
+            read = Chouette::TimeTable.find( subject.id )
+            expect(read.end_date).to eq(new_end_date)
+        end
+    end
+    context "update period start" do
+        let!( :new_start_date ){ subject.start_date - 20.days }
+        let!( :new_period_attributes ) {
+            pa = periods_attributes
+            pa[ "0" ].merge! "period_start" => new_start_date
+            pa
+        }
+        it "should update start_date" do
+            subject.update_attributes :periods_attributes => new_period_attributes
+
+            read = Chouette::TimeTable.find( subject.id )
+            expect(read.start_date).to eq(new_start_date)
+        end
+    end
+    context "remove periods and dates and add a new period" do
+        let!( :new_start_date ){ subject.start_date + 1.days }
+        let!( :new_end_date ){ subject.end_date - 1.days }
+        let!( :new_dates_attributes ) {
+            da = dates_attributes
+            da.each { |k,v| v.merge! "_destroy" => true}
+            da
+        }
+        let!( :new_period_attributes ) {
+            pa = periods_attributes
+            pa.each { |k,v| v.merge! "_destroy" => true}
+            pa[ "11111111111" ] = { "period_end" => new_end_date, "period_start" => new_start_date, "_destroy" => "", "position" => pa.size.to_s, "id" => "", "time_table_id" => subject.id.to_s}
+            pa
+        }
+        it "should update start_date and end_date with new period added" do
+            subject.update_attributes :periods_attributes => new_period_attributes, :dates_attributes => new_dates_attributes
+
+            read = Chouette::TimeTable.find( subject.id )
+            expect(read.start_date).to eq(new_start_date)
+            expect(read.end_date).to eq(new_end_date)
+        end
+    end
+    def dates_attributes
+        {}.tap do |hash|
+            subject.dates.each_with_index do |p, index|
+                hash.merge! index.to_s => p.attributes.merge( "_destroy" => "" )
+            end
+        end
+    end
+    def periods_attributes
+        {}.tap do |hash|
+            subject.periods.each_with_index do |p, index|
+                hash.merge! index.to_s => p.attributes.merge( "_destroy" => "" )
+            end
+        end
+    end
+end
+
+  describe "#periods_min_date" do
+    context "when all period extends from 04/10/2013 to 04/15/2013," do
+      before(:each) do
+        p1 = Chouette::TimeTablePeriod.new( :period_start => Date.strptime("04/10/2013", '%m/%d/%Y'), :period_end => Date.strptime("04/12/2013", '%m/%d/%Y'))
+        p2 = Chouette::TimeTablePeriod.new( :period_start => Date.strptime("04/13/2013", '%m/%d/%Y'), :period_end => Date.strptime("04/15/2013", '%m/%d/%Y'))
+        subject.periods = [ p1, p2]
+        subject.save
+      end
+
+      it "should retreive 04/10/2013" do
+        expect(subject.periods_min_date).to eq(Date.strptime("04/10/2013", '%m/%d/%Y'))
+      end
+      context "when 04/10/2013 is excluded, periods_min_dates select the day after" do
+        before(:each) do
+          excluded_date = Date.strptime("04/10/2013", '%m/%d/%Y')
+          subject.dates = [ Chouette::TimeTableDate.new( :date => excluded_date, :in_out => false)]
+          subject.save
+        end
+        it "should retreive 04/11/2013" do
+          expect(subject.periods_min_date).to eq(Date.strptime("04/11/2013", '%m/%d/%Y'))
+        end
+      end
+      context "when day_types select only tuesday and friday," do
+        before(:each) do
+          # jeudi, vendredi
+          subject.update_attributes( :int_day_types => (2**(1+4) + 2**(1+5)))
+        end
+        it "should retreive 04/11/2013" do
+          expect(subject.periods_min_date).to eq(Date.strptime("04/11/2013", '%m/%d/%Y'))
+        end
+      end
+      context "when day_types select only friday," do
+        before(:each) do
+          # jeudi, vendredi
+          subject.update_attributes( :int_day_types => (2**(1+5)))
+        end
+        it "should retreive 04/12/2013" do
+          expect(subject.periods_min_date).to eq(Date.strptime("04/12/2013", '%m/%d/%Y'))
+        end
+      end
+      context "when day_types select only thursday," do
+        before(:each) do
+          # mardi
+          subject.update_attributes( :int_day_types => (2**(1+2)))
+        end
+        it "should retreive 04/12/2013" do
+          # 04/15/2013 is monday !
+          expect(subject.periods_min_date).to be_nil
+        end
+      end
+    end
+  end
+  describe "#periods.build" do
+    it "should add a new instance of period, and periods_max_date should not raise error" do
+      period = subject.periods.build
+      subject.periods_max_date
+      expect(period.period_start).to be_nil
+      expect(period.period_end).to be_nil
+    end
+  end
+  describe "#periods" do
+    context "when a period is added," do
+      before(:each) do
+        subject.periods << Chouette::TimeTablePeriod.new( :period_start => (subject.bounding_dates.min - 1), :period_end => (subject.bounding_dates.max + 1))
+        subject.save
+      end
+      it "should update shortcut" do
+        expect(subject.start_date).to eq(subject.bounding_dates.min)
+        expect(subject.end_date).to eq(subject.bounding_dates.max)
+      end
+    end
+    context "when a period is removed," do
+      before(:each) do
+        subject.dates = []
+        subject.periods = []
+        subject.periods << Chouette::TimeTablePeriod.new(
+                              :period_start => 4.days.since.to_date,
+                              :period_end => 6.days.since.to_date)
+        subject.periods << Chouette::TimeTablePeriod.new(
+                              :period_start => 1.days.since.to_date,
+                              :period_end => 10.days.since.to_date)
+        subject.save
+        subject.periods = subject.periods - [subject.periods.last]
+        subject.save_shortcuts
+      end
+      def read_tm
+        Chouette::TimeTable.find subject.id
+      end
+      it "should update shortcut" do
+        tm = read_tm
+        expect(subject.start_date).to eq(subject.bounding_dates.min)
+        expect(subject.start_date).to eq(tm.bounding_dates.min)
+        expect(subject.start_date).to eq(4.days.since.to_date)
+        expect(subject.end_date).to eq(subject.bounding_dates.max)
+        expect(subject.end_date).to eq(tm.bounding_dates.max)
+        expect(subject.end_date).to eq(6.days.since.to_date)
+      end
+    end
+    context "when a period is updated," do
+      before(:each) do
+        subject.dates = []
+        subject.periods = []
+        subject.periods << Chouette::TimeTablePeriod.new(
+                              :period_start => 4.days.since.to_date,
+                              :period_end => 6.days.since.to_date)
+        subject.periods << Chouette::TimeTablePeriod.new(
+                              :period_start => 1.days.since.to_date,
+                              :period_end => 10.days.since.to_date)
+        subject.save
+        subject.periods.last.period_end = 15.days.since.to_date
+        subject.save
+      end
+      def read_tm
+        Chouette::TimeTable.find subject.id
+      end
+      it "should update shortcut" do
+        tm = read_tm
+        expect(subject.start_date).to eq(subject.bounding_dates.min)
+        expect(subject.start_date).to eq(tm.bounding_dates.min)
+        expect(subject.start_date).to eq(1.days.since.to_date)
+        expect(subject.end_date).to eq(subject.bounding_dates.max)
+        expect(subject.end_date).to eq(tm.bounding_dates.max)
+        expect(subject.end_date).to eq(15.days.since.to_date)
+      end
+    end
+
+  end
+  describe "#periods.valid?" do
+    context "when an empty period is set," do
+      it "should not save tm if period invalid" do
+        subject = Chouette::TimeTable.new({"comment"=>"test",
+                                           "version"=>"",
+                                           "monday"=>"0",
+                                           "tuesday"=>"0",
+                                           "wednesday"=>"0",
+                                           "thursday"=>"0",
+                                           "friday"=>"0",
+                                           "saturday"=>"0",
+                                           "sunday"=>"0",
+                                           "objectid"=>"",
+                                           "periods_attributes"=>{"1397136188334"=>{"period_start"=>"",
+                                           "period_end"=>"",
+                                           "_destroy"=>""}}})
+        subject.save
+        expect(subject.id).to be_nil
+      end
+    end
+    context "when a valid period is set," do
+      it "it should save tm if period valid" do
+        subject = Chouette::TimeTable.new({"comment"=>"test",
+                                           "version"=>"",
+                                           "monday"=>"1",
+                                           "tuesday"=>"1",
+                                           "wednesday"=>"1",
+                                           "thursday"=>"1",
+                                           "friday"=>"1",
+                                           "saturday"=>"1",
+                                           "sunday"=>"1",
+                                           "objectid"=>"",
+                                           "periods_attributes"=>{"1397136188334"=>{"period_start"=>"2014-01-01",
+                                           "period_end"=>"2015-01-01",
+                                           "_destroy"=>""}}})
+        subject.save
+        tm = Chouette::TimeTable.find subject.id
+        expect(tm.periods.empty?).to be_falsey
+        expect(tm.start_date).to eq(Date.new(2014, 01, 01))
+        expect(tm.end_date).to eq(Date.new(2015, 01, 01))
+
+      end
+    end
+  end
+
+  describe "#dates" do
+    context "when a date is added," do
+      before(:each) do
+        subject.dates << Chouette::TimeTableDate.new( :date => (subject.bounding_dates.max + 1), :in_out => true)
+        subject.save
+      end
+      it "should update shortcut" do
+        expect(subject.start_date).to eq(subject.bounding_dates.min)
+        expect(subject.end_date).to eq(subject.bounding_dates.max)
+      end
+    end
+    context "when a date is removed," do
+      before(:each) do
+        subject.periods = []
+        subject.dates = subject.dates - [subject.bounding_dates.max + 1]
+        subject.save_shortcuts
+      end
+      it "should update shortcut" do
+        expect(subject.start_date).to eq(subject.bounding_dates.min)
+        expect(subject.end_date).to eq(subject.bounding_dates.max)
+      end
+    end
+    context "when all the dates and periods are removed," do
+      before(:each) do
+        subject.periods = []
+        subject.dates = []
+        subject.save_shortcuts
+      end
+      it "should update shortcut" do
+        expect(subject.start_date).to be_nil
+        expect(subject.end_date).to be_nil
+      end
+    end
+    context "when a date is updated," do
+      before(:each) do
+        subject.dates = []
+
+        subject.periods = []
+        subject.periods << Chouette::TimeTablePeriod.new(
+                              :period_start => 4.days.since.to_date,
+                              :period_end => 6.days.since.to_date)
+        subject.periods << Chouette::TimeTablePeriod.new(
+                              :period_start => 1.days.since.to_date,
+                              :period_end => 10.days.since.to_date)
+        subject.dates << Chouette::TimeTableDate.new( :date => 10.days.since.to_date, :in_out => true)
+        subject.save
+        subject.dates.last.date = 15.days.since.to_date
+        subject.save
+      end
+      def read_tm
+        Chouette::TimeTable.find subject.id
+      end
+      it "should update shortcut" do
+        tm = read_tm
+        expect(subject.start_date).to eq(subject.bounding_dates.min)
+        expect(subject.start_date).to eq(tm.bounding_dates.min)
+        expect(subject.start_date).to eq(1.days.since.to_date)
+        expect(subject.end_date).to eq(subject.bounding_dates.max)
+        expect(subject.end_date).to eq(tm.bounding_dates.max)
+        expect(subject.end_date).to eq(15.days.since.to_date)
+      end
+    end
+  end
+  describe "#dates.valid?" do
+    it "should not save tm if date invalid" do
+      subject = Chouette::TimeTable.new({"comment"=>"test",
+                                         "version"=>"",
+                                         "monday"=>"0",
+                                         "tuesday"=>"0",
+                                         "wednesday"=>"0",
+                                         "thursday"=>"0",
+                                         "friday"=>"0",
+                                         "saturday"=>"0",
+                                         "sunday"=>"0",
+                                         "objectid"=>"",
+                                         "dates_attributes"=>{"1397136189216"=>{"date"=>"",
+                                         "_destroy"=>"", "in_out" => true}}})
+      subject.save
+      expect(subject.id).to be_nil
+    end
+    it "it should save tm if date valid" do
+      subject = Chouette::TimeTable.new({"comment"=>"test",
+                                         "version"=>"",
+                                         "monday"=>"1",
+                                         "tuesday"=>"1",
+                                         "wednesday"=>"1",
+                                         "thursday"=>"1",
+                                         "friday"=>"1",
+                                         "saturday"=>"1",
+                                         "sunday"=>"1",
+                                         "objectid"=>"",
+                                         "dates_attributes"=>{"1397136189216"=>{"date"=>"2015-01-01",
+                                         "_destroy"=>"", "in_out" => true}}})
+      subject.save
+      tm = Chouette::TimeTable.find subject.id
+      expect(tm.dates.empty?).to be_falsey
+      expect(tm.start_date).to eq(Date.new(2015, 01, 01))
+      expect(tm.end_date).to eq(Date.new(2015, 01, 01))
+    end
+  end
+
+  describe "#valid_days" do
+    it "should begin with position 0" do
+      subject.int_day_types = 128
+      expect(subject.valid_days).to eq([6])
+    end
+  end
+
+  describe "#intersects" do
+    it "should return day if a date equal day" do
+      time_table = Chouette::TimeTable.create!(:comment => "Test", :objectid => "test:Timetable:1")
+      time_table.dates << Chouette::TimeTableDate.new( :date => Date.today, :in_out => true)
+      expect(time_table.intersects([Date.today])).to eq([Date.today])
+    end
+
+    it "should return [] if a period not include days" do
+      time_table = Chouette::TimeTable.create!(:comment => "Test", :objectid => "test:Timetable:1", :int_day_types => 12)
+      time_table.periods << Chouette::TimeTablePeriod.new(
+                              :period_start => Date.new(2013, 05, 27),
+                              :period_end => Date.new(2013, 05, 30))
+      expect(time_table.intersects([ Date.new(2013, 05, 29),  Date.new(2013, 05, 30)])).to eq([])
+    end
+
+    it "should return days if a period include day" do
+      time_table = Chouette::TimeTable.create!(:comment => "Test", :objectid => "test:Timetable:1", :int_day_types => 12) # Day type monday and tuesday
+      time_table.periods << Chouette::TimeTablePeriod.new(
+                              :period_start => Date.new(2013, 05, 27),
+                              :period_end => Date.new(2013, 05, 30))
+      expect(time_table.intersects([ Date.new(2013, 05, 27),  Date.new(2013, 05, 28)])).to eq([ Date.new(2013, 05, 27),  Date.new(2013, 05, 28)])
+    end
+
+
+  end
+
+  describe "#include_day?" do
+    it "should return true if a date equal day" do
+      time_table = Chouette::TimeTable.create!(:comment => "Test", :objectid => "test:Timetable:1")
+      time_table.dates << Chouette::TimeTableDate.new( :date => Date.today, :in_out => true)
+      expect(time_table.include_day?(Date.today)).to eq(true)
+    end
+
+    it "should return true if a period include day" do
+      time_table = Chouette::TimeTable.create!(:comment => "Test", :objectid => "test:Timetable:1", :int_day_types => 12) # Day type monday and tuesday
+      time_table.periods << Chouette::TimeTablePeriod.new(
+                              :period_start => Date.new(2013, 05, 27),
+                              :period_end => Date.new(2013, 05, 29))
+      expect(time_table.include_day?( Date.new(2013, 05, 27))).to eq(true)
+    end
+  end
+
+  describe "#include_in_dates?" do
+    it "should return true if a date equal day" do
+      time_table = Chouette::TimeTable.create!(:comment => "Test", :objectid => "test:Timetable:1")
+      time_table.dates << Chouette::TimeTableDate.new( :date => Date.today, :in_out => true)
+      expect(time_table.include_in_dates?(Date.today)).to eq(true)
+    end
+
+    it "should return false if a period include day  but that is exclued" do
+      time_table = Chouette::TimeTable.create!(:comment => "Test", :objectid => "test:Timetable:1", :int_day_types => 12) # Day type monday and tuesday
+      excluded_date = Date.new(2013, 05, 27)
+      time_table.dates << Chouette::TimeTableDate.new( :date => excluded_date, :in_out => false)
+      expect(time_table.include_in_dates?( excluded_date)).to be_falsey
+    end
+  end
+
+  describe "#include_in_periods?" do
+    it "should return true if a period include day" do
+      time_table = Chouette::TimeTable.create!(:comment => "Test", :objectid => "test:Timetable:1", :int_day_types => 4)
+      time_table.periods << Chouette::TimeTablePeriod.new(
+                              :period_start => Date.new(2012, 1, 1),
+                              :period_end => Date.new(2012, 01, 30))
+      expect(time_table.include_in_periods?(Date.new(2012, 1, 2))).to eq(true)
+    end
+
+    it "should return false if a period include day  but that is exclued" do
+      time_table = Chouette::TimeTable.create!(:comment => "Test", :objectid => "test:Timetable:1", :int_day_types => 12) # Day type monday and tuesday
+      excluded_date = Date.new(2013, 05, 27)
+      time_table.dates << Chouette::TimeTableDate.new( :date => excluded_date, :in_out => false)
+      time_table.periods << Chouette::TimeTablePeriod.new(
+                              :period_start => Date.new(2013, 05, 27),
+                              :period_end => Date.new(2013, 05, 29))
+      expect(time_table.include_in_periods?( excluded_date)).to be_falsey
+    end
+  end
+
+  describe "#include_in_overlap_dates?" do
+    it "should return true if a day is included in overlap dates" do
+      time_table = Chouette::TimeTable.create!(:comment => "Test", :objectid => "test:Timetable:1", :int_day_types => 4)
+      time_table.periods << Chouette::TimeTablePeriod.new(
+                              :period_start => Date.new(2012, 1, 1),
+                              :period_end => Date.new(2012, 01, 30))
+      time_table.dates << Chouette::TimeTableDate.new( :date => Date.new(2012, 1, 2), :in_out => true)
+      expect(time_table.include_in_overlap_dates?(Date.new(2012, 1, 2))).to eq(true)
+    end
+    it "should return false if the day is excluded" do
+      time_table = Chouette::TimeTable.create!(:comment => "Test", :objectid => "test:Timetable:1", :int_day_types => 4)
+      time_table.periods << Chouette::TimeTablePeriod.new(
+                              :period_start => Date.new(2012, 1, 1),
+                              :period_end => Date.new(2012, 01, 30))
+      time_table.dates << Chouette::TimeTableDate.new( :date => Date.new(2012, 1, 2), :in_out => false)
+      expect(time_table.include_in_overlap_dates?(Date.new(2012, 1, 2))).to be_falsey
+    end
+  end
+
+  describe "#dates" do
+    it "should have with position 0" do
+      expect(subject.dates.first.position).to eq(0)
+    end
+    context "when first date has been removed" do
+      before do
+        subject.dates.first.destroy
+      end
+      it "should begin with position 0" do
+        expect(subject.dates.first.position).to eq(0)
+      end
+    end
+  end
+  describe "#validity_out_between?" do
+    let(:empty_tm) {build(:time_table)}
+    it "should be false if empty calendar" do
+      expect(empty_tm.validity_out_between?( Date.today, Date.today + 7.day)).to be_falsey
+    end
+    it "should be true if caldendar is out during start_date and end_date period" do
+      start_date = subject.bounding_dates.max - 2.day
+      end_date = subject.bounding_dates.max + 2.day
+      expect(subject.validity_out_between?( start_date, end_date)).to be_truthy
+    end
+    it "should be false if calendar is out on start date" do
+      start_date = subject.bounding_dates.max
+      end_date = subject.bounding_dates.max + 2.day
+      expect(subject.validity_out_between?( start_date, end_date)).to be_falsey
+    end
+    it "should be false if calendar is out on end date" do
+      start_date = subject.bounding_dates.max - 2.day
+      end_date = subject.bounding_dates.max
+      expect(subject.validity_out_between?( start_date, end_date)).to be_truthy
+    end
+    it "should be false if calendar is out after start_date" do
+      start_date = subject.bounding_dates.max + 2.day
+      end_date = subject.bounding_dates.max + 4.day
+      expect(subject.validity_out_between?( start_date, end_date)).to be_falsey
+    end
+  end
+  describe "#validity_out_from_on?" do
+    let(:empty_tm) {build(:time_table)}
+    it "should be false if empty calendar" do
+      expect(empty_tm.validity_out_from_on?( Date.today)).to be_falsey
+    end
+    it "should be true if caldendar ends on expected date" do
+      expected_date = subject.bounding_dates.max
+      expect(subject.validity_out_from_on?( expected_date)).to be_truthy
+    end
+    it "should be true if calendar ends before expected date" do
+      expected_date = subject.bounding_dates.max + 30.day
+      expect(subject.validity_out_from_on?( expected_date)).to be_truthy
+    end
+    it "should be false if calendars ends after expected date" do
+      expected_date = subject.bounding_dates.max - 30.day
+      expect(subject.validity_out_from_on?( expected_date)).to be_falsey
+    end
+  end
+  describe "#bounding_dates" do
+    context "when timetable contains only periods" do
+      before do
+        subject.dates = []
+        subject.save
+      end
+      it "should retreive periods.period_start.min and periods.period_end.max" do
+        expect(subject.bounding_dates.min).to eq(subject.periods.map(&:period_start).min)
+        expect(subject.bounding_dates.max).to eq(subject.periods.map(&:period_end).max)
+      end
+    end
+    context "when timetable contains only dates" do
+      before do
+        subject.periods = []
+        subject.save
+      end
+      it "should retreive dates.min and dates.max" do
+        expect(subject.bounding_dates.min).to eq(subject.dates.map(&:date).min)
+        expect(subject.bounding_dates.max).to eq(subject.dates.map(&:date).max)
+      end
+    end
+    it "should contains min date" do
+      min_date = subject.bounding_dates.min
+      subject.dates.each do |tm_date|
+        expect(min_date <= tm_date.date).to be_truthy
+      end
+      subject.periods.each do |tm_period|
+        expect(min_date <= tm_period.period_start).to be_truthy
+      end
+
+    end
+    it "should contains max date" do
+      max_date = subject.bounding_dates.max
+      subject.dates.each do |tm_date|
+        expect(tm_date.date <= max_date).to be_truthy
+      end
+      subject.periods.each do |tm_period|
+        expect(tm_period.period_end <= max_date).to be_truthy
+      end
+
+    end
+  end
+  describe "#periods" do
+    it "should begin with position 0" do
+      expect(subject.periods.first.position).to eq(0)
+    end
+    context "when first period has been removed" do
+      before do
+        subject.periods.first.destroy
+      end
+      it "should begin with position 0" do
+        expect(subject.periods.first.position).to eq(0)
+      end
+    end
+    it "should have period_start before period_end" do
+      period = Chouette::TimeTablePeriod.new
+      period.period_start = Date.today
+      period.period_end = Date.today + 10
+      expect(period.valid?).to be_truthy
+    end
+    it "should not have period_start after period_end" do
+      period = Chouette::TimeTablePeriod.new
+      period.period_start = Date.today
+      period.period_end = Date.today - 10
+      expect(period.valid?).to be_falsey
+    end
+    it "should not have period_start equal to period_end" do
+      period = Chouette::TimeTablePeriod.new
+      period.period_start = Date.today
+      period.period_end = Date.today
+      expect(period.valid?).to be_falsey
+    end
+  end
+
+  describe "#effective_days_of_periods" do
+      before do
+        subject.periods.clear
+        subject.periods << Chouette::TimeTablePeriod.new(
+                              :period_start => Date.new(2014, 6, 30),
+                              :period_end => Date.new(2014, 7, 6))
+        subject.int_day_types = 4|8|16
+      end
+      it "should return monday to wednesday" do
+        expect(subject.effective_days_of_periods.size).to eq(3)
+        expect(subject.effective_days_of_periods[0]).to eq(Date.new(2014, 6, 30))
+        expect(subject.effective_days_of_periods[1]).to eq(Date.new(2014, 7, 1))
+        expect(subject.effective_days_of_periods[2]).to eq(Date.new(2014, 7, 2))
+      end
+      it "should return thursday" do
+        expect(subject.effective_days_of_periods(Chouette::TimeTable.valid_days(32)).size).to eq(1)
+        expect(subject.effective_days_of_periods(Chouette::TimeTable.valid_days(32))[0]).to eq(Date.new(2014, 7, 3))
+      end
+
+  end
+
+  describe "#included_days" do
+      before do
+        subject.dates.clear
+        subject.dates << Chouette::TimeTableDate.new( :date => Date.new(2014,7,16), :in_out => true)
+        subject.dates << Chouette::TimeTableDate.new( :date => Date.new(2014,7,17), :in_out => false)
+        subject.dates << Chouette::TimeTableDate.new( :date => Date.new(2014,7,18), :in_out => true)
+        subject.dates << Chouette::TimeTableDate.new( :date => Date.new(2014,7,19), :in_out => false)
+        subject.dates << Chouette::TimeTableDate.new( :date => Date.new(2014,7,20), :in_out => true)
+      end
+      it "should return 3 dates" do
+        days = subject.included_days
+        expect(days.size).to eq(3)
+        expect(days[0]).to eq(Date.new(2014, 7, 16))
+        expect(days[1]).to eq(Date.new(2014,7, 18))
+        expect(days[2]).to eq(Date.new(2014, 7,20))
+      end
+  end
+
+
+
+  describe "#excluded_days" do
+      before do
+        subject.dates.clear
+        subject.dates << Chouette::TimeTableDate.new( :date => Date.new(2014,7,16), :in_out => true)
+        subject.dates << Chouette::TimeTableDate.new( :date => Date.new(2014,7,17), :in_out => false)
+        subject.dates << Chouette::TimeTableDate.new( :date => Date.new(2014,7,18), :in_out => true)
+        subject.dates << Chouette::TimeTableDate.new( :date => Date.new(2014,7,19), :in_out => false)
+        subject.dates << Chouette::TimeTableDate.new( :date => Date.new(2014,7,20), :in_out => true)
+      end
+      it "should return 3 dates" do
+        days = subject.excluded_days
+        expect(days.size).to eq(2)
+        expect(days[0]).to eq(Date.new(2014, 7, 17))
+        expect(days[1]).to eq(Date.new(2014,7, 19))
+      end
+  end
+
+
+
+  describe "#effective_days" do
+      before do
+        subject.periods.clear
+        subject.periods << Chouette::TimeTablePeriod.new(
+                              :period_start => Date.new(2014, 6, 30),
+                              :period_end => Date.new(2014, 7, 6))
+        subject.int_day_types = 4|8|16
+        subject.dates.clear
+        subject.dates << Chouette::TimeTableDate.new( :date => Date.new(2014,7,1), :in_out => false)
+        subject.dates << Chouette::TimeTableDate.new( :date => Date.new(2014,7,16), :in_out => true)
+        subject.dates << Chouette::TimeTableDate.new( :date => Date.new(2014,7,18), :in_out => true)
+        subject.dates << Chouette::TimeTableDate.new( :date => Date.new(2014,7,20), :in_out => true)
+      end
+      it "should return 5 dates" do
+        days = subject.effective_days
+        expect(days.size).to eq(5)
+        expect(days[0]).to eq(Date.new(2014, 6, 30))
+        expect(days[1]).to eq(Date.new(2014, 7, 2))
+        expect(days[2]).to eq(Date.new(2014, 7, 16))
+        expect(days[3]).to eq(Date.new(2014, 7, 18))
+        expect(days[4]).to eq(Date.new(2014, 7, 20))
+      end
+  end
+
+
+
+  describe "#optimize_periods" do
+      before do
+        subject.periods.clear
+        subject.periods << Chouette::TimeTablePeriod.new(
+                              :period_start => Date.new(2014, 6, 30),
+                              :period_end => Date.new(2014, 7, 6))
+        subject.periods << Chouette::TimeTablePeriod.new(
+                              :period_start => Date.new(2014, 7, 6),
+                              :period_end => Date.new(2014, 7, 14))
+        subject.periods << Chouette::TimeTablePeriod.new(
+                              :period_start => Date.new(2014, 6, 1),
+                              :period_end => Date.new(2014, 6, 14))
+        subject.periods << Chouette::TimeTablePeriod.new(
+                              :period_start => Date.new(2014, 6, 3),
+                              :period_end => Date.new(2014, 6, 4))
+        subject.int_day_types = 4|8|16
+      end
+      it "should return 2 ordered periods" do
+        periods = subject.optimize_periods
+        expect(periods.size).to eq(2)
+        expect(periods[0].period_start).to eq(Date.new(2014, 6, 1))
+        expect(periods[0].period_end).to eq(Date.new(2014, 6, 14))
+        expect(periods[1].period_start).to eq(Date.new(2014, 6, 30))
+        expect(periods[1].period_end).to eq(Date.new(2014, 7, 14))
+      end
+  end
+
+  describe "#add_included_day" do
+      before do
+        subject.dates.clear
+        subject.dates << Chouette::TimeTableDate.new( :date => Date.new(2014,7,16), :in_out => true)
+        subject.dates << Chouette::TimeTableDate.new( :date => Date.new(2014,7,18), :in_out => false)
+        subject.dates << Chouette::TimeTableDate.new( :date => Date.new(2014,7,20), :in_out => true)
+      end
+      it "should do nothing" do
+        subject.add_included_day(Date.new(2014,7,16))
+        days = subject.included_days
+        expect(days.size).to eq(2)
+        expect(days.include?(Date.new(2014,7,16))).to be_truthy
+        expect(days.include?(Date.new(2014,7,18))).to be_falsey
+        expect(days.include?(Date.new(2014,7,20))).to be_truthy
+      end
+      it "should switch in_out flag" do
+        subject.add_included_day(Date.new(2014,7,18))
+        days = subject.included_days
+        expect(days.size).to eq(3)
+        expect(days.include?(Date.new(2014,7,16))).to be_truthy
+        expect(days.include?(Date.new(2014,7,18))).to be_truthy
+        expect(days.include?(Date.new(2014,7,20))).to be_truthy
+      end
+      it "should add date" do
+        subject.add_included_day(Date.new(2014,7,21))
+        days = subject.included_days
+        expect(days.size).to eq(3)
+        expect(days.include?(Date.new(2014,7,16))).to be_truthy
+        expect(days.include?(Date.new(2014,7,20))).to be_truthy
+        expect(days.include?(Date.new(2014,7,21))).to be_truthy
+      end
+  end
+
+
+  describe "#merge!" do
+    context "timetables have periods with common day_types " do
+      before do
+        subject.periods.clear
+        subject.dates.clear
+        subject.periods << Chouette::TimeTablePeriod.new(:period_start => Date.new(2014,8,1), :period_end => Date.new(2014,8,5))
+        subject.periods << Chouette::TimeTablePeriod.new(:period_start => Date.new(2014,6,30), :period_end => Date.new(2014,7,6))
+        subject.dates << Chouette::TimeTableDate.new( :date => Date.new(2014,7,16), :in_out => true)
+        subject.int_day_types = 4|16|32|128
+        another_tt = create(:time_table , :int_day_types => (4|16|64|128) )
+        another_tt.periods.clear
+        another_tt.dates.clear
+        another_tt.periods << Chouette::TimeTablePeriod.new(:period_start => Date.new(2014,8,5), :period_end => Date.new(2014,8,12))
+        another_tt.periods << Chouette::TimeTablePeriod.new(:period_start => Date.new(2014,7,15), :period_end => Date.new(2014,7,25))
+        subject.merge! another_tt
+        subject.reload
+      end
+      it "should have merged periods" do
+        expect(subject.periods.size).to eq(3)
+        expect(subject.periods[0].period_start).to eq(Date.new(2014, 6, 30))
+        expect(subject.periods[0].period_end).to eq(Date.new(2014, 7, 6))
+        expect(subject.periods[1].period_start).to eq(Date.new(2014, 7, 15))
+        expect(subject.periods[1].period_end).to eq(Date.new(2014, 7, 25))
+        expect(subject.periods[2].period_start).to eq(Date.new(2014, 8, 1))
+        expect(subject.periods[2].period_end).to eq(Date.new(2014, 8, 12))
+      end
+      it "should have common day_types" do
+        expect(subject.int_day_types).to eq(4|16|128)
+      end
+      it "should have dates for thursdays and fridays" do
+        expect(subject.dates.size).to eq(4)
+        expect(subject.dates[0].date).to eq(Date.new(2014,7,3))
+        expect(subject.dates[1].date).to eq(Date.new(2014,7,18))
+        expect(subject.dates[2].date).to eq(Date.new(2014,7,25))
+        expect(subject.dates[3].date).to eq(Date.new(2014,8,8))
+      end
+    end
+
+  end
+
+  describe "#intersect!" do
+    context "timetables have periods with common day_types " do
+      before do
+        subject.periods.clear
+        subject.dates.clear
+        subject.periods << Chouette::TimeTablePeriod.new(:period_start => Date.new(2014,8,1), :period_end => Date.new(2014,8,6))
+        subject.periods << Chouette::TimeTablePeriod.new(:period_start => Date.new(2014,6,30), :period_end => Date.new(2014,7,20))
+        subject.dates << Chouette::TimeTableDate.new( :date => Date.new(2014,7,16), :in_out => true)
+        subject.int_day_types = 4|16|32|128
+        another_tt = create(:time_table , :int_day_types => (4|16|64|128) )
+        another_tt.periods.clear
+        another_tt.dates.clear
+        another_tt.periods << Chouette::TimeTablePeriod.new(:period_start => Date.new(2014,8,6), :period_end => Date.new(2014,8,12))
+        another_tt.periods << Chouette::TimeTablePeriod.new(:period_start => Date.new(2014,7,15), :period_end => Date.new(2014,7,25))
+        subject.intersect! another_tt
+        subject.reload
+      end
+      it "should have no period" do
+        expect(subject.periods.size).to eq(0)
+       end
+      it "should have no day_types" do
+        expect(subject.int_day_types).to eq(0)
+      end
+      it "should have date all common days" do
+        expect(subject.dates.size).to eq(3)
+        expect(subject.dates[0].date).to eq(Date.new(2014,7,16))
+        expect(subject.dates[1].date).to eq(Date.new(2014,7,19))
+        expect(subject.dates[2].date).to eq(Date.new(2014,8,6))
+      end
+    end
+    context "timetables have periods or dates " do
+      before do
+        subject.periods.clear
+        subject.dates.clear
+        subject.dates << Chouette::TimeTableDate.new( :date => Date.new(2014,7,16), :in_out => true)
+        subject.dates << Chouette::TimeTableDate.new( :date => Date.new(2014,7,17), :in_out => true)
+        subject.dates << Chouette::TimeTableDate.new( :date => Date.new(2014,7,18), :in_out => true)
+        subject.dates << Chouette::TimeTableDate.new( :date => Date.new(2014,7,19), :in_out => true)
+        subject.dates << Chouette::TimeTableDate.new( :date => Date.new(2014,7,20), :in_out => true)
+        subject.int_day_types = 0
+        another_tt = create(:time_table , :int_day_types => (4|16|64|128) )
+        another_tt.periods.clear
+        another_tt.dates.clear
+        another_tt.periods << Chouette::TimeTablePeriod.new(:period_start => Date.new(2014,8,6), :period_end => Date.new(2014,8,12))
+        another_tt.periods << Chouette::TimeTablePeriod.new(:period_start => Date.new(2014,7,17), :period_end => Date.new(2014,7,25))
+        subject.intersect! another_tt
+        subject.reload
+      end
+      it "should have 0 period" do
+        expect(subject.periods.size).to eq(0)
+      end
+      it "should have no day_types" do
+        expect(subject.int_day_types).to eq(0)
+      end
+      it "should have date reduced for period" do
+        expect(subject.dates.size).to eq(2)
+        expect(subject.dates[0].date).to eq(Date.new(2014,7,18))
+        expect(subject.dates[1].date).to eq(Date.new(2014,7,19))
+      end
+    end
+    context "with only periods : intersect timetable have no one day period" do
+      before do
+        subject.periods.clear
+        subject.dates.clear
+        subject.periods << Chouette::TimeTablePeriod.new(:period_start => Date.new(2014,8,1), :period_end => Date.new(2014,8,6))
+        subject.int_day_types = 4|8|16
+        another_tt = create(:time_table , :int_day_types => (4|8|16) )
+        another_tt.periods.clear
+        another_tt.dates.clear
+        another_tt.periods << Chouette::TimeTablePeriod.new(:period_start => Date.new(2014,8,6), :period_end => Date.new(2014,8,12))
+        subject.intersect! another_tt
+        subject.reload
+      end
+      it "should have 0 result periods" do
+        expect(subject.periods.size).to eq(0)
+      end
+      it "should have no day_types" do
+        expect(subject.int_day_types).to eq(0)
+      end
+      it "should have 1 date " do
+        expect(subject.dates.size).to eq(1)
+        expect(subject.dates[0].date).to eq(Date.new(2014,8,6))
+      end
+    end
+
+  end
+
+  describe "#disjoin!" do
+    context "timetables have periods with common day_types " do
+      before do
+        subject.periods.clear
+        subject.dates.clear
+        subject.periods << Chouette::TimeTablePeriod.new(:period_start => Date.new(2014,8,1), :period_end => Date.new(2014,8,6))
+        subject.periods << Chouette::TimeTablePeriod.new(:period_start => Date.new(2014,6,30), :period_end => Date.new(2014,7,20))
+        subject.int_day_types = 4|16|32|128
+        another_tt = create(:time_table , :int_day_types => (4|16|64|128) )
+        another_tt.periods.clear
+        another_tt.dates.clear
+        another_tt.periods << Chouette::TimeTablePeriod.new(:period_start => Date.new(2014,8,6), :period_end => Date.new(2014,8,12))
+        another_tt.periods << Chouette::TimeTablePeriod.new(:period_start => Date.new(2014,7,15), :period_end => Date.new(2014,8,2))
+        subject.disjoin! another_tt
+        subject.reload
+      end
+      it "should have 0 periods" do
+        expect(subject.periods.size).to eq(0)
+       end
+      it "should have 0 day_types" do
+        expect(subject.int_day_types).to eq(0)
+      end
+      it "should have only dates " do
+        expect(subject.dates.size).to eq(11)
+        expect(subject.dates[0].date).to eq(Date.new(2014,6,30))
+        expect(subject.dates[1].date).to eq(Date.new(2014,7,2))
+        expect(subject.dates[2].date).to eq(Date.new(2014,7,3))
+        expect(subject.dates[3].date).to eq(Date.new(2014,7,5))
+        expect(subject.dates[4].date).to eq(Date.new(2014,7,7))
+        expect(subject.dates[5].date).to eq(Date.new(2014,7,9))
+        expect(subject.dates[6].date).to eq(Date.new(2014,7,10))
+        expect(subject.dates[7].date).to eq(Date.new(2014,7,12))
+        expect(subject.dates[8].date).to eq(Date.new(2014,7,14))
+        expect(subject.dates[9].date).to eq(Date.new(2014,7,17))
+        expect(subject.dates[10].date).to eq(Date.new(2014,8,4))
+      end
+    end
+    context "timetables have periods or dates " do
+      before do
+        subject.periods.clear
+        subject.dates.clear
+        subject.dates << Chouette::TimeTableDate.new( :date => Date.new(2014,7,16), :in_out => true)
+        subject.dates << Chouette::TimeTableDate.new( :date => Date.new(2014,7,17), :in_out => true)
+        subject.dates << Chouette::TimeTableDate.new( :date => Date.new(2014,7,18), :in_out => true)
+        subject.dates << Chouette::TimeTableDate.new( :date => Date.new(2014,7,19), :in_out => true)
+        subject.dates << Chouette::TimeTableDate.new( :date => Date.new(2014,7,20), :in_out => true)
+        subject.dates << Chouette::TimeTableDate.new( :date => Date.new(2014,8,6), :in_out => true)
+        subject.dates << Chouette::TimeTableDate.new( :date => Date.new(2014,8,7), :in_out => true)
+        subject.int_day_types = 0
+        another_tt = create(:time_table , :int_day_types => (4|16|64|128) )
+        another_tt.periods.clear
+        another_tt.dates.clear
+        another_tt.periods << Chouette::TimeTablePeriod.new(:period_start => Date.new(2014,8,6), :period_end => Date.new(2014,8,12))
+        another_tt.periods << Chouette::TimeTablePeriod.new(:period_start => Date.new(2014,7,17), :period_end => Date.new(2014,7,25))
+        subject.disjoin! another_tt
+        subject.reload
+      end
+      it "should have 0 period" do
+        expect(subject.periods.size).to eq(0)
+      end
+      it "should have no remained day_types" do
+        expect(subject.int_day_types).to eq(0)
+      end
+      it "should have date reduced for period" do
+        expect(subject.dates.size).to eq(4)
+        expect(subject.dates[0].date).to eq(Date.new(2014,7,16))
+        expect(subject.dates[1].date).to eq(Date.new(2014,7,17))
+        expect(subject.dates[2].date).to eq(Date.new(2014,7,20))
+        expect(subject.dates[3].date).to eq(Date.new(2014,8,7))
+      end
+    end
+    context "disjoined timetable have all periods in removed ones " do
+      before do
+        subject.periods.clear
+        subject.dates.clear
+        subject.periods << Chouette::TimeTablePeriod.new(:period_start => Date.new(2014,8,1), :period_end => Date.new(2014,8,8))
+        subject.periods << Chouette::TimeTablePeriod.new(:period_start => Date.new(2014,6,30), :period_end => Date.new(2014,7,20))
+        subject.int_day_types = 4|16|32|128
+        another_tt = create(:time_table , :int_day_types => (4|16|64|128) )
+        another_tt.periods.clear
+        another_tt.dates.clear
+        another_tt.periods << Chouette::TimeTablePeriod.new(:period_start => Date.new(2014,7,31), :period_end => Date.new(2014,8,12))
+        another_tt.periods << Chouette::TimeTablePeriod.new(:period_start => Date.new(2014,6,30), :period_end => Date.new(2014,7,20))
+        subject.disjoin! another_tt
+        subject.reload
+      end
+      it "should have 0 result periods" do
+        expect(subject.periods.size).to eq(0)
+      end
+      it "should have no remained day_types" do
+        expect(subject.int_day_types).to eq(0)
+      end
+      it "should have dates for period reduced" do
+        expect(subject.dates.size).to eq(4)
+        expect(subject.dates[0].date).to eq(Date.new(2014,7,3))
+        expect(subject.dates[1].date).to eq(Date.new(2014,7,10))
+        expect(subject.dates[2].date).to eq(Date.new(2014,7,17))
+        expect(subject.dates[3].date).to eq(Date.new(2014,8,7))
+      end
+    end
+
+    context "timetable with dates against timetable with dates and periods" do
+      before do
+        subject.periods.clear
+        subject.dates.clear
+        subject.dates << Chouette::TimeTableDate.new( :date => Date.new(2014,7,16), :in_out => true)
+        subject.dates << Chouette::TimeTableDate.new( :date => Date.new(2014,7,17), :in_out => true)
+        subject.dates << Chouette::TimeTableDate.new( :date => Date.new(2014,7,18), :in_out => true)
+        subject.dates << Chouette::TimeTableDate.new( :date => Date.new(2014,7,19), :in_out => true)
+        subject.dates << Chouette::TimeTableDate.new( :date => Date.new(2014,7,20), :in_out => true)
+        subject.int_day_types = 0
+        another_tt = create(:time_table , :int_day_types => (4|16|64|128) )
+        another_tt.periods.clear
+        another_tt.dates.clear
+        another_tt.periods << Chouette::TimeTablePeriod.new(:period_start => Date.new(2014,7,31), :period_end => Date.new(2014,8,12))
+        another_tt.dates << Chouette::TimeTableDate.new( :date => Date.new(2014,7,17), :in_out => true)
+        another_tt.dates << Chouette::TimeTableDate.new( :date => Date.new(2014,7,18), :in_out => true)
+        subject.disjoin! another_tt
+        subject.reload
+      end
+      it "should have 0 result periods" do
+        expect(subject.periods.size).to eq(0)
+      end
+      it "should have no remained day_types" do
+        subject.int_day_types == 0
+      end
+      it "should have 3 dates left" do
+        expect(subject.dates.size).to eq(3)
+        expect(subject.dates[0].date).to eq(Date.new(2014,7,16))
+        expect(subject.dates[1].date).to eq(Date.new(2014,7,19))
+        expect(subject.dates[2].date).to eq(Date.new(2014,7,20))
+      end
+    end
+    context "timetable with dates against timetable with dates and periods all covered" do
+      before do
+        subject.periods.clear
+        subject.dates.clear
+        subject.dates << Chouette::TimeTableDate.new( :date => Date.new(2014,7,1), :in_out => true)
+        subject.dates << Chouette::TimeTableDate.new( :date => Date.new(2014,7,2), :in_out => true)
+        subject.dates << Chouette::TimeTableDate.new( :date => Date.new(2014,7,5), :in_out => true)
+        subject.dates << Chouette::TimeTableDate.new( :date => Date.new(2014,7,6), :in_out => true)
+        subject.int_day_types = 512
+        another_tt = create(:time_table , :int_day_types => (32|64|512) )
+        another_tt.periods.clear
+        another_tt.dates.clear
+        another_tt.periods << Chouette::TimeTablePeriod.new(:period_start => Date.new(2014,6,30), :period_end => Date.new(2014,7,11))
+        another_tt.dates << Chouette::TimeTableDate.new( :date => Date.new(2014,7,1), :in_out => true)
+        another_tt.dates << Chouette::TimeTableDate.new( :date => Date.new(2014,7,2), :in_out => true)
+        another_tt.dates << Chouette::TimeTableDate.new( :date => Date.new(2014,7,5), :in_out => true)
+        another_tt.dates << Chouette::TimeTableDate.new( :date => Date.new(2014,7,6), :in_out => true)
+        subject.disjoin! another_tt
+        subject.reload
+      end
+      it "should have 0 result periods" do
+        expect(subject.periods.size).to eq(0)
+      end
+      it "should have no remained day_types" do
+        subject.int_day_types == 0
+      end
+      it "should have 0 dates left" do
+        expect(subject.dates.size).to eq(0)
+      end
+    end
+
+    context "with only periods : disjoined timetable have no empty period" do
+      before do
+        subject.periods.clear
+        subject.dates.clear
+        subject.periods << Chouette::TimeTablePeriod.new(:period_start => Date.new(2014,8,1), :period_end => Date.new(2014,8,8))
+        subject.periods << Chouette::TimeTablePeriod.new(:period_start => Date.new(2014,8,10), :period_end => Date.new(2014,8,31))
+        subject.int_day_types = 4|8
+        another_tt = create(:time_table , :int_day_types => (4|8) )
+        another_tt.periods.clear
+        another_tt.dates.clear
+        another_tt.periods << Chouette::TimeTablePeriod.new(:period_start => Date.new(2014,8,4), :period_end => Date.new(2014,8,7))
+        subject.disjoin! another_tt
+        subject.reload
+      end
+      it "should have 0 result periods" do
+        expect(subject.periods.size).to eq(0)
+      end
+      it "should have 0 day_types" do
+        expect(subject.int_day_types).to eq(0)
+      end
+      it "should have 6 dates " do
+        expect(subject.dates.size).to eq(6)
+        expect(subject.dates[0].date).to eq(Date.new(2014,8,11))
+        expect(subject.dates[1].date).to eq(Date.new(2014,8,12))
+        expect(subject.dates[2].date).to eq(Date.new(2014,8,18))
+        expect(subject.dates[3].date).to eq(Date.new(2014,8,19))
+        expect(subject.dates[4].date).to eq(Date.new(2014,8,25))
+        expect(subject.dates[5].date).to eq(Date.new(2014,8,26))
+      end
+    end
+
+    context "with only periods : disjoined timetable have no one day period" do
+      before do
+        subject.periods.clear
+        subject.dates.clear
+        subject.periods << Chouette::TimeTablePeriod.new(:period_start => Date.new(2014,8,1), :period_end => Date.new(2014,8,6))
+        subject.periods << Chouette::TimeTablePeriod.new(:period_start => Date.new(2014,8,10), :period_end => Date.new(2014,8,31))
+        subject.int_day_types = 4|8|16
+        another_tt = create(:time_table , :int_day_types => (4|8) )
+        another_tt.periods.clear
+        another_tt.dates.clear
+        another_tt.periods << Chouette::TimeTablePeriod.new(:period_start => Date.new(2014,8,4), :period_end => Date.new(2014,8,5))
+        subject.disjoin! another_tt
+        subject.reload
+      end
+      it "should have 0 result periods" do
+        expect(subject.periods.size).to eq(0)
+     end
+      it "should have 0 day_types" do
+        expect(subject.int_day_types).to eq(0)
+      end
+      it "should have 10 dates " do
+        expect(subject.dates.size).to eq(10)
+        expect(subject.dates[0].date).to eq(Date.new(2014,8,6))
+        expect(subject.dates[1].date).to eq(Date.new(2014,8,11))
+        expect(subject.dates[2].date).to eq(Date.new(2014,8,12))
+        expect(subject.dates[3].date).to eq(Date.new(2014,8,13))
+        expect(subject.dates[4].date).to eq(Date.new(2014,8,18))
+        expect(subject.dates[5].date).to eq(Date.new(2014,8,19))
+        expect(subject.dates[6].date).to eq(Date.new(2014,8,20))
+        expect(subject.dates[7].date).to eq(Date.new(2014,8,25))
+        expect(subject.dates[8].date).to eq(Date.new(2014,8,26))
+        expect(subject.dates[9].date).to eq(Date.new(2014,8,27))
+      end
+    end
+
+    context "with periods against dates: disjoined timetable have no unused excluded date" do
+      before do
+        subject.periods.clear
+        subject.dates.clear
+        subject.periods << Chouette::TimeTablePeriod.new(:period_start => Date.new(2014,8,1), :period_end => Date.new(2014,8,8))
+        subject.periods << Chouette::TimeTablePeriod.new(:period_start => Date.new(2014,8,10), :period_end => Date.new(2014,8,31))
+        subject.int_day_types = 4|8|16
+        another_tt = create(:time_table , :int_day_types => (0) )
+        another_tt.periods.clear
+        another_tt.dates.clear
+        another_tt.dates << Chouette::TimeTableDate.new( :date => Date.new(2014,8,4), :in_out => true)
+        another_tt.dates << Chouette::TimeTableDate.new( :date => Date.new(2014,8,5), :in_out => true)
+        another_tt.dates << Chouette::TimeTableDate.new( :date => Date.new(2014,8,7), :in_out => true)
+        subject.disjoin! another_tt
+        subject.reload
+      end
+      it "should have same 0 result periods" do
+        expect(subject.periods.size).to eq(0)
+      end
+      it "should have 0 day_types" do
+        expect(subject.int_day_types).to eq(0)
+      end
+      it "should have only 10 dates " do
+        expect(subject.dates.size).to eq(10)
+        expect(subject.dates[0].date).to eq(Date.new(2014,8,6))
+        expect(subject.dates[1].date).to eq(Date.new(2014,8,11))
+        expect(subject.dates[2].date).to eq(Date.new(2014,8,12))
+        expect(subject.dates[3].date).to eq(Date.new(2014,8,13))
+        expect(subject.dates[4].date).to eq(Date.new(2014,8,18))
+        expect(subject.dates[5].date).to eq(Date.new(2014,8,19))
+        expect(subject.dates[6].date).to eq(Date.new(2014,8,20))
+        expect(subject.dates[7].date).to eq(Date.new(2014,8,25))
+        expect(subject.dates[8].date).to eq(Date.new(2014,8,26))
+        expect(subject.dates[9].date).to eq(Date.new(2014,8,27))
+      end
+    end
+  
+  
+    context "with same definition : dsjointed timetable should be empty" do
+      before do
+        subject.periods.clear
+        subject.dates.clear
+        subject.periods << Chouette::TimeTablePeriod.new(:period_start => Date.new(2015,6,1), :period_end => Date.new(2015,6,30))
+        subject.dates << Chouette::TimeTableDate.new( :date => Date.new(2015,6,16), :in_out => true)
+        subject.dates << Chouette::TimeTableDate.new( :date => Date.new(2015,6,22), :in_out => false)
+        subject.int_day_types = 4|8|16|32|64|128|256
+        another_tt = create(:time_table , :int_day_types => ( 4|8|16|32|64|128|256) )
+        another_tt.periods.clear
+        another_tt.dates.clear
+        another_tt.periods << Chouette::TimeTablePeriod.new(:period_start => Date.new(2015,6,1), :period_end => Date.new(2015,6,30))
+        another_tt.dates << Chouette::TimeTableDate.new( :date => Date.new(2015,6,16), :in_out => true)
+        another_tt.dates << Chouette::TimeTableDate.new( :date => Date.new(2015,6,22), :in_out => false)
+        subject.disjoin! another_tt
+        subject.reload
+      end
+      it "should have same 0 result periods" do
+        expect(subject.periods.size).to eq(0)
+      end
+      it "should have 0 day_types" do
+        expect(subject.int_day_types).to eq(0)
+      end
+      it "should have 0 dates " do
+        expect(subject.dates.size).to eq(0)
+      end
+    end
+  end
+
+  describe "#duplicate" do
+      it "should be a copy of" do
+        target=subject.duplicate
+        expect(target.id).to be_nil
+        expect(target.comment).to eq("Copy of "+subject.comment)
+        expect(target.objectid).to eq(subject.objectid+"_1")
+        expect(target.int_day_types).to eq(subject.int_day_types)
+        expect(target.dates.size).to eq(subject.dates.size)
+        target.dates.each do |d|
+          expect(d.time_table_id).to be_nil
+        end
+        expect(target.periods.size).to eq(subject.periods.size)
+        target.periods.each do |p|
+          expect(p.time_table_id).to be_nil
+        end
+      end
+  end
+
+  describe "#tags" do
+      it "should accept tags" do
+        subject.tag_list = "toto, titi"
+        subject.save
+        subject.reload
+        expect(Chouette::TimeTable.tag_counts.size).to eq(2)
+        expect(subject.tag_list.size).to eq(2)
+      end
+  end
+
+end