Module: Test::Unit::Capybara::Assertions

Defined in:
lib/test/unit/capybara.rb

Constant Summary collapse

AssertionMessage = 
::Test::Unit::Assertions::AssertionMessage

Instance Method Summary collapse

Instance Method Details

#assert_all(*args) ⇒ Array<::Capybara::Element> #assert_all(node, *args) ⇒ Array<::Capybara::Element>

Returns The found elements.

Overloads:

  • #assert_all(*args) ⇒ Array<::Capybara::Element>

    Passes if the selector finds one or more elements from the current node.

    Examples:

    Pass case

    # Actual response:
#   <html>
#     <body>
#       <h1>Hello</h1>
#       <h2>Yay!</h2>
#       <div class="section">
#         <h2>World</h2>
#       </div>
#     </body>
#   </html>
h2_elements = assert_page_all("h2")
p h2_elements
  # => [#<Capybara::Element tag="h2" path="/html/body/h2">,
  #     #<Capybara::Element tag="h2" path="/html/body/div/h2">]

    Failure case

    # Actual response:
#   <html>
#     <body>
#       <h1>Hello</h1>
#       <h2>Yay!</h2>
#       <div class="section">
#         <h2>World</h2>
#       </div>
#     </body>
#   </html>
assert_page_all("h3")
  • #assert_all(node, *args) ⇒ Array<::Capybara::Element>

    Passes if the selector finds one or more elements from @node@.

    Examples:

    Pass case (simple)

    # Actual response:
#   <html>
#     <body>
#       <h1>Hello</h1>
#       <h2>Yay!</h2>
#       <div class="section">
#         <h2>World</h2>
#       </div>
#     </body>
#   </html>
section = assert_find("div.section")
p section
  # => #<Capybara::Element tag="h2" path="/html/body/div">
h2_elements = assert_all(section, "h2")
p h2_elements
  # => [#<Capybara::Element tag="h2" path="/html/body/div/h2">]

    Parameters:

    • node (::Capybara::Node::Base) —

      The target node.

Parameters:

  • args (...) —

    (see Capybara::Node::Finders#all)

Returns:

  • (Array<::Capybara::Element>) —

    The found elements.

See Also:

  • Capybara::Node::Finders#all


295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
 
# File 'lib/test/unit/capybara.rb', line 295

def assert_all(*args)
  node = nil
  node = args.shift if args[0].is_a?(::Capybara::Node::Base)
  args = normalize_page_finder_arguments(args)
  format = <<-EOT
<?>(?) expected to find one or more elements in
<?>
EOT
  current_context = node || page.send(:current_node)
  current_context_source = node_source(current_context)
  source_in_message = AssertionMessage.literal(current_context_source)
  full_message = build_message(args[:message],
                               format,
                               args[:locator],
                               args[:kind],
                               source_in_message)
  if node
    elements = node.all(*args[:finder_arguments])
  else
    elements = all(*args[:finder_arguments])
  end
  assert_block(full_message) do
    not elements.empty?
  end
  elements
end

#assert_body(expected, options = {}) {|expected_response, actual_response| ... } ⇒ Object

Passes if @expected@ == @source@. @source@ is a method provided by Capybara::DSL.

@source@ may be parsed depended on response Content-Type before comparing. Here are parsed Content-Types:

  • @“application/json”@ := It’s parsed by @JSON.parse@.

Examples:

Pass case

# Actual response:
#   Content-Type: application/json
#   Body: {"status": true}
assert_body({"status" => true}, :content_type => :json)

Failure case

# Actual response:
#   Content-Type: text/html
#   Body: <html><body>Hello</body></html>
assert_body("<html><body>World</body></html>")

Parameters:

  • expected (Object) —

    the expected body content. The actual body may be parsed. It depends on @:content_type@ option.

  • options (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (options):

  • :content_type (String) — default: nil —

    the expected Content-Type. If this value is @nil@, Content-Type will not be compared.

    This value can be specified by abbreviated. Here are abbreviations:

    • @:json@ := @“application/json”@

Yields:

  • (expected_response, actual_response) —

    the optional compared responses normalizer.

Yield Parameters:

  • expected_response (Hash) —

    the expected response constructed in the method.

  • actual_response (Hash) —

    the actual response constructed in the method.

Yield Returns:

  • (expected_response, actual_response) —

    the normalized compared responses.



215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
 
# File 'lib/test/unit/capybara.rb', line 215

def assert_body(expected, options={}, &block)
  content_type = options[:content_type]
  actual_response = {
    :content_type => page_content_type,
    :body => parsed_page_body,
  }
  expected_response = {:body => expected}
  if content_type
    expected_response[:content_type] = normalize_content_type(content_type)
  else
    actual_response.delete(:content_type)
  end
  if block_given?
    expected_response, actual_response = yield(expected_response,
                                               actual_response)
	end
  assert_equal(expected_response, actual_response)
end

#assert_not_find(*args, &block) ⇒ Object #assert_not_find(node, *args, &block) ⇒ Object

Overloads:

  • #assert_not_find(*args, &block) ⇒ Object

    Passes if the selector doesn’t find any elements from the current node.

    Examples:

    Pass case

    # Actual response:
#   <html>
#     <body>
#       <h1>Hello</h1>
#       <h2>Yay!</h2>
#       <div class="section">
#         <h2>World</h2>
#       </div>
#     </body>
#   </html>
assert_not_find("h3")

    Failure case

    # Actual response:
#   <html>
#     <body>
#       <h1>Hello</h1>
#       <h2>Yay!</h2>
#       <div class="section">
#         <h2>World</h2>
#       </div>
#     </body>
#   </html>
assert_not_find("h1")
  • #assert_not_find(node, *args, &block) ⇒ Object

    Passes if the selector doesn’t find any element from @node@.

    Examples:

    Pass case

    # Actual response:
#   <html>
#     <body>
#       <h1>Hello</h1>
#       <h2>Yay!</h2>
#       <div class="section">
#         <h2>World</h2>
#       </div>
#     </body>
#   </html>
section = find("section")
p section
  # => #<Capybara::Element tag="h2" path="/html/body/div">
assert_not_find(section, "h1")

    Failure case

    # Actual response:
#   <html>
#     <body>
#       <h1>Hello</h1>
#       <h2>Yay!</h2>
#       <div class="section">
#         <h2>World</h2>
#       </div>
#     </body>
#   </html>
section = find("section")
p section
  # => #<Capybara::Element tag="h2" path="/html/body/div">
assert_not_find(section, "h2")

    Parameters:

    • node (::Capybara::Node::Base) —

      The target node.

Parameters:

  • args (...) —

    (see Capybara::Node::Finders#find)

See Also:

  • Capybara::Node::Finders#find


392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
 
# File 'lib/test/unit/capybara.rb', line 392

def assert_not_find(*args, &block)
  node = nil
  node = args.shift if args[0].is_a?(::Capybara::Node::Base)
  args = normalize_page_finder_arguments(args)
  if node
    element = node.first(*args[:finder_arguments])
  else
    element = first(*args[:finder_arguments])
  end
  format = <<-EOT
<?>(?) expected to not find a element but was
<?> in
<?>
EOT
  element_source = nil
  element_source = node_source(element) if element
  current_context = node || page.send(:current_node)
  current_context_source = node_source(current_context)
  source_in_message = AssertionMessage.literal(current_context_source)
  full_message = build_message(args[:message],
                               format,
                               args[:locator],
                               args[:kind],
                               AssertionMessage.literal(element_source),
                               source_in_message)
  assert_block(full_message) do
    element.nil?
  end
end

#flunk_find(base_node, options = {}) ⇒ Object

Fails always with Capybara::Node::Element is not found message.

Parameters:

  • base_node (::Capybara::Node::Element) —

    The node used as search target.

  • options (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (options):

  • :message (String) —

    The user custom message added to failure message.

  • :locator (String) —

    The query used to find a node.

    It should be specified for useful failure message.

  • :kind (String) —

    The kind of query.

    It should be specified for useful failure message.



436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
 
# File 'lib/test/unit/capybara.rb', line 436

def flunk_find(base_node, options={})
  format = <<-EOT
<?>(?) expected to find a element in
<?>
EOT
  base_html = AssertionMessage.literal(node_source(base_node))
  full_message = build_message(options[:message],
                               format,
                               options[:locator],
                               options[:kind],
                               base_html)
  assert_block(full_message) do
    false
  end
end