soloist 1.0.0.pre → 1.0.0

data/soloist.gemspec

@@ -23,10 +23,13 @@ Gem::Specification.new do |s|
   s.add_dependency "librarian"
   s.add_dependency "thor"
   s.add_dependency "hashie"
+  s.add_dependency "net-ssh"
+  s.add_dependency "awesome_print"
 
   s.add_development_dependency "rspec"
   s.add_development_dependency "guard-rspec"
   s.add_development_dependency "guard-bundler"
+  s.add_development_dependency "guard-shell"
   s.add_development_dependency "rb-fsevent"
   s.add_development_dependency "terminal-notifier-guard"
   s.add_development_dependency "gem-release"

data/spec/helpers/net_ssh_test_helper.rb

@@ -0,0 +1,8 @@
+def make_story_channel(&block)
+  story do |session|
+    channel = session.opens_channel
+    block.call(channel)
+    channel.gets_close
+    channel.sends_close
+  end
+end

data/spec/helpers/net_ssh_test_patch.rb

@@ -0,0 +1,38 @@
+require "net/ssh/test"
+
+class Net::SSH::Test::Packet
+  alias :original_types :types
+  def types
+    @types ||= case @type
+      when CHANNEL_EXTENDED_DATA then [:long, :long, :string]
+      else original_types
+      end
+  end
+end
+
+class Net::SSH::Test::Script
+  def gets_channel_extended_data(channel, data)
+    events << Net::SSH::Test::RemotePacket.new(:channel_extended_data, channel.local_id, 1, data)
+  end
+end
+
+class Net::SSH::Test::Channel
+  def gets_extended_data(data)
+    script.gets_channel_extended_data(self, data)
+  end
+end
+
+class Net::SSH::Test::Kex
+  def exchange_keys
+    result = Net::SSH::Buffer.from(:byte, NEWKEYS)
+    @connection.send_message(result)
+
+    buffer = @connection.next_message
+    raise Net::SSH::Exception, "expected NEWKEYS" unless buffer.type == NEWKEYS
+
+    { :session_id        => "abc-xyz",
+      :server_key        => OpenSSL::PKey::RSA.new(512),
+      :shared_secret     => OpenSSL::BN.new("1234567890", 10),
+      :hashing_algorithm => OpenSSL::Digest::SHA1 }
+  end
+end

data/spec/lib/soloist/cli_spec.rb

@@ -2,12 +2,27 @@ require "spec_helper"
 
 describe Soloist::CLI do
   let(:cli) { Soloist::CLI.new }
-  let(:base_path) { Dir.mktmpdir }
+  let(:base_path) { RSpec.configuration.tempdir }
   let(:soloistrc_path) { File.expand_path("soloistrc", base_path) }
 
-  before { FileUtils.mkdir_p(base_path) }
+  before do
+    FileUtils.mkdir_p(base_path)
+    Soloist::Config.any_instance.stub(:exec)
+  end
 
   describe "#chef" do
+    it "receives the outside environment" do
+      FileUtils.touch(soloistrc_path)
+      Dir.chdir(base_path) do
+        ENV["AUTREYISM"] = "pathological-yodeling"
+        cli.soloist_config.should_receive(:exec) do |chef_solo|
+          `#{chef_solo}`.chomp.should == "pathological-yodeling"
+        end
+        cli.soloist_config.stub(:chef_solo).and_return('echo $AUTREYISM')
+        cli.chef
+      end
+    end
+
     context "when the soloistrc file does not exist" do
       it "raises an error" do
         expect do
@@ -26,55 +41,84 @@ describe Soloist::CLI do
         File.open(soloistrc_path, "w") do |file|
           file.write(YAML.dump("recipes" => ["stinky::feet"]))
         end
+        cli.soloist_config = nil
+        Dir.chdir(base_path) { cli.soloist_config.stub(:exec) }
       end
 
       it "runs the proper recipes" do
-        cli.stub(:exec)
-        Dir.chdir(base_path) { cli.chef }
-        cli.config.royal_crown.recipes.should =~ ["stinky::feet"]
+        cli.chef
+        cli.soloist_config.royal_crown.recipes.should =~ ["stinky::feet"]
+      end
+
+      context "when a soloistrc_local file exists" do
+        let(:soloistrc_local_path) { File.expand_path("soloistrc_local", base_path) }
+
+        before do
+          File.open(soloistrc_local_path, "w") do |file|
+            file.write(YAML.dump("recipes" => ["stinky::socks"]))
+          end
+          cli.soloist_config = nil
+          Dir.chdir(base_path) { cli.soloist_config.stub(:exec) }
+        end
+
+        it "installs the proper recipes" do
+          cli.chef
+          cli.soloist_config.royal_crown.recipes.should =~ ["stinky::feet", "stinky::socks"]
+        end
       end
 
       context "when the Cheffile does not exist" do
         it "runs chef" do
-          cli.should_receive(:exec)
-          Dir.chdir(base_path) { cli.chef }
+          cli.soloist_config.should_receive(:exec)
+          cli.chef
         end
 
         it "does not run librarian" do
-          cli.stub(:exec)
           Librarian::Chef::Cli.should_not_receive(:with_environment)
-          Dir.chdir(base_path) { cli.chef }
+          cli.chef
         end
       end
 
       context "when the Cheffile exists" do
         let(:cli_instance) { double(:cli_instance) }
 
-        before do
-          FileUtils.touch(File.expand_path("Cheffile", base_path))
-          cli.stub(:exec)
-        end
+        before { FileUtils.touch(File.expand_path("Cheffile", base_path)) }
 
         it "runs librarian" do
           Librarian::Chef::Cli.should_receive(:with_environment).and_yield
           Librarian::Chef::Cli.should_receive(:new).and_return(cli_instance)
           cli_instance.should_receive(:install)
-          Dir.chdir(base_path) { cli.chef }
+          cli.chef
         end
 
-        it "runs chef" do
-          cli.should_receive(:exec)
-          Dir.chdir(base_path) { cli.chef }
+        context "when the user is not root" do
+          it "creates the cache path using sudo" do
+            cli.soloist_config.should_receive(:exec) do |command|
+              command.should =~ /^sudo -E/
+            end
+            cli.chef
+          end
+        end
+
+        context "when the user is root" do
+          before { Process.stub(:uid => 0) }
+
+          it "creates the cache path" do
+            cli.soloist_config.should_receive(:exec) do |command|
+              command.should_not =~ /^sudo -E/
+            end
+            cli.chef
+          end
         end
       end
     end
   end
 
-  describe "#DO_IT_LIVE" do
+  describe "#run_recipe" do
     context "when the soloistrc does not exist" do
       it "raises an error" do
         expect do
-          Dir.chdir(base_path) { cli.DO_IT_LIVE("pineapple::wut") }
+          Dir.chdir(base_path) { cli.run_recipe("pineapple::wut") }
         end.to raise_error(Soloist::NotFound)
       end
     end
@@ -89,45 +133,22 @@ describe Soloist::CLI do
       it "sets a recipe to run" do
         Dir.chdir(base_path) do
           cli.should_receive(:chef)
-          cli.DO_IT_LIVE("angst::teenage", "ennui::default")
-          cli.config.royal_crown.recipes.should =~ ["angst::teenage", "ennui::default"]
+          cli.run_recipe("angst::teenage", "ennui::default")
+          cli.soloist_config.royal_crown.recipes.should =~ ["angst::teenage", "ennui::default"]
         end
       end
     end
   end
 
-  describe "#ensure_chef_cache_path" do
-    context "when the cache path does not exist" do
-      before { File.stub(:directory? => false) }
-
-      it "creates the cache path" do
-        cli.should_receive(:system).with("sudo mkdir -p /var/chef/cache")
-        cli.ensure_chef_cache_path
-      end
-    end
-
-    context "when the cache path exists" do
-      before { File.stub(:directory? => true) }
-
-      it "does not create the cache path" do
-        cli.should_not_receive(:system)
-        cli.ensure_chef_cache_path
-      end
-    end
-  end
+  describe "#config" do
+    let(:royal_crown) { Soloist::RoyalCrown.new(:node_attributes => {"a" => "b"}) }
+    let(:config) { Soloist::Config.new(royal_crown) }
 
-  describe "#chef_solo" do
-    before do
-      ENV["AUTREYISM"] = "pathological-yodeling"
-      FileUtils.touch(File.expand_path("soloistrc", base_path))
-    end
+    before { cli.stub(:soloist_config => config) }
 
-    it "receives the outside environment" do
-      cli.stub(:chef_solo).and_return('echo $AUTREYISM')
-      cli.should_receive(:exec) do |chef_solo|
-        `#{chef_solo}`.chomp.should == "pathological-yodeling"
-      end
-      Dir.chdir(base_path) { cli.chef }
+    it "prints the hash render of the RoyalCrown" do
+      Kernel.should_receive(:ap).with({"recipes"=>[], "a" => "b"})
+      cli.config
     end
   end
 end

data/spec/lib/soloist/config_spec.rb

@@ -1,107 +1,196 @@
 require "spec_helper"
 
 describe Soloist::Config do
-  let(:soloist_rc) { Soloist::RoyalCrown.new(:path => "/tmp/soloist/soloistrc") }
+  let(:soloist_rc_path) { File.expand_path("soloistrc", RSpec.configuration.tempdir) }
+  let(:soloist_rc) { Soloist::RoyalCrown.new(:path => soloist_rc_path) }
   let(:config) { Soloist::Config.new(soloist_rc) }
+  let(:cookbook_path) { File.expand_path("cookbooks", RSpec.configuration.tempdir) }
+  let(:nested_cookbook_path) { File.expand_path("whoa/cookbooks", RSpec.configuration.tempdir) }
 
   describe "#as_solo_rb" do
-    context "without extra cookbook paths" do
-      it "can generate solo.rb" do
-        config.as_solo_rb.should == 'cookbook_path ["/tmp/soloist/cookbooks"]'
-      end
+    subject { config.as_solo_rb }
+
+    it { should include 'file_cache_path "/var/chef/cache"' }
+    it { should include %(json_attribs "#{config.node_json_path}") }
+  end
+
+  describe "#cookbook_paths" do
+    subject { config.cookbook_paths }
+
+    context "when the default cookbook path does not exist" do
+      it { should have(0).paths }
     end
 
-    context "with a cookbook path" do
-      before { soloist_rc.cookbook_paths = ["/opt/holla/at/yo/soloist"] }
+    context "when the default cookbook path exists" do
+      before { FileUtils.mkdir_p(cookbook_path) }
+
+      it { should have(1).path }
+      it { should =~ [cookbook_path] }
+
+      context "when the default cookbook path is specified" do
+        before { soloist_rc.cookbook_paths = [cookbook_path] }
 
-      it "can have multiple cookbook paths" do
-        config.as_solo_rb.should == 'cookbook_path ["/tmp/soloist/cookbooks", "/opt/holla/at/yo/soloist"]'
+        it { should have(1).path }
+        it { should =~ [cookbook_path] }
       end
 
-      it "removes duplicate cookbook paths" do
-        expect do
-          soloist_rc.cookbook_paths << "/opt/holla/at/yo/soloist"
-        end.not_to change { config.as_solo_rb }
+      context "with a specified cookbook path" do
+        before { soloist_rc.cookbook_paths = [nested_cookbook_path] }
+
+        context "when the specified path exists" do
+          before { FileUtils.mkdir_p(nested_cookbook_path) }
+
+          it { should have(2).paths }
+          it { should =~ [cookbook_path, nested_cookbook_path] }
+
+          context "with duplicate cookbook paths" do
+            before { soloist_rc.cookbook_paths = [nested_cookbook_path, nested_cookbook_path] }
+
+            it { should have(2).paths }
+            it { should =~ [cookbook_path, nested_cookbook_path] }
+          end
+        end
+
+        context "when the specified path does not exist" do
+          it { should have(1).path }
+          it { should =~ [cookbook_path] }
+        end
       end
     end
 
     context "with relative paths" do
-      let(:pwd) { File.expand_path(".") }
-
-      before { soloist_rc.cookbook_paths << "./meth/cookbooks" }
-
-      it "can have multiple cookbook paths" do
-        config.as_solo_rb.should == 'cookbook_path ["/tmp/soloist/cookbooks", "/tmp/soloist/meth/cookbooks"]'
+      before do
+        soloist_rc.cookbook_paths = ["./whoa/cookbooks"]
+        FileUtils.mkdir_p(nested_cookbook_path)
       end
+
+      it { should have(1).path }
+      it { should =~ [nested_cookbook_path] }
     end
 
     context "with unixisms in the cookbook path" do
       let(:home) { File.expand_path("~") }
 
-      before { soloist_rc.cookbook_paths << "~/yo/homes" }
+      before { soloist_rc.cookbook_paths = ["~"] }
 
-      it "expands paths" do
-        config.as_solo_rb.should include "#{home}/yo/homes"
-      end
+      it { should have(1).path }
+      it { should =~ [home] }
     end
   end
 
-  describe "#as_json" do
-    context "with recipes" do
-      before { soloist_rc.recipes = ["waffles"] }
-
-      it "can generate json" do
-        config.as_json["recipes"].should include "waffles"
-      end
+  describe "#as_node_json" do
+    let(:soloist_rc) do
+      Soloist::RoyalCrown.new(
+        :path => soloist_rc_path,
+        :recipes => ["waffles"],
+        :node_attributes => { "gargling" => "cool", "birds" => {"nested" => "cheep"} }
+      )
     end
-  end
 
-  describe "#compiled_rc" do
-    let(:switch) { {"OX_TONGUES" => {"FINE" => {"recipes" => ["hobo_fist"]}}} }
+    describe "node_attributes" do
+      subject { config.as_node_json }
 
-    before do
-      soloist_rc.env_variable_switches =  switch
+      it { should include "gargling" => "cool" }
+      it { should include "birds" => { "nested" => "cheep" } }
     end
 
-    context "when a switch is active" do
-      before { ENV.stub(:[]).and_return("FINE") }
+    describe "recipes" do
+      subject { config.as_node_json["recipes"] }
 
-      it "merges the environment variable switch" do
-        config.compiled_rc.recipes.should include "hobo_fist"
-      end
+      it { should have(1).recipe }
+      it { should =~ ["waffles"] }
     end
+  end
 
-    context "when a switch is inactive" do
-      before { ENV.stub(:[]).and_return("WHAT_NO_EW") }
+  describe "#compiled" do
+    let(:nested) { {} }
+    let(:switch) do
+      {
+        "TONGUES" => {
+          "FINE" => {
+            "recipes" => ["hobo_fist"],
+            "env_variable_switches" => nested
+          }
+        }
+      }
+    end
+
+    before { config.royal_crown.env_variable_switches = switch }
+
+    context "when the switch is inactive" do
+      before { ENV.stub(:[]).and_return("LOLWUT") }
 
-      it "outputs an empty list" do
-        config.compiled_rc.recipes.should be_empty
+      it "does not merge the attribute" do
+        config.compiled["recipes"].should be_empty
       end
     end
 
-    context "when switches are nested" do
-      let(:inner) { {"GOAT" => {"TASTY" => {"node_attributes" => {"bbq" => "satan"}}}} }
-      let(:outer) { {"recipes" => ["stinkditch"], "env_variable_switches" => inner} }
+    context "when a switch is active" do
+      before { ENV.stub(:[]).and_return("FINE") }
 
-      before { ENV.stub(:[]).and_return("TASTY") }
+      it "merges the attributes" do
+        config.compiled.recipes.should =~ ["hobo_fist"]
+      end
 
-      context "when the inner switch is active" do
-        let(:switch) { {"HORSE" => {"TASTY" => outer }} }
+      context "when an inactive switch is nested" do
+        let(:nested) { {"BEANS" => {"EW" => {"recipes" => ["slammin"]}}} }
 
-        it "evalutes all switches" do
-          config.compiled_rc.node_attributes.bbq.should == "satan"
-          config.compiled_rc.recipes.should == ["stinkditch"]
+        it "does not merge the attributes" do
+          config.compiled.recipes.should =~ ["hobo_fist"]
         end
       end
 
-      context "when the outer switch is inactive" do
-        let(:switch) { {"HORSE" => {"GROSS" => outer }} }
+      context "when an active switch is nested" do
+        let(:nested) { {"BEANS" => {"FINE" => {"recipes" => ["slammin"]}}} }
 
-        it "does not evaluate deeper" do
-          config.compiled_rc.recipes.should be_empty
-          config.compiled_rc.node_attributes.should be_empty
+        it "merges the attributes" do
+          config.compiled.recipes.should =~ ["slammin"]
         end
       end
     end
   end
+
+  describe "#merge!" do
+    let(:soloist_rc) { Soloist::RoyalCrown.new(:recipes => ["guts"], :node_attributes => {:reliable => "maybe"}) }
+    let(:other_rc) { Soloist::RoyalCrown.new(:recipes => ["chum"], :node_attributes => {:tasty => "maybe"}) }
+    let(:other_config) { Soloist::Config.new(other_rc) }
+
+    it "merges another config into the current one" do
+      config.merge!(other_config)
+      config.royal_crown.recipes.should =~ ["guts", "chum"]
+      config.royal_crown.node_attributes.keys.should =~ [:reliable, :tasty]
+    end
+
+    it "does not trample the other config" do
+      config.merge!(other_config)
+      other_config.royal_crown.recipes.should =~ ["chum"]
+      other_config.royal_crown.node_attributes.should == {:tasty => "maybe"}
+    end
+  end
+
+  describe "#log_level" do
+    subject { config.log_level }
+
+    context "when LOG_LEVEL is not set" do
+      it { should == "info" }
+    end
+
+    context "when LOG_LEVEL is set" do
+      before { ENV.stub(:[] => "BEANS") }
+      it { should == "BEANS" }
+    end
+  end
+
+  describe "#debug?" do
+    subject { config.debug? }
+
+    context "when log_level is not debug" do
+      it { should_not be }
+    end
+
+    context "when log_level is debug" do
+      before { config.stub(:log_level => "debug") }
+      it { should be }
+    end
+  end
 end

data/spec/lib/soloist/remote_config_spec.rb

@@ -0,0 +1,84 @@
+require "spec_helper"
+
+describe Soloist::RemoteConfig do
+  let(:royal_crown_path) { File.expand_path("soloistrc", RSpec.configuration.tempdir) }
+  let(:royal_crown) { Soloist::RoyalCrown.new(:path => royal_crown_path) }
+  let(:remote) { Soloist::Remote.new("user", "host", "key") }
+  let(:remote_config) { Soloist::RemoteConfig.new(royal_crown, remote) }
+
+  before { remote.stub(:backtick => "", :system => 0) }
+
+  def commands_for(method)
+    [].tap do |commands|
+      remote.stub(:system) { |c| commands << c; 0 }
+      remote.stub(:backtick) { |c| commands << c; "" }
+      remote_config.send(method)
+    end
+  end
+
+  describe "#run_chef" do
+    it "runs chef" do
+      commands_for(:run_chef).last.should include "chef-solo"
+    end
+  end
+
+  describe "#solo_rb_path" do
+    it "sets the path to /etc/chef/solo.rb" do
+      remote_config.solo_rb_path.should == "/etc/chef/solo.rb"
+    end
+
+    it "sets up solo.rb remotely" do
+      commands_for(:solo_rb_path).last.should =~ /sudo -E tee \/etc\/chef\/solo\.rb$/
+    end
+  end
+
+  describe "#node_json_path" do
+    it "sets the path" do
+      remote_config.node_json_path.should == "/etc/chef/node.json"
+    end
+
+    it "sets up node.json remotely" do
+      commands_for(:node_json_path).last.should =~ /sudo -E tee \/etc\/chef\/node\.json$/
+    end
+  end
+
+  describe "#chef_config_path" do
+    it "sets the path" do
+      remote_config.chef_config_path.should == "/etc/chef"
+    end
+
+    it "creates the path remotely" do
+      commands_for(:chef_config_path).tap do |commands|
+        commands.should have(1).command
+        commands.first.should =~ /mkdir .*? -p \/etc\/chef$/
+      end
+    end
+  end
+
+  describe "#chef_cache_path" do
+    it "sets the path" do
+      remote_config.chef_cache_path.should == "/var/chef/cache"
+    end
+
+    it "creates the path remotely" do
+      commands_for(:chef_cache_path).tap do |commands|
+        commands.should have(1).command
+        commands.first.should =~ /mkdir .*? -p \/var\/chef\/cache$/
+      end
+    end
+  end
+
+  describe "#cookbook_paths" do
+    it "sets the path" do
+      remote_config.cookbook_paths.should have(1).path
+      remote_config.cookbook_paths.should =~ ["/var/chef/cookbooks"]
+    end
+
+    it "creates the path remotely" do
+      commands_for(:cookbook_paths).tap do |commands|
+        commands.should have(1).command
+        commands.first.should =~ /mkdir .*? -p \/var\/chef\/cookbooks$/
+      end
+    end
+  end
+end