httparty 0.16.4 → 0.20.0

data/spec/httparty/parser_spec.rb

@@ -1,190 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe HTTParty::Parser do
-  describe ".SupportedFormats" do
-    it "returns a hash" do
-      expect(HTTParty::Parser::SupportedFormats).to be_instance_of(Hash)
-    end
-  end
-
-  describe ".call" do
-    it "generates an HTTParty::Parser instance with the given body and format" do
-      expect(HTTParty::Parser).to receive(:new).with('body', :plain).and_return(double(parse: nil))
-      HTTParty::Parser.call('body', :plain)
-    end
-
-    it "calls #parse on the parser" do
-      parser = double('Parser')
-      expect(parser).to receive(:parse)
-      allow(HTTParty::Parser).to receive_messages(new: parser)
-      parser = HTTParty::Parser.call('body', :plain)
-    end
-  end
-
-  describe ".formats" do
-    it "returns the SupportedFormats constant" do
-      expect(HTTParty::Parser.formats).to eq(HTTParty::Parser::SupportedFormats)
-    end
-
-    it "returns the SupportedFormats constant for subclasses" do
-      klass = Class.new(HTTParty::Parser)
-      klass::SupportedFormats = { "application/atom+xml" => :atom }
-
-      expect(klass.formats).to eq({"application/atom+xml" => :atom})
-    end
-  end
-
-  describe ".format_from_mimetype" do
-    it "returns a symbol representing the format mimetype" do
-      expect(HTTParty::Parser.format_from_mimetype("text/plain")).to eq(:plain)
-    end
-
-    it "returns nil when the mimetype is not supported" do
-      expect(HTTParty::Parser.format_from_mimetype("application/atom+xml")).to be_nil
-    end
-  end
-
-  describe ".supported_formats" do
-    it "returns a unique set of supported formats represented by symbols" do
-      expect(HTTParty::Parser.supported_formats).to eq(HTTParty::Parser::SupportedFormats.values.uniq)
-    end
-  end
-
-  describe ".supports_format?" do
-    it "returns true for a supported format" do
-      allow(HTTParty::Parser).to receive_messages(supported_formats: [:json])
-      expect(HTTParty::Parser.supports_format?(:json)).to be_truthy
-    end
-
-    it "returns false for an unsupported format" do
-      allow(HTTParty::Parser).to receive_messages(supported_formats: [])
-      expect(HTTParty::Parser.supports_format?(:json)).to be_falsey
-    end
-  end
-
-  describe "#parse" do
-    it "attempts to parse supported formats" do
-      parser = HTTParty::Parser.new('body', :json)
-      allow(parser).to receive_messages(supports_format?: true)
-
-      expect(parser).to receive(:parse_supported_format)
-      parser.parse
-    end
-
-    it "returns the unparsed body when the format is unsupported" do
-      parser = HTTParty::Parser.new('body', :json)
-      allow(parser).to receive_messages(supports_format?: false)
-
-      expect(parser.parse).to eq(parser.body)
-    end
-
-    it "returns nil for an empty body" do
-      parser = HTTParty::Parser.new('', :json)
-      expect(parser.parse).to be_nil
-    end
-
-    it "returns nil for a nil body" do
-      parser = HTTParty::Parser.new(nil, :json)
-      expect(parser.parse).to be_nil
-    end
-
-    it "returns nil for a 'null' body" do
-      parser = HTTParty::Parser.new("null", :json)
-      expect(parser.parse).to be_nil
-    end
-
-    it "returns nil for a body with spaces only" do
-      parser = HTTParty::Parser.new("   ", :json)
-      expect(parser.parse).to be_nil
-    end
-
-    it "does not raise exceptions for bodies with invalid encodings" do
-      parser = HTTParty::Parser.new("\x80", :invalid_format)
-      expect(parser.parse).to_not be_nil
-    end
-
-    it "ignores utf-8 bom" do
-      parser = HTTParty::Parser.new("\xEF\xBB\xBF\{\"hi\":\"yo\"\}", :json)
-      expect(parser.parse).to eq({"hi"=>"yo"})
-    end
-
-    it "parses ascii 8bit encoding" do
-      parser = HTTParty::Parser.new(
-        "{\"currency\":\"\xE2\x82\xAC\"}".force_encoding('ASCII-8BIT'),
-        :json
-      )
-      expect(parser.parse).to eq({"currency" => "€"})
-    end
-
-    it "parses frozen strings" do
-      parser = HTTParty::Parser.new('{"a":1}'.freeze, :json)
-      expect(parser.parse).to eq("a" => 1)
-    end
-  end
-
-  describe "#supports_format?" do
-    it "utilizes the class method to determine if the format is supported" do
-      expect(HTTParty::Parser).to receive(:supports_format?).with(:json)
-      parser = HTTParty::Parser.new('body', :json)
-      parser.send(:supports_format?)
-    end
-  end
-
-  describe "#parse_supported_format" do
-    it "calls the parser for the given format" do
-      parser = HTTParty::Parser.new('body', :json)
-      expect(parser).to receive(:json)
-      parser.send(:parse_supported_format)
-    end
-
-    context "when a parsing method does not exist for the given format" do
-      it "raises an exception" do
-        parser = HTTParty::Parser.new('body', :atom)
-        expect do
-          parser.send(:parse_supported_format)
-        end.to raise_error(NotImplementedError, "HTTParty::Parser has not implemented a parsing method for the :atom format.")
-      end
-
-      it "raises a useful exception message for subclasses" do
-        atom_parser = Class.new(HTTParty::Parser) do
-          def self.name
-            'AtomParser'
-          end
-        end
-        parser = atom_parser.new 'body', :atom
-        expect do
-          parser.send(:parse_supported_format)
-        end.to raise_error(NotImplementedError, "AtomParser has not implemented a parsing method for the :atom format.")
-      end
-    end
-  end
-
-  context "parsers" do
-    subject do
-      HTTParty::Parser.new('body', nil)
-    end
-
-    it "parses xml with MultiXml" do
-      expect(MultiXml).to receive(:parse).with('body')
-      subject.send(:xml)
-    end
-
-    it "parses json with JSON" do
-      expect(JSON).to receive(:parse).with('body', :quirks_mode => true, :allow_nan => true)
-      subject.send(:json)
-    end
-
-    it "parses html by simply returning the body" do
-      expect(subject.send(:html)).to eq('body')
-    end
-
-    it "parses plain text by simply returning the body" do
-      expect(subject.send(:plain)).to eq('body')
-    end
-
-    it "parses csv with CSV" do
-      expect(CSV).to receive(:parse).with('body')
-      subject.send(:csv)
-    end
-  end
-end

data/spec/httparty/request/body_spec.rb

@@ -1,165 +0,0 @@
-require 'spec_helper'
-require 'tempfile'
-
-RSpec.describe HTTParty::Request::Body do
-  describe '#call' do
-    let(:options) { {} }
-
-    subject { described_class.new(params, options).call }
-
-    context 'when params is string' do
-      let(:params) { 'name=Bob%20Jones' }
-
-      it { is_expected.to eq params }
-    end
-
-    context 'when params is hash' do
-      let(:params) { { people: ["Bob Jones", "Mike Smith"] } }
-      let(:converted_params) { "people[]=Bob%20Jones&people[]=Mike%20Smith"}
-
-      it { is_expected.to eq converted_params }
-
-      context 'when params has file' do
-        before do
-          allow(HTTParty::Request::MultipartBoundary)
-            .to receive(:generate).and_return("------------------------c772861a5109d5ef")
-        end
-
-        let(:file) { File.open('spec/fixtures/tiny.gif') }
-        let(:params) do
-          {
-            user: {
-              avatar: file,
-              first_name: 'John',
-              last_name: 'Doe',
-              enabled: true
-            }
-          }
-        end
-        let(:expected_file_name) { 'tiny.gif' }
-        let(:expected_file_contents) { "GIF89a\u0001\u0000\u0001\u0000\u0000\xFF\u0000,\u0000\u0000\u0000\u0000\u0001\u0000\u0001\u0000\u0000\u0002\u0000;" }
-        let(:expected_content_type) { 'image/gif' }
-        let(:multipart_params) do
-          "--------------------------c772861a5109d5ef\r\n" \
-          "Content-Disposition: form-data; name=\"user[avatar]\"; filename=\"#{expected_file_name}\"\r\n" \
-          "Content-Type: #{expected_content_type}\r\n" \
-          "\r\n" \
-          "#{expected_file_contents}\r\n" \
-          "--------------------------c772861a5109d5ef\r\n" \
-          "Content-Disposition: form-data; name=\"user[first_name]\"\r\n" \
-          "\r\n" \
-          "John\r\n" \
-          "--------------------------c772861a5109d5ef\r\n" \
-          "Content-Disposition: form-data; name=\"user[last_name]\"\r\n" \
-          "\r\n" \
-          "Doe\r\n" \
-          "--------------------------c772861a5109d5ef\r\n" \
-          "Content-Disposition: form-data; name=\"user[enabled]\"\r\n" \
-          "\r\n" \
-          "true\r\n" \
-          "--------------------------c772861a5109d5ef--\r\n"
-        end
-
-        it { is_expected.to eq multipart_params }
-
-        context 'when passing multipart as an option' do
-          let(:options) { { force_multipart: true } }
-          let(:params) do
-            {
-              user: {
-                first_name: 'John',
-                last_name: 'Doe',
-                enabled: true
-              }
-            }
-          end
-          let(:multipart_params) do
-            "--------------------------c772861a5109d5ef\r\n" \
-            "Content-Disposition: form-data; name=\"user[first_name]\"\r\n" \
-            "\r\n" \
-            "John\r\n" \
-            "--------------------------c772861a5109d5ef\r\n" \
-            "Content-Disposition: form-data; name=\"user[last_name]\"\r\n" \
-            "\r\n" \
-            "Doe\r\n" \
-            "--------------------------c772861a5109d5ef\r\n" \
-            "Content-Disposition: form-data; name=\"user[enabled]\"\r\n" \
-            "\r\n" \
-            "true\r\n" \
-            "--------------------------c772861a5109d5ef--\r\n"
-          end
-
-          it { is_expected.to eq multipart_params }
-
-        end
-
-        context 'file object responds to original_filename' do
-          let(:some_temp_file) { Tempfile.new(['some_temp_file','.gif']) }
-          let(:expected_file_name) { "some_temp_file.gif" }
-          let(:expected_file_contents) { "Hello" }
-          let(:file) { double(:mocked_action_dispatch, path: some_temp_file.path, original_filename: 'some_temp_file.gif', read: expected_file_contents) }
-
-          before { some_temp_file.write('Hello') }
-
-          it { is_expected.to eq multipart_params }
-        end
-      end
-    end
-  end
-
-  describe '#multipart?' do
-    let(:force_multipart) { false }
-    let(:file) { File.open('spec/fixtures/tiny.gif') }
-
-    subject { described_class.new(params, force_multipart: force_multipart).multipart? }
-
-    context 'when params does not respond to to_hash' do
-      let(:params) { 'name=Bob%20Jones' }
-
-      it { is_expected.to be false }
-    end
-
-    context 'when params responds to to_hash' do
-      class HashLike
-        def initialize(hash)
-          @hash = hash
-        end
-
-        def to_hash
-          @hash
-        end
-      end
-
-      class ArrayLike
-        def initialize(ary)
-          @ary = ary
-        end
-
-        def to_ary
-          @ary
-        end
-      end
-
-      context 'when force_multipart is true' do
-        let(:params) { { name: 'Bob Jones' } }
-        let(:force_multipart) { true }
-
-        it { is_expected.to be true }
-      end
-
-      context 'when it does not contain a file' do
-        let(:hash_like_param) { HashLike.new(first: 'Bob', last: ArrayLike.new(['Jones'])) }
-        let(:params) { { name: ArrayLike.new([hash_like_param]) } }
-
-        it { is_expected.to eq false }
-      end
-
-      context 'when it contains file' do
-        let(:hash_like_param) { HashLike.new(first: 'Bob', last: 'Jones', file: ArrayLike.new([file])) }
-        let(:params) { { name: ArrayLike.new([hash_like_param]) } }
-
-        it { is_expected.to be true }
-      end
-    end
-  end
-end