ninoxe 1.2.2 → 1.2.3

data/spec/models/chouette/transport_mode_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe Chouette::TransportMode, :type => :model 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
+      expect(mode("test", 1).to_i).to eq(1)
+    end
+
+  end
+
+  it "should return true to #test? when text code is 'test'" do
+    expect(mode("test")).to be_test
+  end
+
+  it "should be equal when text codes are identical" do
+    expect(mode("test",1)).to eq(mode("test", 2))
+  end
+
+  describe ".new" do
+
+    it "should find numerical code from text code" do
+      expect(mode("unknown").to_i).to eq(0)
+    end
+
+    it "should find text code from numerical code" do
+      expect(mode(0)).to be_unknown
+    end
+
+    it "should accept another mode" do
+      expect(Chouette::TransportMode.new(mode("test"))).to eq(mode("test"))
+    end
+    
+  end
+
+  describe "#public_transport?" do
+    
+    it "should return false for interchange" do
+      expect(mode("interchange")).not_to be_public_transport
+    end
+
+    it "should return true for other modes" do
+      expect(mode("unknown")).to 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
+        expect(Chouette::TransportMode.all).to include(Chouette::TransportMode.new(text_code))
+      end
+    end
+
+  end
+
+end

data/spec/models/chouette/trident_active_record_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+
+describe Chouette::TridentActiveRecord, :type => :model do
+
+  it { expect(Chouette::TridentActiveRecord.ancestors).to include(Chouette::ActiveRecord) }
+
+  subject { create(:time_table) }
+
+  describe "#uniq_objectid" do
+
+    it "should rebuild objectid" do
+      tm = create(:time_table)
+      tm.objectid = subject.objectid
+      tm.uniq_objectid
+      expect(tm.objectid).to eq(subject.objectid+"_1")
+    end
+
+    it "should rebuild objectid" do
+      tm = create(:time_table)
+      tm.objectid = subject.objectid
+      tm.uniq_objectid
+      tm.save
+      tm = create(:time_table)
+      tm.objectid = subject.objectid
+      tm.uniq_objectid
+      expect(tm.objectid).to eq(subject.objectid+"_2")
+    end
+
+  end
+
+  describe "#prepare_auto_columns" do
+
+    it "should left objectid" do
+      tm = Chouette::TimeTable.new :comment => "merge1" , :objectid => "NINOXE:Timetable:merge1"
+      tm.prepare_auto_columns
+      expect(tm.objectid).to eq("NINOXE:Timetable:merge1")
+    end
+
+    it "should add pending_id to objectid" do
+      tm = Chouette::TimeTable.new :comment => "merge1"
+      tm.prepare_auto_columns
+      expect(tm.objectid.start_with?("NINOXE:Timetable:__pending_id__")).to be_truthy
+    end
+
+    it "should set id to objectid" do
+      tm = Chouette::TimeTable.new :comment => "merge1"
+      tm.save
+      expect(tm.objectid).to eq("NINOXE:Timetable:"+tm.id.to_s)
+    end
+
+    it "should detect objectid conflicts" do
+      tm = Chouette::TimeTable.new :comment => "merge1"
+      tm.save
+      tm.objectid = "NINOXE:Timetable:"+(tm.id+1).to_s
+      tm.save
+      tm = Chouette::TimeTable.new :comment => "merge1"
+      tm.save
+      expect(tm.objectid).to eq("NINOXE:Timetable:"+tm.id.to_s+"_1")
+    end
+
+  end
+
+  describe "objectid" do
+
+    it "should build automatic objectid when empty" do
+      g1 = Chouette::GroupOfLine.new( :name => "g1")
+      g1.save
+      expect(g1.objectid).to eq("NINOXE:GroupOfLine:"+g1.id.to_s)
+    end
+
+    it "should build automatic objectid with fixed when only suffix given" do
+      g1 = Chouette::GroupOfLine.new( :name => "g1")
+      g1.objectid = "toto"
+      g1.save
+      expect(g1.objectid).to eq("NINOXE:GroupOfLine:toto")
+    end
+    
+    it "should build automatic objectid with extension when already exists" do
+      g1 = Chouette::GroupOfLine.new( :name => "g1")
+      g1.save
+      cnt = g1.id + 1
+      g1.objectid = "NINOXE:GroupOfLine:"+cnt.to_s
+      g1.save
+      g2 = Chouette::GroupOfLine.new( :name => "g2")
+      g2.save
+      expect(g2.objectid).to eq("NINOXE:GroupOfLine:"+g2.id.to_s+"_1")
+    end
+    
+    it "should build automatic objectid with extension when already exists" do
+      g1 = Chouette::GroupOfLine.new( :name => "g1")
+      g1.save
+      cnt = g1.id + 2
+      g1.objectid = "NINOXE:GroupOfLine:"+cnt.to_s
+      g1.save
+      g2 = Chouette::GroupOfLine.new( :name => "g2")
+      g2.objectid = "NINOXE:GroupOfLine:"+cnt.to_s+"_1"
+      g2.save
+      g3 = Chouette::GroupOfLine.new( :name => "g3")
+      g3.save
+      expect(g3.objectid).to eq("NINOXE:GroupOfLine:"+g3.id.to_s+"_2")
+    end
+    
+    it "should build automatic objectid when id cleared" do
+      g1 = Chouette::GroupOfLine.new( :name => "g1")
+      g1.objectid = "NINOXE:GroupOfLine:xxxx"
+      g1.save
+      g1.objectid = nil
+      g1.save
+      expect(g1.objectid).to eq("NINOXE:GroupOfLine:"+g1.id.to_s)
+    end
+  end
+
+end
+
+

data/spec/models/chouette/vehicle_journey_at_stop_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+require 'pp'
+
+describe Chouette::VehicleJourneyAtStop, :type => :model do
+  let!(:vehicle_journey) { create(: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
+      expect(subject.exceeds_gap?(t1, t2)).to be_truthy
+    end
+    it "should return false if gap > 2.hour" do
+      t1 = 1.minutes.ago
+      t2 = 1.minutes.ago + 3.minutes
+      expect(subject.exceeds_gap?(t1, t2)).to be_falsey
+    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
+        expect(vjas2.increasing_times_validate(vjas1)).to be_falsey
+        expect(vjas2.errors).not_to be_empty
+        expect(vjas2.errors[:arrival_time]).not_to 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
+        expect(vjas2.increasing_times_validate(vjas1)).to be_falsey
+        expect(vjas2.errors).not_to be_empty
+        expect(vjas2.errors[:departure_time]).not_to be_blank
+      end
+    end
+    context "when vjas does'nt exceed gap" do
+      it "should not add errors" do
+        expect(vjas2.increasing_times_validate(vjas1)).to be_truthy
+        expect(vjas2.errors).to be_empty
+      end
+    end
+  end
+end 

data/spec/models/chouette/vehicle_journey_spec.rb

@@ -0,0 +1,223 @@
+require 'spec_helper'
+
+describe Chouette::VehicleJourney, :type => :model do
+  subject { create(:vehicle_journey_odd) }
+
+  describe "in_relation_to_a_journey_pattern methods" do
+    let!(:route) { create(:route)}
+    let!(:journey_pattern) { create(:journey_pattern, :route => route)}
+    let!(:journey_pattern_odd) { create(:journey_pattern_odd, :route => route)}
+    let!(:journey_pattern_even) { create(:journey_pattern_even, :route => route)}
+
+    context "when vehicle_journey is on odd stop whereas selected journey_pattern is on all stops" do
+      subject { create(:vehicle_journey, :route => route, :journey_pattern => journey_pattern_odd)}
+      describe "#extra_stops_in_relation_to_a_journey_pattern" do
+        it "should be empty" do
+          expect(subject.extra_stops_in_relation_to_a_journey_pattern( journey_pattern)).to be_empty
+        end
+      end
+      describe "#extra_vjas_in_relation_to_a_journey_pattern" do
+        it "should be empty" do
+          expect(subject.extra_vjas_in_relation_to_a_journey_pattern( journey_pattern)).to 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)
+          expect(result).to eq(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|
+            expect(journey_pattern_even.stop_points).to 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|
+            expect(vehicle_stops).to include(sp)
+          end
+        end
+        it "should not mark any vjas as _destroy" do
+          subject.update_journey_pattern( journey_pattern)
+          expect(subject.vehicle_journey_at_stops.any?{ |vjas| vjas._destroy }).to be_falsey
+        end
+      end
+    end
+    context "when vehicle_journey is on all stops whereas selected journey_pattern is on odd stops" do
+      subject { create(:vehicle_journey, :route => route, :journey_pattern => journey_pattern)}
+      describe "#missing_stops_in_relation_to_a_journey_pattern" do
+        it "should be empty" do
+          expect(subject.missing_stops_in_relation_to_a_journey_pattern( journey_pattern_odd)).to 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)
+          expect(result).to eq(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)
+          expect(result.map(&:stop_point)).to eq(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)
+          expect(subject.vehicle_journey_at_stops.any?{ |vjas| vjas.new_record? }).to be_falsey
+        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|
+            expect(vjas._destroy).to eq(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
+        expect(subject.vehicle_journey_at_stops[1].errors[:departure_time]).not_to be_blank
+        expect(subject).not_to 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
+        expect(subject.update_attributes(params)).to be_falsey
+      end
+      it "should make instance invalid" do
+        subject.update_attributes(params)
+        expect(subject).not_to be_valid
+      end
+      it "should let first vjas without any errors" do
+        subject.update_attributes(params)
+        expect(subject.vehicle_journey_at_stops[0].errors).to be_empty
+      end
+      it "should add an error on second vjas" do
+        subject.update_attributes(params)
+        expect(subject.vehicle_journey_at_stops[1].errors[:departure_time]).not_to be_blank
+      end
+    end
+  end
+
+  context "#time_table_tokens=" do
+    let!(:tm1){create(:time_table, :comment => "TM1")}
+    let!(:tm2){create(:time_table, :comment => "TM2")}
+
+    it "should return associated time table ids" do
+      subject.update_attributes :time_table_tokens => [tm1.id, tm2.id].join(',')
+      expect(subject.time_tables).to include( tm1)
+      expect(subject.time_tables).to include( tm2)
+    end
+  end
+  describe "#bounding_dates" do
+    before(:each) do
+      tm1 = build(:time_table, :dates =>
+                               [ build(:time_table_date, :date => 1.days.ago.to_date, :in_out => true),
+                                 build(:time_table_date, :date => 2.days.ago.to_date, :in_out => true) ])
+      tm2 = build(:time_table, :periods =>
+                                [ build(:time_table_period, :period_start => 4.days.ago.to_date, :period_end => 3.days.ago.to_date)])
+      tm3 = build(:time_table)
+      subject.time_tables = [ tm1, tm2, tm3]
+    end
+    it "should return min date from associated calendars" do
+      expect(subject.bounding_dates.min).to eq(4.days.ago.to_date)
+    end
+    it "should return max date from associated calendars" do
+      expect(subject.bounding_dates.max).to eq(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)}
+
+      expect(vj_stop_ids).to eq(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
+          expect(subject.transport_mode_name).to eq(transport_mode_name)
+        end
+      end
+    end
+    context "when transport_mode is nil" do
+      it "should be nil" do
+        subject.transport_mode = nil
+        expect(subject.transport_mode_name).to be_nil
+      end
+    end
+
+  end
+
+  describe "#transport_mode_name=" do
+
+    it "should change transport_mode with TransportMode#name" do
+      subject.transport_mode_name = "Test"
+      expect(subject.transport_mode).to eq("Test")
+    end
+
+  end
+
+  describe ".transport_mode_names" do
+
+    it "should not include unknown transport_mode_name" do
+      expect(Chouette::VehicleJourney.transport_mode_names).not_to include(Chouette::TransportMode.new("unknown"))
+    end
+
+    it "should not include interchange transport_mode" do
+      expect(Chouette::VehicleJourney.transport_mode_names).not_to include(Chouette::TransportMode.new("interchange"))
+    end
+
+  end
+
+  describe "#footnote_ids=" do
+    context "when line have footnotes, " do
+      let!( :route) { create( :route ) }
+      let!( :line) { route.line }
+      let!( :footnote_first) {create( :footnote, :code => "1", :label => "dummy 1", :line => route.line)}
+      let!( :footnote_second) {create( :footnote, :code => "2", :label => "dummy 2", :line => route.line)}
+
+
+      it "should update vehicle's footnotes" do
+        expect(Chouette::VehicleJourney.find(subject.id).footnotes).to be_empty
+        subject.footnote_ids = [ footnote_first.id ]
+        subject.save
+        expect(Chouette::VehicleJourney.find(subject.id).footnotes.count).to eq(1)
+      end
+
+    end
+
+  end
+
+end
+