webmachine 1.6.0 → 2.0.0.beta

data/spec/webmachine/decision/fsm_spec.rb

@@ -1,163 +0,0 @@
-require 'spec_helper'
-
-describe Webmachine::Decision::FSM do
-  include_context 'default resource'
-
-  subject { described_class.new(resource, request, response) }
-
-  let(:run_with_exception) do
-    begin
-      subject.run
-    rescue Exception
-    end
-  end
-
-  describe 'handling of exceptions from decision methods' do
-    let(:UNRESCUABLE_exceptions) do
-      Webmachine::RescuableException::UNRESCUABLE
-    end
-
-    describe "rescueable exceptions" do
-      it 'does rescue Exception' do
-        allow(subject).to receive(Webmachine::Decision::Flow::START) { raise(Exception) }
-        expect(resource).to receive(:handle_exception).with instance_of(Exception)
-        expect { subject.run }.to_not raise_error
-      end
-
-      it 'does rescue a failed require' do
-        allow(subject).to receive(Webmachine::Decision::Flow::START) { require 'laterequire' }
-        expect(resource).to receive(:handle_exception).with instance_of(LoadError)
-        expect { subject.run }.to_not raise_error
-      end
-    end
-
-    describe "UNRESCUABLE exceptions"  do
-      shared_examples "UNRESCUABLE" do |e|
-        specify "#{e} is not rescued" do
-          allow(subject).to receive(Webmachine::Decision::Flow::START) {raise(e)}
-          expect(resource).to_not receive(:handle_exception).with instance_of(e)
-          expect { subject.run }.to raise_error(e)
-        end
-      end
-      eary = Webmachine::RescuableException::UNRESCUABLE_DEFAULTS - [
-        Webmachine::MalformedRequest, # Webmachine rescues by default, so it won't re-raise.
-        SignalException # Requires raise in form 'raise SignalException, "SIGSOMESIGNAL"'.
-                        # Haven't found a good no-op signal to use here.
-      ]
-      eary.each{|e| include_examples "UNRESCUABLE", e}
-    end
-  end
-
-  describe 'handling of errors from decision methods' do
-    let(:error) { RuntimeError.new }
-
-    before do
-      allow(subject).to receive(Webmachine::Decision::Flow::START) { raise error }
-    end
-
-    it 'calls resource.handle_exception' do
-      expect(resource).to receive(:handle_exception).with(error)
-      subject.run
-    end
-
-    it 'calls resource.finish_request' do
-      expect(resource).to receive(:finish_request)
-      subject.run
-    end
-  end
-
-  describe 'handling of errors from resource.handle_exception' do
-    let(:error) { RuntimeError.new('an error message') }
-
-    before do
-      allow(subject).to receive(Webmachine::Decision::Flow::START) { raise }
-      allow(resource).to receive(:handle_exception) { raise error }
-    end
-
-    it 'does not call resource.handle_exception again' do
-      expect(resource).to receive(:handle_exception).once { raise }
-      subject.run
-    end
-
-    it 'does not call resource.finish_request' do
-      expect(resource).not_to receive(:finish_request)
-      subject.run
-    end
-
-    it 'renders an error' do
-      expect(Webmachine).
-        to receive(:render_error).
-        with(500, request, response, { :message => error.message })
-      subject.run
-    end
-  end
-
-  describe 'handling of exceptions from resource.finish_request' do
-    let(:exception) { Class.new(Exception).new }
-
-    before do
-      Webmachine::RescuableException.remove(exception)
-      allow(resource).to receive(:finish_request) { raise exception }
-    end
-
-    it 'does not call resource.handle_exception' do
-      expect(resource).to_not receive(:handle_exception)
-      run_with_exception
-    end
-
-    it 'does not call resource.finish_request again' do
-      expect(resource).to receive(:finish_request).once
-      run_with_exception
-    end
-  end
-
-  describe 'handling of errors from resource.finish_request' do
-    let(:error) { RuntimeError.new }
-
-    before do
-      allow(resource).to receive(:finish_request) { raise error }
-    end
-
-    it 'calls resource.handle_exception' do
-      expect(resource).to receive(:handle_exception).with(error)
-      subject.run
-    end
-
-    it 'does not call resource.finish_request again' do
-      expect(resource).to receive(:finish_request).once { raise }
-      subject.run
-    end
-  end
-
-  it "sets the response code before calling finish_request" do
-    resource_class.class_eval do
-      class << self
-        attr_accessor :current_response_code
-      end
-
-      def to_html
-        201
-      end
-
-      def finish_request
-        self.class.current_response_code = response.code
-      end
-    end
-
-    subject.run
-
-    expect(resource_class.current_response_code).to be(201)
-  end
-
-  it 'respects a response code set by resource.finish_request' do
-    resource_class.class_eval do
-      def finish_request
-        response.code = 451
-      end
-    end
-
-    subject.run
-
-    expect(response.code).to be(451)
-  end
-end

data/spec/webmachine/decision/helpers_spec.rb

@@ -1,216 +0,0 @@
-require 'spec_helper'
-
-describe Webmachine::Decision::Helpers do
-  include_context "default resource"
-  subject { Webmachine::Decision::FSM.new(resource, request, response) }
-
-  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
-      expect(subject.accept_helper).to eq 415
-    end
-
-    it "should return 415 when the posted type is not acceptable" do
-      resource.accepted = %W{application/json}
-      headers['Content-Type'] = "text/xml"
-      expect(subject.accept_helper).to eq 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]]
-      expect(resource).to receive(:other).and_return(true)
-      headers['Content-Type'] = 'application/json;v=2'
-      expect(subject.accept_helper).to be(true)
-    end
-  end
-
-  context "setting the Content-Length header when responding" do
-    [204, 205, 304].each do |code|
-      it "removes the header for entity-less response code #{code}" do
-        response.headers['Content-Length'] = '0'
-        response.body = nil
-        subject.send :respond, code
-        expect(response.headers).to_not include 'Content-Length'
-      end
-    end
-
-    (200..599).each do |code|
-      # 204, 205 and 304 have no bodies, 404 is set to a default
-      # non-zero response by Webmachine
-      next if [204, 205, 304, 404].include? code
-
-      it "adds the header for response code #{code} that should include an entity but has an empty body" do
-        response.code = code
-        response.body = nil
-        subject.send :respond, code
-        expect(response.headers['Content-Length']).to eq '0'
-      end
-    end
-
-    (200..599).each do |code|
-      next if [204, 205, 304].include? code
-
-      it "does not add the header when Transfer-Encoding is set on code #{code}" do
-        response.headers['Transfer-Encoding'] = 'chunked'
-        response.body = []
-        subject.send :respond, code
-        expect(response.headers).to_not include 'Content-Length'
-      end
-    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
-        expect(response.body).to be_instance_of(String)
-      end
-
-      it "sets the Content-Length header in the response" do
-        subject.encode_body
-        expect(response.headers['Content-Length']).to eq 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
-        expect(response.headers).to_not have_key('Content-Length')
-      end
-
-      it "sets the Transfer-Encoding response header to chunked" do
-        subject.encode_body
-        expect(response.headers['Transfer-Encoding']).to eq '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
-        expect(response.body).to be_instance_of(Webmachine::Streaming::EnumerableEncoder)
-      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
-        expect(response.body).to be_instance_of(Webmachine::Streaming::CallableEncoder)
-      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
-        expect(response.body).to be_instance_of(Webmachine::Streaming::FiberEncoder)
-      end
-
-      it_should_behave_like "a non-String body"
-    end
-
-    context "with a File body" do
-      before { response.body = File.open("spec/spec_helper.rb", "r") }
-
-      it "wraps the response body in an IOEncoder" do
-        subject.encode_body
-        expect(response.body).to be_instance_of(Webmachine::Streaming::IOEncoder)
-      end
-
-      it "sets the Content-Length header to the size of the file" do
-        subject.encode_body
-        expect(response.headers['Content-Length']).to eq File.stat('spec/spec_helper.rb').size.to_s
-      end
-
-      it "progressively yields file contents for each enumeration" do
-        subject.encode_body
-        body_size = 0
-        response.body.each do |chunk|
-          expect(chunk).to be_instance_of(String)
-          body_size += chunk.length
-        end
-        expect(body_size).to eq File.stat('spec/spec_helper.rb').size
-      end
-
-      context "when the resource provides a non-identity encoding that the client accepts" do
-        let(:resource) do
-          resource_with do
-            def encodings_provided
-              { "deflate" => :encode_deflate, "identity" => :encode_identity }
-            end
-          end
-        end
-
-        let(:headers) do
-          Webmachine::Headers.new({"Accept-Encoding" => "deflate, identity"})
-        end
-
-        it_should_behave_like "a non-String body"
-      end
-    end
-
-    context "with a StringIO body" do
-      before { response.body = StringIO.new("A VERY LONG STRING, NOT") }
-
-      it "wraps the response body in an IOEncoder" do
-        subject.encode_body
-        expect(response.body).to be_instance_of(Webmachine::Streaming::IOEncoder)
-      end
-
-      it "sets the Content-Length header to the size of the string" do
-        subject.encode_body
-        expect(response.headers['Content-Length']).to eq response.body.size.to_s
-      end
-
-      context "when the resource provides a non-identity encoding that the client accepts" do
-        let(:resource) do
-          resource_with do
-            def encodings_provided
-              { "deflate" => :encode_deflate, "identity" => :encode_identity }
-            end
-          end
-        end
-
-        let(:headers) do
-          Webmachine::Headers.new({"Accept-Encoding" => "deflate, identity"})
-        end
-
-        it_should_behave_like "a non-String body"
-      end
-    end
-  end
-end

data/spec/webmachine/dispatcher/rfc3986_percent_decode_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-describe Webmachine::Dispatcher::Route do
-  describe '#rfc3986_percent_decode' do
-    def call_subject(value)
-      Webmachine::Dispatcher::Route.rfc3986_percent_decode(value)
-    end
-
-    it 'does not change un-encoded strings' do
-      expect(call_subject('this is a normal string, I think')).to eq 'this is a normal string, I think'
-      expect(call_subject('')).to eq ''
-    end
-
-    it 'decodes percent encoded sequences' do
-      expect(call_subject('/tenants/esckimo+test%20%65')).to eq '/tenants/esckimo+test e'
-    end
-
-    it 'leaves incorrectly encoded sequences as is' do
-      expect(call_subject('/tenants/esckimo+test%2%65')).to eq '/tenants/esckimo+test%2e'
-    end
-  end
-end

data/spec/webmachine/dispatcher/route_spec.rb

@@ -1,248 +0,0 @@
-require 'spec_helper'
-
-Webmachine::Dispatcher::Route.class_eval do
-  def warn(*msgs); end # silence warnings for tests
-end
-
-describe Webmachine::Dispatcher::Route do
-  let(:method) { "GET" }
-  let(:uri) { URI.parse("http://localhost:8080/") }
-  let(:routing_tokens) { nil }
-  let(:request){ Webmachine::Request.new(method, uri, Webmachine::Headers.new, "", routing_tokens) }
-  let(:resource){ Class.new(Webmachine::Resource) }
-
-  describe '#apply' do
-    let(:route) {
-      Webmachine::Dispatcher::Route.new ['hello', :string], resource, {}
-    }
-
-    describe 'a path_info fragment' do
-      let(:uri) { URI.parse("http://localhost:8080/hello/planet%20earth%20++") }
-
-      it 'should decode the value' do
-        route.apply(request)
-        expect(request.path_info).to eq({:string => 'planet earth ++'})
-      end
-    end
-  end
-
-  matcher :match_route do |*expected|
-    route = Webmachine::Dispatcher::Route.new(expected[0], Class.new(Webmachine::Resource), expected[1] || {})
-    match do |actual|
-      uri = URI.parse("http://localhost:8080")
-      uri.path = actual
-      req = Webmachine::Request.new("GET", uri, Webmachine::Headers.new, "", routing_tokens)
-      route.match?(req)
-    end
-
-    failure_message do |_|
-      "expected route #{expected[0].inspect} to match path #{request.uri.path}"
-    end
-    failure_message_when_negated do |_|
-      "expected route #{expected[0].inspect} not to match path #{request.uri.path}"
-    end
-  end
-
-  it "warns about the deprecated string splat when initializing" do
-    [["*"],["foo", "*"],["foo", :bar, "*"]].each do |path|
-      route = described_class.allocate
-      expect(route).to receive(:warn)
-      route.send :initialize, path, resource, {}
-    end
-  end
-
-  context "matching a request" do
-    context "on the root path" do
-      subject { "/" }
-      it { is_expected.to match_route([]) }
-      it { is_expected.to match_route ['*'] }
-      it { is_expected.to match_route [:*] }
-      it { is_expected.not_to match_route %w{foo} }
-      it { is_expected.not_to match_route [:id] }
-    end
-
-    context "on a deep path" do
-      subject { "/foo/bar/baz" }
-      it { is_expected.to match_route %w{foo bar baz} }
-      it { is_expected.to match_route ['foo', :id, "baz"] }
-      it { is_expected.to match_route ['foo', :*] }
-      it { is_expected.to match_route [:id, :*] }
-      it { is_expected.not_to match_route [] }
-      it { is_expected.not_to match_route ['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 { is_expected.to be_match(request) }
-
-        context "but the path match fails" do
-          let(:uri){ URI.parse("http://localhost:8080/other") }
-          it { is_expected.not_to be_match(request) }
-        end
-      end
-
-      context "when guard fails" do
-        let(:method) { "GET" }
-        it { is_expected.not_to 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 { is_expected.to be_match(request) }
-        end
-
-        context "when the guard fails" do
-          # let(:method){ "GET" }
-          it { is_expected.not_to be_match(request) }
-        end
-      end
-    end
-
-    context "with a request with explicitly specified routing tokens" do
-      subject { "/some/route/foo/bar" }
-      let(:routing_tokens) { ["foo", "bar"] }
-      it { is_expected.to match_route(["foo", "bar"]) }
-      it { is_expected.to match_route(["foo", :id]) }
-      it { is_expected.to match_route ['*'] }
-      it { is_expected.to match_route [:*] }
-      it { is_expected.not_to match_route(["some", "route", "foo", "bar"]) }
-      it { is_expected.not_to match_route %w{foo} }
-      it { is_expected.not_to match_route [:id] }
-    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
-        expect(request.disp_path).to eq("")
-      end
-
-      it "should assign empty bindings" do
-        expect(request.path_info).to eq({})
-      end
-
-      it "should assign empty path tokens" do
-        expect(request.path_tokens).to eq([])
-      end
-
-      context "with extra user-defined bindings" do
-        subject { described_class.new([], resource, "bar" => "baz") }
-
-        it "should assign the user-defined bindings" do
-          expect(request.path_info).to eq({"bar" => "baz"})
-        end
-      end
-
-      context "with a splat" do
-        subject { described_class.new([:*], resource) }
-
-        it "should assign empty path tokens" do
-          expect(request.path_tokens).to eq([])
-        end
-      end
-
-      context "with a deprecated splat string" do
-        subject { described_class.new(['*'], resource) }
-
-        it "should assign empty path tokens" do
-          expect(request.path_tokens).to eq([])
-        end
-      end
-    end
-    context "on a deep path" do
-      subject { described_class.new(%w{foo bar baz}, resource) }
-      let(:uri) { URI.parse("http://localhost:8080/foo/bar/baz") }
-      before { subject.apply(request) }
-
-      it "should assign the dispatched path as the path past the initial slash" do
-        expect(request.disp_path).to eq("foo/bar/baz")
-      end
-
-      it "should assign empty bindings" do
-        expect(request.path_info).to eq({})
-      end
-
-      it "should assign empty path tokens" do
-        expect(request.path_tokens).to eq([])
-      end
-
-      context "with path variables" do
-        subject { described_class.new(['foo', :id, 'baz'], resource) }
-
-        it "should assign the path variables in the bindings" do
-          expect(request.path_info).to eq({:id => "bar"})
-        end
-      end
-      context "with regex" do
-        subject { described_class.new([/foo/, /(.*)/, 'baz'], resource) }
-
-        it "should assign the captures path variables" do
-          expect(request.path_info).to eq({:captures => ["bar"]})
-        end
-      end
-      context "with multi-capture regex" do
-        subject { described_class.new([/foo/, /(.*)/, /baz\.(.*)/], resource) }
-        let(:uri) { URI.parse("http://localhost:8080/foo/bar/baz.json") }
-
-        it "should assign the captures path variables" do
-          expect(request.path_info).to eq({:captures => ["bar", "json"]})
-        end
-      end
-      context "with named capture regex" do
-        subject { described_class.new(['foo', :bar, /(?<baz>[^.]+)\.(?<format>.*)/], resource) }
-        let(:uri) { URI.parse("http://localhost:8080/foo/bar/baz.json") }
-
-        it "should assign the captures path variables" do
-          expect(request.path_info).to eq({bar: 'bar', baz: 'baz', format: "json"})
-        end
-      end
-
-      context "with a splat" do
-        subject { described_class.new(['foo', :*], resource) }
-
-        it "should capture the path tokens matched by the splat" do
-          expect(request.path_tokens).to eq(%w{ bar baz })
-        end
-      end
-
-      context "with a deprecated splat string" do
-        subject { described_class.new(%w{foo *}, resource) }
-
-        it "should capture the path tokens matched by the splat" do
-          expect(request.path_tokens).to eq(%w{ bar baz })
-        end
-      end
-    end
-  end
-end