Method: ActionController::Assertions::SelectorAssertions#assert_select_rjs

Defined in:
actionpack/lib/action_controller/assertions/selector_assertions.rb

- (Object) assert_select_rjs(*args, &block)

:call-seq:

assert_select_rjs(id?) { |elements| ... }
assert_select_rjs(statement, id?) { |elements| ... }
assert_select_rjs(:insert, position, id?) { |elements| ... }

Selects content from the RJS response.

Narrowing down

With no arguments, asserts that one or more elements are updated or inserted by RJS statements.

Use the id argument to narrow down the assertion to only statements that update or insert an element with that identifier.

Use the first argument to narrow down assertions to only statements of that type. Possible values are :replace, :replace_html, :show, :hide, :toggle, :remove and :insert_html.

Use the argument :insert followed by an insertion position to narrow down the assertion to only statements that insert elements in that position. Possible values are :top, :bottom, :before and :after.

Using the :remove statement, you will be able to pass a block, but it will be ignored as there is no HTML passed for this statement.

Using blocks

Without a block, assert_select_rjs merely asserts that the response contains one or more RJS statements that replace or update content.

With a block, assert_select_rjs also selects all elements used in these statements and passes them to the block. Nested assertions are supported.

Calling assert_select_rjs with no arguments and using nested asserts asserts that the HTML content is returned by one or more RJS statements. Using assert_select directly makes the same assertion on the content, but without distinguishing whether the content is returned in an HTML or JavaScript.

Examples

# Replacing the element foo.
# page.replace 'foo', ...
assert_select_rjs :replace, "foo"

# Replacing with the chained RJS proxy.
# page[:foo].replace ...
assert_select_rjs :chained_replace, 'foo'

# Inserting into the element bar, top position.
assert_select_rjs :insert, :top, "bar"

# Remove the element bar
assert_select_rjs :remove, "bar"

# Changing the element foo, with an image.
assert_select_rjs "foo" do
  assert_select "img[src=/images/logo.gif""
end

# RJS inserts or updates a list with four items.
assert_select_rjs do
  assert_select "ol>li", 4
end

# The same, but shorter.
assert_select "ol>li", 4


408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
 
# File 'actionpack/lib/action_controller/assertions/selector_assertions.rb', line 408

def assert_select_rjs(*args, &block)
  rjs_type = args.first.is_a?(Symbol) ? args.shift : nil
  id       = args.first.is_a?(String) ? args.shift : nil

  # If the first argument is a symbol, it's the type of RJS statement we're looking
  # for (update, replace, insertion, etc). Otherwise, we're looking for just about
  # any RJS statement.
  if rjs_type
    if rjs_type == :insert
      position  = args.shift
      id = args.shift
      insertion = "insert_#{position}".to_sym
      raise ArgumentError, "Unknown RJS insertion type #{position}" unless RJS_STATEMENTS[insertion]
      statement = "(#{RJS_STATEMENTS[insertion]})"
    else
      raise ArgumentError, "Unknown RJS statement type #{rjs_type}" unless RJS_STATEMENTS[rjs_type]
      statement = "(#{RJS_STATEMENTS[rjs_type]})"
    end
  else
    statement = "#{RJS_STATEMENTS[:any]}"
  end

  # Next argument we're looking for is the element identifier. If missing, we pick
  # any element, otherwise we replace it in the statement.
  pattern = Regexp.new(
    id ? statement.gsub(RJS_ANY_ID, "\"#{id}\"") : statement
  )

  # Duplicate the body since the next step involves destroying it.
  matches = nil
  case rjs_type
    when :remove, :show, :hide, :toggle
      matches = @response.body.match(pattern)
    else
      @response.body.gsub(pattern) do |match|
        html = unescape_rjs(match)
        matches ||= []
        matches.concat HTML::Document.new(html).root.children.select { |n| n.tag? }
        ""
      end
  end

  if matches
    assert_block("") { true } # to count the assertion
    if block_given? && !([:remove, :show, :hide, :toggle].include? rjs_type)
      begin
        in_scope, @selected = @selected, matches
        yield matches
      ensure
        @selected = in_scope
      end
    end
    matches
  else
    # RJS statement not found.
    case rjs_type
      when :remove, :show, :hide, :toggle
        flunk_message = "No RJS statement that #{rjs_type.to_s}s '#{id}' was rendered."
      else
        flunk_message = "No RJS statement that replaces or inserts HTML content."
    end
    flunk args.shift || flunk_message
  end
end

Comments