ninoxe 1.1.5 → 1.2.0

data/spec/models/chouette/access_point_spec.rb

@@ -1,83 +1,86 @@
 require 'spec_helper'
 
-describe Chouette::AccessPoint do
+describe Chouette::AccessPoint, :type => :model do
 
-  its(:objectid) { should be_kind_of(Chouette::ObjectId) }
+  describe '#objectid' do
+    subject { super().objectid }
+    it { is_expected.to be_kind_of(Chouette::ObjectId) }
+  end
 
-  it { should validate_presence_of :name }
-  it { should validate_numericality_of :latitude }
-  it { should validate_numericality_of :longitude }
+  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 = Factory :access_point
+      subject = create :access_point
       subject.latitude = -90
-      subject.valid?.should be_true
+      expect(subject.valid?).to be_truthy
     end
     it "should reject < -90 value" do
-      subject = Factory :access_point
+      subject = create :access_point
       subject.latitude = -90.0001
-      subject.valid?.should be_false
+      expect(subject.valid?).to be_falsey
     end
     it "should accept 90 value" do
-      subject = Factory :access_point
+      subject = create :access_point
       subject.latitude = 90
-      subject.valid?.should be_true
+      expect(subject.valid?).to be_truthy
     end
     it "should reject > 90 value" do
-      subject = Factory :access_point
+      subject = create :access_point
       subject.latitude = 90.0001
-      subject.valid?.should be_false
+      expect(subject.valid?).to be_falsey
     end
   end
 
   describe ".longitude" do
     it "should accept -180 value" do
-      subject = Factory :access_point
+      subject = create :access_point
       subject.longitude = -180
-      subject.valid?.should be_true
+      expect(subject.valid?).to be_truthy
     end
     it "should reject < -180 value" do
-      subject = Factory :access_point
+      subject = create :access_point
       subject.longitude = -180.0001
-      subject.valid?.should be_false
+      expect(subject.valid?).to be_falsey
     end
     it "should accept 180 value" do
-      subject = Factory :access_point
+      subject = create :access_point
       subject.longitude = 180
-      subject.valid?.should be_true
+      expect(subject.valid?).to be_truthy
     end
     it "should reject > 180 value" do
-      subject = Factory :access_point
+      subject = create :access_point
       subject.longitude = 180.0001
-      subject.valid?.should be_false
+      expect(subject.valid?).to be_falsey
     end
   end
 
   describe ".long_lat" do
     it "should accept longitude and latitude both as nil" do
-      subject = Factory :access_point
+      subject = create :access_point
       subject.longitude = nil
       subject.latitude = nil
-      subject.valid?.should be_true
+      expect(subject.valid?).to be_truthy
     end
     it "should accept longitude and latitude both numerical" do
-      subject = Factory :access_point
+      subject = create :access_point
       subject.longitude = 10
       subject.latitude = 10
-      subject.valid?.should be_true
+      expect(subject.valid?).to be_truthy
     end
     it "should reject longitude nil with latitude numerical" do
-      subject = Factory :access_point
+      subject = create :access_point
       subject.longitude = nil
       subject.latitude = 10
-      subject.valid?.should be_false
+      expect(subject.valid?).to be_falsey
     end
     it "should reject longitude numerical with latitude nil" do
-      subject = Factory :access_point
+      subject = create :access_point
       subject.longitude = 10
       subject.latitude = nil
-      subject.valid?.should be_false
+      expect(subject.valid?).to be_falsey
     end
   end 
 
@@ -91,7 +94,7 @@ describe Chouette::AccessPoint do
         access_point_type = Chouette::AccessPointType.new(access_type.underscore)
         it "should be #{access_point_type}" do
           subject.access_type = access_type
-          subject.access_point_type.should == access_point_type
+          expect(subject.access_point_type).to eq(access_point_type)
         end
       end
     end
@@ -100,7 +103,7 @@ describe Chouette::AccessPoint do
   describe "#access_point_type=" do    
     it "should change access_type with Chouette::AccessPointType#name" do
       subject.access_point_type = "in_out"
-      subject.access_type.should == "InOut"
+      expect(subject.access_type).to eq("InOut")
     end
 
   end
@@ -109,12 +112,12 @@ describe Chouette::AccessPoint do
     
     it "should return nil if latitude is nil" do
       subject.latitude = nil
-      subject.to_lat_lng.should be_nil
+      expect(subject.to_lat_lng).to be_nil
     end
 
     it "should return nil if longitude is nil" do
       subject.longitude = nil
-      subject.to_lat_lng.should be_nil
+      expect(subject.to_lat_lng).to be_nil
     end
 
   end
@@ -122,36 +125,36 @@ describe Chouette::AccessPoint do
   describe "#geometry" do
     
     it "should be nil when to_lat_lng is nil" do
-      subject.stub :to_lat_lng => nil
-      subject.geometry.should be_nil
+      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 = Factory :stop_area, :area_type => "StopPlace" 
-      commercial_stop_point = Factory :stop_area, :area_type => "CommercialStopPoint" ,:parent => stop_place
-      subject = Factory :access_point, :stop_area => stop_place
-      subject.generic_access_link_matrix.size.should == 2
+      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 = Factory :stop_area, :area_type => "CommercialStopPoint" 
-      subject = Factory :access_point, :stop_area => commercial_stop_point
+      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|
-        link.id.should be_nil
+        expect(link.id).to be_nil
       end
     end
     it "should have only last generic_access_links as new in matrix" do
-      commercial_stop_point = Factory :stop_area, :area_type => "CommercialStopPoint" 
-      subject = Factory :access_point, :stop_area => commercial_stop_point
-      link = Factory :access_link, :access_point => subject, :stop_area => commercial_stop_point
+      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_" 
-          link.id.should_not be_nil
+          expect(link.id).not_to be_nil
         else
-          link.id.should be_nil
+          expect(link.id).to be_nil
         end  
       end
     end
@@ -159,32 +162,32 @@ describe Chouette::AccessPoint do
 
   describe "#detail_access_link_matrix" do
     it "should have 4 detail_access_links in matrix" do
-      stop_place = Factory :stop_area, :area_type => "StopPlace" 
-      commercial_stop_point = Factory :stop_area, :area_type => "CommercialStopPoint" ,:parent => stop_place
-      quay1 = Factory :stop_area, :parent => commercial_stop_point, :area_type => "Quay"
-      quay2 = Factory :stop_area, :parent => commercial_stop_point, :area_type => "Quay"
-      subject = Factory :access_point, :stop_area => stop_place
-      subject.detail_access_link_matrix.size.should == 4
+      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 = Factory :stop_area, :area_type => "CommercialStopPoint" 
-      quay = Factory :stop_area, :parent => commercial_stop_point, :area_type => "Quay"
-      subject = Factory :access_point, :stop_area => commercial_stop_point
+      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|
-        link.id.should be_nil
+        expect(link.id).to be_nil
       end
     end
     it "should have only last detail_access_links as new in matrix" do
-      commercial_stop_point = Factory :stop_area, :area_type => "CommercialStopPoint" 
-      quay = Factory :stop_area, :parent => commercial_stop_point, :area_type => "Quay"
-      subject = Factory :access_point, :stop_area => commercial_stop_point
-      link = Factory :access_link, :access_point => subject, :stop_area => quay
+      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_" 
-          link.id.should_not be_nil
+          expect(link.id).not_to be_nil
         else
-          link.id.should be_nil
+          expect(link.id).to be_nil
         end  
       end
     end
@@ -192,74 +195,74 @@ describe Chouette::AccessPoint do
 
   describe "#coordinates" do
     it "should convert coordinates into latitude/longitude" do
-     commercial_stop_point = Factory :stop_area, :area_type => "CommercialStopPoint" 
-     subject = Factory :access_point, :stop_area => commercial_stop_point, :coordinates => "45.123,120.456"
-     subject.longitude.should be_within(0.001).of(120.456)
-     subject.latitude.should be_within(0.001).of(45.123)
+     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 = Factory :stop_area, :area_type => "CommercialStopPoint" 
-     subject = Factory :access_point, :stop_area => commercial_stop_point, :coordinates => "45.123,120.456"
-     subject.longitude.should be_within(0.001).of(120.456)
-     subject.latitude.should be_within(0.001).of(45.123)
+     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
-     subject.longitude.should be_nil
-     subject.latitude.should be_nil
+     expect(subject.longitude).to be_nil
+     expect(subject.latitude).to be_nil
    end
     it "should convert latitude/longitude into coordinates" do
-     commercial_stop_point = Factory :stop_area, :area_type => "CommercialStopPoint" 
-     subject = Factory :access_point, :stop_area => commercial_stop_point, :longitude => 120.456, :latitude => 45.123
-     subject.coordinates.should == "45.123,120.456"
+     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 = Factory :stop_area, :area_type => "CommercialStopPoint" 
-     subject = Factory :access_point, :stop_area => commercial_stop_point, :longitude => nil, :latitude => nil
-     subject.coordinates.should == ""
+    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 = Factory :stop_area, :area_type => "CommercialStopPoint" 
-     subject = Factory :access_point, :stop_area => commercial_stop_point, :coordinates => "45.123,120.456"
-     subject.valid?.should be_true
+     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"
-     subject.valid?.should be_true
-     subject.longitude.should be_within(0.001).of(120.456)
-     subject.latitude.should be_within(0.001).of(45.123)
+     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"
-     subject.valid?.should be_true
+     expect(subject.valid?).to be_truthy
      subject.coordinates = "45.123 ,120.456"
-     subject.valid?.should be_true
+     expect(subject.valid?).to be_truthy
      subject.coordinates = "45.123   ,   120.456"
-     subject.valid?.should be_true
+     expect(subject.valid?).to be_truthy
      subject.coordinates = " 45.123,120.456"
-     subject.valid?.should be_true
+     expect(subject.valid?).to be_truthy
      subject.coordinates = "45.123,120.456  "
-     subject.valid?.should be_true
+     expect(subject.valid?).to be_truthy
     end
     it "should accept valid coordinates on limits" do
-     commercial_stop_point = Factory :stop_area, :area_type => "CommercialStopPoint" 
-     subject = Factory :access_point, :stop_area => commercial_stop_point, :coordinates => "90,180"
-     subject.valid?.should be_true
+     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"
-     subject.valid?.should be_true
+     expect(subject.valid?).to be_truthy
      subject.coordinates = "-90.,180."
-     subject.valid?.should be_true
+     expect(subject.valid?).to be_truthy
      subject.coordinates = "-90.0,180.00"
-     subject.valid?.should be_true
+     expect(subject.valid?).to be_truthy
     end
     it "should reject invalid coordinates" do
-     commercial_stop_point = Factory :stop_area, :area_type => "CommercialStopPoint" 
-     subject = Factory :access_point, :stop_area => commercial_stop_point
+     commercial_stop_point = create :stop_area, :area_type => "CommercialStopPoint" 
+     subject = create :access_point, :stop_area => commercial_stop_point
      subject.coordinates = ",12"
-     subject.valid?.should be_false
+     expect(subject.valid?).to be_falsey
      subject.coordinates = "-90"
-     subject.valid?.should be_false
+     expect(subject.valid?).to be_falsey
      subject.coordinates = "-90.1,180."
-     subject.valid?.should be_false
+     expect(subject.valid?).to be_falsey
      subject.coordinates = "-90.0,180.1"
-     subject.valid?.should be_false
+     expect(subject.valid?).to be_falsey
      subject.coordinates = "-91.0,18.1"
-     subject.valid?.should be_false
+     expect(subject.valid?).to be_falsey
     end
   end
   

data/spec/models/chouette/active_record_spec.rb

@@ -1,25 +1,25 @@
 require 'spec_helper'
 
-describe Chouette::ActiveRecord do
+describe Chouette::ActiveRecord, :type => :model do
 
-  it { Chouette::ActiveRecord.ancestors.should include(ActiveRecord::Base) }
+  it { expect(Chouette::ActiveRecord.ancestors).to include(ActiveRecord::Base) }
 
   describe "table_name" do
 
     it "should return line for Chouette::Line" do
-      Chouette::Line.table_name.should == "lines"
+      expect(Chouette::Line.table_name).to eq("lines")
     end
     
     it "should return ptnetwork for Chouette::Network" do
-      Chouette::Network.table_name.should == "networks"
+      expect(Chouette::Network.table_name).to eq("networks")
     end
 
     it "should return timetable_date for Chouette::TimeTableDate" do
-      Chouette::TimeTableDate.table_name.should == "time_table_dates"
+      expect(Chouette::TimeTableDate.table_name).to eq("time_table_dates")
     end
 
     it "should return timetable_period for Chouette::TimeTablePeriod" do
-      Chouette::TimeTablePeriod.table_name.should == "time_table_periods"
+      expect(Chouette::TimeTablePeriod.table_name).to eq("time_table_periods")
     end
 
   end
@@ -28,7 +28,7 @@ describe Chouette::ActiveRecord do
     
     it "should support method with additionnal underscores" do
       stop_area = Chouette::StopArea.new
-      stop_area.area_type.should == stop_area.area_type
+      expect(stop_area.area_type).to eq(stop_area.area_type)
     end
 
   end
@@ -38,84 +38,84 @@ describe Chouette::ActiveRecord do
     
     it "should respond to method with additionnal underscores" do
       stop_area = Chouette::StopArea.new
-      stop_area.respond_to?(:area_type).should be_true
+      expect(stop_area.respond_to?(:area_type)).to be_truthy
     end
 
   end
 
-  describe "create_reflection" do
+#   describe "create_reflection" do
 
-    let(:macro) { :has_many }
-    let(:name) { :lines }
-    let(:options) { {} }
-    let(:active_record) { Chouette::Network }
+#     let(:macro) { :has_many }
+#     let(:name) { :lines }
+#     let(:options) { {} }
+#     let(:active_record) { Chouette::Network }
     
-    let(:modified_options) { {:modified => true}  }
+#     let(:modified_options) { {:modified => true}  }
 
-    it "should invoke create_reflection_without_chouette_naming with modified options" do
-      Chouette::ActiveRecord::Reflection.stub :new => double(:options_with_default => modified_options)
-      Chouette::ActiveRecord.should_receive(:create_reflection_without_chouette_naming).with macro, name, modified_options, active_record
+#     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
+#       Chouette::ActiveRecord.create_reflection macro, name, options, active_record
+#     end
 
-  end
+#   end
 
 end
 
-describe Chouette::ActiveRecord::Reflection do
+# describe Chouette::ActiveRecord::Reflection, :type => :model do
 
-  let(:macro) { :has_many }
-  let(:name) { :lines }
-  let(:options) { {} }
-  let(:active_record) { Chouette::Network }
+#   let(:macro) { :has_many }
+#   let(:name) { :lines }
+#   let(:options) { {} }
+#   let(:active_record) { Chouette::Network }
 
-  subject { Chouette::ActiveRecord::Reflection.new macro, name, options, active_record }
+#   subject { Chouette::ActiveRecord::Reflection.new macro, name, options, active_record }
 
-  describe "collection?" do
+#   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 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
-      subject.stub :macro => :belong_to
-      subject.should_not 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
+#   end
 
-  describe "class_name" do
+#   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::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
-      subject.stub :name => "routes", :collection? => true
-      subject.class_name.should == "Chouette::Route"
-    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
+#   end
 
 
-  describe "options" do
+#   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 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
-      subject.stub :options => {:class_name => "dummy"}
-      subject.options_with_default[:class_name].should == "dummy"
-    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
   
 
-end
+# end
 
 

data/spec/models/chouette/area_type_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Chouette::AreaType do
+describe Chouette::AreaType, :type => :model do
   
   def mode(text_code = "test", numerical_code = nil)
     numerical_code ||= 1 if text_code == "test"
@@ -10,31 +10,31 @@ describe Chouette::AreaType do
   describe "#to_i" do
     
     it "should return numerical code" do
-      mode("test", 1).to_i.should == 1
+      expect(mode("test", 1).to_i).to eq(1)
     end
 
   end
 
   it "should return true to #test? when text code is 'test'" do
-    mode("test").should be_test
+    expect(mode("test")).to be_test
   end
 
   it "should be equal when text codes are identical" do
-    mode("test",1).should == mode("test", 2)
+    expect(mode("test",1)).to eq(mode("test", 2))
   end
 
   describe ".new" do
 
     it "should find numerical code from text code" do
-      mode("boarding_position").to_i.should == 0
+      expect(mode("boarding_position").to_i).to eq(0)
     end
 
     it "should find text code from numerical code" do
-      mode(0).should == "boarding_position"
+      expect(mode(0)).to eq("boarding_position")
     end
 
     it "should accept another mode" do
-      Chouette::AreaType.new(mode("test")).should == mode("test")
+      expect(Chouette::AreaType.new(mode("test"))).to eq(mode("test"))
     end
     
   end
@@ -44,7 +44,7 @@ describe Chouette::AreaType 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))
+        expect(Chouette::AreaType.all).to include(Chouette::AreaType.new(text_code))
       end
     end
 

data/spec/models/chouette/company_spec.rb

@@ -1,16 +1,16 @@
 require 'spec_helper'
 
-describe Chouette::Company do
+describe Chouette::Company, :type => :model do
 
-  subject { Factory(:company) }
+  subject { create(:company) }
 
-  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 "#nullables empty" do
     it "should set null empty nullable attributes" do
@@ -21,12 +21,12 @@ describe Chouette::Company do
       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
+      expect(subject.organizational_unit).to be_nil
+      expect(subject.operating_department_name).to be_nil
+      expect(subject.code).to be_nil
+      expect(subject.phone).to be_nil
+      expect(subject.fax).to be_nil
+      expect(subject.email).to be_nil
     end
   end
 
@@ -39,12 +39,12 @@ describe Chouette::Company do
       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
+      expect(subject.organizational_unit).not_to be_nil
+      expect(subject.operating_department_name).not_to be_nil
+      expect(subject.code).not_to be_nil
+      expect(subject.phone).not_to be_nil
+      expect(subject.fax).not_to be_nil
+      expect(subject.email).not_to be_nil
     end
   end