ninoxe 1.1.5 → 1.2.0

data/spec/models/chouette/transport_mode_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Chouette::TransportMode do
+describe Chouette::TransportMode, :type => :model do
   
   def mode(text_code = "test", numerical_code = nil)
     numerical_code ||= 1 if text_code == "test"
@@ -10,31 +10,31 @@ describe Chouette::TransportMode 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("unknown").to_i.should == 0
+      expect(mode("unknown").to_i).to eq(0)
     end
 
     it "should find text code from numerical code" do
-      mode(0).should be_unknown
+      expect(mode(0)).to be_unknown
     end
 
     it "should accept another mode" do
-      Chouette::TransportMode.new(mode("test")).should == mode("test")
+      expect(Chouette::TransportMode.new(mode("test"))).to eq(mode("test"))
     end
     
   end
@@ -42,11 +42,11 @@ describe Chouette::TransportMode do
   describe "#public_transport?" do
     
     it "should return false for interchange" do
-      mode("interchange").should_not be_public_transport
+      expect(mode("interchange")).not_to be_public_transport
     end
 
     it "should return true for other modes" do
-      mode("unknown").should be_public_transport
+      expect(mode("unknown")).to be_public_transport
     end
 
   end
@@ -55,7 +55,7 @@ describe Chouette::TransportMode do
     
     Chouette::TransportMode.definitions.each do |text_code, numerical_code|
       it "should include a TransportMode #{text_code}" do
-        Chouette::TransportMode.all.should include(Chouette::TransportMode.new(text_code))
+        expect(Chouette::TransportMode.all).to include(Chouette::TransportMode.new(text_code))
       end
     end
 

data/spec/models/chouette/trident_active_record_spec.rb

@@ -1,29 +1,29 @@
 require 'spec_helper'
 
-describe Chouette::TridentActiveRecord do
+describe Chouette::TridentActiveRecord, :type => :model do
 
-  it { Chouette::TridentActiveRecord.ancestors.should include(Chouette::ActiveRecord) }
+  it { expect(Chouette::TridentActiveRecord.ancestors).to include(Chouette::ActiveRecord) }
 
-  subject { Factory(:time_table) }
+  subject { create(:time_table) }
 
   describe "#uniq_objectid" do
 
     it "should rebuild objectid" do
-      tm = Factory(:time_table)
+      tm = create(:time_table)
       tm.objectid = subject.objectid
       tm.uniq_objectid
-      tm.objectid.should == subject.objectid+"_1"
+      expect(tm.objectid).to eq(subject.objectid+"_1")
     end
 
     it "should rebuild objectid" do
-      tm = Factory(:time_table)
+      tm = create(:time_table)
       tm.objectid = subject.objectid
       tm.uniq_objectid
       tm.save
-      tm = Factory(:time_table)
+      tm = create(:time_table)
       tm.objectid = subject.objectid
       tm.uniq_objectid
-      tm.objectid.should == subject.objectid+"_2"
+      expect(tm.objectid).to eq(subject.objectid+"_2")
     end
 
   end
@@ -33,19 +33,19 @@ describe Chouette::TridentActiveRecord do
     it "should left objectid" do
       tm = Chouette::TimeTable.new :comment => "merge1" , :objectid => "NINOXE:Timetable:merge1"
       tm.prepare_auto_columns
-      tm.objectid.should == "NINOXE:Timetable:merge1"
+      expect(tm.objectid).to eq("NINOXE:Timetable:merge1")
     end
 
     it "should add pending_id to objectid" do
       tm = Chouette::TimeTable.new :comment => "merge1"
       tm.prepare_auto_columns
-      tm.objectid.start_with?("NINOXE:Timetable:__pending_id__").should be_true
+      expect(tm.objectid.start_with?("NINOXE:Timetable:__pending_id__")).to be_truthy
     end
 
     it "should set id to objectid" do
       tm = Chouette::TimeTable.new :comment => "merge1"
       tm.save
-      tm.objectid.should == "NINOXE:Timetable:"+tm.id.to_s
+      expect(tm.objectid).to eq("NINOXE:Timetable:"+tm.id.to_s)
     end
 
     it "should detect objectid conflicts" do
@@ -55,7 +55,7 @@ describe Chouette::TridentActiveRecord do
       tm.save
       tm = Chouette::TimeTable.new :comment => "merge1"
       tm.save
-      tm.objectid.should == "NINOXE:Timetable:"+tm.id.to_s+"_1"
+      expect(tm.objectid).to eq("NINOXE:Timetable:"+tm.id.to_s+"_1")
     end
 
   end
@@ -65,14 +65,14 @@ describe Chouette::TridentActiveRecord do
     it "should build automatic objectid when empty" do
       g1 = Chouette::GroupOfLine.new( :name => "g1")
       g1.save
-      g1.objectid.should == "NINOXE:GroupOfLine:"+g1.id.to_s
+      expect(g1.objectid).to eq("NINOXE:GroupOfLine:"+g1.id.to_s)
     end
 
     it "should build automatic objectid with fixed when only suffix given" do
       g1 = Chouette::GroupOfLine.new( :name => "g1")
       g1.objectid = "toto"
       g1.save
-      g1.objectid.should == "NINOXE:GroupOfLine:toto"
+      expect(g1.objectid).to eq("NINOXE:GroupOfLine:toto")
     end
     
     it "should build automatic objectid with extension when already exists" do
@@ -83,7 +83,7 @@ describe Chouette::TridentActiveRecord do
       g1.save
       g2 = Chouette::GroupOfLine.new( :name => "g2")
       g2.save
-      g2.objectid.should == "NINOXE:GroupOfLine:"+g2.id.to_s+"_1"
+      expect(g2.objectid).to eq("NINOXE:GroupOfLine:"+g2.id.to_s+"_1")
     end
     
     it "should build automatic objectid with extension when already exists" do
@@ -97,7 +97,7 @@ describe Chouette::TridentActiveRecord do
       g2.save
       g3 = Chouette::GroupOfLine.new( :name => "g3")
       g3.save
-      g3.objectid.should == "NINOXE:GroupOfLine:"+g3.id.to_s+"_2"
+      expect(g3.objectid).to eq("NINOXE:GroupOfLine:"+g3.id.to_s+"_2")
     end
     
     it "should build automatic objectid when id cleared" do
@@ -106,7 +106,7 @@ describe Chouette::TridentActiveRecord do
       g1.save
       g1.objectid = nil
       g1.save
-      g1.objectid.should == "NINOXE:GroupOfLine:"+g1.id.to_s
+      expect(g1.objectid).to eq("NINOXE:GroupOfLine:"+g1.id.to_s)
     end
   end
 

data/spec/models/chouette/vehicle_journey_at_stop_spec.rb

@@ -1,19 +1,20 @@
 require 'spec_helper'
+require 'pp'
 
-describe Chouette::VehicleJourneyAtStop do
-  let!(:vehicle_journey){ Factory(:vehicle_journey_odd)}
+describe Chouette::VehicleJourneyAtStop, :type => :model do
+  let!(:vehicle_journey) { create(:vehicle_journey_odd)}
   subject { vehicle_journey.vehicle_journey_at_stops.first }
 
   describe "#exceeds_gap?" do
     it "should return false if gap < 1.hour" do
       t1 = 1.minutes.ago
       t2 = 1.minutes.ago + 3.hour
-      subject.exceeds_gap?(t1, t2).should be_true
+      expect(subject.exceeds_gap?(t1, t2)).to be_truthy
     end
     it "should return false if gap > 2.hour" do
       t1 = 1.minutes.ago
       t2 = 1.minutes.ago + 3.minutes
-      subject.exceeds_gap?(t1, t2).should be_false
+      expect(subject.exceeds_gap?(t1, t2)).to be_falsey
     end
   end
 
@@ -23,23 +24,23 @@ describe Chouette::VehicleJourneyAtStop do
     context "when vjas#arrival_time exceeds gap" do
       it "should add errors on arrival_time" do
         vjas1.arrival_time = vjas2.arrival_time - 3.hour
-        vjas2.increasing_times_validate(vjas1).should be_false
-        vjas2.errors.should_not be_empty
-        vjas2.errors[:arrival_time].should_not be_blank
+        expect(vjas2.increasing_times_validate(vjas1)).to be_falsey
+        expect(vjas2.errors).not_to be_empty
+        expect(vjas2.errors[:arrival_time]).not_to be_blank
       end
     end
     context "when vjas#departure_time exceeds gap" do
       it "should add errors on departure_time" do
         vjas1.departure_time = vjas2.departure_time - 3.hour
-        vjas2.increasing_times_validate(vjas1).should be_false
-        vjas2.errors.should_not be_empty
-        vjas2.errors[:departure_time].should_not be_blank
+        expect(vjas2.increasing_times_validate(vjas1)).to be_falsey
+        expect(vjas2.errors).not_to be_empty
+        expect(vjas2.errors[:departure_time]).not_to be_blank
       end
     end
     context "when vjas does'nt exceed gap" do
       it "should not add errors" do
-        vjas2.increasing_times_validate(vjas1).should be_true
-        vjas2.errors.should be_empty
+        expect(vjas2.increasing_times_validate(vjas1)).to be_truthy
+        expect(vjas2.errors).to be_empty
       end
     end
   end

data/spec/models/chouette/vehicle_journey_spec.rb

@@ -1,80 +1,80 @@
 require 'spec_helper'
 
-describe Chouette::VehicleJourney do
-  subject { Factory(:vehicle_journey_odd) }
+describe Chouette::VehicleJourney, :type => :model do
+  subject { create(:vehicle_journey_odd) }
 
   describe "in_relation_to_a_journey_pattern methods" do
-    let!(:route) { Factory(:route)}
-    let!(:journey_pattern) { Factory(:journey_pattern, :route => route)}
-    let!(:journey_pattern_odd) { Factory(:journey_pattern_odd, :route => route)}
-    let!(:journey_pattern_even) { Factory(:journey_pattern_even, :route => route)}
+    let!(:route) { create(:route)}
+    let!(:journey_pattern) { create(:journey_pattern, :route => route)}
+    let!(:journey_pattern_odd) { create(:journey_pattern_odd, :route => route)}
+    let!(:journey_pattern_even) { create(:journey_pattern_even, :route => route)}
 
     context "when vehicle_journey is on odd stop whereas selected journey_pattern is on all stops" do
-      subject { Factory(:vehicle_journey, :route => route, :journey_pattern => journey_pattern_odd)}
+      subject { create(:vehicle_journey, :route => route, :journey_pattern => journey_pattern_odd)}
       describe "#extra_stops_in_relation_to_a_journey_pattern" do
         it "should be empty" do
-          subject.extra_stops_in_relation_to_a_journey_pattern( journey_pattern).should be_empty
+          expect(subject.extra_stops_in_relation_to_a_journey_pattern( journey_pattern)).to be_empty
         end
       end
       describe "#extra_vjas_in_relation_to_a_journey_pattern" do
         it "should be empty" do
-          subject.extra_vjas_in_relation_to_a_journey_pattern( journey_pattern).should be_empty
+          expect(subject.extra_vjas_in_relation_to_a_journey_pattern( journey_pattern)).to be_empty
         end
       end
       describe "#missing_stops_in_relation_to_a_journey_pattern" do
         it "should return even stops" do
           result = subject.missing_stops_in_relation_to_a_journey_pattern( journey_pattern)
-          result.should == journey_pattern_even.stop_points
+          expect(result).to eq(journey_pattern_even.stop_points)
         end
       end
       describe "#update_journey_pattern" do
         it "should new_record for added vjas" do
           subject.update_journey_pattern( journey_pattern)
           subject.vehicle_journey_at_stops.select{ |vjas| vjas.new_record? }.each do |vjas|
-            journey_pattern_even.stop_points.should include( vjas.stop_point)
+            expect(journey_pattern_even.stop_points).to include( vjas.stop_point)
           end
         end
         it "should add vjas on each even stops" do
           subject.update_journey_pattern( journey_pattern)
           vehicle_stops = subject.vehicle_journey_at_stops.map(&:stop_point)
           journey_pattern_even.stop_points.each do |sp|
-            vehicle_stops.should include(sp)
+            expect(vehicle_stops).to include(sp)
           end
         end
         it "should not mark any vjas as _destroy" do
           subject.update_journey_pattern( journey_pattern)
-          subject.vehicle_journey_at_stops.any?{ |vjas| vjas._destroy }.should be_false
+          expect(subject.vehicle_journey_at_stops.any?{ |vjas| vjas._destroy }).to be_falsey
         end
       end
     end
     context "when vehicle_journey is on all stops whereas selected journey_pattern is on odd stops" do
-      subject { Factory(:vehicle_journey, :route => route, :journey_pattern => journey_pattern)}
+      subject { create(:vehicle_journey, :route => route, :journey_pattern => journey_pattern)}
       describe "#missing_stops_in_relation_to_a_journey_pattern" do
         it "should be empty" do
-          subject.missing_stops_in_relation_to_a_journey_pattern( journey_pattern_odd).should be_empty
+          expect(subject.missing_stops_in_relation_to_a_journey_pattern( journey_pattern_odd)).to be_empty
         end
       end
       describe "#extra_stops_in_relation_to_a_journey_pattern" do
         it "should return even stops" do
           result = subject.extra_stops_in_relation_to_a_journey_pattern( journey_pattern_odd)
-          result.should == journey_pattern_even.stop_points
+          expect(result).to eq(journey_pattern_even.stop_points)
         end
       end
       describe "#extra_vjas_in_relation_to_a_journey_pattern" do
         it "should return vjas on even stops" do
           result = subject.extra_vjas_in_relation_to_a_journey_pattern( journey_pattern_odd)
-          result.map(&:stop_point).should == journey_pattern_even.stop_points
+          expect(result.map(&:stop_point)).to eq(journey_pattern_even.stop_points)
         end
       end
       describe "#update_journey_pattern" do
         it "should add no new vjas" do
           subject.update_journey_pattern( journey_pattern_odd)
-          subject.vehicle_journey_at_stops.any?{ |vjas| vjas.new_record? }.should be_false
+          expect(subject.vehicle_journey_at_stops.any?{ |vjas| vjas.new_record? }).to be_falsey
         end
         it "should mark vehicle_journey_at_stops as _destroy on even stops" do
           subject.update_journey_pattern( journey_pattern_odd)
           subject.vehicle_journey_at_stops.each { |vjas|
-            vjas._destroy.should == journey_pattern_even.stop_points.include?(vjas.stop_point)
+            expect(vjas._destroy).to eq(journey_pattern_even.stop_points.include?(vjas.stop_point))
           }
         end
       end
@@ -90,8 +90,8 @@ describe Chouette::VehicleJourney do
       end
       it "should make instance invalid" do
         subject.increasing_times
-        subject.vehicle_journey_at_stops[1].errors[:departure_time].should_not be_blank
-        subject.should_not be_valid
+        expect(subject.vehicle_journey_at_stops[1].errors[:departure_time]).not_to be_blank
+        expect(subject).not_to be_valid
       end
     end
     describe "#update_attributes" do
@@ -100,48 +100,48 @@ describe Chouette::VehicleJourney do
             "1"=>{"id" => subject.vehicle_journey_at_stops[1].id, "arrival_time" => (1.minutes.ago + 2.hour),"departure_time" => (1.minutes.ago + 2.hour)}
          }}}
       it "should return false" do
-        subject.update_attributes(params).should be_false
+        expect(subject.update_attributes(params)).to be_falsey
       end
       it "should make instance invalid" do
         subject.update_attributes(params)
-        subject.should_not be_valid
+        expect(subject).not_to be_valid
       end
       it "should let first vjas without any errors" do
         subject.update_attributes(params)
-        subject.vehicle_journey_at_stops[0].errors.should be_empty
+        expect(subject.vehicle_journey_at_stops[0].errors).to be_empty
       end
       it "should add an error on second vjas" do
         subject.update_attributes(params)
-        subject.vehicle_journey_at_stops[1].errors[:departure_time].should_not be_blank
+        expect(subject.vehicle_journey_at_stops[1].errors[:departure_time]).not_to be_blank
       end
     end
   end
 
   context "#time_table_tokens=" do
-    let!(:tm1){Factory(:time_table, :comment => "TM1")}
-    let!(:tm2){Factory(:time_table, :comment => "TM2")}
+    let!(:tm1){create(:time_table, :comment => "TM1")}
+    let!(:tm2){create(:time_table, :comment => "TM2")}
 
     it "should return associated time table ids" do
       subject.update_attributes :time_table_tokens => [tm1.id, tm2.id].join(',')
-      subject.time_tables.should include( tm1)
-      subject.time_tables.should include( tm2)
+      expect(subject.time_tables).to include( tm1)
+      expect(subject.time_tables).to include( tm2)
     end
   end
   describe "#bounding_dates" do
     before(:each) do
-      tm1 = Factory.build(:time_table, :dates =>
-        [ Factory.build(:time_table_date, :date => 1.days.ago.to_date, :in_out => true),
-          Factory.build(:time_table_date, :date => 2.days.ago.to_date, :in_out => true)])
-      tm2 = Factory.build(:time_table, :periods =>
-        [ Factory.build(:time_table_period, :period_start => 4.days.ago.to_date, :period_end => 3.days.ago.to_date)])
-      tm3 = Factory.build(:time_table)
+      tm1 = build(:time_table, :dates =>
+                               [ build(:time_table_date, :date => 1.days.ago.to_date, :in_out => true),
+                                 build(:time_table_date, :date => 2.days.ago.to_date, :in_out => true) ])
+      tm2 = build(:time_table, :periods =>
+                                [ build(:time_table_period, :period_start => 4.days.ago.to_date, :period_end => 3.days.ago.to_date)])
+      tm3 = build(:time_table)
       subject.time_tables = [ tm1, tm2, tm3]
     end
     it "should return min date from associated calendars" do
-      subject.bounding_dates.min.should == 4.days.ago.to_date
+      expect(subject.bounding_dates.min).to eq(4.days.ago.to_date)
     end
     it "should return max date from associated calendars" do
-      subject.bounding_dates.max.should == 1.days.ago.to_date
+      expect(subject.bounding_dates.max).to eq(1.days.ago.to_date)
     end
   end
   context "#vehicle_journey_at_stops" do
@@ -150,7 +150,7 @@ describe Chouette::VehicleJourney do
       vj_stop_ids = subject.vehicle_journey_at_stops.map(&:stop_point_id)
       expected_order = route.stop_points.map(&:id).select {|s_id| vj_stop_ids.include?(s_id)}
 
-      vj_stop_ids.should == expected_order
+      expect(vj_stop_ids).to eq(expected_order)
     end
 
   end
@@ -166,14 +166,14 @@ describe Chouette::VehicleJourney do
         transport_mode_name = Chouette::TransportMode.new(transport_mode.underscore)
         it "should be #{transport_mode_name}" do
           subject.transport_mode = transport_mode
-          subject.transport_mode_name.should == transport_mode_name
+          expect(subject.transport_mode_name).to eq(transport_mode_name)
         end
       end
     end
     context "when transport_mode is nil" do
       it "should be nil" do
         subject.transport_mode = nil
-        subject.transport_mode_name.should be_nil
+        expect(subject.transport_mode_name).to be_nil
       end
     end
 
@@ -183,7 +183,7 @@ describe Chouette::VehicleJourney do
 
     it "should change transport_mode with TransportMode#name" do
       subject.transport_mode_name = "Test"
-      subject.transport_mode.should == "Test"
+      expect(subject.transport_mode).to eq("Test")
     end
 
   end
@@ -191,21 +191,21 @@ describe Chouette::VehicleJourney do
   describe ".transport_mode_names" do
 
     it "should not include unknown transport_mode_name" do
-      Chouette::VehicleJourney.transport_mode_names.should_not include(Chouette::TransportMode.new("unknown"))
+      expect(Chouette::VehicleJourney.transport_mode_names).not_to include(Chouette::TransportMode.new("unknown"))
     end
 
     it "should not include interchange transport_mode" do
-      Chouette::VehicleJourney.transport_mode_names.should_not include(Chouette::TransportMode.new("interchange"))
+      expect(Chouette::VehicleJourney.transport_mode_names).not_to include(Chouette::TransportMode.new("interchange"))
     end
 
   end
 
   describe "#footnote_ids=" do
     context "when line have footnotes, " do
-      let!( :route) { Factory( :route ) }
+      let!( :route) { create( :route ) }
       let!( :line) { route.line }
-      let!( :footnote_first) {Factory( :footnote, :code => "1", :label => "dummy 1", :line => route.line)}
-      let!( :footnote_second) {Factory( :footnote, :code => "2", :label => "dummy 2", :line => route.line)}
+      let!( :footnote_first) {create( :footnote, :code => "1", :label => "dummy 1", :line => route.line)}
+      let!( :footnote_second) {create( :footnote, :code => "2", :label => "dummy 2", :line => route.line)}
 
 
       it "should update vehicle's footnotes" do

data/spec/presenters/chouette/geometry/line_presenter_spec.rb

@@ -1,12 +1,12 @@
 require 'spec_helper'
 
 describe Chouette::Geometry::LinePresenter do
-  let!(:line) { Factory(:line_with_stop_areas_having_parent) }
+  let!(:line) { create(:line_with_stop_areas_having_parent) }
   subject { Chouette::Geometry::LinePresenter.new(line)}
 
   describe "#routes_localized_commercials" do
     it "should return 3 stop_areas" do
-      subject.routes_localized_commercials(line.routes.first).size.should == 5
+      expect(subject.routes_localized_commercials(line.routes.first).size).to eq(10)
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,15 +1,27 @@
 # Configure Rails Envinronment
-ENV["RAILS_ENV"] = "test"
+ENV["RAILS_ENV"] ||= "test"
+require 'spec_helper'
 require File.expand_path("../dummy/config/environment.rb",  __FILE__)
-
 require 'rspec/rails'
-require 'rspec/autorun'
 
+# Add additional requires below this line. Rails is not loaded until this point!
 require 'shoulda-matchers'
 require 'factory_girl_rails'
-
 require 'geo_ruby'
 
+# Requires supporting ruby files with custom matchers and macros, etc, in
+# spec/support/ and its subdirectories. Files matching `spec/**/*_spec.rb` are
+# run as spec files by default. This means that files in spec/support that end
+# in _spec.rb will both be required and run as specs, causing the specs to be
+# run twice. It is recommended that you do not name files matching this glob to
+# end with _spec.rb. You can configure this pattern with the --pattern
+# option on the command line or in ~/.rspec, .rspec or `.rspec-local`.
+#
+# The following line is provided for convenience purposes. It has the downside
+# of increasing the boot-up time by auto-requiring all files in the support
+# directory. Alternatively, in the individual `*_spec.rb` files, manually
+# require only the support files necessary.
+#
 ENGINE_RAILS_ROOT=File.join(File.dirname(__FILE__), '../')
 
 # Requires supporting ruby files with custom matchers and macros, etc,
@@ -17,7 +29,13 @@ ENGINE_RAILS_ROOT=File.join(File.dirname(__FILE__), '../')
 Dir[File.join(ENGINE_RAILS_ROOT, "spec/support/**/*.rb")].each {|f| require f }
 Dir[File.join(ENGINE_RAILS_ROOT, "lib/factories/**/*.rb")].each {|f| require f }
 
+# Checks for pending migrations before tests are run.
+# If you are not using ActiveRecord, you can remove this line.
+ActiveRecord::Migration.maintain_test_schema!
+
 RSpec.configure do |config|
+  config.include FactoryGirl::Syntax::Methods
+  
   # == Mock Framework
   #
   # If you prefer to use mocha, flexmock or RR, uncomment the appropriate line:
@@ -35,11 +53,6 @@ RSpec.configure do |config|
   # instead of true.
   config.use_transactional_fixtures = true
 
-  # If true, the base class of anonymous controllers will be inferred
-  # automatically. This will be the default behavior in future versions of
-  # rspec-rails.
-  config.infer_base_class_for_anonymous_controllers = false
-
 end