statistrano 1.2.0

data/spec/lib/statistrano/log/default_logger_spec.rb

@@ -0,0 +1,172 @@
+require 'spec_helper'
+
+describe Statistrano::Log::DefaultLogger do
+
+  before :each do
+    formatter_double = instance_double "Statistrano::Log::DefaultLogger::Formatter",
+                                        output: "stubbed"
+    Formatter = Statistrano::Log::DefaultLogger::Formatter unless defined?(Formatter)
+    allow( Formatter ).to receive(:new)
+                      .and_return( formatter_double )
+  end
+
+  describe "#info [& debug]" do
+    it "outputs to stdout" do
+      expect( $stdout ).to receive(:puts)
+      subject.info 'foo'
+    end
+
+    it "defaults to a blank status" do
+      expect( Formatter ).to receive(:new)
+                         .with( '', :bright, 'msg' )
+
+      subject.info 'msg'
+    end
+
+    it "uses a status if given one" do
+      expect( Formatter ).to receive(:new)
+                         .with( :status, :bright, 'msg' )
+
+      subject.info :status, 'msg'
+    end
+
+    it "colorizes green if given :success as status" do
+      expect( Formatter ).to receive(:new)
+                         .with( :success, :green, 'msg' )
+
+      subject.info :success, 'msg'
+    end
+
+    it "takes multiple lines of messages" do
+      expect( Formatter ).to receive(:new)
+                         .with( '', :bright, 'msg', 'msg2' )
+
+      subject.info 'msg', 'msg2'
+    end
+  end
+
+  describe "#warn" do
+    it "outputs to stdout" do
+      expect( $stdout ).to receive(:puts)
+      subject.warn 'foo'
+    end
+
+    it "defaults to 'warning' status" do
+      expect( Formatter ).to receive(:new)
+                         .with( 'warning', :yellow, 'msg' )
+
+      subject.warn 'msg'
+    end
+
+    it "allows status to be overriden" do
+      expect( Formatter ).to receive(:new)
+                         .with( :omg, :yellow, 'msg' )
+
+      subject.warn :omg, 'msg'
+    end
+
+    it "colorizes yellow" do
+      expect( Formatter ).to receive(:new)
+                         .with( 'warning', :yellow, 'msg' )
+
+      subject.warn 'msg'
+    end
+
+    it "takes multiple lines of messages" do
+      expect( Formatter ).to receive(:new)
+                         .with( 'warning', :yellow, 'msg', 'msg2' )
+
+      subject.warn 'msg', 'msg2'
+    end
+  end
+
+  describe "#error [& fatal]" do
+    it "outputs to stderr" do
+      expect( $stderr ).to receive(:puts)
+      subject.error 'foo'
+    end
+
+    it "defaults to 'error' status" do
+      expect( Formatter ).to receive(:new)
+                         .with( 'error', :red, 'msg' )
+
+      subject.error 'msg'
+    end
+
+    it "colorizes red" do
+      expect( Formatter ).to receive(:new)
+                         .with( 'error', :red, 'msg' )
+
+      subject.error 'msg'
+    end
+
+    it "takes multiple lines of messages" do
+      expect( Formatter ).to receive(:new)
+                         .with( 'error', :red, 'msg', 'msg2' )
+
+      subject.error 'msg', 'msg2'
+    end
+  end
+
+end
+
+describe Statistrano::Log::DefaultLogger::Formatter do
+
+  describe "#initialize" do
+    it "sets status as a string" do
+      expect( described_class.new( :status, '', '' ).status ).to eq 'status'
+    end
+
+    it "sets the given color" do
+      expect( described_class.new( '', 'color', '' ).color ).to eq 'color'
+    end
+
+    it "sets msgs" do
+      expect( described_class.new( '', '', 'msg', 'msg2' ).msgs ).to match_array ['msg','msg2']
+    end
+  end
+
+  describe "#output" do
+    it "pads messages" do
+      subject = described_class.new( '', :green, 'msg' )
+      expect( subject.output ).to match /->\s{15}msg/
+    end
+
+    it "pads multiple lined messages" do
+      subject = described_class.new( '', :green, 'msg', 'msg2' )
+      lines = subject.output.split("\n")
+
+      expect( lines.first ).to match /->\s{15}msg/
+      expect( lines.last  ).to match /\s{16}msg2/
+    end
+
+    it "handles 'too long' status by padding message on second line to match first line" do
+      subject = described_class.new( 'onetwothreefourfive', :green, 'msg', 'msg2' )
+      lines   = subject.output.split("\n")
+
+      expect( lines.first ).to match /->\sonetwothreefourfive\smsg/
+      expect( lines.last  ).to match /\s{23}msg2/
+    end
+
+    it "colorizes status with given color" do
+      Rainbow.enabled = true
+
+      rainbow_double = double
+      subject = described_class.new( 'status', :green, 'msg' )
+      allow( Rainbow::Presenter ).to receive(:new)
+                                 .and_call_original
+      allow( Rainbow::Presenter ).to receive(:new)
+                                 .with('status')
+                                 .and_return(rainbow_double)
+
+      expect( rainbow_double ).to receive(:green)
+                              .and_return('green')
+      subject.output
+
+      unless ENV['RAINBOW']
+        Rainbow.enabled = false
+      end
+    end
+  end
+
+end

data/spec/lib/statistrano/log_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Statistrano::Log do
+
+  def clean_logger_cache
+    if described_class.instance_variable_get(:@_logger)
+      described_class.send(:remove_instance_variable, :@_logger)
+    end
+  end
+
+  before :each do
+    clean_logger_cache
+  end
+
+  after :each do
+    clean_logger_cache
+  end
+
+  describe "::set_logger" do
+    it "sets the logger" do
+      Statistrano::Log.set_logger 'foo'
+      expect( Statistrano::Log.instance_variable_get(:@_logger) ).to eq 'foo'
+    end
+  end
+
+  describe "::logger_instance" do
+    it "returns the cached logger" do
+      Statistrano::Log.instance_variable_set(:@_logger, 'foo')
+      expect( Statistrano::Log.logger_instance ).to eq 'foo'
+    end
+    it "initializes a new DefaultLogger if no logger is set" do
+      expect( Statistrano::Log::DefaultLogger ).to receive(:new)
+      Statistrano::Log.logger_instance
+    end
+  end
+end

data/spec/lib/statistrano/remote/file_spec.rb

@@ -0,0 +1,166 @@
+require 'spec_helper'
+
+describe Statistrano::Remote::File do
+
+  def stub_remote_file_to_exist
+    expect( @remote ).to receive(:run) # the file doesn't exist
+                     .with("[ -f /path ] && echo \"exists\"")
+                     .and_return( HereOrThere::Response.new("exists\n",'',true) )
+  end
+
+  def stub_remote_file_to_not_exist
+    expect( @remote ).to receive(:run) # the file doesn't exist
+                     .with("[ -f /path ] && echo \"exists\"")
+                     .and_return( HereOrThere::Response.new('','',true) )
+  end
+
+  describe "#initialize" do
+    it "sets the given path" do
+      subject = described_class.new "/path", :remote
+      expect( subject.path ).to eq "/path"
+    end
+    it "sets the given remote" do
+      subject = described_class.new "/path", :remote
+      expect( subject.remote ).to eq :remote
+    end
+    it "sets the given permissions" do
+      subject = described_class.new "/path", :remote, 660
+      expect( subject.permissions ).to eq 660
+    end
+    it "defaults to 644 permissions if not set" do
+      subject = described_class.new "/path", :remote
+      expect( subject.permissions ).to eq 644
+    end
+  end
+
+  describe "#content" do
+    it "returns string of file content" do
+      remote_double = instance_double("Statistrano::Remote")
+      subject = described_class.new "/path", remote_double
+
+      expect(remote_double).to receive(:run)
+                           .with("cat /path")
+                           .and_return(HereOrThere::Response.new("content","",true))
+      expect( subject.content ).to eq "content"
+    end
+
+    it "returns an empty string if errors on remote" do
+      remote_double = instance_double("Statistrano::Remote")
+      subject = described_class.new "/path", remote_double
+
+      expect(remote_double).to receive(:run)
+                           .with("cat /path")
+                           .and_return(HereOrThere::Response.new("content","error",false))
+      expect( subject.content ).to eq ""
+    end
+  end
+
+  describe "#update_content!" do
+    before :each do
+      @config  = double("Statistrano::Config", hostname: 'web01')
+      @remote  = instance_double("Statistrano::Remote", config: @config )
+      allow( @remote ).to receive(:run)
+                      .and_return( HereOrThere::Response.new("",'',true) )
+      @subject = described_class.new '/path', @remote
+    end
+
+    it "tests if file exists" do
+      expect( @remote ).to receive(:run)
+                       .with("[ -f /path ] && echo \"exists\"")
+                       .and_return( HereOrThere::Response.new("exists\n",'',true) )
+      @subject.update_content! "foooo"
+    end
+
+    context "when remote file doesn't exist" do
+      before :each do
+        stub_remote_file_to_not_exist
+      end
+
+      it "creates the file" do
+        expect( @remote ).to receive(:run)
+                         .with("touch /path " +
+                               "&& chmod 644 /path")
+                         .and_return( HereOrThere::Response.new("",'',true) )
+
+        @subject.update_content! "content"
+      end
+
+      it "sets the content to the given content" do
+        expect( @remote ).to receive(:run)
+                         .with( "echo 'content' > /path" )
+                         .and_return( HereOrThere::Response.new('','',true) )
+
+        @subject.update_content! "content"
+      end
+    end
+
+    context "when remote file already existed" do
+      before :each do
+        stub_remote_file_to_exist
+      end
+      it "sets the content to the given content" do
+        expect( @remote ).to receive(:run)
+                         .with( "echo 'content' > /path" )
+                         .and_return( HereOrThere::Response.new('','',true) )
+
+        @subject.update_content! "content"
+      end
+    end
+  end
+
+
+  describe "#append_content!" do
+
+    before :each do
+      @config  = double("Statistrano::Config", hostname: 'web01')
+      @remote  = instance_double("Statistrano::Remote", config: @config )
+      allow( @remote ).to receive(:run)
+                      .and_return( HereOrThere::Response.new("",'',true) )
+      @subject = described_class.new '/path', @remote
+    end
+
+    context "when remote file doesn't exist" do
+
+      before :each do
+        stub_remote_file_to_not_exist
+      end
+
+      it "creates the file before trying to append" do
+        expect( @remote ).to receive(:run)
+                         .with("touch /path " +
+                               "&& chmod 644 /path")
+
+        @subject.append_content! "the content"
+      end
+    end
+
+    context "when remote file already exists" do
+
+      before :each do
+        stub_remote_file_to_exist
+      end
+
+      it "appends new content to file" do
+        expect( @remote ).to receive(:run)
+                         .with("echo 'the content' >> /path")
+
+        @subject.append_content! "the content"
+      end
+    end
+  end
+
+
+  describe "#destroy!" do
+    it "removes the file" do
+      config  = double("Statistrano::Config", hostname: 'web01')
+      remote  = instance_double("Statistrano::Remote", config: config )
+      allow( remote ).to receive(:run)
+                      .and_return( HereOrThere::Response.new("",'',true) )
+      subject = described_class.new '/path', remote
+
+      expect(remote).to receive(:run).with("rm /path")
+      subject.destroy!
+    end
+  end
+
+end

data/spec/lib/statistrano/remote_spec.rb

@@ -0,0 +1,226 @@
+require 'spec_helper'
+require 'ostruct'
+
+describe Statistrano::Remote do
+
+  let(:default_options) do
+    {
+      hostname:         'web01',
+      verbose:          false,
+      user:             nil,
+      passowrd:         nil,
+      dir_permissions:  755,
+      file_permissions: 644,
+      rsync_flags:      '-aqz --delete-after'
+    }
+  end
+
+  let(:default_config) do
+    config default_options
+  end
+
+  def create_ssh_double
+    ssh_double = instance_double("HereOrThere::Remote::SSH")
+    allow( HereOrThere::Remote ).to receive(:session).and_return(ssh_double)
+    return ssh_double
+  end
+
+  def config options
+    OpenStruct.new( options )
+  end
+
+  describe "#initialize" do
+    it "assigns given config to config" do
+      subject = described_class.new default_config
+      expect( subject.config ).to eq default_config
+    end
+
+    it "raises an error if no hostname is given" do
+      expect{
+        described_class.new( Struct.new(:hostname).new )
+      }.to raise_error ArgumentError, 'a hostname is required'
+    end
+  end
+
+  describe "#run" do
+    it "passes command to ssh_session#run" do
+      ssh_double = create_ssh_double
+      subject    = described_class.new default_config
+
+      expect( ssh_double ).to receive(:run).with('ls')
+      subject.run 'ls'
+    end
+
+    it "logs the command if verbose is true" do
+      ssh_double = create_ssh_double
+      subject    = described_class.new config default_options.merge verbose: true
+
+
+      allow( ssh_double ).to receive(:run).with('ls')
+      expect( Statistrano::Log ).to receive(:info)
+                                .with( :web01, "running cmd: ls")
+      subject.run 'ls'
+    end
+  end
+
+  describe "#done" do
+    it "passes close_session command to ssh_session" do
+      ssh_double = create_ssh_double
+      subject    = described_class.new default_config
+
+      expect( ssh_double ).to receive(:close_session)
+      subject.done
+    end
+  end
+
+  describe "#test_connection" do
+    it "runs whoami on remote" do
+      ssh_double = create_ssh_double
+      allow(ssh_double).to receive(:close_session)
+      subject    = described_class.new default_config
+
+      expect( ssh_double ).to receive(:run).with('whoami')
+                          .and_return( HereOrThere::Response.new("statistrano","",true))
+      subject.test_connection
+    end
+    it "returns true if successful" do
+      ssh_double = create_ssh_double
+      allow(ssh_double).to receive(:close_session)
+      subject    = described_class.new default_config
+
+      expect( ssh_double ).to receive(:run).with('whoami')
+                          .and_return( HereOrThere::Response.new("statistrano","",true))
+      expect( subject.test_connection ).to be_truthy
+    end
+    it "returns false if fails" do
+      ssh_double = create_ssh_double
+      allow(ssh_double).to receive(:close_session)
+      subject    = described_class.new default_config
+
+      expect( ssh_double ).to receive(:run).with('whoami')
+                          .and_return( HereOrThere::Response.new("","error",false))
+      expect( subject.test_connection ).to be_falsy
+    end
+  end
+
+  describe "#create_remote_dir" do
+    it "runs mkdir command on remote" do
+      ssh_double = create_ssh_double
+      subject = described_class.new default_config
+
+      expect( ssh_double ).to receive(:run)
+                          .with("mkdir -p -m 755 /var/www/proj")
+                          .and_return( HereOrThere::Response.new("","",true) )
+      subject.create_remote_dir "/var/www/proj"
+    end
+
+    it "requires an absolute path" do
+      ssh_double = create_ssh_double
+      subject = described_class.new default_config
+
+      expect {
+        subject.create_remote_dir "var/www/proj"
+      }.to raise_error ArgumentError, "path must be absolute"
+    end
+
+    it "uses the set dir_permissions" do
+      ssh_double = create_ssh_double
+      subject = described_class.new config default_options.merge dir_permissions: 644
+
+      expect( ssh_double ).to receive(:run)
+                          .with("mkdir -p -m 644 /var/www/proj")
+                          .and_return( HereOrThere::Response.new("","",true) )
+      subject.create_remote_dir "/var/www/proj"
+    end
+
+    context "when remote dir creation fails" do
+      it "logs error & exits" do
+        ssh_double = create_ssh_double
+        subject = described_class.new default_config
+        allow( ssh_double ).to receive(:run)
+                            .with("mkdir -p -m 755 /var/www/proj")
+                            .and_return( HereOrThere::Response.new("","oh noes",false) )
+
+        expect( Statistrano::Log ).to receive(:error)
+                                  .with( "Unable to create directory '/var/www/proj' on web01",
+                                          "oh noes")
+        expect{
+          subject.create_remote_dir "/var/www/proj"
+        }.to raise_error SystemExit
+      end
+    end
+  end
+
+  describe "#rsync_to_remote" do
+    it "runs command to rsync local to remote" do
+      subject = described_class.new default_config
+
+      expect( Statistrano::Shell ).to receive(:run_local)
+                                  .with("rsync -aqz --delete-after " +
+                                        "--chmod=Du=rwx,Dg=rx,Do=rx,Fu=rw,Fg=r,Fo=r " +
+                                        "-e ssh local_path/ " +
+                                        "web01:remote_path/")
+                                 .and_return( HereOrThere::Response.new("","",true) )
+
+      subject.rsync_to_remote 'local_path', 'remote_path'
+    end
+
+    it "corrects for adding a trailing slash to local_path or remote_path" do
+      subject = described_class.new default_config
+
+      expect( Statistrano::Shell ).to receive(:run_local)
+                                 .with("rsync -aqz --delete-after " +
+                                        "--chmod=Du=rwx,Dg=rx,Do=rx,Fu=rw,Fg=r,Fo=r " +
+                                        "-e ssh local_path/ " +
+                                        "web01:remote_path/")
+                                 .and_return( HereOrThere::Response.new("","",true) )
+
+      subject.rsync_to_remote 'local_path/', 'remote_path/'
+    end
+
+    it "uses the set dir_permissions & file_permissions" do
+      subject = described_class.new config default_options.merge dir_permissions: 644, file_permissions: 755
+
+      expect( Statistrano::Shell ).to receive(:run_local)
+                                 .with("rsync -aqz --delete-after " +
+                                        "--chmod=Du=rw,Dg=r,Do=r,Fu=rwx,Fg=rx,Fo=rx " +
+                                        "-e ssh local_path/ " +
+                                        "web01:remote_path/")
+                                 .and_return( HereOrThere::Response.new("","",true) )
+
+      subject.rsync_to_remote 'local_path/', 'remote_path/'
+    end
+
+    it "uses the set rsync_flags" do
+      subject = described_class.new config default_options.merge rsync_flags: "-aqz"
+
+      expect( Statistrano::Shell ).to receive(:run_local)
+                                 .with("rsync -aqz " +
+                                        "--chmod=Du=rwx,Dg=rx,Do=rx,Fu=rw,Fg=r,Fo=r " +
+                                        "-e ssh local_path/ " +
+                                        "web01:remote_path/")
+                                 .and_return( HereOrThere::Response.new("","",true) )
+
+      subject.rsync_to_remote 'local_path/', 'remote_path/'
+    end
+
+    it "logs error if rsync command fails" do
+      subject = described_class.new default_config
+      expect( Statistrano::Shell ).to receive(:run_local)
+                                 .and_return( HereOrThere::Response.new("","",false) )
+
+      expect( Statistrano::Log ).to receive(:error)
+      subject.rsync_to_remote 'local_path', 'remote_path'
+    end
+
+    it "returns the response" do
+      subject = described_class.new default_config
+      response = HereOrThere::Response.new("woo","",true)
+      expect( Statistrano::Shell ).to receive(:run_local)
+                                 .and_return( response )
+
+      expect( subject.rsync_to_remote('local_path','remote_path') ).to eq response
+    end
+  end
+
+end

data/spec/lib/statistrano/util/file_permissions_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Statistrano::Util::FilePermissions do
+
+  describe "#initialize" do
+    it "sets user, group, and others based on given perm integer" do
+      subject = described_class.new 644
+
+      expect( subject.user ).to eq   "6"
+      expect( subject.group ).to eq  "4"
+      expect( subject.others ).to eq "4"
+    end
+  end
+
+  describe "#to_chmod" do
+    it "returns an object with the correct user, group, and others" do
+      subject = described_class.new( 644 ).to_chmod
+
+      expect( subject.user ).to eq   "rw"
+      expect( subject.group ).to eq  "r"
+      expect( subject.others ).to eq "r"
+    end
+  end
+
+end

data/spec/lib/statistrano/util_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Statistrano::Util do
+
+  describe "::symbolize_hash_keys" do
+    it "symbolizes keys of hash" do
+      expect(
+        Statistrano::Util.symbolize_hash_keys( { 'foo' => 'bar' })
+      ).to eq foo: 'bar'
+    end
+    it "symbolizes keys of nested hashes" do
+      expect(
+        Statistrano::Util.symbolize_hash_keys( { 'foo' => { 'bar' => 'baz' }})
+      ).to eq foo: { bar: 'baz' }
+    end
+    it "symbolizes keys of hashes nested in arrays" do
+      expect(
+        Statistrano::Util.symbolize_hash_keys( { 'foo' => [{'bar'=>'baz'},{'wu'=>'tang'}]})
+      ).to eq foo: [{bar:'baz'},{wu:'tang'}]
+    end
+  end
+
+end