Module: Merb::Test::RequestHelper

Included in:
ControllerHelper, RouteHelper
Defined in:
lib/merb-core/test/helpers/request_helper.rb

Defined Under Namespace

Classes: FakeRequest

Instance Method Summary collapse

Instance Method Details

#build_request(params = {}, env = {}) ⇒ Object

Prepares and returns a request suitable for dispatching with dispatch_request. If you don't need to modify the request object before dispatching (e.g. to add cookies), you probably want to use dispatch_to instead.

Parameters

params

An optional hash that will end up as params in the controller instance.

env

An optional hash that is passed to the fake request. Any request options should go here (see fake_request), including :req or :post_body for setting the request body itself.

Example

req = build_request(:id => 1) req.cookies = "testing" dispatch_request(req, MyController, :edit)

Notes

Does not use routes.



162
163
164
165
166
167
 
# File 'lib/merb-core/test/helpers/request_helper.rb', line 162

def build_request(params = {}, env = {})
  params             = Merb::Request.params_to_query_string(params)
  env[:query_string] = env["QUERY_STRING"] ? "#{env["QUERY_STRING"]}&#{params}" : params
  
  fake_request(env, { :post_body => env[:post_body], :req => env[:req] })
end

#check_request_for_route(request) ⇒ Object

Checks to see that a request is routable.

Parameters

request<Merb::Test::FakeRequest, Merb::Request>::

The request object to inspect.

Raises

Merb::ControllerExceptions::BadRequest::

No matching route was found.

Returns

Hash

The parameters built based on the matching route.

@semi-public



334
335
336
337
338
339
340
341
 
# File 'lib/merb-core/test/helpers/request_helper.rb', line 334

def check_request_for_route(request)
  match =  ::Merb::Router.match(request)
  if match[0].nil? && match[1].empty?
    raise ::Merb::ControllerExceptions::BadRequest, "No routes match the request"
  else
    match[1]
  end
end

#delete(path, params = {}, env = {}, &block) ⇒ Object

An HTTP DELETE request that operates through the router

Parameters

path

The path that should go to the router as the request uri.

params

An optional hash that will end up as params in the controller instance.

env

An optional hash that is passed to the fake request. Any request options should go here (see fake_request).

&blk

The controller is yielded to the block provided for actions prior to the action being dispatched.



240
241
242
243
 
# File 'lib/merb-core/test/helpers/request_helper.rb', line 240

def delete(path, params = {}, env = {}, &block)
  env[:request_method] = "DELETE"
  request(path, params, env, &block)
end

#dispatch_request(request, controller_klass, action) {|controller| ... } ⇒ Object

The workhorse for the dispatch*to helpers.

Parameters

request<Merb::Test::FakeRequest, Merb::Request>::

A request object that has been setup for testing.

controller_klassMerb::Controller::

The class object off the controller to dispatch the action to.
action

The action to dispatch the request to.

&blk

The controller is yielded to the block provided for actions prior to the action being dispatched.

Returns

An instance of controller_klass based on the parameters.

Notes

Does not use routes.

Yields:

  • (controller) 


308
309
310
311
312
313
314
315
316
317
 
# File 'lib/merb-core/test/helpers/request_helper.rb', line 308

def dispatch_request(request, controller_klass, action, &blk)
  controller = controller_klass.new(request)
  yield controller if block_given?
  controller._dispatch(action)

  Merb.logger.info controller._benchmarks.inspect
  Merb.logger.flush

  controller
end

#dispatch_to(controller_klass, action, params = {}, env = {}, &blk) ⇒ Object

Dispatches an action to the given class. This bypasses the router and is suitable for unit testing of controllers.

Parameters

controller_klass

The controller class object that the action should be dispatched to.

action

The action name, as a symbol.

params

An optional hash that will end up as params in the controller instance.

env

An optional hash that is passed to the fake request. Any request options should go here (see fake_request), including :req or :post_body for setting the request body itself.

&blk

The controller is yielded to the block provided for actions prior to the action being dispatched.

Example

dispatch_to(MyController, :create, :name => 'Homer' ) do |controller| controller.stub!(:current_user).and_return(@user) end

Notes

Does not use routes.



99
100
101
 
# File 'lib/merb-core/test/helpers/request_helper.rb', line 99

def dispatch_to(controller_klass, action, params = {}, env = {}, &blk)
  dispatch_request(build_request(params, env), controller_klass, action.to_s, &blk)
end

#dispatch_with_basic_authentication_to(controller_klass, action, username, password, params = {}, env = {}, &blk) ⇒ Object

Dispatches an action to the given class and using HTTP Basic Authentication This bypasses the router and is suitable for unit testing of controllers.

Parameters

controller_klass

The controller class object that the action should be dispatched to.

action

The action name, as a symbol.

username

The username.

password

The password.

params

An optional hash that will end up as params in the controller instance.

env

An optional hash that is passed to the fake request. Any request options should go here (see fake_request), including :req or :post_body for setting the request body itself.

&blk

The controller is yielded to the block provided for actions prior to the action being dispatched.

Example

dispatch_with_basic_authentication_to(MyController, :create, 'Fred', 'secret', :name => 'Homer' ) do |controller| controller.stub!(:current_user).and_return(@user) end

Notes

Does not use routes.



133
134
135
136
137
 
# File 'lib/merb-core/test/helpers/request_helper.rb', line 133

def dispatch_with_basic_authentication_to(controller_klass, action, username, password, params = {}, env = {}, &blk)
  env["X_HTTP_AUTHORIZATION"] = "Basic #{Base64.encode64("#{username}:#{password}")}"
  
  dispatch_request(build_request(params, env), controller_klass, action.to_s, &blk)
end

#fake_request(env = {}, opt = {}) ⇒ Object

Parameters

env

A hash of environment keys to be merged into the default list.

opt

A hash of options (see below).

Options (opt)

:post_body:: The post body for the request. :req::

The request string. This will only be used if :post_body is left out.

Returns

FakeRequest

A Request object that is built based on the parameters.

Notes

If you pass a post body, the content-type will be set to URL-encoded.



62
63
64
65
66
67
68
69
70
 
# File 'lib/merb-core/test/helpers/request_helper.rb', line 62

def fake_request(env = {}, opt = {})
  if opt[:post_body]
    req = opt[:post_body]
    env[:content_type] ||= "application/x-www-form-urlencoded"
  else
    req = opt[:req]
  end
  FakeRequest.new(env, StringIO.new(req || ''))
end

#get(path, params = {}, env = {}, &block) ⇒ Object

An HTTP GET request that operates through the router.

Parameters

path

The path that should go to the router as the request uri.

params

An optional hash that will end up as params in the controller instance.

env

An optional hash that is passed to the fake request. Any request options should go here (see fake_request).

&blk

The controller is yielded to the block provided for actions prior to the action being dispatched.



183
184
185
186
 
# File 'lib/merb-core/test/helpers/request_helper.rb', line 183

def get(path, params = {}, env = {}, &block)
  env[:request_method] = "GET"
  request(path, params, env, &block)
end

#post(path, params = {}, env = {}, &block) ⇒ Object

An HTTP POST request that operates through the router.

Parameters

path

The path that should go to the router as the request uri.

params

An optional hash that will end up as params in the controller instance.

env

An optional hash that is passed to the fake request. Any request options should go here (see fake_request).

&blk

The controller is yielded to the block provided for actions prior to the action being dispatched.



202
203
204
205
 
# File 'lib/merb-core/test/helpers/request_helper.rb', line 202

def post(path, params = {}, env = {}, &block)
  env[:request_method] = "POST"
  request(path, params, env, &block)
end

#put(path, params = {}, env = {}, &block) ⇒ Object

An HTTP PUT request that operates through the router.

Parameters

path

The path that should go to the router as the request uri.

params

An optional hash that will end up as params in the controller instance.

env

An optional hash that is passed to the fake request. Any request options should go here (see fake_request).

&blk

The controller is yielded to the block provided for actions prior to the action being dispatched.



221
222
223
224
 
# File 'lib/merb-core/test/helpers/request_helper.rb', line 221

def put(path, params = {}, env = {}, &block)
  env[:request_method] = "PUT"
  request(path, params, env, &block)
end

#request(path, params = {}, env = {}, &block) ⇒ Object

A generic request that checks the router for the controller and action. This request goes through the Merb::Router and finishes at the controller.

Parameters

path

The path that should go to the router as the request uri.

params

An optional hash that will end up as params in the controller instance.

env

An optional hash that is passed to the fake request. Any request options should go here (see fake_request).

&blk

The controller is yielded to the block provided for actions prior to the action being dispatched.

Example

request(path, { :name => 'Homer' }, { :request_method => "PUT" }) do |controller| controller.stub!(:current_user).and_return(@user) end

Notes

Uses Routes.

@semi-public



269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
 
# File 'lib/merb-core/test/helpers/request_helper.rb', line 269

def request(path, params = {}, env= {}, &block)
  env[:request_method] ||= "GET"
  env[:request_uri], env[:query_string] = path.split('?')
  
  multipart = env.delete(:test_with_multipart)

  request = fake_request(env)

  opts = check_request_for_route(request) # Check that the request will be routed correctly
  controller_name = (opts[:namespace] ? opts.delete(:namespace) + '/' : '') + opts.delete(:controller)
  klass = Object.full_const_get(controller_name.snake_case.to_const_string)
  
  action = opts.delete(:action).to_s
  params.merge!(opts)

  multipart.nil? ? dispatch_to(klass, action, params, env, &block) : dispatch_multipart_to(klass, action, params, env, &block)
end