rspec-sse-matchers 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bcc165ce931a68f9f7a0be4ae3122a1aee5829293555b08c61f71c9d3e4e037b
-  data.tar.gz: 4ff64228691c17c84bd3efd723048d0b9a8331bbfcc317d4115bfffdcc53114d
+  metadata.gz: 17656eeed4d488ddf391e1e28408bdc5725db0e8e5c8995b7dbe0e3110e6bbfe
+  data.tar.gz: f64e736388e0d1ed6c9456ab6e6b9fbc270a63601302a184e61e42e9cfbdb4d1
 SHA512:
-  metadata.gz: 955ce4158e46bedc2ba2241eeaf094d97e4422a159d0f59f45628ff36307c64521288d573a5e3daa50682c449c8cd746134d66d6ac92ab5ce31edb6406bc925f
-  data.tar.gz: 95eb00670ad06584b248f2de758010a46a96d952e8c5590a50516e8d98ca2e54e63b9cdf39b24219a65515d9be23d2057556cd10084d0c080e4464509d053aea
+  metadata.gz: e8552d575c0766d036c158e8a1444d605ec5808cc9e656c60af85cb61156de91504d50810c04eaa61990b13706adf7516bf49d92c3e191f092d069489bd784eb
+  data.tar.gz: 160aeef4b96028fe0fc43d2627ddf98856d1f5b127f790f12fda8bff0f117dac77f747f422a902a6812904aeaf2d236aa7da372c4eae4fc4694054bcf2d6fbac

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 ## [Unreleased]
 
+### Breaking Changes
+
+- Change matchers' interface: add `sse_` prefix to each one
+
+### Maintenance
+
+- Fix RBS type docs
+
 ## [0.0.1] - 2025-05-08
 
 - Initial release

data/README.md

@@ -35,7 +35,7 @@ def index
   response.headers['Cache-Control'] = 'no-store'
   response.headers['Content-Type'] = 'text/event-stream'
   sse = SSE.new(response.stream)
-  
+
   sse.write({id: 1, message: 'Hello'}, event: 'message', id: 1)
   sse.write({id: 2, message: 'World'}, event: 'update', id: 2)
   sse.close
@@ -45,15 +45,15 @@ end
 RSpec.describe 'SSE endpoint', type: :request do
   it 'sends the expected events' do
     get '/events', headers: { 'Accept' => 'text/event-stream' }
-    
+
     # Verify the response indicates a successful SSE connection
-    expect(response).to be_successfully_opened
-    
+    expect(response).to be_sse_successfully_opened
+
     # Verify the event types
-    expect(response).to be_event_types(['message', 'update'])
-    
+    expect(response).to be_sse_event_types(['message', 'update'])
+
     # Verify that the response is properly closed
-    expect(response).to be_gracefully_closed
+    expect(response).to be_sse_gracefully_closed
   end
 end
 ```
@@ -64,38 +64,38 @@ end
 
 These matchers check that the specified values appear in the exact order:
 
-- `be_events`: Check that the events exactly match the expected events
-- `be_event_types`: Check that the event types exactly match the expected types
-- `be_event_data`: Check that the event data exactly match the expected data
-- `be_event_ids`: Check that the event IDs exactly match the expected IDs
-- `be_reconnection_times`: Check that the reconnection times exactly match the expected times
+- `be_sse_events`: Check that the events exactly match the expected events
+- `be_sse_event_types`: Check that the event types exactly match the expected types
+- `be_sse_event_data`: Check that the event data exactly match the expected data
+- `be_sse_event_ids`: Check that the event IDs exactly match the expected IDs
+- `be_sse_reconnection_times`: Check that the reconnection times exactly match the expected times
 
-All event data matchers (`be_event_data`, `contain_exactly_event_data`, `have_event_data`) and event matchers (`be_events`, `contain_exactly_events`, `have_events`) accept a `json: true` option that will parse the JSON in event data for comparison.
+All event data matchers (`be_sse_event_data`, `contain_exactly_sse_event_data`, `have_sse_event_data`) and event matchers (`be_sse_events`, `contain_exactly_sse_events`, `have_sse_events`) accept a `json: true` option that will parse the JSON in event data for comparison.
 
 #### Order-Independent Matchers
 
 These matchers check that the specified values appear in any order:
 
-- `contain_exactly_events`: Check that the events match the expected events regardless of order
-- `contain_exactly_event_types`: Check that the event types match the expected types regardless of order
-- `contain_exactly_event_data`: Check that the event data match the expected data regardless of order
-- `contain_exactly_event_ids`: Check that the event IDs match the expected IDs regardless of order
-- `contain_exactly_reconnection_times`: Check that the reconnection times match the expected times regardless of order
+- `contain_exactly_sse_events`: Check that the events match the expected events regardless of order
+- `contain_exactly_sse_event_types`: Check that the event types match the expected types regardless of order
+- `contain_exactly_sse_event_data`: Check that the event data match the expected data regardless of order
+- `contain_exactly_sse_event_ids`: Check that the event IDs match the expected IDs regardless of order
+- `contain_exactly_sse_reconnection_times`: Check that the reconnection times match the expected times regardless of order
 
 #### Inclusion Matchers
 
 These matchers check that all the expected values are included:
 
-- `have_events`: Check that all the expected events are included
-- `have_event_types`: Check that all the expected event types are included
-- `have_event_data`: Check that all the expected event data are included
-- `have_event_ids`: Check that all the expected event IDs are included
-- `have_reconnection_times`: Check that all the expected reconnection times are included
+- `have_sse_events`: Check that all the expected events are included
+- `have_sse_event_types`: Check that all the expected event types are included
+- `have_sse_event_data`: Check that all the expected event data are included
+- `have_sse_event_ids`: Check that all the expected event IDs are included
+- `have_sse_reconnection_times`: Check that all the expected reconnection times are included
 
 #### Miscellaneous Matchers
 
-- `be_successfully_opened`: Check that the response indicates the SSE connection has been opened successfully
-- `be_gracefully_closed`: Check that the response body ends with "\n\n" (indicating proper SSE close)
+- `be_sse_successfully_opened`: Check that the response indicates the SSE connection has been opened successfully
+- `be_sse_gracefully_closed`: Check that the response body ends with "\n\n" (indicating proper SSE close)
 
 ### Argument Formats
 
@@ -103,8 +103,8 @@ All matchers can accept their arguments either as individual arguments or as an
 
 ```ruby
 # These are equivalent:
-expect(response).to have_event_types('message', 'update', 'close')
-expect(response).to have_event_types(['message', 'update', 'close'])
+expect(response).to have_sse_event_types('message', 'update', 'close')
+expect(response).to have_sse_event_types(['message', 'update', 'close'])
 ```
 
 ### JSON Parsing Option
@@ -113,15 +113,15 @@ Event data matchers and event matchers accept a `json: true` option that automat
 
 ```ruby
 # Without JSON parsing (string comparison)
-expect(response).to be_event_data(['{"id":1,"name":"Alice"}', '{"id":2,"name":"Bob"}'])
+expect(response).to be_sse_event_data(['{"id":1,"name":"Alice"}', '{"id":2,"name":"Bob"}'])
 
 # With JSON parsing (object comparison)
-expect(response).to be_event_data([{"id" => 1, "name" => "Alice"}, {"id" => 2, "name" => "Bob"}], json: true)
+expect(response).to be_sse_event_data([{"id" => 1, "name" => "Alice"}, {"id" => 2, "name" => "Bob"}], json: true)
 
 # This also works with event matchers
-expect(response).to be_events([
-  { type: 'message', data: {"id" => 1, "name" => "Alice"}, id: '1' },
-  { type: 'update', data: {"id" => 2, "name" => "Bob"}, id: '2' }
+expect(response).to be_sse_events([
+  {type: 'message', data: {"id" => 1, "name" => "Alice"}, id: '1'},
+  {type: 'update', data: {"id" => 2, "name" => "Bob"}, id: '2'}
 ], json: true)
 ```
 
@@ -133,80 +133,80 @@ When the `json: true` option is enabled, the matcher attempts to parse each even
 
 ```ruby
 # Exact order
-expect(response).to be_event_types(['message', 'update', 'close'])
+expect(response).to be_sse_event_types(['message', 'update', 'close'])
 
 # Any order
-expect(response).to contain_exactly_event_types(['update', 'message', 'close'])
+expect(response).to contain_exactly_sse_event_types(['update', 'message', 'close'])
 
 # Inclusion
-expect(response).to have_event_types(['message', 'update'])
+expect(response).to have_sse_event_types(['message', 'update'])
 ```
 
 ### Testing Event Data
 
 ```ruby
 # Exact order
-expect(response).to be_event_data(['{"id":1}', '{"id":2}', '{"id":3}'])
+expect(response).to be_sse_event_data(['{"id":1}', '{"id":2}', '{"id":3}'])
 
 # Any order
-expect(response).to contain_exactly_event_data(['{"id":2}', '{"id":1}', '{"id":3}'])
+expect(response).to contain_exactly_sse_event_data(['{"id":2}', '{"id":1}', '{"id":3}'])
 
 # Inclusion
-expect(response).to have_event_data(['{"id":1}', '{"id":2}'])
+expect(response).to have_sse_event_data(['{"id":1}', '{"id":2}'])
 
 # With JSON parsing
-expect(response).to be_event_data([{"id" => 1}, {"id" => 2}, {"id" => 3}], json: true)
+expect(response).to be_sse_event_data([{"id" => 1}, {"id" => 2}, {"id" => 3}], json: true)
 ```
 
 ### Testing Event IDs
 
 ```ruby
 # Exact order
-expect(response).to be_event_ids(['1', '2', '3'])
+expect(response).to be_sse_event_ids(['1', '2', '3'])
 
 # Any order
-expect(response).to contain_exactly_event_ids(['2', '1', '3'])
+expect(response).to contain_exactly_sse_event_ids(['2', '1', '3'])
 
 # Inclusion
-expect(response).to have_event_ids(['1', '2'])
+expect(response).to have_sse_event_ids(['1', '2'])
 ```
 
 ### Testing Reconnection Times
 
 ```ruby
 # Exact order
-expect(response).to be_reconnection_times([1000, 2000, 3000])
+expect(response).to be_sse_reconnection_times([1000, 2000, 3000])
 
 # Any order
-expect(response).to contain_exactly_reconnection_times([2000, 1000, 3000])
+expect(response).to contain_exactly_sse_reconnection_times([2000, 1000, 3000])
 
 # Inclusion
-expect(response).to have_reconnection_times([1000, 2000])
+expect(response).to have_sse_reconnection_times([1000, 2000])
 ```
 
 ### Testing Complete Events
 
 ```ruby
 events = [
-  { type: 'message', data: '{"id":1}', id: '1', retry: 1000 },
-  { type: 'update', data: '{"id":2}', id: '2', retry: 2000 }
+  {type: 'message', data: '{"id":1}', id: '1', retry: 1000},
+  {type: 'update', data: '{"id":2}', id: '2', retry: 2000}
 ]
 
 # Exact order
-expect(response).to be_events(events)
+expect(response).to be_sse_events(events)
 
 # Any order
-expect(response).to contain_exactly_events(events)
+expect(response).to contain_exactly_sse_events(events)
 
 # Inclusion
-expect(response).to have_events([events.first])
+expect(response).to have_sse_events([events.first])
 
 # With JSON parsing
 json_events = [
-  { type: 'message', data: {"id" => 1}, id: '1', retry: 1000 },
-  { type: 'update', data: {"id" => 2}, id: '2', retry: 2000 }
+  {type: 'message', data: {"id" => 1}, id: '1', retry: 1000},
+  {type: 'update', data: {"id" => 2}, id: '2', retry: 2000}
 ]
-expect(response).to be_events(json_events, json: true)
+expect(response).to be_sse_events(json_events, json: true)
 ```
 
 ## Development

data/examples/sse_spec.rb

@@ -82,31 +82,31 @@ RSpec.describe "SSE Matchers Examples" do
   describe "Order-Independent Matchers" do
     context "contain_exactly_events" do
       it "passes when events match in any order" do
-        expect(multiple_events_response).to contain_exactly_events([event3, event1, event2])
+        expect(multiple_events_response).to contain_exactly_sse_events([event3, event1, event2])
       end
     end
 
     context "contain_exactly_event_types" do
       it "passes when event types match in any order" do
-        expect(multiple_events_response).to contain_exactly_event_types(%w[close message update])
+        expect(multiple_events_response).to contain_exactly_sse_event_types(%w[close message update])
       end
     end
 
     context "contain_exactly_event_data" do
       it "passes when event data match in any order" do
-        expect(multiple_events_response).to contain_exactly_event_data(%w[{"id":3,"message":"Goodbye"} {"id":1,"message":"Hello"} {"id":2,"message":"World"}])
+        expect(multiple_events_response).to contain_exactly_sse_event_data(%w[{"id":3,"message":"Goodbye"} {"id":1,"message":"Hello"} {"id":2,"message":"World"}])
       end
     end
 
     context "contain_exactly_event_ids" do
       it "passes when event IDs match in any order" do
-        expect(multiple_events_response).to contain_exactly_event_ids(%w[3 1 2])
+        expect(multiple_events_response).to contain_exactly_sse_event_ids(%w[3 1 2])
       end
     end
 
     context "contain_exactly_reconnection_times" do
       it "passes when reconnection times match in any order" do
-        expect(multiple_events_response).to contain_exactly_reconnection_times([3000, 1000, 2000])
+        expect(multiple_events_response).to contain_exactly_sse_reconnection_times([3000, 1000, 2000])
       end
     end
   end
@@ -156,7 +156,7 @@ RSpec.describe "SSE Matchers Examples" do
 
       it "fails when the response body doesn't end with a double newline" do
         incomplete_response = MockResponse.new("event: message\ndata: test\n")
-        expect(incomplete_response).not_to be_gracefully_closed
+        expect(incomplete_response).not_to be_sse_gracefully_closed
       end
     end
   end
@@ -186,7 +186,7 @@ RSpec.describe "SSE Matchers Examples" do
       end
 
       it "works with contain_exactly matchers" do
-        expect(multiple_events_response).to contain_exactly_event_data([
+        expect(multiple_events_response).to contain_exactly_sse_event_data([
           {"id" => 3, "message" => "Goodbye"},
           {"id" => 1, "message" => "Hello"},
           {"id" => 2, "message" => "World"}

data/lib/rspec/sse/matchers/version.rb

@@ -3,7 +3,7 @@
 module RSpec
   module SSE
     module Matchers
-      VERSION = "0.0.1"
+      VERSION = "0.1.0"
     end
   end
 end

data/lib/rspec/sse/matchers.rb

@@ -5,29 +5,32 @@ require "event_stream_parser"
 require "json"
 
 # @rbs!
-#   type ssePayload = {type: String?, data: String, id: String?, retry: Integer}
+#   type jsonParsedData = Hash[String, untyped]
+#   type ssePayload = {type: String?, data: String, id: String?, retry: Integer?}
+#   type ssePayloadWithJSONParsedData = {type: String?, data: jsonParsedData, id: String?, retry: Integer?}
 
 module RSpec
   module Matchers
-    # Matches if the response body ends with "\n\n" (SSE graceful close)
+    # Matches if the response body ends with "\n\n"(SSE graceful close)
+    #
     # @rbs return: RSpec::SSE::Matchers::BeGracefullyClosed
-    def be_gracefully_closed
+    def be_sse_gracefully_closed
       RSpec::SSE::Matchers::BeGracefullyClosed.new
     end
 
     # Matches if the response indicates successfully SSE connection opened
     #
     # @rbs return: RSpec::SSE::Matchers::BeSuccessfullyOpened
-    def be_successfully_opened
+    def be_sse_successfully_opened
       RSpec::SSE::Matchers::BeSuccessfullyOpened.new
     end
 
     # Matches if the response's events match the expected events in order
     #
-    # @rbs *events: ssePayload | Array[ssePayload]
+    # @rbs *events: ssePayload | Array[ssePayload] | ssePayloadWithJSONParsedData | Array[ssePayloadWithJSONParsedData]
     # @rbs json: bool
     # @rbs return: RSpec::SSE::Matchers::BeEvents
-    def be_events(*events, json: false)
+    def be_sse_events(*events, json: false)
       RSpec::SSE::Matchers::BeEvents.new(events.flatten, json:)
     end
 
@@ -35,24 +38,24 @@ module RSpec
     #
     # @rbs *types: String | Array[String]
     # @rbs return: RSpec::SSE::Matchers::BeEventTypes
-    def be_event_types(*types)
+    def be_sse_event_types(*types)
       RSpec::SSE::Matchers::BeEventTypes.new(types.flatten)
     end
 
     # Matches if the response's event data match the expected data in order
     #
-    # @rbs *data: String | Array[String] | Array[Hash[String, untyped]]
+    # @rbs *data: String | Array[String] | jsonParsedData | Array[jsonParsedData]
     # @rbs json: bool
     # @rbs return: RSpec::SSE::Matchers::BeEventData
-    def be_event_data(*data, json: false)
+    def be_sse_event_data(*data, json: false)
       RSpec::SSE::Matchers::BeEventData.new(data.flatten, json:)
     end
 
     # Matches if the response's event IDs match the expected IDs in order
     #
-    # @rbs *ids: String
+    # @rbs *ids: String | Array[String]
     # @rbs return: RSpec::SSE::Matchers::BeEventIds
-    def be_event_ids(*ids)
+    def be_sse_event_ids(*ids)
       RSpec::SSE::Matchers::BeEventIds.new(ids.flatten)
     end
 
@@ -60,16 +63,16 @@ module RSpec
     #
     # @rbs *times: Integer | Array[Integer]
     # @rbs return: RSpec::SSE::Matchers::BeReconnectionTimes
-    def be_reconnection_times(*times)
+    def be_sse_reconnection_times(*times)
       RSpec::SSE::Matchers::BeReconnectionTimes.new(times.flatten)
     end
 
     # Matches if the response's events contain the expected events regardless of order
     #
-    # @rbs *events: ssePayload | Array[ssePayload]
+    # @rbs *events: ssePayload | Array[ssePayload] | ssePayloadWithJSONParsedData | Array[ssePayloadWithJSONParsedData]
     # @rbs json: bool
     # @rbs return: RSpec::SSE::Matchers::ContainExactlyEvents
-    def contain_exactly_events(*events, json: false)
+    def contain_exactly_sse_events(*events, json: false)
       RSpec::SSE::Matchers::ContainExactlyEvents.new(events.flatten, json:)
     end
 
@@ -77,16 +80,16 @@ module RSpec
     #
     # @rbs *types: String | Array[String]
     # @rbs return: RSpec::SSE::Matchers::ContainExactlyEventTypes
-    def contain_exactly_event_types(*types)
+    def contain_exactly_sse_event_types(*types)
       RSpec::SSE::Matchers::ContainExactlyEventTypes.new(types.flatten)
     end
 
     # Matches if the response's event data contain the expected data regardless of order
     #
-    # @rbs *data: String | Array[String] | Array[Hash[String, untyped]]
+    # @rbs *data: String | Array[String] | jsonParsedData | Array[jsonParsedData]
     # @rbs json: bool
     # @rbs return: RSpec::SSE::Matchers::ContainExactlyEventData
-    def contain_exactly_event_data(*data, json: false)
+    def contain_exactly_sse_event_data(*data, json: false)
       RSpec::SSE::Matchers::ContainExactlyEventData.new(data.flatten, json:)
     end
 
@@ -94,7 +97,7 @@ module RSpec
     #
     # @rbs *ids: String | Array[String]
     # @rbs return: RSpec::SSE::Matchers::ContainExactlyEventIds
-    def contain_exactly_event_ids(*ids)
+    def contain_exactly_sse_event_ids(*ids)
       RSpec::SSE::Matchers::ContainExactlyEventIds.new(ids.flatten)
     end
 
@@ -102,16 +105,16 @@ module RSpec
     #
     # @rbs *times: Integer | Array[Integer]
     # @rbs return: RSpec::SSE::Matchers::ContainExactlyReconnectionTimes
-    def contain_exactly_reconnection_times(*times)
+    def contain_exactly_sse_reconnection_times(*times)
       RSpec::SSE::Matchers::ContainExactlyReconnectionTimes.new(times.flatten)
     end
 
     # Matches if the response's events include all the expected events
     #
-    # @rbs *events: ssePayload
+    # @rbs *events: ssePayload | Array[ssePayload] | ssePayloadWithJSONParsedData | Array[ssePayloadWithJSONParsedData]
     # @rbs json: bool
     # @rbs return: RSpec::SSE::Matchers::HaveEvents
-    def have_events(*events, json: false)
+    def have_sse_events(*events, json: false)
       RSpec::SSE::Matchers::HaveEvents.new(events.flatten, json:)
     end
 
@@ -119,32 +122,32 @@ module RSpec
     #
     # @rbs *types: String | Array[String]
     # @rbs return: RSpec::SSE::Matchers::HaveEventTypes
-    def have_event_types(*types)
+    def have_sse_event_types(*types)
       RSpec::SSE::Matchers::HaveEventTypes.new(types.flatten)
     end
 
     # Matches if the response's event data include all the expected data
     #
-    # @rbs *data: String | Array[String] | Array[Hash[String, untyped]]
+    # @rbs *data: String | Array[String] | jsonParsedData | Array[jsonParsedData]
     # @rbs json: bool
     # @rbs return: RSpec::SSE::Matchers::HaveEventData
-    def have_event_data(*data, json: false)
+    def have_sse_event_data(*data, json: false)
       RSpec::SSE::Matchers::HaveEventData.new(data.flatten, json:)
     end
 
     # Matches if the response's event IDs include all the expected IDs
     #
-    # @rbs *ids: String
+    # @rbs *ids: String | Array[String]
     # @rbs return: RSpec::SSE::Matchers::HaveEventIds
-    def have_event_ids(*ids)
+    def have_sse_event_ids(*ids)
       RSpec::SSE::Matchers::HaveEventIds.new(ids.flatten)
     end
 
     # Matches if the response's reconnection times include all the expected times
     #
-    # @rbs *times: Integer
+    # @rbs *times: Integer | Array[Integer]
     # @rbs return: RSpec::SSE::Matchers::HaveReconnectionTimes
-    def have_reconnection_times(*times)
+    def have_sse_reconnection_times(*times)
       RSpec::SSE::Matchers::HaveReconnectionTimes.new(times.flatten)
     end
   end
@@ -179,7 +182,6 @@ module RSpec
         # Initialize the matcher with expected values
         #
         # @rbs expected: Array[Object]
-        # @rbs return: RSpec::SSE::Matchers::BaseMatcher
         def initialize(expected, json: false)
           @expected = expected
           @json = json
@@ -240,7 +242,7 @@ module RSpec
       class BeGracefullyClosed
         # @rbs @actual: Object
 
-        # Match if the response body ends with "\n\n" (SSE graceful close)
+        # Match if the response body ends with "\n\n"(SSE graceful close)
         #
         # @rbs actual: Object
         # @rbs return: bool
@@ -405,12 +407,12 @@ module RSpec
         private
 
         # Extract event data from parsed events
-        # If :json option is enabled, attempt to parse the data as JSON
+        # If `:json` option is enabled, attempt to parse the data as JSON
         #
         # @rbs return: Array[String|Hash[String, untyped]]
         def extract_actual
           @parsed_events.map do |event|
-            # JSON parsing is enabled if json: true is passed
+            # JSON parsing is enabled if `json:` true is passed
             if @json
               JSON.parse(event[:data])
             else

data/sig/generated/rspec/sse/matchers.rbs

@@ -2,110 +2,111 @@
 
 module RSpec
   module Matchers
-    # Matches if the response body ends with "\n\n" (SSE graceful close)
+    # Matches if the response body ends with "\n\n"(SSE graceful close)
+    #
     # @rbs return: RSpec::SSE::Matchers::BeGracefullyClosed
-    def be_gracefully_closed: () -> RSpec::SSE::Matchers::BeGracefullyClosed
+    def be_sse_gracefully_closed: () -> RSpec::SSE::Matchers::BeGracefullyClosed
 
     # Matches if the response indicates successfully SSE connection opened
     #
     # @rbs return: RSpec::SSE::Matchers::BeSuccessfullyOpened
-    def be_successfully_opened: () -> RSpec::SSE::Matchers::BeSuccessfullyOpened
+    def be_sse_successfully_opened: () -> RSpec::SSE::Matchers::BeSuccessfullyOpened
 
     # Matches if the response's events match the expected events in order
     #
-    # @rbs *events: ssePayload | Array[ssePayload]
+    # @rbs *events: ssePayload | Array[ssePayload] | ssePayloadWithJSONParsedData | Array[ssePayloadWithJSONParsedData]
     # @rbs json: bool
     # @rbs return: RSpec::SSE::Matchers::BeEvents
-    def be_events: (*ssePayload | Array[ssePayload] events, ?json: bool) -> RSpec::SSE::Matchers::BeEvents
+    def be_sse_events: (*ssePayload | Array[ssePayload] | ssePayloadWithJSONParsedData | Array[ssePayloadWithJSONParsedData] events, ?json: bool) -> RSpec::SSE::Matchers::BeEvents
 
     # Matches if the response's event types match the expected types in order
     #
     # @rbs *types: String | Array[String]
     # @rbs return: RSpec::SSE::Matchers::BeEventTypes
-    def be_event_types: (*String | Array[String] types) -> RSpec::SSE::Matchers::BeEventTypes
+    def be_sse_event_types: (*String | Array[String] types) -> RSpec::SSE::Matchers::BeEventTypes
 
     # Matches if the response's event data match the expected data in order
     #
-    # @rbs *data: String | Array[String] | Array[Hash[String, untyped]]
+    # @rbs *data: String | Array[String] | jsonParsedData | Array[jsonParsedData]
     # @rbs json: bool
     # @rbs return: RSpec::SSE::Matchers::BeEventData
-    def be_event_data: (*String | Array[String] | Array[Hash[String, untyped]] data, ?json: bool) -> RSpec::SSE::Matchers::BeEventData
+    def be_sse_event_data: (*String | Array[String] | jsonParsedData | Array[jsonParsedData] data, ?json: bool) -> RSpec::SSE::Matchers::BeEventData
 
     # Matches if the response's event IDs match the expected IDs in order
     #
-    # @rbs *ids: String
+    # @rbs *ids: String | Array[String]
     # @rbs return: RSpec::SSE::Matchers::BeEventIds
-    def be_event_ids: (*String ids) -> RSpec::SSE::Matchers::BeEventIds
+    def be_sse_event_ids: (*String | Array[String] ids) -> RSpec::SSE::Matchers::BeEventIds
 
     # Matches if the response's reconnection times match the expected times in order
     #
     # @rbs *times: Integer | Array[Integer]
     # @rbs return: RSpec::SSE::Matchers::BeReconnectionTimes
-    def be_reconnection_times: (*Integer | Array[Integer] times) -> RSpec::SSE::Matchers::BeReconnectionTimes
+    def be_sse_reconnection_times: (*Integer | Array[Integer] times) -> RSpec::SSE::Matchers::BeReconnectionTimes
 
     # Matches if the response's events contain the expected events regardless of order
     #
-    # @rbs *events: ssePayload | Array[ssePayload]
+    # @rbs *events: ssePayload | Array[ssePayload] | ssePayloadWithJSONParsedData | Array[ssePayloadWithJSONParsedData]
     # @rbs json: bool
     # @rbs return: RSpec::SSE::Matchers::ContainExactlyEvents
-    def contain_exactly_events: (*ssePayload | Array[ssePayload] events, ?json: bool) -> RSpec::SSE::Matchers::ContainExactlyEvents
+    def contain_exactly_sse_events: (*ssePayload | Array[ssePayload] | ssePayloadWithJSONParsedData | Array[ssePayloadWithJSONParsedData] events, ?json: bool) -> RSpec::SSE::Matchers::ContainExactlyEvents
 
     # Matches if the response's event types contain the expected types regardless of order
     #
     # @rbs *types: String | Array[String]
     # @rbs return: RSpec::SSE::Matchers::ContainExactlyEventTypes
-    def contain_exactly_event_types: (*String | Array[String] types) -> RSpec::SSE::Matchers::ContainExactlyEventTypes
+    def contain_exactly_sse_event_types: (*String | Array[String] types) -> RSpec::SSE::Matchers::ContainExactlyEventTypes
 
     # Matches if the response's event data contain the expected data regardless of order
     #
-    # @rbs *data: String | Array[String] | Array[Hash[String, untyped]]
+    # @rbs *data: String | Array[String] | jsonParsedData | Array[jsonParsedData]
     # @rbs json: bool
     # @rbs return: RSpec::SSE::Matchers::ContainExactlyEventData
-    def contain_exactly_event_data: (*String | Array[String] | Array[Hash[String, untyped]] data, ?json: bool) -> RSpec::SSE::Matchers::ContainExactlyEventData
+    def contain_exactly_sse_event_data: (*String | Array[String] | jsonParsedData | Array[jsonParsedData] data, ?json: bool) -> RSpec::SSE::Matchers::ContainExactlyEventData
 
     # Matches if the response's event IDs contain the expected IDs regardless of order
     #
     # @rbs *ids: String | Array[String]
     # @rbs return: RSpec::SSE::Matchers::ContainExactlyEventIds
-    def contain_exactly_event_ids: (*String | Array[String] ids) -> RSpec::SSE::Matchers::ContainExactlyEventIds
+    def contain_exactly_sse_event_ids: (*String | Array[String] ids) -> RSpec::SSE::Matchers::ContainExactlyEventIds
 
     # Matches if the response's reconnection times contain the expected times regardless of order
     #
     # @rbs *times: Integer | Array[Integer]
     # @rbs return: RSpec::SSE::Matchers::ContainExactlyReconnectionTimes
-    def contain_exactly_reconnection_times: (*Integer | Array[Integer] times) -> RSpec::SSE::Matchers::ContainExactlyReconnectionTimes
+    def contain_exactly_sse_reconnection_times: (*Integer | Array[Integer] times) -> RSpec::SSE::Matchers::ContainExactlyReconnectionTimes
 
     # Matches if the response's events include all the expected events
     #
-    # @rbs *events: ssePayload
+    # @rbs *events: ssePayload | Array[ssePayload] | ssePayloadWithJSONParsedData | Array[ssePayloadWithJSONParsedData]
     # @rbs json: bool
     # @rbs return: RSpec::SSE::Matchers::HaveEvents
-    def have_events: (*ssePayload events, ?json: bool) -> RSpec::SSE::Matchers::HaveEvents
+    def have_sse_events: (*ssePayload | Array[ssePayload] | ssePayloadWithJSONParsedData | Array[ssePayloadWithJSONParsedData] events, ?json: bool) -> RSpec::SSE::Matchers::HaveEvents
 
     # Matches if the response's event types include all the expected types
     #
     # @rbs *types: String | Array[String]
     # @rbs return: RSpec::SSE::Matchers::HaveEventTypes
-    def have_event_types: (*String | Array[String] types) -> RSpec::SSE::Matchers::HaveEventTypes
+    def have_sse_event_types: (*String | Array[String] types) -> RSpec::SSE::Matchers::HaveEventTypes
 
     # Matches if the response's event data include all the expected data
     #
-    # @rbs *data: String | Array[String] | Array[Hash[String, untyped]]
+    # @rbs *data: String | Array[String] | jsonParsedData | Array[jsonParsedData]
     # @rbs json: bool
     # @rbs return: RSpec::SSE::Matchers::HaveEventData
-    def have_event_data: (*String | Array[String] | Array[Hash[String, untyped]] data, ?json: bool) -> RSpec::SSE::Matchers::HaveEventData
+    def have_sse_event_data: (*String | Array[String] | jsonParsedData | Array[jsonParsedData] data, ?json: bool) -> RSpec::SSE::Matchers::HaveEventData
 
     # Matches if the response's event IDs include all the expected IDs
     #
-    # @rbs *ids: String
+    # @rbs *ids: String | Array[String]
     # @rbs return: RSpec::SSE::Matchers::HaveEventIds
-    def have_event_ids: (*String ids) -> RSpec::SSE::Matchers::HaveEventIds
+    def have_sse_event_ids: (*String | Array[String] ids) -> RSpec::SSE::Matchers::HaveEventIds
 
     # Matches if the response's reconnection times include all the expected times
     #
-    # @rbs *times: Integer
+    # @rbs *times: Integer | Array[Integer]
     # @rbs return: RSpec::SSE::Matchers::HaveReconnectionTimes
-    def have_reconnection_times: (*Integer times) -> RSpec::SSE::Matchers::HaveReconnectionTimes
+    def have_sse_reconnection_times: (*Integer | Array[Integer] times) -> RSpec::SSE::Matchers::HaveReconnectionTimes
   end
 end
 
@@ -130,8 +131,7 @@ module RSpec
         # Initialize the matcher with expected values
         #
         # @rbs expected: Array[Object]
-        # @rbs return: RSpec::SSE::Matchers::BaseMatcher
-        def initialize: (Array[Object] expected, ?json: untyped) -> RSpec::SSE::Matchers::BaseMatcher
+        def initialize: (Array[Object] expected, ?json: untyped) -> untyped
 
         # @rbs actual: Object
         # @rbs return: bool
@@ -162,7 +162,7 @@ module RSpec
       class BeGracefullyClosed
         @actual: Object
 
-        # Match if the response body ends with "\n\n" (SSE graceful close)
+        # Match if the response body ends with "\n\n"(SSE graceful close)
         #
         # @rbs actual: Object
         # @rbs return: bool
@@ -284,7 +284,7 @@ module RSpec
         private
 
         # Extract event data from parsed events
-        # If :json option is enabled, attempt to parse the data as JSON
+        # If `:json` option is enabled, attempt to parse the data as JSON
         #
         # @rbs return: Array[String|Hash[String, untyped]]
         def extract_actual: () -> Array[String | Hash[String, untyped]]
@@ -401,4 +401,8 @@ module RSpec
   end
 end
 
-type ssePayload = { type: String?, data: String, id: String?, retry: Integer }
+type jsonParsedData = Hash[String, untyped]
+
+type ssePayload = { type: String?, data: String, id: String?, retry: Integer? }
+
+type ssePayloadWithJSONParsedData = { type: String?, data: jsonParsedData, id: String?, retry: Integer? }

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: rspec-sse-matchers
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - moznion
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-05-08 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: event_stream_parser
@@ -51,7 +50,6 @@ metadata:
   homepage_uri: https://github.com/moznion/rspec-sse-matchers
   source_code_uri: https://github.com/moznion/rspec-sse-matchers
   changelog_uri: https://github.com/moznion/rspec-sse-matchers/blob/main/CHANGELOG.md
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -66,8 +64,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.16
-signing_key:
+rubygems_version: 3.6.7
 specification_version: 4
 summary: RSpec matchers for Server-Sent Events (SSE)
 test_files: []