webmachine 0.1.0 → 0.2.0

data/pkg/webmachine-0.1.0/spec/webmachine/dispatcher/route_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+
+describe Webmachine::Dispatcher::Route do
+  let(:request){ Webmachine::Request.new("GET", URI.parse("http://localhost:8098/"), 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
+  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.1.0/spec/webmachine/dispatcher_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Webmachine::Dispatcher do
+  let(:dispatcher) { described_class }
+  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" do
+    expect {
+      dispatcher.add_route ['*'], resource
+    }.should_not raise_error
+  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
+end

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

@@ -0,0 +1,19 @@
+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'
+  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.1.0/spec/webmachine/request_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Webmachine::Request do
+  subject { Webmachine::Request.new("GET", URI.parse("http://localhost:8080/some/resource"), Webmachine::Headers.new, "") }
+  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
+end

data/pkg/webmachine-0.1.0/webmachine.gemspec

@@ -0,0 +1,44 @@
+$:.push File.expand_path("../lib", __FILE__)
+require 'webmachine/version'
+
+Gem::Specification.new do |gem|
+  gem.name = "webmachine"
+  gem.version = Webmachine::VERSION
+  gem.date = File.mtime("lib/webmachine/version.rb")
+  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"]
+
+  if gem.respond_to? :specification_version then
+    gem.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      gem.add_runtime_dependency(%q<i18n>, [">= 0.4.0"])
+      gem.add_development_dependency(%q<rspec>, ["~> 2.6.0"])
+      gem.add_development_dependency(%q<yard>, ["~> 0.6.7"])
+      gem.add_development_dependency(%q<rake>)
+    else
+      gem.add_dependency(%q<i18n>, [">= 0.4.0"])
+      gem.add_dependency(%q<rspec>, ["~> 2.6.0"])
+      gem.add_dependency(%q<yard>, ["~> 0.6.7"])
+      gem.add_dependency(%q<rake>)
+    end
+  else
+    gem.add_dependency(%q<i18n>, [">= 0.4.0"])
+    gem.add_dependency(%q<rspec>, ["~> 2.6.0"])
+    gem.add_dependency(%q<yard>, ["~> 0.6.7"])
+    gem.add_dependency(%q<rake>)
+  end
+
+  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) }
+  gem.executables   = Dir['bin/*'].map { |f| File.basename(f) }
+  gem.require_paths = ['lib']
+end

data/spec/webmachine/configuration_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Webmachine::Configuration do
+  before { Webmachine.configuration = nil }
+  
+  %w{ip port adapter adapter_options}.each do |field|
+    it { should respond_to(field) }
+    it { should respond_to("#{field}=") }
+  end
+
+  it "should yield configuration to the block" do
+    Webmachine.configure do |config|
+      config.should be_kind_of(described_class)
+    end
+  end
+
+  it "should set the global configuration from the yielded instance" do
+    Webmachine.configure do |config|
+      @config = config
+    end
+    @config.should == Webmachine.configuration
+  end
+
+  it "should return the module from the configure call so you can chain it" do
+    Webmachine.configure {|c|}.should == Webmachine
+  end
+end

data/spec/webmachine/decision/conneg_spec.rb

@@ -8,36 +8,43 @@ describe Webmachine::Decision::Conneg 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      
+      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 a type more specific than requested when an exact match is not present" do
+      subject.choose_media_type(["application/json;v=3;foo=bar", "application/json;v=2"],
+                                "text/html, application/json").
+        should == "application/json;v=3;foo=bar"
+    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
@@ -112,17 +119,17 @@ describe Webmachine::Decision::Conneg 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"      
+      response.headers['Content-Language'].should == "es"
     end
 
     it "should select the first language if all are acceptable" do
@@ -130,13 +137,13 @@ describe Webmachine::Decision::Conneg do
       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

data/spec/webmachine/decision/flow_spec.rb

@@ -309,6 +309,7 @@ describe Webmachine::Decision::Flow do
         subject.run
         response.code.should_not == 406
         response.headers['Content-Language'].should == "en-US"
+        resource.instance_variable_get(:@language).should == 'en-US'
       end
     end
 
@@ -318,6 +319,7 @@ describe Webmachine::Decision::Flow do
         subject.should_not_receive(:d5)
         subject.run
         response.headers['Content-Language'].should == 'en-US'
+        resource.instance_variable_get(:@language).should == 'en-US'
       end
     end
   end

data/spec/webmachine/decision/helpers_spec.rb

@@ -0,0 +1,105 @@
+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
+  end
+end