avm-tools 0.120.2 → 0.121.2

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/fs/temp/directory_spec.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/fs/temp/directory'
-
-RSpec.describe ::EacRubyUtils::Fs::Temp::Directory do
-  describe '#remove!' do
-    let(:instance) { described_class.new }
-
-    it { expect(instance).to be_directory }
-    it { expect { instance.remove! }.not_to raise_error }
-  end
-end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/fs/temp_spec.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/fs/temp'
-
-RSpec.describe ::EacRubyUtils::Fs::Temp do
-  describe '#on_file' do
-    it do # rubocop:disable RSpec/ExampleLength, RSpec/MultipleExpectations
-      temp_path = nil
-      described_class.on_file do |path|
-        temp_path = path
-        expect(temp_path).not_to exist
-        temp_path.write('StubText')
-        expect(temp_path).to exist
-      end
-      expect(temp_path).not_to exist
-    end
-
-    it 'not fail if already removed' do # rubocop:disable RSpec/ExampleLength, RSpec/MultipleExpectations
-      temp_path = nil
-      described_class.on_file do |path|
-        temp_path = path
-        expect(temp_path).not_to exist
-        temp_path.write('StubText')
-        expect(temp_path).to exist
-        temp_path.unlink
-      end
-      expect(temp_path).not_to exist
-    end
-  end
-
-  describe '#on_directory' do
-    it do # rubocop:disable RSpec/ExampleLength, RSpec/MultipleExpectations
-      temp_path = nil
-      described_class.on_directory do |path|
-        temp_path = path
-        expect(temp_path).to be_directory
-      end
-      expect(temp_path).not_to exist
-    end
-
-    it 'not fail if already removed' do # rubocop:disable RSpec/ExampleLength, RSpec/MultipleExpectations
-      temp_path = nil
-      described_class.on_directory do |path|
-        temp_path = path
-        expect(temp_path).to be_directory
-        temp_path.rmtree
-        expect(temp_path).not_to exist
-      end
-      expect(temp_path).not_to exist
-    end
-  end
-end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/inflector_spec.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/inflector'
-
-RSpec.describe ::EacRubyUtils::Inflector do
-  describe '#variableize' do
-    {
-      '_A_variableName' => 'a_variablename',
-      'àéíöũ' => 'aeiou'
-    }.each do |source, expected|
-      context "when source is \"#{source}\"" do
-        it { expect(described_class.variableize(source)).to eq(expected) }
-      end
-    end
-  end
-end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/listable_spec.rb

@@ -1,275 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/listable'
-
-RSpec.describe ::EacRubyUtils::Listable do
-  let(:stub_class) do
-    the_described_class = described_class
-    ::Class.new do
-      class << self
-        def name
-          'Stub'
-        end
-      end
-
-      include the_described_class
-
-      attr_accessor :inteiro, :code, :cadeia, :type
-
-      lists.add_integer :inteiro, :a, :b, :c
-      lists.add_integer :code, 7 => :a, 13 => :b
-      lists.add_string :cadeia, :a, :b, :c
-      lists.add_string :type, 'Namespace::ClazzA' => :a, 'Namespace::ClazzB' => :b
-      lists.add_symbol :simbolo, :a, :b, :c
-      lists.add_symbol :tipado, :tipo_aaa => :a, 'tipo_bbb' => :b
-    end
-  end
-
-  describe 'attribute values' do
-    it { expect(stub_class.lists.inteiro.values).to eq([1, 2, 3]) }
-    it { expect(stub_class.lists.code.values).to eq([7, 13]) }
-    it { expect(stub_class.lists.cadeia.values).to eq(%w[a b c]) }
-    it { expect(stub_class.lists.type.values).to eq(%w[Namespace::ClazzA Namespace::ClazzB]) }
-    it { expect(stub_class.lists.simbolo.values).to eq(%i[a b c]) }
-    it { expect(stub_class.lists.tipado.values).to eq(%i[tipo_aaa tipo_bbb]) }
-  end
-
-  describe 'value instance options' do
-    it {
-      expect(stub_class.lists.inteiro.options)
-        .to eq([['Inteiro A', 1], ['Inteiro BB', 2], ['Inteiro CCC', 3]])
-    }
-
-    it {
-      expect(stub_class.lists.code.options)
-        .to eq([['Código A', 7], ['Código B', 13]])
-    }
-
-    it {
-      expect(stub_class.lists.cadeia.options)
-        .to eq([['Cadeia AAA', 'a'], ['Cadeia BB', 'b'], ['Cadeia C', 'c']])
-    }
-
-    it {
-      expect(stub_class.lists.type.options)
-        .to eq([['Tipo A', 'Namespace::ClazzA'], ['Tipo B', 'Namespace::ClazzB']])
-    }
-
-    it {
-      expect(stub_class.lists.simbolo.options)
-        .to eq([['Simbolo A', :a], ['Simbolo B', :b], ['Simbolo C', :c]])
-    }
-
-    it {
-      expect(stub_class.lists.tipado.options)
-        .to eq([['Tipado A', :tipo_aaa], ['Tipado B', :tipo_bbb]])
-    }
-  end
-
-  describe 'constants' do
-    it { expect(stub_class::INTEIRO_A).to eq(1) }
-    it { expect(stub_class::INTEIRO_B).to eq(2) }
-    it { expect(stub_class::INTEIRO_C).to eq(3) }
-    it { expect(stub_class::CODE_A).to eq(7) }
-    it { expect(stub_class::CODE_B).to eq(13) }
-    it { expect(stub_class::CADEIA_A).to eq('a') }
-    it { expect(stub_class::CADEIA_C).to eq('c') }
-    it { expect(stub_class::TYPE_A).to eq('Namespace::ClazzA') }
-    it { expect(stub_class::TYPE_B).to eq('Namespace::ClazzB') }
-    it { expect(stub_class::SIMBOLO_A).to eq(:a) }
-    it { expect(stub_class::SIMBOLO_B).to eq(:b) }
-    it { expect(stub_class::SIMBOLO_C).to eq(:c) }
-    it { expect(stub_class::TIPADO_A).to eq(:tipo_aaa) }
-    it { expect(stub_class::TIPADO_B).to eq(:tipo_bbb) }
-  end
-
-  describe 'values instances' do
-    it { expect(stub_class.lists.is_a?(::EacRubyUtils::Listable::Lists)).to eq(true) }
-
-    it {
-      expect(stub_class.lists.inteiro.value_a.is_a?(::EacRubyUtils::Listable::Value))
-        .to eq(true)
-    }
-
-    it {
-      expect(stub_class.lists.inteiro.value_b.is_a?(::EacRubyUtils::Listable::Value))
-        .to eq(true)
-    }
-
-    it {
-      expect(stub_class.lists.inteiro.value_c.is_a?(::EacRubyUtils::Listable::Value))
-        .to eq(true)
-    }
-
-    it {
-      expect(stub_class.lists.code.value_a.is_a?(::EacRubyUtils::Listable::Value))
-        .to eq(true)
-    }
-
-    it {
-      expect(stub_class.lists.code.value_b.is_a?(::EacRubyUtils::Listable::Value))
-        .to eq(true)
-    }
-
-    it {
-      expect(stub_class.lists.cadeia.value_a.is_a?(::EacRubyUtils::Listable::Value))
-        .to eq(true)
-    }
-
-    it {
-      expect(stub_class.lists.cadeia.value_b.is_a?(::EacRubyUtils::Listable::Value))
-        .to eq(true)
-    }
-
-    it {
-      expect(stub_class.lists.cadeia.value_c.is_a?(::EacRubyUtils::Listable::Value))
-        .to eq(true)
-    }
-
-    it {
-      expect(stub_class.lists.type.value_a.is_a?(::EacRubyUtils::Listable::Value))
-        .to eq(true)
-    }
-
-    it {
-      expect(stub_class.lists.type.value_b.is_a?(::EacRubyUtils::Listable::Value))
-        .to eq(true)
-    }
-  end
-
-  describe 'value instance label' do
-    it { expect(stub_class.lists.inteiro.value_a.label).to eq('Inteiro A') }
-    it { expect(stub_class.lists.inteiro.value_b.label).to eq('Inteiro BB') }
-    it { expect(stub_class.lists.inteiro.value_c.label).to eq('Inteiro CCC') }
-    it { expect(stub_class.lists.code.value_a.label).to eq('Código A') }
-    it { expect(stub_class.lists.code.value_b.label).to eq('Código B') }
-    it { expect(stub_class.lists.cadeia.value_a.label).to eq('Cadeia AAA') }
-    it { expect(stub_class.lists.cadeia.value_b.label).to eq('Cadeia BB') }
-    it { expect(stub_class.lists.cadeia.value_c.label).to eq('Cadeia C') }
-    it { expect(stub_class.lists.type.value_a.label).to eq('Tipo A') }
-    it { expect(stub_class.lists.type.value_b.label).to eq('Tipo B') }
-  end
-
-  describe 'value instance description' do
-    it { expect(stub_class.lists.inteiro.value_a.description).to eq('Inteiro A Descr.') }
-    it { expect(stub_class.lists.inteiro.value_b.description).to eq('Inteiro BB Descr.') }
-    it { expect(stub_class.lists.inteiro.value_c.description).to eq('Inteiro CCC Descr.') }
-    it { expect(stub_class.lists.code.value_a.description).to eq('Código A Descr.') }
-    it { expect(stub_class.lists.code.value_b.description).to eq('Código B Descr.') }
-    it { expect(stub_class.lists.cadeia.value_a.description).to eq('Cadeia AAA Descr.') }
-    it { expect(stub_class.lists.cadeia.value_b.description).to eq('Cadeia BB Descr.') }
-    it { expect(stub_class.lists.cadeia.value_c.description).to eq('Cadeia C Descr.') }
-    it { expect(stub_class.lists.type.value_a.description).to eq('Tipo A Descr.') }
-    it { expect(stub_class.lists.type.value_b.description).to eq('Tipo B Descr.') }
-  end
-
-  describe 'value instance constant name' do
-    it { expect(stub_class.lists.inteiro.value_a.constant_name).to eq('INTEIRO_A') }
-    it { expect(stub_class.lists.inteiro.value_b.constant_name).to eq('INTEIRO_B') }
-    it { expect(stub_class.lists.inteiro.value_c.constant_name).to eq('INTEIRO_C') }
-    it { expect(stub_class.lists.code.value_a.constant_name).to eq('CODE_A') }
-    it { expect(stub_class.lists.code.value_b.constant_name).to eq('CODE_B') }
-    it { expect(stub_class.lists.cadeia.value_a.constant_name).to eq('CADEIA_A') }
-    it { expect(stub_class.lists.cadeia.value_b.constant_name).to eq('CADEIA_B') }
-    it { expect(stub_class.lists.cadeia.value_c.constant_name).to eq('CADEIA_C') }
-    it { expect(stub_class.lists.type.value_a.constant_name).to eq('TYPE_A') }
-    it { expect(stub_class.lists.type.value_b.constant_name).to eq('TYPE_B') }
-  end
-
-  describe 'instance label and descriptions' do
-    let(:instance) { stub_class.new }
-
-    context 'when inteiro value is A' do
-      before { instance.inteiro = stub_class::INTEIRO_A }
-
-      it { expect(instance.inteiro_label).to eq('Inteiro A') }
-      it { expect(instance.inteiro_description).to eq('Inteiro A Descr.') }
-    end
-
-    context 'when inteiro value is B' do
-      before { instance.inteiro = stub_class::INTEIRO_B }
-
-      it { expect(instance.inteiro_label).to eq('Inteiro BB') }
-      it { expect(instance.inteiro_description).to eq('Inteiro BB Descr.') }
-    end
-
-    context 'when inteiro value is C' do
-      before { instance.inteiro = stub_class::INTEIRO_C }
-
-      it { expect(instance.inteiro_label).to eq('Inteiro CCC') }
-      it { expect(instance.inteiro_description).to eq('Inteiro CCC Descr.') }
-    end
-
-    context 'when inteiro value is blank' do
-      before { instance.inteiro = nil }
-
-      it { expect(instance.inteiro_label).to eq('Inteiro em branco') }
-      it { expect(instance.inteiro_description).to eq('Inteiro em branco Descr.') }
-    end
-
-    context 'when code value is A' do
-      before { instance.code = stub_class::CODE_A }
-
-      it { expect(instance.code_label).to eq('Código A') }
-      it { expect(instance.code_description).to eq('Código A Descr.') }
-    end
-
-    context 'when code value is B' do
-      before { instance.code = stub_class::CODE_B }
-
-      it { expect(instance.code_label).to eq('Código B') }
-      it { expect(instance.code_description).to eq('Código B Descr.') }
-    end
-
-    context 'when code value is blank' do
-      before { instance.code = nil }
-
-      it { expect(instance.code_label).to eq('') }
-      it { expect(instance.code_description).to eq('') }
-    end
-
-    context 'when cadeia value is A' do
-      before { instance.cadeia = stub_class::CADEIA_A }
-
-      it { expect(instance.cadeia_label).to eq('Cadeia AAA') }
-      it { expect(instance.cadeia_description).to eq('Cadeia AAA Descr.') }
-    end
-
-    context 'when cadeia value is B' do
-      before { instance.cadeia = stub_class::CADEIA_B }
-
-      it { expect(instance.cadeia_label).to eq('Cadeia BB') }
-      it { expect(instance.cadeia_description).to eq('Cadeia BB Descr.') }
-    end
-
-    context 'when cadeia value is C' do
-      before { instance.cadeia = stub_class::CADEIA_C }
-
-      it { expect(instance.cadeia_label).to eq('Cadeia C') }
-      it { expect(instance.cadeia_description).to eq('Cadeia C Descr.') }
-    end
-
-    context 'when type value is A' do
-      before { instance.type = stub_class::TYPE_A }
-
-      it { expect(instance.type_label).to eq('Tipo A') }
-      it { expect(instance.type_description).to eq('Tipo A Descr.') }
-    end
-
-    context 'when type value is B' do
-      before { instance.type = stub_class::TYPE_B }
-
-      it { expect(instance.type_label).to eq('Tipo B') }
-      it { expect(instance.type_description).to eq('Tipo B Descr.') }
-    end
-  end
-
-  describe '#value_validate!' do
-    it { expect { stub_class.lists.inteiro.value_validate!(1) }.not_to raise_error }
-    it { expect { stub_class.lists.inteiro.value_validate!('1') }.to raise_error(::StandardError) }
-    it { expect { stub_class.lists.inteiro.value_validate!(10) }.to raise_error(::StandardError) }
-    it { expect { stub_class.lists.cadeia.value_validate!(:a) }.to raise_error(::StandardError)  }
-    it { expect { stub_class.lists.cadeia.value_validate!('a') }.not_to raise_error }
-    it { expect { stub_class.lists.cadeia.value_validate!(:z) }.to raise_error(::StandardError) }
-  end
-end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/local_time_zone_spec.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/local_time_zone'
-
-RSpec.describe(::EacRubyUtils::LocalTimeZone) do
-  describe '#auto' do
-    context 'when TZ environment variable is set' do
-      let(:expected_time_zone) { 'America/Sao_Paulo' }
-
-      before do
-        ENV['TZ'] = expected_time_zone
-      end
-
-      it { expect(described_class.auto).to eq(expected_time_zone) }
-    end
-  end
-end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/method_class_spec.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/method_class'
-
-::RSpec.describe ::EacRubyUtils::MethodClass do
-  let(:sender_class) do
-    ::Class.new do
-      attr_accessor :sender_value
-
-      def initialize(sender_value)
-        self.sender_value = sender_value
-      end
-    end
-  end
-
-  let(:method_class) do
-    the_described_class = described_class
-    ::Class.new do
-      def self.name
-        'TheSender::PerformX'
-      end
-
-      include the_described_class
-      attr_accessor :sender, :method_param
-
-      def initialize(sender, method_param)
-        self.sender = sender
-        self.method_param = method_param
-      end
-
-      def result
-        "#{sender.sender_value},#{method_param}"
-      end
-    end
-  end
-
-  let(:sender_instance) { sender_class.new('AAA') }
-
-  before do
-    ::Object.const_set('TheSender', sender_class)
-    sender_class.const_set('PerformX', method_class)
-  end
-
-  it { expect(sender_instance).to respond_to(:perform_x) }
-  it { expect(sender_instance.perform_x('BBB')).to eq('AAA,BBB') }
-end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/options_consumer_spec.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/options_consumer'
-
-RSpec.describe ::EacRubyUtils::OptionsConsumer do
-  context 'with instance created with some data' do
-    subject(:instance) { described_class.new(a: 'a_value', b: 'b_value', c: 'c_value') }
-
-    let(:consumed_a) { instance.consume(:a) }
-    let(:consumed_b) { instance.consume(:b) }
-    let(:consumed_c) { instance.consume(:c) }
-
-    it 'left data should be Hash' do
-      expect(instance.left_data).to be_a(::Hash)
-    end
-
-    it 'left data should be not empty' do
-      expect { instance.validate }.to raise_error(::StandardError)
-    end
-
-    context 'when no data is consumed' do
-      it do
-        expect(instance.left_data).to eq({ a: 'a_value', b: 'b_value', c: 'c_value' }
-          .with_indifferent_access)
-      end
-
-      it { expect(consumed_a).to eq('a_value') }
-    end
-
-    context 'when A value is consumed' do
-      before { consumed_a }
-
-      it do
-        expect(instance.left_data).to eq({ b: 'b_value', c: 'c_value' }.with_indifferent_access)
-      end
-
-      it { expect(instance.consume(:c)).to eq('c_value') }
-    end
-
-    context 'when A and C values are consumed' do
-      before do
-        consumed_a
-        consumed_c
-      end
-
-      it { expect(instance.left_data).to eq({ b: 'b_value' }.with_indifferent_access) }
-
-      it { expect(consumed_b).to eq('b_value') }
-    end
-
-    context 'when all values are consumed' do
-      before do
-        consumed_a
-        consumed_b
-        consumed_c
-      end
-
-      it { expect(instance.left_data).to eq({}.with_indifferent_access) }
-
-      it do
-        expect { instance.validate }.not_to raise_error
-      end
-    end
-
-    it 'raises if validate has left data' do
-      expect(instance.left_data.empty?).to eq(false)
-    end
-  end
-
-  describe '#consume_all' do
-    subject(:instance) { described_class.new(a: 'a_value', b: 'b_value', c: 'c_value') }
-
-    let(:all_consumed) { instance.consume_all(:a, :b, :c, :d) }
-
-    it { expect(all_consumed[0]).to eq('a_value') }
-    it { expect(all_consumed[1]).to eq('b_value') }
-    it { expect(all_consumed[2]).to eq('c_value') }
-    it { expect(all_consumed[3]).to eq(nil) }
-  end
-end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/class/abstract_spec.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/patches/class/abstract'
-
-RSpec.describe ::Class do
-  let(:abstract_class) do
-    described_class.new do
-      enable_abstract_methods
-    end
-  end
-
-  let(:concrect_class) do
-    described_class.new(abstract_class)
-  end
-
-  describe '#abstract' do
-    it do
-      expect(abstract_class).to be_abstract
-    end
-
-    it do
-      expect(concrect_class).not_to be_abstract
-    end
-  end
-end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/class/self_included_modules_spec.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/patches/class/self_included_modules'
-
-RSpec.describe ::Class do
-  let(:includeable_module) do
-    ::Module.new
-  end
-
-  let(:parent_class) do
-    module_to_include = includeable_module
-    described_class.new do
-      include module_to_include
-    end
-  end
-
-  let(:child_class) do
-    described_class.new(parent_class)
-  end
-
-  describe '#self_included_modules' do
-    it do
-      expect(parent_class.self_included_modules).to include(includeable_module)
-    end
-
-    it do
-      expect(child_class.self_included_modules).not_to include(includeable_module)
-    end
-  end
-end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/enumerable/boolean_combinations_spec.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/patches/enumerable/boolean_combinations'
-
-RSpec.describe ::Enumerable do
-  let(:empty_instance) { [].to_enum }
-  let(:a_instance) { [:a].to_enum }
-  let(:ab_instance) { %i[a b].to_enum }
-
-  describe '#bool_hash_combs' do
-    it do
-      expect(empty_instance.bool_hash_combs).to eq([])
-    end
-
-    it do
-      expect(a_instance.bool_hash_combs).to eq([{ a: false }, { a: true }])
-    end
-
-    it do
-      expect(ab_instance.bool_hash_combs)
-        .to eq([{ a: false, b: false }, { a: false, b: true }, { a: true, b: false },
-                { a: true, b: true }])
-    end
-  end
-
-  describe '#bool_array_combs' do
-    it do
-      expect(empty_instance.bool_array_combs).to eq([])
-    end
-
-    it do
-      expect(a_instance.bool_array_combs).to eq([[], [:a]])
-    end
-
-    it do
-      expect(ab_instance.bool_array_combs).to eq([[], [:a], [:b], %i[a b]])
-    end
-  end
-end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/enumerator/current_spec.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/patches/enumerator/current'
-
-RSpec.describe ::Enumerator do
-  let(:list) { %w[a b] }
-  let(:instance) { list.each }
-
-  it { expect(instance).to be_a(described_class) }
-  it { expect(instance.current).to eq('a') }
-
-  context 'with first next' do
-    before { instance.next }
-
-    it { expect(instance.current).to eq('b') }
-  end
-
-  context 'with last next' do
-    before do
-      instance.next
-      instance.next
-    end
-
-    it { expect(instance.current).to eq(nil) }
-  end
-end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/enumerator/stopped_spec.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/patches/enumerator/stopped'
-
-RSpec.describe ::Enumerator do
-  let(:list) { %w[a b] }
-  let(:instance) { list.each }
-
-  it { expect(instance).to be_a(described_class) }
-  it { expect(instance.peek).to eq('a') }
-  it { expect(instance).to be_ongoing }
-  it { expect(instance).not_to be_stopped }
-
-  context 'with first next' do
-    before { instance.next }
-
-    it { expect(instance.peek).to eq('b') }
-    it { expect(instance).to be_ongoing }
-    it { expect(instance).not_to be_stopped }
-  end
-
-  context 'with last next' do
-    before do
-      instance.next
-      instance.next
-    end
-
-    it { expect { instance.peek }.to raise_error(::StopIteration) }
-    it { expect(instance).not_to be_ongoing }
-    it { expect(instance).to be_stopped }
-  end
-end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/hash/options_consumer_spec.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/patches/hash/options_consumer'
-
-RSpec.describe ::Hash do
-  let(:a_hash) { { a: 'a_value', b: 'b_value', c: 'c_value' } }
-  let(:instance) { a_hash.to_options_consumer }
-
-  it 'returns a OptionsConsumer' do
-    expect(instance).to be_a(::EacRubyUtils::OptionsConsumer)
-  end
-
-  it do
-    expect(instance.left_data).to eq({ a: 'a_value', b: 'b_value', c: 'c_value' }
-      .with_indifferent_access)
-  end
-end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/hash/sym_keys_hash_spec.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/patches/hash/sym_keys_hash'
-
-RSpec.describe ::Hash do
-  let(:a_hash) { { 'a' => 'a_value', 1 => '1_value', s: 's_value' } }
-
-  describe '#to_sym_keys_hash' do
-    it 'converts all keys to symbols' do
-      expect(a_hash.to_sym_keys_hash).to eq(a: 'a_value', '1': '1_value', s: 's_value')
-    end
-  end
-end