dump 1.0.3 → 1.0.4

data/spec/dummy-4.1/config/initializers/backtrace_silencers.rb

@@ -0,0 +1,7 @@
+# Be sure to restart your server when you modify this file.
+
+# You can add backtrace silencers for libraries that you're using but don't wish to see in your backtraces.
+# Rails.backtrace_cleaner.add_silencer { |line| line =~ /my_noisy_library/ }
+
+# You can also remove all the silencers if you're trying to debug a problem that might stem from framework code.
+# Rails.backtrace_cleaner.remove_silencers!

data/spec/dummy-4.1/config/initializers/cookies_serializer.rb

@@ -0,0 +1,3 @@
+# Be sure to restart your server when you modify this file.
+
+Rails.application.config.action_dispatch.cookies_serializer = :json

data/spec/dummy-4.1/config/initializers/filter_parameter_logging.rb

@@ -0,0 +1,4 @@
+# Be sure to restart your server when you modify this file.
+
+# Configure sensitive parameters which will be filtered from the log file.
+Rails.application.config.filter_parameters += [:password]

data/spec/dummy-4.1/config/initializers/inflections.rb

@@ -0,0 +1,16 @@
+# Be sure to restart your server when you modify this file.
+
+# Add new inflection rules using the following format. Inflections
+# are locale specific, and you may define rules for as many different
+# locales as you wish. All of these examples are active by default:
+# ActiveSupport::Inflector.inflections(:en) do |inflect|
+#   inflect.plural /^(ox)$/i, '\1en'
+#   inflect.singular /^(ox)en/i, '\1'
+#   inflect.irregular 'person', 'people'
+#   inflect.uncountable %w( fish sheep )
+# end
+
+# These inflection rules are supported but not enabled by default:
+# ActiveSupport::Inflector.inflections(:en) do |inflect|
+#   inflect.acronym 'RESTful'
+# end

data/spec/dummy-4.1/config/initializers/mime_types.rb

@@ -0,0 +1,4 @@
+# Be sure to restart your server when you modify this file.
+
+# Add new mime types for use in respond_to blocks:
+# Mime::Type.register "text/richtext", :rtf

data/spec/dummy-4.1/config/initializers/session_store.rb

@@ -0,0 +1,3 @@
+# Be sure to restart your server when you modify this file.
+
+Rails.application.config.session_store :cookie_store, key: '_dummy-4_1_session'

data/spec/dummy-4.1/config/initializers/wrap_parameters.rb

@@ -0,0 +1,14 @@
+# Be sure to restart your server when you modify this file.
+
+# This file contains settings for ActionController::ParamsWrapper which
+# is enabled by default.
+
+# Enable parameter wrapping for JSON. You can disable this by setting :format to an empty array.
+ActiveSupport.on_load(:action_controller) do
+  wrap_parameters format: [:json] if respond_to?(:wrap_parameters)
+end
+
+# To enable root element in JSON for ActiveRecord objects.
+# ActiveSupport.on_load(:active_record) do
+#  self.include_root_in_json = true
+# end

data/spec/dummy-4.1/config/locales/en.yml

@@ -0,0 +1,23 @@
+# Files in the config/locales directory are used for internationalization
+# and are automatically loaded by Rails. If you want to use locales other
+# than English, add the necessary files in this directory.
+#
+# To use the locales, use `I18n.t`:
+#
+#     I18n.t 'hello'
+#
+# In views, this is aliased to just `t`:
+#
+#     <%= t('hello') %>
+#
+# To use a different locale, set it with `I18n.locale`:
+#
+#     I18n.locale = :es
+#
+# This would use the information in config/locales/es.yml.
+#
+# To learn more, please read the Rails Internationalization guide
+# available at http://guides.rubyonrails.org/i18n.html.
+
+en:
+  hello: "Hello world"

data/spec/dummy-4.1/config/routes.rb

@@ -0,0 +1,56 @@
+Rails.application.routes.draw do
+  # The priority is based upon order of creation: first created -> highest priority.
+  # See how all your routes lay out with "rake routes".
+
+  # You can have the root of your site routed with "root"
+  # root 'welcome#index'
+
+  # Example of regular route:
+  #   get 'products/:id' => 'catalog#view'
+
+  # Example of named route that can be invoked with purchase_url(id: product.id)
+  #   get 'products/:id/purchase' => 'catalog#purchase', as: :purchase
+
+  # Example resource route (maps HTTP verbs to controller actions automatically):
+  #   resources :products
+
+  # Example resource route with options:
+  #   resources :products do
+  #     member do
+  #       get 'short'
+  #       post 'toggle'
+  #     end
+  #
+  #     collection do
+  #       get 'sold'
+  #     end
+  #   end
+
+  # Example resource route with sub-resources:
+  #   resources :products do
+  #     resources :comments, :sales
+  #     resource :seller
+  #   end
+
+  # Example resource route with more complex sub-resources:
+  #   resources :products do
+  #     resources :comments
+  #     resources :sales do
+  #       get 'recent', on: :collection
+  #     end
+  #   end
+
+  # Example resource route with concerns:
+  #   concern :toggleable do
+  #     post 'toggle'
+  #   end
+  #   resources :posts, concerns: :toggleable
+  #   resources :photos, concerns: :toggleable
+
+  # Example resource route within a namespace:
+  #   namespace :admin do
+  #     # Directs /admin/products/* to Admin::ProductsController
+  #     # (app/controllers/admin/products_controller.rb)
+  #     resources :products
+  #   end
+end

data/spec/dummy-4.1/config/secrets.yml

@@ -0,0 +1,22 @@
+# Be sure to restart your server when you modify this file.
+
+# Your secret key is used for verifying the integrity of signed cookies.
+# If you change this key, all old signed cookies will become invalid!
+
+# Make sure the secret is at least 30 characters and all random,
+# no regular words or you'll be exposed to dictionary attacks.
+# You can use `rake secret` to generate a secure secret key.
+
+# Make sure the secrets in this file are kept private
+# if you're sharing your code publicly.
+
+development:
+  secret_key_base: 97498ce7962ef78b51283c750ba56fbb1bc7895b8e201b098c67c10954832ad9e4f18943edade5757ed4e47f693bbc0ceb2e3dc71df9f2973a20a3bcf4120b67
+
+test:
+  secret_key_base: 5460be29a409fb920786367be99a3c8837e1c08c2e4ad4e535fcec4b0cfdf8771658f7fa1ee3a37205bc85a12efd51a85b945a12694d76a4d303092d51359e00
+
+# Do not keep production secrets in the repository,
+# instead read values from the environment.
+production:
+  secret_key_base: <%= ENV["SECRET_KEY_BASE"] %>

data/spec/dummy-4.1/db/seeds.rb

@@ -0,0 +1,7 @@
+# This file should contain all the record creation needed to seed the database with its default values.
+# The data can then be loaded with the rake db:seed (or created alongside the db with db:setup).
+#
+# Examples:
+#
+#   cities = City.create([{ name: 'Chicago' }, { name: 'Copenhagen' }])
+#   Mayor.create(name: 'Emanuel', city: cities.first)

data/spec/lib/dump_rake/dump_reader_spec.rb

@@ -23,22 +23,22 @@ describe DumpReader do
   describe "restore" do
     it "should create selves instance and open" do
       @dump = double('dump')
-      @dump.should_receive(:open)
-      DumpReader.should_receive(:new).with('/abc/123.tmp').and_return(@dump)
+      expect(@dump).to receive(:open)
+      expect(DumpReader).to receive(:new).with('/abc/123.tmp').and_return(@dump)
       DumpReader.restore('/abc/123.tmp')
     end
 
     it "should call dump subroutines" do
       @dump = double('dump')
-      @dump.stub(:open).and_yield(@dump)
-      @dump.stub(:silence).and_yield
-      DumpReader.stub(:new).and_return(@dump)
+      allow(@dump).to receive(:open).and_yield(@dump)
+      allow(@dump).to receive(:silence).and_yield
+      allow(DumpReader).to receive(:new).and_return(@dump)
 
-      @dump.should_receive(:read_config).ordered
-      @dump.should_receive(:migrate_down).ordered
-      @dump.should_receive(:read_schema).ordered
-      @dump.should_receive(:read_tables).ordered
-      @dump.should_receive(:read_assets).ordered
+      expect(@dump).to receive(:read_config).ordered
+      expect(@dump).to receive(:migrate_down).ordered
+      expect(@dump).to receive(:read_schema).ordered
+      expect(@dump).to receive(:read_tables).ordered
+      expect(@dump).to receive(:read_assets).ordered
 
       DumpReader.restore('/abc/123.tmp')
     end
@@ -70,20 +70,20 @@ describe DumpReader do
             qqq: 123
             www: 345
         TEXT
-        "#{@summary}".should == output.gsub(/#{output[/^\s+/]}/, '  ')
+        expect("#{@summary}").to eq(output.gsub(/#{output[/^\s+/]}/, '  '))
       end
 
       it "should pluralize" do
-        Summary.pluralize(0, 'file').should == '0 files'
-        Summary.pluralize(1, 'file').should == '1 file'
-        Summary.pluralize(10, 'file').should == '10 files'
+        expect(Summary.pluralize(0, 'file')).to eq('0 files')
+        expect(Summary.pluralize(1, 'file')).to eq('1 file')
+        expect(Summary.pluralize(10, 'file')).to eq('10 files')
       end
     end
 
     it "should create selves instance and open" do
       @dump = double('dump')
-      @dump.should_receive(:open)
-      DumpReader.should_receive(:new).with('/abc/123.tmp').and_return(@dump)
+      expect(@dump).to receive(:open)
+      expect(DumpReader).to receive(:new).with('/abc/123.tmp').and_return(@dump)
       DumpReader.summary('/abc/123.tmp')
     end
 
@@ -97,19 +97,19 @@ describe DumpReader do
         formatted_tables = ['a: 10 rows', 'b: 20 rows', 'c: 666 rows']
 
         @dump = double('dump')
-        @dump.stub(:config).and_return(:tables => tables, :assets => assets)
-        @dump.stub(:open).and_yield(@dump)
-        DumpReader.stub(:new).and_return(@dump)
-        @dump.should_receive(:read_config)
+        allow(@dump).to receive(:config).and_return(:tables => tables, :assets => assets)
+        allow(@dump).to receive(:open).and_yield(@dump)
+        allow(DumpReader).to receive(:new).and_return(@dump)
+        expect(@dump).to receive(:read_config)
 
         @summary = double('summary')
-        @summary.should_receive(:header).with('Tables')
-        @summary.should_receive(:data).with(formatted_tables)
-        @summary.should_receive(:header).with('Assets')
-        @summary.should_receive(:data).with(formatted_assets)
-        Summary.stub(:new).and_return(@summary)
+        expect(@summary).to receive(:header).with('Tables')
+        expect(@summary).to receive(:data).with(formatted_tables)
+        expect(@summary).to receive(:header).with('Assets')
+        expect(@summary).to receive(:data).with(formatted_assets)
+        allow(Summary).to receive(:new).and_return(@summary)
 
-        DumpReader.summary('/abc/123.tmp').should == @summary
+        expect(DumpReader.summary('/abc/123.tmp')).to eq(@summary)
       end
     end
 
@@ -120,25 +120,25 @@ describe DumpReader do
 
       schema = double('schema')
       schema_lines = double('schema_lines')
-      schema.should_receive(:split).with("\n").and_return(schema_lines)
+      expect(schema).to receive(:split).with("\n").and_return(schema_lines)
 
       @dump = double('dump')
-      @dump.stub(:config).and_return(:tables => tables, :assets => assets)
-      @dump.stub(:open).and_yield(@dump)
-      @dump.stub(:schema).and_return(schema)
-      DumpReader.stub(:new).and_return(@dump)
-      @dump.should_receive(:read_config)
+      allow(@dump).to receive(:config).and_return(:tables => tables, :assets => assets)
+      allow(@dump).to receive(:open).and_yield(@dump)
+      allow(@dump).to receive(:schema).and_return(schema)
+      allow(DumpReader).to receive(:new).and_return(@dump)
+      expect(@dump).to receive(:read_config)
 
       @summary = double('summary')
-      @summary.should_receive(:header).with('Tables')
-      @summary.should_receive(:data).with(formatted_tables)
-      @summary.should_receive(:header).with('Assets')
-      @summary.should_receive(:data).with(formatted_assets)
-      @summary.should_receive(:header).with('Schema')
-      @summary.should_receive(:data).with(schema_lines)
-      Summary.stub(:new).and_return(@summary)
-
-      DumpReader.summary('/abc/123.tmp', :schema => true).should == @summary
+      expect(@summary).to receive(:header).with('Tables')
+      expect(@summary).to receive(:data).with(formatted_tables)
+      expect(@summary).to receive(:header).with('Assets')
+      expect(@summary).to receive(:data).with(formatted_assets)
+      expect(@summary).to receive(:header).with('Schema')
+      expect(@summary).to receive(:data).with(schema_lines)
+      allow(Summary).to receive(:new).and_return(@summary)
+
+      expect(DumpReader.summary('/abc/123.tmp', :schema => true)).to eq(@summary)
     end
   end
 
@@ -146,13 +146,13 @@ describe DumpReader do
     it "should set stream to gzipped tar reader" do
       @gzip = double('gzip')
       @stream = double('stream')
-      Zlib::GzipReader.should_receive(:open).with(Pathname("123.tgz")).and_yield(@gzip)
-      Archive::Tar::Minitar::Input.should_receive(:open).with(@gzip).and_yield(@stream)
+      expect(Zlib::GzipReader).to receive(:open).with(Pathname("123.tgz")).and_yield(@gzip)
+      expect(Archive::Tar::Minitar::Input).to receive(:open).with(@gzip).and_yield(@stream)
 
       @dump = DumpReader.new('123.tgz')
       @dump.open do |dump|
-        dump.should == @dump
-        dump.stream.should == @stream
+        expect(dump).to eq(@dump)
+        expect(dump.stream).to eq(@stream)
       end
     end
   end
@@ -164,60 +164,60 @@ describe DumpReader do
       @e3 = double('e3', :full_name => 'second.dump', :read => 'second.dump_data')
       @stream = [@e1, @e2, @e3]
       @dump = DumpReader.new('123.tgz')
-      @dump.stub(:stream).and_return(@stream)
+      allow(@dump).to receive(:stream).and_return(@stream)
     end
 
     describe "find_entry" do
       it "should find first entry in stream equal string" do
         @dump.find_entry('config') do |entry|
-          entry.should == @e1
+          expect(entry).to eq(@e1)
         end
       end
 
       it "should find first entry in stream matching regexp" do
         @dump.find_entry(/\.dump$/) do |entry|
-          entry.should == @e2
+          expect(entry).to eq(@e2)
         end
       end
 
       it "should return result of block" do
-        @dump.find_entry(/\.dump$/) do |entry|
+        expect(@dump.find_entry(/\.dump$/) do |entry|
           'hello'
-        end.should == 'hello'
+        end).to eq('hello')
       end
     end
 
     describe "read_entry" do
       it "should call find_entry" do
-        @dump.should_receive(:find_entry).with('config').and_yield(@e1)
+        expect(@dump).to receive(:find_entry).with('config').and_yield(@e1)
         @dump.read_entry('config')
       end
 
       it "should read entries data" do
-        @dump.read_entry('config').should == 'config_data'
+        expect(@dump.read_entry('config')).to eq('config_data')
       end
     end
 
     describe "read_entry_to_file" do
       it "should call find_entry" do
-        @dump.should_receive(:find_entry).with('config')
+        expect(@dump).to receive(:find_entry).with('config')
         @dump.read_entry_to_file('config')
       end
 
       it "should open temp file, write data there, rewind and yield that file" do
         @entry = double('entry')
-        @dump.stub(:find_entry).and_yield(@entry)
+        allow(@dump).to receive(:find_entry).and_yield(@entry)
         @temp = double('temp')
-        Tempfile.should_receive(:open).and_yield(@temp)
+        expect(Tempfile).to receive(:open).and_yield(@temp)
 
-        @entry.should_receive(:eof?).and_return(false, false, true)
-        @entry.should_receive(:read).with(4096).and_return('a' * 4096, 'b' * 1000)
-        @temp.should_receive(:write).with('a' * 4096).ordered
-        @temp.should_receive(:write).with('b' * 1000).ordered
-        @temp.should_receive(:rewind).ordered
+        expect(@entry).to receive(:eof?).and_return(false, false, true)
+        expect(@entry).to receive(:read).with(4096).and_return('a' * 4096, 'b' * 1000)
+        expect(@temp).to receive(:write).with('a' * 4096).ordered
+        expect(@temp).to receive(:write).with('b' * 1000).ordered
+        expect(@temp).to receive(:rewind).ordered
 
         @dump.read_entry_to_file('config') do |f|
-          f.should == @temp
+          expect(f).to eq(@temp)
         end
       end
     end
@@ -227,24 +227,24 @@ describe DumpReader do
     before do
       @stream = double('stream')
       @dump = DumpReader.new('123.tgz')
-      @dump.stub(:stream).and_return(@stream)
-      Progress.stub(:io).and_return(StringIO.new)
+      allow(@dump).to receive(:stream).and_return(@stream)
+      allow(Progress).to receive(:io).and_return(StringIO.new)
     end
 
     describe "read_config" do
       it "should read config" do
         @data = {:tables => {:first => 1}, :assets => %w[images videos]}
-        @dump.should_receive(:read_entry).with('config').and_return(Marshal.dump(@data))
+        expect(@dump).to receive(:read_entry).with('config').and_return(Marshal.dump(@data))
 
         @dump.read_config
-        @dump.config.should == @data
+        expect(@dump.config).to eq(@data)
       end
     end
 
     describe "migrate_down" do
       it "should not invoke rake tasks or find_entry if migrate_down is 0, no or false" do
-        Rake::Task.should_not_receive(:[])
-        @dump.should_not_receive(:find_entry)
+        expect(Rake::Task).not_to receive(:[])
+        expect(@dump).not_to receive(:find_entry)
 
         DumpRake::Env.with_env(:migrate_down => '0') do
           @dump.migrate_down
@@ -260,10 +260,10 @@ describe DumpReader do
       it "should invoke db:drop and db:create if migrate_down is reset" do
         @load_task = double('drop_task')
         @dump_task = double('create_task')
-        Rake::Task.should_receive(:[]).with('db:drop').and_return(@load_task)
-        Rake::Task.should_receive(:[]).with('db:create').and_return(@dump_task)
-        @load_task.should_receive(:invoke)
-        @dump_task.should_receive(:invoke)
+        expect(Rake::Task).to receive(:[]).with('db:drop').and_return(@load_task)
+        expect(Rake::Task).to receive(:[]).with('db:create').and_return(@dump_task)
+        expect(@load_task).to receive(:invoke)
+        expect(@dump_task).to receive(:invoke)
 
         DumpRake::Env.with_env(:migrate_down => 'reset') do
           @dump.migrate_down
@@ -273,8 +273,8 @@ describe DumpReader do
       [nil, '1'].each do |migrate_down_value|
         describe "when migrate_down is #{migrate_down_value.inspect}" do
           it "should not find_entry if table schema_migrations is not present" do
-            @dump.stub(:avaliable_tables).and_return(%w[first])
-            @dump.should_not_receive(:find_entry)
+            allow(@dump).to receive(:avaliable_tables).and_return(%w[first])
+            expect(@dump).not_to receive(:find_entry)
 
             DumpRake::Env.with_env(:migrate_down => migrate_down_value) do
               @dump.migrate_down
@@ -282,8 +282,8 @@ describe DumpReader do
           end
 
           it "should find schema_migrations.dump if table schema_migrations is present" do
-            @dump.stub(:avaliable_tables).and_return(%w[schema_migrations first])
-            @dump.should_receive(:find_entry).with('schema_migrations.dump')
+            allow(@dump).to receive(:avaliable_tables).and_return(%w[schema_migrations first])
+            expect(@dump).to receive(:find_entry).with('schema_migrations.dump')
 
             DumpRake::Env.with_env(:migrate_down => migrate_down_value) do
               @dump.migrate_down
@@ -298,29 +298,29 @@ describe DumpReader do
             end
             @entry.rewind
 
-            @dump.stub(:avaliable_tables).and_return(%w[schema_migrations first])
-            @dump.should_receive(:find_entry).with('schema_migrations.dump').and_yield(@entry)
-            @dump.should_receive('table_rows').with('schema_migrations').and_return(%w[1 2 4 5 6 7].map{ |version| {'version' => version} })
+            allow(@dump).to receive(:avaliable_tables).and_return(%w[schema_migrations first])
+            expect(@dump).to receive(:find_entry).with('schema_migrations.dump').and_yield(@entry)
+            expect(@dump).to receive('table_rows').with('schema_migrations').and_return(%w[1 2 4 5 6 7].map{ |version| {'version' => version} })
 
             @versions = []
             @migrate_down_task = double('migrate_down_task')
-            @migrate_down_task.should_receive('invoke').exactly(2).times.with do
+            expect(@migrate_down_task).to receive('invoke').exactly(3).times do
               version = DumpRake::Env['VERSION']
               @versions << version
               if version == '6'
                 raise ActiveRecord::IrreversibleMigration
               end
             end
-            @migrate_down_task.should_receive('reenable').exactly(3).times
+            expect(@migrate_down_task).to receive('reenable').exactly(3).times
 
-            $stderr.should_receive('puts').with("Irreversible migration: 6")
+            expect($stderr).to receive('puts').with("Irreversible migration: 6")
 
-            Rake::Task.should_receive(:[]).with('db:migrate:down').exactly(3).times.and_return(@migrate_down_task)
+            expect(Rake::Task).to receive(:[]).with('db:migrate:down').exactly(3).times.and_return(@migrate_down_task)
 
             DumpRake::Env.with_env(:migrate_down => migrate_down_value) do
               @dump.migrate_down
             end
-            @versions.should == %w[5 6 7].reverse
+            expect(@versions).to eq(%w[5 6 7].reverse)
           end
         end
       end
@@ -329,33 +329,33 @@ describe DumpReader do
     describe "read_schema" do
       before do
         @task = double('task')
-        Rake::Task.stub(:[]).and_return(@task)
-        @task.stub(:invoke)
+        allow(Rake::Task).to receive(:[]).and_return(@task)
+        allow(@task).to receive(:invoke)
       end
 
       it "should read schema.rb to temp file" do
-        @dump.should_receive(:read_entry_to_file).with('schema.rb')
+        expect(@dump).to receive(:read_entry_to_file).with('schema.rb')
         @dump.read_schema
       end
 
       it "should set ENV SCHEMA to temp files path" do
         @file = double('tempfile', :path => '/temp/123-arst')
-        @dump.stub(:read_entry_to_file).and_yield(@file)
+        allow(@dump).to receive(:read_entry_to_file).and_yield(@file)
 
-        DumpRake::Env.should_receive(:with_env).with('SCHEMA' => '/temp/123-arst')
+        expect(DumpRake::Env).to receive(:with_env).with('SCHEMA' => '/temp/123-arst')
         @dump.read_schema
       end
 
       it "should call task db:schema:load and db:schema:dump" do
         @file = double('tempfile', :path => '/temp/123-arst')
-        @dump.stub(:read_entry_to_file).and_yield(@file)
+        allow(@dump).to receive(:read_entry_to_file).and_yield(@file)
 
         @load_task = double('load_task')
         @dump_task = double('dump_task')
-        Rake::Task.should_receive(:[]).with('db:schema:load').and_return(@load_task)
-        Rake::Task.should_receive(:[]).with('db:schema:dump').and_return(@dump_task)
-        @load_task.should_receive(:invoke)
-        @dump_task.should_receive(:invoke)
+        expect(Rake::Task).to receive(:[]).with('db:schema:load').and_return(@load_task)
+        expect(Rake::Task).to receive(:[]).with('db:schema:dump').and_return(@dump_task)
+        expect(@load_task).to receive(:invoke)
+        expect(@dump_task).to receive(:invoke)
 
         @dump.read_schema
       end
@@ -364,51 +364,76 @@ describe DumpReader do
     describe "schema" do
       it "should read schema" do
         @data = %q{create table, rows, etc...}
-        @dump.should_receive(:read_entry).with('schema.rb').and_return(@data)
-        @dump.schema.should == @data
+        expect(@dump).to receive(:read_entry).with('schema.rb').and_return(@data)
+        expect(@dump.schema).to eq(@data)
       end
     end
 
     describe "read_tables" do
       it "should verify connection" do
-        @dump.stub(:config).and_return({:tables => []})
-        @dump.should_receive(:verify_connection)
+        allow(@dump).to receive(:config).and_return({:tables => []})
+        expect(@dump).to receive(:verify_connection)
         @dump.read_tables
       end
 
       it "should call read_table for each table in config" do
-        @dump.stub(:verify_connection)
-        @dump.stub(:config).and_return({:tables => {'first' => 1, 'second' => 3}})
+        allow(@dump).to receive(:verify_connection)
+        allow(@dump).to receive(:config).and_return({:tables => {'first' => 1, 'second' => 3}})
 
-        @dump.should_receive(:read_table).with('first', 1)
-        @dump.should_receive(:read_table).with('second', 3)
+        expect(@dump).to receive(:read_table).with('first', 1)
+        expect(@dump).to receive(:read_table).with('second', 3)
 
         @dump.read_tables
       end
+
+      describe "when called with restore_tables" do
+        it "should verify connection and call read_table for each table in restore_tables" do
+          allow(@dump).to receive(:config).and_return({:tables => {'first' => 1, 'second' => 3}})
+
+          expect(@dump).to receive(:verify_connection)
+          expect(@dump).to receive(:read_table).with('first', 1)
+          expect(@dump).not_to receive(:read_table).with('second', 3)
+
+          DumpRake::Env.with_env(:restore_tables => 'first') do
+            @dump.read_tables
+          end
+        end
+
+        it "should not verfiy connection or call read_table for empty restore_tables" do
+          allow(@dump).to receive(:config).and_return({:tables => {'first' => 1, 'second' => 3}})
+
+          expect(@dump).not_to receive(:verify_connection)
+          expect(@dump).not_to receive(:read_table)
+
+          DumpRake::Env.with_env(:restore_tables => '') do
+            @dump.read_tables
+          end
+        end
+      end
     end
 
     describe "read_table" do
       it "should not read table if no entry found for table" do
-        @dump.should_receive(:find_entry).with('first.dump').and_return(nil)
-        @dump.should_not_receive(:quote_table_name)
+        expect(@dump).to receive(:find_entry).with('first.dump').and_return(nil)
+        expect(@dump).not_to receive(:quote_table_name)
         @dump.read_table('first', 10)
       end
 
       it "should clear table and read table if entry found for table" do
         @entry = double('entry', :to_str => Marshal.dump('data'), :eof? => true)
-        @dump.should_receive(:columns_insert_sql).with('data')
-        @dump.should_receive(:find_entry).with('first.dump').and_yield(@entry)
-        @dump.should_receive(:quote_table_name).with('first').and_return('`first`')
-        @dump.should_receive(:clear_table).with('`first`')
+        expect(@dump).to receive(:columns_insert_sql).with('data')
+        expect(@dump).to receive(:find_entry).with('first.dump').and_yield(@entry)
+        expect(@dump).to receive(:quote_table_name).with('first').and_return('`first`')
+        expect(@dump).to receive(:clear_table).with('`first`')
         @dump.read_table('first', 10)
       end
 
       it "should clear schema table before writing" do
         @entry = double('entry', :to_str => Marshal.dump('data'), :eof? => true)
-        @dump.should_receive(:columns_insert_sql).with('data')
-        @dump.should_receive(:find_entry).with('schema_migrations.dump').and_yield(@entry)
-        @dump.should_receive(:quote_table_name).with('schema_migrations').and_return('`schema_migrations`')
-        @dump.should_receive(:clear_table).with('`schema_migrations`')
+        expect(@dump).to receive(:columns_insert_sql).with('data')
+        expect(@dump).to receive(:find_entry).with('schema_migrations.dump').and_yield(@entry)
+        expect(@dump).to receive(:quote_table_name).with('schema_migrations').and_return('`schema_migrations`')
+        expect(@dump).to receive(:clear_table).with('`schema_migrations`')
         @dump.read_table('schema_migrations', 10)
       end
 
@@ -426,43 +451,43 @@ describe DumpReader do
           end
           @entry.rewind
 
-          @dump.stub(:find_entry).and_yield(@entry)
+          allow(@dump).to receive(:find_entry).and_yield(@entry)
         end
         it "should read to eof" do
           create_entry(2500)
-          @dump.stub(:clear_table)
-          @dump.stub(:insert_into_table)
+          allow(@dump).to receive(:clear_table)
+          allow(@dump).to receive(:insert_into_table)
           @dump.read_table('first', 2500)
-          @entry.eof?.should be_true
+          expect(@entry.eof?).to be_truthy
         end
 
         it "should try to insert rows in slices of 1000 rows" do
           create_entry(2500)
-          @dump.stub(:clear_table)
-          @dump.should_receive(:insert_into_table).with(anything, anything, object_of_length(1000)).twice
-          @dump.should_receive(:insert_into_table).with(anything, anything, object_of_length(500)).once
+          allow(@dump).to receive(:clear_table)
+          expect(@dump).to receive(:insert_into_table).with(anything, anything, object_of_length(1000)).twice
+          expect(@dump).to receive(:insert_into_table).with(anything, anything, object_of_length(500)).once
 
           @dump.read_table('first', 2500)
         end
 
         it "should try to insert row by row if slice method fails" do
           create_entry(2500)
-          @dump.stub(:clear_table)
-          @dump.should_receive(:insert_into_table).with(anything, anything, kind_of(Array)).exactly(3).times.and_raise('sql error')
-          @dump.should_receive(:insert_into_table).with(anything, anything, kind_of(String)).exactly(2500).times
+          allow(@dump).to receive(:clear_table)
+          expect(@dump).to receive(:insert_into_table).with(anything, anything, kind_of(Array)).exactly(3).times.and_raise('sql error')
+          expect(@dump).to receive(:insert_into_table).with(anything, anything, kind_of(String)).exactly(2500).times
           @dump.read_table('first', 2500)
         end
 
         it "should quote table, columns and values and send them to insert_into_table" do
           create_entry(100)
-          @dump.stub(:clear_table)
-          @dump.should_receive(:quote_table_name).with('first').and_return('`first`')
-          @dump.should_receive(:columns_insert_sql).with(@columns).and_return('(`id`, `name`)')
+          allow(@dump).to receive(:clear_table)
+          expect(@dump).to receive(:quote_table_name).with('first').and_return('`first`')
+          expect(@dump).to receive(:columns_insert_sql).with(@columns).and_return('(`id`, `name`)')
           @rows.each do |row|
-            @dump.should_receive(:values_insert_sql).with(row).and_return{ |vs| vs.inspect }
+            expect(@dump).to receive(:values_insert_sql).with(row){ |vs| vs.inspect }
           end
 
-          @dump.should_receive(:insert_into_table).with('`first`', '(`id`, `name`)', @rows.map(&:inspect))
+          expect(@dump).to receive(:insert_into_table).with('`first`', '(`id`, `name`)', @rows.map(&:inspect))
           @dump.read_table('first', 100)
         end
       end
@@ -471,45 +496,45 @@ describe DumpReader do
     describe "read_assets" do
       before do
         @task = double('task')
-        Rake::Task.stub(:[]).with('assets:delete').and_return(@task)
-        @task.stub(:invoke)
-        @dump.stub(:assets_root_link).and_yield('/tmp', 'assets')
+        allow(Rake::Task).to receive(:[]).with('assets:delete').and_return(@task)
+        allow(@task).to receive(:invoke)
+        allow(@dump).to receive(:assets_root_link).and_yield('/tmp', 'assets')
       end
 
       it "should not read assets if config[:assets] is nil" do
-        @dump.stub(:config).and_return({})
-        @dump.should_not_receive(:find_entry)
+        allow(@dump).to receive(:config).and_return({})
+        expect(@dump).not_to receive(:find_entry)
         @dump.read_assets
       end
 
       it "should not read assets if config[:assets] is blank" do
-        @dump.stub(:config).and_return({:assets => []})
-        @dump.should_not_receive(:find_entry)
+        allow(@dump).to receive(:config).and_return({:assets => []})
+        expect(@dump).not_to receive(:find_entry)
         @dump.read_assets
       end
 
       describe "deleting existing assets" do
         before do
-          @stream.stub(:each)
+          allow(@stream).to receive(:each)
         end
 
         it "should call assets:delete" do
           @assets = %w[images videos]
-          @dump.stub(:config).and_return({:assets => @assets})
-          @dump.stub(:find_entry)
+          allow(@dump).to receive(:config).and_return({:assets => @assets})
+          allow(@dump).to receive(:find_entry)
 
-          @task.should_receive(:invoke)
+          expect(@task).to receive(:invoke)
 
           @dump.read_assets
         end
 
         it "should call assets:delete with ASSETS set to config[:assets] joined with :" do
           @assets = %w[images videos]
-          @dump.stub(:config).and_return({:assets => @assets})
-          @dump.stub(:find_entry)
+          allow(@dump).to receive(:config).and_return({:assets => @assets})
+          allow(@dump).to receive(:find_entry)
 
-          def @task.invoke
-            DumpRake::Env[:assets].should == 'images:videos'
+          expect(@task).to receive(:invoke) do
+            expect(DumpRake::Env[:assets]).to eq('images:videos')
           end
 
           @dump.read_assets
@@ -518,40 +543,57 @@ describe DumpReader do
         describe "when called with restore_assets" do
           it "should delete files and dirs only in requested paths" do
             @assets = %w[images videos]
-            @dump.stub(:config).and_return({:assets => @assets})
+            allow(@dump).to receive(:config).and_return({:assets => @assets})
 
-            DumpRake::Assets.should_receive('glob_asset_children').with('images', '**/*').and_return(%w[images images/a.jpg images/b.jpg])
-            DumpRake::Assets.should_receive('glob_asset_children').with('videos', '**/*').and_return(%w[videos videos/a.mov])
+            expect(DumpRake::Assets).to receive('glob_asset_children').with('images', '**/*').and_return(%w[images images/a.jpg images/b.jpg])
+            expect(DumpRake::Assets).to receive('glob_asset_children').with('videos', '**/*').and_return(%w[videos videos/a.mov])
 
-            @dump.should_receive('read_asset?').with('images/b.jpg', DumpRake::RailsRoot).ordered.and_return(false)
-            @dump.should_receive('read_asset?').with('images/a.jpg', DumpRake::RailsRoot).ordered.and_return(true)
-            @dump.should_receive('read_asset?').with('images', DumpRake::RailsRoot).ordered.and_return(true)
-            @dump.should_receive('read_asset?').with('videos/a.mov', DumpRake::RailsRoot).ordered.and_return(false)
-            @dump.should_receive('read_asset?').with('videos', DumpRake::RailsRoot).ordered.and_return(false)
+            expect(@dump).to receive('read_asset?').with('images/b.jpg', DumpRake::RailsRoot).ordered.and_return(false)
+            expect(@dump).to receive('read_asset?').with('images/a.jpg', DumpRake::RailsRoot).ordered.and_return(true)
+            expect(@dump).to receive('read_asset?').with('images', DumpRake::RailsRoot).ordered.and_return(true)
+            expect(@dump).to receive('read_asset?').with('videos/a.mov', DumpRake::RailsRoot).ordered.and_return(false)
+            expect(@dump).to receive('read_asset?').with('videos', DumpRake::RailsRoot).ordered.and_return(false)
 
-            File.should_receive('file?').with('images/a.jpg').and_return(true)
-            File.should_receive('unlink').with('images/a.jpg')
-            File.should_not_receive('file?').with('images/b.jpg')
-            File.should_receive('file?').with('images').and_return(false)
-            File.should_receive('directory?').with('images').and_return(true)
-            Dir.should_receive('unlink').with('images').and_raise(Errno::ENOTEMPTY)
+            expect(File).to receive('file?').with('images/a.jpg').and_return(true)
+            expect(File).to receive('unlink').with('images/a.jpg')
+            expect(File).not_to receive('file?').with('images/b.jpg')
+            expect(File).to receive('file?').with('images').and_return(false)
+            expect(File).to receive('directory?').with('images').and_return(true)
+            expect(Dir).to receive('unlink').with('images').and_raise(Errno::ENOTEMPTY)
 
             DumpRake::Env.with_env(:restore_assets => 'images/a.*:stylesheets') do
               @dump.read_assets
             end
           end
+
+          it "should not delete any files and dirs for empty list" do
+            @assets = %w[images videos]
+            allow(@dump).to receive(:config).and_return({:assets => @assets})
+
+            expect(DumpRake::Assets).not_to receive('glob_asset_children')
+
+            expect(@dump).not_to receive('read_asset?')
+
+            expect(File).not_to receive('directory?')
+            expect(File).not_to receive('file?')
+            expect(File).not_to receive('unlink')
+
+            DumpRake::Env.with_env(:restore_assets => '') do
+              @dump.read_assets
+            end
+          end
         end
       end
 
       describe "old style" do
         it "should find assets.tar" do
           @assets = %w[images videos]
-          @dump.stub(:config).and_return({:assets => @assets})
-          Dir.stub(:glob).and_return([])
-          FileUtils.stub(:remove_entry)
-          @stream.stub(:each)
+          allow(@dump).to receive(:config).and_return({:assets => @assets})
+          allow(Dir).to receive(:glob).and_return([])
+          allow(FileUtils).to receive(:remove_entry)
+          allow(@stream).to receive(:each)
 
-          @dump.should_receive(:find_entry).with('assets.tar')
+          expect(@dump).to receive(:find_entry).with('assets.tar')
           @dump.read_assets
         end
 
@@ -561,23 +603,23 @@ describe DumpReader do
           {'images' => {:files => 0, :total => 0}, 'videos' => {:files => 0, :total => 0}},
         ].each do |assets|
           it "should rewrite rewind method to empty method - to not raise exception, open tar and extract each entry" do
-            @dump.stub(:config).and_return({:assets => assets})
-            Dir.stub(:glob).and_return([])
-            FileUtils.stub(:remove_entry)
+            allow(@dump).to receive(:config).and_return({:assets => assets})
+            allow(Dir).to receive(:glob).and_return([])
+            allow(FileUtils).to receive(:remove_entry)
 
             @assets_tar = double('assets_tar')
-            @assets_tar.stub(:rewind).and_raise('hehe - we want to rewind to center of gzip')
-            @dump.stub(:find_entry).and_yield(@assets_tar)
+            allow(@assets_tar).to receive(:rewind).and_raise('hehe - we want to rewind to center of gzip')
+            allow(@dump).to receive(:find_entry).and_yield(@assets_tar)
 
             @inp = double('inp')
-            each_excpectation = @inp.should_receive(:each)
+            each_excpectation = expect(@inp).to receive(:each)
             @entries = %w[a b c d].map do |s|
               file = double("file_#{s}")
               each_excpectation.and_yield(file)
-              @inp.should_receive(:extract_entry).with(DumpRake::RailsRoot, file)
+              expect(@inp).to receive(:extract_entry).with(DumpRake::RailsRoot, file)
               file
             end
-            Archive::Tar::Minitar.should_receive(:open).with(@assets_tar).and_yield(@inp)
+            expect(Archive::Tar::Minitar).to receive(:open).with(@assets_tar).and_yield(@inp)
 
             @dump.read_assets
           end
@@ -586,7 +628,7 @@ describe DumpReader do
 
       describe "new style" do
         before do
-          @dump.should_receive(:find_entry).with('assets.tar')
+          expect(@dump).to receive(:find_entry).with('assets.tar')
         end
 
         [
@@ -595,21 +637,21 @@ describe DumpReader do
           {'images' => {:files => 0, :total => 0}, 'videos' => {:files => 0, :total => 0}},
         ].each do |assets|
           it "should extract each entry" do
-            @dump.stub(:config).and_return({:assets => assets})
-            Dir.stub(:glob).and_return([])
-            FileUtils.stub(:remove_entry)
+            allow(@dump).to receive(:config).and_return({:assets => assets})
+            allow(Dir).to receive(:glob).and_return([])
+            allow(FileUtils).to receive(:remove_entry)
 
-            @dump.should_receive(:assets_root_link).and_yield('/tmp/abc', 'assets')
-            each_excpectation = @stream.should_receive(:each)
+            expect(@dump).to receive(:assets_root_link).and_yield('/tmp/abc', 'assets')
+            each_excpectation = expect(@stream).to receive(:each)
             @entries = %w[a b c d].map do |s|
               file = double("file_#{s}", :full_name => "assets/#{s}")
               each_excpectation.and_yield(file)
-              @stream.should_receive(:extract_entry).with('/tmp/abc', file)
+              expect(@stream).to receive(:extract_entry).with('/tmp/abc', file)
               file
             end
             other_file = double('other_file', :full_name => 'other_file')
             each_excpectation.and_yield(other_file)
-            @stream.should_not_receive(:extract_entry).with('/tmp/abc', other_file)
+            expect(@stream).not_to receive(:extract_entry).with('/tmp/abc', other_file)
 
             @dump.read_assets
           end
@@ -620,18 +662,18 @@ describe DumpReader do
     describe "read_asset?" do
       it "should create filter and call custom_pass? on it" do
         @filter = double('filter')
-        @filter.stub('custom_pass?')
+        allow(@filter).to receive('custom_pass?')
 
-        DumpRake::Env.should_receive('filter').with(:restore_assets, DumpRake::Assets::SPLITTER).and_return(@filter)
+        expect(DumpRake::Env).to receive('filter').with(:restore_assets, DumpRake::Assets::SPLITTER).and_return(@filter)
 
         @dump.read_asset?('a', 'b')
       end
 
       it "should test path usint fnmatch" do
         DumpRake::Env.with_env(:restore_assets => '[a-b]') do
-          @dump.read_asset?('x/a', 'x').should be_true
-          @dump.read_asset?('x/b/file', 'x').should be_true
-          @dump.read_asset?('x/c', 'x').should be_false
+          expect(@dump.read_asset?('x/a', 'x')).to be_truthy
+          expect(@dump.read_asset?('x/b/file', 'x')).to be_truthy
+          expect(@dump.read_asset?('x/c', 'x')).to be_falsey
         end
       end
     end