cucumber-chef 0.4.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.gitignore

@@ -0,0 +1,45 @@
+# rcov generated
+coverage
+
+# rdoc generated
+rdoc
+
+# yard generated
+doc
+.yardoc
+
+# bundler
+.bundle
+Gemfile.lock
+
+# jeweler generated
+pkg
+*.gem
+
+
+# Have editor/IDE/OS specific files you need to ignore? Consider using a global gitignore: 
+#
+# * Create a file at ~/.gitignore
+# * Include files you want ignored
+# * Run: git config --global core.excludesfile ~/.gitignore
+#
+# After doing this, these files will be ignored in all your git projects,
+# saving you from having to 'pollute' every project you touch with them
+#
+# Not sure what to needs to be ignored for particular editors/OSes? Here's some ideas to get you started. (Remember, remove the leading # of the line)
+#
+# For MacOS:
+#
+#.DS_Store
+#
+# For TextMate
+#*.tmproj
+#tmtags
+#
+# For emacs:
+*~
+\#*
+.\#*
+
+# For vim:
+*.swp

data/Gemfile

@@ -0,0 +1,21 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+
+gem "chef", ">= 0.10.0"
+gem "cucumber", ">= 0"
+gem "cucumber-nagios", ">= 0"
+gem "rspec", ">= 0"
+gem "fog", ">= 0"
+gem "thor", ">= 0"
+gem "awesome_print", ">= 0"
+
+group :development do
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.6.2"
+  gem "rcov", ">= 0"
+end

data/LICENSE

@@ -0,0 +1,201 @@
+Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+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.

data/README.md

@@ -0,0 +1,83 @@
+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 lightweight virtual machines, configure them by applying the appriporaite Chef roles to them, and then run acceptance and integration tests against the environment.
+
+## Installation 
+
+Cucumber-chef is distributed as a gem.  Until it's published on Rubygems, you'll need to build the gem yourself.  Check the project out, and then build and install the gem.
+
+First ensure you have bundler available, and then run:
+
+    $ bundle install
+
+Cucumber-chef uses Jeweler (see https://github.com/technicalpickles/jeweler) for managing gem builds , publishing and dependencies.  To build the gem simply run:
+
+    $ rake build
+
+This will result in the gem appearing in pkg/.  Install it:
+
+    $ gem install pkg/cucumber-chef-0.0.4.gem
+
+## Overview
+
+Cucumber-chef begins with a very simple premise.  If we are framing our infratructure as code - if we're writing cookbooks, recipes and other pieces of automation in a high level programming language, such as Ruby, then it makes sense to follow the current wisdom across the software development world to maximise the quality, maintainability and reusability of our code, providing maximum chance that we'll deliver value with it.  One area which has been shown to have a very positive effect is the practive of 'test-driven' development.  In this paradigm, the developer begins by writing a test that captures the intended behaviour of the code  they are going to write.  This test will start out by failing.  The developer then writes code to make the test pass, and iterates thereafter.  
+
+Cucumber-chef provides a framework to make it easier to do test-driven development for infrastructure.
+
+### Vocabulary
+
+Throughout this documentation, a few terms will crop up regularly.  It makes sense to define these up front, as they're just terms we've been using since we started writing cucumber-chef.  They may even change, but in the meantime, so we're all n the same page, here are some of the terms we use:
+
+* Test Lab: An environment made up (at present) of an EC2 instance, configured to be an LXC host.  This machine does nothing other than provide space in which Linux containers can be created and destroyed.
+* Controller: One special Linux container which acts as the central point from which tests are run.  This machine is where the tests run, and has connectivity and credentials to connect to the machines that are created as part of a test run.
+* Container: A container is a lightweight virtual machine - it is entirely self-contained, with its own process tree, resource constraints, filesystem and network stack.  It shares a kernel with the Test Lab host server.
+
+## Getting started
+
+Cucumber-chef is tightly integrated with Chef - it uses your knife.rb for credentials, and any cucumber-chef-specific configuration goes in knife.rb under the cucumber-chef namespace.
+
+On installation, the first thing you should do is run:
+
+    $ cucumber-chef displayconfig
+
+This will look for your knife.rb, and extract the relevant sections, check them, and display them on the screen.  If any entries are missing, it will alert you.
+
+The current recommendation is to keep your knife.rb inside your organisation's chef repository, in .chef, and use environment variables to specify username, organisation name and cloud provider credentials.  Cucumber-chef supports and encourages this approach.  It will search for a directory called .chef in your current directory, and then carry on going up the directory tree until it finds one.  In practice this means that if you stay within the chef-repo directory for the organisation on which you're working, cucumber-chef will use the knife.rb; if your elsewhere in the filesystem rooted in your home directory, and have .chef in your home directory, cucumber-chef will use that.  Otherwise you'll need to either change into a directory where a .chef can be found, or copy, creatre or link accordingly.  In most cases we anticipate that you'll be inside the chef-repo of your organisation, and the documentation is written from this perspective.
+
+In its current incarnation, cucumber-chef makes two important assumptions.  Firstly, we assume you're using the Opscode platform rather than your own Chef server.  Secondly, we assume that you are comfortable with using Amazon's EC2 service for providing the 'bare metal' on which we set up the test lab.  Future releases may well allow you to use your own Chef server, and will definitely look at offering alternative cloud providers.  In the meantime, we welcome patches and pull requests!
+
+Set your environment variables:
+
+    $ export OPSCODE_USER=platform_user_name
+    $ export ORGNAME=platform_organisation
+    $ export AWS_ACCESS_KEY_ID=SEKRITKEY
+    $ export AWS_SECRET_ACCESS_KEY=REELYSEKRITKEY
+
+Now check your config again, with cucumber-chef display config.  If you get no complaints, you're ready to set up a test lab.
+
+    $ cucumber-chef setup
+
+This command will set up a complete test lab environment, including a controller.  As long as you've provided valid AWS and Opscode credentials, it will do this automatically.  The process takes about 12 minutes, after which you'll have a fully cuntioning platform available for you to use.
+
+The next stage is to set up a project.  A project is simply a directory structure for containing your cucumber features and steps, already set up with an appropriate environment to make use of the step definitions provided with cucumber-chef.  We think it makes most sense to have this in your organisation's chef repo.  Cucumber-chef provides a task which will create a the directory for you, and populate it with a README and an example feature and step.
+
+    $ cucumber-chef project someproject
+
+**TO DO: fix this....**
+
+## Writing tests
+
+Once you've got your test lab set up, and you've generated a project, it's time to crack on with writing a test.  The basic idea is this:
+
+1) An infrastructure requirement is established
+2) Write a cucumber feature that expresses the required behaviour of the infrastructure requirement
+3) Write steps that will build this infrastructure environment on the test lab, using the step definitions provided - these include the ability to create a container, apply roles to it, and destroy it again.
+4) Write cookbooks and recipes and supporting code to make the test pass
+
+## Running tests
+
+You can write the tests and Chef code wherever you like.  We're assuming you prefer working on your local machine, and checking into version control.  But we don't really care.  When it's time to run tests, cucumber-chef provides a task which handles this:
+
+    $ cucumber-chef test myproject
+
+At the moment cucumber-chef doesn't pass though clever filtering and tagging options that cucumber supports - you run all te tests.  We're going to improve that soon, again, patches and pull requests very welcome.
+
+Running the test task will upload your current project to the controller, and run the tests.

data/Rakefile

@@ -0,0 +1,53 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "cucumber-chef"
+  gem.homepage = "http://github.com/atalanta/cucumber-chef"
+  gem.license = "MIT"
+  gem.summary = "Tests Chef-built infrastructure"
+  gem.description = "Framework for behaviour-drive infrastructure development."
+  gem.email = "stephen@atalanta-systems.com"
+  gem.authors = ["Stephen Nelson-Smith"]
+  gem.has_rdoc = false
+  gem.bindir = "bin"
+  gem.files = `git ls-files`.split("\n")
+  gem.executables = %w(cucumber-chef)
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+require 'rcov/rcovtask'
+Rcov::RcovTask.new do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "cucumber-chef #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.4.0

data/bin/cucumber-chef

@@ -0,0 +1,162 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'thor'
+require 'pathname'
+require 'fileutils'
+require 'yaml'
+require 'awesome_print'
+require 'chef'
+require 'chef/knife'
+require 'chef/knife/bootstrap'
+require 'chef/knife/ssh'
+require 'socket'
+require 'net/ssh/multi'
+require 'readline'
+require 'stringio'
+
+$LOAD_PATH << File.join(File.dirname(__FILE__), '../lib')
+require 'cucumber-chef'
+
+GEM_DIR = Gem.default_dir
+
+class CucumberChef < Thor
+  include Thor::Actions
+  
+  def self.source_root
+    File.dirname(__FILE__)
+  end
+
+  def initialize(args = [], options = {}, config = {})
+    @provisioner = ::Cucumber::Chef::Provisioner.new
+    super(args, options, config)
+  end
+
+  no_tasks do
+    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
+
+    def get_latest_version
+      installed_versions = []
+      Gem::source_index.find_name('cucumber-chef').map do |g|
+        version = g.version.version
+        if version == ""
+          version = "0"
+        end
+        installed_versions << version
+      end
+      version = installed_versions.sort { |a, b| a.to_i <=> b.to_i }.last
+      if version == "0"
+        version = ""
+      end
+      return "cucumber-chef-" + version
+    end
+
+    def create_directory_structure(project_dir)
+      %w{step_definitions support}.each do |dir|
+        FileUtils.mkdir_p(project_dir + "features" + dir)
+      end
+    end
+    
+    def generate_project_skeleton(project_dir)
+      template_dir = self.gem_root + 'lib' + 'cucumber' + 'chef' + 'templates'
+      templates = {
+        "readme.erb" => 'README',
+        "example_feature.erb" => 'features/example.feature',
+        "example_step.erb" => 'features/step_definitions/example_step.rb',
+        "env.rb" => "features/support/env.rb"
+      }
+      templates.each do |filename, destination|
+        template((template_dir + filename).realpath,
+                 project_dir + destination)
+      end
+    end
+    
+    def gem_root
+      Pathname.new(__FILE__).parent.parent
+    end
+
+    def error(message)
+      warn message
+      exit 255
+    end
+
+    def find_knife_config
+      @provisioner.config
+    rescue ::Cucumber::Chef::ProvisionerError => err
+      error(err.message)
+    end
+  end
+  
+  desc "project <project name>" , "Create a project template for testing an infrastructure"
+  def project(project_name)
+    @project = project_name
+    project_dir = Pathname.new(".") + "cucumber-chef" + @project
+    create_directory_structure(project_dir)
+    generate_project_skeleton(project_dir)
+  end
+  
+  desc "setup", "Set up a cucumber-chef test lab in Amazon EC2"
+  method_option :test, :type  => :boolean
+  def setup
+    begin
+      config = find_knife_config
+      if options.test?
+        config[:mode] = "test"
+      else
+        config[:mode] = "user"
+      end
+      @provisioner.verify_opscode_platform_credentials(config)
+      @provisioner.verify_aws_credentials(config)
+      $stdout.sync
+      server = @provisioner.build_test_lab(config, $stdout)
+      sleep(10)
+      @provisioner.upload_cookbook(config)
+      @provisioner.upload_role(config)
+      @provisioner.bootstrap_node(server.dns_name, config).run
+    rescue ::Cucumber::Chef::ProvisionerError => err
+      error(err.message)
+    end
+  end
+
+  desc "displayconfig", "Display the current config from knife.rb"
+  def displayconfig
+    values, missing_keys = Cucumber::Chef::Config.new.display
+    puts values.join("\n")
+    if missing_keys.size > 0
+      error("Incomplete config file, please specify: #{missing_keys.join(", ")}")
+    end
+  rescue ::Cucumber::Chef::ProvisionerError => err
+    error(err.message)
+  end
+  
+  desc "upload", "Upload a cucumber-chef test suite to the test lab platform"
+  def upload
+    puts "Project uploaded to the test-lab."
+  end
+
+  desc "test", "Run a cucumber-chef test suite from a workstation."
+  def test
+    puts "Running test..."
+    puts
+    puts "Test results will appear here."
+  end
+  
+  
+end
+CucumberChef.start