rest-builder 0.9.0

data/test/test_builder.rb

@@ -0,0 +1,45 @@
+
+require 'rest-builder/test'
+
+describe RestBuilder::Builder do
+  would 'default client app is a kind of RestBuilder::Engine' do
+    RestBuilder::Builder.client.new.app.should.kind_of? RestBuilder::Engine
+  end
+
+  would 'default        app is a kind of RestBuilder::Engine' do
+    RestBuilder::Builder.new.to_app.should.kind_of? RestBuilder::Engine
+  end
+
+  would 'switch default_engine to RestBuilder::Dry a' do
+    builder = Class.new(RestBuilder::Builder)
+    builder.default_engine = RestBuilder::Dry
+    builder.new.to_app.class.should.eq RestBuilder::Dry
+  end
+
+  would 'switch default_engine to RestBuilder::Dry b' do
+    builder = RestBuilder::Builder.dup
+    builder.default_engine = RestBuilder::Dry
+    builder.client.new.app.class.should.eq RestBuilder::Dry
+  end
+
+  would 'accept middleware without a member' do
+    RestBuilder::Builder.client{
+      use Class.new.send(:include, RestBuilder::Middleware)
+    }.members.should.eq [:config_engine]
+  end
+
+  would 'not have duplicated fields' do
+    middleware = Class.new do
+      def self.members; [:value]; end
+      include RestBuilder::Middleware
+    end
+    client = RestBuilder::Builder.client(:value){ use middleware }.new
+    client.value = 10
+    client.value.should.eq 10
+  end
+
+  would 'have the same pool for the same client' do
+    client = RestBuilder::Builder.client
+    client.thread_pool.object_id.should.eq client.thread_pool.object_id
+  end
+end

data/test/test_client.rb

@@ -0,0 +1,212 @@
+
+require 'rest-builder/test'
+
+describe RestBuilder::Client do
+  after do
+    WebMock.reset!
+    Muack.verify
+  end
+
+  url = 'http://example.com/'
+  simple = RestBuilder::Builder.client
+
+  would 'do simple request' do
+    c = simple.new
+    [:get, :post, :delete, :put, :patch].each do |method|
+      stub_request(method, url).to_return(:body => '[]')
+      c.send(method, url).should.eq '[]'
+    end
+
+    stub_request(:head   , url).to_return(:headers => {'A' => 'B'})
+    c.   head(url).should.eq('A' => 'B')
+
+    stub_request(:options, url).to_return(:headers => {'A' => 'B'})
+    c.options(url).should.eq('A' => 'B')
+  end
+
+  would 'call the callback' do
+    [:get, :post, :delete, :put, :patch].each do |method|
+      stub_request(method, url).to_return(:body => '123')
+      (client = 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 = simple.new).head(url){ |res|
+      res.should.eq({'A' => 'B'})
+    }.should.eq client
+    client.wait
+
+    stub_request(:options, url).to_return(:headers => {'A' => 'B'})
+    (client = simple.new).options(url){ |res|
+      res.should.eq('A' => 'B')
+    }.should.eq client
+    client.wait
+  end
+
+  would 'wait for all the requests' do
+    t, i, m = 5, 0, Mutex.new
+    stub_request(:get, url).to_return do
+      m.synchronize{ i += 1 }
+      Thread.pass
+      {}
+    end
+
+    client = RestBuilder::Builder.client
+    t.times{ client.new.get(url) }
+    client.wait
+    client.promises.should.empty?
+    i.should.eq t
+  end
+
+  would 'wait for callback' do
+    rd, wr = IO.pipe
+    called = false
+    stub_request(:get, url).to_return(:body => 'nnf')
+    client = simple.new.get(url) do |nnf|
+      wr.puts
+      sleep 0.001 # make sure our callback is slow enough,
+                  # so that if `wait` is not waiting for the callback,
+                  # it would leave before the callback is completely done.
+                  # without sleeping, the callback is very likely to be
+                  # done first than `wait` anyway. raising the sleeping time
+                  # would make this test more reliable...
+      called = true
+      nil # test against returning nil, so that Promise#response is not set
+    end
+    rd.gets
+    client.wait
+    called.should.eq true
+  end
+
+  would 'cleanup promises' do
+    stub_request(:get, url).to_return(:body => 'nnf')
+    5.times{ simple.new.get(url) }
+    Thread.pass
+    GC.start # can only force GC run on MRI, so we mock for jruby and rubinius
+    stub(any_instance_of(WeakRef)).weakref_alive?{false}
+    simple.new.get(url)
+    simple.promises.size.should.lt 6
+    simple.shutdown
+    simple.promises.should.empty?
+  end
+
+  would 'have correct to_i' do
+    stub_request(:get, url).to_return(:body => '123')
+    simple.new.get(url).to_i.should.eq 123
+  end
+
+  would 'use defaults' do
+    client = RestBuilder::Builder.client do
+      use Class.new{
+        def self.members; [:timeout]; end
+        include RestBuilder::Middleware
+      }, 4
+    end
+    c = client.new
+    c.timeout.should.eq 4 # default goes to middleware
+    client.extend(Module.new do
+      def default_timeout
+        3
+      end
+    end)
+    c.timeout.should.eq 4 # default is cached, so it stays the same
+    c.timeout = nil       # clear cache
+    c.timeout.should.eq 3 # now default goes to module default
+    class << client
+      def default_timeout # module defaults could be overriden
+        super - 1
+      end
+    end
+    c.timeout = nil
+    c.timeout.should.eq 2 # so it goes to class default
+    c.timeout = 1         # setup instance level value
+    c.build_env(                )['timeout'].should.eq 1 # pick instance var
+    c.build_env({'timeout' => 0})['timeout'].should.eq 0 # per-request var
+    c.timeout.should.eq 1 # won't affect underlying instance var
+    c.timeout = nil
+    c.timeout.should.eq 2 # goes back to class default
+    c.timeout = false
+    c.timeout.should.eq false # false would disable default
+  end
+
+  would 'work for inheritance' do
+    stub_request(:get, url).to_return(:body => '123')
+    Class.new(simple).new.get(url).should.eq '123'
+  end
+
+  would 'not deadlock when exception was raised in the callback' do
+    client = Class.new(simple).new
+    stub_request(:get, url).to_return(:body => 'nnf')
+
+    (-1..1).each do |size|
+      mock(any_instance_of(RestBuilder::Promise)).warn(is_a(String)) do |msg|
+        msg.should.include?('nnf')
+      end
+      client.class.pool_size = size
+      client.get(url) do |body|
+        raise body
+      end
+      client.class.shutdown
+    end
+  end
+
+  would 'be able to access caller outside the callback' do
+    flag = false
+    client = simple.new
+    stub_request(:get, url).to_return(:body => 'nnf')
+    client.get(url) do
+      current_file = /^#{__FILE__}/
+                     caller.grep(current_file).should.empty?
+      RestBuilder::Promise.backtrace.grep(current_file).should.not.empty?
+      client.get(url) do
+        RestBuilder::Promise.backtrace.last.should.not =~ /promise\.rb:\d+:in/
+        flag = true
+      end
+    end
+    client.wait
+    flag.should.eq true # to make sure the inner most block did run
+  end
+
+  would 'call error_callback' do
+    error = nil
+    error_callback = lambda{ |e| error = e }
+    should.raise(Errno::ECONNREFUSED) do
+      simple.new(:error_callback => error_callback).
+        get('http://localhost:1').tap{}
+    end
+    error.should.kind_of?(Errno::ECONNREFUSED)
+  end
+
+  path = 'http://example.com/'
+
+  would 'give RESPONSE_BODY' do
+    stub_request(:get, path).to_return(:body => 'OK')
+    simple.new.get(path).should.eq 'OK'
+  end
+
+  would 'give RESPONSE_HEADERS' do
+    stub_request(:head, path).to_return(:headers => {'A' => 'B'})
+    simple.new.head(path).should.eq 'A' => 'B'
+  end
+
+  would 'give RESPONSE_HEADERS' do
+    stub_request(:get, path).to_return(:status => 199)
+    simple.new.get(path, {},
+      RestBuilder::RESPONSE_KEY => RestBuilder::RESPONSE_STATUS).should.eq 199
+  end
+
+  would 'give RESPONSE_SOCKET' do
+    stub_request(:get, path).to_return(:body => 'OK')
+    simple.new.get(path, {}, RestBuilder::HIJACK => true).read.should.eq 'OK'
+  end
+
+  would 'give REQUEST_URI' do
+    stub_request(:get, "#{path}?a=b").to_return(:body => 'OK')
+    simple.new.get(path, {:a => 'b'},
+      RestBuilder::RESPONSE_KEY => RestBuilder::REQUEST_URI).
+      should.eq "#{path}?a=b"
+    simple.wait
+  end
+end

data/test/test_event_source.rb

@@ -0,0 +1,152 @@
+
+require 'socket'
+require 'rest-builder/test'
+
+describe RestBuilder::EventSource do
+  after do
+    Muack.verify
+    WebMock.reset!
+  end
+
+  client = RestBuilder::Builder.client.new
+  server = lambda do |close=true|
+    serv = TCPServer.new(0)
+    port = serv.addr[1]
+    path = "http://localhost:#{port}/"
+    payload = <<-SSE
+event: put
+data: {}
+
+event: keep-alive
+data: null
+SSE
+    m = [{'event' => 'put'       , 'data' => '{}'},
+         {'event' => 'keep-alive', 'data' => 'null'}]
+
+    t = Thread.new do
+      sock = serv.accept
+      sock.readline("\r\n\r\n")
+      sock.puts("HTTP/1.1 200 OK\r")
+      sock.puts("Content-Type: text/event-stream\r")
+      sock.puts
+      sock.puts(payload)
+      sock.close if close
+    end
+
+    [client.event_source(path, :a => 'b'), m, t]
+  end
+
+  would 'work regularly' do
+    es, m, t = server.call
+    flag = 0
+
+    es.onopen do |sock|
+      sock.should.kind_of? IO
+      flag.should.eq 0
+      flag += 1
+    end.
+    onmessage do |event, data, sock|
+      {'event' => event, 'data' => data}.should.eq m.shift
+      sock.should.kind_of? IO
+      sock.should.not.closed?
+      flag += 1
+    end.
+    onerror do |error, sock|
+      error.should.kind_of? EOFError
+      m.should.empty?
+      sock.should.closed?
+      flag.should.eq 3
+      flag += 1
+    end.start.wait
+
+    flag.should.eq 4
+    t.join
+  end
+
+  would 'close' do
+    es, _, t = server.call(false)
+    flag = 0
+    es.onmessage do
+      es.close
+      flag += 1
+    end.start.wait
+
+    flag.should.eq 1
+    t.join
+  end
+
+  would 'reconnect' do
+    stub_select_for_stringio
+    stub_request(:get, 'https://a?b=c').to_return(:body => <<-SSE)
+event: put
+data: 0
+
+event: put
+data: 1
+SSE
+    stub_request(:get, 'https://a?c=d').to_return(:body => <<-SSE)
+event: put
+data: 2
+
+event: put
+data: 3
+SSE
+    es = client.event_source('https://a', :b => 'c')
+    m = ('0'..'3').to_a
+    es.onmessage do |event, data|
+      data.should.eq m.shift
+
+    end.onerror do |error|
+      error.should.kind_of? EOFError
+      es.query = {:c => 'd'}
+
+    end.onreconnect do |error, sock|
+      error.should.kind_of? EOFError
+      sock.should.respond_to? :read
+      !m.empty? # not empty to reconnect
+
+    end.start.wait
+    m.should.empty?
+  end
+
+  would 'not cache' do
+    stub_select_for_stringio
+    stub_request(:get, 'https://a?b=c').to_return(:body => <<-SSE)
+event: put
+data: 0
+
+event: put
+data: 1
+SSE
+    es = client.event_source('https://a', :b => 'c')
+    m = %w[0 1 0 1]
+    es.onmessage do |event, data|
+      data.should.eq m.shift
+
+    end.onerror do |error|
+      error.should.kind_of? EOFError
+
+    end.onreconnect do |error, sock|
+      error.should.kind_of? EOFError
+      sock.should.respond_to? :read
+      !m.empty? # not empty to reconnect
+
+    end.start.wait
+    m.should.empty?
+  end
+
+  would 'not deadlock without ErrorHandler' do
+    c = RestBuilder::Builder.client.new.event_source('http://localhost:1')
+    c.onerror{ |e| e.should.kind_of?(Errno::ECONNREFUSED) }
+    c.start.wait
+  end
+
+  would 'not deadlock if errors in onmessage' do
+    err = nil
+    es, _, _ = server.call
+    es.onmessage do |event, data|
+      raise err = "error"
+    end.start.wait
+    err.should.eq "error"
+  end
+end

data/test/test_future.rb

@@ -0,0 +1,21 @@
+
+require 'stringio'
+require 'rest-builder/test'
+
+describe RestBuilder::Promise::Future do
+  would 'fulfill the future' do
+    promise = RestBuilder::Promise.new
+    promise.fulfill(RestBuilder::RESPONSE_STATUS => 200,
+                    RestBuilder::RESPONSE_HEADERS => {'A' => 'B'},
+                    RestBuilder::RESPONSE_BODY => 'body',
+                    RestBuilder::RESPONSE_SOCKET => StringIO.new,
+                    RestBuilder::FAIL => [])
+
+    promise.future_body    .should.eq 'body'
+    promise.future_status  .should.eq 200
+    promise.future_headers .should.eq('A' => 'B')
+    promise.future_socket  .should.kind_of?(StringIO)
+    promise.future_failures.should.eq []
+    ([] + promise.future_failures).should.eq []
+  end
+end

data/test/test_httpclient.rb

@@ -0,0 +1,118 @@
+
+require 'rest-builder/test'
+
+require 'openssl'
+require 'socket'
+require 'zlib'
+
+describe RestBuilder::HttpClient do
+  describe 'POST Payload' do
+    after do
+      WebMock.reset!
+    end
+
+    client = RestBuilder::Builder.client
+    path = 'http://example.com'
+    ok   = 'OK'
+    c    = client.new
+
+    post = lambda do |payload, body|
+      WebMock::API.stub_request(:post, path).
+        with(:body => body).to_return(:body => ok)
+      c.post(path, payload).should.eq ok
+    end
+
+    would 'post with string' do
+      post['string', 'string']
+    end
+
+    would 'post with file' do
+      File.open(__FILE__) do |f|
+        b = f.read
+        f.rewind
+        post[f, b]
+      end
+    end
+
+    would 'post with socket' do
+      rd, wr = IO.pipe
+      wr.write('socket')
+      wr.close
+      post[rd, 'socket']
+    end
+
+    would 'not kill the thread if error was coming from the task' do
+      mock(HTTPClient).new{ raise 'boom' }.with_any_args
+      c.request(RestBuilder::ASYNC => true).message.should.eq 'boom'
+      Muack.verify
+    end
+
+    def accept body
+      server = TCPServer.new(0)
+      t = Thread.new do
+        client = server.accept
+        client.write(<<-HTTP)
+HTTP/1.0 200 OK\r
+Connection: close\r
+Content-Encoding: deflate\r
+\r
+#{body}\r
+          HTTP
+        client.close_write
+      end
+
+      yield("http://localhost:#{server.local_address.ip_port}")
+
+      t.join
+    end
+
+    would 'accept deflate' do
+      accept(Zlib::Deflate.deflate(ok)) do |site|
+        c.post(site, 'body').should.eq ok
+      end
+    end
+
+    config_engine = lambda do |engine|
+      engine.transparent_gzip_decompression = false
+      engine.ssl_config.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    end
+
+    define_method(:define_default_config_engine) do |d|
+      d.singleton_class.module_eval do
+        define_method(:default_config_engine) do
+          config_engine
+        end
+      end
+    end
+
+    would 'disable auto-deflate' do
+      accept(ok) do |site|
+        c.post(site, 'body', {}, :config_engine => config_engine).
+          chomp.should.eq ok
+      end
+    end
+
+    would 'disable auto-deflate with class default_config_engine' do
+      accept(ok) do |site|
+        d = RestBuilder::Builder.client
+        define_default_config_engine(d)
+        d.new.post(site, 'body').chomp.should.eq ok
+      end
+    end
+
+    would 'disable auto-deflate with instance default_config_engine' do
+      accept(ok) do |site|
+        d = RestBuilder::Builder.client.new
+        define_default_config_engine(d)
+        d.post(site, 'body').chomp.should.eq ok
+      end
+    end
+
+    would 'disable auto-deflate with setting config_engine' do
+      accept(ok) do |site|
+        d = RestBuilder::Builder.client.new(:config_engine => config_engine)
+        d.post(site, 'body').chomp.should.eq ok
+      end
+    end
+  end
+end