cuken 0.1.1 → 0.1.2

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

@@ -0,0 +1,34 @@
+#
+# Author:: Hedgehog (<hedgehogshiatus@gmail.com>)
+# Copyright:: Copyright (c) 2011 Hedgehog.
+# Portions of this work are derived from the Chef project
+# The original license header follows:
+#
+# Copyright:: Copyright (c) 2008, 2010 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.
+#
+Given /^the Knife file "([^"]*)"$/ do |path|
+  in_current_dir do
+    chef.client_knife_path = Pathname(path).expand_path.realdirpath
+  end
+end
+
+When /^I successfully run Knife's "([^"]*)"$/ do |cmd|
+  run_knife_command(cmd, true)
+end
+
+When /^I interactively run Knife's "([^"]*)"$/ do |cmd|
+  run_knife_command(cmd, true)
+end

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

@@ -0,0 +1,27 @@
+#
+# 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.
+#
+
+###
+# Given
+###
+Given /^a validated node$/ do
+  # client should have cached ohai assigned to it
+  client.register
+  client.build_node
+  client.node.run_list << "integration_setup"
+end

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

@@ -0,0 +1,88 @@
+#
+# 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.
+#
+
+###
+# Given
+###
+Given /^a validated node$/ do
+  # client should have cached ohai assigned to it
+  client.register
+  client.build_node
+  client.node.run_list << "integration_setup"
+end
+
+Given /^a validated node in the 'cucumber' environment$/ do
+  # client should have cached ohai assigned to it
+  client.register
+  client.build_node
+  client.node.chef_environment("cucumber")
+  client.node.run_list << "integration_setup"
+end
+
+Given /^a validated node with an empty runlist$/ do
+  # client should have cached ohai assigned to it
+  client.register
+  client.build_node
+end
+
+
+Given /^it includes the recipe '([^\']+)'$/ do |recipe|
+  self.recipe = recipe
+  client.node.run_list << recipe
+  client.node.save
+end
+
+Given /^it includes the recipe '([^\']+)' at version '([^\']+)'$/ do |recipe, version|
+  self.recipe = "recipe[#{recipe},#{version}]"
+  client.node.run_list << "recipe[#{recipe}@#{version}]"
+  client.node.save
+end
+
+Given /^it includes no recipes$/ do 
+  self.recipe = "" 
+  client.node.run_list.reset!
+  client.node.save
+end
+
+Given /^it includes the role '([^\']+)'$/ do |role|
+  self.recipe = "role[#{role}]"
+  client.node.run_list << "role[#{role}]" 
+  client.node.save
+end
+
+###
+# When
+###
+When /^I remove '([^']*)' from the node's run list$/ do |run_list_item|
+  client.node.run_list.remove(run_list_item)
+  client.node.save
+end
+
+When /^I add '([^']*)' to the node's run list$/ do |run_list_item|
+  client.node.run_list << run_list_item
+  client.node.save
+end
+
+
+When /^the node is converged$/ do
+  client.run
+end
+
+When /^the node is retrieved from the API$/ do
+  self.inflated_response = Chef::Node.load(client.node.name)
+end

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

@@ -0,0 +1,144 @@
+def debian_compatible?
+  (ohai[:platform] == 'debian') || (ohai[:platform] == "ubuntu")
+end
+
+def chef_test_dpkg_installed?
+  shell_out("dpkg -l chef-integration-test").status.success?
+end
+
+def purge_chef_integration_debs
+  if debian_compatible? && chef_test_dpkg_installed?
+    shell_out!("dpkg -r chef-integration-test")
+    shell_out("dpkg --clear-avail")
+  end
+end
+
+Given /^I have configured my apt sources for integration tests$/ do
+  File.open("/etc/apt/sources.list.d/chef-integration-test.list", "w+") do |f|
+    f.puts "deb http://localhost:9000/ sid main"
+  end
+end
+
+def remove_integration_test_apt_source
+  FileUtils.rm("/etc/apt/sources.list.d/chef-integration-test.list")  
+rescue Errno::ENOENT
+  Chef::Log.info("Attempted to remove integration test from /etc/apt/sources.list.d but it didn't exist")
+end
+
+After("@apt") do
+  remove_integration_test_apt_source
+  purge_chef_integration_debs
+  shell_out! "apt-get clean" if debian_compatible?
+end
+
+Before('@dpkg') do
+  purge_chef_integration_debs if debian_compatible?
+end
+
+Before('@apt') do
+  purge_chef_integration_debs
+  shell_out!("apt-get clean") if debian_compatible?
+end
+
+After('@dpkg') do
+  purge_chef_integration_debs
+end
+
+Given "I am running on a debian compatible OS" do
+  unless debian_compatible?
+    pending("This test can only run on debian or ubuntu, but you have #{ohai[:platform]}")
+  end
+end
+
+Given "my dpkg architecture is 'amd64'" do
+  unless `dpkg --print-architecture`.strip == "amd64"
+    pending("This scenario can only run on an amd64 system")
+  end
+end
+
+Given "the deb package '$pkg_name' is available" do |pkg_name|
+  source = File.expand_path(File.dirname(__FILE__) + "/../data/apt/#{pkg_name}-1_amd64.deb")
+  dest = File.join(tmpdir, File.basename(source))
+  FileUtils.cp(source, dest)
+end
+
+Given "the apt server is running" do
+  self.apt_server_thread = Thread.new do
+    trap("INT") do
+      apt_server.shutdown
+      apt_server_thread.join
+    end
+    
+    apt_server.start
+  end
+
+  Chef::Log.debug "Waiting for apt server to start"
+  until tcp_test_port("localhost", 9000) do
+    Chef::Log.debug "."
+    sleep 1
+  end
+  Chef::Log.debug "done"
+end
+
+Given "I have updated my apt cache" do
+  shell_out!("apt-get update")
+end
+
+Given /^the gems server is running$/ do
+  self.gemserver_thread = Thread.new do
+    trap("INT") do 
+      gemserver.shutdown
+      gemserver_thread.join
+    end
+    
+    gemserver.start
+  end
+end
+
+Given /^that I have the (.+) package system installed$/ do |package_system|
+  unless package_system_available?(package_system)
+    pending "This Cucumber feature will not execute, as it is missing the #{package_system} packaging system."
+  end
+end
+
+Then /^there should be a binary on the path called '(.+)'$/ do |binary_name|
+  binary_name.strip!
+  result = `which #{binary_name}`
+  result.should_not =~ /not found/
+end
+
+Then /^there should not be a binary on the path called '(.+)'$/ do |binary_name|
+  binary_name.strip!
+  result = `which #{binary_name}`.strip
+
+  unless result.empty?
+    result.should =~ /not found/
+  end
+end
+
+Then /^the gem '(.+)' version '(.+)' should be installed$/ do |gem_name, version|
+  Then "a file named 'installed-gems/gems/#{gem_name}-#{version}' should exist"
+end
+
+Then "the gem '$gem_name' version '$version' should not be installed" do |gem_name, version|
+  Then "a file named 'installed-gems/gems/#{gem_name}-#{version}' should not exist"
+end
+
+def dpkg_should_be_installed(pkg_name)
+  shell_out!("dpkg -l #{pkg_name}")
+end
+
+Then "the dpkg package '$package_name' should be installed" do |package_name|
+  dpkg_should_be_installed(package_name)
+end
+
+def tcp_test_port(hostname, port)
+  tcp_socket = TCPSocket.new(hostname, port)
+  true
+rescue Errno::ETIMEDOUT
+  false
+rescue Errno::ECONNREFUSED
+  false
+ensure
+  tcp_socket && tcp_socket.close
+end

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

@@ -0,0 +1,21 @@
+#
+# Author:: Christopher Walters (<cw@opscode.com>)
+# Copyright:: Copyright (c) 2010 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.
+#
+
+When "I haven't yet fixed CHEF-1816, this test should be pending" do
+  pending "CHEF-1816: Timestamp deploy provider rollback doesn't work"
+end

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

@@ -0,0 +1,23 @@
+Given /^the cookbook has a '(.+)' named '(.+)' in the '(.+)' specific directory$/ do |file_type, filename, specificity|
+  cookbook_name, recipe_name = recipe.split('::')
+  type_dir = file_type == 'file' ? 'files' : 'templates'
+  specific_dir = nil
+  case specificity
+  when "host"
+    specific_dir = "host-#{client.node[:fqdn]}"
+  when "platform-version"
+    specific_dir = "#{client.node[:platform]}-#{client.node[:platform_version]}"
+  when "platform"
+    specific_dir = client.node[:platform]
+  when "default"
+    specific_dir = "default"
+  end
+  new_file_dir = File.expand_path(File.dirname(__FILE__) + "/../data/cookbooks/#{cookbook_name}/#{type_dir}/#{specific_dir}")
+  cleanup_dirs << new_file_dir unless new_file_dir =~ /default$/
+  system("mkdir -p #{new_file_dir}")
+  new_file_name = File.join(new_file_dir, filename)
+  cleanup_files << new_file_name
+  new_file = File.open(new_file_name, "w")
+  new_file.puts(specificity)
+  new_file.close
+end

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

@@ -0,0 +1,98 @@
+Given /^I dump the contents of the search index$/ do
+  rest.get_rest("/search/").each do |index_name, index_url|
+    puts "INDEX NAME: `#{index_name}'"
+    pp rest.get_rest(index_url.sub("http://127.0.0.1:4000", ''))
+  end
+end
+
+When /^I '([^']*)' (?:to )?the path '([^']*)'$/ do |http_method, request_uri|
+  begin
+    self.api_response = rest.send("#{http_method}_rest".downcase.to_sym, request_uri)
+    self.inflated_response = self.api_response
+  rescue
+    Chef::Log.debug("Caught exception in request: #{$!.message}")
+    self.exception = $!
+  end
+end
+
+When /^I '(.+)' the path '(.+)' using a wrong private key$/ do |http_method, request_uri|
+  key = OpenSSL::PKey::RSA.generate(2048)
+  File.open(File.join(tmpdir, 'false_key.pem'), "w") { |f| f.print key }
+  @rest = Chef::REST.new(Chef::Config[:chef_server_url], 'snakebite' , File.join(tmpdir, 'false_key.pem'))
+
+  When "I '#{http_method}' the path '#{request_uri}'"
+end
+
+When /^I (.+) the client$/ do |action| 
+  raise ArgumentError, "You can only create or save clients" unless action =~ /^(create|save)$/
+  client = stash['client']
+  request_body = {:name => client.name, :admin => client.admin}
+  begin
+    self.inflated_response = @rest.post_rest("clients", request_body) if action == 'create'
+    self.inflated_response = @rest.put_rest("clients/#{client.name}", request_body) if action == 'save'
+  rescue
+    self.exception = $!
+  end
+end
+
+When /^I '(.+)' the '(.+)' to the path '(.+)'$/ do |http_method, stash_key, request_uri|
+  begin
+    self.api_response = rest.send("#{http_method.to_s.downcase}_rest".downcase.to_sym, request_uri, stash[stash_key])
+    self.inflated_response = self.api_response
+  rescue
+    self.exception = $!
+  end
+end
+
+When /^I '(.+)' the '(.+)' to the path '(.+)' using a wrong private key$/ do |http_method, stash_key, request_uri|
+  key = OpenSSL::PKey::RSA.generate(2048)
+  File.open(File.join(tmpdir, 'false_key.pem'), "w") { |f| f.print key }
+  @rest = Chef::REST.new(Chef::Config[:chef_server_url], 'snakebite' , File.join(tmpdir, 'false_key.pem'))
+
+  When "I '#{http_method}' the '#{stash_key}' to the path '#{request_uri}'"
+end
+
+When /^I delete local private key/ do
+  Chef::FileCache.delete("private_key.pem")
+end
+
+When /^I register '(.+)'$/ do |user|
+  begin
+    rest = Chef::REST.new(Chef::Config[:registration_url])
+    rest.register("bobo")
+  rescue
+    self.exception = $!
+  end
+end
+
+When /^I authenticate as '(.+)'$/ do |reg|
+  begin
+    rest.authenticate(reg, 'tclown')
+  rescue
+    self.exception = $!
+  end
+end
+
+When "I edit the '$not_admin' client" do |client|
+  stash['client'] = @rest.get_rest("/clients/not_admin")
+end
+ 
+When "I set '$property' to true" do |property|
+  stash['client'].send(property.to_sym, true)
+end
+
+def call_as_admin(&block)
+  orig_rest = @rest
+  orig_node_name = Chef::Config[:node_name]
+  orig_client_key = Chef::Config[:client_key]
+  begin
+    @rest = admin_rest
+    Chef::Config[:node_name] = @rest.auth_credentials.client_name
+    Chef::Config[:client_key] = @rest.auth_credentials.key_file
+    yield
+  ensure
+    @rest = orig_rest
+    Chef::Config[:node_name] = orig_node_name
+    Chef::Config[:client_key] = orig_client_key
+  end
+end

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

@@ -0,0 +1,233 @@
+
+# Walk array/hash to determine maximum depth. A scalar (anything but an
+# Array or Hash) has depth 0.
+def count_structure_levels(obj)
+  if obj.respond_to?(:keys)
+    # empty hash also has depth 0.
+    max_depth = 0
+    obj.keys.each do |key|
+      child_levels = 1 + count_structure_levels(obj[key])
+      max_depth = [max_depth, child_levels].max
+    end
+    max_depth
+  elsif obj.is_a?(Array)
+    # empty array also has depth 0.
+    max_depth = 0
+    obj.each do |child|
+      child_levels = 1 + count_structure_levels(child)
+      max_depth = [max_depth, child_levels].max
+    end
+    max_depth
+  else
+    0
+  end
+end
+
+Then /^I should get a '(.+)' exception$/ do |exception|
+  self.exception.message.to_s.should == exception
+end
+
+Then /^I should not get an exception$/ do
+  self.exception.should == nil
+end
+
+Then /^the response code should be '(.+)'$/ do |response_code|
+  case response_code.to_i
+    when 200
+      self.api_response.code.should == 200
+    when 400
+      self.exception.to_s.should match(/(Bad Request|400)/)
+    when 404
+      Then "I should get a 'RestClient::ResourceNotFound' exception"
+    when 412
+      self.exception.to_s.should match(/(Precondition Failed|412)/)
+  end
+end
+
+Then /^the response exception body should match '(.+)'/ do |regex|
+  raise "last response wasn't exception" unless self.exception
+  raise "last response exception had no body" unless self.exception.response && self.exception.response.body
+
+  self.exception.response.body.should =~ /#{regex}/m
+end
+
+Then /^the inflated responses key '(.+)' should be the integer '(\d+)'$/ do |key, int|
+  inflated_response[key].should == int.to_i
+end
+
+Then /^the inflated responses key '(\w+)' should match '(.+)'$/ do |key, regex|
+  puts self.inflated_response.inspect if ENV['DEBUG']
+  self.inflated_response[key].should =~ /#{regex}/m
+end
+
+Then /^the inflated responses key '(.+)' should be literally '(.+)'$/ do |key, literal|
+  puts self.inflated_response.inspect if ENV['DEBUG']
+  to_check = case literal
+             when "true"
+               true
+             when "false"
+               false
+             end
+
+  self.inflated_response[key].should == to_check
+end
+
+Then /^the inflated response should match '(.+)' as json$/ do |regex|
+  puts self.inflated_response.inspect if ENV["DEBUG"]
+  Chef::JSONCompat.to_json(self.inflated_response).should =~ /#{regex}/m
+end
+
+Then /^the inflated responses key '(.+)' should match '(.+)' as json$/ do |key, regex|
+  puts self.inflated_response.inspect if ENV["DEBUG"]
+  Chef::JSONCompat.to_json(self.inflated_response[key]).should =~ /#{regex}/m
+end
+
+Then /^the inflated responses key '(.+)' item '(\d+)' should be '(.+)'$/ do |key, index, to_equal|
+  inflated_response[key][index.to_i].should == to_equal
+end
+
+Then /^the inflated responses key '(.+)' item '(\d+)' should be a kind of '(.+)'$/ do |key, index, constant|
+  inflated_response[key][index.to_i].should be_a_kind_of(eval(constant))
+end
+
+Then /^the inflated responses key '(.+)' item '(\d+)' key '(.+)' should be '(.+)'$/ do |key, index, sub_key, to_equal|
+  inflated_response[key][index.to_i][sub_key].should == to_equal
+end
+
+Then /^the inflated responses key '(.+)' item '(\d+)' should respond to '(.+)' with '(.*)'$/ do |key, index, method_name, method_value|
+  inflated_response[key][index.to_i].send(method_name.to_sym).should == method_value
+end
+
+Then /^the inflated responses key '(.+)' sub-key '(.+)' should be an empty hash$/ do |key, sub_key|
+  inflated_response[key][sub_key].should == {}
+end
+
+Then /^the inflated responses key '(\w+)' sub-key '(\w+)' should match '(.+)'$/ do |key, sub_key, regex|
+  inflated_response[key][sub_key].should =~ /#{regex}/m
+end
+
+Then /^the inflated responses key '(\w+)' sub-key '(\w+)' item '(\d+)' sub-key '(\w+)' should match '(.+)'$/ do |key, sub_key, index, second_sub_key, regex|
+  inflated_response[key][sub_key][index.to_i][second_sub_key].should =~ /#{regex}/m
+end
+
+Then /^the inflated responses key '(\w+)' sub-key '(\w+)' item '(\d+)' sub-key '(\w+)' should equal '(.+)'$/ do |key, sub_key, index, second_sub_key, equal|
+  inflated_response[key][sub_key][index.to_i][second_sub_key].should == equal
+end
+
+Then /^the inflated responses key '(\w+)' sub-key '(\w+)' should be '(\d+)' items long$/ do |key, sub_key, length|
+  inflated_response[key][sub_key].length.should == length.to_i
+end
+
+Then /^the inflated responses key '(\w+)' should be '(\d+)' items long$/ do |key, length|
+  inflated_response[key].length.should == length.to_i
+end
+
+Then /^the inflated responses key '(.+)' should not exist$/ do |key|
+  self.inflated_response.has_key?(key).should == false
+end
+
+Then /^the inflated responses key '(.+)' should exist$/ do |key|
+  self.inflated_response.has_key?(key).should == true
+end
+
+Then /^the inflated responses key '(.+)'.to_s should be '(.+)'$/ do |key, expected_value|
+  self.inflated_response[key].to_s.should == expected_value
+end
+
+Then /^the inflated response should be an empty array$/ do
+  self.inflated_response.should == []
+end
+
+Then /^the inflated response should be an empty hash$/ do
+  self.inflated_response.should == {}
+end
+
+Then /^the inflated response should include '(.+)'$/ do |entry|
+  if inflated_response.size == 1
+    Array(inflated_response).first.should match(/#{entry}/)
+  else
+    inflated_response.detect { |n| n =~ /#{entry}/ }.should_not be_empty
+  end
+end
+
+Then /^the inflated response should be '(.+)' items long$/ do |length|
+  if length.respond_to?(:keys)
+    self.inflated_response.keys.length.should == length.to_i
+  else
+    self.inflated_response.length.should == length.to_i
+  end
+end
+
+Then /^the '(.+)' header should match '(.+)'$/ do |header, regex|
+  self.api_response.headers[header].should =~ /#{regex}/
+end
+
+Then /^the inflated responses key '(.+)' should include '(.+)'$/ do |key, regex|
+  if self.inflated_response[key].size == 1
+    self.inflated_response[key].first.should match(/#{regex}/)
+  else
+    self.inflated_response[key].detect { |n| n =~ /#{regex}/ }.should_not be_empty
+  end
+end
+
+Then /^the inflated response should match the '(.+)'$/ do |stash_name|
+  stash[stash_name].each do |k,v|
+    self.inflated_response[k.to_s].should == v
+  end
+end
+
+Then /^the inflated response should be the '(.+)'$/ do |stash_key|
+  self.inflated_response.should == stash[stash_key]
+end
+
+Then /^the stringified response should be the stringified '(.+)'$/ do |stash_key|
+  self.api_response.to_s.should == stash[stash_key].to_s
+end
+
+Then /^the inflated response should be a kind of '(.+)'$/ do |thing|
+  self.inflated_response.should be_a_kind_of(eval(thing))
+end
+
+Then "the inflated response should equal '$code'" do |code|
+  # cucumber can suck it, I'm using real code.
+  expected = eval(code)
+  inflated_response.should == expected
+end
+
+Then /^the inflated response should respond to '(.+)' with '(.+)'$/ do |method, to_match|
+  to_match = Chef::JSONCompat.from_json(to_match) if to_match =~ /^\[|\{/
+  to_match = true if to_match == 'true'
+  to_match = false if to_match == 'false'
+  self.inflated_response.to_hash[method].should == to_match
+end
+
+Then /^the inflated response should respond to '(.+)' and match '(.+)'$/ do |method, to_match|
+  self.inflated_response.to_hash[method].should == to_match
+end
+
+Then /^the inflated response should respond to '(.+)' and match '(.+)' as json$/ do |method, regex|
+  Chef::JSONCompat.to_json(self.inflated_response.to_hash[method]).should =~ /#{regex}/m
+end
+
+#And the 'deep_array' component has depth of '50' levels
+Then /^the '(.+)' component has depth of '(.+)' levels$/ do |method, levels|
+  count_structure_levels(self.inflated_response.to_hash[method]).should == levels.to_i
+end
+
+Then /^the fields in the inflated response should match the '(.+)'$/ do |stash_name|
+  self.inflated_response.each do |k,v|
+    unless k =~ /^_/ || k == 'couchrest-type'
+      stash[stash_name][k.to_sym].should == v
+    end
+  end
+end
+
+Then /^the data_bag named '(.+)' should not have an item named '(.+)'$/ do |data_bag, item|
+  exists = true
+  begin
+    Chef::DataBagItem.load(data_bag, item, @couchdb)
+  rescue
+    exists = false
+  end
+  exists.should == false
+end