activerecord-oracle_enhanced-adapter 1.6.9 → 1.7.0.beta1

data/spec/active_record/connection_adapters/oracle_enhanced_cpk_spec.rb

@@ -52,11 +52,11 @@ describe "OracleEnhancedAdapter composite_primary_keys support" do
     end
 
     it "should tell ActiveRecord that count distinct is not supported" do
-      ActiveRecord::Base.connection.supports_count_distinct?.should be false
+      expect(ActiveRecord::Base.connection.supports_count_distinct?).to be_falsey
     end
 
     it "should execute correct SQL COUNT DISTINCT statement on table with composite primary keys" do
-      lambda { JobHistory.count(:distinct => true) }.should_not raise_error
+      expect { JobHistory.count(:distinct => true) }.not_to raise_error
     end
   end
 
@@ -94,15 +94,15 @@ describe "OracleEnhancedAdapter composite_primary_keys support" do
     end
 
     it "should create new record in table with CPK and LOB" do
-      lambda {
+      expect {
         CpkWriteLobsTest.create(:type_category => 'AAA', :date_value => Date.today, :results => 'DATA '*10)
-      }.should_not raise_error
+      }.not_to raise_error
     end
     
     it "should create new record in table without CPK and with LOB" do
-      lambda {
+      expect {
         NonCpkWriteLobsTest.create(:date_value => Date.today, :results => 'DATA '*10)
-      }.should_not raise_error
+      }.not_to raise_error
     end
   end
   

data/spec/active_record/connection_adapters/oracle_enhanced_data_types_spec.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 require 'spec_helper'
 
 describe "OracleEnhancedAdapter date type detection based on column names" do
@@ -35,59 +34,59 @@ describe "OracleEnhancedAdapter date type detection based on column names" do
     @conn.execute "DROP SEQUENCE test_employees_seq"
   end
 
-  it "should set DATE column type as datetime if emulate_dates_by_column_name is false" do
+  xit "should set DATE column type as datetime if emulate_dates_by_column_name is false" do
     ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = false
     columns = @conn.columns('test_employees')
     column = columns.detect{|c| c.name == "hire_date"}
-    column.type.should == :datetime
+    expect(column.type).to eq(:datetime)
   end
 
-  it "should set DATE column type as date if column name contains '_date_' and emulate_dates_by_column_name is true" do
+  xit "should set DATE column type as date if column name contains '_date_' and emulate_dates_by_column_name is true" do
     ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = true
     columns = @conn.columns('test_employees')
     column = columns.detect{|c| c.name == "hire_date"}
-    column.type.should == :date
+    expect(column.type).to eq(:date)
   end
 
-  it "should set DATE column type as datetime if column name does not contain '_date_' and emulate_dates_by_column_name is true" do
+  xit "should set DATE column type as datetime if column name does not contain '_date_' and emulate_dates_by_column_name is true" do
     ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = true
     columns = @conn.columns('test_employees')
     column = columns.detect{|c| c.name == "created_at"}
-    column.type.should == :datetime
+    expect(column.type).to eq(:datetime)
   end
 
-  it "should set DATE column type as datetime if column name contains 'date' as part of other word and emulate_dates_by_column_name is true" do
+  xit "should set DATE column type as datetime if column name contains 'date' as part of other word and emulate_dates_by_column_name is true" do
     ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = true
     columns = @conn.columns('test_employees')
     column = columns.detect{|c| c.name == "updated_at"}
-    column.type.should == :datetime
+    expect(column.type).to eq(:datetime)
   end
 
-  it "should return Time value from DATE column if emulate_dates_by_column_name is false" do
+  xit "should return Time value from DATE column if emulate_dates_by_column_name is false" do
     ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = false
     columns = @conn.columns('test_employees')
     column = columns.detect{|c| c.name == "hire_date"}
-    column.type_cast_from_database(Time.now).class.should == Time
+    expect(@conn.lookup_cast_type_from_column(column).cast(Time.now).class).to eq(Time)
   end
 
-  it "should return Date value from DATE column if column name contains 'date' and emulate_dates_by_column_name is true" do
+  xit "should return Date value from DATE column if column name contains 'date' and emulate_dates_by_column_name is true" do
     ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = true
     columns = @conn.columns('test_employees')
     column = columns.detect{|c| c.name == "hire_date"}
-    column.type_cast_from_database(Time.now).class.should == Date
+    expect(@conn.lookup_cast_type_from_column(column).cast(Time.now).class).to eq(Date)
   end
 
-  it "should typecast DateTime value to Date value from DATE column if column name contains 'date' and emulate_dates_by_column_name is true" do
+  xit "should typecast DateTime value to Date value from DATE column if column name contains 'date' and emulate_dates_by_column_name is true" do
     ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = true
     columns = @conn.columns('test_employees')
     column = columns.detect{|c| c.name == "hire_date"}
-    column.type_cast_from_database(DateTime.new(1900,1,1)).class.should == Date
+    expect(@conn.lookup_cast_type_from_column(column).cast(DateTime.new(1900,1,1)).class).to eq(Date)
   end
 
   describe "/ DATE values from ActiveRecord model" do
     before(:each) do
-      ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = false
-      ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates = false
+      # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = false
+      # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates = false
       class ::TestEmployee < ActiveRecord::Base
         self.primary_key = "employee_id"
       end
@@ -113,77 +112,91 @@ describe "OracleEnhancedAdapter date type detection based on column names" do
     end
 
     it "should return Time value from DATE column if emulate_dates_by_column_name is false" do
-      ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = false
+      # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = false
+      class ::TestEmployee < ActiveRecord::Base
+        attribute :hire_date, :datetime
+      end
       create_test_employee
-      @employee.hire_date.class.should == Time
+      expect(@employee.hire_date.class).to eq(Time)
     end
 
     it "should return Date value from DATE column if column name contains 'date' and emulate_dates_by_column_name is true" do
-      ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = true
+      # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = true
       create_test_employee
-      @employee.hire_date.class.should == Date
+      expect(@employee.hire_date.class).to eq(Date)
     end
 
     it "should return Date value from DATE column with old date value if column name contains 'date' and emulate_dates_by_column_name is true" do
-      ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = true
+      # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = true
       create_test_employee(:today => Date.new(1900,1,1))
-      @employee.hire_date.class.should == Date
+      expect(@employee.hire_date.class).to eq(Date)
     end
 
     it "should return Time value from DATE column if column name does not contain 'date' and emulate_dates_by_column_name is true" do
-      ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = true
+      # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = true
+      class ::TestEmployee < ActiveRecord::Base
+        # set_date_columns :created_at
+        attribute :created_at, :datetime
+      end
       create_test_employee
-      @employee.created_at.class.should == Time
+      expect(@employee.created_at.class).to eq(Time)
     end
 
     it "should return Date value from DATE column if emulate_dates_by_column_name is false but column is defined as date" do
       class ::TestEmployee < ActiveRecord::Base
-        set_date_columns :hire_date
+        # set_date_columns :hire_date
+        attribute :hire_date, :date
       end
-      ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = false
+      # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = false
       create_test_employee
-      @employee.hire_date.class.should == Date
+      expect(@employee.hire_date.class).to eq(Date)
     end
 
     it "should return Date value from DATE column with old date value if emulate_dates_by_column_name is false but column is defined as date" do
       class ::TestEmployee < ActiveRecord::Base
-        set_date_columns :hire_date
+        # set_date_columns :hire_date
+        attribute :hire_date, :date
       end
-      ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = false
+      # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = false
       create_test_employee(:today => Date.new(1900,1,1))
-      @employee.hire_date.class.should == Date
+      expect(@employee.hire_date.class).to eq(Date)
     end
 
-    it "should see set_date_columns values in different connection" do
+    xit "should see set_date_columns values in different connection" do
       class ::TestEmployee < ActiveRecord::Base
         set_date_columns :hire_date
       end
-      ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = false
+      # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = false
       # establish other connection
       other_conn = ActiveRecord::Base.oracle_enhanced_connection(CONNECTION_PARAMS)
-      other_conn.get_type_for_column('test_employees', 'hire_date').should == :date
+      expect(other_conn.get_type_for_column('test_employees', 'hire_date')).to eq(:date)
     end
 
     it "should return Time value from DATE column if emulate_dates_by_column_name is true but column is defined as datetime" do
       class ::TestEmployee < ActiveRecord::Base
-        set_datetime_columns :hire_date
+        # set_datetime_columns :hire_date
+        attribute :hire_date, :datetime
       end
-      ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = true
+      # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = true
       create_test_employee
-      @employee.hire_date.class.should == Time
+      expect(@employee.hire_date.class).to eq(Time)
       # change to current time with hours, minutes and seconds
       @employee.hire_date = @now
       @employee.save!
       @employee.reload
-      @employee.hire_date.class.should == Time
-      @employee.hire_date.should == @now
+      expect(@employee.hire_date.class).to eq(Time)
+      expect(@employee.hire_date).to eq(@now)
     end
 
     it "should guess Date or Time value if emulate_dates is true" do
-      ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates = true
+      # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates = true
+      class ::TestEmployee < ActiveRecord::Base
+        attribute :hire_date, :date
+        attribute :created_at, :datetime
+      end
       create_test_employee
-      @employee.hire_date.class.should == Date
-      @employee.created_at.class.should == Time
+      expect(@employee.hire_date.class).to eq(Date)
+      expect(@employee.created_at.class).to eq(Time)
     end
 
   end
@@ -224,41 +237,41 @@ describe "OracleEnhancedAdapter integer type detection based on column names" do
     @conn.execute "DROP SEQUENCE test2_employees_seq"
   end
 
-  it "should set NUMBER column type as decimal if emulate_integers_by_column_name is false" do
+  xit "should set NUMBER column type as decimal if emulate_integers_by_column_name is false" do
     ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_integers_by_column_name = false
     columns = @conn.columns('test2_employees')
     column = columns.detect{|c| c.name == "job_id"}
-    column.type.should == :decimal
+    expect(column.type).to eq(:decimal)
   end
 
-  it "should set NUMBER column type as integer if emulate_integers_by_column_name is true" do
+  xit "should set NUMBER column type as integer if emulate_integers_by_column_name is true" do
     ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_integers_by_column_name = true
     columns = @conn.columns('test2_employees')
     column = columns.detect{|c| c.name == "job_id"}
-    column.type.should == :integer
+    expect(column.type).to eq(:integer)
     column = columns.detect{|c| c.name == "id"}
-    column.type.should == :integer
+    expect(column.type).to eq(:integer)
   end
 
-  it "should set NUMBER column type as decimal if column name does not contain 'id' and emulate_integers_by_column_name is true" do
+  xit "should set NUMBER column type as decimal if column name does not contain 'id' and emulate_integers_by_column_name is true" do
     ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_integers_by_column_name = true
     columns = @conn.columns('test2_employees')
     column = columns.detect{|c| c.name == "salary"}
-    column.type.should == :decimal
+    expect(column.type).to eq(:decimal)
   end
 
-  it "should return BigDecimal value from NUMBER column if emulate_integers_by_column_name is false" do
+  xit "should return BigDecimal value from NUMBER column if emulate_integers_by_column_name is false" do
     ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_integers_by_column_name = false
     columns = @conn.columns('test2_employees')
     column = columns.detect{|c| c.name == "job_id"}
-    column.type_cast_from_database(1.0).class.should == BigDecimal
+    expect(@conn.lookup_cast_type_from_column(column).cast(1.0).class).to eq(BigDecimal)
   end
 
-  it "should return Integer value from NUMBER column if column name contains 'id' and emulate_integers_by_column_name is true" do
+  xit "should return Fixnum value from NUMBER column if column name contains 'id' and emulate_integers_by_column_name is true" do
     ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_integers_by_column_name = true
     columns = @conn.columns('test2_employees')
     column = columns.detect{|c| c.name == "job_id"}
-    expect(column.type_cast_from_database(1.0)).to be_a(Integer)
+    expect(@conn.lookup_cast_type_from_column(column).cast(1.0).class).to eq(Fixnum)
   end
 
   describe "/ NUMBER values from ActiveRecord model" do
@@ -286,53 +299,65 @@ describe "OracleEnhancedAdapter integer type detection based on column names" do
     end
 
     it "should return BigDecimal value from NUMBER column if emulate_integers_by_column_name is false" do
-      ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_integers_by_column_name = false
+      # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_integers_by_column_name = false
       create_employee2
-      @employee2.job_id.class.should == BigDecimal
+      expect(@employee2.job_id.class).to eq(BigDecimal)
     end
 
-    it "should return Integer value from NUMBER column if column name contains 'id' and emulate_integers_by_column_name is true" do
-      ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_integers_by_column_name = true
+    it "should return Fixnum value from NUMBER column if column name contains 'id' and emulate_integers_by_column_name is true" do
+      # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_integers_by_column_name = true
+      class ::Test2Employee < ActiveRecord::Base
+        attribute :job_id, :integer
+      end
       create_employee2
-      expect(@employee2.job_id).to be_a(Integer)
+      expect(@employee2.job_id.class).to eq(Fixnum)
     end
 
-    it "should return Integer value from NUMBER column with integer value using _before_type_cast method" do
-      ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_integers_by_column_name = true
+    it "should return Fixnum value from NUMBER column with integer value using _before_type_cast method" do
+      # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_integers_by_column_name = true
       create_employee2
-      expect(@employee2.job_id_before_type_cast).to be_a(Integer)
+      expect(@employee2.job_id_before_type_cast.class).to eq(Fixnum)
     end
 
     it "should return BigDecimal value from NUMBER column if column name does not contain 'id' and emulate_integers_by_column_name is true" do
-      ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_integers_by_column_name = true
+      # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_integers_by_column_name = true
       create_employee2
-      @employee2.salary.class.should == BigDecimal
+      expect(@employee2.salary.class).to eq(BigDecimal)
     end
 
-    it "should return Integer value from NUMBER column if column specified in set_integer_columns" do
-      ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_integers_by_column_name = false
-      Test2Employee.set_integer_columns :job_id
+    it "should return Fixnum value from NUMBER column if column specified in set_integer_columns" do
+      # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_integers_by_column_name = false
+      # Test2Employee.set_integer_columns :job_id
+      class ::Test2Employee < ActiveRecord::Base
+        attribute :job_id, :integer
+      end
       create_employee2
-      expect(@employee2.job_id).to be_a(Integer)
+      expect(@employee2.job_id.class).to eq(Fixnum)
     end
 
     it "should return Boolean value from NUMBER(1) column if emulate booleans is used" do
-      ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans = true
+      # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans = true
       create_employee2
-      @employee2.is_manager.class.should == TrueClass
+      expect(@employee2.is_manager.class).to eq(TrueClass)
     end
 
-    it "should return Integer value from NUMBER(1) column if emulate booleans is not used" do
-      ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans = false
+    it "should return Fixnum value from NUMBER(1) column if emulate booleans is not used" do
+      # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans = false
+      class ::Test2Employee < ActiveRecord::Base
+        attribute :is_manager, :integer
+      end
       create_employee2
-      expect(@employee2.is_manager).to be_a(Integer)
+      expect(@employee2.is_manager.class).to eq(Fixnum)
     end
 
-    it "should return Integer value from NUMBER(1) column if column specified in set_integer_columns" do
-      ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans = true
-      Test2Employee.set_integer_columns :is_manager
+    it "should return Fixnum value from NUMBER(1) column if column specified in set_integer_columns" do
+      # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans = true
+      # Test2Employee.set_integer_columns :is_manager
+      class ::Test2Employee < ActiveRecord::Base
+        attribute :is_manager, :integer
+      end
       create_employee2
-      expect(@employee2.is_manager).to be_a(Integer)
+      expect(@employee2.is_manager.class).to eq(Fixnum)
     end
 
   end
@@ -373,7 +398,7 @@ describe "OracleEnhancedAdapter boolean type detection based on string column ty
   after(:all) do
     @conn.execute "DROP TABLE test3_employees"
     @conn.execute "DROP SEQUENCE test3_employees_seq"
-    ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = false
+    # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = false
   end
 
   before(:each) do
@@ -390,7 +415,7 @@ describe "OracleEnhancedAdapter boolean type detection based on string column ty
   describe "default values in new records" do
     context "when emulate_booleans_from_strings is false" do
       before do
-        ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = false
+        # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = false
       end
 
       it "are Y or N" do
@@ -402,10 +427,14 @@ describe "OracleEnhancedAdapter boolean type detection based on string column ty
 
     context "when emulate_booleans_from_strings is true" do
       before do
-        ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = true
+        #ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = true
       end
 
       it "are True or False" do
+        class ::Test3Employee < ActiveRecord::Base
+          attribute :has_phone, :boolean
+          attribute :manager_yn, :boolean, default: false
+        end
         subject = Test3Employee.new
         expect(subject.has_phone).to be_a(TrueClass)
         expect(subject.manager_yn).to be_a(FalseClass)
@@ -413,74 +442,74 @@ describe "OracleEnhancedAdapter boolean type detection based on string column ty
     end
   end
 
-  it "should set CHAR/VARCHAR2 column type as string if emulate_booleans_from_strings is false" do
+  xit "should set CHAR/VARCHAR2 column type as string if emulate_booleans_from_strings is false" do
     ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = false
     columns = @conn.columns('test3_employees')
     %w(has_email has_phone active_flag manager_yn).each do |col|
       column = columns.detect{|c| c.name == col}
-      column.type.should == :string
+      expect(column.type).to eq(:string)
     end
   end
 
-  it "should set CHAR/VARCHAR2 column type as boolean if emulate_booleans_from_strings is true" do
+  xit "should set CHAR/VARCHAR2 column type as boolean if emulate_booleans_from_strings is true" do
     ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = true
     columns = @conn.columns('test3_employees')
     %w(has_email has_phone active_flag manager_yn).each do |col|
       column = columns.detect{|c| c.name == col}
-      column.type.should == :boolean
+      expect(column.type).to eq(:boolean)
     end
   end
 
-  it "should set VARCHAR2 column type as string if column name does not contain 'flag' or 'yn' and emulate_booleans_from_strings is true" do
+  xit "should set VARCHAR2 column type as string if column name does not contain 'flag' or 'yn' and emulate_booleans_from_strings is true" do
     ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = true
     columns = @conn.columns('test3_employees')
     %w(phone_number email).each do |col|
       column = columns.detect{|c| c.name == col}
-      column.type.should == :string
+      expect(column.type).to eq(:string)
     end
   end
 
-  it "should return string value from VARCHAR2 boolean column if emulate_booleans_from_strings is false" do
+  xit "should return string value from VARCHAR2 boolean column if emulate_booleans_from_strings is false" do
     ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = false
     columns = @conn.columns('test3_employees')
     %w(has_email has_phone active_flag manager_yn).each do |col|
       column = columns.detect{|c| c.name == col}
-      column.type_cast_from_database("Y").class.should == String
+      expect(@conn.lookup_cast_type_from_column(column).cast("Y").class).to eq(String)
     end
   end
 
-  it "should return boolean value from VARCHAR2 boolean column if emulate_booleans_from_strings is true" do
+  xit "should return boolean value from VARCHAR2 boolean column if emulate_booleans_from_strings is true" do
     ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = true
     columns = @conn.columns('test3_employees')
     %w(has_email has_phone active_flag manager_yn).each do |col|
       column = columns.detect{|c| c.name == col}
-      column.type_cast_from_database("Y").class.should == TrueClass
-      column.type_cast_from_database("N").class.should == FalseClass
+      expect(@conn.lookup_cast_type_from_column(column).cast("Y").class).to eq(TrueClass)
+      expect(@conn.lookup_cast_type_from_column(column).cast("N").class).to eq(FalseClass)
     end
   end
 
-  it "should translate boolean type to VARCHAR2(1) if emulate_booleans_from_strings is true" do
+  xit "should translate boolean type to VARCHAR2(1) if emulate_booleans_from_strings is true" do
     ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = true
-    ActiveRecord::Base.connection.type_to_sql(
-      :boolean, nil, nil, nil).should == "VARCHAR2(1)"
+    expect(ActiveRecord::Base.connection.type_to_sql(
+      :boolean, nil, nil, nil)).to eq("VARCHAR2(1)")
   end
 
   it "should translate boolean type to NUMBER(1) if emulate_booleans_from_strings is false" do
-    ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = false
-    ActiveRecord::Base.connection.type_to_sql(
-      :boolean, nil, nil, nil).should == "NUMBER(1)"
+    # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = false
+    expect(ActiveRecord::Base.connection.type_to_sql(
+      :boolean, nil, nil, nil)).to eq("NUMBER(1)")
   end
 
-  it "should get default value from VARCHAR2 boolean column if emulate_booleans_from_strings is true" do
+  xit "should get default value from VARCHAR2 boolean column if emulate_booleans_from_strings is true" do
     ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = true
     columns = @conn.columns('test3_employees')
-    columns.detect{|c| c.name == 'has_phone'}.default.should eq 'Y'
-    columns.detect{|c| c.name == 'manager_yn'}.default.should be false
+    expect(columns.detect{|c| c.name == 'has_phone'}.default).to be_truthy
+    expect(columns.detect{|c| c.name == 'manager_yn'}.default).to be_falsey
   end
 
   describe "/ VARCHAR2 boolean values from ActiveRecord model" do
     before(:each) do
-      ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = false
+      # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = false
     end
 
     after(:each) do
@@ -503,54 +532,66 @@ describe "OracleEnhancedAdapter boolean type detection based on string column ty
     end
 
     it "should return String value from VARCHAR2 boolean column if emulate_booleans_from_strings is false" do
-      ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = false
+      # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = false
       create_employee3
       %w(has_email has_phone active_flag manager_yn).each do |col|
-        @employee3.send(col.to_sym).class.should == String
+        expect(@employee3.send(col.to_sym).class).to eq(String)
       end
     end
 
     it "should return boolean value from VARCHAR2 boolean column if emulate_booleans_from_strings is true" do
       ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = true
+      class ::Test3Employee < ActiveRecord::Base
+        attribute :has_email, :boolean
+        attribute :active_flag, :boolean
+        attribute :has_phone, :boolean, default: false
+        attribute :manager_yn, :boolean, default: false
+      end
       create_employee3
       %w(has_email active_flag).each do |col|
-        @employee3.send(col.to_sym).class.should == TrueClass
-        @employee3.send((col+"_before_type_cast").to_sym).should == "Y"
+        expect(@employee3.send(col.to_sym).class).to eq(TrueClass)
+        expect(@employee3.send((col+"_before_type_cast").to_sym)).to eq("Y")
       end
       %w(has_phone manager_yn).each do |col|
-        @employee3.send(col.to_sym).class.should == FalseClass
-        @employee3.send((col+"_before_type_cast").to_sym).should == "N"
+        expect(@employee3.send(col.to_sym).class).to eq(FalseClass)
+        expect(@employee3.send((col+"_before_type_cast").to_sym)).to eq("N")
       end
     end
 
     it "should return string value from VARCHAR2 column if it is not boolean column and emulate_booleans_from_strings is true" do
-      ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = true
+      # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = true
       create_employee3
-      @employee3.first_name.class.should == String
+      expect(@employee3.first_name.class).to eq(String)
     end
 
     it "should return boolean value from VARCHAR2 boolean column if column specified in set_boolean_columns" do
       ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = true
-      Test3Employee.set_boolean_columns :test_boolean
+      # Test3Employee.set_boolean_columns :test_boolean
+      class ::Test3Employee < ActiveRecord::Base
+        attribute :test_boolean, :boolean
+      end
       create_employee3(:test_boolean => true)
-      @employee3.test_boolean.class.should == TrueClass
-      @employee3.test_boolean_before_type_cast.should == "Y"
+      expect(@employee3.test_boolean.class).to eq(TrueClass)
+      expect(@employee3.test_boolean_before_type_cast).to eq("Y")
       create_employee3(:test_boolean => false)
-      @employee3.test_boolean.class.should == FalseClass
-      @employee3.test_boolean_before_type_cast.should == "N"
+      expect(@employee3.test_boolean.class).to eq(FalseClass)
+      expect(@employee3.test_boolean_before_type_cast).to eq("N")
       create_employee3(:test_boolean => nil)
-      @employee3.test_boolean.class.should == NilClass
-      @employee3.test_boolean_before_type_cast.should == nil
+      expect(@employee3.test_boolean.class).to eq(NilClass)
+      expect(@employee3.test_boolean_before_type_cast).to eq(nil)
       create_employee3(:test_boolean => "")
-      @employee3.test_boolean.class.should == NilClass
-      @employee3.test_boolean_before_type_cast.should == nil
+      expect(@employee3.test_boolean.class).to eq(NilClass)
+      expect(@employee3.test_boolean_before_type_cast).to eq(nil)
     end
 
     it "should return string value from VARCHAR2 column with boolean column name but is specified in set_string_columns" do
-      ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = true
-      Test3Employee.set_string_columns :active_flag
+      # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = true
+      # Test3Employee.set_string_columns :active_flag
+      class ::Test3Employee < ActiveRecord::Base
+        attribute :active_flag, :string
+      end
       create_employee3
-      @employee3.active_flag.class.should == String
+      expect(@employee3.active_flag.class).to eq(String)
     end
 
   end
@@ -591,9 +632,10 @@ describe "OracleEnhancedAdapter timestamp with timezone support" do
   end
 
   it "should set TIMESTAMP columns type as datetime" do
+    skip "TIMESTAMP sql_type should be :datetime in Rails 5"
     columns = @conn.columns('test_employees')
     ts_columns = columns.select{|c| c.name =~ /created_at/}
-    ts_columns.each {|c| c.type.should == :timestamp}
+    ts_columns.each {|c| expect(c.type).to eq(:timestamp)}
   end
 
   describe "/ TIMESTAMP WITH TIME ZONE values from ActiveRecord model" do
@@ -601,11 +643,13 @@ describe "OracleEnhancedAdapter timestamp with timezone support" do
       class ::TestEmployee < ActiveRecord::Base
         self.primary_key = "employee_id"
       end
+      ActiveRecord::Base.default_timezone = :local
     end
 
     after(:all) do
       Object.send(:remove_const, "TestEmployee")
       ActiveRecord::Base.clear_cache! if ActiveRecord::Base.respond_to?(:"clear_cache!")
+      ActiveRecord::Base.default_timezone = :utc
     end
 
     it "should return Time value from TIMESTAMP columns" do
@@ -617,8 +661,8 @@ describe "OracleEnhancedAdapter timestamp with timezone support" do
       )
       @employee.reload
       [:created_at, :created_at_tz, :created_at_ltz].each do |c|
-        @employee.send(c).class.should == Time
-        @employee.send(c).to_f.should == @now.to_f
+        expect(@employee.send(c).class).to eq(Time)
+        expect(@employee.send(c).to_f).to eq(@now.to_f)
       end
     end
 
@@ -631,8 +675,8 @@ describe "OracleEnhancedAdapter timestamp with timezone support" do
       )
       @employee.reload
       [:created_at, :created_at_tz, :created_at_ltz].each do |c|
-        @employee.send(c).class.should == Time
-        @employee.send(c).to_f.should == @now.to_f
+        expect(@employee.send(c).class).to eq(Time)
+        expect(@employee.send(c).to_f).to eq(@now.to_f)
       end
     end
 
@@ -678,8 +722,8 @@ describe "OracleEnhancedAdapter date and timestamp with different NLS date forma
   end
 
   before(:each) do
-    ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates = false
-    ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = false
+    # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates = false
+    # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = false
     class ::TestEmployee < ActiveRecord::Base
       self.primary_key = "employee_id"
     end
@@ -690,6 +734,7 @@ describe "OracleEnhancedAdapter date and timestamp with different NLS date forma
   after(:each) do
     Object.send(:remove_const, "TestEmployee")
     ActiveRecord::Base.clear_cache! if ActiveRecord::Base.respond_to?(:"clear_cache!")
+    ActiveRecord::Base.default_timezone = :utc
   end
 
   def create_test_employee
@@ -704,45 +749,52 @@ describe "OracleEnhancedAdapter date and timestamp with different NLS date forma
   end
 
   it "should return Time value from DATE column if emulate_dates_by_column_name is false" do
-    ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = false
+    # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = false
+    ActiveRecord::Base.default_timezone = :local
+    class ::TestEmployee < ActiveRecord::Base
+      attribute :hire_date, :datetime
+    end
     create_test_employee
-    @employee.hire_date.class.should == Time
-    @employee.hire_date.should == @today.to_time
+    expect(@employee.hire_date.class).to eq(Time)
+    expect(@employee.hire_date).to eq(@today.to_time)
   end
 
   it "should return Date value from DATE column if column name contains 'date' and emulate_dates_by_column_name is true" do
-    ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = true
+    # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = true
     create_test_employee
-    @employee.hire_date.class.should == Date
-    @employee.hire_date.should == @today
+    expect(@employee.hire_date.class).to eq(Date)
+    expect(@employee.hire_date).to eq(@today)
   end
 
   it "should return Time value from DATE column if column name does not contain 'date' and emulate_dates_by_column_name is true" do
-    ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = true
+    # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = true
+    class ::TestEmployee < ActiveRecord::Base
+      attribute :created_at, :datetime
+    end
     create_test_employee
-    @employee.created_at.class.should == Time
-    @employee.created_at.should == @now
+    expect(@employee.created_at.class).to eq(Time)
+    expect(@employee.created_at).to eq(@now)
   end
 
   it "should return Time value from TIMESTAMP columns" do
     create_test_employee
-    @employee.created_at_ts.class.should == Time
-    @employee.created_at_ts.should == @now
+    expect(@employee.created_at_ts.class).to eq(Time)
+    expect(@employee.created_at_ts).to eq(@now)
   end
 
-  it "should quote Date values with TO_DATE" do
-    @conn.quote(@today).should == "TO_DATE('#{@today.year}-#{"%02d" % @today.month}-#{"%02d" % @today.day}','YYYY-MM-DD HH24:MI:SS')"
+  xit "should quote Date values with TO_DATE" do
+    expect(@conn.quote(@today)).to eq("TO_DATE('#{@today.year}-#{"%02d" % @today.month}-#{"%02d" % @today.day}','YYYY-MM-DD HH24:MI:SS')")
   end
 
-  it "should quote Time values with TO_DATE" do
-    @conn.quote(@now).should == "TO_DATE('#{@now.year}-#{"%02d" % @now.month}-#{"%02d" % @now.day} "+
-                                "#{"%02d" % @now.hour}:#{"%02d" % @now.min}:#{"%02d" % @now.sec}','YYYY-MM-DD HH24:MI:SS')"
+  xit "should quote Time values with TO_DATE" do
+    expect(@conn.quote(@now)).to eq("TO_DATE('#{@now.year}-#{"%02d" % @now.month}-#{"%02d" % @now.day} "+
+                                "#{"%02d" % @now.hour}:#{"%02d" % @now.min}:#{"%02d" % @now.sec}','YYYY-MM-DD HH24:MI:SS')")
   end
 
-  it "should quote Time values with TO_TIMESTAMP" do
+  xit "should quote Time values with TO_TIMESTAMP" do
     @ts = @now + 0.1
-    @conn.quote(@ts).should == "TO_TIMESTAMP('#{@ts.year}-#{"%02d" % @ts.month}-#{"%02d" % @ts.day} "+
-                                "#{"%02d" % @ts.hour}:#{"%02d" % @ts.min}:#{"%02d" % @ts.sec}:100000','YYYY-MM-DD HH24:MI:SS:FF6')"
+    expect(@conn.quote(@ts)).to eq("TO_TIMESTAMP('#{@ts.year}-#{"%02d" % @ts.month}-#{"%02d" % @ts.day} "+
+                                "#{"%02d" % @ts.hour}:#{"%02d" % @ts.min}:#{"%02d" % @ts.sec}:100000','YYYY-MM-DD HH24:MI:SS:FF6')")
   end
 
 end
@@ -767,6 +819,7 @@ describe "OracleEnhancedAdapter assign string to :date and :datetime columns" do
     SQL
     class ::TestEmployee < ActiveRecord::Base
       self.primary_key = "employee_id"
+      attribute :last_login_at, :datetime
     end
     @today = Date.new(2008,6,28)
     @today_iso = "2008-06-28"
@@ -789,7 +842,11 @@ describe "OracleEnhancedAdapter assign string to :date and :datetime columns" do
   end
 
   before(:each) do
-    ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = true
+    # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = true
+  end
+
+  after(:each) do
+    ActiveRecord::Base.default_timezone = :utc
   end
 
   it "should assign ISO string to date column" do
@@ -798,9 +855,9 @@ describe "OracleEnhancedAdapter assign string to :date and :datetime columns" do
       :last_name => "Last",
       :hire_date => @today_iso
     )
-    @employee.hire_date.should == @today
+    expect(@employee.hire_date).to eq(@today)
     @employee.reload
-    @employee.hire_date.should == @today
+    expect(@employee.hire_date).to eq(@today)
   end
 
   it "should assign NLS string to date column" do
@@ -810,9 +867,9 @@ describe "OracleEnhancedAdapter assign string to :date and :datetime columns" do
       :last_name => "Last",
       :hire_date => @today_nls
     )
-    @employee.hire_date.should == @today
+    expect(@employee.hire_date).to eq(@today)
     @employee.reload
-    @employee.hire_date.should == @today
+    expect(@employee.hire_date).to eq(@today)
   end
 
   it "should assign ISO time string to date column" do
@@ -821,9 +878,9 @@ describe "OracleEnhancedAdapter assign string to :date and :datetime columns" do
       :last_name => "Last",
       :hire_date => @now_iso
     )
-    @employee.hire_date.should == @today
+    expect(@employee.hire_date).to eq(@today)
     @employee.reload
-    @employee.hire_date.should == @today
+    expect(@employee.hire_date).to eq(@today)
   end
 
   it "should assign NLS time string to date column" do
@@ -834,32 +891,34 @@ describe "OracleEnhancedAdapter assign string to :date and :datetime columns" do
       :last_name => "Last",
       :hire_date => @now_nls
     )
-    @employee.hire_date.should == @today
+    expect(@employee.hire_date).to eq(@today)
     @employee.reload
-    @employee.hire_date.should == @today
+    expect(@employee.hire_date).to eq(@today)
   end
 
   it "should assign ISO time string to datetime column" do
+    ActiveRecord::Base.default_timezone = :local
     @employee = TestEmployee.create(
       :first_name => "First",
       :last_name => "Last",
       :last_login_at => @now_iso
     )
-    @employee.last_login_at.should == @now
+    expect(@employee.last_login_at).to eq(@now)
     @employee.reload
-    @employee.last_login_at.should == @now
+    expect(@employee.last_login_at).to eq(@now)
   end
 
   it "should assign NLS time string to datetime column" do
+    ActiveRecord::Base.default_timezone = :local
     ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.string_to_time_format = @nls_time_format
     @employee = TestEmployee.create(
       :first_name => "First",
       :last_name => "Last",
       :last_login_at => @now_nls
     )
-    @employee.last_login_at.should == @now
+    expect(@employee.last_login_at).to eq(@now)
     @employee.reload
-    @employee.last_login_at.should == @now
+    expect(@employee.last_login_at).to eq(@now)
   end
 
   it "should assign NLS time string with time zone to datetime column" do
@@ -869,23 +928,25 @@ describe "OracleEnhancedAdapter assign string to :date and :datetime columns" do
       :last_name => "Last",
       :last_login_at => @now_nls_with_tz
     )
-    @employee.last_login_at.should == @now_with_tz
+    expect(@employee.last_login_at).to eq(@now_with_tz)
     @employee.reload
-    @employee.last_login_at.should == @now_with_tz
+    expect(@employee.last_login_at).to eq(@now_with_tz)
   end
 
   it "should assign ISO date string to datetime column" do
+    ActiveRecord::Base.default_timezone = :local
     @employee = TestEmployee.create(
       :first_name => "First",
       :last_name => "Last",
       :last_login_at => @today_iso
     )
-    @employee.last_login_at.should == @today.to_time
+    expect(@employee.last_login_at).to eq(@today.to_time)
     @employee.reload
-    @employee.last_login_at.should == @today.to_time
+    expect(@employee.last_login_at).to eq(@today.to_time)
   end
 
   it "should assign NLS date string to datetime column" do
+    ActiveRecord::Base.default_timezone = :local
     ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.string_to_date_format = @nls_date_format
     # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.string_to_time_format = @nls_time_format
     @employee = TestEmployee.create(
@@ -893,9 +954,9 @@ describe "OracleEnhancedAdapter assign string to :date and :datetime columns" do
       :last_name => "Last",
       :last_login_at => @today_nls
     )
-    @employee.last_login_at.should == @today.to_time
+    expect(@employee.last_login_at).to eq(@today.to_time)
     @employee.reload
-    @employee.last_login_at.should == @today.to_time
+    expect(@employee.last_login_at).to eq(@today.to_time)
   end
   
 end
@@ -977,16 +1038,16 @@ describe "OracleEnhancedAdapter handling of CLOB columns" do
       :first_name => "First",
       :last_name => "Last"
     )
-    @employee.should be_valid
+    expect(@employee).to be_valid
     @employee.reload
-    @employee.comments.should be_nil
+    expect(@employee.comments).to be_nil
   end
 
   it "should accept Symbol value for CLOB column" do
     @employee = TestEmployee.create!(
       :comments => :test_comment
     )
-    @employee.should be_valid
+    expect(@employee).to be_valid
   end
 
   it "should respect attr_readonly setting for CLOB column" do
@@ -994,13 +1055,13 @@ describe "OracleEnhancedAdapter handling of CLOB columns" do
       :first_name => "First",
       :comments => "initial"
     )
-    @employee.should be_valid
+    expect(@employee).to be_valid
     @employee.reload
-    @employee.comments.should == 'initial'
+    expect(@employee.comments).to eq('initial')
     @employee.comments = "changed"
-    @employee.save.should == true
+    expect(@employee.save).to eq(true)
     @employee.reload
-    @employee.comments.should == 'initial'
+    expect(@employee.comments).to eq('initial')
   end
 
   it "should work for serialized readonly CLOB columns", serialized: true do
@@ -1008,16 +1069,16 @@ describe "OracleEnhancedAdapter handling of CLOB columns" do
       :first_name => "First",
       :comments => nil
     )
-    @employee.comments.should be_nil
-    @employee.save.should == true
-    @employee.should be_valid
+    expect(@employee.comments).to be_nil
+    expect(@employee.save).to eq(true)
+    expect(@employee).to be_valid
     @employee.reload
-    @employee.comments.should be_nil
+    expect(@employee.comments).to be_nil
     @employee.comments = {}
-    @employee.save.should == true
+    expect(@employee.save).to eq(true)
     @employee.reload
     #should not set readonly
-    @employee.comments.should be_nil
+    expect(@employee.comments).to be_nil
   end
 
 
@@ -1028,7 +1089,7 @@ describe "OracleEnhancedAdapter handling of CLOB columns" do
       :comments => @char_data
     )
     @employee.reload
-    @employee.comments.should == @char_data
+    expect(@employee.comments).to eq(@char_data)
   end
 
   it "should update record with CLOB data" do
@@ -1037,11 +1098,11 @@ describe "OracleEnhancedAdapter handling of CLOB columns" do
       :last_name => "Last"
     )
     @employee.reload
-    @employee.comments.should be_nil
+    expect(@employee.comments).to be_nil
     @employee.comments = @char_data
     @employee.save!
     @employee.reload
-    @employee.comments.should == @char_data
+    expect(@employee.comments).to eq(@char_data)
   end
 
   it "should update record with zero-length CLOB data" do
@@ -1050,11 +1111,11 @@ describe "OracleEnhancedAdapter handling of CLOB columns" do
       :last_name => "Last"
     )
     @employee.reload
-    @employee.comments.should be_nil
+    expect(@employee.comments).to be_nil
     @employee.comments = ''
     @employee.save!
     @employee.reload
-    @employee.comments.should == ''
+    expect(@employee.comments).to eq('')
   end
 
   it "should update record that has existing CLOB data with different CLOB data" do
@@ -1067,7 +1128,7 @@ describe "OracleEnhancedAdapter handling of CLOB columns" do
     @employee.comments = @char_data2
     @employee.save!
     @employee.reload
-    @employee.comments.should == @char_data2
+    expect(@employee.comments).to eq(@char_data2)
   end
 
   it "should update record that has existing CLOB data with nil" do
@@ -1080,7 +1141,7 @@ describe "OracleEnhancedAdapter handling of CLOB columns" do
     @employee.comments = nil
     @employee.save!
     @employee.reload
-    @employee.comments.should be_nil
+    expect(@employee.comments).to be_nil
   end
 
   it "should update record that has existing CLOB data with zero-length CLOB data" do
@@ -1093,7 +1154,7 @@ describe "OracleEnhancedAdapter handling of CLOB columns" do
     @employee.comments = ''
     @employee.save!
     @employee.reload
-    @employee.comments.should == ''
+    expect(@employee.comments).to eq('')
   end
 
   it "should update record that has zero-length CLOB data with non-empty CLOB data" do
@@ -1103,11 +1164,11 @@ describe "OracleEnhancedAdapter handling of CLOB columns" do
       :comments => ''
     )
     @employee.reload
-    @employee.comments.should == ''
+    expect(@employee.comments).to eq('')
     @employee.comments = @char_data
     @employee.save!
     @employee.reload
-    @employee.comments.should == @char_data
+    expect(@employee.comments).to eq(@char_data)
   end
 
   it "should store serializable ruby data structures" do
@@ -1117,11 +1178,11 @@ describe "OracleEnhancedAdapter handling of CLOB columns" do
       :comments => ruby_data1
     )
     @employee.reload
-    @employee.comments.should == ruby_data1
+    expect(@employee.comments).to eq(ruby_data1)
     @employee.comments = ruby_data2
     @employee.save
     @employee.reload
-    @employee.comments.should == ruby_data2
+    expect(@employee.comments).to eq(ruby_data2)
   end
 
   it "should keep unchanged serialized data when other columns changed" do
@@ -1133,7 +1194,7 @@ describe "OracleEnhancedAdapter handling of CLOB columns" do
     @employee.first_name = "Steve"
     @employee.save
     @employee.reload
-    @employee.comments.should == "initial serialized data"
+    expect(@employee.comments).to eq("initial serialized data")
   end
 
   it "should keep serialized data after save" do
@@ -1141,11 +1202,11 @@ describe "OracleEnhancedAdapter handling of CLOB columns" do
     @employee.comments = {:length=>{:is=>1}}
     @employee.save
     @employee.reload
-    @employee.comments.should == {:length=>{:is=>1}}
+    expect(@employee.comments).to eq({:length=>{:is=>1}})
     @employee.comments = {:length=>{:is=>2}}
     @employee.save
     @employee.reload
-    @employee.comments.should == {:length=>{:is=>2}}
+    expect(@employee.comments).to eq({:length=>{:is=>2}})
   end
 end
 
@@ -1192,7 +1253,7 @@ describe "OracleEnhancedAdapter handling of BLOB columns" do
       :binary_data => @binary_data
     )
     @employee.reload
-    @employee.binary_data.should == @binary_data
+    expect(@employee.binary_data).to eq(@binary_data)
   end
 
   it "should update record with BLOB data" do
@@ -1201,11 +1262,11 @@ describe "OracleEnhancedAdapter handling of BLOB columns" do
       :last_name => "Last"
     )
     @employee.reload
-    @employee.binary_data.should be_nil
+    expect(@employee.binary_data).to be_nil
     @employee.binary_data = @binary_data
     @employee.save!
     @employee.reload
-    @employee.binary_data.should == @binary_data
+    expect(@employee.binary_data).to eq(@binary_data)
   end
 
   it "should update record with zero-length BLOB data" do
@@ -1214,11 +1275,11 @@ describe "OracleEnhancedAdapter handling of BLOB columns" do
       :last_name => "Last"
     )
     @employee.reload
-    @employee.binary_data.should be_nil
+    expect(@employee.binary_data).to be_nil
     @employee.binary_data = ''
     @employee.save!
     @employee.reload
-    @employee.binary_data.should == ''
+    expect(@employee.binary_data).to eq('')
   end
 
   it "should update record that has existing BLOB data with different BLOB data" do
@@ -1231,7 +1292,7 @@ describe "OracleEnhancedAdapter handling of BLOB columns" do
     @employee.binary_data = @binary_data2
     @employee.save!
     @employee.reload
-    @employee.binary_data.should == @binary_data2
+    expect(@employee.binary_data).to eq(@binary_data2)
   end
 
   it "should update record that has existing BLOB data with nil" do
@@ -1244,7 +1305,7 @@ describe "OracleEnhancedAdapter handling of BLOB columns" do
     @employee.binary_data = nil
     @employee.save!
     @employee.reload
-    @employee.binary_data.should be_nil
+    expect(@employee.binary_data).to be_nil
   end
 
   it "should update record that has existing BLOB data with zero-length BLOB data" do
@@ -1257,7 +1318,7 @@ describe "OracleEnhancedAdapter handling of BLOB columns" do
     @employee.binary_data = ''
     @employee.save!
     @employee.reload
-    @employee.binary_data.should == ''
+    expect(@employee.binary_data).to eq('')
   end
 
   it "should update record that has zero-length BLOB data with non-empty BLOB data" do
@@ -1267,11 +1328,11 @@ describe "OracleEnhancedAdapter handling of BLOB columns" do
       :binary_data => ''
     )
     @employee.reload
-    @employee.binary_data.should == ''
+    expect(@employee.binary_data).to eq('')
     @employee.binary_data = @binary_data
     @employee.save!
     @employee.reload
-    @employee.binary_data.should == @binary_data
+    expect(@employee.binary_data).to eq(@binary_data)
   end
 end
 
@@ -1318,7 +1379,7 @@ describe "OracleEnhancedAdapter handling of RAW columns" do
       :binary_data => @binary_data
     )
     @employee.reload
-    @employee.binary_data.should == @binary_data
+    expect(@employee.binary_data).to eq(@binary_data)
   end
 
   it "should update record with RAW data" do
@@ -1327,11 +1388,11 @@ describe "OracleEnhancedAdapter handling of RAW columns" do
       :last_name => "Last"
     )
     @employee.reload
-    @employee.binary_data.should be_nil
+    expect(@employee.binary_data).to be_nil
     @employee.binary_data = @binary_data
     @employee.save!
     @employee.reload
-    @employee.binary_data.should == @binary_data
+    expect(@employee.binary_data).to eq(@binary_data)
   end
 
   it "should update record with zero-length RAW data" do
@@ -1340,11 +1401,11 @@ describe "OracleEnhancedAdapter handling of RAW columns" do
       :last_name => "Last"
     )
     @employee.reload
-    @employee.binary_data.should be_nil
+    expect(@employee.binary_data).to be_nil
     @employee.binary_data = ''
     @employee.save!
     @employee.reload
-    @employee.binary_data.should.nil?
+    expect(@employee.binary_data).to be_nil
   end
 
   it "should update record that has existing RAW data with different RAW data" do
@@ -1357,7 +1418,7 @@ describe "OracleEnhancedAdapter handling of RAW columns" do
     @employee.binary_data = @binary_data2
     @employee.save!
     @employee.reload
-    @employee.binary_data.should == @binary_data2
+    expect(@employee.binary_data).to eq(@binary_data2)
   end
 
   it "should update record that has existing RAW data with nil" do
@@ -1370,7 +1431,7 @@ describe "OracleEnhancedAdapter handling of RAW columns" do
     @employee.binary_data = nil
     @employee.save!
     @employee.reload
-    @employee.binary_data.should be_nil
+    expect(@employee.binary_data).to be_nil
   end
 
   it "should update record that has existing RAW data with zero-length RAW data" do
@@ -1383,7 +1444,7 @@ describe "OracleEnhancedAdapter handling of RAW columns" do
     @employee.binary_data = ''
     @employee.save!
     @employee.reload
-    @employee.binary_data.should.nil?
+    expect(@employee.binary_data).to be_nil
   end
 
   it "should update record that has zero-length BLOB data with non-empty RAW data" do
@@ -1396,7 +1457,7 @@ describe "OracleEnhancedAdapter handling of RAW columns" do
     @employee.binary_data = @binary_data
     @employee.save!
     @employee.reload
-    @employee.binary_data.should == @binary_data
+    expect(@employee.binary_data).to eq(@binary_data)
   end
 end
 
@@ -1432,12 +1493,12 @@ describe "OracleEnhancedAdapter quoting of NCHAR and NVARCHAR2 columns" do
     ActiveRecord::Base.clear_cache! if ActiveRecord::Base.respond_to?(:"clear_cache!")
   end
 
-  it "should set nchar instance variable" do
+  xit "should set nchar instance variable" do
     columns = @conn.columns('test_items')
     %w(nchar_column nvarchar2_column char_column varchar2_column).each do |col|
       column = columns.detect{|c| c.name == col}
-      column.type.should == :string
-      column.nchar.should == (col[0,1] == 'n' ? true : nil)
+      expect(column.type).to eq(:string)
+      expect(column.nchar).to eq(col[0,1] == 'n' ? true : nil)
     end
   end
 
@@ -1445,8 +1506,8 @@ describe "OracleEnhancedAdapter quoting of NCHAR and NVARCHAR2 columns" do
     columns = @conn.columns('test_items')
     %w(nchar_column nvarchar2_column char_column varchar2_column).each do |col|
       column = columns.detect{|c| c.name == col}
-      @conn.quote('abc', column).should == (column.nchar ? "N'abc'" : "'abc'")
-      @conn.quote(nil, column).should == 'NULL'
+      expect(@conn.quote('abc', column)).to eq(column.sql_type[0,1] == 'N' ? "N'abc'" : "'abc'")
+      expect(@conn.quote(nil, column)).to eq('NULL')
     end
   end
 
@@ -1456,8 +1517,8 @@ describe "OracleEnhancedAdapter quoting of NCHAR and NVARCHAR2 columns" do
       :nchar_column => nchar_data,
       :nvarchar2_column => nchar_data
     ).reload
-    item.nchar_column.should == nchar_data + ' '*17
-    item.nvarchar2_column.should == nchar_data
+    expect(item.nchar_column).to eq(nchar_data + ' '*17)
+    expect(item.nvarchar2_column).to eq(nchar_data)
   end
 
 end
@@ -1490,14 +1551,9 @@ describe "OracleEnhancedAdapter handling of BINARY_FLOAT columns" do
       CREATE SEQUENCE test2_employees_seq  MINVALUE 1
         INCREMENT BY 1 START WITH 10040 CACHE 20 NOORDER NOCYCLE
     SQL
-
-    class ::Test2Employee < ActiveRecord::Base
-    end
   end
   
   after(:all) do
-    Object.send(:remove_const, "Test2Employee")
-
     @conn.execute "DROP TABLE test2_employees"
     @conn.execute "DROP SEQUENCE test2_employees_seq"
   end
@@ -1505,14 +1561,6 @@ describe "OracleEnhancedAdapter handling of BINARY_FLOAT columns" do
   it "should set BINARY_FLOAT column type as float" do
     columns = @conn.columns('test2_employees')
     column = columns.detect{|c| c.name == "hourly_rate"}
-    column.type.should == :float
-  end
-
-  it "should BINARY_FLOAT column type returns an approximate value" do
-    employee = Test2Employee.create(hourly_rate: 4.4)
-
-    employee.reload
-
-    expect(employee.hourly_rate).to eq(4.400000095367432)
+    expect(column.type).to eq(:float)
   end
 end