ridley 0.12.4 → 1.0.0.rc1

data/spec/unit/ridley/host_connector/ssh_spec.rb

@@ -1,51 +1,57 @@
 require 'spec_helper'
 
 describe Ridley::HostConnector::SSH do
-  let(:resource) { double('resource') }
-
-  let(:node_one) do
-    Ridley::NodeObject.new(resource, automatic: { cloud: { public_hostname: "33.33.33.10" } })
-  end
-
-  let(:node_two) do
-    Ridley::NodeObject.new(resource, automatic: { cloud: { public_hostname: "33.33.33.11" } })
-  end
+  subject { connector }
+  let(:connector) { described_class.new }
 
+  let(:host) { 'reset.riotgames.com' }
   let(:options) do
     {
-      user: "vagrant",
-      password: "vagrant",
-      timeout: 1
+      server_url: double('server_url'),
+      validator_path: fixtures_path.join('reset.pem'),
+      validator_client: double('validator_client'),
+      encrypted_data_bag_secret: 'encrypted_data_bag_secret',
+      ssh: Hash.new,
+      chef_version: double('chef_version')
     }
   end
 
-  describe "ClassMethods" do
-    subject { described_class }
-
-    describe "::start" do
-      it "raises a LocalJumpError if a block is not provided" do
-        expect {
-          subject.start([node_one, node_two], options)
-        }.to raise_error(LocalJumpError)
-      end
+  describe "#bootstrap" do
+    it "sends a #run message to self to bootstrap a node" do
+      connector.should_receive(:run).with(host, anything, options)
+      connector.bootstrap(host, options)
     end
   end
 
-  subject do
-    Ridley::HostConnector::SSH.new([node_one, node_two], ssh: { user: "vagrant", password: "vagrant", timeout: 1 })
+  describe "#chef_client" do
+    it "sends a #run message to self to execute chef-client" do
+      connector.should_receive(:run).with(host, "chef-client", options)
+      connector.chef_client(host, options)
+    end
   end
 
-  describe "#run" do
-    let(:worker) { double('worker', terminate: nil) }
-    let(:response) { Ridley::HostConnector::Response.new("host") }
-    before { Ridley::HostConnector::SSH::Worker.stub(:new).and_return(worker) }
+  describe "#put_secret" do
+    let(:encrypted_data_bag_secret_path) { fixtures_path.join("encrypted_data_bag_secret").to_s }
+    let(:secret) { File.read(encrypted_data_bag_secret_path).chomp }
 
-    before do
-      worker.stub_chain(:future, :run).and_return(double(value: [:ok, response]))
+    it "receives a run command with echo" do
+      connector.should_receive(:run).with(host,
+        "echo '#{secret}' > /etc/chef/encrypted_data_bag_secret; chmod 0600 /etc/chef/encrypted_data_bag_secret",
+        options
+      )
+      connector.put_secret(host, secret, options)
     end
+  end
+
+  describe "#ruby_script" do
+    let(:command_lines) { ["puts 'hello'", "puts 'there'"] }
 
-    it "returns an SSH::ResponseSet" do
-      subject.run("ls").should be_a(Ridley::HostConnector::ResponseSet)
+    it "receives a ruby call with the command" do
+      connector.should_receive(:run).with(host,
+        "#{described_class::EMBEDDED_RUBY_PATH} -e \"puts 'hello';puts 'there'\"",
+        options
+      )
+      connector.ruby_script(host, command_lines, options)
     end
   end
 end

data/spec/unit/ridley/host_connector/winrm_spec.rb

@@ -1,52 +1,145 @@
 require 'spec_helper'
 
 describe Ridley::HostConnector::WinRM do
-  let(:resource) { double('resource') }
-
-  let(:node_one) do
-    Ridley::NodeObject.new(resource, automatic: { cloud: { public_hostname: "33.33.33.10" } })
+  subject { connector }
+  let(:connector) { described_class.new }
+  let(:host) { 'reset.riotgames.com' }
+  let(:options) do
+    {
+      server_url: double('server_url'),
+      validator_path: fixtures_path.join('reset.pem'),
+      validator_client: double('validator_client'),
+      encrypted_data_bag_secret: 'encrypted_data_bag_secret',
+      winrm: Hash.new,
+      chef_version: double('chef_version')
+    }
   end
 
-  let(:node_two) do
-    Ridley::NodeObject.new(resource, automatic: { cloud: { public_hostname: "33.33.33.11" } })
-  end
-  let(:command_uploader) { double('command_uploader', cleanup: nil) }
+  before { described_class::CommandUploader.stub(:new).and_return(double('command_uploader')) }
+
+  describe "#get_command" do
+    subject(:get_command) { connector.get_command(command, command_uploader_stub) }
+
+    let(:command) { "echo %TEMP%" }
+    let(:command_uploader_stub) { double('CommandUploader') }
+
+    it { should eq(command) }
 
-  before do
-    Ridley::HostConnector::WinRM::CommandUploader.stub(:new).and_return(command_uploader)
+    context "when a command is more than 2047 characters" do
+      let(:command) { "a" * 2048 }
+
+      it "uploads and returns a command" do
+        described_class::CommandUploader.stub(new: command_uploader_stub)
+
+        command_uploader_stub.should_receive :upload
+        command_uploader_stub.stub command: "my command"
+        command_uploader_stub.stub(:cleanup)
+
+        get_command.should eq("my command")
+      end
+    end
   end
 
-  describe "ClassMethods" do
-    subject { Ridley::HostConnector::WinRM }
+  describe "#run" do
+    subject(:result) { connector.run(host, command, options) }
+    let(:command) { "dir" }
+    let(:command_uploader_stub) { double('CommandUploader', cleanup: true) }
+    let(:stdout) { "stdout" }
+    let(:stderr) { nil }
+    let(:winrm_stub) { double }
+
+    before do
+      described_class::CommandUploader.stub(:new).and_return(command_uploader_stub)
+      connector.stub(:winrm).and_return(winrm_stub)
+      winrm_stub.stub(:run_cmd).and_yield(stdout, stderr).and_return(exitcode: 0)
+    end
+
+    context "when the exit_code is 0" do
+      it "returns a non-error HostConnector::Response" do
+        expect(result).to be_a(Ridley::HostConnector::Response)
+        expect(result).to_not be_error
+      end
+
+      it "sets the response's stdout message" do
+        expect(result.stdout).to eq("stdout")
+      end
+    end
+
+    context "when the exit_code is not 0" do
+      let(:stderr) { "stderr" }
+
+      before do
+        winrm_stub.stub(:run_cmd).and_yield(stdout, stderr).and_return(exitcode: 1)
+      end
+
+      it "returns an error HostConnector::Response with an error" do
+        expect(result).to be_a(Ridley::HostConnector::Response)
+        expect(result).to be_error
+      end
 
-    describe "::start" do
-      let(:options) do
-        {
-          user: "Administrator",
-          password: "password1"
-        }
+      it "sets the response's stderr message" do
+        expect(result.stderr).to eq("stderr")
       end
+    end
+
+    context "when a WinRM::WinRMHTTPTransportError error is raised" do
+      let(:stderr) { "error" }
+      before { winrm_stub.stub(:run_cmd).and_yield(stdout, stderr).and_raise(::WinRM::WinRMHTTPTransportError) }
 
-      it "evaluates within the context of a new WinRM and returns the last item in the block" do
-        result = subject.start([node_one, node_two], options) do |winrm|
-          winrm.run("dir")
-        end
-        result.should be_a(Ridley::HostConnector::ResponseSet)
+      it "returns an error HostConnector::Response with an error" do
+        expect(result).to be_a(Ridley::HostConnector::Response)
+        expect(result).to be_error
       end
 
-      it "raises a LocalJumpError if a block is not provided" do
-        expect {
-          subject.start([node_one, node_two], options)
-        }.to raise_error(LocalJumpError)
+      it "sets the response's stderr message to the exception's message" do
+        expect(result.stderr).to eql("WinRM::WinRMHTTPTransportError")
       end
     end
   end
 
-  subject { Ridley::HostConnector::WinRM.new([node_one, node_two], user: 'Administrator', password: 'password1') }
+  describe "#bootstrap" do
+    it "sends a #run message to self to bootstrap a node" do
+      connector.should_receive(:run).with(host, anything, options)
+      connector.bootstrap(host, options)
+    end
+  end
 
-  describe "#run" do
-    it "returns a ResponseSet" do
-      subject.run("dir").should be_a(Ridley::HostConnector::ResponseSet)
+  describe "#chef_client" do
+    subject(:chef_client) { connector.chef_client(host, options) }
+
+    it "receives a command to run chef-client" do
+      connector.should_receive(:run).with(host, "chef-client", options)
+
+      chef_client
+    end
+  end
+
+  describe "#put_secret" do
+    subject(:put_secret) { connector.put_secret(host, secret, options) }
+    let(:encrypted_data_bag_secret_path) { fixtures_path.join("encrypted_data_bag_secret").to_s }
+    let(:secret) { File.read(encrypted_data_bag_secret_path).chomp }
+
+    it "receives a command to copy the secret" do
+      connector.should_receive(:run).with(host,
+        "echo #{secret} > C:\\chef\\encrypted_data_bag_secret",
+        options
+      )
+
+      put_secret
+    end
+  end
+
+  describe "#ruby_script" do
+    subject(:ruby_script) { connector.ruby_script(host, command_lines, options) }
+    let(:command_lines) { ["puts 'hello'", "puts 'there'"] }
+
+    it "receives a ruby call with the command" do
+      connector.should_receive(:run).with(host,
+        "#{described_class::EMBEDDED_RUBY_PATH} -e \"puts 'hello';puts 'there'\"",
+        options
+      )
+
+      ruby_script
     end
   end
 end

data/spec/unit/ridley/host_connector_spec.rb

@@ -1,168 +1,44 @@
 require 'spec_helper'
 
-describe Ridley::HostConnector do
-  subject do
-    described_class
-  end
-
-  it "returns 22 as the default SSH port" do
-    described_class::DEFAULT_SSH_PORT.should eq(22)
-  end
-
-  it "returns 5985 as the default WinRM port" do
-    described_class::DEFAULT_WINRM_PORT.should eq(5985)
-  end
-
-  describe "::new" do
-    let(:host) { "192.168.1.1" }
-    let(:options) do
-      {
-        ssh: {
-          user: "reset",
-          password: "lol"
-        },
-        winrm: {
-          user: "Administrator",
-          password: "secret"
-        }
-      }
-    end
-
-    subject { described_class.new(host, options) }
+describe Ridley::HostConnector::Base do
+  subject { Class.new(Ridley::HostConnector::Base).new }
 
-    context "when the best connector is SSH" do
-      before do
-        described_class.stub(:best_connector_for).and_yield(Ridley::HostConnector::SSH)
-      end
+  let(:host) { double('host') }
+  let(:options) { Hash.new }
 
-      it { should be_a(Ridley::HostConnector::SSH::Worker) }
-      its(:user) { should eq("reset") }
-    end
-
-    context "when the best connector is WinRM" do
-      before do
-        described_class.stub(:best_connector_for).and_yield(Ridley::HostConnector::WinRM)
-      end
+  describe "#run" do
+    let(:command) { double('command') }
 
-      it { should be_a(Ridley::HostConnector::WinRM::Worker) }
-      its(:user) { should eq("Administrator") }
-      its(:password) { should eq("secret") }
+    it "raises a RuntimeError" do
+      expect { subject.run(host, command, options) }.to raise_error(RuntimeError)
     end
   end
 
-  describe "::connector_port_open?" do
-    let(:host) { "127.0.0.1" }
-    let(:port) { 22 }
-    let(:socket) { double(:new => true, :close => nil) }
-
-    context "when a port is open" do
-      before do
-        TCPSocket.stub(:new).and_return(socket)
-      end
-
-      it "returns true" do
-        subject.connector_port_open?(host, port).should eql(true)
-      end
-
-      it "closes the opened socket" do
-        socket.should_receive(:close)
-        subject.connector_port_open?(host, port)
-      end
-    end
-
-    context "when a port is closed" do
-      before do
-        TCPSocket.stub(:new).and_raise(Errno::ECONNREFUSED)
-      end
-
-      it "returns false" do
-        subject.connector_port_open?(host, port).should eq(false)
-      end
-    end
-
-    context "when host is unreachable" do
-      before do
-        TCPSocket.stub(:new).and_raise(SocketError)
-      end
-
-      it "returns false" do
-        subject.connector_port_open?(host, port).should eql(false)
-      end
+  describe "#bootstrap" do
+    it "raises a RuntimeError" do
+      expect { subject.bootstrap(host, options) }.to raise_error(RuntimeError)
     end
   end
 
-  describe "::best_connector_for" do
-    let(:host) {"127.0.0.1"}
-
-    context "when an SSH port is open" do
-      it "returns Ridley::HostConnector::SSH" do
-        subject.stub(:connector_port_open?).and_return(false, true)
-        expect(subject.best_connector_for(host)).to eq(Ridley::HostConnector::SSH)
-      end
-    end
-
-    context "when an SSH port isnt open and a WinRM port is open" do
-      it "retrns Ridley::HostConnector::WinRM" do
-        subject.stub(:connector_port_open?).and_return(true, false)
-        expect(subject.best_connector_for(host)).to eq(Ridley::HostConnector::WinRM)
-      end
-    end
-
-    context "when no useable ports are open" do
-      it "raises an exception" do
-        subject.stub(:connector_port_open?).and_return(false, false)
-        expect {
-          subject.best_connector_for(host)
-        }.to raise_error(Ridley::Errors::HostConnectionError)
-      end
-    end
-
-    context "when a block is provided" do
-      it "yields the best HostConnector to the block" do
-        subject.stub(:connector_port_open?).and_return(false, true)
-        subject.best_connector_for(host) do |yielded|
-          expect(yielded).to eq(Ridley::HostConnector::SSH)
-        end
-      end
+  describe "#chef_client" do
+    it "raises a RuntimeError" do
+      expect { subject.chef_client(host, options) }.to raise_error(RuntimeError)
     end
   end
 
-  describe "::parse_port_options" do
-    let(:options) do
-      {
-        ssh: {
-          port: 1234
-        },
-        winrm: {
-          port: 5678
-        }
-      }
-    end
+  describe "#put_secret" do
+    let(:secret) { double('secret') }
 
-    context "when :ssh has a key for :port" do
-      it "returns the value of port instead of the default" do
-        subject.parse_port_options(options).should include(1234)
-      end
-    end
-
-    context "when there is no :ssh key" do
-      it "returns the default value for port" do
-        options.delete(:ssh)
-        subject.parse_port_options(options).should include(22)
-      end
+    it "raises a RuntimeError" do
+      expect { subject.put_secret(host, secret, options) }.to raise_error(RuntimeError)
     end
+  end
 
-    context "when :winrm has a key for :port" do
-      it "returns the value of port instead of the default" do
-        subject.parse_port_options(options).should include(5678)
-      end
-    end
+  describe "#ruby_script" do
+    let(:command_lines) { double('command-lines') }
 
-    context "when there is no :ssh key" do
-      it "returns the default value for port" do
-        options.delete(:winrm)
-        subject.parse_port_options(options).should include(5985)
-      end
+    it "raises a RuntimeError" do
+      expect { subject.ruby_script(host, command_lines, options) }.to raise_error(RuntimeError)
     end
   end
 end