privacygate 1.1.1

data/lib/privacygate/util.rb

@@ -0,0 +1,59 @@
+module PrivacyGate
+  module Util
+
+    def self.object_classes
+      # Class mappings for api responce fetching
+      @object_classes ||= {
+          # API Resources
+          APIResources::Checkout::OBJECT_NAME => APIResources::Checkout,
+          APIResources::Charge::OBJECT_NAME => APIResources::Charge,
+          APIResources::Event::OBJECT_NAME => APIResources::Event,
+      }
+    end
+
+
+    def self.convert_to_api_object(data, client = nil, klass = nil)
+      # Converts a hash of fields or an array of hashes into a
+      # appropriate APIResources of APIObjects form
+      case data
+      when Array
+        data.map {|i| convert_to_api_object(i, client, klass)}
+      when Hash
+        # If class received in params, create instance
+        if klass
+          klass.create_from(data, client)
+        else
+          # Try converting to a known object class.
+          # If none available, fall back to generic APIObject
+          klass = object_classes.fetch(data[:resource], APIResources::Base::APIObject)
+          # Provide client relation only for APIResource objects
+          klass != APIResources::Base::APIObject ? klass.create_from(data, client) : klass.create_from(data)
+        end
+      else
+        data
+      end
+    end
+
+    def self.symbolize_names(object)
+      # Convert object key and values to symbols if its possible
+      case object
+      when Hash
+        new_hash = {}
+        object.each do |key, value|
+          key = (
+          begin
+            key.to_sym
+          rescue StandardError
+            key
+          end) || key
+          new_hash[key] = symbolize_names(value)
+        end
+        new_hash
+      when Array
+        object.map {|value| symbolize_names(value)}
+      else
+        object
+      end
+    end
+  end
+end

data/lib/privacygate/version.rb

@@ -0,0 +1,3 @@
+module PrivacyGate
+  VERSION = "0.8.7"
+end

data/lib/privacygate/webhooks.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module PrivacyGate
+  module Webhook
+    # Analyze and construct appropriate event object based on webhook notification
+    def self.construct_event(payload, sig_header, secret)
+      data = JSON.parse(payload, symbolize_names: true)
+      if data.key?(:event)
+        WebhookSignature.verify_header(payload, sig_header, secret)
+        PrivacyGate::APIResources::Event.create_from(data[:event])
+      else
+        raise PrivacyGate::Errors::WebhookInvalidPayload.new("no event in payload",
+                                                                  sig_header, http_body: payload)
+      end
+    end
+
+    module WebhookSignature
+      def self.verify_header(payload, sig_header, secret)
+        unless [payload, sig_header, secret].all?
+          raise PrivacyGate::Errors::WebhookInvalidPayload.new(
+              "Missing payload or signature",
+              sig_header, http_body: payload)
+        end
+        expected_sig = compute_signature(payload, secret)
+        unless secure_compare(expected_sig, sig_header)
+          raise PrivacyGate::Errors::SignatureVerificationError.new(
+              "No signatures found matching the expected signature for payload",
+              sig_header, http_body: payload
+          )
+        end
+        true
+      end
+
+      def self.secure_compare(a, b)
+        return false unless a.bytesize == b.bytesize
+
+        l = a.unpack "C#{a.bytesize}"
+        res = 0
+        b.each_byte {|byte| res |= byte ^ l.shift}
+        res.zero?
+      end
+
+      private_class_method :secure_compare
+
+      def self.compute_signature(payload, secret)
+        OpenSSL::HMAC.hexdigest(OpenSSL::Digest.new("sha256"), secret, payload)
+      end
+
+      private_class_method :compute_signature
+    end
+  end
+end

data/lib/privacygate.rb

@@ -0,0 +1,42 @@
+# general
+require "json"
+require "uri"
+require "faraday"
+require "openssl"
+
+# version
+require "privacygate/version"
+
+# client
+require "privacygate/client"
+
+# api response and errors
+require "privacygate/api_errors"
+require "privacygate/api_response"
+
+# api base object
+require "privacygate/api_resources/base/api_object"
+
+# api resource base model
+require "privacygate/api_resources/base/api_resource"
+
+# api base operations
+require "privacygate/api_resources/base/create"
+require "privacygate/api_resources/base/update"
+require "privacygate/api_resources/base/save"
+require "privacygate/api_resources/base/list"
+require "privacygate/api_resources/base/delete"
+
+# api resources
+require "privacygate/api_resources/checkout"
+require "privacygate/api_resources/charge"
+require "privacygate/api_resources/event"
+
+# webhooks
+require "privacygate/webhooks"
+
+# utils
+require "privacygate/util"
+
+module PrivacyGate
+end

data/privacygate.gemspec

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "lib"))
+require 'privacygate/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "privacygate"
+  gem.version       = "1.1.1"
+  gem.license       = "MIT"
+  gem.required_ruby_version = ">= 2.0.0"
+  gem.authors       = ["PrivacyGate"]
+
+  gem.description   = "Client library for PrivacyGate API"
+  gem.summary       = "Client library for PrivacyGate API"
+  gem.homepage      = "https://privacygate.io/docs/"
+
+  gem.files         = `git ls-files`.sub("privacygate.gemspec", "privacygate.gemspec").split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(spec|gem|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency("faraday", "~> 0.10")
+
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "webmock"
+  gem.add_development_dependency "pry-byebug"
+end

data/spec/api_resources/base/api_object_spec.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe PrivacyGate::APIResources::Base::APIObject do
+  describe "#respond_to" do
+    it "should implement respond_to method" do
+      obj = PrivacyGate::APIResources::Base::APIObject.create_from(id: 1, foo: "bar")
+      expect(obj.respond_to?(:foo)).to be true
+      expect(obj.respond_to?(:baz)).to be false
+    end
+  end
+
+  describe "#serialize params" do
+    it "should serialize params on an empty object" do
+      obj = PrivacyGate::APIResources::Base::APIObject.create_from({})
+      expect({}).to eq obj.serialize_params
+    end
+
+    it "should serialize params on a new object with a sub object" do
+      obj = PrivacyGate::APIResources::Base::APIObject.new
+      obj.metadata = {foo: "bar"}
+      expect({metadata: {foo: "bar"}}).to eq obj.serialize_params
+    end
+
+    it "should serialize params on a basic object" do
+      obj = PrivacyGate::APIResources::Base::APIObject.create_from(foo: nil)
+      obj.update_attributes(foo: "bar")
+      expect({foo: "bar"}).to eq obj.serialize_params
+    end
+
+    it "should serialize params on a complex object" do
+      obj = PrivacyGate::APIResources::Base::APIObject.create_from(
+          foo: PrivacyGate::APIResources::Base::APIObject.create_from(bar: nil, baz: nil))
+      obj.foo.bar = "newbar"
+      expect({foo: {bar: "newbar"}}).to eq obj.serialize_params
+    end
+
+    it "should serialize params on an array" do
+      obj = PrivacyGate::APIResources::Base::APIObject.create_from(foo: nil)
+      obj.foo = ["new-value"]
+      expect({foo: ["new-value"]}).to eq obj.serialize_params
+    end
+
+    it "should serialize params on an array that shortens" do
+      obj = PrivacyGate::APIResources::Base::APIObject.create_from(foo: ["0-index", "1-index", "2-index"])
+      obj.foo = ["new-value"]
+      expect({foo: ["new-value"]}).to eq obj.serialize_params
+    end
+
+    it "should serialize params on an array of hashes" do
+      obj = PrivacyGate::APIResources::Base::APIObject.create_from(foo: nil)
+      obj.foo = [
+          PrivacyGate::APIResources::Base::APIObject.create_from(bar: nil),
+      ]
+      obj.foo[0].bar = "baz"
+      expect({foo: [{bar: "baz"}]}).to eq obj.serialize_params
+    end
+
+    it "should serialize params doesn't include unchanged values" do
+      obj = PrivacyGate::APIResources::Base::APIObject.create_from(foo: nil)
+      expect({}).to eq obj.serialize_params
+    end
+
+    it "should serialize params with a APIObject" do
+      obj = PrivacyGate::APIResources::Base::APIObject.create_from({})
+      obj.metadata = PrivacyGate::APIResources::Base::APIObject.create_from(foo: "bar")
+      serialized = obj.serialize_params
+      expect({foo: "bar"}).to eq serialized[:metadata]
+    end
+
+    it "should serialize params with APIObject that's been replaced" do
+      obj = PrivacyGate::APIResources::Base::APIObject.create_from(
+          source: PrivacyGate::APIResources::Base::APIObject.create_from(bar: "foo"))
+
+      obj.source = PrivacyGate::APIResources::Base::APIObject.create_from(baz: "foo")
+
+      serialized = obj.serialize_params
+      expect({baz: "foo"}).to eq serialized[:source]
+    end
+
+    it "should serialize params with an array of APIObjects" do
+      stub_request(:post, "#{@api_base}charges").to_return(body: {data: mock_item}.to_json)
+      obj = PrivacyGate::APIResources::Base::APIObject.create_from({})
+      obj.metadata = [
+          PrivacyGate::APIResources::Base::APIObject.create_from(foo: "bar"),
+      ]
+
+      serialized = obj.serialize_params
+      expect([{foo: "bar"}]).to eq serialized[:metadata]
+    end
+
+    it "should serialize params with embed API resources" do
+      charge = PrivacyGate::APIResources::Charge.create_from(id: "charge_id")
+      obj = PrivacyGate::APIResources::Base::APIObject.create_from({})
+      obj.charge = charge
+      expect(obj.charge).is_a? PrivacyGate::APIResources::Charge
+    end
+
+    it "should serialize params and not include API resources that have not been set" do
+      obj = PrivacyGate::APIResources::Base::APIObject.create_from(id: "cus_123")
+      obj2 = PrivacyGate::APIResources::Base::APIObject.create_from(obj: obj)
+      serialized = obj2.serialize_params
+      expect({}).to eq serialized
+    end
+
+    it "should serialize params takes a push option" do
+      obj = PrivacyGate::APIResources::Base::APIObject.create_from(
+          id: "id", metadata: PrivacyGate::APIResources::Base::APIObject.create_from(foo: "bar"))
+      serialized = obj.serialize_params(push: true)
+      expect({id: "id", metadata: {foo: "bar"}}).to eq serialized
+    end
+  end
+
+  describe "update attributes" do
+    it "should update attributes with a hash" do
+      obj = PrivacyGate::APIResources::Base::APIObject.create_from({})
+      obj.update_attributes(metadata: {foo: "bar"})
+      expect(obj.metadata.class).to eq PrivacyGate::APIResources::Base::APIObject
+    end
+
+    it "should assign question mark accessors for booleans added after initialization" do
+      obj = PrivacyGate::APIResources::Base::APIObject.new
+      obj.bool = true
+      expect(obj.respond_to?(:bool?)).to be true
+      expect(obj.bool?).to be true
+    end
+
+    it "should assign question mark accessors for booleans" do
+      obj = PrivacyGate::APIResources::Base::APIObject.create_from(id: 1, bool: true, not_bool: "bar")
+      expect(obj.respond_to?(:bool?)).to be true
+      expect(obj.respond_to?(:not_bool)).to be true
+      expect(obj.bool?).to be true
+    end
+
+    it "should create accessors when update attributes is called" do
+      obj = PrivacyGate::APIResources::Base::APIObject.create_from({})
+      expect(obj.send(:metaclass).method_defined?(:foo)).to eq false
+      obj.update_attributes(foo: "bar")
+      expect(obj.send(:metaclass).method_defined?(:foo)).to eq true
+    end
+
+    it "should update attributes with a hash" do
+      obj = PrivacyGate::APIResources::Base::APIObject.create_from({})
+      obj.update_attributes(metadata: {foo: "bar"})
+      expect(PrivacyGate::APIResources::Base::APIObject).to eq obj.metadata.class
+    end
+
+    it "should create accessors when update attributes is called" do
+      obj = PrivacyGate::APIResources::Base::APIObject.create_from({})
+      expect(obj.send(:metaclass).method_defined?(:foo)).to be false
+      obj.update_attributes(foo: "bar")
+      expect(obj.send(:metaclass).method_defined?(:foo)).to be true
+    end
+  end
+end

data/spec/api_resources/base/api_resource_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe PrivacyGate::APIResources::Base::APIResource do
+  before :all do
+    @client = PrivacyGate::Client.new(api_key: 'api_key')
+    @api_base = @client.instance_variable_get :@api_uri
+  end
+
+  it "shout create a new APIResource without request" do
+    PrivacyGate::APIResources::Base::APIResource.new("id")
+    assert_not_requested :get, %r{#{@api_base}/.*}
+  end
+
+  it "should create APIResource object form hash without request" do
+    PrivacyGate::APIResources::Base::APIResource.create_from(id: "some_id",
+                                                                  param: {id: "param_id"})
+    assert_not_requested :get, %r{#{@api_base}/.*}
+  end
+
+  it "setting an attribute should not cause a network request" do
+    c = PrivacyGate::APIResources::Base::APIResource.new("cus_123")
+    c.param = {id: "param_id"}
+    assert_not_requested :get, %r{#{@api_base}/.*}
+    assert_not_requested :post, %r{#{@api_base}/.*}
+  end
+
+  it "accessing id should not issue a fetch" do
+    c = PrivacyGate::APIResources::Base::APIResource.new("cus_123")
+    c.id
+    assert_not_requested :get, %r{#{@api_base}/.*}
+  end
+end

data/spec/api_resources/charge_spec.rb

@@ -0,0 +1,19 @@
+describe PrivacyGate::APIResources::Charge do
+  before :all do
+    @client = PrivacyGate::Client.new(api_key: 'api_key')
+    @api_base = @client.instance_variable_get :@api_uri
+  end
+
+  it "making a POST request with parameters should have a body and no query string" do
+    stub_request(:post, "#{@api_base}#{PrivacyGate::APIResources::Charge::RESOURCE_PATH}")
+        .with(body: {:id => "id_value", :key => "key_value"})
+        .to_return(body: {data: {id: "id_value", key: "key_value"}}.to_json)
+    @client.charge.create(id: "id_value", key: "key_value")
+  end
+
+  it "making a GET request with parameters should have a query string and no body" do
+    stub_request(:get, "#{@api_base}#{PrivacyGate::APIResources::Charge::RESOURCE_PATH}")
+        .with(query: {limit: 5}).to_return(body: JSON.generate(data: [mock_list]))
+    @client.charge.list(limit: 5)
+  end
+end

data/spec/api_resources/checkout_spec.rb

@@ -0,0 +1,31 @@
+describe PrivacyGate::APIResources::Checkout do
+  before :all do
+    @client = PrivacyGate::Client.new(api_key: 'api_key')
+    @api_base = @client.instance_variable_get :@api_uri
+  end
+
+  it "checkout should save nothing if nothing changes" do
+    stub_request(:post, "#{@api_base}#{PrivacyGate::APIResources::Checkout::RESOURCE_PATH}")
+        .to_return(body: {data: {id: "id_value", key: "key_value"}}.to_json)
+    checkout = @client.checkout.create(id: "id_value", key: "key_value")
+
+    stub_request(:put, "#{@api_base}#{PrivacyGate::APIResources::Checkout::RESOURCE_PATH}/id_value")
+        .with(body: {})
+        .to_return(body: JSON.generate("id" => "id_value", "key" => "key_value"))
+
+    checkout.save
+  end
+
+  it "making a POST request with parameters should have a body and no query string" do
+    stub_request(:post, "#{@api_base}#{PrivacyGate::APIResources::Checkout::RESOURCE_PATH}")
+        .with(body: {:id => "id_value", :key => "key_value"})
+        .to_return(body: {data: {id: "id_value", key: "key_value"}}.to_json)
+    @client.checkout.create(id: "id_value", key: "key_value")
+  end
+
+  it "making a GET request with parameters should have a query string and no body" do
+    stub_request(:get, "#{@api_base}#{PrivacyGate::APIResources::Checkout::RESOURCE_PATH}")
+        .with(query: {limit: 5}).to_return(body: JSON.generate(data: [mock_list]))
+    @client.checkout.list(limit: 5)
+  end
+end

data/spec/api_resources/event_spec.rb

@@ -0,0 +1,12 @@
+describe PrivacyGate::APIResources::Event do
+  before :all do
+    @client = PrivacyGate::Client.new(api_key: 'api_key')
+    @api_base = @client.instance_variable_get :@api_uri
+  end
+
+  it "making a GET request with parameters should have a query string and no body" do
+    stub_request(:get, "#{@api_base}#{PrivacyGate::APIResources::Event::RESOURCE_PATH}")
+        .with(query: {limit: 5}).to_return(body: JSON.generate(data: [mock_list]))
+    @client.event.list(limit: 5)
+  end
+end

data/spec/endpont_spec.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe PrivacyGate do
+  before :all do
+    @client = PrivacyGate::Client.new(api_key: 'api_key')
+    @api_base = @client.instance_variable_get :@api_uri
+  end
+
+  # test list resources
+  it "should get charges" do
+    stub_request(:get, "#{@api_base}charges").to_return(body: mock_list.to_json)
+    charge_list = @client.charge.list
+    expect(charge_list).is_a? @client.charge
+    expect(charge_list.data).is_a? Array
+    expect(charge_list.pagination).is_a? PrivacyGate::APIResources::Base::APIObject
+    expect(charge_list.data[0].to_hash).to eq mock_item
+  end
+
+  it "should get checkouts" do
+    stub_request(:get, "#{@api_base}checkouts").to_return(body: mock_list.to_json)
+    checkout_list = @client.checkout.list
+    expect(checkout_list).is_a? @client.checkout
+    expect(checkout_list.data).is_a? Array
+    expect(checkout_list.pagination).is_a? PrivacyGate::APIResources::Base::APIObject
+    expect(checkout_list.data[0].to_hash).to eq mock_item
+  end
+
+  it "should should get events" do
+    stub_request(:get, "#{@api_base}events").to_return(body: mock_list.to_json)
+    event_list = @client.event.list
+    expect(event_list).is_a? @client.checkout
+    expect(event_list.data).is_a? Array
+    expect(event_list.pagination).is_a? PrivacyGate::APIResources::Base::APIObject
+    expect(event_list.data[0].to_hash).to eq mock_item
+  end
+
+
+  # test single resources
+  it "should get charge" do
+    stub_request(:get, "#{@api_base}charges/key").to_return(body: {data: mock_item}.to_json)
+    charge = @client.charge.retrieve :key
+    expect(charge).is_a? @client.charge
+    expect(charge).is_a? PrivacyGate::APIResources::Base::APIObject
+    expect(charge.id).to eq mock_item[:id]
+    expect(charge.key).to eq mock_item[:key]
+  end
+
+  it "should get checkout" do
+    stub_request(:get, "#{@api_base}checkouts/key").to_return(body: {data: mock_item}.to_json)
+    checkout = @client.checkout.retrieve :key
+    expect(checkout).is_a? @client.checkout
+    expect(checkout).is_a? PrivacyGate::APIResources::Base::APIObject
+    expect(checkout.id).to eq mock_item[:id]
+    expect(checkout.key).to eq mock_item[:key]
+  end
+
+  it "should get event" do
+    stub_request(:get, "#{@api_base}events/key").to_return(body: {data: mock_item}.to_json)
+    event = @client.event.retrieve :key
+    expect(event).is_a? @client.charge
+    expect(event).is_a? PrivacyGate::APIResources::Base::APIObject
+    expect(event.id).to eq mock_item[:id]
+    expect(event.key).to eq mock_item[:key]
+  end
+
+  # test create resources
+  it "should create charge" do
+    stub_request(:post, "#{@api_base}charges").to_return(body: {data: mock_item}.to_json)
+    charge = @client.charge.create(mock_item)
+    expect(charge).is_a? @client.charge
+    expect(charge).is_a? PrivacyGate::APIResources::Base::APIObject
+    expect(charge.id).to eq mock_item[:id]
+    expect(charge.key).to eq mock_item[:key]
+  end
+
+  it "should create checkout" do
+    stub_request(:post, "#{@api_base}checkouts").to_return(body: {data: mock_item}.to_json)
+    checkout = @client.checkout.create(mock_item)
+    expect(checkout).is_a? @client.checkout
+    expect(checkout).is_a? PrivacyGate::APIResources::Base::APIObject
+    expect(checkout.id).to eq mock_item[:id]
+    expect(checkout.key).to eq mock_item[:key]
+  end
+
+  # test delete resources
+  it "should delete checkout" do
+    stub_request(:post, "#{@api_base}checkouts").to_return(body: {data: mock_item}.to_json)
+    stub_request(:delete, "#{@api_base}checkouts/val").to_return(body: {}.to_json)
+    checkout = @client.checkout.create(mock_item)
+    checkout.delete
+  end
+
+  # test save resources
+  it "should save checkout" do
+    stub_request(:post, "#{@api_base}checkouts").to_return(body: {data: mock_item}.to_json)
+    stub_request(:put, "#{@api_base}checkouts/val").to_return(body: {:edited => true}.to_json)
+    checkout = @client.checkout.create(mock_item)
+    checkout.key = "new value"
+    checkout.save
+    expect(checkout.edited).to eq true
+  end
+end

data/spec/error_spec.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe PrivacyGate do
+  before :all do
+    @client = PrivacyGate::Client.new(api_key: 'api_key')
+  end
+
+  it "should get appropriate error when invalid response object" do
+    stub_request(:get, /.*/).to_return(body: {errors: [{id: "boo", message: "foo"}]}.to_json, status: 400)
+    expect {@client.checkout.list}.to raise_error PrivacyGate::Errors::APIError
+  end
+
+  it "should handle invalid request general" do
+    stub_request(:get, /.*/).to_return(body: {error: {type: "invalid_request", message: "test"}}.to_json, status: 400)
+    expect {@client.checkout.list}.to raise_error PrivacyGate::Errors::InvalidRequestError
+  end
+
+  it "should handle param required" do
+    stub_request(:get, /.*/).to_return(body: {error: {type: "param_required", message: "param_required"}}.to_json, status: 400)
+    expect {@client.checkout.list}.to raise_error PrivacyGate::Errors::ParamRequiredError
+  end
+
+  it "should handle validation error" do
+    stub_request(:get, /.*/).to_return(body: {error: {type: "validation_error", message: "validation_error"}}.to_json, status: 400)
+    expect {@client.checkout.list}.to raise_error PrivacyGate::Errors::ValidationError
+  end
+
+  it "should handle param_required" do
+    stub_request(:get, /.*/).to_return(body: {error: {type: "invalid_request", message: "invalid_request"}}.to_json, status: 400)
+    expect {@client.checkout.list}.to raise_error PrivacyGate::Errors::InvalidRequestError
+  end
+
+  it "should handle authentication error" do
+    stub_request(:get, /.*/).to_return(body: {error: {type: "auth_error", message: "auth_error"}}.to_json, status: 401)
+    expect {@client.checkout.list}.to raise_error PrivacyGate::Errors::AuthenticationError
+  end
+
+  it "should handle resource not found error" do
+    stub_request(:get, /.*/).to_return(body: {error: {type: "not_found", message: "not_found"}}.to_json, status: 404)
+    expect {@client.checkout.list}.to raise_error PrivacyGate::Errors::ResourceNotFoundError
+  end
+
+  it "should handle rate limit exceeded error" do
+    stub_request(:get, /.*/).to_return(body: {error: {type: "rate_limit_exceeded", message: "rate_limit_exceeded"}}.to_json, status: 429)
+    expect {@client.checkout.list}.to raise_error PrivacyGate::Errors::RateLimitExceededError
+  end
+
+  it "should handle internal server error" do
+    stub_request(:get, /.*/).to_return(body: {error: {type: "internal_error", message: "internal_error"}}.to_json, status: 500)
+    expect {@client.checkout.list}.to raise_error PrivacyGate::Errors::InternalServerError
+  end
+
+  it "should handle service unavailable error" do
+    stub_request(:get, /.*/).to_return(body: {error: {type: "service_unavailable", message: "service_unavailable"}}.to_json, status: 503)
+    expect {@client.checkout.list}.to raise_error PrivacyGate::Errors::ServiceUnavailableError
+  end
+end

data/spec/response_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe PrivacyGate::PrivacyGateResponse do
+  describe "from_faraday_hash" do
+    it "should initialize a PrivacyGateResponse object from a Hash like the kind" do
+      body = '{"foo": "bar"}'
+      headers = {"x-request-id" => "x-request-id"}
+      http_resp = {
+          body: body,
+          headers: headers,
+          status: 200,
+      }
+      resp = PrivacyGate::PrivacyGateResponse.from_faraday_hash(http_resp)
+
+      expect(JSON.parse(body, symbolize_names: true)).to eq resp.data
+      expect(body).to eq resp.http_body
+      expect(headers).to eq resp.http_headers
+      expect(200).to eq resp.http_status
+      expect("x-request-id").to eq resp.request_id
+    end
+  end
+
+  describe "from_faraday_response" do
+    it "should initialize a PrivacyGateResponse object from a Faraday HTTP response object." do
+      body = '{"foo": "bar"}'
+      headers = {"x-request-id" => "x-request-id"}
+      env = Faraday::Env.from(
+          status: 200, body: body,
+          response_headers: headers
+      )
+      http_resp = Faraday::Response.new(env)
+
+      resp = PrivacyGate::PrivacyGateResponse.from_faraday_response(http_resp)
+
+      expect(JSON.parse(body, symbolize_names: true)).to eq resp.data
+      expect(body).to eq resp.http_body
+      expect(headers).to eq resp.http_headers
+      expect(200).to eq resp.http_status
+      expect("x-request-id").to eq resp.request_id
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+require 'bundler/setup'
+require 'webmock/rspec'
+Bundler.setup
+require 'privacygate'
+
+def mock_item
+  {:id => "val", :key => "val"}
+end
+
+def mock_list
+  {
+      :pagination => mock_item,
+      :data => [mock_item, mock_item]
+  }
+end