model-context-protocol-rb 0.6.0 → 0.7.0

data/lib/model_context_protocol/rspec/matchers/have_audio_content.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module ModelContextProtocol
+  module RSpec
+    module Matchers
+      # Matcher that validates a tool response contains audio content.
+      #
+      # @example Basic usage
+      #   expect(response).to have_audio_content
+      #
+      # @example With mime type constraint
+      #   expect(response).to have_audio_content(mime_type: "audio/mp3")
+      #
+      def have_audio_content(mime_type: nil)
+        HaveAudioContent.new(mime_type: mime_type)
+      end
+
+      class HaveAudioContent
+        def initialize(mime_type: nil)
+          @expected_mime_type = mime_type
+          @failure_reasons = []
+        end
+
+        def matches?(actual)
+          @actual = actual
+          @failure_reasons = []
+          @serialized = serialize_response(actual)
+
+          return false if @serialized.nil?
+
+          validate_has_content &&
+            validate_has_audio_content
+        end
+
+        def failure_message
+          constraint = @expected_mime_type ? " with mime type '#{@expected_mime_type}'" : ""
+          "expected response to have audio content#{constraint}, but:\n" +
+            @failure_reasons.map { |reason| "  - #{reason}" }.join("\n")
+        end
+
+        def failure_message_when_negated
+          constraint = @expected_mime_type ? " with mime type '#{@expected_mime_type}'" : ""
+          "expected response not to have audio content#{constraint}, but it did"
+        end
+
+        def description
+          constraint = @expected_mime_type ? " with mime type '#{@expected_mime_type}'" : ""
+          "have audio content#{constraint}"
+        end
+
+        private
+
+        def serialize_response(response)
+          if response.respond_to?(:serialized)
+            response.serialized
+          elsif response.is_a?(Hash)
+            response
+          else
+            @failure_reasons << "response must respond to :serialized or be a Hash"
+            nil
+          end
+        end
+
+        def validate_has_content
+          @content = @serialized[:content] || @serialized["content"]
+
+          unless @content
+            @failure_reasons << "response does not have :content key"
+            return false
+          end
+
+          unless @content.is_a?(Array)
+            @failure_reasons << "content must be an Array"
+            return false
+          end
+
+          true
+        end
+
+        def validate_has_audio_content
+          audio_items = @content.select do |item|
+            type = item[:type] || item["type"]
+            type == "audio"
+          end
+
+          if audio_items.empty?
+            @failure_reasons << "no audio content found in response"
+            return false
+          end
+
+          if @expected_mime_type
+            matching_item = audio_items.find do |item|
+              mime_type = item[:mimeType] || item["mimeType"]
+              mime_type == @expected_mime_type
+            end
+
+            unless matching_item
+              actual_types = audio_items.map { |item| item[:mimeType] || item["mimeType"] }
+              @failure_reasons << "no audio content with mime type '#{@expected_mime_type}' found, found: #{actual_types.inspect}"
+              return false
+            end
+          end
+
+          true
+        end
+      end
+    end
+  end
+end

data/lib/model_context_protocol/rspec/matchers/have_embedded_resource_content.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module ModelContextProtocol
+  module RSpec
+    module Matchers
+      # Matcher that validates a tool response contains embedded resource content.
+      #
+      # @example Basic usage
+      #   expect(response).to have_embedded_resource_content
+      #
+      # @example With URI constraint
+      #   expect(response).to have_embedded_resource_content(uri: "file:///path/to/file.txt")
+      #
+      def have_embedded_resource_content(uri: nil, mime_type: nil)
+        HaveEmbeddedResourceContent.new(uri: uri, mime_type: mime_type)
+      end
+
+      class HaveEmbeddedResourceContent
+        def initialize(uri: nil, mime_type: nil)
+          @expected_uri = uri
+          @expected_mime_type = mime_type
+          @failure_reasons = []
+        end
+
+        def matches?(actual)
+          @actual = actual
+          @failure_reasons = []
+          @serialized = serialize_response(actual)
+
+          return false if @serialized.nil?
+
+          validate_has_content &&
+            validate_has_embedded_resource_content
+        end
+
+        def failure_message
+          constraints = build_constraint_message
+          "expected response to have embedded resource content#{constraints}, but:\n" +
+            @failure_reasons.map { |reason| "  - #{reason}" }.join("\n")
+        end
+
+        def failure_message_when_negated
+          constraints = build_constraint_message
+          "expected response not to have embedded resource content#{constraints}, but it did"
+        end
+
+        def description
+          constraints = build_constraint_message
+          "have embedded resource content#{constraints}"
+        end
+
+        private
+
+        def build_constraint_message
+          parts = []
+          parts << "uri: '#{@expected_uri}'" if @expected_uri
+          parts << "mime_type: '#{@expected_mime_type}'" if @expected_mime_type
+          parts.empty? ? "" : " with #{parts.join(", ")}"
+        end
+
+        def serialize_response(response)
+          if response.respond_to?(:serialized)
+            response.serialized
+          elsif response.is_a?(Hash)
+            response
+          else
+            @failure_reasons << "response must respond to :serialized or be a Hash"
+            nil
+          end
+        end
+
+        def validate_has_content
+          @content = @serialized[:content] || @serialized["content"]
+
+          unless @content
+            @failure_reasons << "response does not have :content key"
+            return false
+          end
+
+          unless @content.is_a?(Array)
+            @failure_reasons << "content must be an Array"
+            return false
+          end
+
+          true
+        end
+
+        def validate_has_embedded_resource_content
+          resource_items = @content.select do |item|
+            type = item[:type] || item["type"]
+            type == "resource"
+          end
+
+          if resource_items.empty?
+            @failure_reasons << "no embedded resource content found in response"
+            return false
+          end
+
+          matching_items = resource_items.dup
+
+          if @expected_uri
+            matching_items = matching_items.select do |item|
+              resource = item[:resource] || item["resource"] || {}
+              # Resource can be directly embedded (uri at top level) or have contents array
+              uri = resource[:uri] || resource["uri"]
+              if uri
+                uri == @expected_uri
+              else
+                contents = resource[:contents] || resource["contents"] || []
+                contents.any? do |content|
+                  content_uri = content[:uri] || content["uri"]
+                  content_uri == @expected_uri
+                end
+              end
+            end
+
+            if matching_items.empty?
+              @failure_reasons << "no embedded resource with uri '#{@expected_uri}' found"
+              return false
+            end
+          end
+
+          if @expected_mime_type
+            matching_items = matching_items.select do |item|
+              resource = item[:resource] || item["resource"] || {}
+              # Resource can be directly embedded (mimeType at top level) or have contents array
+              mime_type = resource[:mimeType] || resource["mimeType"]
+              if mime_type
+                mime_type == @expected_mime_type
+              else
+                contents = resource[:contents] || resource["contents"] || []
+                contents.any? do |content|
+                  content_mime_type = content[:mimeType] || content["mimeType"]
+                  content_mime_type == @expected_mime_type
+                end
+              end
+            end
+
+            if matching_items.empty?
+              @failure_reasons << "no embedded resource with mime type '#{@expected_mime_type}' found"
+              return false
+            end
+          end
+
+          true
+        end
+      end
+    end
+  end
+end

data/lib/model_context_protocol/rspec/matchers/have_image_content.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module ModelContextProtocol
+  module RSpec
+    module Matchers
+      # Matcher that validates a tool response contains image content.
+      #
+      # @example Basic usage
+      #   expect(response).to have_image_content
+      #
+      # @example With mime type constraint
+      #   expect(response).to have_image_content(mime_type: "image/png")
+      #
+      def have_image_content(mime_type: nil)
+        HaveImageContent.new(mime_type: mime_type)
+      end
+
+      class HaveImageContent
+        def initialize(mime_type: nil)
+          @expected_mime_type = mime_type
+          @failure_reasons = []
+        end
+
+        def matches?(actual)
+          @actual = actual
+          @failure_reasons = []
+          @serialized = serialize_response(actual)
+
+          return false if @serialized.nil?
+
+          validate_has_content &&
+            validate_has_image_content
+        end
+
+        def failure_message
+          constraint = @expected_mime_type ? " with mime type '#{@expected_mime_type}'" : ""
+          "expected response to have image content#{constraint}, but:\n" +
+            @failure_reasons.map { |reason| "  - #{reason}" }.join("\n")
+        end
+
+        def failure_message_when_negated
+          constraint = @expected_mime_type ? " with mime type '#{@expected_mime_type}'" : ""
+          "expected response not to have image content#{constraint}, but it did"
+        end
+
+        def description
+          constraint = @expected_mime_type ? " with mime type '#{@expected_mime_type}'" : ""
+          "have image content#{constraint}"
+        end
+
+        private
+
+        def serialize_response(response)
+          if response.respond_to?(:serialized)
+            response.serialized
+          elsif response.is_a?(Hash)
+            response
+          else
+            @failure_reasons << "response must respond to :serialized or be a Hash"
+            nil
+          end
+        end
+
+        def validate_has_content
+          @content = @serialized[:content] || @serialized["content"]
+
+          unless @content
+            @failure_reasons << "response does not have :content key"
+            return false
+          end
+
+          unless @content.is_a?(Array)
+            @failure_reasons << "content must be an Array"
+            return false
+          end
+
+          true
+        end
+
+        def validate_has_image_content
+          image_items = @content.select do |item|
+            type = item[:type] || item["type"]
+            type == "image"
+          end
+
+          if image_items.empty?
+            @failure_reasons << "no image content found in response"
+            return false
+          end
+
+          if @expected_mime_type
+            matching_item = image_items.find do |item|
+              mime_type = item[:mimeType] || item["mimeType"]
+              mime_type == @expected_mime_type
+            end
+
+            unless matching_item
+              actual_types = image_items.map { |item| item[:mimeType] || item["mimeType"] }
+              @failure_reasons << "no image content with mime type '#{@expected_mime_type}' found, found: #{actual_types.inspect}"
+              return false
+            end
+          end
+
+          true
+        end
+      end
+    end
+  end
+end

data/lib/model_context_protocol/rspec/matchers/have_message_count.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module ModelContextProtocol
+  module RSpec
+    module Matchers
+      # Matcher that validates a prompt response contains a specific number of messages.
+      #
+      # @example Basic usage
+      #   expect(response).to have_message_count(3)
+      #
+      def have_message_count(expected_count)
+        HaveMessageCount.new(expected_count)
+      end
+
+      class HaveMessageCount
+        def initialize(expected_count)
+          @expected_count = expected_count
+          @failure_reasons = []
+        end
+
+        def matches?(actual)
+          @actual = actual
+          @failure_reasons = []
+          @serialized = serialize_response(actual)
+
+          return false if @serialized.nil?
+
+          validate_has_messages &&
+            validate_count
+        end
+
+        def failure_message
+          "expected response to have #{@expected_count} message(s), but:\n" +
+            @failure_reasons.map { |reason| "  - #{reason}" }.join("\n")
+        end
+
+        def failure_message_when_negated
+          "expected response not to have #{@expected_count} message(s), but it did"
+        end
+
+        def description
+          "have #{@expected_count} message(s)"
+        end
+
+        private
+
+        def serialize_response(response)
+          if response.respond_to?(:serialized)
+            response.serialized
+          elsif response.is_a?(Hash)
+            response
+          else
+            @failure_reasons << "response must respond to :serialized or be a Hash"
+            nil
+          end
+        end
+
+        def validate_has_messages
+          @messages = @serialized[:messages] || @serialized["messages"]
+
+          unless @messages
+            @failure_reasons << "response does not have :messages key"
+            return false
+          end
+
+          unless @messages.is_a?(Array)
+            @failure_reasons << "messages must be an Array"
+            return false
+          end
+
+          true
+        end
+
+        def validate_count
+          actual_count = @messages.size
+
+          if actual_count != @expected_count
+            @failure_reasons << "expected #{@expected_count} message(s), got #{actual_count}"
+            return false
+          end
+
+          true
+        end
+      end
+    end
+  end
+end

data/lib/model_context_protocol/rspec/matchers/have_message_with_role.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module ModelContextProtocol
+  module RSpec
+    module Matchers
+      # Matcher that validates a prompt response contains a message with a specific role.
+      #
+      # @example Basic usage
+      #   expect(response).to have_message_with_role("user")
+      #
+      # @example With content constraint
+      #   expect(response).to have_message_with_role("assistant").containing("How can I help?")
+      #
+      # @example With regex content constraint
+      #   expect(response).to have_message_with_role("user").containing(/generate.*excuses/i)
+      #
+      def have_message_with_role(role)
+        HaveMessageWithRole.new(role)
+      end
+
+      class HaveMessageWithRole
+        def initialize(role)
+          @expected_role = role.to_s
+          @expected_content = nil
+          @failure_reasons = []
+        end
+
+        def containing(content)
+          @expected_content = content
+          self
+        end
+
+        def matches?(actual)
+          @actual = actual
+          @failure_reasons = []
+          @serialized = serialize_response(actual)
+
+          return false if @serialized.nil?
+
+          validate_has_messages &&
+            validate_has_role &&
+            validate_content_match
+        end
+
+        def failure_message
+          constraint = @expected_content ? " containing #{@expected_content.inspect}" : ""
+          "expected response to have message with role '#{@expected_role}'#{constraint}, but:\n" +
+            @failure_reasons.map { |reason| "  - #{reason}" }.join("\n")
+        end
+
+        def failure_message_when_negated
+          constraint = @expected_content ? " containing #{@expected_content.inspect}" : ""
+          "expected response not to have message with role '#{@expected_role}'#{constraint}, but it did"
+        end
+
+        def description
+          constraint = @expected_content ? " containing #{@expected_content.inspect}" : ""
+          "have message with role '#{@expected_role}'#{constraint}"
+        end
+
+        private
+
+        def serialize_response(response)
+          if response.respond_to?(:serialized)
+            response.serialized
+          elsif response.is_a?(Hash)
+            response
+          else
+            @failure_reasons << "response must respond to :serialized or be a Hash"
+            nil
+          end
+        end
+
+        def validate_has_messages
+          @messages = @serialized[:messages] || @serialized["messages"]
+
+          unless @messages
+            @failure_reasons << "response does not have :messages key"
+            return false
+          end
+
+          unless @messages.is_a?(Array)
+            @failure_reasons << "messages must be an Array"
+            return false
+          end
+
+          true
+        end
+
+        def validate_has_role
+          @messages_with_role = @messages.select do |message|
+            role = message[:role] || message["role"]
+            role == @expected_role
+          end
+
+          if @messages_with_role.empty?
+            actual_roles = @messages.map { |m| m[:role] || m["role"] }.uniq
+            @failure_reasons << "no message with role '#{@expected_role}' found, found roles: #{actual_roles.inspect}"
+            return false
+          end
+
+          true
+        end
+
+        def validate_content_match
+          return true unless @expected_content
+
+          matching_message = @messages_with_role.find do |message|
+            content = message[:content] || message["content"]
+            content_matches?(content)
+          end
+
+          unless matching_message
+            @failure_reasons << "no '#{@expected_role}' message contains content matching #{@expected_content.inspect}"
+            return false
+          end
+
+          true
+        end
+
+        def content_matches?(content)
+          return false unless content
+
+          # Content can be a hash with type/text or an array of content blocks
+          texts = extract_texts(content)
+          texts.any? { |text| text_matches?(text) }
+        end
+
+        def extract_texts(content)
+          case content
+          when Array
+            content.flat_map { |item| extract_texts(item) }
+          when Hash
+            text = content[:text] || content["text"]
+            text ? [text] : []
+          else
+            []
+          end
+        end
+
+        def text_matches?(text)
+          case @expected_content
+          when Regexp
+            @expected_content.match?(text)
+          else
+            text.to_s.include?(@expected_content.to_s)
+          end
+        end
+      end
+    end
+  end
+end