ninoxe 0.1.1 → 0.1.2

data/spec/models/chouette/stop_point_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Chouette::StopPoint do
+  let!(:vehicle_journey) { Factory(:vehicle_journey)}
+  subject { Chouette::Route.find( vehicle_journey.route_id).stop_points.first }
+
+  it { should validate_uniqueness_of :objectid }
+  it { should validate_presence_of :stop_area }
+  it { should validate_presence_of :route }
+  
+  its(:objectid) { should be_kind_of(Chouette::ObjectId) }
+
+  describe "#destroy" do
+    before(:each) do
+      @vehicle = Factory(:vehicle_journey)
+      @stop_point = Chouette::Route.find( @vehicle.route_id).stop_points.first
+    end
+    def vjas_stop_point_ids( vehicle_id)
+      Chouette::VehicleJourney.find( vehicle_id).vehicle_journey_at_stops.map(&:stop_point_id)
+    end
+    def jpsp_stop_point_ids( journey_id)
+      Chouette::JourneyPattern.find( journey_id).stop_points.map(&:id)
+    end
+    it "should remove dependent vehicle_journey_at_stop" do
+      vjas_stop_point_ids(@vehicle.id).should include(@stop_point.id)
+
+      @stop_point.destroy
+
+      vjas_stop_point_ids(@vehicle.id).should_not include(@stop_point.id)
+    end
+    it "should remove dependent journey_pattern_stop_point" do
+      jpsp_stop_point_ids(@vehicle.journey_pattern_id).should include(@stop_point.id)
+
+      @stop_point.destroy
+
+      jpsp_stop_point_ids(@vehicle.journey_pattern_id).should_not include(@stop_point.id)
+    end
+  end
+end

data/spec/models/chouette/time_table_spec.rb

@@ -0,0 +1,350 @@
+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.parse("04/10/2013"), :period_end => Date.parse("04/12/2013"))
+        p2 = Chouette::TimeTablePeriod.new( :period_start => Date.parse("04/13/2013"), :period_end => Date.parse("04/15/2013"))
+        subject.periods = [ p1, p2]
+        subject.save
+      end
+
+      it "should retreive 04/15/2013" do
+        subject.periods_max_date.should == Date.parse("04/15/2013")
+      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.parse("04/14/2013")
+        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.parse("04/13/2013")
+        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.parse("04/10/2013"), :period_end => Date.parse("04/12/2013"))
+        p2 = Chouette::TimeTablePeriod.new( :period_start => Date.parse("04/13/2013"), :period_end => Date.parse("04/15/2013"))
+        subject.periods = [ p1, p2]
+        subject.save
+      end
+
+      it "should retreive 04/10/2013" do
+        subject.periods_min_date.should == Date.parse("04/10/2013")
+      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.parse("04/11/2013")
+        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.parse("04/12/2013")
+        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 "#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")
+      time_table_period = Factory(:time_table_period, :period_start => Date.yesterday,:period_end => Date.tomorrow, :time_table_id => time_table.id)
+      time_table.include_day?(Date.today).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

@@ -0,0 +1,64 @@
+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

@@ -0,0 +1,46 @@
+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