rspec-enriched_json 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 563d2936f51c8422129b04e84c39447739a5a0895dd02e3a1e3db58de431a9e4
-  data.tar.gz: f164a70a9216ff65b4e54dbc90b398858f0a6e3b2ea4fa00967a807e71e534c2
+  metadata.gz: 01c7824579e7c7ed920470597289a95c675f57b334796ab2a2b5560366ce5e4b
+  data.tar.gz: 6cc9a5b114339904133849fee204bb1b874e0ca36a54bcb3fc8b95f1639c149b
 SHA512:
-  metadata.gz: b3947459ce3038f272de17e1e6c5425dda737c9d694c04d628ba3a0b00041edf2b0090c51a52daa4c481db970fefe2f123037298760edd334e62e25bcf1d77c5
-  data.tar.gz: 850a62aef71132f3aa4ab925890c6f6841ff18d499e52cc919b1ced2dbf18aa8ea48c20feed970f07748e2400896292c4cd08de72b7a1e442338774cd4c0778d
+  metadata.gz: 362ca7d1944dd84d9b58f0d40aafc1eaf57e1befcf0f55f3876bcf9866769e770d1f62d637053b525ed6e059a9840679034688abab3084907de81675ab8ef0a6
+  data.tar.gz: 9aad9fe933afbf938b721e721d7e381b6b8ad82a40442c097920d7adfe9edafdf21f771b0637b892f70053c2893c67812a32b6c18c27819c445643016944790f

data/README.md

@@ -4,35 +4,19 @@ A drop-in replacement for RSpec's built-in JSON formatter that enriches the outp
 
 ## Quick Demo
 
-To see the difference between RSpec's built-in JSON formatter and this enriched formatter, use the included demo script:
+To see the difference between RSpec's built-in JSON formatter and this enriched formatter:
 
 ```bash
-# Compare the two formatters side-by-side
-# Built-in formatter (string-only failure messages):
-bundle exec rspec demo_all_failures.rb --format json --no-profile 2>/dev/null | jq '.examples[4]'
-
-# Enriched formatter (includes structured_data field):
-bundle exec rspec demo_all_failures.rb --format RSpec::EnrichedJson::Formatters::EnrichedJsonFormatter --no-profile -r ./lib/rspec/enriched_json 2>/dev/null | jq '.examples[4]'
-
-# For a cleaner comparison, look at just the structured data:
-bundle exec rspec demo_all_failures.rb --format RSpec::EnrichedJson::Formatters::EnrichedJsonFormatter --no-profile -r ./lib/rspec/enriched_json 2>/dev/null | jq '.examples[] | select(.description == "fails with string comparison") | .structured_data'
+ruby demo.rb
 ```
 
-The demo file `demo_all_failures.rb` contains 59 different test failure scenarios covering virtually all RSpec matcher types and how they appear in the JSON output.
+This interactive demo script runs the same failing tests with both formatters and shows you the difference side-by-side. No external dependencies, no file cleanup needed!
 
-The demo script (`demo_all_failures.rb`) includes various types of test failures:
-- Simple equality failures
-- String, array, and hash comparisons
-- Custom error messages
-- Exception failures
-- Complex object comparisons
-- Various matcher types (include, respond_to, be_within, etc.)
-
-Key differences you'll see:
-- **Built-in formatter**: Failure information is embedded in string messages
-- **Enriched formatter**: Adds a `structured_data` field with:
+**What you'll see:**
+- **Built-in formatter**: Failure information embedded in string messages  
+- **Enriched formatter**: Adds structured data with:
   - `expected`: The expected value as a proper JSON object
-  - `actual`: The actual value as a proper JSON object
+  - `actual`: The actual value as a proper JSON object  
   - `matcher_name`: The RSpec matcher class used
   - `original_message`: Preserved when custom messages are provided
 
@@ -103,7 +87,10 @@ With this gem, you get structured data alongside the original message:
     "expected": "Hello, Ruby!",
     "actual": "Hello, World!",
     "matcher_name": "RSpec::Matchers::BuiltIn::Eq",
-    "original_message": null
+    "original_message": null,
+    "diff_info": {
+      "diffable": true
+    }
   }
 }
 ```
@@ -115,6 +102,9 @@ With this gem, you get structured data alongside the original message:
 - **Rich object support**: Arrays, hashes, and custom objects are properly serialized
 - **Original message preservation**: When you override with a custom message, the original is preserved
 - **Graceful degradation**: Regular exceptions (non-expectation failures) work normally
+- **Enhanced metadata capture**: Test location, tags, hierarchy, and custom metadata
+- **Robust error recovery**: Handles objects that fail to serialize without crashing
+- **Diff information**: Includes `diff_info.diffable` to help tools determine if values can be meaningfully diffed
 
 ## Examples
 
@@ -145,6 +135,18 @@ expect(balance).to be >= required,
 # structured_data: { "original_message": "expected: >= 100\n     got:    50" }
 ```
 
+### Metadata Capture
+```ruby
+it "validates user input", :slow, :db, priority: :high do
+  expect(user).to be_valid
+end
+# metadata includes:
+# - location: "./spec/models/user_spec.rb:42"
+# - absolute_file_path: "/path/to/project/spec/models/user_spec.rb"
+# - tags: { "slow": true, "db": true, "priority": "high" }
+# - example_group_hierarchy: ["User", "validations", "email format"]
+```
+
 ## Use Cases
 
 - **CI/CD Integration**: Parse test results to create rich error reports

data/lib/rspec/enriched_json/expectation_helper_wrapper.rb

@@ -15,6 +15,82 @@ module RSpec
         RSpec::Expectations::ExpectationHelper.singleton_class.prepend(self)
       end
 
+      # Make serialize_value accessible for other components
+      module Serializer
+        extend self
+
+        MAX_SERIALIZATION_DEPTH = 5
+        MAX_ARRAY_SIZE = 100
+        MAX_HASH_SIZE = 100
+        MAX_STRING_LENGTH = 1000
+
+        def serialize_value(value, depth = 0)
+          return "[Max depth exceeded]" if depth > MAX_SERIALIZATION_DEPTH
+
+          case value
+          when nil, Numeric, TrueClass, FalseClass
+            value
+          when String
+            truncate_string(value)
+          when Symbol
+            value.to_s
+          when Array
+            return "[Large array: #{value.size} items]" if value.size > MAX_ARRAY_SIZE
+            value.map { |v| serialize_value(v, depth + 1) }
+          when Hash
+            return "[Large hash: #{value.size} keys]" if value.size > MAX_HASH_SIZE
+            value.transform_values { |v| serialize_value(v, depth + 1) }
+          else
+            serialize_object(value, depth)
+          end
+        rescue => e
+          {
+            "class" => value.class.name,
+            "serialization_error" => e.message
+          }
+        end
+
+        def serialize_object(obj, depth = 0)
+          result = {
+            "class" => obj.class.name,
+            "inspect" => safe_inspect(obj),
+            "to_s" => safe_to_s(obj)
+          }
+
+          # Handle Structs specially
+          if obj.is_a?(Struct)
+            result["struct_values"] = obj.to_h.transform_values { |v| serialize_value(v, depth + 1) }
+          end
+
+          # Include instance variables only for small objects
+          ivars = obj.instance_variables
+          if ivars.any? && ivars.length <= 10
+            result["instance_variables"] = ivars.each_with_object({}) do |ivar, hash|
+              hash[ivar.to_s] = serialize_value(obj.instance_variable_get(ivar), depth + 1)
+            end
+          end
+
+          result
+        end
+
+        def truncate_string(str)
+          return str if str.length <= MAX_STRING_LENGTH
+          "#{str[0...MAX_STRING_LENGTH]}... (truncated)"
+        end
+
+        def safe_inspect(obj)
+          truncate_string(obj.inspect)
+        rescue => e
+          "[inspect failed: #{e.class}]"
+        end
+
+        def safe_to_s(obj)
+          truncate_string(obj.to_s)
+        rescue => e
+          "[to_s failed: #{e.class}]"
+        end
+      end
+
       def handle_failure(matcher, message, failure_message_method)
         # If a custom message is provided, capture the original message first
         original_message = nil
@@ -25,12 +101,19 @@ module RSpec
         # Call original handler with the original message
         super
       rescue RSpec::Expectations::ExpectationNotMetError => e
+        # Extract raw values for diff analysis
+        expected_raw = extract_value(matcher, :expected)
+        actual_raw = extract_value(matcher, :actual)
+
         # Collect structured data
         structured_data = {
-          expected: serialize_value(extract_value(matcher, :expected)),
-          actual: serialize_value(extract_value(matcher, :actual)),
+          expected: Serializer.serialize_value(expected_raw),
+          actual: Serializer.serialize_value(actual_raw),
           original_message: original_message,  # Only populated when custom message overrides it
-          matcher_name: matcher.class.name
+          matcher_name: matcher.class.name,
+          diff_info: {
+            diffable: values_diffable?(expected_raw, actual_raw, matcher)
+          }
         }
 
         # Raise new exception with data attached
@@ -43,75 +126,38 @@ module RSpec
         return nil unless matcher.respond_to?(method_name)
 
         value = matcher.send(method_name)
-        (value == matcher) ? nil : value
+        # Don't return nil if the value itself is nil
+        # Only return nil if the value is the matcher itself (self-referential)
+        (value == matcher && !value.nil?) ? nil : value
       rescue
         nil
       end
 
-      def serialize_value(value, depth = 0)
-        return "[Max depth exceeded]" if depth > MAX_SERIALIZATION_DEPTH
-
-        case value
-        when nil, Numeric, TrueClass, FalseClass
-          value
-        when String
-          truncate_string(value)
-        when Symbol
-          value.to_s
-        when Array
-          return "[Large array: #{value.size} items]" if value.size > MAX_ARRAY_SIZE
-          value.map { |v| serialize_value(v, depth + 1) }
-        when Hash
-          return "[Large hash: #{value.size} keys]" if value.size > MAX_HASH_SIZE
-          value.transform_values { |v| serialize_value(v, depth + 1) }
-        else
-          serialize_object(value, depth)
+      def values_diffable?(expected, actual, matcher)
+        # First check if the matcher itself declares diffability
+        if matcher.respond_to?(:diffable?)
+          return matcher.diffable?
         end
-      rescue => e
-        {
-          "class" => value.class.name,
-          "serialization_error" => e.message
-        }
-      end
 
-      def serialize_object(obj, depth = 0)
-        result = {
-          "class" => obj.class.name,
-          "inspect" => safe_inspect(obj),
-          "to_s" => safe_to_s(obj)
-        }
+        # If either value is nil, not diffable
+        return false if expected.nil? || actual.nil?
 
-        # Handle Structs specially
-        if obj.is_a?(Struct)
-          result["struct_values"] = obj.to_h.transform_values { |v| serialize_value(v, depth + 1) }
-        end
+        # For different classes, generally not diffable
+        return false unless actual.instance_of?(expected.class)
 
-        # Include instance variables only for small objects
-        ivars = obj.instance_variables
-        if ivars.any? && ivars.length <= 10
-          result["instance_variables"] = ivars.each_with_object({}) do |ivar, hash|
-            hash[ivar.to_s] = serialize_value(obj.instance_variable_get(ivar), depth + 1)
-          end
+        # Check if both values are of the same basic diffable type
+        case expected
+        when String, Array, Hash
+          # These types are inherently diffable when compared to same type
+          true
+        else
+          # For other types, they're diffable if they respond to to_s
+          # and their string representations would be meaningful
+          expected.respond_to?(:to_s) && actual.respond_to?(:to_s)
         end
-
-        result
-      end
-
-      def truncate_string(str)
-        return str if str.length <= MAX_STRING_LENGTH
-        "#{str[0...MAX_STRING_LENGTH]}... (truncated)"
-      end
-
-      def safe_inspect(obj)
-        truncate_string(obj.inspect)
-      rescue => e
-        "[inspect failed: #{e.class}]"
-      end
-
-      def safe_to_s(obj)
-        truncate_string(obj.to_s)
-      rescue => e
-        "[to_s failed: #{e.class}]"
+      rescue
+        # If any error occurs during checking, assume not diffable
+        false
       end
     end
   end

data/lib/rspec/enriched_json/formatters/enriched_json_formatter.rb

@@ -12,6 +12,9 @@ module RSpec
         def stop(group_notification)
           @output_hash[:examples] = group_notification.notifications.map do |notification|
             format_example(notification.example).tap do |hash|
+              # Add enhanced metadata
+              add_metadata(hash, notification.example)
+
               e = notification.example.exception
 
               if e
@@ -23,17 +26,104 @@ module RSpec
 
                 # Add structured data if available
                 if e.is_a?(RSpec::EnrichedJson::EnrichedExpectationNotMetError) && e.structured_data
-                  hash[:structured_data] = {
-                    expected: e.structured_data[:expected],
-                    actual: e.structured_data[:actual],
-                    matcher_name: e.structured_data[:matcher_name],
-                    original_message: e.structured_data[:original_message]
-                  }
+                  hash[:structured_data] = safe_structured_data(e.structured_data)
                 end
               end
             end
           end
         end
+
+        private
+
+        def add_metadata(hash, example)
+          metadata = example.metadata.dup
+
+          # Extract custom tags (all symbols and specific keys)
+          custom_tags = {}
+          metadata.each do |key, value|
+            # Include all symbol keys (like :focus, :slow, etc.)
+            if key.is_a?(Symbol) && value == true
+              custom_tags[key] = true
+            # Include specific metadata that might be useful
+            elsif [:type, :priority, :severity, :db, :js].include?(key)
+              custom_tags[key] = value
+            end
+          end
+
+          # Add enhanced metadata
+          hash[:metadata] = {
+            # Location information
+            location: example.location,
+            absolute_file_path: File.expand_path(example.metadata[:file_path]),
+            rerun_file_path: example.location_rerun_argument,
+
+            # Example hierarchy
+            example_group: example.example_group.description,
+            example_group_hierarchy: extract_group_hierarchy(example),
+
+            # Described class if available
+            described_class: metadata[:described_class]&.to_s,
+
+            # Custom tags and metadata
+            tags: custom_tags.empty? ? nil : custom_tags,
+
+            # Shared example information if applicable
+            shared_group_inclusion_backtrace: metadata[:shared_group_inclusion_backtrace]
+          }.compact # Remove nil values
+        end
+
+        def extract_group_hierarchy(example)
+          hierarchy = []
+          current_group = example.example_group
+
+          while current_group
+            hierarchy.unshift(current_group.description)
+            current_group = (current_group.superclass < RSpec::Core::ExampleGroup) ? current_group.superclass : nil
+          end
+
+          hierarchy
+        end
+
+        def safe_structured_data(structured_data)
+          {
+            expected: safe_serialize(structured_data[:expected]),
+            actual: safe_serialize(structured_data[:actual]),
+            matcher_name: structured_data[:matcher_name],
+            original_message: structured_data[:original_message],
+            diff_info: structured_data[:diff_info]
+          }.compact
+        end
+
+        def safe_serialize(value)
+          # Delegate to the existing serialization logic in ExpectationHelperWrapper
+          RSpec::EnrichedJson::ExpectationHelperWrapper::Serializer.serialize_value(value)
+        rescue => e
+          # Better error recovery - provide context about what failed
+          begin
+            obj_class = value.class.name
+          rescue
+            obj_class = "Unknown"
+          end
+
+          {
+            "serialization_error" => true,
+            "error_class" => e.class.name,
+            "error_message" => e.message,
+            "object_class" => obj_class,
+            "fallback_value" => safe_fallback_value(value)
+          }
+        end
+
+        def safe_fallback_value(value)
+          # Try multiple fallback strategies
+          value.to_s
+        rescue
+          begin
+            value.class.name
+          rescue
+            "Unable to serialize"
+          end
+        end
       end
     end
   end

data/lib/rspec/enriched_json/version.rb

@@ -2,6 +2,6 @@
 
 module RSpec
   module EnrichedJson
-    VERSION = "0.1.0"
+    VERSION = "0.2.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rspec-enriched_json
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Raghu Betina