metasploit_data_models 0.18.1-java → 0.19.0-java

data/spec/app/models/metasploit_data_models/ip_address/v4/segment/segmented_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe MetasploitDataModels::IPAddress::V4::Segmented do
+  context 'CONSTANTS' do
+    context 'SEGMENT_COUNT' do
+      subject(:segment_count) {
+        described_class::SEGMENT_COUNT
+      }
+
+      it { should == 4 }
+    end
+
+    context 'SEPARATOR' do
+      subject(:separator) {
+        described_class::SEPARATOR
+      }
+
+      it { should == '.' }
+    end
+  end
+
+  context 'segment_count' do
+    subject(:segment_count) {
+      described_class.segment_count
+    }
+
+    it { should == 4 }
+  end
+end

data/spec/app/models/metasploit_data_models/ip_address/v4/segment/single_spec.rb

@@ -0,0 +1,315 @@
+require 'spec_helper'
+
+describe MetasploitDataModels::IPAddress::V4::Segment::Single do
+  subject(:single) {
+    described_class.new(
+        value: formatted_value
+    )
+  }
+
+  let(:formatted_value) {
+    nil
+  }
+
+  context 'validations' do
+    it { should validate_numericality_of(:value).is_greater_than_or_equal_to(0).is_less_than_or_equal_to(255).only_integer }
+  end
+
+  it 'can be used in a Range' do
+    expect {
+      Range.new(single, single)
+    }.not_to raise_error
+  end
+
+  context '#add_with_carry' do
+    subject(:add_with_carry) {
+      single.add_with_carry(*arguments)
+    }
+
+    let(:carry_out) {
+      add_with_carry[1]
+    }
+
+    let(:segment_out) {
+      add_with_carry[0]
+    }
+
+    context 'with carry' do
+      let(:arguments) {
+        [
+            other_single,
+            1
+        ]
+      }
+
+      context 'with overflow' do
+        let(:formatted_value) {
+          '255'
+        }
+
+        let(:other_single) {
+          described_class.new(value: 255)
+        }
+
+        it 'outputs a proper segment' do
+          expect(segment_out).to be_a described_class
+          expect(segment_out.value).to be <= 255
+          expect(segment_out.value).to eq(255)
+        end
+
+        it 'outputs a carry' do
+          expect(carry_out).to eq(1)
+        end
+      end
+
+      context 'without overflow' do
+        let(:formatted_value) {
+          '254'
+        }
+
+        let(:other_single) {
+          described_class.new(value: 0)
+        }
+
+        it 'outs a proper segment' do
+          expect(segment_out).to be_a described_class
+          expect(segment_out.value).to be <= 255
+          expect(segment_out.value).to eq(255)
+        end
+
+        it 'does not output a carry' do
+          expect(carry_out).to eq(0)
+        end
+      end
+    end
+
+    context 'without carry' do
+      let(:arguments) {
+        [
+            other_single
+        ]
+      }
+
+      context 'with overflow' do
+        let(:formatted_value) {
+          '255'
+        }
+
+        let(:other_single) {
+          described_class.new(value: 255)
+        }
+
+        it 'outputs a proper segment' do
+          expect(segment_out).to be_a described_class
+          expect(segment_out.value).to be <= 255
+          expect(segment_out.value).to eq(254)
+        end
+
+        it 'outputs a carry' do
+          expect(carry_out).to eq(1)
+        end
+      end
+
+      context 'without overflow' do
+        let(:formatted_value) {
+          '255'
+        }
+
+        let(:other_single) {
+          described_class.new(value: 0)
+        }
+
+        it 'outs a proper segment' do
+          expect(segment_out).to be_a described_class
+          expect(segment_out.value).to be <= 255
+          expect(segment_out.value).to eq(255)
+        end
+
+        it 'does not output a carry' do
+          expect(carry_out).to eq(0)
+        end
+      end
+    end
+  end
+
+  context 'bits' do
+    subject(:bits) {
+      described_class.bits
+    }
+
+    it { should == 8 }
+  end
+
+  context 'match_regexp' do
+    subject(:match_regexp) {
+      described_class.match_regexp
+    }
+
+    it 'matches segment number' do
+      expect(match_regexp).to match('255')
+    end
+
+    it 'does not match segment range' do
+      expect(match_regexp).not_to match('0-225')
+    end
+  end
+
+  context '#<=>' do
+    subject(:compare) {
+      single <=> other
+    }
+
+    let(:other) {
+      double('Other')
+    }
+
+    it 'compares #values' do
+      other_value = double('other.value')
+
+      expect(other).to receive(:value).and_return(other_value)
+      expect(single.value).to receive(:<=>).with(other_value)
+
+      compare
+    end
+  end
+
+  context '#succ' do
+    subject(:succ) {
+      single.succ
+    }
+
+    context '#value' do
+      context 'with nil' do
+        let(:formatted_value) {
+          nil
+        }
+
+        specify {
+          expect(succ).not_to raise_error
+        }
+      end
+
+      context 'with number' do
+        let(:formatted_value) {
+          value.to_s
+        }
+
+        let(:value) {
+          1
+        }
+
+        it { should be_a described_class }
+
+        context 'succ.value' do
+          it 'is succ of #value' do
+            expect(succ.value).to eq(value.succ)
+          end
+        end
+      end
+
+      context 'without number' do
+        let(:formatted_value) {
+          'a'
+        }
+
+        it { should be_a described_class }
+
+        context 'succ.value' do
+          it 'is succ of #value' do
+            expect(succ.value).to eq(single.value.succ)
+          end
+        end
+      end
+    end
+  end
+
+  context '#to_s' do
+    subject(:to_s) {
+      single.to_s
+    }
+
+    #
+    # let
+    #
+
+    let(:value) {
+      double('#value')
+    }
+
+    #
+    # Callbacks
+    #
+
+    before(:each) do
+      allow(single).to receive(:value).and_return(value)
+    end
+
+    it 'delegates to #value' do
+      expect(value).to receive(:to_s)
+
+      to_s
+    end
+  end
+
+  context '#value' do
+    subject(:value) do
+      single.value
+    end
+
+    context 'with Integer' do
+      let(:formatted_value) do
+        1
+      end
+
+      it 'should pass through Integer' do
+        value.should == formatted_value
+      end
+    end
+
+    context 'with Integer#to_s' do
+      let(:formatted_value) do
+        integer.to_s
+      end
+
+      let(:integer) do
+        1
+      end
+
+      it 'should convert String to Integer' do
+        value.should == integer
+      end
+    end
+
+    context 'with mix text and numerals' do
+      let(:formatted_value) do
+        "#{integer}mix"
+      end
+
+      let(:integer) do
+        123
+      end
+
+      it 'should not extract the number' do
+        value.should_not == integer
+      end
+
+      it 'should pass through the full value' do
+        value.should == formatted_value
+      end
+    end
+
+    context 'with Float' do
+      let(:formatted_value) do
+        0.1
+      end
+
+      it 'should not truncate Float to Integer' do
+        value.should_not == formatted_value.to_i
+      end
+
+      it 'should pass through Float' do
+        value.should == formatted_value
+      end
+    end
+  end
+end

data/spec/app/models/metasploit_data_models/ip_address/v4/single_spec.rb

@@ -0,0 +1,183 @@
+require 'spec_helper'
+
+describe MetasploitDataModels::IPAddress::V4::Single do
+  subject(:single) {
+    described_class.new(
+        value: formatted_value
+    )
+  }
+
+  context 'validation' do
+    before(:each) do
+      single.valid?
+    end
+
+    context 'errors on #segments' do
+      subject(:segments_errors) {
+        single.errors[:segments]
+      }
+
+      context 'with segments' do
+        let(:formatted_value) {
+          '1.2.3.4'
+        }
+
+        it { should be_empty }
+      end
+
+      context 'without segments' do
+        let(:formatted_value) {
+          '::1'
+        }
+
+        let(:length_error) {
+          I18n.translate!(
+              'metasploit.model.errors.models.metasploit_data_models/ip_address/v4/segmented.attributes.segments.wrong_length',
+              count: 4
+          )
+        }
+
+        it { should include length_error }
+      end
+    end
+  end
+
+  context '+' do
+    subject(:add) do
+      single + other
+    end
+
+    context 'with MetasploitDataModels::IPAddress::V4::Single' do
+      let(:other) {
+        described_class.new(
+            value: other_formatted_value
+        )
+      }
+
+      context 'with overflow' do
+        let(:formatted_value) {
+          '255.255.255.255'
+        }
+
+        let(:other_formatted_value) {
+          '0.0.0.1'
+        }
+
+        specify {
+          expect {
+            add
+          }.to raise_error(ArgumentError, "255.255.255.255 + 0.0.0.1 is not a valid IP address.  It is 0.0.0.0 with a carry (1)")
+        }
+      end
+
+      context 'without overflow' do
+        let(:formatted_value) {
+          '254.255.255.255'
+        }
+
+        context 'with ripple carry' do
+          let(:other_formatted_value) {
+            '0.0.0.1'
+          }
+
+          it 'propagates carry corretly' do
+            expect(add).to eq(described_class.new(value: '255.0.0.0'))
+          end
+        end
+
+        context 'without ripple carry' do
+          let(:formatted_value) do
+            '4.3.2.1'
+          end
+
+          let(:other_formatted_value) do
+            '5.4.3.2'
+          end
+
+          it 'adds the correct segments together' do
+            expect(add).to eq(described_class.new(value: '9.7.5.3'))
+          end
+        end
+      end
+    end
+
+    context 'without MetasploitDataMOdels::IPAddress::V4::Single' do
+      let(:formatted_value) {
+          '255.255.255.255'
+      }
+
+      let(:other) {
+        1
+      }
+
+      specify {
+        expect {
+          add
+        }.to raise_error(TypeError, "Cannot add #{other.class} to #{described_class}")
+      }
+    end
+  end
+
+  context 'regexp' do
+    subject(:regexp) {
+      described_class.regexp
+    }
+
+    it 'matches a normal IPv4 address' do
+      expect(regexp).to match_string_exactly('1.2.3.4')
+    end
+
+    it 'does matches an IPv4 Nmap address with comma separated list of numbers and ranges for each segment' do
+      expect(regexp).not_to match_string_exactly('1,2-3.4-5,6.7,8.9-10,11-12')
+    end
+  end
+
+  context '#value' do
+    subject(:value) {
+      single.value
+    }
+
+    context 'with nil' do
+      let(:formatted_value) {
+        nil
+      }
+
+      it { should be_nil }
+    end
+
+    context 'with matching formatted value' do
+      let(:formatted_value) {
+        '1.2.3.4'
+      }
+
+      it 'has 4 segments' do
+        expect(value.length).to eq(4)
+      end
+
+      it 'has MetasploitDataModels::IPAddress::V4::Segment::Single for segments' do
+        expect(
+            value.all? { |segment|
+              segment.is_a? MetasploitDataModels::IPAddress::V4::Segment::Single
+            }
+        ).to eq(true)
+      end
+
+      it 'has segments ordered from high to low' do
+        expect(value[0].value).to eq(1)
+        expect(value[1].value).to eq(2)
+        expect(value[2].value).to eq(3)
+        expect(value[3].value).to eq(4)
+      end
+    end
+
+    context 'without matching formatted value' do
+      let(:formatted_value) {
+        '1.2-3.5.6'
+      }
+
+      it 'is the formated value' do
+        expect(value).to eq(formatted_value)
+      end
+    end
+  end
+end