cucumber-chef 0.4.0

data/lib/cucumber/chef/handy.rb

@@ -0,0 +1,87 @@
+module Cucumber
+  module Chef
+    module Handy
+      def create_server(server, ip)
+        create_network_config(server, ip)
+        create_container(server)
+      end
+
+      def create_network_config(name, ip)
+        network_config = File.join("/etc/lxc", name)
+        File.open(network_config, 'w') do |f|
+          f.puts "lxc.network.type = veth"
+          f.puts "lxc.network.flags = up"
+          f.puts "lxc.network.link = br0"
+          f.puts "lxc.network.name = eth0"
+          f.puts "lxc.network.ipv4 = #{ip}/24"
+        end
+      end
+
+      def create_container(name)
+        unless File.exists?("/var/lib/lxc/#{name}")
+          %x[lxc-create -n #{name} -f /etc/lxc/#{name} -t lucid-chef > /dev/null 2>&1 ]
+        end
+      end
+      
+      def set_run_list(name, run_list)
+        rl = Hash.new
+        a = Array.new
+        a << run_list
+        rl['run_list'] = a
+        first_boot = File.join('/var/lib/lxc', name, 'rootfs/etc/chef/first-boot.json')
+        File.open(first_boot, 'w') do |f|
+          f.puts rl.to_json
+        end
+      end
+
+      def run_chef_first_time(name)
+        %x[chroot /var/lib/lxc/#{name}/rootfs /bin/bash -c 'chef-client -j /etc/chef/first-boot.json > /dev/null 2>&1']
+      end
+
+      def run_chef(name)
+        container_path = "/var/lib/lxc/#{name}/rootfs"
+        %x[chroot #{container_path} /bin/bash -c 'chef-client > /dev/null 2>&1']
+      end
+      
+      def upload_databag_item(databag, item)
+        databag_item = ::Chef::DataBagItem.new
+        databag_item.data_bag(databag)
+        databag_item.raw_data = item
+        databag_item.save
+      end
+
+      def create_client_rb(orgname)
+        client_rb = File.join('/var/lib/lxc', name, 'rootfs/etc/chef/client.rb')
+        File.open(client_rb, 'w') do |f|
+          f.puts "log_level        :info"
+          f.puts "log_location     STDOUT"
+          f.puts "chef_server_url  'https://api.opscode.com/organizations/#{orgname}'"
+          f.puts "validation_client_name '#{orgname}-validator'"
+          f.puts "node_name 'cucumber-chef-#{name}'"
+        end
+      end
+      
+      def start_container(name)
+        status = %x[lxc-info -n #{name} 2>&1]
+        if status.include?("STOPPED")
+          %x[lxc-start -d -n #{name}]
+          sleep 5
+        end
+      end
+
+      def stop_container(name)
+        status = %x[lxc-info -n #{name} 2>&1]
+        if status.include?("RUNNING")
+          %x[lxc-destroy -d -n #{name}]
+          sleep 5
+        end
+      end
+
+          def run_remote_command(remote_server, command)
+      %x[ssh workstation.testlab 'ssh #{remote_server} #{command}']
+          end
+
+          
+    end
+  end
+end	

data/lib/cucumber/chef/templates/controller.erb

@@ -0,0 +1,35 @@
+bash -c '
+(
+cat <<EOP
+lxc.network.type = veth
+lxc.network.flags = up
+lxc.network.link = br0
+lxc.network.name = eth0
+lxc.network.ipv4 = 192.168.10.10/24
+EOP
+) > /etc/lxc/controller
+
+lxc-create -n controller -f /etc/lxc/controller -t lucid-chef
+
+(
+cat <<EOP
+
+log_level        :info
+log_location     STDOUT
+chef_server_url  "<%= @config[:chef_server_url] %>"
+validation_client_name "<%= @config[:validation_client_name] %>"
+<% if @config[:chef_node_name] == nil %>
+# Using default node name"
+<% else %>
+node_name "<%= @config[:chef_node_name] %>"
+<% end %>
+EOP
+) > /var/lib/lxc/controller/rootfs/etc/chef/client.rb
+
+cat <<EOP
+{ "run_list": [ "recipe[cucumber-chef::controller]" ] }
+EOP
+) > /var/lib/lxc/controller/rootfs/etc/chef/first-boot.json
+
+chroot /var/lib/lxc/controller/rootfs /bin/bash -c "chef-client -j /etc/chef/first-boot.json > /dev/null 2>&1"
+lxc-start -d -n controller && sleep 5 && lxc-start -d -n controller'

data/lib/cucumber/chef/templates/env.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+require 'rspec/expectations'
+require 'chef'
+require 'cucumber/chef'
+require 'cucumber/nagios/steps'
+require 'cucumber/chef/handy'
+
+class CustomWorld
+  include Cucumber::Chef
+  include Cucumber::Chef::Handy
+end
+
+World do
+  CustomWorld.new
+end

data/lib/cucumber/chef/templates/example_feature.erb

@@ -0,0 +1,11 @@
+Feature: Example feature for <%= @project %>
+  So that I can be learn how to use cucumber-chef
+  As an infrastructure developer
+  I can run an example feature that doesn't do much
+
+Scenario: Example scenario for <%= @project %>
+  Given I have a remote server
+  And I apply the <%= @project %> role/recipe
+  And run Chef
+  When I connect to the remote server from the test server
+  Then the <% @project %> server behaves as it should

data/lib/cucumber/chef/templates/example_step.erb

@@ -0,0 +1,19 @@
+Given /^I have a remote server$/ do
+  pending # express the regexp above with the code you wish you had
+end
+
+Given /^I apply the <%= @project %> role\/recipe$/ do
+  pending # express the regexp above with the code you wish you had
+end
+
+Given /^run Chef$/ do
+  pending # express the regexp above with the code you wish you had
+end
+
+When /^I connect to the remote server from the test server$/ do
+  pending # express the regexp above with the code you wish you had
+end
+
+Then /^the <%= @project %> server behaves as it should$/ do
+  pending # express the regexp above with the code you wish you had
+end

data/lib/cucumber/chef/templates/readme.erb

@@ -0,0 +1,28 @@
+Welcome to the <%= @project %> suite of cucumber-chef tests
+
+Your general workflow will be to write cucumber features that describe the intended behaviour of '<%= @project %>'.  You will then write failing tests by writing steps to test the b$
+
+You will then want to create a '<%= @project %>' cookbook, and write recipes that make your tests pass.  Upload your cookbook to the Opscode Platform, and then push your cucumber-ch$
+
+cucumber-chef upload <%= @project %>
+
+Then run your tests with:
+
+cucumber-chef test <%= @project %>
+
+For an example feature, take a look at ./<%= @project %>/features/example.feature
+
+For an example step definition, look at ./<%= @project %>/features/example.feature
+
+To get started, you'll need to configure cucumber-chef to use your own Opscode Chef platform credentials, and AWS EC2 keys.  You can generate a sample config with:
+
+cucumber-chef genconfig
+
+This will drop a .cucumber-chef config file in the home directory of the user with which you ran the cucumber-chef command.  You'll need to edit the file in order to carry out setup, upload or test functionality.
+
+One you've got a configuration in place, run:
+
+cucumber-chef setup
+
+This will create what we call a 'test lab' in EC2 in which tests will be run.
+

data/lib/cucumber/chef/templates/ubuntu10.04-gems.erb

@@ -0,0 +1,43 @@
+bash -c '
+if [ ! -f /usr/bin/chef-client ]; then
+  apt-get update
+  apt-get install -y ruby ruby1.8-dev build-essential wget libruby-extras libruby1.8-extras
+  cd /tmp
+  wget http://production.cf.rubygems.org/rubygems/rubygems-1.3.7.tgz
+  tar zxf rubygems-1.3.7.tgz
+  cd rubygems-1.3.7
+  ruby setup.rb --no-format-executable
+fi
+gem install ohai chef --no-rdoc --no-ri --verbose <%= '--prerelease' if @config[:prerelease] %>
+
+mkdir -p /etc/chef
+
+(
+cat <<'EOP'
+<%= IO.read(@config[:validation_key]) %>
+EOP
+) > /tmp/validation.pem
+awk NF /tmp/validation.pem > /etc/chef/validation.pem
+rm /tmp/validation.pem
+
+(
+cat <<'EOP'
+log_level        :info
+log_location     STDOUT
+chef_server_url  "<%= @config[:chef_server_url] %>"
+validation_client_name "<%= @config[:validation_client_name] %>"
+<% if @config[:chef_node_name] == nil %>
+# Using default node name"
+<% else %>
+node_name "<%= @config[:chef_node_name] %>"
+<% end %>
+EOP
+) > /etc/chef/client.rb
+
+(
+cat <<'EOP'
+<%= { "run_list" => @run_list }.to_json %>
+EOP
+) > /etc/chef/first-boot.json
+
+/usr/bin/chef-client -j /etc/chef/first-boot.json'

data/lib/cucumber/chef/version.rb

@@ -0,0 +1,5 @@
+module Cucumber
+  module Chef
+    VERSION = '0.0.2'
+  end
+end

data/lib/cucumber/ec2_server_create.rb

@@ -0,0 +1,99 @@
+require 'fog'
+require 'socket'
+require 'chef/knife'
+require 'chef/knife/bootstrap'
+require 'chef/json_compat'
+
+class Chef
+  class Knife
+    class Ec2ServerCreate < Knife
+
+      attr_accessor :initial_sleep_delay
+
+      def tcp_test_ssh(hostname)
+        tcp_socket = TCPSocket.new(hostname, 22)
+        readable = IO.select([tcp_socket], nil, nil, 5)
+        if readable
+          Chef::Log.debug("sshd accepting connections on #{hostname}, banner is #{tcp_socket.gets}")
+          yield
+          true
+        else
+          false
+        end
+      rescue Errno::ETIMEDOUT
+        false
+      rescue Errno::ECONNREFUSED
+        sleep 2
+        false
+      ensure
+        tcp_socket && tcp_socket.close
+      end
+
+      def run
+        require 'fog'
+        require 'highline'
+        require 'net/ssh/multi'
+        require 'readline'
+
+        $stdout.sync = true
+
+        connection = Fog::Compute.new(
+                                      :provider => 'AWS',
+                                      :aws_access_key_id => Chef::Config[:knife][:aws_access_key_id],
+                                      :aws_secret_access_key => Chef::Config[:knife][:aws_secret_access_key],
+                                      :region => #REGION
+                                      )
+
+        # WHAT IS THIS FOR?
+        ami = connection.images.get(locate_config_value(:image))
+
+        server_def = {
+        :image_id => locate_config_value(:image),
+        :groups => config[:security_groups],
+        :flavor_id => locate_config_value(:flavor),
+        :key_name => Chef::Config[:knife][:aws_ssh_key_id],
+        :availability_zone => Chef::Config[:knife][:availability_zone]
+      }
+
+      server = connection.servers.create(server_def)
+
+      puts "Instance ID: #{server.id}"
+      print "\n#{h.color("Waiting for server", :magenta)}"
+
+      # wait for it to be ready to do stuff
+      server.wait_for { print "."; ready? }
+
+      puts("\n")
+
+      puts "Public IP Address #{server.public_ip_address}"
+      
+      print "\n#{h.color("Waiting for sshd", :magenta)}"
+
+      print(".") until tcp_test_ssh(server.dns_name) { sleep @initial_sleep_delay ||= 10; puts("done") }
+
+      bootstrap_for_node(server).run
+
+    end
+
+    def bootstrap_for_node(server)
+      bootstrap = Chef::Knife::Bootstrap.new
+      bootstrap.name_args = [server.dns_name]
+      bootstrap.config[:run_list] = config[:run_list]
+      bootstrap.config[:ssh_user] = config[:ssh_user]
+      bootstrap.config[:identity_file] = config[:identity_file]
+      bootstrap.config[:chef_node_name] = config[:chef_node_name] || server.id
+      bootstrap.config[:prerelease] = config[:prerelease]
+      bootstrap.config[:distro] = locate_config_value(:distro)
+      bootstrap.config[:use_sudo] = true
+      bootstrap.config[:template_file] = locate_config_value(:template_file)
+      bootstrap.config[:environment] = config[:environment]
+      bootstrap
+    end
+
+    def locate_config_value(key)
+      key = key.to_sym
+      Chef::Config[:knife][key] || config[key]
+    end
+  end
+end
+end

data/spec/unit/cucumber_chef_spec.rb

@@ -0,0 +1,270 @@
+require "rubygems"
+require "bundler/setup"
+require File.join(File.dirname(__FILE__), "../../lib/cucumber-chef")
+
+def tcp_test_ssh(hostname)
+  tcp_socket = TCPSocket.new(hostname, 22)
+  IO.select([tcp_socket], nil, nil, 5)
+rescue Errno::ETIMEDOUT
+  false
+rescue Errno::EPERM
+  false
+rescue Errno::ECONNREFUSED
+  sleep 2
+  false
+  # This happens on EC2 quite often
+rescue Errno::EHOSTUNREACH
+  sleep 2
+  false
+ensure
+  tcp_socket && tcp_socket.close
+end
+
+describe Cucumber::Chef::Config do
+  describe "when configuration is missing" do
+    it "should raise if it cannot find a configuration" do
+      begin
+        chef_dir = File.expand_path("~/.chef")
+        config_file = File.join(chef_dir, "knife.rb")
+        FileUtils.mv(config_file, File.join(chef_dir, "knife.rb.bak"))
+        expect { subject.config }.to raise_error(Cucumber::Chef::ConfigError)
+      ensure
+        FileUtils.mv(File.join(chef_dir, "knife.rb.bak"), config_file)
+      end
+    end
+  end
+  
+  describe "when configuration is invalid" do
+    config_dir = File.join(File.dirname(__FILE__), "../../.chef")
+    
+    before(:all) { FileUtils.mkdir_p(config_dir) }
+    after(:all) { FileUtils.rm_rf(config_dir) }
+
+    it "should complain about missing keys" do
+      config = "node_name ''"
+      File.open(Pathname(config_dir) + "knife.rb", 'w') { |f| f.puts config }
+      values, missing_keys = subject.display
+      missing_keys.should include("node_name")
+      missing_keys.should include("knife[:aws_access_key_id]")
+    end
+  end
+
+  describe "when configuration is valid" do
+    it "should find the configuration" do
+      values, missing_keys = subject.display
+      missing_keys.should be_empty
+    end
+
+    it "should display the configuration values" do
+      values, missing_keys = subject.display
+      output = values.join("\n")
+      output.should match(/node_name:/)
+      output.should match(/knife\[:aws_secret_access_key\]:/)
+    end
+  end
+end
+
+describe Cucumber::Chef::Provisioner do
+  before(:all) do
+    @config = subject.config
+    @config[:mode] = "test"
+  end
+
+  describe "verify_opscode_platform_credentials" do
+    describe "when configuration is invalid" do
+      config_dir = File.join(File.dirname(__FILE__), "../../.chef")
+      knife_file = File.join(config_dir, "knife.rb")
+    
+      before(:all) do
+        FileUtils.mkdir_p(config_dir)
+      end
+
+      after(:all) do
+        FileUtils.rm_rf(config_dir)
+      end
+    
+      describe "when node name is missing" do
+        it "should raise" do
+          config = "node_name ''"
+          File.open(knife_file, 'w') { |f| f.puts config }
+          expect {
+            subject.verify_opscode_platform_credentials(subject.config)
+          }.to raise_error(Cucumber::Chef::ProvisionerError)
+        end
+      end
+      
+      describe "when node name is invalid" do
+        it "should raise" do
+          config = "node_name 'REALLYBOGUSORGNAME'"
+          File.open(knife_file, 'w') { |f| f.puts config }
+          expect {
+            subject.verify_opscode_platform_credentials(subject.config)
+          }.to raise_error(Cucumber::Chef::ProvisionerError)
+        end
+      end
+    end
+
+    describe "when configuration is valid" do
+      it "should not raise" do
+        subject.verify_opscode_platform_credentials(subject.config)
+      end
+    end
+  end
+
+  describe "verify_aws_credentials" do
+    describe "when configuration is invalid" do
+      config_dir = File.join(File.dirname(__FILE__), "../../.chef")
+      knife_file = File.join(config_dir, "knife.rb")
+    
+      before(:all) do
+        FileUtils.mkdir_p(config_dir)
+      end
+
+      after(:all) do
+        FileUtils.rm_rf(config_dir)
+      end
+    
+      describe "when configuration is invalid" do
+        it "should raise" do
+          config = "knife[:aws_access_key_id] = ''"
+          File.open(knife_file, 'w') { |f| f.puts config }
+          expect {
+            subject.verify_aws_credentials(subject.config)
+          }.to raise_error(Cucumber::Chef::ProvisionerError)
+        end
+      end
+    end
+
+    describe "when configuration is valid" do
+      it "should not raise" do
+        subject.verify_aws_credentials(subject.config)
+      end
+    end
+  end
+
+  describe "build_test_lab" do
+    after(:each) do
+      config = @config[:knife]
+      connection = Fog::Compute.new(:provider => 'AWS',
+                                    :aws_access_key_id => config[:aws_access_key_id],
+                                    :aws_secret_access_key => config[:aws_secret_access_key],
+                                    :region => config[:region])
+      connection.servers.each do |s|
+        s.destroy if s.tags['cucumber-chef'] == 'test' && s.state == 'running'
+      end
+    end
+    
+    it "should spin up a ec2 instance", :slow => true do
+      output = StringIO.new
+      subject.build_test_lab(@config, output)
+      output.rewind
+      output.read.should match(/Platform provisioned/)
+    end
+
+    it "should only spin up one ec2 instance", :slow => true do
+      subject.build_test_lab(@config, StringIO.new)
+      expect {
+        subject.build_test_lab(@config, StringIO.new)
+      }.to raise_error(Cucumber::Chef::ProvisionerError)
+    end
+  end
+
+  describe "upload_cookbook" do
+    before(:each) do
+      begin
+        cookbook_path = File.expand_path("cookbooks/cucumber-chef")
+        version_loader = ::Chef::Cookbook::CookbookVersionLoader.new(cookbook_path)
+        version_loader.load_cookbooks
+        version = version_loader.cookbook_version
+        version.destroy
+      rescue Net::HTTPServerException => err
+      end
+    end
+
+    it "should upload the cucumber-chef cookbook" do
+      subject.upload_cookbook(@config)
+      ::Chef::CookbookVersion.list["cucumber-chef"].should be
+    end
+  end
+
+  describe "upload_role" do
+    before(:each) do
+      begin
+        role_path = File.expand_path("cookbooks/cucumber-chef/roles")
+        ::Chef::Config[:role_path] = role_path
+        role = ::Chef::Role.from_disk("test_lab_test")
+        role.destroy
+      rescue Net::HTTPServerException => err
+      end
+    end
+
+    it "should upload the test_lab role" do
+      subject.upload_role(@config)
+      ::Chef::Role.list["test_lab_test"].should be
+    end
+  end
+
+  describe "bootstrap_node" do
+    before(:each) do
+      server = subject.build_test_lab(@config, StringIO.new)
+      @dns_name = server.dns_name
+      puts "Hanging around..." until tcp_test_ssh(server.public_ip_address)
+      puts "Got ssh..."
+      sleep(10)
+      subject.upload_cookbook(@config)
+      subject.upload_role(@config)
+    end
+    
+    after(:each) do
+      config = @config[:knife]
+      connection = Fog::Compute.new(:provider => 'AWS',
+                                    :aws_access_key_id => config[:aws_access_key_id],
+                                    :aws_secret_access_key => config[:aws_secret_access_key],
+                                    :region => config[:region])
+      connection.servers.each do |s|
+        s.destroy if s.tags['cucumber-chef'] == 'test' && s.state == 'running'
+      end
+    end
+
+    it "should set up platform as a chef client and apply test-lab role" do
+      bootstrapper = subject.bootstrap_node(@dns_name, @config)
+      bootstrapper.run
+      # DEBUG: puts bootstrapper.ui.stdout.string
+      node = ::Chef::Node.load("cucumber-chef-test-lab")
+      node.run_list.to_s.should match(/role\[test_lab_test\]/)
+    end
+  end
+
+  describe "build_controller" do
+
+    before(:each) do
+      server = subject.build_test_lab(@config, StringIO.new)
+      @dns_name = server.dns_name
+      puts "Hanging around..." until tcp_test_ssh(server.public_ip_address)
+      puts "Got ssh..."
+      sleep(10)
+      subject.upload_cookbook(@config)
+      subject.upload_role(@config)
+      subject.bootstrap_node(@dns_name, @config).run
+    end
+    
+    after(:each) do
+      config = @config[:knife]
+      connection = Fog::Compute.new(:provider => 'AWS',
+                                    :aws_access_key_id => config[:aws_access_key_id],
+                                    :aws_secret_access_key => config[:aws_secret_access_key],
+                                    :region => config[:region])
+      connection.servers.each do |s|
+        s.destroy if s.tags['cucumber-chef'] == 'test' && s.state == 'running'
+      end
+    end
+
+    it "should build a cucumber-chef controller" do
+      controller_builder = subject.build_controller(@dns_name, @config)
+      controller_builder.run
+      puts controller_builder.ui.stdout.string
+    end
+
+  end
+
+end