lobot 2.0.0pre → 2.1.0

data/lib/lobot/templates/default_rails_build_script.sh

@@ -0,0 +1,13 @@
+#!/bin/bash -le
+
+source .rvmrc
+
+# install bundler if necessary
+set -e
+
+gem install bundler --no-ri --no-rdoc && bundle install
+
+# debugging info
+echo USER=$USER && ruby --version && which ruby && which bundle
+
+bundle exec rspec spec

data/lib/lobot/version.rb

@@ -1,3 +1,3 @@
 module Lobot
-  VERSION = "2.0.0pre"
-end
+  VERSION = "2.1.0"
+end

data/lobot.gemspec

@@ -15,23 +15,22 @@ Gem::Specification.new do |s|
   s.rubyforge_project = "lobot"
 
   s.files         = `git ls-files`.split("\n") + `cd chef/travis-cookbooks && git ls-files`.split("\n").map { |f| "chef/travis-cookbooks/#{f}" }
-  s.test_files    = `git ls-files -- {test,spec,features}`.split("\n")
   s.executables   = `git ls-files -- bin`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
   s.add_dependency "fog", "~> 1.6"
   s.add_dependency "ci_reporter", "~> 1.7"
   s.add_dependency "thor"
-  s.add_dependency "hashie"
+  s.add_dependency "hashie", "~> 2.0.2"
+  s.add_dependency "haddock"
   s.add_dependency "net-ssh"
+  s.add_dependency "httpclient"
+  s.add_dependency "godot"
 
-  s.add_development_dependency "godot"
   s.add_development_dependency "rspec"
-  s.add_development_dependency "jasmine"
   s.add_development_dependency "guard-rspec"
   s.add_development_dependency "guard-bundler"
   s.add_development_dependency "test-kitchen"
-  s.add_development_dependency "pry"
 
   s.add_development_dependency "terminal-notifier-guard"
   s.add_development_dependency "rb-fsevent"

data/script/bootstrap_server.sh

@@ -20,7 +20,7 @@ then
 	sudo apt-get install -y $to_install
 fi
 
-test -d /usr/local/rvm || curl -L https://get.rvm.io | sudo bash -s stable
+test -d /usr/local/rvm || curl --location https://get.rvm.io | sudo bash -s stable
 
 sudo tee /etc/profile.d/rvm.sh > /dev/null <<RVMSH_CONTENT
 [[ -s "/usr/local/rvm/scripts/rvm" ]] && source "/usr/local/rvm/scripts/rvm"

data/script/ci_build.sh

@@ -0,0 +1,13 @@
+#!/bin/bash -le
+
+source .rvmrc
+
+# install bundler if necessary
+set -e
+
+gem install bundler --no-ri --no-rdoc && bundle install
+
+# debugging info
+echo USER=$USER && ruby --version && which ruby && which bundle
+
+bundle exec rspec spec --tag ~slow --tag ~vagrant --tag ~osx

data/spec/assets/test_cert.crt

@@ -0,0 +1,18 @@
+-----BEGIN CERTIFICATE-----
+MIIC2TCCAkKgAwIBAgIBAjANBgkqhkiG9w0BAQUFADBvMRUwEwYDVQQDDAxteWRv
+bWFpbi5jb20xETAPBgNVBAsMCE9yZyBVbml0MRcwFQYDVQQKDA5NeSBPcmcgUHR5
+IEx0ZDEPMA0GA1UEBwwGU3lkbmV5MQwwCgYDVQQIDANOU1cxCzAJBgNVBAYTAkFV
+MB4XDTEyMTExMDIxMjgzM1oXDTQwMDMyNzIxMjgzM1oweTELMAkGA1UEBhMCQVUx
+DDAKBgNVBAgMA05TVzEPMA0GA1UEBwwGU3lkbmV5MRcwFQYDVQQKDA5NeSBPcmcg
+UHR5IEx0ZDERMA8GA1UECwwIT3JnIFVuaXQxHzAdBgNVBAMMFmxvYm90X3Rlc3Rf
+Y2VydGlmaWNhdGUwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBAMwBCTdyENiZ
+bIA74XR1Yhe7kk3E/DMhri4RNZ8MQXExNltXC71rzOyhhoq77ND64VzBCZuT/iMb
+RLK29C0SN/XQQa/vqPml4tUTyONqKogqJcXtGyCp7U5hIpW4Y+klw/LtYDPJoFM8
+yMSGxzn0+YIX4KH0u9hrl+i8F5KSOl0jAgMBAAGjezB5MAkGA1UdEwQCMAAwLAYJ
+YIZIAYb4QgENBB8WHU9wZW5TU0wgR2VuZXJhdGVkIENlcnRpZmljYXRlMB0GA1Ud
+DgQWBBRTPY4WEkIjl5AkbeYhQ9aVGacA3zAfBgNVHSMEGDAWgBQ3ZYrFt76HbAP6
+rHBbiEbUjSF+KDANBgkqhkiG9w0BAQUFAAOBgQAwNlqhnO7RZe2q9Y2GzBJe6xTU
+rI4zAEaNPjQFjVgytiYl6w6xS48Ksx46boZ1/RyGRO7N0PgloIWSDnVWDvHgIz2F
+vGho9G63qQtzu122WU9XcW1KDaN+0tQCO/Ow3l9CUUe/J1mzyfLtP3E5e7QGYqOg
+lbrTC5b3JtKGy1MSoQ==
+-----END CERTIFICATE-----

data/spec/fixtures/ssh_keys/vagrant_test_key

@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEpQIBAAKCAQEA3ItezXAizPua9JTKlxN5D3Q3RUNT7TXUbqfg3XmEEEOIcidc
+yAAqG+4XVbp7Fjv80ADSWTrZzJN5/rfr762/zvupBEmDsHcaSaWo6MCTnek6uBPR
+I7GwFh17zKtjrXNdZqKyHn6STwdcar5hh282sqbs7TJjVVnSLuJbjTZEsSVS3r3/
+CVhWTxVQbis/fgE7IQkGCKDDtEJtXRR3VBtDz5n5Ez0aefsjUxtcgSJKLJoVJrOM
+DVO/rIvbiAEBXy3uZsFi9uSvTp0nIyE5t8GPoQeG8pgcgiahNOy+sIiWcbK5BXrb
+SrdWi0NfW+2CfJGzJXo2Fs09QVzpUyts2GAqaQIDAQABAoIBAQC9ab2MN4jMADO/
+Z6LvSbwpd6iYhhCopBjEyM4pqNmxli6zy/a1lt6TilLkP/rCx9aDVpFSLWctemPG
+TnQGL3WS8TTiB7lgb4pWQj7lV6/waYUS34I5Y7xV4hCXYYOETpajNYxBAHfsA+ht
+jQD6bpvNp+vIdAQ4I6KOvb3fdAJfGJSmdr5Yqas2u9DqCidrw4gQ5cPRwxpki+8n
+s6eGKw6HGaoqYk/hsLECec5kZqy89lrn/E0+1xzlUwBXSaUsbLUKE6toHMZzoSIP
+tUIh+WoKe0gt2s4j+sMD0wSYmny0UvuFyDlyQHDOSE8TSVODGWhEr1pztqklYEfg
+oM4JrqPZAoGBAPfd9eS0qviFvRloOxPIdEeHaCc7+yBQnBWBDvgA19fcvFByJlmr
+i6qrQmChIxZS8loDGKQEPsJnrVKww15GcmDU0yesAfQHmXpplQK3cslTXhghwC3z
+p7ohMLnWjEi9Q+k0RizhFCq55w7+9U+E5wbW9017MAzC4A52mhm+GDZ/AoGBAOPH
+55TxoF4/o3rrXNtjajQ/DBYZPAmUbqpdj0QQIRkIxziiV44Aw2HmdqgtlZaQ5a/r
+8qUJCO2/on/zyQvjByx/sGfdqhOcVymySGSPOSusk6cwq2oCaDPdwZorrzueE0jV
+DgHFF9Y3p1W5CEl4Um6IWRZZS9PK4cPC/p1mXDsXAoGAVO1JTjaVChgQxb7P1yRs
+qwF7L04+6kCUak3RCiqHyh+IqmuiNkEv1qddU+yCMCj1ft/mtnP56PRLD7UfC5NJ
+p2Hkg4hNFwbvkGDSvJ6Mhuy4pb4Ssev1QTIUFuirIlUvCp1tmfz4wvb1c07qUHey
+DMbk7zhRK14uFOaQQFfAxhMCgYEAhQINY7b4mzB0COn5Dg7uTFXoe9r+aOWo/Yim
+iOsWOKUcmCCMGdquPLOz5B7CM+qmhOS1itNMyG/XtvmnE27dmIlzfCM/FjZ721hE
+15uembcrfTx5S+zd5jN+wsTxjVGQFz558GSjt65F41Op2CUPlYW+58L6+VCGJqbt
+wQGtp78CgYEA8WD+AcC70tS0h+siJoG2AYvQfBmZPGcZjGmban8SGRHcXMctpVw/
+LOP18TY4/nfT/j4OwwZ07SlCbIWPJm7+u0IiWxmf5j48pGy7p1oMxih9IggXr0+t
+KyWHrnBl8O90L7QLmSBzfOHAIoPhejgAqqADQd9lSDXSSW7GhVh0g4Q=
+-----END RSA PRIVATE KEY-----

data/spec/fixtures/ssh_keys/vagrant_test_key.pub

@@ -0,0 +1 @@
+ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDci17NcCLM+5r0lMqXE3kPdDdFQ1PtNdRup+DdeYQQQ4hyJ1zIACob7hdVunsWO/zQANJZOtnMk3n+t+vvrb/O+6kESYOwdxpJpajowJOd6Tq4E9EjsbAWHXvMq2Otc11morIefpJPB1xqvmGHbzaypuztMmNVWdIu4luNNkSxJVLevf8JWFZPFVBuKz9+ATshCQYIoMO0Qm1dFHdUG0PPmfkTPRp5+yNTG1yBIkosmhUms4wNU7+si9uIAQFfLe5mwWL25K9OnScjITm3wY+hB4bymByCJqE07L6wiJZxsrkFettKt1aLQ19b7YJ8kbMlejYWzT1BXOlTK2zYYCpp pivotal@holloway

data/spec/lib/lobot/amazon_spec.rb

@@ -1,108 +1,149 @@
 require "spec_helper"
 
-describe Lobot::Amazon, :slow => true do
+describe Lobot::Amazon, :slow do
+  subject(:amazon) { Lobot::Amazon.new(ENV["EC2_KEY"], ENV["EC2_SECRET"]) }
   let(:tempdir) { Dir.mktmpdir }
-  let(:amazon) { Lobot::Amazon.new(ENV["EC2_KEY"], ENV["EC2_SECRET"]) }
   let(:fog) { amazon.send(:fog) }
 
+  before { pending "Missing EC2 Credentials" unless SpecHelpers::ec2_credentials_present? }
+
   describe "#create_security_group" do
+    after { amazon.fog_security_groups.get(security_group).destroy if SpecHelpers::ec2_credentials_present? }
+
     context "when there is no existing security group" do
+      let(:security_group) { "totally_not_a_honeypot" }
+
       it "creates a security group" do
-        amazon.create_security_group("totally_not_a_honeypot")
-        amazon.security_groups.map(&:name).should include "totally_not_a_honeypot"
+        amazon.create_security_group(security_group)
+        amazon.fog_security_groups.map(&:name).should include security_group
       end
     end
 
     context "when the security group already exists" do
-      before { amazon.create_security_group("bart_police") }
+      let(:security_group) { "bart_police" }
+      before { amazon.create_security_group(security_group) }
 
       it "does not complain" do
-        expect { amazon.create_security_group("bart_police") }.not_to raise_error
+        expect { amazon.create_security_group(security_group) }.not_to raise_error
       end
     end
   end
 
   describe "#open_port" do
-    before { amazon.create_security_group("bag_of_weasels") }
+    let(:security_group) { "bag_of_weasels" }
+    let(:group) { amazon.fog_security_groups.get(security_group) }
 
-    let(:group) { amazon.security_groups.get("bag_of_weasels") }
+    before { amazon.create_security_group(security_group) }
+    after { amazon.fog_security_groups.get(security_group).destroy if SpecHelpers::ec2_credentials_present? }
 
-    def includes_port?(permissions, ports)
-      permissions.any? { |p| (p["fromPort"]..p["toPort"]).include?(80) }
+    def includes_port?(permissions, port)
+      permissions.any? { |p| (p["fromPort"]..p["toPort"]).include?(port) }
     end
 
     it "opens a port for business" do
       group.ip_permissions.should_not include "80"
-      amazon.open_port("bag_of_weasels", 80)
+      amazon.open_port(security_group, 80)
       includes_port?(group.reload.ip_permissions, 80).should be_true
     end
 
     it "takes a bunch of ports" do
-      amazon.open_port("bag_of_weasels", 22, 443)
+      amazon.open_port(security_group, 22, 443)
       includes_port?(group.reload.ip_permissions, 22).should be_true
       includes_port?(group.reload.ip_permissions, 443).should be_true
     end
   end
 
   describe "#add_key_pair" do
-    let(:key_pair_path) { "#{tempdir}/supernuts" }
+    let(:key_pair_pub) { File.read(File.expand_path(ssh_key_pair_path + ".pub")) }
+    let(:key_pair_name) { "is_supernuts" }
 
-    before do
-      system "ssh-keygen -q -f #{key_pair_path} -P ''"
-      amazon.delete_key_pair("is_supernuts")
-    end
+    before { amazon.delete_key_pair(key_pair_name) }
+    after { amazon.delete_key_pair(key_pair_name) if SpecHelpers::ec2_credentials_present? }
 
     it "uploads the key" do
-      amazon.add_key_pair("is_supernuts", "#{key_pair_path}.pub")
-      amazon.key_pairs.map(&:name).should include "is_supernuts"
+      amazon.add_key_pair(key_pair_name, key_pair_pub)
+      amazon.fog_key_pairs.map(&:name).should include key_pair_name
     end
 
     context "when the key is already there" do
-      before { amazon.add_key_pair("is_supernuts", "#{key_pair_path}.pub") }
+      before { amazon.add_key_pair(key_pair_name, key_pair_pub) }
 
       it "doesn't reupload" do
         expect do
-          amazon.add_key_pair("is_supernuts", "#{key_pair_path}.pub")
+          amazon.add_key_pair(key_pair_name, key_pair_pub)
         end.not_to raise_error
       end
     end
   end
 
   describe "things which launch instances" do
-    let(:key_pair_path) { "#{tempdir}/cookie" }
+    let(:key_pair_name) { "eating_my_cookie" }
+    let(:security_group) { "chump_of_change" }
+    let(:key_pair_pub) { File.read(File.expand_path(ssh_key_pair_path + ".pub")) }
+    let(:freshly_launched_server) { amazon.launch_server(key_pair_name, security_group, "t1.micro") }
 
     before do
-      system "ssh-keygen -q -f #{key_pair_path} -P ''"
-      amazon.add_key_pair("eating_my_cookie", "#{key_pair_path}.pub")
-      amazon.create_security_group("chump_of_change")
+      amazon.delete_key_pair(key_pair_name)
+      amazon.add_key_pair(key_pair_name, key_pair_pub)
+      amazon.create_security_group(security_group)
     end
 
-    let(:freshly_launched_server) { amazon.launch_server("eating_my_cookie", "chump_of_change", "t1.micro") }
+    after do
+      if SpecHelpers::ec2_credentials_present?
+        freshly_launched_server.destroy
+        amazon.delete_key_pair(key_pair_name)
+        # Make a best effort attempt to clean up after the tests have completed
+        # EC2 does not always reap these resources fast enough for our tests, we could wait, but why bother?
+        amazon.elastic_ip_address.destroy rescue nil
+        amazon.fog_security_groups.get(security_group).destroy rescue nil
+      end
+    end
 
     describe "#launch_instance" do
       it "creates an instance" do
-        expect { freshly_launched_server }.to change { amazon.servers.reload.count }.by(1)
+        expect { freshly_launched_server }.to change { amazon.fog_servers.reload.count }.by(1)
 
-        freshly_launched_server.availability_zone.should == "us-east-1a"
+        freshly_launched_server.availability_zone.should =~ /us-east-1[abcd]/
         freshly_launched_server.flavor_id.should == "t1.micro"
-        freshly_launched_server.tags.should == {"lobot"=>Lobot::VERSION, "Name"=>"Lobot"}
-        freshly_launched_server.key_name.should == "eating_my_cookie"
-        freshly_launched_server.groups.should == ["chump_of_change"]
+        freshly_launched_server.tags.should == {"lobot" => Lobot::VERSION, "Name" => "Lobot"}
+        freshly_launched_server.key_name.should == key_pair_name
+        freshly_launched_server.groups.should == [security_group]
         freshly_launched_server.public_ip_address.should == amazon.elastic_ip_address.public_ip
-
-        freshly_launched_server.destroy
-        amazon.elastic_ip_address.destroy
       end
     end
 
     describe "#destroy_ec2" do
       let!(:server_ip) { freshly_launched_server.public_ip_address }
 
-      it "stops all the instances" do
-        expect do
-          amazon.destroy_ec2
-        end.to change { freshly_launched_server.reload.state }.from("running")
-        fog.addresses.get(server_ip).should_not be
+      context 'with a confirmation Proc that returns true' do
+        let(:proc) { ->(_) { true } }
+
+        it "stops all the instances" do
+          # TODO: This probably needs some more testing with n > 1 instances
+          expect do
+            amazon.destroy_ec2(proc, :all)
+          end.to change { freshly_launched_server.reload.state }.from("running")
+          fog.addresses.get(server_ip).should_not be
+        end
+
+        it "stops the named instances" do
+          expect do
+            amazon.destroy_ec2(proc, freshly_launched_server.id)
+            freshly_launched_server.wait_for { !ready? }
+          end.to change { freshly_launched_server.reload.state }.from("running")
+          fog.addresses.get(server_ip).should_not be
+        end
+      end
+
+      context 'with a confirmation Proc that returns false' do
+        let(:proc) { ->(_) { false } }
+
+        it 'does not stop instances' do
+          expect do
+            amazon.destroy_ec2(proc, :all)
+          end.to_not change { freshly_launched_server.reload.state }.from("running")
+          fog.addresses.get(server_ip).should be
+        end
       end
     end
   end

data/spec/lib/lobot/cli_spec.rb

@@ -1,212 +1,281 @@
 require "spec_helper"
 
 describe Lobot::CLI do
-  let(:tempfile) do
-    Tempfile.new('lobot-config').tap do |file|
-      file.write YAML.dump({})
-      file.close
-    end
-  end
-
-  let(:lobot_config) { Lobot::Config.new(:aws_key => ENV["EC2_KEY"], :aws_secret => ENV["EC2_SECRET"]) }
   let(:cli) { subject }
-  let(:sobo) { Lobot::Sobo.new(lobot_config.master, lobot_config.server_ssh_key) }
+  let(:sobo) { Lobot::Sobo.new(lobot_config.master, lobot_config.server_ssh_key_path) }
 
   before do
-    cli.stub(:lobot_config).and_return(lobot_config)
+    cli.stub(:lobot_config).and_return(lobot_config) # lobot_config must be defined in each context below
   end
 
-  describe "#ssh" do
-    it "starts an ssh session to the lobot host" do
-      cli.should_receive(:exec).with("ssh -i #{cli.lobot_config.server_ssh_key} ubuntu@#{cli.lobot_config.master} -p #{cli.lobot_config.ssh_port}")
-      cli.ssh
+  context 'with Amazon' do
+    let(:lobot_config) {
+      Lobot::Config.new(
+        :aws_key => ENV["EC2_KEY"],
+        :aws_secret => ENV["EC2_SECRET"],
+        :server_ssh_key => ssh_key_pair_path)
+    }
+
+    describe '#create & #destroy_ec2', :slow, :ec2 do
+      it "launches an instance and associates elastic ip" do
+        pending "Missing EC2 Credentials" unless SpecHelpers::ec2_credentials_present?
+        cli.lobot_config.instance_size = 't1.micro'
+        expect { cli.create }.to change { lobot_config.master }.from(nil)
+
+        cli.stub(:options).and_return({'force' => 'force'})
+        expect { cli.destroy_ec2 }.to change { lobot_config.master }.to(nil)
+      end
     end
-  end
 
-  describe "#open" do
-    let(:lobot_config) do
-      Lobot::Config.new(:node_attributes => {
-        :nginx => {
-          :basic_auth_user => "ci",
-          :basic_auth_password => "secret"
-        }
-      })
+    describe "#ssh" do
+      it "starts an ssh session to the lobot host" do
+        cli.should_receive(:exec).with("ssh -i #{cli.lobot_config.server_ssh_key_path} ubuntu@#{cli.lobot_config.master} -p #{cli.lobot_config.ssh_port}")
+        cli.ssh
+      end
     end
 
-    it "opens a web browser with the lobot page" do
-      cli.should_receive(:exec).with("open https://#{cli.lobot_config.node_attributes.nginx.basic_auth_user}:#{cli.lobot_config.node_attributes.nginx.basic_auth_password}@#{cli.lobot_config.master}/")
-      cli.open
-    end
-  end
-
-  describe "#add_build" do
-    let(:name) { "bob" }
-    let(:repository) { "http://github.com/mkocher/soloist.git" }
-    let(:branch) { "master" }
-    let(:command) { "script/ci_build.sh" }
-
-    it "adds a build to the node attributes" do
-      cli.add_build(name, repository, branch, command)
-      lobot_config.node_attributes.jenkins.builds.should =~ [{
-        "name" => "bob",
-        "repository" => "http://github.com/mkocher/soloist.git",
-        "command" => "script/ci_build.sh",
-        "branch" => "master"
-      }]
-    end
+    describe "#open", :osx do
+      let(:lobot_config) do
+        Lobot::Config.new(:node_attributes => {
+            :nginx => {
+                :basic_auth_user => "ci",
+                :basic_auth_password => "secret"
+            }
+        })
+      end
 
-    it "does not add a build twice with identical parameters" do
-      cli.add_build(name, repository, branch, command)
-      cli.add_build(name, repository, branch, command)
-      lobot_config.node_attributes.jenkins.builds.should =~ [{
-        "name" => "bob",
-        "repository" => "http://github.com/mkocher/soloist.git",
-        "command" => "script/ci_build.sh",
-        "branch" => "master"
-      }]
+      it "opens a web browser with the lobot page" do
+        lobot_config.master = "127.0.0.1"
+        cli.should_receive(:exec).with("open https://ci:secret@127.0.0.1/")
+        cli.open
+      end
     end
 
-    context "with persisted configuration data" do
-      let(:lobot_config) { Lobot::Config.from_file(tempfile.path) }
+    describe "#trust_certificate", :osx do
+      let(:keychain) { Lobot::Keychain.new("/Library/Keychains/System.keychain") }
+      before { lobot_config.master = "192.168.99.99" }
 
-      def builds
-        cli.lobot_config.reload.node_attributes.jenkins.builds
-      end
+      it "adds the key to the keychain" do
+        fake_keychain = double(:keychain)
+        fake_keychain.should_receive(:fetch_remote_certificate).with("https://#{lobot_config.master}/").and_return("IAMACERTIFICATE")
+        fake_keychain.should_receive(:add_certificate).with("IAMACERTIFICATE")
+        Lobot::Keychain.should_receive(:new).with("/Library/Keychains/System.keychain").and_return(fake_keychain)
 
-      it "persists a build" do
-        cli.add_build(name, repository, branch, command)
-        builds.should_not be_nil
-        builds.should_not be_empty
+        cli.trust_certificate
       end
     end
-  end
-
-  shared_examples_for "a start command that updates known_hosts" do
-    let(:key) { "AAAAB3NzaC1yc2EAAAADAQABAAABAQDjhJ/xZCgVhq9Xk+3DKJZ6tcgyIHcIXKSzu6Z/EK1uykyHeP/i7CwwKgiAv7lAV7B4UiUMHUm2nEiguog9VtYc6mc0g1N829lnuMhPRyOTb0SSYTNEN7Uuwy10cuq3Rd/9QAdxNV/voQW3Rl60BFzZvzp8UxJzCXFT1NmB+0W45X7Ypstv0oVV/EdyJJUuoPijQ097A4kHt6KUThKzxhagh1UrVTCE6eccscxuuRPX3yCEf8cUaVrKtuSE3vZnBcmSOY92zA4NV/YdJYNPIrKyCvWb/R+nC4R0pQNqv1gSEqPT51wYxKnvmIPFGntKaJSN2qmMlvs/AlFnFOeUsUFN" }
 
-    def known_hosts_contents
-      File.read(File.expand_path('~/.ssh/known_hosts'))
-    end
+    describe "#add_build" do
+      let(:name) { "bob" }
+      let(:repository) { "http://github.com/mkocher/soloist.git" }
+      let(:branch) { "master" }
+      let(:command) { "script/ci_build.sh" }
 
-    it "clears out the entry in knownhosts as this is a new box but the ip may be recycled" do
-      system "echo '#{ip_address} ssh-rsa #{key}' >> ~/.ssh/known_hosts"
-      action
-      known_hosts_contents.should_not include(key)
-      known_hosts_contents.should include(ip_address)
-    end
+      context "when the config is invalid" do
+        before { lobot_config.node_attributes.jenkins = {} }
 
-    it "doesn't mess with other entries" do
-      expect { action }.not_to change { known_hosts_contents }
-    end
-  end
+        it "raises an error" do
+          expect do
+            cli.add_build(name, repository, branch, command)
+          end.to raise_error %r{your config file does not have a}
+        end
+      end
 
-  describe "#create", :slow => true do
-    it "launches an instance and associates elastic ip" do
-      cli.lobot_config.instance_size = 't1.micro'
-      expect { cli.create }.to change { lobot_config.master }.from(nil)
-      expect { cli.destroy_ec2 }.to change { lobot_config.master }.to(nil)
+      context "when the configuration is valid" do
+        context "with persisted configuration data" do
+          let(:tempfile) do
+            Tempfile.new('lobot-config').tap do |file|
+              file.write YAML.dump({})
+              file.close
+            end
+          end
+
+          let(:lobot_config) { Lobot::Config.from_file(tempfile.path) }
+
+          def builds
+            cli.lobot_config.reload.node_attributes.jenkins.builds
+          end
+
+          it "persists a build" do
+            cli.add_build(name, repository, branch, command)
+            builds.should_not be_nil
+            builds.should_not be_empty
+          end
+        end
+      end
     end
 
     context "with a fake amazon" do
-      let(:ip_address) { "192.168.33.10" }
+      let(:ip_address) { "127.0.0.1" }
       let(:server) { double("server", :public_ip_address => ip_address).as_null_object }
       let(:amazon) { double("AMZN", :launch_server => server).as_null_object }
+      let(:instance_id) { 'i-xxxxxx' }
 
-      before { cli.stub(:amazon).and_return(amazon) }
-
-      def action
-        cli.create
+      before do
+        cli.stub(:amazon).and_return(amazon)
       end
 
-      it_behaves_like "a start command that updates known_hosts"
-
-      context "with a custom instance size", :slow => false do
-        before { cli.lobot_config.instance_size = 'really_big_instance' }
+      describe "#create" do
+        before do
+          amazon.stub(:with_key_pair).and_yield("unique-key-pair-name")
+          cli.should_receive(:wait_for_server)
+        end
 
-        it "launches the instance with the configured instance size" do
-          amazon.should_receive(:launch_server).with(anything, anything, 'really_big_instance')
+        it "uses the configured key pair" do
+          amazon.should_receive(:with_key_pair).with(cli.lobot_config.server_ssh_pubkey)
           cli.create
         end
-      end
-    end
-  end
 
-  describe "#create_vagrant" do
-    before do
-      File.open(tempfile.path, "w") do |f|
-        f.write(YAML.dump(
-          "node_attributes" => {
-            "nginx" => {
-              "basic_auth_user" => "ci",
-              "basic_auth_password" => "secret"
-            }
-          }
-        ))
+        context "with a custom instance size", :slow => false do
+          before { cli.lobot_config.instance_size = 'really_big_instance' }
+
+          it "launches the instance with the configured instance size" do
+            amazon.should_receive(:launch_server).with(anything, anything, 'really_big_instance')
+            cli.create
+          end
+        end
       end
-    end
 
-    def lobot_config
-      Lobot::Config.from_file(tempfile.path)
-    end
+      describe "destroy_ec2" do
+        before do
+          cli.lobot_config.master = ip_address
+          cli.lobot_config.instance_id = instance_id
+        end
 
-    it "starts a virtual machine" do
-      cli.create_vagrant
-      Godot.wait('192.168.33.10', 22).should be
-    end
+        context 'by default' do
+          before do
+            amazon.stub(:destroy_ec2).and_yield(mock("SERVER").as_null_object)
+          end
+
+          it 'deletes the known instance' do
+            amazon.should_receive(:destroy_ec2).and_yield(mock("SERVER").as_null_object)
+            cli.destroy_ec2
+          end
+
+          it 'clears the master ip address' do
+            expect { cli.destroy_ec2 }.to change(cli.lobot_config, :master).to(nil)
+          end
+
+          it 'clears the master instance id' do
+            expect { cli.destroy_ec2 }.to change(cli.lobot_config, :instance_id).to(nil)
+          end
+
+          it 'does not delete sibling instances' do
+            amazon.should_receive(:destroy_ec2).with(a_kind_of(Proc), instance_id)
+            cli.destroy_ec2
+          end
+
+          it 'prompts for confirmation' do
+            cli.should_receive(:yes?).and_return(true)
+            amazon.should_receive(:destroy_ec2).with(a_kind_of(Proc), instance_id) do |confirm_proc, instance_id|
+              confirm_proc.call(mock("SERVER").as_null_object)
+            end
+            cli.destroy_ec2
+          end
+        end
 
-    it "updates the config master ip address" do
-      expect { cli.create_vagrant }.to change { lobot_config.master }.to('192.168.33.10')
-    end
+        context 'with --all' do
+          before do
+            cli.stub(:options).and_return({'all' => 'all'})
+          end
 
-    context "known_hosts" do
-      let(:ip_address) { "192.168.33.10" }
+          it 'deletes everything tagged "lobot"' do
+            amazon.should_receive(:destroy_ec2).with(a_kind_of(Proc), :all)
+            cli.destroy_ec2
+          end
+        end
 
-      def action
+        context 'with --force' do
+          before do
+            cli.stub(:options).and_return({'force' => 'force'})
+          end
+
+          it 'does not prompt for confirmation' do
+            cli.should_not_receive(:ask)
+            amazon.should_receive(:destroy_ec2).with(a_kind_of(Proc), instance_id) do |confirm_proc, instance_id|
+              confirm_proc.call(mock("SERVER").as_null_object)
+            end
+            cli.destroy_ec2
+          end
+        end
+      end
+    end
+  end
+
+  context 'with Vagrant', :vagrant do
+    let(:lobot_config) {
+      Lobot::Config.new(
+          "node_attributes" => {
+              "jenkins" => {
+                  "builds" => []
+              },
+              "nginx" => {
+                  "basic_auth_user" => "ci",
+                  "basic_auth_password" => "secret"
+              }
+          },
+          "server_ssh_key" => ssh_key_pair_path,
+          "github_ssh_key" => ssh_key_pair_path
+      )
+    }
+
+    describe "#create_vagrant" do
+      it "starts a virtual machine" do
         cli.create_vagrant
+        Godot.wait('192.168.33.10', 22).should be
       end
 
-      it_behaves_like "a start command that updates known_hosts"
+      it "updates the config master ip address" do
+        expect { cli.create_vagrant }.to change { lobot_config.master }.to('192.168.33.10')
+      end
     end
-  end
 
-  describe "#bootstrap", :slow => true do
-    before { cli.create_vagrant }
+    describe "#bootstrap", :slow do
+      before { cli.create_vagrant }
 
-    it "installs all necessary packages, installs rvm and sets up the user" do
-      cli.bootstrap
-      sobo.exec!("dpkg --get-selections").should include("libncurses5-dev")
-      sobo.exec!("ls /usr/local/rvm/").should_not be_empty
-      sobo.exec!("groups ubuntu").should include("rvm")
+      it "installs all necessary packages, installs rvm and sets up the user" do
+        cli.bootstrap
+        sobo.backtick("dpkg --get-selections").should include("libncurses5-dev")
+        sobo.backtick("ls /usr/local/rvm/").should_not be_empty
+        sobo.backtick("groups ubuntu").should include("rvm")
+      end
     end
-  end
 
-  describe "#chef", :slow => true do
-    let(:name) { "Bob" }
-    let(:repository) { "http://github.com/mkocher/soloist.git" }
-    let(:branch) { "master" }
-    let(:command) { "exit 0" }
+    describe "#chef", :slow do
+      let(:name) { "Bob" }
+      let(:repository) { "http://github.com/mkocher/soloist.git" }
+      let(:branch) { "master" }
+      let(:command) { "exit 0" }
 
-    let(:godot) { Godot.new(cli.master_server.ip, 8080) }
-    let(:jenkins) { Lobot::Jenkins.new(lobot_config) }
+      let(:godot) { Godot.new(cli.master_server.ip, 8080, timeout: 180) }
+      let(:jenkins) { Lobot::Jenkins.new(lobot_config) }
 
-    before do
-      cli.create_vagrant
-      cli.bootstrap
-      cli.add_build(name, repository, branch, command)
-    end
+      before do
+        cli.create_vagrant
+        cli.bootstrap
+        cli.add_build(name, repository, branch, command)
+        FileUtils.mkdir_p("/tmp/lobot_dummy/cookbooks/pork/recipes/")
+        File.write("/tmp/lobot_dummy/cookbooks/pork/recipes/bacon.rb", "package 'htop'")
+      end
 
-    it "runs chef" do
-      cli.lobot_config.recipes = ["pivotal_ci::jenkins", "pivotal_ci::id_rsa", "pivotal_ci::git_config", "sysctl", "pivotal_ci::jenkins_config"]
-      cli.chef
+      after do
+        FileUtils.rm_rf("/tmp/lobot_dummy")
+      end
 
-      sobo.exec!("ls /var/lib/").should include "jenkins"
-      sobo.exec!("grep 'kernel.shmmax=' /etc/sysctl.conf").should_not be_empty
-      sobo.exec!("sudo cat /var/lib/jenkins/.ssh/id_rsa").should == File.read(lobot_config.github_ssh_key)
+      it "runs chef" do
+        Dir.chdir('/tmp/lobot_dummy/') do
+          cli.lobot_config.recipes = ["pivotal_ci::jenkins", "pivotal_ci::id_rsa", "pivotal_ci::git_config", "sysctl", "pivotal_ci::jenkins_config", "pork::bacon"]
+          cli.chef
+        end
 
-      godot.wait!
-      godot.match!(/Bob/, 'api/json')
+        sobo.backtick("ls /var/lib/").should include "jenkins"
+        sobo.backtick("grep 'kernel.shmmax=' /etc/sysctl.conf").should_not be_empty
+        sobo.backtick("sudo cat /var/lib/jenkins/.ssh/id_rsa").should == lobot_config.github_ssh_key
+        sobo.system("dpkg -l htop").should == 0
 
-      jenkins.jobs.first.name.should == "Bob"
+        godot.wait!
+        godot.match!(/Bob/, 'api/json')
+      end
     end
   end
 end