ridley 0.10.2 → 0.11.0.rc1

data/spec/unit/ridley/mixin/bootstrap_binding_spec.rb

@@ -7,7 +7,7 @@ describe Ridley::BootstrapBinding do
       server_url: "https://api.opscode.com/organizations/vialstudios",
       validator_client: "chef-validator",
       validator_path: fixtures_path.join("reset.pem").to_s,
-      encrypted_data_bag_secret_path: fixtures_path.join("reset.pem").to_s,
+      encrypted_data_bag_secret: File.read(fixtures_path.join("reset.pem")),
       chef_version: "11.4.0"
     }
   end

data/spec/unit/ridley/resource_spec.rb

@@ -1,33 +1,22 @@
 require 'spec_helper'
 
 describe Ridley::Resource do
-  let(:connection) { double('connection') }
-  
-  describe "ClassMethods" do
-    subject do
-      Class.new(Ridley::Resource)
+  let(:representation) do
+    Class.new(Ridley::ChefObject) do
+      set_chef_id "id"
+      set_chef_type "thing"
+      set_chef_json_class "Chef::Thing"
     end
+  end
 
-    it_behaves_like "a Ridley Resource", Class.new(Ridley::Resource)
-
-    describe "::initialize" do
-      it "mass assigns the given attributes" do
-        new_attrs = {
-          name: "a name"
-        }
-
-        subject.any_instance.should_receive(:mass_assign).with(new_attrs)
-        subject.new(connection, new_attrs)
-      end
+  let(:resource_class) do
+    Class.new(Ridley::Resource) do
+      set_resource_path "rspecs"
     end
+  end
 
-    describe "::set_chef_type" do
-      it "sets the chef_type attr on the class" do
-        subject.set_chef_type("environment")
-
-        subject.chef_type.should eql("environment")
-      end
-    end
+  describe "ClassMethods" do
+    subject { resource_class }
 
     describe "::set_resource_path" do
       it "sets the resource_path attr on the class" do
@@ -37,126 +26,109 @@ describe Ridley::Resource do
       end
     end
 
-    describe "::set_chef_json_class" do
-      it "sets the chef_json_class attr on the class" do
-        subject.set_chef_json_class("Chef::Environment")
-
-        subject.chef_json_class.should eql("Chef::Environment")
-      end
-    end
-
-    describe "::set_chef_id" do
-      it "sets the chef_id attribute on the class" do
-        subject.set_chef_id(:environment)
-
-        subject.chef_id.should eql(:environment)
-      end
-    end
-
     describe "::resource_path" do
-      it "returns the underscored and plural name of the including class if nothing is set" do
-        subject.resource_path.should eql(subject.class.name.underscore.pluralize)
-      end
-    end
+      context "when not explicitly set" do
+        before { subject.set_resource_path(nil) }
 
-    describe "::chef_type" do
-      it "returns the underscored name of the including class if nothing is set" do
-        subject.chef_type.should eql(subject.class.name.underscore)
+        it "returns the representation's chef type, pluralized" do
+          subject.resource_path.should eql(representation.chef_type.pluralize)
+        end
       end
-    end
 
-    describe "::chef_json_class" do
-      it "returns the chef_json if nothing has been set" do
-        subject.chef_json_class.should be_nil
-      end
-    end
+      context "when explicitly set" do
+        let(:set_path) { "hello" }
+        before { subject.set_resource_path(set_path) }
 
-    describe "::chef_id" do
-      it "returns nil if nothing is set" do
-        subject.chef_id.should be_nil
+        it "returns the set value" do
+          subject.resource_path.should eql(set_path)
+        end
       end
     end
   end
 
-  subject do
-    Class.new(Ridley::Resource).new(connection)
+  let(:connection) { double('chef-connection') }
+  let(:response) { double('chef-response', body: Hash.new) }
+
+  subject { resource_class.new(double('registry')) }
+
+  before do
+    resource_class.stub(representation: representation)
+    subject.stub(connection: connection)
   end
 
-  describe "comparable" do
-    subject do
-      Class.new(Ridley::Resource) do
-        set_chef_id "name"
+  describe "::all" do
+    it "sends GET to /{resource_path}" do
+      connection.should_receive(:get).with(subject.class.resource_path).and_return(response)
 
-        attribute "name"
-        attribute "other_extra"
-        attribute "extra"
-      end
+      subject.all
     end
+  end
 
-    let(:one) { subject.new(connection) }
-    let(:two) { subject.new(connection) }
+  describe "::find" do
+    let(:id) { "some_id" }
 
-    context "given two objects with the same value for their 'chef_id'" do
-      before(:each) do
-        one.mass_assign(name: "reset", other_extra: "stuff")
-        two.mass_assign(name: "reset", extra: "stuff")
-      end
+    it "sends GET to /{resource_path}/{id} where {id} is the given ID" do
+      connection.should_receive(:get).with("#{subject.class.resource_path}/#{id}").and_return(response)
 
-      it "is equal" do
-        one.should be_eql(two)
-      end
+      subject.find(id)
     end
 
-    context "given two objects with different values for their 'chef_id'" do
-      before(:each) do
-        one.mass_assign(name: "jamie", other_extra: "stuff")
-        two.mass_assign(name: "winsor", extra: "stuff")
+    context "when the resource is not found" do
+      before do
+        connection.should_receive(:get).with("#{subject.class.resource_path}/#{id}").
+          and_raise(Ridley::Errors::HTTPNotFound.new({}))
       end
 
-      it "is not equal" do
-        one.should_not be_eql(two)
+      it "returns nil" do
+        subject.find(id).should be_nil
       end
     end
   end
 
-  describe "uniqueness" do
-    subject do
-      Class.new(Ridley::Resource) do
-        set_chef_id "name"
+  describe "::create" do
+    let(:attrs) do
+      {
+        first_name: "jamie",
+        last_name: "winsor"
+      }
+    end
 
-        attribute "name"
-        attribute "other_extra"
-        attribute "extra"
-      end
+    it "sends a post request to the given client using the includer's resource_path" do
+      connection.should_receive(:post).with(subject.class.resource_path, duck_type(:to_json)).and_return(response)
+
+      subject.create(attrs)
     end
+  end
 
-    let(:one) { subject.new(connection) }
-    let(:two) { subject.new(connection) }
+  describe "::delete" do
+    it "sends a delete request to the given client using the includer's resource_path for the given string" do
+      connection.should_receive(:delete).with("#{subject.class.resource_path}/ridley-test").and_return(response)
 
-    context "given an array of objects with the same value for their 'chef_id'" do
-      let(:nodes) do
-        one.mass_assign(name: "reset", other_extra: "stuff")
-        two.mass_assign(name: "reset", extra: "stuff")
+      subject.delete("ridley-test")
+    end
 
-        [ one, two ]
-      end
+    it "accepts an object that responds to 'chef_id'" do
+      object = double("obj")
+      object.stub(:chef_id) { "hello" }
+      connection.should_receive(:delete).with("#{subject.class.resource_path}/#{object.chef_id}").and_return(response)
 
-      it "returns only one unique element" do
-        nodes.uniq.should have(1).item
-      end
+      subject.delete( object)
     end
+  end
 
-    context "given an array of objects with different values for their 'chef_id'" do
-      let(:nodes) do
-        one.mass_assign(name: "jamie", other_extra: "stuff")
-        two.mass_assign(name: "winsor", extra: "stuff")
+  describe "::delete_all" do
+    it "sends a delete request for every object in the collection" do
+      pending
+    end
+  end
 
-        [ one, two ]
-      end
+  describe "::update" do
+    it "sends a put request to the given client using the includer's resource_path with the given object" do
+      object = subject.new(name: "hello")
+      connection.should_receive(:put).
+        with("#{subject.class.resource_path}/#{object.chef_id}", duck_type(:to_json)).and_return(response)
 
-      it "returns all of the elements" do
-        nodes.uniq.should have(2).item
-      end
+      subject.update(object)
     end
   end
 end

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

@@ -1,47 +1,32 @@
 require 'spec_helper'
 
 describe Ridley::ClientResource do
-  it_behaves_like "a Ridley Resource", Ridley::ClientResource
+  subject { described_class.new(double('registry')) }
 
-  let(:connection) { double('connection') }
-
-  describe "ClassMethods" do
-    subject { Ridley::ClientResource }
-
-    describe "::regenerate_key" do
-      let(:client) { double('client', name: "ridley-test") }
+  describe "#regenerate_key" do
+    let(:client_id) { "rspec-client" }
+    before { subject.stub(find: nil) }
 
-      it "finds the given client and regenerates it's key" do
-        client.should_receive(:regenerate_key)
-        subject.should_receive(:find!).with(connection, "ridley-test").and_return(client)
-        
-        subject.regenerate_key(connection, "ridley-test")
-      end
+    context "when a client with the given ID exists" do
+      let(:client) { double('chef-client') }
+      before { subject.should_receive(:find).with(client_id).and_return(client) }
 
-      it "returns the updated client" do
-        client.should_receive(:regenerate_key)
-        subject.should_receive(:find!).with(connection, "ridley-test").and_return(client)
+      it "sets the private key to true and updates the client" do
+        client.should_receive(:private_key=).with(true)
+        subject.should_receive(:update).with(client)
 
-        subject.regenerate_key(connection, "ridley-test").should eql(client)
+        subject.regenerate_key(client_id)
       end
     end
-  end
-
-  subject do
-    Ridley::ClientResource.new(connection, name: "ridley-test", admin: false)
-  end
-
-  describe "#regenerate_key" do
-    it "returns true if successful" do
-      subject.should_receive(:save).and_return(true)
-
-      subject.regenerate_key.should be_true
-    end
 
-    it "returns false if not successful" do
-      subject.should_receive(:save).and_return(false)
+    context "when a client with the given ID does not exist" do
+      before { subject.should_receive(:find).with(client_id).and_return(nil) }
 
-      subject.regenerate_key.should be_false
+      it "raises a ResourceNotFound error" do
+        expect {
+          subject.regenerate_key(client_id)
+        }.to raise_error(Ridley::Errors::ResourceNotFound)
+      end
     end
   end
 end

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

@@ -1,268 +1,94 @@
 require 'spec_helper'
 
 describe Ridley::CookbookResource do
-  let(:client) { double('client', connection: double('connection')) }
+  let(:client_name) { "reset" }
+  let(:client_key) { fixtures_path.join('reset.pem') }
+  let(:connection) { double('connection') }
+  subject { described_class.new(double('registry'), client_name, client_key) }
+  before  { subject.stub(connection: connection) }
 
-  subject { described_class.new(client) }
-
-  describe "ClassMethods" do
-    subject { described_class }
-    let(:server_url) { "https://api.opscode.com/organizations/vialstudios" }
-    let(:client_name) { "reset" }
-    let(:client_key) { fixtures_path.join("reset.pem") }
-
-    let(:client) do
-      Ridley.new(
-        server_url: server_url,
-        client_name: client_name,
-        client_key: client_key
-      )
-    end
-
-    describe "::all" do
-      subject { described_class.all(client) }
-
-      before(:each) do
-        stub_request(:get, File.join(server_url, "cookbooks")).
-          to_return(status: 200, body: {
-            "ant" => {
-              "url" => "https://api.opscode.com/organizations/vialstudios/cookbooks/ant",
-              "versions" => [ 
-                {
-                  "url" => "https://api.opscode.com/organizations/vialstudios/cookbooks/ant/0.10.1",
-                  "version" => "0.10.1"
-                }
-              ]
-            },
-            "apache2" => {
-              "url" => "https://api.opscode.com/organizations/vialstudios/cookbooks/apache2",
-              "versions" => [
-                {
-                  "url" => "https://api.opscode.com/organizations/vialstudios/cookbooks/apache2/1.4.0",
-                  "version" => "1.4.0"
-                }
-              ]
-            }
-          }
-        )
-      end
-
-      it "returns a Hash" do
-        subject.should be_a(Hash)
-      end
-
-      it "contains a key for each cookbook" do
-        subject.should include("ant")
-        subject.should include("apache2")
-      end
-
-      it "contains an array of versions for each cookbook" do
-        subject["ant"].should be_a(Array)
-        subject["ant"].should have(1).item
-        subject["ant"].should include("0.10.1")
-        subject["apache2"].should be_a(Array)
-        subject["apache2"].should have(1).item
-        subject["apache2"].should include("1.4.0")
-      end
-    end
-
-    describe "::delete" do
-      let(:name) { "ant" }
-      let(:version) { "1.0.0" }
-
-      it "sends a DELETE to the cookbook version URL" do
-        stub_request(:delete, File.join(server_url, "cookbooks", name, version)).
-          to_return(status: 200, body: {})
-
-        described_class.delete(client, name, version)
-      end
-
-      context "when :purge is true" do
-        it "appends ?purge=true to the end of the URL" do
-          stub_request(:delete, File.join(server_url, "cookbooks", name, "#{version}?purge=true")).
-            to_return(status: 200, body: {})
-
-          described_class.delete(client, name, version, purge: true)
-        end
-      end
-    end
-
-    describe "::delete_all" do
-      let(:name) { "ant" }
-      let(:versions) { ["1.0.0", "1.2.0", "2.0.0"] }
-      let(:options) { Hash.new }
-
-      subject { described_class }
-
-      it "deletes each version of the cookbook" do
-        subject.should_receive(:versions).with(client, name).and_return(versions)
+  describe "#download" do
+    pending
+  end
 
-        versions.each do |version|
-          subject.should_receive(:delete).with(client, name, version, options)
-        end
+  describe "#latest_version" do
+    let(:name) { "ant" }
 
-        subject.delete_all(client, name, options)
-      end
+    before(:each) do
+      subject.should_receive(:versions).with(name).and_return(versions)
     end
 
-    describe "::latest_version" do
-      let(:name) { "ant" }
-      subject { described_class }
-
-      before(:each) do
-        subject.should_receive(:versions).with(client, name).and_return(versions)
-      end
-
-      context "when the cookbook has no versions" do
-        let(:versions) { Array.new }
-
-        it "returns nil" do
-          subject.latest_version(client, name).should be_nil
-        end
-      end
+    context "when the cookbook has no versions" do
+      let(:versions) { Array.new }
 
-      context "when the cookbook has versions" do
-        let(:versions) do
-          [ "1.0.0", "1.2.0", "3.0.0", "1.4.1" ]
-        end
-
-        it "returns nil" do
-          subject.latest_version(client, name).should eql("3.0.0")
-        end
+      it "returns nil" do
+        subject.latest_version(name).should be_nil
       end
     end
 
-    describe "::versions" do
-      let(:cookbook) { "artifact" }
-      subject { described_class.versions(client, cookbook) }
-
-      before(:each) do
-        stub_request(:get, File.join(server_url, "cookbooks", cookbook)).
-          to_return(status: 200, body: {
-            cookbook => {
-              "versions" => [
-                {
-                  "url" => "https://api.opscode.com/organizations/ridley/cookbooks/artifact/1.0.0",
-                  "version" => "1.0.0"
-                },
-                {
-                  "url" => "https://api.opscode.com/organizations/ridley/cookbooks/artifact/1.1.0",
-                  "version" => "1.1.0"
-                },
-                {
-                  "url" => "https://api.opscode.com/organizations/ridley/cookbooks/artifact/1.2.0",
-                  "version" => "1.2.0"
-                }
-              ],
-              "url" => "https://api.opscode.com/organizations/ridley/cookbooks/artifact"}
-            }
-          )
+    context "when the cookbook has versions" do
+      let(:versions) do
+        [ "1.0.0", "1.2.0", "3.0.0", "1.4.1" ]
       end
 
-      it "returns an array" do
-        subject.should be_a(Array)
-      end
-
-      it "contains a version string for each cookbook version available" do
-        subject.should have(3).versions
-        subject.should include("1.0.0")
-        subject.should include("1.1.0")
-        subject.should include("1.2.0")
+      it "returns nil" do
+        subject.latest_version(name).should eql("3.0.0")
       end
     end
-
-    describe "::upload" do
-      pending
-    end
-
-    describe "::update" do
-      pending
-    end
   end
 
-  describe "#download" do
-    it "downloads each file" do
-      subject.stub(:manifest) do
-        {
-          resources: [],
-          providers: [],
-          recipes: [
+  describe "#versions" do
+    let(:cookbook) { "artifact" }
+    let(:versions_path) { "#{described_class.resource_path}/#{cookbook}" }
+    let(:response) do
+      double(body: {
+        cookbook => {
+          "versions" => [
             {
-              checksum: "aa3505d3eb8ce328ea84a4333df05b07",
-              name: "default.rb",
-              path: "recipes/default.rb",
-              specificity: "default",
-              url: "https://chef.lax1.riotgames.com/organizations/reset/cookbooks/ohai/1.0.2/files/aa3505d3eb8ce328ea84a4333df05b07"
-            }
-          ],
-          definitions: [],
-          libraries: [],
-          attributes: [],
-          files: [
+              "url" => "https://api.opscode.com/organizations/ridley/cookbooks/artifact/1.0.0",
+              "version" => "1.0.0"
+            },
+            {
+              "url" => "https://api.opscode.com/organizations/ridley/cookbooks/artifact/1.1.0",
+              "version" => "1.1.0"
+            },
             {
-              checksum: "85bc3bb921efade3f2566a668ab4b639",
-              name: "README",
-              path: "files/default/plugins/README",
-              specificity: "plugins",
-              url: "https://chef.lax1.riotgames.com/organizations/reset/cookbooks/ohai/1.0.2/files/85bc3bb921efade3f2566a668ab4b639"
+              "url" => "https://api.opscode.com/organizations/ridley/cookbooks/artifact/1.2.0",
+              "version" => "1.2.0"
             }
           ],
-          templates: [],
-          root_files: []
+          "url" => "https://api.opscode.com/organizations/ridley/cookbooks/artifact"
         }
-      end
-
-      subject.should_receive(:download_file).with(:recipes, "recipes/default.rb", anything)
-      subject.should_receive(:download_file).with(:files, "files/default/plugins/README", anything)
-
-      subject.download
+      })
     end
-  end
-
-  describe "#download_file" do
-    let(:destination) { tmp_path.join('fake.file').to_s }
 
     before(:each) do
-      subject.stub(:root_files) { [ { path: 'metadata.rb', url: "http://test.it/file" } ] }
+      connection.should_receive(:get).with(versions_path).and_return(response)
     end
 
-    it "downloads the file from the file's url" do
-      client.connection.should_receive(:stream).with("http://test.it/file", destination)
-
-      subject.download_file(:root_file, "metadata.rb", destination)
+    it "returns an array" do
+      subject.versions(cookbook).should be_a(Array)
     end
 
-    context "when given an unknown filetype" do
-      it "raises an UnknownCookbookFileType error" do
-        expect {
-          subject.download_file(:not_existant, "default.rb", destination)
-        }.to raise_error(Ridley::Errors::UnknownCookbookFileType)
-      end
-    end
+    it "contains a version string for each cookbook version available" do
+      result = subject.versions(cookbook)
 
-    context "when the cookbook doesn't have the specified file" do
-      before(:each) do
-        subject.stub(:root_files) { Array.new }
-      end
-
-      it "returns nil" do
-        subject.download_file(:root_file, "metadata.rb", destination).should be_nil
-      end
+      result.should have(3).versions
+      result.should include("1.0.0")
+      result.should include("1.1.0")
+      result.should include("1.2.0")
     end
   end
 
-  describe "#manifest" do
-    it "returns a Hash" do
-      subject.manifest.should be_a(Hash)
-    end
+  describe "#satisfy" do
+    pending
+  end
 
-    it "has a key for each item in FILE_TYPES" do
-      subject.manifest.keys.should =~ described_class::FILE_TYPES
-    end
+  describe "#upload" do
+    pending
+  end
 
-    it "contains an empty array for each key" do
-      subject.manifest.should each be_a(Array)
-      subject.manifest.values.should each be_empty
-    end
+  describe "#update" do
+    pending
   end
 end