chef-workflow-testlib 0.1.0

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.chef-workflow
+html

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in chef-workflow-testlib.gemspec
+gemspec
+
+if ENV["ERIKH_LOCAL"]
+  gem 'chef-workflow', :path => '~/repos/ht/chef-workflow'
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Erik Hollensbe
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,316 @@
+# Chef Workflow - Test Libraries and Tooling
+
+This gem provides a set of libraries to drive
+[minitest](https://github.com/seattlerb/minitest) integration for a number of things:
+
+1. spawning whole networks of machines
+2. testing their converge successes
+3. testing interoperability between machines
+4. testing advanced functionality in chef, like search.
+
+**It is not intended for testing individual cookbooks.** The default
+provisioning systems expect roles, for example, but it's a different tool for a
+different problem. If you want to verify your open-source cookbooks against a
+variety of environments, I strongly suggest you look at
+[test-kitchen](https://github.com/opscode/test-kitchen), which is intended to
+solve this problem.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'chef-workflow-testlib'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install chef-workflow-testlib
+
+## Quick Start
+
+The easiest way to get started is to integrate
+[chef-workflow-tasklib](https://github.com/chef-workflow/chef-workflow-tasklib)
+into your environment. This has a number of benefits, such as working within
+the same system to control machine provisioning, building a chef server,
+uploading your repository to a chef server, several options for driving tests,
+and so on. Once you've set that up, use the instructions over there to build a
+test chef server.
+
+So, after you've done that go ahead and create a `test` directory at the root
+of your repository. Inside that, create a `test_mytest.rb` that provisions a
+few machines and performs a search on them. This actually doesn't have much
+real-world application, but it'll get you familiar with the workflow.
+
+You will need some working roles to perform this test. We'll name these roles
+`my_role` and `my_other_role` in the example, but you'll need to replace them
+with roles you actually use.
+
+This test will use `vagrant` to provision your machines, bootstrap them with
+knife, then run your tests. After it's done, it will tear those machines down.
+If the nodes fail to come up for any reason, your test should yield an error
+and deprovision the machines.
+
+```ruby
+require 'chef-workflow/helper'
+class MyTest < MiniTest::Unit::VagrantTestCase
+  def self.before_suite
+    provision('my_role')
+    provision('my_other_role')
+    wait_for('my_role')
+    wait_for('my_other_role')
+  end
+
+  def self.after_suite
+    deprovision('my_role')
+    deprovision('my_other_role')
+  end
+
+  def test_searching_one
+    assert_search_count(:node, 'roles:my_role', 1)
+  end
+
+  def test_searching_two
+    assert_search_count(:node, 'roles:my_other_role', 1)
+  end
+end
+```
+
+Then run your test suite with `bundle exec rake test:build`, which will perform
+an upload of your repository to the test chef server, and run your tests.
+
+We're quite aware this takes a while to run, and does very little. There are a
+couple of ways to deal with this, but involve understanding the system a little
+more; something we're about to cover.
+
+## Dealing with Slow
+
+Ok, so we got our test suite off the ground, and boy do those tests take a
+while to run. I have two bits of good news for you:
+
+You aren't locked into using Vagrant, and while Vagrant has limitations which
+make it impossible to parallelize, machine provisions don't have to be serial.
+EC2 support allows you to provision many machines in parallel, which can
+improve run time. The provisioning system is also flexible enough to support
+other systems too, so if you'd like to see your favorite system get some love,
+the best way to do so is to file an issue or pull request.
+
+The second is that in most scenarios, you have a few servers that you don't
+really care about for this test, but need to be available for the machine to
+function or converge properly, like a DNS or syslog server. All provisioning is
+tracked and the state information is actually written to disk in your
+`.chef-workflow` directory.  What that means is that if you don't need to
+rebuild your machines, you don't actually have to until you're ready to.
+
+### State Management with MiniTest Subclasses
+
+Let's start off easy. Take our example above, and remove the deprovisioning
+lines in the `after_suite` call:
+
+```ruby
+require 'chef-workflow/helper'
+class MyTest < MiniTest::Unit::VagrantTestCase
+  def self.before_suite
+    provision('my_role')
+    provision('my_other_role')
+    wait_for('my_role')
+    wait_for('my_other_role')
+  end
+
+  def self.after_suite
+    # omg, where did they go?
+  end
+
+  def test_searching_one
+    assert_search_count(:node, 'roles:my_role', 1)
+  end
+
+  def test_searching_two
+    assert_search_count(:node, 'roles:my_other_role', 1)
+  end
+end
+```
+
+And run your tests again. Go ahead, run them twice. The second time should be
+pretty quick, in the order of a second or so. This is because your machines
+weren't provisioned the second time; the system determined they were already
+built and didn't have to provision them again.
+
+So how do we clean them up? `bundle exec rake chef:clean:machines`, or add our
+deprovisioning lines back in and run the suite again. The state for a provision
+lasts until the machine is deprovisioned, whether or not that's the same test
+run. The rake task just reaps everything except for your chef server.
+
+Now that we've seen the obvious performance increase, what is this good for?
+
+### Pre-baking essential infra with MiniTest subclasses
+
+MiniTest (and all SUnit alikes) leverage subclassing pretty heavily when done
+right to manage a common set of test dependencies. For example, we have a
+subclass called 'WithInfra' in our test suite that looks like this:
+
+```ruby
+class MiniTest::Unit::VagrantTestCase::WithInfra < MiniTest::Unit::VagrantTestCase
+  include SSHHelper
+
+  def self.before_suite
+    super
+
+    provision('bind_master')
+    provision('syslog_server')
+
+    wait_for('bind_master', 'syslog_server')
+
+    ssh_role_command('bind_master', 'chef-client')
+    ssh_role_command('syslog_server', 'chef-client')
+  end
+end
+```
+
+`SSHHelper` is a small mixin that provides `ssh_role_command` and other bits of
+ssh-related functionality. In this case, our syslog depends on working DNS and
+our BIND depends on working syslog; while they have cookbooks that are smart
+enough to walk past those dependencies in the first chef run, once they're both
+up converging them again will resolve each other and configure them
+appropriately.
+
+The good news is that we don't have to (but can) tear these servers down during
+a run or even between runs if they're not causing problems, and you can always
+check from a fresh provision by running the `chef:clean:machines` task before
+`test`, or simply `test:rebuild`, which does a full deprovision, repository
+upload, and test run. This saves you time (and money, in the EC2 case) and
+still gives you a way to do a "full" run without a lot of extra work.
+
+An actual test suite that uses this looks like this:
+
+```ruby
+class TestBIND < MiniTest::Unit::VagrantTestCase::WithInfra
+  def self.before_suite 
+    provision('bind_slave', 1, %w[bind_master syslog_server])
+    wait_for('bind_slave')
+  end
+
+  def test_something
+    # maybe a test that nsupdates the master and ensures it made it to slave
+    # could go here
+  end
+
+  def self.after_suite
+    deprovision('bind_slave') 
+  end
+end
+```
+
+This test when run will create, test, and destroy the bind slave, but leave the
+master and the syslog server alone -- something that we will undoubtedly need
+for the next test case.
+
+### Dependency-based Provisioning
+
+All provisions have a dependency list. Until they are satisfied, the stated
+provision will not happen. This is mostly noticable in threaded provisioning
+mode where multiple provisions can occur at once.
+
+To wait for a specific machine to provision before continuing the test process,
+use the `wait_for` method.
+
+We can see this in our example above:
+
+```ruby
+  def self.before_suite 
+    provision('bind_slave', 1, %w[bind_master syslog_server])
+    wait_for('bind_slave')
+  end
+```
+
+In this instance, a `bind_slave` provision is scheduled, which depends on the
+`bind_master` and `syslog_server` provisions. The `wait_for` statement is used
+to control the test flow, so that it does not continue before `bind_slave`
+provisions, which is what we want to actually test in this test case. Properly
+used, this can enhance provisioning times by letting the scheduler provision
+things as soon as they are capable of being provisioned, where you just care
+about the servers you wish to test at any given point, instead of having to
+manage this problem yourself.
+
+You can't declare provisions that are dependent on provisions that don't exist
+-- this will raise an exception. So, don't worry about fat-fingering it. :)
+
+Here's a more advanced example that abuses the performance characteristics of the
+scheduler. In this instance, we intend to test our monitoring system, which
+will assert the "alive" status of many servers. We provision numerous ones in
+the setup, and only wait for what we care about in each unit test.
+
+```ruby
+class TestNagios < MiniTest::Unit::VagrantTestCase
+  def self.before_suite
+    provision('syslog_server')
+    provision('bind_master', 1, %w[syslog_server])
+    # we just care about bind for all these
+    provision('bind_slave', 1, %w[bind_master])
+    provision('web_server', 1, %w[bind_master])
+    provision('db_server', 1, %w[bind_master])
+    provision('nagios_server', 1, %w[bind_master])
+    # we need the nagios server available for all tests, so wait for that
+    wait_for('nagios_server')
+  end
+
+  def test_dns_monitoring
+    wait_for('bind_master', 'bind_slave')
+    # ensure monitoring works
+  end
+
+  def test_web_monitoring
+    wait_for('web_server')
+    # ensure monitoring works
+  end
+
+  def test_db_monitoring
+    wait_for('db_server')
+    # ensure monitoring works
+  end
+
+  def self.after_suite
+    %w[
+        bind_master 
+        bind_slave 
+        syslog_server 
+        web_server 
+        db_server 
+        nagios_server
+    ].each { |x| deprovision(x) }
+  end
+end
+```
+
+The flow of this test is as such:
+
+As soon as `bind_master` completes, `bind_slave`, `web_server`, `db_server`,
+and `nagios_server` will begin provisioning. `setup` will wait until
+`nagios_server` completes, and normal testing will begin. Each test waits for
+its testable unit to finish provisioning before running the actual tests
+against those units. With rare exception, after a test or two, the `wait_for`
+commands will succeed immediately, largely because they have been provsioning
+in the background while the other tests have been running.
+
+If you're curious how all this works under the hood, see the
+[chef-workflow](https://github.com/chef-workflow/chef-workflow) documentation on
+the subject.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+6. Adjustment of the license terms or the author credits will result in a
+   rejected pull request. It ain't cool, yo.
+
+## Authors
+
+This work was partially sponsored by [HotelTonight](http://hoteltonight.com),
+and you should check them out. They use this system for testing their
+infrastructure. The programming was done primarily by [Erik
+Hollensbe](https://github.com/erikh).

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+
+require 'rdoc/task'
+
+RDoc::Task.new do |r|
+  r.main = "README.md"
+  r.rdoc_files.include(r.main, "LICENSE.txt", "lib/**/*.rb")
+  r.options << "--all"
+end

data/chef-workflow-testlib.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'chef-workflow-testlib/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "chef-workflow-testlib"
+  gem.version       = Chef::Workflow::Testlib::VERSION
+  gem.authors       = ["Erik Hollensbe"]
+  gem.email         = ["erik+github@hollensbe.org"]
+  gem.description   = %q{Test helpers and assertions for chef-workflow}
+  gem.summary       = %q{Test helpers and assertions for chef-workflow}
+  gem.homepage      = "https://github.com/chef-workflow/chef-workflow-testlib"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency 'chef-workflow', '~> 0.1.0'
+  gem.add_dependency 'minitest', '~> 4.3.0'
+  gem.add_dependency 'net-ssh', '~> 2.6.0'
+
+  gem.add_development_dependency 'rdoc'
+  gem.add_development_dependency 'rake'
+end

data/lib/chef-workflow/helper.rb

@@ -0,0 +1,12 @@
+require 'chef-workflow'
+require 'chef-workflow/helpers/minitest'
+require 'chef-workflow/test-case/ec2'
+require 'chef-workflow/test-case/vagrant'
+require 'minitest/unit'
+
+class MiniTest::Unit::TestCase
+  include MiniTest::Assertions::RemoteChef
+end
+
+require 'chef-workflow/runner/provisioned'
+require 'minitest/autorun'

data/lib/chef-workflow/helpers/chef.rb

@@ -0,0 +1,15 @@
+require 'chef/search/query'
+require 'chef/config'
+
+#
+# Small helper library, intended to be mixed into others that provides short
+# helpers for doing complicated things with the Chef API.
+#
+module ChefHelper
+  #
+  # Perform a search and return the names of the nodes that match the search.
+  #
+  def perform_search(type, query)
+    Chef::Search::Query.new.search(type, query).first.map(&:name)
+  end
+end

data/lib/chef-workflow/helpers/minitest.rb

@@ -0,0 +1,39 @@
+require 'chef-workflow/helpers/chef'
+require 'minitest/unit'
+
+#
+# Small assertion library for minitest to assist with remote chef tests.
+#
+module MiniTest::Assertions::RemoteChef
+  include ChefHelper
+
+  #
+  # Assert that a search included the node names.
+  #
+  def assert_search(type, query, node_names)
+    assert_equal(node_names.sort, perform_search(type, query).sort)
+  end
+
+  #
+  # Refute that a search included the node names.
+  #
+  def refute_search(type, query, node_names)
+    refute_equal(node_names.sort, perform_search(type, query).sort)
+  end
+
+  #
+  # Assert the search included `count` elements. Does not verify what that
+  # count is of.
+  #
+  def assert_search_count(type, query, count)
+    assert_equal(count, perform_search(type, query).count)
+  end
+
+  #
+  # Refute the search included `count` elements. Does not verify what that
+  # count is of.
+  #
+  def refute_search_count(type, query, count)
+    refute_equal(count, perform_search(type, query).count) 
+  end
+end

data/lib/chef-workflow/helpers/provision.rb

@@ -0,0 +1,36 @@
+require 'chef-workflow/support/scheduler'
+
+$SCHEDULER ||= Scheduler.new
+
+#
+# Helper for provisioning. Intended to be instanced and assigned to the
+# provision_helper attribute of a ProvisionedTestCase.
+#
+# All methods except `provision`, which is shorthand, are passed directly to
+# the scheduler.
+#
+class ProvisionHelper
+  def schedule_provision(*args)
+    $SCHEDULER.schedule_provision(*args)
+  end
+
+  def deprovision(group_name)
+    $SCHEDULER.deprovision_group(group_name)
+  end
+  
+  def wait_for(*args)
+    $SCHEDULER.wait_for(*args)
+  end
+
+  def serial=(arg)
+    $SCHEDULER.serial = arg
+  end
+
+  def run
+    $SCHEDULER.run
+  end
+
+  def provision(group_name, number_of_servers, dependencies)
+    raise "Please override this method"
+  end
+end

data/lib/chef-workflow/helpers/ssh.rb

@@ -0,0 +1,99 @@
+require 'chef-workflow/support/ip'
+require 'chef-workflow/support/knife'
+require 'chef-workflow/support/debug'
+require 'net/ssh'
+
+#
+# Helper for performing SSH on groups of servers. Intended to be mixed into
+# test case classes.
+#
+module SSHHelper
+  include KnifePluginSupport
+  include DebugSupport
+
+  #
+  # run a command against a group of servers. These commands are run in
+  # parallel, but the command itself does not complete until all the threads
+  # have finished running.
+  #
+  def ssh_role_command(role, command)
+    t = []
+    IPSupport.singleton.get_role_ips(role).each do |ip|
+      t.push(
+        Thread.new do
+          ssh_command(ip, command)
+        end
+      )
+    end
+    t.each(&:join)
+  end
+
+  #
+  # takes a block which it uses inside of the open_channel block that Net::SSH
+  # uses. Intended to provide a consistent way of setting up Net::SSH  Makes
+  # heavy use of KnifeSupport to determine how to drive the command.
+  #
+  def configure_ssh_command(ip, command)
+    command = "#{KnifeSupport.singleton.use_sudo ? 'sudo ': ''}#{command}"
+
+    options = { }
+
+    options[:password] = KnifeSupport.singleton.ssh_password          if KnifeSupport.singleton.ssh_password
+    options[:keys]     = [KnifeSupport.singleton.ssh_identity_file]   if KnifeSupport.singleton.ssh_identity_file
+
+    Net::SSH.start(ip, KnifeSupport.singleton.ssh_user, options) do |ssh|
+      ssh.open_channel do |ch|
+        ch.on_open_failed do |ch, code, desc|
+          raise "Connection Error to #{ip}: #{desc}"
+        end
+
+        ch.exec(command) do |ch, success|
+          yield ch, success
+        end
+      end
+
+      ssh.loop
+    end
+  end
+
+  #
+  # Run a command against a single IP. Returns the exit status.
+  # 
+  #
+  def ssh_command(ip, command)
+    configure_ssh_command(ip, command) do |ch, success|
+      return 1 unless success
+
+      if_debug(2) do
+        ch.on_data do |ch, data|
+          $stderr.puts data
+        end
+      end
+
+      ch.on_request("exit-status") do |ch, data|
+        return data.read_long
+      end
+    end
+  end
+
+  #
+  # run a command, and instead of capturing the exit status, return the data
+  # captured during the command run.
+  #
+  def ssh_capture(ip, command)
+    retval = ""
+    configure_ssh_command(ip, command) do |ch, success|
+      return "" unless success
+
+      ch.on_data do |ch, data|
+        retval << data
+      end
+
+      ch.on_request("exit-status") do |ch, data|
+        return retval
+      end
+    end
+
+    return retval
+  end
+end

data/lib/chef-workflow/runner/provisioned.rb

@@ -0,0 +1,23 @@
+require 'minitest/unit'
+
+class MiniTest::Unit::TestCase
+  def self.before_suite; end
+  def self.after_suite; end
+  v = $VERBOSE
+  $VERBOSE = nil
+  const_set(:SUPPORTS_INFO_SIGNAL, nil)
+  $VERBOSE = v
+end
+
+class MiniTest::Unit::ProvisionedRunner < MiniTest::Unit
+  def _run_suite(suite, type)
+    begin
+      suite.before_suite unless suite.test_methods.empty?
+      super(suite, type)
+    ensure
+      suite.after_suite unless suite.test_methods.empty?
+    end
+  end
+end
+
+MiniTest::Unit.runner = MiniTest::Unit::ProvisionedRunner.new

data/lib/chef-workflow/test-case/ec2.rb

@@ -0,0 +1,41 @@
+require 'chef-workflow/support/vm/ec2'
+require 'chef-workflow/support/vm/knife'
+require 'tempfile'
+require 'chef-workflow/test-case/provisioned'
+require 'chef-workflow/helpers/provision'
+require 'chef-workflow/helpers/ssh'
+
+#
+# Subclass of ProvisionHelper, centered around EC2. Pulls some
+# configuration from KnifeSupport and then drives VM::EC2Provisioner and
+# VM::KnifeProvisioner.
+#
+class EC2ProvisionHelper < ProvisionHelper
+  def provision(group_name, number_of_servers=1, dependencies=[])
+    kp              = VM::KnifeProvisioner.new
+    kp.username     = KnifeSupport.singleton.ssh_user
+    kp.password     = KnifeSupport.singleton.ssh_password
+    kp.use_sudo     = KnifeSupport.singleton.use_sudo
+    kp.ssh_key      = KnifeSupport.singleton.ssh_identity_file
+    kp.environment  = KnifeSupport.singleton.test_environment
+
+    schedule_provision(
+      group_name, 
+      [
+        VM::EC2Provisioner.new(group_name, number_of_servers), 
+        kp
+      ], 
+      dependencies
+    )
+  end
+end
+
+#
+# ProvisionedTestCase that uses EC2ProvisionHelper
+#
+class MiniTest::Unit::EC2TestCase < MiniTest::Unit::ProvisionedTestCase
+  include SSHHelper
+  extend SSHHelper
+
+  self.provision_helper = EC2ProvisionHelper.new
+end

data/lib/chef-workflow/test-case/provisioned.rb

@@ -0,0 +1,88 @@
+require 'chef-workflow/support/knife'
+require 'chef-workflow/runner/provisioned'
+
+#
+# Basic provisioned test case. Generally not intended for direct use but
+# provides the scaffolding for subclasses.
+#
+# Set the class attribute `provision_helper` to configure your provision
+# helper, which will be used for many methods this class provides.
+#
+class MiniTest::Unit::ProvisionedTestCase < MiniTest::Unit::TestCase
+  module ProvisionHelper
+    def inherited(klass)
+      unless klass.provision_helper
+        klass.provision_helper = self.provision_helper
+      end
+
+      MiniTest::Unit::TestCase.inherited(klass)
+    end
+
+    #
+    # Retrieves the provision helper.
+    #
+    def provision_helper
+      @provision_helper || (self.class.provision_helper rescue nil)
+    end
+
+    #
+    # Sets the provision helper.
+    #
+    def provision_helper=(arg)
+      @provision_helper = arg
+    end
+    
+    #
+    # wait for a provision. takes a list of server group names. delegates to the
+    # provision helper.
+    #
+    def wait_for(*deps)
+      provision_helper.wait_for(*deps)
+    end
+
+    #
+    # Provision a server group. Takes a name, number of servers, and a list of
+    # dependencies (server group names). Delegates to the provision helper.
+    #
+    def provision(role, number_of_servers=1, addl_dependencies=[])
+      provision_helper.provision(role, number_of_servers, addl_dependencies)
+      provision_helper.run
+    end
+
+    #
+    # De-Provision a server group. Takes a name. Delegates to the provision
+    # helper.
+    #
+    def deprovision(role)
+      provision_helper.deprovision(role)
+    end
+
+    #
+    # Obtains the IP addresses for a given role as an array.
+    #
+    def get_role_ips(role)
+      IPSupport.singleton.get_role_ips(role)
+    end
+
+    #
+    # Easy way to reference KnifeSupport for getting configuration data.
+    #
+    def knife_config
+      KnifeSupport.singleton
+    end
+  end
+
+  include ProvisionHelper
+  extend ProvisionHelper
+
+  #
+  # Hook before the suite starts. Be sure in your subclasses to call this with
+  # `super`. Provisions machines configured as dependencies and starts the
+  # scheduler.
+  #
+  def self.before_suite
+    super
+
+    Chef::Config.from_file(KnifeSupport.singleton.knife_config_path)
+  end
+end

data/lib/chef-workflow/test-case/vagrant.rb

@@ -0,0 +1,44 @@
+require 'chef-workflow/support/vagrant'
+require 'chef-workflow/support/vm/vagrant'
+require 'chef-workflow/support/vm/knife'
+require 'tempfile'
+require 'chef-workflow/test-case/provisioned'
+require 'chef-workflow/helpers/provision'
+require 'chef-workflow/helpers/ssh'
+
+#
+# Subclass of ProvisionHelper, centered around Vagrant. Pulls some
+# configuration from KnifeSupport and then drives VM::VagrantProvisioner and
+# VM::KnifeProvisioner.
+#
+class VagrantProvisionHelper < ProvisionHelper
+  def provision(group_name, number_of_servers=1, dependencies=[])
+    self.serial = true
+
+    kp              = VM::KnifeProvisioner.new
+    kp.username     = KnifeSupport.singleton.ssh_user
+    kp.password     = KnifeSupport.singleton.ssh_password
+    kp.use_sudo     = KnifeSupport.singleton.use_sudo
+    kp.ssh_key      = KnifeSupport.singleton.ssh_identity_file
+    kp.environment  = KnifeSupport.singleton.test_environment
+
+    schedule_provision(
+      group_name, 
+      [
+        VM::VagrantProvisioner.new(group_name, number_of_servers), 
+        kp
+      ], 
+      dependencies
+    )
+  end
+end
+
+#
+# ProvisionedTestCase that uses VagrantProvisionHelper.
+#
+class MiniTest::Unit::VagrantTestCase < MiniTest::Unit::ProvisionedTestCase
+  include SSHHelper
+  extend SSHHelper
+
+  self.provision_helper = VagrantProvisionHelper.new
+end

data/lib/chef-workflow-testlib/version.rb

@@ -0,0 +1,7 @@
+class Chef
+  module Workflow
+    module Testlib
+      VERSION = "0.1.0"
+    end
+  end
+end

data/lib/chef-workflow-testlib.rb

@@ -0,0 +1 @@
+require "chef-workflow-testlib/version"

metadata

@@ -0,0 +1,143 @@
+--- !ruby/object:Gem::Specification
+name: chef-workflow-testlib
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Erik Hollensbe
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: chef-workflow
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.3.0
+- !ruby/object:Gem::Dependency
+  name: net-ssh
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.6.0
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Test helpers and assertions for chef-workflow
+email:
+- erik+github@hollensbe.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- chef-workflow-testlib.gemspec
+- lib/chef-workflow-testlib.rb
+- lib/chef-workflow-testlib/version.rb
+- lib/chef-workflow/helper.rb
+- lib/chef-workflow/helpers/chef.rb
+- lib/chef-workflow/helpers/minitest.rb
+- lib/chef-workflow/helpers/provision.rb
+- lib/chef-workflow/helpers/ssh.rb
+- lib/chef-workflow/runner/provisioned.rb
+- lib/chef-workflow/test-case/ec2.rb
+- lib/chef-workflow/test-case/provisioned.rb
+- lib/chef-workflow/test-case/vagrant.rb
+homepage: https://github.com/chef-workflow/chef-workflow-testlib
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Test helpers and assertions for chef-workflow
+test_files: []
+has_rdoc: