ridley 0.0.1

data/spec/unit/ridley/middleware/chef_auth_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Ridley::Middleware::ChefAuth do
+  let(:server_url) { "https://api.opscode.com/organizations/vialstudios/" }
+
+  subject do
+    Faraday.new(server_url) do |conn|
+      conn.request :chef_auth, "reset", "/Users/reset/.chef/reset.pem"
+      conn.adapter Faraday.default_adapter
+    end
+  end
+
+  pending
+end

data/spec/unit/ridley/middleware/chef_response_spec.rb

@@ -0,0 +1,213 @@
+require 'spec_helper'
+
+describe Ridley::Middleware::ChefResponse do
+  let(:server_url) { "https://api.opscode.com/organizations/vialstudios/" }
+
+  describe "ClassMethods" do
+    subject { Ridley::Middleware::ChefResponse }
+
+    describe "::success?" do
+      let(:env) { double('env') }
+
+      it "returns true if response status between 200 and 210" do
+        (200..210).each do |code|
+          env.should_receive(:[]).with(:status).and_return(code)
+
+          subject.success?(env).should be_true
+        end
+      end
+
+      it "returns false if response status is in the 300 range" do
+        (300..399).each do |code|
+          env.should_receive(:[]).with(:status).and_return(code)
+
+          subject.success?(env).should be_false
+        end
+      end
+
+      it "returns false if response status is in the 400 range" do        
+        (400..499).each do |code|
+          env.should_receive(:[]).with(:status).and_return(code)
+
+          subject.success?(env).should be_false
+        end
+      end
+
+      it "returns false if response status is in the 500 range" do
+        (500..599).each do |code|
+          env.should_receive(:[]).with(:status).and_return(code)
+
+          subject.success?(env).should be_false
+        end
+      end
+    end
+  end
+
+  subject do
+    Faraday.new(server_url) do |conn|
+      conn.response :chef_response
+      conn.response :json
+      conn.adapter Faraday.default_adapter
+    end
+  end
+
+  let(:chef_ok) do
+    {
+      status: 200,
+      body: generate_normalized_json(name: "reset-role", description: "a new role"),
+      headers: {
+        content_type: "application/json; charset=utf8"
+      }
+    }
+  end
+
+  let(:chef_bad_request) do
+    {
+      status: 400,
+      body: generate_normalized_json(error: "400 - Bad Request: Valid X-CHEF-VERSION header is required."),
+      headers: {
+        content_type: "application/json; charset=utf8"
+      }
+    }
+  end
+
+  let(:chef_unauthorized) do
+    {
+      status: 401, 
+      body: generate_normalized_json(error: "401 - Unauthorized.  You must properly authenticate your API requests!"),
+      headers: {
+        content_type: "application/json; charset=utf8"
+      }
+    }
+  end
+
+  let(:chef_forbidden) do
+    {
+      status: 403, 
+      body: generate_normalized_json(error: "403 - Forbidden."),
+      headers: {
+        content_type: "application/json; charset=utf8"
+      }
+    }
+  end
+
+  let(:chef_not_found) do
+    {
+      status: 404,
+      body: generate_normalized_json(error: [ "No routes match the request: /organizations/vialstudios/cookbookss/not_existant" ]),
+      headers: {
+        content_type: "application/json; charset=utf8"
+      }
+    }
+  end
+
+  let(:chef_conflict) do
+    {
+      status: 409,
+      body: generate_normalized_json(error: "409 - Conflict."),
+      headers: {
+        content_type: "application/json; charset=utf8"
+      }
+    }
+  end
+
+  describe "400 Bad Request" do
+    before(:each) do
+      stub_request(:get, File.join(server_url, 'cookbooks')).to_return(chef_bad_request)
+    end
+
+    it "raises a Ridley::Errors::HTTPBadRequest" do
+      lambda {
+        subject.get('cookbooks')
+      }.should raise_error(Ridley::Errors::HTTPBadRequest)
+    end
+
+    it "should have the body of the response as the error's message" do
+      lambda {
+        subject.get('cookbooks')
+      }.should raise_error("errors: '400 - Bad Request: Valid X-CHEF-VERSION header is required.'")
+    end
+  end
+
+  describe "401 Unauthorized" do
+    before(:each) do
+      stub_request(:get, File.join(server_url, 'cookbooks')).to_return(chef_unauthorized)
+    end
+
+    it "raises a Ridley::Errors::HTTPUnauthorized" do
+      lambda {
+        subject.get('cookbooks')
+      }.should raise_error(Ridley::Errors::HTTPUnauthorized)
+    end
+
+    it "should have the body of the response as the error's message" do
+      lambda {
+        subject.get('cookbooks')
+      }.should raise_error("errors: '401 - Unauthorized.  You must properly authenticate your API requests!'")
+    end
+  end
+
+  describe "403 Forbidden" do
+    before(:each) do
+      stub_request(:get, File.join(server_url, 'cookbooks')).to_return(chef_forbidden)
+    end
+
+    it "raises a Ridley::Errors::HTTPForbidden" do
+      lambda {
+        subject.get('cookbooks')
+      }.should raise_error(Ridley::Errors::HTTPForbidden)
+    end
+
+    it "should have the body of the response as the error's message" do
+      lambda {
+        subject.get('cookbooks')
+      }.should raise_error("errors: '403 - Forbidden.'")
+    end
+  end
+
+  describe "404 Not Found" do
+    before(:each) do
+      stub_request(:get, File.join(server_url, 'not_existant_route')).to_return(chef_not_found)
+    end
+
+    it "raises a Ridley::Errors::HTTPNotFound" do      
+      lambda {
+        subject.get('not_existant_route')
+      }.should raise_error(Ridley::Errors::HTTPNotFound)
+    end
+
+    it "should have the body of the response as the error's message" do
+      lambda {
+        subject.get('not_existant_route')
+      }.should raise_error(Ridley::Errors::HTTPNotFound, "errors: 'No routes match the request: /organizations/vialstudios/cookbookss/not_existant'")
+    end
+  end
+
+  describe "409 Conflict" do
+    before(:each) do
+      stub_request(:get, File.join(server_url, 'cookbooks')).to_return(chef_conflict)
+    end
+
+    it "raises a Ridley::Errors::HTTPForbidden" do
+      lambda {
+        subject.get('cookbooks')
+      }.should raise_error(Ridley::Errors::HTTPConflict)
+    end
+
+    it "should have the body of the response as the error's message" do
+      lambda {
+        subject.get('cookbooks')
+      }.should raise_error("errors: '409 - Conflict.'")
+    end
+  end
+
+  describe "200 OK" do
+    before(:each) do
+      stub_request(:get, File.join(server_url, 'roles/reset')).to_return(chef_ok)
+    end
+
+    it "returns a body containing a hash" do
+      subject.get('roles/reset').env[:body].should be_a(Hash)
+    end
+  end
+end

data/spec/unit/ridley/middleware/parse_json_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+describe Ridley::Middleware::ParseJson do
+  let(:server_url) { "https://api.opscode.com/organizations/vialstudios/" }
+
+  describe "ClassMethods" do
+    subject { Ridley::Middleware::ParseJson }
+
+    describe "::response_type" do
+      it "returns the first element of the response content-type" do
+        env = double('env')
+        env.stub(:[]).with(:response_headers).and_return(
+          'content-type' => 'text/html; charset=utf-8'
+        )
+
+        subject.response_type(env).should eql("text/html")
+      end
+    end
+
+    describe "::json_response?" do
+      it "returns true if the value of content-type includes 'application/json'" do
+        env = double('env')
+        env.stub(:[]).with(:response_headers).and_return(
+          'content-type' => 'application/json; charset=utf8'
+        )
+
+        subject.json_response?(env).should be_true
+      end
+
+      it "returns true if the value of content-type does not include 'application/json' and the body contains JSON" do
+        env = double('env')
+        env.stub(:[]).with(:response_headers).and_return(
+          'content-type' => 'text/plain'
+        )
+        subject.should_receive(:looks_like_json?).with(env).and_return(true)
+
+        subject.json_response?(env).should be_true
+      end
+
+      it "returns false if the value of content-type does not include 'application/json' and the body does not contain JSON" do
+        env = double('env')
+        env.stub(:[]).with(:response_headers).and_return(
+          'content-type' => 'text/plain'
+        )
+        subject.should_receive(:looks_like_json?).with(env).and_return(false)
+
+        subject.json_response?(env).should be_false
+      end
+    end
+
+    describe "::looks_like_json?" do
+      let(:env) { double('env') }
+
+      it "returns true if the given string contains JSON brackets" do
+        env.stub(:[]).with(:body).and_return("{\"name\":\"jamie\"}")
+
+        subject.looks_like_json?(env).should be_true
+      end
+
+      it "returns false if the given string does not contain JSON brackets" do
+        env.stub(:[]).with(:body).and_return("name")
+
+        subject.looks_like_json?(env).should be_false
+      end
+    end
+  end
+
+  subject do
+    Faraday.new(server_url) do |conn|
+      conn.response :json
+      conn.adapter Faraday.default_adapter
+    end
+  end
+end

data/spec/unit/ridley/resource_spec.rb

@@ -0,0 +1,214 @@
+require 'spec_helper'
+
+describe Ridley::Resource do
+  let(:connection) { double('connection') }
+  
+  describe "ClassMethods" do
+    subject do
+      Class.new do
+        include Ridley::Resource
+      end
+    end
+
+    it_behaves_like "a Ridley Resource", subject.call
+
+    describe "::initialize" do
+      it "has an empty Hash for attributes if no attributes have been defined" do
+        klass = subject.new(connection)
+
+        klass.attributes.should be_empty
+      end
+
+      it "assigns the given attributes to the attribute hash if the attribute is defined on the class" do
+        subject.attribute(:name)
+        klass = subject.new(connection, name: "a name")
+
+        klass.name.should eql("a name")
+        klass.attributes.should have_key(:name)
+      end
+
+      it "skips attributes which are not defined on the class when assigning attributes" do
+        klass = subject.new(connection, fake: "not here")
+
+        klass.attributes.should_not have_key(:fake)
+      end
+
+      it "merges the default values for attributes into the attributes hash" do
+        subject.stub(:attributes).and_return(Set.new([:name]))
+        subject.should_receive(:attribute_defaults).and_return(name: "whatever")
+        klass = subject.new(connection)
+
+        klass.attributes[:name].should eql("whatever")
+      end
+
+      it "explicit attributes take precedence over defaults" do
+        subject.stub(:attributes).and_return(Set.new([:name]))
+        subject.stub(:attribute_defaults).and_return(name: "default")
+
+        klass = subject.new(connection, name: "explicit_name")
+
+        klass.attributes[:name].should eql("explicit_name")
+      end
+    end
+
+    describe "::attributes" do
+      it "returns a Set" do
+        subject.attributes.should be_a(Set)
+      end
+    end
+
+    describe "::attribute" do
+      it "adds the given symbol to the attributes Set" do
+        subject.attribute(:name)
+
+        subject.attributes.should include(:name)
+      end
+
+      it "convers the given string into a symbol and adds it to the attributes Set" do
+        subject.attribute('last_name')
+
+        subject.attributes.should include(:last_name)
+      end
+
+      describe "setting a default value for the attribute" do
+        it "allows a string as the default value for the attribute" do
+          subject.attribute(:name, default: "jamie")
+
+          subject.attribute_defaults[:name].should eql("jamie")
+        end
+
+        it "allows a false boolean as the default value for the attribute" do
+          subject.attribute(:admin, default: false)
+
+          subject.attribute_defaults[:admin].should eql(false)
+        end
+
+        it "allows a true boolean as the default value for the attribute" do
+          subject.attribute(:admin, default: true)
+
+          subject.attribute_defaults[:admin].should eql(true)
+        end
+
+        it "allows nil as the default value for the attribute" do
+          subject.attribute(:certificate, default: nil)
+
+          subject.attribute_defaults[:certificate].should be_nil
+        end
+      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 "::set_resource_path" do
+      it "sets the resource_path attr on the class" do
+        subject.set_resource_path("environments")
+
+        subject.resource_path.should eql("environments")
+      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
+
+      it "sets the value of the :json_class attribute default to the given value" do
+        subject.set_chef_json_class("Chef::Environment")
+
+        subject.attribute_defaults.should have_key(:json_class)
+        subject.attribute_defaults[: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
+
+    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)
+      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
+
+    describe "::chef_id" do
+      it "returns nil if nothing is set" do
+        subject.chef_id.should be_nil
+      end
+    end
+  end
+
+  subject do
+    Class.new do
+      include Ridley::Resource
+    end.new(connection)
+  end
+
+  describe "#attribute?" do
+    context "if the class has the attribute defined" do
+      before(:each) do
+        subject.class.attribute(:name)
+      end
+
+      it "returns false if the attribute has no value" do
+        subject.name = nil
+
+        subject.attribute?(:name).should be_false
+      end
+
+      it "returns true if the attribute has a value" do
+        subject.name = "reset"
+
+        subject.attribute?(:name).should be_true
+      end
+    end
+
+    context "if the class has the attribute defined with a default value" do
+      before(:each) do
+        subject.class.attribute(:name, default: "exception")
+      end
+
+      it "returns true if the attribute has not been explicitly set" do
+        subject.attribute?(:name).should be_true
+      end
+    end
+
+    context "if the class does not have the attribute defined" do
+      it "returns false" do
+        subject.attribute?(:name).should be_false
+      end
+    end
+  end
+
+  describe "#attributes=" do
+    it "assigns the hash of attributes to the objects attributes" do
+      subject.class.attribute(:name)
+      subject.attributes = { name: "reset" }
+
+      subject.attributes[:name].should eql("reset")
+    end
+  end
+end