strelka 0.0.1pre4 → 0.0.1.pre129

data/spec/strelka/app/exclusiverouter_spec.rb

@@ -0,0 +1,220 @@
+#!/usr/bin/env ruby
+
+BEGIN {
+	require 'pathname'
+	basedir = Pathname.new( __FILE__ ).dirname.parent.parent.parent
+	$LOAD_PATH.unshift( basedir ) unless $LOAD_PATH.include?( basedir )
+}
+
+require 'rspec'
+
+require 'spec/lib/helpers'
+
+require 'strelka'
+require 'strelka/app/exclusiverouter'
+
+
+#####################################################################
+###	C O N T E X T S
+#####################################################################
+
+describe Strelka::App::ExclusiveRouter do
+
+	before( :all ) do
+		setup_logging( :fatal )
+		@request_factory = Mongrel2::RequestFactory.new( route: '/user' )
+	end
+
+	before( :each ) do
+		@router = Strelka::App::ExclusiveRouter.new
+	end
+
+	after( :all ) do
+		reset_logging()
+	end
+
+	context "a router with routes for 'foo', 'foo/bar'" do
+
+		before( :each ) do
+			@router.add_route( :GET, ['foo'], route(:foo) )
+			@router.add_route( :GET, ['foo','bar'], route(:foo_bar) )
+		end
+
+		it "doesn't route /user/foo/bar/baz" do
+			req = @request_factory.get( '/user/foo/bar/baz' )
+			@router.route_request( req ).should be_nil()
+		end
+
+		it "routes /user/foo/bar to the foo/bar action" do
+			req = @request_factory.get( '/user/foo/bar' )
+			@router.route_request( req ).should match_route( :foo_bar )
+		end
+
+		it "routes /user/foo/bar?limit=10 to the foo/bar action" do
+			req = @request_factory.get( '/user/foo/bar?limit=10' )
+			@router.route_request( req ).should match_route( :foo_bar )
+		end
+
+		it "routes /user/foo to the foo action" do
+			req = @request_factory.get( '/user/foo' )
+			@router.route_request( req ).should match_route( :foo )
+		end
+
+		it "doesn't route /user" do
+			req = @request_factory.get( '/user' )
+			@router.route_request( req ).should be_nil()
+		end
+
+		it "doesn't route /user/other" do
+			req = @request_factory.get( '/user/other' )
+			@router.route_request( req ).should be_nil()
+		end
+
+	end
+
+	context "a router with routes for 'foo', 'foo/bar', and a fallback action" do
+
+		before( :each ) do
+			@router.add_route( :GET, [], route(:fallback) )
+			@router.add_route( :GET, ['foo'], route(:foo) )
+			@router.add_route( :GET, ['foo','bar'], route(:foo_bar) )
+		end
+
+		it "doesn't route /user/foo/bar/baz" do
+			req = @request_factory.get( '/user/foo/bar/baz' )
+			@router.route_request( req ).should be_nil()
+		end
+
+		it "routes /user/foo/bar to the foo/bar action" do
+			req = @request_factory.get( '/user/foo/bar' )
+			@router.route_request( req ).should match_route( :foo_bar )
+		end
+
+		it "routes /user/foo to the foo action" do
+			req = @request_factory.get( '/user/foo' )
+			@router.route_request( req ).should match_route( :foo )
+		end
+
+		it "routes /user to the fallback action" do
+			req = @request_factory.get( '/user' )
+			@router.route_request( req ).should match_route( :fallback )
+		end
+
+		it "doesn't route /user/other" do
+			req = @request_factory.get( '/user/other' )
+			@router.route_request( req ).should be_nil()
+		end
+
+	end
+
+	context "a router with routes for 'foo', 'foo/\w{3}', and 'foo/\w{6}'" do
+
+		before( :each ) do
+			@router.add_route( :GET, ['foo'], route(:foo) )
+			@router.add_route( :GET, ['foo',/\w{3}/], route(:foo_three) )
+			@router.add_route( :GET, ['foo',/\w{6}/], route(:foo_six) )
+		end
+
+		it "doesn't route /user/foo/barbim/baz" do
+			req = @request_factory.get( '/user/foo/barbim/baz' )
+			@router.route_request( req ).should be_nil()
+		end
+
+		it "routes /user/foo/barbat to the foo/\w{6} action" do
+			req = @request_factory.get( '/user/foo/barbat' )
+			@router.route_request( req ).should match_route( :foo_six )
+		end
+
+		it "doesn't route /user/foo/bar/baz" do
+			req = @request_factory.get( '/user/foo/bar/baz' )
+			@router.route_request( req ).should be_nil()
+		end
+
+		it "routes /user/foo/bar to the foo/\w{3} action" do
+			req = @request_factory.get( '/user/foo/bar' )
+			@router.route_request( req ).should match_route( :foo_three )
+		end
+
+		it "routes /user/foo to the foo action" do
+			req = @request_factory.get( '/user/foo' )
+			@router.route_request( req ).should match_route( :foo )
+		end
+
+		it "doesn't route /user" do
+			req = @request_factory.get( '/user' )
+			@router.route_request( req ).should be_nil()
+		end
+
+		it "doesn't route /user/other" do
+			req = @request_factory.get( '/user/other' )
+			@router.route_request( req ).should be_nil()
+		end
+
+	end
+
+	# get '/foo/\w{3}'
+	# get '/foo/\d+'
+
+	context "a router with routes for: 'foo/\w{3}', then 'foo/\d+'" do
+
+		before( :each ) do
+			@router.add_route( :GET, ['foo',/\w{3}/], route(:foo_three) )
+			@router.add_route( :GET, ['foo',/\d+/], route(:foo_digit) )
+		end
+
+		it "routes /user/foo/1 to the foo/\d+ action" do
+			req = @request_factory.get( '/user/foo/1' )
+			@router.route_request( req ).should match_route( :foo_digit )
+		end
+
+		it "routes /user/foo/12 to the foo/\d+ action" do
+			req = @request_factory.get( '/user/foo/12' )
+			@router.route_request( req ).should match_route( :foo_digit )
+		end
+
+		it "routes /user/foo/123 to the foo/\w{3} action" do
+			req = @request_factory.get( '/user/foo/123' )
+			@router.route_request( req ).should match_route( :foo_three )
+		end
+
+		it "routes /user/foo/1234 to the foo/\d+ action" do
+			req = @request_factory.get( '/user/foo/1234' )
+			@router.route_request( req ).should match_route( :foo_digit )
+		end
+
+	end
+
+	# get '/foo/\d+'
+	# get '/foo/\w{3}'
+
+	context "a router with routes for: 'foo/\d+', then 'foo/\w{3}'" do
+
+		before( :each ) do
+			@router.add_route( :GET, ['foo',/\d+/], route(:foo_digit) )
+			@router.add_route( :GET, ['foo',/\w{3}/], route(:foo_three) )
+		end
+
+		it "routes /user/foo/1 to the foo/\d+ action" do
+			req = @request_factory.get( '/user/foo/1' )
+			@router.route_request( req ).should match_route( :foo_digit )
+		end
+
+		it "routes /user/foo/12 to the foo/\d+ action" do
+			req = @request_factory.get( '/user/foo/12' )
+			@router.route_request( req ).should match_route( :foo_digit )
+		end
+
+		it "routes /user/foo/123 to the foo/\d+ action" do
+			req = @request_factory.get( '/user/foo/123' )
+			@router.route_request( req ).should match_route( :foo_digit )
+		end
+
+		it "routes /user/foo/1234 to the foo/\d+ action" do
+			req = @request_factory.get( '/user/foo/1234' )
+			@router.route_request( req ).should match_route( :foo_digit )
+		end
+
+	end
+
+end
+

data/spec/strelka/app/filters_spec.rb

@@ -0,0 +1,196 @@
+#!/usr/bin/env ruby
+
+BEGIN {
+	require 'pathname'
+	basedir = Pathname.new( __FILE__ ).dirname.parent.parent.parent
+	$LOAD_PATH.unshift( basedir ) unless $LOAD_PATH.include?( basedir )
+}
+
+require 'rspec'
+
+require 'spec/lib/helpers'
+
+require 'strelka'
+require 'strelka/app/plugins'
+require 'strelka/app/filters'
+
+require 'strelka/behavior/plugin'
+
+
+#####################################################################
+###	C O N T E X T S
+#####################################################################
+
+describe Strelka::App::Filters do
+
+	before( :all ) do
+		setup_logging( :fatal )
+		@request_factory = Mongrel2::RequestFactory.new( route: '' )
+	end
+
+	after( :all ) do
+		reset_logging()
+	end
+
+
+	it_should_behave_like( "A Strelka::App Plugin" )
+
+
+	describe "an including App" do
+
+		before( :each ) do
+			Strelka.log.debug "Creating a new Strelka::App"
+			@app = Class.new( Strelka::App ) do
+				plugin :filters
+				def initialize( appid='params-test', sspec=TEST_SEND_SPEC, rspec=TEST_RECV_SPEC )
+					super
+				end
+			end
+			Strelka.log.debug "  new instance is: %p, filters array: 0x%016x" %
+				[ @app, @app.filters.object_id * 2 ]
+		end
+
+
+		it "has a Hash of filters" do
+			@app.filters.should be_a( Hash )
+		end
+
+
+		describe "that doesn't declare any filters" do
+
+			it "doesn't have any request filters" do
+				@app.request_filters.should be_empty()
+			end
+
+			it "doesn't have any response filters" do
+				@app.response_filters.should be_empty()
+			end
+
+		end
+
+
+		describe "that declares a filter without a phase" do
+
+			before( :each ) do
+				@app.class_eval do
+					filter do |reqres|
+						if reqres.respond_to?( :notes )
+							reqres.notes[:test] = 'filtered notes'
+						else
+							reqres.body = 'filtered body'
+						end
+					end
+				end
+			end
+
+			after( :each ) do
+				@app.filters[:request].clear
+				@app.filters[:response].clear
+				@app.filters[:both].clear
+			end
+
+
+			it "has a single request filter" do
+				@app.request_filters.should have(1).member
+			end
+
+			it "has a single response filter" do
+				@app.response_filters.should have(1).member
+			end
+
+			it "passes both the request and the response through it" do
+				req = @request_factory.get( '/account/118811' )
+
+				res = @app.new.handle( req )
+
+				req.notes[:test].should == 'filtered notes'
+				res.body.should == 'filtered body'
+			end
+
+		end
+
+		describe "that declares a request filter" do
+
+			before( :each ) do
+				@app.class_eval do
+					filter( :request ) do |reqres|
+						if reqres.respond_to?( :notes )
+							reqres.notes[:test] = 'filtered notes'
+						else
+							reqres.body = 'filtered body'
+						end
+					end
+				end
+			end
+
+			after( :each ) do
+				@app.filters[:request].clear
+				@app.filters[:response].clear
+				@app.filters[:both].clear
+			end
+
+
+			it "has a single request filter" do
+				@app.request_filters.should have(1).member
+			end
+
+			it "has no response filters" do
+				@app.response_filters.should be_empty()
+			end
+
+			it "passes just the request through it" do
+				req = @request_factory.get( '/account/118811' )
+
+				res = @app.new.handle( req )
+
+				req.notes[:test].should == 'filtered notes'
+				res.body.should_not == 'filtered body'
+			end
+
+		end
+
+		describe "that declares a response filter" do
+
+			before( :each ) do
+				@app.class_eval do
+					filter( :response ) do |reqres|
+						if reqres.respond_to?( :notes )
+							reqres.notes[:test] = 'filtered notes'
+						else
+							reqres.body = 'filtered body'
+						end
+					end
+				end
+			end
+
+			after( :each ) do
+				@app.filters[:request].clear
+				@app.filters[:response].clear
+				@app.filters[:both].clear
+			end
+
+
+			it "has no request filters" do
+				@app.request_filters.should be_empty()
+			end
+
+			it "has no response filters" do
+				@app.response_filters.should have(1).member
+			end
+
+			it "passes just the response through it" do
+				req = @request_factory.get( '/account/118811' )
+
+				res = @app.new.handle( req )
+
+				req.notes[:test].should == {}
+				res.body.should == 'filtered body'
+			end
+
+		end
+
+	end
+
+
+end
+

data/spec/strelka/app/negotiation_spec.rb

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+
+BEGIN {
+	require 'pathname'
+	basedir = Pathname.new( __FILE__ ).dirname.parent.parent.parent
+	$LOAD_PATH.unshift( basedir ) unless $LOAD_PATH.include?( basedir )
+}
+
+require 'rspec'
+
+require 'spec/lib/helpers'
+
+require 'strelka'
+require 'strelka/app/plugins'
+require 'strelka/app/negotiation'
+require 'strelka/behavior/plugin'
+
+
+#####################################################################
+###	C O N T E X T S
+#####################################################################
+
+describe Strelka::App::Negotiation do
+
+
+	before( :all ) do
+		setup_logging( :fatal )
+		@request_factory = Mongrel2::RequestFactory.new( route: '/service/user' )
+	end
+
+	after( :all ) do
+		reset_logging()
+	end
+
+
+	it_should_behave_like( "A Strelka::App Plugin" )
+
+
+	describe "an including App" do
+
+		before( :each ) do
+			@app = Class.new( Strelka::App ) do
+				plugin :negotiation
+				def initialize( appid='conneg-test', sspec=TEST_SEND_SPEC, rspec=TEST_RECV_SPEC )
+					super
+				end
+			end
+		end
+
+		after( :each ) do
+			@app = nil
+		end
+
+
+		it "gets requests that have been extended with content-negotiation" do
+			req = @request_factory.get( '/service/user/estark' )
+			@app.new.handle( req )
+			req.singleton_class.included_modules.
+				should include( Strelka::HTTPRequest::Negotiation )
+		end
+
+		it "gets responses that have been extended with content-negotiation" do
+			req = @request_factory.get( '/service/user/estark' )
+			res = @app.new.handle( req )
+			res.singleton_class.included_modules.
+				should include( Strelka::HTTPResponse::Negotiation )
+		end
+
+	end
+
+
+end
+

data/spec/strelka/app/parameters_spec.rb

@@ -24,6 +24,7 @@ describe Strelka::App::Parameters do
 
 	before( :all ) do
 		setup_logging( :fatal )
+		@request_factory = Mongrel2::RequestFactory.new( route: '/user' )
 	end
 
 	after( :all ) do
@@ -39,9 +40,16 @@ describe Strelka::App::Parameters do
 		before( :each ) do
 			@app = Class.new( Strelka::App ) do
 				plugin :parameters
+				def initialize( appid='params-test', sspec=TEST_SEND_SPEC, rspec=TEST_RECV_SPEC )
+					super
+				end
 			end
 		end
 
+		after( :each ) do
+			@app = nil
+		end
+
 		it "has a parameters Hash" do
 			@app.parameters.should be_a( Hash )
 		end
@@ -56,6 +64,91 @@ describe Strelka::App::Parameters do
 				should include( :constraint => /(?<username>(?i-mx:\w+))/ )
 		end
 
+		it "can declare a parameter with an Array validation" do
+			@app.class_eval do
+				param :username, [:printable, lambda {|str| str.length <= 16 }]
+			end
+
+			@app.parameters.should have( 1 ).member
+			@app.parameters[:username][:constraint][0].should == :printable
+			@app.parameters[:username][:constraint][1].should be_an_instance_of( Proc )
+		end
+
+		it "can declare a parameter with a Hash validation" do
+			@app.class_eval do
+				param :username, {'ambrel' => 'A. Hotchgah'}
+			end
+
+			@app.parameters.should have( 1 ).member
+			@app.parameters[ :username ].
+				should include( :constraint => {'ambrel' => 'A. Hotchgah'} )
+		end
+
+		it "can declare a parameter with a matcher validation" do
+			@app.class_eval do
+				param :host, :hostname
+			end
+
+			@app.parameters.should have( 1 ).member
+			@app.parameters[ :host ].should include( :constraint => :hostname )
+		end
+
+		it "can declare a parameter with a validation pattern and a description" do
+			@app.class_eval do
+				param :username, /\w+/i, "The user's login"
+			end
+
+			@app.parameters.should have( 1 ).member
+			@app.parameters[ :username ].should include( :required => false )
+			@app.parameters[ :username ].should include( :constraint => /(?<username>(?i-mx:\w+))/ )
+			@app.parameters[ :username ].should include( :description => "The user's login" )
+		end
+
+		it "can declare a parameter with an Array validation and a description" do
+			@app.class_eval do
+				param :username, ['johnny5', 'ariel', 'hotah'], "The user's login"
+			end
+
+			@app.parameters.should have( 1 ).member
+			@app.parameters[ :username ].
+				should include( :constraint => ['johnny5', 'ariel', 'hotah'] )
+			@app.parameters[ :username ].should include( :description => "The user's login" )
+		end
+
+		it "can declare a parameter with just a description" do
+			@app.class_eval do
+				param :uuid, "UUID string"
+			end
+
+			@app.parameters.should have( 1 ).member
+			@app.parameters[ :uuid ].should include( :description => "UUID string" )
+			@app.parameters[ :uuid ].should include( :constraint => :uuid )
+		end
+
+		it "can declare a parameter with a validation pattern and a flag" do
+			@app.class_eval do
+				param :username, /\w+/i, :untaint
+			end
+
+			@app.parameters.should have( 1 ).member
+			@app.parameters[ :username ].should include( :required => false )
+			@app.parameters[ :username ].should include( :untaint => true )
+			@app.parameters[ :username ].should include( :constraint => /(?<username>(?i-mx:\w+))/ )
+			@app.parameters[ :username ].should include( :description => nil )
+		end
+
+		it "can declare a parameter with a validation Array and a flag" do
+			@app.class_eval do
+				param :username, ['amhel', 'hotah', 'aurelii'], :required
+			end
+
+			@app.parameters.should have( 1 ).member
+			@app.parameters[ :username ].should include( :required => true )
+			@app.parameters[ :username ].
+				should include( :constraint => ['amhel', 'hotah', 'aurelii'] )
+			@app.parameters[ :username ].should include( :description => nil )
+		end
+
 		it "inherits parameters from its superclass" do
 			@app.class_eval do
 				param :username, /\w+/i
@@ -67,6 +160,62 @@ describe Strelka::App::Parameters do
 				should include( :constraint => /(?<username>(?i-mx:\w+))/ )
 		end
 
+		describe "instance" do
+
+			before( :each ) do
+				@app.class_eval do
+					param :username, /\w+/, :required
+					param :id, /\d+/
+				end
+			end
+
+			it "gets requests that have had their parameters replaced with a validator" do
+				req = @request_factory.get( '/user/search' )
+				@app.new.handle( req )
+
+				req.params.should be_a( Strelka::App::ParamValidator )
+				req.params.should have_errors()
+				req.params.error_messages.should == ["Missing value for 'Username'"]
+			end
+
+			it "validates parameters from the request" do
+				req = @request_factory.get( '/user/search?username=anheptoh'.taint )
+				@app.new.handle( req )
+
+				req.params.should be_a( Strelka::App::ParamValidator )
+				req.params.should be_okay()
+				req.params.should_not have_errors()
+				req.params[:username].should == 'anheptoh'
+				req.params[:username].should be_tainted()
+			end
+
+			it "untaints all parameters if global untainting is enabled" do
+				@app.class_eval do
+					untaint_all_constraints true
+				end
+
+				@app.untaint_all_constraints.should be_true()
+				req = @request_factory.get( '/user/search?username=shereshnaheth'.taint )
+				@app.new.handle( req )
+
+				req.params[:username].should == 'shereshnaheth'
+				req.params[:username].should_not be_tainted()
+			end
+
+			it "untaints parameters flagged for untainting" do
+				@app.class_eval do
+					param :message, :printable, :untaint
+				end
+
+				req = @request_factory.get( '/user/search?message=I+love+the+circus.'.taint )
+				@app.new.handle( req )
+
+				req.params[:message].should_not be_tainted()
+				req.params[:message].should == 'I love the circus.'
+			end
+
+		end
+
 	end