rest-core 2.0.4 → 2.1.0

data/test/{test_em_http_request.rb → test_em-http-request.rb}

@@ -18,6 +18,46 @@ describe RC::EmHttpRequest do
     }.resume}
   end
 
+  describe 'POST Payload' do
+    after do
+      WebMock.reset!
+    end
+
+    client = RC::Builder.client
+    client.builder.run(RC::EmHttpRequest)
+    path = 'http://example.com'
+    ok   = 'OK'
+    c    = client.new
+
+    post = lambda do |payload, body|
+      stub_request(:post, path).with(:body => body).to_return(:body => ok)
+      EM.error_handler{ |e| e.should.kind_of?(NilClass); EM.stop }
+      EM.run{ EM.defer{
+        c.post(path, payload).should.eq ok
+        EM.next_tick{ EM.stop }
+      }}
+    end
+
+    should 'post with string' do
+      post['string', 'string']
+    end
+
+    should 'post with file' do
+      File.open(__FILE__) do |f|
+        b = f.read
+        f.rewind
+        post[f, b]
+      end
+    end
+
+    should 'post with socket' do
+      rd, wr = IO.pipe
+      wr.write('socket')
+      wr.close
+      post[rd, 'socket']
+    end
+  end
+
   # ----------------------------------------------------------------------
 
   describe RC::Simple do

data/test/test_follow_redirect.rb

@@ -2,21 +2,18 @@
 require 'rest-core/test'
 
 describe RC::FollowRedirect do
-  before do
-    @dry = Class.new do
-      attr_accessor :status
-      def call env
-        yield(env.merge(RC::RESPONSE_STATUS  => status,
-                        RC::RESPONSE_HEADERS => {'LOCATION' => 'location'}))
-      end
-    end.new
-    @app = RC::FollowRedirect.new(dry, 1)
-  end
+  dry = Class.new do
+    attr_accessor :status
+    def call env
+      yield(env.merge(RC::RESPONSE_STATUS  => status,
+                      RC::RESPONSE_HEADERS => {'LOCATION' => 'location'}))
+    end
+  end.new
+  app = RC::FollowRedirect.new(dry, 1)
+
   after do
     RR.verify
   end
-  def dry; @dry; end
-  def app; @app; end
 
   [301, 302, 303, 307].each do |status|
     should "not follow redirect if reached max_redirects: #{status}" do

data/test/test_json_response.rb

@@ -3,9 +3,7 @@ require 'rest-core/test'
 
 describe RC::JsonResponse do
   describe 'app' do
-    def app
-      @app ||= RC::JsonResponse.new(RC::Dry.new, true)
-    end
+    app = RC::JsonResponse.new(RC::Dry.new, true)
 
     should 'do nothing' do
       expected = {RC::RESPONSE_BODY => nil,
@@ -23,15 +21,13 @@ describe RC::JsonResponse do
   end
 
   describe 'client' do
-    def client
-      @client ||= RC::Builder.client do
-        use RC::JsonResponse, true
-        run Class.new{
-          def call env
-            yield(env.merge(RC::RESPONSE_BODY => '{}'))
-          end
-        }
-      end
+    client = RC::Builder.client do
+      use RC::JsonResponse, true
+      run Class.new{
+        def call env
+          yield(env.merge(RC::RESPONSE_BODY => '{}'))
+        end
+      }
     end
 
     should 'do nothing' do

data/test/test_oauth1_header.rb

@@ -2,92 +2,92 @@
 require 'rest-core/test'
 
 describe RC::Oauth1Header do
-  before do
-    @env = {RC::REQUEST_METHOD => :post,
-            RC::REQUEST_PATH   =>
-              'https://api.twitter.com/oauth/request_token'}
+  env = {RC::REQUEST_METHOD  => :post,
+         RC::REQUEST_PATH    =>
+           'https://api.twitter.com/oauth/request_token',
+         RC::REQUEST_QUERY   => {},
+         RC::REQUEST_PAYLOAD => {}}
 
-    callback =
+  callback =
     'http://localhost:3005/the_dance/process_callback?service_provider_id=11'
 
-    @oauth_params =
-      {'oauth_callback'     => callback                                     ,
-       'oauth_consumer_key' => 'GDdmIQH6jhtmLUypg82g'                       ,
-       'oauth_nonce'        => 'QP70eNmVz8jvdPevU3oJD2AfF7R7odC2XJcn4XlZJqk',
-       'oauth_timestamp'    => '1272323042'                                 ,
-       'oauth_version'      => '1.0'                                        ,
-       'oauth_signature_method' => 'HMAC-SHA1'}
-
-    @auth = RC::Oauth1Header.new(RC::Dry.new,
-      nil, nil, nil,
-      'GDdmIQH6jhtmLUypg82g',
-      'MCD8BKwGdgPHvAuvgvz4EQpqDAtx89grbuNMRd7Eh98')
-  end
+  oauth_params =
+    {'oauth_callback'     => callback                                     ,
+     'oauth_consumer_key' => 'GDdmIQH6jhtmLUypg82g'                       ,
+     'oauth_nonce'        => 'QP70eNmVz8jvdPevU3oJD2AfF7R7odC2XJcn4XlZJqk',
+     'oauth_timestamp'    => '1272323042'                                 ,
+     'oauth_version'      => '1.0'                                        ,
+     'oauth_signature_method' => 'HMAC-SHA1'}
+
+  auth = RC::Oauth1Header.new(RC::Dry.new,
+    nil, nil, nil,
+    'GDdmIQH6jhtmLUypg82g',
+    'MCD8BKwGdgPHvAuvgvz4EQpqDAtx89grbuNMRd7Eh98')
 
   should 'have correct signature' do
-    @auth.signature(@env, @oauth_params).should.eq(
+    auth.signature(env, oauth_params).should.eq(
       '8wUi7m5HFQy76nowoCThusfgB+Q=')
   end
 
   describe 'base_string' do
-    before do
-      @base_string =
-        'POST&https%3A%2F%2Fapi.twitter.com%2Foauth%2Frequest_token&' \
-        'oauth_callback%3Dhttp%253A%252F%252Flocalhost%253A3005%252F' \
-        'the_dance%252Fprocess_callback%253Fservice_provider_id%253D' \
-        '11%26oauth_consumer_key%3DGDdmIQH6jhtmLUypg82g%26oauth_nonc' \
-        'e%3DQP70eNmVz8jvdPevU3oJD2AfF7R7odC2XJcn4XlZJqk%26oauth_sig' \
-        'nature_method%3DHMAC-SHA1%26oauth_timestamp%3D1272323042%26' \
-        'oauth_version%3D1.0'
-    end
-
-    def check
-      @auth.base_string(@env, @oauth_params).should.eq @base_string
+    base_string =
+      'POST&https%3A%2F%2Fapi.twitter.com%2Foauth%2Frequest_token&' \
+      'oauth_callback%3Dhttp%253A%252F%252Flocalhost%253A3005%252F' \
+      'the_dance%252Fprocess_callback%253Fservice_provider_id%253D' \
+      '11%26oauth_consumer_key%3DGDdmIQH6jhtmLUypg82g%26oauth_nonc' \
+      'e%3DQP70eNmVz8jvdPevU3oJD2AfF7R7odC2XJcn4XlZJqk%26oauth_sig' \
+      'nature_method%3DHMAC-SHA1%26oauth_timestamp%3D1272323042%26' \
+      'oauth_version%3D1.0'
+
+    check = lambda do |e, b|
+      auth.base_string(e, oauth_params).should.eq b
     end
 
     should 'have correct base_string' do
-      check
+      check[env, base_string]
     end
 
     should 'not use payload in multipart request for base_string' do
-      @env.merge!(RC::REQUEST_PAYLOAD => {'file' => File.open(__FILE__)})
-      check
+      File.open(__FILE__) do |f|
+        check[env.merge(RC::REQUEST_PAYLOAD => {'file' => f}), base_string]
+      end
     end
 
     should 'not use payload if it contains binary' do
-      @env.merge!(RC::REQUEST_PAYLOAD => File.open(__FILE__))
-      check
+      File.open(__FILE__) do |f|
+        check[env.merge(RC::REQUEST_PAYLOAD => f), base_string]
+      end
     end
 
     should 'not use payload if it contains [binary]' do
-      @env.merge!(RC::REQUEST_PAYLOAD => [File.open(__FILE__)])
-      check
+      File.open(__FILE__) do |f|
+        check[env.merge(RC::REQUEST_PAYLOAD => [f]), base_string]
+      end
     end
 
     should 'not use payload if Content-Type is not x-www-form-urlencoded' do
-      @env.merge!(RC::REQUEST_PAYLOAD => {'pay' => 'load'},
-                  RC::REQUEST_HEADERS => {'Content-Type' => 'text/plain'})
-      check
+      check[
+        env.merge(RC::REQUEST_PAYLOAD => {'pay' => 'load'},
+                  RC::REQUEST_HEADERS => {'Content-Type' => 'text/plain'}),
+        base_string]
     end
 
     should 'use payload if Content-Type is x-www-form-urlencoded' do
-      @base_string << '%26pay%3Dload'
-      @env.merge!(RC::REQUEST_PAYLOAD => {'pay' => 'load'},
-                  RC::REQUEST_HEADERS =>
-                    {'Content-Type' => 'application/x-www-form-urlencoded'})
-      check
+      check[env.merge(
+              RC::REQUEST_PAYLOAD => {'pay' => 'load'},
+              RC::REQUEST_HEADERS =>
+                {'Content-Type' => 'application/x-www-form-urlencoded'}),
+            base_string + '%26pay%3Dload']
     end
 
     should 'use payload if there is no binary data' do
-      @base_string << '%26pay%3Dload'
-      @env.merge!(RC::REQUEST_PAYLOAD => {'pay' => 'load'})
-      check
+      check[env.merge(RC::REQUEST_PAYLOAD => {'pay' => 'load'}),
+            base_string + '%26pay%3Dload']
     end
 
     should 'not escape ~' do
-      @base_string << '%26tilde%3D~'
-      @env.merge!(RC::REQUEST_PAYLOAD => {'tilde' => '~'})
-      check
+      check[env.merge(RC::REQUEST_PAYLOAD => {'tilde' => '~'}),
+            base_string + '%26tilde%3D~']
     end
   end
 end

data/test/test_payload.rb

@@ -1,37 +1,204 @@
 
 require 'rest-core/test'
 
-describe RC::DefaultPayload do
-  app = RC::DefaultPayload.new(RC::Dry.new, {})
+describe RC::Payload do
+  describe 'A regular Payload' do
+    should 'use standard enctype as default content-type' do
+      RC::Payload::UrlEncoded.new({}).headers['Content-Type'].
+        should.eq 'application/x-www-form-urlencoded'
+    end
 
-  should 'do nothing' do
-    app.call({}){ |r| r[RC::REQUEST_PAYLOAD].should.eq({}) }
+    should 'form properly encoded params' do
+      RC::Payload::UrlEncoded.new(:foo => 'bar').read.
+        should.eq 'foo=bar'
+      RC::Payload::UrlEncoded.new(:foo => 'bar', :baz => 'qux').read.
+        should.eq 'baz=qux&foo=bar'
+    end
+
+    should 'escape parameters' do
+      RC::Payload::UrlEncoded.new('foo ' => 'bar').read.
+        should.eq 'foo%20=bar'
+    end
+
+    should 'properly handle arrays as repeated parameters' do
+      RC::Payload::UrlEncoded.new(:foo => ['bar']).read.
+        should.eq 'foo=bar'
+      RC::Payload::UrlEncoded.new(:foo => ['bar', 'baz']).read.
+        should.eq 'foo=bar&foo=baz'
+    end
+
+    should 'not close if stream already closed' do
+      p = RC::Payload::UrlEncoded.new('foo ' => 'bar')
+      p.close
+      2.times{ p.close.should.eq nil }
+    end
   end
 
-  should 'merge payload' do
-    app.instance_eval{@payload = {'pay' => 'load'}}
+  describe 'A multipart Payload' do
+    should 'use standard enctype as default content-type' do
+      p = RC::Payload::Multipart.new({})
+      stub(p).boundary{123}
+      p.headers['Content-Type'].should.eq 'multipart/form-data; boundary=123'
+    end
+
+    should 'not error on close if stream already closed' do
+      p = RC::Payload::Multipart.new(:file => File.open(__FILE__))
+      p.close
+      2.times{ p.close.should.eq nil }
+    end
 
-    app.call({}){ |r| r.should.eq({RC::REQUEST_PAYLOAD =>
-      {'pay' => 'load'}}) }
+    should 'form properly separated multipart data' do
+      p = RC::Payload::Multipart.new(:bar => 'baz', :foo => 'bar')
+      p.read.should.eq <<-EOS
+--#{p.boundary}\r
+Content-Disposition: form-data; name="bar"\r
+\r
+baz\r
+--#{p.boundary}\r
+Content-Disposition: form-data; name="foo"\r
+\r
+bar\r
+--#{p.boundary}--\r
+      EOS
+    end
 
-    format = {'format' => 'json'}
-    env    = {RC::REQUEST_PAYLOAD => format}
+    should 'form multiple files with the same name' do
+      with_img do |f, n|
+        with_img do |ff, nn|
+          p = RC::Payload::Multipart.new(:foo => [f, ff])
+          p.read.should.eq <<-EOS
+--#{p.boundary}\r
+Content-Disposition: form-data; name="foo"; filename="#{n}"\r
+Content-Type: image/jpeg\r
+\r
+#{'a'*10}\r
+--#{p.boundary}\r
+Content-Disposition: form-data; name="foo"; filename="#{nn}"\r
+Content-Type: image/jpeg\r
+\r
+#{'a'*10}\r
+--#{p.boundary}--\r
+          EOS
+        end
+      end
+    end
 
-    app.call(env){ |r| r.should.eq({RC::REQUEST_PAYLOAD =>
-      {'pay' => 'load'}.merge(format)})}
+    should 'not escape parameters names' do
+      p = RC::Payload::Multipart.new('bar ' => 'baz')
+      p.read.should.eq <<-EOS
+--#{p.boundary}\r
+Content-Disposition: form-data; name="bar "\r
+\r
+baz\r
+--#{p.boundary}--\r
+      EOS
+    end
+
+    should 'form properly separated multipart data' do
+      with_img do |f, n|
+        p = RC::Payload::Multipart.new(:foo => f)
+        p.read.should.eq <<-EOS
+--#{p.boundary}\r
+Content-Disposition: form-data; name="foo"; filename="#{n}"\r
+Content-Type: image/jpeg\r
+\r
+#{File.read(f.path)}\r
+--#{p.boundary}--\r
+        EOS
+      end
+    end
+
+    should "ignore the name attribute when it's not set" do
+      with_img do |f, n|
+        p = RC::Payload::Multipart.new(nil => f)
+        p.read.should.eq <<-EOS
+--#{p.boundary}\r
+Content-Disposition: form-data; filename="#{n}"\r
+Content-Type: image/jpeg\r
+\r
+#{File.read(f.path)}\r
+--#{p.boundary}--\r
+        EOS
+      end
+    end
+
+    should 'detect optional (original) content type and filename' do
+      File.open(__FILE__) do |f|
+        def f.content_type     ; 'image/jpeg'; end
+        def f.original_filename; 'foo.txt'   ; end
+        p = RC::Payload::Multipart.new(:foo => f)
+        p.read.should.eq <<-EOS
+--#{p.boundary}\r
+Content-Disposition: form-data; name="foo"; filename="foo.txt"\r
+Content-Type: image/jpeg\r
+\r
+#{File.read(f.path)}\r
+--#{p.boundary}--\r
+        EOS
+      end
+    end
   end
 
-  should 'accept non-hash payload' do
-    u = RC::Universal.new(:log_method => false)
-    env = {RC::REQUEST_PAYLOAD => 'payload'}
-    u.request_full(env, u.dry)[RC::REQUEST_PAYLOAD].should.eq('payload')
+  describe 'streamed payloads' do
+    should 'properly determine the size of file payloads' do
+      File.open(__FILE__) do |f|
+        p = RC::Payload.generate(f)
+        p.size.should.eq f.stat.size
+      end
+    end
+
+    should 'properly determine the size of other kinds of payloads' do
+      s = StringIO.new('foo')
+      p = RC::Payload.generate(s)
+      p.size.should.eq 3
+
+      begin
+        f = Tempfile.new('rest-core')
+        f.write('foo bar')
+        f.rewind
+
+        p = RC::Payload.generate(f)
+        p.size.should.eq 7
+      ensure
+        f.close!
+      end
+    end
+  end
+
+  describe 'Payload generation' do
+    should 'recognize standard urlencoded params' do
+      RC::Payload.generate('foo' => 'bar').should.
+        kind_of?(RC::Payload::UrlEncoded)
+    end
+
+    should 'recognize multipart params' do
+      File.open(__FILE__) do |f|
+        RC::Payload.generate('foo' => f).should.
+          kind_of?(RC::Payload::Multipart)
+      end
+    end
+
+    should 'return data if none of the above' do
+      RC::Payload.generate('data').should.
+        kind_of?(RC::Payload::StreamedString)
+    end
+
+    should 'recognize nested multipart payloads in arrays' do
+      File.open(__FILE__) do |f|
+        RC::Payload.generate('foo' => [f]).should.
+          kind_of?(RC::Payload::Multipart)
+      end
+    end
 
-    u.payload = 'default'
-    u.request_full(env, u.dry)[RC::REQUEST_PAYLOAD].should.eq('payload')
-    u.request_full({} , u.dry)[RC::REQUEST_PAYLOAD].should.eq('default')
+    should 'recognize file payloads that can be streamed' do
+      File.open(__FILE__) do |f|
+        RC::Payload.generate(f).should.kind_of?(RC::Payload::Streamed)
+      end
+    end
 
-    u = RC::Builder.client{use RC::DefaultPayload, 'maylord'}.new
-    u.request_full({} , u.dry)[RC::REQUEST_PAYLOAD].should.eq('maylord')
-    u.request_full(env, u.dry)[RC::REQUEST_PAYLOAD].should.eq('payload')
+    should 'recognize other payloads that can be streamed' do
+      RC::Payload.generate(StringIO.new('foo')).should.
+        kind_of?(RC::Payload::Streamed)
+    end
   end
 end