cuken 0.1.13 → 0.1.15

data/features/step_definitions/cuken_steps.rb

@@ -24,9 +24,10 @@ end
 
 Then /^these steps are defined for "([^\"]*)":$/ do |file, table|
   rsc = ::Cucumber::Runtime::SupportCode.new 'ui', :autoload_code_paths => 'lib/cuken/cucumber'
-  rsc.load_files! ["lib/#{file}", "#{ENV['GEM_HOME']}/gems/aruba-0.3.6/lib/aruba/cucumber.rb"]
+  announce_or_puts("Loading: lib/#{file}") if @announce
+  rsc.load_files! ["lib/#{file}"] #"#{ENV['GEM_HOME']}/gems/aruba-0.3.6/lib/aruba/cucumber.rb"
   sd_array = rsc.step_definitions
-  # sd_array.each{|sd| puts sd.regexp_source}
+  sd_array.each{|sd| puts sd.regexp_source}
   table.hashes.each do |hsh|
     sd_array.each{|sd| res = sd.regexp_source == %Q{/^#{hsh['step']}$/}; break('found') if res}.should == 'found'
   end

data/features/support/env.rb

@@ -6,6 +6,7 @@ rescue Bundler::BundlerError => e
   $stderr.puts "Run `bundle install` to install missing gems"
   exit e.status_code
 end
+require 'rspec/expectations'
 
 $LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
 require 'cuken/ssh'
@@ -13,5 +14,5 @@ require 'cuken/cmd'
 require 'cuken/file'
 require 'cuken/chef'
 require 'cuken/vagrant'
+require 'cuken/git'
 
-require 'rspec/expectations'

data/lib/cuken/all.rb

@@ -2,3 +2,4 @@ require 'cuken/cmd'
 require 'cuken/file'
 require 'cuken/ssh'
 require 'cuken/chef'
+require 'cuken/vagrant'

data/lib/cuken/api/aruba/api.rb

@@ -0,0 +1,342 @@
+#require 'fileutils'
+#require 'rbconfig'
+#require 'aruba/process'
+module ::Cuken
+  module Api
+    module Aruba
+      module Api
+        def in_dir(dir=current_dir, &block)
+          exp_dir = ::File.expand_path(dir)
+          _mkdir(exp_dir)
+          Dir.chdir(exp_dir, &block)
+        end
+
+        def current_dir
+          ::File.join(*dirs)
+        end
+
+        def cd(dir)
+          dirs << dir
+          raise "#{current_dir} is not a directory." unless ::File.directory?(current_dir)
+        end
+
+        def dirs
+          @dirs ||= ['tmp/aruba']
+        end
+
+        def write_file(file_name, file_content)
+          _create_file(file_name, file_content, false)
+        end
+
+        def overwrite_file(file_name, file_content)
+          _create_file(file_name, file_content, true)
+        end
+
+        def _create_file(file_name, file_content, check_presence)
+          in_dir do
+            raise "expected #{file_name} to be present" if check_presence && !::File.file?(file_name)
+            _mkdir(::File.dirname(file_name))
+            ::File.open(file_name, 'w') { |f| f << file_content }
+          end
+        end
+
+        def remove_file(file_name)
+          in_dir do
+            ::FileUtils.rm(file_name)
+          end
+        end
+
+        def append_to_file(file_name, file_content)
+          in_dir do
+            ::File.open(file_name, 'a') { |f| f << file_content }
+          end
+        end
+
+        def create_dir(dir_name)
+          in_dir do
+            _mkdir(dir_name)
+          end
+        end
+
+        def check_file_presence(paths, expect_presence)
+          prep_for_fs_check do
+            paths.each do |path|
+              if expect_presence
+                ::File.should be_file(path)
+              else
+                ::File.should_not be_file(path)
+              end
+            end
+          end
+        end
+
+    #    def check_file_content(file, partial_content, expect_match)
+    #      regexp = regexp(partial_content)
+    #      prep_for_fs_check do
+    #        content = IO.read(file)
+    #        if expect_match
+    #          content.should =~ regexp
+    #        else
+    #          content.should_not =~ regexp
+    #        end
+    #      end
+    #    end
+
+        def check_file_content(file, partial_content, expect_match, times = 1)
+          regexp = regexp(partial_content)
+          seen_count = 0
+          prep_for_fs_check do
+            content = IO.read(file)
+            while (seen_count < times.to_i || content =~ regexp)do
+              if content =~ regexp
+                content = content.sub(regexp,'')
+                seen_count+=1
+              end
+            end
+            if expect_match
+              seen_count.should == times.to_i
+            else
+              seen_count.should_not == times.to_i
+            end
+          end
+        end
+
+
+        def check_exact_file_content(file, exact_content)
+          prep_for_fs_check { IO.read(file).should == exact_content }
+        end
+
+        def check_directory_presence(paths, expect_presence)
+          prep_for_fs_check do
+            paths.each do |path|
+              if expect_presence
+                ::File.should be_directory(path)
+              else
+                ::File.should_not be_directory(path)
+              end
+            end
+          end
+        end
+
+        def prep_for_fs_check(&block)
+          stop_processes!
+          in_dir{ block.call }
+        end
+
+        def _mkdir(dir_name)
+          ::FileUtils.mkdir_p(dir_name) unless ::File.directory?(dir_name)
+        end
+
+        def unescape(string)
+          string.gsub('\n', "\n").gsub('\"', '"')
+        end
+
+        def regexp(string_or_regexp)
+          Regexp === string_or_regexp ? string_or_regexp : Regexp.compile(Regexp.escape(string_or_regexp))
+        end
+
+        def output_from(cmd)
+          cmd = detect_ruby(cmd)
+          get_process(cmd).output
+        end
+
+        def stdout_from(cmd)
+          cmd = detect_ruby(cmd)
+          get_process(cmd).stdout
+        end
+
+        def stderr_from(cmd)
+          cmd = detect_ruby(cmd)
+          get_process(cmd).stderr
+        end
+
+        def all_stdout
+          only_processes.inject("") { |out, ps| out << ps.stdout }
+        end
+
+        def all_stderr
+          only_processes.inject("") { |out, ps| out << ps.stderr }
+        end
+
+        def all_output
+          all_stdout << all_stderr
+        end
+
+        def assert_exact_output(exact_output)
+          all_output.should == exact_output
+        end
+
+        def assert_partial_output(partial_output)
+          all_output.should include(unescape(partial_output))
+        end
+
+        def assert_passing_with(partial_output)
+          assert_exit_status_and_partial_output(true, partial_output)
+        end
+
+        def assert_failing_with(partial_output)
+          assert_exit_status_and_partial_output(false, partial_output)
+        end
+
+        def assert_exit_status_and_partial_output(expect_to_pass, partial_output)
+          assert_partial_output(partial_output)
+          assert_exiting_with(expect_to_pass)
+        end
+
+        def assert_exit_status_and_output(expect_to_pass, output, expect_exact_output)
+          if expect_exact_output
+            assert_exact_output(output)
+          else
+            assert_partial_output(output)
+          end
+          assert_exiting_with(expect_to_pass)
+        end
+
+        def assert_exiting_with(expect_to_pass)
+          if expect_to_pass
+            @last_exit_status.should == 0
+          else
+            @last_exit_status.should_not == 0
+          end
+        end
+
+        def processes
+          @processes ||= []
+        end
+
+        def stop_processes!
+          processes.each do |_, process|
+            process.stop
+          end
+        end
+
+        def register_process(name, process)
+          processes << [name, process]
+        end
+
+        def get_process(wanted)
+          processes.find{ |name, _| name == wanted }[-1]
+        end
+
+        def only_processes
+          processes.collect{ |_, process| process }
+        end
+
+        def run(cmd, dir=current_dir)
+          cmd = detect_ruby(cmd)
+
+          in_dir(dir) do
+            announce_or_puts("$ cd #{Dir.pwd}") if @announce_dir
+            announce_or_puts("$ #{cmd}") if @announce_cmd
+
+            process = Process.new(cmd, exit_timeout, io_wait)
+            register_process(cmd, process)
+            process.run!
+
+            block_given? ? yield(process) : process
+          end
+        end
+
+        DEFAULT_TIMEOUT_SECONDS = 3
+
+        def exit_timeout
+          @aruba_timeout_seconds || DEFAULT_TIMEOUT_SECONDS
+        end
+
+        DEFAULT_IO_WAIT_SECONDS = 0.1
+
+        def io_wait
+          @aruba_io_wait_seconds || DEFAULT_IO_WAIT_SECONDS
+        end
+
+        def run_simple(cmd, dir=current_dir, fail_on_error=true)
+          @last_exit_status = run(cmd, dir) do |process|
+            process.stop
+            announce_or_puts(process.stdout) if @announce_stdout
+            announce_or_puts(process.stderr) if @announce_stderr
+            # need to replace with process.exit_code or similar, or remove the block entirely... it doesn't add as much as I thought it would
+            process.stop
+          end
+          @timed_out = @last_exit_status.nil?
+
+          if(@last_exit_status != 0 && fail_on_error)
+            fail("Exit status was #{@last_exit_status}. Output:\n#{all_output}")
+          end
+        end
+
+        def run_interactive(cmd, dir=current_dir)
+          @interactive = run(cmd, dir)
+        end
+
+        def type(input)
+          _write_interactive(_ensure_newline(input))
+        end
+
+        def _write_interactive(input)
+          @interactive.stdin.write(input)
+        end
+
+        def _ensure_newline(str)
+          str.chomp << "\n"
+        end
+
+        def announce_or_puts(msg)
+          puts(msg)
+        end
+
+        def detect_ruby(cmd)
+          if cmd =~ /^ruby\s/
+            cmd.gsub(/^ruby\s/, "#{current_ruby} ")
+          else
+            cmd
+          end
+        end
+
+        def current_ruby
+          ::File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name'])
+        end
+
+        def use_clean_gemset(gemset)
+          run_simple(%{rvm gemset create "#{gemset}"}, true)
+          if all_stdout =~ /'#{gemset}' gemset created \((.*)\)\./
+            gem_home = $1
+            set_env('GEM_HOME', gem_home)
+            set_env('GEM_PATH', gem_home)
+            set_env('BUNDLE_PATH', gem_home)
+
+            paths = (ENV['PATH'] || "").split(File::PATH_SEPARATOR)
+            paths.unshift(::File.join(gem_home, 'bin'))
+            set_env('PATH', paths.uniq.join(File::PATH_SEPARATOR))
+
+            run_simple("gem install bundler", true)
+          else
+            raise "I didn't understand rvm's output: #{all_stdout}"
+          end
+        end
+
+        def unset_bundler_env_vars
+          %w[RUBYOPT BUNDLE_PATH BUNDLE_BIN_PATH BUNDLE_GEMFILE].each do |key|
+            set_env(key, nil)
+          end
+        end
+
+        def set_env(key, value)
+          announce_or_puts(%{$ export #{key}="#{value}"}) if @announce_env
+          original_env[key] = ENV.delete(key)
+          ENV[key] = value
+        end
+
+        def restore_env
+          original_env.each do |key, value|
+            ENV[key] = value
+          end
+        end
+
+        def original_env
+          @original_env ||= {}
+        end
+      end
+    end
+  end
+end
+

data/lib/cuken/api/aruba/hooks.rb

@@ -0,0 +1,63 @@
+
+unless defined?(::Before) && !Before.is_a?(Class)
+  puts "#{defined?(Before).inspect}"
+  puts "do we see this?"
+  puts require 'cucumber'
+  puts 'are we loaded?'
+  puts "#{defined?(Before).inspect}"
+  puts "do we see this?"
+  puts !Before.is_a?(Class)
+end
+
+Before('@disable-bundler') do
+  unset_bundler_env_vars
+end
+
+Before do
+  @__aruba_original_paths = (ENV['PATH'] || '').split(File::PATH_SEPARATOR)
+  ENV['PATH'] = ([File.expand_path('bin')] + @__aruba_original_paths).join(File::PATH_SEPARATOR)
+end
+
+After do
+  ENV['PATH'] = @__aruba_original_paths.join(File::PATH_SEPARATOR)
+end
+
+Before('~@no-clobber') do
+  FileUtils.rm_rf(current_dir)
+end
+
+Before('@puts') do
+  @puts = true
+end
+
+Before('@announce-cmd') do
+  @announce_cmd = true
+end
+
+Before('@announce-stdout') do
+  @announce_stdout = true
+end
+
+Before('@announce-stderr') do
+  @announce_stderr = true
+end
+
+Before('@announce-dir') do
+  @announce_dir = true
+end
+
+Before('@announce-env') do
+  @announce_env = true
+end
+
+Before('@announce') do
+  @announce_stdout = true
+  @announce_stderr = true
+  @announce_cmd = true
+  @announce_dir = true
+  @announce_env = true
+end
+
+After do
+  restore_env
+end

data/lib/cuken/api/aruba/process.rb

@@ -0,0 +1,74 @@
+require 'childprocess'
+require 'tempfile'
+require 'shellwords'
+
+module ::Cuken
+  module Api
+    module Aruba
+      class Process
+        include Shellwords
+
+        def remove_ansi_codes(str)
+          str.gsub(/\e\[(\d+)m/, '')
+        end
+
+        def initialize(cmd, exit_timeout, io_wait)
+          @exit_timeout = exit_timeout
+          @io_wait = io_wait
+
+          @out = ::Tempfile.new("aruba-out")
+          @err = ::Tempfile.new("aruba-err")
+          @process = ChildProcess.build(*shellwords(cmd))
+          @process.io.stdout = @out
+          @process.io.stderr = @err
+          @process.duplex = true
+        end
+
+        def run!(&block)
+          @process.start
+          yield self if block_given?
+        end
+
+        def stdin
+          wait_for_io do
+            @process.io.stdin
+          end
+        end
+
+        def output
+          stdout + stderr
+        end
+
+        def stdout
+          wait_for_io do
+            @out.rewind
+            remove_ansi_codes(@out.read)
+          end
+        end
+
+        def stderr
+          wait_for_io do
+            @err.rewind
+            remove_ansi_codes(@err.read)
+          end
+        end
+
+        def stop
+          if @process
+            stdout && stderr # flush output
+            @process.poll_for_exit(@exit_timeout)
+            @process.exit_code
+          end
+        end
+
+        private
+
+        def wait_for_io(&block)
+          sleep @io_wait if @process.alive?
+          yield
+        end
+      end
+    end
+  end
+end
+

data/lib/cuken/api/aruba.rb

@@ -0,0 +1,5 @@
+require 'fileutils'
+require 'rbconfig'
+require 'cuken/api/aruba/process'
+require 'cuken/api/aruba/api'
+require 'cuken/api/aruba/hooks'

data/lib/cuken/api/chef/common.rb

@@ -57,7 +57,14 @@ module ::Cuken
 
         def in_chef_root(&block)
           raise "You need to specify a Chef root directory." unless chef.root_dir
-          ::Dir.chdir(chef.root_dir, &block)
+          if chef.root_dir.to_s[0] == '/'
+            ::Dir.chdir(chef.root_dir, &block)
+          else
+            in_dir do
+              chef.root_dir = ::File.expand_path(chef.root_dir)
+              ::Dir.chdir(chef.root_dir, &block)
+            end
+          end
         end
 
         def knife

data/lib/cuken/api/chef/cookbook.rb

@@ -21,10 +21,10 @@ module ::Cuken
 
         def parse_to_cookbooks_path(hsh)
           case
-            when not(hsh['cookbook'].nil? || hsh['cookbook'].empty?)
+            when !(hsh['cookbook'].nil? || hsh['cookbook'].empty?)
               ckbk = hsh['cookbook']
               ckbk_src = "cookbooks/#{ckbk}"
-            when not(hsh['site-cookbook'].nil? || hsh['site-cookbook'].empty?)
+            when !(hsh['site-cookbook'].nil? || hsh['site-cookbook'].empty?)
               ckbk = hsh['site-cookbook']
               ckbk_src = "site-cookbooks/#{ckbk}"
             else
@@ -61,8 +61,8 @@ module ::Cuken
           in_chef_root do
             list1 = chef.cookbooks_paths.find_all { |dir| Pathname(dir + path_fragment1 + path_fagment2).exist? }
             list2 = chef.cookbook_paths.find_all { |dir| (dir.to_s[/#{ckbk_src}/] && Pathname(dir+path_fagment2).exist?) }
-            loc = list2[0] || ((list1[0] + ckbk) if list1[0].exist?)
-            if loc.nil? || not(loc.exist?)
+            loc = list2[0] || ((list1[0] + ckbk) if list1[0] && list1[0].exist?)
+            if loc.nil? || !(loc.exist?)
               # TODO: error handling if data bags or cookbooks do not exist
             else
               full_data_bag_src = (loc + path_fagment2).expand_path.realdirpath.to_s
@@ -94,7 +94,7 @@ module ::Cuken
           chef.cookbook_paths.each do |pn|
             curr_ckbk = pn.basename.to_s
             condition = Pathname(pn).exist?
-            given_ckbk = Pathname(ckbk).basename.to_s
+            given_ckbk = Pathname(ckbk).basename.to_s if ckbk
             result = given_ckbk == curr_ckbk
             if condition && result
               given_ckbk.should == curr_ckbk
@@ -111,6 +111,15 @@ module ::Cuken
           end
         end
 
+        def cookbooks_delete(table)
+          table.hashes.each do |hsh|
+            ckbk, ckbk_src = parse_to_cookbooks_path(hsh)
+            full_cookbook_src = find_path_in_cookbook_folders(ckbk, ckbk_src, ckbk)
+            version = hsh['version'] ? hsh['version'] : 'all'
+            cookbook_delete(ckbk, version)
+          end
+        end
+
         def cookbook_load(ckbk)
 
           knife_config_file_error_handling()
@@ -127,6 +136,23 @@ module ::Cuken
           run_knife(argv)
         end
 
+        def cookbook_delete(ckbk, version='all')
+
+          knife_config_file_error_handling()
+
+          ckbk_pth = nil
+          in_chef_root do
+            ckbk_pth = unless chef.cookbooks_paths.empty?
+                  (chef.cookbooks_paths.collect { |pn| pn.expand_path.to_s }).join(':')
+              end
+          end
+
+          argv = ['cookbook', 'delete', ckbk]
+          version == 'all' ? argv << '--all' : argv << version
+          argv << '--yes' << '--no-editor'
+          run_knife(argv)
+        end
+
         def cookbooks_list
 
           knife_config_file_error_handling()

data/lib/cuken/api/chef/knife.rb

@@ -95,7 +95,7 @@ module ::Cuken
 
         def node_show(node_name, attr = :all)
           Pathname(chef.knife_config_file).exist?.should be_true
-          argv = ['node', 'show', node_name, '--no-editor', '--config', chef.knife_config_file]
+          argv = ['node', 'show', node_name, '--no-editor', '--config', chef.knife_config_file.to_s]
           unless attr == :all
             argv << '--attribute' << attr
           end
@@ -110,7 +110,7 @@ module ::Cuken
         end
 
         def node_role_load(hsh)
-          argv = ['node', 'run_list', 'add', hsh[:node], "role[#{hsh[:role]}]", '--no-editor', '--config', chef.knife_config_file]
+          argv = ['node', 'run_list', 'add', hsh[:node], "role[#{hsh[:role]}]", '--no-editor', '--config', chef.knife_config_file.to_s]
           if Pathname(chef.knife_config_file).exist?
             with_args *argv do
               ::Chef::Application::Knife.new.run
@@ -122,7 +122,7 @@ module ::Cuken
         end
 
         def node_create(node_name)
-          argv = ['node', 'create', node_name, '--no-editor', '--config', chef.knife_config_file]
+          argv = ['node', 'create', node_name, '--no-editor', '--config', chef.knife_config_file.to_s]
           if Pathname(chef.knife_config_file).exist?
             with_args *argv do
               ::Chef::Application::Knife.new.run

data/lib/cuken/api/chef/role.rb

@@ -25,14 +25,14 @@ module ::Cuken
           in_chef_root do
             table.hashes.each do |hsh|
               case
-                when not(hsh['cookbook'].nil? || hsh['cookbook'].empty?)
+                when !(hsh['cookbook'].nil? || hsh['cookbook'].empty?)
                   src = "cookbooks/#{hsh['cookbook']}/roles/#{hsh['role']}"
-                when not(hsh['site-cookbook'].nil? || hsh['site-cookbook'].empty?)
+                when !(hsh['site-cookbook'].nil? || hsh['site-cookbook'].empty?)
                   src = "site-cookbooks/#{hsh['site-cookbook']}/roles/#{hsh['role']}"
                 else
                   src =""
               end
-              role_load(src)
+              role_load(::File.expand_path(src))
             end
           end
         end