strelka 0.0.1pre4 → 0.0.1.pre129

data/spec/strelka/httprequest/acceptparams_spec.rb

@@ -0,0 +1,282 @@
+#!/usr/bin/env ruby
+
+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/httprequest/acceptparams'
+
+
+#####################################################################
+###	C O N T E X T S
+#####################################################################
+
+describe Strelka::HTTPRequest, "accept params" do
+	before( :all ) do
+		setup_logging( :fatal )
+	end
+
+	after( :all ) do
+		reset_logging()
+	end
+
+
+	describe Strelka::HTTPRequest::MediaType do
+
+		VALID_HEADERS = {
+			'*/*' =>
+				{:type => nil, :subtype => nil, :qval => 1.0},
+			'*/*; q=0.1' =>
+				{:type => nil, :subtype => nil, :qval => 0.1},
+			'*/*;q=0.1' =>
+				{:type => nil, :subtype => nil, :qval => 0.1},
+			'image/*' =>
+				{:type => 'image', :subtype => nil, :qval => 1.0},
+			'image/*; q=0.18' =>
+				{:type => 'image', :subtype => nil, :qval => 0.18},
+			'image/*;q=0.4' =>
+				{:type => 'image', :subtype => nil, :qval => 0.4},
+			'image/*;q=0.9; porn=0; anseladams=1' =>
+				{:type => 'image', :subtype => nil, :qval => 0.9,
+					:extensions => %w[anseladams=1 porn=0]},
+			'image/png' =>
+				{:type => 'image', :subtype => 'png', :qval => 1.0},
+			'IMAGE/pNg' =>
+				{:type => 'image', :subtype => 'png', :qval => 1.0},
+			'application/x-porno' =>
+				{:type => 'application', :subtype => 'x-porno', :qval => 1.0},
+			'image/png; q=0.2' =>
+				{:type => 'image', :subtype => 'png', :qval => 0.2},
+			'image/x-giraffes;q=0.2' =>
+				{:type => 'image', :subtype => 'x-giraffes', :qval => 0.2},
+			'example/pork;    headcheese=0;withfennel=1' =>
+				{:type => 'example', :subtype => 'pork', :qval => 1.0,
+					:extensions => %w[headcheese=0 withfennel=1]},
+			'model/vnd.moml+xml' =>
+				{:type => 'model', :subtype => 'vnd.moml+xml', :qval => 1.0},
+			'model/parasolid.transmit.binary; q=0.2' =>
+				{:type => 'model', :subtype => 'parasolid.transmit.binary',
+					:qval => 0.2},
+			'image/png; q=0.2; compression=1' =>
+				{:type => 'image', :subtype => 'png', :qval => 0.2,
+					:extensions => %w[compression=1]},
+		}
+
+
+		it "parses valid Accept header values" 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]
+
+				if expectations[:extensions]
+					expectations[:extensions].each do |ext|
+						rval.extensions.should include( ext )
+					end
+				end
+			end
+		end
+
+
+		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
+		end
+
+
+		it "rejects invalid Accept header values" do
+			lambda {
+				Strelka::HTTPRequest::MediaType.parse( 'porksausage' )
+			}.should 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}
+		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
+		end
+
+
+		it "can compare and sort on specificity" do
+			header = "text/xml,application/xml,application/xhtml+xml,text/html;q=0.9," +
+				     "text/html;q=0.9;level=1,text/plain;q=0.8,image/png,*/*;q=0.5"
+			params = header.
+				split( /\s*,\s*/ ).
+				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'
+		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()
+
+			( subtype_wildcard_param =~ 'image/png' ).should be_true()
+			( subtype_wildcard_param =~ 'image/jpeg' ).should be_true()
+			( subtype_wildcard_param =~ 'text/plain' ).should be_false()
+		end
+	end
+
+
+	describe Strelka::HTTPRequest::Language do
+
+		it "can parse a simple language code" 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()
+		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()
+		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()
+		end
+
+	end
+
+
+	describe Strelka::HTTPRequest::Charset do
+
+		it "can parse a simple charset" 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()
+		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()
+		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
+		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()
+		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()
+		end
+	end
+
+
+	describe Strelka::HTTPRequest::Encoding do
+
+		it "can parse a simple encoding" 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()
+		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()
+		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()
+
+			( subtype_wildcard_param =~ 'image/png' ).should be_true()
+			( subtype_wildcard_param =~ 'image/jpeg' ).should be_true()
+			( subtype_wildcard_param =~ 'text/plain' ).should be_false()
+		end
+	end
+
+
+end
+
+# vim: set nosta noet ts=4 sw=4:

data/spec/strelka/httprequest/negotiation_spec.rb

@@ -0,0 +1,246 @@
+#!/usr/bin/env ruby
+
+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/httprequest/negotiation'
+require 'strelka/httpresponse/negotiation'
+
+
+#####################################################################
+###	C O N T E X T S
+#####################################################################
+
+describe Strelka::HTTPRequest::Negotiation do
+
+	before( :all ) do
+		setup_logging( :fatal )
+		@request_factory = Mongrel2::RequestFactory.new( route: '/service/user' )
+	end
+
+	after( :all ) do
+		reset_logging()
+	end
+
+
+	before( :each ) do
+		@req = @request_factory.get( '/service/user/estark' )
+		@req.extend( described_class )
+	end
+
+
+	describe "mediatype 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
+		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()
+		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()
+		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()
+		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()
+		end
+
+	end
+
+
+	describe "character-set 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
+		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()
+		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()
+		end
+
+	end
+
+
+	describe "content encoding 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
+		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()
+		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()
+		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()
+		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()
+		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()
+		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()
+		end
+
+	end
+
+
+	describe "natural language 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
+		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()
+		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()
+		end
+
+	end
+
+end