RubyGems - webmachine - Versions diffs - 0.4.1 → 0.4.2 - Mend

webmachine 0.4.1 → 0.4.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (907) hide show

data/pkg/webmachine-0.4.0/spec/webmachine/decision/helpers_spec.rb DELETED Viewed

@@ -1,116 +0,0 @@
-require 'spec_helper'
-describe Webmachine::Decision::Helpers 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 }
-  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
-  let(:resource) { resource_with }
-  describe "accepting request bodies" do
-    let(:resource) do
-      resource_with do
-        def initialize
-          @accepted, @result = [], true
-        end
-        attr_accessor :accepted, :result
-        def content_types_accepted
-          (accepted || []).map {|t| Array === t ? t : [t, :accept_doc] }
-        end
-        def accept_doc; result; end
-      end
-    end
-    it "should return 415 when no types are accepted" do
-      subject.accept_helper.should == 415
-    end
-    it "should return 415 when the posted type is not acceptable" do
-      resource.accepted = %W{application/json}
-      headers['Content-Type'] = "text/xml"
-      subject.accept_helper.should == 415
-    end
-    it "should call the method for the first acceptable type, taking into account params" do
-      resource.accepted = ["application/json;v=3", ["application/json", :other]]
-      resource.should_receive(:other).and_return(true)
-      headers['Content-Type'] = 'application/json;v=2'
-      subject.accept_helper.should be_true
-    end
-  end
-  describe "#encode_body" do
-    before { subject.run }
-    context "with a String body" do
-      before { response.body = '<body></body>' }
-      it "does not modify the response body" do
-        subject.encode_body
-        String.should === response.body
-      end
-      it "sets the Content-Length header in the response" do
-        subject.encode_body
-        response.headers['Content-Length'].should == response.body.bytesize.to_s
-      end
-    end
-    shared_examples_for "a non-String body" do
-      it "does not set the Content-Length header in the response" do
-        subject.encode_body
-        response.headers.should_not have_key('Content-Length')
-      end
-      it "sets the Transfer-Encoding response header to chunked" do
-        subject.encode_body
-        response.headers['Transfer-Encoding'].should == 'chunked'
-      end
-    end
-    context "with an Enumerable body" do
-      before { response.body = ['one', 'two'] }
-      it "wraps the response body in an EnumerableEncoder" do
-        subject.encode_body
-        Webmachine::EnumerableEncoder.should === response.body
-      end
-      it_should_behave_like "a non-String body"
-    end
-    context "with a callable body" do
-      before { response.body = Proc.new { 'proc' } }
-      it "wraps the response body in a CallableEncoder" do
-        subject.encode_body
-        Webmachine::CallableEncoder.should === response.body
-      end
-      it_should_behave_like "a non-String body"
-    end
-    context "with a Fiber body" do
-      before { response.body = Fiber.new { Fiber.yield "foo" } }
-      it "wraps the response body in a FiberEncoder" do
-        subject.encode_body
-        Webmachine::FiberEncoder.should === response.body
-      end
-      it_should_behave_like "a non-String body"
-    end
-  end
-end

data/pkg/webmachine-0.4.0/spec/webmachine/dispatcher/route_spec.rb DELETED Viewed

@@ -1,166 +0,0 @@
-require 'spec_helper'
-describe Webmachine::Dispatcher::Route do
-  let(:method) { "GET" }
-  let(:uri) { URI.parse("http://localhost:8080/") }
-  let(:request){ Webmachine::Request.new(method, uri, Webmachine::Headers.new, "") }
-  let(:resource){ Class.new(Webmachine::Resource) }
-  matcher :match_route do |*expected|
-    route = described_class.new(expected[0], resource, expected[1] || {})
-    match do |actual|
-      request.uri.path = actual if String === actual
-      route.match?(request)
-    end
-    failure_message_for_should do |_|
-      "expected route #{expected[0].inspect} to match path #{request.uri.path}"
-    end
-    failure_message_for_should_not do |_|
-      "expected route #{expected[0].inspect} not to match path #{request.uri.path}"
-    end
-  end
-  context "matching a request" do
-    context "on the root path" do
-      subject { "/" }
-      it { should match_route([]) }
-      it { should match_route ['*'] }
-      it { should_not match_route %w{foo} }
-      it { should_not match_route [:id] }
-    end
-    context "on a deep path" do
-      subject { "/foo/bar/baz" }
-      it { should match_route %w{foo bar baz} }
-      it { should match_route ['foo', :id, "baz"] }
-      it { should match_route %w{foo *} }
-      it { should match_route [:id, '*'] }
-      it { should_not match_route [] }
-      it { should_not match_route %w{bar *} }
-    end
-    context "with a guard on the request method" do
-      let(:uri){ URI.parse("http://localhost:8080/notes") }
-      let(:route) do
-        described_class.new(
-                            ["notes"],
-                            lambda { |request| request.method == "POST" },
-                            resource
-                            )
-      end
-      subject { route }
-      context "when guard passes" do
-        let(:method){ "POST" }
-        it { should be_match(request) }
-        context "but the path match fails" do
-          let(:uri){ URI.parse("http://localhost:8080/other") }
-          it { should_not be_match(request) }
-        end
-      end
-      context "when guard fails" do
-        let(:method) { "GET" }
-        it { should_not be_match(request) }
-      end
-      context "when the guard responds to #call" do
-        let(:guard_class) do
-          Class.new do
-            def initialize(method)
-              @method = method
-            end
-            def call(request)
-              request.method == @method
-            end
-          end
-        end
-        let(:route) do
-          described_class.new(["notes"], guard_class.new("POST"), resource)
-        end
-        context "when the guard passes" do
-          let(:method){ "POST" }
-          it { should be_match(request) }
-        end
-        context "when the guard fails" do
-          # let(:method){ "GET" }
-          it { should_not be_match(request) }
-        end
-      end
-    end
-  end
-  context "applying bindings" do
-    context "on the root path" do
-      subject { described_class.new([], resource) }
-      before { subject.apply(request) }
-      it "should assign the dispatched path to the empty string" do
-        request.disp_path.should == ""
-      end
-      it "should assign empty bindings" do
-        request.path_info.should == {}
-      end
-      it "should assign empty path tokens" do
-        request.path_tokens.should == []
-      end
-      context "with extra user-defined bindings" do
-        subject { described_class.new([], resource, "bar" => "baz") }
-        it "should assign the user-defined bindings" do
-          request.path_info.should == {"bar" => "baz"}
-        end
-      end
-      context "with a splat" do
-        subject { described_class.new(['*'], resource) }
-        it "should assign empty path tokens" do
-          request.path_tokens.should == []
-        end
-      end
-    end
-    context "on a deep path" do
-      subject { described_class.new(%w{foo bar baz}, resource) }
-      before { request.uri.path = "/foo/bar/baz"; subject.apply(request) }
-      it "should assign the dispatched path as the path past the initial slash" do
-        request.disp_path.should == "foo/bar/baz"
-      end
-      it "should assign empty bindings" do
-        request.path_info.should == {}
-      end
-      it "should assign empty path tokens" do
-        request.path_tokens.should == []
-      end
-      context "with path variables" do
-        subject { described_class.new(['foo', :id, 'baz'], resource) }
-        it "should assign the path variables in the bindings" do
-          request.path_info.should == {:id => "bar"}
-        end
-      end
-      context "with a splat" do
-        subject { described_class.new(%w{foo *}, resource) }
-        it "should capture the path tokens matched by the splat" do
-          request.path_tokens.should == %w{ bar baz }
-        end
-      end
-    end
-  end
-end

data/pkg/webmachine-0.4.0/spec/webmachine/dispatcher_spec.rb DELETED Viewed

@@ -1,59 +0,0 @@
-require 'spec_helper'
-describe Webmachine::Dispatcher do
-  let(:dispatcher) { Webmachine.application.dispatcher }
-  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
-  let(:resource2) do
-    Class.new(Webmachine::Resource) do
-      def to_html; "goodbye, cruel world"; end
-    end
-  end
-  let(:fsm){ mock }
-  before { dispatcher.reset }
-  it "should add routes from a block" do
-    _resource = resource
-    Webmachine.routes do
-      add ['*'], _resource
-    end.should == Webmachine
-    dispatcher.routes.should have(1).item
-  end
-  it "should add routes" do
-    expect {
-      dispatcher.add_route ['*'], resource
-    }.should_not raise_error
-  end
-  it "should have add_route return the newly created route" do
-    route = dispatcher.add_route ['*'], resource
-    route.should be_instance_of Webmachine::Dispatcher::Route
-  end
-  it "should route to the proper resource" do
-    dispatcher.add_route ["goodbye"], resource2
-    dispatcher.add_route ['*'], resource
-    Webmachine::Decision::FSM.should_receive(:new).with(instance_of(resource), request, response).and_return(fsm)
-    fsm.should_receive(:run)
-    dispatcher.dispatch(request, response)
-  end
-  it "should add routes with guards" do
-    dispatcher.add [], lambda {|req| req.method == "POST" }, resource
-    dispatcher.add ['*'], resource2 do |req|
-      !req.query.empty?
-    end
-    request.uri.query = "?foo=bar"
-    dispatcher.routes.should have(2).items
-    Webmachine::Decision::FSM.should_receive(:new).with(instance_of(resource2), request, response).and_return(fsm)
-    fsm.should_receive(:run)
-    dispatcher.dispatch(request, response)
-  end
-end

data/pkg/webmachine-0.4.0/spec/webmachine/errors_spec.rb DELETED Viewed

@@ -1,13 +0,0 @@
-require 'spec_helper'
-describe "Webmachine errors" do
-  describe ".render_error" do
-    it "sets the given response code on the response object" do
-      req = double('request', :method => 'GET').as_null_object
-      res = Webmachine::Response.new
-      Webmachine.render_error(404, req, res)
-      res.code.should be(404)
-    end
-  end
-end

data/pkg/webmachine-0.4.0/spec/webmachine/headers_spec.rb DELETED Viewed

@@ -1,20 +0,0 @@
-require 'spec_helper'
-describe Webmachine::Headers do
-  it "should set and access values insensitive to case" do
-    subject['Content-TYPE'] = "text/plain"
-    subject['CONTENT-TYPE'].should == 'text/plain'
-    subject.delete('CoNtEnT-tYpE').should == 'text/plain'
-  end
-  context "filtering with #grep" do
-    subject { described_class["content-type" => "text/plain", "etag" => '"abcdef1234567890"'] }
-    it "should filter keys by the given pattern" do
-      subject.grep(/content/i).should include("content-type")
-    end
-    it "should return a Headers instance" do
-      subject.grep(/etag/i).should be_instance_of(described_class)
-    end
-  end
-end

data/pkg/webmachine-0.4.0/spec/webmachine/media_type_spec.rb DELETED Viewed

@@ -1,78 +0,0 @@
-require 'spec_helper'
-describe Webmachine::MediaType do
-  let(:raw_type){ "application/xml;charset=UTF-8" }
-  subject { described_class.new("application/xml", {"charset" => "UTF-8"}) }
-  context "equivalence" do
-    it { should == raw_type }
-    it { should == described_class.parse(raw_type) }
-  end
-  context "when it is the wildcard type" do
-    subject { described_class.new("*/*") }
-    it { should be_matches_all }
-  end
-  context "parsing a type" do
-    it "should return MediaTypes untouched" do
-      described_class.parse(subject).should equal(subject)
-    end
-    it "should parse a String" do
-      type = described_class.parse(raw_type)
-      type.should be_kind_of(described_class)
-      type.type.should == "application/xml"
-      type.params.should == {"charset" => "UTF-8"}
-    end
-    it "should parse a type/params pair" do
-      type = described_class.parse(["application/xml", {"charset" => "UTF-8"}])
-      type.should be_kind_of(described_class)
-      type.type.should == "application/xml"
-      type.params.should ==  {"charset" => "UTF-8"}
-    end
-    it "should parse a type/params pair where the type has some params in the string" do
-      type = described_class.parse(["application/xml;version=1",  {"charset" => "UTF-8"}])
-      type.should be_kind_of(described_class)
-      type.type.should == "application/xml"
-      type.params.should ==  {"charset" => "UTF-8", "version" => "1"}
-    end
-    it "should parse a type/params pair with params and whitespace in the string" do
-      type = described_class.parse(["multipart/form-data; boundary=----------------------------2c46a7bec2b9", {"charset" => "UTF-8"}])
-      type.should be_kind_of(described_class)
-      type.type.should == "multipart/form-data"
-      type.params.should ==  {"boundary" => "----------------------------2c46a7bec2b9", "charset" => "UTF-8"}
-    end
-    it "should raise an error when given an invalid type/params pair" do
-      expect {
-        described_class.parse([false, "blah"])
-      }.to raise_error(ArgumentError)
-    end
-  end
-  describe "matching a requested type" do
-    it { should     be_exact_match("application/xml;charset=UTF-8") }
-    it { should     be_exact_match("application/*;charset=UTF-8") }
-    it { should     be_exact_match("*/*;charset=UTF-8") }
-    it { should     be_exact_match("*;charset=UTF-8") }
-    it { should_not be_exact_match("text/xml") }
-    it { should_not be_exact_match("application/xml") }
-    it { should_not be_exact_match("application/xml;version=1") }
-    it { should     be_type_matches("application/xml") }
-    it { should     be_type_matches("application/*") }
-    it { should     be_type_matches("*/*") }
-    it { should     be_type_matches("*") }
-    it { should_not be_type_matches("text/xml") }
-    it { should_not be_type_matches("text/*") }
-    it { should     be_params_match({}) }
-    it { should     be_params_match({"charset" => "UTF-8"}) }
-    it { should_not be_params_match({"charset" => "Windows-1252"}) }
-    it { should_not be_params_match({"version" => "3"}) }
-  end
-end

data/pkg/webmachine-0.4.0/spec/webmachine/request_spec.rb DELETED Viewed

@@ -1,186 +0,0 @@
-require 'spec_helper'
-describe Webmachine::Request do
-  subject { request }
-  let(:uri)         { URI.parse("http://localhost:8080/some/resource") }
-  let(:http_method) { "GET" }
-  let(:headers)     { Webmachine::Headers.new }
-  let(:body)        { "" }
-  let(:request)     { Webmachine::Request.new(http_method, uri, headers, body) }
-  it "should provide access to the headers via brackets" do
-    subject.headers['Accept'] = "*/*"
-    subject["accept"].should == "*/*"
-  end
-  it "should provide access to the headers via underscored methods" do
-    subject.headers["Accept-Encoding"] = "identity"
-    subject.accept_encoding.should == "identity"
-    subject.content_md5.should be_nil
-  end
-  it "should calculate a base URI" do
-    subject.base_uri.should == URI.parse("http://localhost:8080/")
-  end
-  it "should provide a hash of query parameters" do
-    subject.uri.query = "foo=bar&baz=bam"
-    subject.query.should == {"foo" => "bar", "baz" => "bam"}
-  end
-  it "should treat '+' characters in query parameters as spaces" do
-    subject.uri.query = "a%20b=foo+bar&c+d=baz%20quux"
-    subject.query.should == {"a b" => "foo bar", "c d" => "baz quux"}
-  end
-  it "should handle a query parameter value of nil" do
-    subject.uri.query = nil
-    subject.query.should == {}
-  end
-  describe '#https?' do
-    subject { request.https? }
-    context "when the request was issued via HTTPS" do
-      let(:uri) { URI.parse("https://localhost.com:8080/some/resource") }
-      it { should be_true }
-    end
-    context "when the request was not issued via HTTPS" do
-      let(:uri) { URI.parse("http://localhost.com:8080/some/resource") }
-      it { should be_false }
-    end
-  end
-  describe '#get?' do
-    subject { request.get? }
-    context "when the request method is GET" do
-      let(:http_method) { "GET" }
-      it { should be_true }
-    end
-    context "when the request method is not GET" do
-      let(:http_method) { "POST" }
-      it { should be_false }
-    end
-  end
-  describe '#head?' do
-    subject { request.head? }
-    context "when the request method is HEAD" do
-      let(:http_method) { "HEAD" }
-      it { should be_true }
-    end
-    context "when the request method is not HEAD" do
-      let(:http_method) { "GET" }
-      it { should be_false }
-    end
-  end
-  describe '#post?' do
-    subject { request.post? }
-    context "when the request method is POST" do
-      let(:http_method) { "POST" }
-      it { should be_true }
-    end
-    context "when the request method is not POST" do
-      let(:http_method) { "GET" }
-      it { should be_false }
-    end
-  end
-  describe '#put?' do
-    subject { request.put? }
-    context "when the request method is PUT" do
-      let(:http_method) { "PUT" }
-      it { should be_true }
-    end
-    context "when the request method is not PUT" do
-      let(:http_method) { "GET" }
-      it { should be_false }
-    end
-  end
-  describe '#delete?' do
-    subject { request.delete? }
-    context "when the request method is DELETE" do
-      let(:http_method) { "DELETE" }
-      it { should be_true }
-    end
-    context "when the request method is not DELETE" do
-      let(:http_method) { "GET" }
-      it { should be_false }
-    end
-  end
-  describe '#trace?' do
-    subject { request.trace? }
-    context "when the request method is TRACE" do
-      let(:http_method) { "TRACE" }
-      it { should be_true }
-    end
-    context "when the request method is not TRACE" do
-      let(:http_method) { "GET" }
-      it { should be_false }
-    end
-  end
-  describe '#connect?' do
-    subject { request.connect? }
-    context "when the request method is CONNECT" do
-      let(:http_method) { "CONNECT" }
-      it { should be_true }
-    end
-    context "when the request method is not CONNECT" do
-      let(:http_method) { "GET" }
-      it { should be_false }
-    end
-  end
-  describe '#options?' do
-    subject { request.options? }
-    context "when the request method is OPTIONS" do
-      let(:http_method) { "OPTIONS" }
-      it { should be_true }
-    end
-    context "when the request method is not OPTIONS" do
-      let(:http_method) { "GET" }
-      it { should be_false }
-    end
-  end
-end