strelka 0.6.0 → 0.7.0

data/spec/strelka/cookieset_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 'uri'
 require 'rspec'
-require 'spec/lib/helpers'
 require 'strelka/cookie'
 require 'strelka/cookieset'
 
@@ -30,9 +24,9 @@ describe Strelka::CookieSet do
 	it "delegates some methods to its underlying Set" do
 		cookie = Strelka::Cookie.new( 'pants', 'baggy' )
 
-		@cookieset.should be_empty()
-		@cookieset.length.should == 0
-		@cookieset.member?( cookie ).should be_false()
+		expect( @cookieset ).to be_empty()
+		expect( @cookieset.length ).to eq( 0 )
+		expect( @cookieset.member?( cookie ) ).to be_false()
 	end
 
 	it "is able to enummerate over each cookie in the set" do
@@ -45,33 +39,33 @@ describe Strelka::CookieSet do
 			cookies << cookie
 		end
 
-		cookies.length.should == 2
-		cookies.should include( pants_cookie )
-		cookies.should include( shirt_cookie )
+		expect( cookies.length ).to eq( 2 )
+		expect( cookies ).to include( pants_cookie )
+		expect( cookies ).to include( shirt_cookie )
 	end
 
 	it "is able to add a cookie referenced symbolically" do
 		pants_cookie = Strelka::Cookie.new( 'pants', 'denim' )
 		@cookieset[:pants] = pants_cookie
-		@cookieset['pants'].should == pants_cookie
+		expect( @cookieset['pants'] ).to eq( pants_cookie )
 	end
 
 
 	it "autos-create a cookie for a non-cookie passed to the index setter" do
-		lambda { @cookieset['bar'] = 'badgerbadgerbadgerbadger' }.should_not raise_error()
+		@cookieset['bar'] = 'badgerbadgerbadgerbadger'
 
-		@cookieset['bar'].should be_an_instance_of( Strelka::Cookie )
-		@cookieset['bar'].value.should == 'badgerbadgerbadgerbadger'
+		expect( @cookieset['bar'] ).to be_an_instance_of( Strelka::Cookie )
+		expect( @cookieset['bar'].value ).to eq( 'badgerbadgerbadgerbadger' )
 	end
 
 	it "raises an exception if the name of a cookie being set doesn't agree with the key it being set with" do
 		pants_cookie = Strelka::Cookie.new( 'pants', 'corduroy' )
-		lambda { @cookieset['shirt'] = pants_cookie }.should raise_error( ArgumentError )
+		expect { @cookieset['shirt'] = pants_cookie }.to raise_error( ArgumentError )
 	end
 
 	it "implements Enumerable" do
 		Enumerable.instance_methods( false ).each do |meth|
-			@cookieset.should respond_to( meth )
+			expect( @cookieset ).to respond_to( meth )
 		end
 	end
 
@@ -90,9 +84,9 @@ describe Strelka::CookieSet do
 			cookie_array << Strelka::Cookie.new( 'foo', 'bar' )
 			cookie_array << [Strelka::Cookie.new( 'shmoop', 'torgo!' )]
 
-			cookieset = nil
-			lambda {cookieset = Strelka::CookieSet.new(cookie_array)}.should_not raise_error()
-			cookieset.length.should == 2
+			cookieset = Strelka::CookieSet.new( cookie_array )
+
+			expect( cookieset.length ).to eq( 2 )
 		end
 	end
 
@@ -104,32 +98,32 @@ describe Strelka::CookieSet do
 		end
 
 		it "contains only one cookie" do
-			@cookieset.length.should == 1
+			expect( @cookieset.length ).to eq( 1 )
 		end
 
 		it "is able to return the 'foo' Strelka::Cookie via its index operator" do
-			@cookieset[ 'foo' ].should == @cookie
+			expect( @cookieset[ 'foo' ] ).to eq( @cookie )
 		end
 
 
 		it "is able to return the 'foo' Strelka::Cookie via its symbolic name" do
-			@cookieset[ :foo ].should == @cookie
+			expect( @cookieset[ :foo ] ).to eq( @cookie )
 		end
 
 		it "knows if it includes a cookie named 'foo'" do
-			@cookieset.should include( 'foo' )
+			expect( @cookieset ).to include( 'foo' )
 		end
 
 		it "knows if it includes a cookie referenced by :foo" do
-			@cookieset.should include( :foo )
+			expect( @cookieset ).to include( :foo )
 		end
 
 		it "knows that it doesn't contain a cookie named 'lollypop'" do
-			@cookieset.should_not include( 'lollypop' )
+			expect( @cookieset ).to_not include( 'lollypop' )
 		end
 
 		it "knows that it includes the 'foo' cookie object" do
-			@cookieset.should include( @cookie )
+			expect( @cookieset ).to include( @cookie )
 		end
 
 
@@ -137,8 +131,8 @@ describe Strelka::CookieSet do
 			new_cookie = Strelka::Cookie.new( 'bar', 'foo' )
 			@cookieset << new_cookie
 
-			@cookieset.length.should == 2
-			@cookieset.should include( new_cookie )
+			expect( @cookieset.length ).to eq( 2 )
+			expect( @cookieset ).to include( new_cookie )
 		end
 
 
@@ -146,18 +140,18 @@ describe Strelka::CookieSet do
 			new_cookie = Strelka::Cookie.new( 'foo', 'giant scallops of doom' )
 			@cookieset << new_cookie
 
-			@cookieset.length.should == 1
-			@cookieset.should include( new_cookie )
-			@cookieset['foo'].should equal( new_cookie )
+			expect( @cookieset.length ).to eq( 1 )
+			expect( @cookieset ).to include( new_cookie )
+			expect( @cookieset['foo'] ).to equal( new_cookie )
 		end
 
 		it "replaces any existing same-named cookie set via the index operator" do
 			new_cookie = Strelka::Cookie.new( 'foo', 'giant scallops of doom' )
 			@cookieset[:foo] = new_cookie
 
-			@cookieset.length.should == 1
-			@cookieset.should include( new_cookie )
-			@cookieset['foo'].should equal( new_cookie )
+			expect( @cookieset.length ).to eq( 1 )
+			expect( @cookieset ).to include( new_cookie )
+			expect( @cookieset['foo'] ).to equal( new_cookie )
 		end
 
 	end

data/spec/strelka/discovery_spec.rb

@@ -0,0 +1,144 @@
+# -*- ruby -*-
+# vim: set nosta noet ts=4 sw=4:
+# encoding: utf-8
+
+require_relative '../helpers'
+
+require 'rspec'
+require 'zmq'
+require 'mongrel2'
+
+require 'strelka'
+require 'strelka/discovery'
+
+
+#####################################################################
+###	C O N T E X T S
+#####################################################################
+
+describe Strelka::Discovery do
+
+	before( :all ) do
+		setup_logging()
+		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
+		# in the dev environment
+		strelkaspec = make_gemspec( 'strelka', Strelka::VERSION, false )
+		loaded_specs = Gem.instance_variable_get( :@loaded_specs )
+		loaded_specs['strelka'] = strelkaspec
+
+	end
+
+	after( :all ) do
+		reset_logging()
+	end
+
+
+	let( :discoverable_class ) { Class.new {extend Strelka::Discovery} }
+
+
+	#
+	# Examples
+	#
+
+	it "has a method for loading app class/es from a file" do
+
+		app_file = 'an_app.rb'
+		app_path = Pathname( app_file ).expand_path
+		app_class = nil
+
+		expect( Kernel ).to receive( :load ).with( app_path.to_s ).and_return do
+			app_class = Class.new( discoverable_class )
+		end
+		expect( described_class.load(app_file) ).to eq( [ app_class ] )
+	end
+
+
+	it "defaults to loading as a file when finding an app"
+
+
+	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' )
+
+		expect( Gem::Specification ).to receive( :each ).once do |&block|
+			specs.values.each {|val| block.call(val) }
+		end
+
+		donkey_path  = specs[:donkey].full_gem_path
+		rabbit_path  = specs[:rabbit_new].full_gem_path
+		giraffe_path = specs[:giraffe].full_gem_path
+
+		expect( Dir ).to receive( :glob ).with( 'data/*/{apps,handlers}/**/*' ).
+			and_return( [] )
+		expect( Dir ).to receive( :glob ).with( "#{giraffe_path}/data/giraffe/{apps,handlers}/**/*" ).
+			and_return([ "#{giraffe_path}/data/giraffe/apps/app" ])
+		expect( Dir ).to 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" ])
+		expect( Dir ).to receive( :glob ).with( "#{donkey_path}/data/donkey/{apps,handlers}/**/*" ).
+			and_return([ "#{donkey_path}/data/donkey/apps/app.rb" ])
+
+		app_paths = described_class.discover_paths
+
+		expect( app_paths ).to have( 4 ).members
+		expect( app_paths ).to 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' )
+		expect( Gem::Specification ).to receive( :each ).and_yield( gemspec ).at_least( :once )
+
+		expect( Dir ).to receive( :glob ).with( 'data/*/{apps,handlers}/**/*' ).
+			and_return( [] )
+		expect( Dir ).to receive( :glob ).with( "#{gemspec.full_gem_path}/data/blood-orgy/{apps,handlers}/**/*" ).
+			and_return([ "#{gemspec.full_gem_path}/data/blood-orgy/apps/kurzweil" ])
+
+		expect( described_class ).to receive( :gem ).with( 'blood-orgy' )
+		expect( Kernel ).to receive( :load ).
+			with( "#{gemspec.full_gem_path}/data/blood-orgy/apps/kurzweil" ).
+			and_return do
+				Class.new( discoverable_class )
+				true
+			end
+
+		app_classes = described_class.discover
+		expect( app_classes ).to have( 1 ).member
+		expect( app_classes.first ).to be_a( Class )
+		expect( app_classes.first ).to be < discoverable_class
+	end
+
+
+	it "handles exceptions while loading discovered apps" do
+		gemspec = make_gemspec( 'blood-orgy', '0.0.3' )
+		expect( Gem::Specification ).to receive( :each ).and_yield( gemspec ).at_least( :once )
+
+		expect( Dir ).to receive( :glob ).with( 'data/*/{apps,handlers}/**/*' ).
+			and_return( [] )
+		expect( Dir ).to receive( :glob ).with( "#{gemspec.full_gem_path}/data/blood-orgy/{apps,handlers}/**/*" ).
+			and_return([ "#{gemspec.full_gem_path}/data/blood-orgy/apps/kurzweil" ])
+
+		expect( described_class ).to receive( :gem ).with( 'blood-orgy' )
+		expect( Kernel ).to receive( :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::Discovery.discover
+		expect( app_classes ).to be_empty()
+	end
+
+
+end
+

data/spec/strelka/exceptions_spec.rb

@@ -2,18 +2,12 @@
 # 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 'zmq'
 require 'mongrel2'
 
-require 'spec/lib/helpers'
-
 require 'strelka'
 require 'strelka/exceptions'
 
@@ -46,7 +40,7 @@ describe Strelka, "exception classes" do
 				exception = err
 			end
 
-			exception.request.should == req
+			expect( exception.request ).to eq( req )
 		end
 
 	end

data/spec/strelka/httprequest/acceptparams_spec.rb

@@ -2,20 +2,10 @@
 # vim: set nosta noet ts=4 sw=4:
 # encoding: utf-8
 
-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_relative '../../helpers'
 
 require 'rspec'
 
-require 'spec/lib/helpers'
-
 require 'strelka'
 require 'strelka/httprequest/acceptparams'
 
@@ -25,6 +15,7 @@ require 'strelka/httprequest/acceptparams'
 #####################################################################
 
 describe Strelka::HTTPRequest, "accept params" do
+
 	before( :all ) do
 		setup_logging( :fatal )
 	end
@@ -80,14 +71,14 @@ describe Strelka::HTTPRequest, "accept params" do
 			VALID_HEADERS.each do |hdr, expectations|
 				rval = Strelka::HTTPRequest::MediaType.parse( hdr )
 
-				rval.should be_an_instance_of( Strelka::HTTPRequest::MediaType )
-				rval.type.should    == expectations[:type]
-				rval.subtype.should == expectations[:subtype]
-				rval.qvalue.should  == expectations[:qval]
+				expect( rval ).to be_an_instance_of( Strelka::HTTPRequest::MediaType )
+				expect( rval.type ).to eq( expectations[:type] )
+				expect( rval.subtype ).to eq( expectations[:subtype] )
+				expect( rval.qvalue ).to eq( expectations[:qval] )
 
 				if expectations[:extensions]
 					expectations[:extensions].each do |ext|
-						rval.extensions.should include( ext )
+						expect( rval.extensions ).to include( ext )
 					end
 				end
 			end
@@ -96,29 +87,29 @@ describe Strelka::HTTPRequest, "accept params" do
 
 		it "is lenient (but warns) about invalid qvalues" do
 			rval = Strelka::HTTPRequest::MediaType.parse( '*/*; q=18' )
-			rval.should be_an_instance_of( Strelka::HTTPRequest::MediaType )
-			rval.qvalue.should == 1.0
+			expect( rval ).to be_an_instance_of( Strelka::HTTPRequest::MediaType )
+			expect( rval.qvalue ).to eq( 1.0 )
 		end
 
 
 		it "rejects invalid Accept header values" do
-			lambda {
+			expect {
 				Strelka::HTTPRequest::MediaType.parse( 'porksausage' )
-			}.should raise_error()
+			}.to raise_error()
 		end
 
 
 		it "can represent itself in a human-readable object format" do
 			header = "text/html; q=0.9; level=2"
 			acceptparam = Strelka::HTTPRequest::MediaType.parse( header )
-			acceptparam.inspect.should =~ %r{MediaType.*text/html.*q=0.9}
+			expect( acceptparam.inspect ).to match( %r{MediaType.*text/html.*q=0.9} )
 		end
 
 
 		it "can represent itself as an Accept header" do
 			header = "text/html;q=0.9;level=2"
 			acceptparam = Strelka::HTTPRequest::MediaType.parse( header )
-			acceptparam.to_s.should == header
+			expect( acceptparam.to_s ).to eq( header )
 		end
 
 
@@ -130,14 +121,14 @@ describe Strelka::HTTPRequest, "accept params" do
 				collect {|par| Strelka::HTTPRequest::MediaType.parse( par ) }.
 				sort
 
-			params[0].to_s.should == 'application/xhtml+xml;q=1.0'
-			params[1].to_s.should == 'application/xml;q=1.0'
-			params[2].to_s.should == 'image/png;q=1.0'
-			params[3].to_s.should == 'text/xml;q=1.0'
-			params[4].to_s.should == 'text/html;q=0.9'
-			params[5].to_s.should == 'text/html;q=0.9;level=1'
-			params[6].to_s.should == 'text/plain;q=0.8'
-			params[7].to_s.should == '*/*;q=0.5'
+			expect( params[0].to_s ).to eq( 'application/xhtml+xml;q=1.0' )
+			expect( params[1].to_s ).to eq( 'application/xml;q=1.0' )
+			expect( params[2].to_s ).to eq( 'image/png;q=1.0' )
+			expect( params[3].to_s ).to eq( 'text/xml;q=1.0' )
+			expect( params[4].to_s ).to eq( 'text/html;q=0.9' )
+			expect( params[5].to_s ).to eq( 'text/html;q=0.9;level=1' )
+			expect( params[6].to_s ).to eq( 'text/plain;q=0.8' )
+			expect( params[7].to_s ).to eq( '*/*;q=0.5' )
 		end
 
 
@@ -145,12 +136,12 @@ describe Strelka::HTTPRequest, "accept params" do
 			specific_param = Strelka::HTTPRequest::MediaType.parse( 'text/html' )
 			subtype_wildcard_param = Strelka::HTTPRequest::MediaType.parse( 'image/*' )
 
-			( specific_param =~ 'text/html' ).should be_true()
-			( specific_param =~ 'image/png' ).should be_false()
+			expect( ( specific_param =~ 'text/html' ) ).to be_true()
+			expect( ( specific_param =~ 'image/png' ) ).to be_false()
 
-			( subtype_wildcard_param =~ 'image/png' ).should be_true()
-			( subtype_wildcard_param =~ 'image/jpeg' ).should be_true()
-			( subtype_wildcard_param =~ 'text/plain' ).should be_false()
+			expect( ( subtype_wildcard_param =~ 'image/png' ) ).to be_true()
+			expect( ( subtype_wildcard_param =~ 'image/jpeg' ) ).to be_true()
+			expect( ( subtype_wildcard_param =~ 'text/plain' ) ).to be_false()
 		end
 	end
 
@@ -161,33 +152,33 @@ describe Strelka::HTTPRequest, "accept params" do
 			hdr = 'en'
 			param = Strelka::HTTPRequest::Language.parse( hdr )
 
-			param.should be_an_instance_of( Strelka::HTTPRequest::Language )
-			param.primary_tag.should == 'en'
-			param.subtag.should be_nil()
-			param.qvalue.should == 1.0
-			param.extensions.should be_empty()
+			expect( param ).to be_an_instance_of( Strelka::HTTPRequest::Language )
+			expect( param.primary_tag ).to eq( 'en' )
+			expect( param.subtag ).to be_nil()
+			expect( param.qvalue ).to eq( 1.0 )
+			expect( param.extensions ).to be_empty()
 		end
 
 		it "can parse a language range with a dialect" do
 			hdr = 'en-gb'
 			param = Strelka::HTTPRequest::Language.parse( hdr )
 
-			param.should be_an_instance_of( Strelka::HTTPRequest::Language )
-			param.primary_tag.should == 'en'
-			param.subtag.should == 'gb'
-			param.qvalue.should == 1.0
-			param.extensions.should be_empty()
+			expect( param ).to be_an_instance_of( Strelka::HTTPRequest::Language )
+			expect( param.primary_tag ).to eq( 'en' )
+			expect( param.subtag ).to eq( 'gb' )
+			expect( param.qvalue ).to eq( 1.0 )
+			expect( param.extensions ).to be_empty()
 		end
 
 		it "can parse a language tag with a q-value" do
 			hdr = 'en-US; q=0.8'
 			param = Strelka::HTTPRequest::Language.parse( hdr )
 
-			param.should be_an_instance_of( Strelka::HTTPRequest::Language )
-			param.primary_tag.should == 'en'
-			param.subtag.should == 'us'
-			param.qvalue.should == 0.8
-			param.extensions.should be_empty()
+			expect( param ).to be_an_instance_of( Strelka::HTTPRequest::Language )
+			expect( param.primary_tag ).to eq( 'en' )
+			expect( param.subtag ).to eq( 'us' )
+			expect( param.qvalue ).to eq( 0.8 )
+			expect( param.extensions ).to be_empty()
 		end
 
 	end
@@ -199,44 +190,44 @@ describe Strelka::HTTPRequest, "accept params" do
 			hdr = 'iso-8859-1'
 			param = Strelka::HTTPRequest::Charset.parse( hdr )
 
-			param.should be_an_instance_of( Strelka::HTTPRequest::Charset )
-			param.name.should == 'iso-8859-1'
-			param.subtype.should be_nil()
-			param.qvalue.should == 1.0
-			param.extensions.should be_empty()
+			expect( param ).to be_an_instance_of( Strelka::HTTPRequest::Charset )
+			expect( param.name ).to eq( 'iso-8859-1' )
+			expect( param.subtype ).to be_nil()
+			expect( param.qvalue ).to eq( 1.0 )
+			expect( param.extensions ).to be_empty()
 		end
 
 		it "can parse a charset with a q-value" do
 			hdr = 'iso-8859-15; q=0.5'
 			param = Strelka::HTTPRequest::Charset.parse( hdr )
 
-			param.should be_an_instance_of( Strelka::HTTPRequest::Charset )
-			param.name.should == 'iso-8859-15'
-			param.subtype.should be_nil()
-			param.qvalue.should == 0.5
-			param.extensions.should be_empty()
+			expect( param ).to be_an_instance_of( Strelka::HTTPRequest::Charset )
+			expect( param.name ).to eq( 'iso-8859-15' )
+			expect( param.subtype ).to be_nil()
+			expect( param.qvalue ).to eq( 0.5 )
+			expect( param.extensions ).to be_empty()
 		end
 
 		it "can return the Ruby Encoding object associated with its character set" do
 			param = Strelka::HTTPRequest::Charset.parse( 'koi8-r' )
-			param.name.should == 'koi8-r'
-			param.encoding_object.should == Encoding::KOI8_R
+			expect( param.name ).to eq( 'koi8-r' )
+			expect( param.encoding_object ).to eq( Encoding::KOI8_R )
 		end
 
 		it "can be compared against strings" do
 			specific_param = Strelka::HTTPRequest::Charset.parse( 'us-ascii' )
 
-			( specific_param =~ 'us-ascii' ).should be_true()
-			( specific_param =~ 'ansi_x3.4-1968' ).should be_true()
-			( specific_param =~ 'utf-8' ).should be_false()
+			expect( ( specific_param =~ 'us-ascii' ) ).to be_true()
+			expect( ( specific_param =~ 'ansi_x3.4-1968' ) ).to be_true()
+			expect( ( specific_param =~ 'utf-8' ) ).to be_false()
 		end
 
 		it "can be compared against Encoding objects" do
 			specific_param = Strelka::HTTPRequest::Charset.parse( 'utf-8' )
 
-			( specific_param =~ Encoding::UTF_8 ).should be_true()
-			( specific_param =~ Encoding::CP65001 ).should be_true()
-			( specific_param =~ Encoding::MacThai ).should be_false()
+			expect( ( specific_param =~ Encoding::UTF_8 ) ).to be_true()
+			expect( ( specific_param =~ Encoding::CP65001 ) ).to be_true()
+			expect( ( specific_param =~ Encoding::MacThai ) ).to be_false()
 		end
 	end
 
@@ -247,34 +238,34 @@ describe Strelka::HTTPRequest, "accept params" do
 			hdr = 'identity'
 			param = Strelka::HTTPRequest::Encoding.parse( hdr )
 
-			param.should be_an_instance_of( Strelka::HTTPRequest::Encoding )
-			param.content_coding.should == 'identity'
-			param.subtype.should be_nil()
-			param.qvalue.should == 1.0
-			param.extensions.should be_empty()
+			expect( param ).to be_an_instance_of( Strelka::HTTPRequest::Encoding )
+			expect( param.content_coding ).to eq( 'identity' )
+			expect( param.subtype ).to be_nil()
+			expect( param.qvalue ).to eq( 1.0 )
+			expect( param.extensions ).to be_empty()
 		end
 
 		it "can parse an encoding with a q-value" do
 			hdr = 'gzip; q=0.55'
 			param = Strelka::HTTPRequest::Encoding.parse( hdr )
 
-			param.should be_an_instance_of( Strelka::HTTPRequest::Encoding )
-			param.content_coding.should == 'gzip'
-			param.subtype.should be_nil()
-			param.qvalue.should == 0.55
-			param.extensions.should be_empty()
+			expect( param ).to be_an_instance_of( Strelka::HTTPRequest::Encoding )
+			expect( param.content_coding ).to eq( 'gzip' )
+			expect( param.subtype ).to be_nil()
+			expect( param.qvalue ).to eq( 0.55 )
+			expect( param.extensions ).to be_empty()
 		end
 
 		it "can be compared against strings" do
 			specific_param = Strelka::HTTPRequest::MediaType.parse( 'text/html' )
 			subtype_wildcard_param = Strelka::HTTPRequest::MediaType.parse( 'image/*' )
 
-			( specific_param =~ 'text/html' ).should be_true()
-			( specific_param =~ 'image/png' ).should be_false()
+			expect( ( specific_param =~ 'text/html' ) ).to be_true()
+			expect( ( specific_param =~ 'image/png' ) ).to be_false()
 
-			( subtype_wildcard_param =~ 'image/png' ).should be_true()
-			( subtype_wildcard_param =~ 'image/jpeg' ).should be_true()
-			( subtype_wildcard_param =~ 'text/plain' ).should be_false()
+			expect( ( subtype_wildcard_param =~ 'image/png' ) ).to be_true()
+			expect( ( subtype_wildcard_param =~ 'image/jpeg' ) ).to be_true()
+			expect( ( subtype_wildcard_param =~ 'text/plain' ) ).to be_false()
 		end
 	end
 

data/spec/strelka/httprequest/auth_spec.rb

@@ -1,20 +1,10 @@
 # -*- 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_relative '../../helpers'
 
 require 'rspec'
 
-require 'spec/lib/helpers'
-
 require 'strelka'
 require 'strelka/httprequest/auth'
 
@@ -41,15 +31,15 @@ describe Strelka::HTTPRequest::Auth do
 
 
 	it "adds an authenticated? predicate" do
-		@req.should_not be_authenticated()
+		expect( @req ).to_not be_authenticated()
 		@req.authenticated_user = 'anonymous'
-		@req.should be_authenticated()
+		expect( @req ).to be_authenticated()
 	end
 
 	it "adds an authenticated_user attribute" do
-		@req.authenticated_user.should be_nil()
+		expect( @req.authenticated_user ).to be_nil()
 		@req.authenticated_user = 'someone'
-		@req.authenticated_user.should == 'someone'
+		expect( @req.authenticated_user ).to eq( 'someone' )
 	end
 
 end