webmachine 0.1.0

data/spec/webmachine/decision/flow_spec.rb

@@ -0,0 +1,1030 @@
+require 'spec_helper'
+
+describe Webmachine::Decision::Flow do
+  subject { Webmachine::Decision::FSM.new(resource, request, response) }
+  let(:method) { 'GET' }
+  let(:uri) { URI.parse("http://localhost/") }
+  let(:headers) { Webmachine::Headers.new }
+  let(:body) { "" }
+  let(:request) { Webmachine::Request.new(method, uri, headers, body) }
+  let(:response) { Webmachine::Response.new }
+  let(:default_resource) { resource_with }
+  let(:missing_resource) { missing_resource_with }
+
+  def resource_with(&block)
+    klass = Class.new(Webmachine::Resource) do
+      def to_html; "test resource"; end
+    end
+    klass.module_eval(&block) if block_given?
+    klass.new(request, response)
+  end
+
+  def missing_resource_with(&block)
+    resource_with do
+      def resource_exists?; false; end
+      self.module_eval(&block) if block
+    end
+  end
+
+  describe "#b13 (Service Available?)" do
+    let(:resource) do
+      resource_with do
+        attr_accessor :available
+        def service_available?; @available; end
+      end
+    end
+
+    it "should respond with 503 when the service is unavailable" do
+      resource.available = false
+      subject.run
+      response.code.should == 503
+    end
+  end
+
+  describe "#b12 (Known method?)" do
+    let(:resource) do
+      resource_with do
+        def known_methods; ['HEAD']; end
+      end
+    end
+
+    it "should respond with 501 when the method is unknown" do
+      subject.run
+      response.code.should == 501
+    end
+  end
+
+  describe "#b11 (URI too long?)" do
+    let(:resource) do
+      resource_with do
+        def uri_too_long?(uri); true; end
+      end
+    end
+
+    it "should respond with 414 when the URI is too long" do
+      subject.run
+      response.code.should == 414
+    end
+  end
+
+  describe "#b10 (Method allowed?)" do
+    let(:resource) do
+      resource_with do
+        def allowed_methods; ['POST']; end
+      end
+    end
+
+    it "should respond with 405 when the method is not allowed" do
+      subject.run
+      response.code.should == 405
+      response.headers['Allow'].should == "POST"
+    end
+  end
+
+  describe "#b9 (Malformed request?)" do
+    let(:resource) { resource_with { def malformed_request?; true; end } }
+
+    it "should respond with 400 when the request is malformed" do
+      subject.run
+      response.code.should == 400
+    end
+
+    context "when the Content-MD5 header is present" do
+      let(:resource) do
+        resource_with do
+          def allowed_methods; ['POST']; end;
+          def process_post; true; end;
+          attr_accessor :validation
+          def validate_content_checksum; @validation; end
+        end
+      end
+
+      let(:method) { "POST" }
+      let(:body) { "This is the body." }
+      let(:headers) { Webmachine::Headers["Content-Type" => "text/plain"] }
+
+      it "should respond with 400 when the request body does not match the header" do
+        headers['Content-MD5'] = "thiswillnotmatchthehash"
+        subject.run
+        response.code.should == 400
+      end
+
+      it "should respond with 400 when the resource invalidates the checksum" do
+        resource.validation = false
+        headers['Content-MD5'] = "thiswillnotmatchthehash"
+        subject.run
+        response.code.should == 400
+      end
+
+      it "should not respond with 400 when the resource validates the checksum" do
+        resource.validation = true
+        headers['Content-MD5'] = "thiswillnotmatchthehash"
+        subject.run
+        response.code.should_not == 400
+      end
+
+      it "should respond with the given code when the resource returns a code while validating" do
+        resource.validation = 500
+        headers['Content-MD5'] = "thiswillnotmatchthehash"
+        subject.run
+        response.code.should == 500
+      end
+    end
+  end
+
+  describe "#b8 (Authorized?)" do
+    let(:resource) { resource_with { attr_accessor :auth; def is_authorized?(header); @auth; end } }
+
+    it "should reply with 401 when the client is unauthorized" do
+      resource.auth = false
+      subject.run
+      response.code.should == 401
+    end
+
+    it "should reply with 401 when the resource gives a challenge" do
+      resource.auth = "Basic realm=Webmachine"
+      subject.run
+      response.code.should == 401
+      response.headers['WWW-Authenticate'].should == "Basic realm=Webmachine"
+    end
+
+    it "should halt with the given code when the resource returns a status code" do
+      resource.auth = 400
+      subject.run
+      response.code.should == 400
+    end
+
+    it "should not reply with 401 when the client is authorized" do
+      resource.auth = true
+      subject.run
+      response.code.should_not == 401
+    end
+  end
+
+  describe "#b7 (Forbidden?)" do
+    let(:resource) { resource_with { attr_accessor :forbid; def forbidden?; @forbid; end } }
+
+    it "should reply with 403 when the request is forbidden" do
+      resource.forbid = true
+      subject.run
+      response.code.should == 403
+    end
+
+    it "should not reply with 403 when the request is permitted" do
+      resource.forbid = false
+      subject.run
+      response.code.should_not == 403
+    end
+
+    it "should halt with the given code when the resource returns a status code" do
+      resource.forbid = 400
+      subject.run
+      response.code.should == 400
+    end
+  end
+
+  describe "#b6 (Unsupported Content-* header?)" do
+    let(:resource) do
+      resource_with do
+        def valid_content_headers?(contents)
+          contents['Content-Fail'].nil?
+        end
+      end
+    end
+
+    it "should reply with 501 when an invalid Content-* header is present" do
+      headers['Content-Fail'] = "yup"
+      subject.run
+      response.code.should == 501
+    end
+
+    it "should not reply with 501 when all Content-* headers are valid" do
+      subject.run
+      response.code.should_not == 501
+    end
+  end
+
+  describe "#b5 (Known Content-Type?)" do
+    let(:method) { "POST" }
+    let(:body) { "This is the body." }
+    let(:resource) do
+      resource_with do
+        def known_content_type?(type) type !~ /unknown/; end;
+        def process_post; true; end
+        def allowed_methods; %w{POST}; end
+      end
+    end
+
+    before { headers['Content-Length'] = body.length.to_s }
+
+    it "should reply with 415 when the Content-Type is unknown" do
+      headers['Content-Type'] = "application/x-unknown-type"
+      subject.run
+      response.code.should == 415
+    end
+
+    it "should not reply with 415 when the Content-Type is known" do
+      headers['Content-Type'] = "text/plain"
+      subject.run
+      response.code.should_not == 415
+    end
+  end
+
+  describe "#b4 (Request entity too large?)" do
+    let(:resource) do
+      resource_with do
+        def allowed_methods; %w{POST}; end
+        def process_post; true; end
+        def valid_entity_length?(length); length.to_i < 100; end
+      end
+    end
+    let(:method) { "POST" }
+    before { headers['Content-Type'] = "text/plain"; headers['Content-Length'] = body.size.to_s }
+
+    context "when the request body is too large" do
+      let(:body) { "Big" * 100 }
+      it "should reply with 413" do
+        subject.run
+        response.code.should == 413
+      end
+    end
+
+    context "when the request body is not too large" do
+      let(:body) { "small" }
+
+      it "should not reply with 413" do
+        subject.run
+        response.code.should_not == 413
+      end
+    end
+  end
+
+  describe "#b3 (OPTIONS?)" do
+    let(:method){ "OPTIONS" }
+    let(:resource){ resource_with { def allowed_methods; %w[GET HEAD OPTIONS]; end } }
+    it "should reply with 200 when the request method is OPTIONS" do
+      subject.run
+      response.code.should == 200
+    end
+  end
+
+  describe "#c3, #c4 (Acceptable media types)" do
+    let(:resource) { default_resource }
+    context "when the Accept header exists" do
+      it "should reply with 406 when the type is unacceptable" do
+        headers['Accept'] = "text/plain"
+        subject.run
+        response.code.should == 406
+      end
+
+      it "should not reply with 406 when the type is acceptable" do
+        headers['Accept'] = "text/*"
+        subject.run
+        response.code.should_not == 406
+        response.headers['Content-Type'].should == "text/html"
+      end
+    end
+
+    context "when the Accept header does not exist" do
+      it "should not negotiate a media type" do
+        headers['Accept'].should be_nil
+        subject.should_not_receive(:c4)
+        subject.run
+        response.headers['Content-Type'].should == 'text/html'
+      end
+    end
+  end
+
+  describe "#d4, #d5 (Acceptable languages)" do
+    let(:resource) { resource_with { def languages_provided; %w{en-US fr}; end } }
+    context "when the Accept-Language header exists" do
+      it "should reply with 406 when the language is unacceptable" do
+        headers['Accept-Language'] = "es, de"
+        subject.run
+        response.code.should == 406
+      end
+
+      it "should not reply with 406 when the language is acceptable" do
+        headers['Accept-Language'] = "en-GB, en;q=0.7"
+        subject.run
+        response.code.should_not == 406
+        response.headers['Content-Language'].should == "en-US"
+      end
+    end
+
+    context "when the Accept-Language header is absent" do
+      it "should not negotiate the language" do
+        headers['Accept-Language'].should be_nil
+        subject.should_not_receive(:d5)
+        subject.run
+        response.headers['Content-Language'].should == 'en-US'
+      end
+    end
+  end
+
+  describe "#e5, #e6 (Acceptable charsets)" do
+    let(:resource) do
+      resource_with do
+        def charsets_provided
+          [["iso8859-1", :to_iso],["utf-8", :to_utf]];
+        end
+        def to_iso(chunk); chunk; end
+        def to_utf(chunk); chunk; end
+      end
+    end
+
+    context "when the Accept-Charset header exists" do
+      it "should reply with 406 when the charset is unacceptable" do
+        headers['Accept-Charset'] = "utf-16"
+        subject.run
+        response.code.should == 406
+      end
+
+      it "should not reply with 406 when the charset is acceptable" do
+        headers['Accept-Charset'] = "iso8859-1"
+        subject.run
+        response.code.should_not == 406
+        response.headers['Content-Type'].should == "text/html;charset=iso8859-1"
+      end
+    end
+
+    context "when the Accept-Charset header is absent" do
+      it "should not negotiate the language" do
+        headers['Accept-Charset'].should be_nil
+        subject.should_not_receive(:e6)
+        subject.run
+        response.headers['Content-Type'].should == 'text/html;charset=iso8859-1'
+      end
+    end
+  end
+
+  describe "#f6, #f7 (Acceptable encodings)" do
+    let(:resource) do
+      resource_with do
+        def encodings_provided
+          super.merge("gzip" => :encode_gzip)
+        end
+      end
+    end
+
+    context "when the Accept-Encoding header is present" do
+      it "should reply with 406 if the encoding is unacceptable" do
+        headers['Accept-Encoding'] = 'deflate, identity;q=0.0'
+        subject.run
+        response.code.should == 406
+      end
+
+      it "should not reply with 406 if the encoding is acceptable" do
+        headers['Accept-Encoding'] = 'gzip, deflate'
+        subject.run
+        response.code.should_not == 406
+        response.headers['Content-Encoding'].should == 'gzip'
+        # It should be compressed
+        response.body.should_not == 'test resource'
+      end
+    end
+
+    context "when the Accept-Encoding header is not present" do
+      it "should not negotiate  an encoding" do
+        headers['Accept-Encoding'].should be_nil
+        subject.should_not_receive(:f7)
+        subject.run
+        response.code.should_not == 406
+        # It should not be compressed
+        response.body.should == 'test resource'
+      end
+    end
+  end
+
+  describe "#g7 (Resource exists?)" do
+    let(:resource) { resource_with { attr_accessor :exist; def resource_exists?; @exist; end } }
+
+    it "should not enter conditional requests if missing (and eventually reply with 404)" do
+      resource.exist = false
+      subject.should_not_receive(:g8)
+      subject.run
+      response.code.should == 404
+    end
+
+    it "should not reply with 404 if it does exist" do
+      resource.exist = true
+      subject.should_not_receive(:h7)
+      subject.run
+      response.code.should_not == 404
+    end
+  end
+
+  # Conditional requests/preconditions
+  describe "#g8, #g9, #g10 (ETag match)" do
+    let(:resource) { resource_with { def generate_etag; "etag"; end } }
+    it "should skip ETag matching when If-Match is missing" do
+      headers['If-Match'].should be_nil
+      subject.should_not_receive(:g9)
+      subject.should_not_receive(:g11)
+      subject.run
+      response.code.should_not == 412
+    end
+    it "should not reply with 304 when If-Match is *" do
+      headers['If-Match'] = "*"
+      subject.run
+      response.code.should_not == 412
+    end
+    it "should reply with 412 if the ETag is not in If-Match" do
+      headers['If-Match'] = '"notetag"'
+      subject.run
+      response.code.should == 412
+    end
+    it "should not reply with 412 if the ETag is in If-Match" do
+      headers['If-Match'] = '"etag"'
+      subject.run
+      response.code.should_not == 412
+    end
+  end
+
+  describe "#h10, #h11, #h12 (If-Unmodified-Since match [IUMS])" do
+    let(:resource) { resource_with { attr_accessor :now; def last_modified; @now; end } }
+    before { @now = resource.now = Time.now }
+
+    it "should skip LM matching if IUMS is missing" do
+      headers['If-Unmodified-Since'].should be_nil
+      subject.should_not_receive(:h11)
+      subject.should_not_receive(:h12)
+      subject.run
+      response.code.should_not == 412
+    end
+
+    it "should skip LM matching if IUMS is an invalid date" do
+      headers['If-Unmodified-Since'] = "garbage"
+      subject.should_not_receive(:h12)
+      subject.run
+      response.code.should_not == 412
+    end
+
+    it "should not reply with 412 if LM is <= IUMS" do
+      headers['If-Unmodified-Since'] = (@now + 100).httpdate
+      subject.run
+      response.code.should_not == 412
+    end
+
+    it "should reply with 412 if LM is > IUMS" do
+      headers['If-Unmodified-Since'] = (@now - 100).httpdate
+      subject.run
+      response.code.should == 412
+    end
+  end
+
+  describe "#i12, #i13, #k13, #j18 (If-None-Match match)" do
+    let(:resource) do
+      resource_with do
+        def generate_etag; "etag"; end;
+        def process_post; true; end
+        def allowed_methods; %w{GET HEAD POST}; end
+      end
+    end
+
+    it "should skip ETag matching if If-None-Match is missing" do
+      headers['If-None-Match'].should be_nil
+      %w{i13 k13 j18}.each do |m|
+        subject.should_not_receive(m.to_sym)
+      end
+      subject.run
+      [304, 412].should_not include(response.code)
+    end
+
+    it "should not reply with 412 or 304 if the ETag is not in If-None-Match" do
+      headers['If-None-Match'] = '"notetag"'
+      subject.run
+      [304, 412].should_not include(response.code)
+    end
+
+    context "when the method is GET or HEAD" do
+      let(:method){ %w{GET HEAD}[rand(1)] }
+      it "should reply with 304 when If-None-Match is *" do
+        headers['If-None-Match'] = '*'
+      end
+      it "should reply with 304 when the ETag is in If-None-Match" do
+        headers['If-None-Match'] = '"etag", "foobar"'
+      end
+      after { subject.run; response.code.should == 304 }
+    end
+
+    context "when the method is not GET or HEAD" do
+      let(:method){ "POST" }
+      let(:body) { "This is the body." }
+      let(:headers){ Webmachine::Headers["Content-Type" => "text/plain"] }
+
+      it "should reply with 412 when If-None-Match is *" do
+        headers['If-None-Match'] = '*'
+      end
+
+      it "should reply with 412 when the ETag is in If-None-Match" do
+        headers['If-None-Match'] = '"etag"'
+      end
+      after { subject.run; response.code.should == 412 }
+    end
+  end
+
+  describe "#l13, #l14, #l15, #l17 (If-Modified-Since match)" do
+    let(:resource) { resource_with { attr_accessor :now; def last_modified; @now; end } }
+    before { @now = resource.now = Time.now }
+    it "should skip LM matching if IMS is missing" do
+      headers['If-Modified-Since'].should be_nil
+      %w{l14 l15 l17}.each do |m|
+        subject.should_not_receive(m.to_sym)
+      end
+      subject.run
+      response.code.should_not == 304
+    end
+
+    it "should skip LM matching if IMS is an invalid date" do
+      headers['If-Modified-Since'] = "garbage"
+      %w{l15 l17}.each do |m|
+        subject.should_not_receive(m.to_sym)
+      end
+      subject.run
+      response.code.should_not == 304
+    end
+
+    it "should skip LM matching if IMS is later than current time" do
+      headers['If-Modified-Since'] = (@now + 1000).httpdate
+      subject.should_not_receive(:l17)
+      subject.run
+      response.code.should_not == 304
+    end
+
+    it "should reply with 304 if LM is <= IMS" do
+      headers['If-Modified-Since'] = (@now - 1).httpdate
+      resource.now = @now - 1000
+      subject.run
+      response.code.should == 304
+    end
+
+    it "should not reply with 304 if LM is > IMS" do
+      headers['If-Modified-Since'] = (@now - 1000).httpdate
+      subject.run
+      response.code.should_not == 304
+    end
+  end
+
+  # Resource missing branch (upper right)
+  describe "#h7 (If-Match: * exists?)" do
+    let(:resource) { missing_resource }
+    it "should reply with 412 when the If-Match header is *" do
+      headers['If-Match'] = '"*"'
+      subject.run
+      response.code.should == 412
+    end
+
+    it "should not reply with 412 when the If-Match header is missing or not *" do
+      headers['If-Match'] = ['"etag"', nil][rand(1)]
+      subject.run
+      response.code.should_not == 412
+    end
+  end
+
+  describe "#i7 (PUT?)" do
+    let(:resource) do
+      missing_resource_with do
+        def allowed_methods; %w{GET HEAD PUT POST}; end
+        def process_post; true; end
+      end
+    end
+    let(:body) { %W{GET HEAD DELETE}.include?(method) ? nil : "This is the body." }
+    before { headers['Content-Type'] = 'text/plain' }
+
+    context "when the method is PUT" do
+      let(:method){ "PUT" }
+
+      it "should not reach state k7" do
+        subject.should_not_receive(:k7)
+        subject.run
+      end
+
+      after { [404, 410, 303].should_not include(response.code) }
+    end
+
+    context "when the method is not PUT" do
+      let(:method){ %W{GET HEAD POST DELETE}[rand(4)] }
+
+      it "should not reach state i4" do
+        subject.should_not_receive(:i4)
+        subject.run
+      end
+
+      after { response.code.should_not == 409 }
+    end
+  end
+
+  describe "#i4 (Apply to a different URI?)" do
+    let(:resource) do
+      missing_resource_with do
+        attr_accessor :location
+        def moved_permanently?; @location; end
+        def allowed_methods; %w[PUT]; end
+      end
+    end
+    let(:method){ "PUT" }
+    let(:body){ "This is the body." }
+    let(:headers) { Webmachine::Headers["Content-Type" => "text/plain", "Content-Length" => body.size.to_s] }
+
+    it "should reply with 301 when the resource has moved" do
+      resource.location = URI.parse("http://localhost:8098/newuri")
+      subject.run
+      response.code.should == 301
+      response.headers['Location'].should == resource.location.to_s
+    end
+
+    it "should not reply with 301 when resource has not moved" do
+      resource.location = false
+      subject.run
+      response.code.should_not == 301
+    end
+  end
+
+  describe "Redirection (Resource previously existed)" do
+    let(:resource) do
+      missing_resource_with do
+        attr_writer :moved_perm, :moved_temp, :allow_missing
+        def previously_existed?; true; end
+        def moved_permanently?; @moved_perm; end
+        def moved_temporarily?; @moved_temp; end
+        def allow_missing_post?; @allow_missing; end
+        def allowed_methods; %W{GET POST}; end
+        def process_post; true; end
+      end
+    end
+    let(:method){ @method || "GET" }
+
+    describe "#k5 (Moved permanently?)" do
+      it "should reply with 301 when the resource has moved permanently" do
+        uri = resource.moved_perm = URI.parse("http://www.google.com/")
+        subject.run
+        response.code.should == 301
+        response.headers['Location'].should == uri.to_s
+      end
+      it "should not reply with 301 when the resource has not moved permanently" do
+        resource.moved_perm = false
+        subject.run
+        response.code.should_not == 301
+      end
+    end
+
+    describe "#l5 (Moved temporarily?)" do
+      before { resource.moved_perm = false }
+      it "should reply with 307 when the resource has moved temporarily" do
+        uri = resource.moved_temp = URI.parse("http://www.basho.com/")
+        subject.run
+        response.code.should == 307
+        response.headers['Location'].should == uri.to_s
+      end
+      it "should not reply with 307 when the resource has not moved temporarily" do
+        resource.moved_temp = false
+        subject.run
+        response.code.should_not == 307
+      end
+    end
+
+    describe "#m5 (POST?), #n5 (POST to missing resource?)" do
+      before { resource.moved_perm = resource.moved_temp = false }
+      it "should reply with 410 when the method is not POST" do
+        method.should_not == "POST"
+        subject.run
+        response.code.should == 410
+      end
+      it "should reply with 410 when the resource disallows missing POSTs" do
+        @method = "POST"
+        resource.allow_missing = false
+        subject.run
+        response.code.should == 410
+      end
+      it "should not reply with 410 when the resource allows missing POSTs" do
+        @method = "POST"
+        resource.allow_missing = true
+        subject.run
+        response.code.should == 410
+      end
+    end
+  end
+
+  describe "#l7 (POST?), #m7 (POST to missing resource?)" do
+    let(:resource) do
+      missing_resource_with do
+        attr_accessor :allow_missing
+        def allowed_methods; %W{GET POST}; end
+        def previously_existed?; false; end
+        def allow_missing_post?; @allow_missing; end
+        def process_post; true; end
+      end
+    end
+    let(:method){ @method || "GET" }
+    it "should reply with 404 when the method is not POST" do
+      method.should_not == "POST"
+      subject.run
+      response.code.should == 404
+    end
+    it "should reply with 404 when the resource disallows missing POSTs" do
+      @method = "POST"
+      resource.allow_missing = false
+      subject.run
+      response.code.should == 404
+    end
+    it "should not reply with 404 when the resource allows missing POSTs" do
+      @method = "POST"
+      resource.allow_missing = true
+      subject.run
+      response.code.should_not == 404
+    end
+  end
+
+  describe "#p3 (Conflict?)" do
+    let(:resource) do
+      missing_resource_with do
+        attr_writer :conflict
+        def allowed_methods; %W{PUT}; end
+        def is_conflict?; @conflict; end
+      end
+    end
+    let(:method){ "PUT" }
+    it "should reply with 409 if the resource is in conflict" do
+      resource.conflict = true
+      subject.run
+      response.code.should == 409
+    end
+    it "should not reply with 409 if the resource is in conflict" do
+      resource.conflict = false
+      subject.run
+      response.code.should_not == 409
+    end
+  end
+
+  # Bottom right
+  describe "#n11 (Redirect?)" do
+    let(:method) { "POST" }
+    let(:resource) do
+      resource_with do
+        attr_writer :new_loc, :exist
+        def allowed_methods; %w{POST}; end
+        def allow_missing_post?; true; end
+        def process_post
+          response.redirect_to(@new_loc) if @new_loc
+          true
+        end
+      end
+    end
+    [true, false].each do |e|
+      context "and the resource #{ e ? "does not exist" : 'exists'}" do
+        before { resource.exist = e }
+
+        it "should reply with 303 if the resource redirected" do
+          resource.new_loc = URI.parse("/foo/bar")
+          subject.run
+          response.code.should == 303
+          response.headers['Location'].should == "/foo/bar"
+        end
+
+        it "should not reply with 303 if the resource did not redirect" do
+          resource.new_loc = nil
+          subject.run
+          response.code.should_not == 303
+        end
+      end
+    end
+  end
+
+  describe "#p11 (New resource?)" do
+    let(:resource) do
+      resource_with do
+        attr_writer :exist, :new_loc, :create
+
+        def allowed_methods; %W{PUT POST}; end
+        def resource_exists?; @exist; end
+        def process_post; true; end
+        def allow_missing_post?; true; end
+        def post_is_create?; @create; end
+        def create_path; @new_loc; end
+        def content_types_accepted; [["text/plain", :accept_text]]; end
+        def accept_text
+          response.headers['Location'] = @new_loc.to_s if @new_loc
+          true
+        end
+      end
+    end
+    let(:body) { "new content" }
+    let(:headers){ Webmachine::Headers['content-type' => 'text/plain'] }
+
+    context "when the method is PUT" do
+      let(:method){ "PUT" }
+      [true, false].each do |e|
+        context "and the resource #{ e ? "does not exist" : 'exists'}" do
+          before { resource.exist = e }
+
+          it "should reply with 201 when the Location header has been set" do
+            resource.exist = e
+            resource.new_loc = "http://ruby-doc.org/"
+            subject.run
+            response.code.should == 201
+          end
+          it "should not reply with 201 when the Location header has been set" do
+            resource.exist = e
+            subject.run
+            response.headers['Location'].should be_nil
+            response.code.should_not == 201
+          end
+        end
+      end
+    end
+
+    context "when the method is POST" do
+      let(:method){ "POST" }
+      [true, false].each do |e|
+        context "and the resource #{ e ? 'exists' : "does not exist"}" do
+          before { resource.exist = e }
+          it "should reply with 201 when post_is_create is true and create_path returns a URI" do
+            resource.new_loc = created = "/foo/bar/baz"
+            resource.create = true
+            subject.run
+            response.code.should == 201
+            response.headers['Location'].should == created
+          end
+          it "should reply with 500 when post_is_create is true and create_path returns nil" do
+            resource.create = true
+            subject.run
+            response.code.should == 500
+            response.error.should_not be_nil
+          end
+          it "should not reply with 201 when post_is_create is false" do
+            resource.create = false
+            subject.run
+            response.code.should_not == 201
+          end
+        end
+      end
+    end
+  end
+
+  describe "#o14 (Conflict?)" do
+    let(:resource) do
+      resource_with do
+        attr_writer :conflict
+        def allowed_methods; %W{PUT}; end
+        def is_conflict?; @conflict; end
+      end
+    end
+    let(:method){ "PUT" }
+    it "should reply with 409 if the resource is in conflict" do
+      resource.conflict = true
+      subject.run
+      response.code.should == 409
+    end
+    it "should not reply with 409 if the resource is in conflict" do
+      resource.conflict = false
+      subject.run
+      response.code.should_not == 409
+    end
+  end
+
+  describe "#m16 (DELETE?), #m20 (Delete enacted?)" do
+    let(:method){ @method || "DELETE" }
+    let(:resource) do
+      resource_with do
+        attr_writer :deleted, :completed
+        def allowed_methods; %w{GET DELETE}; end
+        def delete_resource; @deleted; end
+        def delete_completed?; @completed; end
+      end
+    end
+    it "should not reply with 202 if the method is not DELETE" do
+      @method = "GET"
+      subject.run
+      response.code.should_not == 202
+    end
+    it "should reply with 500 if the DELETE fails" do
+      resource.deleted = false
+      subject.run
+      response.code.should == 500
+    end
+    it "should reply with 202 if the DELETE succeeds but is not complete" do
+      resource.deleted = true
+      resource.completed = false
+      subject.run
+      response.code.should == 202
+    end
+    it "should not reply with 202 if the DELETE succeeds and completes" do
+      resource.completed = resource.deleted = true
+      subject.run
+      response.code.should_not == 202
+    end
+  end
+
+  # These decisions are covered by dozens of other examples. Leaving
+  # commented for now.
+  # describe "#n16 (POST?)" do it; end
+  # describe "#o16 (PUT?)" do it; end
+  
+  describe "#o18 (Multiple representations?)" do
+    let(:resource) do
+      resource_with do
+        attr_writer :exist, :multiple
+        def delete_resource
+          response.body = "Response content."
+          true
+        end
+        def delete_completed?; true; end
+        def allowed_methods; %{GET HEAD PUT POST DELETE}; end
+        def resource_exists?; @exist; end
+        def allow_missing_post?; true; end
+        def content_types_accepted; [[request.content_type, :accept_all]]; end
+        def multiple_choices?; @multiple; end
+        def process_post
+          response.body = "Response content."
+          true
+        end
+        def accept_all
+          response.body = "Response content."
+          true
+        end
+      end
+    end
+    
+    [["GET", true],["HEAD", true],["PUT", true],["PUT", false],["POST",true],["POST",false],
+     ["DELETE", true]].each do |m, e|
+      context "when the method is #{m} and the resource #{e ? 'exists' : 'does not exist' }" do
+        let(:method){ m }
+        let(:body) { %W{PUT POST}.include?(m) ? "request body" : "" }
+        let(:headers) { %W{PUT POST}.include?(m) ? Webmachine::Headers['content-type' => 'text/plain'] : Webmachine::Headers.new }
+        before { resource.exist = e }
+        it "should reply with 200 if there are not multiple representations" do
+          resource.multiple = false
+          subject.run
+          puts response.error if response.code == 500
+          response.code.should == 200
+        end
+        it "should reply with 300 if there are multiple representations" do
+          resource.multiple = true
+          subject.run
+          puts response.error if response.code == 500
+          response.code.should == 300
+        end
+      end
+    end
+  end
+  
+  describe "#o20 (Response has entity?)" do
+    let(:resource) do
+      resource_with do
+        attr_writer :exist, :body
+        def delete_resource; true; end
+        def delete_completed?; true; end
+        def allowed_methods; %{GET PUT POST DELETE}; end
+        def resource_exists?; @exist; end
+        def allow_missing_post?; true; end
+        def content_types_accepted; [[request.content_type, :accept_all]]; end
+        def process_post
+          response.body = @body if @body
+          true
+        end
+        def accept_all
+          response.body = @body if @body
+          true
+        end
+      end
+    end
+    let(:method) { @method || "GET" }
+    let(:headers) { %{PUT POST}.include?(method) ? Webmachine::Headers["content-type" => "text/plain"] : Webmachine::Headers.new }
+    let(:body) { %{PUT POST}.include?(method) ? "This is the body." : nil }
+    context "when a response body is present" do
+      before { resource.body = "Hello, world!" }
+      [
+       ["PUT", false],
+       ["POST", false],
+       ["DELETE", true],
+       ["POST", true],
+       ["PUT", true]
+      ].each do |m, e|
+        it "should not reply with 204 (via exists:#{e}, #{m})" do
+          @method = m
+          resource.exist = e
+          subject.run
+          response.code.should_not == 204
+        end
+      end
+    end
+    context "when a response body is not present" do
+      [
+       ["PUT", false],
+       ["POST", false],
+       ["DELETE", true],
+       ["POST", true],
+       ["PUT", true]
+      ].each do |m, e|
+        it "should reply with 204 (via exists:#{e}, #{m})" do
+          @method = m
+          resource.exist = e
+          subject.run
+          response.code.should == 204
+          response.trace.last.should == :o20
+        end
+      end
+    end
+  end
+end