eac_tools 0.2.2 → 0.5.0

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/compact'
+
+::RSpec.describe ::EacRubyUtils::Compact do
+  let(:object) { ::OpenStruct.new(a_attr: 'a_value', b_attr: 'b_value') }
+  let(:instance) { described_class.new(object, %w[a_attr b_attr]) }
+
+  describe '#to_a' do
+    it do
+      expect(instance.to_a).to eq(%w[a_value b_value])
+    end
+  end
+
+  describe '#to_h' do
+    it do
+      expect(instance.to_h).to eq(a_attr: 'a_value', b_attr: 'b_value')
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/compare_by'
+
+RSpec.describe ::EacRubyUtils::CompareBy do
+  let(:instance) { described_class.new(%i[field1 field2]) }
+  let(:klass) do
+    ::Class.new do
+      attr_reader :field1, :field2
+      def initialize(field1, field2)
+        @field1 = field1
+        @field2 = field2
+      end
+    end
+  end
+  let(:o1) { klass.new(1, 2) }
+  let(:o2) { klass.new(2, 1) }
+  let(:o3) { klass.new(1, 1) }
+
+  before { instance.apply(klass) }
+
+  describe '#comparable' do
+    it { expect(o1).to be < o2 }
+    it { expect(o1).to be > o3 }
+    it { expect(o2).to be > o3 }
+    it { expect([o1, o2, o3].sort).to eq([o3, o1, o2]) }
+  end
+
+  describe '#equality' do
+    it { expect(o1).not_to eq(o2) }
+    it { expect(o1).not_to eq(o3) }
+    it { expect(o2).not_to eq(o3) }
+
+    it { expect(o1).to eq(klass.new(1, 2)) }
+    it { expect(o2).to eq(klass.new(2, 1)) }
+    it { expect(o3).to eq(klass.new(1, 1)) }
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/custom_format'
+
+class StubObjectData
+  def x_value
+    'X1'
+  end
+
+  def y_value
+    'Y1'
+  end
+end
+
+RSpec.describe ::EacRubyUtils::CustomFormat do
+  let(:instance) { described_class.new(x: :x_value, y: :y_value, z: :unexistent) }
+  let(:ok_format) { instance.format('|%%|%y|%x|%y|') } # rubocop:disable Style/FormatStringToken
+  let(:ok_string_expected) { '|%|Y1|X1|Y1|' }
+  let(:fail_format) { instance.format('|%z|') }
+
+  it do
+    expect(ok_format.sequences).to include(:x, :y)
+  end
+
+  it do
+    expect(fail_format.sequences).to include(:z)
+  end
+
+  context 'when object source is a hash' do
+    let(:object_source) { { x_value: 'X1', y_value: 'Y1' } }
+
+    context 'when hash has all keys' do
+      it do
+        expect(ok_format.with(object_source)).to eq(ok_string_expected)
+      end
+    end
+
+    context 'when hash has not all keys' do
+      it do
+        expect(fail_format.with(object_source)).to eq('||')
+      end
+    end
+  end
+
+  context 'when object source is not a hash' do
+    let(:object_source) { ::StubObjectData.new }
+
+    context 'when object has all methods' do
+      it do
+        expect(ok_format.with(object_source)).to eq(ok_string_expected)
+      end
+    end
+
+    context 'when object has not all methods' do
+      it do
+        expect { fail_format.with(object_source) }.to raise_error(::ArgumentError)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/enum'
+
+::RSpec.describe ::EacRubyUtils::Enum do
+  let(:klass) do
+    ::Class.new(described_class) do
+      attr_reader :color
+      def initialize(key, color = :none)
+        super(key)
+        @color = color
+      end
+
+      enum :horse
+      enum :pig, [:pink]
+      enum(:dog, :white)
+      enum(:cat) { :black }
+    end
+  end
+
+  it { expect(klass.horse).to be_a(klass) }
+  it { expect(klass.pig).to be_a(klass) }
+  it { expect(klass.dog).to be_a(klass) }
+  it { expect(klass.cat).to be_a(klass) }
+
+  it { expect(klass.horse.color).to eq(:none) }
+  it { expect(klass.pig.color).to eq(:pink) }
+  it { expect(klass.dog.color).to eq(:white) }
+  it { expect(klass.cat.color).to eq(:black) }
+
+  it { expect(klass.const_get(:HORSE)).to eq(klass.horse) }
+  it { expect(klass.const_get(:PIG)).to eq(klass.pig) }
+  it { expect(klass.const_get(:DOG)).to eq(klass.dog) }
+  it { expect(klass.const_get(:CAT)).to eq(klass.cat) }
+
+  it { expect(klass.values).to eq([klass.horse, klass::PIG, klass.dog, klass::CAT]) }
+
+  describe '#enum' do
+    it do
+      expect { klass.enum(:PiG) }.to raise_error(::ArgumentError)
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/envs/executable'
+require 'eac_ruby_utils/envs/local_env'
+
+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 eq(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 eq(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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/envs/ssh_env'
+
+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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/fs/extname'
+
+RSpec.describe ::EacRubyUtils::Fs 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

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

@@ -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,275 @@
+# 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

@@ -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