tracing-matchers 1.0.0

data/lib/tracing/matchers/span/be_child_of.rb

@@ -0,0 +1,99 @@
+module Tracing
+  module Matchers
+    module Span
+      # @private
+      class BeChildOf
+        def initialize(parent)
+          @expected = parent
+        end
+
+        # @return [Boolean]
+        def matches?(span)
+          @tracer = span.tracer
+          @subject = span
+          # actual is either Span, or SpanContext
+          @actual = parent_of(@subject)
+
+          case
+          when any? then !!@actual
+          when @actual.nil? && @expected then false
+          else
+            expected_span_id == actual_span_id
+          end
+        end
+
+        # @return [String]
+        def description
+          any? ? "have a parent" : "have #{expected_message} as the parent"
+        end
+
+        # @return [String]
+        def failure_message
+          any? ? "expected a parent" : "expected #{expected_message} as the parent, got #{actual_message}"
+        end
+        alias :failure_message_for_should :failure_message
+
+        # @return [String]
+        def failure_message_when_negated
+          any? ? "did not expect the parent" : "did not expect #{expected_message} parent, got #{actual_message}"
+        end
+        alias :failure_message_for_should_not :failure_message_when_negated
+
+        private
+
+        def any?
+          @expected == :any
+        end
+
+        def parent_of(subject)
+          return nil unless subject.context.parent_span_id
+
+          parent_span = @tracer
+                          .spans
+                          .find { |span| span.context.span_id == subject.context.parent_span_id }
+
+          parent_span || subject.context
+        end
+
+        def actual_span_id
+          case
+          when @actual.respond_to?(:context) then @actual.context.span_id
+          when @actual.respond_to?(:parent_span_id) then @actual.parent_span_id
+          else @actual
+          end
+        end
+
+        def expected_span_id
+          case
+          when @expected.respond_to?(:context) then @expected.context.span_id
+          when @expected.respond_to?(:span_id) then @expected.span_id
+          when @expected.is_a?(String) then @tracer.spans.find { |span| span.operation_name == @expected }&.context&.span_id
+          else @expected
+          end
+        end
+
+        def expected_spans(tracer)
+          tracer.spans.select { |span| span.operation_name == @expected }
+        end
+
+        def expected_message
+          case
+          when @expected.respond_to?(:context) then "the span with operation name \"#{@expected.operation_name}\""
+          when @expected.respond_to?(:span_id) then "the span context with id \"#{@expected.span_id}\""
+          when @expected.is_a?(String) then "a span with operation name \"#{@expected}\""
+          else nil
+          end
+        end
+
+        def actual_message
+          case
+          when @actual.respond_to?(:operation_name) then "a span with operation name \"#{@actual.operation_name}\""
+          when @actual.respond_to?(:parent_span_id) then "a span context with id \"#{@actual.parent_span_id}\""
+          when @actual.nil? then "nothing"
+          else @actual
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tracing/matchers/span/have_baggage.rb

@@ -0,0 +1,50 @@
+module Tracing
+  module Matchers
+    module Span
+      # @private
+      class HaveBaggage
+        def initialize(*args)
+          @expected = args.last.is_a?(Hash) ? args.delete_at(-1) : Hash.new
+          args.each_slice(2) { |k, v| @expected[k] = v }
+        end
+
+        # @return [Boolean]
+        def matches?(span)
+          @subject = span
+          @actual = span.context.baggage
+
+          if any?
+            @actual.any?
+          else
+            @expected.all? { |k, v| @actual.key?(k) && v == @actual[k] }
+          end
+        end
+
+        # @return [String]
+        def description
+          desc = "have baggage"
+          desc << " #{@expected}" unless any?
+          desc
+        end
+
+        # @return [String]
+        def failure_message
+          any? ? "expected any baggage" : "expected #{@expected} baggage, got #{@actual}"
+        end
+        alias :failure_message_for_should :failure_message
+
+        # @return [String]
+        def failure_message_when_negated
+          any? ? "did not expect any baggage" : "did not expect #{@expected} baggage, got #{@actual}"
+        end
+        alias :failure_message_for_should_not :failure_message_when_negated
+
+        private
+
+        def any?
+          @expected.empty?
+        end
+      end
+    end
+  end
+end

data/lib/tracing/matchers/span/have_log.rb

@@ -0,0 +1,51 @@
+module Tracing
+  module Matchers
+    module Span
+      # @private
+      class HaveLog
+        def initialize(**fields)
+          @expected = fields
+        end
+
+        # @return [Boolean]
+        def matches?(span)
+          @subject = span
+          @actual = span.logs.map { |log| log.fields.dup.tap { |h| h[:event] = log.event } }
+
+          if any?
+            @actual.any?
+          else
+            @actual.any? do |log|
+              @expected.all? { |k, v| log.key?(k) && v == log[k] }
+            end
+          end
+        end
+
+        # @return [String]
+        def description
+          desc = "have log entry"
+          desc << " #{@expected}" unless any?
+          desc
+        end
+
+        # @return [String]
+        def failure_message
+          any? ? "expected any log entry" : "expected #{@expected} log entry, got #{@actual}"
+        end
+        alias :failure_message_for_should :failure_message
+
+        # @return [String]
+        def failure_message_when_negated
+          any? ? "did not expect any log entry" : "did not expect #{@expected} log entry, got #{@actual}"
+        end
+        alias :failure_message_for_should_not :failure_message_when_negated
+
+        private
+
+        def any?
+          @expected.empty?
+        end
+      end
+    end
+  end
+end

data/lib/tracing/matchers/span/have_tag.rb

@@ -0,0 +1,50 @@
+module Tracing
+  module Matchers
+    module Span
+      # @private
+      class HaveTag
+        def initialize(*args)
+          @expected = args.last.is_a?(Hash) ? args.delete_at(-1) : Hash.new
+          args.each_slice(2) { |k, v| @expected[k] = v }
+        end
+
+        # @return [Boolean]
+        def matches?(span)
+          @subject = span
+          @actual = span.tags
+
+          if any?
+            @actual.any?
+          else
+            @expected.all? { |k, v| @actual.key?(k) && v == @actual[k] }
+          end
+        end
+
+        # @return [String]
+        def description
+          desc = "have tags"
+          desc << " #{@expected}" unless any?
+          desc
+        end
+
+        # @return [String]
+        def failure_message
+          any? ? "expected any tag" : "expected #{@expected} tags, got #{@actual}"
+        end
+        alias :failure_message_for_should :failure_message
+
+        # @return [String]
+        def failure_message_when_negated
+          any? ? "did not expect any tag" : "did not expect #{@expected} tags, got #{@actual}"
+        end
+        alias :failure_message_for_should_not :failure_message_when_negated
+
+        private
+
+        def any?
+          @expected.empty?
+        end
+      end
+    end
+  end
+end

data/lib/tracing/matchers/span_matchers.rb

@@ -0,0 +1,72 @@
+require "tracing/matchers/span/have_tag"
+require "tracing/matchers/span/have_log"
+require "tracing/matchers/span/have_baggage"
+require "tracing/matchers/span/be_child_of"
+
+module Tracing
+  module Matchers
+    # The `have_tag` matcher tests that the span includes tags.
+    # @example
+    #
+    #   # Passes if span have any tag
+    #   expect(span).to have_tag
+    #
+    #   # Passes if span includes a tag with "tag" key, and "value" value
+    #   expect(span).to have_tag("key", "value")
+    #   expect(span).to have_tag("key" => "value")
+    #
+    # @return [HaveTag]
+    def have_tag(*args)
+      Tracing::Matchers::Span::HaveTag.new(*args)
+    end
+    alias :have_tags :have_tag
+
+    # The `have_log` matcher tests that the span includes a tag.
+    # @example
+    #
+    #   # Passes if span have any log
+    #   expect(span).to have_log
+    #
+    #   # Passes if span includes a log entry with event: "error"
+    #   expect(span).to have_log(event: "error")
+    #
+    # @return [HaveTag]
+    def have_log(**fields)
+      Tracing::Matchers::Span::HaveLog.new(**fields)
+    end
+    alias :have_logs :have_log
+
+    # The `have_baggage` matcher tests that the span/span context includes baggage.
+    # @example
+    #
+    #   # Passes if span have any baggage item
+    #   expect(span).to have_baggage
+    #
+    #   # Passes if span includes a baggage item with "tag" key, and "value" value
+    #   expect(span).to have_baggage("key", "value")
+    #   expect(span).to have_baggage("key" => "value")
+    #
+    # @return [HaveBaggage]
+    def have_baggage(*args)
+      Tracing::Matchers::Span::HaveBaggage.new(*args)
+    end
+    alias :have_baggage_item :have_baggage
+
+    # The `be_child_of` matcher tests that the span/span context is a child of some other span/span context.
+    # @example
+    #
+    #   # Passes if span is a child of any span
+    #   expect(span).to have_parent
+    #
+    #   # Passes if span is a child of a specific span context
+    #   expect(span).to be_child_of("parent operation")
+    #   expect(span).to be_child_of(parent_span)
+    #   expect(span).to be_child_of(parent_span_context)
+    #
+    # @return [HaveBaggage]
+    def be_child_of(parent = :any)
+      Tracing::Matchers::Span::BeChildOf.new(parent)
+    end
+    alias :have_parent :be_child_of
+  end
+end

data/lib/tracing/matchers/version.rb

@@ -0,0 +1,5 @@
+module Tracing
+  module Matchers
+    VERSION = "1.0.0"
+  end
+end

data/tracing-matchers.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "tracing/matchers/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "tracing-matchers"
+  spec.version       = Tracing::Matchers::VERSION
+  spec.authors       = ["iaintshine"]
+  spec.email         = ["bodziomista@gmail.com"]
+
+  spec.summary       = %q{RSpec matchers for testing mocked OpenTracing instrumentations}
+  spec.description   = %q{}
+  spec.homepage      = "https://github.com/iaintshine/ruby-tracing-matchers"
+  spec.license       = "Apache-2.0"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "test-tracer", "~> 1.1"
+  spec.add_dependency "rspec", ">= 2.0"
+
+  spec.add_development_dependency "bundler", "~> 1.15"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: tracing-matchers
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- iaintshine
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-08-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: test-tracer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: ''
+email:
+- bodziomista@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".ruby-version"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/tracing/matchers.rb
+- lib/tracing/matchers/have_span.rb
+- lib/tracing/matchers/have_spans.rb
+- lib/tracing/matchers/have_traces.rb
+- lib/tracing/matchers/span/be_child_of.rb
+- lib/tracing/matchers/span/have_baggage.rb
+- lib/tracing/matchers/span/have_log.rb
+- lib/tracing/matchers/span/have_tag.rb
+- lib/tracing/matchers/span_matchers.rb
+- lib/tracing/matchers/version.rb
+- tracing-matchers.gemspec
+homepage: https://github.com/iaintshine/ruby-tracing-matchers
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.12
+signing_key: 
+specification_version: 4
+summary: RSpec matchers for testing mocked OpenTracing instrumentations
+test_files: []