waves-edge 2009.03.10.13.14

data/test/match/query.rb

@@ -0,0 +1,40 @@
+require "#{File.dirname(__FILE__)}/../../test/helpers.rb"
+require '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, true, :query => { :bar => true }) {}
+    get("/foo?bar=baz").status.should == 200
+    get("/foo").status.should == 404
+  end
+  
+  feature "Test that a query parameter matches a regexp" do 
+    Test::Resources::Map.on( :get, true, :query => { :bar => /\d+/ }) {}
+    get("/foo?bar=123").status.should == 200
+    get("/foo?bar=baz").status.should == 404
+  end
+
+  feature "Test that a query parameter matches a string" do 
+    Test::Resources::Map.on( :get, true, :query => { :bar => '123' }) {}
+    get("/foo?bar=123").status.should == 200
+    get("/foo?bar=baz").status.should == 404
+  end
+
+  feature "Test that a query parameter satisfies a lambda condition" do 
+    Test::Resources::Map.on( :get, true, :query => { :bar => lambda { |x| x == '123' } }) {}
+    get("/foo?bar=123").status.should == 200
+    get("/foo?bar=baz").status.should == 404
+  end
+
+end

data/test/process/request.rb

@@ -0,0 +1,75 @@
+require 'test/helpers.rb'
+require '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::Request::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::Dispatchers::Redirect )
+  end
+  
+  feature "Raise NotFoundError using #not_found" do
+    lambda { 
+      Waves::Request.new(  env( '/', :method => 'GET' ) ).not_found
+    }.should.raise( Waves::Dispatchers::NotFoundError )
+  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

data/test/process/resource.rb

@@ -0,0 +1,53 @@
+require 'test/helpers.rb'
+require 'foundations/compact'
+
+describe "Application Context" 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 "Provide acccess to request, response, and session objects" do
+    Test::Resources::Map.new( Waves::Request.new( env('/', :method => 'GET' ) ) ).
+      instance_eval do
+        { :request => Waves::Request, :response => Waves::Response, 
+          :session => Waves::Session, :query => Waves::Request::Query }.
+          each { |k,v| send( k ).class.should == v }
+      end
+  end
+  
+  feature "Shortcuts to the path, url, domain, and session" do
+    Test::Resources::Map.new( Waves::Request.new( 
+      env('http://localhost/foo/bar.js', :method => 'GET' ) ) ).
+      instance_eval do
+        { :url => request.url, :path => request.path, 
+          :domain => request.domain, :session => request.session }.
+          each { |k,v| send( k ).should == v }    
+      end
+  end
+
+  feature "Access to path and associated helpers" do
+    Test::Resources::Map.new( Waves::Request.new( 
+      env('http://localhost/foo/bar.js', :method => 'GET' ) ) ).
+      instance_eval do
+        { :url => 'http://localhost/foo/bar.js', :path => '/foo/bar.js', 
+          :basename => '/foo/bar', :extension => 'js' }.
+          each { |k,v| send( k ).should == v }
+      end
+  end
+
+  feature "Access to the application object and name" do
+    Test::Resources::Map.new( Waves::Request.new( 
+      env('http://localhost/foo/bar.js', :method => 'GET' ) ) ).
+      instance_eval do
+        { :app => Test, :app_name => :test }.
+          each { |k,v| send( k ).should == v }    
+      end
+  end
+  
+end

data/test/resources/path.rb

@@ -0,0 +1,166 @@
+require "#{File.dirname(__FILE__)}/../helpers.rb"
+require "foundations/compact"
+
+describe "A path generation method" do
+  
+  before do
+    Test = Module.new { include Waves::Foundations::Compact }
+    @resource_class = Test::Resources::Map
+    @paths = @resource_class.new( Waves::Request.new( env( '/', :method => 'GET' ) ) ).paths
+  end
+  
+  after do
+    Waves.applications.clear
+    Object.instance_eval { remove_const(:Test) if const_defined?(:Test) }
+  end
+  
+  it "turns an empty template into '/'" do
+    @resource_class.on(:get, :list => [] ) { nil }
+    @paths.list.should == "/"
+    @paths.list("foo").should == "/"
+  end
+  
+  it "reproduces strings from the path template" do
+    @resource_class.on(:get, :list => [ 'taller', 'ghost', 'walt' ] ) { nil }
+    @paths.list.should == "/taller/ghost/walt"
+  end
+  
+  it "treats symbols as locations for arg interpolation" do
+    @resource_class.on(:get, :show => [ 'hi', 'there', :nickname ]) { nil }
+    @paths.show( 'freckles' ).should == "/hi/there/freckles"
+  end
+  
+  
+  it "treats a hash with string or symbol value as location for arg interpolations" do
+    @resource_class.on(:get, :edit => [ 'form', { :filter => 'textile' } ] ) { nil }
+    @paths.edit( 'markdown' ).should == "/form/markdown"
+    @paths.edit( 'markdown' ).should == "/form/markdown"
+  end
+  
+  it "interpolates for a hash-with-regex only when the arg matches the regex" do
+    @resource_class.on(:get, :edit => [ 'form', { :filter => /^(textile|markdown|plain)$/ } ] ) { nil }
+    @paths.edit( 'markdown' ).should == "/form/markdown"
+    
+    lambda { @paths.edit( 'html' ) }.should.raise ArgumentError
+  end
+  
+  it "appends all arguments to the path when it encounters a true" do
+    @resource_class.on(:get, :count_1 => [ 'first', true ]) { nil }
+    @paths.count_1("second", "third", "fourth").should == "/first/second/third/fourth"
+    
+    @resource_class.on(:get, :count_2 => [ 'first', { :whatever => true } ]) { nil }
+    @paths.count_2("second", "third", "fourth").should == "/first/second/third/fourth"
+  end
+  
+  it "uses hash element value as default in absence of argument" do
+    @resource_class.on(:get, :edit => [ 'form', { :filter => 'textile' } ] ) { nil }
+    @paths.edit.should == "/form/textile"
+  end
+  
+  it "uses regexes for argument interpolation if the arg matches" do
+    @resource_class.on(:get, :list => [ "episode", /\d+/ ] ) { nil }
+    @paths.list( 815 ).should == "/episode/815"
+    
+    lambda { path = @paths.list( "boar" ) }.should.raise ArgumentError
+  end
+  
+  describe "given an (implicit) array of args" do
+    
+    it "interpolates its arguments in order" do
+      @resource_class.on(:get, :list => [ :one, :two, :three ] ) { nil }
+      @paths.list( 'one', 'two', 'three').should == '/one/two/three'
+    end
+    
+    it "raises an ArgumentError if given more args than interpolables" do
+      @resource_class.on(:get, :list => [ :one ] ) { nil }
+      lambda { @paths.list( "x", "y") }.should.raise ArgumentError
+    end
+    
+  end
+  
+  describe "given an argument hash" do
+    
+    it "interpolates arg pairs that match symbols in the template" do
+      @resource_class.on(:get, :list => [ :one, :two, :three ] ) { nil }
+      @paths.list( :three => 'three', :one => 'one', :two => 'two').should == '/one/two/three'
+    end
+    
+    it "interpolates arg pairs that match the keys of hashes in the template" do
+      @resource_class.on(:get, :show => [ {:foo => 'bar'} ] ) { nil }
+      @paths.show( :foo => 'bear' ).should == "/bear"
+    end
+    
+    it "interpolates an arg pair for a hash-with-regex only when the arg matches the regex" do
+      @resource_class.on(:get, :show => [ {:foo => /^ba(r|z|t)$/ } ] ) { nil }
+      @paths.show( :foo => 'baz' ).should == "/baz"
+    end
+    
+    it "uses hash element value as default in absence of an arg pair" do
+      @resource_class.on(:get, :list => [ :one, { :two => 'two' }, :three ] ) { nil }
+      @paths.list( :three => 'three', :one => 'one').should == "/one/two/three"
+    end
+  
+    it "raises when not all necessary interpolations can be performed" do
+      @resource_class.on(:get, :list => [ :one, :two, :three ] ) { nil }
+      lambda { @paths.list( :three => 'three', :one => 'one') }.should.raise ArgumentError
+    end
+  
+    it "raises an ArgumentError if the template contains a regex" do
+      @resource_class.on(:get, :list => [ /anything/ ] ) { nil }
+      lambda { @paths.list( :one => 'one' ) }.should.raise ArgumentError
+    end
+    
+    it "appends value/s of arg pair matching a template hash-with-true" do
+      @resource_class.on(:get, :list => [ :kind, { :parts => true } ]) { nil }
+      lambda { @paths.list( :kind => 'ghost') }.should.raise ArgumentError
+      @paths.list( :kind => 'ghost', :parts => "walt" ).should == "/ghost/walt"
+      @paths.list( :kind => 'ghost', :parts => ["walt", "boone"]).should == "/ghost/walt/boone"
+    end
+    
+    it "raises an ArgumentError if the template contains a true" do
+      @resource_class.on(:get, :list => [ :kind, true ]) { nil }
+      lambda { @paths.list( :kind => 'whuh?' ) }.should.raise ArgumentError
+      
+    end
+    
+  end
+
+  describe "A path template" do
+    
+    it "is compilable when it contains Strings, Symbols, and Hashes with Strings or Symbols" do
+      @resource_class.on(:get, :one => [ 'taller', 'ghost', 'walt' ] ) { nil }
+      @paths.one
+      
+      @resource_class.on(:get, :two => [ 'hi', 'there', :nickname ]) { nil }
+      @paths.two( 'freckles' )
+      
+      @resource_class.on(:get, :three => [ 'form', { :filter => 'textile' } ] ) { nil }
+      @paths.three( 'markdown' )
+      
+      @resource_class.on(:get, :four => [ 'other_form', { :filter => :textile } ] ) { nil }
+      @paths.four( 'markdown' )
+      
+      @paths.compiled_paths.values.sort.should == ["/taller/ghost/walt", "/hi/there/%s", "/form/%s", "/other_form/%s"].sort
+    end
+    
+    it "is not compilable if it contains Regexps, true, or Hashes with Regexp or true" do
+      @resource_class.on(:get, :one => [ "episode", /\d+/ ] ) { nil }
+      @paths.one( 815 )
+      
+      @resource_class.on(:get, :two => [ true ])
+      @paths.two( "foo" )
+      
+      @resource_class.on(:get, :three => [ {:foo => /^ba(r|z|t)$/ } ] ) { nil }
+      @paths.three( :foo => 'baz' )
+      
+      @resource_class.on(:get, :four => [ 'first', { :whatever => true } ]) { nil }
+      @paths.four
+      
+      @paths.compiled_paths.values.should == []
+    end
+    
+  end
+
+
+  
+end

data/test/runtime/configurations.rb

@@ -0,0 +1,19 @@
+require "#{File.dirname(__FILE__)}/../helpers.rb"
+ 
+describe "Configuration attributes" do
+  
+  class Basic < Waves::Configurations::Base; end
+  
+  it "can be declared by developers" do
+    Basic.attribute :smurf
+    Basic.smurf("smurfy") 
+    Basic.smurf.should == "smurfy"
+  end
+  
+  
+  it "must be declared before use" do
+    Basic.should.not.respond_to :gnome
+  end
+  
+end
+ 

data/test/runtime/request.rb

@@ -0,0 +1,63 @@
+require "#{File.dirname(__FILE__)}/../helpers.rb"
+
+describe "A Waves request instance" do
+  
+  before do
+    @request = Waves::Request.new(env( '/', :method => 'GET' ))
+  end
+  
+  it "has session, response, and blackboard objects" do
+    @request.session.class.should == Waves::Session
+    @request.response.class.should == Waves::Response
+  end
+  
+  it "provides an accessor to the Rack request" do
+    @request.rack_request.class.should == Rack::Request
+  end
+  
+  it "wraps some useful Rack data in more elegant methods" do
+    @request.path.should == "/"
+
+    @request.domain.should == "example.org"
+
+    # @request.content_type.should == "text/html"
+  end
+  
+  # it "delegates unknown methods to the Rack request" do
+  #   @request.chitty_bang_bang
+  # end
+  
+end
+
+describe "The HTTP request method" do
+  
+  
+  it "is determined in a straightforward manner for straightforward requests" do
+    @get = Waves::Request.new(env("/", :method => 'GET'))
+    @post = Waves::Request.new(env("/", :method => 'POST'))
+    @put = Waves::Request.new(env("/", :method => 'PUT'))
+    @delete = Waves::Request.new(env("/", :method => 'DELETE'))
+    
+    @get.method.should == :get
+    @post.method.should == :post
+    @put.method.should == :put
+    @delete.method.should == :delete
+  end
+    
+  it "can be set with the '_method' query param on a POST" do  
+    @url_put = Waves::Request.new(env("/?_method=put", :method => 'POST'))
+    @url_delete = Waves::Request.new(env("/?_method=delete", :method => 'POST'))
+    
+    @url_put.method.should == :put; @url_put.put.should.be.true
+    @url_delete.method.should == :delete; @url_delete.delete.should.be.true
+  end
+    
+  it "can be set with the '_method' body param on a POST" do  
+    @body_put = Waves::Request.new(env("/", :method => 'POST', :input => '_method=put'))
+    @body_delete = Waves::Request.new(env("/", :method => 'POST', :input => '_method=delete'))
+    
+    @body_put.method.should == :put; @body_put.put.should.be.true
+    @body_delete.method.should == :delete
+  end
+  
+end

data/test/runtime/response.rb

@@ -0,0 +1,55 @@
+require "#{File.dirname(__FILE__)}/../helpers.rb"
+
+describe "An instance of Waves::Response" do
+  
+  before do
+    @request = Waves::Request.new(env( '/', :method => 'GET' ))
+    @response = Waves::Response.new(@request)
+  end
+  
+  it "has a Rack::Response" do
+    @response.rack_response.class.should == Rack::Response
+  end
+  
+  it "has a Waves::Request" do
+    @response.request.class.should == Waves::Request
+  end
+  
+  it "can access the session for the current request" do
+    @response.session.class.should == Waves::Session
+  end
+  
+  it "provides setter methods for commonly used headers" do
+    @response.rack_response.should.receive(:[]=).with('Content-Type', 'text/javascript')
+    @response.content_type = 'text/javascript'
+    
+    @response.rack_response.should.receive(:[]=).with('Content-Length', '42')
+    @response.content_length = '42'
+    
+    @response.rack_response.should.receive(:[]=).with('Location', '/here/')
+    @response.location = '/here/'
+    
+    @response.rack_response.should.receive(:[]=).with('Expires', 'Thu, 09 Aug 2007 05:22:55 GMT')
+    @response.expires = 'Thu, 09 Aug 2007 05:22:55 GMT'
+  end
+  
+  it "delegates unknown methods to the Rack response" do
+    @response.rack_response.should.receive(:mclintock!)
+    @response.mclintock!
+  end
+  
+end
+
+describe "Waves::Response#finish" do
+  
+  before do
+    @request = Waves::Request.new(env( '/', :method => 'GET' ))
+    @response = Waves::Response.new(@request)
+  end
+  
+  it "saves the request session and calls Rack::Response#finish" do
+    @response.rack_response.should.receive(:finish)
+    @response.finish
+  end
+  
+end