hatetepe 0.5.2 → 0.6.0.pre

data/spec/integration/cli/start_spec.rb

@@ -1,113 +0,0 @@
-require "spec_helper"
-require "hatetepe/cli"
-require "hatetepe/server"
-require "hatetepe/version"
-require "rack/builder"
-
-describe Hatetepe::CLI do
-  let :rackup do
-    [ proc {|*| }, {} ]
-  end
-
-  before do
-    file = File.expand_path("config.ru")
-    Rack::Builder.stub(:parse_file).with(file) { rackup }
-
-    $stdout, $stderr = StringIO.new, StringIO.new
-    @old_env         = ENV.delete("RACK_ENV")
-  end
-  
-  after do
-    $stdout, $stderr = STDOUT, STDERR
-    ENV["RACK_ENV"]  = @old_env
-  end
-
-  describe "#version" do
-    it "prints Hatetepe's version" do
-      Hatetepe::CLI.start([ "version" ])
-      $stdout.rewind
-      $stdout.read.should include(Hatetepe::VERSION)
-    end
-  end
-
-  describe "#start" do
-    it "starts a server running the default configuration" do
-      Hatetepe::Server.should_receive(:start) do |config|
-        config[:host].should    == "127.0.0.1"
-        config[:port].should    equal(3000)
-        config[:timeout].should be_nil
-        
-        config[:app].should    equal(rackup[0])
-        ENV["RACK_ENV"].should == "development"
-      end
-      Hatetepe::CLI.start([])
-    end
-
-    it "writes stuff to stderr" do
-      Hatetepe::CLI.start([])
-      $stderr.rewind
-      $stderr.read.should include("config.ru", "127.0.0.1:3000", "development")
-    end
-
-    it "starts an EventMachine reactor" do
-      EM.should_receive(:synchrony)
-      Hatetepe::CLI.start([])
-    end
-
-    it "enables epoll" do
-      EM.should_receive(:epoll)
-      Hatetepe::CLI.start([])
-    end
-
-    it "doesn't overwrite RACK_ENV" do
-      ENV["RACK_ENV"] = "foobar"
-      Hatetepe::CLI.start([])
-      ENV["RACK_ENV"].should == "foobar"
-    end
-
-    describe "with --bind option" do
-      it "passes the :host option to Server.start" do
-        Hatetepe::Server.should_receive(:start) do |config|
-          config[:host].should == "127.0.5.1"
-        end
-        Hatetepe::CLI.start([ "--bind", "127.0.5.1" ])
-      end
-    end
-
-    describe "with --port option" do
-      it "passes the :port option to Server.start" do
-        Hatetepe::Server.should_receive(:start) do |config|
-          config[:port].should == 5234
-        end
-        Hatetepe::CLI.start([ "--port", "5234" ])
-      end
-    end
-
-    describe "with --timeout option" do
-      it "passes the :timeout option to Server.start" do
-        Hatetepe::Server.should_receive(:start) do |config|
-          config[:timeout].should == 123.4
-        end
-        Hatetepe::CLI.start([ "--timeout", "123.4" ])
-      end
-    end
-
-    describe "with --rackup option" do
-      it "boots from the specified RackUp file" do
-        file = File.expand_path("./other_config.ru")
-        Rack::Builder.should_receive(:parse_file).with(file) { rackup }
-        Hatetepe::Server.should_receive(:start) do |config|
-          config[:app].should equal(rackup[0])
-        end
-        Hatetepe::CLI.start([ "--rackup", "other_config.ru" ])
-      end
-    end
-
-    describe "with --env option" do
-      it "sets RACK_ENV to the specified value" do
-        Hatetepe::CLI.start([ "--env", "production" ])
-        ENV["RACK_ENV"].should == "production"
-      end
-    end
-  end
-end

data/spec/integration/client/keep_alive_spec.rb

@@ -1,23 +0,0 @@
-require "hatetepe/cli"
-require "hatetepe/client"
-require "spec_helper"
-require "stringio"
-require "yaml"
-
-describe Hatetepe::Client, "with Keep-Alive" do
-  let :client do
-    Hatetepe::Client.start :host => "127.0.0.1", :port => 30001
-  end
-  
-  it "keeps the connection open"
-  
-  it "sends Connection: keep-alive"
-  
-  describe "and an obviously single request" do
-    it "sends Connection: close"
-    
-    it "closes the connection immediately after the response"
-  end
-  
-  it "closes the connection if the server tells it to"
-end

data/spec/integration/client/timeout_spec.rb

@@ -1,97 +0,0 @@
-require "spec_helper"
-require "hatetepe/client"
-require "hatetepe/server"
-
-describe Hatetepe::Client do
-  let :options do
-    { host: "127.0.0.1", port: 3123 }
-  end
-
-  let :options2 do
-    { host: "1.2.3.4",   port: 3123}
-  end
-
-  let :client do
-    Hatetepe::Client.start(options)
-  end
-
-  before do
-    if defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
-      pending "EventMachine timeouts are not available on JRuby"
-    end
-
-    Hatetepe::Server.start(options.merge(timeout: 0))
-  end
-
-  it "times out after 5 seconds of connection inactivity" do
-    # only verify that 5 seconds is the default, but actually
-    # use a smaller timeout to keep specs fast
-    Hatetepe::Client::CONFIG_DEFAULTS[:timeout].should == 5
-  end
-
-  it "times out after 5 seconds trying to establish a connection" do
-    # only verify that 5 seconds is the default, but actually
-    # use a smaller timeout to keep specs fast
-    Hatetepe::Client::CONFIG_DEFAULTS[:connect_timeout].should == 5
-  end
-
-  describe "with :timeout option" do
-    let :client do
-      Hatetepe::Client.start(options.merge(timeout: 0.5))
-    end
-
-    it "times out after n seconds of connection inactivity" do
-      client.should_not be_closed
-      EM::Synchrony.sleep(0.45)
-      client.should_not be_closed
-
-      EM::Synchrony.sleep(0.1)
-      client.should     be_closed
-      client.should     be_closed_by_timeout
-      client.should_not be_closed_by_connect_timeout
-    end
-  end
-
-  describe "with :timeout set to 0" do
-    let :client do
-      Hatetepe::Client.start(options.merge(timeout: 0))
-    end
-
-    it "never times out" do
-      client.should_not be_closed
-      EM::Synchrony.sleep(0.55)
-      client.should_not be_closed
-    end
-  end
-
-  describe "with :connect_timeout option" do
-    let :client do
-      Hatetepe::Client.start(options2.merge(connect_timeout: 0.5))
-    end
-
-    # this example fails if there's no network connection
-    it "times out after n seconds trying to establish a connection" do
-      client.should_not be_closed
-      EM::Synchrony.sleep(0.45)
-      client.should_not be_closed
-
-      EM::Synchrony.sleep(0.1)
-      client.should     be_closed
-      client.should     be_closed_by_connect_timeout
-      client.should_not be_closed_by_timeout
-    end
-  end
-
-  describe "with :connect_timeout set to 0" do
-    let :client do
-      Hatetepe::Client.start(options2.merge(connect_timeout: 0))
-    end
-
-    # this example fails if there's no network connection
-    it "never times out trying to establish a connection" do
-      client.should_not be_closed
-      EM::Synchrony.sleep(0.55)
-      client.should_not be_closed
-    end
-  end
-end

data/spec/integration/server/keep_alive_spec.rb

@@ -1,27 +0,0 @@
-require "spec_helper"
-require "hatetepe/client"
-require "hatetepe/server"
-
-describe Hatetepe::Server, "with Keep-Alive" do
-  describe "and :timeout option" do
-    it "times out the connection after the specified amount of time"
-  end
-  
-  describe "and :timeout option set to 0" do
-    it "keeps the connection open until the client closes it"
-  end
-  
-  it "closes the connection if the client sends Connection: close"
-
-  it "responds with Connection: keep-alive if the client also sent it"
-  
-  ["1.0", "0.9"].each do |version|
-    describe "and an HTTP #{version} client" do
-      it "closes the connection after one request" do
-        pending "http_parser.rb doesn't parse HTTP/0.9" if version == "0.9"
-      end
-
-      it "doesn't close the connection if the client sent Connection: Keep-Alive"
-    end
-  end
-end

data/spec/integration/server/timeout_spec.rb

@@ -1,51 +0,0 @@
-require "spec_helper"
-require "hatetepe/client"
-require "hatetepe/server"
-
-describe Hatetepe::Server do
-  before do
-    if defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
-      pending "EventMachine timeouts are not available on JRuby"
-    end
-  end
-
-  let :options do
-    { host: "127.0.0.1", port: 3123 }
-  end
-
-  let :client do
-    Hatetepe::Client.start(options.merge(timeout: 0))
-  end
-
-  it "times out after 5 seconds of connection inactivity" do
-    # only verify that 5 seconds is the default
-    Hatetepe::Server::CONFIG_DEFAULTS[:timeout].should == 5
-  end
-
-  describe "with :timeout option" do
-    before do
-      Hatetepe::Server.start(options.merge(timeout: 0.5))
-    end
-
-    it "times out after the specified amount of seconds" do
-      client.should_not be_closed
-      EM::Synchrony.sleep(0.45)
-      client.should_not be_closed
-
-      EM::Synchrony.sleep(0.1)
-      client.should be_closed_by_remote
-    end
-  end
-
-  describe "with :timeout set to 0" do
-    before do
-      Hatetepe::Server.start(options.merge(timeout: 0))
-    end
-
-    it "never times out" do
-      client.should_not be_closed
-      EM::Synchrony.sleep(0.55)
-      client.should_not be_closed
-    end
-  end
-end

data/spec/unit/body_spec.rb

@@ -1,205 +0,0 @@
-require "spec_helper"
-require "hatetepe/body"
-
-describe Hatetepe::Body do
-  let(:body) { Hatetepe::Body.new }
-  
-  it "is deferrable" do
-    body.should respond_to(:callback)
-  end
-  
-  context "#initialize" do
-    it "leaves the IO stream empty" do
-      body.io.length.should be_zero
-    end
-  end
-  
-  context "#initialize(string)" do
-    let(:body) { Hatetepe::Body.new "herp derp" }
-    
-    before { body.close_write }
-    
-    it "writes the passed string" do
-      body.length.should equal(9)
-      body.io.read.should == "herp derp"
-    end
-  end
-  
-  context "#sync" do
-    let(:conn) { double "conn", :paused? => true }
-    
-    it "resumes the source connection if any" do
-      body.source = conn
-
-      conn.should_receive :resume
-      Fiber.new { body.succeed }.resume
-      body.sync
-    end
-    
-    it "forwards to EM::Synchrony.sync(body)" do
-      EM::Synchrony.should_receive(:sync).with(body)
-      body.sync
-    end
-  end
-  
-  context "#length" do
-    let(:length) { double "length" }
-    
-    it "forwards to io#length" do
-      body.stub :sync
-      body.io.stub :length => length
-      
-      body.length.should equal(length)
-    end
-    
-    it "waits for the body to succeed" do
-      succeeded = false
-      Fiber.new {
-        body.length
-        succeeded = true
-      }.resume
-      
-      succeeded.should be_false
-      
-      body.close_write
-      succeeded.should be_true
-    end
-  end
-  
-  context "#empty?" do
-    it "returns true if length is zero" do
-      body.stub :length => 0
-      body.empty?.should be_true
-    end
-    
-    it "returns false if length is non-zero" do
-      body.stub :length => 42
-      body.empty?.should be_false
-    end
-  end
-  
-  context "#pos" do
-    let(:pos) { double "pos" }
-    
-    it "forwards to io#pos" do
-      body.io.stub :pos => pos
-      body.pos.should equal(pos)
-    end
-  end
-  
-  context "#rewind" do
-    it "blocks and forwards to io#rewind" do
-      body.should_receive(:sync).ordered
-      body.io.should_receive(:rewind).ordered
-      body.rewind
-    end
-  end
-  
-  context "#close_write" do
-    it "forwards to io#close_write" do
-      body.io.should_receive :close_write
-      body.close_write
-    end
-    
-    it "succeeds the body" do
-      body.should_receive :succeed
-      body.close_write
-    end
-  end
-  
-  context "#closed_write?" do
-    it "forwards to io#closed_write?" do
-      ret = double("return")
-      body.io.should_receive(:closed_write?) { ret }
-      
-      body.closed_write?.should equal(ret)
-    end
-  end
-  
-  context "#each {|chunk| ... }" do
-    it "yields each written chunk until the body succeeds" do
-      chunks = ["111", "222"]
-      received, succeeded = [], false
-      
-      body.write chunks[0]
-      Fiber.new {
-        body.each {|chunk| received << chunk }
-        succeeded = true
-      }.resume
-      received.should == chunks.values_at(0)
-      succeeded.should be_false
-      
-      body.write chunks[1]
-      received.should == chunks
-      succeeded.should be_false
-      
-      body.succeed
-      succeeded.should be_true
-    end
-
-    it "returns self" do
-      Fiber.new { body.each {}.should == body }.resume
-      body.succeed
-    end
-
-    describe "without a block" do
-      let(:enumerator) { double }
-
-      before { body.stub(:to_enum).with(:each) { enumerator } }
-
-      it "immediately returns an Enumerator" do
-        Fiber.new { body.each.should == enumerator }.resume
-          body.succeed
-      end
-    end
-  end
-  
-  context "#read(length, buffer)" do
-    it "waits for the body to succeed" do
-      ret, read = nil, false
-      
-      Fiber.new { body.read; read = true }.resume
-      read.should be_false
-      
-      body.succeed
-      read.should be_true
-    end
-    
-    it "forwards to io#read" do
-      body.succeed
-      args, ret = [double("arg#1"), double("arg#2")], double("ret")
-
-      body.io.should_receive(:read).with(*args) { ret }
-      body.read(*args).should equal(ret)
-    end
-  end
-  
-  context "#gets" do
-    it "waits for the body to succeed" do
-      ret, read = nil, false
-      
-      Fiber.new { body.gets; read = true }.resume
-      read.should be_false
-      
-      body.succeed
-      read.should be_true
-    end
-    
-    it "forwards to io#gets" do
-      body.succeed
-      ret = double("ret")
-
-      body.io.should_receive(:gets) { ret }
-      body.gets.should equal(ret)
-    end
-  end
-  
-  context "#write(chunk)" do
-    it "forwards to io#write" do
-      arg, ret = double("arg"), double("ret")
-      body.io.should_receive(:write).with(arg) { ret }
-      
-      body.write(arg).should equal(ret)
-    end
-  end
-end