rest-man 1.0.0

data/spec/unit/exceptions_spec.rb

@@ -0,0 +1,108 @@
+require_relative '_lib'
+
+describe RestMan::Exception do
+  it "returns a 'message' equal to the class name if the message is not set, because 'message' should not be nil" do
+    e = RestMan::Exception.new
+    expect(e.message).to eq "RestMan::Exception"
+  end
+
+  it "returns the 'message' that was set" do
+    e = RestMan::Exception.new
+    message = "An explicitly set message"
+    e.message = message
+    expect(e.message).to eq message
+  end
+
+  it "sets the exception message to ErrorMessage" do
+    expect(RestMan::ResourceNotFound.new.message).to eq 'Not Found'
+  end
+
+  it "contains exceptions in RestMan" do
+    expect(RestMan::Unauthorized.new).to be_a_kind_of(RestMan::Exception)
+    expect(RestMan::ServerBrokeConnection.new).to be_a_kind_of(RestMan::Exception)
+  end
+end
+
+describe RestMan::ServerBrokeConnection do
+  it "should have a default message of 'Server broke connection'" do
+    e = RestMan::ServerBrokeConnection.new
+    expect(e.message).to eq 'Server broke connection'
+  end
+end
+
+describe RestMan::RequestFailed do
+  before do
+    @response = double('HTTP Response', :code => '502')
+  end
+
+  it "stores the http response on the exception" do
+    response = "response"
+    begin
+      raise RestMan::RequestFailed, response
+    rescue RestMan::RequestFailed => e
+      expect(e.response).to eq response
+    end
+  end
+
+  it "http_code convenience method for fetching the code as an integer" do
+    expect(RestMan::RequestFailed.new(@response).http_code).to eq 502
+  end
+
+  it "http_body convenience method for fetching the body (decoding when necessary)" do
+    expect(RestMan::RequestFailed.new(@response).http_code).to eq 502
+    expect(RestMan::RequestFailed.new(@response).message).to eq 'HTTP status code 502'
+  end
+
+  it "shows the status code in the message" do
+    expect(RestMan::RequestFailed.new(@response).to_s).to match(/502/)
+  end
+end
+
+describe RestMan::ResourceNotFound do
+  it "also has the http response attached" do
+    response = "response"
+    begin
+      raise RestMan::ResourceNotFound, response
+    rescue RestMan::ResourceNotFound => e
+      expect(e.response).to eq response
+    end
+  end
+
+  it 'stores the body on the response of the exception' do
+    body = "body"
+    stub_request(:get, "www.example.com").to_return(:body => body, :status => 404)
+    begin
+      RestMan.get "www.example.com"
+      raise
+    rescue RestMan::ResourceNotFound => e
+      expect(e.response.body).to eq body
+    end
+  end
+end
+
+describe "backwards compatibility" do
+  it 'aliases RestMan::NotFound as ResourceNotFound' do
+    expect(RestMan::ResourceNotFound).to eq RestMan::NotFound
+  end
+
+  it 'aliases old names for HTTP 413, 414, 416' do
+    expect(RestMan::RequestEntityTooLarge).to eq RestMan::PayloadTooLarge
+    expect(RestMan::RequestURITooLong).to eq RestMan::URITooLong
+    expect(RestMan::RequestedRangeNotSatisfiable).to eq RestMan::RangeNotSatisfiable
+  end
+
+  it 'subclasses NotFound from RequestFailed, ExceptionWithResponse' do
+    expect(RestMan::NotFound).to be < RestMan::RequestFailed
+    expect(RestMan::NotFound).to be < RestMan::ExceptionWithResponse
+  end
+
+  it 'subclasses timeout from RestMan::RequestTimeout, RequestFailed, EWR' do
+    expect(RestMan::Exceptions::OpenTimeout).to be < RestMan::Exceptions::Timeout
+    expect(RestMan::Exceptions::ReadTimeout).to be < RestMan::Exceptions::Timeout
+
+    expect(RestMan::Exceptions::Timeout).to be < RestMan::RequestTimeout
+    expect(RestMan::Exceptions::Timeout).to be < RestMan::RequestFailed
+    expect(RestMan::Exceptions::Timeout).to be < RestMan::ExceptionWithResponse
+  end
+
+end

data/spec/unit/params_array_spec.rb

@@ -0,0 +1,36 @@
+require_relative '_lib'
+
+describe RestMan::ParamsArray do
+
+  describe '.new' do
+    it 'accepts various types of containers' do
+      as_array = [[:foo, 123], [:foo, 456], [:bar, 789], [:empty, nil]]
+      [
+        [[:foo, 123], [:foo, 456], [:bar, 789], [:empty, nil]],
+        [{foo: 123}, {foo: 456}, {bar: 789}, {empty: nil}],
+        [{foo: 123}, {foo: 456}, {bar: 789}, {empty: nil}],
+        [{foo: 123}, [:foo, 456], {bar: 789}, {empty: nil}],
+        [{foo: 123}, [:foo, 456], {bar: 789}, [:empty]],
+      ].each do |input|
+        expect(RestMan::ParamsArray.new(input).to_a).to eq as_array
+      end
+
+      expect(RestMan::ParamsArray.new([]).to_a).to eq []
+      expect(RestMan::ParamsArray.new([]).empty?).to eq true
+    end
+
+    it 'rejects various invalid input' do
+      expect {
+        RestMan::ParamsArray.new([[]])
+      }.to raise_error(IndexError)
+
+      expect {
+        RestMan::ParamsArray.new([[1,2,3]])
+      }.to raise_error(ArgumentError)
+
+      expect {
+        RestMan::ParamsArray.new([1,2,3])
+      }.to raise_error(NoMethodError)
+    end
+  end
+end

data/spec/unit/payload_spec.rb

@@ -0,0 +1,295 @@
+# encoding: binary
+
+require_relative '_lib'
+
+describe RestMan::Payload, :include_helpers do
+  context "Base Payload" do
+    it "should reset stream after to_s" do
+      payload = RestMan::Payload::Base.new('foobar')
+      expect(payload.to_s).to eq 'foobar'
+      expect(payload.to_s).to eq 'foobar'
+    end
+  end
+
+  context "A regular Payload" do
+    it "should use standard enctype as default content-type" do
+      expect(RestMan::Payload::UrlEncoded.new({}).headers['Content-Type']).
+        to eq 'application/x-www-form-urlencoded'
+    end
+
+    it "should form properly encoded params" do
+      expect(RestMan::Payload::UrlEncoded.new({:foo => 'bar'}).to_s).
+        to eq "foo=bar"
+      expect(["foo=bar&baz=qux", "baz=qux&foo=bar"]).to include(
+                                                        RestMan::Payload::UrlEncoded.new({:foo => 'bar', :baz => 'qux'}).to_s)
+    end
+
+    it "should escape parameters" do
+      expect(RestMan::Payload::UrlEncoded.new({'foo + bar' => 'baz'}).to_s).
+        to eq "foo+%2B+bar=baz"
+    end
+
+    it "should properly handle hashes as parameter" do
+      expect(RestMan::Payload::UrlEncoded.new({:foo => {:bar => 'baz'}}).to_s).
+        to eq "foo[bar]=baz"
+      expect(RestMan::Payload::UrlEncoded.new({:foo => {:bar => {:baz => 'qux'}}}).to_s).
+        to eq "foo[bar][baz]=qux"
+    end
+
+    it "should handle many attributes inside a hash" do
+      parameters = RestMan::Payload::UrlEncoded.new({:foo => {:bar => 'baz', :baz => 'qux'}}).to_s
+      expect(parameters).to eq 'foo[bar]=baz&foo[baz]=qux'
+    end
+
+    it "should handle attributes inside an array inside an hash" do
+      parameters = RestMan::Payload::UrlEncoded.new({"foo" => [{"bar" => 'baz'}, {"bar" => 'qux'}]}).to_s
+      expect(parameters).to eq 'foo[][bar]=baz&foo[][bar]=qux'
+    end
+
+    it "should handle arrays inside a hash inside a hash" do
+      parameters = RestMan::Payload::UrlEncoded.new({"foo" => {'even' => [0, 2], 'odd' => [1, 3]}}).to_s
+      expect(parameters).to eq 'foo[even][]=0&foo[even][]=2&foo[odd][]=1&foo[odd][]=3'
+    end
+
+    it "should form properly use symbols as parameters" do
+      expect(RestMan::Payload::UrlEncoded.new({:foo => :bar}).to_s).
+        to eq "foo=bar"
+      expect(RestMan::Payload::UrlEncoded.new({:foo => {:bar => :baz}}).to_s).
+        to eq "foo[bar]=baz"
+    end
+
+    it "should properly handle arrays as repeated parameters" do
+      expect(RestMan::Payload::UrlEncoded.new({:foo => ['bar']}).to_s).
+        to eq "foo[]=bar"
+      expect(RestMan::Payload::UrlEncoded.new({:foo => ['bar', 'baz']}).to_s).
+        to eq "foo[]=bar&foo[]=baz"
+    end
+
+    it 'should not close if stream already closed' do
+      p = RestMan::Payload::UrlEncoded.new({'foo ' => 'bar'})
+      3.times {p.close}
+    end
+
+  end
+
+  context "A multipart Payload" do
+    it "should use standard enctype as default content-type" do
+      m = RestMan::Payload::Multipart.new({})
+      allow(m).to receive(:boundary).and_return(123)
+      expect(m.headers['Content-Type']).to eq 'multipart/form-data; boundary=123'
+    end
+
+    it 'should not error on close if stream already closed' do
+      m = RestMan::Payload::Multipart.new(:file => File.new(test_image_path))
+      3.times {m.close}
+    end
+
+    it "should form properly separated multipart data" do
+      m = RestMan::Payload::Multipart.new([[:bar, "baz"], [:foo, "bar"]])
+      expect(m.to_s).to eq <<-EOS
+--#{m.boundary}\r
+Content-Disposition: form-data; name="bar"\r
+\r
+baz\r
+--#{m.boundary}\r
+Content-Disposition: form-data; name="foo"\r
+\r
+bar\r
+--#{m.boundary}--\r
+      EOS
+    end
+
+    it "should not escape parameters names" do
+      m = RestMan::Payload::Multipart.new([["bar ", "baz"]])
+      expect(m.to_s).to eq <<-EOS
+--#{m.boundary}\r
+Content-Disposition: form-data; name="bar "\r
+\r
+baz\r
+--#{m.boundary}--\r
+      EOS
+    end
+
+    it "should form properly separated multipart data" do
+      f = File.new(test_image_path)
+      m = RestMan::Payload::Multipart.new({:foo => f})
+      expect(m.to_s).to eq <<-EOS
+--#{m.boundary}\r
+Content-Disposition: form-data; name="foo"; filename="ISS.jpg"\r
+Content-Type: image/jpeg\r
+\r
+#{File.open(f.path, 'rb'){|bin| bin.read}}\r
+--#{m.boundary}--\r
+      EOS
+    end
+
+    it "should ignore the name attribute when it's not set" do
+      f = File.new(test_image_path)
+      m = RestMan::Payload::Multipart.new({nil => f})
+      expect(m.to_s).to eq <<-EOS
+--#{m.boundary}\r
+Content-Disposition: form-data; filename="ISS.jpg"\r
+Content-Type: image/jpeg\r
+\r
+#{File.open(f.path, 'rb'){|bin| bin.read}}\r
+--#{m.boundary}--\r
+      EOS
+    end
+
+    it "should detect optional (original) content type and filename" do
+      f = File.new(test_image_path)
+      expect(f).to receive(:content_type).and_return('text/plain')
+      expect(f).to receive(:original_filename).and_return('foo.txt')
+      m = RestMan::Payload::Multipart.new({:foo => f})
+      expect(m.to_s).to eq <<-EOS
+--#{m.boundary}\r
+Content-Disposition: form-data; name="foo"; filename="foo.txt"\r
+Content-Type: text/plain\r
+\r
+#{File.open(f.path, 'rb'){|bin| bin.read}}\r
+--#{m.boundary}--\r
+      EOS
+    end
+
+    it "should handle hash in hash parameters" do
+      m = RestMan::Payload::Multipart.new({:bar => {:baz => "foo"}})
+      expect(m.to_s).to eq <<-EOS
+--#{m.boundary}\r
+Content-Disposition: form-data; name="bar[baz]"\r
+\r
+foo\r
+--#{m.boundary}--\r
+      EOS
+
+      f = File.new(test_image_path)
+      f.instance_eval "def content_type; 'text/plain'; end"
+      f.instance_eval "def original_filename; 'foo.txt'; end"
+      m = RestMan::Payload::Multipart.new({:foo => {:bar => f}})
+      expect(m.to_s).to eq <<-EOS
+--#{m.boundary}\r
+Content-Disposition: form-data; name="foo[bar]"; filename="foo.txt"\r
+Content-Type: text/plain\r
+\r
+#{File.open(f.path, 'rb'){|bin| bin.read}}\r
+--#{m.boundary}--\r
+      EOS
+    end
+
+    it 'should correctly format hex boundary' do
+      allow(SecureRandom).to receive(:base64).with(12).and_return('TGs89+ttw/xna6TV')
+      f = File.new(test_image_path)
+      m = RestMan::Payload::Multipart.new({:foo => f})
+      expect(m.boundary).to eq('-' * 4 + 'RubyFormBoundary' + 'TGs89AttwBxna6TV')
+    end
+
+  end
+
+  context "streamed payloads" do
+    it "should properly determine the size of file payloads" do
+      f = File.new(test_image_path)
+      payload = RestMan::Payload.generate(f)
+      expect(payload.size).to eq 72_463
+      expect(payload.length).to eq 72_463
+    end
+
+    it "should properly determine the size of other kinds of streaming payloads" do
+      s = StringIO.new 'foo'
+      payload = RestMan::Payload.generate(s)
+      expect(payload.size).to eq 3
+      expect(payload.length).to eq 3
+
+      begin
+        f = Tempfile.new "rest-man"
+        f.write 'foo bar'
+
+        payload = RestMan::Payload.generate(f)
+        expect(payload.size).to eq 7
+        expect(payload.length).to eq 7
+      ensure
+        f.close
+      end
+    end
+
+    it "should have a closed? method" do
+      f = File.new(test_image_path)
+      payload = RestMan::Payload.generate(f)
+      expect(payload.closed?).to be_falsey
+      payload.close
+      expect(payload.closed?).to be_truthy
+    end
+  end
+
+  context "Payload generation" do
+    it "should recognize standard urlencoded params" do
+      expect(RestMan::Payload.generate({"foo" => 'bar'})).to be_kind_of(RestMan::Payload::UrlEncoded)
+    end
+
+    it "should recognize multipart params" do
+      f = File.new(test_image_path)
+      expect(RestMan::Payload.generate({"foo" => f})).to be_kind_of(RestMan::Payload::Multipart)
+    end
+
+    it "should be multipart if forced" do
+      expect(RestMan::Payload.generate({"foo" => "bar", :multipart => true})).to be_kind_of(RestMan::Payload::Multipart)
+    end
+
+    it "should handle deeply nested multipart" do
+      f = File.new(test_image_path)
+      params = {foo: RestMan::ParamsArray.new({nested: f})}
+      expect(RestMan::Payload.generate(params)).to be_kind_of(RestMan::Payload::Multipart)
+    end
+
+
+    it "should return data if no of the above" do
+      expect(RestMan::Payload.generate("data")).to be_kind_of(RestMan::Payload::Base)
+    end
+
+    it "should recognize nested multipart payloads in hashes" do
+      f = File.new(test_image_path)
+      expect(RestMan::Payload.generate({"foo" => {"file" => f}})).to be_kind_of(RestMan::Payload::Multipart)
+    end
+
+    it "should recognize nested multipart payloads in arrays" do
+      f = File.new(test_image_path)
+      expect(RestMan::Payload.generate({"foo" => [f]})).to be_kind_of(RestMan::Payload::Multipart)
+    end
+
+    it "should recognize file payloads that can be streamed" do
+      f = File.new(test_image_path)
+      expect(RestMan::Payload.generate(f)).to be_kind_of(RestMan::Payload::Streamed)
+    end
+
+    it "should recognize other payloads that can be streamed" do
+      expect(RestMan::Payload.generate(StringIO.new('foo'))).to be_kind_of(RestMan::Payload::Streamed)
+    end
+
+    # hashery gem introduces Hash#read convenience method. Existence of #read method used to determine of content is streameable :/
+    it "shouldn't treat hashes as streameable" do
+      expect(RestMan::Payload.generate({"foo" => 'bar'})).to be_kind_of(RestMan::Payload::UrlEncoded)
+    end
+
+    it "should recognize multipart payload wrapped in ParamsArray" do
+      f = File.new(test_image_path)
+      params = RestMan::ParamsArray.new([[:image, f]])
+      expect(RestMan::Payload.generate(params)).to be_kind_of(RestMan::Payload::Multipart)
+    end
+
+    it "should handle non-multipart payload wrapped in ParamsArray" do
+      params = RestMan::ParamsArray.new([[:arg, 'value1'], [:arg, 'value2']])
+      expect(RestMan::Payload.generate(params)).to be_kind_of(RestMan::Payload::UrlEncoded)
+    end
+
+    it "should pass through Payload::Base and subclasses unchanged" do
+      payloads = [
+        RestMan::Payload::Base.new('foobar'),
+        RestMan::Payload::UrlEncoded.new({:foo => 'bar'}),
+        RestMan::Payload::Streamed.new(File.new(test_image_path)),
+        RestMan::Payload::Multipart.new({myfile: File.new(test_image_path)}),
+      ]
+
+      payloads.each do |payload|
+        expect(RestMan::Payload.generate(payload)).to equal(payload)
+      end
+    end
+  end
+end

data/spec/unit/raw_response_spec.rb

@@ -0,0 +1,22 @@
+require_relative '_lib'
+
+describe RestMan::RawResponse do
+  before do
+    @tf = double("Tempfile", :read => "the answer is 42", :open => true, :rewind => true)
+    @net_http_res = double('net http response')
+    @request = double('restman request', :redirection_history => nil)
+    @response = RestMan::RawResponse.new(@tf, @net_http_res, @request)
+  end
+
+  it "behaves like string" do
+    expect(@response.to_s).to eq 'the answer is 42'
+  end
+
+  it "exposes a Tempfile" do
+    expect(@response.file).to eq @tf
+  end
+
+  it "includes AbstractResponse" do
+    expect(RestMan::RawResponse.ancestors).to include(RestMan::AbstractResponse)
+  end
+end

data/spec/unit/request2_spec.rb

@@ -0,0 +1,54 @@
+require_relative '_lib'
+
+describe RestMan::Request, :include_helpers do
+
+  context 'params for GET requests' do
+    it "manage params for get requests" do
+      stub_request(:get, 'http://some/resource?a=b&c=d').with(:headers => {'Accept'=>'*/*', 'Foo'=>'bar'}).to_return(:body => 'foo', :status => 200)
+      expect(RestMan::Request.execute(:url => 'http://some/resource', :method => :get, :headers => {:foo => :bar, :params => {:a => :b, 'c' => 'd'}}).body).to eq 'foo'
+
+      stub_request(:get, 'http://some/resource').with(:headers => {'Accept'=>'*/*', 'Foo'=>'bar'}).to_return(:body => 'foo', :status => 200)
+      expect(RestMan::Request.execute(:url => 'http://some/resource', :method => :get, :headers => {:foo => :bar, :params => :a}).body).to eq 'foo'
+    end
+
+    it 'adds GET params when params are present in URL' do
+      stub_request(:get, 'http://some/resource?a=b&c=d').with(:headers => {'Accept'=>'*/*', 'Foo'=>'bar'}).to_return(:body => 'foo', :status => 200)
+      expect(RestMan::Request.execute(:url => 'http://some/resource?a=b', :method => :get, :headers => {:foo => :bar, :params => {:c => 'd'}}).body).to eq 'foo'
+    end
+
+    it 'encodes nested GET params' do
+      stub_request(:get, 'http://some/resource?a[foo][]=1&a[foo][]=2&a[bar]&b=foo+bar&math=2+%2B+2+%3D%3D+4').with(:headers => {'Accept'=>'*/*',}).to_return(:body => 'foo', :status => 200)
+      expect(RestMan::Request.execute(url: 'http://some/resource', method: :get, headers: {
+        params: {
+          a: {
+            foo: [1,2],
+            bar: nil,
+          },
+          b: 'foo bar',
+          math: '2 + 2 == 4',
+        }
+      }).body).to eq 'foo'
+    end
+
+  end
+
+  it "can use a block to process response" do
+    response_value = nil
+    block = proc do |http_response|
+      response_value = http_response.body
+    end
+    stub_request(:get, 'http://some/resource?a=b&c=d').with(:headers => {'Accept'=>'*/*', 'Foo'=>'bar'}).to_return(:body => 'foo', :status => 200)
+    RestMan::Request.execute(:url => 'http://some/resource', :method => :get, :headers => {:foo => :bar, :params => {:a => :b, 'c' => 'd'}}, :block_response => block)
+    expect(response_value).to eq "foo"
+  end
+
+  it 'closes payload if not nil' do
+    test_file = File.new(test_image_path)
+
+    stub_request(:post, 'http://some/resource').with(:headers => {'Accept'=>'*/*'}).to_return(:body => 'foo', :status => 200)
+    RestMan::Request.execute(:url => 'http://some/resource', :method => :post, :payload => {:file => test_file})
+
+    expect(test_file.closed?).to be true
+  end
+
+end