webmachine 1.6.0 → 2.0.0.beta

data/spec/webmachine/request_spec.rb

@@ -1,273 +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(:routing_tokens)  { nil }
-  let(:base_uri)        { nil }
-  let(:request)         { Webmachine::Request.new(http_method, uri, headers, body, routing_tokens, base_uri) }
-
-  it "should provide access to the headers via brackets" do
-    subject.headers['Accept'] = "*/*"
-    expect(subject["accept"]).to eq("*/*")
-  end
-
-  it "should provide access to the cookies" do
-    subject.headers['Cookie'] = 'name=value;name2=value2';
-    expect(subject.cookies).to eq({ 'name' => 'value', 'name2' => 'value2' })
-  end
-
-  it "should handle cookies with extra whitespace" do
-    subject.headers['Cookie'] = 'name = value; name2 = value2';
-    expect(subject.cookies).to eq({ 'name' => 'value', 'name2' => 'value2' })
-  end
-
-  it "should provide access to the headers via underscored methods" do
-    subject.headers["Accept-Encoding"] = "identity"
-    expect(subject.accept_encoding).to eq("identity")
-    expect(subject.content_md5).to be_nil
-  end
-
-  context "base_uri" do
-    it "should calculate a base URI" do
-      expect(subject.base_uri).to eq(URI.parse("http://localhost:8080/"))
-    end
-
-    context "when base_uri has been explicitly set" do
-      let(:base_uri) { URI.parse("http://localhost:8080/some_base_uri/here") }
-      it "should use the provided base_uri" do
-        expect(subject.base_uri).to eq(URI.parse("http://localhost:8080/some_base_uri/here"))
-      end
-    end
-  end
-
-  it "should provide a hash of query parameters" do
-    subject.uri.query = "foo=bar&baz=bam"
-    expect(subject.query).to eq({"foo" => "bar", "baz" => "bam"})
-  end
-
-  it "should handle = being encoded as a query value." do
-    subject.uri.query = "foo=bar%3D%3D"
-    expect(subject.query).to eq({ "foo" => "bar=="})
-  end
-
-  it "should treat '+' characters in query parameters as spaces" do
-    subject.uri.query = "a%20b=foo+bar&c+d=baz%20quux"
-    expect(subject.query).to eq({"a b" => "foo bar", "c d" => "baz quux"})
-  end
-
-  it "should handle a query parameter value of nil" do
-    subject.uri.query = nil
-    expect(subject.query).to eq({})
-  end
-
-  describe '#has_body?' do
-    let(:wreq) do
-      Class.new {
-        def initialize(body); @body = body; end
-        def body; block_given? ? yield(@body) : @body; end
-      }
-    end
-
-    subject { request.has_body? }
-
-    context "when body is nil" do
-      let(:body) { nil }
-
-      it { is_expected.to be(false) }
-    end
-
-    context "when body is an empty string" do
-      let(:body) { '' }
-
-      it { is_expected.to be(false) }
-    end
-
-    context "when body is not empty" do
-      let(:body) { 'foo' }
-
-      it { is_expected.to be(true) }
-    end
-
-    context "when body is an empty LazyRequestBody" do
-      let(:body) { Webmachine::Adapters::LazyRequestBody.new(wreq.new('')) }
-
-      it { is_expected.to be(false) }
-    end
-
-    context "when body is a LazyRequestBody" do
-      let(:body) { Webmachine::Adapters::LazyRequestBody.new(wreq.new('foo')) }
-
-      it { is_expected.to be(true) }
-    end
-  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 { is_expected.to be(true) }
-    end
-
-    context "when the request was not issued via HTTPS" do
-      let(:uri) { URI.parse("http://localhost.com:8080/some/resource") }
-
-      it { is_expected.to be(false) }
-    end
-  end
-
-  describe '#get?' do
-    subject { request.get? }
-
-    context "when the request method is GET" do
-      let(:http_method) { "GET" }
-
-      it { is_expected.to be(true) }
-    end
-
-    context "when the request method is not GET" do
-      let(:http_method) { "POST" }
-
-      it { is_expected.to be(false) }
-    end
-  end
-
-  describe '#head?' do
-    subject { request.head? }
-
-    context "when the request method is HEAD" do
-      let(:http_method) { "HEAD" }
-
-      it { is_expected.to be(true) }
-    end
-
-    context "when the request method is not HEAD" do
-      let(:http_method) { "GET" }
-
-      it { is_expected.to be(false) }
-    end
-  end
-
-  describe '#post?' do
-    subject { request.post? }
-
-    context "when the request method is POST" do
-      let(:http_method) { "POST" }
-
-      it { is_expected.to be(true) }
-    end
-
-    context "when the request method is not POST" do
-      let(:http_method) { "GET" }
-
-      it { is_expected.to be(false) }
-    end
-  end
-
-  describe '#put?' do
-    subject { request.put? }
-
-    context "when the request method is PUT" do
-      let(:http_method) { "PUT" }
-
-      it { is_expected.to be(true) }
-    end
-
-    context "when the request method is not PUT" do
-      let(:http_method) { "GET" }
-
-      it { is_expected.to be(false) }
-    end
-  end
-
-  describe '#delete?' do
-    subject { request.delete? }
-
-    context "when the request method is DELETE" do
-      let(:http_method) { "DELETE" }
-
-      it { is_expected.to be(true) }
-    end
-
-    context "when the request method is not DELETE" do
-      let(:http_method) { "GET" }
-
-      it { is_expected.to be(false) }
-    end
-  end
-
-  describe '#trace?' do
-    subject { request.trace? }
-
-    context "when the request method is TRACE" do
-      let(:http_method) { "TRACE" }
-
-      it { is_expected.to be(true) }
-    end
-
-    context "when the request method is not TRACE" do
-      let(:http_method) { "GET" }
-
-      it { is_expected.to be(false) }
-    end
-  end
-
-  describe '#connect?' do
-    subject { request.connect? }
-
-    context "when the request method is CONNECT" do
-      let(:http_method) { "CONNECT" }
-
-      it { is_expected.to be(true) }
-    end
-
-    context "when the request method is not CONNECT" do
-      let(:http_method) { "GET" }
-
-      it { is_expected.to be(false) }
-    end
-  end
-
-  describe '#options?' do
-    subject { request.options? }
-
-    context "when the request method is OPTIONS" do
-      let(:http_method) { "OPTIONS" }
-
-      it { is_expected.to be(true) }
-    end
-
-    context "when the request method is not OPTIONS" do
-      let(:http_method) { "GET" }
-
-      it { is_expected.to be(false) }
-    end
-  end
-
-  describe '#routing_tokens' do
-    subject { request.routing_tokens }
-
-    context "haven't been explicitly set" do
-      let(:routing_tokens) { nil }
-      it "extracts the routing tokens from the path portion of the uri" do
-        expect(subject).to eq(["some", "resource"])
-      end
-    end
-
-    context "have been explicitly set" do
-      let(:routing_tokens) { ["foo", "bar"] }
-
-      it "uses the specified routing_tokens" do
-        expect(subject).to eq(["foo", "bar"])
-      end
-    end
-
-  end
-
-end

data/spec/webmachine/rescueable_exception_spec.rb

@@ -1,15 +0,0 @@
-require 'spec_helper'
-RSpec.describe Webmachine::RescuableException do
-  before { described_class.default! }
-
-  describe ".UNRESCUABLEs" do
-    specify "returns an array of UNRESCUABLE exceptions" do
-      expect(described_class.UNRESCUABLEs).to eq(described_class::UNRESCUABLE_DEFAULTS)
-    end
-
-    specify "returns an array of UNRESCUABLE exceptions, with custom exceptions added" do
-      described_class.remove(Exception)
-      expect(described_class.UNRESCUABLEs).to eq(described_class::UNRESCUABLE_DEFAULTS.dup.concat([Exception]))
-    end
-  end
-end

data/spec/webmachine/resource/authentication_spec.rb

@@ -1,68 +0,0 @@
-require 'spec_helper'
-
-describe Webmachine::Resource::Authentication 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
-
-  describe "Basic authentication" do
-    let(:resource) do
-      resource_with do
-        include Webmachine::Resource::Authentication
-        attr_accessor :realm
-        def is_authorized?(auth)
-          basic_auth(auth, @realm || "Webmachine") {|u,p| u == "webmachine" && p == "http" }
-        end
-      end
-    end
-
-    context "when no authorization is sent by the client" do
-      it "should reply with a 401 Unauthorized and a WWW-Authenticate header using Basic" do
-        subject.run
-        expect(response.code).to eq(401)
-        expect(response.headers['WWW-Authenticate']).to eq('Basic realm="Webmachine"')
-      end
-
-      it "should use the specified realm in the WWW-Authenticate header" do
-        resource.realm = "My App"
-        subject.run
-        expect(response.headers['WWW-Authenticate']).to eq('Basic realm="My App"')
-      end
-    end
-
-    context "when the client sends invalid authorization" do
-      before do
-        headers['Authorization'] = "Basic " + ["invalid:auth"].pack('m*').chomp
-      end
-
-      it "should reply with a 401 Unauthorized and a WWW-Authenticate header using Basic" do
-        subject.run
-        expect(response.code).to eq(401)
-        expect(response.headers['WWW-Authenticate']).to eq('Basic realm="Webmachine"')
-      end
-    end
-
-    context "when the client sends valid authorization" do
-      before do
-        headers['Authorization'] = "Basic " + ["webmachine:http"].pack('m*').chomp
-      end
-
-      it "should not reply with 401 Unauthorized" do
-        subject.run
-        expect(response.code).not_to eq(401)
-      end
-    end
-  end
-end

data/spec/webmachine/response_spec.rb

@@ -1,51 +0,0 @@
-require 'spec_helper'
-
-describe Webmachine::Response do
-
-  it "should have sane default values" do
-    expect(subject.code).to eq(200)
-    expect(subject.is_redirect?).to be(false)
-    expect(subject.headers).to be_empty
-  end
-
-  describe "a redirected response" do
-    let(:redirect_url) { "/" }
-
-    before(:each) { subject.redirect_to redirect_url }
-
-    its(:is_redirect?) { should be(true) }
-
-    it "should have a proper Location header" do
-      expect(subject.headers["Location"]).to eq(redirect_url)
-    end
-  end
-
-  describe "setting a cookie" do
-    let(:cookie) { "monster" }
-    let(:cookie_value) { "mash" }
-
-    before(:each) { subject.set_cookie(cookie, cookie_value) }
-
-    it "should have a proper Set-Cookie header" do
-      expect(subject.headers["Set-Cookie"]).to include "monster=mash"
-    end
-
-    describe "setting multiple cookies" do
-      let(:cookie2) { "rodeo" }
-      let(:cookie2_value) { "clown" }
-      let(:cookie3) {"color"}
-      let(:cookie3_value) {"blue"}
-      before(:each) do 
-        subject.set_cookie(cookie2, cookie2_value)
-        subject.set_cookie(cookie3, cookie3_value)
-      end
-
-      it "should have a proper Set-Cookie header" do
-        expect(subject.headers["Set-Cookie"]).to be_a Array
-        expect(subject.headers["Set-Cookie"]).to include "rodeo=clown"
-        expect(subject.headers["Set-Cookie"]).to include "monster=mash"
-        expect(subject.headers["Set-Cookie"]).to include "color=blue"
-      end
-    end
-  end
-end

data/spec/webmachine/trace/fsm_spec.rb

@@ -1,37 +0,0 @@
-require 'spec_helper'
-
-describe Webmachine::Trace::FSM do
-  include_context "default resource"
-
-  subject { Webmachine::Decision::FSM.new(resource, request, response) }
-  before { Webmachine::Trace.trace_store = :memory }
-
-  context "when tracing is enabled" do
-    before { allow(Webmachine::Trace).to receive(:trace?).and_return(true) }
-
-    it "proxies the resource" do
-      expect(subject.resource).to be_kind_of(Webmachine::Trace::ResourceProxy)
-    end
-
-    it "records a trace" do
-      subject.run
-      expect(response.trace).to_not be_empty
-      expect(Webmachine::Trace.traces.size).to eq(1)
-    end
-
-    it "commits the trace to separate storage when the request has finished processing" do
-      expect(Webmachine::Trace).to receive(:record).with(subject.resource.object_id.to_s, response.trace).and_return(true)
-      subject.run
-    end
-  end
-
-  context "when tracing is disabled" do
-    before { allow(Webmachine::Trace).to receive(:trace?).and_return(false) }
-
-    it "leaves no trace" do
-      subject.run
-      expect(response.trace).to be_empty
-      expect(Webmachine::Trace.traces).to be_empty
-    end
-  end
-end

data/spec/webmachine/trace/resource_proxy_spec.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-require 'webmachine/trace/resource_proxy'
-
-describe Webmachine::Trace::ResourceProxy do
-  include_context "default resource"
-  subject { described_class.new(resource) }
-
-  it "duck-types all callback methods" do
-    Webmachine::Resource::Callbacks.instance_methods(false).each do |m|
-      expect(subject).to respond_to(m)
-    end
-  end
-
-  it "logs invocations of callbacks" do
-    subject.generate_etag
-    expect(response.trace).to eq([{:type => :attempt, :name => "(default)#generate_etag"},
-                              {:type => :result, :value => nil}])
-
-  end
-
-  it "logs invocations of body-producing methods" do
-    expect(subject.content_types_provided).to eq([["text/html", :to_html]])
-    subject.to_html
-    expect(response.trace[-2][:type]).to eq(:attempt)
-    expect(response.trace[-2][:name]).to match(/to_html$/)
-    expect(response.trace[-2][:source]).to include("spec_helper.rb") if response.trace[-2][:source]
-    expect(response.trace[-1]).to eq({:type => :result, :value => "<html><body>Hello, world!</body></html>"})
-  end
-
-  it "sets the trace id header when the request has finished processing" do
-    subject.finish_request
-    expect(response.headers["X-Webmachine-Trace-Id"]).to eq(subject.object_id.to_s)
-  end
-end

data/spec/webmachine/trace/trace_store_spec.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-require 'fileutils'
-
-shared_examples_for "trace storage" do
-  it { is_expected.to respond_to(:[]=) }
-  it { is_expected.to respond_to(:keys) }
-  it { is_expected.to respond_to(:fetch) }
-
-  it "stores a trace" do
-    subject["foo"] = [:bar]
-    expect(subject.fetch("foo")).to eq([:bar])
-  end
-
-  it "lists a stored trace in the keys" do
-    subject["foo"] = [:bar]
-    expect(subject.keys).to eq(["foo"])
-  end
-end
-
-describe Webmachine::Trace::PStoreTraceStore do
-  subject { described_class.new("./wmtrace") }
-  after { FileUtils.rm_rf("./wmtrace") }
-  it_behaves_like "trace storage"
-end
-
-describe "Webmachine::Trace :memory Trace Store (Hash)" do
-  subject { Hash.new }
-  it_behaves_like "trace storage"
-end

data/spec/webmachine/trace_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-
-describe Webmachine::Trace do
-  subject { described_class }
-
-  context "determining whether the resource should be traced" do
-    include_context "default resource"
-    it "does not trace by default" do
-      expect(subject.trace?(resource)).to be(false)
-    end
-
-    it "traces when the resource enables tracing" do
-      expect(resource).to receive(:trace?).and_return(true)
-      expect(subject.trace?(resource)).to be(true)
-    end
-  end
-end

data/webmachine.gemspec

@@ -1,25 +0,0 @@
-$:.push File.expand_path("../lib", __FILE__)
-require 'webmachine/version'
-
-Gem::Specification.new do |gem|
-  gem.name = "webmachine"
-  gem.version = Webmachine::VERSION
-  gem.summary = %Q{webmachine is a toolkit for building HTTP applications,}
-  gem.description = <<-DESC.gsub(/\s+/, ' ')
-    webmachine is a toolkit for building HTTP applications in a declarative fashion, that avoids
-    the confusion of going through a CGI-style interface like Rack. It is strongly influenced
-    by the original Erlang project of the same name and shares its opinionated nature about HTTP.
-  DESC
-  gem.homepage = "http://github.com/seancribbs/webmachine-ruby"
-  gem.authors = ["Sean Cribbs"]
-  gem.email = ["sean@basho.com"]
-  gem.license = "Apache-2.0"
-
-  gem.add_runtime_dependency(%q<i18n>, [">= 0.4.0"])
-  gem.add_runtime_dependency(%q<multi_json>)
-  gem.add_runtime_dependency(%q<as-notifications>, ["~> 1.0"])
-
-  ignores = File.read(".gitignore").split(/\r?\n/).reject{ |f| f =~ /^(#.+|\s*)$/ }.map {|f| Dir[f] }.flatten
-  gem.files = (Dir['**/*','.gitignore'] - ignores).reject {|f| !File.file?(f) }
-  gem.test_files = (Dir['spec/**/*','features/**/*','.gitignore'] - ignores).reject {|f| !File.file?(f) }
-end