20 files changed, 770 insertions, 740 deletions

diff --git a/spec/models/api/v1/api_key_spec.rb b/spec/models/api/v1/api_key_spec.rb
index 02c68ea13..3da11527c 100644
--- a/spec/models/api/v1/api_key_spec.rb
+++ b/spec/models/api/v1/api_key_spec.rb
@@ -1,12 +1,12 @@
 require 'spec_helper'
 
-describe Api::V1::ApiKey do
+describe Api::V1::ApiKey, :type => :model do
   let!(:referential){Factory(:referential)}
   subject { Api::V1::ApiKey.create( :name => "test", :referential => referential)}
 
   it "test" do
-    subject.should be_valid
-    subject.referential.should == referential
+    expect(subject).to be_valid
+    expect(subject.referential).to eq(referential)
 
   end
 end
diff --git a/spec/models/compliance_check_result_spec.rb b/spec/models/compliance_check_result_spec.rb
index 4d73d8ad3..42a2e4507 100644
--- a/spec/models/compliance_check_result_spec.rb
+++ b/spec/models/compliance_check_result_spec.rb
@@ -1,68 +1,100 @@
-require 'spec_helper'
-
-describe ComplianceCheckResult do
-
-  subject { Factory( :compliance_check_result)}
-
-  describe "#indice" do
-    context "when 1-NEPTUNE-XML-1 result" do
-      before(:each) do
-        subject.rule_code = "1-NEPTUNE-XML-1"
-      end
-      its(:indice) { should == 1 }
-    end
-    context "when 2-NETEX-AccessLink-2 result" do
-      before(:each) do
-        subject.rule_code = "2-NETEX-AccessLink-2"
-      end
-      its(:indice) { should == 2 }
-    end
-  end
-
-  describe "#data_type" do
-    context "when 1-NEPTUNE-XML-1 result" do
-      before(:each) do
-        subject.rule_code = "1-NEPTUNE-XML-1"
-      end
-      its(:data_type) { should == "XML" }
-    end
-    context "when 2-NETEX-AccessLink-2 result" do
-      before(:each) do
-        subject.rule_code = "2-NETEX-AccessLink-2"
-      end
-      its(:data_type) { should == "AccessLink" }
-    end
-  end
-
-  describe "#format" do
-    context "when 1-NEPTUNE-XML-1 result" do
-      before(:each) do
-        subject.rule_code = "1-NEPTUNE-XML-1"
-      end
-      its(:format) { should == "NEPTUNE" }
-    end
-    context "when 2-NETEX-AccessLink-2 result" do
-      before(:each) do
-        subject.rule_code = "2-NETEX-AccessLink-2"
-      end
-      its(:format) { should == "NETEX" }
-    end
-  end
-
-  describe "#level" do
-    context "when 1-NEPTUNE-XML-1 result" do
-      before(:each) do
-        subject.rule_code = "1-NEPTUNE-XML-1"
-      end
-      its(:level) { should == 1 }
-    end
-    context "when 2-NEPTUNE-AccessLink-2 result" do
-      before(:each) do
-        subject.rule_code = "2-NEPTUNE-AccessLink-2"
-      end
-      its(:level) { should == 2 }
-    end
-  end
-
-end
+# require 'spec_helper'
+
+# describe ComplianceCheckResult, :type => :model do
+
+#   subject { Factory( :compliance_check_result)}
+
+#   describe "#indice" do
+#     context "when 1-NEPTUNE-XML-1 result" do
+#       before(:each) do
+#         subject.rule_code = "1-NEPTUNE-XML-1"
+#       end
+
+#       describe '#indice' do
+#         subject { super().indice }
+#         it { is_expected.to eq(1) }
+#       end
+#     end
+#     context "when 2-NETEX-AccessLink-2 result" do
+#       before(:each) do
+#         subject.rule_code = "2-NETEX-AccessLink-2"
+#       end
+
+#       describe '#indice' do
+#         subject { super().indice }
+#         it { is_expected.to eq(2) }
+#       end
+#     end
+#   end
+
+#   describe "#data_type" do
+#     context "when 1-NEPTUNE-XML-1 result" do
+#       before(:each) do
+#         subject.rule_code = "1-NEPTUNE-XML-1"
+#       end
+
+#       describe '#data_type' do
+#         subject { super().data_type }
+#         it { is_expected.to eq("XML") }
+#       end
+#     end
+#     context "when 2-NETEX-AccessLink-2 result" do
+#       before(:each) do
+#         subject.rule_code = "2-NETEX-AccessLink-2"
+#       end
+
+#       describe '#data_type' do
+#         subject { super().data_type }
+#         it { is_expected.to eq("AccessLink") }
+#       end
+#     end
+#   end
+
+#   describe "#format" do
+#     context "when 1-NEPTUNE-XML-1 result" do
+#       before(:each) do
+#         subject.rule_code = "1-NEPTUNE-XML-1"
+#       end
+
+#       describe '#format' do
+#         subject { super().format }
+#         it { is_expected.to eq("NEPTUNE") }
+#       end
+#     end
+#     context "when 2-NETEX-AccessLink-2 result" do
+#       before(:each) do
+#         subject.rule_code = "2-NETEX-AccessLink-2"
+#       end
+
+#       describe '#format' do
+#         subject { super().format }
+#         it { is_expected.to eq("NETEX") }
+#       end
+#     end
+#   end
+
+#   describe "#level" do
+#     context "when 1-NEPTUNE-XML-1 result" do
+#       before(:each) do
+#         subject.rule_code = "1-NEPTUNE-XML-1"
+#       end
+
+#       describe '#level' do
+#         subject { super().level }
+#         it { is_expected.to eq(1) }
+#       end
+#     end
+#     context "when 2-NEPTUNE-AccessLink-2 result" do
+#       before(:each) do
+#         subject.rule_code = "2-NEPTUNE-AccessLink-2"
+#       end
+
+#       describe '#level' do
+#         subject { super().level }
+#         it { is_expected.to eq(2) }
+#       end
+#     end
+#   end
+
+# end
 
diff --git a/spec/models/compliance_check_task_spec.rb b/spec/models/compliance_check_task_spec.rb
index 475926a7c..2e5379de7 100644
--- a/spec/models/compliance_check_task_spec.rb
+++ b/spec/models/compliance_check_task_spec.rb
@@ -1,314 +1,314 @@
-require 'spec_helper'
+# require 'spec_helper'
 
-describe ComplianceCheckTask do
+# describe ComplianceCheckTask, :type => :model do
 
-  subject { Factory( :compliance_check_task ) }
+#   subject { Factory( :compliance_check_task ) }
 
-  RSpec::Matchers.define :be_log_message do |expected|
-    match do |actual|
-      actual and expected.all? { |k,v| actual[k.to_s] == v }
-    end
-  end
+#   RSpec::Matchers.define :be_log_message do |expected|
+#     match do |actual|
+#       actual and expected.all? { |k,v| actual[k.to_s] == v }
+#     end
+#   end
 
 
-  describe "#any_error_severity_failure?" do
-    context "when compliance_check_results empty" do
-      before(:each) do
-        subject.compliance_check_results = []
-      end
-      it "does return false" do
-        subject.any_error_severity_failure?.should be_false
-      end
-    end
-    context "when compliance_check_results contains a error_severity_failure" do
-      let( :valid_result){ Factory.build( :compliance_check_result) }
-      let( :invalid_result){ Factory.build( :compliance_check_result, :severity => "error", :status => "nok") }
-      before(:each) do
-        subject.compliance_check_results = [ valid_result, invalid_result]
-      end
-      it "does return true" do
-        subject.any_error_severity_failure?.should be_true
-      end
-    end
-    context "when compliance_check_results contains no error_severity_failure" do
-      let( :valid_result){ Factory.build( :compliance_check_result) }
-      before(:each) do
-        subject.compliance_check_results = [ valid_result]
-      end
-      it "does return false" do
-        subject.any_error_severity_failure?.should be_false
-      end
-    end
-  end
+#   describe "#any_error_severity_failure?" do
+#     context "when compliance_check_results empty" do
+#       before(:each) do
+#         subject.compliance_check_results = []
+#       end
+#       it "does return false" do
+#         expect(subject.any_error_severity_failure?).to be_falsey
+#       end
+#     end
+#     context "when compliance_check_results contains a error_severity_failure" do
+#       let( :valid_result){ Factory.build( :compliance_check_result) }
+#       let( :invalid_result){ Factory.build( :compliance_check_result, :severity => "error", :status => "nok") }
+#       before(:each) do
+#         subject.compliance_check_results = [ valid_result, invalid_result]
+#       end
+#       it "does return true" do
+#         expect(subject.any_error_severity_failure?).to be_truthy
+#       end
+#     end
+#     context "when compliance_check_results contains no error_severity_failure" do
+#       let( :valid_result){ Factory.build( :compliance_check_result) }
+#       before(:each) do
+#         subject.compliance_check_results = [ valid_result]
+#       end
+#       it "does return false" do
+#         expect(subject.any_error_severity_failure?).to be_falsey
+#       end
+#     end
+#   end
 
-  describe "#destroy" do
-    let(:import_task){ Factory( :import_task )}
-    context "with an import_task" do
-        before(:each) do
-          subject.import_task = import_task
-        end
-        it "should destroy import_task" do
-          subject.destroy
-          ImportTask.exists?( import_task.id).should be_false
-        end
-    end
-    context "without any import_task" do
-        before(:each) do
-          subject.import_task = nil
-        end
-        it "should not raise exception" do
-          subject.destroy
-          subject.should be_destroyed
-        end
-    end
-  end
+#   describe "#destroy" do
+#     let(:import_task){ Factory( :import_task )}
+#     context "with an import_task" do
+#         before(:each) do
+#           subject.import_task = import_task
+#         end
+#         it "should destroy import_task" do
+#           subject.destroy
+#           expect(ImportTask.exists?( import_task.id)).to be_falsey
+#         end
+#     end
+#     context "without any import_task" do
+#         before(:each) do
+#           subject.import_task = nil
+#         end
+#         it "should not raise exception" do
+#           subject.destroy
+#           expect(subject).to be_destroyed
+#         end
+#     end
+#   end
 
-  describe "#levels" do
-    let(:import_task){ Factory( :import_task )}
-    context "when validation is without import" do
-      it "should not return levels 1 and 2" do
-        subject.levels.include?(1).should be_false
-        subject.levels.include?(2).should be_false
-      end
-      context "when parameter_set is defined" do
-        before(:each) do
-          subject.parameter_set = "dummy"
-        end
-        it "should return level 3" do
-          subject.levels.include?(3).should be_true
-        end
-      end
-      context "when parameter_set is not defined" do
-        before(:each) do
-          subject.parameter_set = nil
-        end
-        it "should not return level 3" do
-          subject.levels.include?(3).should_not be_true
-        end
-      end
-    end
-    context "when validation is done with an import" do
-      before(:each) do
-        subject.import_task = import_task
-      end
-      it "should return levels 1 and 2" do
-        subject.levels.include?(1).should be_true
-        subject.levels.include?(2).should be_true
-      end
-      context "when parameter_set is defined" do
-        before(:each) do
-          subject.parameter_set = "dummy"
-        end
-        it "should return level 3" do
-          subject.levels.include?(3).should be_true
-        end
-      end
-      context "when parameter_set is not defined" do
-        before(:each) do
-          subject.parameter_set = nil
-        end
-        it "should not return level 3" do
-          subject.levels.include?(3).should_not be_true
-        end
-      end
-    end
+#   describe "#levels" do
+#     let(:import_task){ Factory( :import_task )}
+#     context "when validation is without import" do
+#       it "should not return levels 1 and 2" do
+#         expect(subject.levels.include?(1)).to be_falsey
+#         expect(subject.levels.include?(2)).to be_falsey
+#       end
+#       context "when parameter_set is defined" do
+#         before(:each) do
+#           subject.parameter_set = "dummy"
+#         end
+#         it "should return level 3" do
+#           expect(subject.levels.include?(3)).to be_truthy
+#         end
+#       end
+#       context "when parameter_set is not defined" do
+#         before(:each) do
+#           subject.parameter_set = nil
+#         end
+#         it "should not return level 3" do
+#           expect(subject.levels.include?(3)).not_to be_truthy
+#         end
+#       end
+#     end
+#     context "when validation is done with an import" do
+#       before(:each) do
+#         subject.import_task = import_task
+#       end
+#       it "should return levels 1 and 2" do
+#         expect(subject.levels.include?(1)).to be_truthy
+#         expect(subject.levels.include?(2)).to be_truthy
+#       end
+#       context "when parameter_set is defined" do
+#         before(:each) do
+#           subject.parameter_set = "dummy"
+#         end
+#         it "should return level 3" do
+#           expect(subject.levels.include?(3)).to be_truthy
+#         end
+#       end
+#       context "when parameter_set is not defined" do
+#         before(:each) do
+#           subject.parameter_set = nil
+#         end
+#         it "should not return level 3" do
+#           expect(subject.levels.include?(3)).not_to be_truthy
+#         end
+#       end
+#     end
 
-  end
+#   end
 
-  describe "#chouette_command" do
-    it "should be a Chouette::Command instance" do
-      subject.send( :chouette_command).class.should == Chouette::Command
-    end
-    it "should have schema same as referential.slug" do
-      subject.send( :chouette_command).schema.should == subject.referential.slug
-    end
-  end
+#   describe "#chouette_command" do
+#     it "should be a Chouette::Command instance" do
+#       expect(subject.send( :chouette_command).class).to eq(Chouette::Command)
+#     end
+#     it "should have schema same as referential.slug" do
+#       expect(subject.send( :chouette_command).schema).to eq(subject.referential.slug)
+#     end
+#   end
 
-  describe "#validate" do
-    let(:compliance_check_task){ Factory(:compliance_check_task) }
-    let(:chouette_command) { "dummy" }
-    context "for failing validation" do
-      before(:each) do
-        chouette_command.stub!( :run!).and_raise( "dummy")
-        compliance_check_task.stub!( :chouette_command => chouette_command)
-      end
-      it "should have status 'failed'" do
-        compliance_check_task.validate
-        compliance_check_task.status.should == "failed"
-      end
-    end
-    context "for successful validation" do
-      before(:each) do
-        compliance_check_task.stub!( :chouette_command => mock( :run! => true ))
-      end
-      it "should have status 'completed'" do
-        compliance_check_task.validate
-        compliance_check_task.status.should == "completed"
-      end
-    end
-  end
+#   describe "#validate" do
+#     let(:compliance_check_task){ Factory(:compliance_check_task) }
+#     let(:chouette_command) { "dummy" }
+#     context "for failing validation" do
+#       before(:each) do
+#         allow(chouette_command).to receive( :run!).and_raise( "dummy")
+#         allow(compliance_check_task).to receive_messages( :chouette_command => chouette_command)
+#       end
+#       it "should have status 'failed'" do
+#         compliance_check_task.validate
+#         expect(compliance_check_task.status).to eq("failed")
+#       end
+#     end
+#     context "for successful validation" do
+#       before(:each) do
+#         allow(compliance_check_task).to receive_messages( :chouette_command => double( :run! => true ))
+#       end
+#       it "should have status 'completed'" do
+#         compliance_check_task.validate
+#         expect(compliance_check_task.status).to eq("completed")
+#       end
+#     end
+#   end
 
-  describe "#validate" do
-    let(:compliance_check_task){ Factory(:compliance_check_task) }
-    let(:command_args){ "dummy" }
-    before(:each) do
-      compliance_check_task.stub!( :chouette_command => mock( :run! => true ))
-      compliance_check_task.stub!( :chouette_command_args => command_args)
-    end
-    it "should call chouette_command.run! with :c => 'import', :id => id" do
-      compliance_check_task.send( :chouette_command).should_receive( :run! ).with(  command_args)
-      compliance_check_task.validate
-    end
-  end
+#   describe "#validate" do
+#     let(:compliance_check_task){ Factory(:compliance_check_task) }
+#     let(:command_args){ "dummy" }
+#     before(:each) do
+#       allow(compliance_check_task).to receive_messages( :chouette_command => double( :run! => true ))
+#       allow(compliance_check_task).to receive_messages( :chouette_command_args => command_args)
+#     end
+#     it "should call chouette_command.run! with :c => 'import', :id => id" do
+#       expect(compliance_check_task.send( :chouette_command)).to receive( :run! ).with(  command_args)
+#       compliance_check_task.validate
+#     end
+#   end
 
-  describe "#delayed_validate" do
-    let( :import_task){ Factory.build(:import_task) }
-    before(:each) do
-      subject.stub!( :delay => mock( :validate => true))
-    end
-    it "should not call delay#validate if import_task defined" do
-      subject.import_task = import_task
-      subject.delay.should_not_receive( :validate)
-      subject.delayed_validate
-    end
-    it "should call delay#validate if import_task blank" do
-      subject.import_task = nil
-      subject.delay.should_receive( :validate)
-      subject.delayed_validate
-    end
+#   describe "#delayed_validate" do
+#     let( :import_task){ Factory.build(:import_task) }
+#     before(:each) do
+#       allow(subject).to receive_messages( :delay => double( :validate => true))
+#     end
+#     it "should not call delay#validate if import_task defined" do
+#       subject.import_task = import_task
+#       expect(subject.delay).not_to receive( :validate)
+#       subject.delayed_validate
+#     end
+#     it "should call delay#validate if import_task blank" do
+#       subject.import_task = nil
+#       expect(subject.delay).to receive( :validate)
+#       subject.delayed_validate
+#     end
 
-  end
+#   end
 
-  describe "#define_default_attributes" do
-    it "should keep status if defined" do
-      subject.status = "dummy"
-      subject.define_default_attributes
-      subject.status.should == "dummy"
-    end
-    it "should set status to pending if not defined" do
-      subject.status = nil
-      subject.define_default_attributes
-      subject.status.should == "pending"
-    end
-    context "when rule_parameter_set is nil" do
-      before(:each) do
-        subject.stub!( :rule_parameter_set => nil)
-        subject.parameter_set = "dummy"
-        subject.parameter_set_name = "dummy"
-      end
-      it "should keep parameter_set_name" do
-        subject.define_default_attributes
-        subject.parameter_set_name.should == "dummy"
-      end
-      it "should keep parameter_set" do
-        subject.define_default_attributes
-        subject.parameter_set.should == "dummy"
-      end
-    end
-    context "when rule_parameter_set is defined" do
-      let( :rule_parameter_set ){ Factory( :rule_parameter_set ) }
-      before(:each) do
-        subject.stub!( :rule_parameter_set => rule_parameter_set)
-        subject.parameter_set = "dummy"
-        subject.parameter_set_name = "dummy"
-      end
-      it "should set parameter_set_name to rule_parameter_set.name" do
-        subject.define_default_attributes
-        subject.parameter_set_name.should == rule_parameter_set.name
-      end
-      it "should keep set parameter_set to rule_parameter_set.parameters" do
-        subject.define_default_attributes
-        subject.parameter_set.should == rule_parameter_set.parameters
-      end
-    end
-  end
+#   describe "#define_default_attributes" do
+#     it "should keep status if defined" do
+#       subject.status = "dummy"
+#       subject.define_default_attributes
+#       expect(subject.status).to eq("dummy")
+#     end
+#     it "should set status to pending if not defined" do
+#       subject.status = nil
+#       subject.define_default_attributes
+#       expect(subject.status).to eq("pending")
+#     end
+#     context "when rule_parameter_set is nil" do
+#       before(:each) do
+#         allow(subject).to receive_messages( :rule_parameter_set => nil)
+#         subject.parameter_set = "dummy"
+#         subject.parameter_set_name = "dummy"
+#       end
+#       it "should keep parameter_set_name" do
+#         subject.define_default_attributes
+#         expect(subject.parameter_set_name).to eq("dummy")
+#       end
+#       it "should keep parameter_set" do
+#         subject.define_default_attributes
+#         expect(subject.parameter_set).to eq("dummy")
+#       end
+#     end
+#     context "when rule_parameter_set is defined" do
+#       let( :rule_parameter_set ){ Factory( :rule_parameter_set ) }
+#       before(:each) do
+#         allow(subject).to receive_messages( :rule_parameter_set => rule_parameter_set)
+#         subject.parameter_set = "dummy"
+#         subject.parameter_set_name = "dummy"
+#       end
+#       it "should set parameter_set_name to rule_parameter_set.name" do
+#         subject.define_default_attributes
+#         expect(subject.parameter_set_name).to eq(rule_parameter_set.name)
+#       end
+#       it "should keep set parameter_set to rule_parameter_set.parameters" do
+#         subject.define_default_attributes
+#         expect(subject.parameter_set).to eq(rule_parameter_set.parameters)
+#       end
+#     end
+#   end
 
-  describe "#rule_parameter_set" do
-    context "when rule_parameter_set_id is blank" do
-      before(:each) do
-        subject.rule_parameter_set_id = ""
-      end
-      it "should return nil" do
-        subject.rule_parameter_set.should be_nil
-      end
-    end
-    context "when rule_parameter_set_id is not blank" do
-      let( :rule_parameter_set ){ Factory( :rule_parameter_set ) }
-      before(:each) do
-        subject.rule_parameter_set_id = rule_parameter_set.id
-      end
-      it "should return rule_parameter_set instance" do
-        subject.rule_parameter_set.should == rule_parameter_set
-      end
-    end
-  end
+#   describe "#rule_parameter_set" do
+#     context "when rule_parameter_set_id is blank" do
+#       before(:each) do
+#         subject.rule_parameter_set_id = ""
+#       end
+#       it "should return nil" do
+#         expect(subject.rule_parameter_set).to be_nil
+#       end
+#     end
+#     context "when rule_parameter_set_id is not blank" do
+#       let( :rule_parameter_set ){ Factory( :rule_parameter_set ) }
+#       before(:each) do
+#         subject.rule_parameter_set_id = rule_parameter_set.id
+#       end
+#       it "should return rule_parameter_set instance" do
+#         expect(subject.rule_parameter_set).to eq(rule_parameter_set)
+#       end
+#     end
+#   end
 
-  describe "#rule_parameter_set_archived" do
-    context "when parameter_set is blank" do
-      before(:each) do
-        subject.parameter_set = nil
-      end
-      it "should return nil" do
-        subject.rule_parameter_set_archived.should be_nil
-      end
-    end
-    context "when parameter_set is blank" do
-      before(:each) do
-        subject.parameter_set = { :speed => 30, :distance => 5 }
-      end
-      it "should return RuleParameterSet#parameters same as parameter_set" do
-        subject.rule_parameter_set_archived.parameters.should == subject.parameter_set
-      end
-      it "should return RuleParameterSet#name same as parameter_set_name" do
-        subject.rule_parameter_set_archived.name.should == subject.parameter_set_name
-      end
-    end
+#   describe "#rule_parameter_set_archived" do
+#     context "when parameter_set is blank" do
+#       before(:each) do
+#         subject.parameter_set = nil
+#       end
+#       it "should return nil" do
+#         expect(subject.rule_parameter_set_archived).to be_nil
+#       end
+#     end
+#     context "when parameter_set is blank" do
+#       before(:each) do
+#         subject.parameter_set = { :speed => 30, :distance => 5 }
+#       end
+#       it "should return RuleParameterSet#parameters same as parameter_set" do
+#         expect(subject.rule_parameter_set_archived.parameters).to eq(subject.parameter_set)
+#       end
+#       it "should return RuleParameterSet#name same as parameter_set_name" do
+#         expect(subject.rule_parameter_set_archived.name).to eq(subject.parameter_set_name)
+#       end
+#     end
 
-  end
+#   end
 
-#  describe "#validate" do
-#
-#    before(:each) do
-#      subject.stub :validator => mock(:validate => true)
-#    end
-#
-#    it "should create a ComplianceCheckResult :started when started" do
-#      subject.validate
-#      subject.compliance_check_results.first.should be_log_message(:key => "started")
-#    end
-#
-#    it "should create a ComplianceCheckResult :completed when completed" do
-#      subject.validate
-#      subject.compliance_check_results.last.should be_log_message(:key => "completed")
-#    end
-#
-#    it "should create a ComplianceCheckResult :failed when failed" do
-#      pending
-#      # subject.loader.stub(:export).and_raise("export failed")
-#      subject.validate
-#      subject.compliance_check_results.last.should be_log_message(:key => "failed")
-#    end
-#
-#  end
+# #  describe "#validate" do
+# #
+# #    before(:each) do
+# #      subject.stub :validator => mock(:validate => true)
+# #    end
+# #
+# #    it "should create a ComplianceCheckResult :started when started" do
+# #      subject.validate
+# #      subject.compliance_check_results.first.should be_log_message(:key => "started")
+# #    end
+# #
+# #    it "should create a ComplianceCheckResult :completed when completed" do
+# #      subject.validate
+# #      subject.compliance_check_results.last.should be_log_message(:key => "completed")
+# #    end
+# #
+# #    it "should create a ComplianceCheckResult :failed when failed" do
+# #      pending
+# #      # subject.loader.stub(:export).and_raise("export failed")
+# #      subject.validate
+# #      subject.compliance_check_results.last.should be_log_message(:key => "failed")
+# #    end
+# #
+# #  end
 
-  describe ".create" do
-    let( :new_compliance_check_task){ Factory.build( :compliance_check_task) }
+#   describe ".create" do
+#     let( :new_compliance_check_task){ Factory.build( :compliance_check_task) }
 
-    it "should call #define_default_attributes" do
-      new_compliance_check_task.should_receive( :define_default_attributes)
-      new_compliance_check_task.save
-    end
+#     it "should call #define_default_attributes" do
+#       expect(new_compliance_check_task).to receive( :define_default_attributes)
+#       new_compliance_check_task.save
+#     end
 
-    it "should call #delayed_validate" do
-      new_compliance_check_task.should_not_receive( :delayed_validate)
-      new_compliance_check_task.save
-    end
+#     it "should call #delayed_validate" do
+#       expect(new_compliance_check_task).not_to receive( :delayed_validate)
+#       new_compliance_check_task.save
+#     end
 
-  end
+#   end
 
-  it_behaves_like TypeIdsModelable do
-    let(:type_ids_model) { subject}
-  end
+#   it_behaves_like TypeIdsModelable do
+#     let(:type_ids_model) { subject}
+#   end
 
-end
+# end
 
diff --git a/spec/models/csv_export_spec.rb b/spec/models/csv_export_spec.rb
index 8c80ab8da..359474c2a 100644
--- a/spec/models/csv_export_spec.rb
+++ b/spec/models/csv_export_spec.rb
@@ -1,7 +1,10 @@
-require 'spec_helper'
+# require 'spec_helper'
 
-describe CsvExport do
+# describe CsvExport, :type => :model do
 
-  its(:export_options) { should include(:format => :csv) }
+#   describe '#export_options' do
+#     subject { super().export_options }
+#     it { is_expected.to include(:format => :csv) }
+#   end
   
-end
+# end
diff --git a/spec/models/csv_import_spec.rb b/spec/models/csv_import_spec.rb
index 3dad39aeb..be4c8cab6 100644
--- a/spec/models/csv_import_spec.rb
+++ b/spec/models/csv_import_spec.rb
@@ -1,12 +1,12 @@
 require 'spec_helper'
 
-describe CsvImport do
+describe CsvImport, :type => :model do
 
  describe "#object_id_prefix" do
 
    it "should be included in import_options" do
      subject.object_id_prefix = "dummy"
-     subject.parameter_set["object_id_prefix"].should == "dummy"
+     expect(subject.parameter_set["object_id_prefix"]).to eq("dummy")
    end
 
  end
diff --git a/spec/models/export_log_message_spec.rb b/spec/models/export_log_message_spec.rb
index 8aa3cde6e..59948f5ce 100644
--- a/spec/models/export_log_message_spec.rb
+++ b/spec/models/export_log_message_spec.rb
@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe ExportLogMessage do
+describe ExportLogMessage, :type => :model do
 
   describe "#attributes" do
 
@@ -8,7 +8,7 @@ describe ExportLogMessage do
 
     it "should read json stored in database" do
       subject.update_attribute :arguments, { "key" => "value"}
-      subject.raw_attributes.should == { "key" => "value"}.to_json
+      expect(subject.raw_attributes).to eq({ "key" => "value"}.to_json)
     end
 
   end
diff --git a/spec/models/export_spec.rb b/spec/models/export_spec.rb
index 1fd47daad..13953078a 100644
--- a/spec/models/export_spec.rb
+++ b/spec/models/export_spec.rb
@@ -1,66 +1,66 @@
-require 'spec_helper'
+# require 'spec_helper'
 
-describe Export do
+# describe Export, :type => :model do
 
-  subject { create :export }
+#   subject { create :export }
 
-  RSpec::Matchers.define :be_log_message do |expected|
-    match do |actual|
-      actual and expected.all? { |k,v| actual[k.to_s] == v }
-    end
-  end
+#   RSpec::Matchers.define :be_log_message do |expected|
+#     match do |actual|
+#       actual and expected.all? { |k,v| actual[k.to_s] == v }
+#     end
+#   end
 
-  describe "#export" do
+#   describe "#export" do
 
-    before(:each) do
-      subject.stub :exporter => mock(:export => true)
-    end
+#     before(:each) do
+#       allow(subject).to receive_messages :exporter => double(:export => true)
+#     end
 
-    it "should create a ExportLogmessage :started when started" do
-      subject.export
-      subject.log_messages.first.should be_log_message(:key => "started")
-    end
+#     it "should create a ExportLogmessage :started when started" do
+#       subject.export
+#       expect(subject.log_messages.first).to be_log_message(:key => "started")
+#     end
 
-    it "should create a ExportLogmessage :completed when completed" do
-      subject.export
-      subject.log_messages.last.should be_log_message(:key => "completed")
-    end
+#     it "should create a ExportLogmessage :completed when completed" do
+#       subject.export
+#       expect(subject.log_messages.last).to be_log_message(:key => "completed")
+#     end
 
-    it "should create a ExportLogmessage :failed when failed" do
-      pending
-      # subject.loader.stub(:export).and_raise("export failed")
-      subject.export
-      subject.log_messages.last.should be_log_message(:key => "failed")
-    end
+#     it "should create a ExportLogmessage :failed when failed" do
+#       pending
+#       # subject.loader.stub(:export).and_raise("export failed")
+#       subject.export
+#       expect(subject.log_messages.last).to be_log_message(:key => "failed")
+#     end
 
-  end
+#   end
 
-  describe "#options" do
+#   describe "#options" do
 
-    it "should be empty by default" do
-      subject.options.should be_empty
-    end
+#     it "should be empty by default" do
+#       expect(subject.options).to be_empty
+#     end
 
-  end
+#   end
 
-  describe ".types" do
+#   describe ".types" do
 
-    it "should return available Export implementations" do
-      Export.types.should =~ %w{NeptuneExport CsvExport GtfsExport NetexExport KmlExport HubExport}
-    end
+#     it "should return available Export implementations" do
+#       expect(Export.types).to match_array(%w{NeptuneExport CsvExport GtfsExport NetexExport KmlExport HubExport})
+#     end
 
-  end
+#   end
 
-  describe ".new" do
+#   describe ".new" do
 
-    it "should use type attribute to create a subclass" do
-      Export.new(:type => "NeptuneExport").should be_an_instance_of(NeptuneExport)
-    end
+#     it "should use type attribute to create a subclass" do
+#       expect(Export.new(:type => "NeptuneExport")).to be_an_instance_of(NeptuneExport)
+#     end
 
-  end
+#   end
 
-  it_behaves_like TypeIdsModelable do
-    let(:type_ids_model) { subject}
-  end
+#   it_behaves_like TypeIdsModelable do
+#     let(:type_ids_model) { subject}
+#   end
 
-end
+# end
diff --git a/spec/models/gtfs_export_spec.rb b/spec/models/gtfs_export_spec.rb
index 4bc587f14..a5e5d0335 100644
--- a/spec/models/gtfs_export_spec.rb
+++ b/spec/models/gtfs_export_spec.rb
@@ -1,7 +1,10 @@
-require 'spec_helper'
+# require 'spec_helper'
 
-describe GtfsExport do
+# describe GtfsExport, :type => :model do
 
-  its(:export_options) { should include(:format => :gtfs) }
+#   describe '#export_options' do
+#     subject { super().export_options }
+#     it { is_expected.to include(:format => :gtfs) }
+#   end
   
-end
+# end
diff --git a/spec/models/gtfs_import_spec.rb b/spec/models/gtfs_import_spec.rb
index e1a1ac48e..f049bebaa 100644
--- a/spec/models/gtfs_import_spec.rb
+++ b/spec/models/gtfs_import_spec.rb
@@ -1,12 +1,12 @@
 require 'spec_helper'
 
-describe GtfsImport do
+describe GtfsImport, :type => :model do
 
  describe "#object_id_prefix" do
 
    it "should be included in import_options" do
      subject.object_id_prefix = "dummy"
-     subject.parameter_set["object_id_prefix"].should  == "dummy"
+     expect(subject.parameter_set["object_id_prefix"]).to  eq("dummy")
    end
 
  end
@@ -15,7 +15,7 @@ describe GtfsImport do
 
    it "should be included in import_options" do
      subject.max_distance_for_commercial = 300
-     subject.parameter_set["max_distance_for_commercial"].should == 300
+     expect(subject.parameter_set["max_distance_for_commercial"]).to eq(300)
    end
 
  end
@@ -24,7 +24,7 @@ describe GtfsImport do
 
    it "should be included in import_options" do
      subject.max_distance_for_connection_link = 300
-     subject.parameter_set["max_distance_for_connection_link"].should == 300
+     expect(subject.parameter_set["max_distance_for_connection_link"]).to eq(300)
    end
 
  end
@@ -33,7 +33,7 @@ describe GtfsImport do
 
    it "should be included in import_options" do
      subject.ignore_last_word = true
-     subject.parameter_set["ignore_last_word"].should == true
+     expect(subject.parameter_set["ignore_last_word"]).to eq(true)
    end
 
  end
@@ -42,7 +42,7 @@ describe GtfsImport do
 
    it "should be included in import_options" do
      subject.ignore_end_chars = 2
-     subject.parameter_set["ignore_end_chars"].should == 2
+     expect(subject.parameter_set["ignore_end_chars"]).to eq(2)
    end
 
  end
diff --git a/spec/models/import_task_spec.rb b/spec/models/import_task_spec.rb
index 542ccd739..3aa006a69 100644
--- a/spec/models/import_task_spec.rb
+++ b/spec/models/import_task_spec.rb
@@ -1,196 +1,196 @@
-require 'spec_helper'
-
-describe ImportTask do
-
-  subject { build :import_task }
-
-  describe ".new" do
-
-    it "should use type attribute to create a subclass" do
-      ImportTask.new(:format => "Neptune").should be_an_instance_of(NeptuneImport)
-      ImportTask.new(:format => "Gtfs").should be_an_instance_of(GtfsImport)
-      ImportTask.new(:format => "Netex").should be_an_instance_of(NetexImport)
-      ImportTask.new(:format => "Csv").should be_an_instance_of(CsvImport)
-
-      NeptuneImport.new.should be_an_instance_of(NeptuneImport)
-      GtfsImport.new.should be_an_instance_of(GtfsImport)
-      NetexImport.new.should be_an_instance_of(NetexImport)
-      CsvImport.new.should be_an_instance_of(CsvImport)
-    end
-
-  end
-
-  describe "#delayed_import" do
-    before(:each) do
-      subject.stub!( :delay => mock( :import => true))
-    end
-    it "should call delay#import" do
-      subject.delay.should_receive( :import)
-      subject.send :delayed_import
-    end
-  end
-
-  describe ".create" do
-    before(:each) do
-      subject.stub!( :save_resources => true )
-    end
-    it "should call save_resource" do
-      subject.should_receive( :save_resources)
-      subject.send :save
-    end
-    it "should update file_path with #saved_resources" do
-      subject.send :save
-      ImportTask.find( subject.id).file_path.should == subject.send( :saved_resources)
-    end
-    it "should have a compliance_check_task" do
-      subject.send :save
-      ImportTask.find( subject.id).compliance_check_task.should_not be_nil
-    end
-  end
-
-  describe "#compliance_check_task" do
-    let(:rule_parameter_set){ Factory( :rule_parameter_set) }
-    let(:import_task){ Factory(:import_task, :rule_parameter_set_id => rule_parameter_set.id) }
-    let(:compliance_check_task){ import_task.compliance_check_task }
-
-    it "should have same #referential as import_task" do
-      compliance_check_task.referential.should == import_task.referential
-    end
-
-    it "should have same #rule_parameter_set_id as import_task" do
-      compliance_check_task.rule_parameter_set_id.should == import_task.rule_parameter_set_id
-    end
-
-    it "should have same #user_id as import_task" do
-      compliance_check_task.user_id.should == import_task.user_id
-    end
-
-    it "should have same #user_name as import_task" do
-      compliance_check_task.user_name.should == import_task.user_name
-    end
-  end
-
-  describe "#file_path_extension" do
-    let(:import_task){ Factory(:import_task) }
-    context "zip file to import" do
-      before(:each) do
-        import_task.file_path = "aaa/bbb.zip"
-      end
-      it "should return zip" do
-        import_task.file_path_extension.should == "zip"
-      end
-    end
-    context "xml file to import" do
-      before(:each) do
-        import_task.file_path = "aaa/bbb.xml"
-      end
-      it "should return xml" do
-        import_task.file_path_extension.should == "xml"
-      end
-    end
-    context "csv file to import" do
-      before(:each) do
-        import_task.file_path = "aaa/bbb.csv"
-      end
-      it "should return csv" do
-        import_task.file_path_extension.should == "basic"
-      end
-    end
-
-  end
-
-  context "options attributes" do
-    let(:import_task){ Factory(:import_task) }
-    describe "#no_save" do
-      it "should read parameter_set['no_save']" do
-        import_task.parameter_set[ "no_save"] = "dummy"
-        import_task.no_save.should == "dummy"
-      end
-    end
-    describe "#format" do
-      it "should read parameter_set['format']" do
-        import_task.parameter_set[ "format"] = "dummy"
-        import_task.format.should == "dummy"
-      end
-    end
-    describe "#file_path" do
-      it "should read parameter_set['file_path']" do
-        import_task.parameter_set[ "file_path"] = "dummy"
-        import_task.file_path.should == "dummy"
-      end
-    end
-    describe "#no_save=" do
-      it "should read parameter_set['no_save']" do
-        import_task.no_save = "dummy"
-        import_task.parameter_set[ "no_save"].should == false
-      end
-    end
-    describe "#format=" do
-      it "should read parameter_set['format']" do
-        import_task.format = "dummy"
-        import_task.parameter_set[ "format"].should == "dummy"
-      end
-    end
-    describe "#file_path=" do
-      it "should read parameter_set['file_path']" do
-        import_task.file_path = "dummy"
-        import_task.parameter_set[ "file_path"].should == "dummy"
-      end
-    end
-  end
-
-  describe "#chouette_command" do
-    it "should be a Chouette::Command instance" do
-      subject.send( :chouette_command).class.should == Chouette::Command
-    end
-    it "should have schema same as referential.slug" do
-      subject.send( :chouette_command).schema.should == subject.referential.slug
-    end
-  end
-
-  describe "#import" do
-    let(:import_task){ Factory(:import_task) }
-    let(:chouette_command) { "dummy" }
-    context "for failing import" do
-      before(:each) do
-        chouette_command.stub!( :run!).and_raise( "dummy")
-        import_task.stub!( :chouette_command => chouette_command)
-      end
-      it "should have status 'failed'" do
-        import_task.import
-        import_task.status.should == "failed"
-      end
-      it "should have status 'failed' for compliance_check_task" do
-        import_task.import
-        import_task.compliance_check_task.status.should == "failed"
-      end
-    end
-    context "for successful import" do
-      before(:each) do
-        import_task.stub!( :chouette_command => mock( :run! => true ))
-      end
-      it "should have status 'completed'" do
-        import_task.import
-        import_task.status.should == "completed"
-      end
-      it "should have status 'completed' for compliance_check_task" do
-        import_task.import
-        import_task.status.should == "completed"
-      end
-    end
-  end
-
-  describe "#import" do
-    let(:import_task){ Factory(:import_task) }
-    let(:command_args){ "dummy" }
-    before(:each) do
-      import_task.stub!( :chouette_command => mock( :run! => true ))
-      import_task.stub!( :chouette_command_args => command_args)
-    end
-    it "should call chouette_command.run! with :c => 'import', :id => id" do
-      import_task.send( :chouette_command).should_receive( :run! ).with(  command_args)
-      import_task.import
-    end
-  end
-
-end
+# require 'spec_helper'
+
+# describe ImportTask, :type => :model do
+
+#   subject { build :import_task }
+
+#   describe ".new" do
+
+#     it "should use type attribute to create a subclass" do
+#       expect(ImportTask.new(:format => "Neptune")).to be_an_instance_of(NeptuneImport)
+#       expect(ImportTask.new(:format => "Gtfs")).to be_an_instance_of(GtfsImport)
+#       expect(ImportTask.new(:format => "Netex")).to be_an_instance_of(NetexImport)
+#       expect(ImportTask.new(:format => "Csv")).to be_an_instance_of(CsvImport)
+
+#       expect(NeptuneImport.new).to be_an_instance_of(NeptuneImport)
+#       expect(GtfsImport.new).to be_an_instance_of(GtfsImport)
+#       expect(NetexImport.new).to be_an_instance_of(NetexImport)
+#       expect(CsvImport.new).to be_an_instance_of(CsvImport)
+#     end
+
+#   end
+
+#   describe "#delayed_import" do
+#     before(:each) do
+#       allow(subject).to receive_messages( :delay => double( :import => true))
+#     end
+#     it "should call delay#import" do
+#       expect(subject.delay).to receive( :import)
+#       subject.send :delayed_import
+#     end
+#   end
+
+#   describe ".create" do
+#     before(:each) do
+#       allow(subject).to receive_messages( :save_resources => true )
+#     end
+#     it "should call save_resource" do
+#       expect(subject).to receive( :save_resources)
+#       subject.send :save
+#     end
+#     it "should update file_path with #saved_resources" do
+#       subject.send :save
+#       expect(ImportTask.find( subject.id).file_path).to eq(subject.send( :saved_resources))
+#     end
+#     it "should have a compliance_check_task" do
+#       subject.send :save
+#       expect(ImportTask.find( subject.id).compliance_check_task).not_to be_nil
+#     end
+#   end
+
+#   describe "#compliance_check_task" do
+#     let(:rule_parameter_set){ Factory( :rule_parameter_set) }
+#     let(:import_task){ Factory(:import_task, :rule_parameter_set_id => rule_parameter_set.id) }
+#     let(:compliance_check_task){ import_task.compliance_check_task }
+
+#     it "should have same #referential as import_task" do
+#       expect(compliance_check_task.referential).to eq(import_task.referential)
+#     end
+
+#     it "should have same #rule_parameter_set_id as import_task" do
+#       expect(compliance_check_task.rule_parameter_set_id).to eq(import_task.rule_parameter_set_id)
+#     end
+
+#     it "should have same #user_id as import_task" do
+#       expect(compliance_check_task.user_id).to eq(import_task.user_id)
+#     end
+
+#     it "should have same #user_name as import_task" do
+#       expect(compliance_check_task.user_name).to eq(import_task.user_name)
+#     end
+#   end
+
+#   describe "#file_path_extension" do
+#     let(:import_task){ Factory(:import_task) }
+#     context "zip file to import" do
+#       before(:each) do
+#         import_task.file_path = "aaa/bbb.zip"
+#       end
+#       it "should return zip" do
+#         expect(import_task.file_path_extension).to eq("zip")
+#       end
+#     end
+#     context "xml file to import" do
+#       before(:each) do
+#         import_task.file_path = "aaa/bbb.xml"
+#       end
+#       it "should return xml" do
+#         expect(import_task.file_path_extension).to eq("xml")
+#       end
+#     end
+#     context "csv file to import" do
+#       before(:each) do
+#         import_task.file_path = "aaa/bbb.csv"
+#       end
+#       it "should return csv" do
+#         expect(import_task.file_path_extension).to eq("basic")
+#       end
+#     end
+
+#   end
+
+#   context "options attributes" do
+#     let(:import_task){ Factory(:import_task) }
+#     describe "#no_save" do
+#       it "should read parameter_set['no_save']" do
+#         import_task.parameter_set[ "no_save"] = "dummy"
+#         expect(import_task.no_save).to eq("dummy")
+#       end
+#     end
+#     describe "#format" do
+#       it "should read parameter_set['format']" do
+#         import_task.parameter_set[ "format"] = "dummy"
+#         expect(import_task.format).to eq("dummy")
+#       end
+#     end
+#     describe "#file_path" do
+#       it "should read parameter_set['file_path']" do
+#         import_task.parameter_set[ "file_path"] = "dummy"
+#         expect(import_task.file_path).to eq("dummy")
+#       end
+#     end
+#     describe "#no_save=" do
+#       it "should read parameter_set['no_save']" do
+#         import_task.no_save = "dummy"
+#         expect(import_task.parameter_set[ "no_save"]).to eq(false)
+#       end
+#     end
+#     describe "#format=" do
+#       it "should read parameter_set['format']" do
+#         import_task.format = "dummy"
+#         expect(import_task.parameter_set[ "format"]).to eq("dummy")
+#       end
+#     end
+#     describe "#file_path=" do
+#       it "should read parameter_set['file_path']" do
+#         import_task.file_path = "dummy"
+#         expect(import_task.parameter_set[ "file_path"]).to eq("dummy")
+#       end
+#     end
+#   end
+
+#   describe "#chouette_command" do
+#     it "should be a Chouette::Command instance" do
+#       expect(subject.send( :chouette_command).class).to eq(Chouette::Command)
+#     end
+#     it "should have schema same as referential.slug" do
+#       expect(subject.send( :chouette_command).schema).to eq(subject.referential.slug)
+#     end
+#   end
+
+#   describe "#import" do
+#     let(:import_task){ Factory(:import_task) }
+#     let(:chouette_command) { "dummy" }
+#     context "for failing import" do
+#       before(:each) do
+#         allow(chouette_command).to receive( :run!).and_raise( "dummy")
+#         allow(import_task).to receive_messages( :chouette_command => chouette_command)
+#       end
+#       it "should have status 'failed'" do
+#         import_task.import
+#         expect(import_task.status).to eq("failed")
+#       end
+#       it "should have status 'failed' for compliance_check_task" do
+#         import_task.import
+#         expect(import_task.compliance_check_task.status).to eq("failed")
+#       end
+#     end
+#     context "for successful import" do
+#       before(:each) do
+#         allow(import_task).to receive_messages( :chouette_command => double( :run! => true ))
+#       end
+#       it "should have status 'completed'" do
+#         import_task.import
+#         expect(import_task.status).to eq("completed")
+#       end
+#       it "should have status 'completed' for compliance_check_task" do
+#         import_task.import
+#         expect(import_task.status).to eq("completed")
+#       end
+#     end
+#   end
+
+#   describe "#import" do
+#     let(:import_task){ Factory(:import_task) }
+#     let(:command_args){ "dummy" }
+#     before(:each) do
+#       allow(import_task).to receive_messages( :chouette_command => double( :run! => true ))
+#       allow(import_task).to receive_messages( :chouette_command_args => command_args)
+#     end
+#     it "should call chouette_command.run! with :c => 'import', :id => id" do
+#       expect(import_task.send( :chouette_command)).to receive( :run! ).with(  command_args)
+#       import_task.import
+#     end
+#   end
+
+# end
diff --git a/spec/models/neptune_export_spec.rb b/spec/models/neptune_export_spec.rb
index 1b4f4afa9..a96c4c46b 100644
--- a/spec/models/neptune_export_spec.rb
+++ b/spec/models/neptune_export_spec.rb
@@ -1,7 +1,10 @@
-require 'spec_helper'
+# require 'spec_helper'
 
-describe NeptuneExport do
+# describe NeptuneExport, :type => :model do
 
-  its(:export_options) { should include(:format => :neptune) }
+#   describe '#export_options' do
+#     subject { super().export_options }
+#     it { is_expected.to include(:format => :neptune) }
+#   end
   
-end
+# end
diff --git a/spec/models/netex_export_spec.rb b/spec/models/netex_export_spec.rb
index 385f6aa5a..12812dc6f 100644
--- a/spec/models/netex_export_spec.rb
+++ b/spec/models/netex_export_spec.rb
@@ -1,7 +1,10 @@
 require 'spec_helper'
 
-describe NetexExport do
+describe NetexExport, :type => :model do
 
-  its(:export_options) { should include(:format => :netex) }
+  describe '#export_options' do
+    subject { super().export_options }
+    it { is_expected.to include(:format => :netex) }
+  end
   
 end
diff --git a/spec/models/referential_spec.rb b/spec/models/referential_spec.rb
index a11bbd9de..505630586 100644
--- a/spec/models/referential_spec.rb
+++ b/spec/models/referential_spec.rb
@@ -1,70 +1,65 @@
 require 'spec_helper'
 
-describe Referential do
-
-  it { should validate_presence_of(:name) }
-  it { should validate_presence_of(:slug) }
-  it { should validate_presence_of(:prefix) }
-  it { should validate_presence_of(:time_zone) }
+describe Referential, :type => :model do
 
   it "create a rule_parameter_set" do
     referential = Factory.create(:referential)
-    referential.rule_parameter_sets.size.should == 1
+    expect(referential.rule_parameter_sets.size).to eq(1)
   end
 end
 
-describe Chouette::StopArea do
+describe Chouette::StopArea, :type => :model do
   # check override methods
 
    subject {Factory(:stop_area)}
 
     it "should return referential projection " do
       subject.referential.projection_type='27572'
-      subject.projection.should == subject.referential.projection_type
+      expect(subject.projection).to eq(subject.referential.projection_type)
     end
 
     it "should return projection coordinates when referential has projection" do
       subject.latitude = 45
       subject.longitude = 0
       subject.referential.projection_type='27572'
-      subject.projection_x.should_not be_nil
-      subject.projection_y.should_not be_nil
+      expect(subject.projection_x).not_to be_nil
+      expect(subject.projection_y).not_to be_nil
     end
 
     it "should return nil projection coordinates when referential has no projection" do
       subject.latitude = 45
       subject.longitude = 0
       subject.referential.projection_type=nil
-      subject.projection_x.should be_nil
-      subject.projection_y.should be_nil
+      expect(subject.projection_x).to be_nil
+      expect(subject.projection_y).to be_nil
     end
 
 end
 
-describe Chouette::AccessPoint do
+describe Chouette::AccessPoint, :type => :model do
   # check override methods
 
    subject {Factory(:access_point)}
 
     it "should return referential projection " do
       subject.referential.projection_type='27572'
-      subject.projection.should == subject.referential.projection_type
+      expect(subject.projection).to eq(subject.referential.projection_type)
     end
 
     it "should return projection coordinates when referential has projection" do
       subject.latitude = 45
       subject.longitude = 0
       subject.referential.projection_type='27572'
-      subject.projection_x.should_not be_nil
-      subject.projection_y.should_not be_nil
+      expect(subject.projection_x).not_to be_nil
+      expect(subject.projection_y).not_to be_nil
     end
 
     it "should return nil projection coordinates when referential has no projection" do
       subject.latitude = 45
       subject.longitude = 0
       subject.referential.projection_type=nil
-      subject.projection_x.should be_nil
-      subject.projection_y.should be_nil
+      expect(subject.projection_x).to be_nil
+      expect(subject.projection_y).to be_nil
     end
 
 end
diff --git a/spec/models/rule_parameter_set_spec.rb b/spec/models/rule_parameter_set_spec.rb
index bf785d6f7..71ab0cddd 100644
--- a/spec/models/rule_parameter_set_spec.rb
+++ b/spec/models/rule_parameter_set_spec.rb
@@ -1,49 +1,49 @@
-require 'spec_helper'
+# require 'spec_helper'
 
-describe RuleParameterSet do
+# describe RuleParameterSet, :type => :model do
 
-  describe ".mode_of_mode_attribute" do
-    it "should retreive attribute name" do
-      subject.class.attribute_of_mode_attribute("dummy1_mode_dummy2").should == "dummy1"
-    end
-    it "should retreive mode" do
-      subject.class.mode_of_mode_attribute("dummy1_mode_dummy2").should == "dummy2"
-    end
-  end
+#   describe ".mode_of_mode_attribute" do
+#     it "should retreive attribute name" do
+#       expect(subject.class.attribute_of_mode_attribute("dummy1_mode_dummy2")).to eq("dummy1")
+#     end
+#     it "should retreive mode" do
+#       expect(subject.class.mode_of_mode_attribute("dummy1_mode_dummy2")).to eq("dummy2")
+#     end
+#   end
 
-  RuleParameterSet.mode_attribute_prefixes.each do |prefix|
-    RuleParameterSet.all_modes.map do |mode|
-      "#{prefix}_mode_#{mode}".tap do |attribute|
-        describe "##{attribute}=" do
-          it "should store value on parameters hash" do
-            subject.send( "#{attribute}=".to_sym, 1234)
-            subject.send( attribute.to_sym).should == 1234
-            subject.parameters["mode_#{mode}"][ prefix].should == 1234
-          end
-        end
-        it { should allow_mass_assignment_of attribute.to_sym}
-      end
-    end
-  end
+#   RuleParameterSet.mode_attribute_prefixes.each do |prefix|
+#     RuleParameterSet.all_modes.map do |mode|
+#       "#{prefix}_mode_#{mode}".tap do |attribute|
+#         describe "##{attribute}=" do
+#           it "should store value on parameters hash" do
+#             subject.send( "#{attribute}=".to_sym, 1234)
+#             expect(subject.send( attribute.to_sym)).to eq(1234)
+#             expect(subject.parameters["mode_#{mode}"][ prefix]).to eq(1234)
+#           end
+#         end
+#         it { is_expected.to allow_mass_assignment_of attribute.to_sym}
+#       end
+#     end
+#   end
 
-  RuleParameterSet.general_attributes.each do |attribute|
-    describe "##{attribute}=" do
-      it "should store value on parameters hash" do
-        subject.send( "#{attribute}=".to_sym, 1234)
-        subject.send( attribute.to_sym).should == 1234
-        subject.parameters[ attribute].should == 1234
-      end
-    end
-    it { should allow_mass_assignment_of attribute.to_sym}
-  end
+#   RuleParameterSet.general_attributes.each do |attribute|
+#     describe "##{attribute}=" do
+#       it "should store value on parameters hash" do
+#         subject.send( "#{attribute}=".to_sym, 1234)
+#         expect(subject.send( attribute.to_sym)).to eq(1234)
+#         expect(subject.parameters[ attribute]).to eq(1234)
+#       end
+#     end
+#     it { is_expected.to allow_mass_assignment_of attribute.to_sym}
+#   end
 
-  describe "#referential" do
-    it { should validate_presence_of(:referential) }
-    it { should allow_mass_assignment_of :referential_id }
-  end
+#   describe "#referential" do
+#     it { is_expected.to validate_presence_of(:referential) }
+#     it { is_expected.to allow_mass_assignment_of :referential_id }
+#   end
 
-  describe "#name" do
-    it { should validate_presence_of(:name) }
-    it { should allow_mass_assignment_of :name }
-  end
-end
+#   describe "#name" do
+#     it { is_expected.to validate_presence_of(:name) }
+#     it { is_expected.to allow_mass_assignment_of :name }
+#   end
+# end
diff --git a/spec/models/stop_area_copy_spec.rb b/spec/models/stop_area_copy_spec.rb
index 66aa56d30..ad5bc41d8 100644
--- a/spec/models/stop_area_copy_spec.rb
+++ b/spec/models/stop_area_copy_spec.rb
@@ -1,14 +1,9 @@
 # -*- coding: utf-8 -*-
 require 'spec_helper'
 
-describe StopAreaCopy do
+describe StopAreaCopy, :type => :model do
   
   subject { StopAreaCopy.new(:source_id => 1, :hierarchy => "child", :area_type => "Quay") }
-
-  it { should validate_presence_of :source_id }
-  it { should validate_presence_of :hierarchy }
-  it { should validate_presence_of :area_type }
-  
   
   describe ".save" do
 
@@ -20,8 +15,8 @@ describe StopAreaCopy do
       subject.area_type = "Quay"
       subject.save
       source.reload
-      source.children.length.should == 1
-      source.children[0].name.should == "test1"
+      expect(source.children.length).to eq(1)
+      expect(source.children[0].name).to eq("test1")
     end
     it "should create a parent for source" do
       source = Chouette::StopArea.new( :area_type => "CommercialStopPoint", :name => "test2" )
@@ -31,8 +26,8 @@ describe StopAreaCopy do
       subject.area_type = "StopPlace"
       subject.save
       source.reload
-      source.parent.should_not be_nil
-      source.parent.name.should == 'test2'
+      expect(source.parent).not_to be_nil
+      expect(source.parent.name).to eq('test2')
     end
         
   end
diff --git a/spec/models/time_table_combination_spec.rb b/spec/models/time_table_combination_spec.rb
index 842c6f211..20526a0fe 100644
--- a/spec/models/time_table_combination_spec.rb
+++ b/spec/models/time_table_combination_spec.rb
@@ -1,15 +1,11 @@
 require 'spec_helper'
 
-describe TimeTableCombination do
+describe TimeTableCombination, :type => :model do
   let!(:source){ Factory(:time_table)}
   let!(:combined){Factory(:time_table)}
   subject {Factory.build(:time_table_combination)}
   
-  it { should validate_presence_of :source_id }
-  it { should validate_presence_of :combined_id }
-  it { should validate_presence_of :operation }
-  
-  it { should ensure_inclusion_of(:operation).in_array(TimeTableCombination.operations) }
+  it { is_expected.to ensure_inclusion_of(:operation).in_array(TimeTableCombination.operations) }
 
   
   describe "#combine" do
@@ -32,9 +28,9 @@ describe TimeTableCombination do
         source.reload
       end
       it "should add combined to source" do
-        source.periods.size.should == 1
-        source.periods[0].period_start.should == Date.new(2014,8,1)
-        source.periods[0].period_end.should == Date.new(2014,9,15)
+        expect(source.periods.size).to eq(1)
+        expect(source.periods[0].period_start).to eq(Date.new(2014,8,1))
+        expect(source.periods[0].period_end).to eq(Date.new(2014,9,15))
       end
     end
     context "when operation is intersect" do
@@ -56,9 +52,9 @@ describe TimeTableCombination do
         source.reload
       end
       it "should intersect combined to source" do
-        source.periods.size.should == 1
-        source.periods[0].period_start.should == Date.new(2014,8,15)
-        source.periods[0].period_end.should == Date.new(2014,8,31)
+        expect(source.periods.size).to eq(1)
+        expect(source.periods[0].period_start).to eq(Date.new(2014,8,15))
+        expect(source.periods[0].period_end).to eq(Date.new(2014,8,31))
       end
     end
     context "when operation is disjoin" do
@@ -80,9 +76,9 @@ describe TimeTableCombination do
         source.reload
       end
       it "should disjoin combined to source" do
-        source.periods.size.should == 1
-        source.periods[0].period_start.should == Date.new(2014,8,1)
-        source.periods[0].period_end.should == Date.new(2014,8,14)
+        expect(source.periods.size).to eq(1)
+        expect(source.periods[0].period_start).to eq(Date.new(2014,8,1))
+        expect(source.periods[0].period_end).to eq(Date.new(2014,8,14))
       end
     end
  end
diff --git a/spec/models/user_spec.rb b/spec/models/user_spec.rb
index dbf95a120..c818f9673 100644
--- a/spec/models/user_spec.rb
+++ b/spec/models/user_spec.rb
@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe User do
+describe User, :type => :model do
   #it { should validate_uniqueness_of :email }
   #it { should validate_presence_of :name }
 
@@ -11,10 +11,10 @@ describe User do
       let!(:other_user){Factory(:user, :organisation => organisation)}
       it "should destoy also user's organisation" do
         user.destroy
-        Organisation.where(:name => organisation.name).exists?.should be_true
+        expect(Organisation.where(:name => organisation.name).exists?).to be_truthy
         read_organisation = Organisation.where(:name => organisation.name).first
-        read_organisation.users.count.should == 1
-        read_organisation.users.first.should == other_user
+        expect(read_organisation.users.count).to eq(1)
+        expect(read_organisation.users.first).to eq(other_user)
       end
     end
   end
diff --git a/spec/models/vehicle_journey_export_spec.rb b/spec/models/vehicle_journey_export_spec.rb
index 5ce3b9bfc..49c3d2fc6 100644
--- a/spec/models/vehicle_journey_export_spec.rb
+++ b/spec/models/vehicle_journey_export_spec.rb
@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 require 'spec_helper'
 
-describe VehicleJourneyExport do
+describe VehicleJourneyExport, :type => :model do
   
   let!(:route) { create(:route) }
   let!(:other_route) { create(:route) }
diff --git a/spec/models/vehicle_journey_import_spec.rb b/spec/models/vehicle_journey_import_spec.rb
index 68f8669e0..c2f9f473d 100644
--- a/spec/models/vehicle_journey_import_spec.rb
+++ b/spec/models/vehicle_journey_import_spec.rb
@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 require 'spec_helper'
 
-describe VehicleJourneyImport do
+describe VehicleJourneyImport, :type => :model do
 
   def update_csv_file_with_factory_data(filename)
     csv_file = CSV.open("/tmp/#{filename}", "wb",{ :col_sep => ";"}) do |csv|
@@ -49,22 +49,22 @@ describe VehicleJourneyImport do
   # Must use uploaded file and not classical ruby File!
   let(:valid_file) {
     csv_file = update_csv_file_with_factory_data("vehicle_journey_imports_valid.csv")
-    mock("CSV", :tempfile => csv_file, :original_filename => File.basename(csv_file), :path => File.path(csv_file) )
+    double("CSV", :tempfile => csv_file, :original_filename => File.basename(csv_file), :path => File.path(csv_file) )
   }
 
   let(:invalid_file_on_vj) {
     csv_file = update_csv_file_with_factory_data("vehicle_journey_imports_with_vj_invalid.csv")
-    mock("CSV", :tempfile => csv_file, :original_filename => File.basename(csv_file), :path => File.path(csv_file) )
+    double("CSV", :tempfile => csv_file, :original_filename => File.basename(csv_file), :path => File.path(csv_file) )
   }
 
   let(:invalid_file_on_vjas) {
     csv_file = update_csv_file_with_factory_data("vehicle_journey_imports_with_vjas_invalid.csv")
-    mock("CSV", :tempfile => csv_file, :original_filename => File.basename(csv_file), :path => File.path(csv_file) )
+    double("CSV", :tempfile => csv_file, :original_filename => File.basename(csv_file), :path => File.path(csv_file) )
   }
 
   let(:invalid_file_on_vjas_object) {
     csv_file = update_csv_file_with_factory_data("vehicle_journey_imports_with_vjas_bad_order.csv")
-    mock("CSV", :tempfile => csv_file, :original_filename => File.basename(csv_file), :path => File.path(csv_file) )
+    double("CSV", :tempfile => csv_file, :original_filename => File.basename(csv_file), :path => File.path(csv_file) )
   }
   
   subject { VehicleJourneyImport.new(:route => route, :file => valid_file) } 
@@ -72,21 +72,21 @@ describe VehicleJourneyImport do
   describe ".save" do
 
     it "should validate presence of route" do
-      expect(VehicleJourneyImport.new(:route => route).save).to be_false
+      expect(VehicleJourneyImport.new(:route => route).save).to be_falsey
     end
 
     it "should validate presence of file" do
-      expect(VehicleJourneyImport.new(:file => valid_file).save).to be_false
+      expect(VehicleJourneyImport.new(:file => valid_file).save).to be_falsey
     end
 
     it "should import vehicle_journeys and create the right number of objects" do
-      expect(VehicleJourneyImport.new(:file => valid_file, :route => route).save).to be_true
+      expect(VehicleJourneyImport.new(:file => valid_file, :route => route).save).to be_truthy
       expect(Chouette::VehicleJourney.all.size).to eq(4)
       expect(Chouette::VehicleJourneyAtStop.all.size).to eq(17)
     end
 
     it "should not import vehicle_journeys and not create objects when vehicle journey at stops are not in ascendant order" do      
-      expect(VehicleJourneyImport.new(:route => route, :file => invalid_file_on_vjas_object).save).to be_false
+      expect(VehicleJourneyImport.new(:route => route, :file => invalid_file_on_vjas_object).save).to be_falsey
       expect(Chouette::VehicleJourney.all.size).to eq(3)
       expect(Chouette::VehicleJourneyAtStop.all.size).to eq(0)
     end
@@ -107,7 +107,7 @@ describe VehicleJourneyImport do
     end
 
     it "should return new journey_pattern if no journey pattern with same stop points is founded" do      
-      expect(subject.find_journey_pattern_schedule( 1, { stop_point0.id => "9:00", stop_point1.id => "9:05", stop_point2.id => nil, stop_point3.id => "9:15", stop_point4.id => "9:20"} )).to be_true
+      expect(subject.find_journey_pattern_schedule( 1, { stop_point0.id => "9:00", stop_point1.id => "9:05", stop_point2.id => nil, stop_point3.id => "9:15", stop_point4.id => "9:20"} )).to be_truthy
       expect(subject.find_journey_pattern_schedule( 1, { stop_point0.id => "9:00", stop_point1.id => "9:05", stop_point2.id => nil, stop_point3.id => "9:15", stop_point4.id => "9:20"} ).id).not_to eq(journey_pattern.id)
       expect(subject.find_journey_pattern_schedule( 1, { stop_point0.id => "9:00", stop_point1.id => "9:05", stop_point2.id => nil, stop_point3.id => "9:15", stop_point4.id => "9:20"} ).id).not_to eq(other_journey_pattern.id)
     end
diff --git a/spec/models/vehicle_translation_spec.rb b/spec/models/vehicle_translation_spec.rb
index bc16f2260..6b6783c1e 100644
--- a/spec/models/vehicle_translation_spec.rb
+++ b/spec/models/vehicle_translation_spec.rb
@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe VehicleTranslation do
+describe VehicleTranslation, :type => :model do
   let!(:company){ Factory(:company )}
   let!(:journey_pattern){Factory(:journey_pattern)}
   let!(:vehicle_journey){ Factory(:vehicle_journey,
@@ -23,19 +23,19 @@ describe VehicleTranslation do
       it "should have an error on first_stop_departure_time" do
         subject.first_stop_time = "dummy"
         subject.valid?
-        subject.errors[ :first_stop_time].should_not be_nil
+        expect(subject.errors[ :first_stop_time]).not_to be_nil
       end
     end
 
   end
   describe "#evaluate_delta" do
     it "should return 3600 seconds" do
-      subject.evaluate_delta( Time.parse( "11:00")).should == 3600.0
+      expect(subject.evaluate_delta( Time.parse( "11:00"))).to eq(3600.0)
     end
   end
   describe "#first_delta" do
     it "should return 3600 seconds" do
-      subject.should_receive( :first_vjas_time).and_return( Time.parse( "11:00"))
+      expect(subject).to receive( :first_vjas_time).and_return( Time.parse( "11:00"))
       subject.first_delta
     end
   end
@@ -45,42 +45,42 @@ describe VehicleTranslation do
       count_before = Chouette::VehicleJourney.count
       subject.translate
       count_after = Chouette::VehicleJourney.count
-      count_after.should == count_before + subject.count.to_i
+      expect(count_after).to eq(count_before + subject.count.to_i)
     end
     def last_created_vehicle
       Chouette::VehicleJourney.find( :all, :order => :creation_time).last
     end
     it "should add vehicle having same published_journey_name" do
       subject.translate
-      last_created_vehicle.published_journey_name.should == vehicle_journey.published_journey_name
+      expect(last_created_vehicle.published_journey_name).to eq(vehicle_journey.published_journey_name)
     end
     it "should add vehicle having same transport_mode" do
       subject.translate
-      last_created_vehicle.transport_mode.should == vehicle_journey.transport_mode
+      expect(last_created_vehicle.transport_mode).to eq(vehicle_journey.transport_mode)
     end
     it "should add vehicle having same journey_pattern" do
       subject.translate
-      last_created_vehicle.journey_pattern.should == vehicle_journey.journey_pattern
+      expect(last_created_vehicle.journey_pattern).to eq(vehicle_journey.journey_pattern)
     end
     it "should add vehicle having same route" do
       subject.translate
-      last_created_vehicle.route.should == vehicle_journey.route
+      expect(last_created_vehicle.route).to eq(vehicle_journey.route)
     end
     it "should add vehicle having same company" do
       subject.translate
-      last_created_vehicle.company.should == vehicle_journey.company
+      expect(last_created_vehicle.company).to eq(vehicle_journey.company)
     end
     it "should add vehicle with as many vehicle_journey_at_stops as on basic vehicle" do
       subject.translate
-      last_created_vehicle.vehicle_journey_at_stops.count.should == vehicle_journey.vehicle_journey_at_stops.count
+      expect(last_created_vehicle.vehicle_journey_at_stops.count).to eq(vehicle_journey.vehicle_journey_at_stops.count)
     end
     it "should add vehicle where vehicle_journey_at_stops are translated with #duration" do
       read_vehicle = Chouette::VehicleJourney.find(vehicle_journey.id)  # read from bd, change time values
       delta = subject.first_delta
       subject.translate
       last_created_vehicle.vehicle_journey_at_stops.each_with_index do |vjas, index|
-        vjas.departure_time.should == (read_vehicle.vehicle_journey_at_stops[index].departure_time + delta + subject.duration.minutes)
-        vjas.arrival_time.should == (read_vehicle.vehicle_journey_at_stops[index].arrival_time + delta + subject.duration.minutes)
+        expect(vjas.departure_time).to eq(read_vehicle.vehicle_journey_at_stops[index].departure_time + delta + subject.duration.minutes)
+        expect(vjas.arrival_time).to eq(read_vehicle.vehicle_journey_at_stops[index].arrival_time + delta + subject.duration.minutes)
       end
     end
   end