netguru-safe 0.2.9

data/spec/unit/cloudfiles_spec.rb

@@ -0,0 +1,177 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Astrails::Safe::Cloudfiles do
+
+  def def_config
+    {
+      :cloudfiles => {
+        :container => "_container",
+        :user    => "_user",
+        :api_key => "_api_key",
+      },
+      :keep => {
+        :cloudfiles => 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 cloudfiles(config = def_config, backup = def_backup)
+    Astrails::Safe::Cloudfiles.new(
+      Astrails::Safe::Config::Node.new(nil, config),
+      Astrails::Safe::Backup.new(backup)
+    )
+  end
+
+  describe :cleanup do
+
+    before(:each) do
+      @cloudfiles = cloudfiles
+
+      @files = [4,1,3,2].map { |i| "aaaaa#{i}" }
+
+      @container = "container"
+
+      stub(@container).objects(:prefix => "_kind/_id/_kind-_id.") { @files }
+      stub(@container).delete_object(anything)
+
+      stub(CloudFiles::Connection).
+        new('_user', '_api_key', true, false).stub!.
+        container('_container') {@container}
+    end
+
+    it "should check [:keep, :cloudfiles]" do
+      @cloudfiles.config[:keep].data["cloudfiles"] = nil
+      dont_allow(@cloudfiles.backup).filename
+      @cloudfiles.send :cleanup
+    end
+
+    it "should delete extra files" do
+      mock(@container).delete_object('aaaaa1')
+      mock(@container).delete_object('aaaaa2')
+      @cloudfiles.send :cleanup
+    end
+
+  end
+
+  describe :active do
+    before(:each) do
+      @cloudfiles = cloudfiles
+    end
+
+    it "should be true when all params are set" do
+      @cloudfiles.should be_active
+    end
+
+    it "should be false if container is missing" do
+      @cloudfiles.config[:cloudfiles].data["container"] = nil
+      @cloudfiles.should_not be_active
+    end
+
+    it "should be false if user is missing" do
+      @cloudfiles.config[:cloudfiles].data["user"] = nil
+      @cloudfiles.should_not be_active
+    end
+
+    it "should be false if api_key is missing" do
+      @cloudfiles.config[:cloudfiles].data["api_key"] = nil
+      @cloudfiles.should_not be_active
+    end
+  end
+
+  describe :path do
+    before(:each) do
+      @cloudfiles = cloudfiles
+    end
+    it "should use cloudfiles/path 1st" do
+      @cloudfiles.config[:cloudfiles].data["path"] = "cloudfiles_path"
+      @cloudfiles.config[:local] = {:path => "local_path"}
+      @cloudfiles.send(:path).should == "cloudfiles_path"
+    end
+
+    it "should use local/path 2nd" do
+      @cloudfiles.config[:local] = {:path => "local_path"}
+      @cloudfiles.send(:path).should == "local_path"
+    end
+
+    it "should use constant 3rd" do
+      @cloudfiles.send(:path).should == "_kind/_id"
+    end
+
+  end
+
+  describe :save do
+    def add_stubs(*stubs)
+      stubs.each do |s|
+        case s
+        when :connection
+          @connection = "connection"
+          stub(CloudFiles::Authentication).new
+          stub(CloudFiles::Connection).
+            new('_user', '_api_key', true, false) {@connection}
+        when :file_size
+          stub(@cloudfiles).get_file_size("foo") {123}
+        when :create_container
+          @container = "container"
+          stub(@container).create_object("_kind/_id/backup/somewhere/_kind-_id.NOW.bar.bar", true) {@object}
+          stub(@connection).create_container {@container}
+        when :file_open
+          stub(File).open("foo")
+        when :cloudfiles_store
+          @object = "object"
+          stub(@object).write(nil) {true}
+        end
+      end
+    end
+
+    before(:each) do
+      @cloudfiles = cloudfiles(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
+      @cloudfiles.backup.path = nil
+      proc {@cloudfiles.send(:save)}.should raise_error(RuntimeError)
+    end
+
+    it "should establish Cloud Files connection" do
+      add_stubs(:connection, :file_size, :create_container, :file_open, :cloudfiles_store)
+      @cloudfiles.send(:save)
+    end
+
+    it "should open local file" do
+      add_stubs(:connection, :file_size, :create_container, :cloudfiles_store)
+      mock(File).open("foo")
+      @cloudfiles.send(:save)
+    end
+
+    it "should call write on the cloudfile object with files' descriptor" do
+      add_stubs(:connection, :file_size, :create_container, :cloudfiles_store)
+      stub(File).open("foo") {"qqq"}
+      mock(@object).write("qqq") {true}
+      @cloudfiles.send(:save)
+    end
+
+    it "should upload file" do
+      add_stubs(:connection, :file_size, :create_container, :file_open, :cloudfiles_store)
+      @cloudfiles.send(:save)
+    end
+
+    it "should fail on files bigger then 5G" do
+      add_stubs(:connection)
+      mock(File).stat("foo").stub!.size {5*1024*1024*1024+1}
+      mock(STDERR).puts(anything)
+      dont_allow(Benchmark).realtime
+      @cloudfiles.send(:save)
+    end
+  end
+end

data/spec/unit/config_spec.rb

@@ -0,0 +1,234 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Astrails::Safe::Config do
+  it "should parse example config" do
+    config = Astrails::Safe::Config::Node.new do
+      airbrake do
+        api_key "test_airbrake_api_key"
+      end
+
+      local do
+        path "path"
+      end
+
+      s3 do
+        key "s3 key"
+        secret "secret"
+        bucket "bucket"
+        path "path1"
+      end
+
+      sftp do
+        user "sftp user"
+        password "sftp password"
+        host "sftp host"
+      end
+
+      gpg do
+        key "gpg-key"
+        password "astrails"
+      end
+
+      keep do
+        local 4
+        s3 20
+      end
+
+      mysqldump do
+        options "-ceKq --single-transaction --create-options"
+
+        user "astrails"
+        password ""
+        host "localhost"
+        port 3306
+        socket "/var/run/mysqld/mysqld.sock"
+
+        database :blog
+
+        database :production do
+          keep :local => 3
+
+          gpg do
+            password "custom-production-pass"
+          end
+
+          skip_tables [:logger_exceptions, :request_logs]
+        end
+
+      end
+
+      pgdump do
+        options "-i -x -O"
+
+        user "astrails"
+        password ""
+        host "localhost"
+        port 5432
+
+        database :blog
+
+        database :production do
+          keep :local => 3
+
+          skip_tables [:logger_exceptions, :request_logs]
+        end
+
+      end
+
+      svndump do
+        repo :my_repo do
+          repo_path "/home/svn/my_repo"
+        end
+      end
+
+      tar do
+        archive "git-repositories" do
+          files "/home/git/repositories"
+        end
+
+        archive "etc-files" do
+          files "/etc"
+          exclude "/etc/puppet/other"
+        end
+
+        archive "dot-configs" do
+          files "/home/*/.[^.]*"
+        end
+
+        archive "blog" do
+          files "/var/www/blog.astrails.com/"
+          exclude ["/var/www/blog.astrails.com/log", "/var/www/blog.astrails.com/tmp"]
+        end
+
+        archive :misc do
+          files [ "/backup/*.rb" ]
+        end
+      end
+
+      mongodump do
+        host "host"
+        database "database"
+        user "user"
+        password "password"
+      end
+    end
+
+    expected = {
+      "airbrake" => {"api_key" => "test_airbrake_api_key"},
+
+      "local" => {"path" => "path"},
+
+      "s3" => {
+        "key" => "s3 key",
+        "secret" => "secret",
+        "bucket" => "bucket",
+        "path" => "path1",
+      },
+
+      "sftp" => {
+        "user" => "sftp user",
+        "password" => "sftp password",
+        "host" => "sftp host",
+      },
+
+      "gpg" => {"password" => "astrails", "key" => "gpg-key"},
+
+      "keep" => {"s3" => 20, "local" => 4},
+
+      "mysqldump" => {
+        "options" => "-ceKq --single-transaction --create-options",
+        "user" => "astrails",
+        "password" => "",
+        "host" => "localhost",
+        "port" => 3306,
+        "socket" => "/var/run/mysqld/mysqld.sock",
+
+        "databases" => {
+          "blog" => {},
+          "production" => {
+           "keep" => {"local" => 3},
+           "gpg" => {"password" => "custom-production-pass"},
+            "skip_tables" => ["logger_exceptions", "request_logs"],
+          },
+        },
+      },
+
+      "pgdump" => {
+        "options" => "-i -x -O",
+        "user" => "astrails",
+        "password" => "",
+        "host" => "localhost",
+        "port" => 5432,
+
+        "databases" => {
+          "blog" => {},
+          "production" => {
+           "keep" => {"local" => 3},
+            "skip_tables" => ["logger_exceptions", "request_logs"],
+          },
+        },
+      },
+
+      "svndump" => {
+        "repos" => {
+          "my_repo"=> {
+            "repo_path" => "/home/svn/my_repo"
+          }
+        }
+      },
+
+      "tar" => {
+        "archives" => {
+          "git-repositories" => {"files" => "/home/git/repositories"},
+          "etc-files" => {"files" => "/etc", "exclude" => "/etc/puppet/other"},
+          "dot-configs" => {"files" => "/home/*/.[^.]*"},
+          "blog" => {
+            "files" => "/var/www/blog.astrails.com/",
+            "exclude" => ["/var/www/blog.astrails.com/log", "/var/www/blog.astrails.com/tmp"],
+          },
+          "misc" => { "files" => ["/backup/*.rb"] },
+        },
+      },
+      
+      "mongodump" => {
+        "host" => "host",
+        "databases" => {
+          "database" => {}
+        },
+        "user" => "user",
+        "password" => "password"
+      }      
+    }
+
+    config.to_hash.should == expected
+  end
+
+  it "should make an array from multivalues" do
+    config = Astrails::Safe::Config::Node.new do
+      skip_tables "a"
+      skip_tables "b"
+      files "/foo"
+      files "/bar"
+      exclude "/foo/bar"
+      exclude "/foo/bar/baz"
+    end
+
+    expected = {
+      "skip_tables" => ["a", "b"],
+      "files" => ["/foo", "/bar"],
+      "exclude" => ["/foo/bar", "/foo/bar/baz"],
+    }
+
+    config.to_hash.should == expected
+  end
+
+  it "should raise error on key duplication" do
+    proc do
+      Astrails::Safe::Config::Node.new do
+        path "foo"
+        path "bar"
+      end
+    end.should raise_error(ArgumentError, "duplicate value for 'path'")
+  end
+
+end

data/spec/unit/gpg_spec.rb

@@ -0,0 +1,148 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Astrails::Safe::Gpg do
+  def def_backup
+    {
+      :compressed => false,
+      :command => "command",
+      :extension => ".foo",
+      :filename => "qweqwe"
+    }
+  end
+
+  def gpg(config = {}, backup = def_backup)
+    Astrails::Safe::Gpg.new(
+      Astrails::Safe::Config::Node.new(nil, config),
+      Astrails::Safe::Backup.new(backup)
+    )
+  end
+
+  after(:each) { Astrails::Safe::TmpFile.cleanup }
+
+  describe :process do
+
+    before(:each) do
+      @gpg = gpg()
+      stub(@gpg).gpg_password_file {"pwd-file"}
+      stub(@gpg).pipe {"|gpg -BLAH"}
+    end
+
+    describe "when active" do
+      before(:each) do
+        stub(@gpg).active? {true}
+      end
+
+      it "should add .gpg extension" do
+        mock(@gpg.backup.extension) << '.gpg'
+        @gpg.process
+      end
+
+      it "should add command pipe" do
+        mock(@gpg.backup.command) << (/\|gpg -BLAH/)
+        @gpg.process
+      end
+
+      it "should set compressed" do
+        mock(@gpg.backup).compressed = true
+        @gpg.process
+      end
+    end
+
+    describe "when inactive" do
+      before(:each) do
+        stub(@gpg).active? {false}
+      end
+
+      it "should not touch extension" do
+        dont_allow(@gpg.backup.extension) << anything
+        @gpg.process
+      end
+
+      it "should not touch command" do
+        dont_allow(@gpg.backup.command) << anything
+        @gpg.process
+      end
+
+      it "should not touch compressed" do
+        dont_allow(@gpg.backup).compressed = anything
+        @gpg.process
+      end
+    end
+  end
+
+  describe :active? do
+
+    describe "with key" do
+      it "should be true" do
+        gpg(:gpg => {:key => :foo}).should be_active
+      end
+    end
+
+    describe "with password" do
+      it "should be true" do
+        gpg(:gpg => {:password => :foo}).should be_active
+      end
+    end
+
+    describe "without key & password" do
+      it "should be false" do
+        gpg.should_not be_active
+      end
+    end
+
+    describe "with key & password" do
+      it "should raise RuntimeError" do
+        lambda {
+          gpg(:gpg => {:key => "foo", :password => "bar"}).send :active?
+        }.should raise_error(RuntimeError, "can't use both gpg password and pubkey")
+      end
+    end
+  end
+
+  describe :pipe do
+
+    describe "with key" do
+      def kgpg(extra={})
+        gpg({:gpg => {:key => "foo", :options => "GPG-OPT"}.merge(extra), :options => "OPT"})
+      end
+
+      it "should not call gpg_password_file" do
+        g = kgpg
+        dont_allow(g).gpg_password_file(anything)
+        g.send(:pipe)
+      end
+
+      it "should use '-r' and :options" do
+        kgpg.send(:pipe).should == "|gpg GPG-OPT -e -r foo"
+      end
+
+      it "should use the 'command' options" do
+        kgpg(:command => 'other-gpg').send(:pipe).should == "|other-gpg GPG-OPT -e -r foo"
+      end
+    end
+
+    describe "with password" do
+      def pgpg(extra = {})
+        returning(gpg({:gpg => {:password => "bar", :options => "GPG-OPT"}.merge(extra), :options => "OPT"})) do |g|
+          stub(g).gpg_password_file(anything) {"pass-file"}
+        end
+      end
+
+      it "should use '--passphrase-file' and :options" do
+        pgpg.send(:pipe).should == "|gpg GPG-OPT -c --passphrase-file pass-file"
+      end
+
+      it "should use the 'command' options" do
+        pgpg(:command => 'other-gpg').send(:pipe).should == "|other-gpg GPG-OPT -c --passphrase-file pass-file"
+      end
+    end
+  end
+
+  describe :gpg_password_file do
+    it "should create password file" do
+      file = gpg.send(:gpg_password_file, "foo")
+      File.exists?(file).should be_true
+      File.read(file).should == "foo"
+    end
+  end
+end