strelka 0.0.1.pre.187 → 0.0.1.pre.193

data/spec/strelka/httprequest/session_spec.rb

@@ -25,7 +25,7 @@ require 'strelka/session/default'
 ###	C O N T E X T S
 #####################################################################
 
-describe Strelka::HTTPRequest::Session do
+describe Strelka::HTTPRequest::Session, "-extended request" do
 
 	before( :all ) do
 		setup_logging( :fatal )
@@ -48,54 +48,75 @@ describe Strelka::HTTPRequest::Session do
 	end
 
 
-	describe "an HTTPRequest with no session loaded" do
+	it "has a session_namespace attribute" do
+		@req.should respond_to( :session_namespace )
+	end
 
-		it "has a session_namespace attribute" do
-			@req.should respond_to( :session_namespace )
-		end
 
-		it "knows whether or not it has loaded a session" do
-			@req.session?.should be_false()
+	context "with no session ID" do
+
+		it "knows that it doesn't have a session" do
+			@req.should_not have_session()
 		end
 
 		it "doesn't load the session when the session namespace is set" do
 			@req.session_namespace = 'an_appid'
-			@req.session?.should be_false()
+			@req.should_not have_session()
 		end
 
-		it "loads the session as soon as it's accessed" do
+		it "creates a new session as soon as it's accessed" do
 			@req.session.should be_a( Strelka::Session::Default )
 		end
 
-		it "sets the session's namespace when it's loaded" do
+		it "sets its session's namespace when it loads if the session_namespace is set" do
 			@req.session_namespace = 'an_appid'
 			@req.session.namespace.should == :an_appid
 		end
 
-		it "sets a session's namespace when it's set directly" do
-			@req.should respond_to( :session_namespace= )
-			@req.session_namespace = 'the_appid'
 
-			session = mock( "session object" )
-			session.should_receive( :namespace= ).with( 'the_appid' )
+		context "but with a loaded session object" do
+
+			before( :each ) do
+				@session = Strelka::Session.create( :default )
+				@req.session = @session
+			end
 
-			@req.session = session
+			it "knows that it has a session" do
+				@req.should have_session()
+			end
+
+			it "sets the session's namespace when its session_namespace is set" do
+				@req.session_namespace = 'the_appid'
+				@session.namespace.should == :the_appid
+			end
 		end
 
 	end
 
 
-	describe "an HTTPRequest with a session loaded" do
+	context "with a session ID" do
 
 		before( :each ) do
-			@req.session_namespace = 'other_appid'
-			@req.session
+			cookie_name = Strelka::Session::Default.cookie_options[ :name ]
+			@sess_id = Strelka::Session::Default.get_session_id
+			@req.header.cookie = "#{cookie_name}=#{@sess_id}"
 		end
 
-		it "sets its session's namespace when its session_namespace attribute is set" do
-			@req.session.namespace.should == :other_appid
-			@req.session_namespace = 'an_appid'
-			@req.session.namespace.should == :an_appid
+		it "knows that it doesn't have a session unless the ID exists" do
+			@req.should_not have_session()
+		end
+
+
+		context "and a corresponding entry in the database" do
+
+			before( :each ) do
+				Strelka::Session::Default.sessions[ @sess_id ] = {}
+			end
+
+			it "knows that it has a session" do
+				@req.should have_session()
+			end
+
 		end
 
 	end

data/spec/strelka/httprequest_spec.rb

@@ -150,6 +150,27 @@ describe Strelka::HTTPRequest do
 			end
 		end
 
+
+		context "a POST request without a content type" do
+			before( :each ) do
+				@req = @request_factory.post( '/directory/path', '' )
+			end
+
+
+			it "responds with a 400 (BAD_REQUEST)" do
+				expected_info = {
+					status: 400,
+					message: "Malformed request (no content type?)",
+					headers: {}
+				}
+
+				expect {
+					@req.params
+				}.to throw_symbol( :finish, expected_info )
+			end
+		end
+
+
 		context "a POST request with a 'application/x-www-form-urlencoded' body" do
 
 			before( :each ) do

data/spec/strelka/httpresponse/session_spec.rb

@@ -0,0 +1,143 @@
+# -*- rspec -*-
+# vim: set nosta noet ts=4 sw=4:
+
+BEGIN {
+	require 'pathname'
+	basedir = Pathname.new( __FILE__ ).dirname.parent.parent.parent
+
+	libdir = basedir + "lib"
+
+	$LOAD_PATH.unshift( basedir ) unless $LOAD_PATH.include?( basedir )
+	$LOAD_PATH.unshift( libdir ) unless $LOAD_PATH.include?( libdir )
+}
+
+require 'rspec'
+
+require 'spec/lib/helpers'
+
+require 'strelka'
+require 'strelka/app/sessions'
+require 'strelka/httprequest/session'
+require 'strelka/httpresponse/session'
+require 'strelka/session/default'
+
+
+#####################################################################
+###	C O N T E X T S
+#####################################################################
+
+describe Strelka::HTTPResponse::Session, "-extended response" do
+
+	before( :all ) do
+		setup_logging( :fatal )
+		@request_factory = Mongrel2::RequestFactory.new( route: '/service/user' )
+		Strelka::App::Sessions.configure( session_class: 'default' )
+	end
+
+	before( :each ) do
+		@req = @request_factory.get( '/service/user/estark' )
+		@req.extend( Strelka::HTTPRequest::Session )
+		@res = @req.response
+		@res.extend( described_class )
+	end
+
+	after( :each ) do
+		Strelka::Session::Default.sessions.clear
+	end
+
+	after( :all ) do
+		reset_logging()
+	end
+
+
+	it "has a session_namespace attribute" do
+		@res.should respond_to( :session_namespace )
+	end
+
+	it "sets its request's session when its session is set" do
+		@res.session = Strelka::Session.create( :default )
+		pending "not sure if it should do this or not" do
+			@req.session.should be( @res.session )
+		end
+	end
+
+	context "for a request with no session ID" do
+
+		it "knows that it doesn't have a session" do
+			@res.should_not have_session()
+		end
+
+		it "doesn't load the session when the session namespace is set" do
+			@res.session_namespace = 'an_appid'
+			@res.should_not have_session()
+		end
+
+		it "creates a new session as soon as it's accessed" do
+			@res.session.should be_a( Strelka::Session::Default )
+		end
+
+		it "sets its session's namespace when it loads if the session_namespace is set" do
+			@res.session_namespace = 'an_appid'
+			@res.session.namespace.should == :an_appid
+		end
+
+
+		context "but with a loaded session object" do
+
+			before( :each ) do
+				@session = Strelka::Session.create( :default )
+				@res.request.session = @session
+			end
+
+			it "knows that it has a session" do
+				@res.should have_session()
+			end
+
+			it "copies the session from its request when accessed" do
+				@res.session.should be( @session )
+			end
+
+			it "sets the session's namespace when its session_namespace is set" do
+				@res.session_namespace = 'the_appid'
+				@res.session.namespace.should == :the_appid
+			end
+
+		end
+
+	end
+
+
+	context "for a request with a session ID" do
+
+		before( :each ) do
+			@cookie_name = Strelka::Session::Default.cookie_options[ :name ]
+			@sess_id = Strelka::Session::Default.get_session_id
+			@req.header.cookie = "#{@cookie_name}=#{@sess_id}"
+		end
+
+		it "knows that it doesn't have a session unless the ID exists" do
+			@res.should_not have_session()
+		end
+
+
+		context "and a corresponding entry in the database" do
+
+			before( :each ) do
+				Strelka::Session::Default.sessions[ @sess_id ] = {}
+			end
+
+			it "knows that it has a session" do
+				@res.should have_session()
+			end
+
+			it "saves the session via itself when told to do so" do
+				@res.cookies.should_not include( @cookie_name )
+				@res.save_session
+				@res.cookies[ @cookie_name ].value.should == @sess_id
+			end
+
+		end
+
+	end
+
+end

data/spec/strelka/{app/plugins_spec.rb → plugins_spec.rb}

@@ -4,7 +4,7 @@
 
 BEGIN {
 	require 'pathname'
-	basedir = Pathname.new( __FILE__ ).dirname.parent.parent.parent
+	basedir = Pathname.new( __FILE__ ).dirname.parent.parent
 	$LOAD_PATH.unshift( basedir ) unless $LOAD_PATH.include?( basedir )
 }
 
@@ -13,30 +13,36 @@ require 'rspec'
 require 'spec/lib/helpers'
 
 require 'strelka'
-require 'strelka/app/plugins'
+require 'strelka/plugins'
 
 
 #####################################################################
 ###	C O N T E X T S
 #####################################################################
 
-describe Strelka::App::Plugins do
+class Strelka::Pluggable
+	extend Strelka::PluginLoader
+end
+
+
+describe "Strelka plugin system" do
 
 	before( :all ) do
 		setup_logging( :fatal )
-		@original_plugin_registry = Strelka::App.loaded_plugins.dup
+		@original_registry = Strelka::App.loaded_plugins.dup
 	end
 
-	after( :all ) do
+	after( :each ) do
 		Strelka::App.loaded_plugins.clear
-		Strelka::App.loaded_plugins.replace( @original_plugin_registry )
-		reset_logging()
 	end
 
-	after( :each ) do
-		Strelka::App.loaded_plugins.delete_if {|mod| mod =~ /anonymous/ }
+	after( :all ) do
+		Strelka::App.loaded_plugins = @original_registry
+		reset_logging()
 	end
 
+
+
 	RSpec::Matchers.define( :order ) do |item|
 		match do |enumerable|
 			raise "%p doesn't include %p" % [ enumerable, item ] unless
@@ -44,12 +50,12 @@ describe Strelka::App::Plugins do
 			if defined?( @before )
 				raise "%p doesn't include %p" % [ enumerable, @before ] unless
 					enumerable.include?( @before )
-				enumerable.index( @before ) < enumerable.index( item )
+				enumerable.index( @before ) > enumerable.index( item )
 			elsif defined?( @after )
 				raise "%p doesn't include %p" % [ enumerable, @after ] unless
 					enumerable.include?( @after )
 				Strelka.log.debug "Enumerable is: %p" % [ enumerable ]
-				enumerable.index( @after ) > enumerable.index( item )
+				enumerable.index( @after ) < enumerable.index( item )
 			else
 				raise "No .before or .after to compare against!"
 			end
@@ -67,31 +73,25 @@ describe Strelka::App::Plugins do
 
 	describe "Plugin module" do
 
-		it "registers itself with a plugin registry" do
-			plugin = Module.new do
-				extend Strelka::App::Plugin
+		before( :each ) do
+			@plugin = Module.new do
+				def self::name; "Strelka::App::TestPlugin"; end
+				extend Strelka::Plugin
 			end
-
-			Strelka::App.loaded_plugins.should include( plugin.plugin_name => plugin )
 		end
 
-
-		it "extends the object even if included" do
-			plugin = Module.new do
-				include Strelka::App::Plugin
-			end
-
-			Strelka::App.loaded_plugins.should include( plugin.plugin_name => plugin )
+		it "registers itself with a plugin registry" do
+			Strelka::App.loaded_plugins.should include( @plugin.plugin_name => @plugin )
 		end
 
 
 		context "that declares that it should run before another" do
 
 			before( :each ) do
-				@other_mod = Module.new { include Strelka::App::Plugin }
-				modname = @other_mod.plugin_name
+				modname = @plugin.plugin_name
 				@before_mod = Module.new do
-					include Strelka::App::Plugin
+					def self::name; "Strelka::App::BeforeTestPlugin"; end
+					extend Strelka::Plugin
 					run_before( modname )
 				end
 			end
@@ -99,7 +99,7 @@ describe Strelka::App::Plugins do
 
 			it "sorts before it in the plugin registry" do
 				Strelka::App.loaded_plugins.tsort.
-					should order( @other_mod.plugin_name ).before( @before_mod.plugin_name )
+					should order( @plugin.plugin_name ).after( @before_mod.plugin_name )
 			end
 
 		end
@@ -107,10 +107,10 @@ describe Strelka::App::Plugins do
 		context "that declares that it should run after another" do
 
 			before( :each ) do
-				@other_mod = Module.new { include Strelka::App::Plugin }
-				modname = @other_mod.plugin_name
+				modname = @plugin.plugin_name
 				@after_mod = Module.new do
-					include Strelka::App::Plugin
+					def self::name; "Strelka::App::AfterTestPlugin"; end
+					extend Strelka::Plugin
 					run_after( modname )
 				end
 			end
@@ -118,7 +118,7 @@ describe Strelka::App::Plugins do
 
 			it "sorts after it in the plugin registry" do
 				Strelka::App.loaded_plugins.tsort.
-					should order( @other_mod.plugin_name ).after( @after_mod.plugin_name )
+					should order( @plugin.plugin_name ).before( @after_mod.plugin_name )
 			end
 
 		end
@@ -129,7 +129,8 @@ describe Strelka::App::Plugins do
 	context "loading" do
 		it "appends class methods if the plugin has them" do
 			plugin = Module.new do
-				include Strelka::App::Plugin
+				def self::name; "Strelka::App::ClassMethodsTestPlugin"; end
+				include Strelka::Plugin
 				module ClassMethods
 					def a_class_method; return "yep."; end
 				end
@@ -143,7 +144,8 @@ describe Strelka::App::Plugins do
 
 		it "adds class-instance variables to the class if the plugin has them" do
 			plugin = Module.new do
-				include Strelka::App::Plugin
+				def self::name; "Strelka::App::ClassInstanceMethodsTestPlugin"; end
+				include Strelka::Plugin
 				module ClassMethods
 					@testing_value = :default
 					attr_accessor :testing_value
@@ -163,29 +165,45 @@ describe Strelka::App::Plugins do
 	context "plugin/plugins declarative" do
 
 		before( :each ) do
-			@including_class = Class.new { include Strelka::App::Plugins }
+			@pluggable_class = Strelka::Pluggable
+			@routing_plugin = Module.new do
+				def self::name; "Strelka::Pluggable::Routing"; end
+				extend Strelka::Plugin
+				module ClassMethods
+					@routed = false
+					attr_reader :routed
+					def route_some_stuff
+						@routed = true
+					end
+				end
+			end
+			@templating_plugin = Module.new do
+				def self::name; "Strelka::Pluggable::Templating"; end
+				extend Strelka::Plugin
+				run_before :routing
+			end
 		end
 
+
 		it "can declare a single plugin to load" do
-			klass = Class.new( @including_class ) do
+			klass = Class.new( @pluggable_class ) do
 				plugin :routing
 			end
 			klass.install_plugins
 
-			klass.ancestors.should include( Strelka::App::Routing )
+			klass.ancestors.should include( @routing_plugin )
 		end
 
 		it "can declare a list of plugins to load" do
-			klass = Class.new( @including_class ) do
+			klass = Class.new( @pluggable_class ) do
 				plugins :templating, :routing
 			end
 			klass.install_plugins
-
-			klass.ancestors.should include( Strelka::App::Routing, Strelka::App::Templating )
+			klass.ancestors.should include( @routing_plugin, @templating_plugin )
 		end
 
 		it "installs the plugins in the right order even if they're loaded at separate times" do
-			superclass = Class.new( @including_class ) do
+			superclass = Class.new( @pluggable_class ) do
 				plugin :routing
 			end
 			subclass = Class.new( superclass ) do
@@ -193,11 +211,11 @@ describe Strelka::App::Plugins do
 			end
 			subclass.install_plugins
 
-			subclass.ancestors.should order( Strelka::App::Templating ).after( Strelka::App::Routing )
+			subclass.ancestors.should order( @templating_plugin ).before( @routing_plugin )
 		end
 
-		it "adds information about where plugins were installed from when they're installed" do
-			klass = Class.new( @including_class ) do
+		it "adds information about where plugins were installed" do
+			klass = Class.new( @pluggable_class ) do
 				plugin :routing
 			end
 			klass.plugins_installed_from.should be_nil()
@@ -211,8 +229,7 @@ describe Strelka::App::Plugins do
 	context "Plugins loaded in a superclass" do
 
 		before( :each ) do
-			@base_class = Class.new { include Strelka::App::Plugins }
-			@superclass = Class.new( @base_class ) do
+			@superclass = Class.new( Strelka::Pluggable ) do
 				plugin :routing
 			end
 		end
@@ -220,16 +237,10 @@ describe Strelka::App::Plugins do
 
 		it "are inherited by subclasses" do
 			subclass = Class.new( @superclass ) do
-				get 'foom' do |req|
-					res = req.response
-					res.puts( "Yep, it worked." )
-					return res
-				end
+				route_some_stuff
 			end
 
-			subclass.routes.should == [
-				[ :GET, ['foom'], {action: subclass.instance_method(:GET_foom), options: {}} ]
-			]
+			subclass.routed.should be_true()
 		end
 
 	end