ninoxe 1.2.0 → 1.2.1

data/spec/models/chouette/loader_spec.rb

@@ -1,69 +0,0 @@
-require 'spec_helper'
-
-describe Chouette::Loader, :type => :model do
-
-  subject { Chouette::Loader.new("test") }
-
-  before(:each) do
-    allow(subject).to receive_messages :execute! => true
-  end
-
-  describe "#load_dump" do
-
-  end
-
-  describe "#import" 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.import "file"
-    end
-    
-    it "should use specified format in -format option" do
-      expect(chouette_command).to receive(:run!).with(hash_including(:format => 'DUMMY'))
-      subject.import "file", :format => "dummy"
-    end
-    
-  end
-
-  describe "#create" do
-    
-    it "should quote schema name" do
-      expect(subject).to receive(:execute!).with(/"test"/)
-      subject.create
-    end
-
-  end
-
-  describe "#drop" do
-
-    it "should quote schema name" do
-      expect(subject).to receive(:execute!).with(/"test"/)
-      subject.drop
-    end
-    
-  end
-
-  describe "#backup" do
-
-    let(:file) { "/dev/null" }
-
-    it "should call pg_dump" do
-      expect(subject).to receive(:execute!).with(/^pg_dump/)
-      subject.backup file
-    end
-
-    it "should dump in specified file" do
-      expect(subject).to receive(:execute!).with(/-f #{file}/)
-      subject.backup file
-    end
-  end
-
-end
-

data/spec/models/chouette/network_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-describe Chouette::Network, :type => :model do
-
-  subject { create(:network) }
-
-  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 "#stop_areas" do
-    let!(:line){create(:line, :network => subject)}
-    let!(:route){create(:route, :line => line)}
-    it "should retreive route's stop_areas" do
-      expect(subject.stop_areas.count).to eq(route.stop_points.count)
-    end
-  end
-end

data/spec/models/chouette/object_id_spec.rb

@@ -1,149 +0,0 @@
-require 'spec_helper'
-
-describe Chouette::ObjectId, :type => :model do
-
-  def objectid(value = "abc:StopArea:abc123")
-    Chouette::ObjectId.new value
-  end
-
-  subject { objectid }
-
-  context "when invalid" do
-
-    subject { objectid("abc") }
-
-    it { is_expected.not_to be_valid }
-
-    describe '#parts' do
-      subject { super().parts }
-      it { is_expected.to be_nil }
-    end
-
-    describe '#system_id' do
-      subject { super().system_id }
-      it { is_expected.to be_nil }
-    end
-
-  end
-  
-  context "when with spaces in last part" do
-
-    subject { objectid("abc:Line:Aze toto") }
-
-    it { is_expected.not_to be_valid }
-
-
-  end
-  
-  context "when with spaces in first part" do
-
-    subject { objectid("ae abc:Line:Aze") }
-
-    it { is_expected.not_to be_valid }
-
-
-  end
-  
-  context "when with spaces in middle part" do
-
-    subject { objectid("aeabc:Li ne:Aze") }
-
-    it { is_expected.not_to be_valid }
-    
-
-  end
-  
-  context "when invalid in first part" do
-
-    subject { objectid("Abc_+19:Line:Abc") }
-
-    it { is_expected.not_to be_valid }
-  end
-  
-  context "when invalid in middle part" do
-
-    subject { objectid("Abc_19:Li56ne:Abc") }
-
-    it { is_expected.not_to be_valid }
-  end
-
-  context "when invalid in last part" do
-
-    subject { objectid("Abc_19:Line:Ab+c") }
-
-    it { is_expected.not_to be_valid }
-  end
-  context "when valid" do
-
-    subject { objectid("Abc_19:Line:Abc_12-") }
-
-    it { is_expected.to be_valid }
-  end
-
-  describe "#parts" do
-
-    it "should be the 3 parts of the ObjectId" do
-      expect(objectid("abc:StopArea:abc123").parts).to eq(%w{abc StopArea abc123})
-    end
-
-  end
-
-  describe "#system_id" do
-    
-    it "should be the first ObjectId parts" do
-      expect(objectid("first:second:third").system_id).to eq("first")
-    end
-
-  end
-
-  describe "#object_type" do
-    
-    it "should be the second ObjectId parts" do
-      expect(objectid("first:second:third").object_type).to eq("second")
-    end
-
-  end
-
-  describe "#local_id" do
-    
-    it "should be the third ObjectId parts" do
-      expect(objectid("first:second:third").local_id).to eq("third")
-    end
-
-  end
-
-  it "should be valid when parts are found" do
-    allow(subject).to receive_messages :parts => "dummy"
-    expect(subject).to be_valid
-  end
-
-  describe ".create" do
-
-    let(:given_system_id) { "systemId" }
-    let(:given_object_type) { "objectType" }
-    let(:given_local_id) { "localId" }
-
-    subject { Chouette::ObjectId.create(given_system_id, given_object_type, given_local_id) }
-
-    it "should return ObjectId attributes" do
-      expect(subject.send(:system_id)).to eq(given_system_id)
-      expect(subject.send(:object_type)).to eq(given_object_type)
-      expect(subject.send(:local_id)).to eq(given_local_id)
-    end
-
-  end
-
-  describe ".new" do
-    
-    it "should return an existing ObjectId" do
-      expect(Chouette::ObjectId.new(objectid)).to eq(objectid)
-    end
-
-    it "should create an empty ObjectId with nil" do
-      expect(Chouette::ObjectId.new(nil)).to be_empty
-    end
-
-  end
-
-
-end

data/spec/models/chouette/route_spec.rb

@@ -1,238 +0,0 @@
-require 'spec_helper'
-
-describe Chouette::Route, :type => :model do
-  subject { create(:route) }
-
-  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 }
-  it { is_expected.to validate_presence_of :line }
-  #it { is_expected.to validate_presence_of :wayback_code }
-  #it { is_expected.to validate_presence_of :direction_code }
-
-  context "reordering methods" do
-    let( :bad_stop_point_ids){subject.stop_points.map { |sp| sp.id + 1}}
-    let( :ident){subject.stop_points.map(&:id)}
-    let( :first_last_swap){ [ident.last] + ident[1..-2] + [ident.first]}
-
-    describe "#reorder!" do
-      context "invalid stop_point_ids" do
-        let( :new_stop_point_ids) { bad_stop_point_ids}
-        it { expect(subject.reorder!( new_stop_point_ids)).to be_falsey}
-      end
-
-      context "swaped last and first stop_point_ids" do
-        let!( :new_stop_point_ids) { first_last_swap}
-        let!( :old_stop_point_ids) { subject.stop_points.map(&:id) }
-        let!( :old_stop_area_ids) { subject.stop_areas.map(&:id) }
-
-        it "should keep stop_point_ids order unchanged" do
-          expect(subject.reorder!( new_stop_point_ids)).to be_truthy
-          expect(subject.stop_points.map(&:id)).to eq( old_stop_point_ids)
-        end
-        it "should have changed stop_area_ids order" do
-          expect(subject.reorder!( new_stop_point_ids)).to be_truthy
-          subject.reload
-          expect(subject.stop_areas.map(&:id)).to eq( [old_stop_area_ids.last] + old_stop_area_ids[1..-2] + [old_stop_area_ids.first])
-        end
-      end
-    end
-
-    describe "#stop_point_permutation?" do
-      context "invalid stop_point_ids" do
-        let( :new_stop_point_ids) { bad_stop_point_ids}
-        it { is_expected.not_to be_stop_point_permutation( new_stop_point_ids)}
-      end
-      context "unchanged stop_point_ids" do
-        let( :new_stop_point_ids) { ident}
-        it { is_expected.to be_stop_point_permutation( new_stop_point_ids)}
-      end
-      context "swaped last and first stop_point_ids" do
-        let( :new_stop_point_ids) { first_last_swap}
-        it { is_expected.to be_stop_point_permutation( new_stop_point_ids)}
-      end
-    end
-  end
-
-  describe "#stop_points_attributes=" do
-      let( :journey_pattern) { create( :journey_pattern, :route => subject )}
-      let( :vehicle_journey) { create( :vehicle_journey, :journey_pattern => journey_pattern)}
-      def subject_stop_points_attributes
-          {}.tap do |hash|
-              subject.stop_points.each_with_index { |sp,index| hash[ index.to_s ] = sp.attributes }
-          end
-      end
-      context "route having swapped a new stop" do
-          let( :new_stop_point ){build( :stop_point, :route => subject)}
-          def added_stop_hash
-            subject_stop_points_attributes.tap do |h|
-                h["4"] = new_stop_point.attributes.merge( "position" => "4", "_destroy" => "" )
-            end
-          end
-          let!( :new_route_size ){ subject.stop_points.size+1 }
-
-          it "should have added stop_point in route" do
-              subject.update_attributes( :stop_points_attributes => added_stop_hash)
-              expect(Chouette::Route.find( subject.id ).stop_points.size).to eq(new_route_size)
-          end
-          it "should have added stop_point in route's journey pattern" do
-              subject.update_attributes( :stop_points_attributes => added_stop_hash)
-              expect(Chouette::JourneyPattern.find( journey_pattern.id ).stop_points.size).to eq(new_route_size)
-          end
-          it "should have added stop_point in route's vehicle journey at stop" do
-              subject.update_attributes( :stop_points_attributes => added_stop_hash)
-              expect(Chouette::VehicleJourney.find( vehicle_journey.id ).vehicle_journey_at_stops.size).to eq(new_route_size)
-          end
-      end
-      context "route having swapped stop" do
-          def swapped_stop_hash
-            subject_stop_points_attributes.tap do |h|
-                h[ "1" ][ "position" ] = "3"
-                h[ "3" ][ "position" ] = "1"
-            end
-          end
-          let!( :new_stop_id_list ){ subject.stop_points.map(&:id).tap {|array| array.insert( 1, array.delete_at(3)); array.insert( 3, array.delete_at(2) )} }
-
-          it "should have swap stop_points from route" do
-              subject.update_attributes( :stop_points_attributes => swapped_stop_hash)
-              expect(Chouette::Route.find( subject.id ).stop_points.map(&:id)).to eq(new_stop_id_list)
-          end
-          it "should have swap stop_points from route's journey pattern" do
-              subject.update_attributes( :stop_points_attributes => swapped_stop_hash)
-              expect(Chouette::JourneyPattern.find( journey_pattern.id ).stop_points.map(&:id)).to eq(new_stop_id_list)
-          end
-          it "should have swap stop_points from route's vehicle journey at stop" do
-              subject.update_attributes( :stop_points_attributes => swapped_stop_hash)
-              expect(Chouette::VehicleJourney.find( vehicle_journey.id ).vehicle_journey_at_stops.map(&:stop_point_id)).to match_array(new_stop_id_list)
-          end
-      end
-      context "route having a deleted stop" do
-          def removed_stop_hash
-            subject_stop_points_attributes.tap do |h|
-                h[ "1" ][ "_destroy" ] = "1"
-            end
-          end
-          let!( :new_stop_id_list ){ subject.stop_points.map(&:id).tap {|array| array.delete_at(1) } }
-
-          it "should ignore deleted stop_point from route" do
-              subject.update_attributes( :stop_points_attributes => removed_stop_hash)
-              expect(Chouette::Route.find( subject.id ).stop_points.map(&:id)).to eq(new_stop_id_list)
-          end
-          it "should ignore deleted stop_point from route's journey pattern" do
-              subject.update_attributes( :stop_points_attributes => removed_stop_hash)
-              expect(Chouette::JourneyPattern.find( journey_pattern.id ).stop_points.map(&:id)).to eq(new_stop_id_list)
-          end
-          it "should ignore deleted stop_point from route's vehicle journey at stop" do
-              subject.update_attributes( :stop_points_attributes => removed_stop_hash)
-              expect(Chouette::VehicleJourney.find( vehicle_journey.id ).vehicle_journey_at_stops.map(&:stop_point_id)).to match_array(new_stop_id_list)
-          end
-      end
-  end
-
-  describe "#stop_points" do
-    context "#find_by_stop_area" do
-      context "when arg is first quay id" do
-        let(:first_stop_point) { subject.stop_points.first}
-        it "should return first quay" do
-          expect(subject.stop_points.find_by_stop_area( first_stop_point.stop_area_id)).to eq( first_stop_point)
-        end
-      end
-    end
-  end
-  describe "#stop_areas" do
-    let(:line){ create(:line)}
-    let(:route_1){ create(:route, :line => line)}
-    let(:route_2){ create(:route, :line => line)}
-    it "should retreive all stop_area on route" do
-      route_1.stop_areas.each do |sa|
-        expect(sa.stop_points.map(&:route_id).uniq).to eq([route_1.id])
-      end
-    end
-
-    context "when route is looping: last and first stop area are the same" do
-      it "should retreive same stop_area one last and first position" do
-        route_loop = create(:route, :line => line)
-        first_stop = Chouette::StopPoint.where( :route_id => route_loop.id, :position => 0).first
-        last_stop = create(:stop_point, :route => route_loop, :position => 4, :stop_area => first_stop.stop_area)
-
-        expect(route_loop.stop_areas.size).to eq(6)
-        expect(route_loop.stop_areas.select {|s| s.id == first_stop.stop_area.id}.size).to eq(2)
-      end
-    end
-  end
-
-  describe "#direction_code" do
-    def self.legacy_directions
-      %w{A R ClockWise CounterClockWise North NorthWest West SouthWest
-        South SouthEast East NorthEast}
-    end
-    legacy_directions.each do |direction|
-      context "when direction is #{direction}" do
-        direction_code = Chouette::Direction.new( Chouette::Route.direction_binding[ direction])
-        it "should be #{direction_code}" do
-          subject.direction = direction
-          expect(subject.direction_code).to eq(direction_code)
-        end
-      end
-    end
-    context "when direction is nil" do
-      it "should be nil" do
-        subject.direction = nil
-        expect(subject.direction_code).to be_nil
-      end
-    end
-  end
-  describe "#direction_code=" do
-    context "when unknown direction is provided" do
-      it "should change direction to nil" do
-        subject.direction_code = "dummy"
-        expect(subject.direction).to be_nil
-      end
-    end
-    context "when an existing direction (west) is provided" do
-      it "should change direction Direction.west" do
-        subject.direction_code = "west"
-        expect(subject.direction).to eq("West")
-      end
-    end
-  end
-  describe "#wayback_code" do
-    def self.legacy_waybacks
-      %w{A R}
-    end
-    legacy_waybacks.each do |wayback|
-      context "when wayback is #{wayback}" do
-        wayback_code = Chouette::Wayback.new( Chouette::Route.wayback_binding[ wayback])
-        it "should be #{wayback_code}" do
-          subject.wayback = wayback
-          expect(subject.wayback_code).to eq(wayback_code)
-        end
-      end
-    end
-    context "when wayback is nil" do
-      it "should be nil" do
-        subject.wayback = nil
-        expect(subject.wayback_code).to be_nil
-      end
-    end
-  end
-  describe "#wayback_code=" do
-    context "when unknown wayback is provided" do
-      it "should change wayback to nil" do
-        subject.wayback_code = "dummy"
-        expect(subject.wayback).to be_nil
-      end
-    end
-    context "when an existing wayback (straight_forward) is provided" do
-      it "should change wayback Wayback.straight_forward" do
-        subject.wayback_code = "straight_forward"
-        expect(subject.wayback).to eq("A")
-      end
-    end
-  end
-end