specinfra-cisco 2.40.2

data/lib/specinfra/properties.rb

@@ -0,0 +1,17 @@
+require 'singleton'
+
+module Specinfra
+  class Properties
+    include Singleton
+    def initialize
+      @prop = {}
+    end
+    def properties(prop=nil)
+      if ! prop.nil?
+        @prop = prop
+      end
+      @prop
+    end
+  end
+end
+

data/lib/specinfra/runner.rb

@@ -0,0 +1,35 @@
+module Specinfra
+  class Runner
+    def self.method_missing(meth, *args)
+      backend   = Specinfra.backend
+      processor = Specinfra::Processor
+      
+      if ! os.include?(:family) || os[:family] != 'windows'
+        if processor.respond_to?(meth)
+          processor.send(meth, *args)
+        elsif backend.respond_to?(meth)
+          backend.send(meth, *args)
+        else
+          run(meth, *args)
+        end
+      else
+        if backend.respond_to?(meth)
+          backend.send(meth, *args)
+        else
+          run(meth, *args)
+        end
+      end
+    end
+
+    private
+    def self.run(meth, *args)
+      cmd = Specinfra.command.get(meth, *args)
+      ret = Specinfra.backend.run_command(cmd)
+      if meth.to_s =~ /^check/
+        ret.success?
+      else
+        ret
+      end
+    end
+  end
+end

data/lib/specinfra/version.rb

@@ -0,0 +1,3 @@
+module Specinfra
+  VERSION = "2.40.1"
+end

data/spec/backend/exec/build_command_spec.rb

@@ -0,0 +1,148 @@
+require 'spec_helper'
+
+describe Specinfra::Backend::Exec do
+  describe '#build_command' do
+    context 'with simple command' do
+      it 'should escape spaces' do
+        expect(Specinfra.backend.build_command('test -f /etc/passwd')).to eq '/bin/sh -c test\ -f\ /etc/passwd'
+      end
+    end
+
+    context 'with complex command' do
+      it 'should escape special chars' do
+        expect(Specinfra.backend.build_command('test ! -f /etc/selinux/config || (getenforce | grep -i -- disabled && grep -i -- ^SELINUX=disabled$ /etc/selinux/config)')).to eq '/bin/sh -c test\ \!\ -f\ /etc/selinux/config\ \|\|\ \(getenforce\ \|\ grep\ -i\ --\ disabled\ \&\&\ grep\ -i\ --\ \^SELINUX\=disabled\$\ /etc/selinux/config\)'
+      end
+    end
+
+    context 'with custom shell' do
+      before do
+        RSpec.configure {|c| c.shell = '/usr/local/bin/tcsh' }
+      end
+
+      after do
+        RSpec.configure {|c| c.shell = nil }
+      end
+
+      it 'should use custom shell' do
+        expect(Specinfra.backend.build_command('test -f /etc/passwd')).to eq '/usr/local/bin/tcsh -c test\ -f\ /etc/passwd'
+      end
+    end
+
+    context 'with custom shell that needs escaping' do
+      before do
+        RSpec.configure {|c| c.shell = '/usr/test & spec/bin/sh' }
+      end
+
+      after do
+        RSpec.configure {|c| c.shell = nil }
+      end
+
+      it 'should use custom shell' do
+        expect(Specinfra.backend.build_command('test -f /etc/passwd')).to eq '/usr/test\ \&\ spec/bin/sh -c test\ -f\ /etc/passwd'
+      end
+    end
+
+    context 'with custom path' do
+      before do
+        RSpec.configure {|c| c.path = '/opt/bin:/opt/foo/bin:$PATH' }
+      end
+
+      after do
+        RSpec.configure {|c| c.path = nil }
+      end
+
+      it 'should use custom path' do
+        expect(Specinfra.backend.build_command('test -f /etc/passwd')).to eq 'env PATH="/opt/bin:/opt/foo/bin:$PATH" /bin/sh -c test\ -f\ /etc/passwd'
+      end
+    end
+
+    context 'with custom path that needs escaping' do
+      before do
+        RSpec.configure {|c| c.path = '/opt/bin:/opt/test & spec/bin:$PATH' }
+      end
+
+      after do
+        RSpec.configure {|c| c.path = nil }
+      end
+
+      it 'should use custom path' do
+        expect(Specinfra.backend.build_command('test -f /etc/passwd')).to eq 'env PATH="/opt/bin:/opt/test & spec/bin:$PATH" /bin/sh -c test\ -f\ /etc/passwd'
+      end
+    end
+  end
+end
+
+describe 'os' do
+  before do
+    # clear os information cache
+    property[:os_by_host] = {}
+  end
+
+  context 'test ubuntu with lsb_release command' do
+    subject { os }
+    it do
+      expect(Specinfra.backend).to receive(:run_command).at_least(1).times do |args|
+        if ['ls /etc/debian_version', 'lsb_release -ir'].include? args
+          double(
+            :run_command_response,
+            :success? => true,
+            :stdout => "Distributor ID:\tUbuntu\nRelease:\t12.04\n"
+          )
+        elsif args == 'uname -m'
+          double :run_command_response, :success? => true, :stdout => "x86_64\n"
+        else
+          double :run_command_response, :success? => false, :stdout => nil
+        end
+      end
+      should eq({:family => 'ubuntu', :release => '12.04', :arch => 'x86_64' })
+    end
+  end
+
+  context 'test ubuntu with /etc/lsb-release' do
+    before do
+      property[:os] = nil
+    end
+    subject { os }
+    it do
+      expect(Specinfra.backend).to receive(:run_command).at_least(1).times do |args|
+        if ['ls /etc/debian_version', 'cat /etc/lsb-release'].include? args
+          double(
+            :run_command_response,
+            :success? => true,
+            :stdout => <<-EOF
+DISTRIB_ID=Ubuntu
+DISTRIB_RELEASE=12.04
+DISTRIB_CODENAME=precise
+DISTRIB_DESCRIPTION="Ubuntu 12.04.2 LTS"
+EOF
+          )
+        elsif args == 'uname -m'
+          double :run_command_response, :success? => true, :stdout => "x86_64\n"
+        else
+          double :run_command_response, :success? => false, :stdout => nil
+        end
+      end
+      should eq({:family => 'ubuntu', :release => '12.04', :arch => 'x86_64' })
+    end
+  end
+
+  context 'test debian (no lsb_release or lsb-release)' do
+    before do
+      property[:os] = nil
+    end
+    subject { os }
+    it do
+      expect(Specinfra.backend).to receive(:run_command).at_least(1).times do |args|
+        if args == 'ls /etc/debian_version'
+          double :run_command_response, :success? => true, :stdout => nil
+        elsif args == 'uname -m'
+          double :run_command_response, :success? => true, :stdout => "x86_64\n"
+        else
+          double :run_command_response, :success? => false, :stdout => nil
+        end
+      end
+      should eq({:family => 'debian', :release => nil, :arch => 'x86_64' })
+    end
+  end
+end
+

data/spec/backend/exec/child_process_spec.rb

@@ -0,0 +1,18 @@
+# Ref: https://github.com/sorah/infra_operator/blob/6259aada3fdd9d4bed5759115d39bd1df25a81f2/spec/backends/exec_spec.rb#L36
+
+require 'spec_helper'
+
+context "when executed process launches child process like a daemon, and the daemon doesn't close stdout,err" do
+  subject(:result) { Specinfra::Runner.run_command("ruby -e 'pid = fork { sleep 10; puts :bye }; Process.detach(pid); puts pid'") }
+
+  it "doesn't block" do
+    a = Time.now
+    result # exec
+    b = Time.now
+    expect((b-a) < 3).to be_truthy
+
+    expect(result.stderr).to be_empty
+    expect(result.stdout.chomp).to match(/\A\d+\z/)
+    Process.kill :TERM, result.stdout.chomp.to_i
+  end
+end

data/spec/backend/exec/env_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Specinfra.backend.run_command('echo $LANG').stdout.strip do
+  it { should eq 'C' }
+end
+
+describe do
+  before do
+    ENV['LANG'] = 'C'
+    set :env, :LANG => 'ja_JP.UTF-8'
+  end
+  let(:lang) { Specinfra.backend.run_command('echo $LANG').stdout.strip }
+  it { expect(lang).to eq 'ja_JP.UTF-8' }
+  it { expect(ENV['LANG']).to eq 'C' }
+end
+

data/spec/backend/exec/read_noblock_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+def command(cmd)
+  Specinfra::Runner.run_command(cmd)
+end
+
+shared_examples "IO checks" do
+    let (:generator) { "seq 1 #{max}" }
+    let (:expected) { (1..max).map { |x| x.to_s }.join("\n") << "\n" }
+
+    it "stdout only" do
+        out = command(generator).stdout
+        expect(out).to eq expected
+    end
+
+    it "stderr only" do
+        out = command("#{generator} >&2" ).stderr
+        expect(out).to eq expected
+    end
+
+    it "stdout then stderr" do
+        cmd = command("#{generator}; #{generator} >&2" )
+        expect(cmd.stdout).to eq expected
+        expect(cmd.stderr).to eq expected
+    end
+
+    it "stderr then stdout" do
+        cmd = command("#{generator} >&2; #{generator}" )
+        expect(cmd.stdout).to eq expected
+        expect(cmd.stderr).to eq expected
+    end
+
+    it "stdout and stderr" do
+        cmd = command("(#{generator} &); #{generator} >&2; sleep 2" )
+        expect(cmd.stdout).to eq expected
+        expect(cmd.stderr).to eq expected
+    end
+end
+
+describe "buffer overflow problem" do
+    context "with small output amount" do
+        let (:max) { 10 }
+        include_examples "IO checks"
+    end
+
+    context "with huge output amount" do
+        let (:max) { 999999 }
+        include_examples "IO checks"
+    end
+end

data/spec/backend/exec/stdxxx_handler_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+backend = Specinfra::Backend::Exec.new
+
+context 'Output of stdout_handler' do
+  subject(:stdout) do
+    out = ''
+    backend.stdout_handler = Proc.new {|o| out += o }
+    backend.run_command('echo foo')
+    out
+  end
+
+  it { expect(stdout).to eq "foo\n" }
+end
+
+context 'Output of stderr_handler' do
+  subject(:stderr) do
+    err = ''
+    backend.stderr_handler = Proc.new {|e| err += e }
+    backend.run_command('echo foo 1>&2')
+    err
+  end
+
+  it { expect(stderr).to eq "foo\n" }
+end

data/spec/backend/ssh/build_command_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+
+set :backend, :ssh
+
+describe Specinfra::Backend::Ssh do
+  describe '#build_command' do
+    context 'with root user' do 
+      before do
+        RSpec.configure do |c|
+          set :ssh_options, :user => 'root'
+          c.ssh = double(:ssh, Specinfra.configuration.ssh_options)
+        end
+      end
+
+      it 'should not prepend sudo' do
+        expect(Specinfra.backend.build_command('test -f /etc/passwd')).to eq '/bin/sh -c test\ -f\ /etc/passwd'
+      end
+
+      it 'should escape special characters' do
+        expect(Specinfra.backend.build_command('test ! -f /etc/selinux/config || (getenforce | grep -i -- disabled && grep -i -- ^SELINUX=disabled$ /etc/selinux/config)')).to eq '/bin/sh -c test\ \!\ -f\ /etc/selinux/config\ \|\|\ \(getenforce\ \|\ grep\ -i\ --\ disabled\ \&\&\ grep\ -i\ --\ \^SELINUX\=disabled\$\ /etc/selinux/config\)'
+      end
+    end
+
+    context 'with non-root user' do
+      before do
+        RSpec.configure do |c|
+          set :ssh_options, :user => 'foo'
+          c.ssh = double(:ssh, Specinfra.configuration.ssh_options)
+        end
+      end
+
+      it 'should prepend sudo' do
+        expect(Specinfra.backend.build_command('test -f /etc/passwd')).to eq %q{sudo -p 'Password: ' /bin/sh -c test\ -f\ /etc/passwd}
+      end
+
+      it 'should escape special characters' do
+        expect(Specinfra.backend.build_command('test ! -f /etc/selinux/config || (getenforce | grep -i -- disabled && grep -i -- ^SELINUX=disabled$ /etc/selinux/config)')).to eq %q{sudo -p 'Password: ' /bin/sh -c test\ \!\ -f\ /etc/selinux/config\ \|\|\ \(getenforce\ \|\ grep\ -i\ --\ disabled\ \&\&\ grep\ -i\ --\ \^SELINUX\=disabled\$\ /etc/selinux/config\)}
+      end
+    end
+
+    context 'with custom sudo path' do
+      before do
+        RSpec.configure do |c|
+          set :ssh_options, :user => 'foo'
+          c.ssh = double(:ssh, Specinfra.configuration.ssh_options)
+          c.sudo_path = '/usr/local/bin'
+        end
+      end
+
+      after do
+        RSpec.configure do |c|
+          c.sudo_path = nil
+        end
+      end
+
+      it 'command pattern 1a' do
+        expect(Specinfra.backend.build_command('test -f /etc/passwd')).to eq %q{/usr/local/bin/sudo -p 'Password: ' /bin/sh -c test\ -f\ /etc/passwd}
+      end
+
+      it 'command pattern 2a' do
+        expect(Specinfra.backend.build_command('test ! -f /etc/selinux/config || (getenforce | grep -i -- disabled && grep -i -- ^SELINUX=disabled$ /etc/selinux/config)')).to eq %q{/usr/local/bin/sudo -p 'Password: ' /bin/sh -c test\ \!\ -f\ /etc/selinux/config\ \|\|\ \(getenforce\ \|\ grep\ -i\ --\ disabled\ \&\&\ grep\ -i\ --\ \^SELINUX\=disabled\$\ /etc/selinux/config\)}
+      end
+    end
+
+    context 'without sudo' do
+      before do
+        RSpec.configure do |c|
+          set :ssh_options, :user => 'foo'
+          c.ssh = double(:ssh, Specinfra.configuration.ssh_options)
+          c.disable_sudo = true
+        end
+      end
+
+      after do
+        RSpec.configure do |c|
+          c.disable_sudo = false
+        end
+      end
+
+      it 'command pattern 1b' do
+        expect(Specinfra.backend.build_command('test -f /etc/passwd')).to eq '/bin/sh -c test\ -f\ /etc/passwd'
+      end
+
+      it 'command pattern 2b' do
+        expect(Specinfra.backend.build_command('test ! -f /etc/selinux/config || (getenforce | grep -i -- disabled && grep -i -- ^SELINUX=disabled$ /etc/selinux/config)')).to eq '/bin/sh -c test\ \!\ -f\ /etc/selinux/config\ \|\|\ \(getenforce\ \|\ grep\ -i\ --\ disabled\ \&\&\ grep\ -i\ --\ \^SELINUX\=disabled\$\ /etc/selinux/config\)'
+      end
+    end
+
+    context 'with sudo on alternative path' do
+      before do
+        RSpec.configure do |c|
+          set :ssh_options, :user => 'foo'
+          c.ssh = double(:ssh, Specinfra.configuration.ssh_options)
+          c.sudo_path = nil
+        end
+      end
+
+      after do
+        RSpec.configure do |c|
+          c.sudo_options = nil
+        end
+      end
+
+      context 'command pattern 1a' do
+        subject { Specinfra.backend.build_command('test -f /etc/passwd') }
+        it { should eq %q{sudo -p 'Password: ' /bin/sh -c test\ -f\ /etc/passwd} }
+      end
+
+      context 'command pattern 2a' do
+        subject { Specinfra.backend.build_command('test ! -f /etc/selinux/config || (getenforce | grep -i -- disabled && grep -i -- ^SELINUX=disabled$ /etc/selinux/config)') }
+        it { should eq %q{sudo -p 'Password: ' /bin/sh -c test\ \!\ -f\ /etc/selinux/config\ \|\|\ \(getenforce\ \|\ grep\ -i\ --\ disabled\ \&\&\ grep\ -i\ --\ \^SELINUX\=disabled\$\ /etc/selinux/config\)} }
+      end
+    end
+  end
+end

data/spec/command/amazon/interface_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+property[:os] = nil
+set :os, { :family => 'amazon', :release => nil }
+
+describe Specinfra.command.send(:create_command_class, 'interface') do
+   it { should be_an_instance_of(Specinfra::Command::Linux::Base::Interface) }
+end
+