avm-tools 0.48.0 → 0.53.0

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

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

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/listable'
+
+class Stub
+  include ::EacRubyUtils::Listable
+
+  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
+
+RSpec.describe ::EacRubyUtils::Listable do
+  context 'attribute values' do
+    it { expect(Stub.lists.inteiro.values).to eq([1, 2, 3]) }
+    it { expect(Stub.lists.code.values).to eq([7, 13]) }
+    it { expect(Stub.lists.cadeia.values).to eq(%w[a b c]) }
+    it { expect(Stub.lists.type.values).to eq(%w[Namespace::ClazzA Namespace::ClazzB]) }
+    it { expect(Stub.lists.simbolo.values).to eq(%i[a b c]) }
+    it { expect(Stub.lists.tipado.values).to eq(%i[tipo_aaa tipo_bbb]) }
+  end
+
+  context 'value instance options' do
+    it {
+      expect(Stub.lists.inteiro.options)
+        .to eq([['Inteiro A', 1], ['Inteiro BB', 2], ['Inteiro CCC', 3]])
+    }
+
+    it {
+      expect(Stub.lists.code.options)
+        .to eq([['Código A', 7], ['Código B', 13]])
+    }
+
+    it {
+      expect(Stub.lists.cadeia.options)
+        .to eq([['Cadeia AAA', 'a'], ['Cadeia BB', 'b'], ['Cadeia C', 'c']])
+    }
+
+    it {
+      expect(Stub.lists.type.options)
+        .to eq([['Tipo A', 'Namespace::ClazzA'], ['Tipo B', 'Namespace::ClazzB']])
+    }
+
+    it {
+      expect(Stub.lists.simbolo.options)
+        .to eq([['Simbolo A', :a], ['Simbolo B', :b], ['Simbolo C', :c]])
+    }
+
+    it {
+      expect(Stub.lists.tipado.options)
+        .to eq([['Tipado A', :tipo_aaa], ['Tipado B', :tipo_bbb]])
+    }
+  end
+
+  context 'constants' do
+    it { expect(Stub::INTEIRO_A).to eq(1) }
+    it { expect(Stub::INTEIRO_B).to eq(2) }
+    it { expect(Stub::INTEIRO_C).to eq(3) }
+    it { expect(Stub::CODE_A).to eq(7) }
+    it { expect(Stub::CODE_B).to eq(13) }
+    it { expect(Stub::CADEIA_A).to eq('a') }
+    it { expect(Stub::CADEIA_C).to eq('c') }
+    it { expect(Stub::TYPE_A).to eq('Namespace::ClazzA') }
+    it { expect(Stub::TYPE_B).to eq('Namespace::ClazzB') }
+    it { expect(Stub::SIMBOLO_A).to eq(:a) }
+    it { expect(Stub::SIMBOLO_B).to eq(:b) }
+    it { expect(Stub::SIMBOLO_C).to eq(:c) }
+    it { expect(Stub::TIPADO_A).to eq(:tipo_aaa) }
+    it { expect(Stub::TIPADO_B).to eq(:tipo_bbb) }
+  end
+
+  context 'values instances' do
+    it { expect(Stub.lists.is_a?(::EacRubyUtils::Listable::Lists)).to eq(true) }
+    it { expect(Stub.lists.inteiro.value_a.is_a?(::EacRubyUtils::Listable::Value)).to eq(true) }
+    it { expect(Stub.lists.inteiro.value_b.is_a?(::EacRubyUtils::Listable::Value)).to eq(true) }
+    it { expect(Stub.lists.inteiro.value_c.is_a?(::EacRubyUtils::Listable::Value)).to eq(true) }
+    it { expect(Stub.lists.code.value_a.is_a?(::EacRubyUtils::Listable::Value)).to eq(true) }
+    it { expect(Stub.lists.code.value_b.is_a?(::EacRubyUtils::Listable::Value)).to eq(true) }
+    it { expect(Stub.lists.cadeia.value_a.is_a?(::EacRubyUtils::Listable::Value)).to eq(true) }
+    it { expect(Stub.lists.cadeia.value_b.is_a?(::EacRubyUtils::Listable::Value)).to eq(true) }
+    it { expect(Stub.lists.cadeia.value_c.is_a?(::EacRubyUtils::Listable::Value)).to eq(true) }
+    it { expect(Stub.lists.type.value_a.is_a?(::EacRubyUtils::Listable::Value)).to eq(true) }
+    it { expect(Stub.lists.type.value_b.is_a?(::EacRubyUtils::Listable::Value)).to eq(true) }
+  end
+
+  context 'value instance label' do
+    it { expect(Stub.lists.inteiro.value_a.label).to eq('Inteiro A') }
+    it { expect(Stub.lists.inteiro.value_b.label).to eq('Inteiro BB') }
+    it { expect(Stub.lists.inteiro.value_c.label).to eq('Inteiro CCC') }
+    it { expect(Stub.lists.code.value_a.label).to eq('Código A') }
+    it { expect(Stub.lists.code.value_b.label).to eq('Código B') }
+    it { expect(Stub.lists.cadeia.value_a.label).to eq('Cadeia AAA') }
+    it { expect(Stub.lists.cadeia.value_b.label).to eq('Cadeia BB') }
+    it { expect(Stub.lists.cadeia.value_c.label).to eq('Cadeia C') }
+    it { expect(Stub.lists.type.value_a.label).to eq('Tipo A') }
+    it { expect(Stub.lists.type.value_b.label).to eq('Tipo B') }
+  end
+
+  context 'value instance description' do
+    it { expect(Stub.lists.inteiro.value_a.description).to eq('Inteiro A Descr.') }
+    it { expect(Stub.lists.inteiro.value_b.description).to eq('Inteiro BB Descr.') }
+    it { expect(Stub.lists.inteiro.value_c.description).to eq('Inteiro CCC Descr.') }
+    it { expect(Stub.lists.code.value_a.description).to eq('Código A Descr.') }
+    it { expect(Stub.lists.code.value_b.description).to eq('Código B Descr.') }
+    it { expect(Stub.lists.cadeia.value_a.description).to eq('Cadeia AAA Descr.') }
+    it { expect(Stub.lists.cadeia.value_b.description).to eq('Cadeia BB Descr.') }
+    it { expect(Stub.lists.cadeia.value_c.description).to eq('Cadeia C Descr.') }
+    it { expect(Stub.lists.type.value_a.description).to eq('Tipo A Descr.') }
+    it { expect(Stub.lists.type.value_b.description).to eq('Tipo B Descr.') }
+  end
+
+  context 'value instance constant name' do
+    it { expect(Stub.lists.inteiro.value_a.constant_name).to eq('INTEIRO_A') }
+    it { expect(Stub.lists.inteiro.value_b.constant_name).to eq('INTEIRO_B') }
+    it { expect(Stub.lists.inteiro.value_c.constant_name).to eq('INTEIRO_C') }
+    it { expect(Stub.lists.code.value_a.constant_name).to eq('CODE_A') }
+    it { expect(Stub.lists.code.value_b.constant_name).to eq('CODE_B') }
+    it { expect(Stub.lists.cadeia.value_a.constant_name).to eq('CADEIA_A') }
+    it { expect(Stub.lists.cadeia.value_b.constant_name).to eq('CADEIA_B') }
+    it { expect(Stub.lists.cadeia.value_c.constant_name).to eq('CADEIA_C') }
+    it { expect(Stub.lists.type.value_a.constant_name).to eq('TYPE_A') }
+    it { expect(Stub.lists.type.value_b.constant_name).to eq('TYPE_B') }
+  end
+
+  context 'instance label and descriptions' do
+    let(:instance) { Stub.new }
+
+    context 'when inteiro value is A' do
+      before { instance.inteiro = Stub::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 A' do
+      before { instance.inteiro = Stub::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::INTEIRO_C }
+
+      it { expect(instance.inteiro_label).to eq('Inteiro CCC') }
+      it { expect(instance.inteiro_description).to eq('Inteiro CCC Descr.') }
+    end
+
+    context 'when code value is A' do
+      before { instance.code = Stub::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::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 cadeia value is A' do
+      before { instance.cadeia = Stub::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::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::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::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::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.lists.inteiro.value_validate!(1) }.not_to raise_error }
+    it { expect { Stub.lists.inteiro.value_validate!('1') }.to raise_error }
+    it { expect { Stub.lists.inteiro.value_validate!(10) }.to raise_error(::StandardError) }
+    it { expect { Stub.lists.cadeia.value_validate!(:a) }.to raise_error }
+    it { expect { Stub.lists.cadeia.value_validate!('a') }.not_to raise_error }
+    it { expect { Stub.lists.cadeia.value_validate!(:z) }.to raise_error(::StandardError) }
+  end
+end