harpy 0.1.0

data/spec/harpy/entry_point_spec.rb

@@ -0,0 +1,56 @@
+require "spec_helper"
+
+describe Harpy::EntryPoint do
+  let(:url) { "http://localhost" }
+  subject { Harpy::EntryPoint.new url}
+
+  it "should store url" do
+    subject.url.should == url
+  end
+
+  describe "#resource_url(resource_type)" do
+    let(:company_url) { "#{url}/company"}
+    let(:json_response) { %Q|{"link": [{"rel": "company", "href": "#{company_url}"}]}| }
+    let(:success_response) {  Typhoeus::Response.new :code => 200, :body => json_response }
+    let(:error_response) {  Typhoeus::Response.new :code => 500 }
+    it "gets entry point from url using client" do
+      Harpy.client.should_receive(:get).with(url).and_return success_response
+      subject.resource_url "user"
+    end
+    it "return nil if no link for resource_type" do
+      Harpy.client.should_receive(:get).with(url).and_return success_response
+      subject.resource_url("user").should be_nil
+    end
+    it "return url for existing resource_type" do
+      Harpy.client.should_receive(:get).with(url).and_return success_response
+      subject.resource_url("company_url").should be_nil
+    end
+    it "delegates response code != 200 to client" do
+      Harpy.client.should_receive(:get).with(url).and_return error_response
+      Harpy.client.should_receive(:invalid_code).with error_response
+      subject.resource_url("company_url")
+    end
+  end
+  
+  describe "#urn(urn)" do
+    let(:urn) { "urn:harpy:company:1" }
+    let(:company_url) { "#{url}/company/1"}
+    let(:success_response) {  Typhoeus::Response.new :code => 301, :headers => "Location: #{company_url}" }
+    let(:error_response) {  Typhoeus::Response.new :code => 500 }
+    let(:not_found_response) {  Typhoeus::Response.new :code => 404 }
+    it "query remote for this urn using client" do
+      Harpy.client.should_receive(:get).with("#{url}/#{urn}").and_return success_response
+      subject.urn(urn).should == company_url
+    end
+    it "return nil if not found" do
+      Harpy.client.should_receive(:get).with("#{url}/#{urn}").and_return not_found_response
+      subject.urn(urn).should be_nil
+    end
+    it "delegates response code != 301 or 404 to client" do
+      Harpy.client.should_receive(:get).with("#{url}/#{urn}").and_return error_response
+      Harpy.client.should_receive(:invalid_code).with error_response
+      subject.urn(urn)
+    end
+  end
+  
+end

data/spec/harpy/resource_spec.rb

@@ -0,0 +1,516 @@
+require "spec_helper"
+
+describe Harpy::Resource do
+  describe ".from_url(hash)" do
+    let(:company_url) { "http://localhost/company/1" }
+    let(:json_response) { %Q|{"name": "Harpy ltd", "link": [{"rel": "self", "href": "#{company_url}"}]}| }
+    let(:success_response) { Typhoeus::Response.new :code => 200, :body => json_response}
+    it "queries multiple resources in parallel and return instances" do
+      Typhoeus::Hydra.hydra.stub(:get, company_url).and_return success_response
+      responses = Harpy::Resource.from_url({ Harpy::Spec::Company => [company_url] })
+      responses.should have(1).keys
+      responses[Harpy::Spec::Company].should have(1).item
+      responses[Harpy::Spec::Company].first.name.should == "Harpy ltd"
+    end
+  end
+end
+
+module Harpy
+  module Spec
+    class Company
+      include Harpy::Resource
+    end
+    class User
+      include Harpy::Resource
+      validates_presence_of :firstname
+      before_validation :check_lastname
+      before_save :callback_before_save
+      before_create :callback_before_create
+      before_update :callback_before_update
+      attr_reader :callbacks
+      def initialize(*args)
+        @callbacks = []
+        super
+      end
+      def check_lastname
+        !!lastname
+      end
+      def callback_before_save
+        @callbacks << :save
+      end
+      def callback_before_create
+        @callbacks << :create
+      end
+      def callback_before_update
+        @callbacks << :update
+      end
+    end
+  end
+end
+describe "class including Harpy::Resource" do
+  subject{ Harpy::Spec::Company.new }
+  after{ Harpy.reset }
+  describe ".from_url(url)" do
+    context "called with only one url" do
+      let(:url){ "http://localhost/company/1" }
+      it "is a properly filled-in instance of Harpy::Spec::Company on success" do
+        response = Typhoeus::Response.new :code => 200, :body => <<-eos
+          {
+            "name": "Harpy Ltd",
+            "link": [
+              {"rel": "self", "href": "#{url}"}
+            ]
+          }
+        eos
+        Harpy.client.should_receive(:get).with(url).and_return response
+        result = Harpy::Spec::Company.from_url url
+        result.should be_kind_of Harpy::Spec::Company
+        result.name.should == "Harpy Ltd"
+        result.link("self").should == url
+      end
+      it "is nil when not found" do
+        response = Typhoeus::Response.new :code => 404
+        Harpy.client.should_receive(:get).with(url).and_return response
+        Harpy::Spec::Company.from_url(url).should be_nil
+      end
+      it "delegates response code != 200 or 404 to client" do
+        response = Typhoeus::Response.new :code => 500
+        Harpy.client.should_receive(:get).with(url).and_return response
+        Harpy.client.should_receive(:invalid_code).with response
+        Harpy::Spec::Company.from_url(url)
+      end
+    end
+  end
+  describe ".from_id(id)" do
+    context "when entry point is configured" do
+      it "raises Harpy::EntryPointRequired" do
+        lambda{
+          Harpy::Spec::Company.from_id(1)
+        }.should raise_error Harpy::EntryPointRequired
+      end
+    end
+    context "when entry point is set but urn has not been overriden" do
+      it "raises NotImplementedError" do
+        Harpy.entry_point_url = "http://localhost"
+        lambda{
+          Harpy::Spec::Company.from_id(1)
+        }.should raise_error NotImplementedError
+      end
+    end
+    context "when entry point is set and urn has been overriden" do
+      let(:urn) { "urn:harpy:company:1" }
+      let(:url) { "http://localhost/company/1" }
+      it "asks Harpy.entry_point to convert urn to url then call .from_url" do
+        # 1 -> urn:harpy:company:1
+        Harpy::Spec::Company.should_receive(:urn).with(1).and_return urn
+        
+        # urn:harpy:company:1 -> http://localhost/company/1
+        Harpy.entry_point = mock
+        Harpy.entry_point.should_receive(:urn).with(urn).and_return url
+        
+        # http://localhost/company/1 -> Harpy::Spec::Company instance
+        Harpy::Spec::Company.should_receive(:from_url).with(url).and_return(expected = mock)
+        Harpy::Spec::Company.from_id(1).should be expected
+      end
+      it "is nil if urn is not found" do
+        # 1 -> urn:harpy:company:1
+        Harpy::Spec::Company.should_receive(:urn).with(1).and_return urn
+        
+        # urn:harpy:company:1 -> nil
+        Harpy.entry_point = mock
+        Harpy.entry_point.should_receive(:urn).with(urn)
+        
+        Harpy::Spec::Company.from_id(1).should be_nil
+      end
+    end
+  end
+  describe ".urn(id)" do
+    it "raises NotImplementedError" do
+      lambda{
+        Harpy::Spec::Company.urn(1)
+      }.should raise_error NotImplementedError
+    end
+  end
+  describe ".resource_name" do
+    it "defaults to underscored class name" do
+      Harpy::Spec::Company.resource_name.should == "harpy/spec/company"
+    end
+  end
+  describe ".search(conditions)" do
+    let(:url){ "http://localhost/company" }
+    before do
+       Harpy.entry_point = mock
+       Harpy.entry_point.should_receive(:resource_url).with("harpy/spec/company").and_return url
+    end
+    it "return properly filled instances on 200" do
+      response = Typhoeus::Response.new :code => 200, :body => <<-eos
+      {
+        "harpy/spec/company": [
+          {
+            "firstname": "Anthony",
+            "urn": "urn:harpy:company:1",
+            "link": [
+              {"rel": "self", "href": "#{url}/1"}
+            ]
+          }
+        ],
+        "link": [
+          {"rel": "self", "href": "#{url}"}
+        ]
+      }
+      eos
+      Harpy.client.should_receive(:get).with(url, :params => {"firstname" => "Anthony"}).and_return response
+      companies = Harpy::Spec::Company.search "firstname" => "Anthony"
+      companies.should have(1).item
+      companies.first.should be_kind_of Harpy::Spec::Company
+      companies.first.firstname.should == "Anthony"
+      companies.first.id.should == "1"
+    end
+    it "delegates other response codes to client" do
+      response = Typhoeus::Response.new :code => 500
+      Harpy.client.should_receive(:get).with(url, :params => {}).and_return response
+      Harpy.client.should_receive(:invalid_code).with response
+      Harpy::Spec::Company.search
+    end
+  end
+  describe ".with_url(url)" do
+    let(:url){ "http://localhost/user/1/company" }
+    it "overrides url used for searches" do
+      response = Typhoeus::Response.new :code => 500
+      Harpy.client.should_receive(:get).with(url, :params => {}).and_return response
+      Harpy.client.should_receive(:invalid_code).with response
+      Harpy::Spec::Company.with_url(url) do
+        Harpy::Spec::Company.search
+      end
+    end
+    it "can be nested" do
+      url2 = "http://localhost/user/2/company"
+      response = Typhoeus::Response.new :code => 500
+      Harpy.client.should_receive(:get).ordered.with(url2, :params => {}).and_return response
+      Harpy.client.should_receive(:get).ordered.with(url, :params => {}).and_return response
+      Harpy.client.should_receive(:invalid_code).twice.with response
+      Harpy::Spec::Company.with_url(url) do
+        Harpy::Spec::Company.with_url(url2) do
+          Harpy::Spec::Company.search
+        end
+        Harpy::Spec::Company.search
+      end
+    end
+  end
+  describe "mass assignment" do
+    it "sets any attribute on initialization" do
+      company = Harpy::Spec::Company.new "name" => "Harpy Ltd"
+      company.name.should == "Harpy Ltd"
+    end
+    it "initialization works with string keys only" do
+      company = Harpy::Spec::Company.new :name => "Harpy Ltd"
+      company.name.should be_nil
+    end
+    it "#attributes=(attrs) merges new attributes with previous ones" do
+      company = Harpy::Spec::Company.new "name" => "Harpy Ltd", "deleted" => false
+      company.attributes = {"name" => "Harpy Inc", "custom" => true}
+      company.name.should eql "Harpy Inc"
+      company.deleted.should be_false
+      company.custom.should be_true
+    end
+    it "#attributes=(attrs) works with string keys only" do
+      company = Harpy::Spec::Company.new "name" => "Harpy Ltd"
+      company.attributes = {:name => "Harpy Inc"}
+      company.name.should eql "Harpy Ltd"
+    end
+    it "doesn't define writers for each attribute" do
+      company = Harpy::Spec::Company.new "name" => "Harpy Ltd"
+      company.should_not respond_to(:name=)
+    end
+    it "allows accessing undefined attributes when not persisted" do
+      subject.name.should be_nil
+    end
+    it "doesn't allows accessing undefined attributes when not persisted" do
+      subject.should_receive(:persisted?).and_return true
+      lambda{ subject.name }.should raise_error NoMethodError
+    end
+  end
+  describe "advanced attribute readers" do
+    let(:url){ "http://localhost/company/1" }
+    subject{ Harpy::Spec::Company.new "link" => [{"rel" => "self", "href" => url}] }
+    describe "#link(rel)" do
+      it "searches link with matching rel and return href" do
+        subject.link("self").should == url
+      end
+      it "works with symbols too" do
+        subject.link(:self).should == url
+      end
+      it "is nil if no matching link can be found" do
+        subject.link("user").should be_nil
+      end
+    end
+    describe "#url" do
+      it "searches url to self inside links" do
+        subject.should_receive(:link).with("self").and_return (expected = mock)
+        subject.url.should be expected
+      end
+      it "is nil when no link to self can be found" do
+        subject.should_receive(:link).with "self"
+        subject.url.should be_nil
+      end
+    end
+    describe "#url_collection" do
+      it "defaults to entry_point link which rel matches resource name" do
+        Harpy.entry_point = mock
+        Harpy.entry_point.should_receive(:resource_url).with("harpy/spec/company").and_return (expected = mock)
+        subject.url_collection.should be expected
+      end
+    end
+    describe "#id" do
+      it "extracts last part from urn" do
+        company = Harpy::Spec::Company.new "urn" => "urn:harpy:company:1"
+        company.id.should == "1"
+      end
+      it "works with alphanumeric ids too" do
+        company = Harpy::Spec::Company.new "urn" => "urn:harpy:company:e{39,^"
+        company.id.should == "e{39,^"
+      end
+      it "works with urns having more than 4 parts" do
+        company = Harpy::Spec::Company.new "urn" => "urn:harpy:api:company:1"
+        company.id.should == "1"
+      end
+      it "is nil without urn" do
+        subject.id.should be_nil
+      end
+      it "is nil if urn is an empty string" do
+        company = Harpy::Spec::Company.new "urn" => ""
+        company.id.should be_nil
+      end
+      it "never uses manually assigned id attribute" do
+        company = Harpy::Spec::Company.new "id" => "1"
+        company.id.should be_nil
+      end
+    end
+    describe "#persisted?" do
+      it "defaults to false when no urn is defined" do
+        company = Harpy::Spec::Company.new
+        company.persisted?.should be_false
+      end
+      it "is true when an urn is present" do
+        company = Harpy::Spec::Company.new "urn" => "urn:harpy:company:1"
+        company.persisted?.should be_true
+      end
+      it "is false when urn is an empty string" do
+        company = Harpy::Spec::Company.new "urn" => ""
+        company.persisted?.should be_false
+      end
+    end
+    describe "#inspect" do
+      subject { Harpy::Spec::Company.new "firstname" => "Anthony" }
+      it "shows class name, attributes, errors and persisted state" do
+        if RUBY_VERSION.to_f < 1.9
+          subject.inspect.should == '<Harpy::Spec::Company @attrs:{"firstname"=>"Anthony"} @errors:#<OrderedHash {}> persisted:false>'
+        else
+          subject.inspect.should == '<Harpy::Spec::Company @attrs:{"firstname"=>"Anthony"} @errors:{} persisted:false>'
+        end
+      end
+    end
+    describe "#has_key?(key)" do
+      it "is true when attribute is present" do
+        subject.has_key?("link").should be_true
+      end
+      it "does accept symbols too" do
+        subject.has_key?(:link).should be_true
+      end
+      it "is true when attribute is an empty string" do
+        company = Harpy::Spec::Company.new "urn" => ""
+        company.has_key?("urn").should be_true
+      end
+      it "is false when attribute is not defined" do
+        subject.has_key?("custom").should be_false
+      end
+      it "is false when key matches an existing method but not an attribute" do
+        subject.has_key?(:url).should be_false
+      end
+      it "does not raise error when checking for an undefined attribute even when persisted" do
+        subject.stub(:persisted?).and_return true
+        subject.has_key?("custom").should be_false
+      end
+    end
+  end
+  describe "#valid?" do
+    it "has ActiveModel validations" do
+      user = Harpy::Spec::User.new "lastname" => "Stark"
+      user.should_not be_valid
+      user.should have(1).error
+      user.errors[:firstname].should =~ ["can't be blank"]
+    end
+    it "calls before_validation which prevents validation on false" do
+      user = Harpy::Spec::User.new
+      user.should_not be_valid
+      user.should have(:no).error
+    end
+  end
+  describe "#as_json" do
+    let(:url) { "http://localhost/user/1" }
+    subject do 
+      Harpy::Spec::User.new({
+        "urn" => "urn:harpy:user:1", 
+        "company_name" => "Stark Enterprises", 
+        "link" => [{"rel" => "self", "href" => url}],
+      })
+    end
+  
+    it "exclude link and urn from attributes" do
+      subject.as_json.should == {"company_name" => "Stark Enterprises"}
+    end
+    it "does not remove link and urn from object attributes" do
+      subject.as_json
+      subject.urn.should == "urn:harpy:user:1"
+      subject.url.should == url
+    end
+  end
+  describe "#save" do
+    subject{ Harpy::Spec::User.new "company_name" => "Stark Enterprises" }
+    it "is false and does not call before_save callback if not valid" do
+      subject.should_receive :valid?
+      subject.save.should be_false
+      subject.callbacks.should =~ []
+    end
+    context "on create (valid, not persisted)" do
+      let(:url) { "http://localhost/user" }
+      let(:body) { '{"company_name":"Stark Enterprises"}' }
+      before do
+        subject.should_receive(:valid?).and_return true
+        subject.should_receive(:url_collection).and_return url
+      end
+      [200, 201, 302].each do |response_code|
+        it "is true and merges response attributes on #{response_code}" do
+          response = Typhoeus::Response.new :code => response_code, :body => <<-eos
+            {
+              "firstname": "Anthony",
+              "urn": "urn:harpy:user:1",
+              "link": [
+                {"rel": "self", "href": "#{url}/1"}
+              ]
+            }
+          eos
+          Harpy.client.should_receive(:post).with(url, :body => body).and_return response
+          subject.save.should be_true
+          subject.callbacks.should =~ [:save, :create]
+          subject.firstname.should == "Anthony"
+          subject.company_name.should == "Stark Enterprises"
+          subject.urn.should == "urn:harpy:user:1"
+        end
+      end
+      it "raises Harpy::InvalidResponseCode on 204" do
+        response = Typhoeus::Response.new :code => 204
+        Harpy.client.should_receive(:post).with(url, :body => body).and_return response
+        lambda { subject.save }.should raise_error Harpy::InvalidResponseCode, "204"
+        subject.callbacks.should =~ [:save, :create]
+      end
+      it "raises Harpy::Unauthorized on 401" do
+        response = Typhoeus::Response.new :code => 401
+        Harpy.client.should_receive(:post).with(url, :body => body).and_return response
+        lambda { subject.save }.should raise_error Harpy::Unauthorized, "Server returned a 401 response code"
+        subject.callbacks.should =~ [:save, :create]
+      end
+      it "is false and fills in errors on 422" do
+        response = Typhoeus::Response.new :code => 422, :body => <<-eos
+          {
+            "firstname": "Anthony",
+            "errors": {
+              "lastname": ["can't be blank", "must be unique"]
+            }
+          }
+        eos
+        Harpy.client.should_receive(:post).with(url, :body => body).and_return response
+        subject.save.should be_false
+        subject.callbacks.should =~ [:save, :create]
+        subject.should have(1).error
+        subject.errors[:lastname].should =~ ["can't be blank", "must be unique"]
+        subject.firstname.should be_nil
+        subject.company_name.should == "Stark Enterprises"
+      end
+      it "delegates other response codes to client" do
+        response = Typhoeus::Response.new :code => 500
+        Harpy.client.should_receive(:post).with(url, :body => body).and_return response
+        Harpy.client.should_receive(:invalid_code).with(response)
+        subject.save
+        subject.callbacks.should =~ [:save, :create]
+      end
+    end
+    context "on update (valid, persisted but link to self is not present)" do
+      it "raises Harpy::UrlRequired" do
+        subject.should_receive(:valid?).and_return true
+        subject.should_receive(:persisted?).and_return true
+        lambda{ subject.save }.should raise_error Harpy::UrlRequired
+        subject.callbacks.should =~ [:save, :update]
+      end
+    end
+    context "on update (valid, persisted and link to self is present)" do
+      let(:url) { "http://localhost/user/1" }
+      let(:body) { '{"company_name":"Stark Enterprises"}' }
+      subject do
+        Harpy::Spec::User.new({
+          "urn" => "urn:harpy:user:1", 
+          "company_name" => "Stark Enterprises", 
+          "link" => [{"rel" => "self", "href" => url}],
+        })
+      end
+      before do
+        subject.should_receive(:valid?).and_return true
+      end
+      [200, 201, 302].each do |response_code|
+        it "is true and merges response attributes on #{response_code}" do
+          response = Typhoeus::Response.new :code => response_code, :body => <<-eos
+            {
+              "firstname": "Anthony",
+              "urn": "urn:harpy:user:1",
+              "link": [
+                {"rel": "self", "href": "#{url}/1"}
+              ]
+            }
+          eos
+          Harpy.client.should_receive(:put).with(url, :body => body).and_return response
+          subject.save.should be_true
+          subject.callbacks.should =~ [:save, :update]
+          subject.firstname.should == "Anthony"
+          subject.company_name.should == "Stark Enterprises"
+        end
+      end
+      it "is true but doesn't touch attributes on 204" do
+        response = Typhoeus::Response.new :code => 204
+        Harpy.client.should_receive(:put).with(url, :body => body).and_return response
+        subject.save.should be_true
+        subject.callbacks.should =~ [:save, :update]
+        subject.company_name.should == "Stark Enterprises"
+      end
+      it "raises Harpy::Unauthorized on 401" do
+        response = Typhoeus::Response.new :code => 401
+        Harpy.client.should_receive(:put).with(url, :body => body).and_return response
+        lambda { subject.save }.should raise_error Harpy::Unauthorized, "Server returned a 401 response code"
+        subject.callbacks.should =~ [:save, :update]
+      end
+      it "is false and fills in errors on 422" do
+        response = Typhoeus::Response.new :code => 422, :body => <<-eos
+          {
+            "firstname": "Anthony",
+            "errors": {
+              "lastname": ["can't be blank", "must be unique"]
+            }
+          }
+        eos
+        Harpy.client.should_receive(:put).with(url, :body => body).and_return response
+        subject.save.should be_false
+        subject.callbacks.should =~ [:save, :update]
+        subject.should have(1).error
+        subject.errors[:lastname].should =~ ["can't be blank", "must be unique"]
+        lambda { subject.firstname }.should raise_error NoMethodError
+        subject.company_name.should == "Stark Enterprises"
+      end
+      it "delegates other response codes to client" do
+        response = Typhoeus::Response.new :code => 500
+        Harpy.client.should_receive(:put).with(url, :body => body).and_return response
+        Harpy.client.should_receive(:invalid_code).with(response)
+        subject.save
+        subject.callbacks.should =~ [:save, :update]
+      end
+    end
+  end
+end

data/spec/harpy_spec.rb

@@ -0,0 +1,97 @@
+require "spec_helper"
+
+describe Harpy do
+  after{ Harpy.reset }
+
+  it "defaults to Harpy::Client" do
+    Harpy.client.should be_kind_of Harpy::Client
+  end
+
+  it "does allow using another client" do
+    custom_client = mock
+    Harpy.client = custom_client
+    Harpy.client.should be custom_client
+  end
+
+  it "has no default entry_point_url" do
+    Harpy.entry_point_url.should be_nil
+  end
+
+  it "does allow setting an entry_point_url" do
+    Harpy.entry_point_url = "http://localhost"
+    Harpy.entry_point_url.should == "http://localhost"
+  end
+
+  it "raises Harpy::EntryPointRequired when trying to access entry_point and none has been created yet" do
+    lambda{ Harpy.entry_point }.should raise_error Harpy::EntryPointRequired
+  end
+
+  it "returns a valid Harpy::EntryPoint object if entry_point_url has been set" do
+    Harpy.entry_point_url = "http://localhost"
+    Harpy.entry_point.should be_kind_of Harpy::EntryPoint
+    Harpy.entry_point.url.should == "http://localhost"
+  end
+
+  it "does allow setting entry_point manually" do
+    Harpy.entry_point = (entry_point = mock)
+    Harpy.entry_point.should be entry_point
+    entry_point.should_receive(:url).and_return "http://localhost"
+    Harpy.entry_point_url.should == "http://localhost"
+  end
+
+  it "Harpy.reset clears both client and entry_point" do
+    Harpy.entry_point_url = "http://localhost"
+    Harpy.client = (custom_client = mock)
+    Harpy.reset
+    Harpy.entry_point_url.should be_nil
+    Harpy.client.should_not be custom_client
+  end
+end
+
+describe Harpy::Exception do
+  it "is an ::Exception" do
+    Harpy::Exception.ancestors.should include ::Exception
+  end
+end
+
+describe Harpy::EntryPointRequired do
+  it "is an Harpy::Exception" do
+    Harpy::EntryPointRequired.ancestors.should include Harpy::Exception
+  end
+end
+
+describe Harpy::UrlRequired do
+  it "is an Harpy::Exception" do
+    Harpy::UrlRequired.ancestors.should include Harpy::Exception
+  end
+end
+
+describe Harpy::BodyToBig do
+  it "is an Harpy::Exception" do
+    Harpy::BodyToBig.ancestors.should include Harpy::Exception
+  end
+end
+
+describe Harpy::ClientTimeout do
+  it "is an Harpy::Exception" do
+    Harpy::ClientTimeout.ancestors.should include Harpy::Exception
+  end
+end
+
+describe Harpy::ClientError do
+  it "is an Harpy::Exception" do
+    Harpy::ClientError.ancestors.should include Harpy::Exception
+  end
+end
+
+describe Harpy::Unauthorized do
+  it "is an Harpy::Exception" do
+    Harpy::Unauthorized.ancestors.should include Harpy::Exception
+  end
+end
+
+describe Harpy::InvalidResponseCode do
+  it "is an Harpy::Exception" do
+    Harpy::InvalidResponseCode.ancestors.should include Harpy::Exception
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+require "harpy"
+require "typhoeus"
+
+Dir[File.expand_path("../support/**/*.rb", __FILE__)].each{|f| require f}
+
+# Do not allow external connections
+Typhoeus::Hydra.allow_net_connect = false
+
+RSpec.configure do |config|
+  config.after(:each) do
+    Typhoeus::Hydra.hydra.clear_stubs
+  end
+end