ridley 0.10.2 → 0.11.0.rc1

data/spec/unit/ridley/resources/data_bag_item_resource_spec.rb

@@ -1,62 +1,7 @@
 require 'spec_helper'
 
 describe Ridley::DataBagItemResource do
-  let(:connection) { double('connection') }
-  let(:data_bag) { double('data_bag') }
+  subject { described_class.new(double) }
 
-  subject { Ridley::DataBagItemResource.new(connection, data_bag) }
-
-  describe "::from_hash" do
-    context "when JSON has a 'raw_data' field" do
-      let(:response) do
-        {
-          "name" => "data_bag_item_ridley-test_appconfig",
-          "raw_data" => {
-            "id" => "appconfig",
-            "host" => "host.local"
-          },
-          "json_class" => "Chef::DataBagItem",
-          "data_bag" => "ridley-test",
-          "chef_type" => "data_bag_item"
-        }
-      end
-
-      it "returns a new object from attributes in the 'raw_data' field" do
-        subject.from_hash(response).attributes.should eql(response["raw_data"])
-      end
-    end
-
-    context "when JSON does not contain a 'raw_data' field" do
-      let(:response) do
-        {
-          "id" => "appconfig",
-          "host" => "host.local"
-        }
-      end
-
-      it "returns a new object from the hash" do
-        subject.from_hash(response).attributes.should eql(response)
-      end
-    end
-  end
-
-  describe "#decrypt" do
-    before(:each) do
-      encrypted_data_bag_secret = File.read(fixtures_path.join("encrypted_data_bag_secret").to_s)
-      connection.stub(:encrypted_data_bag_secret).and_return(encrypted_data_bag_secret)
-    end
-
-    it "decrypts an encrypted value" do
-      subject.attributes[:test] = "Xk0E8lV9r4BhZzcg4wal0X4w9ZexN3azxMjZ9r1MCZc="
-      subject.decrypt
-      subject.attributes[:test][:database][:username].should == "test"
-    end
-
-    it "does not decrypt the id field" do
-      id = "dbi_id"
-      subject.attributes[:id] = id
-      subject.decrypt
-      subject.attributes[:id].should == id
-    end
-  end
+  pending
 end

data/spec/unit/ridley/resources/data_bag_resource_spec.rb

@@ -1,15 +1,20 @@
 require 'spec_helper'
 
 describe Ridley::DataBagResource do
-  it_behaves_like "a Ridley Resource", Ridley::DataBagResource
+  let(:secret) { "supersecretkey" }
+  let(:instance) { described_class.new(double, secret) }
 
-  let(:connection) { double('connection') }
+  describe "#item_resource" do
+    subject { instance.item_resource }
 
-  describe "ClassMethods" do
-    subject { Ridley::DataBagResource }
-
-    describe "::create_item" do
-      pending
+    it "returns a DataBagItemResource" do
+      subject.should be_a(Ridley::DataBagItemResource)
     end
+
+    its(:data_bag_secret) { should eql(secret) }
+  end
+
+  describe "#find" do
+    pending
   end
 end

data/spec/unit/ridley/resources/environment_resource_spec.rb

@@ -1,129 +1,21 @@
 require 'spec_helper'
 
 describe Ridley::EnvironmentResource do
-  it_behaves_like "a Ridley Resource", Ridley::EnvironmentResource
+  subject { described_class.new(double('registry')) }
 
-  let(:connection) { double("connection") }
+  describe "#delete_all" do
+    let(:default_env) { double(name: "_default") }
+    let(:destroy_env) { double(name: "destroy_me") }
 
-  let(:environment_json) do
-    %(
-      {
-        "name": "crazy-town",
-        "default_attributes": {
-          "nested_attribute": {
-            "status": "running",
-            "list": [
-              "one-thing"
-            ],
-            "feelin_good": true
-          }
-        },
-        "description": "Single letter variables. Who the fuck do you think you are?",
-        "cookbook_versions": {
-
-        },
-        "override_attributes": {
-          "mysql": {
-            "bind_address": "127.0.0.1",
-            "server_root_password": "password_lol"
-          }
-        },
-        "chef_type": "environment"
-      }
-    )
-  end
-
-  describe "ClassMethods" do
-    subject { Ridley::EnvironmentResource }
-
-    describe "::initialize" do
-      before(:each) do
-        @env = subject.new(connection, parse_json(environment_json))
-      end
-
-      it "has a value for 'name'" do
-        @env.name.should eql("crazy-town")
-      end
-
-      it "has a value for 'default_attributes'" do
-        @env.default_attributes.should be_a(Hash)
-        @env.default_attributes.should have_key("nested_attribute")
-        @env.default_attributes["nested_attribute"]["status"].should eql("running")
-      end
-
-      it "has a value for 'description'" do
-        @env.description.should eql("Single letter variables. Who the fuck do you think you are?")
-      end
-
-      it "has a value for 'cookbook_version'" do
-        @env.cookbook_versions.should be_a(Hash)
-      end
-
-      it "has a value for 'override_attributes'" do
-        @env.override_attributes.should be_a(Hash)
-        @env.override_attributes.should have_key("mysql")
-        @env.override_attributes["mysql"].should have_key("bind_address")
-      end
-
-      it "has a value for 'chef_type'" do
-        @env.chef_type.should eql("environment")
-      end
+    before do
+      subject.stub(all: [ default_env, destroy_env ])
     end
-  end
 
-  let(:connection) { double('connection') }
-
-  subject { Ridley::EnvironmentResource.new(connection) }
-
-  describe "#set_override_attribute" do
-    it "sets an override node attribute at the nested path" do
-       subject.set_override_attribute('deep.nested.item', true)
-
-       subject.override_attributes.should have_key("deep")
-       subject.override_attributes["deep"].should have_key("nested")
-       subject.override_attributes["deep"]["nested"].should have_key("item")
-       subject.override_attributes["deep"]["nested"]["item"].should be_true
-    end
-
-    context "when the override attribute is already set" do
-      it "test" do
-        subject.override_attributes = {
-          deep: {
-            nested: {
-              item: false
-            }
-          }
-        }
-        subject.set_override_attribute('deep.nested.item', true)
-        
-        subject.override_attributes["deep"]["nested"]["item"].should be_true
-      end
-    end
-  end
-
-  describe "#set_default_attribute" do
-    it "sets an override node attribute at the nested path" do
-       subject.set_default_attribute('deep.nested.item', true)
-
-       subject.default_attributes.should have_key("deep")
-       subject.default_attributes["deep"].should have_key("nested")
-       subject.default_attributes["deep"]["nested"].should have_key("item")
-       subject.default_attributes["deep"]["nested"]["item"].should be_true
-    end
+    it "does not destroy the '_default' environment" do
+      subject.stub(future: double('future', value: nil))
+      subject.should_not_receive(:future).with(:delete, default_env)
 
-    context "when the override attribute is already set" do
-      it "test" do
-        subject.default_attributes = {
-          deep: {
-            nested: {
-              item: false
-            }
-          }
-        }
-        subject.set_default_attribute('deep.nested.item', true)
-        
-        subject.default_attributes["deep"]["nested"]["item"].should be_true
-      end
+      subject.delete_all
     end
   end
 end

data/spec/unit/ridley/resources/node_resource_spec.rb

@@ -1,12 +1,14 @@
 require 'spec_helper'
 
 describe Ridley::NodeResource do
-  it_behaves_like "a Ridley Resource", Ridley::NodeResource
-
-  let(:connection) do
-    double('conn',
+  let(:host) { "33.33.33.10" }
+  let(:worker) { double('worker', alive?: true, terminate: nil) }
+  let(:options) do
+    {
       server_url: "https://api.opscode.com/organizations/vialstudios",
+      validator_path: "/some/path",
       validator_client: "chef-validator",
+      encrypted_data_bag_secret: "hellokitty",
       ssh: {
         user: "reset",
         password: "lol"
@@ -15,446 +17,133 @@ describe Ridley::NodeResource do
         user: "Administrator",
         password: "secret"
       },
-      encrypted_data_bag_secret_path: nil
-    )
-  end
-  let(:host) { "33.33.33.10" }
-
-  describe "ClassMethods" do
-    subject { Ridley::NodeResource }
-
-    let(:worker) { double('worker', alive?: true, terminate: nil) }
-
-    describe "::bootstrap" do
-      let(:boot_options) do
-        {
-          validator_path: fixtures_path.join("reset.pem").to_s,
-          encrypted_data_bag_secret_path: fixtures_path.join("reset.pem").to_s
-        }
-      end
-
-      it "bootstraps a single node" do
-        pending
-        subject.bootstrap(connection, "33.33.33.10", boot_options)
-      end
-
-      it "bootstraps multiple nodes" do
-        pending
-        subject.bootstrap(connection, "33.33.33.10", "33.33.33.11", boot_options)
-      end
-    end
-
-    describe "::chef_run" do
-      subject { chef_run }
-      let(:chef_run) { described_class.chef_run(connection, host) }
-      let(:response) { [:ok, double('response', stdout: 'success_message')] }
-
-      before do
-        Ridley::NodeResource.stub(:configured_worker_for).and_return(worker)
-        worker.stub(:chef_client).and_return(response)
-      end
-
-      it { should eq(response) }
-
-      context "when it executes unsuccessfully" do
-        let(:response) { [:error, double('response', stderr: 'failure_message')] }
-
-        it {should eq(response)}
-      end
-
-      it "terminates the worker" do
-        worker.should_receive(:terminate)
-        chef_run
-      end
-    end
-
-    describe "::put_secret" do
-      subject { put_secret }
-      let(:put_secret) { described_class.put_secret(connection, host, secret_path)}
-      let(:response) { [:ok, double('response', stdout: 'success_message')] }
-      let(:secret_path) { fixtures_path.join("reset.pem").to_s }
-
-      before do
-        Ridley::NodeResource.stub(:configured_worker_for).and_return(worker)
-        worker.stub(:put_secret).and_return(response)
-      end
-
-      it { should eq(response) }
-
-      context "when it executes unsuccessfully" do
-        let(:response) { [:error, double('response', stderr: 'failure_message')] }
-
-        it { should eq(response) }
-      end
-
-      it "terminates the worker" do
-        worker.should_receive(:terminate)
-        put_secret
-      end
-    end
-
-    describe "::ruby_script" do
-      subject { ruby_script }
-      let(:ruby_script) { described_class.ruby_script(connection, host, command_lines) }
-      let(:response) { [:ok, double('response', stdout: 'success_message')] }
-      let(:command_lines) { ["puts 'hello'", "puts 'there'"] }
-
-      before do
-        Ridley::NodeResource.stub(:configured_worker_for).and_return(worker)
-        worker.stub(:ruby_script).and_return(response)
-      end
-
-      it { should eq(response) }
-
-      context "when it executes unsuccessfully" do
-        let(:response) { [:error, double('response', stderr: 'failure_message')] }
-
-        it { should eq(response) }
-      end
-
-      it "terminates the worker" do
-        worker.should_receive(:terminate)
-        ruby_script
-      end
-    end
-
-    describe "::execute_command" do
-      subject { execute_command }
-
-      let(:execute_command) { described_class.execute_command(connection, host, command) }
-      let(:response) { [:ok, double('response', stdout: 'success_message')] }
-      let(:command) { "echo 'hello world'" }
-
-      before do
-        Ridley::NodeResource.stub(:configured_worker_for).and_return(worker)
-        worker.stub(:run).and_return(response)
-      end
-
-      it { should eq(response) }
-
-      context "when it executes unsuccessfully" do
-        let(:response) { [:error, double('response', stderr: 'failure_message')] }
-
-        it { should eq(response) }
-      end
-    end
-
-    describe "::configured_worker_for" do
-      subject { configured_worker_for }
-
-      let(:configured_worker_for) { described_class.send(:configured_worker_for, connection, host) }
-
-      context "when the best connector is SSH" do
-        before do
-          Ridley::HostConnector.stub(:best_connector_for).and_yield(Ridley::HostConnector::SSH)
-        end
-
-        it "returns an SSH worker instance" do
-          configured_worker_for.should be_a(Ridley::HostConnector::SSH::Worker)
-        end
-
-        its(:user) { should eq("reset") }
-      end
-
-      context "when the best connector is WinRM" do
-        before do
-          Ridley::HostConnector.stub(:best_connector_for).and_yield(Ridley::HostConnector::WinRM)
-          Ridley::HostConnector::WinRM::CommandUploader.stub(:new)
-        end
-
-        it "returns a WinRm worker instance" do
-          configured_worker_for.should be_a(Ridley::HostConnector::WinRM::Worker)
-        end
-
-        its(:user) { should eq("Administrator") }
-        its(:password) { should eq("secret") }
-      end
-    end
-
-    describe "::merge_data" do
-      it "finds the target node and sends it the merge_data message" do
-        data = double('data')
-        node = double('node')
-        node.should_receive(:merge_data).with(data)
-        subject.should_receive(:find!).and_return(node)
-
-        subject.merge_data(connection, node, data)
-      end
-    end
-  end
-
-  subject { node_resource }
-  let(:node_resource) { Ridley::NodeResource.new(connection) }
-
-  describe "#set_chef_attribute" do
-    it "sets an normal node attribute at the nested path" do
-       subject.set_chef_attribute('deep.nested.item', true)
-
-       subject.normal.should have_key("deep")
-       subject.normal["deep"].should have_key("nested")
-       subject.normal["deep"]["nested"].should have_key("item")
-       subject.normal["deep"]["nested"]["item"].should be_true
-    end
-
-    context "when the normal attribute is already set" do
-      it "test" do
-        subject.normal = {
-          deep: {
-            nested: {
-              item: false
-            }
-          }
-        }
-        subject.set_chef_attribute('deep.nested.item', true)
-        
-        subject.normal["deep"]["nested"]["item"].should be_true
-      end
-    end
+      chef_version: "11.4.0"
+    }
   end
-
-  describe "#cloud?" do
-    it "returns true if the cloud automatic attribute is set" do
-      subject.automatic = {
-        "cloud" => Hash.new
+  let(:instance) { described_class.new(double, options) }
+
+  describe "#bootstrap" do
+    let(:hosts) { [ "192.168.1.2" ] }
+    let(:options) do
+      {
+        validator_path: fixtures_path.join("reset.pem").to_s,
+        encrypted_data_bag_secret: File.read(fixtures_path.join("reset.pem"))
       }
-
-      subject.cloud?.should be_true
     end
+    let(:bootstrapper) { double('bootstrapper', run: nil) }
+    subject { instance }
+    before { Ridley::Bootstrapper.should_receive(:new).with(hosts, anything).and_return(bootstrapper) }
 
-    it "returns false if the cloud automatic attribute is not set" do
-      subject.automatic.delete(:cloud)
+    it "runs the Bootstrapper" do
+      bootstrapper.should_receive(:run)
 
-      subject.cloud?.should be_false
+      subject.bootstrap("192.168.1.2", options)
     end
   end
 
-  describe "#eucalyptus?" do
-    it "returns true if the node is a cloud node using the eucalyptus provider" do
-      subject.automatic = {
-        "cloud" => {
-          "provider" => "eucalyptus"
-        }
-      }
-
-      subject.eucalyptus?.should be_true
-    end
-
-    it "returns false if the node is not a cloud node" do
-      subject.automatic.delete(:cloud)
+  describe "#chef_run" do
+    let(:chef_run) { instance.chef_run(host) }
+    let(:response) { [:ok, double('response', stdout: 'success_message')] }
+    subject { chef_run }
 
-      subject.eucalyptus?.should be_false
+    before do
+      Ridley::HostConnector.stub(:new).and_return(worker)
+      worker.stub(:chef_client).and_return(response)
     end
 
-    it "returns false if the node is a cloud node but not using the eucalyptus provider" do
-      subject.automatic = {
-        "cloud" => {
-          "provider" => "ec2"
-        }
-      }
-
-      subject.eucalyptus?.should be_false
-    end
-  end
+    it { should eql(response) }
 
-  describe "#ec2?" do
-    it "returns true if the node is a cloud node using the ec2 provider" do
-      subject.automatic = {
-        "cloud" => {
-          "provider" => "ec2"
-        }
-      }
+    context "when it executes unsuccessfully" do
+      let(:response) { [ :error, double('response', stderr: 'failure_message') ] }
 
-      subject.ec2?.should be_true
+      it { should eql(response) }
     end
 
-    it "returns false if the node is not a cloud node" do
-      subject.automatic.delete(:cloud)
-
-      subject.ec2?.should be_false
-    end
-
-    it "returns false if the node is a cloud node but not using the ec2 provider" do
-      subject.automatic = {
-        "cloud" => {
-          "provider" => "rackspace"
-        }
-      }
-
-      subject.ec2?.should be_false
+    it "terminates the worker" do
+      worker.should_receive(:terminate)
+      chef_run
     end
   end
 
-  describe "#rackspace?" do
-    it "returns true if the node is a cloud node using the rackspace provider" do
-      subject.automatic = {
-        "cloud" => {
-          "provider" => "rackspace"
-        }
-      }
+  describe "#put_secret" do
+    let(:put_secret) { instance.put_secret(host) }
+    let(:response) { [ :ok, double('response', stdout: 'success_message') ] }
+    subject { put_secret }
 
-      subject.rackspace?.should be_true
+    before do
+      Ridley::HostConnector.stub(:new).and_return(worker)
+      worker.stub(:put_secret).and_return(response)
     end
 
-    it "returns false if the node is not a cloud node" do
-      subject.automatic.delete(:cloud)
-
-      subject.rackspace?.should be_false
-    end
+    it { should eql(response) }
 
-    it "returns false if the node is a cloud node but not using the rackspace provider" do
-      subject.automatic = {
-        "cloud" => {
-          "provider" => "ec2"
-        }
-      }
+    context "when it executes unsuccessfully" do
+      let(:response) { [ :error, double('response', stderr: 'failure_message') ] }
 
-      subject.rackspace?.should be_false
+      it { should eql(response) }
     end
-  end
-
-  describe "#cloud_provider" do
-    it "returns the cloud provider if the node is a cloud node" do
-      subject.automatic = {
-        "cloud" => {
-          "provider" => "ec2"
-        }
-      }
 
-      subject.cloud_provider.should eql("ec2")
-    end
-
-    it "returns nil if the node is not a cloud node" do
-      subject.automatic.delete(:cloud)
-
-      subject.cloud_provider.should be_nil
+    it "terminates the worker" do
+      worker.should_receive(:terminate)
+      put_secret
     end
   end
 
-  describe "#public_ipv4" do
-    it "returns the public ipv4 address if the node is a cloud node" do
-      subject.automatic = {
-        "cloud" => {
-          "provider" => "ec2",
-          "public_ipv4" => "10.0.0.1"
-        }
-      }
+  describe "#ruby_script" do
+    let(:ruby_script) { instance.ruby_script(host, command_lines) }
+    let(:response) { [:ok, double('response', stdout: 'success_message')] }
+    let(:command_lines) { ["puts 'hello'", "puts 'there'"] }
+    subject { ruby_script }
 
-      subject.public_ipv4.should eql("10.0.0.1")
+    before do
+      Ridley::HostConnector.stub(:new).and_return(worker)
+      worker.stub(:ruby_script).and_return(response)
     end
 
-    it "returns the ipaddress if the node is not a cloud node" do
-      subject.automatic = {
-        "ipaddress" => "192.168.1.1"
-      }
-      subject.automatic.delete(:cloud)
-
-      subject.public_ipv4.should eql("192.168.1.1")
-    end
-  end
+    it { should eq(response) }
 
-  describe "#public_hostname" do
-    it "returns the public hostname if the node is a cloud node" do
-      subject.automatic = {
-        "cloud" => {
-          "public_hostname" => "reset.cloud.riotgames.com"
-        }
-      }
+    context "when it executes unsuccessfully" do
+      let(:response) { [:error, double('response', stderr: 'failure_message')] }
 
-      subject.public_hostname.should eql("reset.cloud.riotgames.com")
+      it { should eq(response) }
     end
 
-    it "returns the FQDN if the node is not a cloud node" do
-      subject.automatic = {
-        "fqdn" => "reset.internal.riotgames.com"
-      }
-      subject.automatic.delete(:cloud)
-
-      subject.public_hostname.should eql("reset.internal.riotgames.com")
+    it "terminates the worker" do
+      worker.should_receive(:terminate)
+      ruby_script
     end
   end
 
-  describe "#chef_solo" do
-    pending
-  end
-
-  describe "#chef_client" do
-    subject { chef_client }
-    let(:chef_client) { node_resource.chef_client }
-    let(:worker) { double('worker', chef_client: response) }
-    let(:response) { [:ok, Ridley::HostConnector::Response.new(host)] }
+  describe "#execute_command" do
+    let(:execute_command) { instance.execute_command(host, command) }
+    let(:response) { [:ok, double('response', stdout: 'success_message')] }
+    let(:command) { "echo 'hello world'" }
+    subject { execute_command }
 
     before do
-      Ridley::HostConnector.stub(:best_connector_for).and_yield(Ridley::HostConnector::SSH)
-      Ridley::HostConnector::SSH.stub(:start).and_yield(worker)
+      Ridley::HostConnector.stub(:new).and_return(worker)
+      worker.stub(:run).and_return(response)
     end
 
-    it "returns a HostConnector::Response" do
-
-      chef_client.should be_a(Ridley::HostConnector::Response)
-    end
-  end
-
-  describe "#put_secret" do
-    subject { put_secret }
-    let(:put_secret) { node_resource.put_secret }
-    let(:worker) { double('worker', put_secret: response) }
-    let(:response) { [:ok, Ridley::HostConnector::Response.new(host)] }
-
-    before do
-      Ridley::HostConnector.stub(:best_connector_for).and_yield(Ridley::HostConnector::SSH)
-      Ridley::HostConnector::SSH.stub(:start).and_yield(worker)
-    end
+    it { should eq(response) }
 
-    context "when the client does not have an encrypted file" do
-      it "returns nil" do
-        put_secret.should be_nil
-      end
-    end
+    context "when it executes unsuccessfully" do
+      let(:response) { [:error, double('response', stderr: 'failure_message')] }
 
-    it "returns a HostConnector::Response" do
-      pending
+      it { should eq(response) }
     end
   end
 
   describe "#merge_data" do
-    before(:each) do
-      subject.name = "reset.riotgames.com"
-      subject.should_receive(:update)
-    end
+    subject { instance }
 
-    it "appends items to the run_list" do
-      subject.merge_data(run_list: ["cook::one", "cook::two"])
-
-      subject.run_list.should =~ ["cook::one", "cook::two"]
-    end
-
-    it "ensures the run_list is unique if identical items are given" do
-      subject.run_list = [ "cook::one" ]
-      subject.merge_data(run_list: ["cook::one", "cook::two"])
-
-      subject.run_list.should =~ ["cook::one", "cook::two"]
-    end
-
-    it "deep merges attributes into the normal attributes" do
-      subject.normal = {
-        one: {
-          two: {
-            four: :deep
-          }
-        }
-      }
-      subject.merge_data(attributes: {
-        one: {
-          two: {
-            three: :deep
-          }
-        }
-      })
+    it "finds the target node and sends it the merge_data message" do
+      data = double('data')
+      node = double('node')
+      node.should_receive(:merge_data).with(data)
+      subject.should_receive(:find).and_return(node)
 
-      subject.normal[:one][:two].should have_key(:four)
-      subject.normal[:one][:two][:four].should eql(:deep)
-      subject.normal[:one][:two].should have_key(:three)
-      subject.normal[:one][:two][:three].should eql(:deep)
+      subject.merge_data(node, data)
     end
   end
 end