rest-core 3.6.0 → 4.0.0

data/test/test_event_source.rb

@@ -1,159 +0,0 @@
-
-require 'socket'
-require 'rest-core/test'
-
-describe RC::EventSource do
-  after do
-    Muack.verify
-    WebMock.reset!
-  end
-
-  client = RC::Builder.client{use RC::Cache, {}, nil}.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 = RC::Simple.new.event_source('http://localhost:1')
-    c.onerror{ |e| e.should.kind_of?(Errno::ECONNREFUSED) }
-    c.start.wait
-  end
-
-  would 'not deadlock with ErrorHandler' do
-    c = RC::Universal.new(:log_method => false).
-               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

@@ -1,16 +0,0 @@
-
-require 'stringio'
-require 'rest-core/test'
-
-describe RC::Promise::Future do
-  would 'fulfill the future' do
-    promise = RC::Promise.new(RC::FAIL => [])
-    promise.fulfill('body', 200, {'A' => 'B'}, StringIO.new)
-
-    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 []
-  end
-end

data/test/test_httpclient.rb

@@ -1,118 +0,0 @@
-
-require 'rest-core/test'
-
-require 'openssl'
-require 'socket'
-require 'zlib'
-
-describe RC::HttpClient do
-  describe 'POST Payload' do
-    after do
-      WebMock.reset!
-    end
-
-    client = RC::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(RC::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 = RC::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 = RC::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 = RC::Builder.client.new(:config_engine => config_engine)
-        d.post(site, 'body').chomp.should.eq ok
-      end
-    end
-  end
-end

data/test/test_payload.rb

@@ -1,204 +0,0 @@
-
-require 'rest-core/test'
-
-describe RC::Payload do
-  describe 'A regular Payload' do
-    would 'use standard enctype as default content-type' do
-      RC::Payload::UrlEncoded.new({}).headers['Content-Type'].
-        should.eq 'application/x-www-form-urlencoded'
-    end
-
-    would '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
-
-    would 'escape parameters' do
-      RC::Payload::UrlEncoded.new('foo ' => 'bar').read.
-        should.eq 'foo%20=bar'
-    end
-
-    would '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
-
-    would '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
-
-  describe 'A multipart Payload' do
-    would '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
-
-    would '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
-
-    would '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
-
-    would '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
-
-    would '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
-
-    would '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
-
-    would "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
-
-    would '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
-
-  describe 'streamed payloads' do
-    would '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
-
-    would '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
-    would 'recognize standard urlencoded params' do
-      RC::Payload.generate('foo' => 'bar').should.
-        kind_of?(RC::Payload::UrlEncoded)
-    end
-
-    would 'recognize multipart params' do
-      File.open(__FILE__) do |f|
-        RC::Payload.generate('foo' => f).should.
-          kind_of?(RC::Payload::Multipart)
-      end
-    end
-
-    would 'return data if none of the above' do
-      RC::Payload.generate('data').should.
-        kind_of?(RC::Payload::StreamedString)
-    end
-
-    would '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
-
-    would '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
-
-    would 'recognize other payloads that can be streamed' do
-      RC::Payload.generate(StringIO.new('foo')).should.
-        kind_of?(RC::Payload::Streamed)
-    end
-  end
-end