123456789_123456789_123456789_123456789_123456789_

Module: ActiveSupport::Testing::EventReporterAssertions

Overview

Provides test helpers for asserting on ::ActiveSupport::EventReporter events.

Instance Method Summary

Instance Method Details

#assert_event_reported(name, payload: nil, tags: {}, &block)

Asserts that the block causes an event with the given name to be reported to Rails.event.

Passes if the evaluated code in the yielded block reports a matching event.

assert_event_reported("user.created") do
  Rails.event.notify("user.created", { id: 123 })
end

To test further details about the reported event, you can specify payload and tag matchers.

assert_event_reported("user.created",
  payload: { id: 123, name: "John Doe" },
  tags: { request_id: /[0-9]+/ }
) do
  Rails.event.tagged(request_id: "123") do
    Rails.event.notify("user.created", { id: 123, name: "John Doe" })
  end
end

The matchers support partial matching - only the specified keys need to match.

assert_event_reported("user.created", payload: { id: 123 }) do
  Rails.event.notify("user.created", { id: 123, name: "John Doe" })
end
[ GitHub ] 

  


# File 'activesupport/lib/active_support/testing/event_reporter_assertions.rb', line 143



def assert_event_reported(name, payload: nil, tags: {}, &block)
  events = EventCollector.record(&block)

  if events.empty?
    flunk("Expected an event to be reported, but there were no events reported.")
  elsif (event = events.find { |event| event.matches?(name, payload, tags) })
    assert(true)
    event.event_data
  else
    message = "Expected an event to be reported matching:\n  " \
      "name: #{name}\n  " \
      "payload: #{payload.inspect}\n  " \
      "tags: #{tags.inspect}\n" \
      "but none of the #{events.size} reported events matched:\n  " \
      "#{events.map(&:inspect).join("\n  ")}"
    flunk(message)
  end
end


  








  

    #assert_events_reported(expected_events, &block)  
  



  

    

Asserts that the provided events were reported, regardless of order.



assert_events_reported([
  { name: "user.created", payload: { id: 123 } },
  { name: "email.sent", payload: { to: "user@example.com" } }
]) do
  create_user_and_send_welcome_email
end



Supports the same payload and tag matching as #assert_event_reported.



assert_events_reported([
  {
    name: "process.started",
    payload: { id: 123 },
    tags: { request_id: /[0-9]+/ }
  },
  { name: "process.completed" }
]) do
  Rails.event.tagged(request_id: "456") do
    start_and_complete_process(123)
  end
end


  



  [ GitHub ]


  

  


# File 'activesupport/lib/active_support/testing/event_reporter_assertions.rb', line 185



def assert_events_reported(expected_events, &block)
  events = EventCollector.record(&block)

  if events.empty? && expected_events.size > 0
    flunk("Expected #{expected_events.size} events to be reported, but there were no events reported.")
  end

  events_copy = events.dup

  expected_events.each do |expected_event|
    name = expected_event[:name]
    payload = expected_event[:payload] || {}
    tags = expected_event[:tags] || {}

    matching_event_index = events_copy.find_index { |event| event.matches?(name, payload, tags) }

    if matching_event_index
      events_copy.delete_at(matching_event_index)
    else
      message = "Expected an event to be reported matching:\n  " \
        "name: #{name.inspect}\n  " \
        "payload: #{payload.inspect}\n  " \
        "tags: #{tags.inspect}\n" \
        "but none of the #{events.size} reported events matched:\n  " \
        "#{events.map(&:inspect).join("\n  ")}"
      flunk(message)
    end
  end

  assert(true)
end


  








  

    #assert_no_event_reported(name = nil, payload: {}, tags: {}, &block)  
  



  

    

Asserts that the block does not cause an event to be reported to Rails.event.



If no name is provided, passes if evaluated code in the yielded block reports no events.



assert_no_event_reported do
  service_that_does_not_report_events.perform
end



If a name is provided, passes if evaluated code in the yielded block reports no events with that name.



assert_no_event_reported("user.created") do
  service_that_does_not_report_events.perform
end


  



  [ GitHub ]


  

  


# File 'activesupport/lib/active_support/testing/event_reporter_assertions.rb', line 102



def assert_no_event_reported(name = nil, payload: {}, tags: {}, &block)
  events = EventCollector.record(&block)

  if name.nil?
    assert_predicate(events, :empty?)
  else
    matching_event = events.find { |event| event.matches?(name, payload, tags) }
    if matching_event
      message = "Expected no '#{name}' event to be reported, but found:\n  " \
        "#{matching_event.inspect}"
      flunk(message)
    end
    assert(true)
  end
end