waves 0.8.2 → 0.9.0

data/test/helpers.rb

@@ -0,0 +1,17 @@
+require 'rubygems'; %w{ bacon facon }.each { |dep| require dep }
+
+# Framework lib goes to the front of the loadpath
+$:.unshift('lib')
+require 'waves'
+require 'waves/runtime/mocks'
+
+Waves::Runtime.instance = Waves::Runtime.new
+
+Bacon::Context.module_eval do
+  include Waves::Mocks
+  alias_method :specification, :describe
+  alias_method :feature, :it
+end
+
+Bacon.extend Bacon::TestUnitOutput
+Bacon.summary_on_exit

data/test/match/accept.rb

@@ -0,0 +1,78 @@
+require "#{File.dirname(__FILE__)}/../../test/helpers.rb"
+require 'test/helpers.rb'
+
+require 'waves/foundations/compact'
+require "waves/runtime/mime_types"
+
+describe "Accept header matching" do
+  
+  Accept = Waves::Accept
+  
+  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 accept header" do
+    
+    Test::Resources::Map.on( :get, [ "foo" ], :accept => "text/javascript" ) { }
+
+    resp = get "/foo"
+    resp.status.should == 404
+
+    resp = get "/foo", "HTTP_ACCEPT" => "text/javascript"
+    resp.status.should == 200
+    
+  end
+
+  feature 'Accept header is being parsed parses in the right way.' do
+    accept_header = "text/*, text/html ;q=0.3, text/html;q=0.7, text/html;level=1, text/html;level=2;q=0.4, */*;q=0.5"
+    terms = Accept.parse(accept_header)
+    terms.size.should == 6
+    terms.map{|term,params| term }.uniq[0] == %w( text html )
+
+    accept_header = "text/html,application/xhtml+xml;q=0.95,application/xml;q=0.9,*/*;q=0.8"
+    terms = Accept.parse(accept_header)
+    terms.size.should == 4
+    terms[0][0].should == %w( text html )
+    terms[1][0].should == %w( application xhtml+xml )
+    terms[2][0].should == %w( application xml )
+    terms[3][0].should == [ true, true ]
+
+    accept_header = "text/css,*/*;q=0.1"
+    terms = Accept.parse(accept_header)
+    terms.size.should == 2
+    terms[0][0].should == %w( text css )
+    terms[1][0].should == [ true, true ]
+
+    accept_header = "image/png,image/*;q=0.8,*/*;q=0.5"
+    terms = Accept.parse(accept_header)
+    terms.size.should == 3
+    terms[0][0].should == %w( image png )
+    terms[1][0].should == [ 'image', true ]
+    terms[2][0].should == [ true, true ]
+  end
+
+  feature 'Should return all the terms in a Accept-Charset header' do
+    accept_charset_header = "ISO-8859-1,utf-8;q=0.7,*;q=0.7"
+    terms = Accept.parse( accept_charset_header )
+    terms.size.should == 3
+    terms[0][0].should == [ 'ISO-8859-1' ]
+    terms[1][0].should == [ 'utf-8' ]
+    terms[2][0].should == [ true ]
+  end
+
+  feature 'Should return all the terms in a Accept-Language header' do
+    accept_language_header = "en-us,en;q=0.5"
+    terms = Accept.parse(accept_language_header)
+    terms.size.should == 2
+    terms[0][0][0] == 'en-us'
+    terms[1][0][0] == 'en'
+  end
+  
+end

data/test/match/ext.rb

@@ -0,0 +1,156 @@
+require 'test/helpers.rb'
+
+require 'waves/foundations/compact'
+require "waves/runtime/mime_types"
+require "waves/matchers/ext"
+
+describe "File extension 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 "returns falseish if single file extension Symbol is not matched" do
+    m = Waves::Matchers::Ext.new :js
+
+    request = Waves::Request.new env("http://example.com/moo",
+                                     :method => "GET",
+                                     "HTTP_ACCEPT" => "text/javascript")
+
+    (!!m.call(request)).should == false
+
+    request = Waves::Request.new env("http://example.com/moo.sj",
+                                     :method => "GET",
+                                     "HTTP_ACCEPT" => "text/javascript")
+
+    (!!m.call(request)).should == false
+  end
+
+  feature "returns falseish if none of Array of Symbol extensions match" do
+    m = Waves::Matchers::Ext.new [:js, :html]
+
+    request = Waves::Request.new env("http://example.com/moo",
+                                     :method => "GET",
+                                     "HTTP_ACCEPT" => "text/javascript")
+
+    (!!m.call(request)).should == false
+
+    request = Waves::Request.new env("http://example.com/moo.sj",
+                                     :method => "GET",
+                                     "HTTP_ACCEPT" => "text/javascript")
+
+    (!!m.call(request)).should == false
+  end
+
+  feature "returns trueish if single file extension Symbol does match" do
+    m = Waves::Matchers::Ext.new :js
+
+    request = Waves::Request.new env("http://example.com/moo.js",
+                                     :method => "GET",
+                                     "HTTP_ACCEPT" => "text/javascript")
+
+    m.call(request).should == true
+  end
+
+  feature "returns trueish if any in Array of Symbol extensions match" do
+    m = Waves::Matchers::Ext.new [:js, :html]
+
+    request = Waves::Request.new env("http://example.com/moo.js",
+                                     :method => "GET",
+                                     "HTTP_ACCEPT" => "text/javascript")
+
+    (!!m.call(request)).should == true
+
+    request = Waves::Request.new env("http://example.com/moo.html",
+                                     :method => "GET",
+                                     "HTTP_ACCEPT" => "text/javascript")
+
+    (!!m.call(request)).should == true
+  end
+
+  feature "fails to match a Symbol extension with a leading dot included" do
+    m = Waves::Matchers::Ext.new :".js"
+
+    request = Waves::Request.new env("http://example.com/moo.js",
+                                     :method => "GET",
+                                     "HTTP_ACCEPT" => "text/javascript")
+
+    (!!m.call(request)).should == false
+  end
+
+  feature "matches absence of extension, returning true, if Array contains false" do
+    m = Waves::Matchers::Ext.new [ :js, :html, false ]
+
+    request = Waves::Request.new env("http://example.com/moo",
+                                     :method => "GET",
+                                     "HTTP_ACCEPT" => "text/javascript")
+
+    (!!m.call(request)).should == true
+  end
+
+  feature "fails to match if extension provided but no extension specified with empty String" do
+    m = Waves::Matchers::Ext.new( false )
+
+    request = Waves::Request.new env("http://example.com/moo.js",
+                                     :method => "GET",
+                                     "HTTP_ACCEPT" => "text/javascript")
+
+    (!!m.call(request)).should == false
+  end
+
+end
+
+describe "File extension matching in conjunction with Accept 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 "fails if the Accept match fails" do
+    m = Waves::Matchers::Request.new :requested => ["text/html"],
+                                     :ext => :js
+
+    request = Waves::Request.new env("http://example.com/moo.js",
+                                     :method => "GET",
+                                     "HTTP_ACCEPT" => "text/javascript")
+
+    (!!m.call(request)).should == false
+  end
+
+  feature "matches if the extension is Accept-matched with or without Accept header" do
+    m = Waves::Matchers::Request.new :requested => ["text/javascript"],
+                                     :ext => :js
+
+    request = Waves::Request.new env("http://example.com/moo.js",
+                                     :method => "GET",
+                                     "HTTP_ACCEPT" => "text/javascript")
+
+    (!!m.call(request)).should == true
+
+    request = Waves::Request.new env("http://example.com/moo.js", :method => "GET")
+
+    (!!m.call(request)).should == true
+  end
+
+  feature "causes Accept match to fail if there is a file extension, and absence is specified" do
+    m = Waves::Matchers::Request.new :requested => ["text/javascript"],
+                                     :ext => false
+
+    request = Waves::Request.new env("http://example.com/moo.js",
+                                     :method => "GET",
+                                     "HTTP_ACCEPT" => "text/javascript")
+    (!!m.call(request)).should == false
+  end
+
+end
+

data/test/match/methods.rb

@@ -0,0 +1,22 @@
+require "#{File.dirname(__FILE__)}/../../test/helpers.rb"
+require 'waves/foundations/compact'
+
+describe "Matching Request Methods" do
+
+  before do
+    Test = Module.new { include Waves::Foundations::Compact }
+    Test::Resources::Map.module_eval {
+      %w( get put post delete head ).each { |m| on( m ) { m } } }
+    Waves << Test
+  end
+
+  after do
+    Waves.applications.clear
+    Object.instance_eval { remove_const(:Test) if const_defined?(:Test) }
+  end
+
+  %w( get put post delete head ).each do |m|
+    feature( "Match the '#{m}' method" ) { send( m, '/' ).body.should == m }
+  end
+
+end

data/test/match/params.rb

@@ -0,0 +1,33 @@
+require "#{File.dirname(__FILE__)}/../../test/helpers.rb"
+require 'waves/foundations/compact'
+
+describe "A resource that has matched a request" do
+
+  before do
+    Test = Module.new { include Waves::Foundations::Compact }
+    Waves << Test
+
+    @request = Waves::Request.new( env('http://localhost/baz?bar=7', :method => 'GET', "HTTP_ACCEPT" => "text/html" ) )
+    Test::Resources::Map.on(:get, [:foo], :accept => "text/html") { }
+    @resource = Test::Resources::Map.new( @request )
+    @resource.get
+  end
+
+  after do
+    Waves.applications.clear
+    Object.instance_eval { remove_const(:Test) if const_defined?(:Test) }
+  end
+
+  it "makes parameters captured from the path available as #captured" do
+    @resource.captured.to_h.should == { 'foo' => 'baz' }
+  end
+
+  it "makes http query parameters available as #query" do
+    @resource.query.to_h.should == { 'bar' => '7' }
+  end
+
+  it "provides access to all derived parameters using #params" do
+    @resource.params.to_h.should == { 'foo' => 'baz', 'bar' => '7' }
+  end
+
+end

data/test/match/path.rb

@@ -0,0 +1,106 @@
+require "#{File.dirname(__FILE__)}/../../test/helpers.rb"
+require 'waves/foundations/compact'
+
+describe "Matching Request URIs" 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 "By default, we match an arbitrary path." do
+    Test::Resources::Map.on( :get ) {}
+    get("/foobar").status.should == 200
+    get("/foo/bar").status.should  == 200
+  end
+
+  feature "A path of true matches an arbitrary path." do
+    Test::Resources::Map.on( :get, true ) { request.path }
+    get("/foobar").body.should == '/foobar'
+    get("/foo/bar").body.should == '/foo/bar'
+  end
+
+  feature "An empty path matches root." do
+    Test::Resources::Map.on( :get, [] ) { request.path }
+    get("/").body.should == '/'
+  end
+
+  feature "A string path component matches that string." do
+    Test::Resources::Map.on( :get, [ 'foo' ] ) { request.path }
+    get("/foo").body.should == '/foo'
+    get("/bar").status.should == 404
+  end
+
+  feature "A symbol path component captures that component using the symbol as a key." do
+    Test::Resources::Map.on( :get, [ :foo ] ) { captured[:foo] }
+    get("/foo").body.should == 'foo'
+    get("/bar").body.should == 'bar'
+  end
+
+  feature "A regexp path component matches the any component that matches the regexp." do
+    Test::Resources::Map.on( :get, [ /\d+/ ] ) { request.path }
+    get("/1234").body.should == '/1234'
+    get("/foo").status.should == 404
+  end
+
+  feature "A path component of true matches the remaining path." do
+    Test::Resources::Map.on( :get, [ 'foo', true ] ) { request.path }
+    get("/foo/bar/baz").body.should == '/foo/bar/baz'
+    get("/foo").status.should == 404
+  end
+
+  [["one or more", 1..-1, false, true, true],
+   ["zero or more", 0..-1, true, true, true],
+   ["one to N (N=2)", 1..2, false, true, true, false],
+   ["one to N (N=3)", 1..3, false, true, true, true, false]
+  ].each do |name, range, *tests|
+    feature "A Range path component can match #{name} components" do
+      Test::Resources::Map.on(:get, ['foo', range]) { request.path }
+      tests.size.times do |i|
+       get("/foo" * ( i + 1 ) ).status.should == (tests[i] ? 200 : 404)
+      end
+    end
+  end
+
+  feature "A path component can use a hash with a value of true to capture the remaining path." do
+    Test::Resources::Map.on( :get, [ 'foo', { :rest => true }  ] ) { captured[:rest] * ' ' }
+    get("/foo/bar/baz").body.should == 'bar baz'
+  end
+
+  [["one or more", 1..-1, false, 'foo', 'foo foo'],
+   ["zero or more", 0..-1, '', 'foo', 'foo foo'],
+   ["one to N (N=2)", 1..2, false, 'foo', 'foo foo', false],
+   ["one to N (N=3)", 0..3, '', 'foo', 'foo foo', 'foo foo foo', false]
+  ].each do |name, range, *tests|
+    feature "A Range path component can match #{name} components" do
+      Test::Resources::Map.on(:get, ['foo', { :rest => range }]) { captured.rest * ' ' }
+      tests.size.times do |i|
+        response = get("/foo" * ( i + 1 ) )
+        tests[i] ? response.body.should == tests[i] : response.status.should == 404
+      end
+    end
+  end
+
+  feature "A path component can use a hash with a string value to provide a default." do
+    Test::Resources::Map.on( :get, [ 'foo', { :bar => 'bar' }  ] ) { captured[:bar] }
+    get("/foo/baz").body.should == 'baz'
+    get("/foo").body.should == 'bar'
+  end
+
+  feature "A path component can use a hash with a regexp value to match and capture." do
+    Test::Resources::Map.on( :get, [ 'foo', { :bar => /\d+/ }  ] ) { captured[:bar] }
+    get("/foo/123").body.should == '123'
+    get("/foo").status.should == 404
+  end
+
+  it "Path components match against unescaped values" do
+    Test::Resources::Map.on(:get, [ 'polar bear']) { 'bang' }
+    get("/polar%20bear").body.should == 'bang'
+  end
+
+end

data/test/match/query.rb

@@ -0,0 +1,60 @@
+require "#{File.dirname(__FILE__)}/../../test/helpers.rb"
+require 'waves/foundations/compact'
+
+describe "Matching Query Parameters" 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 "Test for a query parameter using true" do
+    Test::Resources::Map.on(:get, ["foo"], :accept => "text/plain",
+                                           :query => {:bar => true}) { }
+
+    resp = get "/foo?bar=baz", "HTTP_ACCEPT" => "text/plain"
+    resp.status.should == 200
+
+    resp = get "/foo", "HTTP_ACCEPT" => "text/plain"
+    resp.status.should == 404
+  end
+
+  feature "Test that a query parameter matches a regexp" do
+    Test::Resources::Map.on(:get, ["foo"], :accept => "text/plain",
+                                           :query => {:bar => /\d+/}) { }
+
+    resp = get "/foo?bar=123", "HTTP_ACCEPT" => "text/plain"
+    resp.status.should == 200
+
+    resp = get "/foo?bar=baz", "HTTP_ACCEPT" => "text/plain"
+    resp.status.should == 404
+  end
+
+  feature "Test that a query parameter matches a string" do
+    Test::Resources::Map.on(:get, ["foo"], :accept => "text/plain",
+                                           :query => {:bar => "123"}) { }
+
+    resp = get "/foo?bar=123", "HTTP_ACCEPT" => "text/plain"
+    resp.status.should == 200
+
+    resp = get "/foo?bar=baz", "HTTP_ACCEPT" => "text/plain"
+    resp.status.should == 404
+  end
+
+  feature "Test that a query parameter satisfies a lambda condition" do
+    Test::Resources::Map.on(:get, ["foo"], :accept => "text/plain",
+                                           :query => {:bar => lambda {|x| x == "123" }}) { }
+
+    resp = get "/foo?bar=123", "HTTP_ACCEPT" => "text/plain"
+    resp.status.should == 200
+
+    resp = get "/foo?bar=baz", "HTTP_ACCEPT" => "text/plain"
+    resp.status.should == 404
+  end
+
+end