reel 0.5.0 → 0.6.0.pre1

data/spec/reel/http_server_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require 'net/http'
 
-describe Reel::Server::HTTP do
+RSpec.describe Reel::Server::HTTP do
   let(:endpoint) { URI(example_url) }
   let(:response_body) { "ohai thar" }
 
@@ -11,18 +11,16 @@ describe Reel::Server::HTTP do
     handler = proc do |connection|
       begin
         request = connection.request
-        request.method.should eq 'GET'
-        request.version.should eq "1.1"
-        request.url.should eq example_path
-
+        expect(request.method).to eq 'GET'
+        expect(request.version).to eq "1.1"
+        expect(request.url).to eq example_path
         connection.respond :ok, response_body
-      rescue => ex
       end
     end
 
     with_reel(handler) do
       response = Net::HTTP.get endpoint
-      response.should eq response_body
+      expect(response).to eq response_body
     end
 
     raise ex if ex
@@ -34,9 +32,8 @@ describe Reel::Server::HTTP do
     handler = proc do |connection|
       begin
         request = connection.request
-        request.method.should eq 'POST'
+        expect(request.method).to eq 'POST'
         connection.respond :ok, request.body.to_s
-      rescue => ex
       end
     end
 
@@ -46,8 +43,8 @@ describe Reel::Server::HTTP do
       request['connection'] = 'close'
       request.body = response_body
       response = http.request(request)
-      response.should be_a Net::HTTPOK
-      response.body.should == response_body
+      expect(response).to be_a Net::HTTPOK
+      expect(response.body).to eq(response_body)
     end
 
     raise ex if ex

data/spec/reel/https_server_spec.rb

@@ -1,19 +1,20 @@
 require 'spec_helper'
 require 'net/http'
 
-describe Reel::Server::HTTPS do
+RSpec.describe Reel::Server::HTTPS do
+
   let(:example_https_port) { example_port + 1 }
   let(:example_url)      { "https://#{example_addr}:#{example_https_port}#{example_path}" }
   let(:endpoint)         { URI(example_url) }
   let(:response_body)    { "ohai thar" }
 
-  let(:ca_file) { fixture_dir.join('ca.crt').to_s }
+  let(:ca_file)              { certs_dir.join('ca.crt').to_s }
 
-  let(:server_cert)          { fixture_dir.join("server.crt")         .read }
-  let(:server_key)           { fixture_dir.join("server.key")         .read }
-  let(:client_cert)          { fixture_dir.join("client.crt")         .read }
-  let(:client_cert_unsigned) { fixture_dir.join("client.unsigned.crt").read }
-  let(:client_key)           { fixture_dir.join("client.key")         .read }
+  let(:server_cert)          { certs_dir.join("server.crt")         .read }
+  let(:server_key)           { certs_dir.join("server.key")         .read }
+  let(:client_cert)          { certs_dir.join("client.crt")         .read }
+  let(:client_cert_unsigned) { certs_dir.join("client.unsigned.crt").read }
+  let(:client_key)           { certs_dir.join("client.key")         .read }
 
   it "receives HTTP requests and sends responses" do
     ex = nil
@@ -21,12 +22,10 @@ describe Reel::Server::HTTPS do
     handler = proc do |connection|
       begin
         request = connection.request
-        request.method.should eq 'GET'
-        request.version.should eq "1.1"
-        request.url.should eq example_path
-
+        expect(request.method).to eq 'GET'
+        expect(request.version).to eq "1.1"
+        expect(request.url).to eq example_path
         connection.respond :ok, response_body
-      rescue => ex
       end
     end
 
@@ -34,28 +33,24 @@ describe Reel::Server::HTTPS do
       http         = Net::HTTP.new(endpoint.host, endpoint.port)
       http.use_ssl = true
       http.ca_file = self.ca_file
-
       request = Net::HTTP::Get.new(endpoint.path)
       response = http.request(request)
-
-      response.body.should eq response_body
+      expect(response.body).to eq response_body
     end
 
     raise ex if ex
   end
 
-  it 'verifies client SSL certs when provided with a CA' do
+  it "verifies client SSL certs when provided with a CA" do
     ex = nil
 
     handler = proc do |connection|
       begin
         request = connection.request
-        request.method.should eq 'GET'
-        request.version.should eq '1.1'
-        request.url.should eq example_path
-
+        expect(request.method).to eq 'GET'
+        expect(request.version).to eq '1.1'
+        expect(request.url).to eq example_path
         connection.respond :ok, response_body
-      rescue => ex
       end
     end
 
@@ -65,28 +60,24 @@ describe Reel::Server::HTTPS do
       http.ca_file = self.ca_file
       http.cert    = OpenSSL::X509::Certificate.new self.client_cert
       http.key     = OpenSSL::PKey::RSA.new         self.client_key
-
       request  = Net::HTTP::Get.new(endpoint.path)
       response = http.request(request)
-
-      response.body.should eq response_body
+      expect(response.body).to eq response_body
     end
 
     raise ex if ex
   end
 
-  it %{fails to verify client certificates that aren't signed} do
+  it "fails to verify client certificates that aren't signed" do
     ex = nil
 
     handler = proc do |connection|
       begin
         request = connection.request
-        request.method.should eq 'GET'
-        request.version.should eq '1.1'
-        request.url.should eq example_path
-
+        expect(request.method).to eq 'GET'
+        expect(request.version).to eq '1.1'
+        expect(request.url).to eq example_path
         connection.respond :ok, response_body
-      rescue => ex
       end
     end
 
@@ -96,10 +87,8 @@ describe Reel::Server::HTTPS do
       http.ca_file = self.ca_file
       http.cert    = OpenSSL::X509::Certificate.new self.client_cert_unsigned
       http.key     = OpenSSL::PKey::RSA.new         self.client_key
-
       request  = Net::HTTP::Get.new(endpoint.path)
-
-      proc { http.request(request) }.should raise_error(OpenSSL::SSL::SSLError)
+      expect { http.request(request) }.to raise_error(OpenSSL::SSL::SSLError)
     end
 
     raise ex if ex

data/spec/reel/response/writer_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Reel::Response::Writer do
+RSpec.describe Reel::Response::Writer do
   let(:fixture_path) { File.expand_path("../../../fixtures/example.txt", __FILE__) }
   let(:expected_response) { "HTTP/1.1 200 OK\r\nContent-Length: 56\r\n\r\n#{File.read(fixture_path)}" }
 

data/spec/reel/response_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Reel::Response do
+RSpec.describe Reel::Response do
   it "streams enumerables" do
     with_socket_pair do |client, peer|
       connection = Reel::Connection.new(peer)
@@ -13,7 +13,7 @@ describe Reel::Response do
       response = client.read(4096)
       crlf = Reel::Response::Writer::CRLF
       fixture = "5#{crlf}Hello#{crlf}5#{crlf}World#{crlf}0#{crlf*2}"
-      response[(response.length - fixture.length)..-1].should eq fixture
+      expect(response[(response.length - fixture.length)..-1]).to eq fixture
     end
   end
 

data/spec/reel/unix_server_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+require 'net/http'
+
+unless defined?(JRUBY_VERSION)
+
+  RSpec.describe Reel::Server::UNIX do
+    let(:endpoint) { URI(example_url) }
+    let(:response_body) { "ohai thar" }
+
+    it 'allows connections over UNIX sockets' do
+      ex = nil
+
+      handler = proc do |connection|
+        begin
+          request = connection.request
+          expect( request.method ).to eq 'GET'
+          connection.respond :ok, self.response_body
+        end
+      end
+
+      Dir::Tmpname.create('reel-sock') do |path|
+        begin
+          server  = Reel::Server::UNIX.new(path, &handler)
+          sock    = Net::BufferedIO.new Celluloid::IO::UNIXSocket.new(path)
+          request = Net::HTTP::Get.new('/')
+
+          request.exec(sock, '1.1', path)
+          response = Net::HTTPResponse.read_new(sock)
+          response.reading_body(sock, request.response_body_permitted?) { }
+
+          expect(response.body).to eq(self.response_body)
+        ensure
+          server.terminate if server && server.alive?
+        end
+      end
+
+      raise ex if ex
+    end
+  end
+  
+end

data/spec/reel/websocket_spec.rb

@@ -1,6 +1,7 @@
 require 'spec_helper'
+require 'websocket_parser'
 
-describe Reel::WebSocket do
+RSpec.describe Reel::WebSocket do
   include WebSocketHelpers
 
   let(:example_message) { "Hello, World!" }
@@ -12,12 +13,12 @@ describe Reel::WebSocket do
       client << handshake.to_data
 
       request = connection.request
-      request.should be_websocket
+      expect(request).to be_websocket
 
       websocket = request.websocket
-      websocket.should be_a Reel::WebSocket
+      expect(websocket).to be_a Reel::WebSocket
 
-      handshake.errors.should be_empty
+      expect(handshake.errors).to be_empty
     end
   end
 
@@ -27,30 +28,80 @@ describe Reel::WebSocket do
       client << handshake.to_data
 
       websocket = connection.request.websocket
-      websocket.should be_a Reel::WebSocket
+      expect(websocket).to be_a Reel::WebSocket
       expect { connection.close }.to raise_error(Reel::StateError)
     end
   end
 
   it "knows its URL" do
     with_websocket_pair do |_, websocket|
-      websocket.url.should == example_path
+      expect(websocket.url).to eq(example_path)
     end
   end
 
   it "knows its headers" do
     with_websocket_pair do |_, websocket|
-      websocket['Host'].should == example_host
+      expect(websocket['Host']).to eq(example_host)
     end
   end
 
   it "reads frames" do
     with_websocket_pair do |client, websocket|
-      client << WebSocket::Message.new(example_message).to_data
-      client << WebSocket::Message.new(another_message).to_data
+      message = WebSocket::Message.new(example_message)
+      message.mask!
+      next_message = WebSocket::Message.new(another_message)
+      next_message.mask!
+      client << message.to_data
+      client << next_message.to_data
+
+      expect(websocket.read).to eq(example_message)
+      expect(websocket.read).to eq(another_message)
+    end
+  end
+
+  describe "WebSocket#next_message" do
+    it "triggers on the next sent message" do
+      with_websocket_pair do |client, websocket|
+        f = Celluloid::Future.new
+        websocket.on_message do |message|
+          f << Celluloid::SuccessResponse.new(:on_message, message)
+        end
+
+        message = WebSocket::Message.new(example_message)
+        message.mask!
+        client << message.to_data
+        websocket.read
+
+        message = f.value
+        expect(message).to eq(example_message)
+      end
+    end
+  end
 
-      websocket.read.should == example_message
-      websocket.read.should == another_message
+  describe "WebSocket#read_every" do
+    it "automatically executes read" do
+      with_websocket_pair do |client, websocket|
+        class MyActor
+          include Celluloid
+
+          def initialize(websocket)
+            websocket.read_every 0.1
+          end
+        end
+
+        f = Celluloid::Future.new
+        websocket.on_message do |message|
+          f << Celluloid::SuccessResponse.new(:on_message, message)
+        end
+
+        message = WebSocket::Message.new(example_message)
+        message.mask!
+        client << message.to_data
+        MyActor.new(websocket)
+
+        message = f.value
+        expect(message).to eq(example_message)
+      end
     end
   end
 
@@ -62,18 +113,27 @@ describe Reel::WebSocket do
       parser = WebSocket::Parser.new
 
       parser.append client.readpartial(4096) until first_message = parser.next_message
-      first_message.should == example_message
+      expect(first_message).to eq(example_message)
 
       parser.append client.readpartial(4096) until next_message = parser.next_message
-      next_message.should == another_message
+      expect(next_message).to eq(another_message)
     end
   end
 
   it "closes" do
     with_websocket_pair do |_, websocket|
-      websocket.should_not be_closed
+      expect(websocket).not_to be_closed
       websocket.close
-      websocket.should be_closed
+      expect(websocket).to be_closed
+    end
+  end
+
+  it "exposes addr and peeraddr" do
+    with_websocket_pair do |client, websocket|
+      expect(websocket).to respond_to(:peeraddr)
+      expect(websocket.peeraddr.first).to eq "AF_INET"
+      expect(websocket).to respond_to(:addr)
+      expect(websocket.addr.first).to eq "AF_INET"
     end
   end
 
@@ -85,12 +145,27 @@ describe Reel::WebSocket do
       remote_host = connection.remote_host
 
       request = connection.request
-      request.should be_websocket
+      expect(request).to be_websocket
       websocket = request.websocket
-      websocket.should be_a Reel::WebSocket
+      expect(websocket).to be_a Reel::WebSocket
 
       expect { connection.remote_host }.to raise_error(Reel::StateError)
-      websocket.remote_host.should == remote_host
+      expect(websocket.remote_host).to eq(remote_host)
+    end
+  end
+
+  it "performs websocket handshakes with header key case-insensitivity" do
+    with_socket_pair do |client, peer|
+      connection = Reel::Connection.new(peer)
+      client << case_handshake.to_data
+
+      request = connection.request
+      expect(request).to be_websocket
+
+      websocket = request.websocket
+      expect(websocket).to be_a Reel::WebSocket
+
+      expect(case_handshake.errors).to be_empty
     end
   end
 
@@ -100,9 +175,9 @@ describe Reel::WebSocket do
       client << handshake.to_data
       request = connection.request
 
-      request.should be_websocket
+      expect(request).to be_websocket
       websocket = request.websocket
-      websocket.should be_a Reel::WebSocket
+      expect(websocket).to be_a Reel::WebSocket
 
       # Discard handshake
       client.readpartial(4096)

data/spec/spec_helper.rb

@@ -5,15 +5,22 @@ require 'bundler/setup'
 require 'reel'
 require 'pry'
 
+def fixture_dir
+  Pathname.new File.expand_path("../fixtures", __FILE__)
+end
+
+def certs_dir
+  Pathname.new File.expand_path('../../tmp/certs', __FILE__)
+end
+
 require 'support/example_request'
+require 'support/create_certs'
+
+RSpec.configure(&:disable_monkey_patching!)
 
 logfile = File.open(File.expand_path("../../log/test.log", __FILE__), 'a')
 Celluloid.logger = Logger.new(logfile)
 
-def fixture_dir
-  Pathname.new File.expand_path("../fixtures", __FILE__)
-end
-
 def example_addr; '127.0.0.1'; end
 def example_port; 1234; end
 def example_path; "/example"; end
@@ -61,7 +68,22 @@ module WebSocketHelpers
         }
       end
 
+      let :case_handshake_headers do
+        {
+          "HoSt"                   => example_host,
+          "UpgRAde"                => "websocket",
+          "ConnECTion"             => "Upgrade",
+          "Sec-WebsOCket-Key"      => "dGhlIHNhbXBsZSBub25jZQ==",
+          "Origin"                 => "http://example.com",
+          "Sec-WEBsOCKET-pROTOCol" => "chat, superchat",
+          "Sec-WEBsOCKET-vERsion"  => "13"
+        }
+      end
+
       let(:handshake) { WebSocket::ClientHandshake.new(:get, example_url, handshake_headers) }
+      let(:case_handshake) do
+        WebSocket::ClientHandshake.new(:get, example_url, case_handshake_headers)
+      end
     end
   end
 end