cucumber-chef 2.1.0.rc.3 → 2.1.0.rc.4

data/README.md

@@ -1,4 +1,4 @@
-[![Build Status](https://secure.travis-ci.org/zpatten/cucumber-chef.png)](http://travis-ci.org/zpatten/cucumber-chef) [![Dependency Status](https://gemnasium.com/jovelabs/cucumber-chef.png)](https://gemnasium.com/jovelabs/cucumber-chef)
+[![Build Status](https://secure.travis-ci.org/jovelabs/cucumber-chef.png)](http://travis-ci.org/jovelabs/cucumber-chef) [![Dependency Status](https://gemnasium.com/jovelabs/cucumber-chef.png)](https://gemnasium.com/jovelabs/cucumber-chef)
 
 Cucumber-chef is a library of tools to enable the emerging discipline of infrastructure as code to practice test driven development.  It provides a testing platform within which Cucumber tests can be run which provision virtual machines, configure them by applying the appropriate Chef roles to them, and then run acceptance and integration tests against the environment.
 

data/bin/cc-knife

@@ -13,13 +13,10 @@ if (test_lab = Cucumber::Chef::TestLab.new) && test_lab.alive?
 
   knife_rb = Cucumber::Chef.knife_rb
   if File.exists?(knife_rb)
-    command = [knife, ARGV, "--server-url http://#{test_lab.ip}:4000", "--config #{knife_rb}", "2>&1"].flatten.compact.join(" ")
-    puts(command)
-    puts(%x(#{command}))
-    exit($?.to_i)
+    test_lab.knife_cli([ARGV], :replace_current_process => true)
   else
     puts("Could not find your Cucumber-Chef 'knife.rb'.  Did you setup your test lab?")
-    exit(255)
+    exit(2)
   end
 
 else

data/bin/cucumber-chef

@@ -205,8 +205,7 @@ class CucumberChef < Thor
           puts
 
           ZTK::Benchmark.bench(:message => "Start cc-server", :mark => "completed in %0.4f seconds.") do
-            cc_server = Cucumber::Chef::Server.new(test_lab)
-            cc_server.up(:silence => true)
+            test_lab.cc_client.up(:silence => true)
           end
 
           args.each do |container|
@@ -217,6 +216,11 @@ class CucumberChef < Thor
               test_lab.drb.save_containers
             end
           end
+
+          ZTK::Benchmark.bench(:message => "Stop cc-server", :mark => "completed in %0.4f seconds.") do
+            test_lab.cc_client.down
+          end
+
         else
           puts
           puts(set_color("Whew! That was close!", :green, true))
@@ -315,43 +319,49 @@ class CucumberChef < Thor
       if @options.containers?
         if test_lab.alive?
           ZTK::Benchmark.bench(:message => "Start cc-server", :mark => "completed in %0.4f seconds.") do
-            test_lab.cc_server.up(:silence => true)
+            test_lab.cc_client.up(:silence => true)
           end
 
           test_lab.drb.load_containers
 
-          headers = [:name, :alive, :arch, :distro, :ip, :mac, :"chef version", :persist]
-          results = ZTK::Report.new.spreadsheet(test_lab.drb.containers, headers) do |name, detail|
-            chef_version = "N/A"
-            alive = (test_lab.drb.command_run_local(%Q{ping -n -c 1 -W 1 #{detail[:ip]}}, :ignore_exit_status => true).exit_code == 0)
-            if alive
-              chef_version = test_lab.drb.command_run_chroot(name, %Q{/usr/bin/env chef-client -v}, :ignore_exit_status => true).output.chomp
+          if test_lab.drb.containers.count > 0
+            headers = [:name, :alive, :arch, :distro, :ip, :mac, :"chef version", :persist]
+            results = ZTK::Report.new.spreadsheet(test_lab.drb.containers, headers) do |name, detail|
+              chef_version = "N/A"
+              alive = (test_lab.drb.command_run_local(%Q{ping -n -c 1 -W 1 #{detail[:ip]}}, :ignore_exit_status => true).exit_code == 0)
+              if alive
+                chef_version = test_lab.drb.command_run_chroot(name, %Q{/usr/bin/env chef-client -v}, :ignore_exit_status => true).output.chomp
+              end
+
+              OpenStruct.new(
+                :name => name,
+                :ip => detail[:ip],
+                :mac => detail[:mac],
+                :distro => detail[:distro],
+                :arch => detail[:arch],
+                :alive => alive,
+                :"chef version" => chef_version,
+                :persist => detail[:persist],
+                :chef_attributes => detail[:chef_client]
+              )
             end
 
-            OpenStruct.new(
-              :name => name,
-              :ip => detail[:ip],
-              :mac => detail[:mac],
-              :distro => detail[:distro],
-              :arch => detail[:arch],
-              :alive => alive,
-              :"chef version" => chef_version,
-              :persist => detail[:persist],
-              :chef_attributes => detail[:chef_client]
-            )
-          end
-
-          if @options.attributes?
-            results.rows.each do |result|
-              puts
-              puts("-" * results.width)
-              puts("Chef-Client attributes for '#{result.name.to_s.downcase}':")
-              puts("-" * results.width)
-              puts(JSON.pretty_generate(result.chef_attributes))
+            if @options.attributes?
+              results.rows.each do |result|
+                puts
+                puts("-" * results.width)
+                puts("Chef-Client attributes for '#{result.name.to_s.downcase}':")
+                puts("-" * results.width)
+                puts(JSON.pretty_generate(result.chef_attributes))
+              end
             end
+          else
+            raise Cucumber::Chef::Error, "We could not find any containers!"
           end
 
-          test_lab.cc_server.down
+          ZTK::Benchmark.bench(:message => "Stop cc-server", :mark => "completed in %0.4f seconds.") do
+            test_lab.cc_client.down
+          end
         else
           raise Cucumber::Chef::Error, "We could not find a running test lab."
         end

data/lib/cucumber/chef/{server.rb → client.rb}

@@ -21,9 +21,9 @@
 module Cucumber
   module Chef
 
-    class ServerError < Error; end
+    class ClientError < Error; end
 
-    class Server
+    class Client
       attr_accessor :test_lab, :stdout, :stderr, :stdin, :logger
 
 ################################################################################
@@ -74,7 +74,7 @@ module Cucumber
         end
 
         ZTK::RescueRetry.try(:tries => 30) do
-          self.ping
+          self.drb.ping
         end
 
         File.exists?(Cucumber::Chef.artifacts_dir) && FileUtils.rm_rf(Cucumber::Chef.artifacts_dir)
@@ -84,17 +84,17 @@ module Cucumber
 
 ################################################################################
 
-      def ping
-        @drb and DRb.stop_service
-        @drb = DRbObject.new_with_uri("druby://#{@test_lab.ip}:8787")
-        @drb and DRb.start_service
-        @drb.ping
+      def down
+        (@test_lab.drb.shutdown rescue nil)
       end
 
 ################################################################################
 
-      def down
-        (@test_lab.drb.shutdown rescue nil)
+      def drb
+        @drb and DRb.stop_service
+        @drb = DRbObject.new_with_uri("druby://#{@test_lab.ip}:8787")
+        @drb and DRb.start_service
+        @drb
       end
 
 ################################################################################

data/lib/cucumber/chef/helpers/chef_client.rb

@@ -60,6 +60,7 @@ module Cucumber::Chef::Helpers::ChefClient
     logger.info { "Running chef client on container '#{name}'." }
 
     arguments = {
+      "--node-name" => name,
       "--json-attributes" => File.join("/etc", "chef", "attributes.json").to_s,
       "--log_level" => (ENV['LOG_LEVEL'] || "INFO").downcase
     }.reject{ |k,v| v.nil? }.sort
@@ -80,18 +81,23 @@ module Cucumber::Chef::Helpers::ChefClient
     client_rb = File.join("/", container_root(name), "etc/chef/client.rb")
     FileUtils.mkdir_p(File.dirname(client_rb))
 
-    max_key_size = @chef_client_config.keys.collect{ |z| z.to_s.size }.max
+    # Do not render out a chef-client config for now; we'll assume the user will
+    # use a cookbook/recipe to accomplish this to their liking.
 
-    File.open(client_rb, 'w') do |f|
-      f.puts(Cucumber::Chef.generate_do_not_edit_warning("Chef Client Configuration"))
-      f.puts
-      @chef_client_config.merge(:node_name => name).each do |(key,value)|
-        next if value.nil?
-        f.puts("%-#{max_key_size}s  %s" % [key, value.inspect])
-      end
-      f.puts
-      f.puts("Mixlib::Log::Formatter.show_time = true")
-    end
+    # File.exists?(client_rb) && File.delete(client_rb)
+
+    # max_key_size = @chef_client_config.keys.collect{ |z| z.to_s.size }.max
+
+    # File.open(client_rb, 'w') do |f|
+    #   f.puts(Cucumber::Chef.generate_do_not_edit_warning("Chef Client Configuration"))
+    #   f.puts
+    #   @chef_client_config.merge(:node_name => name).each do |(key,value)|
+    #     next if value.nil?
+    #     f.puts("%-#{max_key_size}s  %s" % [key, value.inspect])
+    #   end
+    #   f.puts
+    #   f.puts("Mixlib::Log::Formatter.show_time = true")
+    # end
 
     attributes_json = File.join("/", container_root(name), "etc", "chef", "attributes.json")
     FileUtils.mkdir_p(File.dirname(attributes_json))

data/lib/cucumber/chef/helpers/chef_server.rb

@@ -35,91 +35,6 @@ module Cucumber::Chef::Helpers::ChefServer
     logger.info { "Destroyed chef client '#{name}'." }
   end
 
-################################################################################
-
-  def load_cookbook(cookbook, cookbook_path)
-    if !File.exists?(cookbook_path)
-      raise "Cookbook path does not exist!"
-    end
-    cookbook_repo = ::Chef::CookbookLoader.new(cookbook_path)
-    cookbook_repo.each do |name, cbook|
-      next if name != cookbook
-      ::Chef::CookbookUploader.new(cbook, cookbook_path, :force => true).upload_cookbooks
-      logger.info { "Uploaded chef cookbook '#{cookbook}' from '#{cookbook_path}'." }
-    end
-  end
-
-################################################################################
-
-  def load_role(role, role_path)
-    expanded_role_path = File.expand_path(role_path)
-    if !File.exists?(expanded_role_path)
-      raise "Role path, '#{expanded_role_path}', does not exist!"
-    end
-    ::Chef::Config[:role_path] = expanded_role_path
-    role = ::Chef::Role.from_disk(role)
-    role.save
-    logger.info { "Updated chef role '#{role}' from '#{role_path}'." }
-  end
-
-################################################################################
-
-  def get_databag(databag)
-    @rest ||= ::Chef::REST.new(Chef::Config[:chef_server_url])
-    @rest.get_rest("data/#{databag}")
-  rescue Net::HTTPServerException => e
-    raise unless e.to_s =~ /^404/
-  end
-
-  def destroy_databag(databag)
-    @rest ||= ::Chef::REST.new(Chef::Config[:chef_server_url])
-    @rest.delete_rest("data/#{databag}")
-  rescue Net::HTTPServerException => e
-    raise unless e.to_s =~ /^404/
-  end
-
-################################################################################
-
-  def create_databag(databag)
-    @rest ||= ::Chef::REST.new(Chef::Config[:chef_server_url])
-    @rest.post_rest("data", { "name" => databag })
-  rescue Net::HTTPServerException => e
-    raise unless e.to_s =~ /^409/
-  end
-
-  def load_databag_item(databag_item_path)
-    ::Yajl::Parser.parse(IO.read(databag_item_path))
-  end
-
-  def load_databag(databag, databag_path)
-    create_databag(databag)
-    items = Dir.glob(File.expand_path(File.join(databag_path, "*.{json,rb}")))
-    if (items.size == 0)
-      raise "Could not find any of the data bags you defined!"
-    end
-    items.each do |item|
-      next if File.directory?(item)
-
-      item_name = %w(json rb).collect{ |ext| (item =~ /#{ext}/ ? File.basename(item, ".#{ext}") : nil) }.compact.first
-      item_path = File.basename(item)
-      databag_item_path = File.expand_path(File.join(databag_path, item_path))
-
-      data_bag_item = ::Chef::DataBagItem.new
-      data_bag_item.data_bag(databag)
-      raw_data = load_databag_item(databag_item_path)
-      data_bag_item.raw_data = raw_data.dup
-      data_bag_item.save
-
-      loop do
-        chef_data = ::Chef::DataBagItem.load(databag, item_name).raw_data
-        break if chef_data == raw_data
-        logger.info { "Waiting on chef data bag to update; sleeping 1 second." }
-        sleep(1)
-      end
-      logger.info { "Updated chef data bag item '#{databag}/#{item_path}' from '#{databag_path}'." }
-    end
-  end
-
 ################################################################################
 
 end

data/lib/cucumber/chef/provider.rb

@@ -48,11 +48,11 @@ module Cucumber
 ################################################################################
 
       def chef_server_webui
-        "http://#{ip}:4040/"
+        "http://#{ip}:4040"
       end
 
       def chef_server_api
-        "http://#{ip}:4000/"
+        "http://#{ip}:4000"
       end
 
       def status
@@ -90,7 +90,7 @@ module Cucumber
         if Cucumber::Chef::Provider::PROXY_METHODS.include?(method_name.to_s)
           result = @provider.send(method_name.to_sym, *method_args)
           splat = [method_name, *method_args].flatten.compact
-          Cucumber::Chef.logger.debug { "provider: #{splat.inspect} -> #{result.inspect}" }
+          Cucumber::Chef.logger.debug { "Provider: #{splat.inspect}=#{result.inspect}" }
           result
         else
           super(method_name, *method_args)

data/lib/cucumber/chef/providers/vagrant.rb

@@ -39,7 +39,6 @@ module Cucumber
           @stdout.sync = true if @stdout.respond_to?(:sync=)
 
           @env = ::Vagrant::Environment.new
-          # @env = ::Vagrant::Environment.new(:ui_class => ::Vagrant::UI::Colored)
           @vm = @env.primary_vm
         end
 
@@ -49,7 +48,7 @@ module Cucumber
 
         def create
           ZTK::Benchmark.bench(:message => "Creating #{Cucumber::Chef::Config.provider.upcase} instance", :mark => "completed in %0.4f seconds.", :stdout => @stdout) do
-            @env.cli("up")
+            self.vagrant_cli("up")
             ZTK::TCPSocketCheck.new(:host => self.ip, :port => self.port, :wait => 120).wait
           end
 
@@ -67,7 +66,7 @@ module Cucumber
 
         def destroy
           if exists?
-            @env.cli("destroy", "--force")
+            self.vagrant_cli("destroy", "--force")
           else
             raise VagrantError, "We could not find a test lab!"
           end
@@ -84,7 +83,7 @@ module Cucumber
 
         def up
           if (exists? && dead?)
-            @env.cli("up")
+            self.vagrant_cli("up")
             ZTK::TCPSocketCheck.new(:host => self.ip, :port => self.port, :wait => 120).wait
           else
             raise VagrantError, "We could not find a powered off test lab."
@@ -102,7 +101,7 @@ module Cucumber
 
         def halt
           if (exists? && alive?)
-            @env.cli("halt")
+            self.vagrant_cli("halt")
           else
             raise AWSError, "We could not find a running test lab."
           end
@@ -119,7 +118,7 @@ module Cucumber
 
         def reload
           if (exists? && alive?)
-            @env.cli("reload")
+            self.vagrant_cli("reload")
           else
             raise AWSError, "We could not find a running test lab."
           end
@@ -166,6 +165,13 @@ module Cucumber
           @vm.config.vm.forwarded_ports.select{ |fwd_port| (fwd_port[:name] == "ssh") }.first[:hostport].to_i
         end
 
+################################################################################
+
+        def vagrant_cli(*args)
+          command = Cucumber::Chef.build_command("vagrant", *args)
+          ZTK::Command.new.exec(command, :silence => true)
+        end
+
 ################################################################################
 
       end

data/lib/cucumber/chef/provisioner.rb

@@ -27,9 +27,6 @@ module Cucumber
     class Provisioner
       attr_accessor :test_lab, :stdout, :stderr, :stdin
 
-      HOSTNAME = "cucumber-chef.test-lab"
-      PASSWORD = "p@ssw0rd1"
-
 ################################################################################
 
       def initialize(test_lab, stdout=STDOUT, stderr=STDERR, stdin=STDIN)
@@ -162,14 +159,7 @@ module Cucumber
       def upload_cookbook
         Cucumber::Chef.logger.debug { "Uploading cucumber-chef cookbooks..." }
         ZTK::Benchmark.bench(:message => "Uploading 'cucumber-chef' cookbooks", :mark => "completed in %0.4f seconds.", :stdout => @stdout) do
-          Cucumber::Chef.load_chef_config
-          cookbook_repo = ::Chef::CookbookLoader.new(@cookbooks_path)
-          cookbook_repo.each do |name, cookbook|
-            Cucumber::Chef.logger.debug { "::Chef::CookbookUploader(#{name}) ATTEMPT" }
-            ::Chef::CookbookUploader.new(cookbook, @cookbooks_path, :force => true).upload_cookbooks
-            Cucumber::Chef.logger.debug { "::Chef::CookbookUploader(#{name}) UPLOADED" }
-          end
-          #@command.knife([ "cookbook upload cucumber-chef", "-o", @cookbooks_path ], :silence => true)
+          @test_lab.knife_cli(%Q{cookbook upload cucumber-chef -o #{@cookbooks_path}}, :silence => true)
         end
       end
 
@@ -178,13 +168,7 @@ module Cucumber
       def upload_role
         Cucumber::Chef.logger.debug { "Uploading cucumber-chef test lab role..." }
         ZTK::Benchmark.bench(:message => "Uploading 'cucumber-chef' roles", :mark => "completed in %0.4f seconds.", :stdout => @stdout) do
-          Cucumber::Chef.load_chef_config
-          ::Chef::Config[:role_path] = @roles_path
-          [ "test_lab" ].each do |name|
-            role = ::Chef::Role.from_disk(name)
-            role.save
-          end
-          #@command.knife([ "role from file", File.join(@roles_path, "test_lab.rb") ], :silence => true)
+          @test_lab.knife_cli(%Q{role from file #{File.join(@roles_path, "test_lab.rb")}}, :silence => true)
         end
       end
 
@@ -193,13 +177,7 @@ module Cucumber
       def tag_node
         Cucumber::Chef.logger.debug { "Tagging cucumber-chef test lab node..." }
         ZTK::Benchmark.bench(:message => "Tagging 'cucumber-chef' node", :mark => "completed in %0.4f seconds.", :stdout => @stdout) do
-          Cucumber::Chef.load_chef_config
-          node = ::Chef::Node.load(HOSTNAME)
-          [ Cucumber::Chef::Config[:mode].to_s, Cucumber::Chef::Config[:user].to_s ].each do |tag|
-            node.tags << tag
-            node.save
-          end
-          #@command.knife([ "tag create", HOSTNAME, Cucumber::Chef::Config[:mode] ], :silence => true)
+          @test_lab.knife_cli(%Q{tag create #{Cucumber::Chef.lab_hostname_full} #{Cucumber::Chef::Config.mode}}, :silence => true)
         end
       end
 
@@ -208,13 +186,7 @@ module Cucumber
       def add_node_role
         Cucumber::Chef.logger.debug { "Setting up cucumber-chef test lab run list..." }
         ZTK::Benchmark.bench(:message => "Setting 'cucumber-chef' run list", :mark => "completed in %0.4f seconds.", :stdout => @stdout) do
-          Cucumber::Chef.load_chef_config
-          node = ::Chef::Node.load(HOSTNAME)
-          [ "role[test_lab]" ].each do |entry|
-            node.run_list << entry
-          end
-          node.save
-          #@command.knife([ "node run_list add", HOSTNAME, "\"role[test_lab]\"" ], :silence => true)
+          @test_lab.knife_cli(%Q{node run_list add #{Cucumber::Chef.lab_hostname_full} "role[test_lab]"}, :silence => true)
         end
       end
 

data/lib/cucumber/chef/steps/chef_steps.rb

@@ -19,20 +19,54 @@
 #
 ################################################################################
 
-And /^the following databags have been updated:$/ do |table|
+And /^the following (databag|databags) (has|have) been (updated|uploaded):$/ do |ignore0, ignore1, ignore2, table|
   table.hashes.each do |entry|
-    load_databag(entry['databag'], entry['databag_path'])
+    data_bag = entry['databag']
+    data_bag_path = entry['databag_path']
+
+    $test_lab.knife_cli(%Q{data bag from file #{data_bag} #{data_bag_path}}, :silence => true)
   end
 end
 
-And /^the following roles have been updated:$/ do |table|
+And /^the following (role|roles) (has|have) been (updated|uploaded):$/ do |ignore0, ignore1, ignore2, table|
   table.hashes.each do |entry|
-    load_role(entry['role'], entry['role_path'])
+    role = entry['role']
+    role_path = entry['role_path']
+
+    if File.extname(role).empty?
+      Dir.glob(File.join(role_path, "#{role}.*")).each do |role_file|
+        $test_lab.knife_cli(%Q{role from file #{role_file}}, :silence => true)
+      end
+    else
+      $test_lab.knife_cli(%Q{role from file #{File.join(role_path, role)}}, :silence => true)
+    end
   end
 end
 
-And /^the following cookbooks have been uploaded:$/ do |table|
+And /^the following (cookbook|cookbooks) (has|have) been (updated|uploaded):$/ do |ignore0, ignore1, ignore2, table|
+  cookbooks = table.hashes.inject(Hash.new) do |memo, entry|
+    cookbook = entry['cookbook']
+    cookbook_path = entry['cookbook_path']
+
+    memo.merge(cookbook_path => [cookbook]) { |k,o,n| k = o << n }
+  end
+
+  cookbooks.each do |cookbook_path, cookbooks|
+    $test_lab.knife_cli(%Q{cookbook upload #{cookbooks.join(" ")} -o #{cookbook_path}}, :silence => true)
+  end
+end
+
+And /^the following (environment|environments) (has|have) been (updated|uploaded):$/ do |ignore0, ignore1, ignore2, table|
   table.hashes.each do |entry|
-    load_cookbook(entry['cookbook'], entry['cookbook_path'])
+    environment = entry['environment']
+    environment_path = entry['environment_path']
+
+    if File.extname(environment).empty?
+      Dir.glob(File.join(environment_path, "#{environment}.*")).each do |environment_file|
+        $test_lab.knife_cli(%Q{environment from file #{environment_file}}, :silence => true)
+      end
+    else
+      $test_lab.knife_cli(%Q{environment from file #{File.join(environment_path, environment)}}, :silence => true)
+    end
   end
 end

data/lib/cucumber/chef/templates/cucumber/cc-hooks.rb

@@ -23,8 +23,7 @@ puts("  * #{tag}")
 Cucumber::Chef.boot(tag)
 
 if (($test_lab = Cucumber::Chef::TestLab.new) && $test_lab.alive?)
-  $cc_server = Cucumber::Chef::Server.new($test_lab)
-  $cc_server.up
+  $test_lab.cc_client.up
 else
   message = "No running cucumber-chef test labs to connect to!"
   Cucumber::Chef.logger.fatal { message }
@@ -37,15 +36,16 @@ end
 ################################################################################
 
 Before do |scenario|
-  $cc_server.before(scenario)
+  $test_lab.cc_client.before(scenario)
 end
 
 After do |scenario|
-  $cc_server.after(scenario)
+  @connection and @connection.ssh.shutdown!
+  $test_lab.cc_client.after(scenario)
 end
 
 Kernel.at_exit do
-  $cc_server.at_exit
+  $test_lab.cc_client.at_exit
 end
 
 ################################################################################

data/lib/cucumber/chef/test_lab.rb

@@ -90,22 +90,38 @@ module Cucumber
         @proxy_ssh[container]
       end
 
+################################################################################
+
+      def cc_client
+        dead? and raise TestLabError, "The test lab must be running in order to start the cc-server/client session!"
+
+        @cc_client ||= Cucumber::Chef::Client.new(self, @stdout, @stderr, @stdin, @logger)
+        @cc_client
+      end
+
 ################################################################################
 
       def drb
         dead? and raise TestLabError, "The test lab must be running in order to start a Drb session!"
 
-        # @drb and DRb.stop_service
-        @drb ||= DRbObject.new_with_uri("druby://#{self.ip}:8787")
-        @drb and DRb.start_service
-        @drb
+        self.cc_client.drb
       end
 
 ################################################################################
 
-      def cc_server
-        @cc_server ||= Cucumber::Chef::Server.new(self, @stdout, @stderr, @stdin, @logger)
-        @cc_server
+      def knife_cli(args, options={})
+        options = {:silence => true}.merge(options)
+
+        extracted_options = options.select{ |k,v| [:silence, :expected_exit_code].include?(k) }
+        options.reject!{ |k,v| [:silence, :expected_exit_code].include?(k) }
+
+        arguments = Array.new
+        arguments << "--user #{Cucumber::Chef::Config.user}"
+        arguments << "--server-url #{self.chef_server_api}"
+        arguments << "--config #{Cucumber::Chef.knife_rb}" if File.exists?(Cucumber::Chef.knife_rb)
+
+        command = Cucumber::Chef.build_command("knife", args, arguments)
+        ZTK::Command.new(options).exec(command, extracted_options)
       end
 
 ################################################################################
@@ -114,7 +130,7 @@ module Cucumber
         if Cucumber::Chef::Provider::PROXY_METHODS.include?(method_name.to_s)
           result = @provider.send(method_name.to_sym, *method_args)
           splat = [method_name, *method_args].flatten.compact
-          Cucumber::Chef.logger.debug { "test_lab: #{splat.inspect} -> #{result.inspect}" }
+          Cucumber::Chef.logger.debug { "TestLab: #{splat.inspect}=#{result.inspect}" }
           result
         else
           super(method_name, *method_args)

data/lib/cucumber/chef/utility.rb

@@ -216,6 +216,13 @@ module Cucumber
         [ name, "v#{Cucumber::Chef::VERSION}" ].compact.join(" ")
       end
 
+################################################################################
+
+      def build_command(name, *args)
+        executable = (Cucumber::Chef.locate(:file, "bin", name) rescue "/usr/bin/env #{name}")
+        [executable, args].flatten.compact.join(" ")
+      end
+
 ################################################################################
 # BOOT
 ################################################################################

data/lib/cucumber/chef/version.rb

@@ -24,7 +24,7 @@ module Cucumber
 
 ################################################################################
 
-    VERSION = "2.1.0.rc.3" unless const_defined?(:VERSION)
+    VERSION = "2.1.0.rc.4" unless const_defined?(:VERSION)
 
 ################################################################################
 

data/lib/cucumber/chef.rb

@@ -47,10 +47,10 @@ module Cucumber
 
     class Error < StandardError; end
 
+    autoload :Client, 'cucumber/chef/client'
     autoload :Config, 'cucumber/chef/config'
     autoload :Provider, 'cucumber/chef/provider'
     autoload :Provisioner, 'cucumber/chef/provisioner'
-    autoload :Server, 'cucumber/chef/server'
     autoload :TestLab, 'cucumber/chef/test_lab'
 
     require 'cucumber/chef/utility'

data/lib/cucumber-chef/rake/task.rb

@@ -0,0 +1,24 @@
+require 'rubygems'
+require 'cucumber'
+require 'cucumber/rake/task'
+
+Cucumber::Rake::Task.new(:"cucumber-chef") do |t|
+  feature_dirs = Array.new
+
+  feature_dir_glob = File.join(Dir.pwd, "*cookbook*", "*", "*feature*")
+  feature_dirs << Dir.glob(feature_dir_glob)
+
+  feature_dir_glob = File.join(Dir.pwd, "*feature*")
+  feature_dirs << Dir.glob(feature_dir_glob)
+
+  opts = [
+    "--exclude support/cookbooks",
+    "--exclude support/data_bags",
+    "--exclude support/environments",
+    "--exclude support/keys",
+    "--exclude support/roles",
+    feature_dirs
+  ].flatten.compact.join(" ")
+
+  t.cucumber_opts = opts
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cucumber-chef
 version: !ruby/object:Gem::Version
-  version: 2.1.0.rc.3
+  version: 2.1.0.rc.4
   prerelease: 6
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-25 00:00:00.000000000 Z
+date: 2013-01-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chef
@@ -296,7 +296,9 @@ files:
 - features/support/silent_system.rb
 - features/usage.feature
 - lib/cucumber-chef.rb
+- lib/cucumber-chef/rake/task.rb
 - lib/cucumber/chef.rb
+- lib/cucumber/chef/client.rb
 - lib/cucumber/chef/config.rb
 - lib/cucumber/chef/helpers.rb
 - lib/cucumber/chef/helpers/chef_client.rb
@@ -311,7 +313,6 @@ files:
 - lib/cucumber/chef/providers/aws.rb
 - lib/cucumber/chef/providers/vagrant.rb
 - lib/cucumber/chef/provisioner.rb
-- lib/cucumber/chef/server.rb
 - lib/cucumber/chef/steps.rb
 - lib/cucumber/chef/steps/chef_steps.rb
 - lib/cucumber/chef/steps/minitest_steps.rb