activerecord-oracle_enhanced-adapter 1.6.9 → 1.7.0.beta1

data/spec/active_record/connection_adapters/oracle_enhanced_connection_spec.rb

@@ -12,25 +12,25 @@ describe "OracleEnhancedConnection" do
     end
 
     it "should create new connection" do
-      @conn.should be_active
+      expect(@conn).to be_active
     end
 
     it "should ping active connection" do
-      @conn.ping.should be true
+      expect(@conn.ping).to be_truthy
     end
 
     it "should not ping inactive connection" do
       @conn.logoff
-      lambda { @conn.ping }.should raise_error(ActiveRecord::ConnectionAdapters::OracleEnhancedConnectionException)
+      expect { @conn.ping }.to raise_error(ActiveRecord::ConnectionAdapters::OracleEnhancedConnectionException)
     end
 
     it "should reset active connection" do
       @conn.reset!
-      @conn.should be_active
+      expect(@conn).to be_active
     end
 
     it "should be in autocommit mode after connection" do
-      @conn.should be_autocommit
+      expect(@conn).to be_autocommit
     end
 
   end
@@ -45,16 +45,16 @@ describe "OracleEnhancedConnection" do
     end
 
     it "should create new connection" do
-      @conn.should be_active
+      expect(@conn).to be_active
     end
 
     it "should swith to specified schema" do
-      @conn.select_value("select SYS_CONTEXT('userenv', 'current_schema') from dual").should == CONNECTION_WITH_SCHEMA_PARAMS[:schema].upcase
+      expect(@conn.select_value("select SYS_CONTEXT('userenv', 'current_schema') from dual")).to eq(CONNECTION_WITH_SCHEMA_PARAMS[:schema].upcase)
     end
 
     it "should swith to specified schema after reset" do
       @conn.reset!
-      @conn.select_value("select SYS_CONTEXT('userenv', 'current_schema') from dual").should == CONNECTION_WITH_SCHEMA_PARAMS[:schema].upcase
+      expect(@conn.select_value("select SYS_CONTEXT('userenv', 'current_schema') from dual")).to eq(CONNECTION_WITH_SCHEMA_PARAMS[:schema].upcase)
     end
 
   end
@@ -67,20 +67,20 @@ describe "OracleEnhancedConnection" do
     it "should use NLS_DATE_FORMAT environment variable" do
       ENV['NLS_DATE_FORMAT'] = 'YYYY-MM-DD'
       @conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(CONNECTION_PARAMS)
-      @conn.select("SELECT value FROM v$nls_parameters WHERE parameter = 'NLS_DATE_FORMAT'").should == [{'value' => 'YYYY-MM-DD'}]
+      expect(@conn.select("SELECT value FROM v$nls_parameters WHERE parameter = 'NLS_DATE_FORMAT'")).to eq([{'value' => 'YYYY-MM-DD'}])
     end
 
     it "should use configuration value and ignore NLS_DATE_FORMAT environment variable" do
       ENV['NLS_DATE_FORMAT'] = 'YYYY-MM-DD'
       @conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(CONNECTION_PARAMS.merge(:nls_date_format => 'YYYY-MM-DD HH24:MI'))
-      @conn.select("SELECT value FROM v$nls_parameters WHERE parameter = 'NLS_DATE_FORMAT'").should == [{'value' => 'YYYY-MM-DD HH24:MI'}]
+      expect(@conn.select("SELECT value FROM v$nls_parameters WHERE parameter = 'NLS_DATE_FORMAT'")).to eq([{'value' => 'YYYY-MM-DD HH24:MI'}])
     end
 
     it "should use default value when NLS_DATE_FORMAT environment variable is not set" do
       ENV['NLS_DATE_FORMAT'] = nil
       @conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(CONNECTION_PARAMS)
       default = ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter::DEFAULT_NLS_PARAMETERS[:nls_date_format]
-      @conn.select("SELECT value FROM v$nls_parameters WHERE parameter = 'NLS_DATE_FORMAT'").should == [{'value' => default}]
+      expect(@conn.select("SELECT value FROM v$nls_parameters WHERE parameter = 'NLS_DATE_FORMAT'")).to eq([{'value' => default}])
     end
   end
 
@@ -94,7 +94,7 @@ describe "OracleEnhancedConnection" do
     end
 
     it "should create new connection" do
-      @conn.should be_active
+      expect(@conn).to be_active
     end
   end
 
@@ -106,24 +106,7 @@ describe "OracleEnhancedConnection" do
     end
 
     it "should create new connection" do
-      @conn.should be_active
-    end
-  end
-
-  describe 'with host="connection-string"' do
-    let(:username) { CONNECTION_PARAMS[:username] }
-    let(:password) { CONNECTION_PARAMS[:password] }
-    let(:connection_string) { "(DESCRIPTION=(ADDRESS_LIST=(ADDRESS=(PROTOCOL=tcp)(HOST=#{DATABASE_HOST})(PORT=#{DATABASE_PORT})))(CONNECT_DATA=(SERVICE_NAME=#{DATABASE_NAME})))" }
-    let(:params) { { username: username, password: password, host: 'connection-string', database: connection_string } }
-
-    it 'uses the database param as the connection string' do
-      if ORACLE_ENHANCED_CONNECTION == :jdbc
-        expect(java.sql.DriverManager).to receive(:getConnection).with("jdbc:oracle:thin:@#{connection_string}", anything).and_call_original
-      else
-        expect(OCI8).to receive(:new).with(username, password, connection_string, nil).and_call_original
-      end
-      conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(params)
-      expect(conn).to be_active
+      expect(@conn).to be_active
     end
   end
 
@@ -138,7 +121,7 @@ describe "OracleEnhancedConnection" do
         params[:host] = nil
         params[:database] = nil
         @conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(params)
-        @conn.should be_active
+        expect(@conn).to be_active
       end
 
       it "should create new connection using :url and tnsnames alias" do
@@ -147,14 +130,14 @@ describe "OracleEnhancedConnection" do
         params[:host] = nil
         params[:database] = nil
         @conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(params)
-        @conn.should be_active
+        expect(@conn).to be_active
       end
 
       it "should create new connection using just tnsnames alias" do
         params = CONNECTION_PARAMS.dup
         params[:host] = nil
         @conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(params)
-        @conn.should be_active
+        expect(@conn).to be_active
       end
 
       it "should create a new connection using JNDI" do
@@ -187,12 +170,12 @@ describe "OracleEnhancedConnection" do
           end
         end
 
-        javax.naming.InitialContext.stub(:new).and_return(InitialContextMock.new)
+        allow(javax.naming.InitialContext).to receive(:new).and_return(InitialContextMock.new)
 
         params = {}
         params[:jndi] = 'java:comp/env/jdbc/test'
         @conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(params)
-        @conn.should be_active
+        expect(@conn).to be_active
       end
 
     end
@@ -202,9 +185,9 @@ describe "OracleEnhancedConnection" do
       params[:url] = "jdbc:oracle:thin:@#{DATABASE_HOST && "//#{DATABASE_HOST}#{DATABASE_PORT && ":#{DATABASE_PORT}"}/"}#{DATABASE_NAME}"
       params[:host] = nil
       params[:database] = nil
-      java.sql.DriverManager.stub(:getConnection).and_raise('no suitable driver found')
+      allow(java.sql.DriverManager).to receive(:getConnection).and_raise('no suitable driver found')
       @conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(params)
-      @conn.should be_active
+      expect(@conn).to be_active
     end
 
   end
@@ -215,15 +198,15 @@ describe "OracleEnhancedConnection" do
     end
 
     it "should execute SQL statement" do
-      @conn.exec("SELECT * FROM dual").should_not be_nil
+      expect(@conn.exec("SELECT * FROM dual")).not_to be_nil
     end
 
     it "should execute SQL select" do
-      @conn.select("SELECT * FROM dual").should == [{'dummy' => 'X'}]
+      expect(@conn.select("SELECT * FROM dual")).to eq([{'dummy' => 'X'}])
     end
 
     it "should execute SQL select and return also columns" do
-      @conn.select("SELECT * FROM dual", nil, true).should == [ [{'dummy' => 'X'}], ['dummy'] ]
+      expect(@conn.select("SELECT * FROM dual", nil, true)).to eq([ [{'dummy' => 'X'}], ['dummy'] ])
     end
 
   end
@@ -237,8 +220,8 @@ describe "OracleEnhancedConnection" do
       cursor = @conn.prepare("SELECT * FROM dual WHERE :1 = 1")
       cursor.bind_param(1, 1)
       cursor.exec
-      cursor.get_col_names.should == ['DUMMY']
-      cursor.fetch.should == ["X"]
+      expect(cursor.get_col_names).to eq(['DUMMY'])
+      expect(cursor.fetch).to eq(["X"])
       cursor.close
     end
 
@@ -246,10 +229,10 @@ describe "OracleEnhancedConnection" do
       cursor = @conn.prepare("SELECT * FROM dual WHERE :1 = 1")
       cursor.bind_param(1, 1)
       cursor.exec
-      cursor.fetch.should == ["X"]
+      expect(cursor.fetch).to eq(["X"])
       cursor.bind_param(1, 0)
       cursor.exec
-      cursor.fetch.should be_nil
+      expect(cursor.fetch).to be_nil
       cursor.close
     end
   end
@@ -268,14 +251,15 @@ describe "OracleEnhancedConnection" do
 
     it "should execute prepared statement with decimal bind parameter " do
       cursor = @conn.prepare("INSERT INTO test_employees VALUES(:1)")
-      column = ActiveRecord::ConnectionAdapters::OracleEnhancedColumn.new('age', nil, ActiveRecord::Type::Decimal.new, 'NUMBER(10,2)')
-      column.type.should == :decimal
+      type_metadata = ActiveRecord::ConnectionAdapters::SqlTypeMetadata.new(sql_type: "NUMBER", type: :decimal, limit: 10, precision: nil, scale: 2)
+      column = ActiveRecord::ConnectionAdapters::OracleEnhancedColumn.new('age', nil, type_metadata, false, "test_employees", false, false, nil)
+      expect(column.type).to eq(:decimal)
       cursor.bind_param(1, "1.5", column)
       cursor.exec
       cursor.close
       cursor = @conn.prepare("SELECT age FROM test_employees")
       cursor.exec
-      cursor.fetch.should == [1.5]
+      expect(cursor.fetch).to eq([1.5])
       cursor.close
     end
   end
@@ -303,28 +287,36 @@ describe "OracleEnhancedConnection" do
       # @conn.auto_retry = true
       ActiveRecord::Base.connection.auto_retry = true
       kill_current_session
-      @conn.exec("SELECT * FROM dual").should_not be_nil
+      expect(@conn.exec("SELECT * FROM dual")).not_to be_nil
     end
 
     it "should not reconnect and execute SQL statement if connection is lost and auto retry is disabled" do
       # @conn.auto_retry = false
       ActiveRecord::Base.connection.auto_retry = false
       kill_current_session
-      lambda { @conn.exec("SELECT * FROM dual") }.should raise_error
+      if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+        expect { @conn.exec("SELECT * FROM dual") }.to raise_error(NativeException)
+      else
+        expect { @conn.exec("SELECT * FROM dual") }.to raise_error(OCIError)
+      end
     end
 
     it "should reconnect and execute SQL select if connection is lost and auto retry is enabled" do
       # @conn.auto_retry = true
       ActiveRecord::Base.connection.auto_retry = true
       kill_current_session
-      @conn.select("SELECT * FROM dual").should == [{'dummy' => 'X'}]
+      expect(@conn.select("SELECT * FROM dual")).to eq([{'dummy' => 'X'}])
     end
 
     it "should not reconnect and execute SQL select if connection is lost and auto retry is disabled" do
       # @conn.auto_retry = false
       ActiveRecord::Base.connection.auto_retry = false
       kill_current_session
-      lambda { @conn.select("SELECT * FROM dual") }.should raise_error
+      if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+        expect { @conn.select("SELECT * FROM dual") }.to raise_error(NativeException)
+      else
+        expect { @conn.select("SELECT * FROM dual") }.to raise_error(OCIError)
+      end
     end
 
   end
@@ -337,45 +329,45 @@ describe "OracleEnhancedConnection" do
 
     it "should describe existing table" do
       @conn.exec "CREATE TABLE test_employees (first_name VARCHAR2(20))" rescue nil
-      @conn.describe("test_employees").should == [@owner, "TEST_EMPLOYEES"]
+      expect(@conn.describe("test_employees")).to eq([@owner, "TEST_EMPLOYEES"])
       @conn.exec "DROP TABLE test_employees" rescue nil
     end
 
     it "should not describe non-existing table" do
-      lambda { @conn.describe("test_xxx") }.should raise_error(ActiveRecord::ConnectionAdapters::OracleEnhancedConnectionException)
+      expect { @conn.describe("test_xxx") }.to raise_error(ActiveRecord::ConnectionAdapters::OracleEnhancedConnectionException)
     end
 
     it "should describe table in other schema" do
-      @conn.describe("sys.dual").should == ["SYS", "DUAL"]
+      expect(@conn.describe("sys.dual")).to eq(["SYS", "DUAL"])
     end
 
     it "should describe existing view" do
       @conn.exec "CREATE TABLE test_employees (first_name VARCHAR2(20))" rescue nil
       @conn.exec "CREATE VIEW test_employees_v AS SELECT * FROM test_employees" rescue nil
-      @conn.describe("test_employees_v").should == [@owner, "TEST_EMPLOYEES_V"]
+      expect(@conn.describe("test_employees_v")).to eq([@owner, "TEST_EMPLOYEES_V"])
       @conn.exec "DROP VIEW test_employees_v" rescue nil
       @conn.exec "DROP TABLE test_employees" rescue nil
     end
 
     it "should describe view in other schema" do
-      @conn.describe("sys.v_$version").should == ["SYS", "V_$VERSION"]
+      expect(@conn.describe("sys.v_$version")).to eq(["SYS", "V_$VERSION"])
     end
 
     it "should describe existing private synonym" do
       @conn.exec "CREATE SYNONYM test_dual FOR sys.dual" rescue nil
-      @conn.describe("test_dual").should == ["SYS", "DUAL"]
+      expect(@conn.describe("test_dual")).to eq(["SYS", "DUAL"])
       @conn.exec "DROP SYNONYM test_dual" rescue nil
     end
 
     it "should describe existing public synonym" do
-      @conn.describe("all_tables").should == ["SYS", "ALL_TABLES"]
+      expect(@conn.describe("all_tables")).to eq(["SYS", "ALL_TABLES"])
     end
 
     if defined?(OCI8)
       context "OCI8 adapter" do
 
         it "should not fallback to SELECT-based logic when querying non-existant table information" do
-          @conn.should_not_receive(:select_one)
+          expect(@conn).not_to receive(:select_one)
           @conn.describe("non_existant") rescue ActiveRecord::ConnectionAdapters::OracleEnhancedConnectionException
         end
 

data/spec/active_record/connection_adapters/oracle_enhanced_context_index_spec.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 require 'spec_helper'
 
 describe "OracleEnhancedAdapter context index" do
@@ -88,7 +87,7 @@ describe "OracleEnhancedAdapter context index" do
     it "should create single VARCHAR2 column index" do
       @conn.add_context_index :posts, :title
       @title_words.each do |word|
-        Post.contains(:title, word).to_a.should == [@post2, @post1]
+        expect(Post.contains(:title, word).to_a).to eq([@post2, @post1])
       end
       @conn.remove_context_index :posts, :title
     end
@@ -96,28 +95,28 @@ describe "OracleEnhancedAdapter context index" do
     it "should create single CLOB column index" do
       @conn.add_context_index :posts, :body
       @body_words.each do |word|
-        Post.contains(:body, word).to_a.should == [@post2, @post1]
+        expect(Post.contains(:body, word).to_a).to eq([@post2, @post1])
       end
       @conn.remove_context_index :posts, :body
     end
 
     it "should not include text index secondary tables in user tables list" do
       @conn.add_context_index :posts, :title
-      @conn.tables.any?{|t| t =~ /^dr\$/i}.should be false
+      expect(@conn.tables.any?{|t| t =~ /^dr\$/i}).to be_falsey
       @conn.remove_context_index :posts, :title
     end
 
     it "should create multiple column index" do
       @conn.add_context_index :posts, [:title, :body]
       (@title_words+@body_words).each do |word|
-        Post.contains(:title, word).to_a.should == [@post2, @post1]
+        expect(Post.contains(:title, word).to_a).to eq([@post2, @post1])
       end
       @conn.remove_context_index :posts, [:title, :body]
     end
 
     it "should index records with null values" do
       @conn.add_context_index :posts, [:title, :body]
-      Post.contains(:title, "withnull").to_a.should == [@post_with_null_body, @post_with_null_title]
+      expect(Post.contains(:title, "withnull").to_a).to eq([@post_with_null_body, @post_with_null_title])
       @conn.remove_context_index :posts, [:title, :body]
     end
 
@@ -125,14 +124,14 @@ describe "OracleEnhancedAdapter context index" do
       @conn.add_context_index :posts, [:title, :body],
         index_column: :all_text, sync: 'ON COMMIT'
       @post = Post.create(title: "abc", body: "def")
-      Post.contains(:all_text, "abc").to_a.should == [@post]
-      Post.contains(:all_text, "def").to_a.should == [@post]
+      expect(Post.contains(:all_text, "abc").to_a).to eq([@post])
+      expect(Post.contains(:all_text, "def").to_a).to eq([@post])
       @post.update_attributes!(title: "ghi")
       # index will not be updated as all_text column is not changed
-      Post.contains(:all_text, "ghi").to_a.should be_empty
+      expect(Post.contains(:all_text, "ghi").to_a).to be_empty
       @post.update_attributes!(all_text: "1")
       # index will be updated when all_text column is changed
-      Post.contains(:all_text, "ghi").to_a.should == [@post]
+      expect(Post.contains(:all_text, "ghi").to_a).to eq([@post])
       @conn.remove_context_index :posts, index_column: :all_text
     end
 
@@ -141,11 +140,11 @@ describe "OracleEnhancedAdapter context index" do
         index_column: :all_text, index_column_trigger_on: [:created_at, :updated_at],
         sync: 'ON COMMIT'
       @post = Post.create(title: "abc", body: "def")
-      Post.contains(:all_text, "abc").to_a.should == [@post]
-      Post.contains(:all_text, "def").to_a.should == [@post]
+      expect(Post.contains(:all_text, "abc").to_a).to eq([@post])
+      expect(Post.contains(:all_text, "def").to_a).to eq([@post])
       @post.update_attributes!(title: "ghi")
       # index should be updated as created_at column is changed
-      Post.contains(:all_text, "ghi").to_a.should == [@post]
+      expect(Post.contains(:all_text, "ghi").to_a).to eq([@post])
       @conn.remove_context_index :posts, index_column: :all_text
     end
 
@@ -153,9 +152,9 @@ describe "OracleEnhancedAdapter context index" do
       @post = Post.create!(title: "āčē", body: "dummy")
       @conn.add_context_index :posts, :title,
         lexer: { type: "BASIC_LEXER", base_letter_type: 'GENERIC', base_letter: true }
-      Post.contains(:title, "āčē").to_a.should == [@post]
-      Post.contains(:title, "ace").to_a.should == [@post]
-      Post.contains(:title, "ACE").to_a.should == [@post]
+      expect(Post.contains(:title, "āčē").to_a).to eq([@post])
+      expect(Post.contains(:title, "ace").to_a).to eq([@post])
+      expect(Post.contains(:title, "ACE").to_a).to eq([@post])
       @conn.remove_context_index :posts, :title
     end
 
@@ -163,9 +162,9 @@ describe "OracleEnhancedAdapter context index" do
       @conn.add_context_index :posts, :title, transactional: true
       Post.transaction do
         @post = Post.create(title: "abc")
-        Post.contains(:title, "abc").to_a.should == [@post]
+        expect(Post.contains(:title, "abc").to_a).to eq([@post])
         @post.update_attributes!(title: "ghi")
-        Post.contains(:title, "ghi").to_a.should == [@post]
+        expect(Post.contains(:title, "ghi").to_a).to eq([@post])
       end
       @conn.remove_context_index :posts, :title
     end
@@ -218,7 +217,7 @@ describe "OracleEnhancedAdapter context index" do
       @post.comments.create!(author: "ccc", body: "ddd")
       @post.comments.create!(author: "eee", body: "fff")
       ["aaa", "bbb", "ccc", "ddd", "eee", "fff"].each do |word|
-        Post.contains(:all_text, word).to_a.should == [@post]
+        expect(Post.contains(:all_text, word).to_a).to eq([@post])
       end
     end
 
@@ -239,7 +238,7 @@ describe "OracleEnhancedAdapter context index" do
       @post.comments.create!(author: "ccc", body: "ddd")
       @post.comments.create!(author: "eee", body: "fff")
       ["aaa", "bbb", "ccc", "ddd", "eee", "fff"].each do |word|
-        Post.contains(:all_text, word).to_a.should == [@post]
+        expect(Post.contains(:all_text, word).to_a).to eq([@post])
       end
     end
 
@@ -252,14 +251,14 @@ describe "OracleEnhancedAdapter context index" do
         "SELECT comments.author AS comment_author, comments.body AS comment_body FROM comments WHERE comments.post_id = :id"
         ],
         index_column: :all_text
-      Post.contains(:all_text, "aaa within title").to_a.should == [@post]
-      Post.contains(:all_text, "aaa within body").to_a.should be_empty
-      Post.contains(:all_text, "bbb within body").to_a.should == [@post]
-      Post.contains(:all_text, "bbb within title").to_a.should be_empty
-      Post.contains(:all_text, "ccc within comment_author").to_a.should == [@post]
-      Post.contains(:all_text, "ccc within comment_body").to_a.should be_empty
-      Post.contains(:all_text, "ddd within comment_body").to_a.should == [@post]
-      Post.contains(:all_text, "ddd within comment_author").to_a.should be_empty
+      expect(Post.contains(:all_text, "aaa within title").to_a).to eq([@post])
+      expect(Post.contains(:all_text, "aaa within body").to_a).to be_empty
+      expect(Post.contains(:all_text, "bbb within body").to_a).to eq([@post])
+      expect(Post.contains(:all_text, "bbb within title").to_a).to be_empty
+      expect(Post.contains(:all_text, "ccc within comment_author").to_a).to eq([@post])
+      expect(Post.contains(:all_text, "ccc within comment_body").to_a).to be_empty
+      expect(Post.contains(:all_text, "ddd within comment_body").to_a).to eq([@post])
+      expect(Post.contains(:all_text, "ddd within comment_author").to_a).to be_empty
     end
 
   end
@@ -289,22 +288,22 @@ describe "OracleEnhancedAdapter context index" do
 
     def verify_logged_statements
       ['K_TABLE_CLAUSE', 'R_TABLE_CLAUSE', 'N_TABLE_CLAUSE', 'I_INDEX_CLAUSE', 'P_TABLE_CLAUSE'].each do |clause|
-        @logger.output(:debug).should =~ /CTX_DDL\.SET_ATTRIBUTE\('index_posts_on_title_sto', '#{clause}', '.*TABLESPACE #{@tablespace}'\)/
+        expect(@logger.output(:debug)).to match(/CTX_DDL\.SET_ATTRIBUTE\('index_posts_on_title_sto', '#{clause}', '.*TABLESPACE #{@tablespace}'\)/)
       end
-      @logger.output(:debug).should =~ /CREATE INDEX .* PARAMETERS \('STORAGE index_posts_on_title_sto'\)/
+      expect(@logger.output(:debug)).to match(/CREATE INDEX .* PARAMETERS \('STORAGE index_posts_on_title_sto'\)/)
     end
 
     it "should create index on single column" do
       @conn.add_context_index :posts, :title, tablespace: @tablespace
       verify_logged_statements
-      Post.contains(:title, 'aaa').to_a.should == [@post]
+      expect(Post.contains(:title, 'aaa').to_a).to eq([@post])
       @conn.remove_context_index :posts, :title
     end
 
     it "should create index on multiple columns" do
       @conn.add_context_index :posts, [:title, :body], name: 'index_posts_text', tablespace: @conn.default_tablespace
       verify_logged_statements
-      Post.contains(:title, 'aaa AND bbb').to_a.should == [@post]
+      expect(Post.contains(:title, 'aaa AND bbb').to_a).to eq([@post])
       @conn.remove_context_index :posts, name: 'index_posts_text'
     end
 
@@ -332,13 +331,13 @@ describe "OracleEnhancedAdapter context index" do
 
       it "should dump definition of single column index" do
         @conn.add_context_index :posts, :title
-        standard_dump.should =~ /add_context_index "posts", \["title"\], name: \"index_posts_on_title\"$/
+        expect(standard_dump).to match(/add_context_index "posts", \["title"\], name: \"index_posts_on_title\"$/)
         @conn.remove_context_index :posts, :title
       end
 
       it "should dump definition of multiple column index" do
         @conn.add_context_index :posts, [:title, :body]
-        standard_dump.should =~ /add_context_index "posts", \[:title, :body\]$/
+        expect(standard_dump).to match(/add_context_index "posts", \[:title, :body\]$/)
         @conn.remove_context_index :posts, [:title, :body]
       end
 
@@ -351,7 +350,7 @@ describe "OracleEnhancedAdapter context index" do
         }
         sub_query = "SELECT comments.author AS comment_author, comments.body AS comment_body FROM comments WHERE comments.post_id = :id"
         @conn.add_context_index :posts, [:title, :body, sub_query], options
-        standard_dump.should =~ /add_context_index "posts", \[:title, :body, "#{sub_query}"\], #{options.inspect[1..-2]}$/
+        expect(standard_dump).to match(/add_context_index "posts", \[:title, :body, "#{sub_query}"\], #{options.inspect[1..-2]}$/)
         @conn.remove_context_index :posts, name: 'post_and_comments_index'
       end
 
@@ -364,7 +363,7 @@ describe "OracleEnhancedAdapter context index" do
         }
         sub_query = "SELECT comments.author AS comment_author, comments.body AS comment_body FROM comments WHERE comments.post_id = :id#{' AND 1=1' * 500}"
         @conn.add_context_index :posts, [:title, :body, sub_query], options
-        standard_dump.should =~ /add_context_index "posts", \[:title, :body, "#{sub_query}"\], #{options.inspect[1..-2]}$/
+        expect(standard_dump).to match(/add_context_index "posts", \[:title, :body, "#{sub_query}"\], #{options.inspect[1..-2]}$/)
         @conn.remove_context_index :posts, name: 'post_and_comments_index'
       end
 
@@ -377,7 +376,7 @@ describe "OracleEnhancedAdapter context index" do
         }
         sub_query = "SELECT comments.author AS comment_author, comments.body AS comment_body\nFROM comments\nWHERE comments.post_id = :id"
         @conn.add_context_index :posts, [:title, :body, sub_query], options
-        standard_dump.should =~ /add_context_index "posts", \[:title, :body, "#{sub_query.gsub(/\n/, ' ')}"\], #{options.inspect[1..-2]}$/
+        expect(standard_dump).to match(/add_context_index "posts", \[:title, :body, "#{sub_query.gsub(/\n/, ' ')}"\], #{options.inspect[1..-2]}$/)
         @conn.remove_context_index :posts, name: 'post_and_comments_index'
       end
 
@@ -398,13 +397,13 @@ describe "OracleEnhancedAdapter context index" do
 
       it "should dump definition of single column index" do
         schema_define { add_context_index :posts, :title }
-        standard_dump.should =~ /add_context_index "posts", \["title"\], name: "i_xxx_posts_xxx_title"$/
+        expect(standard_dump).to match(/add_context_index "posts", \["title"\], name: "i_xxx_posts_xxx_title"$/)
         schema_define { remove_context_index :posts, :title }
       end
 
       it "should dump definition of multiple column index" do
         schema_define { add_context_index :posts, [:title, :body] }
-        standard_dump.should =~ /add_context_index "posts", \[:title, :body\]$/
+        expect(standard_dump).to match(/add_context_index "posts", \[:title, :body\]$/)
         schema_define { remove_context_index :posts, [:title, :body] }
       end
 
@@ -422,8 +421,8 @@ describe "OracleEnhancedAdapter context index" do
             "SELECT comments.author AS comment_author, comments.body AS comment_body FROM comments WHERE comments.post_id = :id"
             ], options
         end
-        standard_dump.should =~ /add_context_index "posts", \[:title, :body, "SELECT comments.author AS comment_author, comments.body AS comment_body FROM comments WHERE comments.post_id = :id"\], #{
-          options.inspect[1..-2].gsub(/[{}]/){|s| '\\'<<s }}$/
+        expect(standard_dump).to match(/add_context_index "posts", \[:title, :body, "SELECT comments.author AS comment_author, comments.body AS comment_body FROM comments WHERE comments.post_id = :id"\], #{
+          options.inspect[1..-2].gsub(/[{}]/){|s| '\\'<<s }}$/)
         schema_define { remove_context_index :posts, name: 'xxx_post_and_comments_i' }
       end