cucumber-compatibility-kit 13.0.0 → 13.0.1

data/lib/cucumber-compatibility-kit.rb

@@ -1,57 +1 @@
-# frozen_string_literal: true
-
-require 'shared_examples'
-
-module Cucumber::CompatibilityKit
-  class << self
-    def all_examples
-      gherkin_examples + markdown_examples
-    end
-
-    def gherkin_examples
-      Dir
-        .entries(examples_path)
-        .select do |file|
-          folder = File.join(examples_path, file)
-
-          file != '.' && file != '..' &&
-            File.directory?(folder) &&
-            is_gherkin_example?(folder)
-        end
-    end
-
-    def markdown_examples
-      Dir
-      .entries(examples_path)
-      .select do |file|
-        folder = File.join(examples_path, file)
-
-        file != '.' && file != '..' &&
-          File.directory?(folder) &&
-          is_markdown_example?(folder)
-      end
-    end
-
-    def examples_path
-      File.expand_path("#{File.dirname(__FILE__)}/../features/")
-    end
-
-    def example_path(example_name)
-      path = File.join(examples_path, example_name)
-
-      return path if File.directory?(path)
-
-      raise ArgumentError.new
-    end
-
-    private
-
-    def is_gherkin_example?(example_folder)
-      Dir.entries(example_folder).select { |file| File.extname(file) == '.feature' }.count > 0
-    end
-
-    def is_markdown_example?(example_folder)
-      Dir.entries(example_folder).select { |file| File.extname(file) == '.md' }.count > 0
-    end
-  end
-end
+require_relative 'cucumber/cucumber-compatibility-kit'

data/lib/keys_checker.rb

@@ -1,64 +1 @@
-# frozen_string_literal: true
-
-module CCK
-  class KeysChecker
-    def self.compare(detected, expected)
-      new(detected, expected).compare
-    end
-
-    attr_reader :detected, :expected
-
-    def initialize(detected, expected)
-      @detected = detected
-      @expected = expected
-    end
-
-    def compare
-      return [] if identical_keys?
-
-      errors << "Detected extra keys in message #{message_name}: #{extra_keys}" if extra_keys.any?
-      errors << "Missing keys in message #{message_name}: #{missing_keys}" if missing_keys.any?
-      errors
-    rescue StandardError => e
-      ["Unexpected error: #{e.message}"]
-    end
-
-    private
-
-    def detected_keys
-      @detected_keys ||= ordered_uniq_hash_keys(detected)
-    end
-
-    def expected_keys
-      @expected_keys ||= ordered_uniq_hash_keys(expected)
-    end
-
-    def identical_keys?
-      detected_keys == expected_keys
-    end
-
-    def missing_keys
-      (expected_keys - detected_keys).reject { |key| meta_message? && key == :ci }
-    end
-
-    def extra_keys
-      (detected_keys - expected_keys).reject { |key| meta_message? && key == :ci }
-    end
-
-    def meta_message?
-      detected.instance_of?(Cucumber::Messages::Meta)
-    end
-
-    def message_name
-      detected.class.name
-    end
-
-    def ordered_uniq_hash_keys(object)
-      object.to_h(reject_nil_values: true).keys.sort
-    end
-
-    def errors
-      @errors ||= []
-    end
-  end
-end
+require_relative 'cck/keys_checker'

data/lib/messages_comparator.rb

@@ -1,88 +1 @@
-# frozen_string_literal: true
-
-require_relative 'keys_checker'
-
-module CCK
-  class MessagesComparator
-    def initialize(validator, found, expected)
-      @all_errors = []
-      @compared = []
-      @validator = validator
-
-      compare(found, expected)
-    end
-
-    def errors
-      @all_errors.flatten
-    end
-
-    def debug
-      # puts 'Compared the following type of message:'
-      # puts @compared.uniq.map { |m| " - #{m}" }.join("\n")
-      # puts ''
-      puts errors.uniq.join("\n")
-    end
-
-    private
-
-    def compare(found, expected)
-      found_by_type = messages_by_type(found)
-      expected_by_type = messages_by_type(expected)
-
-      found_by_type.keys.each do |type|
-        compare_list(found_by_type[type], expected_by_type[type])
-      rescue StandardError => e
-        @all_errors << "Error whild comparing #{type}: #{e.message}"
-      end
-    end
-
-    def messages_by_type(messages)
-      by_type = Hash.new { |h, k| h[k] = [] }
-      messages.each do |msg|
-        by_type[message_type(msg)] << remove_envelope(msg)
-      end
-      by_type
-    end
-
-    def message_type(message)
-      message.to_h.each do |key, value|
-        return key unless value.nil?
-      end
-    end
-
-    def remove_envelope(message)
-      message.send(message_type(message))
-    end
-
-    def compare_list(found, expected)
-      found.each_with_index do |message, index|
-        compare_message(message, expected[index])
-      end
-    end
-
-    def compare_message(found, expected)
-      return unless found.is_a?(Cucumber::Messages::Message)
-      return if found.is_a?(Cucumber::Messages::GherkinDocument)
-      return if found.is_a?(Cucumber::Messages::Pickle)
-      return if found.is_a?(Cucumber::Messages::Timestamp) && expected.is_a?(Cucumber::Messages::Timestamp)
-      return if found.is_a?(Cucumber::Messages::Duration) && expected.is_a?(Cucumber::Messages::Duration)
-      return if ENV['CI'] && found.is_a?(Cucumber::Messages::Ci) && expected.nil?
-
-      @compared << found.class.name
-      @all_errors << @validator.compare(found, expected)
-      compare_sub_messages(found, expected)
-    end
-
-    def compare_sub_messages(found, expected)
-      return unless expected.respond_to? :to_h
-      expected.to_h.keys.each do |key|
-        value = expected.send(key)
-        if value.is_a?(Array)
-          compare_list(found.send(key), value)
-        else
-          compare_message(found.send(key), value)
-        end
-      end
-    end
-  end
-end
+require_relative 'cck/messages_comparator'

data/lib/shared_examples.rb

@@ -8,6 +8,8 @@ require 'messages_comparator'
 require 'keys_checker'
 
 RSpec.shared_examples 'cucumber compatibility kit' do
+  include CCK::Helpers
+
   # Note: to use those examples, you need to define:
   # let(:example) {  } # the name of the example to test
   # let(:messages) {  } # the messages to validate
@@ -24,45 +26,20 @@ RSpec.shared_examples 'cucumber compatibility kit' do
   let(:generated_messages_types) { parsed_generated.map { |msg| message_type(msg) } }
 
   it 'generates valid message types' do
-    debug_lists(original_messages_types, generated_messages_types)
     expect(generated_messages_types).to contain_exactly(*original_messages_types)
   end
 
   it 'generates valid message structure' do
     comparator = CCK::MessagesComparator.new(CCK::KeysChecker, parsed_generated, parsed_original)
-    comparator.debug if ENV['VERBOSE']
 
-    if comparator.errors.any?
-      fail "There were comparison errors: #{comparator.errors}"
-    end
+    expect(comparator.errors).to be_empty, "There were comparison errors: #{comparator.errors}"
   end
-end
 
-def parse_ndjson_file(path)
-  parse_ndjson(File.read(path))
-end
-
-def parse_ndjson(ndjson)
-  Cucumber::Messages::NdjsonToMessageEnumerator.new(ndjson)
-end
-
-def message_type(message)
-  # TODO: This is duplicate code - from messages_comparator:45 - It should live in a common helper methods module
-  message.to_h.each do |key, value|
-    return key unless value.nil?
+  def parse_ndjson_file(path)
+    parse_ndjson(File.read(path))
   end
-end
-
-def debug_lists(expected, obtained)
-  return unless ENV['VERBOSE']
-  return if expected.sort == obtained.sort
-
-  to_read = expected.count > obtained.count ? expected : obtained
-  columnize = "\t\t\t\t | \t\t\t\t"
 
-  puts "    | Expected #{columnize} GOT"
-  to_read.each_with_index do |_, index|
-    ok = expected[index] == obtained[index] ? 'v' : 'x'
-    puts "[#{ok}] | #{expected[index]} #{columnize} #{obtained[index]}"
+  def parse_ndjson(ndjson)
+    Cucumber::Messages::NdjsonToMessageEnumerator.new(ndjson)
   end
 end

data/spec/cck/keys_checker_spec.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'rspec'
+require 'cucumber/messages'
+require_relative '../../lib/keys_checker'
+
+describe CCK::KeysChecker do
+  describe '#compare' do
+    let(:expected_values) { Cucumber::Messages::Attachment.new(url: 'https://foo.com', file_name: 'file.extension') }
+    let(:erroneous_values) { Cucumber::Messages::Attachment.new(source: '1', test_step_id: '123') }
+    let(:wrong_values) { Cucumber::Messages::Attachment.new(url: 'https://otherfoo.com', file_name: 'file.other') }
+
+    it 'finds missing keys' do
+      expect(described_class.compare(erroneous_values, expected_values)).to include(
+        'Missing keys in message Cucumber::Messages::Attachment: [:file_name, :url]'
+      )
+    end
+
+    it 'finds extra keys' do
+      expect(described_class.compare(erroneous_values, expected_values)).to include(
+        'Detected extra keys in message Cucumber::Messages::Attachment: [:source, :test_step_id]'
+      )
+    end
+
+    it 'finds extra and missing keys' do
+      expect(described_class.compare(erroneous_values, expected_values)).to contain_exactly(
+        'Missing keys in message Cucumber::Messages::Attachment: [:file_name, :url]',
+        'Detected extra keys in message Cucumber::Messages::Attachment: [:source, :test_step_id]'
+      )
+    end
+
+    it 'does not care about the values' do
+      expect(described_class.compare(expected_values, wrong_values)).to be_empty
+    end
+
+    context 'when default values are omitted' do
+      let(:default_set) { Cucumber::Messages::Duration.new(seconds: 0, nanos: 12) }
+      let(:default_not_set) { Cucumber::Messages::Duration.new(nanos: 12) }
+
+      it 'does not raise an exception' do
+        expect(described_class.compare(default_set, default_not_set)).to be_empty
+      end
+    end
+
+    context 'when executed as part of a CI' do
+      before { allow(ENV).to receive(:[]).with('CI').and_return(true) }
+
+      it 'ignores actual CI related messages' do
+        detected = Cucumber::Messages::Meta.new(ci: Cucumber::Messages::Ci.new(name: 'Some CI'))
+        expected = Cucumber::Messages::Meta.new
+
+        expect(described_class.compare(detected, expected)).to be_empty
+      end
+    end
+
+    context 'when an unexpected error occurs' do
+      it 'does not raise error' do
+        expect { described_class.compare(nil, nil) }.not_to raise_error
+      end
+
+      it 'returns the error' do
+        expect(described_class.compare(nil, nil))
+          .to eq(['Unexpected error: wrong number of arguments (given 1, expected 0)'])
+      end
+    end
+  end
+end

data/spec/cck/messages_comparator_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'rspec'
+require 'cucumber/messages'
+require_relative '../../lib/messages_comparator'
+
+describe CCK::MessagesComparator do
+  context 'when executed as part of a CI' do
+    before { allow(ENV).to receive(:[]).with('CI').and_return(true) }
+
+    let(:ci_message) { Cucumber::Messages::Ci.new(name: 'Some CI') }
+    let(:blank_meta_message) { Cucumber::Messages::Meta.new }
+    let(:filled_meta_message) { Cucumber::Messages::Meta.new(ci: ci_message) }
+    let(:ci_message_envelope) { Cucumber::Messages::Envelope.new(meta: filled_meta_message) }
+    let(:meta_message_envelope) { Cucumber::Messages::Envelope.new(meta: blank_meta_message) }
+
+    it 'ignores any detected CI messages' do
+      comparator = described_class.new(CCK::KeysChecker, [ci_message_envelope], [meta_message_envelope])
+
+      expect(comparator.errors).to be_empty
+    end
+
+    it 'ignores any expected CI messages' do
+      comparator = described_class.new(CCK::KeysChecker, [meta_message_envelope], [ci_message_envelope])
+
+      expect(comparator.errors).to be_empty
+    end
+  end
+end

data/spec/{cucumber-compatibility-kit_spec.rb → cucumber/cucumber-compatibility-kit_spec.rb}

@@ -3,8 +3,8 @@
 require 'cucumber-compatibility-kit'
 
 describe Cucumber::CompatibilityKit do
-  let(:features_path) { File.expand_path("#{File.dirname(__FILE__)}/../features") }
-  let(:gherkin_examples) {
+  let(:features_path) { File.expand_path("#{File.dirname(__FILE__)}/../../features") }
+  let(:gherkin_examples) do
     [
       'attachments',
       'cdata',
@@ -21,47 +21,38 @@ describe Cucumber::CompatibilityKit do
       'undefined',
       'unknown-parameter-type'
     ]
-  }
-  let(:markdown_examples) {
-    [
-      'markdown'
-    ]
-  }
+  end
+  let(:markdown_examples) { ['markdown'] }
 
   describe '#examples_path' do
     it 'returns the path of the features folder' do
-      expect(described_class.examples_path)
-        .to eq(features_path)
+      expect(described_class.examples_path).to eq(features_path)
     end
   end
 
   describe '#example_path' do
     context 'with an existing example' do
       it 'returns the path of the folder of the example' do
-        expect(described_class.example_path('hooks'))
-          .to eq("#{features_path}/hooks")
+        expect(described_class.example_path('hooks')).to eq("#{features_path}/hooks")
       end
     end
 
-    context 'with an unexisting example' do
+    context 'with an non-existent example' do
       it 'raises ArgumentError' do
-        expect { described_class.example_path('should-not-exists') }
-          .to raise_error(ArgumentError)
+        expect { described_class.example_path('should-not-exists') }.to raise_error(ArgumentError)
       end
     end
   end
 
   describe '#gherkin_examples' do
     it 'returns the list of gherkin examples' do
-      expect(described_class.gherkin_examples)
-        .to match_array(gherkin_examples)
+      expect(described_class.gherkin_examples).to match_array(gherkin_examples)
     end
   end
 
   describe '#markdown_examples' do
     it 'returns the list of markdown examples' do
-      expect(described_class.markdown_examples)
-        .to match_array(markdown_examples)
+      expect(described_class.markdown_examples).to match_array(markdown_examples)
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cucumber-compatibility-kit
 version: !ruby/object:Gem::Version
-  version: 13.0.0
+  version: 13.0.1
 platform: ruby
 authors:
 - Aurélien Reeves
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-10-09 00:00:00.000000000 Z
+date: 2023-10-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cucumber-messages
@@ -178,14 +178,17 @@ files:
 - features/unknown-parameter-type/unknown-parameter-type.feature
 - features/unknown-parameter-type/unknown-parameter-type.feature.ndjson
 - features/unknown-parameter-type/unknown-parameter-type.feature.rb
+- lib/cck/helpers.rb
+- lib/cck/keys_checker.rb
+- lib/cck/messages_comparator.rb
 - lib/cucumber-compatibility-kit.rb
+- lib/cucumber/cucumber-compatibility-kit.rb
 - lib/keys_checker.rb
 - lib/messages_comparator.rb
 - lib/shared_examples.rb
-- spec/capture_warnings.rb
-- spec/cucumber-compatibility-kit_spec.rb
-- spec/keys_checker_spec.rb
-- spec/messages_comparator_spec.rb
+- spec/cck/keys_checker_spec.rb
+- spec/cck/messages_comparator_spec.rb
+- spec/cucumber/cucumber-compatibility-kit_spec.rb
 homepage: https://github.com/cucumber/compatibility-kit
 licenses:
 - MIT
@@ -214,9 +217,8 @@ requirements: []
 rubygems_version: 3.4.10
 signing_key: 
 specification_version: 4
-summary: cucumber-compatibility-kit-13.0.0
+summary: cucumber-compatibility-kit-13.0.1
 test_files:
-- spec/capture_warnings.rb
-- spec/cucumber-compatibility-kit_spec.rb
-- spec/keys_checker_spec.rb
-- spec/messages_comparator_spec.rb
+- spec/cck/keys_checker_spec.rb
+- spec/cck/messages_comparator_spec.rb
+- spec/cucumber/cucumber-compatibility-kit_spec.rb

data/spec/capture_warnings.rb

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-# With thanks to @myronmarston
-# https://github.com/vcr/vcr/blob/master/spec/capture_warnings.rb
-
-module CaptureWarnings
-  def report_warnings(&block)
-    current_dir = Dir.pwd
-    warnings, errors = capture_error(&block).partition { |line| line.include?('warning') }
-    project_warnings, other_warnings = warnings.uniq.partition { |line| line.include?(current_dir) }
-
-    if errors.any?
-      puts errors.join("\n")
-    end
-
-    if other_warnings.any?
-      puts "#{ other_warnings.count } warnings detected, set VIEW_OTHER_WARNINGS=true to see them."
-      print_warnings('other', other_warnings) if ENV['VIEW_OTHER_WARNINGS']
-    end
-
-    # Until they fix https://bugs.ruby-lang.org/issues/10661
-    if RUBY_VERSION == '2.2.0'
-      project_warnings = project_warnings.reject { |w| w =~ /warning: possible reference to past scope/ }
-    end
-
-    if project_warnings.any?
-      puts "#{ project_warnings.count } warnings detected"
-      print_warnings('cucumber-expressions', project_warnings)
-      fail 'Please remove all cucumber-expressions warnings.'
-    end
-
-    ensure_system_exit_if_required
-  end
-
-  def capture_error(&block)
-    old_stderr = STDERR.clone
-    pipe_r, pipe_w = IO.pipe
-    pipe_r.sync    = true
-    error          = String.new
-    reader = Thread.new do
-      begin
-        loop do
-          error << pipe_r.readpartial(1024)
-        end
-      rescue EOFError
-      end
-    end
-    STDERR.reopen(pipe_w)
-    block.call
-  ensure
-    capture_system_exit
-    STDERR.reopen(old_stderr)
-    pipe_w.close
-    reader.join
-    return error.split("\n")
-  end
-
-  def print_warnings(type, warnings)
-    puts
-    puts '-' * 30 + " #{type} warnings: " + '-' * 30
-    puts
-    puts warnings.join("\n")
-    puts
-    puts '-' * 75
-    puts
-  end
-
-  def ensure_system_exit_if_required
-    raise @system_exit if @system_exit
-  end
-
-  def capture_system_exit
-    @system_exit = $ERROR_INFO
-  end
-end

data/spec/keys_checker_spec.rb

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-require 'rspec'
-require 'cucumber/messages'
-require_relative '../lib/keys_checker'
-
-describe CCK::KeysChecker do
-  let(:subject) { described_class }
-
-  describe '#compare' do
-    let(:complete) do
-      Cucumber::Messages::PickleStepArgument.new(
-        doc_string: '1',
-        data_table: '12'
-      )
-    end
-
-    let(:missing_data_table) do
-      Cucumber::Messages::PickleStepArgument.new(doc_string: '1')
-    end
-
-    let(:missing_doc_string) do
-      Cucumber::Messages::PickleStepArgument.new(data_table: '12')
-    end
-
-    let(:wrong_values) do
-      Cucumber::Messages::PickleStepArgument.new(
-        doc_string: '123',
-        data_table: '456'
-      )
-    end
-
-    it 'finds missing key' do
-      expect(subject.compare(missing_data_table, complete)).to eq(
-        ['Missing keys in message Cucumber::Messages::PickleStepArgument: [:data_table]']
-      )
-    end
-
-    it 'finds extra keys' do
-      expect(subject.compare(complete, missing_doc_string)).to eq(
-        ['Detected extra keys in message Cucumber::Messages::PickleStepArgument: [:doc_string]']
-      )
-    end
-
-    it 'finds extra and missing' do
-      expect(subject.compare(missing_doc_string, missing_data_table)).to contain_exactly(
-        'Missing keys in message Cucumber::Messages::PickleStepArgument: [:doc_string]',
-        'Detected extra keys in message Cucumber::Messages::PickleStepArgument: [:data_table]'
-      )
-    end
-
-    it 'does not care about the values' do
-      expect(subject.compare(complete, wrong_values)).to be_empty
-    end
-
-    context 'when default values are omitted' do
-      let(:default_set) do
-        Cucumber::Messages::Duration.new(
-          seconds: 0,
-          nanos: 12
-        )
-      end
-
-      let(:default_not_set) do
-        Cucumber::Messages::Duration.new(nanos: 12)
-      end
-
-      it 'does not raise an exception' do
-        expect(subject.compare(default_set, default_not_set)).to be_empty
-      end
-    end
-
-    context 'when executed as part of a CI' do
-      before { allow(ENV).to receive(:[]).with('CI').and_return(true) }
-
-      it 'ignores actual CI related messages' do
-        detected = Cucumber::Messages::Meta.new(ci: Cucumber::Messages::Ci.new(name: 'Some CI'))
-        expected = Cucumber::Messages::Meta.new
-
-        expect(subject.compare(detected, expected)).to be_empty
-      end
-    end
-
-    context 'when an unexpected error occurs' do
-      it 'does not raise error' do
-        expect { subject.compare(nil, nil) }.not_to raise_error
-      end
-
-      it 'returns the error' do
-        expect(subject.compare(nil, nil))
-          .to eq(['Unexpected error: wrong number of arguments (given 1, expected 0)'])
-      end
-    end
-  end
-end