ninoxe 0.1.1 → 0.1.2

data/spec/models/chouette/active_record_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+describe Chouette::ActiveRecord do
+
+  it { Chouette::ActiveRecord.ancestors.should include(ActiveRecord::Base) }
+
+  describe "table_name" do
+
+    it "should return line for Chouette::Line" do
+      Chouette::Line.table_name.should == "lines"
+    end
+    
+    it "should return ptnetwork for Chouette::Network" do
+      Chouette::Network.table_name.should == "networks"
+    end
+
+    it "should return timetable_date for Chouette::TimeTableDate" do
+      Chouette::TimeTableDate.table_name.should == "time_table_dates"
+    end
+
+    it "should return timetable_period for Chouette::TimeTablePeriod" do
+      Chouette::TimeTablePeriod.table_name.should == "time_table_periods"
+    end
+
+  end
+
+  describe "method_missing" do
+    
+    it "should support method with additionnal underscores" do
+      stop_area = Chouette::StopArea.new
+      stop_area.area_type.should == stop_area.area_type
+    end
+
+  end
+
+
+  describe "respond_to?" do
+    
+    it "should respond to method with additionnal underscores" do
+      stop_area = Chouette::StopArea.new
+      stop_area.respond_to?(:area_type).should be_true
+    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
+      Chouette::ActiveRecord::Reflection.stub :new => mock(:options_with_default => modified_options)
+      Chouette::ActiveRecord.should_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 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
+      subject.stub :macro => :has_many
+      subject.should be_collection
+    end
+
+    it "should be false when macro is belongs_to" do
+      subject.stub :macro => :belong_to
+      subject.should_not be_collection
+    end
+
+  end
+
+  describe "class_name" do
+    
+    it "should be Chouette::Line when name is line" do
+      subject.stub :name => "line"
+      subject.class_name.should == "Chouette::Line"
+    end
+
+    it "should be Chouette::Routes when name is routes and reflection is a collection" do
+      subject.stub :name => "routes", :collection? => true
+      subject.class_name.should == "Chouette::Route"
+    end
+
+  end
+
+
+  describe "options" do
+    
+    it "should define class_name if not" do
+      subject.stub :options => {}, :class_name => "class_name"
+      subject.options_with_default[:class_name].should == "class_name"
+    end
+
+    it "should not define class_name if presents" do
+      subject.stub :options => {:class_name => "dummy"}
+      subject.options_with_default[:class_name].should == "dummy"
+    end
+
+  end
+  
+
+end
+
+

data/spec/models/chouette/area_type_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe Chouette::AreaType 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
+      mode("test", 1).to_i.should == 1
+    end
+
+  end
+
+  it "should return true to #test? when text code is 'test'" do
+    mode("test").should be_test
+  end
+
+  it "should be equal when text codes are identical" do
+    mode("test",1).should == mode("test", 2)
+  end
+
+  describe ".new" do
+
+    it "should find numerical code from text code" do
+      mode("boarding_position").to_i.should == 0
+    end
+
+    it "should find text code from numerical code" do
+      mode(0).should == "boarding_position"
+    end
+
+    it "should accept another mode" do
+      Chouette::AreaType.new(mode("test")).should == mode("test")
+    end
+    
+  end
+
+
+  describe ".all" do
+    
+    Chouette::AreaType.definitions.each do |text_code, numerical_code|
+      it "should include a AreaType #{text_code}" do
+        Chouette::AreaType.all.should include(Chouette::AreaType.new(text_code))
+      end
+    end
+
+  end
+
+end

data/spec/models/chouette/company_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe Chouette::Company do
+
+  subject { Factory(:company) }
+
+  it { should validate_presence_of :registration_number }
+  it { should validate_uniqueness_of :registration_number }
+
+  it { should validate_presence_of :name }
+
+  # it { should validate_presence_of :objectid }
+  it { should 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
+      subject.organizational_unit.should be_nil
+      subject.operating_department_name.should be_nil
+      subject.code.should be_nil
+      subject.phone.should be_nil
+      subject.fax.should be_nil
+      subject.email.should 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
+      subject.organizational_unit.should_not be_nil
+      subject.operating_department_name.should_not be_nil
+      subject.code.should_not be_nil
+      subject.phone.should_not be_nil
+      subject.fax.should_not be_nil
+      subject.email.should_not be_nil
+    end
+  end
+
+end

data/spec/models/chouette/connection_link_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe Chouette::ConnectionLink do
+  let!(:quay) { Factory :stop_area, :area_type => "Quay" }
+  let!(:boarding_position) { Factory :stop_area, :area_type => "BoardingPosition" }
+  let!(:commercial_stop_point) { Factory :stop_area, :area_type => "CommercialStopPoint" }
+  let!(:stop_place) { Factory :stop_area, :area_type => "StopPlace" }
+  let!(:itl) { Factory :stop_area, :area_type => "ITL" }
+  subject { Factory(:connection_link) }
+
+  it { should validate_uniqueness_of :objectid }
+  its(:objectid) { should be_kind_of(Chouette::ObjectId) }
+
+  it { should 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
+          subject.connection_link_type.should == connection_link_type
+        end
+      end
+    end
+    context "when link_type is nil" do
+      it "should be nil" do
+        subject.link_type = nil
+        subject.connection_link_type.should be_nil
+      end
+    end
+
+  end
+
+  describe "#connection_link_type=" do
+    
+    it "should change link_type with ConnectionLinkType#name" do
+      subject.connection_link_type = "Test"
+      subject.link_type.should == "Test"
+    end
+
+  end
+
+  describe ".possible_areas" do
+
+    it "should not find areas type ITL" do
+      subject.possible_areas.should_not == [itl] 
+    end
+  end
+
+end

data/spec/models/chouette/direction_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Chouette::Direction 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
+        direction.should == Chouette::Direction.new( direction)
+      end
+    end
+  end
+
+  shared_examples_for "west direction" do
+    it "should return true to #west? " do
+      direction.should be_west
+    end
+    context "#to_i" do
+      it "should return 6" do
+        direction.to_i.should == 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
+      direction.send( "#{text}?".to_sym).should be_true
+    end
+
+    it "should return false to #other-dummy? " do
+      direction.send( "other-#{text}?".to_sym).should be_false
+    end
+
+    context "#to_i" do
+      it "should return provided number" do
+        direction.to_i.should == number
+      end
+    end
+
+    context "#name" do
+      it "should return provided text" do
+        direction.name.should == text
+      end
+    end
+  end
+end

data/spec/models/chouette/exporter_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Chouette::Exporter do
+
+  subject { Chouette::Exporter.new("test") }
+
+  describe "#export" do
+
+    let(:chouette_command) { mock :run! => true }
+
+    before(:each) do
+      subject.stub :chouette_command => chouette_command
+    end
+
+    it "should use specified file in -outputFile option" do
+      chouette_command.should_receive(:run!).with(hash_including(:output_file => File.expand_path('file')))
+      subject.export "file"
+    end
+    
+    it "should use specified format in -format option" do
+      chouette_command.should_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 do
+
+  subject { Chouette::FileValidator.new("public") }
+
+  before(:each) do
+    subject.stub :execute! => true
+  end
+
+
+  describe "#validate" do
+
+    let(:chouette_command) { mock :run! => true }
+
+    before(:each) do
+      subject.stub :chouette_command => chouette_command
+    end
+
+    it "should use specified file in -inputFile option" do
+      chouette_command.should_receive(:run!).with(hash_including(:input_file => File.expand_path('file')))
+      subject.validate "file"
+    end
+        
+  end
+
+end
+

data/spec/models/chouette/group_of_line_spec.rb

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

data/spec/models/chouette/journey_pattern_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe Chouette::JourneyPattern do
+  describe "#stop_point_ids" do
+    context "for a journey_pattern using only route's stop on odd position" do
+      let!(:journey_pattern){ Factory( :journey_pattern_odd)}
+      let!(:vehicle_journey){ Factory( :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
+          vjas_stop_ids.count.should == 0
+        end
+        it "should keep departure and arrival shortcut up to date to nil" do
+          subject.arrival_stop_point_id.should be_nil
+          subject.departure_stop_point_id.should 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)
+          vjas_stop_ids.count.should == subject.stop_point_ids.size
+          vjas_stop_ids.should_not 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}
+
+          subject.arrival_stop_point_id.should == ordered.last.id
+          subject.departure_stop_point_id.should == 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)
+          vjas_stop_ids.count.should == subject.stop_point_ids.size
+          vjas_stop_ids.should 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}
+
+          subject.arrival_stop_point_id.should == ordered.last.id
+          subject.departure_stop_point_id.should == ordered.first.id
+        end
+      end
+    end
+  end
+end

data/spec/models/chouette/line_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+
+describe Chouette::Line do
+
+  subject { Factory(:line) }
+
+  it { should validate_presence_of :network }
+  it { should validate_presence_of :company }
+
+  it { should validate_presence_of :registration_number }
+  it { should validate_uniqueness_of :registration_number }
+
+  it { should validate_presence_of :name }
+  
+  # it { should validate_presence_of :objectid }
+  it { should validate_uniqueness_of :objectid }
+  its(:objectid) { should be_kind_of(Chouette::ObjectId) }
+
+  # it { should validate_numericality_of :objectversion }
+
+  describe ".last_stop_areas_parents" do
+    
+    it "should return stop areas if no parents" do
+      line = Factory(:line_with_stop_areas)
+      line.stop_areas_last_parents.should == line.stop_areas
+    end
+
+    it "should return stop areas parents if parents" do
+      line = Factory(:line_with_stop_areas)
+      route = Factory(:route, :line => line)
+      parent = Factory(:stop_area)
+      stop_areas = [ Factory(:stop_area),  Factory(:stop_area), Factory(:stop_area, :parent_id => parent.id) ]
+      stop_areas.each do |stop_area|
+        Factory(:stop_point, :stop_area => stop_area, :route => route)
+      end   
+
+      line.stop_areas_last_parents.should =~ line.stop_areas[0..(line.stop_areas.size - 2)].push(parent)
+    end
+    
+  end
+
+  describe "#stop_areas" do
+    let!(:route){Factory(:route, :line => subject)}
+    it "should retreive route's stop_areas" do
+      subject.stop_areas.count.should == 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
+          subject.transport_mode.should == transport_mode
+        end
+      end
+    end
+    context "when transport_mode_name is nil" do
+      it "should be nil" do
+        subject.transport_mode_name = nil
+        subject.transport_mode.should be_nil
+      end
+    end
+
+  end
+
+  describe "#transport_mode=" do
+    
+    it "should change transport_mode_name with TransportMode#name" do
+      subject.transport_mode = "Test"
+      subject.transport_mode_name.should == "Test"
+    end
+
+  end
+
+  describe ".transport_modes" do
+    
+    it "should not include unknown transport_mode" do
+      Chouette::Line.transport_modes.should_not include(Chouette::TransportMode.new("unknown"))
+    end
+
+    it "should not include interchange transport_mode" do
+      Chouette::Line.transport_modes.should_not include(Chouette::TransportMode.new("interchange"))
+    end
+
+  end
+  
+  context "#group_of_line_tokens=" do
+    let!(:group_of_line1){Factory(:group_of_line)}
+    let!(:group_of_line2){Factory(: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(',')
+      subject.group_of_lines.should include( group_of_line1)
+      subject.group_of_lines.should include( group_of_line2)
+    end
+  end
+
+
+end

data/spec/models/chouette/loader_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe Chouette::Loader do
+
+  subject { Chouette::Loader.new("test") }
+
+  before(:each) do
+    subject.stub :execute! => true
+  end
+
+  describe "#load_dump" do
+
+  end
+
+  describe "#import" do
+
+    let(:chouette_command) { mock :run! => true }
+
+    before(:each) do
+      subject.stub :chouette_command => chouette_command
+    end
+
+    it "should use specified file in -inputFile option" do
+      chouette_command.should_receive(:run!).with(hash_including(:input_file => File.expand_path('file')))
+      subject.import "file"
+    end
+    
+    it "should use specified format in -format option" do
+      chouette_command.should_receive(:run!).with(hash_including(:format => 'DUMMY'))
+      subject.import "file", :format => "dummy"
+    end
+    
+  end
+
+  describe "#create" do
+    
+    it "should quote schema name" do
+      subject.should_receive(:execute!).with(/"test"/)
+      subject.create
+    end
+
+  end
+
+  describe "#drop" do
+
+    it "should quote schema name" do
+      subject.should_receive(:execute!).with(/"test"/)
+      subject.drop
+    end
+    
+  end
+
+  describe "#backup" do
+
+    let(:file) { "/dev/null" }
+
+    it "should call pg_dump" do
+      subject.should_receive(:execute!).with(/^pg_dump/)
+      subject.backup file
+    end
+
+    it "should dump in specified file" do
+      subject.should_receive(:execute!).with(/-f #{file}/)
+      subject.backup file
+    end
+  end
+
+end
+

data/spec/models/chouette/network_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Chouette::Network do
+
+  subject { Factory(:network) }
+
+  it { should validate_presence_of :registration_number }
+  it { should validate_uniqueness_of :registration_number }
+
+  it { should validate_presence_of :name }
+
+  # it { should validate_presence_of :objectid }
+  it { should validate_uniqueness_of :objectid }
+
+  describe "#stop_areas" do
+    let!(:line){Factory(:line, :network => subject)}
+    let!(:route){Factory(:route, :line => line)}
+    it "should retreive route's stop_areas" do
+      subject.stop_areas.count.should == route.stop_points.count
+    end
+  end
+end