strelka 0.0.1pre4 → 0.0.1.pre129

data/spec/strelka/app/routing_spec.rb

@@ -25,6 +25,7 @@ describe Strelka::App::Routing do
 
 	before( :all ) do
 		setup_logging( :fatal )
+		@request_factory = Mongrel2::RequestFactory.new( route: '' )
 	end
 
 	after( :all ) do
@@ -41,6 +42,9 @@ describe Strelka::App::Routing do
 			Strelka.log.debug "Creating a new Strelka::App"
 			@app = Class.new( Strelka::App ) do
 				plugin :routing
+				def initialize( appid='params-test', sspec=TEST_SEND_SPEC, rspec=TEST_RECV_SPEC )
+					super
+				end
 			end
 			Strelka.log.debug "  new instance is: %p, routes array: 0x%016x" %
 				[ @app, @app.routes.object_id * 2 ]
@@ -51,6 +55,32 @@ describe Strelka::App::Routing do
 			@app.routes.should be_a( Array )
 		end
 
+		it "knows what its route methods are" do
+			@app.route_methods.should == []
+			@app.class_eval do
+				get() {}
+				post( '/clowns' ) {}
+				options( '/clowns' ) {}
+			end
+
+			@app.route_methods.should == [ :GET, :POST_clowns, :OPTIONS_clowns ]
+		end
+
+		# OPTIONS GET/HEAD POST PUT DELETE TRACE CONNECT
+
+		it "can declare a OPTIONS route" do
+			@app.routes.should be_empty()
+
+			@app.class_eval do
+				options do |req|
+				end
+			end
+
+			@app.routes.should == [
+				[ :OPTIONS, [], {action: @app.instance_method(:OPTIONS), options: {}} ]
+			]
+		end
+
 		it "can declare a GET route" do
 			@app.routes.should be_empty()
 
@@ -59,9 +89,76 @@ describe Strelka::App::Routing do
 				end
 			end
 
-			@app.routes.should == [[ :GET, [], @app.instance_method(:GET), {} ]]
+			@app.routes.should == [
+				[ :GET, [], {action: @app.instance_method(:GET), options: {}} ]
+			]
+		end
+
+		it "can declare a POST route" do
+			@app.routes.should be_empty()
+
+			@app.class_eval do
+				post do |req|
+				end
+			end
+
+			@app.routes.should == [
+				[ :POST, [], {action: @app.instance_method(:POST), options: {}} ]
+			]
+		end
+
+		it "can declare a PUT route" do
+			@app.routes.should be_empty()
+
+			@app.class_eval do
+				put do |req|
+				end
+			end
+
+			@app.routes.should == [[ :PUT, [], {action: @app.instance_method(:PUT), options: {}} ]]
+		end
+
+		it "can declare a DELETE route" do
+			@app.routes.should be_empty()
+
+			@app.class_eval do
+				delete do |req|
+				end
+			end
+
+			@app.routes.should == [
+				[ :DELETE, [], {action: @app.instance_method(:DELETE), options: {}} ]
+			]
+		end
+
+		it "can declare a TRACE route" do
+			@app.routes.should be_empty()
+
+			@app.class_eval do
+				trace do |req|
+				end
+			end
+
+			@app.routes.should == [
+				[ :TRACE, [], {action: @app.instance_method(:TRACE), options: {}} ]
+			]
+		end
+
+		it "can declare a CONNECT route" do
+			@app.routes.should be_empty()
+
+			@app.class_eval do
+				connect do |req|
+				end
+			end
+
+			@app.routes.should == [
+				[ :CONNECT, [], {action: @app.instance_method(:CONNECT), options: {}} ]
+			]
 		end
 
+
+
 		it "allows a route to specify a path" do
 			@app.routes.should be_empty()
 
@@ -70,7 +167,9 @@ describe Strelka::App::Routing do
 				end
 			end
 
-			@app.routes.should == [[ :GET, ['info'], @app.instance_method(:GET_info), {} ]]
+			@app.routes.should == [
+				[ :GET, ['info'], {action: @app.instance_method(:GET_info), options: {}} ]
+			]
 		end
 
 		it "allows a route to omit the leading '/' when specifying a path" do
@@ -79,23 +178,48 @@ describe Strelka::App::Routing do
 				end
 			end
 
-			@app.routes.should == [[ :GET, ['info'], @app.instance_method(:GET_info), {} ]]
+			@app.routes.should == [
+				[ :GET, ['info'], {action: @app.instance_method(:GET_info), options: {}} ]
+			]
 		end
 
 
 		it "uses the Strelka::App::DefaultRouter as it's router by default" do
-			@app.routerclass.should equal( Strelka::App::DefaultRouter )
+			@app.routerclass.should == :default
+			@app.new.router.should be_a( Strelka::App::DefaultRouter )
 		end
 
 		it "can specify a different Router class than the default" do
-			class MyRouter < Strelka::App::DefaultRouter; end
+			class MyRouter < Strelka::App::Router; end
 			@app.class_eval do
 				router MyRouter
 			end
 			@app.routerclass.should equal( MyRouter )
+			@app.new.router.should be_a( MyRouter )
 		end
 
 
+		it "has its routes inherited by subclasses" do
+			@app.class_eval do
+				get( '/info' ) {}
+				get( '/about' ) {}
+				get( '/origami' ) {}
+			end
+			subclass = Class.new( @app ) do
+				get( '/origami' ) {}
+			end
+
+			subclass.routes.should have( 3 ).members
+
+			subclass.routes.
+				should include([ :GET, ['info'], {action: @app.instance_method(:GET_info), options: {}} ])
+			subclass.routes.
+				should include([ :GET, ['about'], {action: @app.instance_method(:GET_about), options: {}} ])
+			subclass.routes.should include(
+				[ :GET, ['origami'], {action: subclass.instance_method(:GET_origami), options: {}} ]
+			)
+		end
+
 		describe "that also uses the :parameters plugin" do
 
 			before( :each ) do
@@ -109,15 +233,65 @@ describe Strelka::App::Routing do
 					end
 				end
 
-				@app.routes.should == 
-					[[ :POST, ['userinfo', /(?<username>(?i-mx:[a-z]\w+))/], 
-					   @app.instance_method(:POST_userinfo__username), {} ]]
+				@app.routes.should ==
+					[[ :POST, ['userinfo', /(?<username>(?i-mx:[a-z]\w+))/],
+					   {action: @app.instance_method(:POST_userinfo__username), options: {}} ]]
+			end
+
+			it "unbinds parameter patterns bound with ^ and $ for the route" do
+				@app.class_eval do
+					param :username, /^[a-z]\w+$/i
+					post '/userinfo/:username' do |req|
+					end
+				end
+
+				@app.routes.should ==
+					[[ :POST, ['userinfo', /(?<username>(?i-mx:[a-z]\w+))/],
+					   {action: @app.instance_method(:POST_userinfo__username), options: {}} ]]
+			end
+
+			it "unbinds parameter patterns bound with \\A and \\z for the route" do
+				@app.class_eval do
+					param :username, /\A[a-z]\w+\z/i
+					post '/userinfo/:username' do |req|
+					end
+				end
+
+				@app.routes.should ==
+					[[ :POST, ['userinfo', /(?<username>(?i-mx:[a-z]\w+))/],
+					   {action: @app.instance_method(:POST_userinfo__username), options: {}} ]]
+			end
+
+			it "unbinds parameter patterns bound with \\Z for the route" do
+				@app.class_eval do
+					param :username, /\A[a-z]\w+\Z/i
+					post '/userinfo/:username' do |req|
+					end
+				end
+
+				@app.routes.should ==
+					[[ :POST, ['userinfo', /(?<username>(?i-mx:[a-z]\w+))/],
+					  {action: @app.instance_method(:POST_userinfo__username), options: {}} ]]
+			end
+
+			it "merges parameters from the route path into the request's param validator" do
+				@app.class_eval do
+					param :username, /\A[a-z]\w+\Z/i
+					get '/userinfo/:username' do |req|
+					end
+				end
+
+				req = @request_factory.get( '/userinfo/benthik' )
+				@app.new.handle( req )
+
+				req.params[:username].should == 'benthik'
 			end
 
 
 			it "raises a ScriptError if a route is defined with a param without it having first " +
 			   "been set up" do
-				# RSpec's expect {},to only rescues RuntimeErrors, so we have to do this ourselves.
+				# RSpec's "expect {}.to" construct only rescues RuntimeErrors, so we have to do
+				# this ourselves.
 				begin
 					@app.get( '/userinfo/:username' ) {}
 				rescue ScriptError => err

data/spec/strelka/app/templating_spec.rb

@@ -87,12 +87,11 @@ describe Strelka::App::Templating do
 				@app.class_eval do
 					templates :main => 'main.tmpl'
 				end
-				@instance = @app.new( 'template-test', 'tcp://127.0.0.1:9999', 'tcp://127.0.0.1:9998' )
 			end
 
 
 			it "can load declared templates by mentioning the symbol" do
-				@instance.template( :main ).should be_a( Inversion::Template )
+				@app.new.template( :main ).should be_a( Inversion::Template )
 			end
 
 			it "can respond with just a template name" do

data/spec/strelka/app_spec.rb

@@ -25,6 +25,14 @@ describe Strelka::App do
 	before( :all ) do
 		setup_logging( :fatal )
 		@request_factory = Mongrel2::RequestFactory.new( route: '/mail' )
+		Mongrel2::Config.db = Mongrel2::Config.in_memory_db
+		Mongrel2::Config.init_database
+
+		# Skip loading the 'strelka' gem, which probably doesn't exist in the right version
+		strelkaspec = make_gemspec( 'strelka', '0.0.1', false )
+		loaded_specs = Gem.instance_variable_get( :@loaded_specs )
+		loaded_specs['strelka'] = strelkaspec
+
 	end
 
 	before( :each ) do
@@ -32,17 +40,119 @@ describe Strelka::App do
 			def initialize( appid=TEST_APPID, sspec=TEST_SEND_SPEC, rspec=TEST_RECV_SPEC )
 				super
 			end
+			def set_signal_handlers; end
+			def start_accepting_requests; end
+			def restore_signal_handlers; end
 		end
 		@req = @request_factory.get( '/mail/inbox' )
 	end
 
+	after( :each ) do
+		@app = nil
+	end
+
 	after( :all ) do
 		reset_logging()
 	end
 
 
-	it "returns a No Content response by default" do
+	#
+	# Helpers
+	#
+
+	def make_gemspec( name, version, strelka_dep=true )
+		spec = Gem::Specification.new( name, version )
+		spec.add_runtime_dependency( 'strelka', '~> 0.0' ) if strelka_dep
+		return spec
+	end
+
+
+	#
+	# Examples
+	#
+
+	it "has a method for loading app class/es from a file" do
+		app_file = 'an_app.rb'
+		app_path = Pathname( 'an_app.rb' ).expand_path
+		app_class = nil
+
+		Kernel.should_receive( :load ).with( app_path.to_s ).and_return do
+			app_class = Class.new( Strelka::App )
+		end
+		Strelka::App.load( app_file ).should == [ app_class ]
+	end
+
+	it "has a method for discovering installed Strelka app files" do
+		specs = {}
+		specs[:donkey]     = make_gemspec( 'donkey',  '1.0.0' )
+		specs[:rabbit_old] = make_gemspec( 'rabbit',  '1.0.0' )
+		specs[:rabbit_new] = make_gemspec( 'rabbit',  '1.0.8' )
+		specs[:bear]       = make_gemspec( 'bear',    '1.0.0', false )
+		specs[:giraffe]    = make_gemspec( 'giraffe', '1.0.0' )
+
+		expectation = Gem::Specification.should_receive( :each )
+		specs.values.each {|spec| expectation.and_yield(spec) }
+
+		donkey_path  = specs[:donkey].full_gem_path
+		rabbit_path  = specs[:rabbit_new].full_gem_path
+		giraffe_path = specs[:giraffe].full_gem_path
+
+		Dir.should_receive( :glob ).with( "#{giraffe_path}/data/giraffe/{apps,handlers}/**/*" ).
+			and_return([ "#{giraffe_path}/data/giraffe/apps/app" ])
+		Dir.should_receive( :glob ).with( "#{rabbit_path}/data/rabbit/{apps,handlers}/**/*" ).
+			and_return([ "#{rabbit_path}/data/rabbit/apps/subdir/app1.rb",
+			             "#{rabbit_path}/data/rabbit/apps/subdir/app2.rb" ])
+		Dir.should_receive( :glob ).with( "#{donkey_path}/data/donkey/{apps,handlers}/**/*" ).
+			and_return([ "#{donkey_path}/data/donkey/apps/app.rb" ])
+
+		app_paths = Strelka::App.discover_paths
+
+		# app_paths.should have( 4 ).members
+		app_paths.should include(
+			'donkey'  => [Pathname("#{donkey_path}/data/donkey/apps/app.rb")],
+			'rabbit'  => [Pathname("#{rabbit_path}/data/rabbit/apps/subdir/app1.rb"),
+			              Pathname("#{rabbit_path}/data/rabbit/apps/subdir/app2.rb")],
+			'giraffe' => [Pathname("#{giraffe_path}/data/giraffe/apps/app")]
+		)
+	end
+
+	it "has a method for loading discovered app classes from installed Strelka app files" do
+		gemspec = make_gemspec( 'blood-orgy', '0.0.3' )
+		Gem::Specification.should_receive( :each ).and_yield( gemspec ).at_least( :once )
+
+		Dir.should_receive( :glob ).with( "#{gemspec.full_gem_path}/data/blood-orgy/{apps,handlers}/**/*" ).
+			and_return([ "#{gemspec.full_gem_path}/data/blood-orgy/apps/kurzweil" ])
+
+		Kernel.stub( :load ).
+			with( "#{gemspec.full_gem_path}/data/blood-orgy/apps/kurzweil" ).
+			and_return do
+				Class.new( Strelka::App )
+				true
+			end
+
+		app_classes = Strelka::App.discover
+		app_classes.should have( 1 ).member
+		app_classes.first.should be_a( Class )
+		app_classes.first.should < Strelka::App
+	end
+
+	it "handles exceptions while loading discovered apps" do
+		gemspec = make_gemspec( 'blood-orgy', '0.0.3' )
+		Gem::Specification.should_receive( :each ).and_yield( gemspec ).at_least( :once )
+
+		Dir.should_receive( :glob ).with( "#{gemspec.full_gem_path}/data/blood-orgy/{apps,handlers}/**/*" ).
+			and_return([ "#{gemspec.full_gem_path}/data/blood-orgy/apps/kurzweil" ])
+
+		Kernel.stub( :load ).
+			with( "#{gemspec.full_gem_path}/data/blood-orgy/apps/kurzweil" ).
+			and_raise( SyntaxError.new("kurzweil:1: syntax error, unexpected coffeeshop philosopher") )
+
+		app_classes = Strelka::App.discover
+		app_classes.should be_empty()
+	end
 
+
+	it "returns a No Content response by default" do
 		res = @app.new.handle( @req )
 
 		res.should be_a( Mongrel2::HTTPResponse )
@@ -91,9 +201,30 @@ describe Strelka::App do
 	end
 
 
+	it "uses the specified content type for error responses" do
+		# make an auth plugin that always denies requests
+		forbidden_plugin = Module.new do
+			extend Strelka::App::Plugin
+			def handle_request( r )
+				finish_with( HTTP::FORBIDDEN, "You aren't allowed to look at that.",
+					:content_type => 'text/html' )
+				fail "Shouldn't be reached."
+			end
+		end
+		@app.plugin( forbidden_plugin )
+
+		res = @app.new.handle( @req )
+
+		res.should be_a( Mongrel2::HTTPResponse )
+		res.status_line.should == 'HTTP/1.1 403 Forbidden'
+		res.content_type.should == 'text/html'
+		res.body.should == "You aren't allowed to look at that.\n"
+	end
+
+
 	it "provides a declarative for setting the default content type of responses" do
 		@app.class_eval do
-			default_content_type 'text/css'
+			default_type 'text/css'
 			def handle_request( r )
 				r.response.puts( "body { font-family: monospace }" )
 				r.response
@@ -106,54 +237,156 @@ describe Strelka::App do
 		res.content_type.should == 'text/css'
 	end
 
-
-	it "provides a plugin hook for plugins to manipulate the request before handling it" do
-		# make a fixup plugin that adds a custom x- header to the request
-		header_fixup_plugin = Module.new do
-			extend Strelka::App::Plugin
-			def fixup_request( r )
-				r.headers[:x_funted_by] = 'Cragnux/1.1.3'
-				super
-			end
+	it "doesn't override an explicitly-set content-type header with the default" do
+		@app.class_eval do
+			default_type 'text/css'
 			def handle_request( r )
-				res = r.response
-				res.puts( "Request was funted by %s!" % [r.headers.x_funted_by] )
-				res.status = HTTP::OK
-				return res
+				r.response.puts( "I lied, I'm actually returning text." )
+				r.response.content_type = 'text/plain'
+				r.response
 			end
 		end
-		@app.plugin( header_fixup_plugin )
 
 		res = @app.new.handle( @req )
 
 		res.should be_a( Mongrel2::HTTPResponse )
-		res.status_line.should == 'HTTP/1.1 200 OK'
-		res.body.should == "Request was funted by Cragnux/1.1.3!\n"
+		res.content_type.should == 'text/plain'
 	end
 
 
-	it "provides a plugin hook for plugins to manipulate the response before it's returned to Mongrel2" do
-		# make a fixup plugin that adds a custom x- header to the response
-		header_fixup_plugin = Module.new do
-			extend Strelka::App::Plugin
-			def fixup_response( req, res )
-				res.headers.x_funted_by = 'Cragnux/1.1.3'
-				super
+	it "automatically truncates HEAD responses" do
+		@app.class_eval do
+			default_type 'text/plain'
+			def handle_request( r )
+				r.response.puts( "Rendered output." )
+				r.response
 			end
+		end
+
+		req = @request_factory.head( '/mail/inbox' )
+		res = @app.new.handle( req )
+
+		res.should be_a( Mongrel2::HTTPResponse )
+		res.content_type.should == 'text/plain'
+		res.body.should be_empty()
+		res.headers.content_length.should == "Rendered output.\n".bytesize
+	end
+
+
+	it "uses the app's ID constant for the appid if .run is called without one" do
+		@app.const_set( :ID, 'testing-app' )
+
+		Mongrel2::Handler.should_receive( :connection_info_for ).with( 'testing-app' ).
+			and_return([ TEST_SEND_SPEC, TEST_RECV_SPEC ])
+		Mongrel2::Connection.should_receive( :new ).
+			with( 'testing-app', TEST_SEND_SPEC, TEST_RECV_SPEC ).
+			and_return( :a_connection )
+
+		@app.run
+	end
+
+
+	it "uses the app's name for the appid if .run is called without one and it has no ID constant" do
+		@app.class_eval do
+			def self::name; "My::First::Blog" ; end
+		end
+
+		Mongrel2::Handler.should_receive( :connection_info_for ).with( 'my-first-blog' ).
+			and_return([ TEST_SEND_SPEC, TEST_RECV_SPEC ])
+		Mongrel2::Connection.should_receive( :new ).
+			with( 'my-first-blog', TEST_SEND_SPEC, TEST_RECV_SPEC ).
+			and_return( :a_connection )
+
+		@app.run
+	end
+
+
+	it "handles uncaught exceptions with a SERVER_ERROR response" do
+		@app.class_eval do
 			def handle_request( r )
-				res = r.response
-				res.puts( "Funt this" )
-				res.status = HTTP::OK
-				return res
+				raise "Something went wrong."
 			end
 		end
-		@app.plugin( header_fixup_plugin )
 
 		res = @app.new.handle( @req )
 
 		res.should be_a( Mongrel2::HTTPResponse )
-		res.status_line.should == 'HTTP/1.1 200 OK'
-		res.header_data.should =~ %r{X-Funted-By: Cragnux/1.1.3}
+		res.status.should == HTTP::SERVER_ERROR
+		res.content_type = 'text/plain'
+		res.body.should =~ /internal server error/i
+	end
+
+
+	describe "process name" do
+
+		before( :all ) do
+			$old_0 = $0
+		end
+
+		after( :all ) do
+			$0 = $old_0
+		end
+
+		it "sets the process name to something more interesting than the command line" do
+			@app.new.run
+
+			$0.should =~ /#{@app.inspect}/
+			$0.should =~ %r|\{\S+\} tcp://\S+ <-> \S+|
+		end
+
+	end
+
+	describe "plugin hooks" do
+
+		it "provides a plugin hook for plugins to manipulate the request before handling it" do
+			# make a fixup plugin that adds a custom x- header to the request
+			header_fixup_plugin = Module.new do
+				extend Strelka::App::Plugin
+				def fixup_request( r )
+					r.headers[:x_funted_by] = 'Cragnux/1.1.3'
+					super
+				end
+				def handle_request( r )
+					res = r.response
+					res.puts( "Request was funted by %s!" % [r.headers.x_funted_by] )
+					res.status = HTTP::OK
+					return res
+				end
+			end
+			@app.plugin( header_fixup_plugin )
+
+			res = @app.new.handle( @req )
+
+			res.should be_a( Mongrel2::HTTPResponse )
+			res.status_line.should == 'HTTP/1.1 200 OK'
+			res.body.should == "Request was funted by Cragnux/1.1.3!\n"
+		end
+
+
+		it "provides a plugin hook for plugins to manipulate the response before it's returned to Mongrel2" do
+			# make a fixup plugin that adds a custom x- header to the response
+			header_fixup_plugin = Module.new do
+				extend Strelka::App::Plugin
+				def fixup_response( res )
+					res.headers.x_funted_by = 'Cragnux/1.1.3'
+					super
+				end
+				def handle_request( r )
+					res = r.response
+					res.puts( "Funt this" )
+					res.status = HTTP::OK
+					return res
+				end
+			end
+			@app.plugin( header_fixup_plugin )
+
+			res = @app.new.handle( @req )
+
+			res.should be_a( Mongrel2::HTTPResponse )
+			res.status_line.should == 'HTTP/1.1 200 OK'
+			res.header_data.should =~ %r{X-Funted-By: Cragnux/1.1.3}
+		end
+
 	end
 
 end

data/spec/strelka/exceptions_spec.rb

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+
+BEGIN {
+	require 'pathname'
+	basedir = Pathname.new( __FILE__ ).dirname.parent.parent
+	$LOAD_PATH.unshift( basedir ) unless $LOAD_PATH.include?( basedir )
+}
+
+require 'rspec'
+require 'zmq'
+require 'mongrel2'
+
+require 'spec/lib/helpers'
+
+require 'strelka'
+require 'strelka/exceptions'
+
+
+#####################################################################
+###	C O N T E X T S
+#####################################################################
+
+describe Strelka, "exception classes" do
+
+	before( :all ) do
+		setup_logging( :fatal )
+		@request_factory = Mongrel2::RequestFactory.new( route: '/exceptions' )
+	end
+
+	after( :all ) do
+		reset_logging()
+	end
+
+
+	describe Strelka::RequestError do
+
+		it "keeps track of the request that had the error" do
+			req = @request_factory.get( '/exceptions/spec' )
+			exception = nil
+
+			begin
+				raise Strelka::RequestError.new( req, "invalid request" )
+			rescue Strelka::RequestError => err
+				exception = err
+			end
+
+			exception.request.should == req
+		end
+
+	end
+
+end
+