butcher 0.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+.idea
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+tmp/*

data/.rbenv-version

@@ -0,0 +1 @@
+1.9.3-p125

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in butcher.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,18 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec', :version => 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch(%r{spec/support/.+\.rb})  { "spec" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+
+
+guard 'cucumber' do
+  watch(%r{^bin/(.+)$}) { |m| "features/#{m[1]}.feature" }
+  watch(%r{^lib/butcher/(.+)$}) { |m| "features/#{m[1]}.feature" }
+  watch(%r{^features/.+\.feature$})
+  watch(%r{^features/support/.+$})          { 'features' }
+  watch(%r{^features/step_definitions/(.+)_steps\.rb$}) { |m| Dir[File.join("**/#{m[1]}.feature")][0] || 'features' }
+end

data/README.md

@@ -0,0 +1,57 @@
+# Butcher
+
+Butcher is a set of command line tools intended to ease the use of Chef with a managed
+Opscode account.
+
+## Commands
+
+The following commands are currently available. All commands should be run from the top
+level of a chef directory.
+
+### Stab
+
+SSH into a node based on a grep of the node name.
+
+        Usage: stab [options] node_name
+          -c, --cache-dir DIR    # saves node list here (default: ~/.butcher/cache)
+          -f, --force            # download new node list even if a cache file exists
+          -h, --help             # prints usage
+          -l, --login LOGIN      # ssh with specified username
+          -v, --verbose          # be expressive
+
+Node name is loosely matched against name attributes given to nodes in chef. If multiple
+nodes match a given string, a Butcher::AmbiguousNode error is thrown and the program exits.
+
+        > knife status
+        1 hours ago, app.node, app.domain.com, 1.1.1.1, solaris2 5.11.
+        5 minutes ago, other.node, other.domain.com, 1.1.1.2, solaris2 5.11.
+
+        > stab something
+        Unable to find node "something"
+
+        > stab node
+        Multiple nodes match "node"
+        ["app.node", "app.domain.com"] => 1.1.1.1
+        ["other.node", "other.domain.com"] => 1.1.1.2
+
+Nodes are cached in a file named after your organization in Opscode. Stab discovers this
+by looking at the chef_server_url in your knife.rb. For this reason, stab can only be run
+from the top level of a chef repo.
+
+
+## License
+
+Copyright 2012 ModCloth
+
+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/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/stab

@@ -0,0 +1,66 @@
+#!/usr/bin/env ruby
+
+require 'butcher'
+require 'optparse'
+
+EX_USAGE     = 64
+EX_UNMATCHED = 65
+EX_AMBIGUOUS = 66
+EX_KNIFE     = 67
+
+options = {}
+parser = OptionParser.new do |opts|
+  opts.banner = "Usage: stab [options] node_name"
+
+  opts.on('-c', '--cache-dir DIR', 'Location to save cache files (default: ~/.butcher/cache)') do |dir|
+    ENV["CACHE_DIR"] = dir
+  end
+
+  opts.on('-f', '--force', 'Check for new nodes even if a cache file exists') do
+    options[:force] = true
+  end
+
+  opts.on('-h', '--help', 'Display this screen') do
+    puts opts
+    exit
+  end
+
+  opts.on('-l', '--login LOGIN', 'Use LOGIN for ssh session') do |login|
+    options[:login] = login
+  end
+
+  opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
+    options[:verbose] = v
+  end
+end
+
+begin parser.parse!
+rescue OptionParser::InvalidOption => e
+  puts e
+  puts parser
+  exit EX_USAGE
+end
+
+if ARGV == []
+  puts parser
+  exit EX_USAGE
+end
+
+begin
+  Butcher::Stab::CLI.new.run(ARGV, options)
+rescue Butcher::UnmatchedNode
+  STDERR.puts %Q{Unable to find node "#{ARGV.first}"}
+  exit EX_UNMATCHED
+rescue Butcher::AmbiguousNode => e
+  STDERR.puts %Q{Multiple nodes match "#{ARGV.first}"}
+  STDERR.puts e.message
+  exit EX_AMBIGUOUS
+rescue Butcher::NoKnifeRB
+  STDERR.puts "Unable to find knife.rb in ./.chef"
+  STDERR.puts "Are you stabbing from a valid working chef directory?"
+  exit EX_KNIFE
+rescue Butcher::NoKnifeOrganization
+  STDERR.puts "Unable to read organization from knife.rb"
+  STDERR.puts "Expected .chef/knife.rb to contain a chef_server_url"
+  exit EX_KNIFE
+end

data/butcher.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "butcher/version"
+
+Gem::Specification.new do |s|
+  s.name        = "butcher"
+  s.version     = Butcher::VERSION
+  s.authors     = ["ModCloth", "Eric Saxby"]
+  s.email       = %W(git@modcloth.com)
+  s.homepage    = "https://github.com/modcloth/butcher"
+  s.summary     = %q{All the things to make a chef}
+  s.description = %q{Chef is a tool for managing server automation. A good butcher makes for a good chef.}
+
+  s.rubyforge_project = "butcher"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = %W(lib)
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "rspec", "> 2"
+  s.add_development_dependency "aruba"
+  s.add_development_dependency "aruba-doubles"
+  s.add_development_dependency "guard-rspec"
+  s.add_development_dependency "guard-cucumber"
+  s.add_development_dependency "mocha"
+  # s.add_runtime_dependency "x"
+end

data/features/stab.feature

@@ -0,0 +1,121 @@
+Feature: Stab
+
+  Background:
+    # stubbing knife currently doesn't work, but tests pass anyways
+    #Given I could run `knife status` with stdout:
+    #"""
+    #1 minute ago, app.node, app.domain, 1.1.1.1, os
+    #"""
+    Given I have a knife configuration file
+    And I could run `ssh 1.1.1.1` with stdout:
+    """
+    ssh yay!
+    """
+
+  Scenario: Usage information with --help option
+    When I run `stab --help`
+    Then the exit status should be 0
+    And the output should contain:
+    """
+    Usage: stab [options] node_name
+    """
+
+  Scenario: Usage information when no node name is given
+    When I run `stab`
+    Then the exit status should be 64
+    And the output should contain:
+    """
+    Usage: stab [options] node_name
+    """
+
+  Scenario: Invalid option
+    When I run `stab --invalid-option`
+    Then the exit status should be 64
+    And the output should contain:
+    """
+    invalid option: --invalid-option
+    Usage: stab [options] node_name
+    """
+
+  Scenario: Set cache directory
+    Given a directory named "tmp/test_dir" should not exist
+    When I run `stab app.node -c tmp/test_dir`
+    Then a directory named "tmp/test_dir" should exist
+
+  Scenario: Tell user what IP address ssh uses
+    Given I have the following chef nodes:
+      | 1 minute ago | app.node | app.domain | 1.1.1.1 | os |
+    When I run `stab app.node -c tmp/test -v`
+    Then the output should contain "Connecting to app.node at 1.1.1.1"
+    Then the output should contain "ssh yay!"
+
+  Scenario: Don't download node list if already cached
+    Given I have the following chef nodes:
+      | 1 minute ago | app.node | app.domain | 1.1.1.1 | os |
+    Then a file named "tmp/test/my_organization.cache" should exist
+    When I run `stab app.node -c tmp/test -v`
+    Then the output should not contain "Creating cache file of nodes"
+
+  Scenario: Force download of cache file
+    Given I have the following chef nodes:
+      | 1 minute ago | app.node | app.domain | 1.1.1.1 | os |
+    When I run `stab app.node -c tmp/test -f -v`
+    Then the output should contain "Creating cache file of nodes"
+    #And the exit status should be 0      ## Butcher::Cache does not use stubbed knife
+
+  Scenario: User sees error message if no node matches given name
+    Given I have the following chef nodes:
+      | 1 minute ago | app.node | app.domain | 1.1.1.1 | os |
+    When I run `stab some.node -c tmp/test`
+    Then the stderr should contain:
+    """
+    Unable to find node "some.node"
+    """
+    And the exit status should be 65
+
+  Scenario: User sees error message if multiple nodes match given name
+    Given I have the following chef nodes:
+      | 1 minute ago | other.node | other.domain | 1.1.1.2 | os |
+      | 1 minute ago | app.node   | app.domain   | 1.1.1.1 | os |
+    When I run `stab node -c tmp/test`
+    Then the stderr should contain:
+    """
+    Multiple nodes match "node"
+    ["app.node", "app.domain"] => 1.1.1.1
+    ["other.node", "other.domain"] => 1.1.1.2
+    """
+    And the exit status should be 66
+
+  Scenario: User can connect to server with given user name
+    Given I have the following chef nodes:
+      | 1 minute ago | app.node | app.domain | 1.1.1.1 | os |
+    Given I could run `ssh 1.1.1.1 -l user` with stdout:
+    """
+    user: I'm a computer!
+    """
+    When I run `stab app.node -c tmp/test -l user`
+    Then the stdout should contain:
+    """
+    user: I'm a computer!
+    """
+
+  Scenario: User sees error message if knife.rb cannot be found
+    Given I don't have a knife configuration file
+    When I run `stab app.node -c tmp/test`
+    Then the stderr should contain:
+    """
+    Unable to find knife.rb in ./.chef
+    Are you stabbing from a valid working chef directory?
+    """
+    And the exit status should be 67
+
+  Scenario: User sees error message if knife.rb is invalid
+    Given I have an invalid knife configuration file
+    When I run `stab app.node -c tmp/test`
+    Then the stderr should contain:
+    """
+    Unable to read organization from knife.rb
+    Expected .chef/knife.rb to contain a chef_server_url
+    """
+    And the exit status should be 67
+

data/features/step_definitions/chef_steps.rb

@@ -0,0 +1,32 @@
+Given /I (don't|) ?have a knife configuration file/ do |expectation|
+  if expectation == "don't"
+    steps %q{
+      When I remove the file ".chef/knife.rb"
+    }
+  else
+    steps %q{
+      Given a file named ".chef/knife.rb" with:
+      """
+      chef_server_url "https://opscode.url/organizations/my_organization"
+      """
+    }
+  end
+end
+
+Given /I have an invalid knife configuration file/ do
+  steps %q{
+    Given a file named ".chef/knife.rb" with:
+    """
+    some invalid content
+    """
+  }
+
+end
+
+Given /^I have the following chef nodes:$/ do |table|
+  create_cache_file("my_organization.cache") do |f|
+    table.raw.each do |row|
+      f.puts row.join(", ")
+    end
+  end
+end

data/features/support/aruba.rb

@@ -0,0 +1,3 @@
+Before do
+  @dirs = ["."]
+end

data/features/support/env.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
+
+require 'aruba-doubles/cucumber'
+require 'aruba/cucumber'
+require 'fileutils'
+require 'rspec/expectations'
+require 'butcher'
+
+Dir["#{File.dirname(__FILE__)}/../../spec/support/**/*.rb"].each { |f| require f unless /_spec\.rb$/.match(f) }

data/features/support/mocha.rb

@@ -0,0 +1,15 @@
+require "mocha"
+
+World(Mocha::API)
+
+Before do
+  mocha_setup
+end
+
+After do
+  begin
+    mocha_verify
+  ensure
+    mocha_teardown
+  end
+end

data/features/support/test_cache.rb

@@ -0,0 +1,4 @@
+World(Butcher::TestCache::TestHelpers)
+
+Before { Butcher::TestCache.reset }
+After { Butcher::TestCache.cleanup }

data/lib/butcher.rb

@@ -0,0 +1,12 @@
+require "butcher/version"
+
+module Butcher
+  class UnmatchedNode       < Exception;end
+  class AmbiguousNode       < Exception;end
+  class NoKnifeRB           < Exception;end
+  class NoKnifeOrganization < Exception;end
+end
+
+require 'butcher/stab'
+require 'butcher/stab/cli'
+require 'butcher/cache'

data/lib/butcher/cache.rb

@@ -0,0 +1,65 @@
+require 'singleton'
+
+class Butcher::Cache
+  include Singleton
+
+  CACHE_DIR = "#{ENV["HOME"]}/.butcher/cache"
+  KNIFE_FILE = ".chef/knife.rb"
+
+  def initialize
+    FileUtils.mkdir_p(cache_dir)
+  end
+
+  def nodes(options = {})
+    hash = {}
+    cache_file(options) do |file|
+      while file.gets
+        node = $_.split(", ")
+        hash[node[3]] = [node[1],node[2]]
+      end
+    end
+    hash
+  end
+
+  def cache_dir # :nodoc:
+    ENV["CACHE_DIR"] || CACHE_DIR
+  end
+
+  def self.format_nodes_for_stderr(nodes)
+    nodes.map do |key, value|
+      %Q{#{value} => #{key}}
+    end.sort.join("\n")
+  end
+
+  def nodes_file
+    "#{cache_dir}/#{organization}.cache"
+  end
+
+  private
+
+  def organization
+    raise Butcher::NoKnifeRB unless(File.exists?(KNIFE_FILE))
+    if m = File.read(KNIFE_FILE).match(/chef_server_url\s+".+organizations\/([^\/"]+)"/)
+      m[1]
+    else
+      raise Butcher::NoKnifeOrganization
+    end
+  end
+
+  def create_node_cachefile
+    File.open(nodes_file, "w") do |file|
+      file.puts %x[knife status]
+    end
+  end
+
+  def cache_file(options, &block)
+    if options[:force] || !File.exists?(nodes_file)
+      puts "Creating cache file of nodes" if options[:verbose]
+      create_node_cachefile
+    end
+
+    File.open(nodes_file) do |f|
+      block.call f
+    end
+  end
+end

data/lib/butcher/stab.rb

@@ -0,0 +1,2 @@
+module Butcher::Stab
+end

data/lib/butcher/stab/cli.rb

@@ -0,0 +1,36 @@
+class Butcher::Stab::CLI
+  attr_accessor :node_matcher
+  attr_accessor :options
+
+  def run(arguments, options = {})
+    self.options = options
+    self.node_matcher = Array(arguments).first
+    return "" if node_matcher.nil?
+
+    ssh_to(matching_node)
+  end
+
+  private
+
+  def ssh_to(ip)
+    STDOUT.sync = true # exec takes over stdout in tests, so sync output
+    puts "Connecting to #{node_matcher} at #{ip}" if options[:verbose]
+    exec("ssh #{ip}#{ssh_options}")
+  end
+
+  def matching_node
+    nodes = Butcher::Cache.instance.nodes(options).select do |k, v|
+      String(v).include? self.node_matcher
+    end
+
+    raise(Butcher::UnmatchedNode) if nodes.size == 0
+    raise(Butcher::AmbiguousNode, Butcher::Cache.format_nodes_for_stderr(nodes)) if nodes.size > 1
+    nodes.keys.first
+  end
+
+  def ssh_options
+    if options[:login]
+      " -l #{options[:login]}"
+    end
+  end
+end

data/lib/butcher/version.rb

@@ -0,0 +1,3 @@
+module Butcher
+  VERSION = "0.0.1"
+end

data/spec/lib/cache_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+describe Butcher::Cache, "initialization" do
+  ## singletons do not reset after initialization, so we run tests against clones
+  let(:cache_class) { Butcher::Cache.clone }
+
+  it "should accept cache_dir from env" do
+    ENV["CACHE_DIR"] = "tmp/cache_from_options"
+    test(?d, "tmp/cache_from_options").should be_false
+    cache_class.instance
+    ENV["CACHE_DIR"] = nil
+    test(?d, "tmp/cache_from_options").should be_true
+  end
+
+  it "should create cache directory" do
+    cache_class.any_instance.stubs(:cache_dir).returns("tmp/cache_stub")
+    test(?d, "tmp/cache_stub").should be_false
+    cache_class.instance
+    test(?d, "tmp/cache_stub").should be_true
+  end
+end
+
+describe Butcher::Cache, "#nodes_file" do
+  context "cannot find knife.rb" do
+    it "should raise an error" do
+      File.expects(:exists?).with(".chef/knife.rb").returns(false)
+      lambda {
+        Butcher::Cache.instance.nodes_file
+      }.should raise_error(Butcher::NoKnifeRB)
+    end
+  end
+
+  context "sees a knife.rb" do
+    before { File.expects(:exists?).with(".chef/knife.rb").returns(true) }
+
+    context "without chef_server_url" do
+      it "should raise an error" do
+        File.expects(:read).with(".chef/knife.rb").returns(
+          'some random content'
+        )
+        lambda {
+          Butcher::Cache.instance.nodes_file
+        }.should raise_error(Butcher::NoKnifeOrganization)
+      end
+    end
+
+    context "with chef_server_url" do
+      let(:expected_file) { "#{Butcher::TestCache.cache_dir}/my_organization.cache" }
+
+      it "should set filename based on chef_server_url" do
+        File.expects(:read).with(".chef/knife.rb").returns(
+          'chef_server_url "https://api.opscode.com/organizations/my_organization"'
+        )
+        Butcher::Cache.instance.nodes_file.should == expected_file
+      end
+    end
+  end
+end
+
+describe Butcher::Cache, "#nodes" do
+  before { Butcher::Cache.any_instance.stubs(:organization).returns("ops_org") }
+
+  context "cache file does not exist" do
+    let(:cache_file) { "#{Butcher::TestCache.cache_dir}/ops_org.cache" }
+
+    before do
+      File.exists?(cache_file).should be_false
+      Butcher::Cache.any_instance.stubs(:`).with("knife status").returns("knife return codes")
+    end
+
+    it "should not raise an error" do
+      lambda { Butcher::Cache.instance.nodes }.should_not raise_error
+    end
+
+    it "should create a node list from knife" do
+      Butcher::Cache.instance.nodes
+      File.exists?(cache_file).should be_true
+    end
+  end
+
+  context "cache file exists" do
+    create_cache_file("ops_org.cache") do |f|
+      f.puts "5 minutes ago, app.node, app.domain.com, 192.168.1.1, some os"
+      f.puts "1 minute ago, other.node, other.domain.com, 192.168.1.2, some os"
+    end
+
+    it "maps file to hash" do
+      Butcher::Cache.instance.nodes.should == {
+        "192.168.1.1" => %W(app.node app.domain.com),
+        "192.168.1.2" => %W(other.node other.domain.com)
+      }
+    end
+  end
+end

data/spec/lib/stab/cli_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Butcher::Stab::CLI do
+
+  context "arguments are nil" do
+    it "should return empty string" do
+      Butcher::Stab::CLI.new.run(nil).should == ""
+    end
+  end
+
+  context "node cache file exists" do
+    mock_cache(:nodes) do
+      {"10.1.1.1" => %W(app.node app.node.com), "10.1.1.2" => %W(other.node other.node.com)}
+    end
+
+    context "stabbing an existing node" do
+      it "should open an SSH session to named node" do
+        Butcher::Stab::CLI.any_instance.expects(:exec).with("ssh 10.1.1.1").returns(true).once
+        Butcher::Stab::CLI.new.run("app")
+      end
+
+      it "should ssh to IP based on matched node" do
+        Butcher::Stab::CLI.any_instance.expects(:exec).with("ssh 10.1.1.1").never
+        Butcher::Stab::CLI.any_instance.expects(:exec).with("ssh 10.1.1.2").returns(true).once
+        Butcher::Stab::CLI.new.run("other")
+      end
+    end
+
+    context "stabbing a non-existing node" do
+      it "should raise an UnmatchedNode error" do
+        Butcher::Stab::CLI.any_instance.expects(:exec).never
+        lambda {
+          Butcher::Stab::CLI.new.run("nil.node")
+        }.should raise_error(Butcher::UnmatchedNode)
+      end
+    end
+
+    context "ambiguous stabbing" do
+      it "should raise an AmbiguousNode error" do
+        Butcher::Stab::CLI.any_instance.expects(:exec).never
+        lambda {
+          Butcher::Stab::CLI.new.run("node")
+        }.should raise_error(Butcher::AmbiguousNode)
+      end
+    end
+  end
+
+  context "options" do
+    mock_cache(:nodes) do
+      {"10.1.1.1" => %W(app.node app.node.com)}
+    end
+
+    describe ":login" do
+      it "should include login in ssh params" do
+        Butcher::Stab::CLI.any_instance.expects(:exec).with("ssh 10.1.1.1 -l username").returns(true).once
+        Butcher::Stab::CLI.new.run("app", {:login => "username"})
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper.rb"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+require "butcher"
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f unless /_spec\.rb$/.match(f) }
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  config.mock_with :mocha
+
+  Butcher::TestCache.setup_rspec(config)
+end

data/spec/support/test_cache.rb

@@ -0,0 +1,112 @@
+# = Butcher::TestCache
+#
+# Providing helpers for testing Butcher using RSpec and Cucumber.
+#
+# Author::    Eric Saxby (mailto:e.saxby@modcloth.com)
+# Copyright:: Copyright (c) 2012 ModCloth
+# License::   Distributes under the same terms as Ruby
+#
+# == RSpec Usage:
+#
+#    RSpec.configure do |config|
+#      Butcher::TestCache.setup_rspec(config)
+#    end
+#
+# == Cucumber Usage:
+#
+#    require 'butcher'
+#    Before { Butcher::TestCache.reset }
+#    After { Butcher::TestCache.cleanup }
+#    World(Butcher::TestCache::TestHelpers)
+#
+module Butcher::TestCache
+  def self.setup_rspec(config)
+    config.before(:each) do
+      Butcher::TestCache.reset
+    end
+
+    config.after(:suite) do
+      Butcher::TestCache.cleanup
+    end
+
+    config.extend(RSpecExampleHelpers)
+    config.include(TestHelpers)
+  end
+
+  def self.reset # :nodoc:
+    cleanup
+    setup
+  end
+
+  def self.cleanup # :nodoc:
+    FileUtils.rm_rf("tmp")
+    FileUtils.rm_rf(".chef")
+    ENV.delete("CACHE_DIR")
+  end
+
+  def self.cache_dir # :nodoc:
+    File.expand_path("tmp/test")
+  end
+
+  private
+
+  def self.setup
+    stub_cache
+    FileUtils.mkdir_p("tmp/test")
+  end
+
+  def self.stub_cache
+    ENV["CACHE_DIR"] = cache_dir
+  end
+
+  public
+
+  # == RSpecExampleHelpers
+  #
+  # RSpec helpers that can be used in the scope of an example group or a describe block.
+  # These cannot be called from within tests themselves.
+  module RSpecExampleHelpers
+
+    # Creates a file that Butcher::Cache can parse before every test in the current context.
+    # Used for testing the Cache class itself.
+    #
+    # example:
+    #    create_cache_file("nodes.cache") do |f|
+    #      f.puts "1 hour ago, node.name, node.domain, 192.168.1.1, os name"
+    #    end
+    #
+    def create_cache_file(filename, &block)
+      before do
+        create_cache_file(filename, &block)
+      end
+    end
+
+    # Mock out responses on Butcher::Cache for every test in the current context.
+    # Used in classes where you want to test against expected output from Cache.
+    #
+    # example:
+    #    mock_cache(:nodes) do
+    #      {"192.168.1.1" => ["node.name","node.domain"]}
+    #    end
+    #
+    def mock_cache(type, &block)
+      before do
+        Butcher::Cache.any_instance.stubs(type).returns(block.call)
+      end
+    end
+  end
+
+  # == TestHelpers
+  #
+  # RSpec helpers that can be used within tests
+  module TestHelpers
+
+    # Creates a file that Butcher::Cache can parse
+    def create_cache_file(filename)
+      File.open("#{Butcher::TestCache.cache_dir}/#{filename}", "w") do |file|
+        yield file
+      end
+    end
+  end
+end
+

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification
+name: butcher
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- ModCloth
+- Eric Saxby
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70346417175740 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>'
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :development
+  prerelease: false
+  version_requirements: *70346417175740
+- !ruby/object:Gem::Dependency
+  name: aruba
+  requirement: &70346417175140 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70346417175140
+- !ruby/object:Gem::Dependency
+  name: aruba-doubles
+  requirement: &70346417174680 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70346417174680
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: &70346417174260 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70346417174260
+- !ruby/object:Gem::Dependency
+  name: guard-cucumber
+  requirement: &70346417173820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70346417173820
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: &70346417173380 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70346417173380
+description: Chef is a tool for managing server automation. A good butcher makes for
+  a good chef.
+email:
+- git@modcloth.com
+executables:
+- stab
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rbenv-version
+- .rspec
+- Gemfile
+- Guardfile
+- README.md
+- Rakefile
+- bin/stab
+- butcher.gemspec
+- features/stab.feature
+- features/step_definitions/chef_steps.rb
+- features/support/aruba.rb
+- features/support/env.rb
+- features/support/mocha.rb
+- features/support/test_cache.rb
+- lib/butcher.rb
+- lib/butcher/cache.rb
+- lib/butcher/stab.rb
+- lib/butcher/stab/cli.rb
+- lib/butcher/version.rb
+- spec/lib/cache_spec.rb
+- spec/lib/stab/cli_spec.rb
+- spec/spec_helper.rb
+- spec/support/test_cache.rb
+homepage: https://github.com/modcloth/butcher
+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: butcher
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: All the things to make a chef
+test_files:
+- features/stab.feature
+- features/step_definitions/chef_steps.rb
+- features/support/aruba.rb
+- features/support/env.rb
+- features/support/mocha.rb
+- features/support/test_cache.rb
+- spec/lib/cache_spec.rb
+- spec/lib/stab/cli_spec.rb
+- spec/spec_helper.rb
+- spec/support/test_cache.rb