eac_tools 0.122.0 → 0.123.1

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/envs/command/base_example.rb

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.shared_examples 'with_command_env' do
-  let(:echo) { env.executable('echo', '--version') }
-  let(:cat) { env.executable('cat', '--version') }
-  let(:not_existing_file) { Pathname.new('a_file_that_not_exists') }
-  let(:ok_command) { echo.command('-n', ok_command_output) }
-  let(:ok_command_output) { 'THE OUTPUT' }
-  let(:error_command) { cat.command(not_existing_file) }
-
-  it { expect(echo).to exist }
-  it { expect(cat).to exist }
-  it { expect(not_existing_file).not_to exist }
-
-  describe '#execute' do
-    it do
-      assert_execute_result(ok_command.execute, true, ok_command_output)
-    end
-
-    it do
-      assert_execute_result(error_command.execute, false, '')
-    end
-  end
-
-  describe '#execute!' do
-    it { expect(ok_command.execute!).to eq(ok_command_output) }
-
-    it do
-      expect { error_command.execute! }.to(
-        raise_error(EacRubyUtils::Envs::ExecutionError)
-      )
-    end
-  end
-
-  describe '#system' do
-    it { expect(ok_command.system).to be(true) }
-    it { expect(error_command.system).to be(false) }
-  end
-
-  describe '#system!' do
-    it { expect { ok_command.system! }.not_to raise_error }
-
-    it do
-      expect { error_command.system! }.to(
-        raise_error(EacRubyUtils::Envs::ExecutionError)
-      )
-    end
-  end
-
-  describe '#and' do
-    it do
-      assert_execute_result(ok_command.and(error_command).execute, false, ok_command_output)
-    end
-
-    it do
-      assert_execute_result(error_command.and(ok_command).execute, false, '')
-    end
-  end
-
-  describe '#before' do
-    it do
-      assert_execute_result(ok_command.before(error_command).execute, false, ok_command_output)
-    end
-
-    it do
-      assert_execute_result(error_command.before(ok_command).execute, false, '')
-    end
-  end
-
-  describe '#or' do
-    it do
-      assert_execute_result(ok_command.or(error_command).execute, true, ok_command_output)
-    end
-
-    it do
-      assert_execute_result(error_command.or(ok_command).execute, true, ok_command_output)
-    end
-  end
-
-  describe '#pipe' do
-    it do
-      assert_execute_result(ok_command.pipe(error_command).execute, false, '')
-    end
-
-    it do
-      assert_execute_result(error_command.pipe(ok_command).execute, false, ok_command_output)
-    end
-  end
-
-  def assert_execute_result(actual, expected_successful, expected_stdout)
-    expect(successful: actual.fetch(:exit_code).zero?, stdout: actual.fetch(:stdout)).to(
-      eq(successful: expected_successful, stdout: expected_stdout)
-    )
-  end
-end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/envs/command/local_env_spec.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'base_example'
-
-RSpec.describe EacRubyUtils::Envs::Command, '#local_env' do
-  let(:env) { EacRubyUtils::Envs::LocalEnv.new }
-
-  it_behaves_like 'with_command_env'
-end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/envs/command/ssh_env_spec.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-require 'avm/eac_ubuntu_base0/rspec/ssh_docker_server'
-
-require_relative 'base_example'
-
-RSpec.describe EacRubyUtils::Envs::Command, '#ssh_env' do
-  let(:ssh_server) { Avm::EacUbuntuBase0::Rspec::SshDockerServer.new }
-  let(:env) { ssh_server.env }
-
-  around do |example|
-    ssh_server.on_run(&example)
-  end
-
-  it_behaves_like 'with_command_env'
-end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/envs/executable_spec.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe EacRubyUtils::Envs::Executable do
-  let(:env) { EacRubyUtils::Envs::LocalEnv.new }
-
-  context 'when program exist' do
-    let(:instance) { described_class.new(env, 'cat', '--version') }
-
-    it { expect(instance.exist?).to be(true) }
-    it { expect { instance.validate! }.not_to raise_error }
-    it { expect(instance.validate).to be_blank }
-    it { expect(instance.command).to be_a(EacRubyUtils::Envs::Command) }
-  end
-
-  context 'when program does not exist' do
-    let(:instance) { described_class.new(env, 'this_cannot_exist', '--version') }
-
-    it { expect(instance.exist?).to be(false) }
-
-    it {
-      expect { instance.validate! }.to raise_error(
-        described_class.const_get('ProgramNotFoundError')
-      )
-    }
-
-    it { expect(instance.validate).to be_present }
-
-    it {
-      expect { instance.command }.to raise_error(
-        described_class.const_get('ProgramNotFoundError')
-      )
-    }
-  end
-end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/envs/ssh_env_spec.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe EacRubyUtils::Envs::SshEnv do
-  describe '#ssh_command_line' do
-    {
-      'eduardo@localhost' => 'ssh eduardo@localhost',
-      'ssh://eduardo@localhost' => 'ssh eduardo@localhost',
-      'ssh://eduardo@localhost:2222' => 'ssh -p 2222 eduardo@localhost',
-      'localhost' => 'ssh localhost'
-    }.each do |input, expected|
-      it "convert \"#{input}\" to \"#{expected}\"" do
-        env = described_class.new(input)
-        expect(env.send('ssh_command_line')).to eq(expected)
-      end
-    end
-
-    ['my user@hostname', 'http://hostname', 'ssh:/invalid-test', 'Fulano de tal'].each do |input|
-      it "\"#{input}\" raise error" do
-        expect { described_class.new(input) }.to raise_error(StandardError)
-      end
-    end
-  end
-end

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

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe EacRubyUtils::Fs, '#extname' do
-  describe '#extname' do
-    {
-      'After.Life.S01E01.WEBRip.x264-ION10.mp4' => '.mp4',
-      's01e01.en.srt' => '.en.srt',
-      's01e01.srt' => '.srt',
-      '/path/to/file.tar.gz' => '.tar.gz'
-    }.each do |source, expected|
-      context "when source is \"#{source}\"" do
-        it { expect(described_class.extname(source)).to eq(expected) }
-      end
-    end
-  end
-end

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

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-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,50 +0,0 @@
-# frozen_string_literal: true
-
-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/gems_registry_spec.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe EacRubyUtils::GemsRegistry do
-  let(:instance) { described_class.new('Byte') }
-
-  it do
-    expect(instance.registered.map(&:registered_module)).to include(EacRubyUtils::Byte)
-  end
-
-  it do
-    expect(instance.registered.find { |e| e.gemspec.name == 'eac_ruby_utils' }.path_to_require)
-      .to eq('eac_ruby_utils')
-  end
-end

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

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-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,223 +0,0 @@
-# frozen_string_literal: true
-
-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

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-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,45 +0,0 @@
-# frozen_string_literal: true
-
-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

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-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

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-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