Module: Merb::Test::RequestHelper

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

Defined Under Namespace

Classes: CookieJar, FakeRequest

Instance Method Summary collapse

Methods included from MakeRequest

#request

Instance Method Details

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

Deprecated.

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<Hash>

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

env<Hash>

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['app_cookie'] = "testing"
dispatch_request(req, MyController, :edit)

Notes

Does not use routes.

:api: public



217
218
219
220
221
222
223
224
225
 
# File 'lib/merb-core/test/helpers/mock_request_helper.rb', line 217

def build_request(params = {}, env = {})
  params             = Merb::Parse.params_to_query_string(params)

  query_string = env[:query_string] || env['QUERY_STRING']
  env[:query_string] = query_string ? "#{query_string}&#{params}" : params
  
  post_body = env[:post_body] || env['POST_BODY']
  fake_request(env, { :post_body => post_body, :req => env[:req] })
end

#check_request_for_route(request) ⇒ Object

Deprecated.

Checks to see that a request is routable.

Parameters

request<Merb::Test::RequestHelper::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.

:api: plugin



395
396
397
398
399
400
401
402
 
# File 'lib/merb-core/test/helpers/mock_request_helper.rb', line 395

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. Request uri: #{request.uri}"
  else
    match[1]
  end
end

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

Deprecated.

An HTTP DELETE request that operates through the router

Parameters

path<String>

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

params<Hash>

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

env<Hash>

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.

:api: public



301
302
303
304
 
# File 'lib/merb-core/test/helpers/mock_request_helper.rb', line 301

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

#describe_input(input) ⇒ Object 



76
77
78
79
80
81
82
83
84
 
# File 'lib/merb-core/test/helpers/request_helper.rb', line 76

def describe_input(input)
  if input.respond_to?(:controller_name)
    "#{input.controller_name}##{input.action_name}"
  elsif input.respond_to?(:original_env)
    describe_request(input)
  else
    input
  end
end

#describe_request(rack) ⇒ Object 



72
73
74
 
# File 'lib/merb-core/test/helpers/request_helper.rb', line 72

def describe_request(rack)
  "a #{rack.original_env[:method] || rack.original_env["REQUEST_METHOD"] || "GET"} to '#{rack.url}'"
end

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

Deprecated.

The workhorse for the dispatch*to helpers.

Parameters

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

A request object that has been setup for testing.

controller_klass<Merb::Controller>

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

action<Symbol>

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.

:api: public

Yields:

  • (controller) 


369
370
371
372
373
374
375
376
377
378
 
# File 'lib/merb-core/test/helpers/mock_request_helper.rb', line 369

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

Deprecated.

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

Parameters

controller_klass<Controller>

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

action<Symbol>

The action name, as a symbol.

params<Hash>

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

env<Hash>

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.

:api: public



121
122
123
124
 
# File 'lib/merb-core/test/helpers/mock_request_helper.rb', line 121

def dispatch_to(controller_klass, action, params = {}, env = {}, &blk)
  params = merge_controller_and_action(controller_klass, action, params)
  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

Deprecated.

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<Controller>

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

action<Symbol>

The action name, as a symbol.

username<String>

The username.

password<String>

The password.

params<Hash>

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

env<Hash>

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.

:api: public



179
180
181
182
183
184
 
# File 'lib/merb-core/test/helpers/mock_request_helper.rb', line 179

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

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

Deprecated.

Parameters

env<Hash>

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

opt<Hash>

A hash of options (see below).

Options (opt)

:post_body<String>

The post body for the request.

:req<String>

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.

:api: public



84
85
86
87
88
89
90
91
92
 
# File 'lib/merb-core/test/helpers/mock_request_helper.rb', line 84

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

Deprecated.

An HTTP GET request that operates through the router.

Parameters

path<String>

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

params<Hash>

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

env<Hash>

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.

:api: public



242
243
244
245
 
# File 'lib/merb-core/test/helpers/mock_request_helper.rb', line 242

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

#merge_controller_and_action(controller_klass, action, params) ⇒ Object

:api: private



187
188
189
190
191
192
 
# File 'lib/merb-core/test/helpers/mock_request_helper.rb', line 187

def merge_controller_and_action(controller_klass, action, params)
  params[:controller] = controller_klass.name.to_const_path
  params[:action]     = action.to_s
  
  params
end

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

Deprecated.

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<String>

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

params<Hash>

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

env<Hash>

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.

:api: plugin



330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
 
# File 'lib/merb-core/test/helpers/mock_request_helper.rb', line 330

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

  request = build_request(params, 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

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

Deprecated.

An HTTP POST request that operates through the router.

Parameters

path<String>

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

params<Hash>

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

env<Hash>

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.

:api: public



262
263
264
265
 
# File 'lib/merb-core/test/helpers/mock_request_helper.rb', line 262

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

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

An HTTP PUT request that operates through the router.

Parameters

path<String>

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

params<Hash>

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

env<Hash>

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.

:api: public



281
282
283
284
 
# File 'lib/merb-core/test/helpers/mock_request_helper.rb', line 281

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

#requesting(*args) ⇒ Object 



90
 
# File 'lib/merb-core/test/helpers/request_helper.rb', line 90

def requesting(*args)   request(*args) end

#response_for(*args) ⇒ Object 



91
 
# File 'lib/merb-core/test/helpers/request_helper.rb', line 91

def response_for(*args) request(*args) end

#status_code(input) ⇒ Object 



86
87
88
 
# File 'lib/merb-core/test/helpers/request_helper.rb', line 86

def status_code(input)
  input.respond_to?(:status) ? input.status : input
end

#with_cookies(*controller_classes, &blk) ⇒ Object

Deprecated.

Keep track of cookie values in CookieJar within the context of the block; you need to set this up for secific controllers.

Parameters

*controller_classes

Controller classes to operate on in the context of the block.

&blk

The context to operate on; optionally accepts the cookie jar as an argument.

:api: public



135
136
137
138
139
140
141
142
143
144
145
146
147
148
 
# File 'lib/merb-core/test/helpers/mock_request_helper.rb', line 135

def with_cookies(*controller_classes, &blk)
  cookie_jar = CookieJar.new
  before_cb = lambda { |c| c.cookies.update(cookie_jar) }
  after_cb  = lambda { |c| cookie_jar.update_from_request(c.request) }
  controller_classes.each do |klass|
    klass._before_dispatch_callbacks << before_cb
    klass._after_dispatch_callbacks  << after_cb
  end
  blk.arity == 1 ? blk.call(cookie_jar) : blk.call
  controller_classes.each do |klass|
    klass._before_dispatch_callbacks.delete before_cb
    klass._after_dispatch_callbacks.delete after_cb
  end
end