soloist-rvm 0.0.1

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

@@ -0,0 +1,171 @@
+require "spec_helper"
+
+describe Soloist::CLI do
+  let(:cli) { Soloist::CLI.new }
+  let(:base_path) { RSpec.configuration.tempdir }
+  let(:soloistrc_path) { File.expand_path("soloistrc", 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
+          begin
+            Dir.chdir(base_path) { cli.chef }
+          rescue Soloist::NotFound => e
+            e.message.should == "Could not find soloistrc or .soloistrc"
+            raise
+          end
+        end.to raise_error(Soloist::NotFound)
+      end
+    end
+
+    context "when the soloistrc file exists" do
+      before 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.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.soloist_config.should_receive(:exec)
+          cli.chef
+        end
+
+        it "does not run librarian" do
+          Librarian::Chef::Cli.should_not_receive(:with_environment)
+          cli.chef
+        end
+      end
+
+      context "when the Cheffile exists" do
+        let(:cli_instance) { double(:cli_instance) }
+
+        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)
+          cli.chef
+        end
+
+        context "when the user is not root" do
+          context "when rvm is not present" do
+            before do
+              cli.soloist_config.stub(:rvm?).and_return(false)
+            end
+            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 rvm is present" do
+            before do
+              cli.soloist_config.stub(:rvm?).and_return(true)
+            end
+            it "creates the cache path using rvmsudo" do
+              cli.soloist_config.should_receive(:exec) do |command|
+                command.should =~ /rvmsudo -E/
+              end
+              cli.chef
+            end
+          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 "#run_recipe" do
+    context "when the soloistrc does not exist" do
+      it "raises an error" do
+        expect do
+          Dir.chdir(base_path) { cli.run_recipe("pineapple::wut") }
+        end.to raise_error(Soloist::NotFound)
+      end
+    end
+
+    context "when the soloistrc file exists" do
+      before do
+        File.open(soloistrc_path, "w") do |file|
+          file.write(YAML.dump("recipes" => ["pineapple::wutcake"]))
+        end
+      end
+
+      it "sets a recipe to run" do
+        Dir.chdir(base_path) do
+          cli.should_receive(:chef)
+          cli.run_recipe("angst::teenage", "ennui::default")
+          cli.soloist_config.royal_crown.recipes.should =~ ["angst::teenage", "ennui::default"]
+        end
+      end
+    end
+  end
+
+  describe "#config" do
+    let(:royal_crown) { Soloist::RoyalCrown.new(:node_attributes => {"a" => "b"}) }
+    let(:config) { Soloist::Config.new(royal_crown) }
+
+    before { cli.stub(:soloist_config => config) }
+
+    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

@@ -0,0 +1,196 @@
+require "spec_helper"
+
+describe Soloist::Config do
+  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
+    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 "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 { should have(1).path }
+        it { should =~ [cookbook_path] }
+      end
+
+      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
+      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 = ["~"] }
+
+      it { should have(1).path }
+      it { should =~ [home] }
+    end
+  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
+
+    describe "node_attributes" do
+      subject { config.as_node_json }
+
+      it { should include "gargling" => "cool" }
+      it { should include "birds" => { "nested" => "cheep" } }
+    end
+
+    describe "recipes" do
+      subject { config.as_node_json["recipes"] }
+
+      it { should have(1).recipe }
+      it { should =~ ["waffles"] }
+    end
+  end
+
+  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 "does not merge the attribute" do
+        config.compiled["recipes"].should be_empty
+      end
+    end
+
+    context "when a switch is active" do
+      before { ENV.stub(:[]).and_return("FINE") }
+
+      it "merges the attributes" do
+        config.compiled.recipes.should =~ ["hobo_fist"]
+      end
+
+      context "when an inactive switch is nested" do
+        let(:nested) { {"BEANS" => {"EW" => {"recipes" => ["slammin"]}}} }
+
+        it "does not merge the attributes" do
+          config.compiled.recipes.should =~ ["hobo_fist"]
+        end
+      end
+
+      context "when an active switch is nested" do
+        let(:nested) { {"BEANS" => {"FINE" => {"recipes" => ["slammin"]}}} }
+
+        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