cucumber-messages 22.0.0 → 27.2.0

data/spec/capture_warnings.rb

@@ -1,74 +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 = $!
-  end
-end

data/spec/cucumber/messages/acceptance_spec.rb

@@ -1,33 +0,0 @@
-require 'json'
-require 'cucumber/messages'
-require 'cucumber-compatibility-kit'
-
-module Cucumber
-  module Messages
-    describe 'messages acdeptance tests' do
-      ndjson_files = Dir["#{Cucumber::CompatibilityKit::examples_path}/**/*.ndjson"]
-
-      it 'must have ndjson_files as reference messages' do
-        expect(ndjson_files).not_to be_empty
-      end
-
-      ndjson_files.each do |ndjson_file|
-        it "deserialises and serialises messages in #{ndjson_file}" do
-          File.open(ndjson_file, 'r:utf-8') do |io|
-            io.each_line do |json|
-              check(json)
-            end
-          end
-        end
-      end
-
-      def check(json)
-        hash = JSON.parse(json)
-        envelope = Envelope.from_json(json)
-        new_json = envelope.to_json
-        new_hash = JSON.parse(new_json)
-        expect(new_hash).to eq(hash)
-      end
-    end
-  end
-end

data/spec/cucumber/messages/id_generator_spec.rb

@@ -1,29 +0,0 @@
-require 'rspec'
-require 'cucumber/messages'
-
-describe Cucumber::Messages::IdGenerator::Incrementing do
-  subject { Cucumber::Messages::IdGenerator::Incrementing.new }
-
-  context '#new_id' do
-    it 'returns 0 the first time' do
-      expect(subject.new_id).to eq("0")
-    end
-
-    it 'increments on every call' do
-      expect(subject.new_id).to eq("0")
-      expect(subject.new_id).to eq("1")
-      expect(subject.new_id).to eq("2")
-    end
-  end
-end
-
-describe Cucumber::Messages::IdGenerator::UUID do
-  subject { Cucumber::Messages::IdGenerator::UUID.new }
-
-  context '#new_id' do
-    it 'generates a UUID' do
-      allowed_characters = "[0-9a-fA-F]"
-      expect(subject.new_id).to match(/#{allowed_characters}{8}\-#{allowed_characters}{4}\-#{allowed_characters}{4}\-#{allowed_characters}{4}\-#{allowed_characters}{12}/)
-    end
-  end
-end

data/spec/cucumber/messages/message/deserialization_spec.rb

@@ -1,30 +0,0 @@
-require 'rspec'
-require 'cucumber/messages/message/dummy_messages'
-
-describe Cucumber::Messages::Message::Deserialization do
-  describe '#from_json' do
-    subject { Cucumber::Messages::Message.from_json(json_document) }
-
-    let(:json_document) { '' }
-
-    context 'with a valid JSON document' do
-      let(:json_document) { '{"simpleMessage":{"isString":"answer"}}' }
-
-      it 'deserialize the message using #from_h' do
-        allow(Cucumber::Messages::Message).to receive(:from_h)
-
-        subject
-
-        expect(Cucumber::Messages::Message)
-          .to have_received(:from_h)
-          .with({ simpleMessage: { isString: "answer" } })
-      end
-    end
-
-    context 'with an invalid JSON document' do
-      let(:json_document) { '{foo: bar}' }
-
-      it { expect { subject }.to raise_error(JSON::ParserError) }
-    end
-  end
-end

data/spec/cucumber/messages/message/dummy_messages.rb

@@ -1,38 +0,0 @@
-require 'cucumber/messages/message'
-
-module Cucumber::Messages
-  class SimpleMessage < Message
-    attr_reader :is_nil, :is_string, :is_array, :is_number
-
-    def initialize(is_nil: nil, is_string: '', is_array: [], is_number: 0)
-      @is_nil = is_nil
-      @is_string = is_string
-      @is_array = is_array
-      @is_number = is_number
-    end
-  end
-
-  class EnumMessage
-    ENUM = 'an enum'
-  end
-
-  class ComprehensiveMessage < Message
-    attr_reader :simple_message, :message_array, :is_enum
-
-    def initialize(
-      simple_message: SimpleMessage.new,
-      message_array: [SimpleMessage.new, SimpleMessage.new],
-      is_enum: EnumMessage::ENUM
-    )
-      @simple_message = simple_message
-      @message_array = message_array
-      @is_enum = is_enum
-    end
-
-    private
-
-    def self.message_array_from_h(hash)
-      SimpleMessage.from_h(hash)
-    end
-  end
-end

data/spec/cucumber/messages/message/serialization_spec.rb

@@ -1,89 +0,0 @@
-require 'rspec'
-require 'cucumber/messages/message/dummy_messages'
-
-describe Cucumber::Messages::Message::Serialization do
-  context 'with a simple message' do
-    describe '#to_h' do
-      subject { Cucumber::Messages::SimpleMessage.new.to_h }
-
-      it 'returns a Hash with all the attributes of the Message' do
-        expect(subject).to eq({ is_nil: nil, is_string: '', is_array: [], is_number: 0 })
-      end
-
-      context 'whith camelize: true' do
-        subject { Cucumber::Messages::SimpleMessage.new.to_h(camelize: true) }
-
-        it 'camelize the keys of the resulting hash' do
-          expect(subject).to eq({ isNil: nil, isString: '', isArray: [], isNumber: 0 })
-        end
-      end
-
-      context 'with reject_nil_values: true' do
-        subject { Cucumber::Messages::SimpleMessage.new.to_h(reject_nil_values: true) }
-
-        it 'rejects nil values from the resulting hash' do
-          expect(subject).to eq({ is_string: '', is_array: [], is_number: 0 })
-        end
-      end
-    end
-
-    describe '#to_json' do
-      subject { Cucumber::Messages::SimpleMessage.new.to_json }
-
-      it 'returns a JSON document with all the attributes of the Message except nil values' do
-        expect(subject).to eq({ isString: '', isArray: [], isNumber: 0 }.to_json)
-      end
-    end
-  end
-
-  context 'with a message which embeds other messages' do
-    describe '#to_h' do
-      subject { Cucumber::Messages::ComprehensiveMessage.new.to_h }
-
-      it 'includes hash representation of embedded messages' do
-        expect(subject[:simple_message]).to eq({ is_nil: nil, is_string: '', is_array: [], is_number: 0 })
-        expect(subject[:is_enum]).to eq 'an enum'
-      end
-
-      it 'includes hash representation of messages arrays' do
-        expect(subject[:message_array]).to eq([
-          { is_nil: nil, is_string: '', is_array: [], is_number: 0 },
-          { is_nil: nil, is_string: '', is_array: [], is_number: 0 }
-        ])
-      end
-
-      context 'whith camelize: true' do
-        subject { Cucumber::Messages::ComprehensiveMessage.new.to_h(camelize: true) }
-
-        it 'camelize the keys of the embedded messages resulting hashes' do
-          expect(subject[:simpleMessage]).to eq({ isNil: nil, isString: '', isArray: [], isNumber: 0 })
-        end
-
-        it 'camelize the keys of hashes for messages arrays' do
-          expect(subject[:messageArray]).to eq([
-            { isNil: nil, isString: '', isArray: [], isNumber: 0 },
-            { isNil: nil, isString: '', isArray: [], isNumber: 0 }
-          ])
-        end
-      end
-    end
-
-    describe '#to_json' do
-      subject { Cucumber::Messages::ComprehensiveMessage.new.to_json }
-
-      it 'returns a JSON document with embedded messages' do
-        expect(subject).to include({ isString: '', isArray: [], isNumber: 0}.to_json)
-        expect(subject).to include('"isEnum":"an enum"')
-      end
-
-      it 'returns a JSON document with messages arrays' do
-        expect(subject).to include(
-          [
-            { isString: '', isArray: [], isNumber: 0},
-            { isString: '', isArray: [], isNumber: 0}
-          ].to_json
-        )
-      end
-    end
-  end
-end

data/spec/cucumber/messages/message/utils_spec.rb

@@ -1,30 +0,0 @@
-require 'rspec'
-require 'cucumber/messages/message/utils'
-
-class DummyTestClass
-  include Cucumber::Messages::Message::Utils
-end
-
-describe Cucumber::Messages::Message::Utils do
-  subject { DummyTestClass }
-
-  describe '#underscore' do
-    it { expect(subject.underscore('test')).to eq 'test' }
-    it { expect(subject.underscore('testTest')).to eq 'test_test' }
-    it { expect(subject.underscore('')).to eq '' }
-    it { expect(subject.underscore('T')).to eq 't' }
-    it { expect(subject.underscore('test123test456Test')).to eq 'test123test456_test' }
-    it { expect(subject.underscore('test-test')).to eq 'test_test' }
-    it { expect(subject.underscore('TEST_Test')).to eq 'test_test' }
-    it { expect(subject.underscore('test-Test')).to eq 'test_test' }
-  end
-
-  describe '#camelize' do
-    it { expect(subject.camelize('test')).to eq 'test' }
-    it { expect(subject.camelize('test_test')).to eq 'testTest' }
-    it { expect(subject.camelize('Test_TeSt')).to eq 'TestTest' }
-    it { expect(subject.camelize('')).to eq '' }
-    it { expect(subject.camelize('test123test4_5_6_test')).to eq 'test123test456Test' }
-    it { expect(subject.camelize('test-test')).to eq 'test-test' }
-  end
-end

data/spec/cucumber/messages/ndjson_serialization_spec.rb

@@ -1,56 +0,0 @@
-require 'cucumber/messages'
-
-module Cucumber
-  module Messages
-    describe 'messages' do
-      let(:outgoing_messages) do
-        [
-          Envelope.new(
-            source: Source.new(data: 'Feature: Hello')
-          ),
-          Envelope.new(
-            attachment: Attachment.new(body: 'Hello', content_encoding: AttachmentContentEncoding::IDENTITY)
-          )
-        ]
-      end
-
-      it "can be serialised over an ndjson stream" do
-        io = StringIO.new
-        write_outgoing_messages(outgoing_messages, io)
-
-        io.rewind
-        incoming_messages = NdjsonToMessageEnumerator.new(io)
-
-        expect(incoming_messages.to_a.map(&:to_h)).to(eq(outgoing_messages.map(&:to_h)))
-      end
-
-      it "ignores empty lines" do
-        io = StringIO.new
-        write_outgoing_messages(outgoing_messages, io)
-        io.write("\n\n")
-
-        io.rewind
-        incoming_messages = NdjsonToMessageEnumerator.new(io)
-
-        expect(incoming_messages.to_a.map(&:to_h)).to(eq(outgoing_messages.map(&:to_h)))
-      end
-
-      it "includes offending line in error message" do
-        io = StringIO.new
-        io.puts('BLA BLA')
-
-        io.rewind
-        incoming_messages = NdjsonToMessageEnumerator.new(io)
-
-        expect { incoming_messages.to_a }.to(raise_error('Not JSON: BLA BLA'))
-      end
-
-      def write_outgoing_messages(messages, out)
-        messages.each do |message|
-          out.write(message.to_json)
-          out.write("\n")
-        end
-      end
-    end
-  end
-end

data/spec/cucumber/messages/time_conversion_spec.rb

@@ -1,41 +0,0 @@
-require 'cucumber/messages'
-
-module Cucumber
-  module Messages
-    describe TimeConversion do
-      include TimeConversion
-
-      it 'converts to and from milliseconds since epoch' do
-        time = Time.now
-        timestamp = time_to_timestamp(time)
-        time_again = timestamp_to_time(timestamp)
-
-        expect(time).to be_within(0.000001).of(time_again)
-      end
-
-      it 'converts to and from seconds duration' do
-        duration_in_seconds = 1234
-        duration = seconds_to_duration(duration_in_seconds)
-        duration_in_seconds_again = duration_to_seconds(duration)
-
-        expect(duration_in_seconds_again).to eq(duration_in_seconds)
-      end
-
-      it 'converts to and from seconds duration (with decimal places)' do
-        duration_in_seconds = 3.000161
-        duration = seconds_to_duration(duration_in_seconds)
-        duration_in_seconds_again = duration_to_seconds(duration)
-
-        expect(duration_in_seconds_again).to be_within(0.000000001).of(duration_in_seconds)
-      end
-
-      it 'converts to a hash where seconds and nanos are integers' do
-        duration_in_seconds = 3.000161
-        duration = seconds_to_duration(duration_in_seconds)
-
-        expect(duration['seconds']).to be_integer
-        expect(duration['nanos']).to be_integer
-      end
-    end
-  end
-end

data/spec/cucumber/messages/version_spec.rb

@@ -1,11 +0,0 @@
-require 'cucumber/messages'
-
-module Cucumber
-  module Messages
-    describe VERSION do
-      it 'should be defined' do
-        expect(subject).to match(/\d+\.\d+\.\d+/)
-      end
-    end
-  end
-end