strelka 0.6.0 → 0.7.0

data/spec/strelka/httpresponse_spec.rb

@@ -1,15 +1,9 @@
 #!/usr/bin/env ruby
 #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/httpresponse'
 
 
@@ -38,15 +32,15 @@ describe Strelka::HTTPResponse do
 		@res.content_type = 'text/html'
 		@res.charset = Encoding::UTF_8
 
-		@res.header_data.should =~ %r{Content-type: text/html; charset=UTF-8}i
+		expect( @res.header_data ).to match( %r{Content-type: text/html; charset=UTF-8}i )
 	end
 
 	it "replaces the existing content-type header charset if it's text/* and one is explicitly set" do
 		@res.content_type = 'text/html; charset=iso-8859-1'
 		@res.charset = Encoding::UTF_8
 
-		@res.header_data.should =~ /charset=UTF-8/i
-		@res.header_data.should_not =~ /charset=iso-8859-1/
+		expect( @res.header_data ).to match( /charset=UTF-8/i )
+		expect( @res.header_data ).to_not match( /charset=iso-8859-1/ )
 	end
 
 	it "adds a charset to the response's content-type header based on the entity body's encoding " +
@@ -54,7 +48,7 @@ describe Strelka::HTTPResponse do
 		@res.body = "Стрелке".encode( 'koi8-r' )
 		@res.content_type = 'text/plain'
 
-		@res.header_data.should =~ /charset=koi8-r/i
+		expect( @res.header_data ).to match( /charset=koi8-r/i )
 	end
 
 	it "adds a charset to the response's content-type header based on the entity body's " +
@@ -62,15 +56,15 @@ describe Strelka::HTTPResponse do
 		@res.body = File.open( __FILE__, 'r:iso-8859-5' )
 		@res.content_type = 'text/plain'
 
-		@res.header_data.should =~ /charset=iso-8859-5/i
+		expect( @res.header_data ).to match( /charset=iso-8859-5/i )
 	end
 
 	it "doesn't replace a charset in a text/* content-type header with one based on the entity body" do
 		@res.body = "Стрелке".encode( 'iso-8859-5' )
 		@res.content_type = 'text/plain; charset=utf-8'
 
-		@res.header_data.should_not =~ /charset=iso-8859-5/i
-		@res.header_data.should =~ /charset=utf-8/i
+		expect( @res.header_data ).to_not match( /charset=iso-8859-5/i )
+		expect( @res.header_data ).to match( /charset=utf-8/i )
 	end
 
 	it "doesn't add a charset to the response's content-type header if it's explicitly set " +
@@ -78,12 +72,12 @@ describe Strelka::HTTPResponse do
 		@res.content_type = 'text/plain'
 		@res.charset = Encoding::ASCII_8BIT
 
-		@res.header_data.should_not =~ /charset/i
+		expect( @res.header_data ).to_not match( /charset/i )
 	end
 
 	it "doesn't add a charset to the response's content-type header if it's not text/*" do
 		@res.content_type = 'application/octet-stream'
-		@res.header_data.should_not =~ /charset/i
+		expect( @res.header_data ).to_not match( /charset/i )
 	end
 
 	it "strips an existing charset from the response's content-type header if it's explicitly " +
@@ -91,51 +85,51 @@ describe Strelka::HTTPResponse do
 		@res.content_type = 'text/plain; charset=ISO-8859-15'
 		@res.charset = Encoding::ASCII_8BIT
 
-		@res.header_data.should_not =~ /charset/i
+		expect( @res.header_data ).to_not match( /charset/i )
 	end
 
 	it "doesn't try to add an encoding to a response that doesn't have a content type" do
 		@res.content_type = nil
-		@res.header_data.should_not =~ /charset/
+		expect( @res.header_data ).to_not match( /charset/ )
 	end
 
 	it "adds a Content-encoding header if there is one encoding" do
 		@res.encodings << 'gzip'
-		@res.header_data.should =~ /content-encoding: gzip\s*$/i
+		expect( @res.header_data ).to match( /content-encoding: gzip\s*$/i )
 	end
 
 	it "adds a Content-encoding header if there is more than one encoding" do
 		@res.encodings << 'gzip' << 'compress'
-		@res.header_data.should =~ /content-encoding: gzip, compress\s*$/i
+		expect( @res.header_data ).to match( /content-encoding: gzip, compress\s*$/i )
 	end
 
 
 	it "adds a Content-language header if there is one language" do
 		@res.languages << 'de'
-		@res.header_data.should =~ /content-language: de\s*$/i
+		expect( @res.header_data ).to match( /content-language: de\s*$/i )
 	end
 
 	it "adds a Content-language header if there is more than one language" do
 		@res.languages << 'en' << 'sv-chef'
-		@res.header_data.should =~ /content-language: en, sv-chef\s*$/i
+		expect( @res.header_data ).to match( /content-language: en, sv-chef\s*$/i )
 	end
 
 
 	it "allows cookies to be set via a Hash-like interface" do
 		@res.cookies[:foom] = 'chuckUfarly'
-		@res.header_data.should =~ /set-cookie: foom=chuckufarly/i
+		expect( @res.header_data ).to match( /set-cookie: foom=chuckufarly/i )
 	end
 
 	it "allows cookies to be appended" do
 		@res.cookies << Strelka::Cookie.new( 'session', '64a3a92eb7403a8199301e03e8b83810' )
 		@res.cookies << Strelka::Cookie.new( 'cn', '18', :expires => '+1d' )
-		@res.header_data.should =~ /set-cookie: session=64a3a92eb7403a8199301e03e8b83810/i
-		@res.header_data.should =~ /set-cookie: cn=18; expires=/i
+		expect( @res.header_data ).to match( /set-cookie: session=64a3a92eb7403a8199301e03e8b83810/i )
+		expect( @res.header_data ).to match( /set-cookie: cn=18; expires=/i )
 	end
 
 
 	it "shares a 'notes' Hash with its associated request" do
-		@res.notes.should be( @req.notes )
+		expect( @res.notes ).to be( @req.notes )
 	end
 
 end

data/spec/strelka/mixins_spec.rb

@@ -2,15 +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 'set'
 require 'rspec'
-require 'spec/lib/helpers'
 require 'strelka/mixins'
 
 
@@ -92,35 +87,35 @@ describe Strelka, "mixins" do
 			end
 
 			before( :each ) do
-				@subobj = mock( "delegate" )
+				@subobj = double( "delegate" )
 				@obj = @testclass.new( @subobj )
 			end
 
 
 			it "can be used to set up delegation through a method" do
-				@subobj.should_receive( :delegated_method )
+				expect( @subobj ).to receive( :delegated_method )
 				@obj.delegated_method
 			end
 
 			it "passes any arguments through to the delegate object's method" do
-				@subobj.should_receive( :delegated_method ).with( :arg1, :arg2 )
+				expect( @subobj ).to receive( :delegated_method ).with( :arg1, :arg2 )
 				@obj.delegated_method( :arg1, :arg2 )
 			end
 
 			it "allows delegation to the delegate object's method with a block" do
-				@subobj.should_receive( :delegated_method ).with( :arg1 ).
+				expect( @subobj ).to receive( :delegated_method ).with( :arg1 ).
 					and_yield( :the_block_argument )
 				blockarg = nil
 				@obj.delegated_method( :arg1 ) {|arg| blockarg = arg }
-				blockarg.should == :the_block_argument
+				expect( blockarg ).to eq( :the_block_argument )
 			end
 
 			it "reports errors from its caller's perspective", :ruby_1_8_only => true do
 				begin
 					@obj.erroring_delegated_method
 				rescue NoMethodError => err
-					err.message.should =~ /nonexistant_method/
-					err.backtrace.first.should =~ /#{__FILE__}/
+					expect( err.message ).to match( /nonexistant_method/ )
+					expect( err.backtrace.first ).to match( /#{__FILE__}/ )
 				rescue ::Exception => err
 					fail "Expected a NoMethodError, but got a %p (%s)" % [ err.class, err.message ]
 				else
@@ -146,35 +141,35 @@ describe Strelka, "mixins" do
 			end
 
 			before( :each ) do
-				@subobj = mock( "delegate" )
+				@subobj = double( "delegate" )
 				@obj = @testclass.new( @subobj )
 			end
 
 
 			it "can be used to set up delegation through a method" do
-				@subobj.should_receive( :delegated_method )
+				expect( @subobj ).to receive( :delegated_method )
 				@obj.delegated_method
 			end
 
 			it "passes any arguments through to the delegate's method" do
-				@subobj.should_receive( :delegated_method ).with( :arg1, :arg2 )
+				expect( @subobj ).to receive( :delegated_method ).with( :arg1, :arg2 )
 				@obj.delegated_method( :arg1, :arg2 )
 			end
 
 			it "allows delegation to the delegate's method with a block" do
-				@subobj.should_receive( :delegated_method ).with( :arg1 ).
+				expect( @subobj ).to receive( :delegated_method ).with( :arg1 ).
 					and_yield( :the_block_argument )
 				blockarg = nil
 				@obj.delegated_method( :arg1 ) {|arg| blockarg = arg }
-				blockarg.should == :the_block_argument
+				expect( blockarg ).to eq( :the_block_argument )
 			end
 
 			it "reports errors from its caller's perspective", :ruby_1_8_only => true do
 				begin
 					@obj.erroring_delegated_method
 				rescue NoMethodError => err
-					err.message.should =~ /`erroring_delegated_method' for nil/
-					err.backtrace.first.should =~ /#{__FILE__}/
+					expect( err.message ).to match( /`erroring_delegated_method' for nil/ )
+					expect( err.backtrace.first ).to match( /#{__FILE__}/ )
 				rescue ::Exception => err
 					fail "Expected a NoMethodError, but got a %p (%s)" % [ err.class, err.message ]
 				else
@@ -190,16 +185,26 @@ describe Strelka, "mixins" do
 	describe Strelka::DataUtilities do
 
 		it "doesn't try to dup immediate objects" do
-			Strelka::DataUtilities.deep_copy( nil ).should be( nil )
-			Strelka::DataUtilities.deep_copy( 112 ).should be( 112 )
-			Strelka::DataUtilities.deep_copy( true ).should be( true )
-			Strelka::DataUtilities.deep_copy( false ).should be( false )
-			Strelka::DataUtilities.deep_copy( :a_symbol ).should be( :a_symbol )
+			expect( Strelka::DataUtilities.deep_copy( nil ) ).to be( nil )
+			expect( Strelka::DataUtilities.deep_copy( 112 ) ).to be( 112 )
+			expect( Strelka::DataUtilities.deep_copy( true ) ).to be( true )
+			expect( Strelka::DataUtilities.deep_copy( false ) ).to be( false )
+			expect( Strelka::DataUtilities.deep_copy( :a_symbol ) ).to be( :a_symbol )
 		end
 
 		it "doesn't try to dup modules/classes" do
 			klass = Class.new
-			Strelka::DataUtilities.deep_copy( klass ).should be( klass )
+			expect( Strelka::DataUtilities.deep_copy( klass ) ).to be( klass )
+		end
+
+		it "doesn't try to dup IOs" do
+			data = [ $stdin ]
+			expect( Strelka::DataUtilities.deep_copy( data[0] ) ).to be( $stdin )
+		end
+
+		it "doesn't try to dup Tempfiles" do
+			data = Tempfile.new( 'strelka_deepcopy.XXXXX' )
+			expect( Strelka::DataUtilities.deep_copy( data ) ).to be( data )
 		end
 
 		it "makes distinct copies of arrays and their members" do
@@ -207,14 +212,14 @@ describe Strelka, "mixins" do
 
 			copy = Strelka::DataUtilities.deep_copy( original )
 
-			copy.should == original
-			copy.should_not be( original )
-			copy[0].should == original[0]
-			copy[0].should_not be( original[0] )
-			copy[1].should == original[1]
-			copy[1].should_not be( original[1] )
-			copy[2].should == original[2]
-			copy[2].should be( original[2] ) # Immediate
+			expect( copy ).to eq( original )
+			expect( copy ).to_not be( original )
+			expect( copy[0] ).to eq( original[0] )
+			expect( copy[0] ).to_not be( original[0] )
+			expect( copy[1] ).to eq( original[1] )
+			expect( copy[1] ).to_not be( original[1] )
+			expect( copy[2] ).to eq( original[2] )
+			expect( copy[2] ).to be( original[2] ) # Immediate
 		end
 
 		it "makes recursive copies of deeply-nested Arrays" do
@@ -222,12 +227,12 @@ describe Strelka, "mixins" do
 
 			copy = Strelka::DataUtilities.deep_copy( original )
 
-			copy.should == original
-			copy.should_not be( original )
-			copy[1].should_not be( original[1] )
-			copy[1][2].should_not be( original[1][2] )
-			copy[3].should_not be( original[3] )
-			copy[3][1].should_not be( original[3][1] )
+			expect( copy ).to eq( original )
+			expect( copy ).to_not be( original )
+			expect( copy[1] ).to_not be( original[1] )
+			expect( copy[1][2] ).to_not be( original[1][2] )
+			expect( copy[3] ).to_not be( original[3] )
+			expect( copy[3][1] ).to_not be( original[3][1] )
 		end
 
 		it "makes distinct copies of Hashes and their members" do
@@ -239,13 +244,13 @@ describe Strelka, "mixins" do
 
 			copy = Strelka::DataUtilities.deep_copy( original )
 
-			copy.should == original
-			copy.should_not be( original )
-			copy[:a].should == 1
-			copy.key( 2 ).should == 'b'
-			copy.key( 2 ).should_not be( original.key(2) )
-			copy[3].should == 'c'
-			copy[3].should_not be( original[3] )
+			expect( copy ).to eq( original )
+			expect( copy ).to_not be( original )
+			expect( copy[:a] ).to eq( 1 )
+			expect( copy.key( 2 ) ).to eq( 'b' )
+			expect( copy.key( 2 ) ).to_not be( original.key(2) )
+			expect( copy[3] ).to eq( 'c' )
+			expect( copy[3] ).to_not be( original[3] )
 		end
 
 		it "makes distinct copies of deeply-nested Hashes" do
@@ -262,15 +267,15 @@ describe Strelka, "mixins" do
 
 			copy = Strelka::DataUtilities.deep_copy( original )
 
-			copy.should == original
-			copy[:a][:b][:c].should == 'd'
-			copy[:a][:b][:c].should_not be( original[:a][:b][:c] )
-			copy[:a][:b][:e].should == 'f'
-			copy[:a][:b][:e].should_not be( original[:a][:b][:e] )
-			copy[:a][:g].should == 'h'
-			copy[:a][:g].should_not be( original[:a][:g] )
-			copy[:i].should == 'j'
-			copy[:i].should_not be( original[:i] )
+			expect( copy ).to eq( original )
+			expect( copy[:a][:b][:c] ).to eq( 'd' )
+			expect( copy[:a][:b][:c] ).to_not be( original[:a][:b][:c] )
+			expect( copy[:a][:b][:e] ).to eq( 'f' )
+			expect( copy[:a][:b][:e] ).to_not be( original[:a][:b][:e] )
+			expect( copy[:a][:g] ).to eq( 'h' )
+			expect( copy[:a][:g] ).to_not be( original[:a][:g] )
+			expect( copy[:i] ).to eq( 'j' )
+			expect( copy[:i] ).to_not be( original[:i] )
 		end
 
 		it "copies the default proc of copied Hashes" do
@@ -278,7 +283,7 @@ describe Strelka, "mixins" do
 
 			copy = Strelka::DataUtilities.deep_copy( original )
 
-			copy.default_proc.should == original.default_proc
+			expect( copy.default_proc ).to eq( original.default_proc )
 		end
 
 		it "preserves taintedness of copied objects" do
@@ -287,8 +292,8 @@ describe Strelka, "mixins" do
 
 			copy = Strelka::DataUtilities.deep_copy( original )
 
-			copy.should_not be( original )
-			copy.should be_tainted()
+			expect( copy ).to_not be( original )
+			expect( copy ).to be_tainted()
 		end
 
 		it "preserves frozen-ness of copied objects" do
@@ -297,8 +302,8 @@ describe Strelka, "mixins" do
 
 			copy = Strelka::DataUtilities.deep_copy( original )
 
-			copy.should_not be( original )
-			copy.should be_frozen()
+			expect( copy ).to_not be( original )
+			expect( copy ).to be_frozen()
 		end
 
 	end

data/spec/strelka/multipartparser_spec.rb

@@ -1,17 +1,11 @@
 #!/usr/bin/env ruby
 #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 'date'
 require 'rspec'
 
-require 'spec/lib/helpers'
-
 require 'strelka'
 require 'strelka/multipartparser'
 
@@ -83,9 +77,9 @@ describe Strelka::MultipartParser do
 
 		params = parser.parse
 
-		params.should have( 5 ).keys
-		params.keys.should include( 'x-livejournal-entry' )
-		params['velour-fog'].should =~ /Sweet, sweet canday/i
+		expect( params ).to have( 5 ).keys
+		expect( params.keys ).to include( 'x-livejournal-entry' )
+		expect( params['velour-fog'] ).to match( /Sweet, sweet canday/i )
 	end
 
 
@@ -96,13 +90,13 @@ describe Strelka::MultipartParser do
 
 		file = params['upload']
 
-		file.should be_a( Tempfile )
-		file.filename.should == 'testfile.rtf'
-		file.content_length.should == 480
-		file.content_type.should == 'application/rtf'
+		expect( file ).to be_a( Tempfile )
+		expect( file.filename ).to eq( 'testfile.rtf' )
+		expect( file.content_length ).to eq( 480 )
+		expect( file.content_type ).to eq( 'application/rtf' )
 
 		file.open
-		file.read.should =~ /screaming.+anguish.+sirens/
+		expect( file.read ).to match( /screaming.+anguish.+sirens/ )
 	end
 
 	it "strips full paths from upload filenames (e.g., from MSIE)" do
@@ -112,13 +106,13 @@ describe Strelka::MultipartParser do
 
 		file = params['upload']
 
-		file.should be_a( Tempfile )
-		file.filename.should == 'testfile.rtf'
-		file.content_length.should == 480
-		file.content_type.should == 'application/rtf'
+		expect( file ).to be_a( Tempfile )
+		expect( file.filename ).to eq( 'testfile.rtf' )
+		expect( file.content_length ).to eq( 480 )
+		expect( file.content_type ).to eq( 'application/rtf' )
 
 		file.open
-		file.read.should =~ /screaming.+anguish.+sirens/
+		expect( file.read ).to match( /screaming.+anguish.+sirens/ )
 	end
 
 	it "parses a mix of uploaded files and form data" do
@@ -126,23 +120,23 @@ describe Strelka::MultipartParser do
 		parser = described_class.new( socket, BOUNDARY )
 		params = parser.parse
 
-		params['pork'].should be_an_instance_of( Array )
-		params['pork'].should have( 2 ).members
-		params['pork'].should include( 'zoot' )
-		params['pork'].should include( 'fornk' )
+		expect( params['pork'] ).to be_an_instance_of( Array )
+		expect( params['pork'] ).to have( 2 ).members
+		expect( params['pork'] ).to include( 'zoot' )
+		expect( params['pork'] ).to include( 'fornk' )
 
-		params['namespace'].should == 'testing'
-		params['rating'].should == '5'
+		expect( params['namespace'] ).to eq( 'testing' )
+		expect( params['rating'] ).to eq( '5' )
 
 		file = params['upload']
 
-		file.should be_an_instance_of( Tempfile )
-		file.filename.should == 'testfile.rtf'
-		file.content_length.should == 480
-		file.content_type.should == 'application/rtf'
+		expect( file ).to be_an_instance_of( Tempfile )
+		expect( file.filename ).to eq( 'testfile.rtf' )
+		expect( file.content_length ).to eq( 480 )
+		expect( file.content_type ).to eq( 'application/rtf' )
 
 		file.open
-		file.read.should =~ /screaming.+anguish.+sirens/
+		expect( file.read ).to match( /screaming.+anguish.+sirens/ )
 	end
 
 
@@ -155,14 +149,14 @@ describe Strelka::MultipartParser do
 
 		file1, file2 = params['thingfish-upload']
 
-		file1.filename.should == 'Photo 3.jpg'
-		file2.filename.should == 'grass2.jpg'
+		expect( file1.filename ).to eq( 'Photo 3.jpg' )
+		expect( file2.filename ).to eq( 'grass2.jpg' )
 
-		file1.content_type.should == 'image/jpeg'
-		file2.content_type.should == 'image/jpeg'
+		expect( file1.content_type ).to eq( 'image/jpeg' )
+		expect( file2.content_type ).to eq( 'image/jpeg' )
 
-		file1.content_length.should == 82143
-		file2.content_length.should == 439257
+		expect( file1.content_length ).to eq( 82143 )
+		expect( file2.content_length ).to eq( 439257 )
 	end
 
 end