opt_parse_validator 0.0.2

data/spec/lib/opt_parse_validator/options_file_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe OptParseValidator::OptParser do
+
+  subject(:parser)     { described_class.new }
+  let(:fixtures)       { File.join(FIXTURES, 'options_file') }
+  let(:default_file)   { File.join(fixtures, 'default.json') }
+  let(:override_file)  { File.join(fixtures, 'override.yml') }
+
+  describe '#load_options_files' do
+
+    context 'when error' do
+      before { parser.options_files << config_file }
+
+      context 'when the format is not supported' do
+        let(:config_file) { File.join(fixtures, 'unsupported.ext') }
+        let(:exception)   { "The format #{File.extname(config_file).delete('.')} is not supported" }
+
+        it 'raises an error' do
+          expect { parser.load_options_files }.to raise_error(exception)
+        end
+      end
+
+      context 'when file content is malformed' do
+        let(:config_file) { File.join(fixtures, 'malformed.json') }
+        let(:exception)   { "Parse Error, #{config_file} seems to be malformed" }
+
+        it 'raises an error' do
+          expect { parser.load_options_files }.to raise_error(exception)
+        end
+      end
+    end
+
+    context 'otherwise' do
+      let(:verbose_opt) { OptParseValidator::OptBoolean.new(%w(-v --verbose)) }
+      let(:override_opt) { OptParseValidator::OptString.new(['--override-me VALUE'], normalize: :to_sym) }
+
+      let(:opts) { [verbose_opt, override_opt] }
+
+      let(:expected) { { verbose: true, override_me: :Yeaa } }
+
+      it 'sets everything correctly and get the right results' do
+        parser.options_files << default_file << override_file
+        parser.add(*opts)
+
+        expect(parser.results([])).to eq expected
+      end
+    end
+  end
+end

data/spec/lib/opt_parse_validator/opts/base_spec.rb

@@ -0,0 +1,169 @@
+require 'spec_helper'
+
+describe OptParseValidator::OptBase do
+  subject(:opt) { described_class.new(option, attrs) }
+  let(:option)  { %w(-v --verbose) }
+  let(:attrs)   { {} }
+
+  describe '#to_long' do
+    after { expect(described_class.new(@option).to_long).to eq @expected }
+
+    context 'when not found' do
+      it 'returns nil' do
+        @option = %w(-v)
+        @expected = nil
+      end
+    end
+
+    context 'when found' do
+      it 'returns the long name' do
+        @option = ['-v', '--[no-]verbose VALUE [OPT]', 'Verbose Mode']
+        @expected = '--verbose'
+      end
+    end
+  end
+
+  describe '#to_sym' do
+    after :each do
+      if @exception
+        expect { described_class.new(@option).to_sym }.to raise_error(@exception)
+      else
+        expect(described_class.new(@option).to_sym).to eq(@expected)
+      end
+    end
+
+    context 'without REQUIRED or OPTIONAL arguments' do
+      context 'with short option' do
+        it 'returns :test' do
+          @option   = %w(-t --test Testing)
+          @expected = :test
+        end
+
+        it 'returns :its_a_long_option' do
+          @option   = ['-l', '--its-a-long-option', "Testing '-' replacement"]
+          @expected = :its_a_long_option
+        end
+      end
+
+      context 'without short option' do
+        it 'returns :long' do
+          @option   = ['--long']
+          @expected = :long
+        end
+
+        it 'returns :long_option' do
+          @option   = ['--long-option', 'No short !']
+          @expected = :long_option
+        end
+      end
+
+      context 'without long option' do
+        it 'raises an error' do
+          @option    = ['-v', 'long option missing']
+          @exception = 'Could not find option symbol for ["-v", "long option missing"]'
+        end
+
+        it 'raises an error' do
+          @option    = ['long option missing']
+          @exception = 'Could not find option symbol for ["long option missing"]'
+        end
+      end
+
+      context 'with multiple long option names (like alias)' do
+        it 'returns the first long option found' do
+          @option   = %w(--check-long --cl)
+          @expected = :check_long
+        end
+      end
+    end
+
+    context 'when negative prefix name' do
+      it 'returns the positive option symbol' do
+        @option   = %w(-v --[no-]verbose)
+        @expected = :verbose
+      end
+    end
+
+    context 'with REQUIRED or OPTIONAL arguments' do
+      it 'should removed the OPTIONAL argument' do
+        @option   = ['-p', '--page [PAGE_NUMBER]']
+        @expected = :page
+      end
+
+      it 'should removed the REQUIRED argument' do
+        @option   = ['--url TARGET_URL']
+        @expected = :url
+      end
+    end
+  end
+
+  describe '#new, #required?' do
+    context 'when no :required' do
+      its(:option)    { should eq(option) }
+      its(:required?) { should be_falsey }
+      its(:to_sym)    { should eq(:verbose) }
+    end
+
+    context 'when :required' do
+      let(:attrs) { { required: true } }
+
+      its(:required?) { should be true }
+    end
+  end
+
+  describe '#normalize' do
+    after { expect(opt.normalize(@value)).to eq @expected }
+
+    context 'when no :normalize attribute' do
+      it 'returns the value' do
+        @value    = 'test'
+        @expected = @value
+      end
+    end
+
+    context 'when a single normalization' do
+      let(:attrs) { { normalize: :to_sym } }
+
+      context 'when the value does not have a to_sym method' do
+        it 'returns the value' do
+          @value    = 1.0
+          @expected = @value
+        end
+      end
+
+      context 'when a to_sym method' do
+        it 'returns the symbol' do
+          @value    = 'test'
+          @expected = :test
+        end
+      end
+    end
+
+    context 'when multiple normalization' do
+      let(:attrs) { { normalize: [:to_sym, 2.0, :upcase] } }
+
+      it 'apply each of them (if possible)' do
+        @value    = 'test'
+        @expected = :TEST
+      end
+    end
+  end
+
+  describe '#validate' do
+    context 'when an empty or nil value' do
+      it 'raises an error' do
+        [nil, ''].each do |value|
+          expect { opt.validate(value) }
+            .to raise_error('Empty option value supplied')
+        end
+      end
+    end
+
+    context 'when a valid value' do
+      it 'returns it' do
+        expect(opt.validate('testing')).to eq 'testing'
+      end
+    end
+  end
+
+end

data/spec/lib/opt_parse_validator/opts/boolean_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe OptParseValidator::OptBoolean do
+
+  subject(:opt) { described_class.new(['-b', '--bool BOOL']) }
+
+  describe '#validate' do
+    context 'when does not match TRUE_PATTERN and FALSE_PATTERN' do
+      it 'raises an error' do
+        expect { opt.validate("true\nfalse") }
+          .to raise_error('Invalid boolean value, expected true|t|yes|y|1|false|f|no|n|0')
+      end
+    end
+
+    context 'when matches TRUE_PATTERN' do
+      after { expect(opt.validate(@argument)).to be true }
+
+      %w(true t yes y 1).each do |arg|
+        it 'returns true' do
+          @argument = arg
+        end
+      end
+    end
+
+    context 'when matches FALSE_PATTERN' do
+      after { expect(opt.validate(@argument)).to be false }
+
+      %w(false f no n 0).each do |arg|
+        it 'returns false' do
+          @argument = arg
+        end
+      end
+    end
+  end
+
+end

data/spec/lib/opt_parse_validator/opts/choice_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe OptParseValidator::OptChoice do
+  subject(:opt) { described_class.new(option, attrs) }
+  let(:option)  { %w(-f --format FORMAT) }
+  let(:attrs)   { { choices: %w(json cli) } }
+
+  describe '#new' do
+    context 'when errors' do
+      after { expect { opt }.to raise_error(@exception) }
+
+      context 'when :choices not provided' do
+        let(:attrs) { {} }
+
+        it 'raises an error' do
+          @exception = 'The :choices attribute is mandatory'
+        end
+      end
+
+      context 'when :choices is not an array' do
+        let(:attrs) { { choices: 'wrong type' } }
+
+        it 'raises an error' do
+          @exception = 'The :choices attribute must be an array'
+        end
+      end
+    end
+
+    context 'when valid' do
+      it 'sets the option correctly' do
+        expect { opt }.to_not raise_error
+        expect(opt.attrs[:choices]).to eq attrs[:choices]
+      end
+    end
+  end
+
+  describe '#validate' do
+    after :each do
+      if @exception
+        expect { opt.validate(@value) }.to raise_error(@exception)
+      else
+        expect(opt.validate(@value)).to eq(@expected)
+      end
+    end
+
+    context 'when the value is not in the choices' do
+      it 'raises an error' do
+        @value     = 'invalid-format'
+        @exception = "'invalid-format' is not a valid choice, expected one of the followings: json,cli"
+      end
+
+      context 'when :case_sensitive' do
+        let(:attrs) { { choices: %w(json cli), case_sensitive: true } }
+
+        it 'raises an error' do
+          @value     = 'JSON'
+          @exception = "'JSON' is not a valid choice, expected one of the followings: json,cli"
+        end
+      end
+    end
+
+    context 'when valid choice' do
+      it 'returns the choice' do
+        @value    = 'JSON'
+        @expected = 'json'
+      end
+
+      context 'when :case_sensitive' do
+        let(:attrs) { { choices: %w(JSON cli), case_sensitive: true } }
+
+        it 'raises an error' do
+          @value    = 'JSON'
+          @expected = 'JSON'
+        end
+      end
+    end
+  end
+end

data/spec/lib/opt_parse_validator/opts/credentials_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe OptParseValidator::OptCredentials do
+
+  subject(:opt) { described_class.new(['-l', '--login USERNAME:PASSWORD']) }
+
+  describe '#validate' do
+    context 'when incorrect format' do
+      it 'raises an error' do
+        expect { opt.validate('wrong') }
+          .to raise_error 'Incorrect credentials format, username:password expected'
+      end
+    end
+
+    context 'when valid format' do
+      it 'returns a hash with :username and :password' do
+        expect(opt.validate('admin:P@ssw:rd'))
+          .to eq(username: 'admin', password: 'P@ssw:rd')
+      end
+    end
+  end
+
+end

data/spec/lib/opt_parse_validator/opts/direcyory_path_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe OptParseValidator::OptDirectoryPath do
+
+  subject(:opt) { described_class.new(['-d', '--dir DIR'], attrs) }
+  let(:attrs)   { {} }
+  let(:dir)     { File.join(FIXTURES, 'options_file') }
+
+  its(:attrs) { should eq directory: true }
+
+  describe '#validate' do
+    context 'when it is a directory' do
+      it 'returns the path' do
+        expect(opt.validate(dir)).to eq dir
+      end
+    end
+
+    context 'when it\s not ' do
+      it 'raises an error' do
+        expect { opt.validate('yolo.txt') }.to raise_error "'yolo.txt' is not a directory"
+      end
+    end
+  end
+
+end

data/spec/lib/opt_parse_validator/opts/file_path_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+
+describe OptParseValidator::OptFilePath do
+
+  subject(:opt)  { described_class.new(['-f', '--file FILE_PATH'], attrs) }
+  let(:attrs)    { {} }
+  let(:rwx_file) { File.join(FIXTURES, 'rwx.txt') }
+  let(:r_file)  { File.join(FIXTURES, 'r.txt') }
+
+  its(:attrs)    { should eq file: true }
+
+  describe '#validate' do
+    context 'when :extensions' do
+      let(:attrs) { { extensions: 'txt' } }
+
+      its('allowed_attrs.first') { should eq :extensions }
+
+      context 'when it matches' do
+        it 'returns the path' do
+          expect(opt.validate(rwx_file)).to eq rwx_file
+        end
+      end
+
+      context 'when it does no match' do
+        it 'raises an error' do
+          expect { opt.validate('yolo.aa') }
+            .to raise_error "The extension of 'yolo.aa' is not allowed"
+        end
+      end
+    end
+
+    context 'when :executable' do
+      let(:attrs) { { executable: true } }
+
+      it 'returns the path if the file is +x' do
+        expect(opt.validate(rwx_file)).to eq rwx_file
+      end
+
+      it 'raises an error if not ' do
+        expect { opt.validate(r_file) }.to raise_error "'#{r_file}' is not executable"
+      end
+    end
+
+    context 'when :readable' do
+      let(:attrs) { { readable: true, exists: false } }
+
+      it 'returns the path if the file is +r' do
+        expect(opt.validate(rwx_file)).to eq rwx_file
+      end
+
+      it 'raises an error otherwise' do
+        file = File.join(FIXTURES, 'yolo.txt')
+
+        expect { opt.validate(file) }.to raise_error "'#{file}' is not readable"
+      end
+    end
+
+    context 'when :writable' do
+      context 'when the path exists' do
+        let(:attrs) { { writable: true } }
+
+        it 'returns the path if the path is +x' do
+          expect(opt.validate(rwx_file)).to eq rwx_file
+        end
+
+        it 'raises an error otherwise' do
+          expect { opt.validate(r_file) }.to raise_error "'#{r_file}' is not writable"
+        end
+      end
+
+      context 'when it does not exist' do
+        let(:attrs) { { writable: true, exists: false } }
+
+        context 'when the parent directory is +w' do
+          let(:file) { File.join(FIXTURES, 'options_file', 'not_there.txt') }
+
+          it 'returns the path' do
+            expect(opt.validate(file)).to eq file
+          end
+        end
+
+        context 'when the parent directory is not +w' do
+          let(:file) { File.join(FIXTURES, 'hfjhg', 'yolo.rb') }
+
+          it 'raises an error' do
+            expect { opt.validate(file) }.to raise_error "'#{file}' is not writable"
+          end
+        end
+      end
+    end
+  end
+
+end

data/spec/lib/opt_parse_validator/opts/integer_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe OptParseValidator::OptInteger do
+
+  subject(:opt) { described_class.new(['-i', '--int INT']) }
+
+  describe '#validate' do
+    context 'when not an integer' do
+      it 'raises an error' do
+        expect { opt.validate('a') }.to raise_error('a is not an integer')
+      end
+    end
+
+    it 'returns the integer' do
+      expect(opt.validate('12')).to eq 12
+    end
+  end
+
+end

data/spec/lib/opt_parse_validator/opts/path_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe OptParseValidator::OptPath do
+
+  # Everything is handled in OptFilePath & OptDirectoryPath
+
+end

data/spec/lib/opt_parse_validator/opts/positive_integer_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe OptParseValidator::OptPositiveInteger do
+
+  subject(:opt) { described_class.new(['-i', '--int INT']) }
+
+  describe '#validate' do
+    context 'when not > 0' do
+      it 'raises an error' do
+        expect { opt.validate('-3') }.to raise_error('-3 is not > 0')
+      end
+    end
+
+    it 'returns the integer' do
+      expect(opt.validate('20')).to eq 20
+    end
+  end
+
+end

data/spec/lib/opt_parse_validator/opts/proxy_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe OptParseValidator::OptProxy do
+
+  subject(:opt) { described_class.new(['--proxy PROXY'], attrs) }
+  let(:attrs)   { { protocols: %w(http https socks socks5 socks4) } }
+
+  describe '#validate' do
+    # Handled by OptURI
+  end
+
+end

data/spec/lib/opt_parse_validator/opts/uri_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe OptParseValidator::OptURI do
+
+  subject(:opt) { described_class.new(['-u', '--uri URI'], attrs) }
+  let(:attrs)   { {} }
+
+  describe '#new, #allowed_protocols' do
+    context 'when no attrs supplied' do
+      its(:allowed_protocols) { should be_empty }
+    end
+
+    context 'when only one protocol supplied' do
+      let(:attrs) { { protocols: 'http' } }
+
+      it 'sets it' do
+        opt.allowed_protocols << 'ftp'
+        expect(opt.allowed_protocols).to eq %w(http ftp)
+      end
+    end
+
+    context 'when multiple protocols are given' do
+      let(:attrs) { { protocols: %w(ftp https) } }
+
+      it 'sets them' do
+        expect(opt.allowed_protocols).to eq attrs[:protocols]
+      end
+    end
+  end
+
+  describe '#validate' do
+    context 'when the allowed_protocols is empty' do
+      it 'accepts all protocols' do
+        %w(http ftp file).each do |p|
+          expected = "#{p}://testing"
+
+          expect(opt.validate(expected)).to eq expected
+        end
+      end
+    end
+
+    context 'when allowed_protocols is set' do
+      let(:attrs) { { protocols: %w(https) } }
+
+      it 'raises an error if the protocol is not allowed' do
+        expect { opt.validate('ftp://ishouldnotbethere') }
+          .to raise_error(Addressable::URI::InvalidURIError)
+      end
+
+      it 'returns the uri string if valid' do
+        expected = 'https://example.com/'
+
+        expect(opt.validate(expected)).to eq expected
+      end
+    end
+  end
+
+end

data/spec/lib/opt_parse_validator/opts/url_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe OptParseValidator::OptURL do
+
+  subject(:opt) { described_class.new(['-u', '--url URL']) }
+
+  describe '#validate' do
+    context 'when the url is empty' do
+      it 'raises an error' do
+        expect { opt.validate('') }.to raise_error(Addressable::URI::InvalidURIError)
+      end
+    end
+
+    context 'when the protocol is not allowed' do
+      it 'raises an error' do
+        expect { opt.validate('ftp://ftp.domain.com') }
+          .to raise_error(Addressable::URI::InvalidURIError)
+      end
+    end
+
+    it 'returns the url' do
+      url = 'https://duckduckgo.com/'
+
+      expect(opt.validate(url)).to eq url
+    end
+  end
+
+end

data/spec/lib/opt_parse_validator/version_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe OptParseValidator do
+  it 'returns the version' do
+    expect(OptParseValidator::VERSION).to be >= '0'
+  end
+end