strelka 0.6.0 → 0.7.0

data/spec/strelka/plugins_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
-	$LOAD_PATH.unshift( basedir ) unless $LOAD_PATH.include?( basedir )
-}
+require_relative '../helpers'
 
 require 'rspec'
 
-require 'spec/lib/helpers'
-
 require 'strelka'
 require 'strelka/plugins'
 
@@ -80,7 +74,7 @@ describe "Strelka plugin system" do
 		end
 
 		it "registers itself with a plugin registry" do
-			Strelka::Pluggable.loaded_plugins.should include( @plugin.plugin_name => @plugin )
+			expect( Strelka::Pluggable.loaded_plugins ).to include( @plugin.plugin_name => @plugin )
 		end
 
 
@@ -91,7 +85,7 @@ describe "Strelka plugin system" do
 				@before_mod = Module.new do
 					def self::name; "Strelka::Pluggable::BeforeTestPlugin"; end
 					extend Strelka::Plugin
-					run_before( modname )
+					run_outside( modname )
 				end
 			end
 
@@ -110,7 +104,7 @@ describe "Strelka plugin system" do
 				@after_mod = Module.new do
 					def self::name; "Strelka::Pluggable::AfterTestPlugin"; end
 					extend Strelka::Plugin
-					run_after( modname )
+					run_inside( modname )
 				end
 			end
 
@@ -128,7 +122,7 @@ describe "Strelka plugin system" do
 	context "loading" do
 
 		it "requires plugins from a directory based on the name of the loader" do
-			Strelka::Pluggable.should_receive( :require ).
+			expect( Strelka::Pluggable ).to receive( :require ).
 				with( 'strelka/pluggable/scheduler' ).
 				and_return do
 					Module.new do
@@ -152,7 +146,7 @@ describe "Strelka plugin system" do
 			app = Class.new( Strelka::Pluggable )
 			app.register_plugin( plugin )
 
-			app.a_class_method.should == "yep."
+			expect( app.a_class_method ).to eq( "yep." )
 		end
 
 		it "adds class-instance variables to the class if the plugin has them" do
@@ -168,9 +162,9 @@ describe "Strelka plugin system" do
 			app = Class.new( Strelka::Pluggable )
 			app.register_plugin( plugin )
 
-			app.testing_value.should == :default
+			expect( app.testing_value ).to eq( :default )
 			app.testing_value = :not_the_default
-			app.testing_value.should == :not_the_default
+			expect( app.testing_value ).to eq( :not_the_default )
 		end
 
 		it "adds class-instance variables to the class if the plugin has them" do
@@ -187,7 +181,7 @@ describe "Strelka plugin system" do
 			app.instance_variable_set( :@testing_value, :pre_existing_value )
 			app.register_plugin( plugin )
 
-			app.testing_value.should == :pre_existing_value
+			expect( app.testing_value ).to eq( :pre_existing_value )
 		end
 
 	end
@@ -210,7 +204,7 @@ describe "Strelka plugin system" do
 			@templating_plugin = Module.new do
 				def self::name; "Strelka::Pluggable::Templating"; end
 				extend Strelka::Plugin
-				run_before :routing
+				run_outside :routing
 			end
 		end
 
@@ -221,7 +215,7 @@ describe "Strelka plugin system" do
 			end
 			klass.install_plugins
 
-			klass.ancestors.should include( @routing_plugin )
+			expect( klass.ancestors ).to include( @routing_plugin )
 		end
 
 		it "can declare a list of plugins to load" do
@@ -229,7 +223,7 @@ describe "Strelka plugin system" do
 				plugins :templating, :routing
 			end
 			klass.install_plugins
-			klass.ancestors.should include( @routing_plugin, @templating_plugin )
+			expect( klass.ancestors ).to include( @routing_plugin, @templating_plugin )
 		end
 
 		it "has an introspection method for examining the list of loaded plugins" do
@@ -237,7 +231,7 @@ describe "Strelka plugin system" do
 				plugins :templating, :routing
 			end
 			klass.install_plugins
-			klass.application_stack.should == [ @templating_plugin, @routing_plugin ]
+			expect( klass.application_stack ).to eq( [ @templating_plugin, @routing_plugin ] )
 		end
 
 
@@ -250,16 +244,16 @@ describe "Strelka plugin system" do
 			end
 			subclass.install_plugins
 
-			subclass.ancestors.should order( @templating_plugin ).before( @routing_plugin )
+			expect( subclass.ancestors ).to order( @templating_plugin ).before( @routing_plugin )
 		end
 
 		it "adds information about where plugins were installed" do
 			klass = Class.new( Strelka::Pluggable ) do
 				plugin :routing
 			end
-			klass.plugins_installed_from.should be_nil()
+			expect( klass.plugins_installed_from ).to be_nil()
 			klass.install_plugins
-			klass.plugins_installed_from.should =~ /#{__FILE__}:#{__LINE__ - 1}/
+			expect( klass.plugins_installed_from ).to match( /#{__FILE__}:#{__LINE__ - 1}/ )
 		end
 
 		it "are inherited by subclasses" do
@@ -270,7 +264,7 @@ describe "Strelka plugin system" do
 				route_some_stuff
 			end
 
-			subclass.routed.should be_true()
+			expect( subclass.routed ).to be_true()
 		end
 
 	end

data/spec/strelka/router/default_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/router/default'
 
@@ -46,37 +40,37 @@ describe Strelka::Router::Default do
 
 		it "routes GET /user/foo/bar/baz to the GET foo/bar action" do
 			req = @request_factory.get( '/user/foo/bar/baz' )
-			@router.route_request( req ).should match_route( :GET_foo_bar )
+			expect( @router.route_request(req) ).to match_route( :GET_foo_bar )
 		end
 
 		it "routes GET /user/foo/bar to the GET foo/bar action" do
 			req = @request_factory.get( '/user/foo/bar' )
-			@router.route_request( req ).should match_route( :GET_foo_bar )
+			expect( @router.route_request(req) ).to match_route( :GET_foo_bar )
 		end
 
 		it "routes GET /user/foo to the GET foo action" do
 			req = @request_factory.get( '/user/foo' )
-			@router.route_request( req ).should match_route( :GET_foo )
+			expect( @router.route_request(req) ).to match_route( :GET_foo )
 		end
 
 		it "doesn't route GET /user" do
 			req = @request_factory.get( '/user' )
-			@router.route_request( req ).should be_nil()
+			expect( @router.route_request(req) ).to be_nil()
 		end
 
 		it "doesn't route GET /user/something/foo/bar" do
 			req = @request_factory.get( '/user/something/foo/bar' )
-			@router.route_request( req ).should be_nil()
+			expect( @router.route_request(req) ).to be_nil()
 		end
 
 		it "doesn't route GET /user/other" do
 			req = @request_factory.get( '/user/other' )
-			@router.route_request( req ).should be_nil()
+			expect( @router.route_request(req) ).to be_nil()
 		end
 
 		it "routes HEAD requests to the GET route" do
 			req = @request_factory.head( '/user/foo' )
-			@router.route_request( req ).should match_route( :GET_foo )
+			expect( @router.route_request(req) ).to match_route( :GET_foo )
 		end
 
 		it "responds with a 405 (method not allowed) for a DELETE request to /user/foo" do
@@ -107,27 +101,27 @@ describe Strelka::Router::Default do
 
 		it "routes /user/foo/bar/baz to the foo/bar action" do
 			req = @request_factory.get( '/user/foo/bar/baz' )
-			@router.route_request( req ).should match_route( :foo_bar )
+			expect( @router.route_request(req) ).to match_route( :foo_bar )
 		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 )
+			expect( @router.route_request(req) ).to 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 )
+			expect( @router.route_request(req) ).to 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 )
+			expect( @router.route_request(req) ).to match_route( :fallback )
 		end
 
 		it "routes /user/other to the fallback action" do
 			req = @request_factory.get( '/user/other' )
-			@router.route_request( req ).should match_route( :fallback )
+			expect( @router.route_request(req) ).to match_route( :fallback )
 		end
 
 	end
@@ -142,37 +136,37 @@ describe Strelka::Router::Default do
 
 		it "routes /user/foo/barbim/baz to the foo/\w{6} action" do
 			req = @request_factory.get( '/user/foo/barbim/baz' )
-			@router.route_request( req ).should match_route( :foo_six )
+			expect( @router.route_request(req) ).to match_route( :foo_six )
 		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 )
+			expect( @router.route_request(req) ).to match_route( :foo_six )
 		end
 
 		it "routes /user/foo/bar/baz to the foo/\w{3} action" do
 			req = @request_factory.get( '/user/foo/bar/baz' )
-			@router.route_request( req ).should match_route( :foo_three )
+			expect( @router.route_request(req) ).to match_route( :foo_three )
 		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 )
+			expect( @router.route_request(req) ).to 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 )
+			expect( @router.route_request(req) ).to match_route( :foo )
 		end
 
 		it "doesn't route /user" do
 			req = @request_factory.get( '/user' )
-			@router.route_request( req ).should be_nil()
+			expect( @router.route_request(req) ).to be_nil()
 		end
 
 		it "doesn't route /user/other" do
 			req = @request_factory.get( '/user/other' )
-			@router.route_request( req ).should be_nil()
+			expect( @router.route_request(req) ).to be_nil()
 		end
 
 	end
@@ -189,22 +183,22 @@ describe Strelka::Router::Default do
 
 		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 )
+			expect( @router.route_request(req) ).to 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 )
+			expect( @router.route_request(req) ).to 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 )
+			expect( @router.route_request(req) ).to 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 )
+			expect( @router.route_request(req) ).to match_route( :foo_digit )
 		end
 
 	end
@@ -221,22 +215,22 @@ describe Strelka::Router::Default do
 
 		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 )
+			expect( @router.route_request(req) ).to 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 )
+			expect( @router.route_request(req) ).to 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 )
+			expect( @router.route_request(req) ).to 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 )
+			expect( @router.route_request(req) ).to match_route( :foo_digit )
 		end
 
 	end
@@ -250,22 +244,22 @@ describe Strelka::Router::Default do
 
 		it "routes /user/foo/1 to the foo action" do
 			req = @request_factory.get( '/user/foo/1' )
-			@router.route_request( req ).should match_route( :foo )
+			expect( @router.route_request(req) ).to match_route( :foo )
 		end
 
 		it "routes /foo.pdf to the regexp action" do
 			req = @request_factory.get( '/user/foo.pdf' )
-			@router.route_request( req ).should match_route( :as_pdf )
+			expect( @router.route_request(req) ).to match_route( :as_pdf )
 		end
 
 		it "doesn't route /foo%1B.pdf to the regexp action" do
 			req = @request_factory.get( "/user/foo%1B.pdf" )
-			@router.route_request( req ).should_not match_route( :as_pdf )
+			expect( @router.route_request(req) ).to_not match_route( :as_pdf )
 		end
 
 		it "routes /zanzibar.pdf to the regexp action" do
 			req = @request_factory.get( '/user/zanzibar.pdf' )
-			@router.route_request( req ).should match_route( :as_pdf )
+			expect( @router.route_request(req) ).to match_route( :as_pdf )
 		end
 
 	end

data/spec/strelka/router/exclusive_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/router/exclusive'
 
@@ -44,32 +38,32 @@ describe Strelka::Router::Exclusive do
 
 		it "doesn't route /user/foo/bar/baz" do
 			req = @request_factory.get( '/user/foo/bar/baz' )
-			@router.route_request( req ).should be_nil()
+			expect( @router.route_request(req) ).to 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( :GET_foo_bar )
+			expect( @router.route_request(req) ).to match_route( :GET_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( :GET_foo_bar )
+			expect( @router.route_request(req) ).to match_route( :GET_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( :GET_foo )
+			expect( @router.route_request(req) ).to match_route( :GET_foo )
 		end
 
 		it "doesn't route /user" do
 			req = @request_factory.get( '/user' )
-			@router.route_request( req ).should be_nil()
+			expect( @router.route_request(req) ).to be_nil()
 		end
 
 		it "doesn't route /user/other" do
 			req = @request_factory.get( '/user/other' )
-			@router.route_request( req ).should be_nil()
+			expect( @router.route_request(req) ).to be_nil()
 		end
 
 	end
@@ -85,32 +79,32 @@ describe Strelka::Router::Exclusive do
 
 		it "doesn't route GET /user/foo/bar/baz" do
 			req = @request_factory.get( '/user/foo/bar/baz' )
-			@router.route_request( req ).should be_nil()
+			expect( @router.route_request(req) ).to be_nil()
 		end
 
 		it "routes GET /user/foo/bar to the GET foo/bar action" do
 			req = @request_factory.get( '/user/foo/bar' )
-			@router.route_request( req ).should match_route( :GET_foo_bar )
+			expect( @router.route_request(req) ).to match_route( :GET_foo_bar )
 		end
 
 		it "routes POST /user/foo/bar to the POST foor/bar action" do
 			req = @request_factory.post( '/user/foo/bar' )
-			@router.route_request( req ).should match_route( :POST_foo_bar )
+			expect( @router.route_request(req) ).to match_route( :POST_foo_bar )
 		end
 
 		it "routes GET /user/foo to the GET foo action" do
 			req = @request_factory.get( '/user/foo' )
-			@router.route_request( req ).should match_route( :GET_foo )
+			expect( @router.route_request(req) ).to match_route( :GET_foo )
 		end
 
 		it "routes GET /user to the fallback action" do
 			req = @request_factory.get( '/user' )
-			@router.route_request( req ).should match_route( :fallback )
+			expect( @router.route_request(req) ).to match_route( :fallback )
 		end
 
 		it "doesn't route GET /user/other" do
 			req = @request_factory.get( '/user/other' )
-			@router.route_request( req ).should be_nil()
+			expect( @router.route_request(req) ).to be_nil()
 		end
 
 		it "responds with an HTTP::METHOD_NOT_ALLOWED for a POST to /user/foo" do
@@ -140,37 +134,37 @@ describe Strelka::Router::Exclusive do
 
 		it "doesn't route /user/foo/barbim/baz" do
 			req = @request_factory.get( '/user/foo/barbim/baz' )
-			@router.route_request( req ).should be_nil()
+			expect( @router.route_request(req) ).to 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( :GET_foo_six )
+			expect( @router.route_request(req) ).to match_route( :GET_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()
+			expect( @router.route_request(req) ).to 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( :GET_foo_three )
+			expect( @router.route_request(req) ).to match_route( :GET_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( :GET_foo )
+			expect( @router.route_request(req) ).to match_route( :GET_foo )
 		end
 
 		it "doesn't route /user" do
 			req = @request_factory.get( '/user' )
-			@router.route_request( req ).should be_nil()
+			expect( @router.route_request(req) ).to be_nil()
 		end
 
 		it "doesn't route /user/other" do
 			req = @request_factory.get( '/user/other' )
-			@router.route_request( req ).should be_nil()
+			expect( @router.route_request(req) ).to be_nil()
 		end
 
 	end
@@ -187,22 +181,22 @@ describe Strelka::Router::Exclusive do
 
 		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( :GET_foo_digit )
+			expect( @router.route_request(req) ).to match_route( :GET_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( :GET_foo_digit )
+			expect( @router.route_request(req) ).to match_route( :GET_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( :GET_foo_three )
+			expect( @router.route_request(req) ).to match_route( :GET_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( :GET_foo_digit )
+			expect( @router.route_request(req) ).to match_route( :GET_foo_digit )
 		end
 
 	end
@@ -219,22 +213,22 @@ describe Strelka::Router::Exclusive do
 
 		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( :GET_foo_digit )
+			expect( @router.route_request(req) ).to match_route( :GET_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( :GET_foo_digit )
+			expect( @router.route_request(req) ).to match_route( :GET_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( :GET_foo_digit )
+			expect( @router.route_request(req) ).to match_route( :GET_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( :GET_foo_digit )
+			expect( @router.route_request(req) ).to match_route( :GET_foo_digit )
 		end
 
 	end

data/spec/strelka/router_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
-	$LOAD_PATH.unshift( basedir ) unless $LOAD_PATH.include?( basedir )
-}
+require_relative '../helpers'
 
 require 'rspec'
 
-require 'spec/lib/helpers'
-
 require 'strelka'
 require 'strelka/router'
 
@@ -33,7 +27,7 @@ describe Strelka::Router do
 
 
 	it "looks for plugins under strelka/router" do
-		Strelka::Router.plugin_prefixes.should include( 'strelka/router' )
+		expect( Strelka::Router.plugin_prefixes ).to include( 'strelka/router' )
 	end
 
 

data/spec/strelka/session/db_spec.rb

@@ -1,16 +1,10 @@
 # -*- rspec -*-
 # vim: set nosta noet ts=4 sw=4:
 
-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/session/db'
 
@@ -54,14 +48,21 @@ describe Strelka::Session::Db do
 	end
 
 
+	RSpec::Matchers.define( :contain_table ) do |tablename|
+		match do |db|
+			db.table_exists?( tablename )
+		end
+	end
+
+
 	it "creates the database if needed" do
-		described_class.db.table_exists?( :sessions ).should be_true()
+		expect( described_class.db ).to contain_table( :sessions )
 	end
 
 
 	it "can change the default table name" do
 		described_class.configure( @default_config.merge(:table_name => :brothy) )
-		described_class.db.table_exists?( :brothy ).should be_true()
+		expect( described_class.db ).to contain_table( :brothy )
 		described_class.db.drop_table( :brothy )
 	end
 
@@ -73,7 +74,7 @@ describe Strelka::Session::Db do
 			:session    => @session_data.to_yaml )
 
 		session = described_class.load( @session_id )
-		session.namespaced_hash.should == @session_data
+		expect( session.namespaced_hash ).to eq( @session_data )
 	end
 
 
@@ -84,7 +85,7 @@ describe Strelka::Session::Db do
 
 		session_cookie = "%s=%s" % [ @cookie_name, @session_id ]
 		req = @request_factory.get( '/frothy/gymkata', :cookie => session_cookie )
-		described_class.should have_session_for( req )
+		expect( described_class ).to have_session_for( req )
 	end
 
 
@@ -95,9 +96,10 @@ describe Strelka::Session::Db do
 		session.save( response )
 
 		row = session.class.dataset.filter( :session_id => @session_id ).first
-		row[ :session_id ].should   == @session_id
-		row[ :session ].should      =~ /hurrrg: true/
-		row[ :created ].to_s.should =~ /\d{4}-\d{2}-\d{2}/
-		response.header_data.should =~ /Set-Cookie: #{@cookie_name}=#{@session_id}/i
+
+		expect( row[ :session_id ] ).to eq( @session_id )
+		expect( row[ :session ] ).to match( /hurrrg: true/ )
+		expect( row[ :created ].to_s ).to match( /\d{4}-\d{2}-\d{2}/ )
+		expect( response.header_data ).to match( /Set-Cookie: #{@cookie_name}=#{@session_id}/i )
 	end
 end