ronin-core 0.1.0.beta1 → 0.1.0

data/spec/params/types/enum_spec.rb

@@ -1,94 +0,0 @@
-require 'spec_helper'
-require 'ronin/core/params/types/enum'
-
-describe Ronin::Core::Params::Types::Enum do
-  let(:values) { [:one, :two, :three] }
-
-  subject { described_class.new(values) }
-
-  describe "#initialize" do
-    it "must set #values" do
-      expect(subject.values).to eq(values)
-    end
-
-    context "when given an empty Array" do
-      it do
-        expect {
-          described_class.new([])
-        }.to raise_error(ArgumentError,"cannot initialize an empty Enum")
-      end
-    end
-  end
-
-  describe ".[]" do
-    subject { described_class[*values] }
-
-    it "must return a new #{described_class}" do
-      expect(subject).to be_kind_of(described_class)
-    end
-
-    it "must set #values to the given arguments" do
-      expect(subject.values).to eq(values)
-    end
-
-    context "when given no arguments" do
-      it do
-        expect {
-          described_class[]
-        }.to raise_error(ArgumentError,"cannot initialize an empty Enum")
-      end
-    end
-  end
-
-  describe "#coerce" do
-    context "when givne a Symbol" do
-      context "and when the Symbol is in #values" do
-        let(:value) { values[1] }
-
-        it "must return that Symbol" do
-          expect(subject.coerce(value)).to eq(value)
-        end
-      end
-
-      context "but the Symbol is not within #values" do
-        let(:value) { :foo }
-
-        it do
-          expect {
-            subject.coerce(value)
-          }.to raise_error(Ronin::Core::Params::ValidationError,"unknown value (#{value.inspect})")
-        end
-      end
-    end
-
-    context "when given a String" do
-      context "and it maps to one of the Symbols in #values" do
-        let(:value) { values[1].to_s }
-
-        it "must return the Symbol version of the String" do
-          expect(subject.coerce(value)).to eq(values[1])
-        end
-      end
-
-      context "but it does not map to any of the Symbols in #values" do
-        let(:value) { "foo" }
-
-        it "must return the Symbol version of the String" do
-          expect {
-            subject.coerce(value)
-          }.to raise_error(Ronin::Core::Params::ValidationError,"unknown value (#{value.inspect})")
-        end
-      end
-    end
-
-    context "when given a non-Symbol and non-String object" do
-      let(:value) { Object.new }
-
-      it do
-        expect {
-          subject.coerce(value)
-        }.to raise_error(Ronin::Core::Params::ValidationError,"value must be either a Symbol or a String (#{value.inspect})")
-      end
-    end
-  end
-end

data/spec/params/types/float_spec.rb

@@ -1,107 +0,0 @@
-require 'spec_helper'
-require 'ronin/core/params/types/float'
-
-describe Ronin::Core::Params::Types::Float do
-  describe "#coerce" do
-    context "when given a Float" do
-      let(:value) { 0.5 }
-
-      it "must return the Float value" do
-        expect(subject.coerce(value)).to be(value)
-      end
-    end
-
-    context "when given a String" do
-      context "and it is in the format of a decimal number" do
-        let(:value) { '0.5' }
-
-        it "must parse the String as a Float" do
-          expect(subject.coerce(value)).to eq(value.to_f)
-        end
-
-        context "but it starts with a '+'" do
-          let(:value) { '+0.5' }
-
-          it "must parse the String as a Float" do
-            expect(subject.coerce(value)).to eq(value[1..].to_f)
-          end
-        end
-
-        context "but it starts with a '-'" do
-          let(:value) { '-0.5' }
-
-          it "must parse the String as a negative Float" do
-            expect(subject.coerce(value)).to eq(-value[1..].to_f)
-          end
-        end
-      end
-
-      context "and it is in the fomrat of a whole number" do
-        let(:value) { '1' }
-
-        it "must parse the String as a Float" do
-          expect(subject.coerce(value)).to eq(value.to_f)
-        end
-
-        context "but it starts with a '+'" do
-          let(:value) { '+1' }
-
-          it "must parse the String as a Float" do
-            expect(subject.coerce(value)).to eq(value[1..].to_f)
-          end
-        end
-
-        context "but it starts with a '-'" do
-          let(:value) { '-1' }
-
-          it "must parse the String as a negative Float" do
-            expect(subject.coerce(value)).to eq(-value[1..].to_f)
-          end
-        end
-      end
-
-      context "but it contains non-numeric characters" do
-        let(:value) { "foo" }
-
-        it do
-          expect {
-            subject.coerce(value)
-          }.to raise_error(Ronin::Core::Params::ValidationError,"value contains non-numeric characters (#{value.inspect})")
-        end
-      end
-    end
-
-    context "when given a non-Float and non-String object" do
-      context "and it defines a #to_f method" do
-        module TestTypesFloat
-          class ObjectWithToF
-            def to_f
-              0.5
-            end
-          end
-        end
-
-        let(:value) { TestTypesFloat::ObjectWithToF.new }
-
-        it "must call the #to_f method on the value" do
-          expect(subject.coerce(value)).to eq(value.to_f)
-        end
-      end
-
-      context "but it does not define a #to_f method" do
-        module TestTypesFloat
-          class ObjectWithoutToF
-          end
-        end
-
-        let(:value) { TestTypesFloat::ObjectWithoutToF.new }
-
-        it do
-          expect {
-            subject.coerce(value)
-          }.to raise_error(Ronin::Core::Params::ValidationError,"value does not define a #to_f method (#{value.inspect})")
-        end
-      end
-    end
-  end
-end

data/spec/params/types/integer_spec.rb

@@ -1,155 +0,0 @@
-require 'spec_helper'
-require 'ronin/core/params/types/integer'
-
-describe Ronin::Core::Params::Types::Integer do
-  describe "#coerce" do
-    context "when given an Integer" do
-      let(:value) { 42 }
-
-      it "must return the Integer value" do
-        expect(subject.coerce(value)).to eq(value)
-      end
-    end
-
-    context "when given a String" do
-      context "and the String contains decimal digits" do
-        let(:value) { "42" }
-
-        it "must parse the String as base 10 and return an Integer" do
-          expect(subject.coerce(value)).to eq(value.to_i)
-        end
-
-        context "and the String also starts with a '+'" do
-          let(:value) { "+42" }
-
-          it "must parse the String as base 10 and return an Integer" do
-            expect(subject.coerce(value)).to eq(value.to_i)
-          end
-        end
-
-        context "and the String also starts with a '-'" do
-          let(:value) { "-42" }
-
-          it "must parse the String as base 10 and return a negative Integer" do
-            expect(subject.coerce(value)).to eq(-value[1..].to_i)
-          end
-        end
-      end
-
-      context "and the String contains hexadecimal digits" do
-        let(:value) { "ff" }
-
-        it "must parse the String as base 16 and return an Integer" do
-          expect(subject.coerce(value)).to eq(value.to_i(16))
-        end
-
-        context "and the String also starts with a '+'" do
-          let(:value) { "+ff" }
-
-          it "must parse the String as base 16 and return an Integer" do
-            expect(subject.coerce(value)).to eq(value.to_i(16))
-          end
-        end
-
-        context "and the String also starts with a '-'" do
-          let(:value) { "-ff" }
-
-          it "must parse the String as base 16 and return a negative Integer" do
-            expect(subject.coerce(value)).to eq(-value[1..].to_i(16))
-          end
-        end
-
-        context "but the String also starts with '0x'" do
-          let(:value) { "0xff" }
-
-          it "must remove the leading '0x' before parsing the String" do
-            expect(subject.coerce(value)).to eq(value[2..].to_i(16))
-          end
-
-          context "and the String also starts with a '+'" do
-            let(:value) { "+0xff" }
-
-            it "must parse the String as base 16 and return a Integer" do
-              expect(subject.coerce(value)).to eq(value[3..].to_i(16))
-            end
-          end
-
-          context "and the String also starts with a '-'" do
-            let(:value) { "-0xff" }
-
-            it "must parse the String as base 16 and return a negative Integer" do
-              expect(subject.coerce(value)).to eq(-value[3..].to_i(16))
-            end
-          end
-        end
-      end
-
-      context "and the String starts with '0b' and only contains chars 0 and 1" do
-        let(:value) { "0b111" }
-
-        it "must parse the String as binary and return an Integer" do
-          expect(subject.coerce(value)).to eq(value[2..].to_i(2))
-        end
-
-        context "and the String also starts with a '+'" do
-          let(:value) { "+0b111" }
-
-          it "must parse the String as base 16 and return a Integer" do
-            expect(subject.coerce(value)).to eq(value[3..].to_i(2))
-          end
-        end
-
-        context "and the String also starts with a '-'" do
-          let(:value) { "-0b111" }
-
-          it "must parse the String as base 16 and return a negative Integer" do
-            expect(subject.coerce(value)).to eq(-value[3..].to_i(2))
-          end
-        end
-      end
-
-      context "but the String contains non-numeric characters" do
-        let(:value) { "bar" }
-
-        it do
-          expect {
-            subject.coerce(value)
-          }.to raise_error(Ronin::Core::Params::ValidationError,"value contains non-numeric characters (#{value.inspect})")
-        end
-      end
-    end
-
-    context "when given a non-Integer and non-String Object" do
-      context "and it defines a #to_i method" do
-        module TestTypesInteger
-          class ObjectWithToI
-            def to_i
-              42
-            end
-          end
-        end
-
-        let(:value) { TestTypesInteger::ObjectWithToI.new }
-
-        it "must call #to_i on the given value" do
-          expect(subject.coerce(value)).to eq(value.to_i)
-        end
-      end
-
-      context "but it does not define a #to_i method" do
-        module TestTypesInteger
-          class ObjectWithoutToI
-          end
-        end
-
-        let(:value) { TestTypesInteger::ObjectWithoutToI.new }
-
-        it do
-          expect {
-            subject.coerce(value)
-          }.to raise_error(Ronin::Core::Params::ValidationError,"value does not define a #to_i method (#{value.inspect})")
-        end
-      end
-    end
-  end
-end

data/spec/params/types/numeric_spec.rb

@@ -1,138 +0,0 @@
-require 'spec_helper'
-require 'ronin/core/params/types/numeric'
-
-describe Ronin::Core::Params::Types::Numeric do
-  describe "#initialize" do
-    it "must default #min to nil" do
-      expect(subject.min).to be(nil)
-    end
-
-    it "must default #max to nil" do
-      expect(subject.max).to be(nil)
-    end
-
-    it "must default #range to nil" do
-      expect(subject.range).to be(nil)
-    end
-
-    context "when given the min: keyword argument" do
-      let(:min) { 42 }
-
-      subject { described_class.new(min: min) }
-
-      it "must set #min" do
-        expect(subject.min).to eq(min)
-      end
-    end
-
-    context "when given the max: keyword argument" do
-      let(:max) { 42 }
-
-      subject { described_class.new(max: max) }
-
-      it "must set #max" do
-        expect(subject.max).to eq(max)
-      end
-    end
-
-    context "when given the range: keyword argument" do
-      let(:range) { 1..42 }
-
-      subject { described_class.new(range: range) }
-
-      it "must set #range" do
-        expect(subject.range).to eq(range)
-      end
-    end
-  end
-
-  describe "#coerce" do
-    context "when #range is set" do
-      let(:range) { 1..10 }
-
-      subject { described_class.new(range: range) }
-
-      context "and when the given number is within the range" do
-        let(:value) { 5 }
-
-        it "must return the number" do
-          expect(subject.coerce(value)).to eq(value)
-        end
-      end
-
-      context "but the given number is not within the range" do
-        let(:value) { 20 }
-
-        it do
-          expect {
-            subject.coerce(value)
-          }.to raise_error(Ronin::Core::Params::ValidationError,"value is not within the range of acceptable values #{range.begin}-#{range.end} (#{value.inspect})")
-        end
-      end
-    end
-
-    context "when #min is set" do
-      let(:min) { 10 }
-
-      subject { described_class.new(min: min) }
-
-      context "and when then value is above the #min value" do
-        let(:value) { 20 }
-
-        it "must return the value" do
-          expect(subject.coerce(value)).to eq(value)
-        end
-      end
-
-      context "and when then value is equal to the #min value" do
-        let(:value) { min }
-
-        it "must return the value" do
-          expect(subject.coerce(value)).to eq(value)
-        end
-      end
-
-      context "but when the value is below the #min value" do
-        let(:value) { 5 }
-
-        it do
-          expect {
-            subject.coerce(value)
-          }.to raise_error(Ronin::Core::Params::ValidationError,"value is below minimum value of #{min} (#{value.inspect})")
-        end
-      end
-    end
-
-    context "when #max is set" do
-      let(:max) { 10 }
-
-      subject { described_class.new(max: max) }
-
-      context "and when then value is below the #max value" do
-        let(:value) { 5 }
-
-        it "must return the value" do
-          expect(subject.coerce(value)).to eq(value)
-        end
-      end
-
-      context "and when then value is equal to the #max value" do
-        let(:value) { max }
-
-        it "must return the value" do
-          expect(subject.coerce(value)).to eq(value)
-        end
-      end
-
-      context "but when the value is above the #max value" do
-        let(:value) { 20 }
-
-        it do
-          expect {
-            subject.coerce(value)
-          }.to raise_error(Ronin::Core::Params::ValidationError,"value is above maximum value of #{max} (#{value.inspect})")
-        end
-      end
-    end
-  end
-end

data/spec/params/types/regexp_spec.rb

@@ -1,64 +0,0 @@
-require 'spec_helper'
-require 'ronin/core/params/types/regexp'
-
-describe Ronin::Core::Params::Types::Regexp do
-  describe "#coerce" do
-    context "when given a Regexp value" do
-      let(:value) { /foo/ }
-
-      it "must return the Regexp" do
-        expect(subject.coerce(value)).to eq(value)
-      end
-    end
-
-    context "when given a String value" do
-      context "and the String is of the format '/.../'" do
-        let(:value) { "/foo/" }
-
-        it "must parse the contents of the String as a Regexp" do
-          expect(subject.coerce(value)).to eq(Regexp.new(value[1..-2]))
-        end
-      end
-
-      context "but the String does not parse to a valid Regexp" do
-        let(:value) { "/foo[/" }
-
-        it do
-          expect {
-            subject.coerce(value)
-          }.to raise_error(Ronin::Core::Params::ValidationError,"value is not a valid Regexp (#{value.inspect})")
-        end
-      end
-
-      context "but the String does not start with a '/' character" do
-        let(:value) { "foo/" }
-
-        it do
-          expect {
-            subject.coerce(value)
-          }.to raise_error(Ronin::Core::Params::ValidationError,"value must be of the format '/.../' (#{value.inspect})")
-        end
-      end
-
-      context "but the String does not end with a '/' character" do
-        let(:value) { "/foo" }
-
-        it do
-          expect {
-            subject.coerce(value)
-          }.to raise_error(Ronin::Core::Params::ValidationError,"value must be of the format '/.../' (#{value.inspect})")
-        end
-      end
-    end
-
-    context "when given a non-Regexp and non-String value" do
-      let(:value) { Object.new }
-
-      it do
-        expect {
-          subject.coerce(value)
-        }.to raise_error(Ronin::Core::Params::ValidationError,"value must be either a String or a Regexp (#{value.inspect})")
-      end
-    end
-  end
-end