cuken 0.1.1 → 0.1.2

data/lib/cuken/cucumber/chef/result_steps.rb

@@ -0,0 +1,15 @@
+Then /^I should see "(.*)"$/ do |text|
+  response.body.to_s.should =~ /#{text}/m
+end
+ 
+Then /^I should not see "(.*)"$/ do |text|
+  response.body.to_s.should_not =~ /#{text}/m
+end
+ 
+Then /^I should see an? (\w+) message$/ do |message_type|
+  response.should have_xpath("//*[@class='#{message_type}']")
+end
+ 
+Then /^the (.*) ?request should fail/ do |_|
+  response.should_not be_successful
+end

data/lib/cuken/cucumber/chef/run_client_steps.rb

@@ -0,0 +1,260 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#     http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'chef/shell_out'
+require 'chef/mixin/shell_out'
+
+include Chef::Mixin::ShellOut
+
+CHEF_CLIENT = File.join(CHEF_PROJECT_ROOT, "chef", "bin", "chef-client")
+
+def chef_client_command_string
+  @log_level ||= ENV["LOG_LEVEL"] ? ENV["LOG_LEVEL"] : "error"
+  @chef_args ||= ""
+  @config_file ||= File.expand_path(File.join(configdir, 'client.rb'))
+
+  "#{File.join(File.dirname(__FILE__), "..", "..", "chef", "bin", "chef-client")} -l #{@log_level} -c #{@config_file} #{@chef_args}"
+end
+
+###
+# When
+###
+When /^I run the chef\-client$/ do
+  status = Chef::Mixin::Command.popen4(chef_client_command_string()) do |p, i, o, e|
+    @stdout = o.gets(nil)
+    @stderr = e.gets(nil)
+  end
+  @status = status
+end
+
+When "I run the chef-client for no more than '$timeout' seconds" do |timeout|
+  cmd = shell_out("#{CHEF_CLIENT} -l info -i 1 -s 1 -c #{File.expand_path(File.join(configdir, 'client.rb'))}", :timeout => timeout.to_i)
+  @status = cmd.status
+end
+
+When /^I run the chef\-client again$/ do
+  When "I run the chef-client"
+end
+
+When /^I run the chef\-client with '(.+)'$/ do |args|
+  @chef_args = args
+  When "I run the chef-client"
+end
+
+When "I run the chef-client with '$options' and the '$config_file' config" do |options, config_file|
+  @config_file = File.expand_path(File.join(configdir, "#{config_file}.rb"))
+  @chef_args = options
+  When "I run the chef-client"
+end
+
+When /^I run the chef\-client with '(.+)' for '(.+)' seconds$/ do |args, run_for|
+  @chef_args = args
+  When "I run the chef-client for '#{run_for}' seconds"
+end
+
+When /^I run the chef\-client for '(.+)' seconds$/ do |run_for|
+  # Normal behavior depends on the run_interval/recipes/default.rb to count down
+  # and exit subordinate chef-client after two runs. However, we will forcably
+  # kill the client if that didn't work.
+  begin
+    stdout_filename = "/tmp/chef.run_interval.stdout.#{$$}.txt"
+    stderr_filename = "/tmp/chef.run_interval.stderr.#{$$}.txt"
+    client_pid = Process.fork do
+      STDOUT.reopen(File.open(stdout_filename, "w"))
+      STDERR.reopen(File.open(stderr_filename, "w"))
+      exec chef_client_command_string()
+      exit 2
+    end
+  
+    killer_pid = Process.fork {
+      sleep run_for.to_i
+
+      # Send KILL to the child chef-client. Due to OHAI-223, where ohai sometimes
+      # ignores/doesn't exit correctly on receipt of SIGINT, brutally kill the
+      # subprocess.
+      begin
+        Process.kill("KILL", client_pid)
+      rescue Errno::ESRCH
+        # Kill didn't work; the process exited while we were waiting, like
+        # it's supposed to.
+      end
+    }
+
+    Process.waitpid2(killer_pid)
+    @status = Process.waitpid2(client_pid).last
+    
+    # Read these in so they can be used in later steps.
+    @stdout = IO.read(stdout_filename)
+    @stderr = IO.read(stderr_filename)
+  ensure
+    # clean up after ourselves.
+    File.delete(stdout_filename)
+    File.delete(stderr_filename)
+  end
+end
+
+When /^I run the chef\-client at log level '(.+)'$/ do |log_level|
+  @log_level = log_level.to_sym
+  When "I run the chef-client"
+end
+
+When 'I run the chef-client with json attributes' do
+  @log_level = :debug
+  @chef_args = "-j #{File.join(FEATURES_DATA, 'json_attribs', 'attribute_settings.json')}"
+  When "I run the chef-client"
+end
+
+When "I run the chef-client with json attributes '$json_file_basename'" do |json_file_basename|
+  @log_level = :debug
+  @chef_args = "-j #{File.join(FEATURES_DATA, 'json_attribs', "#{json_file_basename}.json")}"
+  When "I run the chef-client"
+end
+
+When /^I run the chef\-client with config file '(.+)'$/ do |config_file|
+  @config_file = config_file
+  When "I run the chef-client"
+end
+
+When /^I run the chef\-client with logging to the file '(.+)'$/ do |log_file|
+  
+config_data = <<CONFIG
+supportdir = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+tmpdir = File.expand_path(File.join(File.dirname(__FILE__), "..", "tmp"))
+
+log_level        :debug
+log_location     File.join(tmpdir, "silly-monkey.log")
+file_cache_path  File.join(tmpdir, "cache")
+ssl_verify_mode  :verify_none
+registration_url "http://127.0.0.1:4000"
+template_url     "http://127.0.0.1:4000"
+remotefile_url   "http://127.0.0.1:4000"
+search_url       "http://127.0.0.1:4000"
+role_url         "http://127.0.0.1:4000"
+client_url       "http://127.0.0.1:4000"
+chef_server_url  "http://127.0.0.1:4000"
+validation_client_name "validator"
+systmpdir = File.expand_path(File.join(Dir.tmpdir, "chef_integration"))
+validation_key   File.join(systmpdir, "validation.pem")
+client_key       File.join(systmpdir, "client.pem")
+CONFIG
+  
+  @config_file = File.expand_path(File.join(File.dirname(__FILE__), '..', 'data', 'config', 'client-with-logging.rb'))  
+  File.open(@config_file, "w") do |file|
+    file.write(config_data)
+  end
+
+  self.cleanup_files << @config_file
+  
+  
+  @status = Chef::Mixin::Command.popen4("#{File.join(File.dirname(__FILE__), "..", "..", "chef", "bin", "chef-client")} -c #{@config_file} #{@chef_args}") do |p, i, o, e|
+    @stdout = o.gets(nil)
+    @stderr = e.gets(nil)
+  end
+end
+
+###
+# Then
+###
+Then /^the run should exit '(.+)'$/ do |exit_code|
+  if ENV['LOG_LEVEL'] == 'debug'
+    puts @status.inspect
+    puts @status.exitstatus
+  end
+  begin
+    @status.exitstatus.should eql(exit_code.to_i)
+  rescue 
+    print_output
+    raise
+  end
+  print_output if ENV["LOG_LEVEL"] == "debug"
+end
+
+Then "I print the debug log" do
+  print_output
+end
+
+Then /^the run should exit from being signaled$/ do 
+  begin
+    @status.signaled?.should == true
+  rescue 
+    print_output
+    raise
+  end
+  print_output if ENV["LOG_LEVEL"] == "debug"
+end
+
+
+def print_output
+  puts "--- run stdout:"
+  puts @stdout
+  puts "--- run stderr:"
+  puts @stderr
+end
+
+# Matcher for regular expression which uses normal string interpolation for
+# the actual (target) value instead of expecting it, as stdout/stderr which
+# get matched against may have lots of newlines, which looks ugly when
+# inspected, as the newlines show up as \n
+class NoInspectMatch
+  def initialize(expected_regex)
+    @expected_regex = expected_regex
+  end
+  def matches?(target)
+    @target = target
+    @target =~ @expected_regex
+  end
+  def failure_message
+    "expected #{@target} should match #{@expected_regex}"
+  end
+  def negative_failure_message
+    "expected #{@target} not to match #{@expected_regex}"
+  end
+end
+def noinspect_match(expected_regex)
+  NoInspectMatch.new(expected_regex)
+end
+
+
+Then /^'(.+)' should have '(.+)'$/ do |which, to_match|
+  if which == "stdout" || which == "stderr"
+    self.instance_variable_get("@#{which}".to_sym).should noinspect_match(/#{to_match}/m)
+  else
+    self.instance_variable_get("@#{which}".to_sym).should match(/#{to_match}/m)
+  end    
+end
+
+Then /^'(.+)' should not have '(.+)'$/ do |which, to_match|
+  to_match = Regexp.escape(to_match)
+  if which == "stdout" || which == "stderr"
+    self.instance_variable_get("@#{which}".to_sym).should_not noinspect_match(/#{to_match}/m)
+  else
+    self.instance_variable_get("@#{which}".to_sym).should_not match(/#{to_match}/m)
+  end
+end
+
+Then /^'(.+)' should appear on '(.+)' '(.+)' times$/ do |to_match, which, count|
+  seen_count = 0
+  self.instance_variable_get("@#{which}".to_sym).split("\n").each do |line|
+    seen_count += 1 if line =~ /#{to_match}/
+  end
+  seen_count.should == count.to_i
+end
+
+Then "I inspect the contents of the features tmpdir" do
+  puts `ls -halpR #{tmpdir}`
+end

data/lib/cuken/cucumber/chef/run_solo.rb

@@ -0,0 +1,78 @@
+# This is kind of a crazy-ass setup, but it works.
+When /^I run chef-solo with the '(.+)' recipe$/ do |recipe_name|
+  # Set up the JSON file with the recipe we want to run.
+  dna_file = "#{tmpdir}/chef-solo-features-dna.json"
+  File.open(dna_file, "w") do |fp|
+    fp.write("{ \"run_list\": [\"#{recipe_name}\"] }")
+  end
+
+  cleanup_files << "#{tmpdir}/chef-solo-features-dna.json"
+
+  # Set up the cache dir.
+  cache_dir = "#{tmpdir}/chef-solo-cache-features"
+  system("mkdir -p #{cache_dir}")
+  cleanup_dirs << cache_dir 
+
+  # Cookbook dir
+  cookbook_dir ||= File.expand_path(File.join(File.dirname(__FILE__), '..', 'data', 'cookbooks'))
+  system("cp -r #{cookbook_dir} #{cache_dir}")
+
+  # Config file
+  config_file = "#{tmpdir}/chef-solo-config-features.rb"
+  File.open(config_file, "w") do |fp|
+    fp.write("cookbook_path \"#{cache_dir}/cookbooks\"\n")
+    fp.write("file_cache_path \"#{cache_dir}/cookbooks\"\n")
+  end
+  cleanup_files << config_file
+
+  binary_path = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'chef', 'bin', 'chef-solo'))
+  command = "#{binary_path} -c #{config_file} -j #{dna_file}"
+  command += " -l debug" if ENV['LOG_LEVEL'] == 'debug'
+
+  # Run it
+  puts "Running solo: #{command}" if ENV['LOG_LEVEL'] == 'debug'
+
+  status = Chef::Mixin::Command.popen4(command) do |p, i, o, e|
+    @stdout = o.gets(nil)
+    @stderr = o.gets(nil)
+  end
+  @status = status
+
+  print_output if ENV['LOG_LEVEL'] == 'debug'
+end
+
+
+# This is kind of a crazy-ass setup, but it works.
+When /^I run chef-solo without cookbooks$/ do
+
+  # Set up the cache dir.
+  cache_dir = "#{tmpdir}/chef-solo-cache-features"
+  system("mkdir -p #{cache_dir}")
+  cleanup_dirs << cache_dir 
+
+  # Empty Cookbook dir
+  system("mkdir #{cache_dir}/cookbooks")
+
+  # Config file
+  config_file = "#{tmpdir}/chef-solo-config-features.rb"
+  File.open(config_file, "w") do |fp|
+    fp.write("cookbook_path \"#{cache_dir}/cookbooks\"\n")
+    fp.write("file_cache_path \"#{cache_dir}/cookbooks\"\n")
+  end
+  cleanup_files << config_file
+
+  binary_path = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'chef', 'bin', 'chef-solo'))
+  command = "#{binary_path} -c #{config_file}"
+  command += " -l debug" if ENV['LOG_LEVEL'] == 'debug'
+
+  # Run it
+  puts "Running solo: #{command}" if ENV['LOG_LEVEL'] == 'debug'
+
+  status = Chef::Mixin::Command.popen4(command) do |p, i, o, e|
+    @stdout = o.gets(nil)
+    @stderr = o.gets(nil)
+  end
+  @status = status
+
+  print_output if ENV['LOG_LEVEL'] == 'debug'
+end

data/lib/cuken/cucumber/chef/sandbox_steps.rb

@@ -0,0 +1,137 @@
+require 'chef/sandbox'
+
+# Upload the given file to the sandbox which was created by 'when I create a
+# sandbox named'
+def upload_to_sandbox(sandbox_filename, sandbox_file_checksum, url)
+  
+  checksum64 = Base64.encode64([sandbox_file_checksum].pack("H*")).strip
+  timestamp = Time.now.utc.iso8601
+  file_contents = File.read(sandbox_filename)
+  # TODO - 5/28/2010, cw: make signing and sending the request streaming
+  sign_obj = Mixlib::Authentication::SignedHeaderAuth.signing_object(
+                                                                     :http_method => :put,
+                                                                     :path => URI.parse(url).path,
+                                                                     :body => file_contents,
+                                                                     :timestamp => timestamp,
+                                                                     :user_id => rest.client_name
+                                                                     )
+  headers = { 
+    'content-type' => 'application/x-binary', 
+    'content-md5' => checksum64, 
+    :accept => 'application/json'
+  }
+  headers.merge!(sign_obj.sign(OpenSSL::PKey::RSA.new(rest.signing_key)))
+
+  # Don't set inflated_response as S3 (for the Platform) doesn't return JSON.
+  # Only Open Source does.
+  self.inflated_response = nil
+  self.exception = nil
+  self.api_response = RestClient::Request.execute(
+    :method => :put, 
+    :url => url, 
+    :headers => headers, 
+    :payload => file_contents
+  )
+end
+  
+
+When /^I create a sandbox named '([^\']+)'$/ do |sandbox_name|
+  begin
+    sandbox = get_fixture('sandbox', sandbox_name)
+    raise "no such sandbox in fixtures: #{sandbox_name}" unless sandbox
+    
+    @stash['sandbox'] = sandbox
+    
+    self.api_response = nil
+    self.exception = nil
+    self.inflated_response = rest.post_rest('/sandboxes', sandbox)
+    self.sandbox_url = self.inflated_response['uri']
+
+    @stash['sandbox_response'] = self.inflated_response
+  rescue
+    Chef::Log.debug("Caught exception in sandbox create (POST) request: #{$!.message}: #{$!.backtrace.join("\n")}")
+    self.exception = $!
+  end
+end
+
+When /^I commit the sandbox$/ do
+  begin
+    sandbox = @stash['sandbox']
+
+    # sandbox_url is fully qualified (with http://, sandboxes, etc.)
+    self.api_response = nil
+    self.exception = nil
+    self.inflated_response = rest.put_rest("#{self.sandbox_url}", {:is_completed => true})
+    
+    @stash.delete('sandbox_response')
+  rescue
+    Chef::Log.debug("Caught exception in sandbox commit (PUT) request: #{$!.message}: #{$!.backtrace.join("\n")}")
+    self.exception = $!
+  end
+end
+
+Then /^I upload a file named '([^\']+)' to the sandbox$/ do |stash_sandbox_filename|
+  begin
+    sandbox = @stash['sandbox']
+    raise "no sandbox defined, have you called 'When I create a sandbox'" unless sandbox
+    
+    sandbox_filename = get_fixture('sandbox_file', stash_sandbox_filename)
+    raise "no such stash_sandbox_filename in fixtures: #{stash_sandbox_filename}" unless sandbox_filename
+    
+    sandbox_file_checksum = Chef::CookbookVersion.checksum_cookbook_file(sandbox_filename)
+    if @stash['sandbox_response']['checksums'].key?(sandbox_file_checksum)
+      Chef::Log.debug "uploading a file '#{stash_sandbox_filename}' with correct checksum #{sandbox_file_checksum}"
+      url = @stash['sandbox_response']['checksums'][sandbox_file_checksum]['url']
+    else
+      Chef::Log.debug "Sandbox doesn't have a checksum #{sandbox_file_checksum}, assuming a negative test"
+      Chef::Log.debug "using checksum 'F157'... just kidding, using #{sandbox_file_checksum}"
+      url = @stash['sandbox_response']['uri'] + "/#{sandbox_file_checksum}"
+    end
+    
+    upload_to_sandbox(sandbox_filename, sandbox_file_checksum, url)
+  rescue
+    Chef::Log.debug("Caught exception in sandbox checksum upload (PUT) request: #{$!.message}: #{$!.backtrace.join("\n")}")
+    self.exception = $!
+  end
+end
+
+# Upload a file sandbox_filename_to_upload, but post it to the URL specified by
+# sandbox_file_for_checksum, to cause the checksum check to fail.
+Then /^I upload a file named '([^\']+)' using the checksum of '(.+)' to the sandbox$/ do |stash_upload_filename, stash_checksum_filename|
+  begin
+    sandbox = @stash['sandbox']
+
+    sandbox_upload_filename = get_fixture('sandbox_file', stash_upload_filename)
+    sandbox_checksum_filename = get_fixture('sandbox_file', stash_checksum_filename)
+    raise "no such stash_upload_filename in fixtures: #{stash_upload_filename}" unless sandbox_upload_filename
+    raise "no such stash_checksum_filename in fixtures: #{stash_checksum_filename}" unless stash_checksum_filename
+    
+    use_checksum = Chef::CookbookVersion.checksum_cookbook_file(sandbox_checksum_filename)
+    url = @stash['sandbox_response']['checksums'][use_checksum]['url']
+    
+    upload_to_sandbox(sandbox_upload_filename, use_checksum, url)
+  rescue
+    Chef::Log.debug("Caught exception in bad sandbox checksum upload (PUT) request: #{$!.message}: #{$!.backtrace.join("\n")}")
+    self.exception = $!
+  end
+end
+
+#Then the sandbox file 'sandbox2_file1' should need upload
+Then /^the sandbox file '(.+)' should need upload$/ do |stash_filename|
+  sandbox = @stash['sandbox_response']
+  
+  sandbox_filename = get_fixture('sandbox_file', stash_filename)
+  sandbox_checksum = Chef::CookbookVersion.checksum_cookbook_file(sandbox_filename)
+
+  sandbox['checksums'][sandbox_checksum]['needs_upload'] == true
+end
+
+Then /^the sandbox file '(.+)' should not need upload$/ do |stash_filename|
+  sandbox = @stash['sandbox_response']
+  
+  sandbox_filename = get_fixture('sandbox_file', stash_filename)
+  sandbox_checksum = Chef::CookbookVersion.checksum_cookbook_file(sandbox_filename)
+  
+  sandbox['checksums'][sandbox_checksum]['needs_upload'] == false
+end
+