rest-core 1.0.3 → 2.0.0

data/test/test_auth_basic.rb

@@ -1,36 +1,40 @@
 
 require 'rest-core/test'
 
-describe RestCore::AuthBasic do
+describe RC::AuthBasic do
   before do
-    @auth = RestCore::AuthBasic.new(RestCore::Dry.new, nil, nil)
+    @auth = RC::AuthBasic.new(RC::Dry.new, nil, nil)
   end
 
   should 'do nothing' do
-    @auth.call({}).should.eq({})
+    @auth.call({}){ |res| res.should.eq({}) }
   end
 
   should 'send Authorization header' do
     @auth.instance_eval{@username = 'Aladdin'}
     @auth.instance_eval{@password = 'open sesame'}
 
-    @auth.call({}).should.eq({RestCore::REQUEST_HEADERS =>
-      {'Authorization' => 'Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ=='}})
+    @auth.call({}){ |res|
+      res.should.eq({RC::REQUEST_HEADERS =>
+        {'Authorization' => 'Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ=='}})
+    }
 
     acc = {'Accept' => 'text/plain'}
-    env = {RestCore::REQUEST_HEADERS => acc}
+    env = {RC::REQUEST_HEADERS => acc}
 
-    @auth.call(env).should.eq({RestCore::REQUEST_HEADERS =>
-      {'Authorization' => 'Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ=='}.merge(acc)})
+    @auth.call(env){ |res|
+      res.should.eq({RC::REQUEST_HEADERS =>
+        {'Authorization' => 'Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ=='}.merge(acc)})
+    }
   end
 
   should 'leave a log if username are not both provided' do
     @auth.instance_eval{@username = 'Aladdin'}
-    @auth.call({})[RestCore::LOG].size.should.eq 1
+    @auth.call({}){ |res| res[RC::LOG].size.should.eq 1 }
   end
 
   should 'leave a log if password are not both provided' do
     @auth.instance_eval{@password = 'open sesame'}
-    @auth.call({})[RestCore::LOG].size.should.eq 1
+    @auth.call({}){ |res| res[RC::LOG].size.should.eq 1 }
   end
 end

data/test/test_builder.rb

@@ -1,14 +1,14 @@
 
 require 'rest-core/test'
 
-describe RestCore::Builder do
-  should 'default app is RestCore::RestClient' do
-    RestCore::Builder.client.new.app.class.should.eq RestCore::RestClient
+describe RC::Builder do
+  should 'default app is RestCore::Auto' do
+    RC::Builder.client.new.app.class.should.eq RC::Auto
   end
 
-  should 'switch default_app to RestCore::Dry' do
-    builder = RestCore::Builder.dup
-    builder.default_app = RestCore::Dry
-    builder.client.new.app.class.should.eq RestCore::Dry
+  should 'switch default_engine to RestCore::Dry' do
+    builder = RC::Builder.dup
+    builder.default_engine = RC::Dry
+    builder.client.new.app.class.should.eq RC::Dry
   end
 end

data/test/test_cache.rb

@@ -7,7 +7,7 @@ describe RC::Cache do
     RR.verify
   end
 
-  should 'basic' do
+  should 'basic 0' do
     c = RC::Builder.client do
       use RC::Cache, {}, 3600
       run Class.new{
@@ -17,71 +17,160 @@ describe RC::Cache do
         end
         def call env
           self.tick +=1
-          env.merge(RC::RESPONSE_BODY => 'response')
+          yield(env.merge(RC::RESPONSE_BODY    => 'response',
+                          RC::RESPONSE_HEADERS => {'A' => 'B'},
+                          RC::RESPONSE_STATUS  => 200))
         end
       }
     end.new
     c.get('/')
-    c.cache.should.eq({Digest::MD5.hexdigest('/') => 'response'})
+    key = Digest::MD5.hexdigest('get:/:')
+    c.cache.should.eq("rest-core:cache:#{key}" => "200\nA: B\n\nresponse")
     c.app.app.tick.should.eq 1
     c.get('/')
     c.app.app.tick.should.eq 1
     c.cache.clear
     c.get('/')
     c.app.app.tick.should.eq 2
+    c.head('/').should.eq('A' => 'B')
+    c.get('/').should.eq 'response'
+    c.request({RC::REQUEST_PATH => '/'}, RC::RESPONSE_STATUS).should.eq 200
   end
 
-  should 'cancel timeout for fiber' do
-    any_instance_of(RC::Timeout::EventMachineTimer) do |timer|
-      proxy.mock(timer).cancel.times(2)
+  should 'basic 1' do
+    path = 'http://a'
+    stub_request(:get , path).to_return(:body => 'OK')
+    stub_request(:post, path).to_return(:body => 'OK')
+    c = RC::Builder.client do
+      use RC::Cache, nil, nil
     end
-    path = 'http://example.com/'
-    stub_request(:get, path).to_return(:body => 'response')
+
+    c.new                  . get(path).should.eq('OK')
+    c.new(:cache => (h={})).post(path).should.eq('OK')
+    h.should.eq({})
+    c.new(:cache => (h={})). get(path).should.eq('OK')
+    h.size.should.eq 1
+    c.new(:cache => (h={})). get(path, {}, :cache => false).should.eq('OK')
+    h.should.eq({})
+    c.new                  . get(path, {}, 'cache.update' => true).
+                                                            should.eq('OK')
+  end
+
+  should 'not raise error if headers is nil' do
+    path = 'http://a'
+    stub_request(:get , path).to_return(:body => 'OK', :headers => nil)
     c = RC::Builder.client do
-      use RC::Timeout, 10
-      use RC::Cache, {}, 3600
-      run RC::EmHttpRequestFiber
+      use RC::Cache, {}, nil
     end.new
-    EM.run{ Fiber.new{
-      c.request_full(RC::REQUEST_PATH => path)
-      c.request_full(RC::REQUEST_PATH => path)
-      EM.stop }.resume }
-    c.cache.size.should.eq 1
-  end if defined?(Fiber)
-
-  should 'cancel timeout for async' do
-    path = 'http://example.com/'
-    any_instance_of(RC::Timeout::EventMachineTimer) do |timer|
-      mock(timer).cancel.times(2)
-    end
-    stub_request(:get, path).to_return(:body => 'response')
+    c.get(path).should.eq 'OK'
+    c.get(path).should.eq 'OK'
+  end
+
+  should 'head then get' do
     c = RC::Builder.client do
-      use RC::Timeout, 10
-      use RC::Cache, {}, 3600
-      run RC::EmHttpRequestAsync
+      use RC::Cache, {}, nil
     end.new
-    EM.run{
-      c.request_full(RC::REQUEST_PATH => path){
-        c.request_full(RC::REQUEST_PATH => path){
-          EM.stop }}}
-    c.cache.size.should.eq 1
+    path = 'http://example.com'
+    stub_request(:head, path).to_return(:headers => {'A' => 'B'})
+    c.head(path).should.eq('A' => 'B')
+    stub_request(:get , path).to_return(:body => 'body')
+    c.get(path).should.eq('body')
   end
 
   should 'only [] and []= should be implemented' do
     cache = Class.new do
-      def initialize    ; @h = {}            ; end
-      def []  key       ; @h[key]            ; end
-      def []= key, value; @h[key] = value * 2; end
+      def initialize    ; @h = {}                      ; end
+      def []  key       ; @h[key]                      ; end
+      def []= key, value; @h[key] = value.sub('4', '5'); end
     end.new
     c = RC::Builder.client do
       use RC::Cache, cache, 0
       run Class.new{
         def call env
-          env.merge(RC::RESPONSE_BODY => env[RC::REQUEST_PATH])
+          yield(env.merge(RC::RESPONSE_BODY   => env[RC::REQUEST_PATH],
+                          RC::RESPONSE_STATUS => 200))
         end
       }
     end.new
     c.get('4')
-    c.get('4').should.eq '44'
+    c.get('4').should.eq '5'
+  end
+
+  should 'cache the original response' do
+    c = RC::Builder.client do
+      use RC::Cache, {}, 3600 do
+        use RC::JsonResponse, true
+      end
+    end.new
+    stub_request(:get, 'me').to_return(:body => body = '{"a":"b"}')
+    c.get('me').should.eq 'a' => 'b'
+    c.cache.values.first.should.eq "200\n\n\n#{body}"
+  end
+
+  should "follow redirect with cache.update correctly" do
+    c = RC::Builder.client do
+      use RC::FollowRedirect, 10
+      use RC::Cache, {}, nil
+    end.new
+    x, y, z = 'http://X', 'http://Y', 'http://Z'
+    stub_request(:get, x).to_return(:headers => {'Location' => y},
+                                    :status  => 301)
+    stub_request(:get, y).to_return(:headers => {'Location' => z},
+                                    :status  => 302)
+    stub_request(:get, z).to_return(:body => 'OK')
+    c.get(x, {}, 'cache.update' => true).should.eq 'OK'
+  end
+
+  should 'not cache post/put/delete' do
+    [:put, :post, :delete].each{ |meth|
+      url, body = "https://cache", 'ok'
+      stub_request(meth, url).to_return(:body => body).times(3)
+
+      cache = {}
+      c = RC::Builder.client{use RC::Cache, cache, nil}.new
+      3.times{
+        if meth == :delete
+          c.send(meth, url).should.eq(body)
+        else
+          c.send(meth, url, 'payload').should.eq(body)
+        end
+      }
+      cache.should.eq({})
+    }
+  end
+
+  should 'update cache if there is cache option set to false' do
+    url, body = "https://cache", 'ok'
+    stub_request(:get, url).to_return(:body => body)
+    c = RC::Builder.client{use RC::Cache, {}, nil}.new
+
+    c.get(url)                            .should.eq body
+    stub_request(:get, url).to_return(:body => body.reverse).times(2)
+    c.get(url)                            .should.eq body
+    c.get(url, {}, 'cache.update' => true).should.eq body.reverse
+    c.get(url)                            .should.eq body.reverse
+    c.cache = nil
+    c.get(url, {}, 'cache.update' => true).should.eq body.reverse
+  end
+
+  describe 'expires_in' do
+    before do
+      @url, @body = "https://cache", 'ok'
+      stub_request(:get, @url).to_return(:body => @body)
+      @cache = {}
+      mock(@cache).method(:store){ mock!.arity{ -3 } }
+      mock(@cache).store(is_a(String), is_a(String), :expires_in => 3)
+      @cache
+    end
+
+    should 'respect in options' do
+      c = RC::Builder.client{use RC::Cache, nil, nil}.new
+      c.get(@url, {}, :cache => @cache, :expires_in => 3).should.eq @body
+    end
+
+    should 'respect in middleware' do
+      c = RC::Builder.client{use RC::Cache, nil,   3}.new(:cache => @cache)
+      c.get(@url).should.eq @body
+    end
   end
 end

data/test/test_client.rb

@@ -24,12 +24,14 @@ describe RC::Simple do
       stub_request(method, url).to_return(:body => '123')
       (client = RC::Simple.new).send(method, url){ |res|
         res.should.eq '123' }.should.eq client
+      client.wait
     end
 
     stub_request(:head, url).to_return(:headers => {'A' => 'B'})
     (client = RC::Simple.new).head(url){ |res|
       res.should.eq({'A' => 'B'})
     }.should.eq client
+    client.wait
   end
 
   should 'have correct to_i' do
@@ -38,7 +40,7 @@ describe RC::Simple do
   end
 
   should 'use defaults' do
-    client = RestCore::Builder.client do
+    client = RC::Builder.client do
       use RC::Timeout, 4
     end
     c = client.new

data/test/test_client_oauth1.rb

@@ -17,7 +17,7 @@ describe RC::ClientOauth1 do
     data = {'a' => 'b', 'c' => 'd'}
     sig = Digest::MD5.hexdigest('e&a=b&c=d')
     data_sig = data.merge('sig' => sig)
-    data_json = RC::JsonDecode.json_encode(data_sig)
+    data_json = RC::Json.encode(data_sig)
     @client = client.new(:data => data, :consumer_secret => 'e')
 
     @client.send(:calculate_sig).should.eq sig
@@ -26,8 +26,7 @@ describe RC::ClientOauth1 do
     @client.data_json = data_json
     @client.data.should.eq data_sig
 
-    @client.data_json = RC::JsonDecode.json_encode(
-      data_sig.merge('sig' => 'wrong'))
+    @client.data_json = RC::Json.encode(data_sig.merge('sig' => 'wrong'))
     @client.data.should.eq({})
 
     @client.data_json = data_json

data/test/test_default_query.rb

@@ -2,44 +2,38 @@
 require 'rest-core/test'
 
 describe RC::DefaultQuery do
-  describe 'when given query' do
-    before do
-      @app = RC::DefaultQuery.new(RC::Dry.new, {})
-    end
-
-    def app
-      @app
-    end
+  before do
+    @app = RC::DefaultQuery.new(RC::Dry.new, {})
+  end
 
+  describe 'when given query' do
     should 'do nothing' do
-      app.call({})[RC::REQUEST_QUERY].should.eq({})
+      @app.call({}){ |r| r[RC::REQUEST_QUERY].should.eq({}) }
     end
 
     should 'merge query' do
-      app.instance_eval{@query = {'q' => 'uery'}}
+      @app.instance_eval{@query = {'q' => 'uery'}}
 
-      app.call({}).should.eq({RC::REQUEST_QUERY =>
-        {'q' => 'uery'}})
+      @app.call({}){ |r| r.should.eq({RC::REQUEST_QUERY => {'q' => 'uery'}}) }
 
       format = {'format' => 'json'}
       env    = {RC::REQUEST_QUERY => format}
 
-      app.call(env).should.eq({RC::REQUEST_QUERY =>
-        {'q' => 'uery'}.merge(format)})
-    end
-  end
-
-  describe 'when not given query' do
-    before do
-      @app = RC::DefaultQuery.new(RC::Dry.new)
+      @app.call(env){ |r|
+        r.should.eq({RC::REQUEST_QUERY => {'q' => 'uery'}.merge(format)}) }
     end
 
-    def app
-      @app
+    should 'string_keys in query' do
+      env = {'query' => {:symbol => 'value'}}
+      @app.call(env){ |r|
+        r.should.eq({RC::REQUEST_QUERY => {'symbol' => 'value'}}.merge(env))
+      }
     end
+  end
 
+  describe 'when not given query' do
     should 'merge query with {}' do
-      app.call({}).should.eq({RC::REQUEST_QUERY => {}})
+      @app.call({}){ |r| r.should.eq({RC::REQUEST_QUERY => {}}) }
     end
   end
 end

data/test/test_em_http_request.rb

@@ -0,0 +1,146 @@
+
+require 'rest-core/test'
+
+describe RC::EmHttpRequest do
+  should 'raise RC::Error' do
+    EM.run{Fiber.new{
+      lambda{
+        RC::Universal.new.get('http://localhost:1').tap{}
+      }.should.raise(RC::Error)
+      EM.stop
+    }.resume}
+  end
+
+  should 'never crash EM!' do
+    EM.error_handler{ |e| e.should.kind_of?(NoMethodError); EM.stop}
+    EM.run{Fiber.new{
+      RC::Simple.new.get('http://localhost:1').no_such_method
+    }.resume}
+  end
+
+  # ----------------------------------------------------------------------
+
+  describe RC::Simple do
+    before do
+      @path = 'http://example.com'
+      stub_request(:get, @path).to_return(:body => 'OK')
+    end
+
+    should 'work with EM' do
+      EM.run{Fiber.new{
+        RC::Simple.new.get(@path).should.eq 'OK'; EM.stop}.resume}
+    end
+  end
+
+  # ----------------------------------------------------------------------
+
+  describe RC::Timeout do
+    after do
+      WebMock.reset!
+      RR.verify
+    end
+
+    should 'cancel timeout for fiber' do
+      any_instance_of(RC::Timeout::TimerEm) do |timer|
+        proxy.mock(timer).cancel.times(2)
+      end
+      path = 'http://example.com/'
+      stub_request(:get, path).to_return(:body => 'response')
+      c = RC::Builder.client do
+        use RC::Timeout, 10
+        use RC::Cache, {}, 3600
+        run RC::EmHttpRequest
+      end.new
+      EM.run{ Fiber.new{
+        c.request(RC::REQUEST_PATH => path).should.eq 'response'
+        c.request(RC::REQUEST_PATH => path).should.eq 'response'
+        EM.stop }.resume }
+      c.cache.size.should.eq 1
+    end
+
+    should 'cancel timeout for async' do
+      path = 'http://example.com/'
+      any_instance_of(RC::Timeout::TimerEm) do |timer|
+        mock(timer).cancel.times(2)
+      end
+      stub_request(:get, path).to_return(:body => 'response')
+      c = RC::Builder.client do
+        use RC::Timeout, 10
+        use RC::Cache, {}, 3600
+        run RC::EmHttpRequest
+      end.new
+      EM.run{
+        c.request_full(RC::REQUEST_PATH => path){
+          c.request_full(RC::REQUEST_PATH => path){
+            EM.stop }}}
+      c.cache.size.should.eq 1
+    end
+
+    should 'return correct result for futures' do
+      path = 'http://example.com/'
+      stub_request(:get, path).to_return(:body => 'response')
+
+      c = RC::Builder.client do
+        use RC::Timeout, 10
+        run RC::EmHttpRequest
+      end.new
+      EM.run{Fiber.new{c.get(path).should.eq('response');EM.stop}.resume}
+    end
+
+    describe 'raise exception' do
+      should 'default timeout' do
+        c = RC::Builder.client do
+          use RC::Timeout, 0.00001
+          run Class.new{
+            def call env
+              sleep 1
+              yield(env)
+            end
+          }
+        end.new
+        lambda{ c.get('') }.should.raise ::Timeout::Error
+      end
+
+      should 'future timeout' do
+        port = 35795
+        path = "http://localhost:#{port}/"
+
+        c = RC::Builder.client do
+          use RC::Timeout, 0.00001
+          run RC::EmHttpRequest
+        end.new
+
+        EM.run{
+          EM.start_server '127.0.0.1', port, Module.new{
+            def receive_data data; end
+          }
+          Fiber.new{
+            begin
+              c.get(path).tap{}
+            rescue => e
+              e.should.kind_of ::Timeout::Error
+              EM.stop
+            end
+          }.resume}
+      end
+
+      should 'async timeout' do
+        port = 35795
+        path = "http://localhost:#{port}/"
+
+        c = RC::Builder.client do
+          use RC::Timeout, 0.00001
+          use RC::ErrorHandler
+          run RC::EmHttpRequest
+        end.new
+
+        EM.run{
+          EM.start_server '127.0.0.1', port, Module.new{
+            def receive_data data; end
+          }
+          c.get(path){ |e| e.should.kind_of ::Timeout::Error; EM.stop }
+        }
+      end
+    end
+  end
+end unless RUBY_ENGINE == 'jruby'