ruby-plsql 0.5.0 → 0.5.1

data/spec/plsql/schema_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe "Schema" do
   
   it "should create Schema object" do
-    plsql.class.should == PLSQL::Schema
+    expect(plsql.class).to eq(PLSQL::Schema)
   end
   
 end
@@ -24,28 +24,28 @@ describe "Schema connection" do
 
   it "should connect to test database" do
     plsql.connection = @conn
-    plsql.connection.raw_connection.should == @conn
+    expect(plsql.connection.raw_connection).to eq(@conn)
   end
 
   it "should connect to test database using connection alias" do
     plsql(:hr).connection = @conn
-    plsql(:hr).connection.raw_connection.should == @conn
+    expect(plsql(:hr).connection.raw_connection).to eq(@conn)
   end
   
   it "should return schema name" do
     plsql.connection = @conn
-    plsql.schema_name.should == DATABASE_USERS_AND_PASSWORDS[0][0].upcase
+    expect(plsql.schema_name).to eq(DATABASE_USERS_AND_PASSWORDS[0][0].upcase)
   end
 
   it "should return new schema name after reconnection" do
     plsql.connection = @conn
-    plsql.schema_name.should == DATABASE_USERS_AND_PASSWORDS[0][0].upcase
+    expect(plsql.schema_name).to eq(DATABASE_USERS_AND_PASSWORDS[0][0].upcase)
     plsql.connection = get_connection(1)
-    plsql.schema_name.should == DATABASE_USERS_AND_PASSWORDS[1][0].upcase
+    expect(plsql.schema_name).to eq(DATABASE_USERS_AND_PASSWORDS[1][0].upcase)
   end
 
   it "should return nil schema name if not connected" do
-    plsql(:xxx).schema_name.should == nil
+    expect(plsql(:xxx).schema_name).to eq(nil)
   end
 
 end
@@ -55,6 +55,7 @@ describe "Connection with connect!" do
   before(:all) do
     @username, @password = DATABASE_USERS_AND_PASSWORDS[0]
     @database = DATABASE_NAME
+    @database_service = DATABASE_SERVICE_NAME
     @host = DATABASE_HOST
     @port = DATABASE_PORT
   end
@@ -65,43 +66,43 @@ describe "Connection with connect!" do
 
   it "should connect with username, password and database alias" do
     plsql.connect! @username, @password, @database
-    plsql.connection.should_not be_nil
-    plsql.schema_name.should == @username.upcase
+    expect(plsql.connection).not_to be_nil
+    expect(plsql.schema_name).to eq(@username.upcase)
   end
 
   it "should connect with username, password, host, port and database name" do
-    plsql.connect! @username, @password, :host => @host, :port => @port, :database => @database
-    plsql.connection.should_not be_nil
-    plsql.schema_name.should == @username.upcase
+    plsql.connect! @username, @password, :host => @host, :port => @port, :database => @database_service
+    expect(plsql.connection).not_to be_nil
+    expect(plsql.schema_name).to eq(@username.upcase)
   end
 
   it "should connect with username, password, host, database name and default port" do
-    pending "Non-default port used for test database" unless @port == 1521
-    plsql.connect! @username, @password, :host => @host, :database => @database
-    plsql.connection.should_not be_nil
-    plsql.schema_name.should == @username.upcase
+    skip "Non-default port used for test database" unless @port == 1521
+    plsql.connect! @username, @password, :host => @host, :database => @database_service
+    expect(plsql.connection).not_to be_nil
+    expect(plsql.schema_name).to eq(@username.upcase)
   end
 
   it "should not connect with wrong port number" do
-    lambda {
+    expect {
       plsql.connect! @username, @password, :host => @host, :port => 9999, :database => @database
-    }.should raise_error(/no listener|could not establish the connection/)
+    }.to raise_error(/no listener|could not establish the connection/)
   end
 
   it "should connect with one Hash parameter" do
     plsql.connect! :username => @username, :password => @password, :database => @database
-    plsql.connection.should_not be_nil
-    plsql.schema_name.should == @username.upcase
+    expect(plsql.connection).not_to be_nil
+    expect(plsql.schema_name).to eq(@username.upcase)
   end
 
   it "should set session time zone from TZ environment variable" do
     plsql.connect! @username, @password, @database
-    plsql.connection.time_zone.should == ENV['TZ']
+    expect(plsql.connection.time_zone).to eq(ENV['TZ'])
   end
 
   it "should set session time zone from :time_zone parameter" do
     plsql.connect! :username => @username, :password => @password, :database => @database, :time_zone => 'EET'
-    plsql.connection.time_zone.should == 'EET'
+    expect(plsql.connection.time_zone).to eq('EET')
   end
 
 end
@@ -116,19 +117,19 @@ describe "Named Schema" do
   end
 
   it "should find existing schema" do
-    plsql.hr.class.should == PLSQL::Schema
+    expect(plsql.hr.class).to eq(PLSQL::Schema)
   end
 
   it "should have the same connection as default schema" do
-    plsql.hr.connection.raw_connection.should == @conn
+    expect(plsql.hr.connection.raw_connection).to eq(@conn)
   end
 
   it "should return schema name" do
-    plsql.hr.schema_name.should == 'HR'
+    expect(plsql.hr.schema_name).to eq('HR')
   end
 
   it "should not find named schema if specified twice" do
-    lambda { plsql.hr.hr }.should raise_error(ArgumentError)
+    expect { plsql.hr.hr }.to raise_error(ArgumentError)
   end
 
 end
@@ -155,22 +156,22 @@ describe "Schema commit and rollback" do
   it "should do commit" do
     plsql.test_commit.insert @data
     plsql.commit
-    plsql.test_commit.first.should == @data
+    expect(plsql.test_commit.first).to eq(@data)
   end
 
   it "should do rollback" do
     plsql.test_commit.insert @data
     plsql.rollback
-    plsql.test_commit.first.should be_nil
+    expect(plsql.test_commit.first).to be_nil
   end
 
   it "should create savepoint and rollback to savepoint" do
     plsql.test_commit.insert @data
     plsql.savepoint 'test'
     plsql.test_commit.insert @data2
-    plsql.test_commit.all.should == [@data, @data2]
+    expect(plsql.test_commit.all).to eq([@data, @data2])
     plsql.rollback_to 'test'
-    plsql.test_commit.all.should == [@data]
+    expect(plsql.test_commit.all).to eq([@data])
   end
 
 end
@@ -191,33 +192,33 @@ describe "ActiveRecord connection" do
 
   it "should connect to test database" do
     unless defined?(JRUBY_VERSION)
-      plsql.connection.is_a?(PLSQL::OCIConnection).should be_true
+      expect(plsql.connection.is_a?(PLSQL::OCIConnection)).to be_truthy
     else
-      plsql.connection.is_a?(PLSQL::JDBCConnection).should be_true
+      expect(plsql.connection.is_a?(PLSQL::JDBCConnection)).to be_truthy
     end
   end
 
   it "should return schema name" do
-    plsql.schema_name.should == 'HR'
+    expect(plsql.schema_name).to eq('HR')
   end
 
   it "should use ActiveRecord::Base.default_timezone as default" do
     ActiveRecord::Base.default_timezone = :utc
-    plsql.default_timezone.should == :utc
+    expect(plsql.default_timezone).to eq(:utc)
   end
 
   it "should have the same connection as default schema" do
-    plsql.hr.connection.should == plsql.connection
+    expect(plsql.hr.connection).to eq(plsql.connection)
   end
 
   it "should accept inherited ActiveRecord class" do
     plsql.activerecord_class = TestBaseModel
-    plsql.schema_name.should == 'HR'
+    expect(plsql.schema_name).to eq('HR')
   end
 
   it "should accept subclass of inherited ActiveRecord class" do
     plsql.activerecord_class = TestModel
-    plsql.schema_name.should == 'HR'
+    expect(plsql.schema_name).to eq('HR')
   end
 end if defined?(ActiveRecord)
 
@@ -268,7 +269,7 @@ describe "DBMS_OUTPUT logging" do
 
     it "should log output to specified stream" do
       plsql.test_dbms_output("test_dbms_output")
-      @buffer.string.should == "DBMS_OUTPUT: test_dbms_output\n"
+      expect(@buffer.string).to eq("DBMS_OUTPUT: test_dbms_output\n")
     end
 
     it "should not log output to stream when output is disabled" do
@@ -277,32 +278,32 @@ describe "DBMS_OUTPUT logging" do
       plsql.test_dbms_output("disabled")
       plsql.dbms_output_stream = @buffer
       plsql.test_dbms_output("enabled again")
-      @buffer.string.should == "DBMS_OUTPUT: enabled\nDBMS_OUTPUT: enabled again\n"
+      expect(@buffer.string).to eq("DBMS_OUTPUT: enabled\nDBMS_OUTPUT: enabled again\n")
     end
 
     it "should log 20_000 character output with default buffer size" do
       times = 2_000
       plsql.test_dbms_output_large("1234567890", times)
-      @buffer.string.should == "DBMS_OUTPUT: 1234567890\n" * times
+      expect(@buffer.string).to eq("DBMS_OUTPUT: 1234567890\n" * times)
     end
 
     it "should log 100_000 character output with specified buffer size" do
       times = 10_000
       plsql.dbms_output_buffer_size = 10 * times
       plsql.test_dbms_output_large("1234567890", times)
-      @buffer.string.should == "DBMS_OUTPUT: 1234567890\n" * times
+      expect(@buffer.string).to eq("DBMS_OUTPUT: 1234567890\n" * times)
     end
 
     it "should log output when database version is less than 10.2" do
-      plsql.connection.stub!(:database_version).and_return([9, 2, 0, 0])
+      allow(plsql.connection).to receive(:database_version).and_return([9, 2, 0, 0])
       times = 2_000
       plsql.test_dbms_output_large("1234567890", times)
-      @buffer.string.should == "DBMS_OUTPUT: 1234567890\n" * times
+      expect(@buffer.string).to eq("DBMS_OUTPUT: 1234567890\n" * times)
     end
 
     it "should log output when calling procedure with schema prefix" do
       plsql.hr.test_dbms_output("test_dbms_output")
-      @buffer.string.should == "DBMS_OUTPUT: test_dbms_output\n"
+      expect(@buffer.string).to eq("DBMS_OUTPUT: test_dbms_output\n")
     end
 
   end
@@ -317,13 +318,13 @@ describe "DBMS_OUTPUT logging" do
 
     it "should log output to specified stream" do
       plsql(:ar).test_dbms_output("test_dbms_output")
-      @buffer.string.should == "DBMS_OUTPUT: test_dbms_output\n"
+      expect(@buffer.string).to eq("DBMS_OUTPUT: test_dbms_output\n")
     end
 
     it "should log output after reconnection" do
       ActiveRecord::Base.connection.reconnect!
       plsql(:ar).test_dbms_output("after reconnection")
-      @buffer.string.should == "DBMS_OUTPUT: after reconnection\n"
+      expect(@buffer.string).to eq("DBMS_OUTPUT: after reconnection\n")
     end
 
   end if defined?(ActiveRecord)

data/spec/plsql/sequence_spec.rb

@@ -19,15 +19,15 @@ describe "Table" do
   describe "find" do
 
     it "should find existing sequence" do
-      PLSQL::Sequence.find(plsql, :test_employees_seq).should_not be_nil
+      expect(PLSQL::Sequence.find(plsql, :test_employees_seq)).not_to be_nil
     end
 
     it "should not find nonexisting table" do
-      PLSQL::Sequence.find(plsql, :qwerty123456).should be_nil
+      expect(PLSQL::Sequence.find(plsql, :qwerty123456)).to be_nil
     end
 
     it "should find existing sequence in schema" do
-      plsql.test_employees_seq.should be_a(PLSQL::Sequence)
+      expect(plsql.test_employees_seq).to be_a(PLSQL::Sequence)
     end
 
   end
@@ -43,11 +43,11 @@ describe "Table" do
     end
 
     it "should find synonym to sequence" do
-      PLSQL::Sequence.find(plsql, :test_employees_seq_synonym).should_not be_nil
+      expect(PLSQL::Sequence.find(plsql, :test_employees_seq_synonym)).not_to be_nil
     end
 
     it "should find sequence using synonym in schema" do
-      plsql.test_employees_seq_synonym.should be_a(PLSQL::Sequence)
+      expect(plsql.test_employees_seq_synonym).to be_a(PLSQL::Sequence)
     end
 
   end
@@ -55,12 +55,12 @@ describe "Table" do
   describe "values" do
     it "should get next value from sequence" do
       next_value = plsql.select_one "SELECT test_employees_seq.NEXTVAL FROM dual"
-      plsql.test_employees_seq.nextval.should == next_value + 1
+      expect(plsql.test_employees_seq.nextval).to eq(next_value + 1)
     end
 
     it "should get current value from sequence" do
       next_value = plsql.test_employees_seq.nextval
-      plsql.test_employees_seq.currval.should == next_value
+      expect(plsql.test_employees_seq.currval).to eq(next_value)
     end
   end
 

data/spec/plsql/sql_statements_spec.rb

@@ -57,33 +57,33 @@ describe "SQL statements /" do
     end
 
     it "should select first result" do
-      plsql.select(:first, "SELECT * FROM test_employees WHERE employee_id = :employee_id",
-        @employees.first[:employee_id]).should == @employees.first
+      expect(plsql.select(:first, "SELECT * FROM test_employees WHERE employee_id = :employee_id",
+        @employees.first[:employee_id])).to eq(@employees.first)
     end
 
     it "should prefetch only one row when selecting first result" do
-      lambda {
+      expect {
         plsql.select(:first, "SELECT 1 FROM dual UNION ALL SELECT 1/0 FROM dual")
-      }.should_not raise_error
+      }.not_to raise_error
     end
 
     it "should select one value" do
-      plsql.select_one("SELECT count(*) FROM test_employees").should == @employees.size
+      expect(plsql.select_one("SELECT count(*) FROM test_employees")).to eq(@employees.size)
     end
 
     it "should return nil when selecting non-existing one value" do
-      plsql.select_one("SELECT employee_id FROM test_employees WHERE 1=2").should be_nil
+      expect(plsql.select_one("SELECT employee_id FROM test_employees WHERE 1=2")).to be_nil
     end
 
     it "should prefetch only one row when selecting one value" do
-      lambda {
+      expect {
         plsql.select_one("SELECT 1 FROM dual UNION ALL SELECT 1/0 FROM dual")
-      }.should_not raise_error
+      }.not_to raise_error
     end
 
     it "should select all results" do
-      plsql.select(:all, "SELECT * FROM test_employees ORDER BY employee_id").should == @employees
-      plsql.select("SELECT * FROM test_employees ORDER BY employee_id").should == @employees
+      expect(plsql.select(:all, "SELECT * FROM test_employees ORDER BY employee_id")).to eq(@employees)
+      expect(plsql.select("SELECT * FROM test_employees ORDER BY employee_id")).to eq(@employees)
     end
 
   end

data/spec/plsql/table_spec.rb

@@ -85,15 +85,15 @@ describe "Table" do
   describe "find" do
 
     it "should find existing table" do
-      PLSQL::Table.find(plsql, :test_employees).should_not be_nil
+      expect(PLSQL::Table.find(plsql, :test_employees)).not_to be_nil
     end
 
     it "should not find nonexisting table" do
-      PLSQL::Table.find(plsql, :qwerty123456).should be_nil
+      expect(PLSQL::Table.find(plsql, :qwerty123456)).to be_nil
     end
 
     it "should find existing table in schema" do
-      plsql.test_employees.should be_a(PLSQL::Table)
+      expect(plsql.test_employees).to be_a(PLSQL::Table)
     end
 
   end
@@ -109,11 +109,11 @@ describe "Table" do
     end
 
     it "should find synonym to table" do
-      PLSQL::Table.find(plsql, :test_employees_synonym).should_not be_nil
+      expect(PLSQL::Table.find(plsql, :test_employees_synonym)).not_to be_nil
     end
 
     it "should find table using synonym in schema" do
-      plsql.test_employees_synonym.should be_a(PLSQL::Table)
+      expect(plsql.test_employees_synonym).to be_a(PLSQL::Table)
     end
 
   end
@@ -121,11 +121,11 @@ describe "Table" do
   describe "public synonym" do
 
     it "should find public synonym to table" do
-      PLSQL::Table.find(plsql, :dual).should_not be_nil
+      expect(PLSQL::Table.find(plsql, :dual)).not_to be_nil
     end
 
     it "should find table using public synonym in schema" do
-      plsql.dual.should be_a(PLSQL::Table)
+      expect(plsql.dual).to be_a(PLSQL::Table)
     end
 
   end
@@ -133,11 +133,11 @@ describe "Table" do
   describe "columns" do
 
     it "should get column names for table" do
-      plsql.test_employees.column_names.should == @employees_all_fields
+      expect(plsql.test_employees.column_names).to eq(@employees_all_fields)
     end
 
     it "should get columns metadata for table" do
-      plsql.test_employees.columns.should == {
+      expect(plsql.test_employees.columns).to eq({
         :employee_id => {
           :position=>1, :data_type=>"NUMBER", :data_length=>22, :data_precision=>15, :data_scale=>0, :char_used=>nil,
           :type_owner=>nil, :type_name=>nil, :sql_type_name=>nil, :nullable => false, :data_default => nil},
@@ -156,11 +156,11 @@ describe "Table" do
         :status => {
           :position=>6, :data_type=>"VARCHAR2", :data_length=>1, :data_precision=>nil, :data_scale=>nil, :char_used=>"B",
           :type_owner=>nil, :type_name=>nil, :sql_type_name=>nil, :nullable => true, :data_default => "'N'"}
-      }
+      })
     end
 
     it "should get columns metadata for table with object columns" do
-      plsql.test_employees2.columns.should == {
+      expect(plsql.test_employees2.columns).to eq({
         :employee_id => {
           :position=>1, :data_type=>"NUMBER", :data_length=>22, :data_precision=>15, :data_scale=>0, :char_used=>nil,
           :type_owner=>nil, :type_name=>nil, :sql_type_name=>nil, :nullable => false, :data_default => nil},
@@ -179,7 +179,7 @@ describe "Table" do
         :phones => {
           :position=>6, :data_type=>"TABLE", :data_length=>nil, :data_precision=>nil, :data_scale=>nil, :char_used=>nil,
           :type_owner=>"HR", :type_name=>"T_PHONES", :sql_type_name=>"HR.T_PHONES", :nullable => true, :data_default => nil}
-      }
+      })
     end
 
   end
@@ -187,32 +187,32 @@ describe "Table" do
   describe "insert" do
     it "should insert a record in table" do
       plsql.test_employees.insert @employees.first
-      plsql.test_employees.all.should == [@employees.first]
+      expect(plsql.test_employees.all).to eq([@employees.first])
     end
 
     it "should insert a record in table using partial list of columns" do
       plsql.test_employees.insert @employees.first.except(:hire_date)
-      plsql.test_employees.all.should == [@employees.first.merge(:hire_date => nil)]
+      expect(plsql.test_employees.all).to eq([@employees.first.merge(:hire_date => nil)])
     end
 
     it "should insert default value from table definition if value not provided" do
       plsql.test_employees.insert @employees.first.except(:status)
-      plsql.test_employees.all.should == [@employees.first.merge(:status => 'N')]
+      expect(plsql.test_employees.all).to eq([@employees.first.merge(:status => 'N')])
     end
 
     it "should insert array of records in table" do
       plsql.test_employees.insert @employees
-      plsql.test_employees.all("ORDER BY employee_id").should == @employees
+      expect(plsql.test_employees.all("ORDER BY employee_id")).to eq(@employees)
     end
 
     it "should insert a record in table with object types" do
       plsql.test_employees2.insert @employees2.first
-      plsql.test_employees2.all.should == [@employees2.first]
+      expect(plsql.test_employees2.all).to eq([@employees2.first])
     end
 
     it "should insert array of records in table with object types" do
       plsql.test_employees2.insert @employees2
-      plsql.test_employees2.all("ORDER BY employee_id").should == @employees2
+      expect(plsql.test_employees2.all("ORDER BY employee_id")).to eq(@employees2)
     end
 
   end
@@ -220,32 +220,32 @@ describe "Table" do
   describe "insert values" do
     it "should insert a record with array of values" do
       plsql.test_employees.insert_values @employees_all_values.first
-      plsql.test_employees.all.should == [@employees.first]
+      expect(plsql.test_employees.all).to eq([@employees.first])
     end
 
     it "should insert a record with list of all fields and array of values" do
       plsql.test_employees.insert_values @employees_all_fields, @employees_all_values.first
-      plsql.test_employees.all.should == [@employees.first]
+      expect(plsql.test_employees.all).to eq([@employees.first])
     end
 
     it "should insert a record with list of some fields and array of values" do
       plsql.test_employees.insert_values @employees_some_fields, @employees_some_values.first
-      plsql.test_employees.all.should == [@employees.first.merge(@employee_default_values)]
+      expect(plsql.test_employees.all).to eq([@employees.first.merge(@employee_default_values)])
     end
 
     it "should insert many records with array of values" do
       plsql.test_employees.insert_values *@employees_all_values
-      plsql.test_employees.all.should == @employees
+      expect(plsql.test_employees.all).to eq(@employees)
     end
 
     it "should insert many records with list of all fields and array of values" do
       plsql.test_employees.insert_values @employees_all_fields, *@employees_all_values
-      plsql.test_employees.all.should == @employees
+      expect(plsql.test_employees.all).to eq(@employees)
     end
 
     it "should insert many records with list of some fields and array of values" do
       plsql.test_employees.insert_values @employees_some_fields, *@employees_some_values
-      plsql.test_employees.all.should == @employees.map{|e| e.merge(@employee_default_values)}
+      expect(plsql.test_employees.all).to eq(@employees.map{|e| e.merge(@employee_default_values)})
     end
 
   end
@@ -256,24 +256,24 @@ describe "Table" do
     end
 
     it "should select first record in table" do
-      plsql.test_employees.select(:first, "ORDER BY employee_id").should == @employees.first
-      plsql.test_employees.first("ORDER BY employee_id").should == @employees.first
+      expect(plsql.test_employees.select(:first, "ORDER BY employee_id")).to eq(@employees.first)
+      expect(plsql.test_employees.first("ORDER BY employee_id")).to eq(@employees.first)
     end
 
     it "should select all records in table" do
-      plsql.test_employees.select(:all, "ORDER BY employee_id").should == @employees
-      plsql.test_employees.all("ORDER BY employee_id").should == @employees
-      plsql.test_employees.all(:order_by => :employee_id).should == @employees
+      expect(plsql.test_employees.select(:all, "ORDER BY employee_id")).to eq(@employees)
+      expect(plsql.test_employees.all("ORDER BY employee_id")).to eq(@employees)
+      expect(plsql.test_employees.all(:order_by => :employee_id)).to eq(@employees)
     end
 
     it "should select record in table using WHERE condition" do
-      plsql.test_employees.select(:first, "WHERE employee_id = :1", @employees.first[:employee_id]).should == @employees.first
-      plsql.test_employees.first("WHERE employee_id = :1", @employees.first[:employee_id]).should == @employees.first
-      plsql.test_employees.first(:employee_id => @employees.first[:employee_id]).should == @employees.first
+      expect(plsql.test_employees.select(:first, "WHERE employee_id = :1", @employees.first[:employee_id])).to eq(@employees.first)
+      expect(plsql.test_employees.first("WHERE employee_id = :1", @employees.first[:employee_id])).to eq(@employees.first)
+      expect(plsql.test_employees.first(:employee_id => @employees.first[:employee_id])).to eq(@employees.first)
     end
 
     it "should select records in table using WHERE condition and ORDER BY sorting" do
-      plsql.test_employees.all(:employee_id => @employees.first[:employee_id], :order_by => :employee_id).should == [@employees.first]
+      expect(plsql.test_employees.all(:employee_id => @employees.first[:employee_id], :order_by => :employee_id)).to eq([@employees.first])
     end
 
     it "should select record in table using :column => nil condition" do
@@ -281,8 +281,8 @@ describe "Table" do
       employee[:employee_id] = employee[:employee_id] + 1
       employee[:hire_date] = nil
       plsql.test_employees.insert employee
-      plsql.test_employees.first("WHERE hire_date IS NULL").should == employee
-      plsql.test_employees.first(:hire_date => nil).should == employee
+      expect(plsql.test_employees.first("WHERE hire_date IS NULL")).to eq(employee)
+      expect(plsql.test_employees.first(:hire_date => nil)).to eq(employee)
     end
 
     it "should select record in table using :column => :is_null condition" do
@@ -290,7 +290,7 @@ describe "Table" do
       employee[:employee_id] = employee[:employee_id] + 1
       employee[:hire_date] = nil
       plsql.test_employees.insert employee
-      plsql.test_employees.first(:hire_date => :is_null).should == employee
+      expect(plsql.test_employees.first(:hire_date => :is_null)).to eq(employee)
     end
 
     it "should select record in table using :column => :is_not_null condition" do
@@ -298,17 +298,17 @@ describe "Table" do
       employee[:employee_id] = employee[:employee_id] + 1
       employee[:hire_date] = nil
       plsql.test_employees.insert employee
-      plsql.test_employees.all(:hire_date => :is_not_null, :order_by => :employee_id).should == @employees
+      expect(plsql.test_employees.all(:hire_date => :is_not_null, :order_by => :employee_id)).to eq(@employees)
     end
 
     it "should count records in table" do
-      plsql.test_employees.select(:count).should == @employees.size
-      plsql.test_employees.count.should == @employees.size
+      expect(plsql.test_employees.select(:count)).to eq(@employees.size)
+      expect(plsql.test_employees.count).to eq(@employees.size)
     end
 
     it "should count records in table using condition" do
-      plsql.test_employees.select(:count, "WHERE employee_id <= :1", @employees[2][:employee_id]).should == 3
-      plsql.test_employees.count("WHERE employee_id <= :1", @employees[2][:employee_id]).should == 3
+      expect(plsql.test_employees.select(:count, "WHERE employee_id <= :1", @employees[2][:employee_id])).to eq(3)
+      expect(plsql.test_employees.count("WHERE employee_id <= :1", @employees[2][:employee_id])).to eq(3)
     end
 
   end
@@ -318,17 +318,17 @@ describe "Table" do
       employee_id = @employees.first[:employee_id]
       plsql.test_employees.insert @employees.first
       plsql.test_employees.update :first_name => 'Test', :where => {:employee_id => employee_id}
-      plsql.test_employees.first(:employee_id => employee_id)[:first_name].should == 'Test'
+      expect(plsql.test_employees.first(:employee_id => employee_id)[:first_name]).to eq('Test')
     end
 
     it "should update a record in table using String WHERE condition" do
       employee_id = @employees.first[:employee_id]
       plsql.test_employees.insert @employees
       plsql.test_employees.update :first_name => 'Test', :where => "employee_id = #{employee_id}"
-      plsql.test_employees.first(:employee_id => employee_id)[:first_name].should == 'Test'
+      expect(plsql.test_employees.first(:employee_id => employee_id)[:first_name]).to eq('Test')
       # all other records should not be changed
       plsql.test_employees.all("WHERE employee_id > :1", employee_id) do |employee|
-        employee[:first_name].should_not == 'Test'
+        expect(employee[:first_name]).not_to eq('Test')
       end
     end
 
@@ -336,7 +336,7 @@ describe "Table" do
       plsql.test_employees.insert @employees
       plsql.test_employees.update :first_name => 'Test'
       plsql.test_employees.all do |employee|
-        employee[:first_name].should == 'Test'
+        expect(employee[:first_name]).to eq('Test')
       end
     end
 
@@ -346,8 +346,8 @@ describe "Table" do
       plsql.test_employees2.insert employee
       plsql.test_employees2.update :address => employee2[:address], :phones => employee2[:phones], :where => {:employee_id => employee[:employee_id]}
       updated_employee = plsql.test_employees2.first(:employee_id => employee[:employee_id])
-      updated_employee[:address].should == employee2[:address]
-      updated_employee[:phones].should == employee2[:phones]
+      expect(updated_employee[:address]).to eq(employee2[:address])
+      expect(updated_employee[:phones]).to eq(employee2[:phones])
     end
 
   end
@@ -357,14 +357,14 @@ describe "Table" do
       employee_id = @employees.first[:employee_id]
       plsql.test_employees.insert @employees
       plsql.test_employees.delete :employee_id => employee_id
-      plsql.test_employees.first(:employee_id => employee_id).should be_nil
-      plsql.test_employees.all(:order_by => :employee_id).should == @employees[1, @employees.size-1]
+      expect(plsql.test_employees.first(:employee_id => employee_id)).to be_nil
+      expect(plsql.test_employees.all(:order_by => :employee_id)).to eq(@employees[1, @employees.size-1])
     end
 
     it "should delete all records from table" do
       plsql.test_employees.insert @employees
       plsql.test_employees.delete
-      plsql.test_employees.all.should be_empty
+      expect(plsql.test_employees.all).to be_empty
     end
   end