celluloid-io 0.12.1 → 0.13.0.pre

data/spec/celluloid/io/ssl_server_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+describe Celluloid::IO::SSLServer do
+  let(:client_cert) { OpenSSL::X509::Certificate.new fixture_dir.join("client.crt").read }
+  let(:client_key)  { OpenSSL::PKey::RSA.new fixture_dir.join("client.key").read }
+  let(:client_context) do
+    OpenSSL::SSL::SSLContext.new.tap do |context|
+      context.cert = client_cert
+      context.key  = client_key
+    end
+  end
+
+  let(:server_cert) { OpenSSL::X509::Certificate.new fixture_dir.join("server.crt").read }
+  let(:server_key)  { OpenSSL::PKey::RSA.new fixture_dir.join("server.key").read }
+  let(:server_context) do
+    OpenSSL::SSL::SSLContext.new.tap do |context|
+      context.cert = server_cert
+      context.key  = server_key
+    end
+  end
+
+  describe "#accept" do
+    let(:payload) { 'ohai' }
+
+    context "inside Celluloid::IO" do
+      it "should be evented" do
+        with_ssl_server do |subject|
+          within_io_actor { subject.evented? }.should be_true
+        end
+      end
+
+      it "accepts a connection and returns a Celluloid::IO::SSLSocket" do
+        with_ssl_server do |subject|
+          thread = Thread.new do
+            raw = TCPSocket.new(example_addr, example_ssl_port)
+            ssl = OpenSSL::SSL::SSLSocket.new(raw, client_context).connect
+          end
+          peer = within_io_actor { subject.accept }
+          peer.should be_a Celluloid::IO::SSLSocket
+
+          client = thread.value
+          client.write payload
+          peer.read(payload.size).should eq payload
+        end
+      end
+    end
+
+    context "outside Celluloid::IO" do
+      it "should be blocking" do
+        with_ssl_server do |subject|
+          subject.should_not be_evented
+        end
+      end
+
+      it "accepts a connection and returns a Celluloid::IO::SSLSocket" do
+        with_ssl_server do |subject|
+          thread = Thread.new do
+            raw = TCPSocket.new(example_addr, example_ssl_port)
+            ssl = OpenSSL::SSL::SSLSocket.new(raw, client_context).connect
+          end
+          peer = subject.accept
+          peer.should be_a Celluloid::IO::SSLSocket
+
+          client = thread.value
+          client.write payload
+          peer.read(payload.size).should eq payload
+        end
+      end
+    end
+  end
+
+  describe "#initialize" do
+    it "should auto-wrap a raw ::TCPServer" do
+      raw_server = ::TCPServer.new(example_addr, example_ssl_port)
+      with_ssl_server(raw_server) do |ssl_server|
+        ssl_server.tcp_server.class.should == Celluloid::IO::TCPServer
+      end
+    end
+  end
+
+  def with_ssl_server(raw_server = nil)
+    raw_server ||= Celluloid::IO::TCPServer.new(example_addr, example_ssl_port)
+    server = Celluloid::IO::SSLServer.new(raw_server, server_context)
+    begin
+      yield server
+    ensure
+      server.close
+    end
+  end
+end
+

data/spec/celluloid/io/ssl_socket_spec.rb

@@ -0,0 +1,189 @@
+require 'spec_helper'
+require 'openssl'
+
+describe Celluloid::IO::SSLSocket do
+  let(:request)  { 'ping' }
+  let(:response) { 'pong' }
+
+  let(:client_cert) { OpenSSL::X509::Certificate.new fixture_dir.join("client.crt").read }
+  let(:client_key)  { OpenSSL::PKey::RSA.new fixture_dir.join("client.key").read }
+  let(:client_context) do
+    OpenSSL::SSL::SSLContext.new.tap do |context|
+      context.cert = client_cert
+      context.key  = client_key
+    end
+  end
+
+  let(:client)     { TCPSocket.new example_addr, example_ssl_port }
+  let(:ssl_client) { Celluloid::IO::SSLSocket.new client, client_context }
+
+  let(:server_cert) { OpenSSL::X509::Certificate.new fixture_dir.join("server.crt").read }
+  let(:server_key)  { OpenSSL::PKey::RSA.new fixture_dir.join("server.key").read }
+  let(:server_context) do
+    OpenSSL::SSL::SSLContext.new.tap do |context|
+      context.cert = server_cert
+      context.key  = server_key
+    end
+  end
+
+  let(:server)     { TCPServer.new example_addr, example_ssl_port }
+  let(:ssl_server) { OpenSSL::SSL::SSLServer.new server, server_context }
+  let(:server_thread) do
+    Thread.new { ssl_server.accept }.tap do |thread|
+      Thread.pass while thread.status && thread.status != "sleep"
+    end
+  end
+
+  let(:celluloid_server) { Celluloid::IO::TCPServer.new example_addr, example_ssl_port }
+  let(:raw_server_thread) do
+    Thread.new { celluloid_server.accept }.tap do |thread|
+      Thread.pass while thread.status && thread.status != "sleep"
+    end
+  end
+
+  context "inside Celluloid::IO" do
+    it "connects to SSL servers over TCP" do
+      with_ssl_sockets do |ssl_client, ssl_peer|
+        within_io_actor do
+          ssl_peer << request
+          ssl_client.read(request.size).should == request
+
+          ssl_client << response
+          ssl_peer.read(response.size).should == response
+        end
+      end
+    end
+
+    it "starts SSL on a connected TCP socket" do
+      with_raw_sockets do |client, peer|
+        within_io_actor do
+          peer << request
+          client.read(request.size).should == request
+
+          client << response
+          peer.read(response.size).should == response
+
+          # now that we've written bytes, upgrade to SSL
+          client_thread = Thread.new { OpenSSL::SSL::SSLSocket.new(client).connect }
+          ssl_peer = Celluloid::IO::SSLSocket.new peer, server_context
+          ssl_peer.should == ssl_peer.accept
+          ssl_client = client_thread.value
+
+          ssl_peer << request
+          ssl_client.read(request.size).should == request
+
+          ssl_client << response
+          ssl_peer.read(response.size).should == response
+        end
+      end
+    end
+  end
+
+  context "outside Celluloid::IO" do
+    it "connects to SSL servers over TCP" do
+      with_ssl_sockets do |ssl_client, ssl_peer|
+        ssl_peer << request
+        ssl_client.read(request.size).should == request
+
+        ssl_client << response
+        ssl_peer.read(response.size).should == response
+      end
+    end
+
+    it "starts SSL on a connected TCP socket" do
+      with_raw_sockets do |client, peer|
+        peer << request
+        client.read(request.size).should == request
+
+        client << response
+        peer.read(response.size).should == response
+
+        # now that we've written bytes, upgrade to SSL
+        client_thread = Thread.new { OpenSSL::SSL::SSLSocket.new(client).connect }
+        ssl_peer = Celluloid::IO::SSLSocket.new peer, server_context
+        ssl_peer.should == ssl_peer.accept
+        ssl_client = client_thread.value
+
+        ssl_peer << request
+        ssl_client.read(request.size).should == request
+
+        ssl_client << response
+        ssl_peer.read(response.size).should == response
+      end
+    end
+  end
+
+  it "knows its cert" do
+    # FIXME: seems bad? o_O
+    pending "wtf is wrong with this on JRuby" if defined? JRUBY_VERSION
+    with_ssl_sockets do |ssl_client|
+      ssl_client.cert.to_der.should == client_cert.to_der
+    end
+  end
+
+  it "knows its peer_cert" do
+    with_ssl_sockets do |ssl_client|
+      ssl_client.peer_cert.to_der.should == ssl_client.to_io.peer_cert.to_der
+    end
+  end
+
+  it "knows its peer_cert_chain" do
+    with_ssl_sockets do |ssl_client|
+      ssl_client.peer_cert_chain.zip(ssl_client.to_io.peer_cert_chain).map do |c1, c2|
+        c1.to_der == c2.to_der
+      end.should be_all
+    end
+  end
+
+  it "knows its cipher" do
+    with_ssl_sockets do |ssl_client|
+      ssl_client.cipher.should == ssl_client.to_io.cipher
+    end
+  end
+
+  it "knows its client_ca" do
+    # jruby-openssl does not implement this method
+    pending "jruby-openssl support" if defined? JRUBY_VERSION
+
+    with_ssl_sockets do |ssl_client|
+      ssl_client.client_ca.should == ssl_client.to_io.client_ca
+    end
+  end
+
+  it "verifies peer certificates" do
+    # FIXME: JRuby seems to be giving the wrong result here o_O
+    pending "jruby-openssl support" if defined? JRUBY_VERSION
+
+    with_ssl_sockets do |ssl_client, ssl_peer|
+      ssl_client.verify_result.should == OpenSSL::X509::V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT
+    end
+  end
+
+  def with_ssl_sockets
+    thread = server_thread
+    ssl_client.connect
+
+    begin
+      ssl_peer = thread.value
+      yield ssl_client, ssl_peer
+    ensure
+      ssl_server.close
+      ssl_client.close
+      ssl_peer.close
+    end
+  end
+
+  def with_raw_sockets
+    server_thread = raw_server_thread
+    raw_client = client
+
+    begin
+      raw_peer = server_thread.value
+      yield raw_client, raw_peer
+    ensure
+      celluloid_server.close
+      raw_client.close
+      raw_peer.close
+    end
+  end
+end

data/spec/celluloid/io/tcp_server_spec.rb

@@ -23,7 +23,7 @@ describe Celluloid::IO::TCPServer do
         end
       end
 
-      context "elsewhere in Ruby" do
+      context "outside Celluloid::IO" do
         it "should be blocking" do
           with_tcp_server do |subject|
             subject.should_not be_evented

data/spec/celluloid/io/tcp_socket_spec.rb

@@ -25,14 +25,14 @@ describe Celluloid::IO::TCPSocket do
     end
 
     it "read complete payload when nil size is given to #read" do
-        with_connected_sockets do |subject, peer|
+      with_connected_sockets do |subject, peer|
         peer << payload
         within_io_actor { subject.read(nil) }.should eq payload
       end
     end
 
     it "read complete payload when no size is given to #read" do
-        with_connected_sockets do |subject, peer|
+      with_connected_sockets do |subject, peer|
         peer << payload
         within_io_actor { subject.read }.should eq payload
       end
@@ -45,6 +45,13 @@ describe Celluloid::IO::TCPSocket do
       end
     end
 
+    it "reads data in ASCII-8BIT encoding" do
+      with_connected_sockets do |subject, peer|
+        peer << payload
+        within_io_actor { subject.read(payload.size).encoding }.should eq Encoding::ASCII_8BIT
+      end
+    end
+
     it "reads partial data" do
       with_connected_sockets do |subject, peer|
         peer << payload * 2
@@ -52,15 +59,71 @@ describe Celluloid::IO::TCPSocket do
       end
     end
 
+    it "reads partial data in ASCII-8BIT encoding" do
+      with_connected_sockets do |subject, peer|
+        peer << payload * 2
+        within_io_actor { subject.readpartial(payload.size).encoding }.should eq Encoding::ASCII_8BIT
+      end
+    end
+
     it "writes data" do
       with_connected_sockets do |subject, peer|
         within_io_actor { subject << payload }
         peer.read(payload.size).should eq payload
       end
     end
+
+    it "raises Errno::ECONNREFUSED when the connection is refused" do
+      expect {
+        within_io_actor { ::TCPSocket.new(example_addr, example_port) }
+      }.to raise_error(Errno::ECONNREFUSED)
+    end
+
+    context "readpartial" do
+      it "raises EOFError when reading from a closed socket" do
+        with_connected_sockets do |subject, peer|
+          peer.close
+          expect {
+            within_io_actor { subject.readpartial(payload.size) }
+          }.to raise_error(EOFError)
+        end
+      end
+
+      it "raises IOError when active sockets are closed across threads" do
+	pending "not implemented :("
+
+        with_connected_sockets do |subject, peer|
+          actor = ExampleActor.new
+          begin
+            read_future = actor.future.wrap do
+              subject.readpartial(payload.size)
+            end
+            sleep 0.1
+            subject.close
+            expect { read_future.value 0.25 }.to raise_error(IOError)
+          ensure
+            actor.terminate if actor.alive?
+          end
+        end
+      end
+
+      it "raises IOError when partial reading from a socket the peer closed" do
+        with_connected_sockets do |subject, peer|
+          actor = ExampleActor.new
+          begin
+            actor.async.wrap { sleep 0.01; peer.close }
+            expect do
+              within_io_actor { subject.readpartial(payload.size) }
+            end.to raise_error(IOError)
+          ensure
+            actor.terminate if actor.alive?
+          end
+        end
+      end
+    end
   end
 
-  context "elsewhere in Ruby" do
+  context "outside Celluloid::IO" do
     it "connects to TCP servers" do
       server = ::TCPServer.new example_addr, example_port
       thread = Thread.new { server.accept }

data/spec/celluloid/io/udp_socket_spec.rb

@@ -21,7 +21,7 @@ describe Celluloid::IO::UDPSocket do
     end
   end
 
-  context "elsewhere in Ruby" do
+  context "outside Celluloid::IO" do
     it "should be blocking" do
       subject.should_not be_evented
     end

data/spec/celluloid/io/unix_server_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe Celluloid::IO::UNIXServer do
+  describe "#accept" do
+    before do
+      pending "JRuby support" if defined?(JRUBY_VERSION)
+    end
+
+    let(:payload) { 'ohai' }
+
+    context "inside Celluloid::IO" do
+      it "should be evented" do
+        with_unix_server do |subject|
+          within_io_actor { subject.evented? }.should be_true
+        end
+      end
+
+      it "accepts a connection and returns a Celluloid::IO::UNIXSocket" do
+        with_unix_server do |subject|
+          thread = Thread.new { UNIXSocket.new(example_unix_sock) }
+          peer = within_io_actor { subject.accept }
+          peer.should be_a Celluloid::IO::UNIXSocket
+
+          client = thread.value
+          client.write payload
+          peer.read(payload.size).should eq payload
+        end
+      end
+      
+      it "raises if server already up" do
+        with_unix_server do |subject|
+          within_io_actor do
+            expect {
+              Celluloid::IO::UNIXServer.open(example_unix_sock)
+            }.to raise_error(Errno::EADDRINUSE)
+          end
+        end
+      end
+
+      context "outside Celluloid::IO" do
+        it "should be blocking" do
+          with_unix_server do |subject|
+            subject.should_not be_evented
+          end
+        end
+
+        it "accepts a connection and returns a Celluloid::IO::UNIXSocket" do
+          with_unix_server do |subject|
+            thread = Thread.new { UNIXSocket.new(example_unix_sock) }
+            peer   = subject.accept
+            peer.should be_a Celluloid::IO::UNIXSocket
+
+            client = thread.value
+            client.write payload
+            peer.read(payload.size).should eq payload
+          end
+        end
+          
+        it "raises if server already up" do
+          with_unix_server do |subject|
+            expect {
+              Celluloid::IO::UNIXServer.open(example_unix_sock)
+            }.to raise_error(Errno::EADDRINUSE)
+          end
+        end
+        
+      end
+    end
+  end
+end

data/spec/celluloid/io/unix_socket_spec.rb

@@ -0,0 +1,140 @@
+require 'spec_helper'
+
+describe Celluloid::IO::UNIXSocket do
+  before do
+    pending "JRuby support" if defined?(JRUBY_VERSION)
+  end
+
+  let(:payload) { 'ohai' }
+
+  context "inside Celluloid::IO" do
+    it "connects to UNIX servers" do
+      server = ::UNIXServer.open example_unix_sock
+      thread = Thread.new { server.accept }
+      socket = within_io_actor { Celluloid::IO::UNIXSocket.open example_unix_sock }
+      peer = thread.value
+
+      peer << payload
+      within_io_actor { socket.read(payload.size) }.should eq payload
+
+      server.close
+      socket.close
+      peer.close
+      File.delete(example_unix_sock)
+    end
+
+    it "should be evented" do
+      with_connected_unix_sockets do |subject|
+        within_io_actor { subject.evented? }.should be_true
+      end
+    end
+
+    it "read complete payload when nil size is given to #read" do
+      with_connected_unix_sockets do |subject, peer|
+        peer << payload
+        within_io_actor { subject.read(nil) }.should eq payload
+      end
+    end
+
+    it "read complete payload when no size is given to #read" do
+      with_connected_unix_sockets do |subject, peer|
+        peer << payload
+        within_io_actor { subject.read }.should eq payload
+      end
+    end
+
+    it "reads data" do
+      with_connected_unix_sockets do |subject, peer|
+        peer << payload
+        within_io_actor { subject.read(payload.size) }.should eq payload
+      end
+    end
+
+    it "reads data in ASCII-8BIT encoding" do
+      with_connected_unix_sockets do |subject, peer|
+        peer << payload
+        within_io_actor { subject.read(payload.size).encoding }.should eq Encoding::ASCII_8BIT
+      end
+    end
+
+    it "reads partial data" do
+      with_connected_unix_sockets do |subject, peer|
+        peer << payload * 2
+        within_io_actor { subject.readpartial(payload.size) }.should eq payload
+      end
+    end
+
+    it "reads partial data in ASCII-8BIT encoding" do
+      with_connected_unix_sockets do |subject, peer|
+        peer << payload * 2
+        within_io_actor { subject.readpartial(payload.size).encoding }.should eq Encoding::ASCII_8BIT
+      end
+    end
+
+    it "writes data" do
+      with_connected_unix_sockets do |subject, peer|
+        within_io_actor { subject << payload }
+        peer.read(payload.size).should eq payload
+      end
+    end
+
+    it "raises Errno::ENOENT when the connection is refused" do
+      expect {
+        within_io_actor { Celluloid::IO::UNIXSocket.open(example_unix_sock) }
+      }.to raise_error(Errno::ENOENT)
+    end
+
+    it "raises EOFError when partial reading from a closed socket" do
+      with_connected_unix_sockets do |subject, peer|
+        peer.close
+        expect {
+          within_io_actor { subject.readpartial(payload.size) }
+        }.to raise_error(EOFError)
+      end
+    end
+  end
+
+  context "outside Celluloid::IO" do
+    it "connects to UNIX servers" do
+      server = ::UNIXServer.new example_unix_sock
+      thread = Thread.new { server.accept }
+      socket = Celluloid::IO::UNIXSocket.open example_unix_sock
+      peer = thread.value
+
+      peer << payload
+      socket.read(payload.size).should eq payload
+
+      server.close
+      socket.close
+      peer.close
+      File.delete example_unix_sock
+    end
+
+    it "should be blocking" do
+      with_connected_unix_sockets do |subject|
+        subject.should_not be_evented
+      end
+    end
+
+    it "reads data" do
+      with_connected_unix_sockets do |subject, peer|
+        peer << payload
+        subject.read(payload.size).should eq payload
+      end
+    end
+
+    it "reads partial data" do
+      with_connected_unix_sockets do |subject, peer|
+        peer << payload * 2
+        subject.readpartial(payload.size).should eq payload
+      end
+    end
+
+    it "writes data" do
+      with_connected_unix_sockets do |subject, peer|
+        subject << payload
+        peer.read(payload.size).should eq payload
+      end
+    end
+  end
+end

data/spec/fixtures/client.crt

@@ -0,0 +1,22 @@
+-----BEGIN CERTIFICATE-----
+MIIDmjCCAoICCQDwZ8yE/0n4PjANBgkqhkiG9w0BAQUFADCBjjELMAkGA1UEBhMC
+VVMxEzARBgNVBAgTCkNhbGlmb3JuaWExFjAUBgNVBAcTDVNhbiBGcmFuY2lzY28x
+EjAQBgNVBAoTCUNlbGx1bG9pZDEbMBkGA1UEAxMSY2xpZW50LmV4YW1wbGUuY29t
+MSEwHwYJKoZIhvcNAQkBFhJjbGllbnRAZXhhbXBsZS5jb20wHhcNMTIxMTI1MTkx
+NjI2WhcNMjIxMTIzMTkxNjI2WjCBjjELMAkGA1UEBhMCVVMxEzARBgNVBAgTCkNh
+bGlmb3JuaWExFjAUBgNVBAcTDVNhbiBGcmFuY2lzY28xEjAQBgNVBAoTCUNlbGx1
+bG9pZDEbMBkGA1UEAxMSY2xpZW50LmV4YW1wbGUuY29tMSEwHwYJKoZIhvcNAQkB
+FhJjbGllbnRAZXhhbXBsZS5jb20wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEK
+AoIBAQDV6zzpkAIX4FijnytX84GgHb8hYdNJAn+9g57XGrqtAH6BlLoANFl4n/+y
+nEQwBqlrNnfstPrf7sPezytntSVyufSE+LGUGBJA/jyjQCMcEe8+4bfOC2ZhCpvn
+I2dKNKwsmM+DyWs/PVl7XEAZF2P4iQ8eGLVFjph+KA/D79cHkIeGt4FEA4xJWqKf
++Kjftxo1cBqLx2dUiucRL7tva3ingAqYSs/i82jKLGlj7fdRMytOx87Nhs35RWpu
+66l7hvpetx3t2wU2obKOzKhS4ycaZ2AptEDNXKaBTQ5lejSRxFBCpYQtqmkd0bMG
+/T5ZfXC45axj9a2rj8AKZct+mLCzAgMBAAEwDQYJKoZIhvcNAQEFBQADggEBAHzr
+b4VTktAi+8baGRJCXupt0Ari8ffoWhsYerELFLQF7K2sluxOqCsGEEF21e99fZxP
+lisLi0DIQ7cNlOGjRJ3xaydE74Fsry3xBNKoR8I7OMr9VFsrC54tc0x7NQ7bRHy6
+kCjSwKN4I2KWJjQ8yf8mIalmUKOmb/hirzna8io4CiDeJGZ1XNAQ9dl1RHRW442G
+GTu2ofAtU8TlzilZyclMY/lN7whw7sKP+pPr6fpAOJZsR64IzbBcWHHjJhx70XOx
+jnd5FB1oXnuupgPqEKmatSCytrue8GTkanB8VZ6+Zd/4XgTkie3UtCZW8R+NL/Lo
+us/+Ks3WIDyYdPSPnbE=
+-----END CERTIFICATE-----

data/spec/fixtures/client.key

@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEpAIBAAKCAQEA1es86ZACF+BYo58rV/OBoB2/IWHTSQJ/vYOe1xq6rQB+gZS6
+ADRZeJ//spxEMAapazZ37LT63+7D3s8rZ7Ulcrn0hPixlBgSQP48o0AjHBHvPuG3
+zgtmYQqb5yNnSjSsLJjPg8lrPz1Ze1xAGRdj+IkPHhi1RY6YfigPw+/XB5CHhreB
+RAOMSVqin/io37caNXAai8dnVIrnES+7b2t4p4AKmErP4vNoyixpY+33UTMrTsfO
+zYbN+UVqbuupe4b6Xrcd7dsFNqGyjsyoUuMnGmdgKbRAzVymgU0OZXo0kcRQQqWE
+LappHdGzBv0+WX1wuOWsY/Wtq4/ACmXLfpiwswIDAQABAoIBAQCFDDcpaUj0ArP+
+qEuz+x6/MGEk6QwZV7WNcGSFkvlSCoGkJJV+9RBExvao5yo92JbcuNbj4Tg7uOwY
+EzAC45a0AVZEscz4t/P6emXKf2SW28y6hnbkbxCxAIEwxENE0vfXEP/YDplmjsit
+whWXxYWHGe/OHz33UhYkONR9YBmUeLrtloRNUV82XDSpn4d7toLKaZW2kOFl4nFR
+SQ3pDPk1hleG8AZcfnF2LwaPx1XjPwBnXY9FK2jyNupVghfCw/Sv91dbbVkkIG14
+A8WpZKAXjXXOcTroof5+NJSPXzYrRuvP8K6H2zGj7F/AsP4hiZqGkb4tel0yH5VM
+oLCUTHqhAoGBAPysxeoT1ytajQ55UV1yjsnQ3jF9YcWsZwPEJgMI+bt+QzAfqqZs
+Kuvg8Gi7ukbcc2pKwXv+ma9HLJq/pQbWlfxcMNulY0VCPY/ceaPen+EfCJTApVpY
+YFS25i/JnIp9IudpQBuLHz9Yy4f1W2VoeG/mFqOmUxiTx4LM87G6rdtDAoGBANi7
+5raiwDS+rD91l5FLq3kdvgSDgYk4hh7BBJNJt8vhJYInIev5eb/Z41X8PfqWa2ir
+9aanpMYhWDJxbdSQDd3/op6jtOZM7InLceAm2O29VY2+HW5ePpc21AHsqoZpFYEZ
+YP8xvbSjJzfkrYr4y+aAMXONVAi4afqG7x6GqCXRAoGBAPbzFWu1gHKKyZn/0Bn4
+wL1WOhM8a7Z6zSPNLSmCODGbMadzC6Ijzb9D1TNHZsOi6dpUvc2mBCZe9aU48N1C
+FMzUfZvuhJtIJkrYPLp/9tpbLlPUBMfL4Dprl4XVEf34V4i8QT+qNRwAeMukbXMr
+K6qRwkanZEd9B107WmG2Bf1pAoGACpld1g6tgabVe6D/kY52y0yGD2hy/Ef0Xyqn
+U6CmSWUwVWYehZDEwHoiYQEd8tRKWmsWb1kBeOMGkijz6xJEa1fmFwYAgca/RpnZ
+btHXiADbXzwt6kjXnMOEqLdvO3WGJLMeCDzhfyT/dP9M8V/rcNFSGcmOk4KZRDQ3
+G3IQZRECgYBqHqvxHeL087UHXE1tdAGFVfxOiYE1afksJbkV06VnO8XXr9sNSWwy
+YjXVY9k6U1BFo7jHrWr6TkeMkB45wyn/fasHKU7qsPt0joRFkXMCzwl376hto3Tg
+RGXQCA4RUQXkxaDctJ5TgcF7MhK7tAFd1aBVlxwGENLYUVL0ZPaMrw==
+-----END RSA PRIVATE KEY-----

data/spec/fixtures/server.crt

@@ -0,0 +1,22 @@
+-----BEGIN CERTIFICATE-----
+MIIDmjCCAoICCQD+dJ16wNIKnzANBgkqhkiG9w0BAQUFADCBjjELMAkGA1UEBhMC
+VVMxEzARBgNVBAgTCkNhbGlmb3JuaWExFjAUBgNVBAcTDVNhbiBGcmFuY2lzY28x
+EjAQBgNVBAoTCUNlbGx1bG9pZDEbMBkGA1UEAxMSc2VydmVyLmV4YW1wbGUuY29t
+MSEwHwYJKoZIhvcNAQkBFhJzZXJ2ZXJAZXhhbXBsZS5jb20wHhcNMTIxMTI1MTkx
+NjAwWhcNMjIxMTIzMTkxNjAwWjCBjjELMAkGA1UEBhMCVVMxEzARBgNVBAgTCkNh
+bGlmb3JuaWExFjAUBgNVBAcTDVNhbiBGcmFuY2lzY28xEjAQBgNVBAoTCUNlbGx1
+bG9pZDEbMBkGA1UEAxMSc2VydmVyLmV4YW1wbGUuY29tMSEwHwYJKoZIhvcNAQkB
+FhJzZXJ2ZXJAZXhhbXBsZS5jb20wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEK
+AoIBAQCpLs3Xg00RtoG4+SKaaNfw6Dve9d0Kkg0CNfU8AsxOgTIU1Qu8s+bzKkqe
+66NfCa6T8VPpk9VbIlF2ONdgY4o8muV1q+mS6j2HDAtWPiDjP+9YOwGf/DT3LhSb
+g8k+alL2cqe7B1XNUsNFEvQ+yQLlj9MWKb7nbYDM8aqdv46KGoDj9v9rfm4QiKwI
+B6u/KoQG22YF7sT4O44jU/u20xcm3rV1Elg0gC/UP/YqnuMPCZYcK/Z9vYGtDJ6G
+8OYDcPZSZBdkqlffhYBssSj3R7sTCqoh4ms08ukcGycbvUO+cWrPKnmySsGaCYtG
+kp7QsH1ec7QGA01hZL2yL8CuJMUbAgMBAAEwDQYJKoZIhvcNAQEFBQADggEBABE4
+gYVSdC87NhpA49k0vcLLU7v7mU3a3no/vu1CIqQxzx8/xh26Qi3aGb1s9MgHpF2Z
+NiB1irXER2tyz/F3qCi8OCo7eNsndmDjj4GnkBjEPTtqRxH9imRWw4bJyqwqFHcu
+1kczCZa+2VFQFEL4ErGycPFKM59ppTcJ0IxbK7PCGzO75TRQoAl52+3Aob+oejPP
+qFbiqNlV1T3EKa5yLdvOC5sLrEcfm3iMxmOtNVzp9OBhjXfm8Q1zgYs4VyJXzLMK
+wf956w2YEbpTAAzNc53zly/Jhr4MnFsa9Mn1oYp9Rfjzw/qJtXw+a3PtEKrO4XNe
+TsKHsAkj8XvUrhliiNQ=
+-----END CERTIFICATE-----