waves 0.8.2 → 0.9.0

data/test/match/request.rb

@@ -0,0 +1,91 @@
+require "#{File.dirname(__FILE__)}/../../test/helpers.rb"
+require "test/helpers.rb"
+
+require "waves/foundations/compact"
+require "waves/matchers/request"
+
+describe "Top-level request matcher" do
+  before do
+    Test = Module.new { include Waves::Foundations::Compact }
+    Waves << Test
+  end
+
+  after do
+    Waves.applications.clear
+    Object.instance_eval { remove_const(:Test) if const_defined?(:Test) }
+  end
+
+  # @todo Change these to mocks to ensure we really are dealing
+  #       with a non-constructed URI matcher.
+
+  feature "matches any URI, returning {}, if URI matcher omitted" do
+    m = Waves::Matchers::Request.new  :path => nil,
+                                      :host => nil,
+                                      :port => nil,
+                                      :scheme => nil
+
+    request = Waves::Request.new env("http://example.com/moo",
+                                     :method => "GET",
+                                     "HTTP_ACCEPT" => "text/html")
+    m.call(request).should == {}
+
+    request = Waves::Request.new env("http://example2.com/moo",
+                                     :method => "GET",
+                                     "HTTP_ACCEPT" => "text/html")
+    m.call(request).should == {}
+
+    request = Waves::Request.new env("http://example2.com:8008/moo",
+                                     :method => "GET",
+                                     "HTTP_ACCEPT" => "text/html")
+    m.call(request).should == {}
+  end
+
+  feature "omits Accept constraints if none given" do
+    Waves::Matchers::Request.new({}).constraints.has_key?(:accept).should == false
+  end
+
+  feature "omits Ext constraints if none given" do
+    Waves::Matchers::Request.new({}).constraints.has_key?(:ext).should == false
+    Waves::Matchers::Request.new({}).constraints.has_key?(:extension).should == false
+  end
+
+  feature "omits Query constraints if none given" do
+    Waves::Matchers::Request.new({}).constraints.has_key?(:query).should == false
+  end
+
+  feature "omits Traits constraints if none given" do
+    Waves::Matchers::Request.new({}).constraints.has_key?(:traits).should == false
+  end
+
+  feature "returns captured values when matched" do
+    m = Waves::Matchers::Request.new  :path => [:something],
+                                      :host => nil,
+                                      :port => nil,
+                                      :scheme => nil
+
+    request = Waves::Request.new env("http://example.com/moo",
+                                     :method => "GET",
+                                     "HTTP_ACCEPT" => "text/html")
+
+    res = m.call request
+    res.kind_of?(Hash).should == true
+    res.size.should == 1
+    res.has_key?(:something).should == true
+  end
+
+  feature "sets the captured trait to return value when matched" do
+    m = Waves::Matchers::Request.new  :path => [:something],
+                                      :host => nil,
+                                      :port => nil,
+                                      :scheme => nil
+
+    request = Waves::Request.new env("http://example.com/moo",
+                                     :method => "GET",
+                                     "HTTP_ACCEPT" => "text/html")
+
+    res = m.call request
+    request.traits.waves.captured.something.should == res[:something]
+  end
+
+end
+

data/test/match/requested.rb

@@ -0,0 +1,149 @@
+require "#{File.dirname(__FILE__)}/../../test/helpers.rb"
+require 'test/helpers.rb'
+
+require 'waves/foundations/compact'
+require "waves/runtime/mime_types"
+
+describe "Requested header matching" do
+  before do
+    Test = Module.new { include Waves::Foundations::Compact }
+    Waves << Test
+  end
+
+  after do
+    Waves.applications.clear
+    Object.instance_eval { remove_const(:Test) if const_defined?(:Test) }
+  end
+
+  feature "matches correct MIME given as a file extension" do
+    Test::Resources::Map.on(:get, ["foo"], :requested => "text/javascript") { }
+
+    resp = get "/foo.js"
+    resp.status.should == 200
+  end
+
+  feature "matches correct MIME given in the Requested header" do
+    Test::Resources::Map.on(:get,
+                            ["foo"],
+                            :requested => "text/javascript") { }
+
+    resp = get "/foo", "HTTP_ACCEPT" => "text/javascript"
+    resp.status.should == 200
+  end
+
+  feature "allows both a file extension and Requested" do
+    Test::Resources::Map.on(:get,
+                            ["foo"],
+                            :requested => "text/javascript") { }
+
+    resp = get "/foo.js", "HTTP_ACCEPT" => "text/javascript"
+    resp.status.should == 200
+  end
+
+  feature "prefers a present file extension over any Requested" do
+    # note that the order matters here: LIFO, just as tho we were using #define_method
+    Test::Resources::Map.on(:get, ["foo"], :requested => "image/png") { "png" }
+    Test::Resources::Map.on(:get, ["foo"], :requested => "text/javascript") { "js" }
+    Test::Resources::Map.on(:get, ["foo"], :requested => "text/x-fortran") { "fortran" }
+
+    resp = get "/foo.f90", "HTTP_ACCEPT" => "text/javascript"
+    resp.status.should == 200
+    resp.body.should == "fortran"
+
+    resp = get "/foo.f90", "HTTP_ACCEPT" => "image/png"
+    resp.status.should == 200
+    resp.body.should == "fortran"
+  end
+
+
+  feature "does not match for absent extension by default" do
+    Test::Resources::Map.on(:get,
+                            ["foo"],
+                            :requested => "text/html") {
+      "undefined"
+    }
+
+    resp = get "/foo", {"HTTP_ACCEPT" => "text/javascript"}
+    resp.status.should == 404
+  end
+
+  feature "matches single type Strings or Symbols against general MIME types" do
+    Test::Resources::Map.on(:get, ["foo"], :requested => "image") { }
+    Test::Resources::Map.on(:get, ["bar"], :requested => :image) { }
+
+    resp = get "/foo", "HTTP_ACCEPT" => "image/png"
+    resp.status.should == 200
+
+    resp = get "/bar", "HTTP_ACCEPT" => "image/png"
+    resp.status.should == 200
+  end
+
+  feature "matches single type Strings or Symbols against MIME subtypes" do
+    Test::Resources::Map.on(:get, ["foo"], :requested => "png") { }
+    Test::Resources::Map.on(:get, ["bar"], :requested => :png) { }
+
+    resp = get "/foo", "HTTP_ACCEPT" => "image/png"
+    resp.status.should == 200
+
+    resp = get "/bar", "HTTP_ACCEPT" => "image/png"
+    resp.status.should == 200
+  end
+
+  feature "matches type/* form MIME specifiers against general MIME types (but superfluous)" do
+    Test::Resources::Map.on(:get, ["foo"], :requested => "image/*") { }
+
+    resp = get "/foo", "HTTP_ACCEPT" => "image/png"
+    resp.status.should == 200
+
+    resp = get "/foo", "HTTP_ACCEPT" => "image/jpeg"
+    resp.status.should == 200
+  end
+
+  feature "does not match <type>/* form MIME specifiers against MIME subtypes" do
+    Test::Resources::Map.on(:get, ["foo"], :requested => "png/*") { }
+
+    resp = get "/foo", "HTTP_ACCEPT" => "image/png"
+    resp.status.should == 404
+  end
+
+  feature "requested */* matches anything" do
+    Test::Resources::Map.on(:get, ["foo"], :requested => "*/*") { }
+    Test::Resources::Map.on(:get, ["foo"], :requested => "text/*") { }
+    Test::Resources::Map.on(:get, ["foo"], :requested => "text/plain") { }
+
+    resp = get "/foo", "HTTP_ACCEPT" => "text/javascript"
+    resp.status.should == 200
+  end
+
+  feature "requested * matches anything" do
+    Test::Resources::Map.on(:get, ["foo"], :requested => "*") { }
+    Test::Resources::Map.on(:get, ["foo"], :requested => "*/*") { }
+    Test::Resources::Map.on(:get, ["foo"], :requested => "text/*") { }
+    Test::Resources::Map.on(:get, ["foo"], :requested => "text/plain") { }
+
+    resp = get "/foo", "HTTP_ACCEPT" => "text/javascript"
+    resp.status.should == 200
+  end
+
+  feature "allows multiple MIMEs to be accepted for one representation" do
+    Test::Resources::Map.on(:get,
+                            ["foo"],
+                            :requested => ["text/javascript",
+                                        :application,
+                                        "text/fortran",
+                                        :png]) { }
+
+    resp = get "/foo", "HTTP_ACCEPT" => "text/javascript"
+    resp.status.should == 200
+
+    resp = get "/foo", "HTTP_ACCEPT" => "text/fortran"
+    resp.status.should == 200
+
+    resp = get "/foo", "HTTP_ACCEPT" => "image/png"
+    resp.status.should == 200
+
+    resp = get "/foo", "HTTP_ACCEPT" => "application/xhtml+xml"
+    resp.status.should == 200
+  end
+
+end

data/test/match/uri.rb

@@ -0,0 +1,136 @@
+require "#{File.dirname(__FILE__)}/../../test/helpers.rb"
+require "test/helpers.rb"
+
+require "waves/foundations/compact"
+require "waves/matchers/URI"
+
+describe "URI matcher without specified path" do
+  before do
+    Test = Module.new { include Waves::Foundations::Compact }
+    Waves << Test
+  end
+
+  after do
+    Waves.applications.clear
+    Object.instance_eval { remove_const(:Test) if const_defined?(:Test) }
+  end
+
+  feature "always matches and returns {} if no host/port/scheme given either" do
+    m = Waves::Matchers::URI.new  :path => nil,
+                                  :host => nil,
+                                  :port => nil,
+                                  :scheme => nil
+
+    request = Waves::Request.new env("http://example.com/moo",
+                                     :method => "GET",
+                                     "HTTP_ACCEPT" => "text/html")
+
+    m.call(request).should == {}
+  end
+
+  feature "matches returning {} when all of given host/port/scheme match" do
+    m = Waves::Matchers::URI.new  :path => nil,
+                                  :host => "example.com",
+                                  :port => nil,
+                                  :scheme => nil
+
+    n = Waves::Matchers::URI.new  :path => nil,
+                                  :host => nil,
+                                  :port => nil,
+                                  :scheme => "http"
+
+    o = Waves::Matchers::URI.new  :path => nil,
+                                  :host => nil,
+                                  :port => nil,
+                                  :scheme => "http"
+
+    q = Waves::Matchers::URI.new  :path => nil,
+                                  :host => "example.com",
+                                  :port => 80,
+                                  :scheme => "http"
+
+    request = Waves::Request.new env("http://example.com/moo",
+                                     :method => "GET",
+                                     "HTTP_ACCEPT" => "text/html")
+
+    m.call(request).should == {}
+    n.call(request).should == {}
+    o.call(request).should == {}
+    q.call(request).should == {}
+  end
+
+  feature "returns falseish if either host, port or scheme fail to match when given" do
+    m = Waves::Matchers::URI.new  :path => nil,
+                                  :host => "example.com",
+                                  :port => nil,
+                                  :scheme => nil
+
+    n = Waves::Matchers::URI.new  :path => nil,
+                                  :host => nil,
+                                  :port => nil,
+                                  :scheme => "https"
+
+    o = Waves::Matchers::URI.new  :path => nil,
+                                  :host => nil,
+                                  :port => 8080,
+                                  :scheme => nil
+
+    request = Waves::Request.new env("http://example2.com/moo",
+                                     :method => "GET",
+                                     "HTTP_ACCEPT" => "text/html")
+
+    (!!m.call(request)).should == false
+    (!!n.call(request)).should == false
+    (!!o.call(request)).should == false
+  end
+end
+
+describe "URI matcher with path specified" do
+  before do
+    Test = Module.new { include Waves::Foundations::Compact }
+    Waves << Test
+  end
+
+  after do
+    Waves.applications.clear
+    Object.instance_eval { remove_const(:Test) if const_defined?(:Test) }
+  end
+
+  feature "returns path captures if path and any present host/port/scheme match" do
+    m = Waves::Matchers::URI.new  :path => [:aminal],
+                                  :host => "example.com",
+                                  :port => nil,
+                                  :scheme => "http"
+
+    request = Waves::Request.new env("http://example.com/moo",
+                                     :method => "GET",
+                                     "HTTP_ACCEPT" => "text/html")
+
+    m.call(request).should == {:aminal => "moo"}
+  end
+
+  feature "returns falseish if path matches but a present host/port/scheme does not" do
+    m = Waves::Matchers::URI.new  :path => [:aminal],
+                                  :host => "example2.com",
+                                  :port => nil,
+                                  :scheme => nil
+
+    n = Waves::Matchers::URI.new  :path => [:aminal],
+                                  :host => nil,
+                                  :port => 8008,
+                                  :scheme => nil
+
+    o = Waves::Matchers::URI.new  :path => [:aminal],
+                                  :host => nil,
+                                  :port => nil,
+                                  :scheme => "https"
+
+    request = Waves::Request.new env("http://example.com/moo",
+                                     :method => "GET",
+                                     "HTTP_ACCEPT" => "text/html")
+
+    (!!m.call(request)).should == false
+    (!!n.call(request)).should == false
+    (!!o.call(request)).should == false
+  end
+end

data/test/process/request.rb

@@ -0,0 +1,75 @@
+require 'test/helpers.rb'
+require 'waves/foundations/compact'
+
+describe "Request Object" do
+  before do
+    Test = Module.new { include Waves::Foundations::Compact }
+    Waves << Test
+  end
+  
+  after do
+    Waves.applications.clear
+    Object.instance_eval { remove_const( :Test ) if const_defined?( :Test ) }
+  end
+  
+  feature "Access the request method, scheme, url, host, port, path, referer, and query" do
+    r = Waves::Request.new(  env( 'http://localhost/', :method => 'GET' ) )
+    { :scheme => 'http', :url => 'http://localhost/', :method => :get,
+      :path => '/', :host => 'localhost', :domain => 'localhost', 
+      :query => {}, :params => {}, :port => 80, :referer => '/' }.
+      each { |k,v| r.send( k ).should == v }
+  end
+  
+  feature "Access the request method as a boolean" do
+    Waves::Request.new(  env( '/', :method => 'GET' ) ).get.should == true
+  end
+
+  feature "Access HTTP headers as accessor methods" do
+    Waves::Request.new(  env( '/', :method => 'GET', 
+      'HTTP_CACHE_CONTROL' => 'no-cache' ) ).
+      cache_control.should == 'no-cache'
+  end
+
+  feature "Access accept headers as Waves::Request::Accept objects" do
+    Waves::Request.new(  env( '/', :method => 'GET', 
+      'HTTP_ACCEPT_LANGUAGE' => 'en/us' ) ).
+      accept_language.class.should == Waves::Accept
+  end
+  
+  feature "Access custom headers as methods" do
+    Waves::Request.new(  env( '/', :method => 'GET', 
+      'X_CUSTOM_HEADER' => 'foo' ) )[ :x_custom_header ].should == 'foo'
+  end
+  
+  feature "Initiate redirect using #redirect" do
+    lambda { 
+      Waves::Request.new(  env( '/', :method => 'GET' ) ).redirect('/')
+    }.should.raise( Waves::Redirects::Found )
+  end
+  
+  feature "Raise NotFound using #not_found" do
+    lambda { 
+      Waves::Request.new(  env( '/', :method => 'GET' ) ).not_found
+    }.should.raise( Waves::Response::ClientErrors::NotFound )
+  end
+
+  feature "Access to content_type, media_type, and content_length" do
+    r = Waves::Request.new( env( '/', :method => 'GET', 
+      'CONTENT_TYPE' => 'text/plain;charset=utf-8', 'CONTENT_LENGTH' => 0 ) )
+    r.content_type.should == 'text/plain;charset=utf-8'
+    r.media_type.should == 'text/plain'
+    r.content_length.should == 0
+  end
+  
+  feature "Read / write traits to the request" do
+    r = Waves::Request.new( env( '/', :method => 'GET' )) 
+    r.traits[:foo] = 'bar'
+    r.traits.foo.should == 'bar'
+  end
+
+  feature "The Rack request is frozen and cannot be modified" do
+    r = Waves::Request.new( env( '/', :method => 'GET' )) 
+    lambda { r.rack_request.instance_eval { @env = {} } }.should.raise( TypeError )
+  end
+
+end