dump 1.0.4 → 1.0.5

data/spec/lib/dump_rake/env/filter_spec.rb

@@ -1,8 +1,8 @@
-require File.dirname(__FILE__) + '/../../../spec_helper'
+require 'spec_helper'
 
 Filter = DumpRake::Env::Filter
 describe Filter do
-  it "should pass everything if initialized with nil" do
+  it 'should pass everything if initialized with nil' do
     filter = Filter.new(nil)
     expect(filter.pass?('a')).to be_truthy
     expect(filter.pass?('b')).to be_truthy
@@ -10,7 +10,7 @@ describe Filter do
     expect(filter.pass?('d')).to be_truthy
   end
 
-  it "should pass only specified values" do
+  it 'should pass only specified values' do
     filter = Filter.new('a,c')
     expect(filter.pass?('a')).to be_truthy
     expect(filter.pass?('b')).to be_falsey
@@ -18,7 +18,7 @@ describe Filter do
     expect(filter.pass?('d')).to be_falsey
   end
 
-  it "should not pass anything if initialized empty" do
+  it 'should not pass anything if initialized empty' do
     filter = Filter.new('')
     expect(filter.pass?('a')).to be_falsey
     expect(filter.pass?('b')).to be_falsey
@@ -26,8 +26,8 @@ describe Filter do
     expect(filter.pass?('d')).to be_falsey
   end
 
-  describe "when initialized with -" do
-    it "should pass everything except specified values" do
+  describe 'when initialized with -' do
+    it 'should pass everything except specified values' do
       filter = Filter.new('-a,c')
       expect(filter.pass?('a')).to be_falsey
       expect(filter.pass?('b')).to be_truthy
@@ -35,7 +35,7 @@ describe Filter do
       expect(filter.pass?('d')).to be_truthy
     end
 
-    it "should pass everything if initialized empty" do
+    it 'should pass everything if initialized empty' do
       filter = Filter.new('-')
       expect(filter.pass?('a')).to be_truthy
       expect(filter.pass?('b')).to be_truthy
@@ -44,8 +44,8 @@ describe Filter do
     end
   end
 
-  describe "custom_pass?" do
-    it "should pass only when any call to block returns true" do
+  describe 'custom_pass?' do
+    it 'should pass only when any call to block returns true' do
       filter = Filter.new('a,c')
       expect(filter.custom_pass?{ |value| value == 'a' }).to be_truthy
       expect(filter.custom_pass?{ |value| value == 'b' }).to be_falsey

data/spec/lib/dump_rake/env_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
+require 'spec_helper'
 
 Env = DumpRake::Env
 describe Env do
@@ -21,8 +21,8 @@ describe Env do
     end
   end
 
-  describe "with_env" do
-    it "should set env to new_value for duration of block" do
+  describe 'with_env' do
+    it 'should set env to new_value for duration of block' do
       ENV['LIKE'] = 'old_value'
 
       expect(ENV['LIKE']).to eq('old_value')
@@ -32,7 +32,7 @@ describe Env do
       expect(ENV['LIKE']).to eq('old_value')
     end
 
-    it "should use dictionary" do
+    it 'should use dictionary' do
       ENV['LIKE'] = 'old_value'
 
       expect(ENV['LIKE']).to eq('old_value')
@@ -43,17 +43,17 @@ describe Env do
     end
   end
 
-  describe "[]" do
-    it "should mimic ENV" do
+  describe '[]' do
+    it 'should mimic ENV' do
       ENV['VERSION'] = 'VERSION_value'
       expect(Env['VERSION']).to eq(ENV['VERSION'])
     end
 
-    it "should return nil on non existing env variable" do
+    it 'should return nil on non existing env variable' do
       expect(Env['DESCRIPTON']).to eq(nil)
     end
 
-    it "should get first value that is set" do
+    it 'should get first value that is set' do
       ENV['VERSION'] = 'VERSION_value'
       expect(Env[:like]).to eq('VERSION_value')
       ENV['VER'] = 'VER_value'
@@ -62,17 +62,17 @@ describe Env do
       expect(Env[:like]).to eq('LIKE_value')
     end
 
-    it "should return nil for unset variable" do
+    it 'should return nil for unset variable' do
       expect(Env[:desc]).to eq(nil)
     end
   end
 
-  describe "filter" do
+  describe 'filter' do
     before do
       Env.instance_variable_set(:@filters, nil)
     end
 
-    it "should return Filter" do
+    it 'should return Filter' do
       ENV['TABLES'] = 'a,b,c'
       filter = Env.filter('TABLES')
       expect(filter).to be_instance_of(Env::Filter)
@@ -80,7 +80,7 @@ describe Env do
       expect(filter.values).to eq(%w[a b c])
     end
 
-    it "should cache created filter" do
+    it 'should cache created filter' do
       ENV['TABLES'] = 'a,b,c'
       ENV['TABLES2'] = 'a,b,c'
       expect(Env::Filter).to receive(:new).with('a,b,c', nil).once
@@ -90,16 +90,16 @@ describe Env do
     end
   end
 
-  describe "for_command" do
-    describe "when no vars present" do
-      it "should return empty hash for every command" do
+  describe 'for_command' do
+    describe 'when no vars present' do
+      it 'should return empty hash for every command' do
         expect(Env.for_command(:create)).to eq({})
         expect(Env.for_command(:restore)).to eq({})
         expect(Env.for_command(:versions)).to eq({})
         expect(Env.for_command(:bad)).to eq({})
       end
 
-      it "should return empty hash for every command when asking for string keys" do
+      it 'should return empty hash for every command when asking for string keys' do
         expect(Env.for_command(:create, true)).to eq({})
         expect(Env.for_command(:restore, true)).to eq({})
         expect(Env.for_command(:versions, true)).to eq({})
@@ -107,20 +107,20 @@ describe Env do
       end
     end
 
-    describe "when vars are present" do
+    describe 'when vars are present' do
       before do
         ENV['LIKE'] = 'Version'
         ENV['DESC'] = 'Description'
       end
 
-      it "should return hash with symbol keys for every command" do
+      it 'should return hash with symbol keys for every command' do
         expect(Env.for_command(:create)).to eq({:desc => 'Description'})
         expect(Env.for_command(:restore)).to eq({:like => 'Version'})
         expect(Env.for_command(:versions)).to eq({:like => 'Version'})
         expect(Env.for_command(:bad)).to eq({})
       end
 
-      it "should return hash with symbol keys for every command when asking for string keys" do
+      it 'should return hash with symbol keys for every command when asking for string keys' do
         expect(Env.for_command(:create, true)).to eq({'DESC' => 'Description'})
         expect(Env.for_command(:restore, true)).to eq({'LIKE' => 'Version'})
         expect(Env.for_command(:versions, true)).to eq({'LIKE' => 'Version'})
@@ -129,8 +129,8 @@ describe Env do
     end
   end
 
-  describe "stringify!" do
-    it "should convert keys to strings" do
+  describe 'stringify!' do
+    it 'should convert keys to strings' do
       @env = {:desc => 'text', :tags => 'a b c', 'LEAVE' => 'none', 'OTHER' => 'data'}
       Env.stringify!(@env)
       expect(@env).to eq({'DESC' => 'text', 'TAGS' => 'a b c', 'LEAVE' => 'none', 'OTHER' => 'data'})

data/spec/lib/dump_rake/rails_root_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
+require 'spec_helper'
 
 def temp_remove_const(where, which)
   around do |example|
@@ -24,22 +24,22 @@ describe 'RailsRoot' do
   temp_remove_const Object, :RAILS_ROOT
   temp_remove_const DumpRake, :RailsRoot
 
-  it "should use Rails if it is present" do
+  it 'should use Rails if it is present' do
     Object.const_set('Rails', double('rails'))
     expect(Rails).to receive(:root).and_return(@root)
     load 'dump_rake/rails_root.rb'
-    expect(DumpRake::RailsRoot).to be === @root
+    expect(DumpRake::RailsRoot).to equal(@root)
   end
 
-  it "should use RAILS_ROOT if it is present" do
+  it 'should use RAILS_ROOT if it is present' do
     Object.const_set('RAILS_ROOT', @root)
     load 'dump_rake/rails_root.rb'
-    expect(DumpRake::RailsRoot).to be === @root
+    expect(DumpRake::RailsRoot).to equal(@root)
   end
 
-  it "should use Dir.pwd else" do
+  it 'should use Dir.pwd else' do
     expect(Dir).to receive(:pwd).and_return(@root)
     load 'dump_rake/rails_root.rb'
-    expect(DumpRake::RailsRoot).to be === @root
+    expect(DumpRake::RailsRoot).to equal(@root)
   end
 end

data/spec/lib/dump_rake/table_manipulation_spec.rb

@@ -1,73 +1,71 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-require File.dirname(__FILE__) + '/../../../lib/dump_rake'
+require 'spec_helper'
+require 'dump_rake'
 
 TableManipulation = DumpRake::TableManipulation
 describe TableManipulation do
   include TableManipulation
 
-  describe "schema_tables" do
-    it "should return schema_tables" do
+  describe 'schema_tables' do
+    it 'should return schema_tables' do
       expect(schema_tables).to eq(%w[schema_info schema_migrations])
     end
   end
 
-  describe "verify_connection" do
-    it "should return result of ActiveRecord::Base.connection.verify!" do
+  describe 'verify_connection' do
+    it 'should return result of ActiveRecord::Base.connection.verify!' do
       expect(ActiveRecord::Base.connection).to receive(:verify!).and_return(:result)
       expect(verify_connection).to eq(:result)
     end
   end
 
-  describe "quote_table_name" do
-    it "should return result of ActiveRecord::Base.connection.quote_table_name" do
+  describe 'quote_table_name' do
+    it 'should return result of ActiveRecord::Base.connection.quote_table_name' do
       expect(ActiveRecord::Base.connection).to receive(:quote_table_name).with('first').and_return('`first`')
       expect(quote_table_name('first')).to eq('`first`')
     end
   end
 
-  describe "quote_column_name" do
-    it "should return result of ActiveRecord::Base.connection.quote_column_name" do
+  describe 'quote_column_name' do
+    it 'should return result of ActiveRecord::Base.connection.quote_column_name' do
       expect(ActiveRecord::Base.connection).to receive(:quote_column_name).with('first').and_return('`first`')
       expect(quote_column_name('first')).to eq('`first`')
     end
   end
 
-  describe "quote_value" do
-    it "should return result of ActiveRecord::Base.connection.quote_value" do
+  describe 'quote_value' do
+    it 'should return result of ActiveRecord::Base.connection.quote_value' do
       expect(ActiveRecord::Base.connection).to receive(:quote).with('first').and_return('`first`')
       expect(quote_value('first')).to eq('`first`')
     end
   end
 
-
-  describe "clear_table" do
-    it "should call ActiveRecord::Base.connection.delete with sql for deleting everything from table" do
+  describe 'clear_table' do
+    it 'should call ActiveRecord::Base.connection.delete with sql for deleting everything from table' do
       expect(ActiveRecord::Base.connection).to receive(:delete).with('DELETE FROM `first`', anything)
       clear_table('`first`')
     end
   end
 
-  describe "insert_into_table" do
-    it "should call ActiveRecord::Base.connection.insert with sql for insert if values is string" do
-      expect(ActiveRecord::Base.connection).to receive(:insert).with("INSERT INTO `table` (`c1`,`c2`) VALUES (`v1`,`v2`)", anything)
+  describe 'insert_into_table' do
+    it 'should call ActiveRecord::Base.connection.insert with sql for insert if values is string' do
+      expect(ActiveRecord::Base.connection).to receive(:insert).with('INSERT INTO `table` (`c1`,`c2`) VALUES (`v1`,`v2`)', anything)
       insert_into_table('`table`', '(`c1`,`c2`)', '(`v1`,`v2`)')
     end
 
-    it "should call ActiveRecord::Base.connection.insert with sql for insert if values is array" do
-      expect(ActiveRecord::Base.connection).to receive(:insert).with("INSERT INTO `table` (`c1`,`c2`) VALUES (`v11`,`v12`),(`v21`,`v22`)", anything)
+    it 'should call ActiveRecord::Base.connection.insert with sql for insert if values is array' do
+      expect(ActiveRecord::Base.connection).to receive(:insert).with('INSERT INTO `table` (`c1`,`c2`) VALUES (`v11`,`v12`),(`v21`,`v22`)', anything)
       insert_into_table('`table`', '(`c1`,`c2`)', ['(`v11`,`v12`)', '(`v21`,`v22`)'])
     end
   end
 
-  describe "join_for_sql" do
+  describe 'join_for_sql' do
     it "should convert array ['`a`', '`b`'] to \"(`a`,`b`)\"" do
       expect(join_for_sql(%w[`a` `b`])).to eq('(`a`,`b`)')
     end
   end
 
-  describe "columns_insert_sql" do
-    it "should return columns sql part for insert" do
+  describe 'columns_insert_sql' do
+    it 'should return columns sql part for insert' do
       expect(self).to receive(:quote_column_name).with('a').and_return('`a`')
       expect(self).to receive(:quote_column_name).with('b').and_return('`b`')
 
@@ -75,8 +73,8 @@ describe TableManipulation do
     end
   end
 
-  describe "values_insert_sql" do
-    it "should return values sql part for insert" do
+  describe 'values_insert_sql' do
+    it 'should return values sql part for insert' do
       expect(self).to receive(:quote_value).with('a').and_return('`a`')
       expect(self).to receive(:quote_value).with('b').and_return('`b`')
 
@@ -84,48 +82,47 @@ describe TableManipulation do
     end
   end
 
-
-  describe "tables_to_dump" do
-    it "should call ActiveRecord::Base.connection.tables" do
+  describe 'tables_to_dump' do
+    it 'should call ActiveRecord::Base.connection.tables' do
       expect(ActiveRecord::Base.connection).to receive(:tables).and_return([])
       tables_to_dump
     end
 
-    it "should exclude sessions table from result" do
+    it 'should exclude sessions table from result' do
       expect(ActiveRecord::Base.connection).to receive(:tables).and_return(%w[first second schema_info schema_migrations sessions])
       expect(tables_to_dump).to eq(%w[first second schema_info schema_migrations])
     end
 
-    describe "with user defined tables" do
+    describe 'with user defined tables' do
       before do
         expect(ActiveRecord::Base.connection).to receive(:tables).and_return(%w[first second schema_info schema_migrations sessions])
       end
 
-      it "should select certain tables" do
+      it 'should select certain tables' do
         DumpRake::Env.with_env(:tables => 'first,third,-fifth') do
           expect(tables_to_dump).to eq(%w[first schema_info schema_migrations])
         end
       end
 
-      it "should select skip certain tables" do
+      it 'should select skip certain tables' do
         DumpRake::Env.with_env(:tables => '-first,third,-fifth') do
           expect(tables_to_dump).to eq(%w[second schema_info schema_migrations sessions])
         end
       end
 
-      it "should not exclude sessions table from result if asked to exclude nothing" do
+      it 'should not exclude sessions table from result if asked to exclude nothing' do
         DumpRake::Env.with_env(:tables => '-') do
           expect(tables_to_dump).to eq(%w[first second schema_info schema_migrations sessions])
         end
       end
 
-      it "should not exclude schema tables" do
+      it 'should not exclude schema tables' do
         DumpRake::Env.with_env(:tables => '-second,schema_info,schema_migrations') do
           expect(tables_to_dump).to eq(%w[first schema_info schema_migrations sessions])
         end
       end
 
-      it "should not exclude schema tables ever if asked to dump only certain tables" do
+      it 'should not exclude schema tables ever if asked to dump only certain tables' do
         DumpRake::Env.with_env(:tables => 'second') do
           expect(tables_to_dump).to eq(%w[second schema_info schema_migrations])
         end
@@ -133,50 +130,47 @@ describe TableManipulation do
     end
   end
 
-  describe "table_row_count" do
-    it "should ruturn row count for table" do
+  describe 'table_row_count' do
+    it 'should ruturn row count for table' do
       expect(ActiveRecord::Base.connection).to receive(:select_value).with("SELECT COUNT(*) FROM #{quote_table_name('first')}").and_return('666')
       expect(table_row_count('first')).to eq(666)
     end
   end
 
-  describe "table_chunk_size" do
-    it "should return chunk_size based on estimated average for row size" do
+  describe 'table_chunk_size' do
+    it 'should return chunk_size based on estimated average for row size' do
       expect(self).to receive(:table_columns).with('first').and_return(
         [double(:column, :type => :integer, :limit => nil)] * 3 +
         [double(:column, :type => :string, :limit => nil)] * 3 +
-        [double(:column, :type => :text, :limit => nil)]
-      )
-      expect(table_chunk_size('first')).to satisfy { |n|
+        [double(:column, :type => :text, :limit => nil)])
+      expect(table_chunk_size('first')).to satisfy{ |n|
         (TableManipulation::CHUNK_SIZE_MIN..TableManipulation::CHUNK_SIZE_MAX).include?(n)
       }
     end
 
-    it "should not return value less than CHUNK_SIZE_MIN" do
+    it 'should not return value less than CHUNK_SIZE_MIN' do
       expect(self).to receive(:table_columns).with('first').and_return(
-        [double(:column, :type => :text, :limit => nil)] * 100
-      )
+        [double(:column, :type => :text, :limit => nil)] * 100)
       expect(table_chunk_size('first')).to eq(TableManipulation::CHUNK_SIZE_MIN)
     end
 
-    it "should not return value more than CHUNK_SIZE_MAX" do
+    it 'should not return value more than CHUNK_SIZE_MAX' do
       expect(self).to receive(:table_columns).with('first').and_return(
-        [double(:column, :type => :boolean, :limit => 1)] * 10
-      )
+        [double(:column, :type => :boolean, :limit => 1)] * 10)
       expect(table_chunk_size('first')).to eq(TableManipulation::CHUNK_SIZE_MAX)
     end
   end
 
-  describe "table_columns" do
-    it "should return table column definitions" do
+  describe 'table_columns' do
+    it 'should return table column definitions' do
       columns = [double(:column), double(:column), double(:column)]
       expect(ActiveRecord::Base.connection).to receive(:columns).with('first').and_return(columns)
       expect(table_columns('first')).to eq(columns)
     end
   end
 
-  describe "table_has_primary_column?" do
-    it "should return true only if table has column with name id and type :integer" do
+  describe 'table_has_primary_column?' do
+    it 'should return true only if table has column with name id and type :integer' do
       expect(self).to receive(:table_primary_key).at_least(3).times.and_return('id')
 
       expect(self).to receive(:table_columns).with('first').and_return([double(:column, :name => 'id', :type => :integer), double(:column, :name => 'title', :type => :integer)])
@@ -190,14 +184,14 @@ describe TableManipulation do
     end
   end
 
-  describe "table_primary_key" do
-    it "should return id" do
+  describe 'table_primary_key' do
+    it 'should return id' do
       expect(table_primary_key('first')).to eq('id')
       expect(table_primary_key(nil)).to eq('id')
     end
   end
 
-  describe "each_table_row" do
+  describe 'each_table_row' do
     before do
       @row_count = 550
       @rows = Array.new(@row_count){ |i| {'id' => "#{i + 1}"} }
@@ -212,7 +206,7 @@ describe TableManipulation do
       expect(i).to eq(@row_count)
     end
 
-    it "should get rows in chunks if table has primary column and chunk size is less than row count" do
+    it 'should get rows in chunks if table has primary column and chunk size is less than row count' do
       expect(self).to receive(:table_has_primary_column?).with('first').and_return(true)
       expect(self).to receive(:table_chunk_size).with('first').and_return(100)
       quoted_table_name = quote_table_name('first')
@@ -233,24 +227,24 @@ describe TableManipulation do
       verify_getting_rows
     end
 
-    it "should get rows in one pass if table has primary column but chunk size is not less than row count" do
+    it 'should get rows in one pass if table has primary column but chunk size is not less than row count' do
       expect(self).to receive(:table_has_primary_column?).with('first').and_return(true)
       expect(self).to receive(:table_chunk_size).with('first').and_return(3_000)
       verify_getting_rows_in_one_pass
     end
 
-    it "should get rows in one pass if table has no primary column" do
+    it 'should get rows in one pass if table has no primary column' do
       expect(self).to receive(:table_has_primary_column?).with('first').and_return(false)
       expect(self).to_not receive(:table_chunk_size)
       verify_getting_rows_in_one_pass
     end
   end
 
-  describe "select_all_by_sql" do
-    it "should return all rows returned by database" do
+  describe 'select_all_by_sql' do
+    it 'should return all rows returned by database' do
       rows = [double(:row), double(:row), double(:row)]
-      expect(ActiveRecord::Base.connection).to receive(:select_all).with("SELECT * FROM abc WHERE x = y").and_return(rows)
-      expect(select_all_by_sql("SELECT * FROM abc WHERE x = y")).to eq(rows)
+      expect(ActiveRecord::Base.connection).to receive(:select_all).with('SELECT * FROM abc WHERE x = y').and_return(rows)
+      expect(select_all_by_sql('SELECT * FROM abc WHERE x = y')).to eq(rows)
     end
   end
 end