metasploit_data_models 0.18.1 → 0.19.0

data/spec/factories/mdm/services.rb

@@ -10,7 +10,7 @@ FactoryGirl.define do
     #
     name { generate :mdm_service_name }
     port { generate :port }
-    proto 'snmp'
+    proto { generate :mdm_service_proto }
     state 'open'
 
     factory :web_service do
@@ -23,6 +23,8 @@ FactoryGirl.define do
     "mdm_service_name#{n}"
   }
 
+  sequence :mdm_service_proto, Mdm::Service::PROTOS.cycle
+
   port_bits = 16
   port_limit = 1 << port_bits
 

data/spec/lib/metasploit_data_models/ip_address/cidr_spec.rb

@@ -0,0 +1,350 @@
+require 'spec_helper'
+
+describe MetasploitDataModels::IPAddress::CIDR do
+  subject(:including_class_instance) {
+    including_class.new(
+        value: formatted_value
+    )
+  }
+
+  #
+  # lets
+  #
+
+  let(:expected_address) {
+    double(
+        '#address',
+        valid?: true
+    )
+  }
+
+  let(:expected_address_class) {
+    double(
+        '#address_class',
+        new: expected_address,
+        regexp: expected_address_class_regexp,
+        segment_class: segment_class,
+        segment_count: segment_count
+    )
+  }
+
+  let(:expected_address_class_regexp) {
+    /\d+\.\d+/
+  }
+
+  let(:formatted_value) {
+    nil
+  }
+
+  let(:including_class) {
+    expected_address_class = self.expected_address_class
+    described_class = self.described_class
+
+    Class.new(Metasploit::Model::Base) do
+      include described_class
+
+      #
+      # CIDR
+      #
+
+      cidr address_class: expected_address_class
+    end
+  }
+
+  let(:segment_bits) {
+    4
+  }
+
+  let(:segment_class) {
+    double(
+        '#address_class segment_class',
+        bits: segment_bits
+    )
+  }
+
+  let(:segment_count) {
+    2
+  }
+
+  #
+  # Callbacks
+  #
+
+  before(:each) do
+    stub_const('IncludingClass', including_class)
+  end
+
+  context 'CONSTANTS' do
+    context 'SEPARATOR' do
+      subject(:separator) {
+        described_class::SEPARATOR
+      }
+
+      it { should == '/' }
+    end
+  end
+
+  context 'validation errors on' do
+    before(:each) do
+      including_class_instance.valid?
+    end
+
+    context '#address' do
+      subject(:address_errors) {
+        including_class_instance.errors[:address]
+      }
+
+      context 'with #address' do
+        let(:expected_address) {
+          super().tap { |address|
+            expect(address).to receive(:valid?).and_return(address_valid)
+          }
+        }
+
+        let(:invalid_error) {
+          I18n.translate!('errors.messages.invalid')
+        }
+
+        context 'with valid' do
+          let(:address_valid) {
+            true
+          }
+
+          it { should_not include(invalid_error) }
+        end
+
+        context 'without valid' do
+          let(:address_valid) {
+            false
+          }
+
+          it { should include(invalid_error) }
+        end
+      end
+
+      context 'without #address' do
+        let(:expected_address) {
+          nil
+        }
+
+        let(:blank_error) {
+          I18n.translate!('errors.messages.blank')
+        }
+
+        it { should include(blank_error) }
+      end
+    end
+
+    context '#prefix_length' do
+      let(:maximum_prefix_length) {
+        segment_count * segment_bits
+      }
+
+      it 'validates it is an integer between 0 and maximum_prefix_length' do
+        expect(including_class_instance).to validate_numericality_of(:prefix_length).only_integer.is_greater_than_or_equal_to(0).is_less_than_or_equal_to(maximum_prefix_length)
+      end
+    end
+  end
+
+  context 'address_class' do
+    subject(:address_class) do
+      including_class.address_class
+    end
+
+    context 'with call to cidr' do
+      it 'is value for :address_class key passed to cidr' do
+        expect(address_class).to eq(expected_address_class)
+      end
+    end
+
+    context 'without call to cidr' do
+      let(:including_class) {
+        described_class = self.described_class
+
+        Class.new(Metasploit::Model::Base) do
+          include described_class
+        end
+      }
+
+      it { should be_nil }
+    end
+  end
+
+  context 'match_regexp' do
+    subject(:match_regexp) {
+      including_class.match_regexp
+    }
+
+    before(:each) do
+      expect(including_class).to receive(:regexp).and_return(/regexp/)
+    end
+
+    it "is regexp pinned with '\\A' and '\\z'" do
+      expect(match_regexp).to eq(/\A(?-mix:regexp)\z/)
+    end
+  end
+
+  context 'maximum_prefix_length' do
+    subject(:maximum_prefix_length) {
+      including_class.maximum_prefix_length
+    }
+
+    it 'is the total number of bits across all segments' do
+      expect(maximum_prefix_length).to eq(segment_count * segment_bits)
+    end
+  end
+
+  context 'regexp' do
+    subject(:regexp) {
+      including_class.regexp
+    }
+
+    it 'includes address_class.regexp' do
+      expect(regexp.to_s).to include(expected_address_class_regexp.to_s)
+    end
+
+    context 'Regexp#names' do
+      subject(:names) {
+        regexp.names
+      }
+
+      it { should include 'address' }
+      it { should include 'prefix_length' }
+    end
+  end
+
+  context '#address' do
+    subject(:address) {
+      including_class_instance.address
+    }
+
+    let(:expected_address_class) {
+      Class.new(Metasploit::Model::Base) {
+        attr_accessor :value
+      }.tap { |address_class|
+
+        allow(address_class).to receive(:segment_class).and_return(segment_class)
+        allow(address_class).to receive(:segment_count).and_return(segment_count)
+      }
+    }
+
+    context 'writer' do
+      #
+      # lets
+      #
+
+      let(:formatted_address) {
+        '1.2'
+      }
+
+      it 'sets address_class #value' do
+        including_class_instance
+
+        expect(expected_address_class).to receive(:new).with(
+                                              hash_including(
+                                                  value: formatted_value
+                                              )
+                                          )
+
+        including_class_instance.address = formatted_value
+      end
+    end
+  end
+
+  context '#prefix_length' do
+    subject(:prefix_length) {
+      including_class_instance.prefix_length
+    }
+
+    let(:formatted_address) {
+      ''
+    }
+
+    let(:formatted_value) {
+      "#{formatted_address}/#{formatted_prefix_length}"
+    }
+
+    context 'with integer' do
+      let(:formatted_prefix_length) {
+        expected_prefix_length.to_s
+      }
+
+      let(:expected_prefix_length) {
+        7
+      }
+
+      it 'sets #prefix_length_before_type_cast to formatted prefix length' do
+        expect(including_class_instance.prefix_length_before_type_cast).to eq(formatted_prefix_length)
+      end
+
+      it 'is set to Integer' do
+        expect(prefix_length).to eq(expected_prefix_length)
+      end
+    end
+
+    context 'without integer' do
+      let(:formatted_prefix_length) {
+        '255.255.255.0'
+      }
+
+      it 'sets #prefix_length_before_type_cast to formatted prefix length' do
+        expect(including_class_instance.prefix_length_before_type_cast).to eq(formatted_prefix_length)
+      end
+
+      it 'is set to the formatted prefix length' do
+        expect(prefix_length).to eq(formatted_prefix_length)
+      end
+    end
+  end
+
+  context '#value' do
+    subject(:value) {
+      including_class_instance.value
+    }
+
+    let(:formatted_address) {
+      '1.2'
+    }
+
+    context "with '/'" do
+      let(:formatted_value) {
+        "#{formatted_address}/#{formatted_prefix_length}"
+      }
+
+      let(:formatted_prefix_length) {
+        '7'
+      }
+
+      it "sets #address to formatted address before '/'" do
+        expect(including_class_instance).to receive(:address=).with(formatted_address)
+
+        including_class_instance.value = formatted_value
+      end
+
+      it "sets #prefix_length to formatted prefix length after '/'" do
+        expect(including_class_instance).to receive(:prefix_length=).with(formatted_prefix_length)
+
+        including_class_instance.value = formatted_value
+      end
+    end
+
+    context "without '/'" do
+      let(:formatted_value) {
+        "#{formatted_address}"
+      }
+
+
+      it "sets #address to formatted address before '/'" do
+        expect(including_class_instance).to receive(:address=).with(formatted_address)
+
+        including_class_instance.value = formatted_value
+      end
+
+      it "sets #prefix_length to nil" do
+        expect(including_class_instance).to receive(:prefix_length=).with(nil)
+
+        including_class_instance.value = formatted_value
+      end
+    end
+  end
+end

data/spec/lib/metasploit_data_models/ip_address/range_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe MetasploitDataModels::IPAddress::Range do
+  subject(:range) {
+    range_class.new
+  }
+
+  #
+  # Shared examples
+  #
+
+  shared_examples_for 'extreme' do |extreme|
+    context "##{extreme}" do
+      subject("range_#{extreme}") {
+        range.send(extreme)
+      }
+
+      before(:each) do
+        allow(range).to receive(:value).and_return(value)
+      end
+
+      context 'with #value' do
+        context 'with Range' do
+          let(:value) {
+            Range.new(0, 1)
+          }
+
+          it "is Range##{extreme} of #value" do
+            expect(send("range_#{extreme}")).to eq(value.send(extreme))
+          end
+        end
+
+        context 'without Range' do
+          let(:value) {
+            'invalid_value'
+          }
+
+          it { should be_nil }
+        end
+      end
+
+      context 'without #value' do
+        let(:value) {
+          nil
+        }
+
+        it { should be_nil }
+      end
+    end
+  end
+
+  #
+  # lets
+  #
+
+  let(:range_class) {
+    described_class = self.described_class
+
+    Class.new do
+      include described_class
+    end
+  }
+
+  context 'CONSTANTS' do
+    context 'SEPARATOR' do
+      subject(:separator) {
+        described_class::SEPARATOR
+      }
+
+      it { should == '-' }
+    end
+  end
+
+  it_should_behave_like 'extreme', :begin
+  it_should_behave_like 'extreme', :end
+
+end

data/spec/lib/metasploit_data_models/match/child_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe MetasploitDataModels::Match::Child do
+  let(:extending_class) {
+    # capture as local for Class.new block scope
+    described_class = self.described_class
+
+    Class.new(Metasploit::Model::Base) {
+      extend described_class
+
+      #
+      # Attributes
+      #
+
+      # @!attribute value
+      #   @return [String]
+      attr_accessor :value
+    }
+  }
+
+  before(:each) do
+    stub_const('ExtendingClass', extending_class)
+    stub_const('ExtendingClass::REGEXP', /\d+-\d+/)
+  end
+
+  context '#match' do
+    subject(:match) {
+      extending_class.match(formatted_value)
+    }
+
+    context 'formatted value' do
+      context 'with matching' do
+        let(:formatted_value) {
+          '1-2'
+        }
+
+        it 'returns instance of extending class' do
+          expect(match).to be_an extending_class
+        end
+
+        context '#value' do
+          subject(:value) {
+            match.value
+          }
+
+          it 'is set to formatted value' do
+            expect(value).to eq(formatted_value)
+          end
+        end
+      end
+
+      context 'without matching' do
+        let(:formatted_value) do
+          '1,2-3'
+        end
+
+        it { should be_nil }
+      end
+    end
+  end
+end