ridley 0.0.6 → 0.1.0

data/README.md

@@ -274,6 +274,13 @@ Unlike a role, node, client, or environment, a data bag is a container for other
     conn.search(:node)
     conn.search(:node, "name:ridley-test.local")
 
+Search will return an array of Ridley resource objects if one of the default indices is specified. Chef's default indices are
+
+* node
+* role
+* client
+* environment
+
 ## Manipulating Attributes
 
 Using Ridley you can quickly manipulate node or environment attributes. Attributes are identified by a dotted path notation.
@@ -300,6 +307,7 @@ Other attribute precedence levels can be set with their own respective set attri
       obj = node.find("jwinsor-1")
       obj.set_override_attribute("my_app.proxy.enabled", false)
       obj.set_normal_attribute("my_app.webapp.enabled", false)
+      obj.save
     end
 
 ### Environment Attributes
@@ -322,6 +330,21 @@ And the same goes for setting an environment level override attribute
       obj.save
     end
 
+### Role Attributes
+
+    conn = Ridley.connection
+    conn.sync do
+      obj = role.find("why_god_why")
+      obj.set_default_attribute("my_app.proxy.enabled", false)
+      obj.save
+    end
+
+    conn.sync do
+      obj = role.find("why_god_why")
+      obj.set_override_attribute("my_app.webapp.enabled", false)
+      obj.save
+    end
+
 # Authors and Contributors
 
 * Jamie Winsor (<jamie@vialstudios.com>)

data/lib/ridley.rb

@@ -15,7 +15,7 @@ require 'ridley/errors'
 
 # @author Jamie Winsor <jamie@vialstudios.com>
 module Ridley
-  CHEF_VERSION = '10.12.0'.freeze
+  CHEF_VERSION = '10.14.4'.freeze
 
   autoload :Log, 'ridley/log'  
   autoload :Connection, 'ridley/connection'

data/lib/ridley/resources/role.rb

@@ -12,10 +12,56 @@ module Ridley
     validates_presence_of :name
 
     attribute :description, default: String.new
-    attribute :default_attributes, default: Hash.new
-    attribute :override_attributes, default: Hash.new
+    attribute :default_attributes, default: HashWithIndifferentAccess.new
+    attribute :override_attributes, default: HashWithIndifferentAccess.new
     attribute :run_list, default: Array.new
     attribute :env_run_lists, default: Hash.new
+
+    # @param [Hash] hash
+    def default_attributes=(hash)
+      super(HashWithIndifferentAccess.new(hash))
+    end
+
+    # @param [Hash] hash
+    def override_attributes=(hash)
+      super(HashWithIndifferentAccess.new(hash))
+    end
+
+    # Set a role level override attribute given the dotted path representation of the Chef
+    # attribute and value
+    # 
+    # @example setting and saving a node level override attribute
+    #
+    #   obj = node.role("why_god_why")
+    #   obj.set_override_attribute("my_app.billing.enabled", false)
+    #   obj.save
+    #
+    # @param [String] key
+    # @param [Object] value
+    #
+    # @return [HashWithIndifferentAccess]
+    def set_override_attribute(key, value)
+      attr_hash = HashWithIndifferentAccess.from_dotted_path(key, value)
+      self.override_attributes = self.override_attributes.merge(attr_hash)
+    end
+
+    # Set a role level default attribute given the dotted path representation of the Chef
+    # attribute and value
+    # 
+    # @example setting and saving a node level default attribute
+    #
+    #   obj = node.role("why_god_why")
+    #   obj.set_default_attribute("my_app.billing.enabled", false)
+    #   obj.save
+    #
+    # @param [String] key
+    # @param [Object] value
+    #
+    # @return [HashWithIndifferentAccess]
+    def set_default_attribute(key, value)
+      attr_hash = HashWithIndifferentAccess.from_dotted_path(key, value)
+      self.default_attributes = self.default_attributes.merge(attr_hash)
+    end
   end
 
   module DSL

data/lib/ridley/resources/search.rb

@@ -3,14 +3,19 @@ module Ridley
     class << self
       # Returns an array of possible search indexes to be search on
       #
-      # @param [Ridley::Connection]
+      # @param [Ridley::Connection] connection
       #
-      # @return [Array<String, Symbol]
+      # @example
+      #
+      #   Search.indexes(connection) => [ :client, :environment, :node, :role ]
+      #
+      # @return [Array<String, Symbol>]
       def indexes(connection)
         connection.get("search").body.collect { |name, _| name }
       end
     end
 
+    # @return [Ridley::Connection]
     attr_reader :connection
     attr_reader :index
     attr_reader :query
@@ -19,9 +24,19 @@ module Ridley
     attr_accessor :rows
     attr_accessor :start
 
+    # @param [Ridley::Connection] connection
+    # @param [#to_sym] index
+    # @param [#to_s] query
+    #
+    # @option options [String] :sort
+    #   a sort string such as 'name DESC'
+    # @option options [Integer] :rows
+    #   how many rows to return
+    # @option options [Integer] :start
+    #   the result number to start from
     def initialize(connection, index, query, options = {})
       @connection = connection
-      @index      = index
+      @index      = index.to_sym
       @query      = query
 
       @sort       = options[:sort]
@@ -53,7 +68,20 @@ module Ridley
     #
     # @return [Hash]
     def run
-      connection.get(query_uri, query_options).body
+      response = connection.get(query_uri, query_options).body
+
+      case index
+      when :node
+        response[:rows].collect { |row| Node.new(connection, row) }
+      when :role
+        response[:rows].collect { |row| Role.new(connection, row) }
+      when :client
+        response[:rows].collect { |row| Client.new(connection, row) }
+      when :environment
+        response[:rows].collect { |row| Environment.new(connection, row) }
+      else
+        response[:rows]
+      end
     end
 
     private

data/lib/ridley/version.rb

@@ -1,3 +1,3 @@
 module Ridley
-  VERSION = "0.0.6"
+  VERSION = "0.1.0"
 end

data/spec/acceptance/search_resource_spec.rb

@@ -28,24 +28,6 @@ describe "Search API operations", type: "acceptance" do
     end
   end
 
-  describe "showing an index" do
-    before(:each) do
-      @result = connection.search(:node)
-    end
-
-    it "returns a hash with a total key" do
-      @result.should have_key(:total)
-    end
-
-    it "returns a hash with a start key" do
-      @result.should have_key(:start)
-    end
-
-    it "returns a hash with a rows key" do
-      @result.should have_key(:rows)
-    end
-  end
-
   describe "searching an index that doesn't exist" do
     it "it raises a Ridley::Errors::HTTPNotFound error" do
       lambda {

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

@@ -2,4 +2,92 @@ require 'spec_helper'
 
 describe Ridley::Role do
   it_behaves_like "a Ridley Resource", Ridley::Role
+
+  let(:connection) { double("connection") }
+
+  subject { Ridley::Role.new(connection) }
+
+  describe "#override_attributes=" do
+    context "given a Hash" do
+      it "returns a HashWithIndifferentAccess" do
+        subject.override_attributes = {
+          "key" => "value"
+        }
+
+        subject.override_attributes.should be_a(HashWithIndifferentAccess)
+      end
+    end
+  end
+
+  describe "#default_attributes=" do
+    context "given a Hash" do
+      it "returns a HashWithIndifferentAccess" do
+        subject.default_attributes = {
+          "key" => "value"
+        }
+
+        subject.default_attributes.should be_a(HashWithIndifferentAccess)
+      end
+    end
+  end
+
+  describe "#set_override_attribute" do
+    it "returns a HashWithIndifferentAccess" do
+      subject.set_override_attribute('deep.nested.item', true).should be_a(HashWithIndifferentAccess)
+    end
+
+    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 "returns a HashWithIndifferentAccess" do
+      subject.set_default_attribute('deep.nested.item', true).should be_a(HashWithIndifferentAccess)
+    end
+
+    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
+
+    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
+    end
+  end
 end

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

@@ -4,7 +4,16 @@ describe Ridley::Search do
   let(:connection) { double('connection') }
   let(:index) { :role }
   let(:query) { "*:*" }
-  let(:response) { double("response", body: Hash.new) }
+  let(:response) do
+    double(
+      "response", 
+      body: {
+        rows: Array.new,
+        total: 0,
+        start: 0
+      }
+    )
+  end
 
   describe "ClassMethods" do
     subject { Ridley::Search }
@@ -61,5 +70,148 @@ describe Ridley::Search do
         subject.run
       end
     end
+
+    context "when ':node' is given as index" do
+      let(:index) { :node }
+      let(:response) do
+        double(
+          "response", 
+          body: {
+            rows: [
+              {
+                chef_type: "node",
+                json_class: "Chef::Node",
+                name: "ridley-one",
+                chef_environment: "_default",
+                automatic: {},
+                normal: {},
+                default: {},
+                override: {},
+                run_list: [
+                  "recipe[one]",
+                  "recipe[two]"
+                ]
+              }
+            ],
+            total: 1,
+            start: 0
+          }
+        )
+      end
+
+      subject { Ridley::Search.new(connection, index, query) }
+
+      it "returns an array of Ridley::Node" do
+        connection.should_receive(:get).with("search/#{index}", q: query).and_return(response)
+        result = subject.run
+
+        result.should be_a(Array)
+        result.should each be_a(Ridley::Node)
+      end
+    end
+
+    context "when ':role' is given as index" do
+      let(:index) { :role }
+      let(:response) do
+        double(
+          "response", 
+          body: {
+            rows: [
+              {
+                chef_type: "role",
+                json_class: "Chef::Role",
+                name: "ridley-role-one",
+                description: "",
+                default_attributes: {},
+                override_attributes: {},
+                run_list: [],
+                env_run_lists: {}
+              }
+            ],
+            total: 1,
+            start: 0
+          }
+        )
+      end
+
+      subject { Ridley::Search.new(connection, index, query) }
+
+      it "returns an array of Ridley::Role" do
+        connection.should_receive(:get).with("search/#{index}", q: query).and_return(response)
+        result = subject.run
+
+        result.should be_a(Array)
+        result.should each be_a(Ridley::Role)
+      end
+    end
+
+    context "when ':environment' is given as index" do
+      let(:index) { :environment }
+      let(:response) do
+        double(
+          "response", 
+          body: {
+            rows: [
+              {
+                chef_type: "environment",
+                json_class: "Chef::Environment",
+                name: "ridley-env-test",
+                description: "ridley testing environment",
+                default_attributes: {},
+                override_attributes: {},
+                cookbook_versions: {}
+              }
+            ],
+            total: 1,
+            start: 0
+          }
+        )
+      end
+
+      subject { Ridley::Search.new(connection, index, query) }
+
+      it "returns an array of Ridley::Environment" do
+        connection.should_receive(:get).with("search/#{index}", q: query).and_return(response)
+        result = subject.run
+
+        result.should be_a(Array)
+        result.should each be_a(Ridley::Environment)
+      end
+    end
+
+    context "when ':client' is given as index" do
+      let(:index) { :client }
+      let(:response) do
+        double(
+          "response", 
+          body: {
+            rows: [
+              {
+                chef_type: "client",
+                name: nil,
+                admin: false,
+                validator: false,
+                certificate: "-----BEGIN CERTIFICATE-----\nMIIDOjCCAqOgAwIBAgIE47eOmDANBgkqhkiG9w0BAQUFADCBnjELMAkGA1UEBhMC\nVVMxEzARBgNVBAgMCldhc2hpbmd0b24xEDAOBgNVBAcMB1NlYXR0bGUxFjAUBgNV\nBAoMDU9wc2NvZGUsIEluYy4xHDAaBgNVBAsME0NlcnRpZmljYXRlIFNlcnZpY2Ux\nMjAwBgNVBAMMKW9wc2NvZGUuY29tL2VtYWlsQWRkcmVzcz1hdXRoQG9wc2NvZGUu\nY29tMCAXDTEyMTAwOTAwMTUxNVoYDzIxMDExMTA0MDAxNTE1WjCBnTEQMA4GA1UE\nBxMHU2VhdHRsZTETMBEGA1UECBMKV2FzaGluZ3RvbjELMAkGA1UEBhMCVVMxHDAa\nBgNVBAsTE0NlcnRpZmljYXRlIFNlcnZpY2UxFjAUBgNVBAoTDU9wc2NvZGUsIElu\nYy4xMTAvBgNVBAMUKFVSSTpodHRwOi8vb3BzY29kZS5jb20vR1VJRFMvY2xpZW50\nX2d1aWQwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCqB9KEGzl7Wcm/\nwz/x8HByZANCn6WQC+R12qQso5I6nLbTNkRP668jXG3j0R5/F5i/KearAB9ePzL/\nQe3iHtwW6u1qLI1hVNFNB+I1fGu1p6fZyIOjnLn3bqsbOkBplHOIqHsp4GVSsHKb\nD32UXZDa9S9ZFXnR4iT6hUGm5895ReZG9TDiHvBpi9NJFDZXz+AQ6JuQY8UgYMMA\nm80KbO8/NJlXbRW+siRuvr+LIsi9Mx4i63pBWAN46my291rQU31PF3IB+btfGtR/\nyDWDgMSB37bTzZeOf1Dg9fpl2vIXyu3PoHER0oYmrMQbrdwAt7qCHZNuNWn51WPb\n1PHxXL1rAgMBAAEwDQYJKoZIhvcNAQEFBQADgYEAGnJUVAv951fUhGyPOrl+LbQG\nqgchMwIn7oDLE863e66BYTDj7koK3jjhx3EBkrT2vt/xS4yW0ZRV1BNqfnNKWbBq\nMNQiKkYdTr+oq2O3plOg/q/M1eG1B5pxGXqvH0O76DVWQcV/svO+HQEi1n8y5UQd\n+pBJCygpuv78wPCM+c4=\n-----END CERTIFICATE-----\n",
+                public_key: nil,
+                private_key: nil,
+                orgname: "ridley"
+              }
+            ],
+            total: 1,
+            start: 0
+          }
+        )
+      end
+
+      subject { Ridley::Search.new(connection, index, query) }
+
+      it "returns an array of Ridley::Client" do
+        connection.should_receive(:get).with("search/#{index}", q: query).and_return(response)
+        result = subject.run
+
+        result.should be_a(Array)
+        result.should each be_a(Ridley::Client)
+      end
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ridley
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -434,7 +434,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -3992965463787136581
+      hash: 1428878148981436287
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23