strelka 0.6.0 → 0.7.0

data/spec/strelka/app/errors_spec.rb

@@ -2,17 +2,11 @@
 # vim: set nosta noet ts=4 sw=4:
 # encoding: utf-8
 
-BEGIN {
-	require 'pathname'
-	basedir = Pathname.new( __FILE__ ).dirname.parent.parent.parent
-	$LOAD_PATH.unshift( basedir ) unless $LOAD_PATH.include?( basedir )
-}
+require_relative '../../helpers'
 
 require 'rspec'
 require 'inversion'
 
-require 'spec/lib/helpers'
-
 require 'strelka'
 require 'strelka/plugins'
 require 'strelka/app/errors'
@@ -36,7 +30,7 @@ describe Strelka::App::Errors do
 	end
 
 
-	it_should_behave_like( "A Strelka::App Plugin" )
+	it_should_behave_like( "A Strelka Plugin" )
 
 
 	describe "an including App" do
@@ -55,8 +49,8 @@ describe Strelka::App::Errors do
 				'blap'
 			end
 			subclass = Class.new( @app )
-			subclass.status_handlers.should == @app.status_handlers
-			subclass.status_handlers.should_not equal( @app.status_handlers )
+			expect( subclass.status_handlers ).to eq( @app.status_handlers )
+			expect( subclass.status_handlers ).to_not equal( @app.status_handlers )
 		end
 
 		it "doesn't alter normal responses" do
@@ -72,9 +66,9 @@ describe Strelka::App::Errors do
 			req = @request_factory.get( '/koolaid' )
 			res = @app.new.handle( req )
 
-			res.status.should == HTTP::OK
+			expect( res.status ).to eq( HTTP::OK )
 			res.body.rewind
-			res.body.read.should == "Oh yeah! Kool-Aid!\n"
+			expect( res.body.read ).to eq( "Oh yeah! Kool-Aid!\n" )
 		end
 
 		it "raises an error if a handler is declared with both a template and a block" do
@@ -107,7 +101,7 @@ describe Strelka::App::Errors do
 			res = @app.new.handle( req )
 
 			res.body.rewind
-			res.body.read.should =~ /internal server error/i
+			expect( res.body.read ).to match( /internal server error/i )
 		end
 
 		it "calls a callback-style handler for any status when finished with BAD_REQUEST" do
@@ -125,9 +119,9 @@ describe Strelka::App::Errors do
 			req = @request_factory.get( '/foom' )
 			res = @app.new.handle( req )
 
-			res.status.should == HTTP::BAD_REQUEST
+			expect( res.status ).to eq( HTTP::BAD_REQUEST )
 			res.body.rewind
-			res.body.read.should == '(400) Filthy banana'
+			expect( res.body.read ).to eq( '(400) Filthy banana' )
 		end
 
 
@@ -143,7 +137,7 @@ describe Strelka::App::Errors do
 			res = @app.new.handle( req )
 
 			res.body.rewind
-			res.body.read.should == 'NOPE!'
+			expect( res.body.read ).to eq( 'NOPE!' )
 		end
 
 
@@ -159,7 +153,7 @@ describe Strelka::App::Errors do
 			res = @app.new.handle( req )
 
 			res.body.rewind
-			res.body.read.should == 'Error:  JAMBA'
+			expect( res.body.read ).to eq( 'Error:  JAMBA' )
 		end
 
 		it "sets the error status info in the transaction notes when the response is handled by a status-handler" do
@@ -177,9 +171,9 @@ describe Strelka::App::Errors do
 			req = @request_factory.get( '/foom' )
 			res = @app.new.handle( req )
 
-			res.notes[:status_info].should include( :status, :message, :headers )
-			res.notes[:status_info][:status].should == HTTP::BAD_REQUEST
-			res.notes[:status_info][:message].should == "Your sandwich is missing something."
+			expect( res.notes[:status_info] ).to include( :status, :message, :headers )
+			expect( res.notes[:status_info][:status] ).to eq( HTTP::BAD_REQUEST )
+			expect( res.notes[:status_info][:message] ).to eq( "Your sandwich is missing something." )
 		end
 
 		it "provides its own exception handler for the request phase" do
@@ -197,12 +191,12 @@ describe Strelka::App::Errors do
 			req = @request_factory.get( '/foom' )
 			res = @app.new.handle( req )
 
-			res.notes[:status_info].should include( :status, :message, :headers, :exception )
-			res.notes[:status_info][:status].should == HTTP::SERVER_ERROR
-			res.notes[:status_info][:message].should == "An uncaught exception"
-			res.notes[:status_info][:exception].should be_a( RuntimeError )
+			expect( res.notes[:status_info] ).to include( :status, :message, :headers, :exception )
+			expect( res.notes[:status_info][:status] ).to eq( HTTP::SERVER_ERROR )
+			expect( res.notes[:status_info][:message] ).to eq( "An uncaught exception" )
+			expect( res.notes[:status_info][:exception] ).to be_a( RuntimeError )
 			res.body.rewind
-			res.body.read.should == "RuntimeError"
+			expect( res.body.read ).to eq( "RuntimeError" )
 		end
 
 
@@ -235,7 +229,7 @@ describe Strelka::App::Errors do
 				res = @app.new.handle( req )
 
 				res.body.rewind
-				res.body.read.should =~ /error-handler template/i
+				expect( res.body.read ).to match( /error-handler template/i )
 			end
 		end
 

data/spec/strelka/app/filters_spec.rb

@@ -2,16 +2,10 @@
 # vim: set nosta noet ts=4 sw=4:
 # encoding: utf-8
 
-BEGIN {
-	require 'pathname'
-	basedir = Pathname.new( __FILE__ ).dirname.parent.parent.parent
-	$LOAD_PATH.unshift( basedir ) unless $LOAD_PATH.include?( basedir )
-}
+require_relative '../../helpers'
 
 require 'rspec'
 
-require 'spec/lib/helpers'
-
 require 'strelka'
 require 'strelka/plugins'
 require 'strelka/app/filters'
@@ -35,10 +29,10 @@ describe Strelka::App::Filters do
 	end
 
 
-	it_should_behave_like( "A Strelka::App Plugin" )
+	it_should_behave_like( "A Strelka Plugin" )
 
 
-	describe "an including App" do
+	context "an including App" do
 
 		before( :each ) do
 			@app = Class.new( Strelka::App ) do
@@ -55,41 +49,39 @@ describe Strelka::App::Filters do
 			end
 			subclass = Class.new( @app )
 
-			subclass.filters.should == @app.filters
-			subclass.filters.should_not equal( @app.filters )
-			subclass.filters[:request].should_not equal( @app.filters[:request] )
-			subclass.filters[:response].should_not equal( @app.filters[:response] )
-			subclass.filters[:both].should_not equal( @app.filters[:both] )
+			expect( subclass.filters ).to eq( @app.filters )
+			expect( subclass.filters ).to_not equal( @app.filters )
+			expect( subclass.filters[:request] ).to_not equal( @app.filters[:request] )
+			expect( subclass.filters[:response] ).to_not equal( @app.filters[:response] )
+			expect( subclass.filters[:both] ).to_not equal( @app.filters[:both] )
 		end
 
 		it "has a Hash of filters" do
-			@app.filters.should be_a( Hash )
+			expect( @app.filters ).to be_a( Hash )
 		end
 
 
-		describe "that doesn't declare any filters" do
+		context "that doesn't declare any filters" do
 
 			it "doesn't have any request filters" do
-				@app.request_filters.should be_empty()
+				expect( @app.request_filters ).to be_empty()
 			end
 
 			it "doesn't have any response filters" do
-				@app.response_filters.should be_empty()
+				expect( @app.response_filters ).to be_empty()
 			end
 
 		end
 
 
-		describe "that declares a filter without a phase" do
+		context "that declares a filter without a phase" do
 
 			before( :each ) do
-				@app.class_eval do
-					filter do |reqres|
-						if reqres.is_a?( Strelka::HTTPRequest )
-							reqres.notes[:saw][:request] = true
-						else
-							reqres.notes[:saw][:response] = true
-						end
+				@app.filter do |reqres|
+					if reqres.is_a?( Strelka::HTTPRequest )
+						reqres.notes[:saw][:request] = true
+					else
+						reqres.notes[:saw][:response] = true
 					end
 				end
 			end
@@ -102,11 +94,11 @@ describe Strelka::App::Filters do
 
 
 			it "has a single request filter" do
-				@app.request_filters.should have(1).member
+				expect( @app.request_filters ).to have(1).member
 			end
 
 			it "has a single response filter" do
-				@app.response_filters.should have(1).member
+				expect( @app.response_filters ).to have(1).member
 			end
 
 			it "passes both the request and the response through it" do
@@ -114,22 +106,20 @@ describe Strelka::App::Filters do
 
 				res = @app.new.handle( req )
 
-				req.notes[:saw][:request].should be_true()
-				res.notes[:saw][:response].should be_true()
+				expect( req.notes[:saw][:request] ).to be_true()
+				expect( res.notes[:saw][:response] ).to be_true()
 			end
 
 		end
 
-		describe "that declares a request filter" do
+		context "that declares a request filter" do
 
 			before( :each ) do
-				@app.class_eval do
-					filter( :request ) do |reqres|
-						if reqres.is_a?( Strelka::HTTPRequest )
-							reqres.notes[:saw][:request] = true
-						else
-							reqres.notes[:saw][:response] = true
-						end
+				@app.filter( :request ) do |reqres|
+					if reqres.is_a?( Strelka::HTTPRequest )
+						reqres.notes[:saw][:request] = true
+					else
+						reqres.notes[:saw][:response] = true
 					end
 				end
 			end
@@ -142,11 +132,11 @@ describe Strelka::App::Filters do
 
 
 			it "has a single request filter" do
-				@app.request_filters.should have(1).member
+				expect( @app.request_filters ).to have(1).member
 			end
 
 			it "has no response filters" do
-				@app.response_filters.should be_empty()
+				expect( @app.response_filters ).to be_empty()
 			end
 
 			it "passes just the request through it" do
@@ -154,22 +144,20 @@ describe Strelka::App::Filters do
 
 				res = @app.new.handle( req )
 
-				req.notes[:saw][:request].should be_true()
-				res.notes[:saw][:response].should be_nil()
+				expect( req.notes[:saw][:request] ).to be_true()
+				expect( res.notes[:saw][:response] ).to be_nil()
 			end
 
 		end
 
-		describe "that declares a response filter" do
+		context "that declares a response filter" do
 
 			before( :each ) do
-				@app.class_eval do
-					filter( :response ) do |reqres|
-						if reqres.is_a?( Strelka::HTTPRequest )
-							reqres.notes[:saw][:request] = true
-						else
-							reqres.notes[:saw][:response] = true
-						end
+				@app.filter( :response ) do |reqres|
+					if reqres.is_a?( Strelka::HTTPRequest )
+						reqres.notes[:saw][:request] = true
+					else
+						reqres.notes[:saw][:response] = true
 					end
 				end
 			end
@@ -182,11 +170,11 @@ describe Strelka::App::Filters do
 
 
 			it "has no request filters" do
-				@app.request_filters.should be_empty()
+				expect( @app.request_filters ).to be_empty()
 			end
 
 			it "has no response filters" do
-				@app.response_filters.should have(1).member
+				expect( @app.response_filters ).to have(1).member
 			end
 
 			it "passes just the response through it" do
@@ -194,10 +182,35 @@ describe Strelka::App::Filters do
 
 				res = @app.new.handle( req )
 
-				req.notes[:saw][:request].should be_nil()
-				res.notes[:saw][:response].should be_true()
+				expect( req.notes[:saw][:request] ).to be_nil()
+				expect( res.notes[:saw][:response] ).to be_true()
+			end
+
+		end
+
+
+		context "that returns something other than an HTTPResponse from its handler" do
+
+			before( :each ) do
+				@app.class_eval do
+					plugin :templating
+					templates :main => 'spec/data/main.tmpl'
+					def handle_request( req )
+						super { :main }
+					end
+				end
 			end
 
+			it "still gives the response filter an HTTPResponse" do
+				@app.filter( :response ) do |res|
+					expect( res ).to be_a( Strelka::HTTPResponse )
+				end
+
+				req = @request_factory.get( '/account/118811' )
+				res = @app.new.handle( req )
+
+				expect( res.status_line ).to match( /200 ok/i )
+			end
 		end
 
 	end

data/spec/strelka/app/negotiation_spec.rb

@@ -2,16 +2,10 @@
 # vim: set nosta noet ts=4 sw=4:
 # encoding: utf-8
 
-BEGIN {
-	require 'pathname'
-	basedir = Pathname.new( __FILE__ ).dirname.parent.parent.parent
-	$LOAD_PATH.unshift( basedir ) unless $LOAD_PATH.include?( basedir )
-}
+require_relative '../../helpers'
 
 require 'rspec'
 
-require 'spec/lib/helpers'
-
 require 'strelka'
 require 'strelka/plugins'
 require 'strelka/app/negotiation'
@@ -35,7 +29,7 @@ describe Strelka::App::Negotiation do
 	end
 
 
-	it_should_behave_like( "A Strelka::App Plugin" )
+	it_should_behave_like( "A Strelka Plugin" )
 
 
 	describe "an including App" do
@@ -70,22 +64,22 @@ describe Strelka::App::Negotiation do
 		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 )
+			expect( req.singleton_class.included_modules ).
+				to 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 )
+			expect( res.singleton_class.included_modules ).
+				to include( Strelka::HTTPResponse::Negotiation )
 		end
 
 		it "adds custom content-type transforms to outgoing responses" do
 			req = @request_factory.get( '/service/user/astark', :accept => 'text/x-tnetstring' )
 			res = @app.new.handle( req )
-			res.content_type.should == 'text/x-tnetstring'
-			res.body.read.should == '28:2:an,19:5:array,8:of stuff,}]'
+			expect( res.content_type ).to eq( 'text/x-tnetstring' )
+			expect( res.body.read ).to eq( '28:2:an,19:5:array,8:of stuff,}]' )
 		end
 
 	end

data/spec/strelka/app/parameters_spec.rb

@@ -2,16 +2,10 @@
 # vim: set nosta noet ts=4 sw=4:
 # encoding: utf-8
 
-BEGIN {
-	require 'pathname'
-	basedir = Pathname.new( __FILE__ ).dirname.parent.parent.parent
-	$LOAD_PATH.unshift( basedir ) unless $LOAD_PATH.include?( basedir )
-}
+require_relative '../../helpers'
 
 require 'rspec'
 
-require 'spec/lib/helpers'
-
 require 'strelka'
 require 'strelka/plugins'
 require 'strelka/app/parameters'
@@ -34,7 +28,7 @@ describe Strelka::App::Parameters do
 	end
 
 
-	it_should_behave_like( "A Strelka::App Plugin" )
+	it_should_behave_like( "A Strelka Plugin" )
 
 
 	describe "an including App" do
@@ -56,12 +50,12 @@ describe Strelka::App::Parameters do
 			@app.param :string
 			subclass = Class.new( @app )
 
-			subclass.paramvalidator.param_names.should == @app.paramvalidator.param_names
-			subclass.paramvalidator.should_not equal( @app.paramvalidator )
+			expect( subclass.paramvalidator.param_names ).to eq( @app.paramvalidator.param_names )
+			expect( subclass.paramvalidator ).to_not equal( @app.paramvalidator )
 		end
 
 		it "has a ParamValidator" do
-			@app.paramvalidator.should be_a( Strelka::ParamValidator )
+			expect( @app.paramvalidator ).to be_a( Strelka::ParamValidator )
 		end
 
 		it "can declare a parameter with a regular-expression constraint" do
@@ -69,7 +63,7 @@ describe Strelka::App::Parameters do
 				param :username, /\w+/i
 			end
 
-			@app.paramvalidator.param_names.should == [ 'username' ]
+			expect( @app.paramvalidator.param_names ).to eq( [ 'username' ] )
 		end
 
 		it "can declare a parameter with a builtin constraint" do
@@ -77,7 +71,7 @@ describe Strelka::App::Parameters do
 				param :comment_body, :printable
 			end
 
-			@app.paramvalidator.param_names.should == [ 'comment_body' ]
+			expect( @app.paramvalidator.param_names ).to eq( [ 'comment_body' ] )
 		end
 
 		it "can declare a parameter with a Proc constraint" do
@@ -87,7 +81,7 @@ describe Strelka::App::Parameters do
 				end
 			end
 
-			@app.paramvalidator.param_names.should == [ 'start_time' ]
+			expect( @app.paramvalidator.param_names ).to eq( [ 'start_time' ] )
 		end
 
 
@@ -98,7 +92,7 @@ describe Strelka::App::Parameters do
 				end
 			end
 
-			@app.paramvalidator.param_names.should == [ 'created_at' ]
+			expect( @app.paramvalidator.param_names ).to eq( [ 'created_at' ] )
 		end
 
 
@@ -108,7 +102,7 @@ describe Strelka::App::Parameters do
 			end
 			subapp = Class.new( @app )
 
-			subapp.paramvalidator.param_names.should == [ 'username' ]
+			expect( subapp.paramvalidator.param_names ).to eq( [ 'username' ] )
 		end
 
 		describe "instance" do
@@ -124,20 +118,20 @@ describe Strelka::App::Parameters do
 				req = @request_factory.get( '/user/search' )
 				@app.new.handle( req )
 
-				req.params.should be_a( Strelka::ParamValidator )
-				req.params.should have_errors()
-				req.params.error_messages.should == ["Missing value for 'Username'"]
+				expect( req.params ).to be_a( Strelka::ParamValidator )
+				expect( req.params ).to have_errors()
+				expect( req.params.error_messages ).to eq( ["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::ParamValidator )
-				req.params.should be_okay()
-				req.params.should_not have_errors()
-				req.params[:username].should == 'anheptoh'
-				req.params[:username].should be_tainted()
+				expect( req.params ).to be_a( Strelka::ParamValidator )
+				expect( req.params ).to be_okay()
+				expect( req.params ).to_not have_errors()
+				expect( req.params[:username] ).to eq( 'anheptoh' )
+				expect( req.params[:username] ).to be_tainted()
 			end
 
 			it "untaints all parameters if global untainting is enabled" do
@@ -145,12 +139,12 @@ describe Strelka::App::Parameters do
 					untaint_all_constraints true
 				end
 
-				@app.untaint_all_constraints.should be_true()
+				expect( @app.untaint_all_constraints ).to 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()
+				expect( req.params[:username] ).to eq( 'shereshnaheth' )
+				expect( req.params[:username] ).to_not be_tainted()
 			end
 
 			it "untaints parameters flagged for untainting" do
@@ -161,8 +155,8 @@ describe Strelka::App::Parameters do
 				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.'
+				expect( req.params[:message] ).to_not be_tainted()
+				expect( req.params[:message] ).to eq( 'I love the circus.' )
 			end
 
 		end