dump 1.0.0

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

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

data/spec/lib/dump_rake/env_spec.rb

@@ -0,0 +1,139 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+Env = DumpRake::Env
+describe Env do
+  def silence_warnings
+    old_verbose, $VERBOSE = $VERBOSE, nil
+    yield
+  ensure
+    $VERBOSE = old_verbose
+  end
+
+  before do
+    silence_warnings do
+      @old_env, ENV = ENV, {}
+    end
+  end
+
+  after do
+    silence_warnings do
+      ENV = @old_env
+    end
+  end
+
+  describe "with_env" do
+    it "should set env to new_value for duration of block" do
+      ENV['LIKE'] = 'old_value'
+
+      ENV['LIKE'].should == 'old_value'
+      Env.with_env('LIKE' => 'new_value') do
+        ENV['LIKE'].should == 'new_value'
+      end
+      ENV['LIKE'].should == 'old_value'
+    end
+
+    it "should use dictionary" do
+      ENV['LIKE'] = 'old_value'
+
+      ENV['LIKE'].should == 'old_value'
+      Env.with_env(:like => 'new_value') do
+        ENV['LIKE'].should == 'new_value'
+      end
+      ENV['LIKE'].should == 'old_value'
+    end
+  end
+
+  describe "[]" do
+    it "should mimic ENV" do
+      ENV['VERSION'] = 'VERSION_value'
+      Env['VERSION'].should == ENV['VERSION']
+    end
+
+    it "should return nil on non existing env variable" do
+      Env['DESCRIPTON'].should == nil
+    end
+
+    it "should get first value that is set" do
+      ENV['VERSION'] = 'VERSION_value'
+      Env[:like].should == 'VERSION_value'
+      ENV['VER'] = 'VER_value'
+      Env[:like].should == 'VER_value'
+      ENV['LIKE'] = 'LIKE_value'
+      Env[:like].should == 'LIKE_value'
+    end
+
+    it "should return nil for unset variable" do
+      Env[:desc].should == nil
+    end
+  end
+
+  describe "filter" do
+    before do
+      Env.instance_variable_set(:@filters, nil)
+    end
+
+    it "should return Filter" do
+      ENV['TABLES'] = 'a,b,c'
+      filter = Env.filter('TABLES')
+      filter.should be_instance_of(Env::Filter)
+      filter.invert.should be_false
+      filter.values.should == %w[a b c]
+    end
+
+    it "should cache created filter" do
+      ENV['TABLES'] = 'a,b,c'
+      ENV['TABLES2'] = 'a,b,c'
+      Env::Filter.should_receive(:new).with('a,b,c', nil).once
+      Env.filter('TABLES')
+      Env.filter('TABLES')
+      Env.filter('TABLES2')
+    end
+  end
+
+  describe "for_command" do
+    describe "when no vars present" do
+      it "should return empty hash for every command" do
+        Env.for_command(:create).should == {}
+        Env.for_command(:restore).should == {}
+        Env.for_command(:versions).should == {}
+        Env.for_command(:bad).should == {}
+      end
+
+      it "should return empty hash for every command when asking for string keys" do
+        Env.for_command(:create, true).should == {}
+        Env.for_command(:restore, true).should == {}
+        Env.for_command(:versions, true).should == {}
+        Env.for_command(:bad, true).should == {}
+      end
+    end
+
+    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
+        Env.for_command(:create).should == {:desc => 'Description'}
+        Env.for_command(:restore).should == {:like => 'Version'}
+        Env.for_command(:versions).should == {:like => 'Version'}
+        Env.for_command(:bad).should == {}
+      end
+
+      it "should return hash with symbol keys for every command when asking for string keys" do
+        Env.for_command(:create, true).should == {'DESC' => 'Description'}
+        Env.for_command(:restore, true).should == {'LIKE' => 'Version'}
+        Env.for_command(:versions, true).should == {'LIKE' => 'Version'}
+        Env.for_command(:bad, true).should == {}
+      end
+    end
+  end
+
+  describe "stringify!" do
+    it "should convert keys to strings" do
+      @env = {:desc => 'text', :tags => 'a b c', 'LEAVE' => 'none', 'OTHER' => 'data'}
+      Env.stringify!(@env)
+      @env.should == {'DESC' => 'text', 'TAGS' => 'a b c', 'LEAVE' => 'none', 'OTHER' => 'data'}
+    end
+  end
+end

data/spec/lib/dump_rake/rails_root_spec.rb

@@ -0,0 +1,45 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+def temp_remove_const(where, which)
+  around do |example|
+    if where.const_defined?(which)
+      old = where.send(:const_get, which)
+      where.send(:remove_const, which)
+      example.run
+      where.send(:remove_const, which) if where.const_defined?(which)
+      where.const_set(which, old)
+    else
+      example.run
+    end
+  end
+end
+
+describe 'RailsRoot' do
+  before do
+    @root = mock('root')
+    @root.should_receive(:to_s).and_return(@root)
+  end
+
+  temp_remove_const Object, :Rails
+  temp_remove_const Object, :RAILS_ROOT
+  temp_remove_const DumpRake, :RailsRoot
+
+  it "should use Rails if it is present" do
+    Object.const_set('Rails', mock('rails'))
+    Rails.should_receive(:root).and_return(@root)
+    load 'dump_rake/rails_root.rb'
+    DumpRake::RailsRoot.should === @root
+  end
+
+  it "should use RAILS_ROOT if it is present" do
+    Object.const_set('RAILS_ROOT', @root)
+    load 'dump_rake/rails_root.rb'
+    DumpRake::RailsRoot.should === @root
+  end
+
+  it "should use Dir.pwd else" do
+    Dir.should_receive(:pwd).and_return(@root)
+    load 'dump_rake/rails_root.rb'
+    DumpRake::RailsRoot.should === @root
+  end
+end

data/spec/lib/dump_rake/table_manipulation_spec.rb

@@ -0,0 +1,256 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require File.dirname(__FILE__) + '/../../../lib/dump_rake'
+
+TableManipulation = DumpRake::TableManipulation
+describe TableManipulation do
+  include TableManipulation
+
+  describe "schema_tables" do
+    it "should return schema_tables" do
+      schema_tables.should == %w[schema_info schema_migrations]
+    end
+  end
+
+  describe "verify_connection" do
+    it "should return result of ActiveRecord::Base.connection.verify!" do
+      ActiveRecord::Base.connection.should_receive(:verify!).and_return(:result)
+      verify_connection.should == :result
+    end
+  end
+
+  describe "quote_table_name" do
+    it "should return result of ActiveRecord::Base.connection.quote_table_name" do
+      ActiveRecord::Base.connection.should_receive(:quote_table_name).with('first').and_return('`first`')
+      quote_table_name('first').should == '`first`'
+    end
+  end
+
+  describe "quote_column_name" do
+    it "should return result of ActiveRecord::Base.connection.quote_column_name" do
+      ActiveRecord::Base.connection.should_receive(:quote_column_name).with('first').and_return('`first`')
+      quote_column_name('first').should == '`first`'
+    end
+  end
+
+  describe "quote_value" do
+    it "should return result of ActiveRecord::Base.connection.quote_value" do
+      ActiveRecord::Base.connection.should_receive(:quote).with('first').and_return('`first`')
+      quote_value('first').should == '`first`'
+    end
+  end
+
+
+  describe "clear_table" do
+    it "should call ActiveRecord::Base.connection.delete with sql for deleting everything from table" do
+      ActiveRecord::Base.connection.should_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
+      ActiveRecord::Base.connection.should_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
+      ActiveRecord::Base.connection.should_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
+    it "should convert array ['`a`', '`b`'] to \"(`a`,`b`)\"" do
+      join_for_sql(%w[`a` `b`]).should == '(`a`,`b`)'
+    end
+  end
+
+  describe "columns_insert_sql" do
+    it "should return columns sql part for insert" do
+      should_receive(:quote_column_name).with('a').and_return('`a`')
+      should_receive(:quote_column_name).with('b').and_return('`b`')
+
+      columns_insert_sql(%w[a b]).should == '(`a`,`b`)'
+    end
+  end
+
+  describe "values_insert_sql" do
+    it "should return values sql part for insert" do
+      should_receive(:quote_value).with('a').and_return('`a`')
+      should_receive(:quote_value).with('b').and_return('`b`')
+
+      values_insert_sql(%w[a b]).should == '(`a`,`b`)'
+    end
+  end
+
+
+  describe "tables_to_dump" do
+    it "should call ActiveRecord::Base.connection.tables" do
+      ActiveRecord::Base.connection.should_receive(:tables).and_return([])
+      tables_to_dump
+    end
+
+    it "should exclude sessions table from result" do
+      ActiveRecord::Base.connection.should_receive(:tables).and_return(%w[first second schema_info schema_migrations sessions])
+      tables_to_dump.should == %w[first second schema_info schema_migrations]
+    end
+
+    describe "with user defined tables" do
+      before do
+        ActiveRecord::Base.connection.should_receive(:tables).and_return(%w[first second schema_info schema_migrations sessions])
+      end
+
+      it "should select certain tables" do
+        DumpRake::Env.with_env(:tables => 'first,third,-fifth') do
+          tables_to_dump.should == %w[first schema_info schema_migrations]
+        end
+      end
+
+      it "should select skip certain tables" do
+        DumpRake::Env.with_env(:tables => '-first,third,-fifth') do
+          tables_to_dump.should == %w[second schema_info schema_migrations sessions]
+        end
+      end
+
+      it "should not exclude sessions table from result if asked to exclude nothing" do
+        DumpRake::Env.with_env(:tables => '-') do
+          tables_to_dump.should == %w[first second schema_info schema_migrations sessions]
+        end
+      end
+
+      it "should not exclude schema tables" do
+        DumpRake::Env.with_env(:tables => '-second,schema_info,schema_migrations') do
+          tables_to_dump.should == %w[first schema_info schema_migrations sessions]
+        end
+      end
+
+      it "should not exclude schema tables ever if asked to dump only certain tables" do
+        DumpRake::Env.with_env(:tables => 'second') do
+          tables_to_dump.should == %w[second schema_info schema_migrations]
+        end
+      end
+    end
+  end
+
+  describe "table_row_count" do
+    it "should ruturn row count for table" do
+      ActiveRecord::Base.connection.should_receive(:select_value).with("SELECT COUNT(*) FROM #{quote_table_name('first')}").and_return('666')
+      table_row_count('first').should == 666
+    end
+  end
+
+  describe "table_chunk_size" do
+    it "should return chunk_size based on estimated average for row size" do
+      should_receive(:table_columns).with('first').and_return(
+        [mock(:column, :type => :integer, :limit => nil)] * 3 +
+        [mock(:column, :type => :string, :limit => nil)] * 3 +
+        [mock(:column, :type => :text, :limit => nil)]
+      )
+      table_chunk_size('first').should satisfy { |n|
+        (TableManipulation::CHUNK_SIZE_MIN..TableManipulation::CHUNK_SIZE_MAX).include?(n)
+      }
+    end
+
+    it "should not return value less than CHUNK_SIZE_MIN" do
+      should_receive(:table_columns).with('first').and_return(
+        [mock(:column, :type => :text, :limit => nil)] * 100
+      )
+      table_chunk_size('first').should == TableManipulation::CHUNK_SIZE_MIN
+    end
+
+    it "should not return value more than CHUNK_SIZE_MAX" do
+      should_receive(:table_columns).with('first').and_return(
+        [mock(:column, :type => :boolean, :limit => 1)] * 10
+      )
+      table_chunk_size('first').should == TableManipulation::CHUNK_SIZE_MAX
+    end
+  end
+
+  describe "table_columns" do
+    it "should return table column definitions" do
+      columns = [mock(:column), mock(:column), mock(:column)]
+      ActiveRecord::Base.connection.should_receive(:columns).with('first').and_return(columns)
+      table_columns('first').should == 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
+      should_receive(:table_primary_key).at_least(3).times.and_return('id')
+
+      should_receive(:table_columns).with('first').and_return([mock(:column, :name => 'id', :type => :integer), mock(:column, :name => 'title', :type => :integer)])
+      table_has_primary_column?('first').should be_true
+
+      should_receive(:table_columns).with('second').and_return([mock(:column, :name => 'id', :type => :string), mock(:column, :name => 'title', :type => :integer)])
+      table_has_primary_column?('second').should be_false
+
+      should_receive(:table_columns).with('third').and_return([mock(:column, :name => 'name', :type => :integer), mock(:column, :name => 'title', :type => :integer)])
+      table_has_primary_column?('third').should be_false
+    end
+  end
+
+  describe "table_primary_key" do
+    it "should return id" do
+      table_primary_key('first').should == 'id'
+      table_primary_key(nil).should == 'id'
+    end
+  end
+
+  describe "each_table_row" do
+    before do
+      @row_count = 550
+      @rows = Array.new(@row_count){ |i| {'id' => "#{i + 1}"} }
+    end
+
+    def verify_getting_rows
+      i = 0
+      each_table_row('first', @row_count) do |row|
+        row.should == {'id' => "#{i + 1}"}
+        i += 1
+      end
+      i.should == @row_count
+    end
+
+    it "should get rows in chunks if table has primary column and chunk size is less than row count" do
+      should_receive(:table_has_primary_column?).with('first').and_return(true)
+      should_receive(:table_chunk_size).with('first').and_return(100)
+      quoted_table_name = quote_table_name('first')
+      quoted_primary_key = "#{quoted_table_name}.#{quote_column_name(table_primary_key('first'))}"
+      sql = "SELECT * FROM #{quoted_table_name} WHERE #{quoted_primary_key} %s ORDER BY #{quoted_primary_key} ASC LIMIT 100"
+
+      should_receive(:select_all_by_sql).with(sql % '>= 0').and_return(@rows[0, 100])
+      5.times do |i|
+        last_primary_key = 100 + i * 100
+        should_receive(:select_all_by_sql).with(sql % "> #{last_primary_key}").and_return(@rows[last_primary_key, 100])
+      end
+
+      verify_getting_rows
+    end
+
+    def verify_getting_rows_in_one_pass
+      should_receive(:select_all_by_sql).with("SELECT * FROM #{quote_table_name('first')}").and_return(@rows)
+      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
+      should_receive(:table_has_primary_column?).with('first').and_return(true)
+      should_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
+      should_receive(:table_has_primary_column?).with('first').and_return(false)
+      should_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
+      rows = [mock(:row), mock(:row), mock(:row)]
+      ActiveRecord::Base.connection.should_receive(:select_all).with("SELECT * FROM abc WHERE x = y").and_return(rows)
+      select_all_by_sql("SELECT * FROM abc WHERE x = y").should == rows
+    end
+  end
+end