ninoxe 1.1.4 → 1.1.5

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) { double :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) { double :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/footnote_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Chouette::Footnote do
+
+  subject { Factory.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 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,119 @@
+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
+
+  describe "#update_attributes footnotes_attributes" do
+    context "instanciate 2 footnotes without line" do
+      let!( :footnote_first) {Factory.build( :footnote, :line_id => nil)}
+      let!( :footnote_second) {Factory.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

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) { double :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

data/spec/models/chouette/object_id_spec.rb

@@ -0,0 +1,146 @@
+require 'spec_helper'
+
+describe Chouette::ObjectId do
+
+  def objectid(value = "abc:StopArea:abc123")
+    Chouette::ObjectId.new value
+  end
+
+  subject { objectid }
+
+  context "when invalid" do
+
+    subject { objectid("abc") }
+
+    it { should_not be_valid }
+
+    its(:parts) { should be_nil }
+    its(:system_id) { should be_nil }
+
+  end
+  
+  context "when with spaces in last part" do
+
+    subject { objectid("abc:Line:Aze toto") }
+
+    it { should_not be_valid }
+
+
+  end
+  
+  context "when with spaces in first part" do
+
+    subject { objectid("ae abc:Line:Aze") }
+
+    it { should_not be_valid }
+
+
+  end
+  
+  context "when with spaces in middle part" do
+
+    subject { objectid("aeabc:Li ne:Aze") }
+
+    it { should_not be_valid }
+    
+
+  end
+  
+  context "when invalid in first part" do
+
+    subject { objectid("Abc_+19:Line:Abc") }
+
+    it { should_not be_valid }
+  end
+  
+  context "when invalid in middle part" do
+
+    subject { objectid("Abc_19:Li56ne:Abc") }
+
+    it { should_not be_valid }
+  end
+
+  context "when invalid in last part" do
+
+    subject { objectid("Abc_19:Line:Ab+c") }
+
+    it { should_not be_valid }
+  end
+  context "when valid" do
+
+    subject { objectid("Abc_19:Line:Abc_12-") }
+
+    it { should be_valid }
+  end
+
+  describe "#parts" do
+
+    it "should be the 3 parts of the ObjectId" do
+      objectid("abc:StopArea:abc123").parts.should == %w{abc StopArea abc123}
+    end
+
+  end
+
+  describe "#system_id" do
+    
+    it "should be the first ObjectId parts" do
+      objectid("first:second:third").system_id.should == "first"
+    end
+
+  end
+
+  describe "#object_type" do
+    
+    it "should be the second ObjectId parts" do
+      objectid("first:second:third").object_type.should == "second"
+    end
+
+  end
+
+  describe "#local_id" do
+    
+    it "should be the third ObjectId parts" do
+      objectid("first:second:third").local_id.should == "third"
+    end
+
+  end
+
+  it "should be valid when parts are found" do
+    subject.stub :parts => "dummy"
+    subject.should 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) }
+    
+    RSpec::Matchers.define :return_an_objectid_with_given do |attribute|
+      match do |actual|
+        actual.send(attribute).should == send("given_#{attribute}")
+      end
+    end
+
+    it { should return_an_objectid_with_given(:system_id) }
+    it { should return_an_objectid_with_given(:object_type) }
+    it { should return_an_objectid_with_given(:local_id) }
+
+  end
+
+  describe ".new" do
+    
+    it "should return an existing ObjectId" do
+      Chouette::ObjectId.new(objectid).should == objectid
+    end
+
+    it "should create an empty ObjectId with nil" do
+      Chouette::ObjectId.new(nil).should be_empty
+    end
+
+  end
+
+
+end