schema_plus 1.5.2 → 1.5.3

data/spec/named_schemas_spec.rb

@@ -46,13 +46,13 @@ describe "with multiple schemas" do
 
     it "should not find indexes in other schema" do
       User.reset_column_information
-      User.indexes.should be_empty
+      expect(User.indexes).to be_empty
     end
 
     it "should find index in current schema" do
       connection.execute 'CREATE INDEX index_users_on_login ON users (login)'
       User.reset_column_information
-      User.indexes.map(&:name).should == ['index_users_on_login']
+      expect(User.indexes.map(&:name)).to eq(['index_users_on_login'])
     end
   end
 
@@ -72,12 +72,12 @@ describe "with multiple schemas" do
     end
 
     it "should not find views in other schema" do
-      connection.views.should be_empty
+      expect(connection.views).to be_empty
     end
 
     it "should find views in this schema" do
       connection.execute 'CREATE VIEW myview AS SELECT * FROM users'
-      connection.views.should == ['myview']
+      expect(connection.views).to eq(['myview'])
     end
   end
 
@@ -106,9 +106,9 @@ describe "with multiple schemas" do
         t.integer :user_id, :foreign_key => false
       end
       Comment.reset_column_information
-      Comment.foreign_keys.length.should == 0
+      expect(Comment.foreign_keys.length).to eq(0)
       User.reset_column_information
-      User.reverse_foreign_keys.length.should == 0
+      expect(User.reverse_foreign_keys.length).to eq(0)
     end
 
     it "should find foreign keys in this schema" do
@@ -116,9 +116,9 @@ describe "with multiple schemas" do
         t.integer :user_id, :foreign_key => true
       end
       Comment.reset_column_information
-      Comment.foreign_keys.map(&:column_names).flatten.should == ["user_id"]
+      expect(Comment.foreign_keys.map(&:column_names).flatten).to eq(["user_id"])
       User.reset_column_information
-      User.reverse_foreign_keys.map(&:column_names).flatten.should == ["user_id"]
+      expect(User.reverse_foreign_keys.map(&:column_names).flatten).to eq(["user_id"])
     end
 
   end
@@ -157,25 +157,25 @@ describe "with multiple schemas" do
     end
 
     it "should find foreign keys" do
-      Member.foreign_keys.should_not be_empty
+      expect(Member.foreign_keys).not_to be_empty
     end
 
     it "should find reverse foreign keys" do
-      Group.reverse_foreign_keys.should_not be_empty
+      expect(Group.reverse_foreign_keys).not_to be_empty
     end
 
     it "should reference table in same schema" do
-      Member.foreign_keys.map(&:references_table_name).should include "schema_plus_test2.groups"
+      expect(Member.foreign_keys.map(&:references_table_name)).to include "schema_plus_test2.groups"
     end
 
     it "should reference table in default schema" do
-      Member.foreign_keys.map(&:references_table_name).should include "items"
+      expect(Member.foreign_keys.map(&:references_table_name)).to include "items"
     end unless SchemaPlusHelpers.mysql?
 
     it "should include the schema in the constraint name" do
       expected_names = ["fk_schema_plus_test2_members_group_id"]
       expected_names << "fk_schema_plus_test2_members_item_id" unless SchemaPlusHelpers.mysql?
-      Member.foreign_keys.map(&:name).should =~ expected_names
+      expect(Member.foreign_keys.map(&:name).sort).to match_array(expected_names.sort)
     end
   end
 
@@ -199,14 +199,14 @@ describe "with multiple schemas" do
       end
 
       before(:each) do
-        connection.stub :adapter_name => 'PostGIS'
+        allow(connection).to receive(:adapter_name).and_return('PostGIS')
       end
 
       it "should hide views in postgis schema" do
         begin
         connection.create_view "postgis.hidden", "select 1", :force => true
         connection.create_view :myview, "select 2", :force => true
-        connection.views.should == ["myview"]
+        expect(connection.views).to eq(["myview"])
         ensure
           connection.execute 'DROP VIEW postgis.hidden' rescue nil
           connection.execute 'DROP VIEW myview' rescue nil

data/spec/schema_dumper_spec.rb

@@ -49,39 +49,39 @@ describe "Schema dump" do
 
   it "should include foreign_key definition" do
     with_foreign_key Post, :user_id, :users, :id do
-      dump_posts.should match(to_regexp(%q{t.foreign_key ["user_id"], "users", ["id"]}))
+      expect(dump_posts).to match(to_regexp(%q{t.foreign_key ["user_id"], "users", ["id"]}))
     end
   end
 
   it "should include foreign_key name" do
     with_foreign_key Post, :user_id, :users, :id, :name => "yippee" do
-      dump_posts.should match /foreign_key.*user_id.*users.*id.*:name => "yippee"/
+      expect(dump_posts).to match /foreign_key.*user_id.*users.*id.*:name => "yippee"/
     end
   end
 
   it "should sort foreign_key definitions" do
     with_foreign_keys Comment, [ [ :post_id, :posts, :id ], [ :commenter_id, :users, :id ]] do
-      dump_schema.should match(/foreign_key.+commenter_id.+foreign_key.+post_id/m)
+      expect(dump_schema).to match(/foreign_key.+commenter_id.+foreign_key.+post_id/m)
     end
   end
 
   context "with constraint dependencies" do
     it "should sort in Posts => Comments direction" do
       with_foreign_key Comment, :post_id, :posts, :id do
-        dump_schema.should match(%r{create_table "posts".*create_table "comments"}m)
+        expect(dump_schema).to match(%r{create_table "posts".*create_table "comments"}m)
       end
     end
     it "should sort in Comments => Posts direction" do
       with_foreign_key Post, :first_comment_id, :comments, :id do
-        dump_schema.should match(%r{create_table "comments".*create_table "posts"}m)
+        expect(dump_schema).to match(%r{create_table "comments".*create_table "posts"}m)
       end
     end
 
     it "should handle regexp in ignore_tables" do
       with_foreign_key Comment, :post_id, :posts, :id do
         dump = dump_schema(:ignore => /post/)
-        dump.should match /create_table "comments"/
-        dump.should_not match /create_table "posts"/
+        expect(dump).to match /create_table "comments"/
+        expect(dump).not_to match /create_table "posts"/
       end
     end
 
@@ -91,19 +91,19 @@ describe "Schema dump" do
     if SchemaPlusHelpers.postgresql?
       it "should dump the default hash expr as now()" do
         with_additional_column Post, :posted_at, :datetime, :default => :now do
-          dump_posts.should match(%r{t\.datetime\s+"posted_at",\s*(?:default:|:default =>)\s*\{\s*(?:expr:|:expr\s*=>)\s*"now\(\)"\s*\}})
+          expect(dump_posts).to match(%r{t\.datetime\s+"posted_at",\s*(?:default:|:default =>)\s*\{\s*(?:expr:|:expr\s*=>)\s*"now\(\)"\s*\}})
         end
       end
 
       it "should dump the default hash expr as CURRENT_TIMESTAMP" do
         with_additional_column Post, :posted_at, :datetime, :default => {:expr => 'date \'2001-09-28\''} do
-          dump_posts.should match(%r{t\.datetime\s+"posted_at",\s*(?:default:|:default =>)\s*'2001-09-28 00:00:00'})
+          expect(dump_posts).to match(%r{t\.datetime\s+"posted_at",\s*(?:default:|:default =>)\s*'2001-09-28 00:00:00'})
         end
       end
 
       it "can dump a complex default expression" do
         with_additional_column Post, :name, :string, :default => {:expr => 'substring(random()::text from 3 for 6)'} do
-          dump_posts.should match(%r{t\.string\s+"name",\s*(?:default:|:default\s*=>)\s*{\s*(?:expr:|:expr\s*=>)\s*"\\"substring\\"\(\(random\(\)\)::text, 3, 6\)"\s*}})
+          expect(dump_posts).to match(%r{t\.string\s+"name",\s*(?:default:|:default\s*=>)\s*{\s*(?:expr:|:expr\s*=>)\s*"\\"substring\\"\(\(random\(\)\)::text, 3, 6\)"\s*}})
         end
       end
     end
@@ -111,19 +111,19 @@ describe "Schema dump" do
     if SchemaPlusHelpers.sqlite3?
       it "should dump the default hash expr as now" do
         with_additional_column Post, :posted_at, :datetime, :default => :now do
-          dump_posts.should match(%r{t\.datetime\s+"posted_at",\s*(?:default:|:default =>)\s*\{\s*(?:expr:|:expr =>)\s*"\(DATETIME\('now'\)\)"\s*\}})
+          expect(dump_posts).to match(%r{t\.datetime\s+"posted_at",\s*(?:default:|:default =>)\s*\{\s*(?:expr:|:expr =>)\s*"\(DATETIME\('now'\)\)"\s*\}})
         end
       end
 
       it "should dump the default hash expr string as now" do
         with_additional_column Post, :posted_at, :datetime, :default => { :expr => "(DATETIME('now'))" } do
-          dump_posts.should match(%r{t\.datetime\s+"posted_at",\s*(?:default:|:default =>)\s*\{\s*(?:expr:|:expr =>)\s*"\(DATETIME\('now'\)\)"\s*\}})
+          expect(dump_posts).to match(%r{t\.datetime\s+"posted_at",\s*(?:default:|:default =>)\s*\{\s*(?:expr:|:expr =>)\s*"\(DATETIME\('now'\)\)"\s*\}})
         end
       end
 
       it "should dump the default value normally" do
         with_additional_column Post, :posted_at, :string, :default => "now" do
-          dump_posts.should match(%r{t\.string\s*"posted_at",\s*(?:default:|:default =>)\s*"now"})
+          expect(dump_posts).to match(%r{t\.string\s*"posted_at",\s*(?:default:|:default =>)\s*"now"})
         end
       end
     end
@@ -134,37 +134,37 @@ describe "Schema dump" do
     ActiveRecord::Migration.suppress_messages do
       ActiveRecord::Migration.change_column_default :posts, :string_no_default, nil
     end
-    dump_posts.should match(%r{t\.string\s+"string_no_default"\s*$})
+    expect(dump_posts).to match(%r{t\.string\s+"string_no_default"\s*$})
   end
 
   it "should include foreign_key options" do
     with_foreign_key Post, :user_id, :users, :id, :on_update => :cascade, :on_delete => :set_null do
-      dump_posts.should match(to_regexp(%q{t.foreign_key ["user_id"], "users", ["id"], :on_update => :cascade, :on_delete => :set_null}))
+      expect(dump_posts).to match(to_regexp(%q{t.foreign_key ["user_id"], "users", ["id"], :on_update => :cascade, :on_delete => :set_null}))
     end
   end
 
   it "should include index definition" do
     with_index Post, :user_id do
-      dump_posts.should match(to_regexp(%q{t.index ["user_id"]}))
+      expect(dump_posts).to match(to_regexp(%q{t.index ["user_id"]}))
     end
   end
 
   it "should include index name" do
     with_index Post, :user_id, :name => "custom_name" do
-      dump_posts.should match(to_regexp(%q{t.index ["user_id"], :name => "custom_name"}))
+      expect(dump_posts).to match(to_regexp(%q{t.index ["user_id"], :name => "custom_name"}))
     end
   end
   
   it "should define unique index" do
     with_index Post, :user_id, :name => "posts_user_id_index", :unique => true do
-      dump_posts.should match(to_regexp(%q{t.index ["user_id"], :name => "posts_user_id_index", :unique => true}))
+      expect(dump_posts).to match(to_regexp(%q{t.index ["user_id"], :name => "posts_user_id_index", :unique => true}))
     end
   end
 
   it "should sort indexes" do
     with_index Post, :user_id do
       with_index Post, :short_id do
-        dump_posts.should match(/on_short_id.+on_user_id/m)
+        expect(dump_posts).to match(/on_short_id.+on_user_id/m)
       end
     end
   end
@@ -173,7 +173,7 @@ describe "Schema dump" do
 
     it "should include index order" do
       with_index Post, [:user_id, :first_comment_id, :short_id], :order => { :user_id => :asc, :first_comment_id => :desc } do
-        dump_posts.should match(%r{t.index \["user_id", "first_comment_id", "short_id"\],.*:order => {"user_id" => :asc, "first_comment_id" => :desc, "short_id" => :asc}})
+        expect(dump_posts).to match(%r{t.index \["user_id", "first_comment_id", "short_id"\],.*:order => {"user_id" => :asc, "first_comment_id" => :desc, "short_id" => :asc}})
       end
     end
 
@@ -183,20 +183,20 @@ describe "Schema dump" do
 
     it "should define case insensitive index" do
       with_index Post, [:body, :string_no_default], :case_sensitive => false do
-        dump_posts.should match(to_regexp(%q{t.index ["body", "string_no_default"], :name => "index_posts_on_body_and_string_no_default", :case_sensitive => false}))
+        expect(dump_posts).to match(to_regexp(%q{t.index ["body", "string_no_default"], :name => "index_posts_on_body_and_string_no_default", :case_sensitive => false}))
       end
     end
 
     it "should define index with type cast" do
       with_index Post, [:integer_col], :name => "index_with_type_cast", :expression => "LOWER(integer_col::text)" do
-        dump_posts.should match(to_regexp(%q{t.index :name => "index_with_type_cast", :expression => "lower((integer_col)::text)"}))
+        expect(dump_posts).to match(to_regexp(%q{t.index :name => "index_with_type_cast", :expression => "lower((integer_col)::text)"}))
       end
     end
 
 
     it "should define case insensitive index with mixed ids and strings" do
       with_index Post, [:user_id, :str_short, :short_id, :body], :case_sensitive => false do
-        dump_posts.should match(to_regexp(%q{t.index ["user_id", "str_short", "short_id", "body"], :name => "index_posts_on_user_id_and_str_short_and_short_id_and_body", :case_sensitive => false}))
+        expect(dump_posts).to match(to_regexp(%q{t.index ["user_id", "str_short", "short_id", "body"], :name => "index_posts_on_user_id_and_str_short_and_short_id_and_body", :case_sensitive => false}))
       end
     end
 
@@ -204,47 +204,47 @@ describe "Schema dump" do
       col_name = "#{col_type}_col"
       it "should define case insensitive index that includes an #{col_type}" do
         with_index Post, [:user_id, :str_short, col_name, :body], :case_sensitive => false do
-          dump_posts.should match(to_regexp(%Q!t.index ["user_id", "str_short", "#{col_name}", "body"], :name => "index_posts_on_user_id_and_str_short_and_#{col_name}_and_body", :case_sensitive => false!))
+          expect(dump_posts).to match(to_regexp(%Q!t.index ["user_id", "str_short", "#{col_name}", "body"], :name => "index_posts_on_user_id_and_str_short_and_#{col_name}_and_body", :case_sensitive => false!))
         end
       end
     end
 
     it "should define conditions" do
       with_index Post, :user_id, :name => "posts_user_id_index", :conditions => "user_id IS NOT NULL" do
-        dump_posts.should match(to_regexp(%q{t.index ["user_id"], :name => "posts_user_id_index", :conditions => "(user_id IS NOT NULL)"}))
+        expect(dump_posts).to match(to_regexp(%q{t.index ["user_id"], :name => "posts_user_id_index", :conditions => "(user_id IS NOT NULL)"}))
       end
     end
 
     it "should define expression" do
       with_index Post, :name => "posts_freaky_index", :expression => "USING hash (least(id, user_id))" do
-        dump_posts.should match(to_regexp(%q{t.index :name => "posts_freaky_index", :kind => "hash", :expression => "LEAST(id, user_id)"}))
+        expect(dump_posts).to match(to_regexp(%q{t.index :name => "posts_freaky_index", :kind => "hash", :expression => "LEAST(id, user_id)"}))
       end
     end
 
     it "should dump unique: true with expression (Issue #142)" do
       with_index Post, :name => "posts_user_body_index", :unique => true, :expression => "BTRIM(LOWER(body))" do
-        dump_posts.should match(%r{#{to_regexp(%q{t.index :name => "posts_user_body_index", :unique => true, :expression => "btrim(lower(body))"})}$})
+        expect(dump_posts).to match(%r{#{to_regexp(%q{t.index :name => "posts_user_body_index", :unique => true, :expression => "btrim(lower(body))"})}$})
       end
     end
 
 
     it "should not define :case_sensitive => false with non-trivial expression" do
       with_index Post, :name => "posts_user_body_index", :expression => "BTRIM(LOWER(body))" do
-        dump_posts.should match(%r{#{to_regexp(%q{t.index :name => "posts_user_body_index", :expression => "btrim(lower(body))"})}$})
+        expect(dump_posts).to match(%r{#{to_regexp(%q{t.index :name => "posts_user_body_index", :expression => "btrim(lower(body))"})}$})
       end
     end
 
 
     it "should define kind" do
       with_index Post, :name => "posts_body_index", :expression => "USING hash (body)" do
-        dump_posts.should match(to_regexp(%q{t.index ["body"], :name => "posts_body_index", :kind => "hash"}))
+        expect(dump_posts).to match(to_regexp(%q{t.index ["body"], :name => "posts_body_index", :kind => "hash"}))
       end
     end
 
     it "should not include index order for non-ordered index types" do
       with_index Post, :user_id, :kind => :hash do
-        dump_posts.should match(to_regexp(%q{t.index ["user_id"], :name => "index_posts_on_user_id", :kind => "hash"}))
-        dump_posts.should_not match(%r{:order})
+        expect(dump_posts).to match(to_regexp(%q{t.index ["user_id"], :name => "index_posts_on_user_id", :kind => "hash"}))
+        expect(dump_posts).not_to match(%r{:order})
       end
     end
 
@@ -265,11 +265,11 @@ describe "Schema dump" do
       end
 
       it "should dump constraints after the tables they reference" do
-        dump_schema.should match(%r{create_table "comments".*foreign_key.*\["first_comment_id"\], "comments", \["id"\]}m)
-        dump_schema.should match(%r{create_table "posts".*foreign_key.*\["first_post_id"\], "posts", \["id"\]}m)
-        dump_schema.should match(%r{create_table "posts".*foreign_key.*\["post_id"\], "posts", \["id"\]}m)
-        dump_schema.should match(%r{create_table "users".*foreign_key.*\["commenter_id"\], "users", \["id"\]}m)
-        dump_schema.should match(%r{create_table "users".*foreign_key.*\["user_id"\], "users", \["id"\]}m)
+        expect(dump_schema).to match(%r{create_table "comments".*foreign_key.*\["first_comment_id"\], "comments", \["id"\]}m)
+        expect(dump_schema).to match(%r{create_table "posts".*foreign_key.*\["first_post_id"\], "posts", \["id"\]}m)
+        expect(dump_schema).to match(%r{create_table "posts".*foreign_key.*\["post_id"\], "posts", \["id"\]}m)
+        expect(dump_schema).to match(%r{create_table "users".*foreign_key.*\["commenter_id"\], "users", \["id"\]}m)
+        expect(dump_schema).to match(%r{create_table "users".*foreign_key.*\["user_id"\], "users", \["id"\]}m)
       end
     end
   end

data/spec/schema_spec.rb

@@ -23,12 +23,12 @@ describe ActiveRecord::Schema do
     it "should create only explicity added indexes" do
       do_schema
       expected = SchemaPlusHelpers.mysql? ? 2 : 1
-      connection.tables.collect { |table| connection.indexes(table) }.flatten.should have(expected).items
+      expect(connection.tables.collect { |table| connection.indexes(table) }.flatten.size).to eq(expected)
     end
 
     it "should create only explicity added foriegn keys" do
       do_schema
-      connection.tables.collect { |table| connection.foreign_keys(table) }.flatten.should have(2).items
+      expect(connection.tables.collect { |table| connection.foreign_keys(table) }.flatten.size).to eq(2)
     end
 
   end

data/spec/spec_helper.rb

@@ -1,5 +1,5 @@
 require 'simplecov'
-require 'simplecov-gem-adapter'
+require 'simplecov-gem-profile'
 SimpleCov.use_merging true
 SimpleCov.merge_timeout 3600
 SimpleCov.start "gem"

data/spec/support/matchers/have_index.rb

@@ -3,25 +3,34 @@ module SchemaPlusMatchers
   class HaveIndex
 
     def initialize(expectation, options = {})
-      set_required_columns(expectation, options)
+      set_required_columns(expectation)
+      @unique = options.delete(:unique)
+      @name   = options.delete(:name)
     end
 
     def matches?(model)
       @model = model
-      @model.indexes.any? do |index|
-        index.columns.to_set == @required_columns &&
-          (@unique  ? index.unique : true) &&
-          (@name    ? index.name == @name.to_s : true)
+      indexes = @model.indexes.select { |index| index.columns.to_set == @required_columns }
+      if indexes.length > 1
+        @too_many = indexes.length
+        return false
       end
+      index = indexes.first
+      return index && (@unique ? index.unique : true) && (@name ? index.name == @name.to_s : true)
     end
 
-    def failure_message_for_should(should_not = false)
-      invert = should_not ? "not to" : ""
-      "Expected #{@model.table_name} to #{invert} contain index on #{@required_columns.entries.inspect}"
+    def failure_message(should_not = false)
+      invert = should_not ? "not to" : "to"
+      what = ""
+      what += "unique " if @unique
+      what += "named '{@name}'" if @name
+      msg = "Expected #{@model.table_name} #{invert} contain one #{what}index on #{@required_columns.entries.inspect}"
+      msg += "; found #{@too_many} indexes" if @too_many
+      msg
     end
 
-    def failure_message_for_should_not
-      failure_message_for_should(true)
+    def failure_message_when_negated
+      failure_message(true)
     end
 
     def on(expectation)
@@ -30,10 +39,8 @@ module SchemaPlusMatchers
     end
 
     private
-    def set_required_columns(expectation, options = {})
+    def set_required_columns(expectation)
       @required_columns = Array(expectation).collect(&:to_s).to_set
-      @unique = options.delete(:unique)
-      @name   = options.delete(:name)
     end
 
   end

data/spec/support/matchers/reference.rb

@@ -27,7 +27,7 @@ module SchemaPlusMatchers
       !@result.empty?
     end
 
-    def failure_message_for_should(should_not = false)
+    def failure_message(should_not = false)
       target_column_names = @column_names.present? ? "(#{@column_names.join(', ')})" : "" 
       destinantion_column_names = @references_table_name ? "#{@references_table_name}(#{@references_column_names.join(', ')})" : "anything"
       invert = should_not ? 'not' : ''
@@ -41,8 +41,8 @@ module SchemaPlusMatchers
       msg
     end
 
-    def failure_message_for_should_not
-      failure_message_for_should(true)
+    def failure_message_when_negated
+      failure_message(true)
     end
   
     def on(*column_names)

data/spec/views_spec.rb

@@ -26,36 +26,36 @@ describe ActiveRecord do
     end
 
     it "should query correctly" do
-      AOnes.all.collect(&:s).should == %W[one_one one_two]
-      ABOnes.all.collect(&:s).should == %W[one_one]
+      expect(AOnes.all.collect(&:s)).to eq(%W[one_one one_two])
+      expect(ABOnes.all.collect(&:s)).to eq(%W[one_one])
     end
 
     it "should instrospect" do
       # for postgresql, ignore views named pg_*
-      connection.views.sort.should == %W[a_ones ab_ones]
-      connection.view_definition('a_ones').should match(%r{^SELECT .*b.*,.*s.* FROM .*items.* WHERE .*a.* = 1}i)
-      connection.view_definition('ab_ones').should match(%r{^SELECT .*s.* FROM .*a_ones.* WHERE .*b.* = 1}i)
+      expect(connection.views.sort).to eq(%W[a_ones ab_ones])
+      expect(connection.view_definition('a_ones')).to match(%r{^ ?SELECT .*b.*,.*s.* FROM .*items.* WHERE .*a.* = 1}mi)
+      expect(connection.view_definition('ab_ones')).to match(%r{^ ?SELECT .*s.* FROM .*a_ones.* WHERE .*b.* = 1}mi)
     end
 
     it "should not be listed as a table" do
-      connection.tables.should_not include('a_ones')
-      connection.tables.should_not include('ab_ones')
+      expect(connection.tables).not_to include('a_ones')
+      expect(connection.tables).not_to include('ab_ones')
     end
 
 
     it "should be included in schema dump" do
-      dump.should match(%r{create_view "a_ones", "SELECT .*b.*,.*s.* FROM .*items.* WHERE .*a.* = 1.*, :force => true}i)
-      dump.should match(%r{create_view "ab_ones", "SELECT .*s.* FROM .*a_ones.* WHERE .*b.* = 1.*, :force => true}i)
+      expect(dump).to match(%r{create_view "a_ones", " ?SELECT .*b.*,.*s.* FROM .*items.* WHERE .*a.* = 1.*, :force => true}mi)
+      expect(dump).to match(%r{create_view "ab_ones", " ?SELECT .*s.* FROM .*a_ones.* WHERE .*b.* = 1.*, :force => true}mi)
     end
 
     it "should be included in schema dump in dependency order" do
-      dump.should match(%r{create_table "items".*create_view "a_ones".*create_view "ab_ones"}m) 
+      expect(dump).to match(%r{create_table "items".*create_view "a_ones".*create_view "ab_ones"}m) 
     end
 
     it "should not be included in schema if listed in ignore_tables" do
       dump(ignore_tables: /b_/) do |dump|
-        dump.should match(%r{create_view "a_ones", "SELECT .*b.*,.*s.* FROM .*items.* WHERE .*a.* = 1.*, :force => true}i)
-        dump.should_not match(%r{"ab_ones"})
+        expect(dump).to match(%r{create_view "a_ones", " ?SELECT .*b.*,.*s.* FROM .*items.* WHERE .*a.* = 1.*, :force => true}mi)
+        expect(dump).not_to match(%r{"ab_ones"})
       end
     end
 
@@ -69,7 +69,7 @@ describe ActiveRecord do
       # initialize the test database when testing.  this meant that the
       # test database had views into the development database.
       db = connection.respond_to?(:current_database)? connection.current_database : ActiveRecord::Base.configurations['schema_plus'][:database]
-      dump.should_not match(%r{#{connection.quote_table_name(db)}[.]})
+      expect(dump).not_to match(%r{#{connection.quote_table_name(db)}[.]})
     end
 
     context "duplicate view creation" do
@@ -91,7 +91,7 @@ describe ActiveRecord do
 
       it "should override existing definition if :force true" do
         migration.create_view('dupe_me', 'SELECT * FROM items WHERE (a=2)', :force => true)
-        connection.view_definition('dupe_me').should =~ %r{WHERE .*a.*=.*2}i
+        expect(connection.view_definition('dupe_me')).to match(%r{WHERE .*a.*=.*2}i)
       end
     end
 
@@ -111,17 +111,17 @@ describe ActiveRecord do
 
         it "should introspect WITH CHECK OPTION" do
           migration.create_view :check, 'SELECT * FROM items WHERE (a=2) WITH CHECK OPTION'
-          connection.view_definition('check').should match(%r{WITH CASCADED CHECK OPTION$})
+          expect(connection.view_definition('check')).to match(%r{WITH CASCADED CHECK OPTION$})
         end
 
         it "should introspect WITH CASCADED CHECK OPTION" do
           migration.create_view :check, 'SELECT * FROM items WHERE (a=2) WITH CASCADED CHECK OPTION'
-          connection.view_definition('check').should match(%r{WITH CASCADED CHECK OPTION$})
+          expect(connection.view_definition('check')).to match(%r{WITH CASCADED CHECK OPTION$})
         end
 
         it "should introspect WITH LOCAL CHECK OPTION" do
           migration.create_view :check, 'SELECT * FROM items WHERE (a=2) WITH LOCAL CHECK OPTION'
-          connection.view_definition('check').should match(%r{WITH LOCAL CHECK OPTION$})
+          expect(connection.view_definition('check')).to match(%r{WITH LOCAL CHECK OPTION$})
         end
       end 
     end