ridley 0.0.1

data/spec/support/each_matcher.rb

@@ -0,0 +1,12 @@
+RSpec::Matchers.define :each do |check|
+  match do |actual|
+    actual.each_with_index do |index, o|
+      @object = o
+      index.should check
+    end
+  end
+
+  failure_message_for_should do |actual|
+    "at[#{@object}] #{check.failure_message_for_should}"
+  end
+end

data/spec/support/shared_examples/ridley_resource.rb

@@ -0,0 +1,237 @@
+shared_examples_for "a Ridley Resource" do |resource_klass|
+  let(:connection) { double('connection') }
+  let(:active_connection) { double('active-connection') }
+  let(:response) { double('response') }
+
+  describe "ClassMethods" do
+    subject { resource_klass }
+
+    describe "::all" do
+      it "sends a get request for the class' resource_path using the given connection" do
+        response.stub(:body) { Hash.new }
+        connection.should_receive(:get).with(subject.resource_path).and_return(response)
+        
+        subject.all(connection)
+      end
+    end
+
+    describe "::find" do
+      it "delegates to find!" do
+        id = double('id')
+        subject.should_receive(:find!).with(connection, id)
+
+        subject.find(connection, id)
+      end
+
+      context "when the resource is not found" do
+        it "returns nil" do
+          pending
+        end
+      end
+    end
+
+    describe "::find!" do
+      it "sends a get request to the given connection to the resource_path of the class for the given chef_id" do
+        chef_id = "ridley_test"
+        response.stub(:body) { Hash.new }
+        connection.should_receive(:get).with("#{subject.resource_path}/#{chef_id}").and_return(response)
+
+        subject.find(connection, chef_id)
+      end
+
+      context "when the resource is not found" do
+        it "raises a Ridley::Errors::HTTPNotFound error" do
+          pending
+        end
+      end
+    end
+
+    describe "::create" do
+      it "sends a post request to the given connection using the includer's resource_path" do
+        attrs = {
+          first_name: "jamie",
+          last_name: "winsor"
+        }
+
+        response.stub(:body) { attrs }
+        connection.should_receive(:post).with(subject.resource_path, duck_type(:to_json)).and_return(response)
+
+        subject.create(connection, attrs)
+      end
+    end
+
+    describe "::delete" do
+      it "sends a delete request to the given connection using the includer's resource_path for the given string" do
+        response.stub(:body) { Hash.new }
+        connection.should_receive(:delete).with("#{subject.resource_path}/ridley-test").and_return(response)
+
+        subject.delete(connection, "ridley-test")
+      end
+
+      it "accepts an object that responds to 'chef_id'" do
+        object = double("obj")
+        object.stub(:chef_id) { "hello" }
+        response.stub(:body) { Hash.new }
+        connection.should_receive(:delete).with("#{subject.resource_path}/#{object.chef_id}").and_return(response)
+
+        subject.delete(connection, object)
+      end
+    end
+
+    describe "::delete_all" do
+      it "sends a delete request for every object in the collection" do
+        pending
+      end
+    end
+
+    describe "::update" do
+      it "sends a put request to the given connection using the includer's resource_path with the given object" do
+        subject.stub(:chef_id) { :name }
+        subject.attribute(:name)
+        object = subject.new(name: "hello")
+        response.stub(:body) { Hash.new }
+        connection.should_receive(:put).with("#{subject.resource_path}/#{object.chef_id}", duck_type(:to_json)).and_return(response)
+
+        subject.update(connection, object)
+      end
+    end
+  end
+
+  subject { resource_klass.new(connection) }
+
+  describe "#attribute" do
+    it "returns the value of the attribute of the corresponding identifier" do
+      subject.attributes.each do |attr, value|
+        subject.attribute(attr).should eql(value)
+      end
+    end
+  end
+
+  describe "#attribute=" do
+    it "assigns the desired to the attribute of the corresponding identifier" do
+      subject.attributes.each do |attr, value|
+        subject.send(:attribute=, attr, "testval")
+      end
+
+      subject.attributes.each do |attr, value|
+        subject.attribute(attr).should eql("testval")
+      end
+    end
+  end
+
+  describe "#attributes" do
+    it "returns a hash of attributes" do
+      subject.attributes.should be_a(Hash)
+    end
+
+    it "includes attribute_defaults in the attributes" do
+      subject.class.stub(:attributes).and_return(Set.new([:val_one]))
+      subject.class.stub(:attribute_defaults).and_return(val_one: "value")
+
+      subject.attributes.should have_key(:val_one)
+      subject.attributes[:val_one].should eql("value")
+    end
+  end
+
+  describe "#save" do
+    context "when the object is valid" do
+      before(:each) { subject.stub(:valid?).and_return(true) }
+
+      it "sends a create message to the implementing class" do
+        updated = double('updated')
+        updated.stub(:attributes).and_return(Hash.new)
+        subject.class.should_receive(:create).with(connection, subject).and_return(updated)
+
+        subject.save
+      end
+
+      context "when there is an HTTPConflict" do
+        it "sends an update message to the implemeneting class" do
+          updated = double('updated')
+          updated.stub(:[]).and_return(Hash.new)
+          updated.stub(:attributes).and_return(Hash.new)
+          subject.class.should_receive(:create).and_raise(Ridley::Errors::HTTPConflict.new(updated))
+          subject.class.should_receive(:update).with(connection, subject).and_return(updated)
+
+          subject.save
+        end
+      end
+    end
+
+    context "when the object is invalid" do
+      before(:each) { subject.stub(:valid?).and_return(false) }
+
+      it "raises an InvalidObject error" do
+        lambda {
+          subject.save
+        }.should raise_error(Ridley::Errors::InvalidResource)
+      end
+    end
+  end
+
+  describe "#chef_id" do
+    it "returns the value of the chef_id attribute" do
+      subject.class.attribute(:name)
+      subject.class.stub(:chef_id) { :name }
+      subject.attributes = { name: "reset" }
+
+      subject.chef_id.should eql("reset")
+    end
+  end
+
+  describe "#from_hash" do
+    before(:each) do
+      subject.class.attribute(:name)
+      @object = subject.from_hash(name: "reset")
+    end
+
+    it "returns an instance of the implementing class" do
+      @object.should be_a(subject.class)
+    end
+
+    it "assigns the attributes to the values of the corresponding keys in the given Hash" do
+      @object.name.should eql("reset")
+    end
+  end
+
+  describe "#to_hash" do
+    it "returns a hash" do
+      subject.to_hash.should be_a(Hash)
+    end
+
+    it "delegates to .attributes" do
+      subject.should_receive(:attributes)
+
+      subject.to_hash
+    end
+  end
+
+  describe "#to_json" do
+    it "serializes the objects attributes using MultiJson" do
+      MultiJson.should_receive(:dump).with(subject.attributes, kind_of(Hash))
+
+      subject.to_json
+    end
+
+    it "returns the seralized value" do
+      MultiJson.stub(:dump).and_return("{}")
+
+      subject.to_json.should eql("{}")
+    end
+  end
+
+  describe "#from_json" do
+    before(:each) do
+      subject.class.attribute(:name)
+      @object = subject.from_json(%({"name": "reset"}))
+    end
+
+    it "returns an instance of the implementing class" do
+      @object.should be_a(subject.class)
+    end
+
+    it "assigns the attributes to the values of the corresponding keys in the given JSON" do
+      @object.name.should eql("reset")
+    end
+  end
+end

data/spec/support/spec_helpers.rb

@@ -0,0 +1,11 @@
+module Ridley
+  module SpecHelpers
+    def app_root_path
+      Pathname.new(File.expand_path('../../../', __FILE__))
+    end
+
+    def fixtures_path
+      app_root_path.join('spec/fixtures')
+    end
+  end
+end

data/spec/unit/ridley/connection_spec.rb

@@ -0,0 +1,167 @@
+require 'spec_helper'
+
+describe Ridley::Connection do
+  let(:server_url) { "https://api.opscode.com" }
+  let(:client_name) { "reset" }
+  let(:client_key) { fixtures_path.join("reset.pem").to_s }
+  let(:organization) { "vialstudios" }
+
+  let(:config) do
+    {
+      server_url: server_url,
+      client_name: client_name,
+      client_key: client_key,
+      organization: organization
+    }
+  end
+
+  describe "ClassMethods" do
+    subject { Ridley::Connection }
+
+    describe "::initialize" do
+      let(:server_url) { "https://api.opscode.com/some_path" }
+
+      describe "parsing the 'server_url' option" do
+        before(:each) do
+          @conn = subject.new(
+            server_url: server_url,
+            client_name: client_name,
+            client_key: client_key
+          )
+        end
+
+        it "assigns a 'host' attribute from the given 'server_url' option" do
+          @conn.host.should eql("api.opscode.com")
+        end
+
+        it "assigns a 'scheme' attribute from the given 'server_url' option" do
+          @conn.scheme.should eql("https")
+        end
+
+        it "sets a 'path_prefix' to the root of the given 'server_url' option" do
+          @conn.path_prefix.should eql("/")
+        end
+      end
+
+      describe "specifying an 'organization' option" do
+        before(:each) do
+          @conn = subject.new(
+            server_url: server_url,
+            client_name: client_name,
+            client_key: client_key,
+            organization: organization
+          )
+        end
+
+        it "assigns the value of the 'organization' option to an 'organization' attribute" do
+          @conn.organization.should eql(organization)
+        end
+
+        it "sets the 'path_prefix' of the connection the organization sub URI" do
+          @conn.path_prefix.should eql("/organizations/#{organization}")
+        end
+      end
+
+      it "raises 'ArgumentError' if a value for server_url is not given" do
+        lambda {
+          subject.new(
+            client_name: client_name,
+            client_key: client_key
+          )
+        }.should raise_error(ArgumentError, "missing required option(s): 'server_url'")
+      end
+
+      it "raises if a value for client_name is not given" do
+        lambda {
+          subject.new(
+            server_url: server_url,
+            client_key: client_key
+          )
+        }.should raise_error(ArgumentError, "missing required option(s): 'client_name'")
+      end
+
+      it "raises if a value for client_key is not given" do
+        lambda {
+          subject.new(
+            server_url: server_url,
+            client_name: client_name
+          )
+        }.should raise_error(ArgumentError, "missing required option(s): 'client_key'")
+      end
+    end
+
+    describe "::sync" do
+      it "raises a Ridley::Errors::InternalError if no block is given" do
+        lambda {
+          subject.sync(config)
+        }.should raise_error(Ridley::Errors::InternalError)
+      end
+    end
+  end
+
+  subject do
+    Ridley::Connection.new(config)
+  end
+
+  describe "#sync" do
+    it "raises a Ridley::Errors::InternalError if no block is given" do
+      lambda {
+        subject.sync
+      }.should raise_error(Ridley::Errors::InternalError)
+    end
+
+    describe "HTTP Request" do
+      describe "#get" do
+        it "appends the given path to the connection's server_uri path and sends a get request to it" do
+          stub_request(:get, subject.build_url("cookbooks")).
+            to_return(status: 200, body: "{}")
+
+          subject.get("cookbooks")
+        end
+      end
+
+      describe "#put" do
+        it "appends the given path to the connection's server_uri path and sends a put request to it" do
+          stub_request(:put, subject.build_url("cookbooks")).
+            with(body: "content").
+            to_return(status: 200, body: "{}")
+
+          subject.put("cookbooks", "content")
+        end
+      end
+
+      describe "#post" do
+        it "appends the given path to the connection's server_uri path and sends a post request to it" do
+          stub_request(:post, subject.build_url("cookbooks")).
+            with(body: "content").
+            to_return(status: 200, body: "{}")
+
+          subject.post("cookbooks", "content")
+        end
+      end
+
+      describe "#delete" do
+        it "appends the given path to the connection's server_uri path and sends a delete request to it" do
+          stub_request(:delete, subject.build_url("cookbooks/nginx")).
+            to_return(status: 200, body: "{}")
+
+          subject.delete("cookbooks/nginx")
+        end
+      end
+    end
+
+    describe "api_type" do
+      it "returns :foss if the organization is not set" do
+        subject.stub(:organization).and_return(nil)
+
+        subject.api_type.should eql(:foss)
+      end
+
+      it "returns :hosted if the organization is set" do
+        subject.stub(:organization).and_return("vialstudios")
+
+        subject.api_type.should eql(:hosted)
+      end
+    end
+  end
+end

data/spec/unit/ridley/errors_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Ridley::Errors do
+  describe Ridley::Errors::HTTPError do
+    describe "ClassMethods" do
+      subject { Ridley::Errors::HTTPError }
+
+      before(:each) do
+        @original = Ridley::Errors::HTTPError.class_variable_get :@@error_map
+        Ridley::Errors::HTTPError.class_variable_set :@@error_map, Hash.new
+      end
+
+      after(:each) do
+        Ridley::Errors::HTTPError.class_variable_set :@@error_map, @original
+      end
+
+      describe "::register_error" do
+        it "adds an item to the error map" do
+          subject.register_error(400)
+
+          subject.error_map.should have(1).item
+        end
+
+        it "adds a key of the given status code with a value of the class inheriting from HTTPError" do
+          class RidleyTestHTTPError < Ridley::Errors::HTTPError
+            register_error(400)
+          end
+
+          subject.error_map[400].should eql(RidleyTestHTTPError)
+        end
+      end
+    end
+  end
+end