ninoxe 1.1.5 → 1.2.0

data/spec/models/chouette/object_id_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Chouette::ObjectId do
+describe Chouette::ObjectId, :type => :model do
 
   def objectid(value = "abc:StopArea:abc123")
     Chouette::ObjectId.new value
@@ -12,10 +12,17 @@ describe Chouette::ObjectId do
 
     subject { objectid("abc") }
 
-    it { should_not be_valid }
+    it { is_expected.not_to be_valid }
 
-    its(:parts) { should be_nil }
-    its(:system_id) { should be_nil }
+    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
   
@@ -23,7 +30,7 @@ describe Chouette::ObjectId do
 
     subject { objectid("abc:Line:Aze toto") }
 
-    it { should_not be_valid }
+    it { is_expected.not_to be_valid }
 
 
   end
@@ -32,7 +39,7 @@ describe Chouette::ObjectId do
 
     subject { objectid("ae abc:Line:Aze") }
 
-    it { should_not be_valid }
+    it { is_expected.not_to be_valid }
 
 
   end
@@ -41,7 +48,7 @@ describe Chouette::ObjectId do
 
     subject { objectid("aeabc:Li ne:Aze") }
 
-    it { should_not be_valid }
+    it { is_expected.not_to be_valid }
     
 
   end
@@ -50,33 +57,33 @@ describe Chouette::ObjectId do
 
     subject { objectid("Abc_+19:Line:Abc") }
 
-    it { should_not be_valid }
+    it { is_expected.not_to be_valid }
   end
   
   context "when invalid in middle part" do
 
     subject { objectid("Abc_19:Li56ne:Abc") }
 
-    it { should_not be_valid }
+    it { is_expected.not_to be_valid }
   end
 
   context "when invalid in last part" do
 
     subject { objectid("Abc_19:Line:Ab+c") }
 
-    it { should_not be_valid }
+    it { is_expected.not_to be_valid }
   end
   context "when valid" do
 
     subject { objectid("Abc_19:Line:Abc_12-") }
 
-    it { should be_valid }
+    it { is_expected.to 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}
+      expect(objectid("abc:StopArea:abc123").parts).to eq(%w{abc StopArea abc123})
     end
 
   end
@@ -84,7 +91,7 @@ describe Chouette::ObjectId do
   describe "#system_id" do
     
     it "should be the first ObjectId parts" do
-      objectid("first:second:third").system_id.should == "first"
+      expect(objectid("first:second:third").system_id).to eq("first")
     end
 
   end
@@ -92,7 +99,7 @@ describe Chouette::ObjectId do
   describe "#object_type" do
     
     it "should be the second ObjectId parts" do
-      objectid("first:second:third").object_type.should == "second"
+      expect(objectid("first:second:third").object_type).to eq("second")
     end
 
   end
@@ -100,14 +107,14 @@ describe Chouette::ObjectId do
   describe "#local_id" do
     
     it "should be the third ObjectId parts" do
-      objectid("first:second:third").local_id.should == "third"
+      expect(objectid("first:second:third").local_id).to eq("third")
     end
 
   end
 
   it "should be valid when parts are found" do
-    subject.stub :parts => "dummy"
-    subject.should be_valid
+    allow(subject).to receive_messages :parts => "dummy"
+    expect(subject).to be_valid
   end
 
   describe ".create" do
@@ -117,27 +124,23 @@ describe Chouette::ObjectId do
     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) }
+    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
-      Chouette::ObjectId.new(objectid).should == objectid
+      expect(Chouette::ObjectId.new(objectid)).to eq(objectid)
     end
 
     it "should create an empty ObjectId with nil" do
-      Chouette::ObjectId.new(nil).should be_empty
+      expect(Chouette::ObjectId.new(nil)).to be_empty
     end
 
   end

data/spec/models/chouette/route_spec.rb

@@ -1,15 +1,19 @@
 require 'spec_helper'
 
-describe Chouette::Route do
-  subject { Factory(:route) }
+describe Chouette::Route, :type => :model do
+  subject { create(:route) }
 
-  it { should validate_uniqueness_of :objectid }
-  its(:objectid) { should be_kind_of(Chouette::ObjectId) }
+  it { is_expected.to validate_uniqueness_of :objectid }
 
-  it { should validate_presence_of :name }
-  it { should validate_presence_of :line }
-  it { should validate_presence_of :wayback_code }
-  it { should validate_presence_of :direction_code }
+  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}}
@@ -19,7 +23,7 @@ describe Chouette::Route do
     describe "#reorder!" do
       context "invalid stop_point_ids" do
         let( :new_stop_point_ids) { bad_stop_point_ids}
-        it { subject.reorder!( new_stop_point_ids).should be_false}
+        it { expect(subject.reorder!( new_stop_point_ids)).to be_falsey}
       end
 
       context "swaped last and first stop_point_ids" do
@@ -28,13 +32,13 @@ describe Chouette::Route do
         let!( :old_stop_area_ids) { subject.stop_areas.map(&:id) }
 
         it "should keep stop_point_ids order unchanged" do
-          subject.reorder!( new_stop_point_ids).should be_true
-          subject.stop_points.map(&:id).should eq( old_stop_point_ids)
+          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
-          subject.reorder!( new_stop_point_ids).should be_true
+          expect(subject.reorder!( new_stop_point_ids)).to be_truthy
           subject.reload
-          subject.stop_areas.map(&:id).should eq( [old_stop_area_ids.last] + old_stop_area_ids[1..-2] + [old_stop_area_ids.first])
+          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
@@ -42,29 +46,29 @@ describe Chouette::Route do
     describe "#stop_point_permutation?" do
       context "invalid stop_point_ids" do
         let( :new_stop_point_ids) { bad_stop_point_ids}
-        it { should_not be_stop_point_permutation( new_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 { should be_stop_point_permutation( new_stop_point_ids)}
+        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 { should be_stop_point_permutation( new_stop_point_ids)}
+        it { is_expected.to be_stop_point_permutation( new_stop_point_ids)}
       end
     end
   end
 
   describe "#stop_points_attributes=" do
-      let( :journey_pattern) { Factory( :journey_pattern, :route => subject )}
-      let( :vehicle_journey) { Factory( :vehicle_journey, :journey_pattern => journey_pattern)}
+      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 ){Factory.build( :stop_point, :route => subject)}
+          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" => "" )
@@ -74,15 +78,15 @@ describe Chouette::Route do
 
           it "should have added stop_point in route" do
               subject.update_attributes( :stop_points_attributes => added_stop_hash)
-              Chouette::Route.find( subject.id ).stop_points.size.should == new_route_size
+              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)
-              Chouette::JourneyPattern.find( journey_pattern.id ).stop_points.size.should == new_route_size
+              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)
-              Chouette::VehicleJourney.find( vehicle_journey.id ).vehicle_journey_at_stops.size.should == new_route_size
+              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
@@ -92,19 +96,19 @@ describe Chouette::Route do
                 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) )}.join(",") }
+          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)
-              Chouette::Route.find( subject.id ).stop_points.map(&:id).join(",").should == new_stop_id_list
+              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)
-              Chouette::JourneyPattern.find( journey_pattern.id ).stop_points.map(&:id).join(",").should == new_stop_id_list
+              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)
-              Chouette::VehicleJourney.find( vehicle_journey.id ).vehicle_journey_at_stops.map(&:stop_point_id).join(",").should == new_stop_id_list
+              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
@@ -113,19 +117,19 @@ describe Chouette::Route do
                 h[ "1" ][ "_destroy" ] = "1"
             end
           end
-          let!( :new_stop_id_list ){ subject.stop_points.map(&:id).tap {|array| array.delete_at(1) }.join(",") }
+          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)
-              Chouette::Route.find( subject.id ).stop_points.map(&:id).join(",").should == new_stop_id_list
+              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)
-              Chouette::JourneyPattern.find( journey_pattern.id ).stop_points.map(&:id).join(",").should == new_stop_id_list
+              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)
-              Chouette::VehicleJourney.find( vehicle_journey.id ).vehicle_journey_at_stops.map(&:stop_point_id).join(",").should == new_stop_id_list
+              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
@@ -135,29 +139,29 @@ describe Chouette::Route do
       context "when arg is first quay id" do
         let(:first_stop_point) { subject.stop_points.first}
         it "should return first quay" do
-          subject.stop_points.find_by_stop_area( first_stop_point.stop_area_id).should eq( first_stop_point)
+          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){ Factory(:line)}
-    let(:route_1){ Factory(:route, :line => line)}
-    let(:route_2){ Factory(:route, :line => line)}
+    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|
-        sa.stop_points.map(&:route_id).uniq.should == [route_1.id]
+        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 = Factory(:route, :line => line)
+        route_loop = create(:route, :line => line)
         first_stop = Chouette::StopPoint.where( :route_id => route_loop.id, :position => 0).first
-        last_stop = Factory(:stop_point, :route => route_loop, :position => 5, :stop_area => first_stop.stop_area)
+        last_stop = create(:stop_point, :route => route_loop, :position => 4, :stop_area => first_stop.stop_area)
 
-        route_loop.stop_areas.size.should == 6
-        route_loop.stop_areas.select {|s| s.id == first_stop.stop_area.id}.size.should == 2
+        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
@@ -172,14 +176,14 @@ describe Chouette::Route do
         direction_code = Chouette::Direction.new( Chouette::Route.direction_binding[ direction])
         it "should be #{direction_code}" do
           subject.direction = direction
-          subject.direction_code.should == direction_code
+          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
-        subject.direction_code.should be_nil
+        expect(subject.direction_code).to be_nil
       end
     end
   end
@@ -187,13 +191,13 @@ describe Chouette::Route do
     context "when unknown direction is provided" do
       it "should change direction to nil" do
         subject.direction_code = "dummy"
-        subject.direction.should be_nil
+        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"
-        subject.direction.should == "West"
+        expect(subject.direction).to eq("West")
       end
     end
   end
@@ -206,14 +210,14 @@ describe Chouette::Route do
         wayback_code = Chouette::Wayback.new( Chouette::Route.wayback_binding[ wayback])
         it "should be #{wayback_code}" do
           subject.wayback = wayback
-          subject.wayback_code.should == wayback_code
+          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
-        subject.wayback_code.should be_nil
+        expect(subject.wayback_code).to be_nil
       end
     end
   end
@@ -221,13 +225,13 @@ describe Chouette::Route do
     context "when unknown wayback is provided" do
       it "should change wayback to nil" do
         subject.wayback_code = "dummy"
-        subject.wayback.should be_nil
+        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"
-        subject.wayback.should == "A"
+        expect(subject.wayback).to eq("A")
       end
     end
   end