dump 1.0.5 → 1.0.6

data/spec/{lib/dump_rake/dump_writer_spec.rb → dump/writer_spec.rb}

@@ -1,39 +1,39 @@
 require 'spec_helper'
-require 'dump_rake'
+require 'dump/writer'
 
-DumpWriter = DumpRake::DumpWriter
-describe DumpWriter do
+Writer = Dump::Writer
+describe Writer do
   describe 'create' do
-    it 'should create selves instance and open' do
+    it 'creates instance and open' do
       @dump = double('dump')
       expect(@dump).to receive(:open)
-      expect(DumpWriter).to receive(:new).with('/abc/123.tmp').and_return(@dump)
-      DumpWriter.create('/abc/123.tmp')
+      expect(described_class).to receive(:new).with('/abc/123.tmp').and_return(@dump)
+      described_class.create('/abc/123.tmp')
     end
 
-    it 'should call dump subroutines' do
+    it 'calls dump subroutines' do
       @dump = double('dump')
       allow(@dump).to receive(:open).and_yield(@dump)
       allow(@dump).to receive(:silence).and_yield
-      allow(DumpWriter).to receive(:new).and_return(@dump)
+      allow(described_class).to receive(:new).and_return(@dump)
 
       expect(@dump).to receive(:write_schema).ordered
       expect(@dump).to receive(:write_tables).ordered
       expect(@dump).to receive(:write_assets).ordered
       expect(@dump).to receive(:write_config).ordered
 
-      DumpWriter.create('/abc/123.tmp')
+      described_class.create('/abc/123.tmp')
     end
   end
 
   describe 'open' do
-    it 'should create dir for dump' do
+    it 'creates dir for dump' do
       allow(Zlib::GzipWriter).to receive(:open)
       expect(FileUtils).to receive(:mkpath).with('/abc/def/ghi')
-      DumpWriter.new('/abc/def/ghi/123.tgz').open
+      described_class.new('/abc/def/ghi/123.tgz').open
     end
 
-    it 'should set stream to gzipped tar writer' do
+    it 'sets stream to gzipped tar writer' do
       allow(FileUtils).to receive(:mkpath)
       @gzip = double('gzip')
       @stream = double('stream')
@@ -41,7 +41,7 @@ describe DumpWriter do
       expect(Archive::Tar::Minitar::Output).to receive(:open).with(@gzip).and_yield(@stream)
       expect(@gzip).to receive(:mtime=).with(Time.utc(2000))
 
-      @dump = DumpWriter.new('123.tgz')
+      @dump = described_class.new('123.tgz')
       expect(@dump).to receive(:lock).and_yield
       @dump.open do |dump|
         expect(dump).to eq(@dump)
@@ -55,14 +55,14 @@ describe DumpWriter do
       @tar = double('tar')
       @stream = double('stream', :tar => @tar)
       @config = {:tables => {}}
-      @dump = DumpWriter.new('123.tgz')
+      @dump = described_class.new('123.tgz')
       allow(@dump).to receive(:stream).and_return(@stream)
       allow(@dump).to receive(:config).and_return(@config)
       allow(Progress).to receive(:io).and_return(StringIO.new)
     end
 
     describe 'create_file' do
-      it 'should create temp file, yield it for writing, create file in tar and write it there' do
+      it 'creates temp file, yields it for writing, creates file in tar and writes it there' do
         @temp = double('temp', :open => true, :length => 6, :read => 'qwfpgj')
         expect(@temp).to receive(:write).with('qwfpgj')
         allow(@temp).to receive(:eof?).and_return(false, true)
@@ -81,19 +81,19 @@ describe DumpWriter do
     end
 
     describe 'write_schema' do
-      it 'should create file schema.rb' do
+      it 'creates file schema.rb' do
         expect(@dump).to receive(:create_file).with('schema.rb')
         @dump.write_schema
       end
 
-      it 'should set ENV[SCHEMA] to path of returned file' do
+      it 'sets ENV[SCHEMA] to path of returned file' do
         @file = double('file', :path => 'db/schema.rb')
         allow(@dump).to receive(:create_file).and_yield(@file)
-        expect(DumpRake::Env).to receive(:with_env).with('SCHEMA' => 'db/schema.rb')
+        expect(Dump::Env).to receive(:with_env).with('SCHEMA' => 'db/schema.rb')
         @dump.write_schema
       end
 
-      it 'should call rake task db:schema:dump' do
+      it 'calls rake task db:schema:dump' do
         @file = double('file', :path => 'db/schema.rb')
         allow(@dump).to receive(:create_file).and_yield(@file)
         @task = double('task')
@@ -104,13 +104,13 @@ describe DumpWriter do
     end
 
     describe 'write_tables' do
-      it 'should verify connection' do
+      it 'verifies connection' do
         allow(@dump).to receive(:tables_to_dump).and_return([])
         expect(@dump).to receive(:verify_connection)
         @dump.write_tables
       end
 
-      it 'should call write_table for each table returned by tables_to_dump' do
+      it 'calls write_table for each table returned by tables_to_dump' do
         allow(@dump).to receive(:verify_connection)
         allow(@dump).to receive(:tables_to_dump).and_return(%w[first second])
 
@@ -122,20 +122,20 @@ describe DumpWriter do
     end
 
     describe 'write_table' do
-      it 'should get row count and store it to config' do
+      it 'gets row count and store it to config' do
         expect(@dump).to receive(:table_row_count).with('first').and_return(666)
         allow(@dump).to receive(:create_file)
         @dump.write_table('first')
         expect(@config[:tables]['first']).to eq(666)
       end
 
-      it 'should create_file' do
+      it 'create_files' do
         allow(@dump).to receive(:table_row_count).and_return(666)
         expect(@dump).to receive(:create_file)
         @dump.write_table('first')
       end
 
-      it 'should dump column names and values of each row' do
+      it 'dumps column names and values of each row' do
         @column_definitions = [
           double('column', :name => 'id'),
           double('column', :name => 'name'),
@@ -171,21 +171,21 @@ describe DumpWriter do
         allow(@dump).to receive(:assets_root_link).and_yield('/tmp', 'assets')
       end
 
-      it 'should call assets_to_dump' do
+      it 'calls assets_to_dump' do
         expect(@dump).to receive(:assets_to_dump).and_return([])
         @dump.write_assets
       end
 
-      it 'should change root to rails app root' do
+      it 'changes root to rails app root' do
         @file = double('file')
         allow(@dump).to receive(:assets_to_dump).and_return(%w[images videos])
         allow(@dump).to receive(:create_file).and_yield(@file)
 
-        expect(Dir).to receive(:chdir).with(DumpRake::RailsRoot)
+        expect(Dir).to receive(:chdir).with(Dump.rails_root)
         @dump.write_assets
       end
 
-      it 'should put assets to config' do
+      it 'puts assets to config' do
         @file = double('file')
         allow(@dump).to receive(:assets_to_dump).and_return(%w[images/* videos])
         allow(@dump).to receive(:create_file).and_yield(@file)
@@ -200,7 +200,7 @@ describe DumpWriter do
         expect(@config[:assets]).to eq({'images/a' => counts, 'images/b' => counts, 'videos' => counts})
       end
 
-      it 'should use glob to find files' do
+      it 'uses glob to find files' do
         @file = double('file')
         allow(@dump).to receive(:assets_to_dump).and_return(%w[images/* videos])
         allow(@dump).to receive(:create_file).and_yield(@file)
@@ -216,7 +216,7 @@ describe DumpWriter do
         @dump.write_assets
       end
 
-      it 'should pack each file from assets_root_link' do
+      it 'packs each file from assets_root_link' do
         @file = double('file')
         allow(@dump).to receive(:assets_to_dump).and_return(%w[images/* videos])
         allow(@dump).to receive(:create_file).and_yield(@file)
@@ -234,7 +234,7 @@ describe DumpWriter do
         @dump.write_assets
       end
 
-      it 'should pack each file' do
+      it 'packs each file' do
         @file = double('file')
         allow(@dump).to receive(:assets_to_dump).and_return(%w[images/* videos])
         allow(@dump).to receive(:create_file).and_yield(@file)
@@ -254,7 +254,7 @@ describe DumpWriter do
         @dump.write_assets
       end
 
-      it 'should not raise if something fails when packing' do
+      it 'does not raise if something fails when packing' do
         @file = double('file')
         allow(@dump).to receive(:assets_to_dump).and_return(%w[videos])
         allow(@dump).to receive(:create_file).and_yield(@file)
@@ -272,16 +272,15 @@ describe DumpWriter do
           @dump.write_assets
         end
       end
-
     end
 
     describe 'write_config' do
-      it 'should create file config' do
+      it 'creates file config' do
         expect(@dump).to receive(:create_file).with('config')
         @dump.write_config
       end
 
-      it 'should dump column names and values of each row' do
+      it 'dumps column names and values of each row' do
         @file = double('file')
         allow(@dump).to receive(:create_file).and_yield(@file)
         @config.replace({:tables => {'first' => 1, 'second' => 2}, :assets => %w[images videos]})
@@ -292,34 +291,34 @@ describe DumpWriter do
     end
 
     describe 'assets_to_dump' do
-      it 'should call rake task assets' do
+      it 'calls rake task assets' do
         @task = double('task')
         expect(Rake::Task).to receive(:[]).with('assets').and_return(@task)
         expect(@task).to receive(:invoke)
         @dump.assets_to_dump
       end
 
-      it 'should return array of assets if separator is colon' do
+      it 'returns array of assets if separator is colon' do
         @task = double('task')
         allow(Rake::Task).to receive(:[]).and_return(@task)
         allow(@task).to receive(:invoke)
-        DumpRake::Env.with_env(:assets => 'images:videos') do
+        Dump::Env.with_env(:assets => 'images:videos') do
           expect(@dump.assets_to_dump).to eq(%w[images videos])
         end
       end
 
-      it 'should return array of assets if separator is comma' do
+      it 'returns array of assets if separator is comma' do
         @task = double('task')
         allow(Rake::Task).to receive(:[]).and_return(@task)
         allow(@task).to receive(:invoke)
-        DumpRake::Env.with_env(:assets => 'images,videos') do
+        Dump::Env.with_env(:assets => 'images,videos') do
           expect(@dump.assets_to_dump).to eq(%w[images videos])
         end
       end
 
-      it 'should return empty array if calling rake task assets raises an exception' do
+      it 'returns empty array if calling rake task assets raises an exception' do
         allow(Rake::Task).to receive(:[]).and_raise('task assets not found')
-        DumpRake::Env.with_env(:assets => 'images:videos') do
+        Dump::Env.with_env(:assets => 'images:videos') do
           expect(@dump.assets_to_dump).to eq([])
         end
       end

data/spec/dump_spec.rb

@@ -0,0 +1,327 @@
+require 'spec_helper'
+require 'dump'
+
+describe Dump do
+  describe 'versions' do
+    it 'calls Snapshot.list if called without version' do
+      expect(Dump::Snapshot).to receive(:list).and_return([])
+      described_class.versions
+    end
+
+    it 'calls Snapshot.list with options if called with version' do
+      expect(Dump::Snapshot).to receive(:list).with(:like => '123').and_return([])
+      described_class.versions(:like => '123')
+    end
+
+    it 'prints versions' do
+      expect(Dump::Snapshot).to receive(:list).and_return(%w[123.tgz 456.tgz])
+      expect(grab_output do
+        described_class.versions
+      end[:stdout]).to eq("123.tgz\n456.tgz\n")
+    end
+
+    it 'does not show summary if not asked for' do
+      dumps = %w[123.tgz 456.tgz].map do |s|
+        dump = double("dump_#{s}", :path => double("dump_#{s}_path"))
+        expect(Dump::Reader).not_to receive(:summary)
+        dump
+      end
+
+      expect(Dump::Snapshot).to receive(:list).and_return(dumps)
+      grab_output do
+        expect($stderr).not_to receive(:puts)
+        described_class.versions
+      end
+    end
+
+    it 'shows summary if asked for' do
+      dumps = %w[123.tgz 456.tgz].map do |s|
+        dump = double("dump_#{s}", :path => double("dump_#{s}_path"))
+        expect(Dump::Reader).to receive(:summary).with(dump.path)
+        dump
+      end
+
+      expect(Dump::Snapshot).to receive(:list).and_return(dumps)
+      grab_output do
+        expect($stderr).not_to receive(:puts)
+        described_class.versions(:summary => '1')
+      end
+    end
+
+    it 'shows summary with scmema if asked for' do
+      dumps = %w[123.tgz 456.tgz].map do |s|
+        dump = double("dump_#{s}", :path => double("dump_#{s}_path"))
+        expect(Dump::Reader).to receive(:summary).with(dump.path, :schema => true)
+        dump
+      end
+
+      expect(Dump::Snapshot).to receive(:list).and_return(dumps)
+      grab_output do
+        expect($stderr).not_to receive(:puts)
+        described_class.versions(:summary => '2')
+      end
+    end
+
+    it 'shows output to stderr if summary raises error' do
+      allow(Dump::Reader).to receive(:summary)
+      dumps = %w[123.tgz 456.tgz].map do |s|
+        double("dump_#{s}", :path => double("dump_#{s}_path"))
+      end
+      expect(Dump::Reader).to receive(:summary).with(dumps[1].path).and_raise('terrible error')
+
+      expect(Dump::Snapshot).to receive(:list).and_return(dumps)
+      grab_output do
+        allow($stderr).to receive(:puts)
+        expect($stderr).to receive(:puts) do |s|
+          expect(s['terrible error']).not_to be_nil
+        end
+        described_class.versions(:summary => 'true')
+      end
+    end
+  end
+
+  describe 'create' do
+    describe 'naming' do
+      it "creates file in 'rails app root'/dump" do
+        allow(File).to receive(:rename)
+        expect(Dump::Writer).to receive(:create) do |path|
+          expect(File.dirname(path)).to eq(File.join(described_class.rails_root, 'dump'))
+        end
+        grab_output do
+          described_class.create
+        end
+      end
+
+      it "creates file with name like 'yyyymmddhhmmss.tmp' when called without description" do
+        allow(File).to receive(:rename)
+        expect(Dump::Writer).to receive(:create) do |path|
+          expect(File.basename(path)).to match(/^\d{14}\.tmp$/)
+        end
+        grab_output do
+          described_class.create
+        end
+      end
+
+      it "creates file with name like 'yyyymmddhhmmss-Some text and _.tmp' when called with description 'Some text and !@'" do
+        allow(File).to receive(:rename)
+        expect(Dump::Writer).to receive(:create) do |path|
+          expect(File.basename(path)).to match(/^\d{14}-Some text and _\.tmp$/)
+        end
+        grab_output do
+          described_class.create(:desc => 'Some text and !@')
+        end
+      end
+
+      it "creates file with name like 'yyyymmddhhmmss@super tag,second.tmp' when called with description 'Some text and !@'" do
+        allow(File).to receive(:rename)
+        expect(Dump::Writer).to receive(:create) do |path|
+          expect(File.basename(path)).to match(/^\d{14}-Some text and _\.tmp$/)
+        end
+        grab_output do
+          described_class.create(:desc => 'Some text and !@')
+        end
+      end
+
+      it 'renames file after creating' do
+        expect(File).to receive(:rename) do |tmp_path, tgz_path|
+          expect(File.basename(tmp_path)).to match(/^\d{14}-Some text and _\.tmp$/)
+          expect(File.basename(tgz_path)).to match(/^\d{14}-Some text and _\.tgz$/)
+        end
+        allow(Dump::Writer).to receive(:create)
+        grab_output do
+          described_class.create(:desc => 'Some text and !@')
+        end
+      end
+
+      it 'outputs file name' do
+        allow(File).to receive(:rename)
+        allow(Dump::Writer).to receive(:create)
+        expect(grab_output do
+          described_class.create(:desc => 'Some text and !@')
+        end[:stdout]).to match(/^\d{14}-Some text and _\.tgz$/)
+      end
+    end
+
+    describe 'writing' do
+      it 'dumps schema, tables, assets' do
+        allow(File).to receive(:rename)
+        @dump = double('dump')
+        expect(Dump::Writer).to receive(:create)
+
+        grab_output do
+          described_class.create
+        end
+      end
+    end
+  end
+
+  describe 'restore' do
+    describe 'without version' do
+      it 'calls Snapshot.list' do
+        allow(Dump::Snapshot).to receive(:list)
+        expect(Dump::Snapshot).to receive(:list).and_return([])
+        grab_output do
+          described_class.restore
+        end
+      end
+
+      it 'does not call Reader.restore and should call Snapshot.list and output it to $stderr if there are no versions at all' do
+        allow(Dump::Snapshot).to receive(:list).and_return([])
+        expect(Dump::Reader).not_to receive(:restore)
+        all_dumps = double('all_dumps')
+        expect(Dump::Snapshot).to receive(:list).with(no_args).and_return(all_dumps)
+        grab_output do
+          expect($stderr).to receive(:puts).with(kind_of(String))
+          expect($stderr).to receive(:puts).with(all_dumps)
+          described_class.restore
+        end
+      end
+
+      it 'does not call Reader.restore and should call Snapshot.list and output it to $stderr if there are no versions at all' do
+        allow(Dump::Snapshot).to receive(:list).and_return([])
+        expect(Dump::Reader).not_to receive(:restore)
+        all_dumps = double('all_dumps')
+        expect(Dump::Snapshot).to receive(:list).with(no_args).and_return(all_dumps)
+        grab_output do
+          expect($stderr).to receive(:puts).with(kind_of(String))
+          expect($stderr).to receive(:puts).with(all_dumps)
+          described_class.restore('213')
+        end
+      end
+
+      it 'calls Reader.restore if there are versions' do
+        @dump = double('dump', :path => 'dump/213.tgz')
+        expect(Dump::Snapshot).to receive(:list).once.and_return([@dump])
+        expect(Dump::Reader).to receive(:restore).with('dump/213.tgz')
+        grab_output do
+          expect($stderr).not_to receive(:puts)
+          described_class.restore
+        end
+      end
+    end
+
+    describe 'with version' do
+      it 'calls Snapshot.list with options' do
+        allow(Dump::Snapshot).to receive(:list)
+        expect(Dump::Snapshot).to receive(:list).with(:like => '213').and_return([])
+        grab_output do
+          described_class.restore(:like => '213')
+        end
+      end
+
+      it 'does not call Reader.restore and should call versions if desired version not found' do
+        allow(Dump::Snapshot).to receive(:list).and_return([])
+        expect(Dump::Reader).not_to receive(:restore)
+        all_dumps = double('all_dumps')
+        expect(Dump::Snapshot).to receive(:list).with(no_args).and_return(all_dumps)
+        grab_output do
+          expect($stderr).to receive(:puts).with(kind_of(String))
+          expect($stderr).to receive(:puts).with(all_dumps)
+          described_class.restore('213')
+        end
+      end
+
+      it 'calls Reader.restore if there is desired version' do
+        @dump = double('dump', :path => 'dump/213.tgz')
+        expect(Dump::Snapshot).to receive(:list).once.and_return([@dump])
+        expect(Dump::Reader).to receive(:restore).with('dump/213.tgz')
+        expect(described_class).not_to receive(:versions)
+        grab_output do
+          expect($stderr).not_to receive(:puts)
+          described_class.restore(:like => '213')
+        end
+      end
+
+      it 'calls Reader.restore on last version if found multiple matching versions' do
+        @dump_a = double('dump_a', :path => 'dump/213-a.tgz')
+        @dump_b = double('dump_b', :path => 'dump/213-b.tgz')
+        expect(Dump::Snapshot).to receive(:list).once.and_return([@dump_a, @dump_b])
+        expect(Dump::Reader).to receive(:restore).with('dump/213-b.tgz')
+        grab_output do
+          expect($stderr).not_to receive(:puts)
+          described_class.restore(:like => '213')
+        end
+      end
+    end
+  end
+
+  describe 'cleanup' do
+    it 'calls ask for all files in dump dir and for dumps' do
+      expect(Dump::Snapshot).to receive(:list).with(:all => true).and_return([])
+      expect(Dump::Snapshot).to receive(:list).with({}).and_return([])
+      described_class.cleanup
+    end
+
+    it 'calls Snapshot.list with options if called with version and tags' do
+      expect(Dump::Snapshot).to receive(:list).with(:like => '123', :tags => 'a,b,c', :all => true).and_return([])
+      expect(Dump::Snapshot).to receive(:list).with(:like => '123', :tags => 'a,b,c').and_return([])
+      described_class.cleanup(:like => '123', :tags => 'a,b,c')
+    end
+
+    {
+      {} => [0..4],
+      {:leave => '3'} => [0..6],
+      {:leave => '5'} => [0..4],
+      {:leave => '9'} => [0],
+      {:leave => '10'} => [],
+      {:leave => '15'} => [],
+      {:leave => 'none'} => [0..9],
+    }.each do |options, ids|
+      it "calls delete #{ids} dumps when called with #{options}" do
+        dumps = %w[a b c d e f g h i j].map do |s|
+          double("dump_#{s}", :ext => 'tgz', :path => double("dump_#{s}_path"))
+        end
+        tmp_dumps = %w[a b c].map do |s|
+          double("tmp_dump_#{s}", :ext => 'tmp', :path => double("tmp_dump_#{s}_path"))
+        end
+        all_dumps = tmp_dumps[0, 1] + dumps[0, 5] + tmp_dumps[1, 1] + dumps[5, 5] + tmp_dumps[2, 1]
+
+        (dumps.values_at(*ids) + [tmp_dumps[0], tmp_dumps[2]]).each do |dump|
+          expect(dump).to receive(:lock).and_yield
+          expect(dump.path).to receive(:unlink)
+        end
+        [tmp_dumps[1]].each do |dump|
+          expect(dump).to receive(:lock)
+          expect(dump.path).not_to receive(:unlink)
+        end
+        (dumps - dumps.values_at(*ids)).each do |dump|
+          expect(dump).not_to receive(:lock)
+          expect(dump.path).not_to receive(:unlink)
+        end
+
+        expect(Dump::Snapshot).to receive(:list).with(hash_including(:all => true)).and_return(all_dumps)
+        expect(Dump::Snapshot).to receive(:list).with(hash_not_including(:all => true)).and_return(dumps)
+        grab_output do
+          described_class.cleanup({:like => '123', :tags => 'a,b,c'}.merge(options))
+        end
+      end
+    end
+
+    it 'prints to stderr if can not delete dump' do
+      dumps = %w[a b c d e f g h i j].map do |s|
+        dump = double("dump_#{s}", :ext => 'tgz', :path => double("dump_#{s}_path"))
+        allow(dump).to receive(:lock).and_yield
+        allow(dump.path).to receive(:unlink)
+        dump
+      end
+
+      expect(dumps[3].path).to receive(:unlink).and_raise('Horrible error')
+
+      allow(Dump::Snapshot).to receive(:list).and_return(dumps)
+      grab_output do
+        allow($stderr).to receive(:puts)
+        expect($stderr).to receive(:puts) do |s|
+          expect(s[dumps[3].path.to_s]).not_to be_nil
+          expect(s['Horrible error']).not_to be_nil
+        end
+        described_class.cleanup
+      end
+    end
+
+    it "raises if called with :leave which is not a number or 'none'" do
+      expect do
+        described_class.cleanup(:leave => 'nothing')
+      end.to raise_error
+    end
+  end
+end