strelka 0.6.0 → 0.7.0

data/spec/strelka/httprequest/negotiation_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/negotiation'
 require 'strelka/httpresponse/negotiation'
@@ -48,53 +38,53 @@ describe Strelka::HTTPRequest::Negotiation do
 		it "know what content-types are accepted by the client" do
 			@req.headers.accept = 'application/x-yaml, application/json; q=0.2, text/xml; q=0.75'
 
-			@req.accepted_types.should have(3).members
-			@req.accepted_types[0].mediatype.should == 'application/x-yaml'
-			@req.accepted_types[0].qvalue.should == 1.0
-			@req.accepted_types[1].mediatype.should == 'application/json'
-			@req.accepted_types[1].qvalue.should == 0.2
-			@req.accepted_types[2].mediatype.should == 'text/xml'
-			@req.accepted_types[2].qvalue.should == 0.75
+			expect( @req.accepted_types ).to have(3).members
+			expect( @req.accepted_types[0].mediatype ).to eq( 'application/x-yaml' )
+			expect( @req.accepted_types[0].qvalue ).to eq( 1.0 )
+			expect( @req.accepted_types[1].mediatype ).to eq( 'application/json' )
+			expect( @req.accepted_types[1].qvalue ).to eq( 0.2 )
+			expect( @req.accepted_types[2].mediatype ).to eq( 'text/xml' )
+			expect( @req.accepted_types[2].qvalue ).to eq( 0.75 )
 		end
 
 		it "knows what mimetypes are acceptable responses" do
 			@req.headers.accept = 'text/html, text/plain; q=0.5, image/*;q=0.1'
 
-			@req.accepts?( 'text/html' ).should be_true()
-			@req.accepts?( 'text/plain' ).should be_true()
-			@req.accepts?( 'text/ascii' ).should be_false()
-			@req.accepts?( 'image/png' ).should be_true()
-			@req.accepts?( 'application/x-yaml' ).should be_false()
+			expect( @req.accepts?( 'text/html' ) ).to be_true()
+			expect( @req.accepts?( 'text/plain' ) ).to be_true()
+			expect( @req.accepts?( 'text/ascii' ) ).to be_false()
+			expect( @req.accepts?( 'image/png' ) ).to be_true()
+			expect( @req.accepts?( 'application/x-yaml' ) ).to be_false()
 		end
 
 		it "knows what mimetypes are explicitly acceptable responses" do
 			@req.headers.accept = 'text/html, text/plain; q=0.5, image/*;q=0.1, */*'
 
-			@req.explicitly_accepts?( 'text/html' ).should be_true()
-			@req.explicitly_accepts?( 'text/plain' ).should be_true()
-			@req.explicitly_accepts?( 'text/ascii' ).should be_false()
-			@req.explicitly_accepts?( 'image/png' ).should be_false()
-			@req.explicitly_accepts?( 'application/x-yaml' ).should be_false()
+			expect( @req.explicitly_accepts?( 'text/html' ) ).to be_true()
+			expect( @req.explicitly_accepts?( 'text/plain' ) ).to be_true()
+			expect( @req.explicitly_accepts?( 'text/ascii' ) ).to be_false()
+			expect( @req.explicitly_accepts?( 'image/png' ) ).to be_false()
+			expect( @req.explicitly_accepts?( 'application/x-yaml' ) ).to be_false()
 		end
 
 		it "accepts anything if the client doesn't provide an Accept header" do
 			@req.headers.delete( :accept )
 
-			@req.accepts?( 'text/html' ).should be_true()
-			@req.accepts?( 'text/plain' ).should be_true()
-			@req.accepts?( 'text/ascii' ).should be_true()
-			@req.accepts?( 'image/png' ).should be_true()
-			@req.accepts?( 'application/x-yaml' ).should be_true()
+			expect( @req.accepts?( 'text/html' ) ).to be_true()
+			expect( @req.accepts?( 'text/plain' ) ).to be_true()
+			expect( @req.accepts?( 'text/ascii' ) ).to be_true()
+			expect( @req.accepts?( 'image/png' ) ).to be_true()
+			expect( @req.accepts?( 'application/x-yaml' ) ).to be_true()
 		end
 
 		it "doesn't explicitly accept anything if the client doesn't provide an Accept header" do
 			@req.headers.delete( :accept )
 
-			@req.explicitly_accepts?( 'text/html' ).should be_false()
-			@req.explicitly_accepts?( 'text/plain' ).should be_false()
-			@req.explicitly_accepts?( 'text/ascii' ).should be_false()
-			@req.explicitly_accepts?( 'image/png' ).should be_false()
-			@req.explicitly_accepts?( 'application/x-yaml' ).should be_false()
+			expect( @req.explicitly_accepts?( 'text/html' ) ).to be_false()
+			expect( @req.explicitly_accepts?( 'text/plain' ) ).to be_false()
+			expect( @req.explicitly_accepts?( 'text/ascii' ) ).to be_false()
+			expect( @req.explicitly_accepts?( 'image/png' ) ).to be_false()
+			expect( @req.explicitly_accepts?( 'application/x-yaml' ) ).to be_false()
 		end
 
 	end
@@ -105,33 +95,33 @@ describe Strelka::HTTPRequest::Negotiation do
 		it "knows what character sets are accepted by the client" do
 			@req.headers.accept_charset = 'iso-8859-5, utf-8;q=0.8'
 
-			@req.accepted_charsets.should have(2).members
-			@req.accepted_charsets[0].name.should == 'iso-8859-5'
-			@req.accepted_charsets[0].qvalue.should == 1.0
-			@req.accepted_charsets[1].name.should == 'utf-8'
-			@req.accepted_charsets[1].qvalue.should == 0.8
+			expect( @req.accepted_charsets ).to have(2).members
+			expect( @req.accepted_charsets[0].name ).to eq( 'iso-8859-5' )
+			expect( @req.accepted_charsets[0].qvalue ).to eq( 1.0 )
+			expect( @req.accepted_charsets[1].name ).to eq( 'utf-8' )
+			expect( @req.accepted_charsets[1].qvalue ).to eq( 0.8 )
 		end
 
 		it "knows what charsets are acceptable responses" do
 			@req.headers.accept_charset = 'iso-8859-5, utf-8;q=0.8'
 
-			@req.accepts_charset?( 'iso8859-5' ).should be_true()
-			@req.accepts_charset?( 'iso-8859-5' ).should be_true()
-			@req.accepts_charset?( 'utf-8' ).should be_true()
-			@req.accepts_charset?( Encoding::CP65001 ).should be_true()
-			@req.accepts_charset?( 'mac' ).should be_false()
-			@req.accepts_charset?( Encoding::SJIS ).should be_false()
+			expect( @req.accepts_charset?( 'iso8859-5' ) ).to be_true()
+			expect( @req.accepts_charset?( 'iso-8859-5' ) ).to be_true()
+			expect( @req.accepts_charset?( 'utf-8' ) ).to be_true()
+			expect( @req.accepts_charset?( Encoding::CP65001 ) ).to be_true()
+			expect( @req.accepts_charset?( 'mac' ) ).to be_false()
+			expect( @req.accepts_charset?( Encoding::SJIS ) ).to be_false()
 		end
 
 		it "accepts any charset if the client doesn't provide an Accept-Charset header" do
 			@req.headers.delete( :accept_charset )
 
-			@req.accepts_charset?( 'iso8859-5' ).should be_true()
-			@req.accepts_charset?( 'iso-8859-5' ).should be_true()
-			@req.accepts_charset?( 'utf-8' ).should be_true()
-			@req.accepts_charset?( Encoding::CP65001 ).should be_true()
-			@req.accepts_charset?( 'mac' ).should be_true()
-			@req.accepts_charset?( Encoding::SJIS ).should be_true()
+			expect( @req.accepts_charset?( 'iso8859-5' ) ).to be_true()
+			expect( @req.accepts_charset?( 'iso-8859-5' ) ).to be_true()
+			expect( @req.accepts_charset?( 'utf-8' ) ).to be_true()
+			expect( @req.accepts_charset?( Encoding::CP65001 ) ).to be_true()
+			expect( @req.accepts_charset?( 'mac' ) ).to be_true()
+			expect( @req.accepts_charset?( Encoding::SJIS ) ).to be_true()
 		end
 
 	end
@@ -142,63 +132,63 @@ describe Strelka::HTTPRequest::Negotiation do
 		it "knows what encodings are accepted by the client" do
 			@req.headers.accept_encoding = 'gzip;q=1.0, identity; q=0.5, *;q=0'
 
-			@req.accepted_encodings.should have(3).members
-			@req.accepted_encodings[0].content_coding.should == 'gzip'
-			@req.accepted_encodings[0].qvalue.should == 1.0
-			@req.accepted_encodings[1].content_coding.should == 'identity'
-			@req.accepted_encodings[1].qvalue.should == 0.5
-			@req.accepted_encodings[2].content_coding.should be_nil()
-			@req.accepted_encodings[2].qvalue.should == 0.0
+			expect( @req.accepted_encodings ).to have(3).members
+			expect( @req.accepted_encodings[0].content_coding ).to eq( 'gzip' )
+			expect( @req.accepted_encodings[0].qvalue ).to eq( 1.0 )
+			expect( @req.accepted_encodings[1].content_coding ).to eq( 'identity' )
+			expect( @req.accepted_encodings[1].qvalue ).to eq( 0.5 )
+			expect( @req.accepted_encodings[2].content_coding ).to be_nil()
+			expect( @req.accepted_encodings[2].qvalue ).to eq( 0.0 )
 		end
 
 		it "knows what encodings are acceptable" do
 			@req.headers.accept_encoding = 'gzip;q=1.0, identity; q=0.5, *;q=0'
 
-			@req.accepts_encoding?( 'gzip' ).should be_true()
-			@req.accepts_encoding?( 'identity' ).should be_true()
-			@req.accepts_encoding?( 'compress' ).should be_false()
+			expect( @req.accepts_encoding?( 'gzip' ) ).to be_true()
+			expect( @req.accepts_encoding?( 'identity' ) ).to be_true()
+			expect( @req.accepts_encoding?( 'compress' ) ).to be_false()
 		end
 
 		it "knows that the identity encoding is acceptable if it isn't disabled" do
 			@req.headers.accept_encoding = 'gzip;q=1.0, compress; q=0.5'
 
-			@req.accepts_encoding?( 'gzip' ).should be_true()
-			@req.accepts_encoding?( 'identity' ).should be_true()
-			@req.accepts_encoding?( 'compress' ).should be_true()
-			@req.accepts_encoding?( 'clowns' ).should be_false()
+			expect( @req.accepts_encoding?( 'gzip' ) ).to be_true()
+			expect( @req.accepts_encoding?( 'identity' ) ).to be_true()
+			expect( @req.accepts_encoding?( 'compress' ) ).to be_true()
+			expect( @req.accepts_encoding?( 'clowns' ) ).to be_false()
 		end
 
 		it "accepts only the 'identity' encoding if the Accept-Encoding field is empty" do
 			@req.headers.accept_encoding = ''
 
-			@req.accepts_encoding?( 'identity' ).should be_true()
-			@req.accepts_encoding?( 'gzip' ).should be_false()
-			@req.accepts_encoding?( 'compress' ).should be_false()
+			expect( @req.accepts_encoding?( 'identity' ) ).to be_true()
+			expect( @req.accepts_encoding?( 'gzip' ) ).to be_false()
+			expect( @req.accepts_encoding?( 'compress' ) ).to be_false()
 		end
 
 		it "doesn't accept the 'identity' encoding if the Accept-Encoding field explicitly disables it" do
 			@req.headers.accept_encoding = 'gzip;q=0.5, identity;q=0'
 
-			@req.accepts_encoding?( 'identity' ).should be_false()
-			@req.accepts_encoding?( 'gzip' ).should be_true()
-			@req.accepts_encoding?( 'compress' ).should be_false()
+			expect( @req.accepts_encoding?( 'identity' ) ).to be_false()
+			expect( @req.accepts_encoding?( 'gzip' ) ).to be_true()
+			expect( @req.accepts_encoding?( 'compress' ) ).to be_false()
 		end
 
 		it "doesn't accept the 'identity' encoding if the Accept-Encoding field has a wildcard " +
 		   "with q-value of 0 and doesn't explicitly include 'identity'" do
 			@req.headers.accept_encoding = 'gzip;q=0.5, *;q=0'
 
-			@req.accepts_encoding?( 'identity' ).should be_false()
-			@req.accepts_encoding?( 'gzip' ).should be_true()
-			@req.accepts_encoding?( 'compress' ).should be_false()
+			expect( @req.accepts_encoding?( 'identity' ) ).to be_false()
+			expect( @req.accepts_encoding?( 'gzip' ) ).to be_true()
+			expect( @req.accepts_encoding?( 'compress' ) ).to be_false()
 		end
 
 		it "accepts every encoding if the request doesn't have an Accept-Encoding header" do
 			@req.headers.delete( :accept_encoding )
 
-			@req.accepts_encoding?( 'identity' ).should be_true()
-			@req.accepts_encoding?( 'gzip' ).should be_true()
-			@req.accepts_encoding?( 'compress' ).should be_true()
+			expect( @req.accepts_encoding?( 'identity' ) ).to be_true()
+			expect( @req.accepts_encoding?( 'gzip' ) ).to be_true()
+			expect( @req.accepts_encoding?( 'compress' ) ).to be_true()
 		end
 
 	end
@@ -209,38 +199,38 @@ describe Strelka::HTTPRequest::Negotiation do
 		it "knows what languages are accepted by the client" do
 			@req.headers.accept_language = 'da, en-gb;q=0.8, en;q=0.7'
 
-			@req.accepted_languages.should have(3).members
-			@req.accepted_languages[0].primary_tag.should == 'da'
-			@req.accepted_languages[0].subtag.should == nil
-			@req.accepted_languages[0].qvalue.should == 1.0
-			@req.accepted_languages[1].primary_tag.should == 'en'
-			@req.accepted_languages[1].subtag.should == 'gb'
-			@req.accepted_languages[1].qvalue.should == 0.8
-			@req.accepted_languages[2].primary_tag.should == 'en'
-			@req.accepted_languages[2].subtag.should == nil
-			@req.accepted_languages[2].qvalue.should == 0.7
+			expect( @req.accepted_languages ).to have(3).members
+			expect( @req.accepted_languages[0].primary_tag ).to eq( 'da' )
+			expect( @req.accepted_languages[0].subtag ).to eq( nil )
+			expect( @req.accepted_languages[0].qvalue ).to eq( 1.0 )
+			expect( @req.accepted_languages[1].primary_tag ).to eq( 'en' )
+			expect( @req.accepted_languages[1].subtag ).to eq( 'gb' )
+			expect( @req.accepted_languages[1].qvalue ).to eq( 0.8 )
+			expect( @req.accepted_languages[2].primary_tag ).to eq( 'en' )
+			expect( @req.accepted_languages[2].subtag ).to eq( nil )
+			expect( @req.accepted_languages[2].qvalue ).to eq( 0.7 )
 		end
 
 		it "knows what languages may be used in acceptable responses" do
 			@req.headers.accept_language = 'da, en-gb;q=0.8, en;q=0.7'
 
-			@req.accepts_language?( 'da' ).should be_true()
-			@req.accepts_language?( 'en' ).should be_true()
-			@req.accepts_language?( 'en-gb' ).should be_true()
-			@req.accepts_language?( 'en-cockney' ).should be_true()
-			@req.accepts_language?( 'de' ).should be_false()
-			@req.accepts_language?( 'tlh' ).should be_false()
+			expect( @req.accepts_language?( 'da' ) ).to be_true()
+			expect( @req.accepts_language?( 'en' ) ).to be_true()
+			expect( @req.accepts_language?( 'en-gb' ) ).to be_true()
+			expect( @req.accepts_language?( 'en-cockney' ) ).to be_true()
+			expect( @req.accepts_language?( 'de' ) ).to be_false()
+			expect( @req.accepts_language?( 'tlh' ) ).to be_false()
 		end
 
 		it "accepts any language if the client doesn't provide an Accept-Language header" do
 			@req.headers.delete( :accept_language )
 
-			@req.accepts_language?( 'da' ).should be_true()
-			@req.accepts_language?( 'en' ).should be_true()
-			@req.accepts_language?( 'en-gb' ).should be_true()
-			@req.accepts_language?( 'en-cockney' ).should be_true()
-			@req.accepts_language?( 'de' ).should be_true()
-			@req.accepts_language?( 'tlh' ).should be_true()
+			expect( @req.accepts_language?( 'da' ) ).to be_true()
+			expect( @req.accepts_language?( 'en' ) ).to be_true()
+			expect( @req.accepts_language?( 'en-gb' ) ).to be_true()
+			expect( @req.accepts_language?( 'en-cockney' ) ).to be_true()
+			expect( @req.accepts_language?( 'de' ) ).to be_true()
+			expect( @req.accepts_language?( 'tlh' ) ).to be_true()
 		end
 
 	end

data/spec/strelka/httprequest/session_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/app/sessions'
 require 'strelka/httprequest/session'
@@ -48,28 +38,28 @@ describe Strelka::HTTPRequest::Session, "-extended request" do
 
 
 	it "has a session_namespace attribute" do
-		@req.should respond_to( :session_namespace )
+		expect( @req ).to respond_to( :session_namespace )
 	end
 
 
 	context "with no session ID" do
 
 		it "knows that it doesn't have a session" do
-			@req.should_not have_session()
+			expect( @req ).to_not have_session()
 		end
 
 		it "doesn't load the session when the session namespace is set" do
 			@req.session_namespace = 'an_appid'
-			@req.should_not have_session()
+			expect( @req ).to_not have_session()
 		end
 
 		it "creates a new session as soon as it's accessed" do
-			@req.session.should be_a( Strelka::Session::Default )
+			expect( @req.session ).to be_a( Strelka::Session::Default )
 		end
 
 		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
+			expect( @req.session.namespace ).to eq( :an_appid )
 		end
 
 
@@ -81,12 +71,12 @@ describe Strelka::HTTPRequest::Session, "-extended request" do
 			end
 
 			it "knows that it has a session" do
-				@req.should have_session()
+				expect( @req ).to 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
+				expect( @session.namespace ).to eq( :the_appid )
 			end
 		end
 
@@ -100,7 +90,7 @@ describe Strelka::HTTPRequest::Session, "-extended request" do
 		end
 
 		it "knows that it doesn't have a session unless the ID exists" do
-			@req.should_not have_session()
+			expect( @req ).to_not have_session()
 		end
 
 
@@ -113,16 +103,16 @@ describe Strelka::HTTPRequest::Session, "-extended request" do
 			it "knows that it has a session" do
 				cookie_name = Strelka::Session::Default.cookie_name
 				@req.header.cookie = "#{cookie_name}=#{@sess_id}"
-				@req.should have_session()
+				expect( @req ).to have_session()
 			end
 
 			it "knows when its session hasn't been loaded" do
-				@req.session_loaded?.should be_false()
+				expect( @req.session_loaded? ).to be_false()
 			end
 
 			it "knows when its session has been loaded" do
 				@req.session # Load it
-				@req.session_loaded?.should be_true()
+				expect( @req.session_loaded? ).to be_true()
 			end
 
 		end

data/spec/strelka/httprequest_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/httprequest'
 require 'strelka/cookie'