avm-tools 0.50.0 → 0.54.1

data/vendor/gems/eac_ruby_utils/spec/lib/eac_ruby_utils/configs_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'tempfile'
+require 'eac_ruby_utils/configs'
+
+RSpec.describe ::EacRubyUtils::Configs do
+  let(:configs_key) { 'configsspec' }
+  let(:storage_path) do
+    file = ::Tempfile.new(configs_key)
+    path = file.path
+    file.close
+    file.unlink
+    path
+  end
+  let(:instance) { described_class.new(configs_key, storage_path: storage_path) }
+
+  describe '#storage_path' do
+    it { expect(instance.storage_path).to eq(storage_path) }
+  end
+
+  describe '#write' do
+    let(:entry_key) { 'parent.child' }
+
+    before do
+      instance[entry_key] = 'value1'
+      instance.save
+    end
+
+    it { expect(::YAML.load_file(storage_path)).to eq(parent: { child: 'value1' }) }
+  end
+end

data/vendor/gems/eac_ruby_utils/spec/lib/eac_ruby_utils/console/configs_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/console/configs'
+
+RSpec.describe ::EacRubyUtils::Console::Configs do
+  describe '#entry_key_to_envvar_name' do
+    {
+      'a.entry.value' => 'A_ENTRY_VALUE',
+      'appli-cation_0.var_one' => 'APPLICATION_0_VAR_ONE'
+    }.each do |input, expected_result|
+      it { expect(described_class.entry_key_to_envvar_name(input)).to eq(expected_result) }
+    end
+  end
+end

data/vendor/gems/eac_ruby_utils/spec/lib/eac_ruby_utils/console/docopt_runner_spec.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/console/docopt_runner'
+
+RSpec.describe ::EacRubyUtils::Console::DocoptRunner do
+  context 'runner without DOC constant' do
+    class RunnerWithoutDocConstant < ::EacRubyUtils::Console::DocoptRunner
+      def run
+        # Do nothing
+      end
+    end
+
+    let(:options) { { argv: [] } }
+
+    it 'raises exception if doc argument is not supplied' do
+      expect { RunnerWithoutDocConstant.new(options) }.to raise_error(::StandardError)
+    end
+
+    context 'doc argument is supplied' do
+      let(:doc) do
+        <<~DOCUMENT
+          Runner without doc constant.
+
+          Usage:
+            __PROGRAM__
+        DOCUMENT
+      end
+
+      let(:options_with_doc) { options.merge(doc: doc) }
+
+      it 'reads doc from arguments' do
+        expect { RunnerWithoutDocConstant.new(options_with_doc) }.not_to raise_error
+      end
+    end
+  end
+
+  context 'doc with subcommands' do
+    class RunnerWithSubcommands < ::EacRubyUtils::Console::DocoptRunner
+      attr_accessor :subarg_value, :suboption_value
+
+      DOC = <<~DOCUMENT
+        A root runner with subcommands.
+
+        Usage:
+          __PROGRAM__ <parent-arg> __SUBCOMMANDS__
+      DOCUMENT
+
+      def parent_arg
+        options.fetch('<parent-arg>')
+      end
+
+      class MySubCommand < ::EacRubyUtils::Console::DocoptRunner
+        DOC = <<~DOCUMENT
+          A root runner with subcommands.
+
+          Usage:
+            __PROGRAM__ [--suboption=<suboption-value] <subarg-value>
+        DOCUMENT
+
+        def run
+          parent.suboption_value = options.fetch('--suboption')
+          parent.subarg_value = options.fetch('<subarg-value>')
+        end
+      end
+    end
+
+    let(:instance) { RunnerWithSubcommands.new }
+
+    describe '#subcommands?' do
+      it 'returns true' do
+        expect(instance.subcommands?).to eq(true)
+      end
+    end
+
+    context 'when subcommand is valid' do
+      let(:instance) do
+        RunnerWithSubcommands.new(argv: %w[value0 my-sub-command value1 --suboption value2])
+      end
+
+      describe '#subcommand_arg_as_list?' do
+        it { expect(instance.subcommand_arg_as_list?).to eq(false) }
+      end
+
+      describe '#target_doc' do
+        it { expect(instance.target_doc).to include('Subcommands:') }
+      end
+
+      describe '#subcommand' do
+        it 'is of subcommand class' do
+          expect(instance.subcommand).to be_a(RunnerWithSubcommands::MySubCommand)
+        end
+      end
+
+      describe '#context' do
+        it 'accesses instance methods by subcommand' do
+          expect(instance.subcommand.context(:parent_arg)).to eq('value0')
+        end
+      end
+
+      describe '#run' do
+        it 'calls subcommand' do
+          instance.run
+          expect(instance.subarg_value).to eq('value1')
+          expect(instance.suboption_value).to eq('value2')
+        end
+      end
+    end
+
+    context 'when subcommand is invalid' do
+      let(:instance) { RunnerWithSubcommands.new(argv: %w[value0 invalid-subcommand]) }
+
+      describe '#run' do
+        it 'raises Docopt::Exit' do
+          expect { instance.run }.to raise_error(::Docopt::Exit)
+        end
+      end
+    end
+
+    context 'when subcommand as arg list is enabled' do
+      let(:argv) { %w[value0 my-sub-command value1 --suboption value2] }
+      let(:instance) { RunnerWithSubcommands.new(argv: argv, subcommand_arg_as_list: true) }
+
+      describe '#subcommand_arg_as_list?' do
+        it { expect(instance.subcommand_arg_as_list?).to eq(true) }
+      end
+
+      describe '#target_doc' do
+        it { expect(instance.target_doc).to include('(my-sub-command)') }
+      end
+
+      describe '#subcommand_name' do
+        it { expect(instance.subcommand_name).to eq('my-sub-command') }
+      end
+    end
+  end
+end

data/vendor/gems/eac_ruby_utils/spec/lib/eac_ruby_utils/console/speaker_spec.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/console/speaker'
+
+RSpec.describe ::EacRubyUtils::Console::Speaker do
+  let(:instance) do
+    r = ::Object.new
+    r.extend(described_class)
+    r
+  end
+
+  describe '#request_input' do
+    it 'recover value from hash list' do
+      allow(instance).to receive(:request_string).and_return('opt1')
+      list = { opt1: 'value1', opt2: 'value2' }
+      expect(instance.request_input('Question', list: list)).to eq('value1')
+    end
+
+    it 'recover value from array list' do
+      allow(instance).to receive(:request_string).and_return('OPT1')
+      list = %w[opt1 opt2]
+      expect(instance.request_input('Question', list: list)).to eq('opt1')
+    end
+
+    {
+      'yes' => true, 'y' => true, 'Y' => true, 'NO' => false, 'no' => false, 'n' => false
+    }.each do |input, expected|
+      context "when bool: true and input is \"#{input}\"" do
+        it "return #{expected}" do
+          allow(instance).to receive(:request_string).and_return(input)
+          expect(instance.request_input('Question', bool: true)).to eq(expected)
+        end
+      end
+    end
+  end
+end

data/vendor/gems/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/vendor/gems/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/vendor/gems/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/vendor/gems/eac_ruby_utils/spec/lib/eac_ruby_utils/filesystem_cache_spec.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object/blank'
+require 'eac_ruby_utils/filesystem_cache'
+
+RSpec.describe ::EacRubyUtils::FilesystemCache do
+  let(:tmpdir) { ::Dir.mktmpdir }
+  let(:instance) { described_class.new(tmpdir, 'instance') }
+
+  it { expect(instance.read).to be_blank }
+  it { expect(instance.cached?).to eq(false) }
+
+  context 'when instance is writed' do
+    before { instance.write('STUB') }
+
+    it { expect(instance.read).to eq('STUB') }
+    it { expect(instance.cached?).to eq(true) }
+
+    context 'when instance is cleared' do
+      before { instance.clear }
+
+      it { expect(instance.read).to be_blank }
+      it { expect(instance.cached?).to eq(false) }
+    end
+  end
+
+  describe '#child' do
+    let(:child) { instance.child('child') }
+
+    it { expect(child.path).to match(/\A#{::Regexp.quote(instance.path)}/) }
+  end
+end

data/vendor/gems/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/vendor/gems/eac_ruby_utils/spec/lib/eac_ruby_utils/fs/temp/temp_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/vendor/gems/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
+      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
+      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
+      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
+      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