webmachine 1.0.0 → 1.1.0

data/spec/webmachine/decision/flow_spec.rb

@@ -414,6 +414,18 @@ describe Webmachine::Decision::Flow do
       subject.run
       response.code.should_not == 404
     end
+
+    it "should not reply with 404 for truthy non-booleans" do
+      resource.exist = []
+      subject.run
+      response.code.should_not == 404
+    end
+
+    it "should reply with 404 for nil" do
+      resource.exist = nil
+      subject.run
+      response.code.should == 404
+    end
   end
 
   # Conditional requests/preconditions

data/spec/webmachine/decision/fsm_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+describe Webmachine::Decision::FSM do
+  include_context 'default resource'
+
+  subject { described_class.new(resource, request, response) }
+
+  describe 'handling of exceptions from decision methods' do
+    let(:exception) { Exception.new }
+
+    before do
+      subject.stub(Webmachine::Decision::Flow::START) { raise exception }
+    end
+
+    it 'calls resource.handle_exception' do
+      resource.should_receive(:handle_exception).with(exception)
+      subject.run
+    end
+
+    it 'calls resource.finish_request' do
+      resource.should_receive(:finish_request)
+      subject.run
+    end
+  end
+
+  describe 'handling of exceptions from resource.handle_exception' do
+    let(:exception) { Exception.new('an error message') }
+
+    before do
+      subject.stub(Webmachine::Decision::Flow::START) { raise }
+      resource.stub(:handle_exception) { raise exception }
+    end
+
+    it 'does not call resource.handle_exception again' do
+      resource.should_receive(:handle_exception).once { raise }
+      subject.run
+    end
+
+    it 'does not call resource.finish_request' do
+      resource.should_not_receive(:finish_request)
+      subject.run
+    end
+
+    it 'renders an error' do
+      Webmachine.
+        should_receive(:render_error).
+        with(500, request, response, { :message => exception.message })
+      subject.run
+    end
+  end
+
+  describe 'handling of exceptions from resource.finish_request' do
+    let(:exception) { Exception.new }
+
+    before do
+      resource.stub(:finish_request) { raise exception }
+    end
+
+    it 'calls resource.handle_exception' do
+      resource.should_receive(:handle_exception).with(exception)
+      subject.run
+    end
+
+    it 'does not call resource.finish_request again' do
+      resource.should_receive(:finish_request).once { raise }
+      subject.run
+    end
+  end
+
+  it "sets the response code before calling finish_request" do
+    resource_class.class_eval do
+      class << self
+        attr_accessor :current_response_code
+      end
+
+      def to_html
+        201
+      end
+
+      def finish_request
+        self.class.current_response_code = response.code
+      end
+    end
+
+    subject.run
+
+    resource_class.current_response_code.should be(201)
+  end
+
+  it 'respects a response code set by resource.finish_request' do
+    resource_class.class_eval do
+      def finish_request
+        response.code = 451
+      end
+    end
+
+    subject.run
+
+    response.code.should be(451)
+  end
+end

data/spec/webmachine/decision/helpers_spec.rb

@@ -47,7 +47,7 @@ describe Webmachine::Decision::Helpers do
   end
 
   context "setting the Content-Length header when responding" do
-    [204, 304].each do |code|
+    [204, 205, 304].each do |code|
       it "removes the header for entity-less response code #{code}" do
         response.headers['Content-Length'] = '0'
         response.body = nil
@@ -57,9 +57,9 @@ describe Webmachine::Decision::Helpers do
     end
 
     (200..599).each do |code|
-      # 204 and 304 have no bodies, 404 is set to a default non-zero
-      # response by Webmachine
-      next if code == 204 || code == 304 || code == 404
+      # 204, 205 and 304 have no bodies, 404 is set to a default
+      # non-zero response by Webmachine
+      next if [204, 205, 304, 404].include? code
 
       it "adds the header for response code #{code} that should include an entity but has an empty body" do
         response.code = code
@@ -70,7 +70,7 @@ describe Webmachine::Decision::Helpers do
     end
 
     (200..599).each do |code|
-      next if code == 204 || code == 304
+      next if [204, 205, 304].include? code
 
       it "does not add the header when Transfer-Encoding is set on code #{code}" do
         response.headers['Transfer-Encoding'] = 'chunked'
@@ -115,7 +115,7 @@ describe Webmachine::Decision::Helpers do
 
       it "wraps the response body in an EnumerableEncoder" do
         subject.encode_body
-        Webmachine::EnumerableEncoder.should === response.body
+        Webmachine::Streaming::EnumerableEncoder.should === response.body
       end
 
       it_should_behave_like "a non-String body"
@@ -126,7 +126,7 @@ describe Webmachine::Decision::Helpers do
 
       it "wraps the response body in a CallableEncoder" do
         subject.encode_body
-        Webmachine::CallableEncoder.should === response.body
+        Webmachine::Streaming::CallableEncoder.should === response.body
       end
 
       it_should_behave_like "a non-String body"
@@ -137,10 +137,70 @@ describe Webmachine::Decision::Helpers do
 
       it "wraps the response body in a FiberEncoder" do
         subject.encode_body
-        Webmachine::FiberEncoder.should === response.body
+        Webmachine::Streaming::FiberEncoder.should === response.body
       end
 
       it_should_behave_like "a non-String body"
     end
+
+    context "with a File body" do
+      before { response.body = File.open("spec/spec_helper.rb", "r") }
+
+      it "wraps the response body in an IOEncoder" do
+        subject.encode_body
+        Webmachine::Streaming::IOEncoder.should === response.body
+      end
+
+      it "sets the Content-Length header to the size of the file" do
+        subject.encode_body
+        response.headers['Content-Length'].should == File.stat('spec/spec_helper.rb').size.to_s
+      end
+
+      context "when the resource provides a non-identity encoding that the client accepts" do
+        let(:resource) do
+          resource_with do
+            def encodings_provided
+              { "deflate" => :encode_deflate, "identity" => :encode_identity }
+            end
+          end
+        end
+
+        let(:headers) do
+          Webmachine::Headers.new({"Accept-Encoding" => "deflate, identity"})
+        end
+
+        it_should_behave_like "a non-String body"
+      end
+    end
+
+    context "with a StringIO body" do
+      before { response.body = StringIO.new("A VERY LONG STRING, NOT") }
+
+      it "wraps the response body in an IOEncoder" do
+        subject.encode_body
+        Webmachine::Streaming::IOEncoder.should === response.body
+      end
+
+      it "sets the Content-Length header to the size of the string" do
+        subject.encode_body
+        response.headers['Content-Length'].should == response.body.size.to_s
+      end
+
+      context "when the resource provides a non-identity encoding that the client accepts" do
+        let(:resource) do
+          resource_with do
+            def encodings_provided
+              { "deflate" => :encode_deflate, "identity" => :encode_identity }
+            end
+          end
+        end
+
+        let(:headers) do
+          Webmachine::Headers.new({"Accept-Encoding" => "deflate, identity"})
+        end
+
+        it_should_behave_like "a non-String body"
+      end
+    end
   end
 end

data/spec/webmachine/dispatcher/route_spec.rb

@@ -7,7 +7,7 @@ describe Webmachine::Dispatcher::Route do
   let(:resource){ Class.new(Webmachine::Resource) }
 
   matcher :match_route do |*expected|
-    route = described_class.new(expected[0], resource, expected[1] || {})
+    route = Webmachine::Dispatcher::Route.new(expected[0], Class.new(Webmachine::Resource), expected[1] || {})
     match do |actual|
       request.uri.path = actual if String === actual
       route.match?(request)

data/spec/webmachine/dispatcher_spec.rb

@@ -29,7 +29,7 @@ describe Webmachine::Dispatcher do
   it "should add routes" do
     expect {
       dispatcher.add_route ['*'], resource
-    }.should_not raise_error
+    }.to_not raise_error
   end
 
   it "should have add_route return the newly created route" do

data/spec/webmachine/errors_spec.rb

@@ -7,7 +7,7 @@ describe "Webmachine errors" do
       res = Webmachine::Response.new
 
       Webmachine.render_error(404, req, res)
-      res.code.should be(404)
+      res.code.should == 404
     end
   end
 end

data/spec/webmachine/etags_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe Webmachine::ETag do
+  let(:etag_str){ '"deadbeef12345678"' }
+  let(:etag) { described_class.new etag_str }
+
+  subject { etag }
+
+  it { should == etag_str }
+  it { should be_kind_of(described_class) }
+  its(:to_s) { should == '"deadbeef12345678"' }
+  its(:etag) { should == '"deadbeef12345678"' }
+  it { should == described_class.new(etag_str.dup) }
+
+  context "when the original etag is unquoted" do
+    let(:etag_str) { 'deadbeef12345678' }
+
+    it { should == etag_str }
+    its(:to_s) { should == '"deadbeef12345678"' }
+    its(:etag) { should == '"deadbeef12345678"' }
+    it { should == described_class.new(etag_str.dup) }
+  end
+
+  context "when the original etag contains unbalanced quotes" do
+    let(:etag_str) { 'deadbeef"12345678' }
+
+    it { should == etag_str }
+    its(:to_s) { should == '"deadbeef\\"12345678"' }
+    its(:etag) { should == '"deadbeef\\"12345678"' }
+    it { should == described_class.new(etag_str.dup) }
+  end
+end
+
+describe Webmachine::WeakETag do
+  let(:strong_etag){ '"deadbeef12345678"' }
+  let(:weak_etag) { described_class.new strong_etag }
+
+  subject { weak_etag }
+
+  it { should == strong_etag }
+  it { should be_kind_of(described_class) }
+  its(:to_s) { should == 'W/"deadbeef12345678"' }
+  its(:etag) { should == '"deadbeef12345678"' }
+  it { should == described_class.new(strong_etag.dup) }
+
+  context "when the original etag is unquoted" do
+    let(:strong_etag) { 'deadbeef12345678' }
+
+    it { should == strong_etag }
+    it { should be_kind_of(described_class) }
+    its(:to_s) { should == 'W/"deadbeef12345678"' }
+    its(:etag) { should == '"deadbeef12345678"' }
+    it { should == described_class.new(strong_etag.dup) }
+  end
+
+  context "when the original etag contains unbalanced quotes" do
+    let(:strong_etag) { 'deadbeef"12345678' }
+
+    it { should == strong_etag }
+    it { should be_kind_of(described_class) }
+    its(:to_s) { should == 'W/"deadbeef\\"12345678"' }
+    its(:etag) { should == '"deadbeef\\"12345678"' }
+    it { should == described_class.new(strong_etag.dup) }
+  end
+
+  context "when the original etag is already a weak tag" do
+    let(:strong_etag) { 'W/"deadbeef12345678"' }
+
+    it { should == strong_etag }
+    it { should be_kind_of(described_class) }
+    its(:to_s) { should == 'W/"deadbeef12345678"' }
+    its(:etag) { should == '"deadbeef12345678"' }
+    it { should == described_class.new(strong_etag.dup) }
+  end
+end

data/spec/webmachine/headers_spec.rb

@@ -14,6 +14,78 @@ describe Webmachine::Headers do
     end
   end
 
+  describe ".[]" do
+    context "Webmachine::Headers['Content-Type', 'application/json']" do
+      it "creates a hash with lowercase keys" do
+        headers = described_class[
+          'Content-Type', 'application/json',
+          'Accept', 'application/json'
+        ]
+
+        headers.to_hash.should == {
+          'content-type' => 'application/json',
+          'accept' => 'application/json'
+        }
+      end
+    end
+
+    context "Webmachine::Headers[[['Content-Type', 'application/json']]]" do
+      it "creates a hash with lowercase keys" do
+        headers = described_class[
+          [
+            ['Content-Type', 'application/json'],
+            ['Accept', 'application/json']
+          ]
+        ]
+
+        headers.to_hash.should == {
+          'content-type' => 'application/json',
+          'accept' => 'application/json'
+        }
+      end
+    end
+
+    context "Webmachine::Headers['Content-Type' => 'application/json']" do
+      it "creates a hash with lowercase keys" do
+        headers = described_class[
+          'Content-Type' => 'application/json',
+          'Accept' => 'application/json'
+        ]
+
+        headers.to_hash.should == {
+          'content-type' => 'application/json',
+          'accept' => 'application/json'
+        }
+      end
+    end
+  end
+
+  describe "#fetch" do
+    subject { described_class['Content-Type' => 'application/json'] }
+
+    it "returns the value for the given key" do
+      subject.fetch('conTent-tYpe').should == 'application/json'
+    end
+
+    context "acessing a missing key" do
+      it "raises an IndexError" do
+        expect { subject.fetch('accept') }.to raise_error(IndexError)
+      end
+
+      context "and a default value given" do
+        it "returns the default value if the key does not exist" do
+          subject.fetch('accept', 'text/html').should == 'text/html'
+        end
+      end
+
+      context "and a block given" do
+        it "passes the value to the block and returns the block's result" do
+          subject.fetch('access') {|k| "#{k} not found"}.should == 'access not found'
+        end
+      end
+    end
+  end
+
   context "filtering with #grep" do
     subject { described_class["content-type" => "text/plain", "etag" => '"abcdef1234567890"'] }
     it "should filter keys by the given pattern" do

data/spec/webmachine/trace/fsm_spec.rb

@@ -18,6 +18,11 @@ describe Webmachine::Trace::FSM do
       response.trace.should_not be_empty
       Webmachine::Trace.traces.should have(1).item
     end
+
+    it "commits the trace to separate storage when the request has finished processing" do
+      Webmachine::Trace.should_receive(:record).with(subject.resource.object_id.to_s, response.trace).and_return(true)
+      subject.run
+    end
   end
 
   context "when tracing is disabled" do

data/spec/webmachine/trace/resource_proxy_spec.rb

@@ -27,9 +27,7 @@ describe Webmachine::Trace::ResourceProxy do
     response.trace[-1].should == {:type => :result, :value => "<html><body>Hello, world!</body></html>"}
   end
 
-  it "commits the trace to separate storage when the request has finished processing" do
-    Webmachine::Trace.should_receive(:record).with(subject.object_id.to_s, [{:type=>:attempt, :name=>"(default)#finish_request"},
-                                                                       {:type=>:result, :value=>nil}]).and_return(true)
+  it "sets the trace id header when the request has finished processing" do
     subject.finish_request
     response.headers["X-Webmachine-Trace-Id"].should == subject.object_id.to_s
   end