rest-man 1.0.0 → 1.1.0

data/spec/unit/payload/url_encoded_spec.rb

@@ -0,0 +1,65 @@
+# encoding: binary
+
+require_relative '../_lib'
+
+describe RestMan::Payload::UrlEncoded, :include_helpers 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

data/spec/unit/payload_spec.rb

@@ -11,214 +11,6 @@ describe RestMan::Payload, :include_helpers do
     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)

data/spec/unit/request/init/url/add_query_from_headers_spec.rb

@@ -0,0 +1,40 @@
+require_relative "../../../_lib"
+
+RSpec.describe RestMan::Request::Init::Url::AddQueryFromHeaders do
+
+  it 'should handle basic URL params' do
+    expect(RestMan::Request::Init::Url::AddQueryFromHeaders.call('https://example.com/foo', params: {key1: 123, key2: 'abc'})).
+      to eq 'https://example.com/foo?key1=123&key2=abc'
+
+    expect(RestMan::Request::Init::Url::AddQueryFromHeaders.call('https://example.com/foo', params: {'key1' => 123})).
+      to eq 'https://example.com/foo?key1=123'
+
+    expect(RestMan::Request::Init::Url::AddQueryFromHeaders.call('https://example.com/path',
+                                params: {foo: 'one two', bar: 'three + four == seven'})).
+      to eq 'https://example.com/path?foo=one+two&bar=three+%2B+four+%3D%3D+seven'
+  end
+
+  it 'should combine with & when URL params already exist' do
+    expect(RestMan::Request::Init::Url::AddQueryFromHeaders.call('https://example.com/path?foo=1', params: {bar: 2})).
+      to eq 'https://example.com/path?foo=1&bar=2'
+  end
+
+  it 'should handle complex nested URL params per Rack / Rails conventions' do
+    expect(RestMan::Request::Init::Url::AddQueryFromHeaders.call('https://example.com/', params: {
+      foo: [1,2,3],
+      null: nil,
+      falsy: false,
+      math: '2+2=4',
+      nested: {'key + escaped' => 'value + escaped', other: [], arr: [1,2]},
+    })).to eq 'https://example.com/?foo[]=1&foo[]=2&foo[]=3&null&falsy=false&math=2%2B2%3D4' \
+                  '&nested[key+%2B+escaped]=value+%2B+escaped&nested[other]' \
+                  '&nested[arr][]=1&nested[arr][]=2'
+  end
+
+  it 'should handle ParamsArray objects' do
+    expect(RestMan::Request::Init::Url::AddQueryFromHeaders.call('https://example.com/',
+      params: RestMan::ParamsArray.new([[:foo, 1], [:foo, 2]])
+    )).to eq 'https://example.com/?foo=1&foo=2'
+  end
+
+end

data/spec/unit/request/init/url/normalize_url_spec.rb

@@ -0,0 +1,25 @@
+require_relative "../../../_lib"
+
+RSpec.describe RestMan::Request::Init::Url::NormalizeUrl do
+
+  it "adds http:// to the front of resources specified in the syntax example.com/resource" do
+    expect(RestMan::Request::Init::Url::NormalizeUrl.call('example.com/resource')).to eq 'http://example.com/resource'
+  end
+
+  it 'adds http:// to resources containing a colon' do
+    expect(RestMan::Request::Init::Url::NormalizeUrl.call('example.com:1234')).to eq 'http://example.com:1234'
+  end
+
+  it 'does not add http:// to the front of https resources' do
+    expect(RestMan::Request::Init::Url::NormalizeUrl.call('https://example.com/resource')).to eq 'https://example.com/resource'
+  end
+
+  it 'does not add http:// to the front of capital HTTP resources' do
+    expect(RestMan::Request::Init::Url::NormalizeUrl.call('HTTP://example.com/resource')).to eq 'HTTP://example.com/resource'
+  end
+
+  it 'does not add http:// to the front of capital HTTPS resources' do
+    expect(RestMan::Request::Init::Url::NormalizeUrl.call('HTTPS://example.com/resource')).to eq 'HTTPS://example.com/resource'
+  end
+
+end

data/spec/unit/request/init_spec.rb

@@ -0,0 +1,83 @@
+require_relative '../_lib'
+
+RSpec.describe "RestMan::Request::Init" do
+
+  describe ".http_method" do
+    context 'when :method is nil' do
+      let(:args) { {} }
+
+      it "raise ArgumentError" do
+        expect {
+          RestMan::Request::Init.http_method(args)
+        }.to raise_error(ArgumentError, "must pass :method")
+      end
+    end
+
+    context 'when :method is not nil' do
+      let(:args) { {method: :POST} }
+
+      it "return post" do
+        expect(RestMan::Request::Init.http_method(args)).to eq('post')
+      end
+    end
+  end
+
+  describe ".headers" do
+    let(:args) { {} }
+
+    context "when :headers is nil" do
+      it "return {}" do
+        expect(RestMan::Request::Init.headers(args)).to eq({})
+      end
+    end
+
+    context "when :headers is not nil" do
+      let(:args) { { headers: { foo: 'bar' } } }
+
+      it "return args[:headers].dup" do
+        expect(RestMan::Request::Init.headers(args)).to eq({foo: 'bar'})
+        expect(RestMan::Request::Init.headers(args).object_id).not_to eq(args[:headers])
+      end
+    end
+  end
+
+  describe ".uri" do
+    it 'should parse to an URI' do
+      uri = RestMan::Request::Init.uri('http://example.com')
+      expect(uri).to be_a(URI)
+    end
+
+    it 'should reject valid URIs with no hostname' do
+      expect {
+        RestMan::Request::Init.uri('http:///')
+      }.to raise_error(URI::InvalidURIError, "bad URI(no host provided): http:///")
+    end
+
+    it 'should reject invalid URIs' do
+      expect {
+        RestMan::Request::Init.uri('http://::')
+      }.to raise_error(URI::InvalidURIError)
+    end
+  end
+
+  describe ".auth" do
+    it "doesn't overwrite user and password (which may have already been set by the Resource constructor) if there is no user/password in the url" do
+      user, password = RestMan::Request::Init.auth(URI.parse('http://example.com/resource'), {user: 'beth', password: 'pass2'})
+      expect(user).to eq 'beth'
+      expect(password).to eq 'pass2'
+    end
+
+    it 'uses the username and password from the URL' do
+      user, password = RestMan::Request::Init.auth(URI.parse('http://person:secret@example.com/resource'), {})
+      expect(user).to eq 'person'
+      expect(password).to eq 'secret'
+    end
+
+    it 'overrides URL user/pass with explicit options' do
+      user, password = RestMan::Request::Init.auth(URI.parse('http://person:secret@example.com/resource'), {user: 'beth', password: 'pass2'})
+      expect(user).to eq 'beth'
+      expect(password).to eq 'pass2'
+    end
+  end
+
+end