sagamore-client 3.0.1

data/sagamore-client.gemspec

@@ -0,0 +1,20 @@
+Gem::Specification.new do |s|
+  s.name              = "sagamore-client"
+  s.version           = "3.0.1"
+  s.platform          = Gem::Platform::RUBY
+  s.authors           = ["Sagamore"]
+  s.summary           = "Sagamore client library"
+
+  s.required_rubygems_version = ">= 1.3.6"
+  
+  s.add_runtime_dependency 'patron', '~> 0.4.18'
+  s.add_runtime_dependency 'addressable', '~> 2.2.8'
+  s.add_runtime_dependency 'json', '~> 1.7.4'
+  s.add_runtime_dependency 'hashie'
+
+  s.files         = `git ls-files`.split("\n")
+  
+  s.require_path = 'lib'
+end
+
+

data/spec/sagamore/client/body_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Sagamore::Client::Body do
+  let(:hash) { {"key1" => "val1", "key2" => {"subkey1" => "subval1"}} }
+  let(:body) { Sagamore::Client::Body.new(hash)}
+
+  describe "[]" do
+    it "should support string keys" do
+      body["key1"].should == "val1"
+    end
+
+    it "should support symbol keys" do
+      body[:key1].should == "val1"
+    end
+  end
+
+  describe "nested hashes" do
+    it "should support nested indifferent access" do
+      body[:key2][:subkey1].should == "subval1"
+      body['key2']['subkey1'].should == "subval1"
+      body[:key2]['subkey1'].should == "subval1"
+      body['key2'][:subkey1].should == "subval1"
+    end
+  end
+
+  describe "to_hash" do
+    it "should return the original hash" do
+      body.to_hash.should === hash
+    end
+  end
+end
+

data/spec/sagamore/client/resource_spec.rb

@@ -0,0 +1,250 @@
+require 'spec_helper'
+
+describe Sagamore::Client::Resource do
+  include_context "client"
+
+  let(:resource_path) { '/some/path' }
+  let(:resource) { Sagamore::Client::Resource.new(client, resource_path) }
+
+  def parse_uri(uri)
+    Addressable::URI.parse(uri)
+  end
+
+  describe "[]" do
+    it "should return a new resource" do
+      resource["subpath"].should be_a Sagamore::Client::Resource
+      resource["subpath"].object_id.should_not == resource.object_id
+    end
+
+    it "should return a resource with the given subpath appended to its URI" do
+      resource["subpath"].uri.to_s.should == "/some/path/subpath"
+    end
+
+    it "should return a resource with the same client instance" do
+      resource["subpath"].client.should === resource.client
+    end
+
+    it "should accept a symbol as a path" do
+      resource[:subpath].uri.to_s.should == "/some/path/subpath"
+    end
+
+    it "should accept a symbol as a path" do
+      resource[:subpath].uri.to_s.should == "/some/path/subpath"
+    end
+
+    it "should not URI encode the given subpath" do
+      resource["subpath with spaces"].uri.to_s.should == "/some/path/subpath with spaces"
+    end
+  end
+
+  %w{query params}.each do |method|
+    describe method do
+      describe "when called with a hash" do
+        it "should set the query string parameters" do
+          resource.__send__(method, :a => 1, :b => 2).uri.to_s.should == "/some/path?a=1&b=2"
+        end
+
+        it "should URL encode the given keys and values" do
+          resource.__send__(method, "i have spaces" => "so do i: duh").uri.to_s.
+            should == "/some/path?i%20have%20spaces=so%20do%20i%3A%20duh"
+        end
+
+        it "should add bracket notation for array parameters" do
+          resource.__send__(method, :somearray => [1, 2, 3]).uri.to_s.should == "/some/path?somearray[]=1&somearray[]=2&somearray[]=3"
+        end
+      end
+
+      describe "when called without arguments" do
+        it "should return the current query string parameters as a hash" do
+          resource.__send__(method).should == {}
+          new_resource = resource.__send__(method, :a => 1, :b => 2)
+          new_resource.__send__(method).should == {"a"=>"1", "b"=>"2"}
+        end
+      end
+    end
+  end
+
+  describe "filter" do
+    describe "when given a hash" do
+      it "should add a _filter query string param" do
+        resource.filter(:a => 1, :b => 2).uri.should ==
+          '/some/path?_filter={"a":1,"b":2}'.to_uri
+      end
+    end
+
+    describe "when called multiple times" do
+      it "should append args to _filter param as JSON array" do
+        resource.filter(:a => 1).filter(:b => 2).filter(:c => 3).uri.should ==
+          '/some/path?_filter=[{"a":1},{"b":2},{"c":3}]'.to_uri
+      end
+    end
+
+    describe "when given a string" do
+      it "should add a _filter query string param" do
+        resource.filter('{"a":1,"b":2}').uri.should ==
+          '/some/path?_filter={"a":1,"b":2}'.to_uri
+      end
+    end
+  end
+
+  describe "sort" do
+    it "should set the sort parameter based on the given values" do
+      resource.sort('f1', 'f2,desc').uri.query.should == 'sort[]=f1&sort[]=f2%2Cdesc'
+    end
+
+    it "should replace any existing sort parameter" do
+      resource.sort('f1', 'f2,desc')
+      resource.sort('f3,asc', 'f4').uri.query.should == 'sort[]=f3%2Casc&sort[]=f4'
+    end
+  end
+
+  %w{count each each_page}.each do |method|
+    describe method do
+      it "should call the client's #{method} method with the resource's URI" do
+        client.should_receive(method).with(resource.uri)
+        resource.__send__(method)
+      end
+    end
+  end
+
+  %w{get head delete}.each do |method|
+    describe method do
+      it "should call the client's #{method} method with the resource's URI and a header hash" do
+        client.should_receive(method).with(resource.uri, false)
+        resource.__send__(method)
+      end
+    end
+  end
+
+  %w{put post}.each do |method|
+    describe method do
+      it "should call the client's #{method} method with the resource's URI, the given body, and a headers hash" do
+        client.should_receive(method).with(resource.uri, "body", false)
+        resource.__send__(method, "body")
+      end
+    end
+  end
+
+  describe "first" do
+    let(:response_data) {
+      {
+        :status => 200,
+        :body => {:results => [{:id => "Me first!"}, {:id => "Me second!"}]}.to_json
+      }
+    }
+
+    it "should set the per_page query string param to 1" do
+      request_stub = stub_request(:get, "#{base_url}/some/path?page=1&per_page=1").to_return(response_data)
+      resource.first
+      request_stub.should have_been_requested
+    end
+
+    it "should return the first element of the :results array" do
+      request_stub = stub_request(:get, "#{base_url}/some/path?page=1&per_page=1").to_return(response_data)
+      resource.first.should == {"id" => "Me first!"}
+    end
+  end
+
+  describe "embed" do
+    it "should support a single embed" do
+      resource.embed(:thing1).uri.to_s.should ==
+        '/some/path?_include[]=thing1'
+    end
+
+    it "should support multiple embeds" do
+      resource.embed(:thing1, :thing2, :thing3).uri.to_s.should ==
+        '/some/path?_include[]=thing1&_include[]=thing2&_include[]=thing3'
+    end
+
+    it "should merge multiple embed calls" do
+      resource.embed(:thing1, :thing2).embed(:thing3, :thing4).uri.to_s.should ==
+        '/some/path?_include[]=thing1&_include[]=thing2&_include[]=thing3&_include[]=thing4'
+    end
+
+    it "should merge multiple embed calls" do
+      resource.embed(:thing1, :thing2).embed(:thing3, :thing4).uri.to_s.should ==
+        '/some/path?_include[]=thing1&_include[]=thing2&_include[]=thing3&_include[]=thing4'
+    end
+
+    it "should merge a call to embed with a manually added _include query param" do
+      resource.query('_include[]' => :thing1).embed(:thing2, :thing3).uri.to_s.should ==
+        '/some/path?_include[]=thing1&_include[]=thing2&_include[]=thing3'
+    end
+  end
+
+  describe "while_results" do
+    it "should yield each result to the block as long as the response includes results" do
+      results = ["r1", "r2", "r3"]
+
+      request_stub = stub_request(:get, "#{base_url}/some/path").to_return do |req|
+        {:body => {:results => results}.to_json}
+      end
+
+      yielded_results = []
+
+      # timeout in case of endless loop
+      Timeout::timeout(1) do
+        resource.while_results do |result|
+          yielded_results.push results.shift
+        end
+      end
+
+      yielded_results.should == ["r1", "r2", "r3"]
+    end
+
+    it "should raise an exception if it receives an error response" do
+      request_stub = stub_request(:get, "#{base_url}/some/path").to_return do |req|
+        {:status => 400}
+      end
+
+      # timeout in case of endless loop
+      Timeout::timeout(1) do
+        expect do
+          resource.while_results do |result|
+            # nothing
+          end
+        end.to raise_error(Sagamore::Client::RequestFailed)
+      end
+    end
+
+    describe "exists?" do
+      let(:response) { mock(Sagamore::Client::Response) }
+
+      it "should return true if the response indicates success" do
+        response.stub!(:success?).and_return(true)
+        client.should_receive(:head).with(resource.uri, false).and_return(response)
+        resource.exists?.should === true
+      end
+
+      it "should return false if the response status is 404" do
+        response.stub!(:status).and_return(404)
+        response.stub!(:success?).and_return(false)
+        client.should_receive(:head).with(resource.uri, false).and_return(response)
+        resource.exists?.should === false
+      end
+
+      it "should raise a RequestFailed exception if the request fails but the status is not 404" do
+        response.stub!(:status).and_return(400)
+        response.stub!(:success?).and_return(false)
+        client.should_receive(:head).with(resource.uri, false).and_return(response)
+        expect { resource.exists? }.to raise_error { |e|
+          e.should be_a Sagamore::Client::RequestFailed
+          e.response.should === response
+          e.message.should == "Request during call to 'exists?' resulted in non-404 error."
+        }
+      end
+    end
+
+    describe "empty?" do
+      it "should return true if the resource has a count of zero" do
+        resource.stub!(:count).and_return 0
+        resource.empty?.should === true
+      end
+
+      it "should return false if the resource has a count greater than zero" do
+        resource.stub!(:count).and_return 10
+        resource.empty?.should === false
+      end
+    end
+  end
+end

data/spec/sagamore/client/response_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+describe Sagamore::Client::Response do
+  include_context "client"
+
+  let(:raw_body) { '{"key":"value"}' }
+  let(:raw_headers) { 'X-Custom-Header: Hi' }
+  let(:status_code) { 200 }
+  let(:path) { '/path' }
+  let(:patron_response) { Patron::Response.new(path, status_code, 0, raw_headers, raw_body) }
+  let(:response) { Sagamore::Client::Response.new(patron_response, client) }
+
+  describe "body" do
+    describe "if raw body is valid JSON" do
+      it "should return a Sagamore::Client::Body" do
+        response.body.should be_a Sagamore::Client::Body
+      end
+
+      it "should wrap the parsed response body" do
+        response.body.to_hash.should == {"key" => "value"}
+      end
+    end
+
+    describe "if raw body is not valid JSON" do
+      let(:raw_body) { 'I am not JSON!' }
+      it "should raise an informative error" do
+        expect { response.body }.to raise_error \
+          Sagamore::Client::BodyError,
+          "Can't parse response body. (Hint: Try the raw_body method.)"
+      end
+    end
+
+    describe "if raw body is empty" do
+      let(:raw_body) { '' }
+      it "should raise an informative error" do
+        expect { response.body }.to raise_error \
+          Sagamore::Client::BodyError,
+          "Response body is empty. (Hint: If you just created a new resource, try: response.resource.get)"
+      end
+    end
+  end
+
+  describe "raw_body" do
+    it "should return the raw body JSON" do
+      response.raw_body.should == raw_body
+    end
+  end
+
+  describe "headers" do
+    it "should return the response headers as a hash" do
+      response.headers.should == {'X-Custom-Header' => 'Hi'}
+    end
+  end
+
+  describe "resource" do
+    describe "when Location header is returned" do
+      let(:raw_headers) { 'Location: /new/path' }
+
+      it "should be a Sagamore::Client::Resource" do
+        response.resource.should be_a Sagamore::Client::Resource
+      end
+
+      it "should have the Location header value as its URL" do
+        response.resource.uri.to_s.should == '/new/path'
+      end
+    end
+
+    describe "when Location header is not returned" do
+      let(:raw_headers) { '' }
+
+      it "should be nil" do
+        response.resource.should be_nil
+      end
+    end
+  end
+
+  describe "[]" do
+    it "should forward [] to body" do
+      response.body.should_receive(:[]).with("key").and_return("value")
+      response["key"].should == "value"
+    end
+  end
+
+  describe "success?" do
+    %w{100 101 102 200 201 202 203 204 205 206 207 208 226 300 301 302 303 304 305 306 307 308}.each do |code|
+      it "should return true if the response status code is #{code}" do
+        response.stub!(:status).and_return(code.to_i)
+        response.success?.should === true
+      end
+    end
+
+    %w{400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 420 422 423 424 425 426 428 429 431
+       444 449 450 499 500 501 502 503 504 505 506 507 508 509 510 511 598 599}.each do |code|
+      it "should return false if the response status code is #{code}" do
+        response.stub!(:status).and_return(code.to_i)
+        response.success?.should === false
+      end
+    end
+  end
+end

data/spec/sagamore/client/uri_ext_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe Addressable::URI do
+  let(:uri) { Addressable::URI.parse('/relative/path') }
+
+  describe "subpath" do
+    it "should return a new URI with the path relative to the receiver" do
+      uri.subpath('other').should == Addressable::URI.parse('/relative/path/other')
+      uri.subpath('/other').should == Addressable::URI.parse('/relative/path/other')
+      uri.subpath(Addressable::URI.parse('/other')) == Addressable::URI.parse('/relative/path/other')
+    end
+  end
+
+  describe "merge_query_values!" do
+    it "should call sagamore_query_values=" do
+      uri.query_values = {'a' => '1'}
+      uri.should_receive(:sagamore_query_values=).with({'a' => '1', 'b' => '2'})
+      uri.merge_query_values! 'b' => '2'
+    end
+
+    it "should merge the given values with the existing query_values" do
+      uri.query_values = {'a' => '1', 'b' => '2'}
+      uri.merge_query_values! 'b' => '20', 'c' => '30'
+      uri.query_values.should == {'a' => '1', 'b' => '20', 'c' => '30'}
+    end
+
+    it "should set the given values if there are no existing query_values" do
+      uri.query_values.should be_nil
+      uri.merge_query_values! 'b' => '20', 'c' => '30'
+      uri.query_values.should == {'b' => '20', 'c' => '30'}
+    end
+  end
+
+  describe "sagamore_query_values=" do
+    it "should preserve empty bracket notation for array params" do
+      uri.query = 'sort[]=f1&sort[]=f2'
+      uri.__send__(:sagamore_query_values=, uri.query_values)
+      uri.to_s.should == '/relative/path?sort[]=f1&sort[]=f2'
+    end
+
+    it "should stringify boolean param values" do
+      uri.__send__(:sagamore_query_values=, {:p1 => true, :p2 => false})
+      uri.to_s.should == '/relative/path?p1=true&p2=false'
+    end
+
+    it "should support hash param values" do
+      uri.__send__(:sagamore_query_values=, {:a => {:b => {:c => 123}}})
+      uri.to_s.should == '/relative/path?a[b][c]=123'
+    end
+  end
+end