paypalhttp 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6e1d7486774ce1d1a9a52d214a00f3212196d0d1da58b599861056a0367753db
+  data.tar.gz: 18f0971f48707107899ed7cbd397384605b334e761ef33176c9b642742e8bf31
+SHA512:
+  metadata.gz: 219e4ffe88eeabfde09731075a2dfd92394568c14d64c0ac4d6f9ac2d2cfe7e24e36353150555fe922077b761e5b01678ae1d3df0435cb10a377bae99d223870
+  data.tar.gz: ed6ee01c152150c9df2d34b47cb1f620271e549c1f8e8953cdbc19eded34d83c7604c97ca6929db8ab9feb972ea03d8221c62758151a615de65b73ac915171e0

data/lib/paypalhttp.rb

@@ -0,0 +1,7 @@
+module PayPalHttp
+  require_relative "paypalhttp/environment"
+  require_relative "paypalhttp/http_client"
+  require_relative "paypalhttp/errors"
+  require_relative "paypalhttp/encoder"
+  require_relative "paypalhttp/serializers/form_part"
+end

data/lib/paypalhttp/encoder.rb

@@ -0,0 +1,77 @@
+require 'stringio'
+require 'zlib'
+
+require_relative './serializers/json'
+require_relative './serializers/form_encoded'
+require_relative './serializers/text'
+require_relative './serializers/multipart'
+
+module PayPalHttp
+  class Encoder
+    def initialize
+      @encoders = [Json.new, Text.new, Multipart.new, FormEncoded.new]
+    end
+
+    def serialize_request(req)
+      raise UnsupportedEncodingError.new('HttpRequest did not have Content-Type header set') unless req.headers && (req.headers['content-type'])
+
+      content_type = _extract_header(req.headers, 'content-type')
+
+      enc = _encoder(content_type)
+      raise UnsupportedEncodingError.new("Unable to serialize request with Content-Type #{content_type}. Supported encodings are #{supported_encodings}") unless enc
+
+      encoded = enc.encode(req)
+      content_encoding = _extract_header(req.headers, 'content-encoding')
+
+      if content_encoding == 'gzip'
+        out = StringIO.new('w')
+        writer = Zlib::GzipWriter.new(out)
+
+        writer.write encoded
+
+        writer.close
+
+        encoded = out.string
+      end
+
+      encoded
+    end
+
+    def deserialize_response(resp, headers)
+      raise UnsupportedEncodingError.new('HttpResponse did not have Content-Type header set') unless headers && (headers['content-type'])
+
+      content_type = _extract_header(headers, 'content-type')
+
+      enc = _encoder(content_type)
+      raise UnsupportedEncodingError.new("Unable to deserialize response with Content-Type #{content_type}. Supported decodings are #{supported_encodings}") unless enc
+
+      content_encoding = _extract_header(headers, 'content-encoding')
+
+      if content_encoding == 'gzip'
+        buf = StringIO.new(resp, 'rb')
+        reader = Zlib::GzipReader.new(buf)
+
+        resp = reader.read
+      end
+
+      enc.decode(resp)
+    end
+
+    def supported_encodings
+      @encoders.map { |enc| enc.content_type.inspect }
+    end
+
+    def _encoder(content_type)
+      idx = @encoders.index { |enc| enc.content_type.match(content_type) }
+
+      @encoders[idx] if idx
+    end
+
+    def _extract_header(headers, key)
+      value = headers[key.downcase]
+      value = value.first if value.kind_of?(Array)
+
+      value
+    end
+  end
+end

data/lib/paypalhttp/environment.rb

@@ -0,0 +1,9 @@
+module PayPalHttp
+  class Environment
+    attr_accessor :base_url
+    def initialize(base_url)
+      @base_url = base_url
+    end
+  end
+end
+

data/lib/paypalhttp/errors.rb

@@ -0,0 +1,16 @@
+module PayPalHttp
+  class HttpError < IOError
+    attr_accessor :status_code, :result, :headers
+    def initialize(status_code, result, headers)
+      @status_code = status_code
+      @result = result
+      @headers = headers
+    end
+  end
+
+  class UnsupportedEncodingError < IOError
+    def initialize(msg)
+      super(msg)
+    end
+  end
+end

data/lib/paypalhttp/http_client.rb

@@ -0,0 +1,134 @@
+require 'ostruct'
+require 'net/http'
+require 'date'
+
+module PayPalHttp
+
+  class HttpClient
+    attr_accessor :environment, :encoder
+
+    def initialize(environment)
+      @environment = environment
+      @injectors = []
+      @encoder = Encoder.new
+    end
+
+    def user_agent
+      "PayPalHttp-Ruby HTTP/1.1"
+    end
+
+    def add_injector(&block)
+      @injectors << block
+    end
+
+    def has_body(request)
+      request.respond_to?(:body) and request.body
+    end
+
+    def format_headers(headers)
+      formatted_headers = {}
+      headers.each do |key, value|
+        formatted_headers[key.downcase] = value
+      end
+      formatted_headers
+    end
+
+    def map_headers(raw_headers , formatted_headers)
+      raw_headers.each do |key, value|
+        if formatted_headers.key?(key.downcase) == true
+          raw_headers[key] = formatted_headers[key.downcase]
+        end
+      end
+      raw_headers
+    end
+
+    def execute(req)
+      headers = req.headers || {}
+
+      request = OpenStruct.new({
+        :verb => req.verb,
+        :path => req.path,
+        :headers => headers.clone,
+        :body => req.body,
+      })
+
+      if !request.headers
+        request.headers = {}
+      end
+
+      @injectors.each do |injector|
+        injector.call(request)
+      end
+
+      formatted_headers = format_headers(request.headers)
+      if !formatted_headers["user-agent"] || formatted_headers["user-agent"] == "Ruby"
+        request.headers["user-agent"] = user_agent
+      end
+
+      body = nil
+      if has_body(request)
+        raw_headers = request.headers
+        request.headers = formatted_headers
+        body = @encoder.serialize_request(request)
+        request.headers = map_headers(raw_headers, request.headers)
+      end
+
+      http_request = Net::HTTPGenericRequest.new(request.verb, body != nil, true, request.path, request.headers)
+      http_request.body = body
+
+      uri = URI(@environment.base_url)
+      Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https') do |http|
+        _parse_response(http.request(http_request))
+      end
+    end
+
+    def _parse_response(response)
+      status_code = response.code.to_i
+
+      result = response.body
+      headers = response.to_hash
+      if result && !result.empty?
+        deserialized = @encoder.deserialize_response(response.body, format_headers(headers))
+        if deserialized.is_a?(String) || deserialized.is_a?(Array)
+          result = deserialized
+        else
+          result = _parse_values(deserialized)
+        end
+      else
+        result = nil
+      end
+
+      obj = OpenStruct.new({
+        :status_code => status_code,
+        :result => result,
+        :headers => response.to_hash,
+      })
+
+      if status_code >= 200 and status_code < 300
+        return obj
+      elsif
+        raise HttpError.new(obj.status_code, obj.result, obj.headers)
+      end
+    end
+
+    def _parse_values(values)
+      obj = nil
+
+      if values.is_a?(Array)
+        obj = []
+        values.each do |v|
+          obj << _parse_values(v)
+        end
+      elsif values.is_a?(Hash)
+        obj = OpenStruct.new()
+        values.each do |k, v|
+          obj[k] = _parse_values(v)
+        end
+      else
+        obj = values
+      end
+
+      obj
+    end
+  end
+end

data/lib/paypalhttp/serializers/form_encoded.rb

@@ -0,0 +1,22 @@
+require 'uri'
+
+module PayPalHttp
+  class FormEncoded
+    def encode(request)
+      encoded_params = []
+      request.body.each do |k, v|
+        encoded_params.push("#{URI.escape(k.to_s)}=#{URI.escape(v.to_s)}")
+      end
+
+      encoded_params.join("&")
+    end
+
+    def decode(body)
+      raise UnsupportedEncodingError.new("FormEncoded does not support deserialization")
+    end
+
+    def content_type
+      /^application\/x-www-form-urlencoded/
+    end
+  end
+end

data/lib/paypalhttp/serializers/form_part.rb

@@ -0,0 +1,14 @@
+module PayPalHttp
+  class FormPart
+    attr_accessor :value, :headers
+
+    def initialize(value, headers)
+      @value = value
+      @headers = {}
+
+      headers.each do |key, value|
+        @headers[key.to_s.downcase.split('-').map { |word| "#{word[0].upcase}#{word[1..-1]}" }.join("-")] = value
+      end
+    end
+  end
+end

data/lib/paypalhttp/serializers/json.rb

@@ -0,0 +1,17 @@
+require 'json'
+
+module PayPalHttp
+  class Json
+    def encode(request)
+      JSON.generate(request.body)
+    end
+
+    def decode(body)
+      JSON.parse(body)
+    end
+
+    def content_type
+      /application\/json/
+    end
+  end
+end

data/lib/paypalhttp/serializers/multipart.rb

@@ -0,0 +1,99 @@
+module PayPalHttp
+  class Multipart
+
+    LINE_FEED = "\r\n"
+
+    def encode(request)
+      boundary = DateTime.now.strftime("%Q")
+      request.headers["content-type"] = "#{request.headers['content-type']}; boundary=#{boundary}"
+
+      form_params = []
+      value_params = []
+      file_params = []
+
+      request.body.each do |k, v|
+        if v.is_a? File
+          file_params.push(_add_file_part(k, v))
+        elsif v.is_a? FormPart
+          value_params.push(_add_form_part(k, v))
+        else
+          value_params.push(_add_form_field(k, v))
+        end
+      end
+
+      form_params = value_params + file_params
+      form_params.collect {|p| "--" + boundary + "#{LINE_FEED}" + p}.join("") + "--" + boundary + "--"
+    end
+
+    def decode(body)
+      raise UnsupportedEncodingError.new("Multipart does not support deserialization")
+    end
+
+    def content_type
+      /multipart\/.*/
+    end
+
+    def _add_form_field(key, value)
+      return "Content-Disposition: form-data; name=\"#{key}\"#{LINE_FEED}#{LINE_FEED}#{value}#{LINE_FEED}"
+    end
+
+    def _add_form_part(key, form_part)
+      retValue = "Content-Disposition: form-data; name=\"#{key}\""
+      formatted_headers = format_headers(form_part.headers)
+      if formatted_headers["content-type"] == "application/json"
+        retValue += "; filename=\"#{key}.json\""
+      end
+      retValue += "#{LINE_FEED}"
+
+      form_part.headers.each do |key, value|
+        retValue += "#{key}: #{value}#{LINE_FEED}"
+      end
+
+      retValue += "#{LINE_FEED}"
+
+      if formatted_headers["content-type"]
+        retValue += Encoder.new().serialize_request(OpenStruct.new({
+          :verb => 'POST',
+          :path => '/',
+          :headers => formatted_headers,
+          :body => form_part.value
+        }))
+      else
+        retValue += form_part.value
+      end
+
+      retValue += "#{LINE_FEED}"
+
+      return retValue
+    end
+
+    def _add_file_part(key, file)
+      mime_type = _mime_type_for_file_name(file.path)
+      return "Content-Disposition: form-data; name=\"#{key}\"; filename=\"#{File.basename(file.path)}\"#{LINE_FEED}" +
+        "Content-Type: #{mime_type}#{LINE_FEED}#{LINE_FEED}#{file.read}#{LINE_FEED}"
+    end
+
+    def _mime_type_for_file_name(filename)
+      file_extension = File.extname(filename).strip.downcase[1..-1]
+      if file_extension == "jpeg" || file_extension == "jpg"
+        return "image/jpeg"
+      elsif file_extension == "gif"
+        return "image/gif"
+      elsif file_extension == "png"
+        return "image/png"
+      elsif file_extension == "pdf"
+        return "application/pdf"
+      else
+        return "application/octet-stream"
+      end
+    end
+
+    def format_headers(headers)
+      formatted_headers = {}
+      headers.each do |key, value|
+        formatted_headers[key.downcase] = value
+      end
+      formatted_headers
+    end
+  end
+end

data/lib/paypalhttp/serializers/text.rb

@@ -0,0 +1,15 @@
+module PayPalHttp
+  class Text
+    def encode(request)
+      request.body.to_s
+    end
+
+    def decode(body)
+      body.to_s
+    end
+
+    def content_type
+      /text\/.*/
+    end
+  end
+end

data/lib/paypalhttp/version.rb

@@ -0,0 +1 @@
+VERSION = "1.0.0"

data/paypalhttp.gemspec

@@ -0,0 +1,15 @@
+require_relative './lib/paypalhttp/version'
+
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name = "paypalhttp"
+  s.summary = "PayPalHttp Client Library"
+  s.description = "Used for generated API clients"
+  s.version = VERSION
+  s.license = "MIT"
+  s.author = "PayPal"
+  s.rubyforge_project = "paypalhttp"
+  s.has_rdoc = false
+  s.files = Dir.glob ["lib/**/*.{rb}", "spec/**/*", "*.gemspec"]
+end

data/spec/paypalhttp/encoder_spec.rb

@@ -0,0 +1,247 @@
+require 'ostruct'
+require 'json'
+require 'stringio'
+require 'zlib'
+
+describe Encoder do
+
+  describe 'serialize_request' do
+    it 'serializes the request when content-type == application/json' do
+      req = OpenStruct.new({
+        :headers  => {
+          "content-type" => "application/json; charset=utf8"
+        },
+        :body => {
+          "string" => "value",
+          "number" => 1.23,
+          "bool" => true,
+          "array" => ["one", "two", "three"],
+          "nested" => {
+            "nested_string" => "nested_value",
+            "nested_array" => [1,2,3]
+          }
+        }
+      })
+
+      expected = '{"string":"value","number":1.23,"bool":true,"array":["one","two","three"],"nested":{"nested_string":"nested_value","nested_array":[1,2,3]}}'
+
+      expect(Encoder.new.serialize_request(req)).to eq(expected)
+    end
+
+    it 'serializes the request when content-type == text/*' do
+      req = OpenStruct.new({
+        :headers  => {
+          "content-type" => "text/plain; charset=utf8"
+        },
+        :body => "some text"
+      })
+
+      expect(Encoder.new.serialize_request(req)).to eq("some text")
+    end
+
+    it 'serializes the request when content-type == multipart/form-data' do
+      file = File.new("README.md", "r")
+      req = OpenStruct.new({
+        :verb => "POST",
+        :path => "/v1/api",
+        :headers => {
+          "content-type" => "multipart/form-data; charset=utf8"
+        },
+        :body => {
+          :key => "value",
+          :another_key => 1013,
+          :readme => file
+        }
+      })
+
+      serialized = Encoder.new.serialize_request(req)
+
+      expect(req.headers['content-type']).to include('multipart/form-data; charset=utf8; boundary=')
+
+      expect(serialized).to include("Content-Disposition: form-data; name=\"readme\"; filename=\"README.md\"")
+      expect(serialized).to include("Content-Disposition: form-data; name=\"key\"")
+      expect(serialized).to include("value")
+      expect(serialized).to include("Content-Disposition: form-data; name=\"another_key\"")
+      expect(serialized).to include("1013")
+    end
+
+    it 'serializes the request when Json is provided inside multipart/form-data' do
+      file = File.new("README.md", "r")
+      req = OpenStruct.new({
+        :verb => "POST",
+        :path => "/v1/api",
+        :headers => {
+          "content-type" => "multipart/form-data; charset=utf8"
+        },
+        :body => {
+          :readme => file,
+          :input=> FormPart.new({:key => 'val'}, {'content-type': 'application/json'}),
+        }
+      })
+
+      serialized = Encoder.new.serialize_request(req)
+
+      expect(req.headers['content-type']).to include('multipart/form-data; charset=utf8; boundary=')
+
+      expect(serialized).to include("Content-Disposition: form-data; name=\"readme\"; filename=\"README.md\"")
+      expect(serialized).to include("Content-Type: application/octet-stream")
+      expect(serialized).to include("Content-Disposition: form-data; name=\"input\"; filename=\"input.json\"")
+      expect(serialized).to include("Content-Type: application/json")
+      expect(serialized).to include("{\"key\":\"val\"}")
+      expect(serialized).to match(/.*Content-Disposition: form-data; name=\"input\"; filename=\"input.json\".*Content-Disposition: form-data; name=\"readme\"; filename=\"README.md\".*/m)
+    end
+
+    it 'serializes the request when content-type == application/x-www-form-urlencoded' do
+      req = OpenStruct.new({
+        :verb => "POST",
+        :path => "/v1/api",
+        :headers => {
+          "content-type" => "application/x-www-form-urlencoded; charset=utf8"
+        },
+        :body => {
+          :key => "value with a space",
+          :another_key => 1013,
+        }
+      })
+      serialized = Encoder.new.serialize_request(req)
+
+      expect(serialized).to eq("key=value%20with%20a%20space&another_key=1013")
+    end
+
+    it 'throws when content-type is unsupported' do
+      req = OpenStruct.new({
+        :headers  => {
+          "content-type" => "fake/content-type"
+        },
+        :body => { :string => "value" }
+      })
+
+      expect{Encoder.new.serialize_request(req)}.to raise_error(UnsupportedEncodingError, /Unable to serialize request with Content-Type .*\. Supported encodings are .*/)
+    end
+
+    it 'throws when headers undefined' do
+      req = OpenStruct.new({
+        :body => { :string => "value" }
+      })
+
+      expect{Encoder.new.serialize_request(req)}.to raise_error(UnsupportedEncodingError, 'HttpRequest did not have Content-Type header set')
+    end
+
+    it 'throws when conent-type undefined' do
+      req = OpenStruct.new({
+        :headers => {},
+        :body  => { :key => "value" }
+      })
+
+
+      expect{Encoder.new.serialize_request(req)}.to raise_error(UnsupportedEncodingError, 'HttpRequest did not have Content-Type header set')
+    end
+
+    it 'encodes data as gzip when content-encoding == gzip' do
+      req = OpenStruct.new({
+        :path => '/143j2bz1',
+        :verb => "POST",
+        :headers => {
+          'content-type' => 'application/json',
+          'content-encoding' => 'gzip'
+        },
+        :body => {
+          :one => "two"
+        }
+      })
+
+      encoder = Encoder.new
+
+      out = StringIO.new('w')
+      writer = Zlib::GzipWriter.new(out)
+      writer.write JSON.generate(req.body)
+      writer.close
+
+      expected_body = out.string
+
+      expect(encoder.serialize_request(req)).to eq(expected_body)
+    end
+  end
+
+  describe 'deserialize_response' do
+    it 'throws when content-type unsupported' do
+      body = '{"string":"value","number":1.23,"bool":true,"array":["one","two","three"],"nested":{"nested_string":"nested_value","nested_array":[1,2,3]}}'
+      headers = {
+        "content-type" => ["application/xml"]
+      }
+
+      expect{Encoder.new.deserialize_response(body, headers)}.to raise_error(UnsupportedEncodingError, /Unable to deserialize response with Content-Type .*\. Supported decodings are .*/)
+    end
+
+    it 'throws when headers undefined' do
+      body = '{"string":"value","number":1.23,"bool":true,"array":["one","two","three"],"nested":{"nested_string":"nested_value","nested_array":[1,2,3]}}'
+
+      expect{Encoder.new.deserialize_response(body, nil)}.to raise_error(UnsupportedEncodingError, 'HttpResponse did not have Content-Type header set')
+    end
+
+    it 'throws when content-type undefined' do
+      body = '{"string":"value","number":1.23,"bool":true,"array":["one","two","three"],"nested":{"nested_string":"nested_value","nested_array":[1,2,3]}}'
+
+      expect{Encoder.new.deserialize_response(body, {})}.to raise_error(UnsupportedEncodingError, 'HttpResponse did not have Content-Type header set')
+    end
+
+    it 'deserializes the response when content-type == application/json' do
+      expected = {
+        "string" => "value",
+        "number" => 1.23,
+        "bool" => true,
+        "array" => ["one", "two", "three"],
+        "nested" => {
+          "nested_string" => "nested_value",
+          "nested_array" => [1,2,3]
+        }
+      }
+
+      headers = {"content-type" => ["application/json; charset=utf8"]}
+      body = '{"string":"value","number":1.23,"bool":true,"array":["one","two","three"],"nested":{"nested_string":"nested_value","nested_array":[1,2,3]}}'
+
+      deserialized = Encoder.new.deserialize_response(body, headers)
+
+      expect(deserialized).to eq(expected)
+    end
+
+    it 'deserializes the response when content-type == text/*' do
+      headers = {"content-type" => ["text/plain; charset=utf8"]}
+      body = 'some text'
+
+      expect(Encoder.new.deserialize_response(body, headers)).to eq('some text')
+    end
+
+    it 'throws when attempting to deserialize multipart/*' do
+      headers = {"content-type" => ["multipart/form-data"]}
+      body = 'some multipart encoded data here'
+
+      expect{Encoder.new.deserialize_response(body, headers)}.to raise_error(UnsupportedEncodingError, 'Multipart does not support deserialization')
+    end
+
+    it 'throws when attempting to deserialize application/x-www-form-urlencoded' do
+      headers = {"content-type" => ["application/x-www-form-urlencoded"]}
+      body = 'some multipart encoded data here'
+
+      expect{Encoder.new.deserialize_response(body, headers)}.to raise_error(UnsupportedEncodingError, 'FormEncoded does not support deserialization')
+    end
+
+    it 'decodes data from gzip when content-encoding == gzip' do
+      headers = {
+        'content-type' => 'application/json',
+        'content-encoding' => 'gzip'
+      }
+      body = JSON.generate({
+        :one => 'two'
+      })
+
+      out = StringIO.new('w')
+      encoder = Zlib::GzipWriter.new(out)
+      encoder.write(body)
+      encoder.close
+      encoded_body = out.string
+
+      expect(Encoder.new.deserialize_response(encoded_body, headers)).to eq({'one' => 'two'})
+    end
+  end
+end

data/spec/paypalhttp/http_client_spec.rb

@@ -0,0 +1,284 @@
+require 'net/http'
+require 'ostruct'
+
+describe HttpClient do
+
+  before do
+    WebMock.disable!
+    @environment = Environment.new('https://ip.jsontest.com')
+  end
+
+  it "uses injectors to modify request" do
+    WebMock.enable!
+
+    http_client = HttpClient.new(@environment)
+
+    http_client.add_injector do |request|
+      request.headers["Some-Key"] = "Some Value"
+    end
+
+    req = OpenStruct.new({:verb => "GET", :path => "/"})
+
+    stub_request(:any, @environment.base_url)
+
+    http_client.execute(req)
+
+    assert_requested :get, "#{@environment.base_url}/", {
+      :headers => {'Some-Key' => 'Some Value'},
+      :times => 1
+    }
+  end
+
+  it "uses method injector to modify request" do
+    WebMock.enable!
+
+    http_client = HttpClient.new(@environment)
+
+    def _inj(req)
+      req.headers["Some-Key"] = "Some Value"
+    end
+
+    http_client.add_injector(&method(:_inj))
+
+    req = OpenStruct.new({:verb => "GET", :path => "/"})
+
+    stub_request(:any, @environment.base_url)
+
+    http_client.execute(req)
+
+    assert_requested :get, "#{@environment.base_url}/", {
+      :headers => {'Some-Key' => 'Some Value'},
+      :times => 1
+    }
+  end
+
+  it "sets User-Agent header in request if not set" do
+    WebMock.enable!
+
+    http_client = HttpClient.new(@environment)
+    req = OpenStruct.new({:verb => "GET", :path => "/"})
+
+    stub_request(:any, @environment.base_url)
+
+    http_client.execute(req)
+
+    assert_requested :get, "#{@environment.base_url}/", {
+      :headers => {"User-Agent" => "PayPalHttp-Ruby HTTP/1.1"},
+      :times => 1
+    }
+  end
+
+  it "does not overwrite User-Agent header if set" do
+    WebMock.enable!
+
+    http_client = HttpClient.new(@environment)
+
+    req = OpenStruct.new({:verb => "GET", :path => "/", :headers => {"User-Agent" => "Not Ruby Http/1.1"}})
+
+    stub_request(:any, @environment.base_url)
+
+    http_client.execute(req)
+
+    assert_requested :get, "#{@environment.base_url}/", {
+      :headers => {"User-Agent" => "Not Ruby Http/1.1"},
+      :times => 1
+    }
+  end
+
+  it "does not modify the original request" do
+    WebMock.enable!
+
+    http_client = HttpClient.new(@environment)
+
+    req = OpenStruct.new({:verb => "GET", :path => "/"})
+
+    stub_request(:any, @environment.base_url)
+
+    http_client.execute(req)
+
+    expect(req.headers).to be_nil
+  end
+
+  it "uses body in request" do
+    WebMock.enable!
+
+    stub_request(:delete, @environment.base_url + "/path")
+
+    req = OpenStruct.new({
+      :verb => "DELETE",
+      :path => "/path",
+      :headers => {
+        "Content-Type" => "text/plain"
+      }
+    })
+
+    req.body = "I want to delete the thing"
+
+    http_client = HttpClient.new(@environment)
+
+    resp = http_client.execute(req)
+    expect(resp.status_code).to eq(200)
+
+    assert_requested(:delete, @environment.base_url + "/path") { |requested| requested.body == "I want to delete the thing" }
+  end
+
+  it "parses 200 level response" do
+    WebMock.enable!
+
+    return_data = JSON.generate({
+      :some_key => "value"
+    })
+
+    stub_request(:any, @environment.base_url).
+      to_return(body: return_data, status: 204,
+                headers: {
+        'Some-Weird-Header' => 'Some weird value',
+        'Content-Type' => 'application/json'
+    })
+
+    http_client = HttpClient.new(@environment)
+    req = OpenStruct.new({:verb => "GET", :path => "/"})
+
+    resp = http_client.execute(req)
+
+    expect(resp.status_code).to eq(204)
+    expect(resp.result.some_key).to eq('value')
+    expect(resp.headers["Some-Weird-Header".downcase]).to eq(["Some weird value"])
+  end
+
+  it "throws for non-200 level response" do
+    WebMock.enable!
+
+    return_data = {
+      :error => "error message",
+      :another_key => 1013
+    }
+
+    json = JSON.generate(return_data)
+
+    stub_request(:any, @environment.base_url).
+      to_return(body: json, status: 400,
+                headers: {
+        'Some-Weird-Header' => 'Some weird value',
+        'Content-Type' => 'application/json'
+      })
+
+    http_client = HttpClient.new(@environment)
+    req = OpenStruct.new({:verb => "GET", :path => URI(@environment.base_url)})
+
+    begin
+      resp = http_client.execute(req)
+      fail
+    rescue => e
+      resp = e
+      expect(resp.status_code).to eq(400)
+      expect(resp.result.error).to eq('error message')
+      expect(resp.result.another_key).to eq(1013)
+      expect(resp.headers["Some-Weird-Header".downcase]).to eq(["Some weird value"])
+    end
+  end
+
+  it "makes request when only a path is specified" do
+    WebMock.enable!
+
+    stub_request(:any, @environment.base_url + "/v1/api")
+      .to_return(status: 200)
+
+    http_client = HttpClient.new(@environment)
+    req = OpenStruct.new({:verb => "GET", :path => "/v1/api"})
+
+    resp = http_client.execute(req)
+    expect(resp.status_code).to eq(200)
+  end
+
+  it 'uses encoder to serialize requests by default' do
+    WebMock.enable!
+
+    return_data = {
+      :key => "value"
+    }
+
+    http_client = HttpClient.new(@environment)
+    stub_request(:get, @environment.base_url + "/v1/api")
+      .to_return(body: JSON.generate(return_data), status: 200, headers: {"Content-Type" => "application/json"})
+
+    req = OpenStruct.new({:verb => "GET", :path => "/v1/api"})
+    resp = http_client.execute(req)
+
+    expect(resp.status_code).to eq(200)
+    expect(resp.result.key).to eq('value')
+  end
+
+  it 'handles json array result' do
+    WebMock.enable!
+
+    return_data = ["one", "two"]
+
+    http_client = HttpClient.new(@environment)
+
+    stub_request(:get, @environment.base_url + "/v1/api")
+      .to_return(body: JSON.generate(return_data), status: 200, headers: {"Content-Type" => "application/json"})
+
+    req = OpenStruct.new({:verb => "GET", :path => "/v1/api"})
+
+    resp = http_client.execute(req)
+
+    expect(resp.result).to eq(return_data)
+  end
+
+  it 'deserializes nested response object into nested openstruct response' do
+    WebMock.enable!
+
+    return_data = {
+      :key => 'value',
+      :nested_key => {
+        :string => 'stringvalue',
+        :some_hash => {
+          :some_int => 1
+        },
+        :some_array => [[{
+          :array_key => 'array-value'
+        }]]
+      }
+    }
+
+    http_client = HttpClient.new(@environment)
+
+    stub_request(:get, @environment.base_url + "/v1/api")
+      .to_return(body: JSON.generate(return_data), status: 200, headers: {"Content-Type" => "application/json"})
+
+    req = OpenStruct.new({:verb => "GET", :path => "/v1/api"})
+
+    resp = http_client.execute(req)
+
+    expect(resp.result.key).to eq('value')
+    expect(resp.result.nested_key.string).to eq('stringvalue')
+    expect(resp.result.nested_key.some_hash.some_int).to eq(1)
+    expect(resp.result.nested_key.some_array[0][0].array_key).to eq('array-value')
+  end
+
+	it "does not error if no file or body present on a request class" do
+		class Request
+
+			attr_accessor :path, :body, :headers, :verb, :file
+
+			def initialize()
+				@headers = {}
+				@verb = "POST"
+				@path = "/v1/api"
+			end
+		end
+
+		WebMock.enable!
+
+		stub_request(:any, @environment.base_url + "/v1/api")
+    http_client = HttpClient.new(@environment)
+
+		begin
+			http_client.execute(Request.new)
+		rescue Exception => e
+			fail e.message
+		end
+	end
+end
+

data/spec/paypalhttp/serializers/form_part_spec.rb

@@ -0,0 +1,33 @@
+describe FormPart do
+  describe 'initialize' do
+    it 'Header-Cases lower-case headers' do
+      lowerCaseFormPart = FormPart.new({:key => 'val'}, {'content-type': 'application/json'});
+
+      expect(lowerCaseFormPart.headers.keys).to include('Content-Type')
+      expect(lowerCaseFormPart.headers.keys.length).to eq(1)
+    end
+
+    it 'Header-Cases single char headers' do
+      singleCharFormPart = FormPart.new({:key => 'val'}, {'x': 'application/json'});
+
+      expect(singleCharFormPart.headers.keys).to include('X')
+      expect(singleCharFormPart.headers.keys.length).to eq(1)
+    end
+
+    it 'Header-Cases keeps single header if collision' do
+      multiHeaderFormPart = FormPart.new({:key => 'val'}, {'content-type': 'application/json', 'CONTENT-TYPE': 'application/pdf'});
+
+      expect(multiHeaderFormPart.headers.keys).to include('Content-Type')
+      expect(multiHeaderFormPart.headers.keys.length).to eq(1)
+    end
+
+    it 'Header-Cases multiple headers when supplied' do
+      multiHeaderFormPart = FormPart.new({:key => 'val'}, {'header-one': 'application/json', 'header-Two': 'application/pdf', 'HEADER-THREE': 'img/jpg'});
+
+      expect(multiHeaderFormPart.headers.keys).to include('Header-One')
+      expect(multiHeaderFormPart.headers.keys).to include('Header-Two')
+      expect(multiHeaderFormPart.headers.keys).to include('Header-Three')
+      expect(multiHeaderFormPart.headers.keys.length).to eq(3)
+    end
+  end
+end

data/spec/paypalhttp/serializers/multipart_spec.rb

@@ -0,0 +1,23 @@
+describe Multipart do
+  describe 'mime_type_for_filename' do
+    it 'supports gif' do
+      expect(Multipart.new()._mime_type_for_file_name("test.gif")).to eq('image/gif')
+    end
+
+    it 'supports jpeg' do
+      expect(Multipart.new()._mime_type_for_file_name("test.jpeg")).to eq('image/jpeg')
+    end
+
+    it 'supports jpg' do
+      expect(Multipart.new()._mime_type_for_file_name("test.jpg")).to eq('image/jpeg')
+    end
+
+    it 'supports pdf' do
+      expect(Multipart.new()._mime_type_for_file_name("test.pdf")).to eq('application/pdf')
+    end
+
+    it 'supports appication/octet-stream' do
+      expect(Multipart.new()._mime_type_for_file_name("test.random")).to eq('application/octet-stream')
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,109 @@
+require 'webmock/rspec'
+require_relative "../lib/paypalhttp.rb"
+include WebMock::API
+include PayPalHttp
+
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
+  # have no way to turn it off -- the option exists only for backwards
+  # compatibility in RSpec 3). It causes shared context metadata to be
+  # inherited by the metadata hash of host groups and examples, rather than
+  # triggering implicit auto-inclusion in groups with matching metadata.
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # This allows you to limit a spec run to individual examples or groups
+  # you care about by tagging them with `:focus` metadata. When nothing
+  # is tagged with `:focus`, all examples get run. RSpec also provides
+  # aliases for `it`, `describe`, and `context` that include `:focus`
+  # metadata: `fit`, `fdescribe` and `fcontext`, respectively.
+  config.filter_run_when_matching :focus
+
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = "spec/examples.txt"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification
+name: paypalhttp
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- PayPal
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-11-11 00:00:00.000000000 Z
+dependencies: []
+description: Used for generated API clients
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/paypalhttp.rb
+- lib/paypalhttp/encoder.rb
+- lib/paypalhttp/environment.rb
+- lib/paypalhttp/errors.rb
+- lib/paypalhttp/http_client.rb
+- lib/paypalhttp/serializers/form_encoded.rb
+- lib/paypalhttp/serializers/form_part.rb
+- lib/paypalhttp/serializers/json.rb
+- lib/paypalhttp/serializers/multipart.rb
+- lib/paypalhttp/serializers/text.rb
+- lib/paypalhttp/version.rb
+- paypalhttp.gemspec
+- spec/paypalhttp/encoder_spec.rb
+- spec/paypalhttp/http_client_spec.rb
+- spec/paypalhttp/serializers/form_part_spec.rb
+- spec/paypalhttp/serializers/multipart_spec.rb
+- spec/spec_helper.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: PayPalHttp Client Library
+test_files: []