strelka 0.7.0 → 0.8.0

data/spec/strelka/app/restresources_spec.rb

@@ -74,7 +74,7 @@ describe Strelka::App::RestResources do
 			end
 
 			it "keeps track of what resources are mounted where" do
-				expect( @app.resource_verbs ).to have( 1 ).member
+				expect( @app.resource_verbs.size ).to eq(  1  )
 				expect( @app.resource_verbs ).to include( 'servers' )
 				@app.resource_verbs[ 'servers' ].
 					should include( :OPTIONS, :GET, :HEAD, :POST, :PUT, :DELETE )
@@ -87,6 +87,7 @@ describe Strelka::App::RestResources do
 
 			# Writer regular routes
 			it { should have_route(:POST,    'servers') }
+			it { should have_route(:POST,    'servers/:id') }
 			it { should have_route(:PUT,     'servers') }
 			it { should have_route(:PUT,     'servers/:id') }
 			it { should have_route(:DELETE,  'servers') }
@@ -111,7 +112,7 @@ describe Strelka::App::RestResources do
 			end
 
 			it "keeps track of what resources are mounted where" do
-				expect( @app.resource_verbs ).to have( 1 ).member
+				expect( @app.resource_verbs.size ).to eq(  1  )
 				expect( @app.resource_verbs ).to include( 'servers' )
 				@app.resource_verbs[ 'servers' ].
 					should include( :OPTIONS, :GET, :HEAD )
@@ -126,6 +127,7 @@ describe Strelka::App::RestResources do
 
 			# Writer regular routes
 			it { should_not have_route(:POST,    'servers') }
+			it { should_not have_route(:POST,    'servers/:id') }
 			it { should_not have_route(:PUT,     'servers') }
 			it { should_not have_route(:PUT,     'servers/:id') }
 			it { should_not have_route(:DELETE,  'servers') }
@@ -191,7 +193,7 @@ describe Strelka::App::RestResources do
 					expect( res.content_type ).to eq( 'application/json' )
 					body = Yajl.load( res.body )
 
-					expect( body ).to have( 2 ).members
+					expect( body.size ).to eq(  2  )
 					expect( body.map {|record| record['uuid'] } ).to include( 'test-server', 'step-server' )
 				end
 
@@ -204,7 +206,7 @@ describe Strelka::App::RestResources do
 					expect( res.content_type ).to eq( 'application/json' )
 					body = Yajl.load( res.body )
 
-					expect( body ).to have( 1 ).member
+					expect( body.size ).to eq(  1  )
 					expect( body[0]['uuid'] ).to eq( 'test-server' )
 				end
 
@@ -217,7 +219,7 @@ describe Strelka::App::RestResources do
 					expect( res.content_type ).to eq( 'application/json' )
 					body = Yajl.load( res.body )
 
-					expect( body ).to have( 1 ).member
+					expect( body.size ).to eq(  1  )
 					expect( body[0]['uuid'] ).to eq( 'step-server' )
 				end
 
@@ -230,7 +232,7 @@ describe Strelka::App::RestResources do
 					expect( res.content_type ).to eq( 'application/json' )
 					body = Yajl.load( res.body )
 
-					expect( body ).to have( 2 ).members
+					expect( body.size ).to eq(  2  )
 					expect( body[0]['name'] ).to eq( 'Step' )
 				end
 
@@ -243,7 +245,7 @@ describe Strelka::App::RestResources do
 					expect( res.content_type ).to eq( 'application/json' )
 					body = Yajl.load( res.body )
 
-					expect( body ).to have( 2 ).members
+					expect( body.size ).to eq(  2  )
 					expect( body[0]['name'] ).to eq( 'Test' )
 				end
 
@@ -285,7 +287,7 @@ describe Strelka::App::RestResources do
 					body = Yajl.load( res.body )
 
 					expect( body ).to be_an( Array )
-					expect( body ).to have( 1 ).member
+					expect( body.size ).to eq(  1  )
 					expect( body.first ).to be_a( Hash )
 					expect( body.first['uuid'] ).to eq( 'test-server' )
 				end
@@ -299,7 +301,7 @@ describe Strelka::App::RestResources do
 					body = Yajl.load( res.body )
 
 					expect( body ).to be_an( Array )
-					expect( body ).to have( 1 ).member
+					expect( body.size ).to eq(  1  )
 					expect( body.first ).to be_a( Hash )
 					expect( body.first['port'] ).to be > 1024
 				end
@@ -313,7 +315,7 @@ describe Strelka::App::RestResources do
 					body = Yajl.load( res.body )
 
 					expect( body ).to be_an( Array )
-					expect( body ).to have( 1 ).member
+					expect( body.size ).to eq(  1  )
 					expect( body.first ).to be_a( Hash )
 					expect( body.first['name'] ).to eq( 'Step' )
 				end
@@ -327,7 +329,7 @@ describe Strelka::App::RestResources do
 					body = Yajl.load( res.body )
 
 					expect( body ).to be_an( Array )
-					expect( body ).to have( 4 ).members
+					expect( body.size ).to eq(  4  )
 					expect( body.first ).to be_a( Hash )
 					expect( body.first['server_id'] ).to eq( 1 )
 					expect( body.first['id'] ).to eq( 1 )
@@ -341,7 +343,7 @@ describe Strelka::App::RestResources do
 					body = Yajl.load( res.body )
 
 					expect( body ).to be_an( Array )
-					expect( body ).to have( 2 ).members
+					expect( body.size ).to eq(  2  )
 					expect( body.first ).to be_a( Hash )
 					expect( body.first['server_id'] ).to eq( 1 )
 					expect( body.first['id'] ).to eq( 3 )
@@ -350,7 +352,7 @@ describe Strelka::App::RestResources do
 			end # GET routes
 
 
-			context "POST route" do
+			context "POST routes" do
 
 				before( :each ) do
 					@server_values = {
@@ -395,52 +397,83 @@ describe Strelka::App::RestResources do
 					expect( new_server.use_ssl ).to      eq( 0 )
 				end
 
-				it "has a POST route to update instances"
-
-			end # POST routes
+				it "has a POST route to update a single resource" do
+					server = Mongrel2::Config::Server.create( @server_values )
 
+					req = @request_factory.post( "/api/v1/servers/#{server.id}" )
+					req.content_type = 'application/json'
+					req.body = Yajl.dump({ 'name' => 'Staging Server' })
 
-			context "PUT route" do
+					res = @app.new.handle( req )
+					server.refresh
 
-				before( :each ) do
-					@posted_values = {
-						'name'      => 'Not A Testing Server',
-						'bind_addr' => '0.0.0.0',
-					}
+					expect( res.status ).to eq( HTTP::NO_CONTENT )
+					expect( server.name ).to eq( 'Staging Server' )
+					expect( server.uuid ).to eq( @server_values['uuid'] )
 				end
 
+				it "ignores attributes that aren't in the allowed columns list"
+
+			end # POST routes
+
+
+			context "PUT routes" do
+
 				it "has a PUT route to replace instances in the resource collection" do
 					req = @request_factory.put( '/api/v1/servers/1' )
 					req.content_type = 'application/json'
 					req.headers.accept = 'application/json'
-					req.body = Yajl.dump( @posted_values )
+					req.body = Yajl.dump({
+							'name'         => 'Staging',
+							'uuid'         => 'staging',
+							'access_log'   => "/logs/staging-access.log",
+							'error_log'    => "/logs/staging-error.log",
+							'chroot'       => "",
+							'pid_file'     => "/var/run/staging.pid",
+							'default_host' => "staging.local",
+							'port'         => '6455',
+						})
 
 					res = @app.new.handle( req )
 
 					expect( res.status ).to eq( HTTP::NO_CONTENT )
 
-					expect( Mongrel2::Config::Server[ 1 ].name ).to eq( 'Not A Testing Server' )
-					expect( Mongrel2::Config::Server[ 1 ].bind_addr ).to eq( '0.0.0.0' )
+					server = Mongrel2::Config::Server[1]
+					expect( server.name ).to eq( 'Staging' )
+					expect( server.bind_addr ).to eq( '0.0.0.0' )
+					expect( server.uuid ).to eq( 'staging' )
 				end
 
 				it "has a PUT route to replace all resources in a collection" do
-					pending "fix the semantics of PUT and POST" do
-						req = @request_factory.put( '/api/v1/servers' )
-						req.content_type = 'application/json'
-						req.body = Yajl.dump({ 'bind_addr' => '0.0.0.0' })
+					req = @request_factory.put( '/api/v1/servers' )
+					req.content_type = 'application/json'
+					req.body = Yajl.dump([
+						{
+							'name'         => 'Staging Server',
+							'uuid'         => 'staging',
+							'access_log'   => "/logs/staging-access.log",
+							'error_log'    => "/logs/staging-error.log",
+							'chroot'       => "",
+							'pid_file'     => "/var/run/staging.pid",
+							'default_host' => "staging.local",
+							'port'         => '6455',
+						}
+					])
 
-						res = @app.new.handle( req )
+					res = @app.new.handle( req )
 
-						expect( res.status ).to eq( HTTP::NO_CONTENT )
+					expect( res.status ).to eq( HTTP::NO_CONTENT )
 
-						expect( Mongrel2::Config::Server.map( :bind_addr ) ).to eq( ['0.0.0.0'] )
-					end
+					expect( Mongrel2::Config::Server.count ).to eq( 1 )
+					server = Mongrel2::Config::Server.first
+					expect( server.name ).to eq( 'Staging Server' )
+					expect( server.uuid ).to eq( 'staging' )
 				end
 
 			end # PUT routes
 
 
-			context "DELETE route" do
+			context "DELETE routes" do
 
 				it "has a DELETE route to delete single instances in the resource collection" do
 					req = @request_factory.delete( '/api/v1/servers/1' )
@@ -449,6 +482,7 @@ describe Strelka::App::RestResources do
 
 					expect( res.status ).to eq( HTTP::NO_CONTENT )
 
+					expect( Mongrel2::Config::Server[1] ).to be_nil
 					expect( Mongrel2::Config::Server.count ).to eq( 1 )
 				end
 
@@ -481,7 +515,7 @@ describe Strelka::App::RestResources do
 			end
 
 			it "has its metadata inherited by subclasses" do
-				expect( subject.resource_verbs ).to have( 1 ).member
+				expect( subject.resource_verbs.size ).to eq(  1  )
 				expect( subject.resource_verbs ).to include( 'servers' )
 				subject.resource_verbs[ 'servers' ].
 					should include( :OPTIONS, :GET, :HEAD, :POST, :PUT, :DELETE )

data/spec/strelka/app/routing_spec.rb

@@ -214,7 +214,7 @@ describe Strelka::App::Routing do
 				get( '/origami' ) {}
 			end
 
-			expect( subclass.routes ).to have( 3 ).members
+			expect( subclass.routes.size ).to eq(  3  )
 
 			subclass.routes.
 				should include([ :GET, ['info'], {action: @app.instance_method(:GET_info), options: {}} ])

data/spec/strelka/app/templating_spec.rb

@@ -69,7 +69,7 @@ describe Strelka::App::Templating do
 
 			template_dirs = described_class.discover_template_dirs
 
-			expect( template_dirs ).to have( 3 ).pathnames
+			expect( template_dirs.size ).to eq(  3  )
 			expect( template_dirs ).to include(
 				Pathname("data/foom/templates"),
 				Pathname("#{javelin_path}/data/javelin/templates"),

data/spec/strelka/authprovider/basic_spec.rb

@@ -165,7 +165,7 @@ describe Strelka::AuthProvider::Basic do
 			req = @request_factory.get( '/admin/console' )
 			req.header.authorization = make_authorization_header( 'lessa', 'ramoth' )
 
-			expect( @provider.authenticate(req) ).to be_true()
+			expect( @provider.authenticate(req) ).to be_truthy()
 		end
 	end
 

data/spec/strelka/authprovider/hostaccess_spec.rb

@@ -38,7 +38,7 @@ describe Strelka::AuthProvider::HostAccess do
 
 	it "allows its netblocks to be set" do
 		@provider.allowed_netblocks = %w[10.5.2.0/22 10.6.2.0/24]
-		expect( @provider.allowed_netblocks ).to have( 2 ).members
+		expect( @provider.allowed_netblocks.size ).to eq(  2  )
 		expect( @provider.allowed_netblocks ).to include( IPAddr.new('10.5.2.0/22'), IPAddr.new('10.6.2.0/24') )
 	end
 
@@ -50,13 +50,13 @@ describe Strelka::AuthProvider::HostAccess do
 
 	it "allows a request that originates from one of its allowed netblocks" do
 		req = @request_factory.get( '/admin/console', :x_forwarded_for => '127.0.0.1' )
-		expect( @provider.authorize( nil, req, nil ) ).to be_true()
+		expect( @provider.authorize( nil, req, nil ) ).to be_truthy()
 	end
 
 
 	it "doesn't allow a request which is not from one of its allowed netblocks" do
 		req = @request_factory.get( '/admin/console', :x_forwarded_for => '8.8.8.8' )
-		expect( @provider.authorize( nil, req, nil ) ).to be_false()
+		expect( @provider.authorize( nil, req, nil ) ).to be_falsey()
 	end
 
 

data/spec/strelka/cookie_spec.rb

@@ -35,7 +35,7 @@ describe Strelka::Cookie do
 		result = Strelka::Cookie.parse( 'a=b' )
 
 		expect( result ).to be_a( Hash )
-		expect( result ).to have(1).member
+		expect( result.size ).to eq( 1 )
 		expect( result[:a] ).to be_a( Strelka::Cookie )
 		expect( result[:a].name ).to eq( 'a' )
 		expect( result[:a].value ).to eq( 'b' )
@@ -44,15 +44,16 @@ describe Strelka::Cookie do
 	it "parses a cookie header field with an empty value as a cookie with a nil value" do
 		result = Strelka::Cookie.parse( 'a=' )
 
-		expect( result ).to have( 1 ).member
+		expect( result.size ).to eq(  1  )
 		expect( result[:a] ).to be_a( Strelka::Cookie )
 		expect( result[:a].name ).to eq( 'a' )
 		expect( result[:a].value ).to be_nil()
 	end
 
-	it "doesn't raise an error if asked to parse an invalid cookie header" do
-		result = Strelka::Cookie.parse( "{a}=foo" )
-		expect( result ).to eq( {} )
+	it "raises an error if asked to parse an invalid cookie header" do
+		expect {
+			Strelka::Cookie.parse( "{a}=foo" )
+		}.to raise_error( Strelka::ParseError, /malformed/i )
 	end
 
 	it "guards against a nil options hash" do

data/spec/strelka/cookieset_spec.rb

@@ -26,7 +26,7 @@ describe Strelka::CookieSet do
 
 		expect( @cookieset ).to be_empty()
 		expect( @cookieset.length ).to eq( 0 )
-		expect( @cookieset.member?( cookie ) ).to be_false()
+		expect( @cookieset.member?( cookie ) ).to be_falsey()
 	end
 
 	it "is able to enummerate over each cookie in the set" do

data/spec/strelka/discovery_spec.rb

@@ -87,7 +87,7 @@ describe Strelka::Discovery do
 
 		app_paths = described_class.discover_paths
 
-		expect( app_paths ).to have( 4 ).members
+		expect( app_paths.size ).to eq(  4  )
 		expect( app_paths ).to include(
 			'donkey'  => [Pathname("#{donkey_path}/data/donkey/apps/app.rb")],
 			'rabbit'  => [Pathname("#{rabbit_path}/data/rabbit/apps/subdir/app1.rb"),
@@ -115,7 +115,7 @@ describe Strelka::Discovery do
 			end
 
 		app_classes = described_class.discover
-		expect( app_classes ).to have( 1 ).member
+		expect( app_classes.size ).to eq(  1  )
 		expect( app_classes.first ).to be_a( Class )
 		expect( app_classes.first ).to be < discoverable_class
 	end

data/spec/strelka/httprequest/acceptparams_spec.rb

@@ -136,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/*' )
 
-			expect( ( specific_param =~ 'text/html' ) ).to be_true()
-			expect( ( specific_param =~ 'image/png' ) ).to be_false()
+			expect( ( specific_param =~ 'text/html' ) ).to be_truthy()
+			expect( ( specific_param =~ 'image/png' ) ).to be_falsey()
 
-			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()
+			expect( ( subtype_wildcard_param =~ 'image/png' ) ).to be_truthy()
+			expect( ( subtype_wildcard_param =~ 'image/jpeg' ) ).to be_truthy()
+			expect( ( subtype_wildcard_param =~ 'text/plain' ) ).to be_falsey()
 		end
 	end
 
@@ -217,17 +217,17 @@ describe Strelka::HTTPRequest, "accept params" do
 		it "can be compared against strings" do
 			specific_param = Strelka::HTTPRequest::Charset.parse( 'us-ascii' )
 
-			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()
+			expect( ( specific_param =~ 'us-ascii' ) ).to be_truthy()
+			expect( ( specific_param =~ 'ansi_x3.4-1968' ) ).to be_truthy()
+			expect( ( specific_param =~ 'utf-8' ) ).to be_falsey()
 		end
 
 		it "can be compared against Encoding objects" do
 			specific_param = Strelka::HTTPRequest::Charset.parse( 'utf-8' )
 
-			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()
+			expect( ( specific_param =~ Encoding::UTF_8 ) ).to be_truthy()
+			expect( ( specific_param =~ Encoding::CP65001 ) ).to be_truthy()
+			expect( ( specific_param =~ Encoding::MacThai ) ).to be_falsey()
 		end
 	end
 
@@ -260,12 +260,12 @@ describe Strelka::HTTPRequest, "accept params" do
 			specific_param = Strelka::HTTPRequest::MediaType.parse( 'text/html' )
 			subtype_wildcard_param = Strelka::HTTPRequest::MediaType.parse( 'image/*' )
 
-			expect( ( specific_param =~ 'text/html' ) ).to be_true()
-			expect( ( specific_param =~ 'image/png' ) ).to be_false()
+			expect( ( specific_param =~ 'text/html' ) ).to be_truthy()
+			expect( ( specific_param =~ 'image/png' ) ).to be_falsey()
 
-			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()
+			expect( ( subtype_wildcard_param =~ 'image/png' ) ).to be_truthy()
+			expect( ( subtype_wildcard_param =~ 'image/jpeg' ) ).to be_truthy()
+			expect( ( subtype_wildcard_param =~ 'text/plain' ) ).to be_falsey()
 		end
 	end
 

data/spec/strelka/httprequest/negotiation_spec.rb

@@ -38,7 +38,7 @@ 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'
 
-			expect( @req.accepted_types ).to have(3).members
+			expect( @req.accepted_types.size ).to eq( 3 )
 			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' )
@@ -50,41 +50,47 @@ describe Strelka::HTTPRequest::Negotiation do
 		it "knows what mimetypes are acceptable responses" do
 			@req.headers.accept = 'text/html, text/plain; q=0.5, image/*;q=0.1'
 
-			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()
+			expect( @req.accepts?( 'text/html' ) ).to be_truthy()
+			expect( @req.accepts?( 'text/plain' ) ).to be_truthy()
+			expect( @req.accepts?( 'text/ascii' ) ).to be_falsey()
+			expect( @req.accepts?( 'image/png' ) ).to be_truthy()
+			expect( @req.accepts?( 'application/x-yaml' ) ).to be_falsey()
 		end
 
 		it "knows what mimetypes are explicitly acceptable responses" do
 			@req.headers.accept = 'text/html, text/plain; q=0.5, image/*;q=0.1, */*'
 
-			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()
+			expect( @req.explicitly_accepts?( 'text/html' ) ).to be_truthy()
+			expect( @req.explicitly_accepts?( 'text/plain' ) ).to be_truthy()
+			expect( @req.explicitly_accepts?( 'text/ascii' ) ).to be_falsey()
+			expect( @req.explicitly_accepts?( 'image/png' ) ).to be_falsey()
+			expect( @req.explicitly_accepts?( 'application/x-yaml' ) ).to be_falsey()
 		end
 
 		it "accepts anything if the client doesn't provide an Accept header" do
 			@req.headers.delete( :accept )
 
-			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()
+			expect( @req.accepts?( 'text/html' ) ).to be_truthy()
+			expect( @req.accepts?( 'text/plain' ) ).to be_truthy()
+			expect( @req.accepts?( 'text/ascii' ) ).to be_truthy()
+			expect( @req.accepts?( 'image/png' ) ).to be_truthy()
+			expect( @req.accepts?( 'application/x-yaml' ) ).to be_truthy()
 		end
 
 		it "doesn't explicitly accept anything if the client doesn't provide an Accept header" do
 			@req.headers.delete( :accept )
 
-			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()
+			expect( @req.explicitly_accepts?( 'text/html' ) ).to be_falsey()
+			expect( @req.explicitly_accepts?( 'text/plain' ) ).to be_falsey()
+			expect( @req.explicitly_accepts?( 'text/ascii' ) ).to be_falsey()
+			expect( @req.explicitly_accepts?( 'image/png' ) ).to be_falsey()
+			expect( @req.explicitly_accepts?( 'application/x-yaml' ) ).to be_falsey()
+		end
+
+		it "finishes with a BAD REQUEST response if the Accept header is malformed" do
+			@req.headers.accept = 'text/html, image/gif, image/jpeg, *; q=.2, */*; q=.2'
+
+			expect { @req.accepted_types }.to finish_with( HTTP::BAD_REQUEST, /malformed/i )
 		end
 
 	end
@@ -95,7 +101,7 @@ 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'
 
-			expect( @req.accepted_charsets ).to have(2).members
+			expect( @req.accepted_charsets.size ).to eq( 2 )
 			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' )
@@ -105,23 +111,23 @@ describe Strelka::HTTPRequest::Negotiation do
 		it "knows what charsets are acceptable responses" do
 			@req.headers.accept_charset = 'iso-8859-5, utf-8;q=0.8'
 
-			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()
+			expect( @req.accepts_charset?( 'iso8859-5' ) ).to be_truthy()
+			expect( @req.accepts_charset?( 'iso-8859-5' ) ).to be_truthy()
+			expect( @req.accepts_charset?( 'utf-8' ) ).to be_truthy()
+			expect( @req.accepts_charset?( Encoding::CP65001 ) ).to be_truthy()
+			expect( @req.accepts_charset?( 'mac' ) ).to be_falsey()
+			expect( @req.accepts_charset?( Encoding::SJIS ) ).to be_falsey()
 		end
 
 		it "accepts any charset if the client doesn't provide an Accept-Charset header" do
 			@req.headers.delete( :accept_charset )
 
-			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()
+			expect( @req.accepts_charset?( 'iso8859-5' ) ).to be_truthy()
+			expect( @req.accepts_charset?( 'iso-8859-5' ) ).to be_truthy()
+			expect( @req.accepts_charset?( 'utf-8' ) ).to be_truthy()
+			expect( @req.accepts_charset?( Encoding::CP65001 ) ).to be_truthy()
+			expect( @req.accepts_charset?( 'mac' ) ).to be_truthy()
+			expect( @req.accepts_charset?( Encoding::SJIS ) ).to be_truthy()
 		end
 
 	end
@@ -132,7 +138,7 @@ 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'
 
-			expect( @req.accepted_encodings ).to have(3).members
+			expect( @req.accepted_encodings.size ).to eq( 3 )
 			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' )
@@ -144,51 +150,51 @@ describe Strelka::HTTPRequest::Negotiation do
 		it "knows what encodings are acceptable" do
 			@req.headers.accept_encoding = 'gzip;q=1.0, identity; q=0.5, *;q=0'
 
-			expect( @req.accepts_encoding?( 'gzip' ) ).to be_true()
-			expect( @req.accepts_encoding?( 'identity' ) ).to be_true()
-			expect( @req.accepts_encoding?( 'compress' ) ).to be_false()
+			expect( @req.accepts_encoding?( 'gzip' ) ).to be_truthy()
+			expect( @req.accepts_encoding?( 'identity' ) ).to be_truthy()
+			expect( @req.accepts_encoding?( 'compress' ) ).to be_falsey()
 		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'
 
-			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()
+			expect( @req.accepts_encoding?( 'gzip' ) ).to be_truthy()
+			expect( @req.accepts_encoding?( 'identity' ) ).to be_truthy()
+			expect( @req.accepts_encoding?( 'compress' ) ).to be_truthy()
+			expect( @req.accepts_encoding?( 'clowns' ) ).to be_falsey()
 		end
 
 		it "accepts only the 'identity' encoding if the Accept-Encoding field is empty" do
 			@req.headers.accept_encoding = ''
 
-			expect( @req.accepts_encoding?( 'identity' ) ).to be_true()
-			expect( @req.accepts_encoding?( 'gzip' ) ).to be_false()
-			expect( @req.accepts_encoding?( 'compress' ) ).to be_false()
+			expect( @req.accepts_encoding?( 'identity' ) ).to be_truthy()
+			expect( @req.accepts_encoding?( 'gzip' ) ).to be_falsey()
+			expect( @req.accepts_encoding?( 'compress' ) ).to be_falsey()
 		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'
 
-			expect( @req.accepts_encoding?( 'identity' ) ).to be_false()
-			expect( @req.accepts_encoding?( 'gzip' ) ).to be_true()
-			expect( @req.accepts_encoding?( 'compress' ) ).to be_false()
+			expect( @req.accepts_encoding?( 'identity' ) ).to be_falsey()
+			expect( @req.accepts_encoding?( 'gzip' ) ).to be_truthy()
+			expect( @req.accepts_encoding?( 'compress' ) ).to be_falsey()
 		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'
 
-			expect( @req.accepts_encoding?( 'identity' ) ).to be_false()
-			expect( @req.accepts_encoding?( 'gzip' ) ).to be_true()
-			expect( @req.accepts_encoding?( 'compress' ) ).to be_false()
+			expect( @req.accepts_encoding?( 'identity' ) ).to be_falsey()
+			expect( @req.accepts_encoding?( 'gzip' ) ).to be_truthy()
+			expect( @req.accepts_encoding?( 'compress' ) ).to be_falsey()
 		end
 
 		it "accepts every encoding if the request doesn't have an Accept-Encoding header" do
 			@req.headers.delete( :accept_encoding )
 
-			expect( @req.accepts_encoding?( 'identity' ) ).to be_true()
-			expect( @req.accepts_encoding?( 'gzip' ) ).to be_true()
-			expect( @req.accepts_encoding?( 'compress' ) ).to be_true()
+			expect( @req.accepts_encoding?( 'identity' ) ).to be_truthy()
+			expect( @req.accepts_encoding?( 'gzip' ) ).to be_truthy()
+			expect( @req.accepts_encoding?( 'compress' ) ).to be_truthy()
 		end
 
 	end
@@ -199,7 +205,7 @@ 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'
 
-			expect( @req.accepted_languages ).to have(3).members
+			expect( @req.accepted_languages.size ).to eq( 3 )
 			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 )
@@ -214,23 +220,23 @@ describe Strelka::HTTPRequest::Negotiation do
 		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'
 
-			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()
+			expect( @req.accepts_language?( 'da' ) ).to be_truthy()
+			expect( @req.accepts_language?( 'en' ) ).to be_truthy()
+			expect( @req.accepts_language?( 'en-gb' ) ).to be_truthy()
+			expect( @req.accepts_language?( 'en-cockney' ) ).to be_truthy()
+			expect( @req.accepts_language?( 'de' ) ).to be_falsey()
+			expect( @req.accepts_language?( 'tlh' ) ).to be_falsey()
 		end
 
 		it "accepts any language if the client doesn't provide an Accept-Language header" do
 			@req.headers.delete( :accept_language )
 
-			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()
+			expect( @req.accepts_language?( 'da' ) ).to be_truthy()
+			expect( @req.accepts_language?( 'en' ) ).to be_truthy()
+			expect( @req.accepts_language?( 'en-gb' ) ).to be_truthy()
+			expect( @req.accepts_language?( 'en-cockney' ) ).to be_truthy()
+			expect( @req.accepts_language?( 'de' ) ).to be_truthy()
+			expect( @req.accepts_language?( 'tlh' ) ).to be_truthy()
 		end
 
 	end