ninoxe 1.2.0 → 1.2.1

data/spec/factories/chouette_vehicle_journey.rb

@@ -1,66 +0,0 @@
-FactoryGirl.define do
-  
-  factory :vehicle_journey_common, :class => Chouette::VehicleJourney do
-    sequence(:objectid) { |n| "test:VehicleJourney:#{n}" }
-    
-    factory :vehicle_journey do
-      association :journey_pattern, :factory => :journey_pattern
-    
-      after(:build) do |vehicle_journey|
-        vehicle_journey.route = vehicle_journey.journey_pattern.route
-      end
-      
-      after(:create) do |vehicle_journey|
-        vehicle_journey.journey_pattern.stop_points.each_with_index do |stop_point, index|
-          vehicle_journey.vehicle_journey_at_stops << create(:vehicle_journey_at_stop, 
-                 :vehicle_journey => vehicle_journey, 
-                 :stop_point => stop_point, 
-                 :arrival_time => (-1 * index).minutes.ago, 
-                 :departure_time => (-1 * index).minutes.ago)
-        end
-      end
-      
-      factory :vehicle_journey_odd do
-        association :journey_pattern, :factory => :journey_pattern_odd
-      end
-      
-      factory :vehicle_journey_even do
-        association :journey_pattern, :factory => :journey_pattern_even
-      end
-    end
-  end
-end
-
-#      after(:build) do |vehicle_journey|
-#        vehicle_journey.route_id = vehicle_journey.journey_pattern.route_id
-#      end
-#      
-#      after(:create) do |vehicle_journey|
-#        vehicle_journey.journey_pattern.stop_points.each_with_index do |stop_point, index|
-#          vehicle_journey.vehicle_journey_at_stops.create(:vehicle_journey_at_stop, 
-#                                                          :vehicle_journey => vehicle_journey, 
-#                                                          :stop_point => stop_point, 
-#                                                          :arrival_time => (-1 * index).minutes.ago, 
-#                                                          :departure_time => (-1 * index).minutes.ago)
-#        end
-#      end
-#    end
-#    
-#      after(:build) do |vehicle_journey|
-#        vehicle_journey.route_id = vehicle_journey.journey_pattern.route_id
-#      end
-#      
-#      after(:create) do |vehicle_journey|
-#        vehicle_journey.journey_pattern.stop_points.each_with_index do |stop_point, index|
-#          vehicle_journey.vehicle_journey_at_stops.create(:vehicle_journey_at_stop, 
-#                                                          :vehicle_journey => vehicle_journey, 
-#                                                          :stop_point => stop_point, 
-#                                                          :arrival_time => (-1 * index).minutes.ago, 
-#                                                          :departure_time => (-1 * index).minutes.ago)
-#        end
-#      end
-#    end
-#    
-#  end
-#end
-#

data/spec/factories/chouette_vehicle_journey_at_stop.rb

@@ -1,8 +0,0 @@
-FactoryGirl.define do
-  
-  factory :vehicle_journey_at_stop, :class => Chouette::VehicleJourneyAtStop do
-    association :vehicle_journey, :factory => :vehicle_journey
-  end
-
-end
-

data/spec/models/chouette/access_link_spec.rb

@@ -1,82 +0,0 @@
-require 'spec_helper'
-
-describe Chouette::AccessLink, :type => :model do
-  subject { create(:access_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 }
-  it { is_expected.to validate_presence_of :link_type }
-  it { is_expected.to validate_presence_of :link_orientation }
-
-  describe "#access_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
-        access_link_type = Chouette::ConnectionLinkType.new(link_type.underscore)
-        it "should be #{access_link_type}" do
-          subject.link_type = link_type
-          expect(subject.access_link_type).to eq(access_link_type)
-        end
-      end
-    end
-  end
-
-  describe "#access_link_type=" do
-    
-    it "should change link_type with ConnectionLinkType#name" do
-      subject.access_link_type = "underground"
-      expect(subject.link_type).to eq("Underground")
-    end
-
-  end
-
-  describe "#link_orientation_type" do
-
-    def self.legacy_link_orientations
-      %w{AccessPointToStopArea StopAreaToAccessPoint}
-    end
-    
-    legacy_link_orientations.each do |link_orientation|
-      context "when link_orientation is #{link_orientation}" do
-        link_orientation_type = Chouette::LinkOrientationType.new(link_orientation.underscore)
-        it "should be #{link_orientation_type}" do
-          subject.link_orientation = link_orientation
-          expect(subject.link_orientation_type).to eq(link_orientation_type)
-        end
-      end
-    end
-
-  end
-
-  describe "#link_orientation_type=" do
-    
-    it "should change link_orientation with LinkOrientationType#name" do
-      subject.link_orientation_type = "access_point_to_stop_area"
-      expect(subject.link_orientation).to eq("AccessPointToStopArea")
-    end
-
-  end
-
-  describe "#link_key" do
-    it "should calculate link_key for access to area" do
-      subject.link_orientation_type = "access_point_to_stop_area"
-      expect(subject.link_key).to eq("A_#{subject.access_point.id}-S_#{subject.stop_area.id}")
-    end
-    it "should calculate link_key for area to access" do
-      subject.link_orientation_type = "stop_area_to_access_point"
-      expect(subject.link_key).to eq("S_#{subject.stop_area.id}-A_#{subject.access_point.id}")
-    end
-    
-  end
-
-end

data/spec/models/chouette/access_point_spec.rb

@@ -1,269 +0,0 @@
-require 'spec_helper'
-
-describe Chouette::AccessPoint, :type => :model do
-
-  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_numericality_of :latitude }
-  it { is_expected.to validate_numericality_of :longitude }
-  
-  describe ".latitude" do
-    it "should accept -90 value" do
-      subject = create :access_point
-      subject.latitude = -90
-      expect(subject.valid?).to be_truthy
-    end
-    it "should reject < -90 value" do
-      subject = create :access_point
-      subject.latitude = -90.0001
-      expect(subject.valid?).to be_falsey
-    end
-    it "should accept 90 value" do
-      subject = create :access_point
-      subject.latitude = 90
-      expect(subject.valid?).to be_truthy
-    end
-    it "should reject > 90 value" do
-      subject = create :access_point
-      subject.latitude = 90.0001
-      expect(subject.valid?).to be_falsey
-    end
-  end
-
-  describe ".longitude" do
-    it "should accept -180 value" do
-      subject = create :access_point
-      subject.longitude = -180
-      expect(subject.valid?).to be_truthy
-    end
-    it "should reject < -180 value" do
-      subject = create :access_point
-      subject.longitude = -180.0001
-      expect(subject.valid?).to be_falsey
-    end
-    it "should accept 180 value" do
-      subject = create :access_point
-      subject.longitude = 180
-      expect(subject.valid?).to be_truthy
-    end
-    it "should reject > 180 value" do
-      subject = create :access_point
-      subject.longitude = 180.0001
-      expect(subject.valid?).to be_falsey
-    end
-  end
-
-  describe ".long_lat" do
-    it "should accept longitude and latitude both as nil" do
-      subject = create :access_point
-      subject.longitude = nil
-      subject.latitude = nil
-      expect(subject.valid?).to be_truthy
-    end
-    it "should accept longitude and latitude both numerical" do
-      subject = create :access_point
-      subject.longitude = 10
-      subject.latitude = 10
-      expect(subject.valid?).to be_truthy
-    end
-    it "should reject longitude nil with latitude numerical" do
-      subject = create :access_point
-      subject.longitude = nil
-      subject.latitude = 10
-      expect(subject.valid?).to be_falsey
-    end
-    it "should reject longitude numerical with latitude nil" do
-      subject = create :access_point
-      subject.longitude = 10
-      subject.latitude = nil
-      expect(subject.valid?).to be_falsey
-    end
-  end 
-
-  describe "#access_type" do
-    def self.legacy_access_types
-      %w{In Out InOut}
-    end
-    
-    legacy_access_types.each do |access_type|
-      context "when access_type is #{access_type}" do
-        access_point_type = Chouette::AccessPointType.new(access_type.underscore)
-        it "should be #{access_point_type}" do
-          subject.access_type = access_type
-          expect(subject.access_point_type).to eq(access_point_type)
-        end
-      end
-    end
-  end
-
-  describe "#access_point_type=" do    
-    it "should change access_type with Chouette::AccessPointType#name" do
-      subject.access_point_type = "in_out"
-      expect(subject.access_type).to eq("InOut")
-    end
-
-  end
-
-  describe "#to_lat_lng" do
-    
-    it "should return nil if latitude is nil" do
-      subject.latitude = nil
-      expect(subject.to_lat_lng).to be_nil
-    end
-
-    it "should return nil if longitude is nil" do
-      subject.longitude = nil
-      expect(subject.to_lat_lng).to be_nil
-    end
-
-  end
-
-  describe "#geometry" do
-    
-    it "should be nil when to_lat_lng is nil" do
-      allow(subject).to receive_messages :to_lat_lng => nil
-      expect(subject.geometry).to be_nil
-    end
-
-  end
-
-  describe "#generic_access_link_matrix" do
-    it "should have 2 generic_access_links in matrix" do
-      stop_place = create :stop_area, :area_type => "StopPlace" 
-      commercial_stop_point = create :stop_area, :area_type => "CommercialStopPoint" ,:parent => stop_place
-      subject = create :access_point, :stop_area => stop_place
-      expect(subject.generic_access_link_matrix.size).to eq(2)
-    end
-    
-    it "should have new generic_access_links in matrix" do
-      commercial_stop_point = create :stop_area, :area_type => "CommercialStopPoint" 
-      subject = create :access_point, :stop_area => commercial_stop_point
-      subject.generic_access_link_matrix.each do |link|
-        expect(link.id).to be_nil
-      end
-    end
-    it "should have only last generic_access_links as new in matrix" do
-      commercial_stop_point = create :stop_area, :area_type => "CommercialStopPoint" 
-      subject = create :access_point, :stop_area => commercial_stop_point
-      link = create :access_link, :access_point => subject, :stop_area => commercial_stop_point
-      subject.generic_access_link_matrix.each do |link|
-        if link.link_key.start_with?"A_" 
-          expect(link.id).not_to be_nil
-        else
-          expect(link.id).to be_nil
-        end  
-      end
-    end
-  end
-
-  describe "#detail_access_link_matrix" do
-    it "should have 4 detail_access_links in matrix" do
-      stop_place = create :stop_area, :area_type => "StopPlace" 
-      commercial_stop_point = create :stop_area, :area_type => "CommercialStopPoint" ,:parent => stop_place
-      quay1 = create :stop_area, :parent => commercial_stop_point, :area_type => "Quay"
-      quay2 = create :stop_area, :parent => commercial_stop_point, :area_type => "Quay"
-      subject = create :access_point, :stop_area => stop_place
-      expect(subject.detail_access_link_matrix.size).to eq(4)
-    end
-    
-    it "should have new detail_access_links in matrix" do
-      commercial_stop_point = create :stop_area, :area_type => "CommercialStopPoint" 
-      quay = create :stop_area, :parent => commercial_stop_point, :area_type => "Quay"
-      subject = create :access_point, :stop_area => commercial_stop_point
-      subject.detail_access_link_matrix.each do |link|
-        expect(link.id).to be_nil
-      end
-    end
-    it "should have only last detail_access_links as new in matrix" do
-      commercial_stop_point = create :stop_area, :area_type => "CommercialStopPoint" 
-      quay = create :stop_area, :parent => commercial_stop_point, :area_type => "Quay"
-      subject = create :access_point, :stop_area => commercial_stop_point
-      link = create :access_link, :access_point => subject, :stop_area => quay
-      subject.detail_access_link_matrix.each do |link|
-        if link.link_key.start_with?"A_" 
-          expect(link.id).not_to be_nil
-        else
-          expect(link.id).to be_nil
-        end  
-      end
-    end
-  end
-
-  describe "#coordinates" do
-    it "should convert coordinates into latitude/longitude" do
-     commercial_stop_point = create :stop_area, :area_type => "CommercialStopPoint" 
-     subject = create :access_point, :stop_area => commercial_stop_point, :coordinates => "45.123,120.456"
-     expect(subject.longitude).to be_within(0.001).of(120.456)
-     expect(subject.latitude).to be_within(0.001).of(45.123)
-   end
-    it "should set empty coordinates into nil latitude/longitude" do
-     commercial_stop_point = create :stop_area, :area_type => "CommercialStopPoint" 
-     subject = create :access_point, :stop_area => commercial_stop_point, :coordinates => "45.123,120.456"
-     expect(subject.longitude).to be_within(0.001).of(120.456)
-     expect(subject.latitude).to be_within(0.001).of(45.123)
-     subject.coordinates = ""
-     subject.save
-     expect(subject.longitude).to be_nil
-     expect(subject.latitude).to be_nil
-   end
-    it "should convert latitude/longitude into coordinates" do
-     commercial_stop_point = create :stop_area, :area_type => "CommercialStopPoint" 
-     subject = create :access_point, :stop_area => commercial_stop_point, :longitude => 120.456, :latitude => 45.123
-     expect(subject.coordinates).to eq("45.123,120.456")
-   end
-    it "should convert nil latitude/longitude into empty coordinates" do
-    commercial_stop_point = create :stop_area, :area_type => "CommercialStopPoint" 
-     subject = create :access_point, :stop_area => commercial_stop_point, :longitude => nil, :latitude => nil
-     expect(subject.coordinates).to eq("")
-   end
-    it "should accept valid coordinates" do
-     commercial_stop_point = create :stop_area, :area_type => "CommercialStopPoint" 
-     subject = create :access_point, :stop_area => commercial_stop_point, :coordinates => "45.123,120.456"
-     expect(subject.valid?).to be_truthy
-     subject.coordinates = "45.123, 120.456"
-     expect(subject.valid?).to be_truthy
-     expect(subject.longitude).to be_within(0.001).of(120.456)
-     expect(subject.latitude).to be_within(0.001).of(45.123)
-     subject.coordinates = "45.123,  -120.456"
-     expect(subject.valid?).to be_truthy
-     subject.coordinates = "45.123 ,120.456"
-     expect(subject.valid?).to be_truthy
-     subject.coordinates = "45.123   ,   120.456"
-     expect(subject.valid?).to be_truthy
-     subject.coordinates = " 45.123,120.456"
-     expect(subject.valid?).to be_truthy
-     subject.coordinates = "45.123,120.456  "
-     expect(subject.valid?).to be_truthy
-    end
-    it "should accept valid coordinates on limits" do
-     commercial_stop_point = create :stop_area, :area_type => "CommercialStopPoint" 
-     subject = create :access_point, :stop_area => commercial_stop_point, :coordinates => "90,180"
-     expect(subject.valid?).to be_truthy
-     subject.coordinates = "-90,-180"
-     expect(subject.valid?).to be_truthy
-     subject.coordinates = "-90.,180."
-     expect(subject.valid?).to be_truthy
-     subject.coordinates = "-90.0,180.00"
-     expect(subject.valid?).to be_truthy
-    end
-    it "should reject invalid coordinates" do
-     commercial_stop_point = create :stop_area, :area_type => "CommercialStopPoint" 
-     subject = create :access_point, :stop_area => commercial_stop_point
-     subject.coordinates = ",12"
-     expect(subject.valid?).to be_falsey
-     subject.coordinates = "-90"
-     expect(subject.valid?).to be_falsey
-     subject.coordinates = "-90.1,180."
-     expect(subject.valid?).to be_falsey
-     subject.coordinates = "-90.0,180.1"
-     expect(subject.valid?).to be_falsey
-     subject.coordinates = "-91.0,18.1"
-     expect(subject.valid?).to be_falsey
-    end
-  end
-  
-end

data/spec/models/chouette/active_record_spec.rb

@@ -1,121 +0,0 @@
-require 'spec_helper'
-
-describe Chouette::ActiveRecord, :type => :model do
-
-  it { expect(Chouette::ActiveRecord.ancestors).to include(ActiveRecord::Base) }
-
-  describe "table_name" do
-
-    it "should return line for Chouette::Line" do
-      expect(Chouette::Line.table_name).to eq("lines")
-    end
-    
-    it "should return ptnetwork for Chouette::Network" do
-      expect(Chouette::Network.table_name).to eq("networks")
-    end
-
-    it "should return timetable_date for Chouette::TimeTableDate" do
-      expect(Chouette::TimeTableDate.table_name).to eq("time_table_dates")
-    end
-
-    it "should return timetable_period for Chouette::TimeTablePeriod" do
-      expect(Chouette::TimeTablePeriod.table_name).to eq("time_table_periods")
-    end
-
-  end
-
-  describe "method_missing" do
-    
-    it "should support method with additionnal underscores" do
-      stop_area = Chouette::StopArea.new
-      expect(stop_area.area_type).to eq(stop_area.area_type)
-    end
-
-  end
-
-
-  describe "respond_to?" do
-    
-    it "should respond to method with additionnal underscores" do
-      stop_area = Chouette::StopArea.new
-      expect(stop_area.respond_to?(:area_type)).to be_truthy
-    end
-
-  end
-
-#   describe "create_reflection" do
-
-#     let(:macro) { :has_many }
-#     let(:name) { :lines }
-#     let(:options) { {} }
-#     let(:active_record) { Chouette::Network }
-    
-#     let(:modified_options) { {:modified => true}  }
-
-#     it "should invoke create_reflection_without_chouette_naming with modified options" do
-#       allow(Chouette::ActiveRecord::Reflection).to receive_messages :new => double(:options_with_default => modified_options)
-#       expect(Chouette::ActiveRecord).to receive(:create_reflection_without_chouette_naming).with macro, name, modified_options, active_record
-
-#       Chouette::ActiveRecord.create_reflection macro, name, options, active_record
-#     end
-
-#   end
-
-end
-
-# describe Chouette::ActiveRecord::Reflection, :type => :model do
-
-#   let(:macro) { :has_many }
-#   let(:name) { :lines }
-#   let(:options) { {} }
-#   let(:active_record) { Chouette::Network }
-
-#   subject { Chouette::ActiveRecord::Reflection.new macro, name, options, active_record }
-
-#   describe "collection?" do
-
-#     it "should be true when macro is has_many" do
-#       allow(subject).to receive_messages :macro => :has_many
-#       expect(subject).to be_collection
-#     end
-
-#     it "should be false when macro is belongs_to" do
-#       allow(subject).to receive_messages :macro => :belong_to
-#       expect(subject).not_to be_collection
-#     end
-
-#   end
-
-#   describe "class_name" do
-    
-#     it "should be Chouette::Line when name is line" do
-#       allow(subject).to receive_messages :name => "line"
-#       expect(subject.class_name).to eq("Chouette::Line")
-#     end
-
-#     it "should be Chouette::Routes when name is routes and reflection is a collection" do
-#       allow(subject).to receive_messages :name => "routes", :collection? => true
-#       expect(subject.class_name).to eq("Chouette::Route")
-#     end
-
-#   end
-
-
-#   describe "options" do
-    
-#     it "should define class_name if not" do
-#       allow(subject).to receive_messages :options => {}, :class_name => "class_name"
-#       expect(subject.options_with_default[:class_name]).to eq("class_name")
-#     end
-
-#     it "should not define class_name if presents" do
-#       allow(subject).to receive_messages :options => {:class_name => "dummy"}
-#       expect(subject.options_with_default[:class_name]).to eq("dummy")
-#     end
-
-#   end
-  
-
-# end
-
-