ridley 0.10.2 → 0.11.0.rc1

data/spec/unit/ridley/chef_objects/sandbox_object_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe Ridley::SandboxObject do
+  let(:resource) { double('chef-resource') }
+
+  subject do
+    described_class.new(double('registry'),
+      "uri" => "https://api.opscode.com/organizations/vialstudios/sandboxes/bd091b150b0a4578b97771af6abf3e05",
+      "checksums" => {
+        "385ea5490c86570c7de71070bce9384a" => {
+          "url" => "https://s3.amazonaws.com/opscode-platform-production-data/organization",
+          "needs_upload" => true
+        },
+        "f6f73175e979bd90af6184ec277f760c" => {
+          "url" => "https://s3.amazonaws.com/opscode-platform-production-data/organization",
+          "needs_upload" => true
+        },
+        "2e03dd7e5b2e6c8eab1cf41ac61396d5" => {
+          "url" => "https://s3.amazonaws.com/opscode-platform-production-data/organization",
+          "needs_upload" => true
+        },
+      },
+      "sandbox_id" => "bd091b150b0a4578b97771af6abf3e05"
+    )
+  end
+
+  before { subject.stub(resource: resource) }
+
+  describe "#checksums" do
+    pending
+  end
+
+  describe "#commit" do
+    let(:response) { { is_completed: nil} }
+    before { resource.should_receive(:commit).with(subject).and_return(response) }
+
+    context "when the commit is successful" do
+      before { response[:is_completed] = true }
+
+      it "has an 'is_completed' value of true" do
+        subject.commit
+
+        subject.is_completed.should be_true
+      end
+    end
+
+    context "when the commit is a failure" do
+      before { response[:is_completed] = false }
+
+      it "has an 'is_completed' value of false" do
+        subject.commit
+
+        subject.is_completed.should be_false
+      end
+    end
+  end
+
+  describe "#upload" do
+    it "delegates to resource#upload" do
+      checksums = double('checksums')
+      resource.should_receive(:upload).with(subject, checksums)
+
+      subject.upload(checksums)
+    end
+  end
+end

data/spec/unit/ridley/client_spec.rb

@@ -24,124 +24,124 @@ describe Ridley::Client do
   end
 
   describe "ClassMethods" do
-    subject { described_class }
+    let(:options) do
+      {
+        server_url: "https://api.opscode.com/some_path",
+        client_name: client_name,
+        client_key: client_key
+      }
+    end
 
     describe "::initialize" do
-      let(:server_url) { "https://api.opscode.com/some_path" }
+      subject { described_class.new(options) }
 
       describe "parsing the 'server_url' option" do
-        before(:each) do
-          @conn = subject.new(
-            server_url: server_url,
-            client_name: client_name,
-            client_key: client_key,
-          )
-        end
-
-        it "assigns a 'host' attribute from the given 'server_url' option" do
-          @conn.host.should eql("api.opscode.com")
-        end
-
-        it "assigns a 'scheme' attribute from the given 'server_url' option" do
-          @conn.scheme.should eql("https")
-        end
-
-        it "sets a 'path_prefix' to the root of the given 'server_url' option" do
-          @conn.path_prefix.should eql("/")
-        end
+        its(:host) { should eql("api.opscode.com") }
+        its(:scheme) { should eql("https") }
+        its(:path_prefix) { should eql("/") }
       end
 
       describe "with a server_url containing an organization" do
-        before(:each) do
-          @conn = subject.new(
-            server_url: "#{server_url}/organizations/#{organization}",
-            client_name: client_name,
-            client_key: client_key
-          )
+        before do
+         options[:server_url] = "#{server_url}/organizations/#{organization}"
         end
 
         it "gets the host data from the server_url" do
-          @conn.host.should eql("api.opscode.com")
-          @conn.scheme.should eql("https")
+          subject.host.should eql("api.opscode.com")
+          subject.scheme.should eql("https")
         end
 
-        it "assigns the value of the 'organization' option to an 'organization' attribute" do
-          @conn.connection.organization.should eql(organization)
+        it "takes the organization out of the server_url and assigns it to the organization reader" do
+          subject.organization.should eql(organization)
         end
 
         it "sets the 'path_prefix' of the connection the organization sub URI" do
-          @conn.path_prefix.should eql("/organizations/#{organization}")
+          subject.path_prefix.should eql("/organizations/#{organization}")
         end
       end
 
       it "raises 'ArgumentError' if a value for server_url is not given" do
-        lambda {
-          subject.new(
+        expect {
+          described_class.new(
             client_name: client_name,
             client_key: client_key
           )
-        }.should raise_error(ArgumentError, "Missing required option(s): 'server_url'")
+        }.to raise_error(ArgumentError, "Missing required option(s): 'server_url'")
       end
 
       it "raises if a value for client_name is not given" do
-        lambda {
-          subject.new(
+        expect {
+          described_class.new(
             server_url: server_url,
             client_key: client_key
           )
-        }.should raise_error(ArgumentError, "Missing required option(s): 'client_name'")
+        }.to raise_error(ArgumentError, "Missing required option(s): 'client_name'")
       end
 
       it "raises if a value for client_key is not given" do
-        lambda {
-          subject.new(
+        expect {
+          described_class.new(
             server_url: server_url,
             client_name: client_name
           )
-        }.should raise_error(ArgumentError, "Missing required option(s): 'client_key'")
+        }.to raise_error(ArgumentError, "Missing required option(s): 'client_key'")
       end
 
       it "raises a ClientKeyFileNotFound if the filepath for client_key is not found" do
         config[:client_key] = "/tmp/nofile.xxsa"
 
-        lambda {
-          subject.new(config)
-        }.should raise_error(Ridley::Errors::ClientKeyFileNotFound)
+        expect {
+          described_class.new(config)
+        }.to raise_error(Ridley::Errors::ClientKeyFileNotFound)
       end
 
       it "expands the path of the client_key" do
         config[:client_key] = "~/"
 
-        subject.new(config).client_key.should_not == "~/"
+        described_class.new(config).client_key.should_not == "~/"
       end
 
       it "assigns a 'ssh' attribute from the given 'ssh' option" do
-        subject.new(config).ssh.should eql({user: "reset", password: "password1", port: "222"})
+        described_class.new(config).ssh.should eql({user: "reset", password: "password1", port: "222"})
       end
 
       it "assigns a 'winrm' attribute from the given 'winrm' option" do
-        subject.new(config).winrm.should eql({user: "reset", password: "password2", port: "5986"})
+        described_class.new(config).winrm.should eql({user: "reset", password: "password2", port: "5986"})
       end
 
       it "assigns a 'chef_version' attribute from the given 'chef_version' option" do
-        subject.new(config).chef_version.should eql("10.24.0-01")
+        described_class.new(config).chef_version.should eql("10.24.0-01")
       end
     end
 
     describe "::open" do
       it "raises a LocalJumpError if no block is given" do
         lambda {
-          subject.open(config)
+          described_class.open(config)
         }.should raise_error(LocalJumpError)
       end
     end
   end
 
-  subject do
-    described_class.new(config)
+  let(:instance) { described_class.new(config) }
+
+  describe "#node" do
+    subject { instance.node }
+
+    it { should be_a(Ridley::NodeResource) }
+
+    its(:server_url) { should eql(config[:server_url]) }
+    its(:validator_path) { should eql(config[:validator_path]) }
+    its(:validator_client) { should eql(config[:validator_client]) }
+    its(:encrypted_data_bag_secret) { should eql(instance.encrypted_data_bag_secret) }
+    its(:ssh) { should eql(config[:ssh]) }
+    its(:winrm) { should eql(config[:winrm]) }
+    its(:chef_version) { should eql(config[:chef_version]) }
   end
 
   describe "#encrypted_data_bag_secret" do
+    subject { instance }
+
     it "returns a string" do
       subject.encrypted_data_bag_secret.should be_a(String)
     end

data/spec/unit/ridley/host_connector/ssh/worker_spec.rb

@@ -6,7 +6,7 @@ describe Ridley::HostConnector::SSH::Worker do
 
   let(:host) { 'reset.riotgames.com' }
   let(:options) { {} }
-  
+
   describe "#sudo" do
     subject { ssh_worker.sudo }
 
@@ -14,7 +14,7 @@ describe Ridley::HostConnector::SSH::Worker do
 
     context "with sudo" do
       let(:options) { { ssh: { sudo: true } } }
-      
+
       it { should be_true }
     end
   end
@@ -35,10 +35,10 @@ describe Ridley::HostConnector::SSH::Worker do
   end
 
   describe "#put_secret" do
-    subject(:put_secret) { ssh_worker.put_secret(encrypted_data_bag_secret_path) }
+    subject(:put_secret) { ssh_worker.put_secret(secret) }
     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 run command with echo" do
       ssh_worker.should_receive(:run).with("echo '#{secret}' > /etc/chef/encrypted_data_bag_secret; chmod 0600 /etc/chef/encrypted_data_bag_secret")
       put_secret

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

@@ -1,37 +1,29 @@
 require 'spec_helper'
 
 describe Ridley::HostConnector::SSH do
-  let(:connection) { double('conn', ssh: { user: "vagrant", password: "vagrant" }) }
+  let(:resource) { double('resource') }
 
   let(:node_one) do
-    Ridley::NodeResource.new(connection, automatic: { cloud: { public_hostname: "33.33.33.10" } })
+    Ridley::NodeObject.new(resource, automatic: { cloud: { public_hostname: "33.33.33.10" } })
   end
 
   let(:node_two) do
-    Ridley::NodeResource.new(connection, automatic: { cloud: { public_hostname: "33.33.33.11" } })
+    Ridley::NodeObject.new(resource, automatic: { cloud: { public_hostname: "33.33.33.11" } })
   end
 
-  describe "ClassMethods" do
-    subject { Ridley::HostConnector::SSH }
-    
-    describe "::start" do
-      let(:options) do
-        {
-          user: "vagrant",
-          password: "vagrant",
-          timeout: 1
-        }
-      end
-
-      it "evaluates within the context of a new SSH and returns the last item in the block" do
-        result = subject.start([node_one, node_two], options) do |ssh|
-          ssh.run("ls")
-        end
+  let(:options) do
+    {
+      user: "vagrant",
+      password: "vagrant",
+      timeout: 1
+    }
+  end
 
-        result.should be_a(Ridley::HostConnector::ResponseSet)
-      end
+  describe "ClassMethods" do
+    subject { described_class }
 
-      it "raises a LocalJumpError if a block is not provided" do        
+    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)
@@ -39,10 +31,20 @@ describe Ridley::HostConnector::SSH do
     end
   end
 
-  subject { Ridley::HostConnector::SSH.new([node_one, node_two], ssh: {user: "vagrant", password: "vagrant", timeout: 1}) }
+  subject do
+    Ridley::HostConnector::SSH.new([node_one, node_two], ssh: { user: "vagrant", password: "vagrant", timeout: 1 })
+  end
 
   describe "#run" do
-    it "returns an HostConnector::ResponseSet" do
+    let(:worker) { double('worker', terminate: nil) }
+    let(:response) { Ridley::HostConnector::Response.new("host") }
+    before { Ridley::HostConnector::SSH::Worker.stub(:new).and_return(worker) }
+
+    before do
+      worker.stub_chain(:future, :run).and_return(double(value: [:ok, response]))
+    end
+
+    it "returns an SSH::ResponseSet" do
       subject.run("ls").should be_a(Ridley::HostConnector::ResponseSet)
     end
   end

data/spec/unit/ridley/host_connector/winrm/worker_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Ridley::HostConnector::WinRM::Worker do
   subject { winrm_worker }
   let(:winrm_worker) { described_class.new(host, options) }
-  let(:host) { 'reset.riotgames.com' }  
+  let(:host) { 'reset.riotgames.com' }
   let(:options) { {} }
 
   before do
@@ -35,7 +35,7 @@ describe Ridley::HostConnector::WinRM::Worker do
     let(:command_uploader_stub) { double('CommandUploader') }
 
     it { should eq(command) }
-    
+
     context "when a command is more than 2047 characters" do
       let(:command) { "a" * 2048 }
 
@@ -62,8 +62,7 @@ describe Ridley::HostConnector::WinRM::Worker do
   end
 
   describe "#put_secret" do
-    subject(:put_secret) { winrm_worker.put_secret(encrypted_data_bag_secret_path) }
-
+    subject(:put_secret) { winrm_worker.put_secret(secret) }
     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 }
 

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

@@ -1,14 +1,14 @@
 require 'spec_helper'
 
 describe Ridley::HostConnector::WinRM do
-  let(:connection) { double('conn', ssh: { user: "vagrant", password: "vagrant" }) }
+  let(:resource) { double('resource') }
 
   let(:node_one) do
-    Ridley::NodeResource.new(connection, automatic: { cloud: { public_hostname: "33.33.33.10" } })
+    Ridley::NodeObject.new(resource, automatic: { cloud: { public_hostname: "33.33.33.10" } })
   end
 
   let(:node_two) do
-    Ridley::NodeResource.new(connection, automatic: { cloud: { public_hostname: "33.33.33.11" } })
+    Ridley::NodeObject.new(resource, automatic: { cloud: { public_hostname: "33.33.33.11" } })
   end
   let(:command_uploader) { double('command_uploader', cleanup: nil) }
 
@@ -18,7 +18,7 @@ describe Ridley::HostConnector::WinRM do
 
   describe "ClassMethods" do
     subject { Ridley::HostConnector::WinRM }
-    
+
     describe "::start" do
       let(:options) do
         {

data/spec/unit/ridley/host_connector_spec.rb

@@ -13,7 +13,44 @@ describe Ridley::HostConnector do
     described_class::DEFAULT_WINRM_PORT.should eq(5985)
   end
 
-  describe "#connector_port_open?" do
+  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) }
+
+    context "when the best connector is SSH" do
+      before do
+        described_class.stub(:best_connector_for).and_yield(Ridley::HostConnector::SSH)
+      end
+
+      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
+
+      it { should be_a(Ridley::HostConnector::WinRM::Worker) }
+      its(:user) { should eq("Administrator") }
+      its(:password) { should eq("secret") }
+    end
+  end
+
+  describe "::connector_port_open?" do
     let(:host) { "127.0.0.1" }
     let(:port) { 22 }
     let(:socket) { double(:new => true, :close => nil) }
@@ -54,7 +91,7 @@ describe Ridley::HostConnector do
     end
   end
 
-  describe "#best_connector_for" do
+  describe "::best_connector_for" do
     let(:host) {"127.0.0.1"}
 
     context "when an SSH port is open" do
@@ -90,7 +127,7 @@ describe Ridley::HostConnector do
     end
   end
 
-  describe "#parse_port_options" do
+  describe "::parse_port_options" do
     let(:options) do
       {
         ssh: {