ridley 0.11.0.rc1 → 0.11.1

data/lib/ridley/resource.rb

@@ -45,7 +45,7 @@ module Ridley
     #
     # @return [Array<Object>]
     def all
-      connection.get(self.class.resource_path).body.collect do |identity, location|
+      request(:get, self.class.resource_path).collect do |identity, location|
         new(self.class.representation.chef_id => identity)
       end
     end
@@ -55,7 +55,7 @@ module Ridley
     # @return [nil, Object]
     def find(object)
       chef_id = object.respond_to?(:chef_id) ? object.chef_id : object
-      new(connection.get("#{self.class.resource_path}/#{chef_id}").body)
+      new(request(:get, "#{self.class.resource_path}/#{chef_id}"))
     rescue Errors::HTTPNotFound => ex
       nil
     end
@@ -65,9 +65,11 @@ module Ridley
     # @return [Object]
     def create(object)
       resource = new(object.to_hash)
-      new_attributes = connection.post(self.class.resource_path, resource.to_json).body
+      new_attributes = request(:post, self.class.resource_path, resource.to_json)
       resource.mass_assign(resource._attributes_.deep_merge(new_attributes))
       resource
+    rescue Errors::HTTPConflict => ex
+      abort(ex)
     end
 
     # @param [String, #chef_id] object
@@ -75,7 +77,7 @@ module Ridley
     # @return [Object]
     def delete(object)
       chef_id = object.respond_to?(:chef_id) ? object.chef_id : object
-      new(connection.delete("#{self.class.resource_path}/#{chef_id}").body)
+      new(request(:delete, "#{self.class.resource_path}/#{chef_id}"))
     end
 
     # @return [Array<Object>]
@@ -90,7 +92,25 @@ module Ridley
     # @return [Object]
     def update(object)
       resource = new(object.to_hash)
-      new(connection.put("#{self.class.resource_path}/#{resource.chef_id}", resource.to_json).body)
+      new(request(:put, "#{self.class.resource_path}/#{resource.chef_id}", resource.to_json))
+    rescue Errors::HTTPConflict => ex
+      abort(ex)
     end
+
+    private
+
+      # @param [Symbol] method
+      def request(method, *args)
+        raw_request(method, *args).body
+      end
+
+      # @param [Symbol] method
+      def raw_request(method, *args)
+        unless Connection::METHODS.include?(method)
+          raise
+        end
+
+        defer { connection.send(method, *args) }
+      end
   end
 end

data/lib/ridley/resources/cookbook_resource.rb

@@ -6,7 +6,7 @@ module Ridley
 
     def initialize(connection_registry, client_name, client_key, options = {})
       super(connection_registry)
-      # @sandbox_resource = SandboxResource.new_link(connection_registry, client_name, client_key, options)
+      @sandbox_resource = SandboxResource.new_link(connection_registry, client_name, client_key, options)
     end
 
     # List all of the cookbooks and their versions present on the remote
@@ -25,7 +25,7 @@ module Ridley
     #   a hash containing keys which represent cookbook names and values which contain
     #   an array of strings representing the available versions
     def all
-      response = connection.get(self.class.resource_path).body
+      response = request(:get, self.class.resource_path)
 
       {}.tap do |cookbooks|
         response.each do |name, details|
@@ -47,7 +47,7 @@ module Ridley
       url = "#{self.class.resource_path}/#{name}/#{version}"
       url += "?purge=true" if options[:purge]
 
-      connection.delete(url).body
+      request(:delete, url)
       true
     rescue Errors::HTTPNotFound
       true
@@ -73,13 +73,15 @@ module Ridley
     #   the place to download the cookbook too. If no value is provided the cookbook
     #   will be downloaded to a temporary location
     #
+    # @raise [Errors::ResourceNotFound] if the target cookbook is not found
+    #
     # @return [String]
     #   the path to the directory the cookbook was downloaded to
     def download(name, version, destination = Dir.mktmpdir)
-      cookbook = find(name, version)
-
-      unless cookbook.nil?
+      if cookbook = find(name, version)
         cookbook.download(destination)
+      else
+        abort Errors::ResourceNotFound.new("cookbook #{name} (#{version}) was not found")
       end
     end
 
@@ -89,7 +91,7 @@ module Ridley
     # @return [nil, CookbookResource]
     def find(object, version)
       chef_id = object.respond_to?(:chef_id) ? object.chef_id : object
-      new(connection.get("#{self.class.resource_path}/#{chef_id}/#{version}").body)
+      new(request(:get, "#{self.class.resource_path}/#{chef_id}/#{version}"))
     rescue Errors::HTTPNotFound
       nil
     end
@@ -98,6 +100,8 @@ module Ridley
     #
     # @param [String] name
     #
+    # @raise [Errors::ResourceNotFound] if the target cookbook has no versions
+    #
     # @return [String, nil]
     def latest_version(name)
       ver = versions(name).collect do |version|
@@ -114,6 +118,8 @@ module Ridley
     # @param [String, Solve::Constraint] constraint
     #   constraint to solve for
     #
+    # @raise [Errors::ResourceNotFound] if the target cookbook has no versions
+    #
     # @return [CookbookResource, nil]
     #   returns the cookbook resource for the best solution or nil if no solution exists
     def satisfy(name, constraint)
@@ -150,7 +156,7 @@ module Ridley
       url = "cookbooks/#{cookbook.cookbook_name}/#{cookbook.version}"
       url << "?force=true" if options[:force]
 
-      connection.put(url, cookbook.to_json)
+      request(:put, url, cookbook.to_json)
     rescue Ridley::Errors::HTTPConflict => ex
       abort Ridley::Errors::FrozenCookbook.new(ex)
     end
@@ -206,13 +212,17 @@ module Ridley
     # @example
     #   versions("nginx") => [ "1.0.0", "1.2.0" ]
     #
+    # @raise [Errors::ResourceNotFound] if the target cookbook has no versions
+    #
     # @return [Array<String>]
     def versions(name)
-      response = connection.get("#{self.class.resource_path}/#{name}").body
+      response = request(:get, "#{self.class.resource_path}/#{name}")
 
       response[name]["versions"].collect do |cb_ver|
         cb_ver["version"]
       end
+    rescue Errors::HTTPNotFound => ex
+      abort(Errors::ResourceNotFound.new(ex))
     end
 
     private

data/lib/ridley/resources/data_bag_item_resource.rb

@@ -3,13 +3,13 @@ module Ridley
   class DataBagItemResource < Ridley::Resource
     represented_by Ridley::DataBagItemObject
 
-    attr_reader :data_bag_secret
+    attr_reader :encrypted_data_bag_secret
 
     # @param [Celluloid::Registry] connection_registry
-    # @param [String] data_bag_secret
-    def initialize(connection_registry, data_bag_secret)
+    # @param [String] encrypted_data_bag_secret
+    def initialize(connection_registry, encrypted_data_bag_secret)
       super(connection_registry)
-      @data_bag_secret = data_bag_secret
+      @encrypted_data_bag_secret = encrypted_data_bag_secret
     end
 
     # @param [Ridley::DataBagObject] data_bag
@@ -45,6 +45,8 @@ module Ridley
       new_attributes = connection.post("#{DataBagResource.resource_path}/#{data_bag.name}", resource.to_json).body
       resource.mass_assign(new_attributes)
       resource
+    rescue Errors::HTTPConflict => ex
+      abort(ex)
     end
 
     # @param [Ridley::DataBagObject] data_bag
@@ -77,6 +79,8 @@ module Ridley
       new(data_bag).from_hash(
         connection.put("#{DataBagResource.resource_path}/#{data_bag.name}/#{resource.chef_id}", resource.to_json).body
       )
+    rescue Errors::HTTPConflict => ex
+      abort(ex)
     end
   end
 end

data/lib/ridley/resources/search_resource.rb

@@ -77,20 +77,20 @@ module Ridley
     #     }
     #
     # @return [Array<ChefObject>, Hash]
-    def run(index, query_string, options = {})
+    def run(index, query_string, resources_registry, options = {})
       query_uri = self.class.query_uri(index)
       query     = self.class.build_query(query_string, options)
       response  = connection.get(query_uri, query).body
 
       case index.to_sym
       when :node
-        response[:rows].collect { |row| Ridley::NodeObject.new(row) }
+        response[:rows].collect { |row| Ridley::NodeObject.new(resources_registry[:node_resource], row) }
       when :role
-        response[:rows].collect { |row| Ridley::RoleObject.new(row) }
+        response[:rows].collect { |row| Ridley::RoleObject.new(resources_registry[:role_resource], row) }
       when :client
-        response[:rows].collect { |row| Ridley::ClientObject.new(row) }
+        response[:rows].collect { |row| Ridley::ClientObject.new(resources_registry[:client_resource], row) }
       when :environment
-        response[:rows].collect { |row| Ridley::EnvironmentObject.new(row) }
+        response[:rows].collect { |row| Ridley::EnvironmentObject.new(resources_registry[:environment_resource], row) }
       else
         response[:rows]
       end

data/lib/ridley/sandbox_uploader.rb

@@ -75,6 +75,12 @@ module Ridley
       upload_path = url.path
       url.path    = ""
 
+      # versions prior to OSS Chef 11 will strip the port to upload the file to in the checksum
+      # url returned. This will ensure we are uploading to the proper location.
+      if sandbox.send(:resource).connection.foss?
+        url.port = URI(sandbox.send(:resource).connection.server_url).port
+      end
+
       begin
         Faraday.new(url, self.options) do |c|
           c.response :chef_response

data/lib/ridley/version.rb

@@ -1,3 +1,3 @@
 module Ridley
-  VERSION = "0.11.0.rc1"
+  VERSION = "0.11.1"
 end

data/ridley.gemspec

@@ -27,7 +27,7 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency 'addressable'
   s.add_runtime_dependency 'faraday', '>= 0.8.4'
   s.add_runtime_dependency 'activesupport', '>= 3.2.0'
-  s.add_runtime_dependency 'solve', '>= 0.4.1'
+  s.add_runtime_dependency 'solve', '>= 0.4.3'
   s.add_runtime_dependency 'celluloid', '~> 0.13.0'
   s.add_runtime_dependency 'net-ssh'
   s.add_runtime_dependency 'erubis'

data/spec/acceptance/client_resource_spec.rb

@@ -1,111 +1,93 @@
 require 'spec_helper'
 
 describe "Client API operations", type: "acceptance" do
-  let(:server_url) { "https://api.opscode.com/organizations/ridley" }
+  let(:server_url)  { Ridley::RSpec::ChefServer.server_url }
   let(:client_name) { "reset" }
-  let(:client_key) { "/Users/reset/.chef/reset.pem" }
-  let(:resource) { double('client-resource') }
-
-  let(:connection) do
-    Ridley.new(
-      server_url: server_url,
-      client_name: client_name,
-      client_key: client_key
-    )
-  end
-
-  before(:all) { WebMock.allow_net_connect! }
-  after(:all) { WebMock.disable_net_connect! }
-
-  before(:each) do
-    connection.client.delete_all
-  end
+  let(:client_key)  { fixtures_path.join('reset.pem').to_s }
+  let(:connection)  { Ridley.new(server_url: server_url, client_name: client_name, client_key: client_key) }
 
   describe "finding a client" do
-    let(:target) { Ridley::ClientObject.new(resource, name: "motherbrain-test", admin: false) }
+    context "when the server has a client of the given name" do
+      before { chef_client("reset", admin: false) }
 
-    before(:each) do
-      connection.client.create(target)
+      it "returns a ClientObject" do
+        connection.client.find("reset").should be_a(Ridley::ClientObject)
+      end
     end
 
-    it "returns a valid Ridley::ClientObject" do
-      connection.sync do
-        obj = client.find(target)
-
-        obj.should be_a(Ridley::ClientObject)
-        obj.should be_valid
+    context "when the server does not have the client" do
+      it "returns a nil value" do
+        connection.client.find("not_there").should be_nil
       end
     end
   end
 
   describe "creating a client" do
-    let(:target) { Ridley::ClientObject.new(resource, name: "motherbrain-test", admin: false) }
+    it "returns a Ridley::ClientObject" do
+      connection.client.create(name: "reset").should be_a(Ridley::ClientObject)
+    end
 
-    it "returns a Ridley::ClientObject object" do
-      connection.sync do
-        client.create(target).should be_a(Ridley::ClientObject)
-      end
+    it "adds a client to the chef server" do
+      old = connection.client.all.length
+      connection.client.create(name: "reset")
+      connection.client.all.should have(old + 1).items
     end
 
-    it "has a value for 'private_key'" do
-      connection.sync do
-        client.create(target).private_key.should_not be_nil
-      end
+    it "has a value for #private_key" do
+      connection.client.create(name: "reset").private_key.should_not be_nil
     end
   end
 
   describe "deleting a client" do
-    let(:target) { Ridley::ClientObject.new(resource, name: "motherbrain-test", admin: false) }
+    before { chef_client("reset", admin: false) }
 
-    before(:each) do
-      connection.client.create(target)
+    it "returns a Ridley::ClientObject object" do
+      connection.client.delete("reset").should be_a(Ridley::ClientObject)
     end
 
-    it "returns a Ridley::ClientObject object" do
-      connection.client.delete(target).should be_a(Ridley::ClientObject)
+    it "removes the client from the server" do
+      connection.client.delete("reset")
+
+      connection.client.find("reset").should be_nil
     end
   end
 
   describe "deleting all clients" do
     before(:each) do
-      connection.sync do
-        client.create(name: "ridley-one")
-        client.create(name: "ridley-two")
-      end
+      chef_client("reset", admin: false)
+      chef_client("jwinsor", admin: false)
     end
 
-    it "returns an array of Ridley::ClientResource objects" do
+    it "returns an array of Ridley::ClientObject objects" do
       connection.client.delete_all.should each be_a(Ridley::ClientObject)
     end
 
     it "deletes all clients from the remote" do
-      connection.sync do
-        client.delete_all
-
-        client.all.should have(0).clients
-      end
+      connection.client.delete_all
+      connection.client.all.should have(0).clients
     end
   end
 
   describe "listing all clients" do
+    before(:each) do
+      chef_client("reset", admin: false)
+      chef_client("jwinsor", admin: false)
+    end
+
     it "returns an array of Ridley::ClientObject objects" do
       connection.client.all.should each be_a(Ridley::ClientObject)
     end
-  end
-
-  describe "regenerating a client's private key" do
-    let(:target) { Ridley::ClientObject.new(resource, name: "motherbrain-test", admin: false) }
 
-    before(:each) do
-      connection.client.create(target)
+    it "returns all of the clients on the server" do
+      connection.client.all.should have(4).items
     end
+  end
 
-    it "returns a Ridley::ClientObject object with a value for 'private_key'" do
-      connection.sync do
-        obj = client.regenerate_key(target)
+  describe "regenerating a client's private key" do
+    before { chef_client("reset", admin: false) }
 
-        obj.private_key.should match(/^-----BEGIN RSA PRIVATE KEY-----/)
-      end
+    it "returns a Ridley::ClientObject object with a value for #private_key" do
+      connection.client.regenerate_key("reset").private_key.should match(/^-----BEGIN RSA PRIVATE KEY-----/)
     end
   end
 end

data/spec/acceptance/cookbook_resource_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe "Client API operations", type: "acceptance" do
+  let(:server_url)  { Ridley::RSpec::ChefServer.server_url }
+  let(:client_name) { "reset" }
+  let(:client_key)  { fixtures_path.join('reset.pem').to_s }
+  let(:connection)  { Ridley.new(server_url: server_url, client_name: client_name, client_key: client_key) }
+
+  describe "uploading a cookbook" do
+    let(:path) { fixtures_path.join("example_cookbook") }
+
+    it "uploads the entire contents of the cookbook in the given path" do
+      connection.cookbook.upload(path)
+      cookbook = connection.cookbook.find("example_cookbook", "0.1.0")
+
+      cookbook.attributes.should have(1).item
+      cookbook.definitions.should have(1).item
+      cookbook.files.should have(2).items
+      cookbook.libraries.should have(1).item
+      cookbook.providers.should have(1).item
+      cookbook.recipes.should have(1).item
+      cookbook.resources.should have(1).item
+      cookbook.templates.should have(1).item
+      cookbook.root_files.should have(2).items
+    end
+  end
+end

data/spec/acceptance/data_bag_item_resource_spec.rb

@@ -1,58 +1,46 @@
 require 'spec_helper'
 
 describe "DataBag API operations", type: "acceptance" do
-  let(:server_url) { "https://api.opscode.com/organizations/ridley" }
+  let(:server_url)  { Ridley::RSpec::ChefServer.server_url }
   let(:client_name) { "reset" }
-  let(:client_key) { "/Users/reset/.chef/reset.pem" }
-
-  let(:client) do
-    Ridley.new(
-      server_url: server_url,
-      client_name: client_name,
-      client_key: client_key
-    )
-  end
-
-  before(:all) { WebMock.allow_net_connect! }
-  after(:all) { WebMock.disable_net_connect! }
+  let(:client_key)  { fixtures_path.join('reset.pem').to_s }
+  let(:connection)  { Ridley.new(server_url: server_url, client_name: client_name, client_key: client_key) }
 
-  before(:all) do
-    client.data_bag.delete_all
-    @databag = client.data_bag.create(name: "ridley-test")
+  let(:data_bag) do
+    chef_data_bag("ridley-test")
+    connection.data_bag.find("ridley-test")
   end
 
-  before { @databag.item.delete_all }
-
   describe "listing data bag items" do
     context "when the data bag has no items" do
       it "returns an empty array" do
-        @databag.item.all.should have(0).items
+        data_bag.item.all.should have(0).items
       end
     end
 
     context "when the data bag has items" do
       before(:each) do
-        @databag.item.create(id: "one")
-        @databag.item.create(id: "two")
+        data_bag.item.create(id: "one")
+        data_bag.item.create(id: "two")
       end
 
       it "returns an array with each item" do
-        @databag.item.all.should have(2).items
+        data_bag.item.all.should have(2).items
       end
     end
   end
 
   describe "creating a data bag item" do
     it "adds a data bag item to the collection of data bag items" do
-      @databag.item.create(id: "appconfig", host: "host.local", port: 80, admin: false, servers: ["one"])
+      data_bag.item.create(id: "appconfig", host: "host.local", port: 80, admin: false, servers: ["one"])
 
-      @databag.item.all.should have(1).item
+      data_bag.item.all.should have(1).item
     end
 
     context "when an 'id' field is missing" do
       it "raises an Ridley::Errors::InvalidResource error" do
         expect {
-          @databag.item.create(name: "jamie")
+          data_bag.item.create(name: "jamie")
         }.to raise_error(Ridley::Errors::InvalidResource)
       end
     end
@@ -69,9 +57,9 @@ describe "DataBag API operations", type: "acceptance" do
           "one"
         ]
       }
-      @databag.item.create(attributes)
+      data_bag.item.create(attributes)
 
-      @databag.item.find("appconfig").to_hash.should eql(attributes)
+      data_bag.item.find("appconfig").to_hash.should eql(attributes)
     end
   end
 
@@ -83,48 +71,44 @@ describe "DataBag API operations", type: "acceptance" do
       }
     end
 
-    before(:each) do
-      @databag.item.create(attributes)
-    end
+    before { data_bag.item.create(attributes) }
 
     it "returns the deleted data bag item" do
-      dbi = @databag.item.delete(attributes["id"])
+      dbi = data_bag.item.delete(attributes["id"])
 
       dbi.should be_a(Ridley::DataBagItemObject)
       dbi.attributes.should eql(attributes)
     end
 
     it "deletes the data bag item from the server" do
-      @databag.item.delete(attributes["id"])
+      data_bag.item.delete(attributes["id"])
 
-      @databag.item.find(attributes["id"]).should be_nil
+      data_bag.item.find(attributes["id"]).should be_nil
     end
   end
 
   describe "deleting all data bag items in a data bag" do
-    before(:each) do
-      @databag.item.create(id: "one")
-      @databag.item.create(id: "two")
+    before do
+      data_bag.item.create(id: "one")
+      data_bag.item.create(id: "two")
     end
 
     it "returns the array of deleted data bag items" do
-      @databag.item.delete_all.should each be_a(Ridley::DataBagItemObject)
+      data_bag.item.delete_all.should each be_a(Ridley::DataBagItemObject)
     end
 
     it "removes all data bag items from the data bag" do
-      @databag.item.delete_all
+      data_bag.item.delete_all
 
-      @databag.item.all.should have(0).items
+      data_bag.item.all.should have(0).items
     end
   end
 
   describe "updating a data bag item" do
-    before(:each) do
-      @databag.item.create(id: "one")
-    end
+    before { data_bag.item.create(id: "one") }
 
     it "returns the updated data bag item" do
-      dbi = @databag.item.update(id: "one", name: "brooke")
+      dbi = data_bag.item.update(id: "one", name: "brooke")
 
       dbi[:name].should eql("brooke")
     end
@@ -132,37 +116,35 @@ describe "DataBag API operations", type: "acceptance" do
 
   describe "saving a data bag item" do
     context "when the data bag item exists" do
-      before(:each) do
-        @dbi = @databag.item.create(id: "ridley-test")
-      end
+      let(:dbi) { data_bag.item.create(id: "ridley-test") }
 
       it "returns true if successful" do
-        @dbi[:name] = "brooke"
-        @dbi.save.should be_true
+        dbi[:name] = "brooke"
+        dbi.save.should be_true
       end
 
       it "creates a new data bag item on the remote" do
-        @dbi[:name] = "brooke"
-        @dbi.save
+        dbi[:name] = "brooke"
+        dbi.save
 
-        @databag.item.all.should have(1).item
+        data_bag.item.all.should have(1).item
       end
     end
 
     context "when the data bag item does not exist" do
       it "returns true if successful" do
-        dbi = @databag.item.new
+        dbi = data_bag.item.new
 
         dbi.attributes = { id: "not-there", name: "brooke" }
         dbi.save.should be_true
       end
 
       it "creates a new data bag item on the remote" do
-        dbi = @databag.item.new
+        dbi = data_bag.item.new
         dbi.attributes = { id: "not-there", name: "brooke" }
         dbi.save
 
-        @databag.item.all.should have(1).item
+        data_bag.item.all.should have(1).item
       end
     end
   end