ninoxe 0.1.6 → 1.0.0

data/spec/models/chouette/time_table_spec.rb

@@ -1,372 +0,0 @@
-require 'spec_helper'
-
-describe Chouette::TimeTable do
-
-  subject { Factory(:time_table) }
-
-  it { should validate_presence_of :comment }
-  it { should 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
-        subject.periods_max_date.should == Date.strptime("04/15/2013", '%m/%d/%Y')
-      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
-          subject.periods_max_date.should == 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
-          subject.periods_max_date.should == 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 !
-          subject.periods_max_date.should be_nil
-        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
-        subject.periods_min_date.should == Date.strptime("04/10/2013", '%m/%d/%Y')
-      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
-          subject.periods_min_date.should == 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
-          subject.periods_min_date.should == 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 !
-          subject.periods_min_date.should 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
-      period.period_start.should be_nil
-      period.period_end.should 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
-        subject.start_date.should == subject.bounding_dates.min
-        subject.end_date.should == 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]
-      end
-      def read_tm
-        Chouette::TimeTable.find subject.id
-      end
-      it "should update shortcut" do
-        tm = read_tm
-        subject.start_date.should == subject.bounding_dates.min
-        subject.start_date.should == tm.bounding_dates.min
-        subject.start_date.should == 4.days.since.to_date
-        subject.end_date.should == subject.bounding_dates.max
-        subject.end_date.should == tm.bounding_dates.max
-        subject.end_date.should == 6.days.since.to_date
-      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))
-        subject.save
-      end
-      it "should update shortcut" do
-        subject.start_date.should == subject.bounding_dates.min
-        subject.end_date.should == 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]
-      end
-      it "should update shortcut" do
-        subject.start_date.should == subject.bounding_dates.min
-        subject.end_date.should == subject.bounding_dates.max
-      end
-    end
-    context "when all the dates and periods are removed," do
-      before(:each) do
-        subject.periods = []
-        subject.dates = []
-      end
-      it "should update shortcut" do
-        subject.start_date.should be_nil
-        subject.end_date.should be_nil
-      end
-    end
-  end
-
-  describe "#valid_days" do
-    it "should begin with position 0" do
-      subject.int_day_types = 128
-      subject.valid_days.should == [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_date = Factory(:time_table_date, :date => Date.today, :time_table_id => time_table.id)
-      time_table.intersects([Date.today]).should == [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_period = Factory(:time_table_period, :period_start => Date.new(2013, 05, 27),:period_end =>  Date.new(2013, 05, 30), :time_table_id => time_table.id)
-      time_table.intersects([ Date.new(2013, 05, 29),  Date.new(2013, 05, 30)]).should == []
-    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_period = Factory(:time_table_period, :period_start => Date.new(2013, 05, 27),:period_end =>  Date.new(2013, 05, 30), :time_table_id => time_table.id)
-      time_table.intersects([ Date.new(2013, 05, 27),  Date.new(2013, 05, 28)]).should == [ 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_date = Factory(:time_table_date, :date => Date.today, :time_table_id => time_table.id)
-      time_table.include_day?(Date.today).should == 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_period = Factory(:time_table_period, :period_start => Date.new(2013, 05, 27),:period_end =>  Date.new(2013, 05, 29), :time_table_id => time_table.id)
-      time_table.include_day?( Date.new(2013, 05, 27)).should == 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_date = Factory(:time_table_date, :date => Date.today, :time_table_id => time_table.id)
-      time_table.include_in_dates?(Date.today).should == true
-    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_period = Factory(:time_table_period, :period_start => Date.new(2012, 1, 1),:period_end => Date.new(2012, 01, 30), :time_table_id => time_table.id)
-      time_table.include_in_periods?(Date.new(2012, 1, 2)).should == true
-    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_period = Factory(:time_table_period, :period_start => Date.new(2012, 1, 1),:period_end => Date.new(2012, 01, 30), :time_table_id => time_table.id)
-      time_table_date = Factory(:time_table_date, :date => Date.new(2012, 1, 2), :time_table_id => time_table.id)
-      time_table.include_in_overlap_dates?(Date.new(2012, 1, 2)).should == true      
-    end
-  end
-
-  describe "#dates" do
-    it "should have with position 0" do
-      subject.dates.first.position.should == 0
-    end
-    context "when first date has been removed" do
-      before do
-        subject.dates.first.destroy
-      end
-      it "should begin with position 0" do
-        subject.dates.first.position.should == 0
-      end
-    end
-  end
-  describe "#validity_out_between?" do
-    let(:empty_tm) {Factory.build(:time_table)}
-    it "should be false if empty calendar" do
-      empty_tm.validity_out_between?( Date.today, Date.today + 7.day).should be_false
-    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
-      subject.validity_out_between?( start_date, end_date).should be_true
-    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
-      subject.validity_out_between?( start_date, end_date).should be_false
-    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 
-      subject.validity_out_between?( start_date, end_date).should be_true
-    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
-      subject.validity_out_between?( start_date, end_date).should be_false
-    end
-  end
-  describe "#validity_out_from_on?" do
-    let(:empty_tm) {Factory.build(:time_table)}
-    it "should be false if empty calendar" do
-      empty_tm.validity_out_from_on?( Date.today).should be_false
-    end
-    it "should be true if caldendar ends on expected date" do
-      expected_date = subject.bounding_dates.max
-      subject.validity_out_from_on?( expected_date).should be_true
-    end
-    it "should be true if calendar ends before expected date" do
-      expected_date = subject.bounding_dates.max + 30.day
-      subject.validity_out_from_on?( expected_date).should be_true
-    end
-    it "should be false if calendars ends after expected date" do
-      expected_date = subject.bounding_dates.max - 30.day
-      subject.validity_out_from_on?( expected_date).should be_false
-    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
-        subject.bounding_dates.min.should == subject.periods.map(&:period_start).min
-        subject.bounding_dates.max.should == 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
-        subject.bounding_dates.min.should == subject.dates.map(&:date).min
-        subject.bounding_dates.max.should == 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|
-        (min_date <= tm_date.date).should be_true
-      end
-      subject.periods.each do |tm_period|
-        (min_date <= tm_period.period_start).should be_true
-      end
-
-    end
-    it "should contains max date" do
-      max_date = subject.bounding_dates.max
-      subject.dates.each do |tm_date|
-        (tm_date.date <= max_date).should be_true
-      end
-      subject.periods.each do |tm_period|
-        (tm_period.period_end <= max_date).should be_true
-      end
-
-    end
-  end
-  describe "#periods" do
-    it "should begin with position 0" do
-      subject.periods.first.position.should == 0
-    end
-    context "when first period has been removed" do
-      before do
-        subject.periods.first.destroy
-      end
-      it "should begin with position 0" do
-        subject.periods.first.position.should == 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
-      period.valid?.should be_true
-    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
-      period.valid?.should be_false
-    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
-      period.valid?.should be_false
-    end  
-  end
-
-end

data/spec/models/chouette/transport_mode_spec.rb

@@ -1,64 +0,0 @@
-require 'spec_helper'
-
-describe Chouette::TransportMode do
-  
-  def mode(text_code = "test", numerical_code = nil)
-    numerical_code ||= 1 if text_code == "test"
-    Chouette::TransportMode.new(text_code, numerical_code)
-  end
-
-  describe "#to_i" do
-    
-    it "should return numerical code" do
-      mode("test", 1).to_i.should == 1
-    end
-
-  end
-
-  it "should return true to #test? when text code is 'test'" do
-    mode("test").should be_test
-  end
-
-  it "should be equal when text codes are identical" do
-    mode("test",1).should == mode("test", 2)
-  end
-
-  describe ".new" do
-
-    it "should find numerical code from text code" do
-      mode("unknown").to_i.should == 0
-    end
-
-    it "should find text code from numerical code" do
-      mode(0).should be_unknown
-    end
-
-    it "should accept another mode" do
-      Chouette::TransportMode.new(mode("test")).should == mode("test")
-    end
-    
-  end
-
-  describe "#public_transport?" do
-    
-    it "should return false for interchange" do
-      mode("interchange").should_not be_public_transport
-    end
-
-    it "should return true for other modes" do
-      mode("unknown").should be_public_transport
-    end
-
-  end
-
-  describe ".all" do
-    
-    Chouette::TransportMode.definitions.each do |text_code, numerical_code|
-      it "should include a TransportMode #{text_code}" do
-        Chouette::TransportMode.all.should include(Chouette::TransportMode.new(text_code))
-      end
-    end
-
-  end
-
-end

data/spec/models/chouette/vehicle_journey_at_stop_spec.rb

@@ -1,46 +0,0 @@
-require 'spec_helper'
-
-describe Chouette::VehicleJourneyAtStop do
-  let!(:vehicle_journey){ Factory(:vehicle_journey_odd)}
-  subject { vehicle_journey.vehicle_journey_at_stops.first }
-
-  describe "#exceeds_gap?" do
-    it "should return false if gap < 1.hour" do
-      t1 = 1.minutes.ago
-      t2 = 1.minutes.ago + 3.hour
-      subject.exceeds_gap?(t1, t2).should be_true
-    end
-    it "should return false if gap > 2.hour" do
-      t1 = 1.minutes.ago
-      t2 = 1.minutes.ago + 3.minutes
-      subject.exceeds_gap?(t1, t2).should be_false
-    end
-  end
-
-  describe "#increasing_times_validate" do
-    let(:vjas1){ vehicle_journey.vehicle_journey_at_stops[0]}
-    let(:vjas2){ vehicle_journey.vehicle_journey_at_stops[1]}
-    context "when vjas#arrival_time exceeds gap" do
-      it "should add errors on arrival_time" do
-        vjas1.arrival_time = vjas2.arrival_time - 3.hour
-        vjas2.increasing_times_validate(vjas1).should be_false
-        vjas2.errors.should_not be_empty
-        vjas2.errors[:arrival_time].should_not be_blank
-      end
-    end
-    context "when vjas#departure_time exceeds gap" do
-      it "should add errors on departure_time" do
-        vjas1.departure_time = vjas2.departure_time - 3.hour
-        vjas2.increasing_times_validate(vjas1).should be_false
-        vjas2.errors.should_not be_empty
-        vjas2.errors[:departure_time].should_not be_blank
-      end
-    end
-    context "when vjas does'nt exceed gap" do
-      it "should not add errors" do
-        vjas2.increasing_times_validate(vjas1).should be_true
-        vjas2.errors.should be_empty
-      end
-    end
-  end
-end 

data/spec/models/chouette/vehicle_journey_spec.rb

@@ -1,204 +0,0 @@
-require 'spec_helper'
-
-describe Chouette::VehicleJourney do
-  subject { Factory(:vehicle_journey_odd) }
-
-  describe "in_relation_to_a_journey_pattern methods" do
-    let!(:route) { Factory(:route)}
-    let!(:journey_pattern) { Factory(:journey_pattern, :route => route)}
-    let!(:journey_pattern_odd) { Factory(:journey_pattern_odd, :route => route)}
-    let!(:journey_pattern_even) { Factory(:journey_pattern_even, :route => route)}
-
-    context "when vehicle_journey is on odd stop whereas selected journey_pattern is on all stops" do
-      subject { Factory(:vehicle_journey, :route => route, :journey_pattern => journey_pattern_odd)}
-      describe "#extra_stops_in_relation_to_a_journey_pattern" do
-        it "should be empty" do
-          subject.extra_stops_in_relation_to_a_journey_pattern( journey_pattern).should be_empty
-        end
-      end
-      describe "#extra_vjas_in_relation_to_a_journey_pattern" do
-        it "should be empty" do
-          subject.extra_vjas_in_relation_to_a_journey_pattern( journey_pattern).should be_empty
-        end
-      end
-      describe "#missing_stops_in_relation_to_a_journey_pattern" do
-        it "should return even stops" do
-          result = subject.missing_stops_in_relation_to_a_journey_pattern( journey_pattern)
-          result.should == journey_pattern_even.stop_points
-        end
-      end
-      describe "#update_journey_pattern" do
-        it "should new_record for added vjas" do
-          subject.update_journey_pattern( journey_pattern)
-          subject.vehicle_journey_at_stops.select{ |vjas| vjas.new_record? }.each do |vjas|
-            journey_pattern_even.stop_points.should include( vjas.stop_point)
-          end
-        end
-        it "should add vjas on each even stops" do
-          subject.update_journey_pattern( journey_pattern)
-          vehicle_stops = subject.vehicle_journey_at_stops.map(&:stop_point)
-          journey_pattern_even.stop_points.each do |sp|
-            vehicle_stops.should include(sp)
-          end
-        end
-        it "should not mark any vjas as _destroy" do
-          subject.update_journey_pattern( journey_pattern)
-          subject.vehicle_journey_at_stops.any?{ |vjas| vjas._destroy }.should be_false
-        end
-      end
-    end
-    context "when vehicle_journey is on all stops whereas selected journey_pattern is on odd stops" do
-      subject { Factory(:vehicle_journey, :route => route, :journey_pattern => journey_pattern)}
-      describe "#missing_stops_in_relation_to_a_journey_pattern" do
-        it "should be empty" do
-          subject.missing_stops_in_relation_to_a_journey_pattern( journey_pattern_odd).should be_empty
-        end
-      end
-      describe "#extra_stops_in_relation_to_a_journey_pattern" do
-        it "should return even stops" do
-          result = subject.extra_stops_in_relation_to_a_journey_pattern( journey_pattern_odd)
-          result.should == journey_pattern_even.stop_points
-        end
-      end
-      describe "#extra_vjas_in_relation_to_a_journey_pattern" do
-        it "should return vjas on even stops" do
-          result = subject.extra_vjas_in_relation_to_a_journey_pattern( journey_pattern_odd)
-          result.map(&:stop_point).should == journey_pattern_even.stop_points
-        end
-      end
-      describe "#update_journey_pattern" do
-        it "should add no new vjas" do
-          subject.update_journey_pattern( journey_pattern_odd)
-          subject.vehicle_journey_at_stops.any?{ |vjas| vjas.new_record? }.should be_false
-        end
-        it "should mark vehicle_journey_at_stops as _destroy on even stops" do
-          subject.update_journey_pattern( journey_pattern_odd)
-          subject.vehicle_journey_at_stops.each { |vjas| 
-            vjas._destroy.should == journey_pattern_even.stop_points.include?(vjas.stop_point) 
-          }
-        end
-      end
-    end
-
-  end
-  context "when following departure times exceeds gap" do
-    describe "#increasing_times" do
-      before(:each) do
-        subject.vehicle_journey_at_stops[0].departure_time = subject.vehicle_journey_at_stops[1].departure_time - 2.hour
-        subject.vehicle_journey_at_stops[0].arrival_time = subject.vehicle_journey_at_stops[0].departure_time
-        subject.vehicle_journey_at_stops[1].arrival_time = subject.vehicle_journey_at_stops[1].departure_time
-      end
-      it "should make instance invalid" do
-        subject.increasing_times
-        subject.vehicle_journey_at_stops[1].errors[:departure_time].should_not be_blank
-        subject.should_not be_valid
-      end
-    end
-    describe "#update_attributes" do
-      let!(:params){ {"vehicle_journey_at_stops_attributes" => {
-            "0"=>{"id" => subject.vehicle_journey_at_stops[0].id ,"arrival_time" => 1.minutes.ago,"departure_time" => 1.minutes.ago},
-            "1"=>{"id" => subject.vehicle_journey_at_stops[1].id, "arrival_time" => (1.minutes.ago + 2.hour),"departure_time" => (1.minutes.ago + 2.hour)}
-         }}}
-      it "should return false" do
-        subject.update_attributes(params).should be_false
-      end
-      it "should make instance invalid" do
-        subject.update_attributes(params)
-        subject.should_not be_valid
-      end
-      it "should let first vjas without any errors" do
-        subject.update_attributes(params)
-        subject.vehicle_journey_at_stops[0].errors.should be_empty
-      end
-      it "should add an error on second vjas" do
-        subject.update_attributes(params)
-        subject.vehicle_journey_at_stops[1].errors[:departure_time].should_not be_blank
-      end
-    end
-  end
-
-  context "#time_table_tokens=" do
-    let!(:tm1){Factory(:time_table, :comment => "TM1")}
-    let!(:tm2){Factory(:time_table, :comment => "TM2")}
-
-    it "should return associated time table ids" do
-      subject.update_attributes :time_table_tokens => [tm1.id, tm2.id].join(',')
-      subject.time_tables.should include( tm1)
-      subject.time_tables.should include( tm2)
-    end
-  end
-  describe "#bounding_dates" do
-    before(:each) do
-      tm1 = Factory.build(:time_table, :dates => 
-        [ Factory.build(:time_table_date, :date => 1.days.ago.to_date),
-          Factory.build(:time_table_date, :date => 2.days.ago.to_date)])
-      tm2 = Factory.build(:time_table, :periods =>
-        [ Factory.build(:time_table_period, :period_start => 4.days.ago.to_date, :period_end => 3.days.ago.to_date)])
-      tm3 = Factory.build(:time_table)
-      subject.time_tables = [ tm1, tm2, tm3]
-    end
-    it "should return min date from associated calendars" do
-      subject.bounding_dates.min.should == 4.days.ago.to_date
-    end
-    it "should return max date from associated calendars" do
-      subject.bounding_dates.max.should == 1.days.ago.to_date
-    end
-  end
-  context "#vehicle_journey_at_stops" do
-    it "should be ordered like stop_points on route" do
-      route = subject.route
-      vj_stop_ids = subject.vehicle_journey_at_stops.map(&:stop_point_id)
-      expected_order = route.stop_points.map(&:id).select {|s_id| vj_stop_ids.include?(s_id)}
-
-      vj_stop_ids.should == expected_order
-    end
-
-  end
-  
-    describe "#transport_mode_name" do
-
-    def self.legacy_transport_modes
-      %w{Air Train LongDistanceTrain LocalTrain RapidTransit Metro Tramway Coach Bus Ferry Waterborne PrivateVehicle Walk Trolleybus Bicycle Shuttle Taxi VAL Other}
-    end
-    
-    legacy_transport_modes.each do |transport_mode|
-      context "when transport_mode is #{transport_mode}" do
-        transport_mode_name = Chouette::TransportMode.new(transport_mode.underscore)
-        it "should be #{transport_mode_name}" do
-          subject.transport_mode = transport_mode
-          subject.transport_mode_name.should == transport_mode_name
-        end
-      end
-    end
-    context "when transport_mode is nil" do
-      it "should be nil" do
-        subject.transport_mode = nil
-        subject.transport_mode_name.should be_nil
-      end
-    end
-
-  end
-
-  describe "#transport_mode_name=" do
-    
-    it "should change transport_mode with TransportMode#name" do
-      subject.transport_mode_name = "Test"
-      subject.transport_mode.should == "Test"
-    end
-
-  end
-
-  describe ".transport_mode_names" do
-    
-    it "should not include unknown transport_mode_name" do
-      Chouette::VehicleJourney.transport_mode_names.should_not include(Chouette::TransportMode.new("unknown"))
-    end
-
-    it "should not include interchange transport_mode" do
-      Chouette::VehicleJourney.transport_mode_names.should_not include(Chouette::TransportMode.new("interchange"))
-    end
-
-  end
-
-end
-

data/spec/presenters/chouette/geometry/general_presenter.rb

@@ -1 +0,0 @@
-