ronin-core 0.1.0.beta1

data/spec/params/types/enum_spec.rb

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

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

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

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

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