rspec-sse-matchers 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb59580533e9cd9424757c013ba82dc7f6735ad1064e434a30601f5e388d9423
-  data.tar.gz: 781c89151d3c0bf01cdc463cce0e3cab5ebeee1b280c5834d9dfc626a5687a2b
+  metadata.gz: 9e06b785e8c91c1cc5fa04b08dfaf81a9a33d3e750bf9b52bd6b417db55e01ab
+  data.tar.gz: e16dde236261e02ff67d80e4deb1fc8ec1847dd5e432b193918c186f10487c59
 SHA512:
-  metadata.gz: 554de4d1324acc2c018c5ef9900455475972c81f6b376d1874c2c7f6515efa5eca56534d55355d4a013729fed74d577dfb1fab48c9032b425e373cabe6374b5e
-  data.tar.gz: ded963231f3c11f214c2c0bcac8ab2cc21ca9d1b36ce9ed473e991f4d874f5e4ab92d2a8bf5771101780fe67335dc3cb36b1c4ae49964ed0ac856d460f8b8f97
+  metadata.gz: f14b23281a644ca36dd8a636ed43a594954e4a7095a1f30debd81c82e4d718a1792ed77711e71ea9147f2e41b409e002a132e70f9b29471d42836bdb350a45ff
+  data.tar.gz: bc1ff76aa4c587d292cc329686d0c61e04d7e854a50c966f6d315af2166e8da572f0d84788f3899dbd3a52bf794a49960705034fc884bde168326cdf3d052999

data/README.md

@@ -127,6 +127,51 @@ expect(response).to be_sse_events([
 
 When the `json: true` option is enabled, the matcher attempts to parse each event's `data` as JSON. If parsing fails (the data is not valid JSON), it raises an error.
 
+### Using Custom RSpec Matchers
+
+The SSE matchers now support RSpec custom matchers like `hash_including`, `a_kind_of`, `be_an`, etc. This allows for more flexible matching when testing SSE events with complex data structures:
+
+```ruby
+# With hash_including for partial matching
+expect(response).to be_sse_events([
+  {type: "in_progress", data: {"event" => "in_progress", "data" => {}}, id: "1", retry: 250},
+  hash_including(
+    type: "finished",
+    data: hash_including(
+      "event" => "finished",
+      "data" => hash_including(
+        "object_id" => a_kind_of(String),  # or a_string_starting_with("prefix_")
+        "results" => be_an(Array)
+      )
+    ),
+    id: "2",
+    retry: 250
+  )
+], json: true)
+
+# With type checking matchers
+expect(response).to be_sse_event_data([
+  hash_including("id" => a_kind_of(Integer), "name" => a_kind_of(String)),
+  hash_including("status" => match(/active|pending/))
+], json: true)
+
+# Works with all matcher types
+expect(response).to contain_exactly_sse_events([
+  hash_including(data: hash_including("status" => "pending")),
+  hash_including(data: hash_including("status" => "active"))
+], json: true)
+
+expect(response).to have_sse_events([
+  hash_including(data: hash_including("important_field" => "value"))
+], json: true)
+```
+
+Custom matchers are particularly useful when:
+- You only care about specific fields in the event data
+- You want to match patterns or types rather than exact values
+- You need to test complex nested structures
+- You want to ignore irrelevant fields
+
 ## Examples
 
 ### Testing Event Types

data/examples/custom_matchers_example.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require "rspec"
+require "rspec/sse/matchers"
+require "json"
+
+# Mock response for demonstration
+class MockResponse
+  attr_reader :body, :headers, :status
+  def initialize(body:, status: 200, headers: {"content-type" => "text/event-stream", "cache-control" => "no-store"})
+    @body = body
+    @status = status
+    @headers = headers
+  end
+end
+
+def create_sse_body(events)
+  body = ""
+  events.each do |event|
+    body += "id: #{event[:id]}\n" if event[:id]
+    body += "event: #{event[:type]}\n" if event[:type]
+    body += "data: #{event[:data]}\n" if event[:data]
+    body += "retry: #{event[:retry]}\n" if event[:retry]
+    body += "\n"
+  end
+  body
+end
+
+RSpec.describe "SSE with custom matchers" do
+  include RSpec::Matchers
+
+  describe "example from the original request" do
+    let(:event1) { {type: "in_progress", data: '{"event":"in_progress","data":{}}', id: "", retry: 250} }
+    let(:event2) { {type: "finished", data: '{"event":"finished","data":{"object_id":"special_prefix_12345","results":[1,2,3]}}', id: "", retry: 250} }
+    let(:response) { MockResponse.new(body: create_sse_body([event1, event2])) }
+
+    it "matches SSE events with custom matchers" do
+      expect(response).to be_sse_events([
+        {type: "in_progress", data: {"event" => "in_progress", "data" => {}}, id: "", retry: 250},
+        hash_including(
+          type: "finished",
+          data: hash_including(
+            "event" => "finished",
+            "data" => hash_including(
+              "object_id" => a_kind_of(String),  # or a_string_starting_with("special_prefix_")
+              "results" => be_an(Array)
+            )
+          ),
+          id: "",
+          retry: 250
+        )
+      ], json: true)
+    end
+  end
+
+  describe "other examples" do
+    context "partial matching with hash_including" do
+      let(:events) {
+        [
+          {type: "user_update", data: '{"user_id":123,"name":"John","email":"john@example.com","status":"active"}', id: "1", retry: 1000}
+        ]
+      }
+      let(:response) { MockResponse.new(body: create_sse_body(events)) }
+
+      it "matches only specific fields" do
+        expect(response).to be_sse_events([
+          hash_including(
+            type: "user_update",
+            data: hash_including(
+              "user_id" => 123,
+              "status" => "active"
+              # Other fields are ignored
+            )
+          )
+        ], json: true)
+      end
+    end
+
+    context "type checking with RSpec matchers" do
+      let(:events) {
+        [
+          {type: "data_point", data: '{"value":42.5,"timestamp":"2023-01-01T10:00:00Z","tags":["sensor","temperature"]}', id: "2", retry: 500}
+        ]
+      }
+      let(:response) { MockResponse.new(body: create_sse_body(events)) }
+
+      it "validates data types" do
+        expect(response).to be_sse_events([
+          hash_including(
+            type: "data_point",
+            data: hash_including(
+              "value" => a_kind_of(Numeric),
+              "timestamp" => match(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z/),
+              "tags" => include("sensor")
+            )
+          )
+        ], json: true)
+      end
+    end
+
+    context "array matching" do
+      let(:events) {
+        [
+          {type: "batch", data: '{"items":[{"id":1,"status":"ok"},{"id":2,"status":"error"},{"id":3,"status":"ok"}]}', id: "3", retry: 1000}
+        ]
+      }
+      let(:response) { MockResponse.new(body: create_sse_body(events)) }
+
+      it "matches arrays with custom expectations" do
+        expect(response).to be_sse_events([
+          hash_including(
+            type: "batch",
+            data: hash_including(
+              "items" => include(
+                hash_including("id" => 2, "status" => "error")
+              )
+            )
+          )
+        ], json: true)
+      end
+
+      it "matches array properties" do
+        expect(response).to be_sse_events([
+          hash_including(
+            type: "batch",
+            data: hash_including(
+              "items" => have_attributes(size: 3)
+            )
+          )
+        ], json: true)
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module RSpec
   module SSE
     module Matchers
-      VERSION = "0.1.2"
+      VERSION = "0.2.0"
     end
   end
 end

data/lib/rspec/sse/matchers.rb

@@ -187,6 +187,40 @@ module RSpec
           @json = json
         end
 
+        # Check if individual items match
+        # Supports RSpec matchers as expected values
+        #
+        # @rbs actual_item: Object
+        # @rbs expected_item: Object
+        # @rbs return: bool
+        def match_items(actual_item, expected_item)
+          if expected_item.respond_to?(:===)
+            # It's an RSpec argument matcher (hash_including, etc.)
+            expected_item === actual_item
+          elsif expected_item.respond_to?(:matches?)
+            # It's an RSpec regular matcher
+            expected_item.matches?(actual_item)
+          else
+            actual_item == expected_item
+          end
+        end
+
+        # Check if two arrays match element by element
+        # Supports RSpec matchers as expected values
+        #
+        # @rbs actual_array: Array[Object]
+        # @rbs expected_array: Array[Object]
+        # @rbs return: bool
+        def match_arrays(actual_array, expected_array)
+          return false unless actual_array.size == expected_array.size
+
+          actual_array.each_with_index do |actual_item, index|
+            expected_item = expected_array[index]
+            return false unless match_items(actual_item, expected_item)
+          end
+          true
+        end
+
         # @rbs actual: Object
         # @rbs return: bool
         def matches?(actual)
@@ -302,7 +336,7 @@ module RSpec
         #
         # @rbs return: bool
         def match_condition
-          extract_actual == @expected
+          match_arrays(extract_actual, @expected)
         end
 
         # @rbs return: String
@@ -317,7 +351,22 @@ module RSpec
         #
         # @rbs return: bool
         def match_condition
-          (extract_actual - @expected).empty? && (@expected - extract_actual).empty? && extract_actual.size == @expected.size
+          return false unless extract_actual.size == @expected.size
+
+          matched_indices = {}
+          @expected.each do |expected_item|
+            matched = false
+            extract_actual.each_with_index do |actual_item, index|
+              next if matched_indices[index]
+              if match_items(actual_item, expected_item)
+                matched_indices[index] = true
+                matched = true
+                break
+              end
+            end
+            return false unless matched
+          end
+          true
         end
 
         # @rbs return: String
@@ -332,7 +381,9 @@ module RSpec
         #
         # @rbs return: bool
         def match_condition
-          @expected.all? { |expected_item| extract_actual.include?(expected_item) }
+          @expected.all? do |expected_item|
+            extract_actual.any? { |actual_item| match_items(actual_item, expected_item) }
+          end
         end
 
         # @rbs return: String

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

@@ -133,6 +133,22 @@ module RSpec
         # @rbs expected: Array[Object]
         def initialize: (Array[Object] expected, ?json: untyped) -> untyped
 
+        # Check if individual items match
+        # Supports RSpec matchers as expected values
+        #
+        # @rbs actual_item: Object
+        # @rbs expected_item: Object
+        # @rbs return: bool
+        def match_items: (Object actual_item, Object expected_item) -> bool
+
+        # Check if two arrays match element by element
+        # Supports RSpec matchers as expected values
+        #
+        # @rbs actual_array: Array[Object]
+        # @rbs expected_array: Array[Object]
+        # @rbs return: bool
+        def match_arrays: (Array[Object] actual_array, Array[Object] expected_array) -> bool
+
         # @rbs actual: Object
         # @rbs return: bool
         def matches?: (Object actual) -> bool

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rspec-sse-matchers
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - moznion
@@ -36,6 +36,7 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- examples/custom_matchers_example.rb
 - examples/sse_spec.rb
 - lib/rspec/sse/matchers.rb
 - lib/rspec/sse/matchers/version.rb