ninoxe 1.1.5 → 1.2.0

data/spec/models/chouette/connection_link_spec.rb

@@ -1,17 +1,21 @@
 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) }
+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 { should validate_presence_of :name }
+  it { is_expected.to validate_presence_of :name }
 
   describe "#connection_link_type" do
 
@@ -24,14 +28,14 @@ describe Chouette::ConnectionLink 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
+          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
-        subject.connection_link_type.should be_nil
+        expect(subject.connection_link_type).to be_nil
       end
     end
 
@@ -41,7 +45,7 @@ describe Chouette::ConnectionLink do
     
     it "should change link_type with ConnectionLinkType#name" do
       subject.connection_link_type = "Test"
-      subject.link_type.should == "Test"
+      expect(subject.link_type).to eq("Test")
     end
 
   end
@@ -49,7 +53,7 @@ describe Chouette::ConnectionLink do
   describe ".possible_areas" do
 
     it "should not find areas type ITL" do
-      subject.possible_areas.should_not == [itl] 
+      expect(subject.possible_areas).not_to eq([itl]) 
     end
   end
 

data/spec/models/chouette/direction_spec.rb

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

data/spec/models/chouette/exporter_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Chouette::Exporter do
+describe Chouette::Exporter, :type => :model do
 
   subject { Chouette::Exporter.new("test") }
 
@@ -9,16 +9,16 @@ describe Chouette::Exporter do
     let(:chouette_command) { double :run! => true }
 
     before(:each) do
-      subject.stub :chouette_command => chouette_command
+      allow(subject).to receive_messages :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')))
+      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
-      chouette_command.should_receive(:run!).with(hash_including(:format => 'DUMMY'))
+      expect(chouette_command).to receive(:run!).with(hash_including(:format => 'DUMMY'))
       subject.export "file", :format => "dummy"
     end
     

data/spec/models/chouette/file_validator_spec.rb

@@ -1,11 +1,11 @@
 require 'spec_helper'
 
-describe Chouette::FileValidator do
+describe Chouette::FileValidator, :type => :model do
 
   subject { Chouette::FileValidator.new("public") }
 
   before(:each) do
-    subject.stub :execute! => true
+    allow(subject).to receive_messages :execute! => true
   end
 
 
@@ -14,11 +14,11 @@ describe Chouette::FileValidator do
     let(:chouette_command) { double :run! => true }
 
     before(:each) do
-      subject.stub :chouette_command => chouette_command
+      allow(subject).to receive_messages :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')))
+      expect(chouette_command).to receive(:run!).with(hash_including(:input_file => File.expand_path('file')))
       subject.validate "file"
     end
         

data/spec/models/chouette/footnote_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe Chouette::Footnote do
 
-  subject { Factory.build(:footnote) }
+  subject { build(:footnote) }
 
   it { should validate_presence_of :line }
 

data/spec/models/chouette/group_of_line_spec.rb

@@ -1,30 +1,30 @@
 require 'spec_helper'
 
-describe Chouette::GroupOfLine do
+describe Chouette::GroupOfLine, :type => :model do
 
-  subject { Factory(:group_of_line) }
+  subject { create(:group_of_line) }
 
-  it { should validate_presence_of :name }
+  it { is_expected.to validate_presence_of :name }
 
   # it { should validate_presence_of :objectid }
-  it { should validate_uniqueness_of :objectid }
+  it { is_expected.to validate_uniqueness_of :objectid }
 
   describe "#stop_areas" do
-    let!(:line){Factory(:line, :group_of_lines => [subject])}
-    let!(:route){Factory(:route, :line => line)}
+    let!(:line){create(:line, :group_of_lines => [subject])}
+    let!(:route){create(:route, :line => line)}
     it "should retreive group of line's stop_areas" do
-      subject.stop_areas.count.should == route.stop_points.count
+      expect(subject.stop_areas.count).to eq(route.stop_points.count)
     end
   end
   
   context "#line_tokens=" do
-    let!(:line1){Factory(:line)}
-    let!(:line2){Factory(:line)}
+    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(',')
-      subject.lines.should include( line1)
-      subject.lines.should include( line2)
+      expect(subject.lines).to include( line1)
+      expect(subject.lines).to include( line2)
     end
   end
 

data/spec/models/chouette/journey_pattern_spec.rb

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
-describe Chouette::JourneyPattern do
+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){ Factory( :journey_pattern_odd)}
-      let!(:vehicle_journey){ Factory( :vehicle_journey_odd, :journey_pattern => journey_pattern)}
+      let!(:journey_pattern){ create( :journey_pattern_odd)}
+      let!(:vehicle_journey){ create( :vehicle_journey_odd, :journey_pattern => journey_pattern)}
       
       # workaroud
       #subject { journey_pattern}
@@ -16,13 +16,14 @@ describe Chouette::JourneyPattern do
         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
+          expect(vjas_stop_ids.count).to eq(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
+          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
@@ -30,16 +31,17 @@ describe Chouette::JourneyPattern do
         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)
+          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}
 
-          subject.arrival_stop_point_id.should == ordered.last.id
-          subject.departure_stop_point_id.should == ordered.first.id
+          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
@@ -47,14 +49,14 @@ describe Chouette::JourneyPattern do
         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)
+          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}
 
-          subject.arrival_stop_point_id.should == ordered.last.id
-          subject.departure_stop_point_id.should == ordered.first.id
+          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

data/spec/models/chouette/line_spec.rb

@@ -1,48 +1,52 @@
 require 'spec_helper'
 
-describe Chouette::Line do
+describe Chouette::Line, :type => :model do
 
-  subject { Factory(:line) }
+  subject { create(:line) }
 
-  it { should validate_presence_of :network }
-  it { should validate_presence_of :company }
+  it { is_expected.to validate_presence_of :network }
+  it { is_expected.to 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 { 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 { should validate_uniqueness_of :objectid }
-  its(:objectid) { should be_kind_of(Chouette::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 = Factory(:line_with_stop_areas)
-      line.stop_areas_last_parents.should == line.stop_areas
+      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 = 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) ]
+      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|
-        Factory(:stop_point, :stop_area => stop_area, :route => route)
-      end
+        create(: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)
+      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){Factory(:route, :line => subject)}
+    let!(:route){create(:route, :line => subject)}
     it "should retreive route's stop_areas" do
-      subject.stop_areas.count.should == route.stop_points.count
+      expect(subject.stop_areas.count).to eq(route.stop_points.count)
     end
   end
 
@@ -57,14 +61,14 @@ describe Chouette::Line 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
+          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
-        subject.transport_mode.should be_nil
+        expect(subject.transport_mode).to be_nil
       end
     end
 
@@ -74,7 +78,7 @@ describe Chouette::Line do
 
     it "should change transport_mode_name with TransportMode#name" do
       subject.transport_mode = "Test"
-      subject.transport_mode_name.should == "Test"
+      expect(subject.transport_mode_name).to eq("Test")
     end
 
   end
@@ -82,30 +86,30 @@ describe Chouette::Line do
   describe ".transport_modes" do
 
     it "should not include unknown transport_mode" do
-      Chouette::Line.transport_modes.should_not include(Chouette::TransportMode.new("unknown"))
+      expect(Chouette::Line.transport_modes).not_to 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"))
+      expect(Chouette::Line.transport_modes).not_to 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)}
+    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(',')
-      subject.group_of_lines.should include( group_of_line1)
-      subject.group_of_lines.should include( group_of_line2)
+      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) {Factory.build( :footnote, :line_id => nil)}
-      let!( :footnote_second) {Factory.build( :footnote, :line_id => nil)}
+      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,

data/spec/models/chouette/loader_spec.rb

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

data/spec/models/chouette/network_spec.rb

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