From 70cccb2dad101d76f152409bc2517a70376e8f0d Mon Sep 17 00:00:00 2001
From: Carlos Eduardo Cabral da Cunha <eduardosolrac286@gmail.com>
Date: Tue, 2 Jul 2019 14:44:37 -0300
Subject: [PATCH 1/9] #298 adding create header labels to pages that did not
 have them

---
 app/controllers/advisement_authorizations_controller.rb        | 3 ++-
 app/controllers/enrollment_holds_controller.rb                 | 1 +
 app/controllers/queries_controller.rb                          | 2 +-
 app/controllers/roles_controller.rb                            | 3 ++-
 .../thesis_defense_committee_participations_controller.rb      | 2 +-
 config/locales/pt-BR.yml                                       | 3 +++
 6 files changed, 10 insertions(+), 4 deletions(-)

diff --git a/app/controllers/advisement_authorizations_controller.rb b/app/controllers/advisement_authorizations_controller.rb
index e4538e88..42c415c8 100644
--- a/app/controllers/advisement_authorizations_controller.rb
+++ b/app/controllers/advisement_authorizations_controller.rb
@@ -5,6 +5,7 @@ class AdvisementAuthorizationsController < ApplicationController
   authorize_resource
 
   active_scaffold :advisement_authorization do |config|
+    config.create.label = :create_advisement_authorization_label	  
     config.columns = [:professor, :level]
     config.actions.swap :search, :field_search
     config.field_search.columns = [:professor, :level]
@@ -17,4 +18,4 @@ class AdvisementAuthorizationsController < ApplicationController
     config.actions.exclude :deleted_records
   end
   record_select :per_page => 10
-end
\ No newline at end of file
+end
diff --git a/app/controllers/enrollment_holds_controller.rb b/app/controllers/enrollment_holds_controller.rb
index 6929b06e..5a100c96 100644
--- a/app/controllers/enrollment_holds_controller.rb
+++ b/app/controllers/enrollment_holds_controller.rb
@@ -5,6 +5,7 @@
 class EnrollmentHoldsController < ApplicationController
   authorize_resource
   active_scaffold :"enrollment_hold" do |config|
+    config.create.label = :create_enrollment_hold_label
   	config.columns = [:enrollment, :year, :semester, :number_of_semesters, :active]
   	config.actions.swap :search, :field_search
     config.field_search.columns = [:enrollment, :active]
diff --git a/app/controllers/queries_controller.rb b/app/controllers/queries_controller.rb
index 23af22bf..15e775e3 100644
--- a/app/controllers/queries_controller.rb
+++ b/app/controllers/queries_controller.rb
@@ -5,7 +5,7 @@ class QueriesController < ApplicationController
   authorize_resource
 
   active_scaffold :query do |config|
-
+    config.create.label = :create_query_label
     config.action_links.add 'execute',
       :label => "<i title='#{I18n.t('active_scaffold.query.execute')}' class='fa fa-table'></i>".html_safe,
       :page => true,
diff --git a/app/controllers/roles_controller.rb b/app/controllers/roles_controller.rb
index 83147c47..1ebf24cb 100644
--- a/app/controllers/roles_controller.rb
+++ b/app/controllers/roles_controller.rb
@@ -6,6 +6,7 @@ class RolesController < ApplicationController
   authorize_resource
 
   active_scaffold :role do |config|
+    config.create.label = :create_role_label
     config.list.columns = [:id, :name, :description]
     config.columns = [:name, :description]
     config.columns[:description].form_ui = :textarea
@@ -14,4 +15,4 @@ class RolesController < ApplicationController
     config.actions.exclude :deleted_records
   end
 
-end
\ No newline at end of file
+end
diff --git a/app/controllers/thesis_defense_committee_participations_controller.rb b/app/controllers/thesis_defense_committee_participations_controller.rb
index e3f2188c..a2247f40 100644
--- a/app/controllers/thesis_defense_committee_participations_controller.rb
+++ b/app/controllers/thesis_defense_committee_participations_controller.rb
@@ -7,7 +7,7 @@ class ThesisDefenseCommitteeParticipationsController < ApplicationController
 
   active_scaffold :"thesis_defense_committee_participation" do |config|
   	columns = [:enrollment, :professor]
-
+    config.create.label = :create_thesis_defense_committee_participation_label
     config.list.columns = columns
     config.create.columns = columns
     config.update.columns = columns
diff --git a/config/locales/pt-BR.yml b/config/locales/pt-BR.yml
index f4b930d4..7bd11af8 100644
--- a/config/locales/pt-BR.yml
+++ b/config/locales/pt-BR.yml
@@ -751,6 +751,7 @@ pt-BR:
     create_deferral_type_label: "Adicionar Tipo de Prorrogação"
     create_dismissal_label: "Adicionar Desligamento"
     create_dismissal_reason_label: "Adicionar Razão de Desligamento"
+    create_enrollment_hold_label: "Adicionar Trancamento"
     create_enrollment_label: "Adicionar Matrícula"
     create_enrollment_status_label: "Adicionar Tipo de Matrícula"
     create_institution_label: "Adicionar Instituição"
@@ -762,8 +763,10 @@ pt-BR:
     create_phase_label: "Adicionar Fase"
     create_professor_label: "Adicionar Professor"
     create_professor_research_area_label: "Adicionar Área de Pesquisa do Professor"
+    create_query_label: "Adicionar Consulta"
     create_report_configuration_label: "Adicionar Configuração de Relatório"
     create_research_area_label: "Adicionar Área de Pesquisa"
+    create_role_label: "Adicionar Papel"
     create_scholarship_duration_label: "Adicionar Bolsa"
     create_scholarship_label: "Adicionar Bolsa"
     create_scholarship_type_label: "Adicionar Tipo de Bolsa"

From 50f1f60022c57cbed9d6ed906fba3c7cc3d066b9 Mon Sep 17 00:00:00 2001
From: Carlos Eduardo Cabral da Cunha <eduardosolrac286@gmail.com>
Date: Tue, 2 Jul 2019 18:39:46 -0300
Subject: [PATCH 2/9] #297 adding rspec presence tests to model Query and
 fixing them

---
 app/helpers/queries_helper.rb |  3 ++-
 app/models/query.rb           |  3 +++
 spec/models/query_spec.rb     | 18 ++++++++++++++++++
 3 files changed, 23 insertions(+), 1 deletion(-)

diff --git a/app/helpers/queries_helper.rb b/app/helpers/queries_helper.rb
index 56271174..efbea40d 100644
--- a/app/helpers/queries_helper.rb
+++ b/app/helpers/queries_helper.rb
@@ -4,6 +4,7 @@
 module QueriesHelper
 
   def code_mirror_text_area(column, id, type, options)
+    options[:required] = false
     block = text_area(:record, :sql_query, options)
     block += "<script>
     CodeMirror.fromTextArea(document.getElementById('#{id}'),
@@ -54,4 +55,4 @@ def next_execution_column(record, options)
   def body_template_show_column(record, column)
     code_mirror_view("body_template-view-#{record.id}", "text/html", record.body_template)
   end
-end
\ No newline at end of file
+end
diff --git a/app/models/query.rb b/app/models/query.rb
index 7ae7af49..9e9705a2 100644
--- a/app/models/query.rb
+++ b/app/models/query.rb
@@ -9,6 +9,8 @@ class Query < ApplicationRecord
 
   accepts_nested_attributes_for :params, reject_if: :all_blank, allow_destroy: true
 
+  validates :name, :presence => true
+  validates :sql, :presence => true
   validate :ensure_valid_params
   validates_associated :params
 
@@ -68,6 +70,7 @@ def execute(override_params = {})
 
 
   def ensure_valid_params
+    return if (sql.nil? || sql.strip.empty?)	  
     begin
       self.execute
     rescue ActiveRecord::PreparedStatementInvalid => e
diff --git a/spec/models/query_spec.rb b/spec/models/query_spec.rb
index 151f958a..e8f53d84 100644
--- a/spec/models/query_spec.rb
+++ b/spec/models/query_spec.rb
@@ -6,4 +6,22 @@
 
 describe Query do
 
+  let(:query) {Query.new}
+  subject { query }
+  context "creating or updating" do
+
+    context "name is blank" do
+      it "show an blank error on name" do
+	query.name = nil     
+        query.should have_error(:blank).on :name
+      end
+    end
+    context "sql is blank" do
+      it "show an blank error on sql" do
+        query.sql = ""      
+        query.should have_error(:blank).on :sql
+      end
+    end
+  end
+
 end

From 69b272da7aec7c54c02ee446d5e9217ffba0b591 Mon Sep 17 00:00:00 2001
From: Carlos Eduardo Cabral da Cunha <eduardosolrac286@gmail.com>
Date: Fri, 9 Aug 2019 13:10:26 -0300
Subject: [PATCH 3/9] #254 adding a variable to enable or disable if professors
 can post grades

---
 db/migrate/20190809144853_add_new_custom_variable.rb | 5 +++++
 db/schema.rb                                         | 2 +-
 2 files changed, 6 insertions(+), 1 deletion(-)
 create mode 100644 db/migrate/20190809144853_add_new_custom_variable.rb

diff --git a/db/migrate/20190809144853_add_new_custom_variable.rb b/db/migrate/20190809144853_add_new_custom_variable.rb
new file mode 100644
index 00000000..1e96cca2
--- /dev/null
+++ b/db/migrate/20190809144853_add_new_custom_variable.rb
@@ -0,0 +1,5 @@
+class AddNewCustomVariable < ActiveRecord::Migration[5.1]
+  def change
+    CustomVariable.where(:variable => "professor_login_can_post_grades").first or CustomVariable.create(:description=>"Professor logado no sistema pode lançar notas", :variable =>"professor_login_can_post_grades", :value => "no")
+  end
+end
diff --git a/db/schema.rb b/db/schema.rb
index 61364963..364abd17 100644
--- a/db/schema.rb
+++ b/db/schema.rb
@@ -10,7 +10,7 @@
 #
 # It's strongly recommended that you check this file into your version control system.
 
-ActiveRecord::Schema.define(version: 20180202200850) do
+ActiveRecord::Schema.define(version: 20190809144853) do
 
   create_table "accomplishments", force: :cascade do |t|
     t.integer "enrollment_id"

From 4d221761bb93f5e7e34a2ffc0691fb76184f0800 Mon Sep 17 00:00:00 2001
From: Carlos Eduardo Cabral da Cunha <eduardosolrac286@gmail.com>
Date: Mon, 21 Oct 2019 17:28:43 -0200
Subject: [PATCH 4/9] #296 implementing query_param_spec and fixing query_param
 bugs

---
 app/models/query.rb             |   2 +-
 app/models/query_param.rb       |  11 +-
 config/locales/pt-BR.yml        |   8 +-
 spec/models/query_param_spec.rb | 427 +++++++++++++++++++++++++++++++-
 4 files changed, 441 insertions(+), 7 deletions(-)

diff --git a/app/models/query.rb b/app/models/query.rb
index 9e9705a2..7aa60ed7 100644
--- a/app/models/query.rb
+++ b/app/models/query.rb
@@ -4,7 +4,7 @@
 class Query < ApplicationRecord
 
   has_many :notifications, inverse_of: :query
-  has_many :params, class_name: 'QueryParam', dependent: :destroy
+  has_many :params, class_name: 'QueryParam', dependent: :destroy, validate: false
 
 
   accepts_nested_attributes_for :params, reject_if: :all_blank, allow_destroy: true
diff --git a/app/models/query_param.rb b/app/models/query_param.rb
index bf0988a1..5c55e58b 100644
--- a/app/models/query_param.rb
+++ b/app/models/query_param.rb
@@ -20,7 +20,8 @@ class QueryParam < ApplicationRecord
                  VALUE_DATE, VALUE_DATETIME, VALUE_TIME, VALUE_LITERAL]
 
   validates :value_type, presence: true, inclusion: VALUE_TYPES
-  validates :name, presence: true, :format => /\A([a-z_][a-zA-Z_0-9]+)?\z/
+  #validates :name, presence: true, :format => /\A([a-z_][a-zA-Z_0-9]+)?\z/
+  validates :name, presence: true, format: { with: /\A([a-z_][a-zA-Z_0-9]+)?\z/, message: :invalid_name }
 
   validate do
     validate_value(default_value)
@@ -58,11 +59,15 @@ def validate_value(val)
           end
 
         when VALUE_INTEGER
-          if val.to_i.to_s != val.to_s
+	  begin
+	    Integer(val)	  
+	  rescue
             self.errors.add :default_value, :invalid_integer
           end
         when VALUE_FLOAT
-          if val.to_f.to_s != val.to_s
+	  begin
+	    Float(val)	  
+	  rescue
             self.errors.add :default_value, :invalid_float
           end
       end
diff --git a/config/locales/pt-BR.yml b/config/locales/pt-BR.yml
index 7bd11af8..c0297604 100644
--- a/config/locales/pt-BR.yml
+++ b/config/locales/pt-BR.yml
@@ -306,7 +306,7 @@ pt-BR:
         notifications: Notificações
         params: Parâmetros
       query_param:
-        name: Name
+        name: Nome
         value_type: Tipo
         default_value: Valor padrão
       notification_param:
@@ -470,6 +470,7 @@ pt-BR:
           attributes:
             name:
               restricted_name: não pode ser usado pois é uma palavra reservada do sistema.
+              invalid_name: "não é válido. Ele deve iniciar com letra minúscula ou underscore '_', seguido de um ou mais: letra minúscula, maiúscula, dígito ou underscore"
             default_value:
               invalid_integer: não é um número inteiro válido
               invalid_float: não é um número float válido
@@ -676,8 +677,11 @@ pt-BR:
         one: "Área de Pesquisa do Professor"
         other: "Área de Pesquisa dos Professores"
       query:
-        one: Contulta
+        one: Consulta
         other: Consultas
+      query_param:
+        one: "Parâmetro"
+        other: "Parâmetros"      
       report:
         one: Relatório
         other: Relatórios
diff --git a/spec/models/query_param_spec.rb b/spec/models/query_param_spec.rb
index f0de5677..3db3d992 100644
--- a/spec/models/query_param_spec.rb
+++ b/spec/models/query_param_spec.rb
@@ -5,5 +5,430 @@
 require 'spec_helper'
 
 describe QueryParam do
-  pending "add some examples to (or delete) #{__FILE__}"
+
+  let(:query_param) {QueryParam.new}
+  subject { query_param }
+
+  context "creating or updating" do
+
+    context "name is blank" do
+      it "show an blank error on name" do
+	query_param.name = nil     
+        query_param.should have_error(:blank).on :name
+      end
+    end
+
+    context "name is invalid" do
+      it "show an format error on name" do
+	query_param.name = "A"
+        query_param.should have_error(:invalid_name).on :name
+
+	query_param.name = "_"
+        query_param.should have_error(:invalid_name).on :name
+
+	query_param.name = " "
+        query_param.should have_error(:invalid_name).on :name
+
+        query_param.name = "0"
+        query_param.should have_error(:invalid_name).on :name
+
+        query_param.name = "Za"
+        query_param.should have_error(:invalid_name).on :name
+
+        query_param.name = "9z"
+        query_param.should have_error(:invalid_name).on :name
+
+	query_param.name = "a|\\<>,.:;?/ç^~{}[]'`'\"!@#$%&*()-+= 	\t\n\r"
+        query_param.should have_error(:invalid_name).on :name
+
+      end
+    end
+
+    context "name is valid" do
+      it "do not have errors on name" do
+	query_param.name = "aa"
+        query_param.should have(0).errors_on :name
+
+	query_param.name = "zA"
+        query_param.should have(0).errors_on :name
+
+	query_param.name = "a9"
+        query_param.should have(0).errors_on :name
+
+        query_param.name = "z0"
+        query_param.should have(0).errors_on :name
+
+	query_param.name = "a_"
+        query_param.should have(0).errors_on :name
+
+        query_param.name = "_a"
+        query_param.should have(0).errors_on :name
+
+        query_param.name = "_z"
+        query_param.should have(0).errors_on :name
+
+	query_param.name = "_0"
+        query_param.should have(0).errors_on :name
+
+	query_param.name = "_9"
+        query_param.should have(0).errors_on :name
+
+        query_param.name = "__"
+        query_param.should have(0).errors_on :name
+
+	query_param.name = "aA_z0"
+        query_param.should have(0).errors_on :name
+
+        query_param.name = "_aZ9_"
+        query_param.should have(0).errors_on :name
+      end
+    end
+
+    context "value_type is blank" do
+      it "show an blank error on value_type" do
+        query_param.value_type = nil      
+        query_param.should have_error(:blank).on :value_type
+      end
+    end
+
+    context "value_type is invalid" do
+      it "show an inclusion error on value_type" do
+        query_param.value_type = "tipo_invalido"
+        query_param.should have_error(:inclusion).on :value_type
+      end
+    end
+
+    context "value_type is valid" do
+      it "do not have errors in value_type" do
+
+     	query_param.value_type = "String"
+        query_param.should have(0).errors_on :value_type
+
+     	query_param.value_type = "Integer"
+        query_param.should have(0).errors_on :value_type
+
+     	query_param.value_type = "Float"
+        query_param.should have(0).errors_on :value_type
+
+     	query_param.value_type = "List"
+        query_param.should have(0).errors_on :value_type
+
+     	query_param.value_type = "Date"
+        query_param.should have(0).errors_on :value_type
+
+     	query_param.value_type = "DateTime"
+        query_param.should have(0).errors_on :value_type
+
+     	query_param.value_type = "Time"
+        query_param.should have(0).errors_on :value_type
+
+     	query_param.value_type = "Literal"
+        query_param.should have(0).errors_on :value_type
+
+      end	      
+    end
+
+    context "default_value is incompatible with value_type" do
+     it "show an integer error on default_value" do
+       query_param.value_type = "Integer"
+
+       query_param.default_value = " "
+       query_param.should have_error(:invalid_integer).on :default_value
+
+       query_param.default_value = "a"
+       query_param.should have_error(:invalid_integer).on :default_value
+
+       query_param.default_value = "0.0"
+       query_param.should have_error(:invalid_integer).on :default_value
+
+       query_param.default_value = "1.0"
+       query_param.should have_error(:invalid_integer).on :default_value
+
+       query_param.default_value = "0.1"
+       query_param.should have_error(:invalid_integer).on :default_value
+
+       query_param.default_value = "-1.0"
+       query_param.should have_error(:invalid_integer).on :default_value
+
+       query_param.default_value = ".0"
+       query_param.should have_error(:invalid_integer).on :default_value
+
+       query_param.default_value = ".1"
+       query_param.should have_error(:invalid_integer).on :default_value
+
+       query_param.default_value = ",0" 
+       query_param.should have_error(:invalid_integer).on :default_value
+
+       query_param.default_value = ",1"
+       query_param.should have_error(:invalid_integer).on :default_value
+
+       query_param.default_value = "1,0" 
+       query_param.should have_error(:invalid_integer).on :default_value
+     end
+
+     it "show an float error on default_value" do
+       query_param.value_type = "Float"
+
+       query_param.default_value = " "
+       query_param.should have_error(:invalid_float).on :default_value
+
+       query_param.default_value = "a"
+       query_param.should have_error(:invalid_float).on :default_value
+ 
+       query_param.default_value = "."
+       query_param.should have_error(:invalid_float).on :default_value
+
+       query_param.default_value = ","
+       query_param.should have_error(:invalid_float).on :default_value
+
+       query_param.default_value = "1,0"
+       query_param.should have_error(:invalid_float).on :default_value
+
+       query_param.default_value = "0,0"
+       query_param.should have_error(:invalid_float).on :default_value
+
+       query_param.default_value = "0,1"
+       query_param.should have_error(:invalid_float).on :default_value
+
+       query_param.default_value = "1,000"
+       query_param.should have_error(:invalid_float).on :default_value
+     end
+
+     it "show an time error on default_value" do
+       query_param.value_type = "Time"
+
+       query_param.default_value = " "
+       query_param.should have_error(:invalid_time).on :default_value
+
+       query_param.default_value = "a"
+       query_param.should have_error(:invalid_time).on :default_value
+
+       query_param.default_value = "1"
+       query_param.should have_error(:invalid_time).on :default_value
+
+       query_param.default_value = "24:01"
+       query_param.should have_error(:invalid_time).on :default_value
+
+       query_param.default_value = "25:00"
+       query_param.should have_error(:invalid_time).on :default_value
+
+       query_param.default_value = "22:60"
+       query_param.should have_error(:invalid_time).on :default_value
+
+       query_param.default_value = "22:50:61"
+       query_param.should have_error(:invalid_time).on :default_value
+     end
+
+     it "show an date error on default_value" do
+       query_param.value_type = "Date"
+
+       query_param.default_value = " "
+       query_param.should have_error(:invalid_date).on :default_value
+
+       query_param.default_value = "a"
+       query_param.should have_error(:invalid_date).on :default_value
+
+       query_param.default_value = "1"
+       query_param.should have_error(:invalid_date).on :default_value
+
+       query_param.default_value = "32/12/2019"
+       query_param.should have_error(:invalid_date).on :default_value
+
+       query_param.default_value = "30/13/2019"
+       query_param.should have_error(:invalid_date).on :default_value
+
+       query_param.default_value = "29/02/2019"
+       query_param.should have_error(:invalid_date).on :default_value
+
+       query_param.default_value = "20193112"
+       query_param.should have_error(:invalid_date).on :default_value
+     end
+
+     it "show an date_time error on default_value" do
+       query_param.value_type = "DateTime"
+
+       query_param.default_value = " "
+       query_param.should have_error(:invalid_date_time).on :default_value
+
+       query_param.default_value = "a"
+       query_param.should have_error(:invalid_date_time).on :default_value
+
+       query_param.default_value = "1"
+       query_param.should have_error(:invalid_date_time).on :default_value
+
+       query_param.default_value = "32/10/2010 20:21:22"
+       query_param.should have_error(:invalid_date_time).on :default_value
+
+       query_param.default_value = "30/13/2010 20:21:22"
+       query_param.should have_error(:invalid_date_time).on :default_value
+
+       query_param.default_value = "15/12/2010 24:21:22"
+       query_param.should have_error(:invalid_date_time).on :default_value
+
+       query_param.default_value = "15/12/2010 23:60:22"
+       query_param.should have_error(:invalid_date_time).on :default_value
+
+       query_param.default_value = "15/12/2010 23:30:61"
+       query_param.should have_error(:invalid_date_time).on :default_value
+     end
+
+    end
+
+    context "default_value is compatible with value_type" do
+      it "do not have errors in default_value" do
+        query_param.value_type = "String"
+       
+	query_param.default_value = " "
+        query_param.should have(0).errors_on :default_value	
+
+        query_param.default_value = " Qualquer String 1234 "
+        query_param.should have(0).errors_on :default_value
+
+        query_param.value_type = "Literal"
+       
+	query_param.default_value = " "
+        query_param.should have(0).errors_on :default_value	
+
+        query_param.default_value = " Qualquer Literal 1234 "
+        query_param.should have(0).errors_on :default_value
+
+	query_param.value_type = "List"
+
+	query_param.default_value = " "
+        query_param.should have(0).errors_on :default_value
+
+        query_param.default_value = " Qualquer String para lista 1234 ,, ,,, ,a,b,123, "
+        query_param.should have(0).errors_on :default_value
+
+	query_param.value_type = "Integer"
+
+	query_param.default_value = "0"
+        query_param.should have(0).errors_on :default_value
+
+        query_param.default_value = "+0"
+        query_param.should have(0).errors_on :default_value
+
+	query_param.default_value = "-0"
+        query_param.should have(0).errors_on :default_value
+
+	query_param.default_value = "01"
+        query_param.should have(0).errors_on :default_value
+
+	query_param.default_value = "1"
+        query_param.should have(0).errors_on :default_value
+
+	query_param.default_value = "-1"
+        query_param.should have(0).errors_on :default_value
+
+	query_param.default_value = "+1"
+        query_param.should have(0).errors_on :default_value
+
+	query_param.default_value = "99999999"
+        query_param.should have(0).errors_on :default_value
+
+	query_param.default_value = "-99999999"
+        query_param.should have(0).errors_on :default_value
+
+        query_param.value_type = "Float"
+       
+	query_param.default_value = "0"
+        query_param.should have(0).errors_on :default_value	
+
+        query_param.default_value = "+0"
+        query_param.should have(0).errors_on :default_value
+
+	query_param.default_value = "-0"
+        query_param.should have(0).errors_on :default_value
+
+	query_param.default_value = "1"
+        query_param.should have(0).errors_on :default_value
+
+	query_param.default_value = "-1"
+        query_param.should have(0).errors_on :default_value
+
+	query_param.default_value = "+1"
+        query_param.should have(0).errors_on :default_value
+
+	query_param.default_value = ".0"
+        query_param.should have(0).errors_on :default_value
+
+	query_param.default_value = ".1"
+        query_param.should have(0).errors_on :default_value
+
+	query_param.default_value = "-.0"
+        query_param.should have(0).errors_on :default_value
+
+	query_param.default_value = "-.1"
+        query_param.should have(0).errors_on :default_value
+
+	query_param.default_value = "0.0"
+        query_param.should have(0).errors_on :default_value
+
+	query_param.default_value = "0.1"
+        query_param.should have(0).errors_on :default_value
+
+	query_param.default_value = "10.01"
+        query_param.should have(0).errors_on :default_value
+
+	query_param.default_value = "-10.01"
+        query_param.should have(0).errors_on :default_value
+
+	query_param.default_value = "9999.9999"
+        query_param.should have(0).errors_on :default_value
+
+	query_param.default_value = "-9999.9999"
+        query_param.should have(0).errors_on :default_value
+
+	query_param.default_value = "+9999.9999"
+        query_param.should have(0).errors_on :default_value
+
+        query_param.value_type = "Time"
+       
+	query_param.default_value = "11:50"
+        query_param.should have(0).errors_on :default_value	
+
+        query_param.default_value = "11:50:30"
+        query_param.should have(0).errors_on :default_value
+
+	query_param.default_value = "23:59:59"
+        query_param.should have(0).errors_on :default_value
+
+	query_param.default_value = "23:59"
+        query_param.should have(0).errors_on :default_value
+	
+        query_param.value_type = "Date"
+
+	query_param.default_value = "31/12/2019"
+        query_param.should have(0).errors_on :default_value
+
+        query_param.default_value = "31-12-2019"
+        query_param.should have(0).errors_on :default_value
+
+	query_param.default_value = "20191231"
+        query_param.should have(0).errors_on :default_value
+
+	query_param.default_value = "29/02/2020"
+        query_param.should have(0).errors_on :default_value
+
+        query_param.value_type = "DateTime"
+       
+	query_param.default_value = "31/12/2018 10:11"
+        query_param.should have(0).errors_on :default_value	
+
+        query_param.default_value = "31/12/2018-10:11"
+        query_param.should have(0).errors_on :default_value
+
+	query_param.default_value = "31/12/2018;10:11"
+        query_param.should have(0).errors_on :default_value
+
+	query_param.default_value = "31/12/2018 10:11:53"
+        query_param.should have(0).errors_on :default_value
+
+	query_param.default_value = "20191225202122"
+        query_param.should have(0).errors_on :default_value
+      end	      
+    end
+
+  end
+
 end

From 54a427bec4c357ca41aa9e7aec26f04ff0ae5254 Mon Sep 17 00:00:00 2001
From: Carlos Eduardo Cabral da Cunha <eduardosolrac286@gmail.com>
Date: Tue, 29 Oct 2019 11:42:32 -0200
Subject: [PATCH 5/9] #304 changing old rspec syntax should and should_not to
 'expect to' and 'expect not_to'

---
 .../scholarships_controller_spec.rb           |  14 +-
 spec/models/accomplishment_spec.rb            |  16 +-
 spec/models/advisement_authorization_spec.rb  |  12 +-
 spec/models/advisement_spec.rb                |  32 +--
 spec/models/allocation_spec.rb                |  42 ++--
 spec/models/city_spec.rb                      |  10 +-
 spec/models/class_enrollment_spec.rb          |  60 ++---
 spec/models/country_spec.rb                   |   8 +-
 spec/models/course_class_spec.rb              |  26 +-
 spec/models/course_research_area_spec.rb      |  12 +-
 spec/models/course_spec.rb                    |  32 +--
 spec/models/course_type_spec.rb               |   8 +-
 spec/models/custom_variable_spec.rb           |  36 +--
 spec/models/deferral_spec.rb                  |  24 +-
 spec/models/deferral_type_spec.rb             |  18 +-
 spec/models/dismissal_reason_spec.rb          |  14 +-
 spec/models/dismissal_spec.rb                 |  26 +-
 spec/models/enrollment_hold_spec.rb           |  28 +--
 spec/models/enrollment_spec.rb                |  74 +++---
 spec/models/enrollment_status_spec.rb         |   8 +-
 spec/models/institution_spec.rb               |   8 +-
 spec/models/level_spec.rb                     |  12 +-
 spec/models/major_spec.rb                     |  16 +-
 spec/models/notification_spec.rb              |  58 ++---
 spec/models/phase_completion_spec.rb          |  12 +-
 spec/models/phase_duration_spec.rb            |  34 +--
 spec/models/phase_spec.rb                     |  12 +-
 spec/models/professor_research_area_spec.rb   |  14 +-
 spec/models/professor_spec.rb                 |  44 ++--
 spec/models/query_param_spec.rb               | 232 +++++++++---------
 spec/models/query_spec.rb                     |   4 +-
 spec/models/research_area_spec.rb             |  14 +-
 spec/models/scholarship_duration_spec.rb      |  52 ++--
 spec/models/scholarship_spec.rb               |  24 +-
 spec/models/scholarship_suspension_spec.rb    |  34 +--
 spec/models/scholarship_type_spec.rb          |   8 +-
 spec/models/sponsor_spec.rb                   |   8 +-
 spec/models/state_spec.rb                     |  18 +-
 spec/models/string_time_delta_spec.rb         |  28 +--
 spec/models/student_major_spec.rb             |  12 +-
 spec/models/student_spec.rb                   |  32 +--
 ...is_defense_committee_participation_spec.rb |  14 +-
 spec/models/user_spec.rb                      |  18 +-
 spec/models/year_semester_spec.rb             |  74 +++---
 44 files changed, 641 insertions(+), 641 deletions(-)

diff --git a/spec/controllers/scholarships_controller_spec.rb b/spec/controllers/scholarships_controller_spec.rb
index 694e8d71..6a0f0f75 100644
--- a/spec/controllers/scholarships_controller_spec.rb
+++ b/spec/controllers/scholarships_controller_spec.rb
@@ -13,40 +13,40 @@
       it "should include the scholarship if there is no allocation, end_date is nil and search date is after start_date" do
         scholarship = FactoryGirl.create(:scholarship, :start_date => Date.parse("2012/01/01"), :end_date => nil)
         condition = ScholarshipsController.condition_for_available_column(:available, {:use => 'yes', :month => "2", :year => "2013"}, "")
-        Scholarship.where(condition.map(&:to_sql).join(' OR ')).should include(scholarship)
+        expect(Scholarship.where(condition.map(&:to_sql).join(' OR '))).to include(scholarship)
       end
 
       it "should not include the scholarship if there is no allocation, end_date is nil and search date is before start_date" do
         scholarship = FactoryGirl.create(:scholarship, :start_date => Date.parse("2012/01/01"), :end_date => nil)
         condition = ScholarshipsController.condition_for_available_column(:available, {:use => 'yes', :month => "2", :year => "2011"}, "")
-        Scholarship.where(condition.map(&:to_sql).join(' OR ')).should_not include(scholarship)
+        expect(Scholarship.where(condition.map(&:to_sql).join(' OR '))).not_to include(scholarship)
       end
 
       it "should not include the scholarship if there is no allocation, search date is after end_date" do
         scholarship = FactoryGirl.create(:scholarship, :start_date => Date.parse("2012/01/01"), :end_date => Date.parse("2015/01/31"))
         condition = ScholarshipsController.condition_for_available_column(:available, {:use => 'yes', :month => "2", :year => "2016"}, "")
-        Scholarship.where(condition.map(&:to_sql).join(' OR ')).should_not include(scholarship)
+        expect(Scholarship.where(condition.map(&:to_sql).join(' OR '))).not_to include(scholarship)
       end
 
       it "should include the scholarship if there is allocation, but it ends before the search date" do
         scholarship = FactoryGirl.create(:scholarship, :start_date => Date.parse("2012/01/01"), :end_date => Date.parse("2015/01/31"))
         FactoryGirl.create(:scholarship_duration, :scholarship_id => scholarship.id, :start_date => Date.parse("2012/01/01"), :end_date => Date.parse("2013/01/31"), :cancel_date => nil)
         condition = ScholarshipsController.condition_for_available_column(:available, {:use => 'yes', :month => "2", :year => "2013"}, "")
-        Scholarship.where(condition.map(&:to_sql).join(' OR ')).should include(scholarship)
+        expect(Scholarship.where(condition.map(&:to_sql).join(' OR '))).to include(scholarship)
       end
 
       it "should not include the scholarship if there is allocation, and it ends after the search date" do
         scholarship = FactoryGirl.create(:scholarship, :start_date => Date.parse("2012/01/01"), :end_date => Date.parse("2015/01/31"))
         FactoryGirl.create(:scholarship_duration, :scholarship_id => scholarship.id, :start_date => Date.parse("2012/01/01"), :end_date => Date.parse("2013/03/31"), :cancel_date => nil)
         condition = ScholarshipsController.condition_for_available_column(:available, {:use => 'yes', :month => "2", :year => "2013"}, "")
-        Scholarship.where(condition.map(&:to_sql).join(' OR ')).should_not include(scholarship)
+        expect(Scholarship.where(condition.map(&:to_sql).join(' OR '))).not_to include(scholarship)
       end
 
       it "should include the scholarship if there is allocation, and it ends after the search date, but was cancelled before" do
         scholarship = FactoryGirl.create(:scholarship, :start_date => Date.parse("2012/01/01"), :end_date => Date.parse("2015/01/31"))
         FactoryGirl.create(:scholarship_duration, :scholarship_id => scholarship.id, :start_date => Date.parse("2012/01/01"), :end_date => Date.parse("2013/03/31"), :cancel_date => Date.parse("2013/01/31"))
         condition = ScholarshipsController.condition_for_available_column(:available, {:use => 'yes', :month => "2", :year => "2013"}, "")
-        Scholarship.where(condition.map(&:to_sql).join(' OR ')).should include(scholarship)
+        expect(Scholarship.where(condition.map(&:to_sql).join(' OR '))).to include(scholarship)
       end
 
 
@@ -55,4 +55,4 @@
   end
 
 
-end
\ No newline at end of file
+end
diff --git a/spec/models/accomplishment_spec.rb b/spec/models/accomplishment_spec.rb
index d0b01ce0..fc097a3c 100644
--- a/spec/models/accomplishment_spec.rb
+++ b/spec/models/accomplishment_spec.rb
@@ -11,7 +11,7 @@
       context "should be valid when" do
         it "enrollment is not null" do
           accomplishment.enrollment = Enrollment.new
-          accomplishment.should have(0).errors_on :enrollment
+          expect(accomplishment).to have(0).errors_on :enrollment
         end
 
         it "phase has the enrollment level" do
@@ -21,13 +21,13 @@
           accomplishment.phase = phase
           phase_duration = FactoryGirl.create(:phase_duration, :phase => phase, :level => level)
           
-          accomplishment.should have(0).errors_on :enrollment
+          expect(accomplishment).to have(0).errors_on :enrollment
         end
       end
       context "should have error blank when" do
         it "enrollment is null" do
           accomplishment.enrollment = nil
-          accomplishment.should have_error(:blank).on :enrollment
+          expect(accomplishment).to have_error(:blank).on :enrollment
         end
       end
       context "should have error enrollment_level when" do
@@ -37,7 +37,7 @@
           accomplishment.enrollment = FactoryGirl.create(:enrollment, :level => level)
           accomplishment.phase = phase
           
-          accomplishment.should have_error(:enrollment_level).on :enrollment
+          expect(accomplishment).to have_error(:enrollment_level).on :enrollment
         end
       end
     end
@@ -45,13 +45,13 @@
       context "should be valid when" do
         it "phase is not null" do
           accomplishment.phase = Phase.new
-          accomplishment.should have(0).errors_on :phase
+          expect(accomplishment).to have(0).errors_on :phase
         end
       end
       context "should have error blank when" do
         it "phase is null" do
           accomplishment.phase = nil
-          accomplishment.should have_error(:blank).on :phase
+          expect(accomplishment).to have_error(:blank).on :phase
         end
       end
     end
@@ -61,8 +61,8 @@
       it "should return the expected string" do
         phase_name = "Accomplished Phase"
         accomplishment.phase = Phase.new(:name => phase_name)
-        accomplishment.to_label.should eql(phase_name)
+        expect(accomplishment.to_label).to eql(phase_name)
       end
     end
   end
-end
\ No newline at end of file
+end
diff --git a/spec/models/advisement_authorization_spec.rb b/spec/models/advisement_authorization_spec.rb
index c62ce990..4748e77c 100644
--- a/spec/models/advisement_authorization_spec.rb
+++ b/spec/models/advisement_authorization_spec.rb
@@ -11,13 +11,13 @@
       context "should be valid when" do
         it "professor is not null" do
           advisement_authorization.professor = Professor.new
-          advisement_authorization.should have(0).errors_on :professor
+          expect(advisement_authorization).to have(0).errors_on :professor
         end
       end
       context "should have error blank when" do
         it "professor is null" do
           advisement_authorization.professor = nil
-          advisement_authorization.should have_error(:blank).on :professor
+          expect(advisement_authorization).to have_error(:blank).on :professor
         end
       end
     end
@@ -25,13 +25,13 @@
       context "should be valid when" do
         it "level is not null" do
           advisement_authorization.level = Level.new
-          advisement_authorization.should have(0).errors_on :level
+          expect(advisement_authorization).to have(0).errors_on :level
         end
       end
       context "should have error blank when" do
         it "level is null" do
           advisement_authorization.level = nil
-          advisement_authorization.should have_error(:blank).on :level
+          expect(advisement_authorization).to have_error(:blank).on :level
         end
       end
     end
@@ -41,8 +41,8 @@
       it "should return the expected string" do
         level_name = "AuthorizedLevel"
         advisement_authorization.level = Level.new(:name => level_name)
-        advisement_authorization.to_label.should eql(level_name)
+        expect(advisement_authorization.to_label).to eql(level_name)
       end
     end
   end
-end
\ No newline at end of file
+end
diff --git a/spec/models/advisement_spec.rb b/spec/models/advisement_spec.rb
index 8299331f..663638da 100644
--- a/spec/models/advisement_spec.rb
+++ b/spec/models/advisement_spec.rb
@@ -11,13 +11,13 @@
       context "should be valid when" do
         it "enrollment is not null" do
           advisement.enrollment = Enrollment.new
-          advisement.should have(0).errors_on :enrollment
+          expect(advisement).to have(0).errors_on :enrollment
         end
       end
       context "should have error blank when" do
         it "enrollment is null" do
           advisement.enrollment = nil
-          advisement.should have_error(:blank).on :enrollment
+          expect(advisement).to have_error(:blank).on :enrollment
         end
       end
     end
@@ -25,13 +25,13 @@
       context "should be valid when" do
         it "professor is not null" do
           advisement.professor = Professor.new
-          advisement.should have(0).errors_on :professor
+          expect(advisement).to have(0).errors_on :professor
         end
       end
       context "should have error blank when" do
         it "professor is null" do
           advisement.professor = nil
-          advisement.should have_error(:blank).on :professor
+          expect(advisement).to have_error(:blank).on :professor
         end
       end
     end
@@ -40,12 +40,12 @@
         it "have other advisor" do
           allow(advisement).to receive(:enrollment_has_advisors).and_return(true)
           advisement.main_advisor = nil
-          advisement.should have(0).errors_on :main_advisor
+          expect(advisement).to have(0).errors_on :main_advisor
         end
         it "does not have other advisor and main_advisor is true" do
           allow(advisement).to receive(:enrollment_has_advisors).and_return(false)
           advisement.main_advisor = true
-          advisement.should have(0).errors_on :main_advisor
+          expect(advisement).to have(0).errors_on :main_advisor
         end
       end
     end
@@ -53,7 +53,7 @@
       context "should be valid when" do
         it "don't exists another advisement for the same enrollment" do
           advisement.professor = Professor.new
-          advisement.should have(0).errors_on :professor_id
+          expect(advisement).to have(0).errors_on :professor_id
         end
       end
       context "should have uniqueness error when" do
@@ -61,7 +61,7 @@
           advisement.professor = FactoryGirl.create(:professor)
           advisement.enrollment = FactoryGirl.create(:enrollment)
           FactoryGirl.create(:advisement, :professor => advisement.professor, :enrollment => advisement.enrollment)
-          advisement.should have_error(:advisement_professor_uniqueness).on :professor_id
+          expect(advisement).to have_error(:advisement_professor_uniqueness).on :professor_id
         end
       end
     end
@@ -73,7 +73,7 @@
         professor_name = "professor"
         advisement.enrollment = Enrollment.new(:enrollment_number => enrollment_number)
         advisement.professor = Professor.new(:name => professor_name)
-        advisement.to_label.should eql("#{enrollment_number} - #{professor_name}")
+        expect(advisement.to_label).to eql("#{enrollment_number} - #{professor_name}")
       end
     end
     describe "co_advisor_list" do
@@ -85,21 +85,21 @@
         advisement = FactoryGirl.create(:advisement)
         FactoryGirl.create(:advisement, :professor => professor1, :enrollment => advisement.enrollment, :main_advisor => false)
         FactoryGirl.create(:advisement, :professor => professor2, :enrollment => advisement.enrollment, :main_advisor => false)
-        advisement.co_advisor_list.should eql("#{professor1_name} , #{professor2_name}")
+        expect(advisement.co_advisor_list).to eql("#{professor1_name} , #{professor2_name}")
       end
     end
     describe "active" do
       context "should return true when " do
         it "the enrollment does not have a dismissal" do
           advisement = FactoryGirl.create(:advisement)
-          advisement.active.should be_truthy
+          expect(advisement.active).to be_truthy
         end
       end
       context "should return false when " do
         it "the enrollment have a dismissal" do
           advisement = FactoryGirl.create(:advisement)
           FactoryGirl.create(:dismissal, :enrollment => advisement.enrollment)
-          advisement.active.should be_falsey
+          expect(advisement.active).to be_falsey
         end
       end
     end
@@ -108,13 +108,13 @@
         it "the enrollment have another advisement" do
           other_advisement = FactoryGirl.create(:advisement)
           FactoryGirl.create(:advisement, :enrollment => other_advisement.enrollment, :main_advisor => false)
-          other_advisement.co_advisor.should be_truthy
+          expect(other_advisement.co_advisor).to be_truthy
         end
       end
       context "should return false when " do
         it "the enrollment does not have another advisement" do
           advisement = FactoryGirl.create(:advisement)
-          advisement.co_advisor.should be_falsey
+          expect(advisement.co_advisor).to be_falsey
         end
       end
     end
@@ -122,13 +122,13 @@
       context "should return true when " do
         it "the enrollment have one advisement" do
           advisement = FactoryGirl.create(:advisement)
-          advisement.enrollment_has_advisors.should be_truthy
+          expect(advisement.enrollment_has_advisors).to be_truthy
         end
       end
       context "should return false when " do
         it "the enrollment does not have any advisements" do
           advisement.enrollment = FactoryGirl.create(:enrollment)
-          advisement.enrollment_has_advisors.should be_falsey
+          expect(advisement.enrollment_has_advisors).to be_falsey
         end
       end
     end
diff --git a/spec/models/allocation_spec.rb b/spec/models/allocation_spec.rb
index adcabc0b..07cb7b88 100644
--- a/spec/models/allocation_spec.rb
+++ b/spec/models/allocation_spec.rb
@@ -11,13 +11,13 @@
       context "should be valid when" do
         it "course_class is not null" do
           allocation.course_class = CourseClass.new
-          allocation.should have(0).errors_on :course_class
+          expect(allocation).to have(0).errors_on :course_class
         end
       end
       context "should have error blank when" do
         it "course_class is null" do
           allocation.course_class = nil
-          allocation.should have_error(:blank).on :course_class
+          expect(allocation).to have_error(:blank).on :course_class
         end
       end
     end
@@ -25,25 +25,25 @@
       context "should be valid when" do
         it "start_time is not null" do
           allocation.start_time = Time.now.hour
-          allocation.should have(0).errors_on :start_time
+          expect(allocation).to have(0).errors_on :start_time
         end
       end
       context "should have error blank when" do
         it "start_time is null" do
           allocation.start_time = nil
-          allocation.should have_error(:blank).on :start_time
+          expect(allocation).to have_error(:blank).on :start_time
         end
       end
       context "should have error less_than_or_equal_to when" do
         it "start_time is greater than 23" do
           allocation.start_time = 24
-          allocation.should have_error(:less_than_or_equal_to).with_parameter(:count, 23).on :start_time
+          expect(allocation).to have_error(:less_than_or_equal_to).with_parameter(:count, 23).on :start_time
         end
       end
       context "should have error greater_than_or_equal_to when" do
         it "start_time is less than 0" do
           allocation.start_time = -1
-          allocation.should have_error(:greater_than_or_equal_to).with_parameter(:count, 0).on :start_time
+          expect(allocation).to have_error(:greater_than_or_equal_to).with_parameter(:count, 0).on :start_time
         end
       end
     end
@@ -51,19 +51,19 @@
       context "should be valid when" do
         it "day is in the list" do
           allocation.day = I18n.translate("date.day_names").first
-          allocation.should have(0).errors_on :day
+          expect(allocation).to have(0).errors_on :day
         end
       end
       context "should have error blank when" do
         it "day is null" do
           allocation.day = nil
-          allocation.should have_error(:blank).on :day
+          expect(allocation).to have_error(:blank).on :day
         end
       end
       context "should have error inclusion when" do
         it "day is not in the list" do
           allocation.day = "ANYTHING NOT IN THE LIST"
-          allocation.should have_error(:inclusion).on :day
+          expect(allocation).to have_error(:inclusion).on :day
         end
       end
     end
@@ -71,25 +71,25 @@
       context "should be valid when" do
         it "end_time is not null" do
           allocation.end_time = Time.now.hour
-          allocation.should have(0).errors_on :end_time
+          expect(allocation).to have(0).errors_on :end_time
         end
       end
       context "should have error blank when" do
         it "end_time is null" do
           allocation.end_time = nil
-          allocation.should have_error(:blank).on :end_time
+          expect(allocation).to have_error(:blank).on :end_time
         end
       end
       context "should have error less_than_or_equal_to when" do
         it "end_time is greater than 23" do
           allocation.end_time = 24
-          allocation.should have_error(:less_than_or_equal_to).with_parameter(:count, 23).on :end_time
+          expect(allocation).to have_error(:less_than_or_equal_to).with_parameter(:count, 23).on :end_time
         end
       end
       context "should have error greater_than_or_equal_to when" do
         it "end_time is less than 0" do
           allocation.end_time = -1
-          allocation.should have_error(:greater_than_or_equal_to).with_parameter(:count, 0).on :end_time
+          expect(allocation).to have_error(:greater_than_or_equal_to).with_parameter(:count, 0).on :end_time
         end
       end
     end
@@ -98,14 +98,14 @@
         it "end_time is greater_than_start_time" do
           allocation.start_time = (Time.now.at_beginning_of_day + 10.hours).hour
           allocation.end_time = (Time.now.at_beginning_of_day + 12.hours).hour
-          allocation.should have(0).errors_on :start_time
+          expect(allocation).to have(0).errors_on :start_time
         end
       end
       context "should have error end_time_before_start_time when" do
         it "start_time is greater_than_end_time" do
           allocation.end_time = (Time.now.at_beginning_of_day + 10.hours).hour
           allocation.start_time = (Time.now.at_beginning_of_day + 12.hours).hour
-          allocation.should have_error(:end_time_before_start_time).on :start_time
+          expect(allocation).to have_error(:end_time_before_start_time).on :start_time
         end
       end
     end
@@ -117,8 +117,8 @@
           allocation.end_time = (Time.now.at_beginning_of_day + 9.hours).hour
           allocation.course_class = other_allocation.course_class
           allocation.day = other_allocation.day
-          allocation.should have(0).errors_on :start_time
-          allocation.should have(0).errors_on :end_time
+          expect(allocation).to have(0).errors_on :start_time
+          expect(allocation).to have(0).errors_on :end_time
         end
       end
       context "should have error scheduling_conflict when" do
@@ -128,8 +128,8 @@
           allocation.end_time = (Time.now.at_beginning_of_day + 13.hours).hour
           allocation.course_class = other_allocation.course_class
           allocation.day = other_allocation.day
-          allocation.should have_error(:scheduling_conflict).on :start_time
-          allocation.should have(0).errors_on :end_time
+          expect(allocation).to have_error(:scheduling_conflict).on :start_time
+          expect(allocation).to have(0).errors_on :end_time
         end
         it "end_time between another allocation's start_time and end_time" do
           other_allocation = FactoryGirl.create(:allocation, :start_time => (Time.now.at_beginning_of_day + 10.hours).hour, :end_time => (Time.now.at_beginning_of_day + 12.hours).hour)
@@ -137,8 +137,8 @@
           allocation.end_time = (Time.now.at_beginning_of_day + 11.hours).hour
           allocation.course_class = other_allocation.course_class
           allocation.day = other_allocation.day
-          allocation.should have_error(:scheduling_conflict).on :end_time
-          allocation.should have(0).errors_on :start_time
+          expect(allocation).to have_error(:scheduling_conflict).on :end_time
+          expect(allocation).to have(0).errors_on :start_time
         end
       end
     end
diff --git a/spec/models/city_spec.rb b/spec/models/city_spec.rb
index 5cdce352..24e7a271 100644
--- a/spec/models/city_spec.rb
+++ b/spec/models/city_spec.rb
@@ -16,13 +16,13 @@
       context "should be valid when" do
         it "state is not null" do
           city.state = State.new
-          city.should have(0).errors_on :state
+          expect(city).to have(0).errors_on :state
         end
       end
       context "should have error blank when" do
         it "state is null" do
           city.state = nil
-          city.should have_error(:blank).on :state
+          expect(city).to have_error(:blank).on :state
         end
       end
     end
@@ -30,15 +30,15 @@
       context "should be valid when" do
         it "name is not null" do
           city.name = "City name"
-          city.should have(0).errors_on :name
+          expect(city).to have(0).errors_on :name
         end
       end
       context "should have error blank when" do
         it "name is null" do
           city.name = nil
-          city.should have_error(:blank).on :name
+          expect(city).to have_error(:blank).on :name
         end
       end
     end
   end
-end
\ No newline at end of file
+end
diff --git a/spec/models/class_enrollment_spec.rb b/spec/models/class_enrollment_spec.rb
index 4bb333cc..7a749777 100644
--- a/spec/models/class_enrollment_spec.rb
+++ b/spec/models/class_enrollment_spec.rb
@@ -11,13 +11,13 @@
       context "should be valid when" do
         it "enrollment is not null" do
           class_enrollment.enrollment = Enrollment.new
-          class_enrollment.should have(0).errors_on :enrollment
+          expect(class_enrollment).to have(0).errors_on :enrollment 
         end
       end
       context "should have error blank when" do
         it "enrollment is null" do
           class_enrollment.enrollment = nil
-          class_enrollment.should have_error(:blank).on :enrollment
+          expect(class_enrollment).to have_error(:blank).on :enrollment
         end
       end
     end
@@ -25,13 +25,13 @@
       context "should be valid when" do
         it "course_class is not null and is unique for the enrollment" do
           class_enrollment.course_class = CourseClass.new
-          class_enrollment.should have(0).errors_on :course_class
+          expect(class_enrollment).to have(0).errors_on :course_class
         end
       end
       context "should have error blank when" do
         it "course_class is null" do
           class_enrollment.course_class = nil
-          class_enrollment.should have_error(:blank).on :course_class
+          expect(class_enrollment).to have_error(:blank).on :course_class
         end
       end
       context "should have error taken when" do
@@ -42,7 +42,7 @@
 
           class_enrollment.course_class = course_class
           class_enrollment.enrollment = enrollment
-          class_enrollment.should have_error(:taken).on :course_class_id
+          expect(class_enrollment).to have_error(:taken).on :course_class_id
         end
       end
     end
@@ -50,19 +50,19 @@
       context "should be valid when" do
         it "situation is in the list" do
           class_enrollment.situation = ClassEnrollment::SITUATIONS.first
-          class_enrollment.should have(0).errors_on :situation
+          expect(class_enrollment).to have(0).errors_on :situation
         end
       end
       context "should have error blank when" do
         it "situation is null" do
           class_enrollment.situation = nil
-          class_enrollment.should have_error(:blank).on :situation
+          expect(class_enrollment).to have_error(:blank).on :situation
         end
       end
       context "should have error inclusion when" do
         it "situation is not in the list" do
           class_enrollment.situation = "ANYTHING NOT IN THE LIST"
-          class_enrollment.should have_error(:inclusion).on :situation
+          expect(class_enrollment).to have_error(:inclusion).on :situation
         end
       end
     end
@@ -72,25 +72,25 @@
           class_enrollment.situation = I18n.translate("activerecord.attributes.class_enrollment.situations.registered")
           class_enrollment.grade = nil
           allow(class_enrollment).to receive(:course_has_grade).and_return(true)
-          class_enrollment.should have(0).errors_on :grade
+          expect(class_enrollment).to have(0).errors_on :grade
         end
         it "situation is aproved and grade is greater than 59" do
           class_enrollment.situation = I18n.translate("activerecord.attributes.class_enrollment.situations.aproved")
           class_enrollment.grade = 60
           allow(class_enrollment).to receive(:course_has_grade).and_return(true)
-          class_enrollment.should have(0).errors_on :grade
+          expect(class_enrollment).to have(0).errors_on :grade
         end
         it "situation is disapproved and grade is less than 60" do
           class_enrollment.situation = I18n.translate("activerecord.attributes.class_enrollment.situations.disapproved")
           class_enrollment.grade = 59
           allow(class_enrollment).to receive(:course_has_grade).and_return(true)
-          class_enrollment.should have(0).errors_on :grade
+          expect(class_enrollment).to have(0).errors_on :grade
         end
         it "course does not have grade and grade is null" do
           class_enrollment.situation = I18n.translate("activerecord.attributes.class_enrollment.situations.aproved")
           class_enrollment.grade = nil
           allow(class_enrollment).to receive(:course_has_grade).and_return(false)
-          class_enrollment.should have(0).errors_on :grade
+          expect(class_enrollment).to have(0).errors_on :grade
         end
       end
       context "should have error grade_for_situation_registered when" do
@@ -98,7 +98,7 @@
           class_enrollment.situation = I18n.translate("activerecord.attributes.class_enrollment.situations.registered")
           class_enrollment.grade = 100
           allow(class_enrollment).to receive(:course_has_grade).and_return(true)
-          class_enrollment.should have_error(:grade_for_situation_registered).on :grade
+          expect(class_enrollment).to have_error(:grade_for_situation_registered).on :grade
         end
       end
       context "should have error grade_for_situation_aproved when" do
@@ -106,13 +106,13 @@
           class_enrollment.situation = I18n.translate("activerecord.attributes.class_enrollment.situations.aproved")
           class_enrollment.grade = nil
           allow(class_enrollment).to receive(:course_has_grade).and_return(true)
-          class_enrollment.should have_error(:grade_for_situation_aproved).with_parameter(:minimum_grade_for_approval, (CustomVariable.minimum_grade_for_approval.to_f/10.0).to_s.tr('.',',')).on :grade
+          expect(class_enrollment).to have_error(:grade_for_situation_aproved).with_parameter(:minimum_grade_for_approval, (CustomVariable.minimum_grade_for_approval.to_f/10.0).to_s.tr('.',',')).on :grade
         end
         it "situation is aproved and grade is less than 60" do
           class_enrollment.situation = I18n.translate("activerecord.attributes.class_enrollment.situations.aproved")
           class_enrollment.grade = 59
           allow(class_enrollment).to receive(:course_has_grade).and_return(true)
-          class_enrollment.should have_error(:grade_for_situation_aproved).with_parameter(:minimum_grade_for_approval, (CustomVariable.minimum_grade_for_approval.to_f/10.0).to_s.tr('.',',')).on :grade
+          expect(class_enrollment).to have_error(:grade_for_situation_aproved).with_parameter(:minimum_grade_for_approval, (CustomVariable.minimum_grade_for_approval.to_f/10.0).to_s.tr('.',',')).on :grade
         end
       end
       context "should have error grade_for_situation_disapproved when" do
@@ -120,13 +120,13 @@
           class_enrollment.situation = I18n.translate("activerecord.attributes.class_enrollment.situations.disapproved")
           class_enrollment.grade = nil
           allow(class_enrollment).to receive(:course_has_grade).and_return(true)
-          class_enrollment.should have_error(:grade_for_situation_disapproved).with_parameter(:minimum_grade_for_approval, (CustomVariable.minimum_grade_for_approval.to_f/10.0).to_s.tr('.',',')).on :grade
+          expect(class_enrollment).to have_error(:grade_for_situation_disapproved).with_parameter(:minimum_grade_for_approval, (CustomVariable.minimum_grade_for_approval.to_f/10.0).to_s.tr('.',',')).on :grade
         end
         it "situation is disapproved and grade is greater than 59" do
           class_enrollment.situation = I18n.translate("activerecord.attributes.class_enrollment.situations.disapproved")
           class_enrollment.grade = 60
           allow(class_enrollment).to receive(:course_has_grade).and_return(true)
-          class_enrollment.should have_error(:grade_for_situation_disapproved).with_parameter(:minimum_grade_for_approval, (CustomVariable.minimum_grade_for_approval.to_f/10.0).to_s.tr('.',',')).on :grade
+          expect(class_enrollment).to have_error(:grade_for_situation_disapproved).with_parameter(:minimum_grade_for_approval, (CustomVariable.minimum_grade_for_approval.to_f/10.0).to_s.tr('.',',')).on :grade
         end
       end
       context "should have error grade_filled_for_course_without_score when" do
@@ -134,7 +134,7 @@
           class_enrollment.situation = I18n.translate("activerecord.attributes.class_enrollment.situations.disapproved")
           class_enrollment.grade = 59
           allow(class_enrollment).to receive(:course_has_grade).and_return(false)
-          class_enrollment.should have_error(:grade_filled_for_course_without_score).on :grade
+          expect(class_enrollment).to have_error(:grade_filled_for_course_without_score).on :grade
         end
       end
 
@@ -143,7 +143,7 @@
           class_enrollment.situation = I18n.translate("activerecord.attributes.class_enrollment.situations.aproved")
           class_enrollment.grade = 101
           allow(class_enrollment).to receive(:course_has_grade).and_return(true)
-          class_enrollment.should have_error(:grade_gt_100).on :grade
+          expect(class_enrollment).to have_error(:grade_gt_100).on :grade
         end
       end
 
@@ -152,7 +152,7 @@
           class_enrollment.situation = I18n.translate("activerecord.attributes.class_enrollment.situations.aproved")
           class_enrollment.grade = -1
           allow(class_enrollment).to receive(:course_has_grade).and_return(true)
-          class_enrollment.should have_error(:grade_lt_0).on :grade
+          expect(class_enrollment).to have_error(:grade_lt_0).on :grade
         end
       end
     end
@@ -161,36 +161,36 @@
         it "situation is registered and disapproved_by_absence is false" do
           class_enrollment.situation = I18n.translate("activerecord.attributes.class_enrollment.situations.registered")
           class_enrollment.disapproved_by_absence = false
-          class_enrollment.should have(0).errors_on :disapproved_by_absence
+          expect(class_enrollment).to have(0).errors_on :disapproved_by_absence
         end
         it "situation is aproved and disapproved_by_absence is false" do
           class_enrollment.situation = I18n.translate("activerecord.attributes.class_enrollment.situations.aproved")
           class_enrollment.disapproved_by_absence = false
-          class_enrollment.should have(0).errors_on :disapproved_by_absence
+          expect(class_enrollment).to have(0).errors_on :disapproved_by_absence
         end
         it "situation is disapproved and disapproved_by_absence is false" do
           class_enrollment.situation = I18n.translate("activerecord.attributes.class_enrollment.situations.disapproved")
           class_enrollment.disapproved_by_absence = false
-          class_enrollment.should have(0).errors_on :disapproved_by_absence
+          expect(class_enrollment).to have(0).errors_on :disapproved_by_absence
         end
         it "situation is disapproved and disapproved_by_absence is true" do
           class_enrollment.situation = I18n.translate("activerecord.attributes.class_enrollment.situations.disapproved")
           class_enrollment.disapproved_by_absence = true
-          class_enrollment.should have(0).errors_on :disapproved_by_absence
+          expect(class_enrollment).to have(0).errors_on :disapproved_by_absence
         end
       end
       context "should have error disapproved_by_absence_for_situation_registered when" do
         it "situation is registered and disapproved_by_absence is true" do
           class_enrollment.situation = I18n.translate("activerecord.attributes.class_enrollment.situations.registered")
           class_enrollment.disapproved_by_absence = true
-          class_enrollment.should have_error(:disapproved_by_absence_for_situation_registered).on :disapproved_by_absence
+          expect(class_enrollment).to have_error(:disapproved_by_absence_for_situation_registered).on :disapproved_by_absence
         end
       end
       context "should have error disapproved_by_absence_for_situation_aproved when" do
         it "situation is aproved and grade is null" do
           class_enrollment.situation = I18n.translate("activerecord.attributes.class_enrollment.situations.aproved")
           class_enrollment.disapproved_by_absence = true
-          class_enrollment.should have_error(:disapproved_by_absence_for_situation_aproved).on :disapproved_by_absence
+          expect(class_enrollment).to have_error(:disapproved_by_absence_for_situation_aproved).on :disapproved_by_absence
         end
       end
     end
@@ -200,11 +200,11 @@
       context "parameter is a String number" do
         it "converts comma separated numbers" do
           class_enrollment.grade = "4,5"
-          class_enrollment.grade.should eq 45
+          expect(class_enrollment.grade).to eq 45
         end
         it "converts dot separated numbers" do
           class_enrollment.grade = "6.3"
-          class_enrollment.grade.should eq 63
+          expect(class_enrollment.grade).to eq 63
         end
       end
     end
@@ -212,13 +212,13 @@
       context "should return true" do
         it "when grade is not null" do
           class_enrollment.grade = 10
-          class_enrollment.grade_filled?.should be_truthy
+          expect(class_enrollment.grade_filled?).to be_truthy
         end
       end
       context "should return false" do
         it "when grade is null" do
           class_enrollment.grade = nil
-          class_enrollment.grade_filled?.should be_falsey
+          expect(class_enrollment.grade_filled?).to be_falsey
         end
       end
     end
diff --git a/spec/models/country_spec.rb b/spec/models/country_spec.rb
index d2add541..5b4cbc41 100644
--- a/spec/models/country_spec.rb
+++ b/spec/models/country_spec.rb
@@ -14,13 +14,13 @@
       context "should be valid when" do
         it "name is not null and is not taken" do
           country.name = "Country name"
-          country.should have(0).errors_on :name
+          expect(country).to have(0).errors_on :name
         end
       end
       context "should have error blank when" do
         it "name is null" do
           country.name = nil
-          country.should have_error(:blank).on :name
+          expect(country).to have_error(:blank).on :name
         end
       end
       context "should have error taken when" do
@@ -28,9 +28,9 @@
           name = "Country name"
           FactoryGirl.create(:country, :name => name)
           country.name = name
-          country.should have_error(:taken).on :name
+          expect(country).to have_error(:taken).on :name
         end
       end
     end
   end
-end
\ No newline at end of file
+end
diff --git a/spec/models/course_class_spec.rb b/spec/models/course_class_spec.rb
index 7782e08f..6bc9982a 100644
--- a/spec/models/course_class_spec.rb
+++ b/spec/models/course_class_spec.rb
@@ -15,13 +15,13 @@
       context "should be valid when" do
         it "course is not null" do
           course_class.course = Course.new
-          course_class.should have(0).errors_on :course
+          expect(course_class).to have(0).errors_on :course
         end
       end
       context "should have error blank when" do
         it "course is null" do
           course_class.course = nil
-          course_class.should have_error(:blank).on :course
+          expect(course_class).to have_error(:blank).on :course
         end
       end
     end
@@ -29,13 +29,13 @@
       context "should be valid when" do
         it "professor is not null" do
           course_class.professor = Professor.new
-          course_class.should have(0).errors_on :professor
+          expect(course_class).to have(0).errors_on :professor
         end
       end
       context "should have error blank when" do
         it "professor is null" do
           course_class.professor = nil
-          course_class.should have_error(:blank).on :professor
+          expect(course_class).to have_error(:blank).on :professor
         end
       end
     end
@@ -43,13 +43,13 @@
       context "should be valid when" do
         it "year is not null" do
           course_class.year = 2013
-          course_class.should have(0).errors_on :year
+          expect(course_class).to have(0).errors_on :year
         end
       end
       context "should have error blank when" do
         it "year is null" do
           course_class.year = nil
-          course_class.should have_error(:blank).on :year
+          expect(course_class).to have_error(:blank).on :year
         end
       end
     end
@@ -57,19 +57,19 @@
       context "should be valid when" do
         it "semester is not null" do
           course_class.semester = CourseClass::SEMESTERS.first
-          course_class.should have(0).errors_on :semester
+          expect(course_class).to have(0).errors_on :semester
         end
       end
       context "should have error blank when" do
         it "semester is null" do
           course_class.semester = nil
-          course_class.should have_error(:blank).on :semester
+          expect(course_class).to have_error(:blank).on :semester
         end
       end
       context "should have error inclusion when" do
         it "semester is not in the list" do
           course_class.semester = 3
-          course_class.should have_error(:inclusion).on :semester
+          expect(course_class).to have_error(:inclusion).on :semester
         end
       end
     end
@@ -85,7 +85,7 @@
           course_class.semester = CourseClass::SEMESTERS.first
           course_class.course = Course.new(:name => other_name)
           course_class.course.course_type = FactoryGirl.create(:course_type, :show_class_name => true)
-          course_class.to_label.should eql("#{other_name} (#{name}) - #{course_class.year}/#{course_class.semester}")
+          expect(course_class.to_label).to eql("#{other_name} (#{name}) - #{course_class.year}/#{course_class.semester}")
         end
         it "name is not null and course type doesnt show class name" do
           name = "name"
@@ -95,7 +95,7 @@
           course_class.semester = CourseClass::SEMESTERS.first
           course_class.course = Course.new(:name => other_name)
           course_class.course.course_type = FactoryGirl.create(:course_type, :show_class_name => false)
-          course_class.to_label.should eql("#{other_name} - #{course_class.year}/#{course_class.semester}")
+          expect(course_class.to_label).to eql("#{other_name} - #{course_class.year}/#{course_class.semester}")
         end
         it "name is null" do
           course_name = "course_name"
@@ -103,9 +103,9 @@
           course_class.semester = CourseClass::SEMESTERS.first
           course_class.course = Course.new(:name => course_name)
           course_class.course.course_type = FactoryGirl.create(:course_type, :show_class_name => true)
-          course_class.to_label.should eql("#{course_name} - #{course_class.year}/#{course_class.semester}")
+          expect(course_class.to_label).to eql("#{course_name} - #{course_class.year}/#{course_class.semester}")
         end
       end
     end
   end
-end
\ No newline at end of file
+end
diff --git a/spec/models/course_research_area_spec.rb b/spec/models/course_research_area_spec.rb
index 45a08218..b1a2c0ff 100644
--- a/spec/models/course_research_area_spec.rb
+++ b/spec/models/course_research_area_spec.rb
@@ -11,13 +11,13 @@
       context "should be valid when" do
         it "course is not null" do
           course_research_area.course = Course.new
-          course_research_area.should have(0).errors_on :course
+          expect(course_research_area).to have(0).errors_on :course
         end
       end
       context "should have error blank when" do
         it "course is null" do
           course_research_area.course = nil
-          course_research_area.should have_error(:blank).on :course
+          expect(course_research_area).to have_error(:blank).on :course
         end
       end
     end
@@ -25,13 +25,13 @@
       context "should be valid when" do
         it "research_area is not null" do
           course_research_area.research_area = ResearchArea.new
-          course_research_area.should have(0).errors_on :research_area
+          expect(course_research_area).to have(0).errors_on :research_area
         end
       end
       context "should have error blank when" do
         it "research_area is null" do
           course_research_area.research_area = nil
-          course_research_area.should have_error(:blank).on :research_area
+          expect(course_research_area).to have_error(:blank).on :research_area
         end
       end
     end
@@ -40,7 +40,7 @@
       context "should be valid when" do
         it "don't exists the course for the same research_area" do
           course_research_area.course = Course.new
-          course_research_area.should have(0).errors_on :course_id
+          expect(course_research_area).to have(0).errors_on :course_id
         end
       end
       context "should have uniqueness error when" do
@@ -48,7 +48,7 @@
           course_research_area.course = FactoryGirl.create(:course)
           course_research_area.research_area = FactoryGirl.create(:research_area)
           FactoryGirl.create(:course_research_area, :course => course_research_area.course, :research_area => course_research_area.research_area)
-          course_research_area.should have_error(:unique_pair).on :course_id
+          expect(course_research_area).to have_error(:unique_pair).on :course_id
         end
       end
     end
diff --git a/spec/models/course_spec.rb b/spec/models/course_spec.rb
index 9b1d6291..d83e90e8 100644
--- a/spec/models/course_spec.rb
+++ b/spec/models/course_spec.rb
@@ -14,13 +14,13 @@
       context "should be valid when" do
         it "name is not null and is not taken" do
           course.name = "Course"
-          course.should have(0).errors_on :name
+          expect(course).to have(0).errors_on :name
         end
       end
       context "should have error blank when" do
         it "name is null" do
           course.name = nil
-          course.should have_error(:blank).on :name
+          expect(course).to have_error(:blank).on :name
         end
       end
       context "should have error taken when" do
@@ -28,7 +28,7 @@
           name = "Course"
 	  FactoryGirl.create(:course, :name => name, :available => true)
 	  course.name = name
-	  course.should have_error(:check_unique_name_for_available_courses).on :name
+	  expect(course).to have_error(:check_unique_name_for_available_courses).on :name
 	end
       end
     end
@@ -36,13 +36,13 @@
       context "should be valid when" do
         it "course_type is not null" do
           course.course_type = CourseType.new
-          course.should have(0).errors_on :course_type
+          expect(course).to have(0).errors_on :course_type
         end
       end
       context "should have error blank when" do
         it "course_type is null" do
           course.course_type = nil
-          course.should have_error(:blank).on :course_type
+          expect(course).to have_error(:blank).on :course_type
         end
       end
     end
@@ -50,13 +50,13 @@
       context "should be valid when" do
         it "code is not null and is not taken" do
           course.code = "Code"
-          course.should have(0).errors_on :code
+          expect(course).to have(0).errors_on :code
         end
       end
       context "should have error blank when" do
         it "code is null" do
           course.code = nil
-          course.should have_error(:blank).on :code
+          expect(course).to have_error(:blank).on :code
         end
       end
       context "should have error taken when" do
@@ -64,7 +64,7 @@
           code = "Code"
           FactoryGirl.create(:course, :code => code)
           course.code = code
-          course.should have_error(:taken).on :code
+          expect(course).to have_error(:taken).on :code
         end
       end
     end
@@ -72,13 +72,13 @@
       context "should be valid when" do
         it "credits is not null" do
           course.credits = 10
-          course.should have(0).errors_on :credits
+          expect(course).to have(0).errors_on :credits
         end
       end
       context "should have error blank when" do
         it "credits is null" do
           course.credits = nil
-          course.should have_error(:blank).on :credits
+          expect(course).to have_error(:blank).on :credits
         end
       end
     end
@@ -86,13 +86,13 @@
       context "should be valid when" do
         it "workload is not null" do
           course.workload = 10
-          course.should have(0).errors_on :workload
+          expect(course).to have(0).errors_on :workload
         end
       end
       context "should have error blank when" do
         it "workload is null" do
           course.workload = nil
-          course.should have_error(:blank).on :workload
+          expect(course).to have_error(:blank).on :workload
         end
       end
     end
@@ -101,24 +101,24 @@
     context "workload_value" do
       it "should return 0 when there is no workload" do
         course.workload = nil
-        course.workload_value.should == 0
+        expect(course.workload_value).to eq(0)
       end
 
       it "should return 5 when workload is 5" do
         course.workload = 5
-        course.workload_value.should == 5
+        expect(course.workload_value).to eq(5)
       end
     end
 
     context "workload_text" do
       it "should return N/A when there is no workload" do
         course.workload = nil
-        course.workload_text.should == I18n.translate('activerecord.attributes.course.empty_workload')
+        expect(course.workload_text).to eq(I18n.translate('activerecord.attributes.course.empty_workload'))
       end
 
       it "should return 5h when workload is 5" do
         course.workload = 5
-        course.workload_text.should == I18n.translate('activerecord.attributes.course.workload_time', :time => 5)
+        expect(course.workload_text).to eq(I18n.translate('activerecord.attributes.course.workload_time', :time => 5))
       end
     end
 
diff --git a/spec/models/course_type_spec.rb b/spec/models/course_type_spec.rb
index b4d2ddb9..b38cd27d 100644
--- a/spec/models/course_type_spec.rb
+++ b/spec/models/course_type_spec.rb
@@ -14,13 +14,13 @@
       context "should be valid when" do
         it "name is not null and is not taken" do
           course_type.name = "CourseType name"
-          course_type.should have(0).errors_on :name
+          expect(course_type).to have(0).errors_on :name
         end
       end
       context "should have error blank when" do
         it "name is null" do
           course_type.name = nil
-          course_type.should have_error(:blank).on :name
+          expect(course_type).to have_error(:blank).on :name
         end
       end
       context "should have error taken when" do
@@ -28,9 +28,9 @@
           name = "CourseType name"
           FactoryGirl.create(:course_type, :name => name)
           course_type.name = name
-          course_type.should have_error(:taken).on :name
+          expect(course_type).to have_error(:taken).on :name
         end
       end
     end
   end
-end
\ No newline at end of file
+end
diff --git a/spec/models/custom_variable_spec.rb b/spec/models/custom_variable_spec.rb
index e080deb7..786e958a 100644
--- a/spec/models/custom_variable_spec.rb
+++ b/spec/models/custom_variable_spec.rb
@@ -11,13 +11,13 @@
       context "should be valid when" do
         it "variable is not null" do
           custom_variable.variable = "variable"
-          custom_variable.should have(0).errors_on :variable
+          expect(custom_variable).to have(0).errors_on :variable
         end
       end
       context "should have error blank when" do
         it "variable is null" do
           custom_variable.variable = nil
-          custom_variable.should have_error(:blank).on :variable
+          expect(custom_variable).to have_error(:blank).on :variable
         end
       end
     end
@@ -29,7 +29,7 @@
         config = CustomVariable.find_by_variable(:single_advisor_points)
         config.delete unless config.nil?
 
-        CustomVariable.single_advisor_points.should == 1.0
+        expect(CustomVariable.single_advisor_points).to eq(1.0)
       end
 
       it "should return 2.0 when it is defined to 2.0" do
@@ -37,7 +37,7 @@
         config.delete unless config.nil?
         CustomVariable.create(:variable=>:single_advisor_points, :value=>"2.0")
 
-        CustomVariable.single_advisor_points.should == 2.0
+        expect(CustomVariable.single_advisor_points).to eq(2.0)
       end
     end
 
@@ -46,7 +46,7 @@
         config = CustomVariable.find_by_variable(:multiple_advisor_points)
         config.delete unless config.nil?
 
-        CustomVariable.multiple_advisor_points.should == 0.5
+        expect(CustomVariable.multiple_advisor_points).to eq(0.5)
       end
 
       it "should return 2.0 when it is defined to 2.0" do
@@ -54,7 +54,7 @@
         config.delete unless config.nil?
         CustomVariable.create(:variable=>:multiple_advisor_points, :value=>"2.0")
 
-        CustomVariable.multiple_advisor_points.should == 2.0
+        expect(CustomVariable.multiple_advisor_points).to eq(2.0)
       end
     end 
 
@@ -63,7 +63,7 @@
         config = CustomVariable.find_by_variable(:program_level)
         config.delete unless config.nil?
 
-        CustomVariable.program_level.should == nil
+        expect(CustomVariable.program_level).to eq(nil)
       end
 
       it "should return 5 when it is defined to 5" do
@@ -71,7 +71,7 @@
         config.delete unless config.nil?
         CustomVariable.create(:variable=>:program_level, :value=>"5")
 
-        CustomVariable.program_level.should == 5
+        expect(CustomVariable.program_level).to eq(5)
       end
     end 
 
@@ -83,7 +83,7 @@
         config = CustomVariable.find_by_variable(:identity_issuing_country)
         config.delete unless config.nil?
 
-        CustomVariable.identity_issuing_country.should == nil
+        expect(CustomVariable.identity_issuing_country).to eq(nil)
       end
 
       it "should return Brasil when there is no variable, but there is a country named Brasil" do
@@ -94,7 +94,7 @@
         config = CustomVariable.find_by_variable(:identity_issuing_country)
         config.delete unless config.nil?
         
-        CustomVariable.identity_issuing_country.should == country
+        expect(CustomVariable.identity_issuing_country).to eq(country)
       end
 
       it "should return England it is defined to England" do
@@ -111,7 +111,7 @@
 
         CustomVariable.create(:variable => :identity_issuing_country, :value=>"England")
 
-        CustomVariable.identity_issuing_country.should == england
+        expect(CustomVariable.identity_issuing_country).to eq(england)
       end
     end 
 
@@ -120,7 +120,7 @@
         config = CustomVariable.find_by_variable(:class_schedule_text)
         config.delete unless config.nil?
 
-        CustomVariable.class_schedule_text.should == ''
+        expect(CustomVariable.class_schedule_text).to eq('')
       end
 
       it "should return 'bla' when it is defined to bla" do
@@ -128,7 +128,7 @@
         config.delete unless config.nil?
         CustomVariable.create(:variable=>:class_schedule_text, :value=>"bla")
 
-        CustomVariable.class_schedule_text.should == 'bla'
+        expect(CustomVariable.class_schedule_text).to eq('bla')
       end
     end 
 
@@ -137,7 +137,7 @@
         config = CustomVariable.find_by_variable(:redirect_email)
         config.delete unless config.nil?
 
-        CustomVariable.redirect_email.should == nil
+        expect(CustomVariable.redirect_email).to eq(nil)
       end
 
       it "should return '' when the value is nil" do
@@ -145,7 +145,7 @@
         config.delete unless config.nil?
         CustomVariable.create(:variable=>:redirect_email, :value=>nil)
 
-        CustomVariable.redirect_email.should == ''
+        expect(CustomVariable.redirect_email).to eq('')
       end
 
       it "should return 'bla' when it is defined to bla" do
@@ -153,7 +153,7 @@
         config.delete unless config.nil?
         CustomVariable.create(:variable=>:redirect_email, :value=>"bla")
 
-        CustomVariable.redirect_email.should == 'bla'
+        expect(CustomVariable.redirect_email).to eq('bla')
       end
     end
 
@@ -162,7 +162,7 @@
         config = CustomVariable.find_by_variable(:notification_footer)
         config.delete unless config.nil?
 
-        CustomVariable.notification_footer.should == ''
+        expect(CustomVariable.notification_footer).to eq('')
       end
 
       it "should return 'bla' when it is defined to bla" do
@@ -170,7 +170,7 @@
         config.delete unless config.nil?
         CustomVariable.create(:variable=>:notification_footer, :value=>"bla")
 
-        CustomVariable.notification_footer.should == 'bla'
+        expect(CustomVariable.notification_footer).to eq('bla')
       end
     end 
   end
diff --git a/spec/models/deferral_spec.rb b/spec/models/deferral_spec.rb
index 510a0434..65c15d1a 100644
--- a/spec/models/deferral_spec.rb
+++ b/spec/models/deferral_spec.rb
@@ -11,7 +11,7 @@
       context "should be valid when" do
         it "enrollment is not null" do
           deferral.enrollment = Enrollment.new
-          deferral.should have(0).errors_on :enrollment
+          expect(deferral).to have(0).errors_on :enrollment
         end
 
         it "deferral_type phase has the enrollment level" do
@@ -21,13 +21,13 @@
           deferral.deferral_type = FactoryGirl.create(:deferral_type, :phase => phase)
           phase_duration = FactoryGirl.create(:phase_duration, :phase => phase, :level => level)
           
-          deferral.should have(0).errors_on :enrollment
+          expect(deferral).to have(0).errors_on :enrollment
         end
       end
       context "should have error blank when" do
         it "enrollment is null" do
           deferral.enrollment = nil
-          deferral.should have_error(:blank).on :enrollment
+          expect(deferral).to have_error(:blank).on :enrollment
         end
       end
 
@@ -38,7 +38,7 @@
           deferral.enrollment = FactoryGirl.create(:enrollment, :level => level)
           deferral.deferral_type = FactoryGirl.create(:deferral_type, :phase => phase)
           
-          deferral.should have_error(:enrollment_level).on :enrollment
+          expect(deferral).to have_error(:enrollment_level).on :enrollment
         end
       end
     end
@@ -46,13 +46,13 @@
       context "should be valid when" do
         it "deferral_type is not null" do
           deferral.deferral_type = DeferralType.new
-          deferral.should have(0).errors_on :deferral_type
+          expect(deferral).to have(0).errors_on :deferral_type
         end
       end
       context "should have error blank when" do
         it "deferral_type is null" do
           deferral.deferral_type = nil
-          deferral.should have_error(:blank).on :deferral_type
+          expect(deferral).to have_error(:blank).on :deferral_type
         end
       end
     end
@@ -60,13 +60,13 @@
       context "should be valid when" do
         it "approval_date is not null" do
           deferral.approval_date = Date.parse("2014/01/01")
-          deferral.should have(0).errors_on :approval_date
+          expect(deferral).to have(0).errors_on :approval_date
         end
       end
       context "should have error blank when" do
         it "approval_date is null" do
           deferral.approval_date = nil
-          deferral.should have_error(:blank).on :approval_date
+          expect(deferral).to have_error(:blank).on :approval_date
         end
       end
     end
@@ -76,7 +76,7 @@
       it "should return the expected string" do
         deferral_type_name = "DeferralType"
         deferral.deferral_type = DeferralType.new(:name => deferral_type_name)
-        deferral.to_label.should eql(deferral_type_name)
+        expect(deferral.to_label).to eql(deferral_type_name)
       end
     end
     describe "valid_until" do
@@ -88,7 +88,7 @@
         deferral_type = FactoryGirl.create(:deferral_type, :phase => phase, :duration_semesters => 2, :duration_days => 0)
         deferral = FactoryGirl.create(:deferral, :enrollment => enrollment, :deferral_type => deferral_type, :approval_date => Date.today)
 
-        deferral.valid_until.should eql(Date.new(2013, 7, 31).strftime('%d/%m/%Y'))
+        expect(deferral.valid_until).to eql(Date.new(2013, 7, 31).strftime('%d/%m/%Y'))
       end
 
       it "should return 28th of february 2023" do
@@ -100,7 +100,7 @@
         deferral = FactoryGirl.create(:deferral, :enrollment => enrollment, :deferral_type => deferral_type, :approval_date => Date.today)
 
 
-        deferral.valid_until.should eql(Date.new(2023, 2, 28).strftime('%d/%m/%Y'))
+        expect(deferral.valid_until).to eql(Date.new(2023, 2, 28).strftime('%d/%m/%Y'))
       end
 
       it "should return 7th of june 2014" do
@@ -111,7 +111,7 @@
         deferral_type = FactoryGirl.create(:deferral_type, :phase => phase, :duration_months => 3, :duration_days => 7)
         deferral = FactoryGirl.create(:deferral, :enrollment => enrollment, :deferral_type => deferral_type, :approval_date => Date.today)
 
-        deferral.valid_until.should eql(Date.new(2014, 6, 7).strftime('%d/%m/%Y'))
+        expect(deferral.valid_until).to eql(Date.new(2014, 6, 7).strftime('%d/%m/%Y'))
       end
     end
   end
diff --git a/spec/models/deferral_type_spec.rb b/spec/models/deferral_type_spec.rb
index 083f150b..905643c9 100644
--- a/spec/models/deferral_type_spec.rb
+++ b/spec/models/deferral_type_spec.rb
@@ -14,13 +14,13 @@
       context "should be valid when" do
         it "name is not null" do
           deferral_type.name = "DeferralType"
-          deferral_type.should have(0).errors_on :name
+          expect(deferral_type).to have(0).errors_on :name
         end
       end
       context "should have error blank when" do
         it "name is null" do
           deferral_type.name = nil
-          deferral_type.should have_error(:blank).on :name
+          expect(deferral_type).to have_error(:blank).on :name
         end
       end
     end
@@ -28,13 +28,13 @@
       context "should be valid when" do
         it "phase is not null" do
           deferral_type.phase = Phase.new
-          deferral_type.should have(0).errors_on :phase
+          expect(deferral_type).to have(0).errors_on :phase
         end
       end
       context "should have error blank when" do
         it "phase is null" do
           deferral_type.phase = nil
-          deferral_type.should have_error(:blank).on :phase
+          expect(deferral_type).to have_error(:blank).on :phase
         end
       end
     end
@@ -44,7 +44,7 @@
           deferral_type.duration_months = 0
           deferral_type.duration_semesters = 0
           deferral_type.duration_days = 1
-          deferral_type.should have(0).errors_on :duration
+          expect(deferral_type).to have(0).errors_on :duration
         end
       end
       context "should have error blank_duration when" do
@@ -52,7 +52,7 @@
           deferral_type.duration_days = 0
           deferral_type.duration_months = 0
           deferral_type.duration_semesters = nil
-          deferral_type.should have_error(:blank_duration).on :duration
+          expect(deferral_type).to have_error(:blank_duration).on :duration
         end
       end
     end
@@ -66,7 +66,7 @@
         FactoryGirl.create(:deferral_type)
         
         deferral_types = DeferralType.where(DeferralType::find_all_for_enrollment(nil))
-        deferral_types.count.should == DeferralType.count
+        expect(deferral_types.count).to eq(DeferralType.count)
       end
 
       it "should return deferral_types that have the same level as the enrollment" do
@@ -90,8 +90,8 @@
         enrollment = FactoryGirl.create(:enrollment, :level => level1) 
         
         deferral_types = DeferralType.where(DeferralType::find_all_for_enrollment(enrollment))
-        deferral_types.count.should == 2
+        expect(deferral_types.count).to eq(2)
       end
     end
   end
-end
\ No newline at end of file
+end
diff --git a/spec/models/dismissal_reason_spec.rb b/spec/models/dismissal_reason_spec.rb
index eb68fbaf..e2f86e31 100644
--- a/spec/models/dismissal_reason_spec.rb
+++ b/spec/models/dismissal_reason_spec.rb
@@ -11,13 +11,13 @@
       context "should be valid when" do
         it "name is not null and is not taken" do
           dismissal_reason.name = "DismissalReason name"
-          dismissal_reason.should have(0).errors_on :name
+          expect(dismissal_reason).to have(0).errors_on :name
         end
       end
       context "should have error blank when" do
         it "name is null" do
           dismissal_reason.name = nil
-          dismissal_reason.should have_error(:blank).on :name
+          expect(dismissal_reason).to have_error(:blank).on :name
         end
       end
       context "should have error taken when" do
@@ -25,7 +25,7 @@
           name = "DismissalReason name"
           FactoryGirl.create(:dismissal_reason, :name => name)
           dismissal_reason.name = name
-          dismissal_reason.should have_error(:taken).on :name
+          expect(dismissal_reason).to have_error(:taken).on :name
         end
       end
     end
@@ -33,21 +33,21 @@
       context "should be valid when" do
         it "thesis_judgement is in the list" do
           dismissal_reason.thesis_judgement = DismissalReason::THESIS_JUDGEMENT.first
-          dismissal_reason.should have(0).errors_on :thesis_judgement
+          expect(dismissal_reason).to have(0).errors_on :thesis_judgement
         end
       end
       context "should have error blank when" do
         it "thesis_judgement is null" do
           dismissal_reason.thesis_judgement = nil
-          dismissal_reason.should have_error(:blank).on :thesis_judgement
+          expect(dismissal_reason).to have_error(:blank).on :thesis_judgement
         end
       end
       context "should have error inclusion when" do
         it "thesis_judgement is not in the list" do
           dismissal_reason.thesis_judgement = "ANYTHING NOT IN THE LIST"
-          dismissal_reason.should have_error(:inclusion).on :thesis_judgement
+          expect(dismissal_reason).to have_error(:inclusion).on :thesis_judgement
         end
       end
     end
   end
-end
\ No newline at end of file
+end
diff --git a/spec/models/dismissal_spec.rb b/spec/models/dismissal_spec.rb
index af6ec90e..df96b0bf 100644
--- a/spec/models/dismissal_spec.rb
+++ b/spec/models/dismissal_spec.rb
@@ -11,7 +11,7 @@
       context "should be valid when" do
         it "enrollment is not null" do
           dismissal.enrollment = Enrollment.new
-          dismissal.should have(0).errors_on :enrollment
+          expect(dismissal).to have(0).errors_on :enrollment
         end
 
         it "enrollment has an ended scholarship" do
@@ -19,13 +19,13 @@
           scholarship = FactoryGirl.create(:scholarship, :start_date => 3.months.ago.to_date, :end_date => 3.months.from_now.to_date)
           scholarship_duration = FactoryGirl.create(:scholarship_duration, :start_date => 1.month.ago.to_date, :end_date => 2.months.from_now.to_date, :cancel_date => nil, :scholarship => scholarship, :enrollment => dismissal.enrollment)
           dismissal.date = 5.months.from_now.to_date
-          dismissal.should have(0).errors_on :enrollment
+          expect(dismissal).to have(0).errors_on :enrollment
         end
       end
       context "should have error blank when" do
         it "enrollment is null" do
           dismissal.enrollment = nil
-          dismissal.should have_error(:blank).on :enrollment
+          expect(dismissal).to have_error(:blank).on :enrollment
         end
       end
 
@@ -35,8 +35,8 @@
           scholarship = FactoryGirl.create(:scholarship, :start_date => 3.months.ago.to_date, :end_date => 3.months.from_now.to_date)
           scholarship_duration = FactoryGirl.create(:scholarship_duration, :start_date => 1.month.ago.to_date, :end_date => 2.months.from_now.to_date, :cancel_date => nil, :scholarship => scholarship, :enrollment => dismissal.enrollment)
           dismissal.date = 1.month.from_now.to_date
-          dismissal.should_not be_valid
-          dismissal.errors[:enrollment].should include I18n.translate("activerecord.errors.models.dismissal.enrollment_has_scholarship")
+          expect(dismissal).not_to be_valid
+          expect(dismissal.errors[:enrollment]).to include I18n.translate("activerecord.errors.models.dismissal.enrollment_has_scholarship")
         end
       end
     end
@@ -44,13 +44,13 @@
       context "should be valid when" do
         it "dismissal_reason is not null" do
           dismissal.dismissal_reason = DismissalReason.new
-          dismissal.should have(0).errors_on :dismissal_reason
+          expect(dismissal).to have(0).errors_on :dismissal_reason
         end
       end
       context "should have error blank when" do
         it "dismissal_reason is null" do
           dismissal.dismissal_reason = nil
-          dismissal.should have_error(:blank).on :dismissal_reason
+          expect(dismissal).to have_error(:blank).on :dismissal_reason
         end
       end
     end
@@ -59,25 +59,25 @@
         it "date is not null" do
           dismissal.enrollment = FactoryGirl.create(:enrollment, :admission_date => 3.days.ago.to_date)
           dismissal.date = Date.today
-          dismissal.should have(0).errors_on :date
+          expect(dismissal).to have(0).errors_on :date
         end
         it "is after enrollment admission date" do
           enrollment = FactoryGirl.create(:enrollment, :admission_date => 3.days.ago.to_date)
           dismissal.enrollment = enrollment
           dismissal.date = Date.today
-          dismissal.should have(0).errors_on :date
+          expect(dismissal).to have(0).errors_on :date
         end
       end
       context "should have error when" do
         it "date is null" do
           dismissal.date = nil
-          dismissal.should have_error(:blank).on :date
+          expect(dismissal).to have_error(:blank).on :date
         end
         it "is before enrollment admission date" do
           enrollment = FactoryGirl.create(:enrollment, :admission_date => 3.days.ago.to_date)
           dismissal.enrollment = enrollment
           dismissal.date = 4.days.ago.to_date
-          dismissal.should have_error(:date_before_enrollment_admission_date).on :date
+          expect(dismissal).to have_error(:date_before_enrollment_admission_date).on :date
         end
       end
     end
@@ -87,8 +87,8 @@
       it "should return the expected string" do
         dismissal_date = "#{Date.today}"
         dismissal.date = dismissal_date
-        dismissal.to_label.should eql(dismissal_date)
+        expect(dismissal.to_label).to eql(dismissal_date)
       end
     end
   end
-end
\ No newline at end of file
+end
diff --git a/spec/models/enrollment_hold_spec.rb b/spec/models/enrollment_hold_spec.rb
index c7eadbcd..b9993c0a 100644
--- a/spec/models/enrollment_hold_spec.rb
+++ b/spec/models/enrollment_hold_spec.rb
@@ -11,13 +11,13 @@
       context "should be valid when" do
         it "enrollment is not null" do
           enrollment_hold.enrollment = Enrollment.new
-          enrollment_hold.should have(0).errors_on :enrollment
+          expect(enrollment_hold).to have(0).errors_on :enrollment
         end
       end
       context "should have error blank when" do
         it "enrollment is null" do
           enrollment_hold.enrollment = nil
-          enrollment_hold.should have_error(:blank).on :enrollment
+          expect(enrollment_hold).to have_error(:blank).on :enrollment
         end
       end
     end
@@ -25,18 +25,18 @@
       context "should be valid when" do
         it "it is greater than 0" do
           enrollment_hold.number_of_semesters = 1
-          enrollment_hold.should have(0).errors_on :number_of_semesters
+          expect(enrollment_hold).to have(0).errors_on :number_of_semesters
         end
       end
       context "should have error when" do
         it "it is lower than or equal to 0" do
           enrollment_hold.number_of_semesters = 0
-          enrollment_hold.should have_error(:greater_than_or_equal_to).with_parameter(:count, 1).on :number_of_semesters
+          expect(enrollment_hold).to have_error(:greater_than_or_equal_to).with_parameter(:count, 1).on :number_of_semesters
         end
 
         it "it is blank" do
           enrollment_hold.number_of_semesters = nil
-          enrollment_hold.should have_error(:blank).on :number_of_semesters
+          expect(enrollment_hold).to have_error(:blank).on :number_of_semesters
         end
       end
     end
@@ -44,13 +44,13 @@
       context "should be valid when" do
         it "it is not null" do
           enrollment_hold.year = 2014
-          enrollment_hold.should have(0).errors_on :year
+          expect(enrollment_hold).to have(0).errors_on :year
         end
       end
       context "should have error when" do
         it "it is blank" do
           enrollment_hold.year = nil
-          enrollment_hold.should have_error(:blank).on :year
+          expect(enrollment_hold).to have_error(:blank).on :year
         end
       end
     end
@@ -58,21 +58,21 @@
       context "should be valid when" do
         it "it is 1" do
           enrollment_hold.semester = 1
-          enrollment_hold.should have(0).errors_on :semester
+          expect(enrollment_hold).to have(0).errors_on :semester
         end
         it "it is 2" do
           enrollment_hold.semester = 2
-          enrollment_hold.should have(0).errors_on :semester
+          expect(enrollment_hold).to have(0).errors_on :semester
         end
       end
       context "should have error when" do
         it "it is blank" do
           enrollment_hold.semester = nil
-          enrollment_hold.should have_error(:blank).on :semester
+          expect(enrollment_hold).to have_error(:blank).on :semester
         end
         it "it isnt 1 or 2" do
           enrollment_hold.semester = nil
-          enrollment_hold.should have_error(:inclusion).on :semester
+          expect(enrollment_hold).to have_error(:inclusion).on :semester
         end
       end
     end
@@ -84,7 +84,7 @@
           enrollment_hold.enrollment = e
           enrollment_hold.year = e.admission_date.year - 1
           enrollment_hold.semester = 1
-          enrollment_hold.should have_error(:before_admission_date).on :base
+          expect(enrollment_hold).to have_error(:before_admission_date).on :base
         end
 
         it "year-semester is before enrollment admission date" do
@@ -94,7 +94,7 @@
           enrollment_hold.year = e.admission_date.year
           enrollment_hold.semester = 1
           enrollment_hold.number_of_semesters = 20
-          enrollment_hold.should have_error(:after_dismissal_date).on :base
+          expect(enrollment_hold).to have_error(:after_dismissal_date).on :base
         end
       end
     end
@@ -107,7 +107,7 @@
         enrollment_hold.semester = 1
         enrollment_hold.number_of_semesters = 2
 
-        enrollment_hold.to_label.should == "2014.1 - 2 semestres"
+        expect(enrollment_hold.to_label).to eq("2014.1 - 2 semestres")
       end
     end
   end
diff --git a/spec/models/enrollment_spec.rb b/spec/models/enrollment_spec.rb
index 48423e7b..f5955925 100644
--- a/spec/models/enrollment_spec.rb
+++ b/spec/models/enrollment_spec.rb
@@ -21,27 +21,27 @@
       context "should be valid when" do
         it "student is not null" do
           enrollment.student = Student.new
-          enrollment.should have(0).errors_on :student
+          expect(enrollment).to have(0).errors_on :student
         end
       end
       context "should have error blank when" do
         it "student is null" do
           enrollment.student = nil
-          enrollment.should have_error(:blank).on :student
+          expect(enrollment).to have_error(:blank).on :student
         end
       end
       context "should have advisment error when it" do
         it "has just one advisor that is not a main advisor" do
           enrollment.advisements << FactoryGirl.create(:advisement, :main_advisor => false)
-          enrollment.should_not be_valid
-          enrollment.errors[:base].should include I18n.translate("activerecord.errors.models.enrollment.main_advisor_required")
+          expect(enrollment).not_to be_valid
+          expect(enrollment.errors[:base]).to include I18n.translate("activerecord.errors.models.enrollment.main_advisor_required")
         end
 
         it "has more than one main advisor" do
           enrollment.advisements << advisement1 = FactoryGirl.create(:advisement, :main_advisor => true)
           enrollment.advisements << advisement2 = FactoryGirl.create(:advisement, :main_advisor => true)
-          enrollment.should_not be_valid
-          enrollment.errors[:base].should include I18n.translate("activerecord.errors.models.enrollment.main_advisor_uniqueness")
+          expect(enrollment).not_to be_valid
+          expect(enrollment.errors[:base]).to include I18n.translate("activerecord.errors.models.enrollment.main_advisor_uniqueness")
         end
       end
     end
@@ -49,13 +49,13 @@
       context "should be valid when" do
         it "enrollment_status is not null" do
           enrollment.enrollment_status = EnrollmentStatus.new
-          enrollment.should have(0).errors_on :enrollment_status
+          expect(enrollment).to have(0).errors_on :enrollment_status
         end
       end
       context "should have error blank when" do
         it "enrollment_status is null" do
           enrollment.enrollment_status = nil
-          enrollment.should have_error(:blank).on :enrollment_status
+          expect(enrollment).to have_error(:blank).on :enrollment_status
         end
       end
     end
@@ -63,13 +63,13 @@
       context "should be valid when" do
         it "level is not null" do
           enrollment.level = Level.new
-          enrollment.should have(0).errors_on :level
+          expect(enrollment).to have(0).errors_on :level
         end
       end
       context "should have error blank when" do
         it "level is null" do
           enrollment.level = nil
-          enrollment.should have_error(:blank).on :level
+          expect(enrollment).to have_error(:blank).on :level
         end
       end
     end
@@ -77,13 +77,13 @@
       context "should be valid when" do
         it "enrollment_number is not null and is not taken" do
           enrollment.enrollment_number = "M123"
-          enrollment.should have(0).errors_on :enrollment_number
+          expect(enrollment).to have(0).errors_on :enrollment_number
         end
       end
       context "should have error blank when" do
         it "enrollment_number is null" do
           enrollment.enrollment_number = nil
-          enrollment.should have_error(:blank).on :enrollment_number
+          expect(enrollment).to have_error(:blank).on :enrollment_number
         end
       end
       context "should have error taken when" do
@@ -91,7 +91,7 @@
           enrollment_number = "D123"
           FactoryGirl.create(:enrollment, :enrollment_number => enrollment_number)
           enrollment.enrollment_number = enrollment_number
-          enrollment.should have_error(:taken).on :enrollment_number
+          expect(enrollment).to have_error(:taken).on :enrollment_number
         end
       end
     end
@@ -100,14 +100,14 @@
         it "is after admission_date" do
           enrollment = FactoryGirl.create(:enrollment, :admission_date => 3.days.ago.to_date)
           enrollment.thesis_defense_date = 3.days.from_now.to_date
-          enrollment.should have(0).errors_on :thesis_defense_date
+          expect(enrollment).to have(0).errors_on :thesis_defense_date
         end
       end
       context "should not be valid when" do
         it "is before admission_date" do
           enrollment = FactoryGirl.create(:enrollment, :admission_date => 3.days.ago.to_date)
           enrollment.thesis_defense_date = 4.days.ago.to_date
-          enrollment.should have_error(:thesis_defense_date_before_admission_date).on :thesis_defense_date
+          expect(enrollment).to have_error(:thesis_defense_date_before_admission_date).on :thesis_defense_date
         end
       end
     end
@@ -116,7 +116,7 @@
       context "should be valid when" do
         it "is empty" do
           enrollment = FactoryGirl.create(:enrollment, :research_area => nil)
-          enrollment.should have(0).errors_on :research_area
+          expect(enrollment).to have(0).errors_on :research_area
         end
 
         it "is the same research_area as the advisor" do
@@ -124,13 +124,13 @@
           enrollment = FactoryGirl.create(:enrollment, :research_area => research_area)
           professor = FactoryGirl.create(:professor, :research_areas => [research_area])
           FactoryGirl.create(:advisement, :enrollment => enrollment, :professor => professor)
-          enrollment.should have(0).errors_on :research_area
+          expect(enrollment).to have(0).errors_on :research_area
         end
 
         it "there is no advisor" do
           research_area = FactoryGirl.create(:research_area) 
           enrollment = FactoryGirl.create(:enrollment, :research_area => research_area)
-          enrollment.should have(0).errors_on :research_area
+          expect(enrollment).to have(0).errors_on :research_area
         end
       end
       context "should not be valid when" do
@@ -141,7 +141,7 @@
           professor = FactoryGirl.create(:professor, :research_areas => [research_area2])
           FactoryGirl.create(:advisement, :enrollment => enrollment, :professor => professor)
           enrollment.save
-          enrollment.errors[:research_area].should include I18n.translate("activerecord.errors.models.enrollment.research_area_different_from_professors")
+          expect(enrollment.errors[:research_area]).to include I18n.translate("activerecord.errors.models.enrollment.research_area_different_from_professors")
         end
       end
     end
@@ -179,7 +179,7 @@
         enrollment.enrollment_number = enrollment_number
         student_name = "Student"
         enrollment.student = Student.new(:name => student_name)
-        enrollment.to_label.should eql("#{enrollment_number} - #{student_name}")
+        expect(enrollment.to_label).to eql("#{enrollment_number} - #{student_name}")
       end
     end
     describe "self.with_delayed_phases_on" do
@@ -187,7 +187,7 @@
         result = Enrollment.with_delayed_phases_on(2.months.from_now.to_date, nil)
 
         expected_result = [@delayed_enrollment.id, @enrollment_expired_deferral.id].sort
-        result.sort.should eql(expected_result.sort)
+        expect(result.sort).to eql(expected_result.sort)
       end
     end
     describe "self.with_all_phases_accomplished_on" do
@@ -197,7 +197,7 @@
         result = Enrollment.with_all_phases_accomplished_on(Date.today)
 
         expected_result = [@enrollment_accomplished.id].sort
-        result.sort.should eql(expected_result.sort)
+        expect(result.sort).to eql(expected_result.sort)
       end
     end
 
@@ -216,15 +216,15 @@
       it "shouldn't return any value when the enrollment doesn't have any classes" do
         admission_date = YearSemester.current.semester_begin
         enrollment = FactoryGirl.create(:enrollment, :admission_date => admission_date)
-        enrollment.available_semesters.any?.should be_falsey
+        expect(enrollment.available_semesters.any?).to be_falsey
       end
 
       it "should return [[2013,2]] when it is enrolled to a class of 2013.2" do
         admission_date = YearSemester.current.semester_begin
         enrollment = FactoryGirl.create(:enrollment, :admission_date => admission_date)
         FactoryGirl.create(:class_enrollment, :enrollment => enrollment, :course_class => @class6)
-        enrollment.available_semesters.any?.should be_truthy
-        enrollment.available_semesters.should == [[2013, 2]]
+        expect(enrollment.available_semesters.any?).to be_truthy
+        expect(enrollment.available_semesters).to eq([[2013, 2]])
       end
 
       it "should return [[2013,2]] when it is enrolled to more than one class of 2013.2" do
@@ -232,8 +232,8 @@
         enrollment = FactoryGirl.create(:enrollment, :admission_date => admission_date)
         FactoryGirl.create(:class_enrollment, :enrollment => enrollment, :course_class => @class6)
         FactoryGirl.create(:class_enrollment, :enrollment => enrollment, :course_class => @class7)
-        enrollment.available_semesters.any?.should be_truthy
-        enrollment.available_semesters.should == [[2013, 2]]
+        expect(enrollment.available_semesters.any?).to be_truthy
+        expect(enrollment.available_semesters).to eq([[2013, 2]])
       end
 
       it "should return [[2013, 1], [2013,2]] when it is enrolled a class of 2013.1 and a class of 2013.2" do
@@ -241,8 +241,8 @@
         enrollment = FactoryGirl.create(:enrollment, :admission_date => admission_date)
         FactoryGirl.create(:class_enrollment, :enrollment => enrollment, :course_class => @class6)
         FactoryGirl.create(:class_enrollment, :enrollment => enrollment, :course_class => @class5)
-        enrollment.available_semesters.any?.should be_truthy
-        enrollment.available_semesters.should == [[2013, 1], [2013, 2]]
+        expect(enrollment.available_semesters.any?).to be_truthy
+        expect(enrollment.available_semesters).to eq([[2013, 1], [2013, 2]])
       end
 
       it "should be ordered: [[2012, 1], [2012, 2], [2013, 1], [2013,2]]" do
@@ -255,8 +255,8 @@
         FactoryGirl.create(:class_enrollment, :enrollment => enrollment, :course_class => @class4)
         FactoryGirl.create(:class_enrollment, :enrollment => enrollment, :course_class => @class2)
         FactoryGirl.create(:class_enrollment, :enrollment => enrollment, :course_class => @class6)
-        enrollment.available_semesters.any?.should be_truthy
-        enrollment.available_semesters.should == [[2012, 1], [2012, 2], [2013, 1], [2013,2]]
+        expect(enrollment.available_semesters.any?).to be_truthy
+        expect(enrollment.available_semesters).to eq([[2012, 1], [2012, 2], [2013, 1], [2013,2]])
       end
     end
 
@@ -294,29 +294,29 @@
 
       describe "gpr_by_semester" do
         it "should return 90 for 2012.2 (testing 1 grade)" do
-          @enrollment.gpr_by_semester(2012, 2).should == 90
+          expect(@enrollment.gpr_by_semester(2012, 2)).to eq(90)
         end
 
         it "should return 62 for 2012.1 (testing 2 grades)" do
-          @enrollment.gpr_by_semester(2012, 1).should == 62
+          expect(@enrollment.gpr_by_semester(2012, 1)).to eq(62)
         end
 
         it "should return 0 for 2013.2 (testing 1 incomplete class)" do
-          @enrollment.gpr_by_semester(2013, 2).should be_nil
+          expect(@enrollment.gpr_by_semester(2013, 2)).to be_nil
         end
         
         it "should return 99 for 2013.1 (testing 2 grades, 1 incomplete class, 1 approved class without grade)" do
-          @enrollment.gpr_by_semester(2013, 1).round(0).should == 99
+          expect(@enrollment.gpr_by_semester(2013, 1).round(0)).to eq(99)
         end
 
         it "should return 0 if it is not enrolled in any classes of the semester" do
-          @enrollment.gpr_by_semester(2011, 2).should be_nil
+          expect(@enrollment.gpr_by_semester(2011, 2)).to be_nil
         end
       end
 
       describe "total_gpr" do
         it "should return 83" do
-          @enrollment.total_gpr.round.should == 83
+          expect(@enrollment.total_gpr.round).to eq(83)
         end
       end
 
diff --git a/spec/models/enrollment_status_spec.rb b/spec/models/enrollment_status_spec.rb
index 4dfbd206..bd6b2a93 100644
--- a/spec/models/enrollment_status_spec.rb
+++ b/spec/models/enrollment_status_spec.rb
@@ -14,13 +14,13 @@
       context "should be valid when" do
         it "name is not null and is not taken" do
           enrollment_status.name = "EnrollmentStatus name"
-          enrollment_status.should have(0).errors_on :name
+          expect(enrollment_status).to have(0).errors_on :name
         end
       end
       context "should have error blank when" do
         it "name is null" do
           enrollment_status.name = nil
-          enrollment_status.should have_error(:blank).on :name
+          expect(enrollment_status).to have_error(:blank).on :name
         end
       end
       context "should have error taken when" do
@@ -28,9 +28,9 @@
           name = "EnrollmentStatus name"
           FactoryGirl.create(:enrollment_status, :name => name)
           enrollment_status.name = name
-          enrollment_status.should have_error(:taken).on :name
+          expect(enrollment_status).to have_error(:taken).on :name
         end
       end
     end
   end
-end
\ No newline at end of file
+end
diff --git a/spec/models/institution_spec.rb b/spec/models/institution_spec.rb
index 39acda8d..b30576b4 100644
--- a/spec/models/institution_spec.rb
+++ b/spec/models/institution_spec.rb
@@ -15,13 +15,13 @@
       context "should be valid when" do
         it "name is not null and is not taken" do
           institution.name = "Institution name"
-          institution.should have(0).errors_on :name
+          expect(institution).to have(0).errors_on :name
         end
       end
       context "should have error blank when" do
         it "name is null" do
           institution.name = nil
-          institution.should have_error(:blank).on :name
+          expect(institution).to have_error(:blank).on :name
         end
       end
       context "should have error taken when" do
@@ -29,9 +29,9 @@
           name = "Institution name"
           FactoryGirl.create(:institution, :name => name)
           institution.name = name
-          institution.should have_error(:taken).on :name
+          expect(institution).to have_error(:taken).on :name
         end
       end
     end
   end
-end
\ No newline at end of file
+end
diff --git a/spec/models/level_spec.rb b/spec/models/level_spec.rb
index 6e830ca2..fe03e7e8 100644
--- a/spec/models/level_spec.rb
+++ b/spec/models/level_spec.rb
@@ -19,13 +19,13 @@
       context "should be valid when" do
         it "name is not null and is not taken" do
           level.name = "Level name"
-          level.should have(0).errors_on :name
+          expect(level).to have(0).errors_on :name
         end
       end
       context "should have error blank when" do
         it "name is null" do
           level.name = nil
-          level.should have_error(:blank).on :name
+          expect(level).to have_error(:blank).on :name
         end
       end
       context "should have error taken when" do
@@ -33,7 +33,7 @@
           name = "Level name"
           FactoryGirl.create(:level, :name => name)
           level.name = name
-          level.should have_error(:taken).on :name
+          expect(level).to have_error(:taken).on :name
         end
       end
     end
@@ -41,15 +41,15 @@
       context "should be valid when" do
         it "default_duration is not null" do
           level.default_duration = 48
-          level.should have(0).errors_on :default_duration
+          expect(level).to have(0).errors_on :default_duration
         end
       end
       context "should have error blank when" do
         it "default_duration is null" do
           level.default_duration = nil
-          level.should have_error(:blank).on :default_duration
+          expect(level).to have_error(:blank).on :default_duration
         end
       end
     end
   end
-end
\ No newline at end of file
+end
diff --git a/spec/models/major_spec.rb b/spec/models/major_spec.rb
index a3f68fdd..d04d9762 100644
--- a/spec/models/major_spec.rb
+++ b/spec/models/major_spec.rb
@@ -14,13 +14,13 @@
       context "should be valid when" do
         it "institution is not null" do
           major.institution = Institution.new
-          major.should have(0).errors_on :institution
+          expect(major).to have(0).errors_on :institution
         end
       end
       context "should have error blank when" do
         it "institution is null" do
           major.institution = nil
-          major.should have_error(:blank).on :institution
+          expect(major).to have_error(:blank).on :institution
         end
       end
     end
@@ -28,13 +28,13 @@
       context "should be valid when" do
         it "level is not null" do
           major.level = Level.new
-          major.should have(0).errors_on :level
+          expect(major).to have(0).errors_on :level
         end
       end
       context "should have error blank when" do
         it "level is null" do
           major.level = nil
-          major.should have_error(:blank).on :level
+          expect(major).to have_error(:blank).on :level
         end
       end
     end
@@ -42,13 +42,13 @@
       context "should be valid when" do
         it "name is not null" do
           major.name = "Name"
-          major.should have(0).errors_on :name
+          expect(major).to have(0).errors_on :name
         end
       end
       context "should have error blank when" do
         it "name is null" do
           major.name = nil
-          major.should have_error(:blank).on :name
+          expect(major).to have_error(:blank).on :name
         end
       end
     end
@@ -64,8 +64,8 @@
         major.name = major_name
         major.institution = Institution.new(:name => institution_name)
         expected = "#{major_name} - #{institution_name} - (#{level_name})"
-        major.to_label.should eql(expected)
+        expect(major.to_label).to eql(expected)
       end
     end
   end
-end
\ No newline at end of file
+end
diff --git a/spec/models/notification_spec.rb b/spec/models/notification_spec.rb
index 04dba799..592e8a28 100644
--- a/spec/models/notification_spec.rb
+++ b/spec/models/notification_spec.rb
@@ -15,13 +15,13 @@
       context "should be valid when" do
         it "body_template is not null" do
           notification.body_template = "MSG"
-          notification.should have(0).errors_on :body_template
+          expect(notification).to have(0).errors_on :body_template
         end
       end
       context "should have error blank when" do
         it "body_template is null" do
           notification.body_template = nil
-          notification.should have_error(:blank).on :body_template
+          expect(notification).to have_error(:blank).on :body_template
         end
       end
     end
@@ -30,19 +30,19 @@
       context "should be valid when" do
         it "frequency is not null" do
           notification.frequency = I18n.translate("activerecord.attributes.notification.frequencies.annual")
-          notification.should have(0).errors_on :frequency
+          expect(notification).to have(0).errors_on :frequency
         end
       end
       context "should have error blank when" do
         it "frequency is null" do
           notification.frequency = nil
-          notification.should have_error(:blank).on :frequency
+          expect(notification).to have_error(:blank).on :frequency
         end
       end
       context "should have error inclusion when" do
         it "frequency is not in the list" do
           notification.frequency = "bla"
-          notification.should have_error(:inclusion).on :frequency
+          expect(notification).to have_error(:inclusion).on :frequency
         end
       end
     end
@@ -51,13 +51,13 @@
       context "should be valid when" do
         it "notification_offset is not null" do
           notification.notification_offset = "5"
-          notification.should have(0).errors_on :notification_offset
+          expect(notification).to have(0).errors_on :notification_offset
         end
       end
       context "should have error blank when" do
         it "notification_offset is null" do
           notification.notification_offset = nil
-          notification.should have_error(:blank).on :notification_offset
+          expect(notification).to have_error(:blank).on :notification_offset
         end
       end
     end
@@ -66,13 +66,13 @@
       context "should be valid when" do
         it "query_offset is not null" do
           notification.query_offset = "5"
-          notification.should have(0).errors_on :query_offset
+          expect(notification).to have(0).errors_on :query_offset
         end
       end
       context "should have error blank when" do
         it "query_offset is null" do
           notification.query_offset = nil
-          notification.should have_error(:blank).on :query_offset
+          expect(notification).to have_error(:blank).on :query_offset
         end
       end
     end
@@ -81,13 +81,13 @@
       context "should be valid when" do
         it "query is not null" do
           notification.sql_query = "SELECT * FROM USERS"
-          notification.should have(0).errors_on :query
+          expect(notification).to have(0).errors_on :query
         end
       end
       context "should have error blank when" do
         it "query is null" do
           notification.query = nil
-          notification.should have_error(:blank).on :query
+          expect(notification).to have_error(:blank).on :query
         end
       end
     end
@@ -96,13 +96,13 @@
       context "should be valid when" do
         it "subject_template is not null" do
           notification.subject_template = "SELECT * FROM USERS"
-          notification.should have(0).errors_on :subject_template
+          expect(notification).to have(0).errors_on :subject_template
         end
       end
       context "should have error blank when" do
         it "subject_template is null" do
           notification.subject_template = nil
-          notification.should have_error(:blank).on :subject_template
+          expect(notification).to have_error(:blank).on :subject_template
         end
       end
     end
@@ -111,13 +111,13 @@
       context "should be valid when" do
         it "to_template is not null" do
           notification.to_template = "SELECT * FROM USERS"
-          notification.should have(0).errors_on :to_template
+          expect(notification).to have(0).errors_on :to_template
         end
       end
       context "should have error blank when" do
         it "to_template is null" do
           notification.to_template = nil
-          notification.should have_error(:blank).on :to_template
+          expect(notification).to have_error(:blank).on :to_template
         end
       end
     end
@@ -129,7 +129,7 @@
         it "should be 01/04 if today is 01/03" do
           notification = FactoryGirl.create(:notification)
           notification.frequency = I18n.translate("activerecord.attributes.notification.frequencies.daily")
-          notification.calculate_next_notification_date(:time => Time.parse("01/03")).should == Time.parse("01/04")
+          expect(notification.calculate_next_notification_date(:time => Time.parse("01/03"))).to eq(Time.parse("01/04"))
         end
       end
 
@@ -137,25 +137,25 @@
         it "should be 2014/01/20(monday) if today is 2014/01/14(tuesday)" do
           notification = FactoryGirl.create(:notification)
           notification.frequency = I18n.translate("activerecord.attributes.notification.frequencies.weekly")
-          notification.calculate_next_notification_date(:time => Time.parse("2014/01/14")).should == Time.parse("2014/01/20")
+          expect(notification.calculate_next_notification_date(:time => Time.parse("2014/01/14"))).to eq(Time.parse("2014/01/20"))
         end
 
         it "should be 2014/01/16(thursday) if today is 2014/01/14(tuesday) and offset is 3" do
           notification = FactoryGirl.create(:notification, :notification_offset => "3")
           notification.frequency = I18n.translate("activerecord.attributes.notification.frequencies.weekly")
-          notification.calculate_next_notification_date(:time => Time.parse("2014/01/14")).should == Time.parse("2014/01/16")
+          expect(notification.calculate_next_notification_date(:time => Time.parse("2014/01/14"))).to eq(Time.parse("2014/01/16"))
         end
 
         it "should be 2014/01/18(saturday) if today is 2014/01/14(tuesday) and offset is -2" do
           notification = FactoryGirl.create(:notification, :notification_offset => "-2")
           notification.frequency = I18n.translate("activerecord.attributes.notification.frequencies.weekly")
-          notification.calculate_next_notification_date(:time => Time.parse("2014/01/14")).should == Time.parse("2014/01/18")
+          expect(notification.calculate_next_notification_date(:time => Time.parse("2014/01/14"))).to eq(Time.parse("2014/01/18"))
         end
 
          it "should be 2014/02/01(saturday) if today is 2014/01/25(saturday) and offset is -2" do
           notification = FactoryGirl.create(:notification, :notification_offset => "-2")
           notification.frequency = I18n.translate("activerecord.attributes.notification.frequencies.weekly")
-          notification.calculate_next_notification_date(:time => Time.parse("2014/01/25")).should == Time.parse("2014/02/01")
+          expect(notification.calculate_next_notification_date(:time => Time.parse("2014/01/25"))).to eq(Time.parse("2014/02/01"))
         end
       end
 
@@ -163,19 +163,19 @@
         it "should be 02/01 if today is 01/17" do
           notification = FactoryGirl.create(:notification)
           notification.frequency = I18n.translate("activerecord.attributes.notification.frequencies.monthly")
-          notification.calculate_next_notification_date(:time => Time.parse("01/17")).should == Time.parse("02/01")
+          expect(notification.calculate_next_notification_date(:time => Time.parse("01/17"))).to eq(Time.parse("02/01"))
         end
 
         it "should be 02/15 if today is 01/17 and offset is 14" do
           notification = FactoryGirl.create(:notification, :notification_offset => "14")
           notification.frequency = I18n.translate("activerecord.attributes.notification.frequencies.monthly")
-          notification.calculate_next_notification_date(:time => Time.parse("01/17")).should == Time.parse("02/15")
+          expect(notification.calculate_next_notification_date(:time => Time.parse("01/17"))).to eq(Time.parse("02/15"))
         end
 
         it "should be 02/08 if today is 01/17 and offset is 1w" do
           notification = FactoryGirl.create(:notification, :notification_offset => "1w")
           notification.frequency = I18n.translate("activerecord.attributes.notification.frequencies.monthly")
-          notification.calculate_next_notification_date(:time => Time.parse("01/17")).should == Time.parse("02/08")
+          expect(notification.calculate_next_notification_date(:time => Time.parse("01/17"))).to eq(Time.parse("02/08"))
         end
       end
 
@@ -183,31 +183,31 @@
         it "should be 03/01 of this year if today is 09/01 of last year" do
           notification = FactoryGirl.create(:notification)
           notification.frequency = I18n.translate("activerecord.attributes.notification.frequencies.semiannual")
-          notification.calculate_next_notification_date(:time => Time.parse("09/01") - 1.year).should == Time.parse("03/01")
+          expect(notification.calculate_next_notification_date(:time => Time.parse("09/01") - 1.year)).to eq(Time.parse("03/01"))
         end
 
         it "should be 03/01 of this year if today is 02/01" do
           notification = FactoryGirl.create(:notification)
           notification.frequency = I18n.translate("activerecord.attributes.notification.frequencies.semiannual")
-          notification.calculate_next_notification_date(:time => Time.parse("02/01")).should == Time.parse("03/01")
+          expect(notification.calculate_next_notification_date(:time => Time.parse("02/01"))).to eq(Time.parse("03/01"))
         end
 
         it "should be 08/01 if today is 04/01" do
           notification = FactoryGirl.create(:notification)
           notification.frequency = I18n.translate("activerecord.attributes.notification.frequencies.semiannual")
-          notification.calculate_next_notification_date(:time => Time.parse("04/01")).should == Time.parse("08/01")
+          expect(notification.calculate_next_notification_date(:time => Time.parse("04/01"))).to eq(Time.parse("08/01"))
         end
 
         it "should be 03/01 of next year if today is 09/01" do
           notification = FactoryGirl.create(:notification)
           notification.frequency = I18n.translate("activerecord.attributes.notification.frequencies.semiannual")
-          notification.calculate_next_notification_date(:time => Time.parse("09/01")).should == (Time.parse("03/01") + 1.year)
+          expect(notification.calculate_next_notification_date(:time => Time.parse("09/01"))).to eq((Time.parse("03/01") + 1.year))
         end
 
         it "should be 07/01 if today is 02/15 and offset is -31" do
           notification = FactoryGirl.create(:notification, :notification_offset => "-31")
           notification.frequency = I18n.translate("activerecord.attributes.notification.frequencies.semiannual")
-          notification.calculate_next_notification_date(:time => Time.parse("02/15")).should == Time.parse("07/01")
+          expect(notification.calculate_next_notification_date(:time => Time.parse("02/15"))).to eq(Time.parse("07/01"))
         end
 
       end
@@ -216,7 +216,7 @@
         it "should be 2015/01/01 if today is 2014/06/27" do
           notification = FactoryGirl.create(:notification)
           notification.frequency = I18n.translate("activerecord.attributes.notification.frequencies.annual")
-          notification.calculate_next_notification_date(:time => Time.parse("2014/06/27")).should == Time.parse("2015/01/01")
+          expect(notification.calculate_next_notification_date(:time => Time.parse("2014/06/27"))).to eq(Time.parse("2015/01/01"))
         end
       end
     end
diff --git a/spec/models/phase_completion_spec.rb b/spec/models/phase_completion_spec.rb
index d113f9ee..2ee42025 100644
--- a/spec/models/phase_completion_spec.rb
+++ b/spec/models/phase_completion_spec.rb
@@ -11,13 +11,13 @@
       context "should be valid when" do
         it "enrollment_id is not null" do
           phase_completion.enrollment_id = 1
-          phase_completion.should have(0).errors_on :enrollment_id
+          expect(phase_completion).to have(0).errors_on :enrollment_id
         end
       end
       context "should have error blank when" do
         it "enrollment_id is null" do
           phase_completion.enrollment_id = nil
-          phase_completion.should have_error(:blank).on :enrollment_id
+          expect(phase_completion).to have_error(:blank).on :enrollment_id
         end
       end
     end
@@ -26,13 +26,13 @@
         it "phase_id is not null" do
           PhaseCompletion.destroy_all
           phase_completion.phase_id = 1
-          phase_completion.should have(0).errors_on :phase_id
+          expect(phase_completion).to have(0).errors_on :phase_id
         end
       end
       context "should have error blank when" do
         it "phase_id is null" do
           phase_completion.phase_id = nil
-          phase_completion.should have_error(:blank).on :phase_id
+          expect(phase_completion).to have_error(:blank).on :phase_id
         end
       end
     end
@@ -43,7 +43,7 @@
           PhaseCompletion.destroy_all
           phase_completion.phase_id = 1
           phase_completion.enrollment_id = 1
-          phase_completion.should have(0).errors_on :phase_id
+          expect(phase_completion).to have(0).errors_on :phase_id
         end
       end
       context "should have error taken when" do
@@ -53,7 +53,7 @@
           
           phase_completion.phase_id = 1
           phase_completion.enrollment_id = 1
-          phase_completion.should have_error(:taken).on :phase_id
+          expect(phase_completion).to have_error(:taken).on :phase_id
         end
       end
     end
diff --git a/spec/models/phase_duration_spec.rb b/spec/models/phase_duration_spec.rb
index 078e5817..016d6a28 100644
--- a/spec/models/phase_duration_spec.rb
+++ b/spec/models/phase_duration_spec.rb
@@ -12,13 +12,13 @@
       context "should be valid when" do
         it "phase is not null" do
           phase_duration.phase = Phase.new
-          phase_duration.should have(0).errors_on :phase
+          expect(phase_duration).to have(0).errors_on :phase
         end
       end
       context "should have error blank when" do
         it "phase is null" do
           phase_duration.phase = nil
-          phase_duration.should have_error(:blank).on :phase
+          expect(phase_duration).to have_error(:blank).on :phase
         end
       end
     end
@@ -26,13 +26,13 @@
       context "should be valid when" do
         it "level is not null" do
           phase_duration.level = Level.new
-          phase_duration.should have(0).errors_on :level
+          expect(phase_duration).to have(0).errors_on :level
         end
       end
       context "should have error blank when" do
         it "level is null" do
           phase_duration.level = nil
-          phase_duration.should have_error(:blank).on :level
+          expect(phase_duration).to have_error(:blank).on :level
         end
       end
     end
@@ -42,7 +42,7 @@
           phase_duration.deadline_months = 0
           phase_duration.deadline_semesters = 0
           phase_duration.deadline_days = 1
-          phase_duration.should have(0).errors_on :deadline
+          expect(phase_duration).to have(0).errors_on :deadline
         end
       end
       context "should have error blank_duration when" do
@@ -50,7 +50,7 @@
           phase_duration.deadline_days = 0
           phase_duration.deadline_months = 0
           phase_duration.deadline_semesters = nil
-          phase_duration.should have_error(:blank_deadline).on :deadline
+          expect(phase_duration).to have_error(:blank_deadline).on :deadline
         end
       end
     end
@@ -58,9 +58,9 @@
       context "should be valid when" do
         it "there is no deferral with the same level and no accomplishment with the same phase and level as the phase_duration" do
           phase_duration = FactoryGirl.create(:phase_duration)
-          phase_duration.validate_destroy.should == true
-          phase_duration.phase.should have(0).errors_on :base
-          phase_duration.should have(0).errors_on :deadline
+          expect(phase_duration.validate_destroy).to eq(true)
+          expect(phase_duration.phase).to have(0).errors_on :base
+          expect(phase_duration).to have(0).errors_on :deadline
         end
       end
       context "should have error has_deferral when" do
@@ -73,9 +73,9 @@
 
           phase_duration = FactoryGirl.create(:phase_duration, :phase => phase, :level => level)
        
-          phase_duration.validate_destroy.should == false
-          phase_duration.phase.errors.full_messages.should include(I18n.t('activerecord.errors.models.phase.phase_duration_has_deferral', :level => level.to_label))
-          phase_duration.errors.full_messages.should include(I18n.t('activerecord.errors.models.phase_duration.has_deferral'))
+          expect(phase_duration.validate_destroy).to eq(false)
+          expect(phase_duration.phase.errors.full_messages).to include(I18n.t('activerecord.errors.models.phase.phase_duration_has_deferral', :level => level.to_label))
+          expect(phase_duration.errors.full_messages).to include(I18n.t('activerecord.errors.models.phase_duration.has_deferral'))
         end
       end
       context "should have error has_level when" do
@@ -86,9 +86,9 @@
           phase_duration = FactoryGirl.create(:phase_duration, :phase => phase, :level => level)
           accomplishment = FactoryGirl.create(:accomplishment, :enrollment => enrollment, :phase => phase)
 
-          phase_duration.validate_destroy.should == false
-          phase_duration.phase.errors.full_messages.should include(I18n.t('activerecord.errors.models.phase.phase_duration_has_level', :level => level.to_label))
-          phase_duration.errors.full_messages.should include(I18n.t('activerecord.errors.models.phase_duration.has_level'))
+          expect(phase_duration.validate_destroy).to eq(false)
+          expect(phase_duration.phase.errors.full_messages).to include(I18n.t('activerecord.errors.models.phase.phase_duration_has_level', :level => level.to_label))
+          expect(phase_duration.errors.full_messages).to include(I18n.t('activerecord.errors.models.phase_duration.has_level'))
         end
       end
 
@@ -104,8 +104,8 @@
         phase_duration.deadline_months = deadline_months
         phase_duration.deadline_days = deadline_days
         expected = "#{deadline_semesters} períodos, #{deadline_months} meses e #{deadline_days} dias"
-        phase_duration.to_label.should eql(expected)
+        expect(phase_duration.to_label).to eql(expected)
       end
     end
   end
-end
\ No newline at end of file
+end
diff --git a/spec/models/phase_spec.rb b/spec/models/phase_spec.rb
index c0ce4850..42b1e67c 100644
--- a/spec/models/phase_spec.rb
+++ b/spec/models/phase_spec.rb
@@ -16,13 +16,13 @@
       context "should be valid when" do
         it "name is not null and is not taken" do
           phase.name = "Phase name"
-          phase.should have(0).errors_on :name
+          expect(phase).to have(0).errors_on :name
         end
       end
       context "should have error blank when" do
         it "name is null" do
           phase.name = nil
-          phase.should have_error(:blank).on :name
+          expect(phase).to have_error(:blank).on :name
         end
       end
       context "should have error taken when" do
@@ -30,7 +30,7 @@
           name = "Phase name"
           FactoryGirl.create(:phase, :name => name)
           phase.name = name
-          phase.should have_error(:taken).on :name
+          expect(phase).to have_error(:taken).on :name
         end
       end
     end
@@ -44,7 +44,7 @@
         FactoryGirl.create(:phase)
         
         phases = Phase.where(Phase::find_all_for_enrollment(nil))
-        phases.count.should == Phase.count
+        expect(phases.count).to eq(Phase.count)
       end
 
       it "should return phases that have the same level as the enrollment" do
@@ -63,8 +63,8 @@
         enrollment = FactoryGirl.create(:enrollment, :level => level1) 
         
         phases = Phase.where(Phase::find_all_for_enrollment(enrollment))
-        phases.count.should == 2
+        expect(phases.count).to eq(2)
       end
     end
   end
-end
\ No newline at end of file
+end
diff --git a/spec/models/professor_research_area_spec.rb b/spec/models/professor_research_area_spec.rb
index f04b7af8..d9d286a7 100644
--- a/spec/models/professor_research_area_spec.rb
+++ b/spec/models/professor_research_area_spec.rb
@@ -11,13 +11,13 @@
       context "should be valid when" do
         it "professor is not null" do
           professor_research_area.professor = Professor.new
-          professor_research_area.should have(0).errors_on :professor
+          expect(professor_research_area).to have(0).errors_on :professor
         end
       end
       context "should have error blank when" do
         it "professor is null" do
           professor_research_area.professor = nil
-          professor_research_area.should have_error(:blank).on :professor
+          expect(professor_research_area).to have_error(:blank).on :professor
         end
       end
     end
@@ -25,13 +25,13 @@
       context "should be valid when" do
         it "research_area is not null" do
           professor_research_area.research_area = ResearchArea.new
-          professor_research_area.should have(0).errors_on :research_area
+          expect(professor_research_area).to have(0).errors_on :research_area
         end
       end
       context "should have error blank when" do
         it "professor is null" do
           professor_research_area.research_area = nil
-          professor_research_area.should have_error(:blank).on :research_area
+          expect(professor_research_area).to have_error(:blank).on :research_area
         end
       end
     end
@@ -40,7 +40,7 @@
       context "should be valid when" do
         it "don't exists the professor for the same research_area" do
           professor_research_area.professor = Professor.new
-          professor_research_area.should have(0).errors_on :professor_id
+          expect(professor_research_area).to have(0).errors_on :professor_id
         end
       end
       context "should have uniqueness error when" do
@@ -48,9 +48,9 @@
           professor_research_area.professor = FactoryGirl.create(:professor)
           professor_research_area.research_area = FactoryGirl.create(:research_area)
           FactoryGirl.create(:professor_research_area, :professor => professor_research_area.professor, :research_area => professor_research_area.research_area)
-          professor_research_area.should have_error(:unique_pair).on :professor_id
+          expect(professor_research_area).to have_error(:unique_pair).on :professor_id
         end
       end
     end
   end
-end
\ No newline at end of file
+end
diff --git a/spec/models/professor_spec.rb b/spec/models/professor_spec.rb
index f765a924..6d19a48b 100644
--- a/spec/models/professor_spec.rb
+++ b/spec/models/professor_spec.rb
@@ -19,13 +19,13 @@
       context "should be valid when" do
         it "cpf is not null and is not taken" do
           professor.cpf = "Professor cpf"
-          professor.should have(0).errors_on :cpf
+          expect(professor).to have(0).errors_on :cpf
         end
       end
       context "should have error blank when" do
         it "cpf is null" do
           professor.cpf = nil
-          professor.should have_error(:blank).on :cpf
+          expect(professor).to have_error(:blank).on :cpf
         end
       end
       context "should have error taken when" do
@@ -33,7 +33,7 @@
           cpf = "Professor cpf"
           FactoryGirl.create(:professor, :cpf => cpf)
           professor.cpf = cpf
-          professor.should have_error(:taken).on :cpf
+          expect(professor).to have_error(:taken).on :cpf
         end
       end
     end
@@ -41,13 +41,13 @@
       context "should be valid when" do
         it "name is not null and is not taken" do
           professor.name = "Professor name"
-          professor.should have(0).errors_on :name
+          expect(professor).to have(0).errors_on :name
         end
       end
       context "should have error blank when" do
         it "name is null" do
           professor.name = nil
-          professor.should have_error(:blank).on :name
+          expect(professor).to have_error(:blank).on :name
         end
       end
     end
@@ -55,18 +55,18 @@
       context "should be valid when" do
         it "email is null" do
           professor.email = nil
-          professor.should have(0).errors_on :email
+          expect(professor).to have(0).errors_on :email
         end
         it "email is not null and not taken" do
           professor.email = "professor@sapos.com"
-          professor.should have(0).errors_on :email
+          expect(professor).to have(0).errors_on :email
         end
       end
       context "should have error taken when" do
         it "email is already in use" do
           other_professor = FactoryGirl.create(:professor, :email => "professor@sapos.com")
           professor.email = other_professor.email
-          professor.should have_error(:taken).on :email
+          expect(professor).to have_error(:taken).on :email
         end
       end
     end
@@ -74,18 +74,18 @@
       context "should be valid when" do
         it "enrollment_number is null" do
           professor.enrollment_number = nil
-          professor.should have(0).errors_on :enrollment_number
+          expect(professor).to have(0).errors_on :enrollment_number
         end
         it "enrollment_number is not null and not taken" do
           professor.enrollment_number = "Professor Enrollment Number"
-          professor.should have(0).errors_on :enrollment_number
+          expect(professor).to have(0).errors_on :enrollment_number
         end
       end
       context "should have error taken when" do
         it "enrollment_number is already in use" do
           other_professor = FactoryGirl.create(:professor, :enrollment_number => "Enrollment number")
           professor.enrollment_number = other_professor.enrollment_number
-          professor.should have_error(:taken).on :enrollment_number
+          expect(professor).to have_error(:taken).on :enrollment_number
         end
       end
     end
@@ -93,7 +93,7 @@
   describe "Methods" do
     describe "advisement_points" do
       it "should return 0 if the professor has no advisement_authorizations" do
-        professor.advisement_points.should eql("0.0")
+        expect(professor.advisement_points).to eql("0.0")
       end
       it "should return the spected number if the professor has advisement_authorizations (default)" do
         professor = FactoryGirl.create(:professor)
@@ -109,7 +109,7 @@
 
         FactoryGirl.create(:advisement, :professor => other_professor, :enrollment => other_enrollment, :main_advisor => false)
 
-        professor.advisement_points.should eql("1.5")
+        expect(professor.advisement_points).to eql("1.5")
       end
 
       it "should return the spected number if the professor has advisement_authorizations and the points are changed" do
@@ -133,14 +133,14 @@
 
         FactoryGirl.create(:advisement, :professor => other_professor, :enrollment => other_enrollment, :main_advisor => false)
 
-        professor.advisement_points.should eql("3.0")
+        expect(professor.advisement_points).to eql("3.0")
       end
     end
     describe "advisement_point" do
       context "should return 0 when" do
         it "the professor has no advisement_authorizations" do
           enrollment = FactoryGirl.create(:enrollment)
-          professor.advisement_point(enrollment).should eql(0.0)
+          expect(professor.advisement_point(enrollment)).to eql(0.0)
         end
         it "the enrollment is not advised by the professor" do
           professor = FactoryGirl.create(:professor)
@@ -150,7 +150,7 @@
           FactoryGirl.create(:advisement_authorization, :professor => other_professor, :level => enrollment.level)
           FactoryGirl.create(:advisement, :professor => other_professor, :enrollment => enrollment)
 
-          professor.advisement_point(enrollment).should eql(0.0)
+          expect(professor.advisement_point(enrollment)).to eql(0.0)
         end
         it "the enrollment have a dismissal" do
           professor = FactoryGirl.create(:professor)
@@ -159,7 +159,7 @@
           FactoryGirl.create(:advisement, :professor => professor, :enrollment => enrollment)
           FactoryGirl.create(:dismissal, :enrollment => enrollment)
 
-          professor.advisement_point(enrollment).should eql(0.0)
+          expect(professor.advisement_point(enrollment)).to eql(0.0)
         end
       end
       it "should return 1 when the professor is the only authorized advisor (default)" do
@@ -173,7 +173,7 @@
         FactoryGirl.create(:advisement, :professor => professor, :enrollment => enrollment)
         FactoryGirl.create(:advisement, :professor => other_professor, :enrollment => enrollment, :main_advisor => false)
 
-        professor.advisement_point(enrollment).should eql(1.0)
+        expect(professor.advisement_point(enrollment)).to eql(1.0)
       end
 
       it "should return the configured value when the professor is the only authorized advisor" do
@@ -190,7 +190,7 @@
         FactoryGirl.create(:advisement, :professor => professor, :enrollment => enrollment)
         FactoryGirl.create(:advisement, :professor => other_professor, :enrollment => enrollment, :main_advisor => false)
 
-        professor.advisement_point(enrollment).should eql(2.0)
+        expect(professor.advisement_point(enrollment)).to eql(2.0)
       end      
 
       it "should return 0.5 when the professor is not the only authorized advisor (default)" do
@@ -204,7 +204,7 @@
         FactoryGirl.create(:advisement, :professor => professor, :enrollment => enrollment)
         FactoryGirl.create(:advisement, :professor => other_professor, :enrollment => enrollment, :main_advisor => false)
 
-        professor.advisement_point(enrollment).should eql(0.5)
+        expect(professor.advisement_point(enrollment)).to eql(0.5)
       end
 
       it "should return the configured value when the professor is not the only authorized advisor" do
@@ -222,8 +222,8 @@
         FactoryGirl.create(:advisement, :professor => professor, :enrollment => enrollment)
         FactoryGirl.create(:advisement, :professor => other_professor, :enrollment => enrollment, :main_advisor => false)
 
-        professor.advisement_point(enrollment).should eql(1.0)
+        expect(professor.advisement_point(enrollment)).to eql(1.0)
       end
     end
   end
-end
\ No newline at end of file
+end
diff --git a/spec/models/query_param_spec.rb b/spec/models/query_param_spec.rb
index 3db3d992..2e644840 100644
--- a/spec/models/query_param_spec.rb
+++ b/spec/models/query_param_spec.rb
@@ -14,32 +14,32 @@
     context "name is blank" do
       it "show an blank error on name" do
 	query_param.name = nil     
-        query_param.should have_error(:blank).on :name
+        expect(query_param).to have_error(:blank).on :name
       end
     end
 
     context "name is invalid" do
       it "show an format error on name" do
 	query_param.name = "A"
-        query_param.should have_error(:invalid_name).on :name
+        expect(query_param).to have_error(:invalid_name).on :name
 
 	query_param.name = "_"
-        query_param.should have_error(:invalid_name).on :name
+        expect(query_param).to have_error(:invalid_name).on :name
 
 	query_param.name = " "
-        query_param.should have_error(:invalid_name).on :name
+        expect(query_param).to have_error(:invalid_name).on :name
 
         query_param.name = "0"
-        query_param.should have_error(:invalid_name).on :name
+        expect(query_param).to have_error(:invalid_name).on :name
 
         query_param.name = "Za"
-        query_param.should have_error(:invalid_name).on :name
+        expect(query_param).to have_error(:invalid_name).on :name
 
         query_param.name = "9z"
-        query_param.should have_error(:invalid_name).on :name
+        expect(query_param).to have_error(:invalid_name).on :name
 
 	query_param.name = "a|\\<>,.:;?/ç^~{}[]'`'\"!@#$%&*()-+= 	\t\n\r"
-        query_param.should have_error(:invalid_name).on :name
+        expect(query_param).to have_error(:invalid_name).on :name
 
       end
     end
@@ -47,54 +47,54 @@
     context "name is valid" do
       it "do not have errors on name" do
 	query_param.name = "aa"
-        query_param.should have(0).errors_on :name
+        expect(query_param).to have(0).errors_on :name
 
 	query_param.name = "zA"
-        query_param.should have(0).errors_on :name
+        expect(query_param).to have(0).errors_on :name
 
 	query_param.name = "a9"
-        query_param.should have(0).errors_on :name
+        expect(query_param).to have(0).errors_on :name
 
         query_param.name = "z0"
-        query_param.should have(0).errors_on :name
+        expect(query_param).to have(0).errors_on :name
 
 	query_param.name = "a_"
-        query_param.should have(0).errors_on :name
+        expect(query_param).to have(0).errors_on :name
 
         query_param.name = "_a"
-        query_param.should have(0).errors_on :name
+        expect(query_param).to have(0).errors_on :name
 
         query_param.name = "_z"
-        query_param.should have(0).errors_on :name
+        expect(query_param).to have(0).errors_on :name
 
 	query_param.name = "_0"
-        query_param.should have(0).errors_on :name
+        expect(query_param).to have(0).errors_on :name
 
 	query_param.name = "_9"
-        query_param.should have(0).errors_on :name
+        expect(query_param).to have(0).errors_on :name
 
         query_param.name = "__"
-        query_param.should have(0).errors_on :name
+        expect(query_param).to have(0).errors_on :name
 
 	query_param.name = "aA_z0"
-        query_param.should have(0).errors_on :name
+        expect(query_param).to have(0).errors_on :name
 
         query_param.name = "_aZ9_"
-        query_param.should have(0).errors_on :name
+        expect(query_param).to have(0).errors_on :name
       end
     end
 
     context "value_type is blank" do
       it "show an blank error on value_type" do
         query_param.value_type = nil      
-        query_param.should have_error(:blank).on :value_type
+        expect(query_param).to have_error(:blank).on :value_type
       end
     end
 
     context "value_type is invalid" do
       it "show an inclusion error on value_type" do
         query_param.value_type = "tipo_invalido"
-        query_param.should have_error(:inclusion).on :value_type
+        expect(query_param).to have_error(:inclusion).on :value_type
       end
     end
 
@@ -102,28 +102,28 @@
       it "do not have errors in value_type" do
 
      	query_param.value_type = "String"
-        query_param.should have(0).errors_on :value_type
+        expect(query_param).to have(0).errors_on :value_type
 
      	query_param.value_type = "Integer"
-        query_param.should have(0).errors_on :value_type
+        expect(query_param).to have(0).errors_on :value_type
 
      	query_param.value_type = "Float"
-        query_param.should have(0).errors_on :value_type
+        expect(query_param).to have(0).errors_on :value_type
 
      	query_param.value_type = "List"
-        query_param.should have(0).errors_on :value_type
+        expect(query_param).to have(0).errors_on :value_type
 
      	query_param.value_type = "Date"
-        query_param.should have(0).errors_on :value_type
+        expect(query_param).to have(0).errors_on :value_type
 
      	query_param.value_type = "DateTime"
-        query_param.should have(0).errors_on :value_type
+        expect(query_param).to have(0).errors_on :value_type
 
      	query_param.value_type = "Time"
-        query_param.should have(0).errors_on :value_type
+        expect(query_param).to have(0).errors_on :value_type
 
      	query_param.value_type = "Literal"
-        query_param.should have(0).errors_on :value_type
+        expect(query_param).to have(0).errors_on :value_type
 
       end	      
     end
@@ -133,143 +133,143 @@
        query_param.value_type = "Integer"
 
        query_param.default_value = " "
-       query_param.should have_error(:invalid_integer).on :default_value
+       expect(query_param).to have_error(:invalid_integer).on :default_value
 
        query_param.default_value = "a"
-       query_param.should have_error(:invalid_integer).on :default_value
+       expect(query_param).to have_error(:invalid_integer).on :default_value
 
        query_param.default_value = "0.0"
-       query_param.should have_error(:invalid_integer).on :default_value
+       expect(query_param).to have_error(:invalid_integer).on :default_value
 
        query_param.default_value = "1.0"
-       query_param.should have_error(:invalid_integer).on :default_value
+       expect(query_param).to have_error(:invalid_integer).on :default_value
 
        query_param.default_value = "0.1"
-       query_param.should have_error(:invalid_integer).on :default_value
+       expect(query_param).to have_error(:invalid_integer).on :default_value
 
        query_param.default_value = "-1.0"
-       query_param.should have_error(:invalid_integer).on :default_value
+       expect(query_param).to have_error(:invalid_integer).on :default_value
 
        query_param.default_value = ".0"
-       query_param.should have_error(:invalid_integer).on :default_value
+       expect(query_param).to have_error(:invalid_integer).on :default_value
 
        query_param.default_value = ".1"
-       query_param.should have_error(:invalid_integer).on :default_value
+       expect(query_param).to have_error(:invalid_integer).on :default_value
 
        query_param.default_value = ",0" 
-       query_param.should have_error(:invalid_integer).on :default_value
+       expect(query_param).to have_error(:invalid_integer).on :default_value
 
        query_param.default_value = ",1"
-       query_param.should have_error(:invalid_integer).on :default_value
+       expect(query_param).to have_error(:invalid_integer).on :default_value
 
        query_param.default_value = "1,0" 
-       query_param.should have_error(:invalid_integer).on :default_value
+       expect(query_param).to have_error(:invalid_integer).on :default_value
      end
 
      it "show an float error on default_value" do
        query_param.value_type = "Float"
 
        query_param.default_value = " "
-       query_param.should have_error(:invalid_float).on :default_value
+       expect(query_param).to have_error(:invalid_float).on :default_value
 
        query_param.default_value = "a"
-       query_param.should have_error(:invalid_float).on :default_value
+       expect(query_param).to have_error(:invalid_float).on :default_value
  
        query_param.default_value = "."
-       query_param.should have_error(:invalid_float).on :default_value
+       expect(query_param).to have_error(:invalid_float).on :default_value
 
        query_param.default_value = ","
-       query_param.should have_error(:invalid_float).on :default_value
+       expect(query_param).to have_error(:invalid_float).on :default_value
 
        query_param.default_value = "1,0"
-       query_param.should have_error(:invalid_float).on :default_value
+       expect(query_param).to have_error(:invalid_float).on :default_value
 
        query_param.default_value = "0,0"
-       query_param.should have_error(:invalid_float).on :default_value
+       expect(query_param).to have_error(:invalid_float).on :default_value
 
        query_param.default_value = "0,1"
-       query_param.should have_error(:invalid_float).on :default_value
+       expect(query_param).to have_error(:invalid_float).on :default_value
 
        query_param.default_value = "1,000"
-       query_param.should have_error(:invalid_float).on :default_value
+       expect(query_param).to have_error(:invalid_float).on :default_value
      end
 
      it "show an time error on default_value" do
        query_param.value_type = "Time"
 
        query_param.default_value = " "
-       query_param.should have_error(:invalid_time).on :default_value
+       expect(query_param).to have_error(:invalid_time).on :default_value
 
        query_param.default_value = "a"
-       query_param.should have_error(:invalid_time).on :default_value
+       expect(query_param).to have_error(:invalid_time).on :default_value
 
        query_param.default_value = "1"
-       query_param.should have_error(:invalid_time).on :default_value
+       expect(query_param).to have_error(:invalid_time).on :default_value
 
        query_param.default_value = "24:01"
-       query_param.should have_error(:invalid_time).on :default_value
+       expect(query_param).to have_error(:invalid_time).on :default_value
 
        query_param.default_value = "25:00"
-       query_param.should have_error(:invalid_time).on :default_value
+       expect(query_param).to have_error(:invalid_time).on :default_value
 
        query_param.default_value = "22:60"
-       query_param.should have_error(:invalid_time).on :default_value
+       expect(query_param).to have_error(:invalid_time).on :default_value
 
        query_param.default_value = "22:50:61"
-       query_param.should have_error(:invalid_time).on :default_value
+       expect(query_param).to have_error(:invalid_time).on :default_value
      end
 
      it "show an date error on default_value" do
        query_param.value_type = "Date"
 
        query_param.default_value = " "
-       query_param.should have_error(:invalid_date).on :default_value
+       expect(query_param).to have_error(:invalid_date).on :default_value
 
        query_param.default_value = "a"
-       query_param.should have_error(:invalid_date).on :default_value
+       expect(query_param).to have_error(:invalid_date).on :default_value
 
        query_param.default_value = "1"
-       query_param.should have_error(:invalid_date).on :default_value
+       expect(query_param).to have_error(:invalid_date).on :default_value
 
        query_param.default_value = "32/12/2019"
-       query_param.should have_error(:invalid_date).on :default_value
+       expect(query_param).to have_error(:invalid_date).on :default_value
 
        query_param.default_value = "30/13/2019"
-       query_param.should have_error(:invalid_date).on :default_value
+       expect(query_param).to have_error(:invalid_date).on :default_value
 
        query_param.default_value = "29/02/2019"
-       query_param.should have_error(:invalid_date).on :default_value
+       expect(query_param).to have_error(:invalid_date).on :default_value
 
        query_param.default_value = "20193112"
-       query_param.should have_error(:invalid_date).on :default_value
+       expect(query_param).to have_error(:invalid_date).on :default_value
      end
 
      it "show an date_time error on default_value" do
        query_param.value_type = "DateTime"
 
        query_param.default_value = " "
-       query_param.should have_error(:invalid_date_time).on :default_value
+       expect(query_param).to have_error(:invalid_date_time).on :default_value
 
        query_param.default_value = "a"
-       query_param.should have_error(:invalid_date_time).on :default_value
+       expect(query_param).to have_error(:invalid_date_time).on :default_value
 
        query_param.default_value = "1"
-       query_param.should have_error(:invalid_date_time).on :default_value
+       expect(query_param).to have_error(:invalid_date_time).on :default_value
 
        query_param.default_value = "32/10/2010 20:21:22"
-       query_param.should have_error(:invalid_date_time).on :default_value
+       expect(query_param).to have_error(:invalid_date_time).on :default_value
 
        query_param.default_value = "30/13/2010 20:21:22"
-       query_param.should have_error(:invalid_date_time).on :default_value
+       expect(query_param).to have_error(:invalid_date_time).on :default_value
 
        query_param.default_value = "15/12/2010 24:21:22"
-       query_param.should have_error(:invalid_date_time).on :default_value
+       expect(query_param).to have_error(:invalid_date_time).on :default_value
 
        query_param.default_value = "15/12/2010 23:60:22"
-       query_param.should have_error(:invalid_date_time).on :default_value
+       expect(query_param).to have_error(:invalid_date_time).on :default_value
 
        query_param.default_value = "15/12/2010 23:30:61"
-       query_param.should have_error(:invalid_date_time).on :default_value
+       expect(query_param).to have_error(:invalid_date_time).on :default_value
      end
 
     end
@@ -279,153 +279,153 @@
         query_param.value_type = "String"
        
 	query_param.default_value = " "
-        query_param.should have(0).errors_on :default_value	
+        expect(query_param).to have(0).errors_on :default_value	
 
         query_param.default_value = " Qualquer String 1234 "
-        query_param.should have(0).errors_on :default_value
+        expect(query_param).to have(0).errors_on :default_value
 
         query_param.value_type = "Literal"
        
 	query_param.default_value = " "
-        query_param.should have(0).errors_on :default_value	
+        expect(query_param).to have(0).errors_on :default_value	
 
         query_param.default_value = " Qualquer Literal 1234 "
-        query_param.should have(0).errors_on :default_value
+        expect(query_param).to have(0).errors_on :default_value
 
 	query_param.value_type = "List"
 
 	query_param.default_value = " "
-        query_param.should have(0).errors_on :default_value
+        expect(query_param).to have(0).errors_on :default_value
 
         query_param.default_value = " Qualquer String para lista 1234 ,, ,,, ,a,b,123, "
-        query_param.should have(0).errors_on :default_value
+        expect(query_param).to have(0).errors_on :default_value
 
 	query_param.value_type = "Integer"
 
 	query_param.default_value = "0"
-        query_param.should have(0).errors_on :default_value
+        expect(query_param).to have(0).errors_on :default_value
 
         query_param.default_value = "+0"
-        query_param.should have(0).errors_on :default_value
+        expect(query_param).to have(0).errors_on :default_value
 
 	query_param.default_value = "-0"
-        query_param.should have(0).errors_on :default_value
+        expect(query_param).to have(0).errors_on :default_value
 
 	query_param.default_value = "01"
-        query_param.should have(0).errors_on :default_value
+        expect(query_param).to have(0).errors_on :default_value
 
 	query_param.default_value = "1"
-        query_param.should have(0).errors_on :default_value
+        expect(query_param).to have(0).errors_on :default_value
 
 	query_param.default_value = "-1"
-        query_param.should have(0).errors_on :default_value
+        expect(query_param).to have(0).errors_on :default_value
 
 	query_param.default_value = "+1"
-        query_param.should have(0).errors_on :default_value
+        expect(query_param).to have(0).errors_on :default_value
 
 	query_param.default_value = "99999999"
-        query_param.should have(0).errors_on :default_value
+        expect(query_param).to have(0).errors_on :default_value
 
 	query_param.default_value = "-99999999"
-        query_param.should have(0).errors_on :default_value
+        expect(query_param).to have(0).errors_on :default_value
 
         query_param.value_type = "Float"
        
 	query_param.default_value = "0"
-        query_param.should have(0).errors_on :default_value	
+        expect(query_param).to have(0).errors_on :default_value	
 
         query_param.default_value = "+0"
-        query_param.should have(0).errors_on :default_value
+        expect(query_param).to have(0).errors_on :default_value
 
 	query_param.default_value = "-0"
-        query_param.should have(0).errors_on :default_value
+        expect(query_param).to have(0).errors_on :default_value
 
 	query_param.default_value = "1"
-        query_param.should have(0).errors_on :default_value
+        expect(query_param).to have(0).errors_on :default_value
 
 	query_param.default_value = "-1"
-        query_param.should have(0).errors_on :default_value
+        expect(query_param).to have(0).errors_on :default_value
 
 	query_param.default_value = "+1"
-        query_param.should have(0).errors_on :default_value
+        expect(query_param).to have(0).errors_on :default_value
 
 	query_param.default_value = ".0"
-        query_param.should have(0).errors_on :default_value
+        expect(query_param).to have(0).errors_on :default_value
 
 	query_param.default_value = ".1"
-        query_param.should have(0).errors_on :default_value
+        expect(query_param).to have(0).errors_on :default_value
 
 	query_param.default_value = "-.0"
-        query_param.should have(0).errors_on :default_value
+        expect(query_param).to have(0).errors_on :default_value
 
 	query_param.default_value = "-.1"
-        query_param.should have(0).errors_on :default_value
+        expect(query_param).to have(0).errors_on :default_value
 
 	query_param.default_value = "0.0"
-        query_param.should have(0).errors_on :default_value
+        expect(query_param).to have(0).errors_on :default_value
 
 	query_param.default_value = "0.1"
-        query_param.should have(0).errors_on :default_value
+        expect(query_param).to have(0).errors_on :default_value
 
 	query_param.default_value = "10.01"
-        query_param.should have(0).errors_on :default_value
+        expect(query_param).to have(0).errors_on :default_value
 
 	query_param.default_value = "-10.01"
-        query_param.should have(0).errors_on :default_value
+        expect(query_param).to have(0).errors_on :default_value
 
 	query_param.default_value = "9999.9999"
-        query_param.should have(0).errors_on :default_value
+        expect(query_param).to have(0).errors_on :default_value
 
 	query_param.default_value = "-9999.9999"
-        query_param.should have(0).errors_on :default_value
+        expect(query_param).to have(0).errors_on :default_value
 
 	query_param.default_value = "+9999.9999"
-        query_param.should have(0).errors_on :default_value
+        expect(query_param).to have(0).errors_on :default_value
 
         query_param.value_type = "Time"
        
 	query_param.default_value = "11:50"
-        query_param.should have(0).errors_on :default_value	
+        expect(query_param).to have(0).errors_on :default_value	
 
         query_param.default_value = "11:50:30"
-        query_param.should have(0).errors_on :default_value
+        expect(query_param).to have(0).errors_on :default_value
 
 	query_param.default_value = "23:59:59"
-        query_param.should have(0).errors_on :default_value
+        expect(query_param).to have(0).errors_on :default_value
 
 	query_param.default_value = "23:59"
-        query_param.should have(0).errors_on :default_value
+        expect(query_param).to have(0).errors_on :default_value
 	
         query_param.value_type = "Date"
 
 	query_param.default_value = "31/12/2019"
-        query_param.should have(0).errors_on :default_value
+        expect(query_param).to have(0).errors_on :default_value
 
         query_param.default_value = "31-12-2019"
-        query_param.should have(0).errors_on :default_value
+        expect(query_param).to have(0).errors_on :default_value
 
 	query_param.default_value = "20191231"
-        query_param.should have(0).errors_on :default_value
+        expect(query_param).to have(0).errors_on :default_value
 
 	query_param.default_value = "29/02/2020"
-        query_param.should have(0).errors_on :default_value
+        expect(query_param).to have(0).errors_on :default_value
 
         query_param.value_type = "DateTime"
        
 	query_param.default_value = "31/12/2018 10:11"
-        query_param.should have(0).errors_on :default_value	
+        expect(query_param).to have(0).errors_on :default_value	
 
         query_param.default_value = "31/12/2018-10:11"
-        query_param.should have(0).errors_on :default_value
+        expect(query_param).to have(0).errors_on :default_value
 
 	query_param.default_value = "31/12/2018;10:11"
-        query_param.should have(0).errors_on :default_value
+        expect(query_param).to have(0).errors_on :default_value
 
 	query_param.default_value = "31/12/2018 10:11:53"
-        query_param.should have(0).errors_on :default_value
+        expect(query_param).to have(0).errors_on :default_value
 
 	query_param.default_value = "20191225202122"
-        query_param.should have(0).errors_on :default_value
+        expect(query_param).to have(0).errors_on :default_value
       end	      
     end
 
diff --git a/spec/models/query_spec.rb b/spec/models/query_spec.rb
index e8f53d84..61057065 100644
--- a/spec/models/query_spec.rb
+++ b/spec/models/query_spec.rb
@@ -13,13 +13,13 @@
     context "name is blank" do
       it "show an blank error on name" do
 	query.name = nil     
-        query.should have_error(:blank).on :name
+        expect(query).to have_error(:blank).on :name
       end
     end
     context "sql is blank" do
       it "show an blank error on sql" do
         query.sql = ""      
-        query.should have_error(:blank).on :sql
+        expect(query).to have_error(:blank).on :sql
       end
     end
   end
diff --git a/spec/models/research_area_spec.rb b/spec/models/research_area_spec.rb
index 477e1a4e..b79ea49d 100644
--- a/spec/models/research_area_spec.rb
+++ b/spec/models/research_area_spec.rb
@@ -15,13 +15,13 @@
       context "should be valid when" do
         it "name is not null and is not taken" do
           research_area.name = "ResearchArea name"
-          research_area.should have(0).errors_on :name
+          expect(research_area).to have(0).errors_on :name
         end
       end
       context "should have error blank when" do
         it "name is null" do
           research_area.name = nil
-          research_area.should have_error(:blank).on :name
+          expect(research_area).to have_error(:blank).on :name
         end
       end
       context "should have error taken when" do
@@ -29,7 +29,7 @@
           name = "ResearchArea name"
           FactoryGirl.create(:research_area, :name => name)
           research_area.name = name
-          research_area.should have_error(:taken).on :name
+          expect(research_area).to have_error(:taken).on :name
         end
       end
     end
@@ -37,13 +37,13 @@
       context "should be valid when" do
         it "code is not null and is not taken" do
           research_area.code = "ResearchArea code"
-          research_area.should have(0).errors_on :code
+          expect(research_area).to have(0).errors_on :code
         end
       end
       context "should have error blank when" do
         it "code is null" do
           research_area.code = nil
-          research_area.should have_error(:blank).on :code
+          expect(research_area).to have_error(:blank).on :code
         end
       end
       context "should have error taken when" do
@@ -51,7 +51,7 @@
           code = "ResearchArea code"
           FactoryGirl.create(:research_area, :code => code)
           research_area.code = code
-          research_area.should have_error(:taken).on :code
+          expect(research_area).to have_error(:taken).on :code
         end
       end
     end
@@ -64,7 +64,7 @@
         research_area.code = research_area_code
         research_area.name = research_area_name
         expected = "#{research_area_code} - #{research_area_name}"
-        research_area.to_label.should eql(expected)
+        expect(research_area.to_label).to eql(expected)
       end
     end
   end
diff --git a/spec/models/scholarship_duration_spec.rb b/spec/models/scholarship_duration_spec.rb
index e7b1d22a..a1b20892 100644
--- a/spec/models/scholarship_duration_spec.rb
+++ b/spec/models/scholarship_duration_spec.rb
@@ -14,7 +14,7 @@
       context "should be valid when" do
         it "scholarship is not null" do
           scholarship_duration.scholarship = Scholarship.new
-          scholarship_duration.should have(0).errors_on :scholarship
+          expect(scholarship_duration).to have(0).errors_on :scholarship
         end
       end
     end
@@ -23,7 +23,7 @@
         it "enrollment is not null and scholarship is not with another student" do
           scholarship_duration.scholarship = FactoryGirl.create(:scholarship)
           scholarship_duration.enrollment = Enrollment.new
-          scholarship_duration.should have(0).errors_on :enrollment
+          expect(scholarship_duration).to have(0).errors_on :enrollment
         end
       end
       context "should have error taken when" do
@@ -37,7 +37,7 @@
           scholarship_duration.start_date = start_date
           scholarship_duration.end_date = end_date
 
-          scholarship_duration.should have_error(:enrollment_and_scholarship_uniqueness).on :enrollment_id
+          expect(scholarship_duration).to have_error(:enrollment_and_scholarship_uniqueness).on :enrollment_id
         end
       end
     end
@@ -50,7 +50,7 @@
           scholarship_duration.scholarship = scholarship
           scholarship_duration.start_date = start_date + 1.day
           scholarship_duration.end_date = end_date
-          scholarship_duration.should have(0).errors_on :start_date
+          expect(scholarship_duration).to have(0).errors_on :start_date
         end
         it "is before scholarship end date" do
           enrollment = FactoryGirl.create(:enrollment)
@@ -59,7 +59,7 @@
           scholarship_duration.scholarship = scholarship
           scholarship_duration.start_date = end_date - 2.day
           scholarship_duration.end_date = end_date - 1.day
-          scholarship_duration.should have(0).errors_on :start_date
+          expect(scholarship_duration).to have(0).errors_on :start_date
         end
       end
     end
@@ -73,7 +73,7 @@
           scholarship_duration.start_date = scholarship.start_date
           scholarship_duration.end_date = scholarship.end_date + 1.day
           scholarship_duration.cancel_date = scholarship.end_date
-          scholarship_duration.should have(0).errors_on :end_date
+          expect(scholarship_duration).to have(0).errors_on :end_date
         end
       end
     end
@@ -88,7 +88,7 @@
           scholarship_duration.start_date = end_date
           scholarship_duration.end_date = end_date + 5.days
           scholarship_duration.enrollment = enrollment
-          scholarship_duration.should have_error(:start_date_before_scholarship_end_date).on :start_date
+          expect(scholarship_duration).to have_error(:start_date_before_scholarship_end_date).on :start_date
         end
 
         it "has an old scholarship that was canceled after the new scholarship starts" do
@@ -100,7 +100,7 @@
           scholarship_duration.start_date = end_date
           scholarship_duration.end_date = end_date + 5.days
           scholarship_duration.enrollment = enrollment
-          scholarship_duration.should have_error(:start_date_before_scholarship_cancel_date).on :start_date
+          expect(scholarship_duration).to have_error(:start_date_before_scholarship_cancel_date).on :start_date
         end
         it "has an new scholarship that starts before the scholarship ends" do
           enrollment = FactoryGirl.create(:enrollment)
@@ -111,7 +111,7 @@
           scholarship_duration.start_date = start_date
           scholarship_duration.end_date = end_date + 1.day
           scholarship_duration.enrollment = enrollment
-          scholarship_duration.should have_error(:scholarship_start_date_after_end_or_cancel_date).on :end_date
+          expect(scholarship_duration).to have_error(:scholarship_start_date_after_end_or_cancel_date).on :end_date
         end
 
         it "has an new scholarship that is canceled before the scholarship ends" do
@@ -124,7 +124,7 @@
           scholarship_duration.end_date = end_date + 2.days
           scholarship_duration.cancel_date = end_date + 1.day
           scholarship_duration.enrollment = enrollment
-          scholarship_duration.should have_error(:scholarship_start_date_after_end_or_cancel_date).on :cancel_date
+          expect(scholarship_duration).to have_error(:scholarship_start_date_after_end_or_cancel_date).on :cancel_date
         end
 
       end
@@ -143,7 +143,7 @@
           scholarship_duration.start_date = end_date
           scholarship_duration.end_date = end_date + 5.days
           scholarship_duration.enrollment = enrollment
-          scholarship_duration.student_has_other_scholarship_duration.should be_truthy
+          expect(scholarship_duration.student_has_other_scholarship_duration).to be_truthy
         end
         it "has an old scholarship that was canceled after the new scholarship starts" do
           enrollment = FactoryGirl.create(:enrollment)
@@ -154,7 +154,7 @@
           scholarship_duration.start_date = end_date
           scholarship_duration.end_date = end_date + 5.days
           scholarship_duration.enrollment = enrollment
-          scholarship_duration.student_has_other_scholarship_duration.should be_truthy
+          expect(scholarship_duration.student_has_other_scholarship_duration).to be_truthy
         end
         it "has an new scholarship that starts before the scholarship ends" do
           enrollment = FactoryGirl.create(:enrollment)
@@ -165,7 +165,7 @@
           scholarship_duration.start_date = start_date
           scholarship_duration.end_date = end_date + 1.day
           scholarship_duration.enrollment = enrollment
-          scholarship_duration.student_has_other_scholarship_duration.should be_truthy
+          expect(scholarship_duration.student_has_other_scholarship_duration).to be_truthy
         end
 
         it "has an new scholarship that is canceled before the scholarship ends" do
@@ -178,7 +178,7 @@
           scholarship_duration.end_date = end_date + 2.days
           scholarship_duration.cancel_date = end_date + 1.day
           scholarship_duration.enrollment = enrollment
-          scholarship_duration.student_has_other_scholarship_duration.should be_truthy
+          expect(scholarship_duration.student_has_other_scholarship_duration).to be_truthy
         end
       end
     end
@@ -186,7 +186,7 @@
       it "should return the expected string" do
         scholarship_duration.start_date = start_date
         scholarship_duration.end_date = end_date
-        scholarship_duration.to_label.should eql("#{I18n.localize(start_date, :format => :monthyear)} - #{I18n.localize(end_date, :format => :monthyear)}")
+        expect(scholarship_duration.to_label).to eql("#{I18n.localize(start_date, :format => :monthyear)} - #{I18n.localize(end_date, :format => :monthyear)}")
       end
     end
 
@@ -201,7 +201,7 @@
         scholarship_duration.end_date = end_date + 5.days
         #scholarship_duration.cancel_date = end_date + 1.day
         scholarship_duration.enrollment = enrollment
-        scholarship_duration.warning_message.should be_nil
+        expect(scholarship_duration.warning_message).to be_nil
       end
 
       it "should return unfinished scholarship warning when there is an unfinished scholarship" do
@@ -214,7 +214,7 @@
         scholarship_duration.end_date = end_date + 5.days
         #scholarship_duration.cancel_date = end_date + 1.day
         scholarship_duration.enrollment = enrollment
-        scholarship_duration.warning_message.should == I18n.t("activerecord.errors.models.scholarship_duration.unfinished_scholarship")
+        expect(scholarship_duration.warning_message).to  eq(I18n.t("activerecord.errors.models.scholarship_duration.unfinished_scholarship"))
       end
     end
 
@@ -226,12 +226,12 @@
 
       it 'should return end_date.end_of_month if there is no cancel_date' do
         scholarship_duration = FactoryGirl.create(:scholarship_duration, :start_date => end_date, :end_date => end_date + 2.months, :cancel_date => nil, :scholarship => @scholarship)
-        scholarship_duration.last_date.should == (end_date + 2.months).end_of_month
+        expect(scholarship_duration.last_date).to eq((end_date + 2.months).end_of_month)
       end
 
       it 'should return cancel_date.end_of_month if there is a cancel_date' do
         scholarship_duration = FactoryGirl.create(:scholarship_duration, :start_date => end_date, :end_date => end_date + 2.months, :cancel_date => end_date + 1.months, :scholarship => @scholarship)
-        scholarship_duration.last_date.should == (end_date + 1.months).end_of_month
+        expect(scholarship_duration.last_date).to eq((end_date + 1.months).end_of_month)
       end
     end
 
@@ -242,17 +242,17 @@
 
       it 'should return false if there is no cancel_date' do
         scholarship_duration = FactoryGirl.create(:scholarship_duration, :start_date => end_date, :end_date => end_date + 2.months, :cancel_date => nil, :scholarship => @scholarship)
-        scholarship_duration.was_cancelled?.should == false
+        expect(scholarship_duration.was_cancelled?).to eq(false)
       end
 
       it 'should return false if cancel_date == end_date' do
         scholarship_duration = FactoryGirl.create(:scholarship_duration, :start_date => end_date, :end_date => end_date + 2.months, :cancel_date => end_date + 2.months, :scholarship => @scholarship)
-        scholarship_duration.was_cancelled?.should == false
+        expect(scholarship_duration.was_cancelled?).to eq(false)
       end
 
       it 'should return true if cancel_date != end_date' do
         scholarship_duration = FactoryGirl.create(:scholarship_duration, :start_date => end_date, :end_date => end_date + 2.months, :cancel_date => end_date + 1.months, :scholarship => @scholarship)
-        scholarship_duration.was_cancelled?.should == true
+        expect(scholarship_duration.was_cancelled?).to eq(true)
       end      
     end
     describe 'active?' do
@@ -262,23 +262,23 @@
 
       it 'should return false if date is after end_date' do
         scholarship_duration = FactoryGirl.create(:scholarship_duration, :start_date => end_date, :end_date => end_date + 2.months, :cancel_date => nil, :scholarship => @scholarship)
-        scholarship_duration.active?(:date => end_date + 4.months).should == false
+        expect(scholarship_duration.active?(:date => end_date + 4.months)).to eq(false)
       end
 
       it 'should return false if date is in the month of cancel_date' do
         scholarship_duration = FactoryGirl.create(:scholarship_duration, :start_date => end_date, :end_date => end_date + 2.months, :cancel_date => end_date + 2.months, :scholarship => @scholarship)
-        scholarship_duration.active?(:date => scholarship_duration.cancel_date - 1.day).should == false
+        expect(scholarship_duration.active?(:date => scholarship_duration.cancel_date - 1.day)).to eq(false)
       end
 
       it 'should return false if date < start_date' do
         scholarship_duration = FactoryGirl.create(:scholarship_duration, :start_date => end_date, :end_date => end_date + 2.months, :cancel_date => end_date + 2.months, :scholarship => @scholarship)
-        scholarship_duration.active?(:date => end_date - 1.month).should == false
+        expect(scholarship_duration.active?(:date => end_date - 1.month)).to eq(false)
       end
 
 
       it 'should return true if date < cancel_date' do
         scholarship_duration = FactoryGirl.create(:scholarship_duration, :start_date => end_date, :end_date => end_date + 2.months, :cancel_date => end_date + 1.months, :scholarship => @scholarship)
-        scholarship_duration.active?(:date => end_date.end_of_month).should == true
+        expect(scholarship_duration.active?(:date => end_date.end_of_month)).to eq(true)
       end      
     end
   end
diff --git a/spec/models/scholarship_spec.rb b/spec/models/scholarship_spec.rb
index f2c525b6..4819d9d0 100644
--- a/spec/models/scholarship_spec.rb
+++ b/spec/models/scholarship_spec.rb
@@ -14,13 +14,13 @@
       context "should be valid when" do
         it "level is not null" do
           scholarship.level = Level.new
-          scholarship.should have(0).errors_on :level
+          expect(scholarship).to have(0).errors_on :level
         end
       end
       context "should have error blank when" do
         it "level is null" do
           scholarship.level = nil
-          scholarship.should have_error(:blank).on :level
+          expect(scholarship).to have_error(:blank).on :level
         end
       end
     end
@@ -28,13 +28,13 @@
       context "should be valid when" do
         it "sponsor is not null" do
           scholarship.sponsor = Sponsor.new
-          scholarship.should have(0).errors_on :sponsor
+          expect(scholarship).to have(0).errors_on :sponsor
         end
       end
       context "should have error blank when" do
         it "sponsor is null" do
           scholarship.sponsor = nil
-          scholarship.should have_error(:blank).on :sponsor
+          expect(scholarship).to have_error(:blank).on :sponsor
         end
       end
     end
@@ -76,14 +76,14 @@
         it "end_date is greater than start_date" do
           scholarship.end_date = Date.today
           scholarship.start_date = 1.day.ago
-          scholarship.should have(0).errors_on :end_date
+          expect(scholarship).to have(0).errors_on :end_date
         end
       end
       context "should have error on_or_after when" do
         it "start_date is greater than end_date" do
           scholarship.start_date = 2.days.from_now
           scholarship.end_date = 2.days.ago
-          scholarship.should have_error(:on_or_after).on :end_date
+          expect(scholarship).to have_error(:on_or_after).on :end_date
         end
       end
     end
@@ -91,13 +91,13 @@
       context "should be valid when" do
         it "scholarship_number is not null and is not taken" do
           scholarship.scholarship_number = "M123"
-          scholarship.should have(0).errors_on :scholarship_number
+          expect(scholarship).to have(0).errors_on :scholarship_number
         end
       end
       context "should have error blank when" do
         it "scholarship_number is null" do
           scholarship.scholarship_number = nil
-          scholarship.should have_error(:blank).on :scholarship_number
+          expect(scholarship).to have_error(:blank).on :scholarship_number
         end
       end
       context "should have error taken when" do
@@ -105,7 +105,7 @@
           scholarship_number = "D123"
           FactoryGirl.create(:scholarship, :scholarship_number => scholarship_number)
           scholarship.scholarship_number = scholarship_number
-          scholarship.should have_error(:taken).on :scholarship_number
+          expect(scholarship).to have_error(:taken).on :scholarship_number
         end
       end
     end
@@ -115,7 +115,7 @@
       it "should return the expected string" do
         scholarship_number = 123
         scholarship.scholarship_number = scholarship_number
-        scholarship.to_label.should eql("#{scholarship_number}")
+        expect(scholarship.to_label).to eql("#{scholarship_number}")
       end
     end
 
@@ -124,12 +124,12 @@
 
       it 'should return end_date.end_of_month if there is end_date' do
         scholarship = FactoryGirl.create(:scholarship, :start_date => end_date, :end_date => end_date + 2.months)
-        scholarship.last_date.should == (end_date + 2.months).end_of_month
+        expect(scholarship.last_date).to eq((end_date + 2.months).end_of_month)
       end
 
       it 'should be greater or equal to 100 years if there is no end_date' do
         scholarship = FactoryGirl.create(:scholarship, :start_date => end_date, :end_date => nil)
-        scholarship.last_date.should >= Date.today + 100.years - 1.day
+        expect(scholarship.last_date).to be >= Date.today + 100.years - 1.day
       end
     end
   end
diff --git a/spec/models/scholarship_suspension_spec.rb b/spec/models/scholarship_suspension_spec.rb
index 0f248529..42ea3cd3 100644
--- a/spec/models/scholarship_suspension_spec.rb
+++ b/spec/models/scholarship_suspension_spec.rb
@@ -14,13 +14,13 @@
       context "should be valid when" do
         it "scholarship_duration is not null" do
           scholarship_suspension.scholarship_duration = ScholarshipDuration.new
-          scholarship_suspension.should have(0).errors_on :scholarship_duration
+          expect(scholarship_suspension).to have(0).errors_on :scholarship_duration
         end
       end
       context "should have error when" do
         it "scholarship_duration is null" do
           scholarship_suspension.scholarship_duration = nil
-          scholarship_suspension.should have_error(:blank).on :scholarship_duration
+          expect(scholarship_suspension).to have_error(:blank).on :scholarship_duration
         end
       end
     end
@@ -31,21 +31,21 @@
           scholarship_suspension.scholarship_duration = scholarship_duration
           scholarship_suspension.start_date = scholarship_duration.start_date + 1.day
           scholarship_suspension.end_date = scholarship_duration.end_date
-          scholarship_suspension.should have(0).errors_on :start_date
+          expect(scholarship_suspension).to have(0).errors_on :start_date
         end
         it "is before scholarship_duration end date" do
           scholarship_duration = FactoryGirl.create(:scholarship_duration)
           scholarship_suspension.scholarship_duration = scholarship_duration
           scholarship_suspension.start_date = scholarship_duration.end_date - 1.day
           scholarship_suspension.end_date = scholarship_duration.end_date
-          scholarship_suspension.should have(0).errors_on :start_date
+          expect(scholarship_suspension).to have(0).errors_on :start_date
         end
         it "is before end date" do
           scholarship_duration = FactoryGirl.create(:scholarship_duration)
           scholarship_suspension.scholarship_duration = scholarship_duration
           scholarship_suspension.start_date = scholarship_duration.end_date - 1.day
           scholarship_suspension.end_date = scholarship_duration.end_date
-          scholarship_suspension.should have(0).errors_on :start_date
+          expect(scholarship_suspension).to have(0).errors_on :start_date
         end
       end
       context "should have error when" do
@@ -54,25 +54,25 @@
           scholarship_suspension.scholarship_duration = scholarship_duration
           scholarship_suspension.start_date = scholarship_duration.start_date - 1.day
           scholarship_suspension.end_date = scholarship_duration.end_date
-          scholarship_suspension.should have_error(:suspension_start_date_before_scholarship_start_date).on :start_date
+          expect(scholarship_suspension).to have_error(:suspension_start_date_before_scholarship_start_date).on :start_date
         end
         it "is after scholarship_duration end date" do
           scholarship_duration = FactoryGirl.create(:scholarship_duration)
           scholarship_suspension.scholarship_duration = scholarship_duration
           scholarship_suspension.start_date = scholarship_duration.end_date + 1.day
           scholarship_suspension.end_date = scholarship_duration.end_date + 2.day
-          scholarship_suspension.should have_error(:suspension_start_date_after_scholarship_end_date).on :start_date
+          expect(scholarship_suspension).to have_error(:suspension_start_date_after_scholarship_end_date).on :start_date
         end
         it "is after end date" do
           scholarship_duration = FactoryGirl.create(:scholarship_duration)
           scholarship_suspension.scholarship_duration = scholarship_duration
           scholarship_suspension.start_date = scholarship_duration.end_date + 1.day
           scholarship_suspension.end_date = scholarship_duration.end_date
-          scholarship_suspension.should have_error(:suspension_start_date_after_end_date).on :start_date
+          expect(scholarship_suspension).to have_error(:suspension_start_date_after_end_date).on :start_date
         end
         it "is null" do
           scholarship_suspension.start_date =  nil
-          scholarship_suspension.should have_error(:blank).on :start_date
+          expect(scholarship_suspension).to have_error(:blank).on :start_date
         end
       end
     end
@@ -83,7 +83,7 @@
           scholarship_suspension.scholarship_duration = scholarship_duration
           scholarship_suspension.start_date = scholarship_duration.start_date
           scholarship_suspension.end_date = scholarship_duration.end_date - 1.day
-          scholarship_suspension.should have(0).errors_on :end_date
+          expect(scholarship_suspension).to have(0).errors_on :end_date
         end
       end
       context "should have error when" do
@@ -92,11 +92,11 @@
           scholarship_suspension.scholarship_duration = scholarship_duration
           scholarship_suspension.start_date = scholarship_duration.end_date - 1.day
           scholarship_suspension.end_date = scholarship_duration.end_date + 2.day
-          scholarship_suspension.should have_error(:suspension_end_date_after_scholarship_end_date).on :end_date
+          expect(scholarship_suspension).to have_error(:suspension_end_date_after_scholarship_end_date).on :end_date
         end
         it "is null" do
           scholarship_suspension.end_date =  nil
-          scholarship_suspension.should have_error(:blank).on :end_date
+          expect(scholarship_suspension).to have_error(:blank).on :end_date
         end
       end
     end
@@ -110,8 +110,8 @@
           scholarship_suspension.start_date = ss.start_date
           scholarship_suspension.end_date = ss.end_date
           scholarship_suspension.active = false
-          scholarship_suspension.valid?.should be_truthy
-          scholarship_suspension.errors.full_messages.should_not include(I18n.t("activerecord.errors.models.scholarship_suspension.active_suspension"))
+          expect(scholarship_suspension.valid?).to be_truthy
+          expect(scholarship_suspension.errors.full_messages).not_to include(I18n.t("activerecord.errors.models.scholarship_suspension.active_suspension"))
         end
       end
       context "should have error when" do
@@ -122,8 +122,8 @@
           scholarship_suspension.scholarship_duration = ss.scholarship_duration 
           scholarship_suspension.start_date = ss.start_date
           scholarship_suspension.end_date = ss.end_date
-          scholarship_suspension.valid?.should be_falsey
-          scholarship_suspension.errors.full_messages.should include(I18n.t("activerecord.errors.models.scholarship_suspension.active_suspension"))
+          expect(scholarship_suspension.valid?).to be_falsey
+          expect(scholarship_suspension.errors.full_messages).to include(I18n.t("activerecord.errors.models.scholarship_suspension.active_suspension"))
         end
       end
     end
@@ -134,7 +134,7 @@
         scholarship_suspension.start_date = start_date
         scholarship_suspension.end_date = end_date
         scholarship_suspension.active = true
-        scholarship_suspension.to_label.should eql("#{I18n.localize(start_date, :format => :monthyear)} - #{I18n.localize(end_date, :format => :monthyear)}: Bolsa Suspensa")
+        expect(scholarship_suspension.to_label).to eql("#{I18n.localize(start_date, :format => :monthyear)} - #{I18n.localize(end_date, :format => :monthyear)}: Bolsa Suspensa")
       end
       
     end
diff --git a/spec/models/scholarship_type_spec.rb b/spec/models/scholarship_type_spec.rb
index 27db1c02..61d4a2c7 100644
--- a/spec/models/scholarship_type_spec.rb
+++ b/spec/models/scholarship_type_spec.rb
@@ -14,13 +14,13 @@
       context "should be valid when" do
         it "name is not null and is not taken" do
           scholarship_type.name = "ScholarshipType name"
-          scholarship_type.should have(0).errors_on :name
+          expect(scholarship_type).to have(0).errors_on :name
         end
       end
       context "should have error blank when" do
         it "name is null" do
           scholarship_type.name = nil
-          scholarship_type.should have_error(:blank).on :name
+          expect(scholarship_type).to have_error(:blank).on :name
         end
       end
       context "should have error taken when" do
@@ -28,9 +28,9 @@
           name = "ScholarshipType name"
           FactoryGirl.create(:scholarship_type, :name => name)
           scholarship_type.name = name
-          scholarship_type.should have_error(:taken).on :name
+          expect(scholarship_type).to have_error(:taken).on :name
         end
       end
     end
   end
-end
\ No newline at end of file
+end
diff --git a/spec/models/sponsor_spec.rb b/spec/models/sponsor_spec.rb
index bb660e75..1c3ae016 100644
--- a/spec/models/sponsor_spec.rb
+++ b/spec/models/sponsor_spec.rb
@@ -14,13 +14,13 @@
       context "should be valid when" do
         it "name is not null and is not taken" do
           sponsor.name = "Sponsor name"
-          sponsor.should have(0).errors_on :name
+          expect(sponsor).to have(0).errors_on :name
         end
       end
       context "should have error blank when" do
         it "name is null" do
           sponsor.name = nil
-          sponsor.should have_error(:blank).on :name
+          expect(sponsor).to have_error(:blank).on :name
         end
       end
       context "should have error taken when" do
@@ -28,9 +28,9 @@
           name = "Sponsor name"
           FactoryGirl.create(:sponsor, :name => name)
           sponsor.name = name
-          sponsor.should have_error(:taken).on :name
+          expect(sponsor).to have_error(:taken).on :name
         end
       end
     end
   end
-end
\ No newline at end of file
+end
diff --git a/spec/models/state_spec.rb b/spec/models/state_spec.rb
index e180570f..6bef54fd 100644
--- a/spec/models/state_spec.rb
+++ b/spec/models/state_spec.rb
@@ -15,13 +15,13 @@
       context "should be valid when" do
         it "name is not null and is not taken" do
           state.name = "State name"
-          state.should have(0).errors_on :name
+          expect(state).to have(0).errors_on :name
         end
       end
       context "should have error blank when" do
         it "name is null" do
           state.name = nil
-          state.should have_error(:blank).on :name
+          expect(state).to have_error(:blank).on :name
         end
       end
       context "should have error taken when" do
@@ -29,7 +29,7 @@
           name = "State name"
           FactoryGirl.create(:state, :name => name)
           state.name = name
-          state.should have_error(:taken).on :name
+          expect(state).to have_error(:taken).on :name
         end
       end
     end
@@ -37,13 +37,13 @@
       context "should be valid when" do
         it "code is not null and is not taken" do
           state.code = "State code"
-          state.should have(0).errors_on :code
+          expect(state).to have(0).errors_on :code
         end
       end
       context "should have error blank when" do
         it "code is null" do
           state.code = nil
-          state.should have_error(:blank).on :code
+          expect(state).to have_error(:blank).on :code
         end
       end
       context "should have error taken when" do
@@ -51,7 +51,7 @@
           code = "State code"
           FactoryGirl.create(:state, :code => code)
           state.code = code
-          state.should have_error(:taken).on :code
+          expect(state).to have_error(:taken).on :code
         end
       end
     end
@@ -59,15 +59,15 @@
       context "should be valid when" do
         it "country is not null" do
           state.country = Country.new
-          state.should have(0).errors_on :country
+          expect(state).to have(0).errors_on :country
         end
       end
       context "should have error blank when" do
         it "country is null" do
           state.country = nil
-          state.should have_error(:blank).on :country
+          expect(state).to have_error(:blank).on :country
         end
       end
     end
   end
-end
\ No newline at end of file
+end
diff --git a/spec/models/string_time_delta_spec.rb b/spec/models/string_time_delta_spec.rb
index 4ed9e1d7..f566e841 100644
--- a/spec/models/string_time_delta_spec.rb
+++ b/spec/models/string_time_delta_spec.rb
@@ -7,59 +7,59 @@
 
   describe "multiply" do
     it ("should return 1 day if it is multiplying 1.day * 1") do
-      StringTimeDelta::multiply(1.day, 1).should == 1.day
+      expect(StringTimeDelta::multiply(1.day, 1)).to eq(1.day)
     end
 
     it ("should return 3 days if it is multiplying 1.day * 3") do
-      StringTimeDelta::multiply(1.day, 3).should == 3.days
+      expect(StringTimeDelta::multiply(1.day, 3)).to eq(3.days)
     end
 
     it ("should return -1 day if it is multiplying 1.day * -1") do
-      StringTimeDelta::multiply(1.day, -1).should == -1.day
+      expect(StringTimeDelta::multiply(1.day, -1)).to eq(-1.day)
     end
 
     it ("should return -3 days if it is multiplying 1.day * -3") do
-      StringTimeDelta::multiply(1.day, -3).should == -3.days
+      expect(StringTimeDelta::multiply(1.day, -3)).to eq(-3.days)
     end
 
     it ("should return 0 seconds if it is multiplying 1.day * 0") do
-      StringTimeDelta::multiply(1.day, 0).should == 0.seconds
+      expect(StringTimeDelta::multiply(1.day, 0)).to eq(0.seconds)
     end
   end
 
   describe "multiply" do
     it ("should return 1 second if it is parsing 1s") do
-      StringTimeDelta::parse("1s").should == 1.second
+      expect(StringTimeDelta::parse("1s")).to eq(1.second)
     end
 
     it ("should return 1 minute if it is parsing 1m") do
-      StringTimeDelta::parse("1m").should == 1.minute
+      expect(StringTimeDelta::parse("1m")).to eq(1.minute)
     end
 
     it ("should return 2 hours if it is parsing 2h") do
-      StringTimeDelta::parse("2h").should == 2.hours
+      expect(StringTimeDelta::parse("2h")).to eq(2.hours)
     end
 
     it ("should return 3 days if it is parsing 3d") do
-      StringTimeDelta::parse("3d").should == 3.days
+      expect(StringTimeDelta::parse("3d")).to eq(3.days)
     end
 
     it ("should return -1 week if it is parsing -1w") do
-      StringTimeDelta::parse("-1w").should == -1.week
+      expect(StringTimeDelta::parse("-1w")).to eq(-1.week)
     end
 
     it ("should return -3 months if it is parsing -3M") do
-      StringTimeDelta::parse("-3M").should == -3.months
+      expect(StringTimeDelta::parse("-3M")).to eq(-3.months)
     end
   
     it ("should return 1 year and 6 months if it is parsing 1y6M") do
-      StringTimeDelta::parse("1y6M").should == (1.year + 6.months)
+      expect(StringTimeDelta::parse("1y6M")).to eq((1.year + 6.months))
     end
 
     it ("should return 15 days if it is parsing 15") do
-      StringTimeDelta::parse("15").should == 15.days
+      expect(StringTimeDelta::parse("15")).to eq(15.days)
     end
 
   end
 
-end
\ No newline at end of file
+end
diff --git a/spec/models/student_major_spec.rb b/spec/models/student_major_spec.rb
index 0f677ee7..fe0942f9 100644
--- a/spec/models/student_major_spec.rb
+++ b/spec/models/student_major_spec.rb
@@ -11,13 +11,13 @@
       context "should be valid when" do
         it "student is not null" do
           student_major.student = Student.new
-          student_major.should have(0).errors_on :student
+          expect(student_major).to have(0).errors_on :student
         end
       end
       context "should have error blank when" do
         it "student is null" do
           student_major.student = nil
-          student_major.should have_error(:blank).on :student
+          expect(student_major).to have_error(:blank).on :student
         end
       end
     end
@@ -25,13 +25,13 @@
       context "should be valid when" do
         it "major is not null" do
           student_major.major = Major.new
-          student_major.should have(0).errors_on :major
+          expect(student_major).to have(0).errors_on :major
         end
       end
       context "should have error blank when" do
         it "major is null" do
           student_major.major = nil
-          student_major.should have_error(:blank).on :major
+          expect(student_major).to have_error(:blank).on :major
         end
       end
     end
@@ -40,7 +40,7 @@
       context "should be valid when" do
         it "don't exists the same student for the same major" do
           student_major.student = Student.new
-          student_major.should have(0).errors_on :student_id
+          expect(student_major).to have(0).errors_on :student_id
         end
       end
       context "should have uniqueness error when" do
@@ -48,7 +48,7 @@
           student_major.student = FactoryGirl.create(:student)
           student_major.major = FactoryGirl.create(:major)
           FactoryGirl.create(:student_major, :student => student_major.student, :major => student_major.major)
-          student_major.should have_error(:unique_pair).on :student_id
+          expect(student_major).to have_error(:unique_pair).on :student_id
         end
       end
     end
diff --git a/spec/models/student_spec.rb b/spec/models/student_spec.rb
index 4a6ce44e..3f1c9111 100644
--- a/spec/models/student_spec.rb
+++ b/spec/models/student_spec.rb
@@ -15,13 +15,13 @@
       context "should be valid when" do
         it "cpf is not null and is not taken" do
           student.cpf = "Student cpf"
-          student.should have(0).errors_on :cpf
+          expect(student).to have(0).errors_on :cpf
         end
       end
       context "should have error blank when" do
         it "cpf is null" do
           student.cpf = nil
-          student.should have_error(:blank).on :cpf
+          expect(student).to have_error(:blank).on :cpf
         end
       end
       context "should have error taken when" do
@@ -29,7 +29,7 @@
           cpf = "Student cpf"
           FactoryGirl.create(:student, :cpf => cpf)
           student.cpf = cpf
-          student.should have_error(:taken).on :cpf
+          expect(student).to have_error(:taken).on :cpf
         end
       end
     end
@@ -37,13 +37,13 @@
       context "should be valid when" do
         it "name is not null and is not taken" do
           student.name = "Student name"
-          student.should have(0).errors_on :name
+          expect(student).to have(0).errors_on :name
         end
       end
       context "should have error blank when" do
         it "name is null" do
           student.name = nil
-          student.should have_error(:blank).on :name
+          expect(student).to have_error(:blank).on :name
         end
       end
       end
@@ -53,14 +53,14 @@
       it "should return the enrollment number when the student has one enrollment" do
         student = FactoryGirl.create(:student)
         FactoryGirl.create(:enrollment, :enrollment_number => "M123", :student => student)
-        student.enrollments_number.should == "M123"
+        expect(student.enrollments_number).to eq("M123")
       end
 
       it "should return the enrollments number separated by comma when the student has two enrollments" do
         student = FactoryGirl.create(:student)
         FactoryGirl.create(:enrollment, :enrollment_number => "M123", :student => student)
         FactoryGirl.create(:enrollment, :enrollment_number => "D234", :student => student)
-        student.enrollments_number.should == "M123, D234"
+        expect(student.enrollments_number).to eq("M123, D234")
       end
     end
 
@@ -68,16 +68,16 @@
       it "should return country, when birth_city is specified" do
         city = FactoryGirl.create(:city)
         student = FactoryGirl.create(:student, :birth_city => city)
-        student.birthplace.should == "#{city.state.country.name}"
+        expect(student.birthplace).to eq("#{city.state.country.name}")
       end
       it "should return country, when birth_city is not specified" do
         state = FactoryGirl.create(:state)
         student = FactoryGirl.create(:student, :birth_state => state)
-        student.birthplace.should == "#{state.country.name}"
+        expect(student.birthplace).to eq("#{state.country.name}")
       end
       it "should return nil when neither birth_city and birth_state are specified" do
         student = FactoryGirl.create(:student)
-        student.birthplace.should be_nil
+        expect(student.birthplace).to be_nil
       end
     end
   end
@@ -87,19 +87,19 @@
       birth_state = FactoryGirl.create(:state)
       student = FactoryGirl.build(:student, :birth_state => birth_state, :birth_city => nil)
       student.birth_city = birth_city
-      student.birth_state.should == birth_state
+      expect(student.birth_state).to eq(birth_state)
 
       student.save
-      student.birth_state.should == birth_city.state
-      student.birth_state.should_not == birth_state
+      expect(student.birth_state).to eq(birth_city.state)
+      expect(student.birth_state).not_to eq(birth_state)
     end
 
     it "should not set the birth_state when birth_city is not filled" do
       birth_state = FactoryGirl.create(:state)
       student = FactoryGirl.build(:student, :birth_state => birth_state, :birth_city => nil)
-      student.birth_state.should == birth_state
+      expect(student.birth_state).to eq(birth_state)
       student.save
-      student.birth_state.should == birth_state
+      expect(student.birth_state).to eq(birth_state)
     end
   end
-end
\ No newline at end of file
+end
diff --git a/spec/models/thesis_defense_committee_participation_spec.rb b/spec/models/thesis_defense_committee_participation_spec.rb
index 9ed802d1..33f32637 100644
--- a/spec/models/thesis_defense_committee_participation_spec.rb
+++ b/spec/models/thesis_defense_committee_participation_spec.rb
@@ -11,13 +11,13 @@
       context "should be valid when" do
         it "enrollment is not null" do
           thesis_defense_committee_participation.enrollment = Enrollment.new
-          thesis_defense_committee_participation.should have(0).errors_on :enrollment
+          expect(thesis_defense_committee_participation).to have(0).errors_on :enrollment
         end
       end
       context "should have error blank when" do
         it "enrollment is null" do
           thesis_defense_committee_participation.enrollment = nil
-          thesis_defense_committee_participation.should have_error(:blank).on :enrollment
+          expect(thesis_defense_committee_participation).to have_error(:blank).on :enrollment
         end
       end
     end
@@ -25,13 +25,13 @@
       context "should be valid when" do
         it "professor is not null" do
           thesis_defense_committee_participation.professor = Professor.new
-          thesis_defense_committee_participation.should have(0).errors_on :professor
+          expect(thesis_defense_committee_participation).to have(0).errors_on :professor
         end
       end
       context "should have error blank when" do
         it "professor is null" do
           thesis_defense_committee_participation.professor = nil
-          thesis_defense_committee_participation.should have_error(:blank).on :professor
+          expect(thesis_defense_committee_participation).to have_error(:blank).on :professor
         end
       end
     end
@@ -40,7 +40,7 @@
       context "should be valid when" do
         it "don't exists another advisement for the same enrollment" do
           thesis_defense_committee_participation.professor = Professor.new
-          thesis_defense_committee_participation.should have(0).errors_on :professor_id
+          expect(thesis_defense_committee_participation).to have(0).errors_on :professor_id
         end
       end
       context "should have uniqueness error when" do
@@ -48,7 +48,7 @@
           thesis_defense_committee_participation.professor = FactoryGirl.create(:professor)
           thesis_defense_committee_participation.enrollment = FactoryGirl.create(:enrollment)
           FactoryGirl.create(:thesis_defense_committee_participation, :professor => thesis_defense_committee_participation.professor, :enrollment => thesis_defense_committee_participation.enrollment)
-          thesis_defense_committee_participation.should have_error(:thesis_defense_committee_participation_professor_uniqueness).on :professor_id
+          expect(thesis_defense_committee_participation).to have_error(:thesis_defense_committee_participation_professor_uniqueness).on :professor_id
         end
       end
     end
@@ -60,7 +60,7 @@
         professor_name = "professor"
         thesis_defense_committee_participation.enrollment = Enrollment.new(:enrollment_number => enrollment_number)
         thesis_defense_committee_participation.professor = Professor.new(:name => professor_name)
-        thesis_defense_committee_participation.to_label.should eql("#{enrollment_number} - #{professor_name}")
+        expect(thesis_defense_committee_participation.to_label).to eql("#{enrollment_number} - #{professor_name}")
       end
     end
   end
diff --git a/spec/models/user_spec.rb b/spec/models/user_spec.rb
index 911d5ff6..96a578fa 100644
--- a/spec/models/user_spec.rb
+++ b/spec/models/user_spec.rb
@@ -14,20 +14,20 @@
       context "should be valid when" do
         it "email is not null" do
           user.email = "Username"
-          user.should have(0).errors_on :email
+          expect(user).to have(0).errors_on :email
         end
       end
       context "should have error blank when" do
         it "email is null" do
           user.email = nil
-          user.should have_error(:blank).on :email
+          expect(user).to have_error(:blank).on :email
         end
       end
       context "should have error taken when" do
         it "email is already in use" do
           FactoryGirl.create(:user, :email => 'email@sapos.com')
           user.email = 'email@sapos.com'
-          user.should have_error(:taken).on :email
+          expect(user).to have_error(:taken).on :email
         end
       end
     end
@@ -35,13 +35,13 @@
       context "should be valid when" do
         it "name is not null and is unique" do
           user.name = "Username"
-          user.should have(0).errors_on :name
+          expect(user).to have(0).errors_on :name
         end
       end
       context "should have error blank when" do
         it "name is null" do
           user.name = nil
-          user.should have_error(:blank).on :name
+          expect(user).to have_error(:blank).on :name
         end
       end
       context "should have error taken when" do
@@ -49,7 +49,7 @@
           name = "Username"
           FactoryGirl.create(:user, :name => name)
           user.name = name
-          user.should have_error(:taken).on :name
+          expect(user).to have_error(:taken).on :name
         end
       end
     end
@@ -57,15 +57,15 @@
       context "should be valid when" do
         it "role is not null" do
           user.role = FactoryGirl.create(:role)
-          user.should have(0).errors_on :role
+          expect(user).to have(0).errors_on :role
         end
       end
       context "should have error blank when" do
         it "role is null" do
           user.role = nil
-          user.should have_error(:blank).on :role
+          expect(user).to have_error(:blank).on :role
         end
       end
     end
   end
-end
\ No newline at end of file
+end
diff --git a/spec/models/year_semester_spec.rb b/spec/models/year_semester_spec.rb
index 153c8317..b74d44d9 100644
--- a/spec/models/year_semester_spec.rb
+++ b/spec/models/year_semester_spec.rb
@@ -13,24 +13,24 @@
         it "date is between first semester begin and second semester begin" do
           date = Date.parse("#{current_year}/#{YearSemester::FIRST_SEMESTER_BEGIN_MONTH}/#{YearSemester::FIRST_SEMESTER_BEGIN_DAY + 1}")
           year_semester = YearSemester.on_date(date)
-          year_semester.semester.should eql(YearSemester::FIRST_SEMESTER)
-          year_semester.year.should eql(Date.today.year)
+          expect(year_semester.semester).to eql(YearSemester::FIRST_SEMESTER)
+          expect(year_semester.year).to eql(Date.today.year)
         end
       end
       context "should return the second semester of the current year when" do
         it "date is after second semester begin" do
           date = Date.parse("#{current_year}/#{YearSemester::SECOND_SEMESTER_BEGIN_MONTH}/#{YearSemester::SECOND_SEMESTER_BEGIN_DAY + 1}")
           year_semester = YearSemester.on_date(date)
-          year_semester.semester.should eql(YearSemester::SECOND_SEMESTER)
-          year_semester.year.should eql(current_year)
+          expect(year_semester.semester).to eql(YearSemester::SECOND_SEMESTER)
+          expect(year_semester.year).to eql(current_year)
         end
       end
       context "should return the second semester of the last year when" do
         it "date is before first semester begin" do
           date = Date.parse("#{current_year}/#{YearSemester::FIRST_SEMESTER_BEGIN_MONTH}/#{YearSemester::FIRST_SEMESTER_BEGIN_DAY}") - 1.day
           year_semester = YearSemester.on_date(date)
-          year_semester.semester.should eql(YearSemester::SECOND_SEMESTER)
-          year_semester.year.should eql(current_year - 1)
+          expect(year_semester.semester).to eql(YearSemester::SECOND_SEMESTER)
+          expect(year_semester.year).to eql(current_year - 1)
         end
       end
     end
@@ -40,7 +40,7 @@
           year_semester.year = current_year
           year_semester.semester = YearSemester::FIRST_SEMESTER
           date = Date.parse("#{current_year}/#{YearSemester::FIRST_SEMESTER_BEGIN_MONTH}/#{YearSemester::FIRST_SEMESTER_BEGIN_DAY}")
-          year_semester.semester_begin.should eql(date)
+          expect(year_semester.semester_begin).to eql(date)
         end
       end
       context "should return date of the second semester begin when" do
@@ -48,7 +48,7 @@
           year_semester.year = current_year
           year_semester.semester = YearSemester::SECOND_SEMESTER
           date = Date.parse("#{current_year}/#{YearSemester::SECOND_SEMESTER_BEGIN_MONTH}/#{YearSemester::SECOND_SEMESTER_BEGIN_DAY}")
-          year_semester.semester_begin.should eql(date)
+          expect(year_semester.semester_begin).to eql(date)
         end
       end
     end
@@ -57,7 +57,7 @@
         year_semester.year = current_year
         year_semester.semester = YearSemester::FIRST_SEMESTER
         date = Date.parse("#{current_year}/#{YearSemester::SECOND_SEMESTER_BEGIN_MONTH}/#{YearSemester::SECOND_SEMESTER_BEGIN_DAY}") - 1.day
-        year_semester.semester_end.should eql(date)
+        expect(year_semester.semester_end).to eql(date)
       end
     end
     describe "next_semester_start" do
@@ -66,13 +66,13 @@
           year_semester.year = current_year
           year_semester.semester = YearSemester::FIRST_SEMESTER
           date = Date.parse("#{current_year}/#{YearSemester::SECOND_SEMESTER_BEGIN_MONTH}/#{YearSemester::SECOND_SEMESTER_BEGIN_DAY}")
-          year_semester.next_semester_start.should eql(date)
+          expect(year_semester.next_semester_start).to eql(date)
         end
         it "semester is set to second semester" do
           year_semester.year = current_year
           year_semester.semester = YearSemester::SECOND_SEMESTER
           date = Date.parse("#{current_year + 1}/#{YearSemester::FIRST_SEMESTER_BEGIN_MONTH}/#{YearSemester::FIRST_SEMESTER_BEGIN_DAY}")
-          year_semester.next_semester_start.should eql(date)
+          expect(year_semester.next_semester_start).to eql(date)
         end
       end
     end
@@ -80,25 +80,25 @@
       it "should return the year semester on today's date" do
         year_semester = YearSemester.on_date(Date.today)
         current_year_semester = YearSemester.current
-        year_semester.semester.should eql(current_year_semester.semester)
-        year_semester.year.should eql(current_year_semester.year)
+        expect(year_semester.semester).to eql(current_year_semester.semester)
+        expect(year_semester.year).to eql(current_year_semester.year)
       end
     end
     describe "opposite_semester" do
       it "should return first semester when semester is set to second" do
         year_semester.semester = YearSemester::SECOND_SEMESTER
-        year_semester.opposite_semester.should eql(YearSemester::FIRST_SEMESTER)
+        expect(year_semester.opposite_semester).to eql(YearSemester::FIRST_SEMESTER)
       end
       it "should return second semester when semester is set to first" do
         year_semester.semester = YearSemester::FIRST_SEMESTER
-        year_semester.opposite_semester.should eql(YearSemester::SECOND_SEMESTER)
+        expect(year_semester.opposite_semester).to eql(YearSemester::SECOND_SEMESTER)
       end
     end
     describe "toggle_semester" do
       it "should switch to first semester when semester is set to second" do
         year_semester.semester = YearSemester::SECOND_SEMESTER
         year_semester.toggle_semester
-        year_semester.semester.should eql(YearSemester::FIRST_SEMESTER)
+        expect(year_semester.semester).to eql(YearSemester::FIRST_SEMESTER)
       end
     end
     describe "decrease_semesters" do
@@ -107,37 +107,37 @@
           year_semester.year = current_year
           year_semester.semester = YearSemester::FIRST_SEMESTER
           year_semester.decrease_semesters(2)
-          year_semester.semester.should eql(YearSemester::FIRST_SEMESTER)
-          year_semester.year.should eql(current_year - 1)
+          expect(year_semester.semester).to eql(YearSemester::FIRST_SEMESTER)
+          expect(year_semester.year).to eql(current_year - 1)
         end
         it "semester is set to first and the parameter is odd" do
           year_semester.year = current_year
           year_semester.semester = YearSemester::FIRST_SEMESTER
           year_semester.decrease_semesters(3)
-          year_semester.semester.should eql(YearSemester::SECOND_SEMESTER)
-          year_semester.year.should eql(current_year - 2)
+          expect(year_semester.semester).to eql(YearSemester::SECOND_SEMESTER)
+          expect(year_semester.year).to eql(current_year - 2)
         end
         it "semester is set to second and the parameter is even" do
           year_semester.year = current_year
           year_semester.semester = YearSemester::SECOND_SEMESTER
           year_semester.decrease_semesters(2)
-          year_semester.semester.should eql(YearSemester::SECOND_SEMESTER)
-          year_semester.year.should eql(current_year - 1)
+          expect(year_semester.semester).to eql(YearSemester::SECOND_SEMESTER)
+          expect(year_semester.year).to eql(current_year - 1)
         end
         it "semester is set to second and the parameter is odd" do
           year_semester.year = current_year
           year_semester.semester = YearSemester::SECOND_SEMESTER
           year_semester.decrease_semesters(3)
-          year_semester.semester.should eql(YearSemester::FIRST_SEMESTER)
-          year_semester.year.should eql(current_year - 1)
+          expect(year_semester.semester).to eql(YearSemester::FIRST_SEMESTER)
+          expect(year_semester.year).to eql(current_year - 1)
         end
         it "the parameter is negative" do
           year_semester.year = current_year
           year_semester.semester = YearSemester::SECOND_SEMESTER
           expected = year_semester + 3
           year_semester.decrease_semesters(-3)
-          year_semester.semester.should eql(expected.semester)
-          year_semester.year.should eql(expected.year)
+          expect(year_semester.semester).to eql(expected.semester)
+          expect(year_semester.year).to eql(expected.year)
         end
       end
     end
@@ -147,39 +147,39 @@
           year_semester.year = current_year
           year_semester.semester = YearSemester::FIRST_SEMESTER
           year_semester.increase_semesters(2)
-          year_semester.semester.should eql(YearSemester::FIRST_SEMESTER)
-          year_semester.year.should eql(current_year + 1)
+          expect(year_semester.semester).to eql(YearSemester::FIRST_SEMESTER)
+          expect(year_semester.year).to eql(current_year + 1)
         end
         it "semester is set to first and the parameter is odd" do
           year_semester.year = current_year
           year_semester.semester = YearSemester::FIRST_SEMESTER
           year_semester.increase_semesters(3)
-          year_semester.semester.should eql(YearSemester::SECOND_SEMESTER)
-          year_semester.year.should eql(current_year + 1)
+          expect(year_semester.semester).to eql(YearSemester::SECOND_SEMESTER)
+          expect(year_semester.year).to eql(current_year + 1)
         end
         it "semester is set to second and the parameter is even" do
           year_semester.year = current_year
           year_semester.semester = YearSemester::SECOND_SEMESTER
           year_semester.increase_semesters(2)
-          year_semester.semester.should eql(YearSemester::SECOND_SEMESTER)
-          year_semester.year.should eql(current_year + 1)
+          expect(year_semester.semester).to eql(YearSemester::SECOND_SEMESTER)
+          expect(year_semester.year).to eql(current_year + 1)
         end
         it "semester is set to second and the parameter is odd" do
           year_semester.year = current_year
           year_semester.semester = YearSemester::SECOND_SEMESTER
           year_semester.increase_semesters(3)
-          year_semester.semester.should eql(YearSemester::FIRST_SEMESTER)
-          year_semester.year.should eql(current_year + 2)
+          expect(year_semester.semester).to eql(YearSemester::FIRST_SEMESTER)
+          expect(year_semester.year).to eql(current_year + 2)
         end
         it "the parameter is negative" do
           year_semester.year = current_year
           year_semester.semester = YearSemester::SECOND_SEMESTER
           expected = year_semester - 3
           year_semester.increase_semesters(-3)
-          year_semester.semester.should eql(expected.semester)
-          year_semester.year.should eql(expected.year)
+          expect(year_semester.semester).to eql(expected.semester)
+          expect(year_semester.year).to eql(expected.year)
         end
       end
     end
   end
-end
\ No newline at end of file
+end

From f26d160f91d7bda9666fd6cbcb9e77cb3605565e Mon Sep 17 00:00:00 2001
From: Carlos Eduardo Cabral da Cunha <eduardosolrac286@gmail.com>
Date: Thu, 31 Oct 2019 11:55:34 -0200
Subject: [PATCH 6/9] #297 adding sql and params spec tests and changing error
 messages to model Query

---
 app/models/query.rb       |  4 +++-
 config/locales/pt-BR.yml  |  3 +++
 spec/models/query_spec.rb | 27 +++++++++++++++++++++++++++
 3 files changed, 33 insertions(+), 1 deletion(-)

diff --git a/app/models/query.rb b/app/models/query.rb
index 7aa60ed7..6f2b92ad 100644
--- a/app/models/query.rb
+++ b/app/models/query.rb
@@ -76,7 +76,9 @@ def ensure_valid_params
     rescue ActiveRecord::PreparedStatementInvalid => e
       variable_name = e.message.match(/missing value for :([a-zA-Z0-9_]+)/)[1]
 
-      self.errors.add(:base, "O parametro #{variable_name} foi usado na query mas nao foi definido.")
+      self.errors.add(:sql, I18n.translate("activerecord.errors.models.query.sql_has_an_undefined_parameter", :parametro => variable_name))
+    rescue Exception => e
+      self.errors.add(:sql, I18n.translate("activerecord.errors.models.query.sql_execution_generated_an_error", :erro => e.message))
     end
   end
 
diff --git a/config/locales/pt-BR.yml b/config/locales/pt-BR.yml
index c0297604..512df118 100644
--- a/config/locales/pt-BR.yml
+++ b/config/locales/pt-BR.yml
@@ -568,6 +568,9 @@ pt-BR:
           has_level: "Já existe conclusão de etapa para a duração de etapa deste nível"
         professor_research_area:
           unique_pair: "não pode estar em duas ou mais áreas de pesquisa repetidas e área de pesquisa não pode possuir o mesmo professor duas ou mais vezes"
+        query:
+          sql_has_an_undefined_parameter: "tem um parâmetro chamado '%{parametro}' que não foi definido."
+          sql_execution_generated_an_error: "gerou o seguinte erro ao ser executada: '%{erro}'"        
         student_major:
           unique_pair: "não pode estar em dois ou mais cursos repetidos e curso não pode possuir o mesmo aluno duas ou mais vezes"
         thesis_defense_committee_participation:
diff --git a/spec/models/query_spec.rb b/spec/models/query_spec.rb
index 61057065..801e2eef 100644
--- a/spec/models/query_spec.rb
+++ b/spec/models/query_spec.rb
@@ -22,6 +22,33 @@
         expect(query).to have_error(:blank).on :sql
       end
     end
+    context "sql has an undefined parameter" do
+      it "show an undefined parameter error on sql" do      	    
+        query.sql = "SELECT students.name as name FROM students\r\nWHERE students.created_at < :data_consulta"
+        query.validate
+	expect(query.errors[:sql]).to include I18n.translate("activerecord.errors.models.query.sql_has_an_undefined_parameter", :parametro=>"data_consulta")
+      end
+    end
+    context "sql has an syntax error" do
+      it "show an message about sql execution causing an error on sql" do      	    
+        query.sql = "aSELECT students.name as name FROM students"
+	inicio_da_mensagem = I18n.translate("activerecord.errors.models.query.sql_execution_generated_an_error", :erro=>"mensagem_de_erro").split("mensagem_de_erro")[0]
+	fim_da_mensagem = I18n.translate("activerecord.errors.models.query.sql_execution_generated_an_error", :erro=>"mensagem_de_erro").split("mensagem_de_erro")[1]
+        query.validate
+	expect( (query.errors[:sql][0].start_with?(inicio_da_mensagem)) && (query.errors[:sql][0].end_with?(fim_da_mensagem))  ).to be true
+      end
+    end
+    context "query is valid" do
+      it "have no errors on a valid query execution" do
+        query.name="nome"
+        query.description="descricao"
+        query.sql="SELECT students.name as name FROM students\r\nWHERE students.created_at < :data_consulta"
+        parameter = query.params.new
+        parameter.name="data_consulta"
+        parameter.value_type="Date"
+        expect(query).to be_valid
+      end	      
+    end
   end
 
 end

From bbc650458d79893940789a4b15da11c85d1b737a Mon Sep 17 00:00:00 2001
From: Carlos Eduardo Cabral da Cunha <eduardosolrac286@gmail.com>
Date: Wed, 27 Nov 2019 17:07:29 -0200
Subject: [PATCH 7/9] Revert "#254 adding a variable to enable or disable if
 professors can post grades"

This reverts commit 69b272da7aec7c54c02ee446d5e9217ffba0b591.
---
 db/migrate/20190809144853_add_new_custom_variable.rb | 5 -----
 db/schema.rb                                         | 2 +-
 2 files changed, 1 insertion(+), 6 deletions(-)
 delete mode 100644 db/migrate/20190809144853_add_new_custom_variable.rb

diff --git a/db/migrate/20190809144853_add_new_custom_variable.rb b/db/migrate/20190809144853_add_new_custom_variable.rb
deleted file mode 100644
index 1e96cca2..00000000
--- a/db/migrate/20190809144853_add_new_custom_variable.rb
+++ /dev/null
@@ -1,5 +0,0 @@
-class AddNewCustomVariable < ActiveRecord::Migration[5.1]
-  def change
-    CustomVariable.where(:variable => "professor_login_can_post_grades").first or CustomVariable.create(:description=>"Professor logado no sistema pode lançar notas", :variable =>"professor_login_can_post_grades", :value => "no")
-  end
-end
diff --git a/db/schema.rb b/db/schema.rb
index 364abd17..61364963 100644
--- a/db/schema.rb
+++ b/db/schema.rb
@@ -10,7 +10,7 @@
 #
 # It's strongly recommended that you check this file into your version control system.
 
-ActiveRecord::Schema.define(version: 20190809144853) do
+ActiveRecord::Schema.define(version: 20180202200850) do
 
   create_table "accomplishments", force: :cascade do |t|
     t.integer "enrollment_id"

From 832ad8ce0f5bfdd27c17f384a5ab2b5a65f35767 Mon Sep 17 00:00:00 2001
From: Carlos Eduardo Cabral da Cunha <eduardosolrac286@gmail.com>
Date: Fri, 13 Dec 2019 20:12:38 -0200
Subject: [PATCH 8/9] #281 correcting method name changes to differentiate
 names when methods are called by before_save or after_save

---
 app/controllers/class_enrollments_controller.rb | 6 +++---
 app/controllers/course_classes_controller.rb    | 6 +++---
 app/controllers/enrollments_controller.rb       | 6 +++---
 app/models/class_enrollment.rb                  | 6 +++---
 app/models/notification.rb                      | 2 +-
 5 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/app/controllers/class_enrollments_controller.rb b/app/controllers/class_enrollments_controller.rb
index de1b00da..7dc62960 100644
--- a/app/controllers/class_enrollments_controller.rb
+++ b/app/controllers/class_enrollments_controller.rb
@@ -31,13 +31,13 @@ class ClassEnrollmentsController < ApplicationController
 
   def before_update_save(record)
     return if record.grade.nil? or !record.valid? or !record.should_send_email_to_professor?
-    absence_changed = record.saved_change_to_disapproved_by_absence? ? '*' : ''
+    absence_changed = record.will_save_change_to_disapproved_by_absence? ? '*' : ''
     info = {
       :name => record.enrollment.to_label,
       :professor => record.course_class.professor.name,
       :course => record.course_class.label_with_course,
-      :situation => "#{record.situation}#{record.saved_change_to_situation? ? '*' : ''}",
-      :grade => "#{record.grade_to_view}#{record.saved_change_to_grade? ? '*' : ''}",
+      :situation => "#{record.situation}#{record.will_save_change_to_situation? ? '*' : ''}",
+      :grade => "#{record.grade_to_view}#{record.will_save_change_to_grade? ? '*' : ''}",
       :absence => ((record.attendance_to_label == "I") ? I18n.t('active_scaffold.true') : I18n.t('active_scaffold.false')) + absence_changed
     }
     message_to_professor = {
diff --git a/app/controllers/course_classes_controller.rb b/app/controllers/course_classes_controller.rb
index 2302bff4..1d802fbd 100644
--- a/app/controllers/course_classes_controller.rb
+++ b/app/controllers/course_classes_controller.rb
@@ -113,9 +113,9 @@ def before_update_save(record)
       :professor => record.professor.name,
       :values => record.class_enrollments.map do |class_enrollment| 
         enrollment = class_enrollment.enrollment.to_label
-        situation = "#{class_enrollment.situation}#{class_enrollment.saved_change_to_situation? ? '*' : ''}"
-        grade = "#{class_enrollment.grade_to_view}#{class_enrollment.saved_change_to_grade? ? '*' : ''}"
-        absence_changed = class_enrollment.saved_change_to_disapproved_by_absence? ? '*' : ''
+        situation = "#{class_enrollment.situation}#{class_enrollment.will_save_change_to_situation? ? '*' : ''}"
+        grade = "#{class_enrollment.grade_to_view}#{class_enrollment.will_save_change_to_grade? ? '*' : ''}"
+        absence_changed = class_enrollment.will_save_change_to_disapproved_by_absence? ? '*' : ''
         if class_enrollment.attendance_to_label == "I"
           absence = "#{I18n.t('activerecord.attributes.class_enrollment.disapproved_by_absence')}#{absence_changed}"
         else
diff --git a/app/controllers/enrollments_controller.rb b/app/controllers/enrollments_controller.rb
index 4933189f..bf600f78 100644
--- a/app/controllers/enrollments_controller.rb
+++ b/app/controllers/enrollments_controller.rb
@@ -296,13 +296,13 @@ def before_update_save(record)
     emails = []
     record.class_enrollments.each do |class_enrollment| 
       if class_enrollment.should_send_email_to_professor?
-        absence_changed = class_enrollment.saved_change_to_disapproved_by_absence? ? '*' : ''
+        absence_changed = class_enrollment.will_save_change_to_disapproved_by_absence? ? '*' : ''
         info = {
           :name => record.to_label,
           :professor => class_enrollment.course_class.professor.name,
           :course => class_enrollment.course_class.label_with_course,
-          :situation => "#{class_enrollment.situation}#{class_enrollment.saved_change_to_situation? ? '*' : ''}",
-          :grade => "#{class_enrollment.grade_to_view}#{class_enrollment.saved_change_to_grade? ? '*' : ''}",
+          :situation => "#{class_enrollment.situation}#{class_enrollment.will_save_change_to_situation? ? '*' : ''}",
+          :grade => "#{class_enrollment.grade_to_view}#{class_enrollment.will_save_change_to_grade? ? '*' : ''}",
           :absence => ((class_enrollment.attendance_to_label == "I") ? I18n.t('active_scaffold.true') : I18n.t('active_scaffold.false')) + absence_changed
         }
         message_to_professor = {
diff --git a/app/models/class_enrollment.rb b/app/models/class_enrollment.rb
index 1c2c693b..4237792c 100644
--- a/app/models/class_enrollment.rb
+++ b/app/models/class_enrollment.rb
@@ -86,9 +86,9 @@ def disapproved_by_absence_to_view
   def should_send_email_to_professor?
     (!self.id.nil?) and 
     (
-      self.saved_change_to_grade? or 
-      self.saved_change_to_situation? or 
-      self.saved_change_to_disapproved_by_absence?
+      self.will_save_change_to_grade? or 
+      self.will_save_change_to_situation? or 
+      self.will_save_change_to_disapproved_by_absence?
     )
   end
 
diff --git a/app/models/notification.rb b/app/models/notification.rb
index 827dd245..48984022 100644
--- a/app/models/notification.rb
+++ b/app/models/notification.rb
@@ -71,7 +71,7 @@ def hammer_current_params!
       self.notification_params.create(:query_param_id => query_param_id, :notification_id => self.id, :active => true)
     end
 
-    if self.saved_change_to_query_id?
+    if self.will_save_change_to_query_id?
       cached_query_params_ids = self.query_params_ids
       self.notification_params.each do |np|
         np.update_attribute(:active, cached_query_params_ids.include?(np.query_param_id))

From fbbc9ba1eb04380914e97e6c1bd9fc58b63ea395 Mon Sep 17 00:00:00 2001
From: Carlos Eduardo Cabral da Cunha <eduardosolrac286@gmail.com>
Date: Wed, 18 Dec 2019 19:38:31 -0200
Subject: [PATCH 9/9] #281 fixing merge conflicts with branch master

---
 app/models/class_enrollment.rb | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/app/models/class_enrollment.rb b/app/models/class_enrollment.rb
index 4237792c..ef256291 100644
--- a/app/models/class_enrollment.rb
+++ b/app/models/class_enrollment.rb
@@ -86,8 +86,8 @@ def disapproved_by_absence_to_view
   def should_send_email_to_professor?
     (!self.id.nil?) and 
     (
-      self.will_save_change_to_grade? or 
-      self.will_save_change_to_situation? or 
+      self.will_save_change_to_grade? or
+      self.will_save_change_to_situation? or
       self.will_save_change_to_disapproved_by_absence?
     )
   end