webmachine 0.1.0 → 0.2.0

data/pkg/webmachine-0.1.0/lib/webmachine/streaming.rb

@@ -0,0 +1,27 @@
+module Webmachine
+  class StreamingEncoder
+    def initialize(resource, encoder, charsetter, body)
+      @resource, @encoder, @charsetter, @body = resource, encoder, charsetter, body
+    end
+  end
+
+  class EnumerableEncoder < StreamingEncoder
+    include Enumerable
+
+    def each
+      body.each do |block|
+        yield @resource.send(@encoder, resource.send(@charsetter, block))
+      end
+    end
+  end
+
+  class CallableEncoder < StreamingEncoder
+    def call
+      @resource.send(@encoder, @resource.send(@charsetter, body.call))
+    end
+
+    def to_proc
+      method(:call).to_proc
+    end
+  end
+end

data/pkg/webmachine-0.1.0/lib/webmachine/translation.rb

@@ -0,0 +1,11 @@
+require 'i18n'
+
+I18n.config.load_path << File.expand_path("../locale/en.yml", __FILE__)
+
+module Webmachine
+  module Translation
+    def t(key, options={})
+      ::I18n.t(key, options.merge(:scope => :webmachine))
+    end
+  end
+end

data/pkg/webmachine-0.1.0/lib/webmachine/version.rb

@@ -0,0 +1,4 @@
+module Webmachine
+  VERSION = "0.1.0"
+  SERVER_STRING = "Webmachine-Ruby/#{VERSION}"
+end

data/pkg/webmachine-0.1.0/lib/webmachine.rb

@@ -0,0 +1,19 @@
+require 'webmachine/headers'
+require 'webmachine/request'
+require 'webmachine/response'
+require 'webmachine/errors'
+require 'webmachine/decision'
+require 'webmachine/streaming'
+require 'webmachine/adapters'
+require 'webmachine/dispatcher'
+require 'webmachine/resource'
+require 'webmachine/version'
+
+# Webmachine is a toolkit for making well-behaved HTTP applications.
+# It is based on the Erlang library of the same name.
+module Webmachine
+  # Starts Webmachine serving requests
+  def self.run
+    Adapters.const_get(adapter).run
+  end
+end

data/pkg/webmachine-0.1.0/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+$LOAD_PATH << File.expand_path("..", __FILE__)
+$LOAD_PATH << File.expand_path("../../lib", __FILE__)
+
+require 'rubygems'
+require 'webmachine'
+require 'rspec'
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+  config.filter_run :focus => true
+  config.run_all_when_everything_filtered = true
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+end

data/pkg/webmachine-0.1.0/spec/tests.org

@@ -0,0 +1,57 @@
+* 2,2 Basic Rules
+  - HTTP/1.1 header field values can be folded onto multiple lines if
+    the continuation line begins with a space or horizontal tab. All
+    linear white space, including folding, has the same semantics as
+    SP. A recipient MAY replace any linear white space with a single
+    SP before interpreting the field value or forwarding the message
+    downstream.
+  - Many HTTP/1.1 header field values consist of words separated by
+    LWS or special characters. These special characters MUST be in a
+    quoted string to be used within a parameter value (as defined in
+    section 3.6).
+* 3.1 HTTP Version
+  - Note that the major and minor numbers MUST be treated as separate
+    integers and that each MAY be incremented higher than a single
+    digit.
+  - Leading zeros MUST be ignored by recipients and MUST NOT be sent.
+  - An application that sends a request or response message that
+    includes HTTP-Version of "HTTP/1.1" MUST be at least conditionally
+    compliant with this specification.
+  - Applications that are at least conditionally compliant with this
+    specification SHOULD use an HTTP-Version of "HTTP/1.1" in their
+    messages, and MUST do so for any message that is not compatible
+    with HTTP/1.0.
+  - Since the protocol version indicates the protocol capability of
+    the sender, a proxy/gateway MUST NOT send a message with a version
+    indicator which is greater than its actual version. If a higher
+    version request is received, the proxy/gateway MUST either
+    downgrade the request version, or respond with an error, or switch
+    to tunnel behavior.
+  - Due to interoperability problems with HTTP/1.0 proxies discovered
+    since the publication of RFC 2068 [33], caching proxies MUST,
+    gateways MAY, and tunnels MUST NOT upgrade the request to the
+    highest version they support. The proxy/gateway's response to that
+    request MUST be in the same major version as the request.
+* 3.2 URIs
+** General Syntax
+   - Servers MUST be able to handle the URI of any resource they serve.
+   - Servers SHOULD be able to handle URIs of unbounded length if they
+     provide GET-based forms that could generate such URIs.
+   - A server SHOULD return 414 (Request-URI Too Long) status if a URI
+     is longer than the server can handle
+** http URL
+   - If the abs_path is not present in the URL, it MUST be given as
+     "/" when used as a Request-URI for a resource.
+   - If a proxy receives a fully qualified domain name, the proxy MUST
+     NOT change the host name.
+** URI Comparison
+   - When comparing two URIs to decide if they match or not, a client
+     SHOULD use a case-sensitive octet-by-octet comparison of the
+     entire URIs, with these exceptions:
+     - A port that is empty or not given is equivalent to the default
+       port for that URI-reference
+     - Comparisons of host names MUST be case-insensitive
+     - Comparisons of scheme names MUST be case-insensitive
+     - An empty abs_path is equivalent to an abs_path of "/"  
+* 3.3 Date/Time Formats
+  

data/pkg/webmachine-0.1.0/spec/webmachine/decision/conneg_spec.rb

@@ -0,0 +1,152 @@
+require 'spec_helper'
+
+describe Webmachine::Decision::Conneg do
+  let(:request) { Webmachine::Request.new("GET", URI.parse("http://localhost:8080/"), Webmachine::Headers["accept" => "*/*"], "") }
+  let(:response) { Webmachine::Response.new }
+  let(:resource) do
+    Class.new(Webmachine::Resource) do
+      def to_html; "hello world!"; end
+    end
+  end
+  subject do
+    Webmachine::Decision::FSM.new(resource, request, response)
+  end
+
+  context "choosing a media type" do
+    it "should not choose a type when none are provided" do
+      subject.choose_media_type([], "*/*").should be_nil      
+    end
+    
+    it "should not choose a type when none are acceptable" do
+      subject.choose_media_type(["text/html"], "application/json").should be_nil
+    end
+    
+    it "should choose the first acceptable type" do
+      subject.choose_media_type(["text/html", "application/xml"],
+                                "application/xml, text/html, */*").should == "application/xml"
+    end
+    
+    it "should choose the type that matches closest when matching subparams" do
+      subject.choose_media_type(["text/html",
+                                 ["text/html", {"charset" => "iso8859-1"}]],
+                                "text/html;charset=iso8859-1, application/xml").
+        should == "text/html;charset=iso8859-1"
+        
+    end
+    
+    it "should choose the preferred type over less-preferred types" do
+      subject.choose_media_type(["text/html", "application/xml"],
+                                "application/xml;q=0.7, text/html, */*").should == "text/html"
+      
+    end
+
+    it "should raise an exception when a media-type is improperly formatted" do
+      expect {
+        subject.choose_media_type(["text/html", "application/xml"],
+                                  "bah;")
+      }.to raise_error(Webmachine::MalformedRequest)
+    end
+  end
+
+  context "choosing an encoding" do
+    it "should not set the encoding when none are provided" do
+      subject.choose_encoding({}, "identity, gzip")
+      subject.metadata['Content-Encoding'].should be_nil
+      subject.response.headers['Content-Encoding'].should be_nil
+    end
+
+    it "should not set the Content-Encoding header when it is identity" do
+      subject.choose_encoding({"gzip"=> :encode_gzip, "identity" => :encode_identity}, "identity")
+      subject.metadata['Content-Encoding'].should == 'identity'
+      response.headers['Content-Encoding'].should be_nil
+    end
+
+    it "should choose the first acceptable encoding" do
+      subject.choose_encoding({"gzip" => :encode_gzip}, "identity, gzip")
+      subject.metadata['Content-Encoding'].should == 'gzip'
+      response.headers['Content-Encoding'].should == 'gzip'
+    end
+
+    it "should choose the preferred encoding over less-preferred encodings" do
+      subject.choose_encoding({"gzip" => :encode_gzip, "identity" => :encode_identity}, "gzip, identity;q=0.7")
+      subject.metadata['Content-Encoding'].should == 'gzip'
+      response.headers['Content-Encoding'].should == 'gzip'
+    end
+
+    it "should not set the encoding if none are acceptable" do
+      subject.choose_encoding({"gzip" => :encode_gzip}, "identity")
+      subject.metadata['Content-Encoding'].should be_nil
+      response.headers['Content-Encoding'].should be_nil
+    end
+  end
+
+  context "choosing a charset" do
+    it "should not set the charset when none are provided" do
+      subject.choose_charset([], "ISO-8859-1")
+      subject.metadata['Charset'].should be_nil
+    end
+
+    it "should choose the first acceptable charset" do
+      subject.choose_charset([["UTF-8", :to_utf8],["US-ASCII", :to_ascii]], "US-ASCII, UTF-8")
+      subject.metadata['Charset'].should == "US-ASCII"
+    end
+
+    it "should choose the preferred charset over less-preferred charsets" do
+      subject.choose_charset([["UTF-8", :to_utf8],["US-ASCII", :to_ascii]], "US-ASCII;q=0.7, UTF-8")
+      subject.metadata['Charset'].should == "UTF-8"
+    end
+
+    it "should not set the charset if none are acceptable" do
+      subject.choose_charset([["UTF-8", :to_utf8],["US-ASCII", :to_ascii]], "ISO-8859-1")
+      subject.metadata['Charset'].should be_nil
+    end
+
+    it "should choose a charset case-insensitively" do
+      subject.choose_charset([["UtF-8", :to_utf8],["US-ASCII", :to_ascii]], "iso-8859-1, utf-8")
+      subject.metadata['Charset'].should == "utf-8"
+    end
+  end
+
+  context "choosing a language" do
+    it "should not set the language when none are provided" do
+      subject.choose_language([], "en")
+      subject.metadata['Language'].should be_nil
+    end
+    
+    it "should choose the first acceptable language" do
+      subject.choose_language(['en', 'en-US', 'es'], "en-US, es")
+      subject.metadata['Language'].should == "en-US"
+      response.headers['Content-Language'].should == "en-US"
+    end
+    
+    it "should choose the preferred language over less-preferred languages" do
+      subject.choose_language(['en', 'en-US', 'es'], "en-US;q=0.6, es")
+      subject.metadata['Language'].should == "es"
+      response.headers['Content-Language'].should == "es"      
+    end
+
+    it "should select the first language if all are acceptable" do
+      subject.choose_language(['en', 'fr', 'es'], "*")
+      subject.metadata['Language'].should == "en"
+      response.headers['Content-Language'].should == "en"
+    end
+    
+    it "should select the closest acceptable language when an exact match is not available" do
+      subject.choose_language(['en-US', 'es'], "en, fr")
+      subject.metadata['Language'].should == 'en-US'
+      response.headers['Content-Language'].should == 'en-US'
+    end
+    
+    it "should not set the language if none are acceptable" do
+      subject.choose_language(['en'], 'es')
+      subject.metadata['Language'].should be_nil
+      response.headers.should_not include('Content-Language')
+    end
+
+    it "should choose a language case-insensitively" do
+      subject.choose_language(['en-US', 'ZH'], 'zh-ch, EN')
+      subject.metadata['Language'].should == 'en-US'
+      response.headers['Content-Language'].should == 'en-US'
+    end
+  end
+end

data/pkg/webmachine-0.1.0/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