dump 1.0.0

data/spec/lib/dump_rake/dump_spec.rb

@@ -0,0 +1,291 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe DumpRake::Dump do
+  def dump_path(file_name)
+    File.join(DumpRake::RailsRoot, 'dump', file_name)
+  end
+
+  def new_dump(file_name)
+    DumpRake::Dump.new(dump_path(file_name))
+  end
+
+  describe "lock" do
+    before do
+      @yield_receiver = mock('yield_receiver')
+    end
+
+    it "should not yield if file does not exist" do
+      @yield_receiver.should_not_receive(:fire)
+
+      File.should_receive(:open).and_return(nil)
+
+      DumpRake::Dump.new('hello').lock do
+        @yield_receiver.fire
+      end
+    end
+
+    it "should not yield if file can not be locked" do
+      @yield_receiver.should_not_receive(:fire)
+
+      @file = mock('file')
+      @file.should_receive(:flock).with(File::LOCK_EX | File::LOCK_NB).and_return(nil)
+      @file.should_receive(:flock).with(File::LOCK_UN)
+      @file.should_receive(:close)
+      File.should_receive(:open).and_return(@file)
+
+      DumpRake::Dump.new('hello').lock do
+        @yield_receiver.fire
+      end
+    end
+
+    it "should yield if file can not be locked" do
+      @yield_receiver.should_receive(:fire)
+
+      @file = mock('file')
+      @file.should_receive(:flock).with(File::LOCK_EX | File::LOCK_NB).and_return(true)
+      @file.should_receive(:flock).with(File::LOCK_UN)
+      @file.should_receive(:close)
+      File.should_receive(:open).and_return(@file)
+
+      DumpRake::Dump.new('hello').lock do
+        @yield_receiver.fire
+      end
+    end
+  end
+
+  describe "new" do
+    it "should init with path if String sent" do
+      DumpRake::Dump.new('hello').path.should == Pathname('hello')
+    end
+
+    it "should init with path if Pathname sent" do
+      DumpRake::Dump.new(Pathname('hello')).path.should == Pathname('hello')
+    end
+
+    describe "with options" do
+      before do
+        @time = mock('time')
+        @time.stub!(:utc).and_return(@time)
+        @time.stub!(:strftime).and_return('19650414065945')
+        Time.stub!(:now).and_return(@time)
+      end
+
+      it "should generate path with no options" do
+        DumpRake::Dump.new.path.should == Pathname('19650414065945.tgz')
+      end
+
+      it "should generate with dir" do
+        DumpRake::Dump.new(:dir => 'dump_dir').path.should == Pathname('dump_dir/19650414065945.tgz')
+      end
+
+      it "should generate path with description" do
+        DumpRake::Dump.new(:dir => 'dump_dir', :desc => 'hello world').path.should == Pathname('dump_dir/19650414065945-hello world.tgz')
+      end
+
+      it "should generate path with tags" do
+        DumpRake::Dump.new(:dir => 'dump_dir', :tags => ' mirror, hello world ').path.should == Pathname('dump_dir/19650414065945@hello world,mirror.tgz')
+      end
+
+      it "should generate path with description and tags" do
+        DumpRake::Dump.new(:dir => 'dump_dir', :desc => 'Anniversary backup', :tags => ' mirror, hello world ').path.should == Pathname('dump_dir/19650414065945-Anniversary backup@hello world,mirror.tgz')
+      end
+    end
+  end
+
+  describe "versions" do
+    describe "list" do
+      def stub_glob
+        paths = %w[123 345 567].map do |name|
+          path = dump_path("#{name}.tgz")
+          File.should_receive(:file?).with(path).at_least(1).and_return(true)
+          path
+        end
+        Dir.stub!(:[]).and_return(paths)
+      end
+
+      it "should search for files in dump dir when asked for list" do
+        Dir.should_receive(:[]).with(dump_path('*.tgz')).and_return([])
+        DumpRake::Dump.list
+      end
+
+      it "should return selves instances for each found file" do
+        stub_glob
+        DumpRake::Dump.list.all?{ |dump| dump.should be_a(DumpRake::Dump) }
+      end
+
+      it "should return dumps with name containting :like" do
+        stub_glob
+        DumpRake::Dump.list(:like => '3').should == DumpRake::Dump.list.values_at(0, 1)
+      end
+    end
+
+    describe "with tags" do
+      before do
+        #             0        1  2    3      4      5        6    7    8      9  10   11   12     13 14 15   16
+        dumps_tags = [''] + %w[a  a,d  a,d,o  a,d,s  a,d,s,o  a,o  a,s  a,s,o  d  d,o  d,s  d,s,o  o  s  s,o  z]
+        paths = dumps_tags.each_with_index.map do |dump_tags, i|
+          path = dump_path("196504140659#{10 + i}@#{dump_tags}.tgz")
+          File.should_receive(:file?).with(path).at_least(1).and_return(true)
+          path
+        end
+        Dir.stub!(:[]).and_return(paths)
+      end
+
+      it "should return all dumps if no tags send" do
+        DumpRake::Dump.list(:tags => '').should == DumpRake::Dump.list
+      end
+
+      {
+        'x'           => [],
+        '+x'          => [],
+        'z'           => [16],
+        'a,d,s,o'     => [1..15],
+        '+a,+d,+s,+o' => [5],
+        '-o'          => [0, 1, 2, 4, 7, 9, 11, 14, 16],
+        'a,b,c,+s,-o' => [4, 7],
+        '+a,+d'          => [2, 3, 4, 5],
+        '+d,+a'          => [2, 3, 4, 5],
+      }.each do |tags, ids|
+        it "should return dumps filtered by #{tags}" do
+          DumpRake::Dump.list(:tags => tags).should == DumpRake::Dump.list.values_at(*ids)
+        end
+      end
+    end
+  end
+
+  describe "name" do
+    it "should return file name" do
+      new_dump("19650414065945.tgz").name.should == '19650414065945.tgz'
+    end
+  end
+
+  describe "parts" do
+    before do
+      @time = Time.utc(1965, 4, 14, 6, 59, 45)
+    end
+
+    def dump_name_parts(name)
+      dump = new_dump(name)
+      [dump.time, dump.description, dump.tags, dump.ext]
+    end
+
+    %w[tmp tgz].each do |ext|
+      it "should return empty results for dump with wrong name" do
+        dump_name_parts("196504140659.#{ext}").should == [nil, '', [], nil]
+        dump_name_parts("196504140659-lala.#{ext}").should == [nil, '', [], nil]
+        dump_name_parts("196504140659@lala.#{ext}").should == [nil, '', [], nil]
+        dump_name_parts("19650414065945.ops").should == [nil, '', [], nil]
+      end
+
+      it "should return tags for dump with tags" do
+        dump_name_parts("19650414065945.#{ext}").should == [@time, '', [], ext]
+        dump_name_parts("19650414065945- Hello world &&& .#{ext}").should == [@time, 'Hello world _', [], ext]
+        dump_name_parts("19650414065945- Hello world &&& @ test , hello world , bad tag ~~~~.#{ext}").should == [@time, 'Hello world _', ['bad tag _', 'hello world', 'test'], ext]
+        dump_name_parts("19650414065945@test, test , hello world , bad tag ~~~~.#{ext}").should == [@time, '', ['bad tag _', 'hello world', 'test'], ext]
+        dump_name_parts("19650414065945-Hello world@test,super tag.#{ext}").should == [@time, 'Hello world', ['super tag', 'test'], ext]
+      end
+    end
+  end
+
+  describe "path" do
+    it "should return path" do
+      new_dump("19650414065945.tgz").path.should == Pathname(File.join(DumpRake::RailsRoot, 'dump', "19650414065945.tgz"))
+    end
+  end
+
+  describe "tgz_path" do
+    it "should return path if extension is already tgz" do
+      new_dump("19650414065945.tgz").tgz_path.should == new_dump("19650414065945.tgz").path
+    end
+
+    it "should return path with tgz extension" do
+      new_dump("19650414065945.tmp").tgz_path.should == new_dump("19650414065945.tgz").path
+    end
+  end
+
+  describe "tmp_path" do
+    it "should return path if extension is already tmp" do
+      new_dump("19650414065945.tmp").tmp_path.should == new_dump("19650414065945.tmp").path
+    end
+
+    it "should return path with tmp extension" do
+      new_dump("19650414065945.tgz").tmp_path.should == new_dump("19650414065945.tmp").path
+    end
+  end
+
+  describe "clean_description" do
+    it "should shorten string to 50 chars and replace special symblos with '-'" do
+      DumpRake::Dump.new('').send(:clean_description, 'Special  Dump #12837192837 (before fixind *&^*&^ photos)').should == 'Special Dump #12837192837 (before fixind _ photos)'
+      DumpRake::Dump.new('').send(:clean_description, "To#{'o' * 100} long description").should == "T#{'o' * 49}"
+    end
+
+    it "should accept non string" do
+      DumpRake::Dump.new('').send(:clean_description, nil).should == ''
+    end
+  end
+
+  describe "clean_tag" do
+    it "should shorten string to 20 chars and replace special symblos with '-'" do
+      DumpRake::Dump.new('').send(:clean_tag, 'Very special  tag #12837192837 (fixind *&^*&^)').should == 'very special tag _12'
+      DumpRake::Dump.new('').send(:clean_tag, "To#{'o' * 100} long tag").should == "t#{'o' * 19}"
+    end
+
+    it "should not allow '-' or '+' to be first symbol" do
+      DumpRake::Dump.new('').send(:clean_tag, ' Very special tag').should == 'very special tag'
+      DumpRake::Dump.new('').send(:clean_tag, '-Very special tag').should == 'very special tag'
+      DumpRake::Dump.new('').send(:clean_tag, '-----------').should == ''
+      DumpRake::Dump.new('').send(:clean_tag, '+Very special tag').should == '_very special tag'
+      DumpRake::Dump.new('').send(:clean_tag, '+++++++++++').should == '_'
+    end
+
+    it "should accept non string" do
+      DumpRake::Dump.new('').send(:clean_tag, nil).should == ''
+    end
+  end
+
+  describe "clean_tags" do
+    it "should split string and return uniq non blank sorted tags" do
+      DumpRake::Dump.new('').send(:clean_tags, ' perfect  tag , hello,Hello,this  is (*^(*&').should == ['hello', 'perfect tag', 'this is _']
+      DumpRake::Dump.new('').send(:clean_tags, "l#{'o' * 100}ng tag").should == ["l#{'o' * 19}"]
+    end
+
+    it "should accept non string" do
+      DumpRake::Dump.new('').send(:clean_tags, nil).should == []
+    end
+  end
+
+  describe "get_filter_tags" do
+    it "should split string and return uniq non blank sorted tags" do
+      DumpRake::Dump.new('').send(:get_filter_tags, 'a,+b,+c,-d').should == {:simple => %w[a], :mandatory => %w[b c], :forbidden => %w[d]}
+      DumpRake::Dump.new('').send(:get_filter_tags, ' a , + b , + c , - d ').should == {:simple => %w[a], :mandatory => %w[b c], :forbidden => %w[d]}
+      DumpRake::Dump.new('').send(:get_filter_tags, ' a , + c , + b , - d ').should == {:simple => %w[a], :mandatory => %w[b c], :forbidden => %w[d]}
+      DumpRake::Dump.new('').send(:get_filter_tags, ' a , + b , + , - ').should == {:simple => %w[a], :mandatory => %w[b], :forbidden => []}
+      DumpRake::Dump.new('').send(:get_filter_tags, ' a , a , + b , + b , - d , - d ').should == {:simple => %w[a], :mandatory => %w[b], :forbidden => %w[d]}
+      proc{ DumpRake::Dump.new('').send(:get_filter_tags, 'a,+a') }.should_not raise_error
+      proc{ DumpRake::Dump.new('').send(:get_filter_tags, 'a,-a') }.should raise_error
+      proc{ DumpRake::Dump.new('').send(:get_filter_tags, '+a,-a') }.should raise_error
+    end
+
+    it "should accept non string" do
+      DumpRake::Dump.new('').send(:get_filter_tags, nil).should == {:simple => [], :mandatory => [], :forbidden => []}
+    end
+  end
+
+  describe "assets_root_link" do
+    it "should create tem dir, chdir there, symlink rails app root to assets, yield and unlink assets ever if something raised" do
+      Dir.should_receive(:mktmpdir).and_yield('/tmp/abc')
+      Dir.should_receive(:chdir).with('/tmp/abc').and_yield
+      File.should_receive(:symlink).with(DumpRake::RailsRoot, 'assets')
+      File.should_receive(:unlink).with('assets')
+      proc{
+        DumpRake::Dump.new('').send(:assets_root_link) do |dir, prefix|
+          dir.should == '/tmp/abc'
+          prefix.should == 'assets'
+          @yielded = true
+          raise 'just test'
+        end
+      }.should raise_error('just test')
+      @yielded.should == true
+    end
+  end
+end

data/spec/lib/dump_rake/dump_writer_spec.rb

@@ -0,0 +1,328 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require File.dirname(__FILE__) + '/../../../lib/dump_rake'
+
+DumpWriter = DumpRake::DumpWriter
+describe DumpWriter do
+  describe "create" do
+    it "should create selves instance and open" do
+      @dump = mock('dump')
+      @dump.should_receive(:open)
+      DumpWriter.should_receive(:new).with('/abc/123.tmp').and_return(@dump)
+      DumpWriter.create('/abc/123.tmp')
+    end
+
+    it "should call dump subroutines" do
+      @dump = mock('dump')
+      @dump.stub!(:open).and_yield(@dump)
+      DumpWriter.stub!(:new).and_return(@dump)
+
+      @dump.should_receive(:write_schema).ordered
+      @dump.should_receive(:write_tables).ordered
+      @dump.should_receive(:write_assets).ordered
+      @dump.should_receive(:write_config).ordered
+
+      DumpWriter.create('/abc/123.tmp')
+    end
+  end
+
+  describe "open" do
+    it "should create dir for dump" do
+      Zlib::GzipWriter.stub!(:open)
+      FileUtils.should_receive(:mkpath).with('/abc/def/ghi')
+      DumpWriter.new('/abc/def/ghi/123.tgz').open
+    end
+
+    it "should set stream to gzipped tar writer" do
+      FileUtils.stub!(:mkpath)
+      @gzip = mock('gzip')
+      @stream = mock('stream')
+      Zlib::GzipWriter.should_receive(:open).with(Pathname("123.tgz")).and_yield(@gzip)
+      Archive::Tar::Minitar::Output.should_receive(:open).with(@gzip).and_yield(@stream)
+      @gzip.should_receive(:mtime=).with(Time.utc(2000))
+
+      @dump = DumpWriter.new('123.tgz')
+      @dump.should_receive(:lock).and_yield
+      @dump.open do |dump|
+        dump.should == @dump
+        dump.stream.should == @stream
+      end
+    end
+  end
+
+  describe "subroutines" do
+    before do
+      @tar = mock('tar')
+      @stream = mock('stream', :tar => @tar)
+      @config = {:tables => {}}
+      @dump = DumpWriter.new('123.tgz')
+      @dump.stub!(:stream).and_return(@stream)
+      @dump.stub!(:config).and_return(@config)
+      Progress.stub!(: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
+        @temp = mock('temp', :open => true, :length => 6, :read => 'qwfpgj')
+        @temp.should_receive(:write).with('qwfpgj')
+        @temp.stub!(:eof?).and_return(false, true)
+        Tempfile.should_receive(:open).and_yield(@temp)
+
+        @file = mock('file')
+        @file.should_receive(:write).with('qwfpgj')
+
+        @stream.tar.should_receive(:add_file_simple).with('abc/def.txt', :mode => 0100444, :size => 6).and_yield(@file)
+
+        @dump.create_file('abc/def.txt') do |file|
+          file.should == @temp
+          file.write('qwfpgj')
+        end
+      end
+    end
+
+    describe "write_schema" do
+      it "should create file schema.rb" do
+        @dump.should_receive(:create_file).with('schema.rb')
+        @dump.write_schema
+      end
+
+      it "should set ENV[SCHEMA] to path of returned file" do
+        @file = mock('file', :path => 'db/schema.rb')
+        @dump.stub!(:create_file).and_yield(@file)
+        DumpRake::Env.should_receive(:with_env).with('SCHEMA' => 'db/schema.rb')
+        @dump.write_schema
+      end
+
+      it "should call rake task db:schema:dump" do
+        @file = mock('file', :path => 'db/schema.rb')
+        @dump.stub!(:create_file).and_yield(@file)
+        @task = mock('task')
+        Rake::Task.should_receive(:[]).with('db:schema:dump').and_return(@task)
+        @task.should_receive(:invoke)
+        @dump.write_schema
+      end
+    end
+
+    describe "write_tables" do
+      it "should verify connection" do
+        @dump.stub!(:tables_to_dump).and_return([])
+        @dump.should_receive(:verify_connection)
+        @dump.write_tables
+      end
+
+      it "should call write_table for each table returned by tables_to_dump" do
+        @dump.stub!(:verify_connection)
+        @dump.stub!(:tables_to_dump).and_return(%w[first second])
+
+        @dump.should_receive(:write_table).with('first')
+        @dump.should_receive(:write_table).with('second')
+
+        @dump.write_tables
+      end
+    end
+
+    describe "write_table" do
+      it "should get row count and store it to config" do
+        @dump.should_receive(:table_row_count).with('first').and_return(666)
+        @dump.stub!(:create_file)
+        @dump.write_table('first')
+        @config[:tables]['first'].should == 666
+      end
+
+      it "should create_file" do
+        @dump.stub!(:table_row_count).and_return(666)
+        @dump.should_receive(:create_file)
+        @dump.write_table('first')
+      end
+
+      it "should dump column names and values of each row" do
+        @column_definitions = [
+          mock('column', :name => 'id'),
+          mock('column', :name => 'name'),
+          mock('column', :name => 'associated_id')
+        ]
+        ActiveRecord::Base.connection.stub!(:columns).and_return(@column_definitions)
+        @rows = [
+          {'id' => 1, 'name' => 'a', 'associated_id' => 100},
+          {'id' => 2, 'name' => 'b', 'associated_id' => 666},
+        ]
+
+        @file = mock('file')
+        @dump.stub!(:table_row_count).and_return(666)
+        @dump.stub!(:create_file).and_yield(@file)
+
+        column_names = @column_definitions.map(&:name).sort
+        @file.should_receive(:write).with(Marshal.dump(column_names)).ordered
+        each_tabler_row_yielder = @dump.should_receive(:each_table_row)
+        @rows.each do |row|
+          each_tabler_row_yielder.and_yield(row)
+          @file.should_receive(:write).with(Marshal.dump(row.values_at(*column_names))).ordered
+          @column_definitions.each do |column_definition|
+            column_definition.should_receive(:type_cast).with(row[column_definition.name]).and_return(row[column_definition.name])
+          end
+        end
+
+        @dump.write_table('first')
+      end
+    end
+
+    describe "write_assets" do
+      before do
+        @dump.stub!(:assets_root_link).and_yield('/tmp', 'assets')
+      end
+
+      it "should call assets_to_dump" do
+        @dump.should_receive(:assets_to_dump).and_return([])
+        @dump.write_assets
+      end
+
+      it "should change root to rails app root" do
+        @file = mock('file')
+        @dump.stub!(:assets_to_dump).and_return(%w[images videos])
+        @dump.stub!(:create_file).and_yield(@file)
+
+        Dir.should_receive(:chdir).with(DumpRake::RailsRoot)
+        @dump.write_assets
+      end
+
+      it "should put assets to config" do
+        @file = mock('file')
+        @dump.stub!(:assets_to_dump).and_return(%w[images/* videos])
+        @dump.stub!(:create_file).and_yield(@file)
+        Dir.stub!(:chdir).and_yield
+        @tar = mock('tar_writer')
+        Archive::Tar::Minitar::Output.stub!(:open).and_yield(@tar)
+        Dir.stub!(:[]).and_return([])
+        Dir.should_receive(:[]).with(*%w[images/* videos]).and_return(%w[images/a images/b videos])
+
+        @dump.write_assets
+        counts = {:files => 0, :total => 0}
+        @config[:assets].should == {'images/a' => counts, 'images/b' => counts, 'videos' => counts}
+      end
+
+      it "should use glob to find files" do
+        @file = mock('file')
+        @dump.stub!(:assets_to_dump).and_return(%w[images/* videos])
+        @dump.stub!(:create_file).and_yield(@file)
+        Dir.stub!(:chdir).and_yield
+        @tar = mock('tar_writer')
+        Archive::Tar::Minitar::Output.stub!(:open).and_yield(@tar)
+
+        Dir.should_receive(:[]).with(*%w[images/* videos]).and_return(%w[images/a images/b videos])
+        Dir.should_receive(:[]).with('images/a/**/*').and_return([])
+        Dir.should_receive(:[]).with('images/b/**/*').and_return([])
+        Dir.should_receive(:[]).with('videos/**/*').and_return([])
+
+        @dump.write_assets
+      end
+
+      it "should pack each file from assets_root_link" do
+        @file = mock('file')
+        @dump.stub!(:assets_to_dump).and_return(%w[images/* videos])
+        @dump.stub!(:create_file).and_yield(@file)
+        Dir.stub!(:chdir).and_yield
+        @tar = mock('tar_writer')
+        Archive::Tar::Minitar::Output.stub!(:open).and_yield(@tar)
+
+        Dir.should_receive(:[]).with(*%w[images/* videos]).and_return(%w[images/a images/b videos])
+        Dir.should_receive(:[]).with('images/a/**/*').and_return([])
+        Dir.should_receive(:[]).with('images/b/**/*').and_return([])
+        Dir.should_receive(:[]).with('videos/**/*').and_return([])
+
+        @dump.should_receive(:assets_root_link).exactly(3).times
+
+        @dump.write_assets
+      end
+
+      it "should pack each file" do
+        @file = mock('file')
+        @dump.stub!(:assets_to_dump).and_return(%w[images/* videos])
+        @dump.stub!(:create_file).and_yield(@file)
+        Dir.stub!(:chdir).and_yield
+        @tar = mock('tar_writer')
+        Archive::Tar::Minitar::Output.stub!(:open).and_yield(@tar)
+
+        Dir.should_receive(:[]).with(*%w[images/* videos]).and_return(%w[images/a images/b videos])
+        Dir.should_receive(:[]).with('images/a/**/*').and_return(%w[a.jpg b.jpg])
+        Dir.should_receive(:[]).with('images/b/**/*').and_return(%w[c.jpg d.jpg])
+        Dir.should_receive(:[]).with('videos/**/*').and_return(%w[a.mov b.mov])
+
+        %w[a.jpg b.jpg c.jpg d.jpg a.mov b.mov].each do |file_name|
+          Archive::Tar::Minitar.should_receive(:pack_file).with("assets/#{file_name}", @stream)
+        end
+
+        @dump.write_assets
+      end
+
+      it "should not raise if something fails when packing" do
+        @file = mock('file')
+        @dump.stub!(:assets_to_dump).and_return(%w[videos])
+        @dump.stub!(:create_file).and_yield(@file)
+        Dir.stub!(:chdir).and_yield
+        @tar = mock('tar_writer')
+        Archive::Tar::Minitar::Output.stub!(:open).and_yield(@tar)
+
+        Dir.should_receive(:[]).with(*%w[videos]).and_return(%w[videos])
+        Dir.should_receive(:[]).with('videos/**/*').and_return(%w[a.mov b.mov])
+
+        Archive::Tar::Minitar.should_receive(:pack_file).with('assets/a.mov', @stream).and_raise('file not found')
+        Archive::Tar::Minitar.should_receive(:pack_file).with('assets/b.mov', @stream)
+
+        grab_output {
+          @dump.write_assets
+        }
+      end
+
+    end
+
+    describe "write_config" do
+      it "should create file config" do
+        @dump.should_receive(:create_file).with('config')
+        @dump.write_config
+      end
+
+      it "should dump column names and values of each row" do
+        @file = mock('file')
+        @dump.stub!(:create_file).and_yield(@file)
+        @config.replace({:tables => {'first' => 1, 'second' => 2}, :assets => %w[images videos]})
+
+        @file.should_receive(:write).with(Marshal.dump(@config))
+        @dump.write_config
+      end
+    end
+
+    describe "assets_to_dump" do
+      it "should call rake task assets" do
+        @task = mock('task')
+        Rake::Task.should_receive(:[]).with('assets').and_return(@task)
+        @task.should_receive(:invoke)
+        @dump.assets_to_dump
+      end
+
+      it "should return array of assets if separator is colon" do
+        @task = mock('task')
+        Rake::Task.stub!(:[]).and_return(@task)
+        @task.stub!(:invoke)
+        DumpRake::Env.with_env(:assets => 'images:videos') do
+          @dump.assets_to_dump.should == %w[images videos]
+        end
+      end
+
+      it "should return array of assets if separator is comma" do
+        @task = mock('task')
+        Rake::Task.stub!(:[]).and_return(@task)
+        @task.stub!(:invoke)
+        DumpRake::Env.with_env(:assets => 'images,videos') do
+          @dump.assets_to_dump.should == %w[images videos]
+        end
+      end
+
+      it "should return empty array if calling rake task assets raises an exception" do
+        Rake::Task.stub!(:[]).and_raise('task assets not found')
+        DumpRake::Env.with_env(:assets => 'images:videos') do
+          @dump.assets_to_dump.should == []
+        end
+      end
+    end
+  end
+end