opt_parse_validator 0.0.9 → 0.0.10

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

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

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

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

@@ -1,91 +0,0 @@
-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_range_spec.rb

@@ -1,54 +0,0 @@
-require 'spec_helper'
-
-describe OptParseValidator::OptIntegerRange do
-  subject(:opt) { described_class.new(['--range RANGE'], attrs) }
-  let(:attrs)   { {} }
-
-  describe '#validate' do
-    context 'when incorrect number of ranges given' do
-      it 'raises an error' do
-        expect { opt.validate('1-2-3') }.to raise_error('Incorrect number of ranges found: 3, should be 2')
-      end
-    end
-
-    context 'when not an integer range' do
-      it 'raises an error' do
-        expect { opt.validate('a-e') }.to raise_error('Argument is not a valid integer range')
-      end
-    end
-
-    context 'when a valid range' do
-      it 'returns the range' do
-        expect(opt.validate('1-5')).to eql((1..5))
-      end
-
-      context 'when another separator' do
-        let(:attrs) { super().merge(separator: ':') }
-
-        it 'returns the range' do
-          expect(opt.validate('0:10')).to eql((0..10))
-        end
-      end
-    end
-
-    context 'when nil or "" supplied' do
-      context 'when no value_if_empty attribute' 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 value_if_empty attribute' do
-        let(:attrs) { super().merge(value_if_empty: '0-2') }
-
-        it 'returns the value_if_empty value' do
-          [nil, ''].each do |value|
-            expect(opt.validate(value)).to eql((0..2))
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,17 +0,0 @@
-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/multi_choices_spec.rb

@@ -1,105 +0,0 @@
-require 'spec_helper'
-
-describe OptParseValidator::OptMultiChoices do
-  subject(:opt) { described_class.new(['--enumerate [CHOICES]'], attrs) }
-  let(:attrs) do
-    {
-      choices: {
-        vp: OptParseValidator::OptBoolean.new(['--vulnerable-plugins']),
-        ap: OptParseValidator::OptBoolean.new(['--all-plugins']),
-        p:  OptParseValidator::OptBoolean.new(['--plugins']),
-        vt: OptParseValidator::OptBoolean.new(['--vulnerable-themes']),
-        at: OptParseValidator::OptBoolean.new(['--all-themes']),
-        t:  OptParseValidator::OptBoolean.new(['--themes']),
-        tt: OptParseValidator::OptBoolean.new(['--timthumbs']),
-        u:  OptParseValidator::OptIntegerRange.new(['--users'], value_if_empty: '1-10'),
-        m:  OptParseValidator::OptIntegerRange.new(['--media'], value_if_empty: '1-100')
-      }
-    }
-  end
-
-  describe '#new' do
-    context 'when no choices attribute' do
-      let(:attrs) { {} }
-
-      it 'raises an error' do
-        expect { opt }.to raise_error 'The :choices attribute is mandatory'
-      end
-    end
-
-    context 'when choices attribute' do
-      context 'when not a hash' do
-        let(:attrs) { { choices: 'invalid' } }
-
-        it 'raises an error' do
-          expect { opt }.to raise_error 'The :choices attribute must be a hash'
-        end
-      end
-
-      context 'when a hash' do
-        it 'does not raise any error' do
-          expect { opt }.to_not raise_error
-        end
-      end
-    end
-  end
-
-  describe '#validate' do
-    context 'when an unknown choice is given' do
-      it 'raises an error' do
-        expect { opt.validate('vp,n') }.to raise_error 'Unknown choice: n'
-      end
-    end
-
-    context 'when nil or empty value' do
-      context 'when no value_if_empty attribute' 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 value_if_empty attribute' do
-        let(:attrs) { super().merge(value_if_empty: 'vp,u') }
-
-        it 'returns the expected hash' do
-          [nil, ''].each do |value|
-            expect(opt.validate(value)).to eql(vulnerable_plugins: true, users: (1..10))
-          end
-        end
-      end
-    end
-
-    context 'when value' do
-      let(:attrs) do
-        super().merge(incompatible: [
-          [:vulnerable_plugins, :all_plugins, :plugins],
-          [:vulnerable_themes, :all_themes, :themes]
-        ])
-      end
-
-      it 'returns the expected hash' do
-        expect(opt.validate('u2-5')).to eql(users: (2..5))
-      end
-
-      context 'when incompatible choices given' do
-        it 'raises an error' do
-          {
-            'ap,p,t' => 'all_plugins, plugins',
-            'ap,t,vp' => 'vulnerable_plugins, all_plugins',
-            'ap,at,t' => 'all_themes, themes'
-          }.each do |value, msg|
-            expect { opt.validate(value) }.to raise_error "Incompatible choices detected: #{msg}"
-          end
-        end
-      end
-    end
-  end
-
-  describe '#normalize' do
-    it 'returns the same value (no normalization)' do
-      expect(opt.normalize('a')).to eql 'a'
-    end
-  end
-end

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

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

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

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

@@ -1,73 +0,0 @@
-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 }
-      its(:default_protocol) { should be nil }
-    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 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
-
-    context 'when default_protocol' do
-      let(:attrs) { { default_protocol: 'ftp' } }
-
-      context 'when the argument already contains a protocol' do
-        it 'does not add the default protocol' do
-          expect(opt.validate('http://ex.lo')).to eq 'http://ex.lo'
-        end
-      end
-
-      context 'when no protocol given in the argument' do
-        it 'adds it' do
-          expect(opt.validate('ex.lo')).to eq 'ftp://ex.lo'
-        end
-      end
-    end
-  end
-end

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

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

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