eac_tools 0.97.0 → 0.97.2

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

@@ -0,0 +1,52 @@
+# 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

@@ -0,0 +1,16 @@
+# 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

@@ -0,0 +1,225 @@
+# 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 be(true) }
+
+    it {
+      expect(stub_class.lists.inteiro.value_a.is_a?(EacRubyUtils::Listable::Item))
+        .to be(true)
+    }
+
+    it {
+      expect(stub_class.lists.inteiro.value_b.is_a?(EacRubyUtils::Listable::Item))
+        .to be(true)
+    }
+
+    it {
+      expect(stub_class.lists.inteiro.value_c.is_a?(EacRubyUtils::Listable::Item))
+        .to be(true)
+    }
+
+    it {
+      expect(stub_class.lists.code.value_a.is_a?(EacRubyUtils::Listable::Item))
+        .to be(true)
+    }
+
+    it {
+      expect(stub_class.lists.code.value_b.is_a?(EacRubyUtils::Listable::Item))
+        .to be(true)
+    }
+
+    it {
+      expect(stub_class.lists.cadeia.value_a.is_a?(EacRubyUtils::Listable::Item))
+        .to be(true)
+    }
+
+    it {
+      expect(stub_class.lists.cadeia.value_b.is_a?(EacRubyUtils::Listable::Item))
+        .to be(true)
+    }
+
+    it {
+      expect(stub_class.lists.cadeia.value_c.is_a?(EacRubyUtils::Listable::Item))
+        .to be(true)
+    }
+
+    it {
+      expect(stub_class.lists.type.value_a.is_a?(EacRubyUtils::Listable::Item))
+        .to be(true)
+    }
+
+    it {
+      expect(stub_class.lists.type.value_b.is_a?(EacRubyUtils::Listable::Item))
+        .to be(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 }
+
+    {
+      inteiro: {
+        INTEIRO_A: ['Inteiro A', 'Inteiro A Descr.'],
+        INTEIRO_B: ['Inteiro BB', 'Inteiro BB Descr.'],
+        INTEIRO_C: ['Inteiro CCC', 'Inteiro CCC Descr.'],
+        nil => ['Inteiro em branco', 'Inteiro em branco Descr.']
+      },
+      code: {
+        CODE_A: ['Código A', 'Código A Descr.'],
+        CODE_B: ['Código B', 'Código B Descr.'],
+        nil => ['', '']
+      },
+      cadeia: {
+        CADEIA_A: ['Cadeia AAA', 'Cadeia AAA Descr.'],
+        CADEIA_B: ['Cadeia BB', 'Cadeia BB Descr.'],
+        CADEIA_C: ['Cadeia C', 'Cadeia C Descr.']
+      },
+      type: {
+        TYPE_A: ['Tipo A', 'Tipo A Descr.'],
+        TYPE_B: ['Tipo B', 'Tipo B Descr.']
+      }
+    }.each do |attr, attr_values|
+      attr_values.each do |attr_value_const, expected_values|
+        context "when #{attr} value is #{attr_value_const}" do
+          let(:attr_value) { attr_value_const ? stub_class.const_get(attr_value_const) : nil }
+
+          before { instance.send("#{attr}=", attr_value) }
+
+          it { expect(instance.send("#{attr}_label")).to eq(expected_values[0]) }
+          it { expect(instance.send("#{attr}_description")).to eq(expected_values[1]) }
+        end
+      end
+    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

@@ -0,0 +1,17 @@
+# 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

@@ -0,0 +1,46 @@
+# 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/module_ancestors_variable/hash_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/module_ancestors_variable/hash'
+
+RSpec.describe(EacRubyUtils::ModuleAncestorsVariable::Hash) do
+  let(:included_module) do
+    Module.new do
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods # rubocop:disable Lint/ConstantDefinitionInBlock, RSpec/LeakyConstantDeclaration
+        def hash_variable
+          @hash_variable ||= ::EacRubyUtils::ModuleAncestorsVariable::Hash.new(self, __method__)
+        end
+      end
+    end
+  end
+
+  let(:super_class) do
+    r = Class.new
+    r.include included_module
+    r
+  end
+
+  let(:sub_class) do
+    Class.new(super_class)
+  end
+
+  it { expect(super_class.hash_variable).to be_a(described_class) }
+  it { expect(super_class.hash_variable.self_variable).to eq({}) }
+  it { expect(super_class.hash_variable.ancestors_variable).to eq({}) }
+  it { expect(super_class.hash_variable.to_h).to eq({}) }
+
+  it { expect(sub_class.hash_variable).to be_a(described_class) }
+  it { expect(sub_class.hash_variable.self_variable).to eq({}) }
+  it { expect(sub_class.hash_variable.ancestors_variable).to eq({}) }
+  it { expect(sub_class.hash_variable.to_h).to eq({}) }
+
+  context 'when super class is changed' do
+    before do
+      super_class.hash_variable[:by_super] = 1
+    end
+
+    it { expect(super_class.hash_variable.to_h).to eq({ by_super: 1 }) }
+    it { expect(sub_class.hash_variable.to_h).to eq({ by_super: 1 }) }
+
+    context 'when sub class is changed' do
+      before do
+        sub_class.hash_variable[:by_sub] = 2
+      end
+
+      it { expect(super_class.hash_variable.to_h).to eq({ by_super: 1 }) }
+      it { expect(sub_class.hash_variable.to_h).to eq({ by_super: 1, by_sub: 2 }) }
+    end
+  end
+end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/module_ancestors_variable/set_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/module_ancestors_variable/set'
+
+RSpec.describe(EacRubyUtils::ModuleAncestorsVariable::Set) do
+  let(:included_module) do
+    Module.new do
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods # rubocop:disable Lint/ConstantDefinitionInBlock, RSpec/LeakyConstantDeclaration
+        def set_variable
+          @set_variable ||= ::EacRubyUtils::ModuleAncestorsVariable::Set.new(self, __method__)
+        end
+      end
+    end
+  end
+
+  let(:super_class) do
+    r = Class.new
+    r.include included_module
+    r
+  end
+
+  let(:sub_class) do
+    Class.new(super_class)
+  end
+
+  it { expect(super_class.set_variable).to be_a(described_class) }
+  it { expect(super_class.set_variable.self_variable).to eq(Set.new) }
+  it { expect(super_class.set_variable.ancestors_variable).to eq(Set.new) }
+  it { expect(super_class.set_variable.to_set).to eq(Set.new) }
+
+  it { expect(sub_class.set_variable).to be_a(described_class) }
+  it { expect(sub_class.set_variable.self_variable).to eq(Set.new) }
+  it { expect(sub_class.set_variable.ancestors_variable).to eq(Set.new) }
+  it { expect(sub_class.set_variable.to_set).to eq(Set.new) }
+
+  context 'when super class is changed' do
+    before do
+      super_class.set_variable << 1
+    end
+
+    it { expect(super_class.set_variable.to_set).to eq(Set.new([1])) }
+    it { expect(sub_class.set_variable.to_set).to eq(Set.new([1])) }
+
+    context 'when sub class is changed' do
+      before do
+        sub_class.set_variable << 2
+      end
+
+      it { expect(super_class.set_variable.to_set).to eq(Set.new([1])) }
+      it { expect(sub_class.set_variable.to_set).to eq(Set.new([1, 2])) }
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# 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 be(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 be_nil }
+  end
+end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/addressable/uri/query_value_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/addressable/uri/query_value'
+
+RSpec.describe Addressable::URI, '#query_value' do
+  subject(:instance) { described_class.parse('http://example.net') }
+
+  it { expect(instance.query_values).to be_nil }
+  it { expect(instance.hash_query_values).to eq({}) }
+
+  it { expect(instance.query_value('param1')).to be_nil }
+  it { expect(instance.query_value(:param1)).to be_nil }
+
+  context 'when param is set' do
+    let(:set_result) { instance.query_value(:param1, :value1) }
+
+    before { set_result }
+
+    it { expect(set_result).to eq(instance) }
+    it { expect(instance.query_values).to eq({ 'param1' => 'value1' }) }
+    it { expect(instance.hash_query_values).to eq({ 'param1' => 'value1' }) }
+    it { expect(instance.query_value('param1')).to eq('value1') }
+    it { expect(instance.query_value(:param1)).to eq('value1') }
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/class/abstract'
+
+RSpec.describe Class, '#abstract' do
+  let(:abstract_class) do
+    described_class.new do
+      acts_as_abstract
+    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/acts_as_abstract_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/acts_as_abstract'
+require 'eac_ruby_utils/patches/module/acts_as_abstract'
+
+RSpec.describe Class, '#acts_as_abstract' do
+  let(:stub_class) do
+    described_class.new { acts_as_abstract }
+  end
+
+  describe '#acts_as_abstract' do
+    it { expect(stub_class.included_modules).to include(EacRubyUtils::ActsAsAbstract) }
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/method_class'
+require 'eac_ruby_utils/patches/class/method_class'
+
+RSpec.describe Class, '#method_class' do
+  let(:stub_method_class) do
+    described_class.new do
+      def self.name
+        'StubMethodClass'
+      end
+
+      enable_method_class
+    end
+  end
+
+  describe '#enable_simple_cache' do
+    it { expect(stub_method_class.included_modules).to include(EacRubyUtils::MethodClass) }
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/class/self_included_modules'
+
+RSpec.describe Class, '#self_included_modules' 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