ninoxe 1.2.0 → 1.2.1

data/spec/models/chouette/area_type_spec.rb

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

@@ -1,51 +0,0 @@
-require 'spec_helper'
-
-describe Chouette::Company, :type => :model do
-
-  subject { create(:company) }
-
-  it { is_expected.to validate_presence_of :registration_number }
-  it { is_expected.to validate_uniqueness_of :registration_number }
-
-  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

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

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

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

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

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

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

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

@@ -1,123 +0,0 @@
-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 :registration_number }
-  it { is_expected.to validate_uniqueness_of :registration_number }
-
-  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}
-        Chouette::Line.find( subject.id ).footnotes.size.should == 2
-      end
-    end
-  end
-
-
-end