netguru-safe 0.2.9

data/spec/unit/gzip_spec.rb

@@ -0,0 +1,64 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Astrails::Safe::Gzip do
+
+  def def_backup
+    {
+      :compressed => false,
+      :command => "command",
+      :extension => ".foo",
+      :filename => "qweqwe"
+    }
+  end
+
+  after(:each) { Astrails::Safe::TmpFile.cleanup }
+
+  def gzip(config = {}, backup = def_backup)
+    Astrails::Safe::Gzip.new(
+      @config = Astrails::Safe::Config::Node.new(nil, config),
+      @backup = Astrails::Safe::Backup.new(backup)
+    )
+  end
+
+  describe :preocess do
+
+    describe "when not yet compressed" do
+      before(:each) { @gzip = gzip }
+
+      it "should add .gz extension" do
+        mock(@backup.extension) << '.gz'
+        @gzip.process
+      end
+
+      it "should add |gzip pipe" do
+        mock(@backup.command) << '|gzip'
+        @gzip.process
+      end
+
+      it "should set compressed" do
+        mock(@backup).compressed = true
+        @gzip.process
+      end
+    end
+
+    describe "when already compressed" do
+
+      before(:each) { @gzip = gzip({}, :extension => ".foo", :command => "foobar", :compressed => true) }
+
+      it "should not touch extension" do
+        @gzip.process
+        @backup.extension.should == ".foo"
+      end
+
+      it "should not touch command" do
+        @gzip.process
+        @backup.command.should == "foobar"
+      end
+
+      it "should not touch compressed" do
+        @gzip.process
+        @backup.compressed.should == true
+      end
+    end
+  end
+end

data/spec/unit/local_spec.rb

@@ -0,0 +1,110 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Astrails::Safe::Local do
+  def def_config
+    {
+      :local => {
+        :path => "/:kind~:id~:timestamp"
+      },
+      :keep => {
+        :local => 2
+      }
+    }
+  end
+
+  def def_backup
+    {
+      :kind => "mysqldump",
+      :id => "blog",
+      :timestamp => "NoW",
+      :compressed => true,
+      :command => "command",
+      :extension => ".foo.gz",
+      :filename => "qweqwe"
+    }
+  end
+
+  def local(config = def_config, backup = def_backup)
+    Astrails::Safe::Local.new(
+      @config = Astrails::Safe::Config::Node.new(nil, config),
+      @backup = Astrails::Safe::Backup.new(backup)
+    )
+  end
+
+  describe :active? do
+    it "should be true" do
+      local.should be_active
+    end
+  end
+
+  describe :path do
+    it "should raise RuntimeError when no path" do
+      lambda {
+        local({}).send :path
+      }.should raise_error(RuntimeError, "missing :local/:path")
+    end
+
+    it "should use local/path" do
+      local.send(:path).should == "/mysqldump~blog~NoW"
+    end
+  end
+
+  describe :save do
+    before(:each) do
+      @local = local
+      stub(@local).system
+      stub(@local).full_path {"file-path"}
+      stub(FileUtils).mkdir_p
+    end
+
+    it "should call system to save the file" do
+      mock(@local).system("command>file-path")
+      @local.send(:save)
+    end
+
+    it "should create directory" do
+      mock(FileUtils).mkdir_p("/mysqldump~blog~NoW")
+      @local.send(:save)
+    end
+
+    it "should set backup.path" do
+      mock(@backup).path = "file-path"
+      @local.send(:save)
+    end
+
+    describe "dry run" do
+      before(:all) {$DRY_RUN = true}
+      after(:all)  {$DRY_RUN = false}
+
+      it "should not create directory"
+      it "should not call system"
+      it "should set backup.path" do
+        mock(@backup).path = "file-path"
+        @local.send(:save)
+      end
+    end
+  end
+
+  describe :cleanup do
+    before(:each) do
+      @files = [4,1,3,2].map { |i| "/mysqldump~blog~NoW/qweqwe.#{i}" }
+      stub(File).file?(anything) {true}
+      stub(File).size(anything) {1}
+      stub(File).unlink
+    end
+
+    it "should check [:keep, :local]" do
+      @local = local(def_config.merge(:keep => {}))
+      dont_allow(Dir).[]
+      @local.send :cleanup
+    end
+
+    it "should delete extra files" do
+      @local = local
+      mock(Dir).[]("/mysqldump~blog~NoW/qweqwe.*") {@files}
+      mock(File).unlink("/mysqldump~blog~NoW/qweqwe.1")
+      mock(File).unlink("/mysqldump~blog~NoW/qweqwe.2")
+      @local.send :cleanup
+    end
+  end
+end

data/spec/unit/mongodump_spec.rb

@@ -0,0 +1,54 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Astrails::Safe::Mongodump do
+  def def_config
+    {
+      :host => 'prod.example.com',
+      :user => 'testuser',
+      :password => 'p4ssw0rd',
+    }
+  end
+  
+  def mongodump(id = :foo, config = def_config)
+    Astrails::Safe::Mongodump.new(id, Astrails::Safe::Config::Node.new(nil, config))
+  end
+  
+  before(:each) do
+    stub(Time).now.stub!.strftime {"NOW"}
+    @output_folder = File.join(Astrails::Safe::TmpFile.tmproot, 'mongodump')
+  end
+  
+  after(:each) { Astrails::Safe::TmpFile.cleanup }
+  
+  describe :backup do
+    before(:each) do
+      @mongo = mongodump
+    end
+    
+    {
+      :id => "foo",
+      :kind => "mongodump",
+      :extension => ".tar",
+      :filename => "mongodump-foo.NOW"
+    }.each do |k, v|
+      it "should set #{k} to #{v}" do
+        @mongo.backup.send(k).should == v
+      end
+    end
+    
+    it "should set the command" do
+      @mongo.backup.send(:command).should == "mongodump -q \"{xxxx : { \\$ne : 0 } }\" --db foo --host prod.example.com -u testuser -p p4ssw0rd --out #{@output_folder} && cd #{@output_folder} && tar cf - ."
+    end
+    
+    {
+      :host => "--host ",
+      :user => "-u ",
+      :password => "-p "
+    }.each do |key, v|    
+      it "should not add #{key} to command if it is not present" do
+        @mongo = mongodump(:foo, def_config.reject! {|k,v| k == key})
+        @mongo.backup.send(:command).should_not =~ /#{v}/
+      end
+    end
+  end
+end

data/spec/unit/mysqldump_spec.rb

@@ -0,0 +1,83 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Astrails::Safe::Mysqldump do
+
+  def def_config(extra = {})
+    {
+      :options => "OPTS",
+      :user => "User",
+      :password => "pwd",
+      :host => "localhost",
+      :port => 7777,
+      :socket => "socket",
+      :skip_tables => [:bar, :baz]
+    }.merge(extra)
+  end
+
+  def mysqldump(id = :foo, config = def_config)
+    Astrails::Safe::Mysqldump.new(id, Astrails::Safe::Config::Node.new(nil, config))
+  end
+
+  before(:each) do
+    stub(Time).now.stub!.strftime {"NOW"}
+  end
+
+  after(:each) { Astrails::Safe::TmpFile.cleanup }
+
+  describe :backup do
+    before(:each) do
+      @mysql = mysqldump
+      stub(@mysql).mysql_password_file {"/tmp/pwd"}
+    end
+
+    {
+      :id => "foo",
+      :kind => "mysqldump",
+      :extension => ".sql",
+      :filename => "mysqldump-foo.NOW",
+      :command => "mysqldump --defaults-extra-file=/tmp/pwd OPTS --ignore-table=foo.bar --ignore-table=foo.baz foo",
+    }.each do |k, v|
+      it "should set #{k} to #{v}" do
+        @mysql.backup.send(k).should == v
+      end
+    end
+
+  end
+
+  describe :mysql_skip_tables do
+    it "should return nil if no skip_tables" do
+      config = def_config.dup
+      config.delete(:skip_tables)
+      m = mysqldump(:foo, Astrails::Safe::Config::Node.new(nil, config))
+      stub(m).timestamp {"NOW"}
+      m.send(:mysql_skip_tables).should be_nil
+      m.backup.command.should_not match(/ignore-table/)
+    end
+
+    it "should return '' if skip_tables empty" do
+      config = def_config.dup
+      config[:skip_tables] = []
+      m = mysqldump(:foo, Astrails::Safe::Config::Node.new(nil, config))
+      stub(m).timestamp {"NOW"}
+      m.send(:mysql_skip_tables).should == ""
+      m.backup.command.should_not match(/ignore-table/)
+    end
+
+  end
+
+  describe :mysql_password_file do
+    it "should create passwords file with quoted values" do
+      m = mysqldump(:foo, def_config(:password => '#qwe"asd\'zxc'))
+      file = m.send(:mysql_password_file)
+      File.exists?(file).should == true
+      File.read(file).should == <<-PWD
+[mysqldump]
+user = "User"
+password = "#qwe\\"asd'zxc"
+socket = "socket"
+host = "localhost"
+port = 7777
+      PWD
+    end
+  end
+end

data/spec/unit/pgdump_spec.rb

@@ -0,0 +1,45 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Astrails::Safe::Pgdump do
+
+  def def_config
+    {
+      :options => "OPTS",
+      :user => "User",
+      :password => "pwd",
+      :host => "localhost",
+      :port => 7777,
+      :skip_tables => [:bar, :baz]
+    }
+  end
+
+  def pgdump(id = :foo, config = def_config)
+    Astrails::Safe::Pgdump.new(id, Astrails::Safe::Config::Node.new(nil, config))
+  end
+
+  before(:each) do
+    stub(Time).now.stub!.strftime {"NOW"}
+  end
+
+  after(:each) { Astrails::Safe::TmpFile.cleanup }
+
+  describe :backup do
+    before(:each) do
+      @pg = pgdump
+    end
+
+    {
+      :id => "foo",
+      :kind => "pgdump",
+      :extension => ".sql",
+      :filename => "pgdump-foo.NOW",
+      :command => "pg_dump OPTS --username='User' --host='localhost' --port='7777' foo",
+    }.each do |k, v|
+      it "should set #{k} to #{v}" do
+        @pg.backup.send(k).should == v
+      end
+    end
+
+  end
+
+end

data/spec/unit/s3_spec.rb

@@ -0,0 +1,163 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Astrails::Safe::S3 do
+
+  def def_config
+    {
+      :s3 => {
+        :bucket => "bucket_name",
+        :key    => "_key",
+        :secret => "_secret",
+      },
+      :keep => {
+        :s3 => 2
+      }
+    }
+  end
+
+  def def_backup(extra = {})
+    {
+      :kind      => "_kind",
+      :filename  => "/backup/somewhere/_kind-_id.NOW.bar",
+      :extension => ".bar",
+      :id        => "_id",
+      :timestamp => "NOW"
+    }.merge(extra)
+  end
+
+  def s3(config = def_config, backup = def_backup)
+    Astrails::Safe::S3.new(
+      Astrails::Safe::Config::Node.new(nil, config),
+      Astrails::Safe::Backup.new(backup)
+    )
+  end
+
+  describe :cleanup do
+
+    before(:each) do
+      @s3 = s3
+
+      @files = [4,1,3,2].map do |i|
+        stub(object = Object.new).key { "aaaaa#{i}" }
+        object
+      end
+
+      stub(@s3).remote_bucket.stub!.objects.stub!.with_prefix(:prefix => '_kind/_id/_kind-_id.') { @files }
+    end
+
+    it "should check [:keep, :s3]" do
+      @s3.config[:keep].data["s3"] = nil
+      dont_allow(@s3.backup).filename
+      @s3.send :cleanup
+    end
+
+    it "should delete extra files" do
+      dont_allow(@files[0]).delete
+      mock(@files[1]).delete
+      dont_allow(@files[2]).delete
+      mock(@files[3]).delete
+      @s3.send :cleanup
+    end
+
+  end
+
+  describe :active do
+    before(:each) do
+      @s3 = s3
+    end
+
+    it "should be true when all params are set" do
+      @s3.should be_active
+    end
+
+    it "should be false if bucket is missing" do
+      @s3.config[:s3].data["bucket"] = nil
+      @s3.should_not be_active
+    end
+
+    it "should be false if key is missing" do
+      @s3.config[:s3].data["key"] = nil
+      @s3.should_not be_active
+    end
+
+    it "should be false if secret is missing" do
+      @s3.config[:s3].data["secret"] = nil
+      @s3.should_not be_active
+    end
+  end
+
+  describe :path do
+    before(:each) do
+      @s3 = s3
+    end
+    it "should use s3/path 1st" do
+      @s3.config[:s3].data["path"] = "s3_path"
+      @s3.config[:local] = {:path => "local_path"}
+      @s3.send(:path).should == "s3_path"
+    end
+
+    it "should use local/path 2nd" do
+      @s3.config[:local] = {:path => "local_path"}
+      @s3.send(:path).should == "local_path"
+    end
+
+    it "should use constant 3rd" do
+      @s3.send(:path).should == "_kind/_id"
+    end
+
+  end
+
+  describe :save do
+    def add_stubs(*stubs)
+      stubs.each do |s|
+        case s
+        when :stat
+          stub(File).stat("foo").stub!.size {123}
+        when :create_bucket
+          stub.instance_of(AWS::S3).buckets.stub!.create.stub!
+        when :file_open
+          stub(File).open("foo") {|f, block| block.call(:opened_file)}
+        when :s3_store
+          stub.instance_of(AWS::S3).buckets.stub!.create.stub!.objects.stub!.create(@full_path, :data => :opened_file)
+        end
+      end
+    end
+
+    before(:each) do
+      @s3 = s3(def_config, def_backup(:path => "foo"))
+      @full_path = "_kind/_id/backup/somewhere/_kind-_id.NOW.bar.bar"
+    end
+
+    it "should fail if no backup.file is set" do
+      @s3.backup.path = nil
+      proc {@s3.send(:save)}.should raise_error(RuntimeError)
+    end
+
+    it "should establish s3 connection" do
+      connection = AWS::S3.new(:access_key_id => "_key", :secret_access_key => "_secret")
+      mock(AWS::S3).new(:access_key_id => "_key", :secret_access_key => "_secret") { connection }
+      add_stubs(:stat, :create_bucket, :file_open, :s3_store)
+
+      @s3.send(:save)
+    end
+
+    it "should open local file" do
+      add_stubs(:stat, :create_bucket)
+      mock(File).open("foo")
+      @s3.send(:save)
+    end
+
+    it "should upload file" do
+      add_stubs(:stat, :create_bucket, :file_open)
+      mock(@s3).remote_bucket.mock!.objects.mock!.create(@full_path, :data => :opened_file)
+      @s3.send(:save)
+    end
+
+    it "should fail on files bigger then 5G" do
+      mock(File).stat("foo").stub!.size {5*1024*1024*1024+1}
+      mock(STDERR).puts(anything)
+      dont_allow(Benchmark).realtime
+      @s3.send(:save)
+    end
+  end
+end