ninoxe 1.2.2 → 1.2.3

data/spec/models/chouette/area_type_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe Chouette::AreaType, :type => :model do
+  
+  def mode(text_code = "test", numerical_code = nil)
+    numerical_code ||= 1 if text_code == "test"
+    Chouette::AreaType.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("boarding_position").to_i).to eq(0)
+    end
+
+    it "should find text code from numerical code" do
+      expect(mode(0)).to eq("boarding_position")
+    end
+
+    it "should accept another mode" do
+      expect(Chouette::AreaType.new(mode("test"))).to eq(mode("test"))
+    end
+    
+  end
+
+
+  describe ".all" do
+    
+    Chouette::AreaType.definitions.each do |text_code, numerical_code|
+      it "should include a AreaType #{text_code}" do
+        expect(Chouette::AreaType.all).to include(Chouette::AreaType.new(text_code))
+      end
+    end
+
+  end
+
+end

data/spec/models/chouette/company_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Chouette::Company, :type => :model do
+
+  subject { create(:company) }
+
+  it { is_expected.to validate_presence_of :name }
+
+  # it { should validate_presence_of :objectid }
+  it { is_expected.to validate_uniqueness_of :objectid }
+
+  describe "#nullables empty" do
+    it "should set null empty nullable attributes" do
+      subject.organizational_unit = ''
+      subject.operating_department_name = ''
+      subject.code = ''
+      subject.phone = ''
+      subject.fax = ''
+      subject.email = ''
+      subject.nil_if_blank
+      expect(subject.organizational_unit).to be_nil
+      expect(subject.operating_department_name).to be_nil
+      expect(subject.code).to be_nil
+      expect(subject.phone).to be_nil
+      expect(subject.fax).to be_nil
+      expect(subject.email).to be_nil
+    end
+  end
+
+  describe "#nullables non empty" do
+    it "should not set null non epmty nullable attributes" do
+      subject.organizational_unit = 'a'
+      subject.operating_department_name = 'b'
+      subject.code = 'c'
+      subject.phone = 'd'
+      subject.fax = 'z'
+      subject.email = 'r'
+      subject.nil_if_blank
+      expect(subject.organizational_unit).not_to be_nil
+      expect(subject.operating_department_name).not_to be_nil
+      expect(subject.code).not_to be_nil
+      expect(subject.phone).not_to be_nil
+      expect(subject.fax).not_to be_nil
+      expect(subject.email).not_to be_nil
+    end
+  end
+
+end

data/spec/models/chouette/connection_link_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Chouette::ConnectionLink, :type => :model do
+  let!(:quay) { create :stop_area, :area_type => "Quay" }
+  let!(:boarding_position) { create :stop_area, :area_type => "BoardingPosition" }
+  let!(:commercial_stop_point) { create :stop_area, :area_type => "CommercialStopPoint" }
+  let!(:stop_place) { create :stop_area, :area_type => "StopPlace" }
+  let!(:itl) { create :stop_area, :area_type => "ITL" }
+  subject { create(:connection_link) }
+
+  it { is_expected.to validate_uniqueness_of :objectid }
+
+  describe '#objectid' do
+    subject { super().objectid }
+    it { is_expected.to be_kind_of(Chouette::ObjectId) }
+  end
+
+  it { is_expected.to validate_presence_of :name }
+
+  describe "#connection_link_type" do
+
+    def self.legacy_link_types
+      %w{Underground Mixed Overground}
+    end
+    
+    legacy_link_types.each do |link_type|
+      context "when link_type is #{link_type}" do
+        connection_link_type = Chouette::ConnectionLinkType.new(link_type.underscore)
+        it "should be #{connection_link_type}" do
+          subject.link_type = link_type
+          expect(subject.connection_link_type).to eq(connection_link_type)
+        end
+      end
+    end
+    context "when link_type is nil" do
+      it "should be nil" do
+        subject.link_type = nil
+        expect(subject.connection_link_type).to be_nil
+      end
+    end
+
+  end
+
+  describe "#connection_link_type=" do
+    
+    it "should change link_type with ConnectionLinkType#name" do
+      subject.connection_link_type = "Test"
+      expect(subject.link_type).to eq("Test")
+    end
+
+  end
+
+  describe ".possible_areas" do
+
+    it "should not find areas type ITL" do
+      expect(subject.possible_areas).not_to eq([itl]) 
+    end
+  end
+
+end

data/spec/models/chouette/direction_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Chouette::Direction, :type => :model do
+
+  describe ".new" do
+    context "when single argument provided is a direction" do
+      let(:text) { "dummy"}
+      let(:direction){ Chouette::Direction.new( text, 1)}
+      it "should be equals to the provided direction" do
+        expect(direction).to eq(Chouette::Direction.new( direction))
+      end
+    end
+  end
+
+  shared_examples_for "west direction" do
+    it "should return true to #west? " do
+      expect(direction).to be_west
+    end
+    context "#to_i" do
+      it "should return 6" do
+        expect(direction.to_i).to eq(6)
+      end
+    end
+  end
+
+  context "when instanciating with existing text only ('west' for example)" do
+    let(:direction){ Chouette::Direction.new "west"}
+    it_should_behave_like "west direction"
+  end
+  context "when instanciating with existing numerical code only (6 for example)" do
+    let(:direction){ Chouette::Direction.new 6}
+    it_should_behave_like "west direction"
+  end
+
+  context "when instanciating with 'dummy' and 1 as argumrent" do
+    let(:text) { "dummy"}
+    let(:number) { 1}
+    let(:direction){ Chouette::Direction.new( text, number)}
+
+    it "should return true to #dummy? " do
+      expect(direction.send( "#{text}?".to_sym)).to be_truthy
+    end
+
+    it "should return false to #other-dummy? " do
+      expect(direction.send( "other-#{text}?".to_sym)).to be_falsey
+    end
+
+    context "#to_i" do
+      it "should return provided number" do
+        expect(direction.to_i).to eq(number)
+      end
+    end
+
+    context "#name" do
+      it "should return provided text" do
+        expect(direction.name).to eq(text)
+      end
+    end
+  end
+end

data/spec/models/chouette/exporter_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Chouette::Exporter, :type => :model do
+
+  subject { Chouette::Exporter.new("test") }
+
+  describe "#export" do
+
+    let(:chouette_command) { double :run! => true }
+
+    before(:each) do
+      allow(subject).to receive_messages :chouette_command => chouette_command
+    end
+
+    it "should use specified file in -outputFile option" do
+      expect(chouette_command).to receive(:run!).with(hash_including(:output_file => File.expand_path('file')))
+      subject.export "file"
+    end
+    
+    it "should use specified format in -format option" do
+      expect(chouette_command).to receive(:run!).with(hash_including(:format => 'DUMMY'))
+      subject.export "file", :format => "dummy"
+    end
+    
+  end
+
+end
+

data/spec/models/chouette/file_validator_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Chouette::FileValidator, :type => :model do
+
+  subject { Chouette::FileValidator.new("public") }
+
+  before(:each) do
+    allow(subject).to receive_messages :execute! => true
+  end
+
+
+  describe "#validate" do
+
+    let(:chouette_command) { double :run! => true }
+
+    before(:each) do
+      allow(subject).to receive_messages :chouette_command => chouette_command
+    end
+
+    it "should use specified file in -inputFile option" do
+      expect(chouette_command).to receive(:run!).with(hash_including(:input_file => File.expand_path('file')))
+      subject.validate "file"
+    end
+        
+  end
+
+end
+

data/spec/models/chouette/footnote_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Chouette::Footnote do
+
+  subject { build(:footnote) }
+
+  it { should validate_presence_of :line }
+
+end

data/spec/models/chouette/group_of_line_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Chouette::GroupOfLine, :type => :model do
+
+  subject { create(:group_of_line) }
+
+  it { is_expected.to validate_presence_of :name }
+
+  # it { should validate_presence_of :objectid }
+  it { is_expected.to validate_uniqueness_of :objectid }
+
+  describe "#stop_areas" do
+    let!(:line){create(:line, :group_of_lines => [subject])}
+    let!(:route){create(:route, :line => line)}
+    it "should retreive group of line's stop_areas" do
+      expect(subject.stop_areas.count).to eq(route.stop_points.count)
+    end
+  end
+  
+  context "#line_tokens=" do
+    let!(:line1){create(:line)}
+    let!(:line2){create(:line)}
+
+    it "should return associated line ids" do
+      subject.update_attributes :line_tokens => [line1.id, line2.id].join(',')
+      expect(subject.lines).to include( line1)
+      expect(subject.lines).to include( line2)
+    end
+  end
+
+end

data/spec/models/chouette/journey_pattern_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe Chouette::JourneyPattern, :type => :model do
+  describe "#stop_point_ids" do
+    context "for a journey_pattern using only route's stop on odd position" do
+      let!(:journey_pattern){ create( :journey_pattern_odd)}
+      let!(:vehicle_journey){ create( :vehicle_journey_odd, :journey_pattern => journey_pattern)}
+      
+      # workaroud
+      #subject { journey_pattern}
+      subject { Chouette::JourneyPattern.find(vehicle_journey.journey_pattern_id)}
+
+      context "when a all route's stop have been removed from journey_pattern" do
+        before(:each) do
+          subject.stop_point_ids = []
+        end
+        it "should remove all vehicle_journey_at_stop" do
+          vjas_stop_ids = Chouette::VehicleJourney.find(vehicle_journey.id).vehicle_journey_at_stops
+          expect(vjas_stop_ids.count).to eq(0)
+        end
+        it "should keep departure and arrival shortcut up to date to nil" do
+          expect(subject.arrival_stop_point_id).to be_nil
+          expect(subject.departure_stop_point_id).to be_nil
+        end
+      end
+      
+      context "when a route's stop has been removed from journey_pattern" do
+        let!(:last_stop_id){ subject.stop_point_ids.last}
+        before(:each) do
+          subject.stop_point_ids = subject.stop_point_ids - [last_stop_id]
+        end
+        it "should remove vehicle_journey_at_stop for last stop" do
+          vjas_stop_ids = Chouette::VehicleJourney.find(vehicle_journey.id).vehicle_journey_at_stops.map(&:stop_point_id)
+          expect(vjas_stop_ids.count).to eq(subject.stop_point_ids.size)
+          expect(vjas_stop_ids).not_to include( last_stop_id)
+        end
+        it "should keep departure and arrival shortcut up to date" do
+          ordered = subject.stop_points.sort { |a,b| a.position <=> b.position}
+
+          expect(subject.arrival_stop_point_id).to eq(ordered.last.id)
+          expect(subject.departure_stop_point_id).to eq(ordered.first.id)
+        end
+      end
+      
+      context "when a route's stop has been added in journey_pattern" do
+        let!(:new_stop){ subject.route.stop_points[1]}
+        before(:each) do
+          subject.stop_point_ids = subject.stop_point_ids + [new_stop.id]
+        end
+        it "should add a new vehicle_journey_at_stop for that stop" do
+          vjas_stop_ids = Chouette::VehicleJourney.find(vehicle_journey.id).vehicle_journey_at_stops.map(&:stop_point_id)
+          expect(vjas_stop_ids.count).to eq(subject.stop_point_ids.size)
+          expect(vjas_stop_ids).to include( new_stop.id)
+        end
+        it "should keep departure and arrival shortcut up to date" do
+          ordered = subject.stop_points.sort { |a,b| a.position <=> b.position}
+
+          expect(subject.arrival_stop_point_id).to eq(ordered.last.id)
+          expect(subject.departure_stop_point_id).to eq(ordered.first.id)
+        end
+      end
+    end
+  end
+end

data/spec/models/chouette/line_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+
+describe Chouette::Line, :type => :model do
+
+  subject { create(:line) }
+
+  it { is_expected.to validate_presence_of :network }
+  it { is_expected.to validate_presence_of :company }
+
+  it { is_expected.to validate_presence_of :name }
+
+  # it { should validate_presence_of :objectid }
+  it { is_expected.to validate_uniqueness_of :objectid }
+
+  describe '#objectid' do
+    subject { super().objectid }
+    it { is_expected.to be_kind_of(Chouette::ObjectId) }
+  end
+
+  # it { should validate_numericality_of :objectversion }
+
+  describe ".last_stop_areas_parents" do
+
+    it "should return stop areas if no parents" do
+      line = create(:line_with_stop_areas)
+      expect(line.stop_areas_last_parents).to eq(line.stop_areas)
+    end
+
+    it "should return stop areas parents if parents" do
+      line = create(:line_with_stop_areas)
+      route = create(:route, :line => line)
+      parent = create(:stop_area)
+      stop_areas = [ create(:stop_area),  create(:stop_area), create(:stop_area, :parent_id => parent.id) ]
+      stop_areas.each do |stop_area|
+        create(:stop_point, :stop_area => stop_area, :route => route)
+      end
+
+      expect(line.stop_areas_last_parents).to match(line.stop_areas[0..(line.stop_areas.size - 2)].push(parent))
+    end
+
+  end
+
+  describe "#stop_areas" do
+    let!(:route){create(:route, :line => subject)}
+    it "should retreive route's stop_areas" do
+      expect(subject.stop_areas.count).to eq(route.stop_points.count)
+    end
+  end
+
+  describe "#transport_mode" do
+
+    def self.legacy_transport_mode_names
+      %w{Air Train LongDistanceTrain LocalTrain RapidTransit Metro Tramway Coach Bus Ferry Waterborne PrivateVehicle Walk Trolleybus Bicycle Shuttle Taxi VAL Other}
+    end
+
+    legacy_transport_mode_names.each do |transport_mode_name|
+      context "when transport_mode_name is #{transport_mode_name}" do
+        transport_mode = Chouette::TransportMode.new(transport_mode_name.underscore)
+        it "should be #{transport_mode}" do
+          subject.transport_mode_name = transport_mode_name
+          expect(subject.transport_mode).to eq(transport_mode)
+        end
+      end
+    end
+    context "when transport_mode_name is nil" do
+      it "should be nil" do
+        subject.transport_mode_name = nil
+        expect(subject.transport_mode).to be_nil
+      end
+    end
+
+  end
+
+  describe "#transport_mode=" do
+
+    it "should change transport_mode_name with TransportMode#name" do
+      subject.transport_mode = "Test"
+      expect(subject.transport_mode_name).to eq("Test")
+    end
+
+  end
+
+  describe ".transport_modes" do
+
+    it "should not include unknown transport_mode" do
+      expect(Chouette::Line.transport_modes).not_to include(Chouette::TransportMode.new("unknown"))
+    end
+
+    it "should not include interchange transport_mode" do
+      expect(Chouette::Line.transport_modes).not_to include(Chouette::TransportMode.new("interchange"))
+    end
+
+  end
+
+  context "#group_of_line_tokens=" do
+    let!(:group_of_line1){create(:group_of_line)}
+    let!(:group_of_line2){create(:group_of_line)}
+
+    it "should return associated group_of_line ids" do
+      subject.update_attributes :group_of_line_tokens => [group_of_line1.id, group_of_line2.id].join(',')
+      expect(subject.group_of_lines).to include( group_of_line1)
+      expect(subject.group_of_lines).to include( group_of_line2)
+    end
+  end
+
+  describe "#update_attributes footnotes_attributes" do
+    context "instanciate 2 footnotes without line" do
+      let!( :footnote_first) {build( :footnote, :line_id => nil)}
+      let!( :footnote_second) {build( :footnote, :line_id => nil)}
+      it "should add 2 footnotes to the line" do
+        subject.update_attributes :footnotes_attributes =>
+          { Time.now.to_i => footnote_first.attributes,
+            (Time.now.to_i-5) => footnote_second.attributes}
+        expect(Chouette::Line.find( subject.id ).footnotes.size).to eq(2)
+      end
+    end
+  end
+
+
+end