heartland-retail 5.0.0

data/spec/heartland/client/resource_spec.rb

@@ -0,0 +1,318 @@
+require 'spec_helper'
+
+describe HeartlandRetail::Client::Resource do
+  include_context "client"
+
+  let(:resource_path) { '/some/path' }
+  let(:resource) { HeartlandRetail::Client::Resource.new(client, resource_path) }
+
+  describe "[]" do
+    it "should return a new resource" do
+      expect(resource["subpath"]).to be_a HeartlandRetail::Client::Resource
+      expect(resource["subpath"].object_id).not_to eq(resource.object_id)
+    end
+
+    it "should return a resource with the given subpath appended to its URI" do
+      expect(resource["subpath"].uri.to_s).to eq("#{base_url}/some/path/subpath")
+    end
+
+    it "should return a resource with the same client instance" do
+      expect(resource["subpath"].client).to be === resource.client
+    end
+
+    it "should accept a symbol as a path" do
+      expect(resource[:subpath].uri.to_s).to eq("#{base_url}/some/path/subpath")
+    end
+
+    it "should URI encode the given subpath" do
+      expect(resource["subpath with spaces"].uri.to_s).to eq(
+        "#{base_url}/some/path/subpath%20with%20spaces"
+      )
+    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
+          expect(resource.__send__(method, :a => 1, :b => 2).uri.to_s).to eq("#{base_url}/some/path?a=1&b=2")
+        end
+
+        it "should URL encode the given keys and values" do
+          expect(resource.__send__(method, "i have spaces" => "so do i: duh").uri.to_s).to eq(
+            "#{base_url}/some/path?i+have+spaces=so+do+i%3A+duh"
+          )
+        end
+
+        it "should add bracket notation for array parameters" do
+          expect(resource.__send__(method, :somearray => [1, 2, 3]).uri.to_s).to eq(
+            "#{base_url}/some/path?somearray%5B%5D=1&somearray%5B%5D=2&somearray%5B%5D=3"
+          )
+        end
+
+        it "should return a new resource without modifying the existing URI" do
+          new_resource = resource.query(per_page: 1)
+          expect(new_resource.uri.to_s).to eq("#{base_url}/some/path?per_page=1")
+          expect(resource.uri.to_s).to eq("#{base_url}/some/path")
+        end
+      end
+
+      describe "when called without arguments" do
+        it "should return the current query string parameters as a hash" do
+          expect(resource.__send__(method)).to eq({})
+          new_resource = resource.__send__(method, :a => 1, :b => 2)
+          expect(new_resource.__send__(method)).to eq({"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
+        expect(resource.filter(:a => 1, :b => 2).uri).to eq(
+          "#{base_url}/some/path?_filter=%7B%22a%22%3A1%2C%22b%22%3A2%7D".to_uri
+        )
+      end
+    end
+
+    describe "when called multiple times" do
+      it "should append args to _filter param as JSON array" do
+        expect(resource.filter(:a => 1).filter(:b => 2).filter(:c => 3).uri).to eq(
+          "#{base_url}/some/path?_filter=%5B%7B%22a%22%3A1%7D%2C%7B%22b%22%3A2%7D%2C%7B%22c%22%3A3%7D%5D".to_uri
+        )
+      end
+    end
+
+    describe "when given a string" do
+      it "should add a _filter query string param" do
+        expect(resource.filter('{"a":1,"b":2}').uri).to eq(
+          "#{base_url}/some/path?_filter=%7B%22a%22%3A1%2C%22b%22%3A2%7D".to_uri
+        )
+      end
+    end
+
+    describe "when called multiple times with other methods" do
+      it "should append args to _filter param as JSON array" do
+        expect(resource.filter(:a => 1).embed(:other).only(:field).filter(:b => 2).uri).to eq(
+          "#{base_url}/some/path?_filter=%5B%7B%22a%22%3A1%7D%2C%7B%22b%22%3A2%7D%5D&_include%5B%5D=other&_only%5B%5D=field".to_uri
+        )
+      end
+    end
+  end
+
+  describe "sort" do
+    it "should set the sort parameter based on the given values" do
+      expect(resource.sort('f1', 'f2,desc').uri.to_s).to eq(
+        "#{base_url}/some/path?sort%5B%5D=f1&sort%5B%5D=f2%2Cdesc"
+      )
+    end
+
+    it "should replace any existing sort parameter" do
+      resource.sort('f1', 'f2,desc')
+      expect(resource.sort('f3,asc', 'f4').uri.to_s).to eq(
+        "#{base_url}/some/path?sort%5B%5D=f3%2Casc&sort%5B%5D=f4"
+      )
+    end
+  end
+
+  describe "only" do
+    it "should set the _only parameter based on the given values" do
+      expect(resource.only('f1', 'f2').uri.to_s).to eq(
+        "#{base_url}/some/path?_only%5B%5D=f1&_only%5B%5D=f2"
+      )
+    end
+
+    it "should replace the existing _only parameters" do
+      expect(resource.only('f1').only('f2', 'f3').uri.to_s).to eq(
+        "#{base_url}/some/path?_only%5B%5D=f2&_only%5B%5D=f3"
+      )
+    end
+  end
+
+  %w{each each_page}.each do |method|
+    describe method do
+      it "should call the client's #{method} method with the resource's URI" do
+        expect(client).to 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
+        expect(client).to 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
+        expect(client).to receive(method).with(resource.uri, "body", false)
+        resource.__send__(method, "body")
+      end
+    end
+  end
+
+  describe "count" do
+    let(:response_data) {
+      {
+        :status => 200,
+        :body => {total: 123}.to_json
+      }
+    }
+
+    it "should call the client's count method with the resource's URI" do
+      expect(client).to receive(:count).with(resource.uri)
+      resource.count
+    end
+
+    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.count
+      expect(request_stub).to have_been_requested
+    end
+
+    it "should return the resource count" do
+      request_stub = stub_request(:get, "#{base_url}/some/path?page=1&per_page=1").to_return(response_data)
+      expect(resource.count).to eq(123)
+    end
+
+    it "should not modify the original resource URI" do
+      request_stub = stub_request(:get, "#{base_url}/some/path?page=1&per_page=1").to_return(response_data)
+      resource.count
+      expect(resource.uri.to_s).to eq("#{base_url}/some/path")
+    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
+      expect(request_stub).to 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)
+      expect(resource.first).to eq({"id" => "Me first!"})
+    end
+
+    it "should not modify the original resource URI" do
+      request_stub = stub_request(:get, "#{base_url}/some/path?page=1&per_page=1").to_return(response_data)
+      resource.first
+      expect(resource.uri.to_s).to eq("#{base_url}/some/path")
+    end
+  end
+
+  describe "embed" do
+    it "should support a single embed" do
+      expect(resource.embed(:thing1).uri.to_s).to eq(
+        "#{base_url}/some/path?_include%5B%5D=thing1"
+      )
+    end
+
+    it "should support multiple embeds" do
+      expect(resource.embed(:thing1, :thing2, :thing3).uri.to_s).to eq(
+        "#{base_url}/some/path?_include%5B%5D=thing1&_include%5B%5D=thing2&_include%5B%5D=thing3"
+      )
+    end
+
+    it "should merge multiple embed calls" do
+      expect(resource.embed(:thing1, :thing2).embed(:thing3, :thing4).uri.to_s).to eq(
+        "#{base_url}/some/path?_include%5B%5D=thing1&_include%5B%5D=thing2&_include%5B%5D=thing3&_include%5B%5D=thing4"
+      )
+    end
+
+    it "should merge a call to embed with a manually added _include query param" do
+      expect(resource.query('_include[]' => :thing1).embed(:thing2, :thing3).uri.to_s).to eq(
+        "#{base_url}/some/path?_include%5B%5D=thing1&_include%5B%5D=thing2&_include%5B%5D=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(10) do
+        resource.while_results do |result|
+          yielded_results.push results.shift
+        end
+      end
+
+      expect(yielded_results).to eq(["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(10) do
+        expect do
+          resource.while_results do |result|
+            # nothing
+          end
+        end.to raise_error(HeartlandRetail::Client::RequestFailed)
+      end
+    end
+
+    describe "exists?" do
+      let(:response) { double(HeartlandRetail::Client::Response) }
+
+      it "should return true if the response indicates success" do
+        allow(response).to receive(:success?).and_return(true)
+        expect(client).to receive(:head).with(resource.uri, false).and_return(response)
+        expect(resource.exists?).to be === true
+      end
+
+      it "should return false if the response status is 404" do
+        allow(response).to receive(:status).and_return(404)
+        allow(response).to receive(:success?).and_return(false)
+        expect(client).to receive(:head).with(resource.uri, false).and_return(response)
+        expect(resource.exists?).to be === false
+      end
+
+      it "should raise a RequestFailed exception if the request fails but the status is not 404" do
+        allow(response).to receive(:status).and_return(400)
+        allow(response).to receive(:success?).and_return(false)
+        expect(client).to receive(:head).with(resource.uri, false).and_return(response)
+        expect { resource.exists? }.to raise_error { |e|
+          expect(e).to be_a HeartlandRetail::Client::RequestFailed
+          expect(e.response).to be === response
+          expect(e.message).to eq("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
+        allow(resource).to receive(:count).and_return 0
+        expect(resource.empty?).to be === true
+      end
+
+      it "should return false if the resource has a count greater than zero" do
+        allow(resource).to receive(:count).and_return 10
+        expect(resource.empty?).to be === false
+      end
+    end
+  end
+end

data/spec/heartland/client/response_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+describe HeartlandRetail::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(:faraday_response) do
+    env = Faraday::Env.new(:get, raw_body, path, nil, nil, nil, nil,
+                           nil, raw_body, raw_headers, status_code)
+
+    Faraday::Response.new(env)
+  end
+  let(:response) { HeartlandRetail::Client::Response.new(faraday_response, client) }
+
+  describe "body" do
+    describe "if raw body is valid JSON" do
+      it "should return a HeartlandRetail::Client::Body" do
+        expect(response.body).to be_a HeartlandRetail::Client::Body
+      end
+
+      it "should wrap the parsed response body" do
+        expect(response.body.to_hash).to eq({"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 \
+          HeartlandRetail::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 \
+          HeartlandRetail::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
+      expect(response.raw_body).to eq(raw_body)
+    end
+  end
+
+  describe "headers" do
+    it "should return the response headers as a hash" do
+      expect(response.headers).to eq({'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 HeartlandRetail::Client::Resource" do
+        expect(response.resource).to be_a HeartlandRetail::Client::Resource
+      end
+
+      it "should have the Location header value as its URL" do
+        expect(response.resource.uri.to_s).to eq("#{base_url}/new/path")
+      end
+    end
+
+    describe "when Location header is not returned" do
+      let(:raw_headers) { Hash.new }
+
+      it "should be nil" do
+        expect(response.resource).to be_nil
+      end
+    end
+  end
+
+  describe "[]" do
+    it "should forward [] to body" do
+      expect(response.body).to receive(:[]).with("key").and_return("value")
+      expect(response["key"]).to eq("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
+        allow(response).to receive(:status).and_return(code.to_i)
+        expect(response.success?).to be === 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
+        allow(response).to receive(:status).and_return(code.to_i)
+        expect(response.success?).to be === false
+      end
+    end
+  end
+end

data/spec/heartland/client/uri_spec.rb

@@ -0,0 +1,157 @@
+require 'spec_helper'
+
+describe HeartlandRetail::Client::URI do
+  let(:uri) { described_class.parse('/relative/path') }
+
+  describe "subpath" do
+    it "should return a new URI with the path relative to the receiver" do
+      expect(uri.subpath('other')).to eq(described_class.parse('/relative/path/other'))
+      expect(uri.subpath('/other')).to eq(described_class.parse('/relative/path/other'))
+      uri.subpath(described_class.parse('/other')) == described_class.parse('/relative/path/other')
+    end
+  end
+
+  describe "parse" do
+    describe "when called with a URI object" do
+      it "should return a cloned URI object" do
+        parsed_uri = described_class.parse(uri)
+        expect(uri.class).to eq(parsed_uri.class)
+        expect(uri.object_id).not_to eq(parsed_uri.object_id)
+        expect(parsed_uri.to_s).to eq(uri.to_s)
+      end
+    end
+
+    describe "when called with a URI string" do
+      it "should return a URI based on the given string" do
+        uri = described_class.parse('/some_path')
+        expect(uri).to be_a(described_class)
+        expect(uri.to_s).to eq('/some_path')
+      end
+    end
+  end
+
+  describe "dup" do
+    it "should return a duplicate URI object" do
+      dup_uri = uri.dup
+      expect(uri.class).to eq(dup_uri.class)
+      expect(uri.to_s).to eq(dup_uri.to_s)
+      expect(uri.object_id).not_to eq(dup_uri.object_id)
+    end
+
+    describe "when mutating the copy" do
+      it "should not affect the original" do
+        dup_uri = uri.dup
+        dup_uri.query_values = {per_page: 1}
+        expect(uri.to_s).to eq('/relative/path')
+        expect(dup_uri.to_s).to eq('/relative/path?per_page=1')
+      end
+    end
+  end
+
+  describe "==" do
+    it "should consider two URIs parsed from the same string equal" do
+      expect(
+        described_class.parse('http://example.com/some_path?a=1&b=2') ==
+        described_class.parse('http://example.com/some_path?a=1&b=2')
+      ).to be(true)
+    end
+
+    it "should consider two URIs parsed from different strings not equal" do
+      expect(
+        described_class.parse('http://example.com/some_path?a=1&b=2') ==
+        described_class.parse('http://example.com/some_path?a=1&c=3')
+      ).to be(false)
+
+      expect(
+        described_class.parse('http://foo.example.com') ==
+        described_class.parse('http://bar.example.com')
+      ).to be(false)
+    end
+  end
+
+  describe "merge_query_values!" do
+    it "should merge the given values with the existing query_values" do
+      uri.query_values = {'a' => '1', 'b' => '2'}
+      uri.merge_query_values! 'c' => '3'
+      expect(uri.query_values).to eq(
+        {'a' => '1', 'b' => '2', 'c' => '3'}
+      )
+    end
+
+    it "should overwrite the previous values when a new value is given" do
+      uri.query_values = {'a' => '1', 'b' => '2'}
+      uri.merge_query_values! 'a' => '3', 'b' => '4'
+      expect(uri.query_values).to eq(
+        {'a' => '3', 'b' => '4'}
+      )
+    end
+
+    it "should overwrite the previous values if a new array is given" do
+      uri.query_values = {'a' => '1', 'b' => ['2', '3']}
+      uri.merge_query_values! 'b' => ['4', '5']
+      expect(uri.query_values).to eq(
+        {'a' => '1', 'b' => ['4', '5']}
+      )
+    end
+
+    it "should set the given values if there are no existing query_values" do
+      expect(uri.query_values).to be_nil
+      uri.merge_query_values! 'a' => ['10'], 'b' => '20', 'c' => '30'
+      expect(uri.query_values).to eq({'a' => ['10'], 'b' => '20', 'c' => '30'})
+    end
+  end
+
+  describe "query_values=" do
+    it "should set the string value for the specified key" do
+      uri.query_values = {'p1' => '1'}
+      expect(uri.query_values).to eq({'p1' => '1'})
+    end
+
+    it "should preserve empty bracket notation for array params" do
+      uri.query = 'sort[]=f1&sort[]=f2'
+      uri.query_values = uri.query_values
+      expect(uri.to_s).to eq('/relative/path?sort%5B%5D=f1&sort%5B%5D=f2')
+    end
+
+    it "should stringify symbol keys" do
+      uri.query_values = {:a => '1'}
+      expect(uri.query_values).to eq({'a' => '1'})
+    end
+
+    it "should stringify boolean param values" do
+      uri.query_values = {:p1 => true, :p2 => false}
+      expect(uri.to_s).to eq('/relative/path?p1=true&p2=false')
+    end
+
+    it "should support hash param values" do
+      uri.query_values = {:a => {:b => {:c => 123}}}
+      expect(uri.to_s).to eq(
+        '/relative/path?a=%7B%22b%22%3D%3E%7B%22c%22%3D%3E123%7D%7D'
+      )
+    end
+
+    it "should add [] to the key for array values" do
+      uri.query_values = {:a => ['1', '2', '3']}
+      expect(uri.query).to eq('a%5B%5D=1&a%5B%5D=2&a%5B%5D=3')
+    end
+
+    it "should remove duplicate values for the same key" do
+      uri.query_values = {:a => ['1', '1', '2']}
+      expect(uri.query_values).to eq({'a' => ['1', '2']})
+    end
+  end
+
+  describe "query_values" do
+    it "should return the current query values" do
+      uri.query = 'sort[]=f1&sort[]=f2&per_page=all'
+      uri.query_values = uri.query_values
+      expect(uri.query_values).to eq({'sort' => ['f1', 'f2'], 'per_page' => 'all'})
+    end
+
+    it "should remove [] from array keys" do
+      uri.query = 'sort[]=f1&sort[]=f2'
+      uri.query_values = uri.query_values
+      expect(uri.query_values).to eq({'sort' => ['f1', 'f2']})
+    end
+  end
+end