eac_tools 0.97.0 → 0.97.2

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/common_concern'
+
+RSpec.describe EacRubyUtils::CommonConcern do
+  let(:instance) do
+    described_class.new do
+      self.valor = 'changed'
+    end
+  end
+
+  let(:stub_module) do
+    Module.new do
+      module ClassMethods # rubocop:disable Lint/ConstantDefinitionInBlock, RSpec/LeakyConstantDeclaration,
+        def my_class_method
+          'class'
+        end
+      end
+
+      module InstanceMethods # rubocop:disable Lint/ConstantDefinitionInBlock, RSpec/LeakyConstantDeclaration
+        def my_instance_method
+          'from_module'
+        end
+      end
+    end
+  end
+
+  let(:stub_class) do
+    Class.new do
+      class << self
+        attr_accessor :valor
+      end
+
+      def my_instance_method
+        'from_class'
+      end
+    end
+  end
+
+  let(:stub_class_instance) { stub_class.new }
+
+  before do
+    instance.setup(stub_module)
+  end
+
+  context 'when included' do
+    before do
+      stub_class.include stub_module
+    end
+
+    it { expect(stub_class_instance.my_instance_method).to eq('from_class') }
+    it { expect(stub_class_instance.class.my_class_method).to eq('class') }
+    it { expect(stub_class_instance.class.valor).to eq('changed') }
+  end
+
+  context 'when prepended' do
+    before do
+      stub_class.prepend stub_module
+    end
+
+    it { expect(stub_class_instance.my_instance_method).to eq('from_module') }
+    it { expect(stub_class_instance.class.my_class_method).to eq('class') }
+    it { expect(stub_class_instance.class.valor).to eq('changed') }
+  end
+end

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

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/common_constructor'
+
+RSpec.describe EacRubyUtils::CommonConstructor do
+  ARG_LIST = %i[a b c d].freeze # rubocop:disable Lint/ConstantDefinitionInBlock, RSpec/LeakyConstantDeclaration
+
+  let(:instance) do
+    described_class.new(*ARG_LIST, default: %w[Vcc Vd]) do
+      @z = 'Vz'
+    end
+  end
+
+  let(:a_class) do
+    Class.new do
+      attr_reader :z
+    end
+  end
+
+  let(:a_class_instance) { a_class.new('Va', 'Vb', 'Vc') }
+
+  before do
+    instance.setup_class(a_class)
+  end
+
+  it { expect(a_class_instance.z).to eq('Vz') }
+
+  ARG_LIST.each do |attr|
+    expected_value = "V#{attr}"
+    it "attribute \"#{attr}\" equal to \"#{expected_value}\"" do
+      expect(a_class_instance.send(attr)).to eq(expected_value)
+    end
+
+    [false, true].each do |include_all|
+      it "respond_to?('#{attr}', #{include_all}) == #{include_all}" do
+        expect(a_class_instance.respond_to?("#{attr}=", include_all)).to eq(include_all)
+      end
+    end
+  end
+
+  context 'with super class' do
+    let(:super_class) do
+      Class.new do
+        attr_reader :super_a, :super_b
+
+        def initialize(a, b) # rubocop:disable Naming/MethodParameterName
+          @super_a = a
+          @super_b = b
+        end
+      end
+    end
+
+    let(:sub_class) do
+      sub_constructor.setup_class(Class.new(super_class))
+    end
+
+    let(:sub_object) { sub_class.new(1, 2, 3, 4) }
+
+    context 'with super_args parameter' do
+      let(:sub_constructor) do
+        described_class.new(:c, :a, :b, :d, super_args: -> { [c, a] })
+      end
+
+      it { expect(sub_object.a).to eq(2) }
+      it { expect(sub_object.b).to eq(3) }
+      it { expect(sub_object.c).to eq(1) }
+      it { expect(sub_object.d).to eq(4) }
+      it { expect(sub_object.super_a).to eq(1) }
+      it { expect(sub_object.super_b).to eq(2) }
+    end
+
+    context 'without super_args parameter' do
+      let(:sub_constructor) do
+        described_class.new(:c, :a, :b, :d)
+      end
+
+      it { expect(sub_object.a).to eq(2) }
+      it { expect(sub_object.b).to eq(3) }
+      it { expect(sub_object.c).to eq(1) }
+      it { expect(sub_object.d).to eq(4) }
+      it { expect(sub_object.super_a).to eq(2) }
+      it { expect(sub_object.super_b).to eq(3) }
+    end
+
+    context 'with undefined super arguments' do
+      let(:sub_constructor) do
+        described_class.new(:x, :y, :w, :a)
+      end
+
+      it do
+        expect { sub_object }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  context 'with block argument' do
+    let(:instance) do
+      described_class.new(:first, :second, :last, block_arg: true, default: ['second'])
+    end
+
+    let(:block) do
+      proc { first + second }
+    end
+
+    let(:a_class) do
+      Class.new do
+        def result
+          last.run
+        end
+      end
+    end
+
+    let(:a_class_instance) { a_class.new('first') { 'last' } }
+
+    it { expect(a_class_instance.last).to be_a(Proc) }
+    it { expect(a_class_instance.last.call).to eq('last') }
+
+    it { expect(a_class_instance.first).to eq('first') }
+    it { expect(a_class_instance.second).to eq('second') }
+  end
+
+  context 'with class hierarchy mixed with and without common_constructor' do
+    let(:klass_0) do # rubocop:disable Naming/VariableNumber, RSpec/IndexedLet
+      described_class.new(:a_param).setup_class(Class.new)
+    end
+
+    let(:klass_1) do # rubocop:disable Naming/VariableNumber, RSpec/IndexedLet
+      Class.new(klass_0) do
+        def initialize(a_param) # rubocop:disable Lint/UselessMethodDefinition
+          super
+        end
+      end
+    end
+
+    let(:klass_2) do # rubocop:disable Naming/VariableNumber, RSpec/IndexedLet
+      Class.new(klass_1)
+    end
+
+    let(:klass_3) do # rubocop:disable Naming/VariableNumber, RSpec/IndexedLet
+      described_class.new(:a_param).setup_class(Class.new(klass_2))
+    end
+
+    4.times.each do |i|
+      context "with #{i}-th class" do
+        let(:class_instance) { send("klass_#{i}").new(:a) }
+
+        it { expect(class_instance.a_param).to eq(:a) }
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,39 @@
+# 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) } # rubocop:disable RSpec/IndexedLet
+  let(:o2) { klass.new(2, 1) } # rubocop:disable RSpec/IndexedLet
+  let(:o3) { klass.new(1, 1) } # rubocop:disable RSpec/IndexedLet
+
+  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|') }
+  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,44 @@
+# 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/enumerables_methods_spec.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/enumerables_methods'
+
+RSpec.describe EacRubyUtils::EnumerablesMethods do
+  describe '#write_method?' do
+    it do
+      expect(described_class).to be_write_method(:'[]=')
+    end
+
+    it do
+      expect(described_class).not_to be_write_method(:'!=')
+    end
+  end
+
+  [
+    [:enumerable, %i[drop lazy sort], []],
+    [:hash, %i[\[\] <= compact slice to_h values],
+     %i[\[\]= compact! delete default= keep_if shift]],
+    [:set, %i[<= include?], %i[<< add clear collect! divide delete keep_if merge reset subtract]]
+  ].each do |test_values|
+    klass_underscore, read_methods, write_methods = test_values
+
+    context "when class/module is #{klass_underscore}" do
+      let(:const_prefix) { klass_underscore.to_s.upcase }
+      let(:const_all) { "#{const_prefix}_METHODS" }
+      let(:const_read) { "#{const_prefix}_READ_METHODS" }
+      let(:const_write) { "#{const_prefix}_WRITE_METHODS" }
+      let(:actual_all) { described_class.const_get(const_all) }
+      let(:actual_read) { described_class.const_get(const_read) }
+      let(:actual_write) { described_class.const_get(const_write) }
+
+      read_methods.each do |method_name|
+        context "when method is \"#{method_name}\"" do
+          it { expect(actual_all).to include(method_name) }
+          it { expect(actual_read).to include(method_name) }
+          it { expect(actual_write).not_to include(method_name) }
+        end
+      end
+
+      write_methods.each do |method_name|
+        context "when method is \"#{method_name}\"" do
+          it { expect(actual_all).to include(method_name) }
+          it { expect(actual_read).not_to include(method_name) }
+          it { expect(actual_write).to include(method_name) }
+        end
+      end
+    end
+  end
+end

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

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/envs/command'
+require 'eac_ruby_utils/envs/local_env'
+require_relative 'base_example'
+
+RSpec.describe EacRubyUtils::Envs::Command, '#local_env' do
+  let(:env) { EacRubyUtils::Envs::LocalEnv.new }
+
+  include_examples 'with_command_env'
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'avm/eac_ubuntu_base0/rspec/ssh_docker_server'
+require 'eac_ruby_utils/envs/command'
+require 'eac_ruby_utils/envs/ssh_env'
+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
+
+  include_examples 'with_command_env'
+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 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

@@ -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, '#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

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