metasploit_data_models 0.18.1 → 0.19.0

data/spec/app/models/metasploit_data_models/ip_address/v4/segment/nmap/list_spec.rb

@@ -0,0 +1,278 @@
+require 'spec_helper'
+
+describe MetasploitDataModels::IPAddress::V4::Segment::Nmap::List do
+  subject(:nmap) {
+    described_class.new(
+        value: formatted_value
+    )
+  }
+
+  context 'CONSTANTS' do
+    context 'MATCH_REGEXP' do
+      subject(:match_regexp) {
+        described_class::MATCH_REGEXP
+      }
+
+      it 'matches comma separated list of segment numbers and range' do
+        expect(match_regexp).to match('1,2-3,4-5,6,7-8,9')
+      end
+
+      it 'does not match an Nmap IP address' do
+        segment = '1,2-3,4-5,6,7-8,9'
+        expect(match_regexp).not_to match(([segment]*4).join('.'))
+      end
+    end
+
+    context 'RANGE_OR_NUMBER_REGEXP' do
+      subject(:range_or_number_regexp) {
+        described_class::RANGE_OR_NUMBER_REGEXP
+      }
+
+      it 'matches a number' do
+        expect(range_or_number_regexp).to match_string_exactly('0')
+      end
+
+      it 'matches a range' do
+        expect(range_or_number_regexp).to match_string_exactly('0-255')
+      end
+    end
+
+    context 'REGEXP' do
+      subject(:regexp) {
+        described_class::REGEXP
+      }
+
+      it 'matches a number' do
+        expect(regexp).to match_string_exactly('0')
+      end
+
+      it 'matches a range' do
+        expect(regexp).to match_string_exactly('0-255')
+      end
+
+      it 'matches comma separated list of numbers' do
+        expect(regexp).to match_string_exactly('0,1,2')
+      end
+
+      it 'matches comma separated list of ranges' do
+        expect(regexp).to match_string_exactly('1-2,3-4,5-6')
+      end
+
+      it 'matches commad separated list of numbers and ranges' do
+        expect(regexp).to match_string_exactly('1,2-3,4-5,6,7-8,9')
+      end
+    end
+
+    context 'SEPARATOR' do
+      subject(:separator) {
+        described_class::SEPARATOR
+      }
+
+      it { should == ',' }
+    end
+  end
+
+  context 'validation' do
+    before(:each) do
+      nmap.valid?
+    end
+
+    context 'errors on #value' do
+      subject(:value_errors) {
+        nmap.errors[:value]
+      }
+
+      context 'with nil' do
+        let(:blank_error) {
+          I18n.translate!('errors.messages.blank')
+        }
+
+        let(:formatted_value) {
+          nil
+        }
+
+        it { should include blank_error }
+      end
+
+      context 'with matching String' do
+        context 'with valid elements' do
+          let(:formatted_value) {
+            '1,2-3'
+          }
+
+          it { should be_empty }
+        end
+
+        context 'with invalid MetasploitDataModels::IPAddress::V4::Nmap::Range' do
+          let(:error) {
+            I18n.translate!(
+                'metasploit.model.errors.models.metasploit_data_models/ip_address/v4/segment/nmap/list.attributes.value.element',
+                element: '255-0',
+                index: 1
+            )
+          }
+
+          let(:formatted_value) {
+            '1,255-0'
+          }
+
+          it 'says index of element that as invalid with the value' do
+            expect(value_errors).to include(error)
+          end
+        end
+      end
+
+      context 'without matching String' do
+        let(:array_error) {
+          I18n.translate!('metasploit.model.errors.models.metasploit_data_models/ip_address/v4/segment/nmap/list.attributes.value.array')
+        }
+
+        let(:formatted_value) {
+          'non_matching_string'
+        }
+
+        it { should include array_error }
+      end
+    end
+  end
+
+  context '#to_s' do
+    subject(:to_s) do
+      nmap.to_s
+    end
+
+    context 'with matching formatted value' do
+      let(:formatted_value) {
+        '1,2-3'
+      }
+
+      it 'returns a string equal to the original formatted value' do
+        expect(to_s).to eq(formatted_value)
+      end
+    end
+
+    context 'without matching formatted value' do
+      let(:formatted_value) {
+        Set.new([1,2])
+      }
+
+      it 'returned the formatted value as a string' do
+        expect(to_s).to eq(formatted_value.to_s)
+      end
+    end
+  end
+
+  context '#value' do
+    subject(:value) {
+      nmap.value
+    }
+
+    context 'with segment number' do
+      let(:formatted_value) {
+        number.to_s
+      }
+
+      let(:number) {
+        255
+      }
+
+      it 'has correct number of elements' do
+        expect(value.length).to eq(1)
+      end
+
+      context 'only element' do
+        subject(:element) {
+          value.first
+        }
+
+        it { should be_a MetasploitDataModels::IPAddress::V4::Segment::Single }
+
+        context 'MetasploitDataModels::IPAddress::V4::Segment::Single#value' do
+          it 'is value from formatted_value' do
+            expect(element.value).to eq(number)
+          end
+        end
+      end
+    end
+
+    context 'with segment range' do
+      let(:begin_number) {
+        0
+      }
+
+      let(:end_number) {
+        255
+      }
+
+      let(:formatted_value) {
+        "#{begin_number}-#{end_number}"
+      }
+
+      it 'has correct number of elements' do
+        expect(value.length).to eq(1)
+      end
+
+      context 'only element' do
+        subject(:element) {
+          value.first
+        }
+
+        it { should be_a MetasploitDataModels::IPAddress::V4::Segment::Nmap::Range }
+
+        context 'MetasploitDataModels::IPAddress::V4::Segment::Nmap::Range#value' do
+          subject(:element_value) {
+            element.value
+          }
+
+          context 'MetasploitDataModels::IPAddress::V4::Segment::Nmap::Range#begin' do
+            subject(:range_begin) {
+              element_value.begin
+            }
+
+            it { should be_a MetasploitDataModels::IPAddress::V4::Segment::Single }
+
+            context 'MetasploitDataModels::IPAddress::V4::Segment::Single#value' do
+              it 'is beginning of formatted value' do
+                expect(range_begin.value).to eq(begin_number)
+              end
+            end
+          end
+
+          context 'MetasploitDataModels::IPAddress::V4::Segment::Nmap::Range#end' do
+            subject(:range_end) {
+              element_value.end
+            }
+
+            it { should be_a MetasploitDataModels::IPAddress::V4::Segment::Single }
+
+            context 'MetasploitDataModels::IPAddress::V4::Segment::Single#value' do
+              it 'is beginning of formatted value' do
+                expect(range_end.value).to eq(end_number)
+              end
+            end
+          end
+        end
+      end
+    end
+
+    context 'with comma separated list of segment numbers and ranges' do
+      let(:formatted_value) {
+        '1,2-3,4-5,6,7'
+      }
+
+      it 'has correct number elements' do
+        expect(value.length).to eq(5)
+      end
+    end
+
+    context 'with additional data' do
+      let(:formatted_value) {
+        'additional_data1,2-3'
+      }
+
+      it 'is original formatted value' do
+        expect(value).to eq(formatted_value)
+      end
+    end
+  end
+end

data/spec/app/models/metasploit_data_models/ip_address/v4/segment/nmap/range_spec.rb

@@ -0,0 +1,304 @@
+require 'spec_helper'
+
+describe MetasploitDataModels::IPAddress::V4::Segment::Nmap::Range do
+  subject(:range) {
+    described_class.new(
+        value: formatted_value
+    )
+  }
+
+  #
+  # lets
+  #
+
+  let(:formatted_value) {
+    nil
+  }
+
+  context 'validations' do
+    #
+    # lets
+    #
+
+    let(:presence_error) {
+      I18n.translate!('errors.messages.blank')
+    }
+
+    let(:invalid_error) {
+      I18n.translate!('errors.messages.invalid')
+    }
+
+    #
+    # Callbacks
+    #
+
+    before(:each) do
+      range.valid?
+    end
+
+    context 'errors on #begin' do
+      subject(:begin_errors) {
+        range.errors[:begin]
+      }
+
+      context '#begin' do
+        context 'with nil' do
+          let(:formatted_value) {
+            nil
+          }
+
+          it { should include presence_error }
+        end
+
+        context 'with MetasploitDataModels::IPAddress::V4::Segment' do
+          context 'with valid' do
+            let(:formatted_value) {
+              '1-256'
+            }
+
+            it { should_not include invalid_error }
+          end
+
+          context 'without valid' do
+            let(:formatted_value) {
+              '256-257'
+            }
+
+            it { should include invalid_error }
+          end
+        end
+      end
+    end
+
+    context 'errors on #end' do
+      subject(:end_errors) {
+        range.errors[:end]
+      }
+
+      context '#end' do
+        context 'with nil' do
+          let(:formatted_value) {
+            nil
+          }
+
+          it { should include presence_error }
+        end
+
+        context 'with MetasploitDataModels::IPAddress::V4::Segment' do
+          context 'with valid' do
+            let(:formatted_value) {
+              '256-1'
+            }
+
+            it { should_not include invalid_error }
+          end
+
+          context 'without valid' do
+            let(:formatted_value) {
+              '257-256'
+            }
+
+            it { should include invalid_error }
+          end
+        end
+      end
+    end
+
+    context 'errors on #value' do
+      subject(:value_errors) {
+        range.errors[:value]
+      }
+
+      let(:error) {
+        I18n.translate!(
+            'metasploit.model.errors.models.metasploit_data_models/ip_address/v4/segment/nmap/range.attributes.value.order',
+            begin: range.begin,
+            end: range.end
+        )
+      }
+
+      context 'with nil' do
+        let(:formatted_value) {
+          nil
+        }
+
+        it { should_not include error }
+      end
+
+      context 'with incomparables' do
+        let(:formatted_value) {
+          'a-1'
+        }
+
+        it { should_not include error }
+      end
+
+      context 'with numbers' do
+        context 'in order' do
+          let(:formatted_value) {
+            '1-2'
+          }
+
+          it { should_not include error }
+        end
+
+        context 'out of order' do
+          let(:formatted_value) {
+            '2-1'
+          }
+
+          it { should include error }
+        end
+      end
+    end
+  end
+
+  context 'match_regexp' do
+    subject(:match_regexp) do
+      described_class::match_regexp
+    end
+
+    it 'matches range exactly' do
+      expect(match_regexp).to match_string_exactly('0-255')
+    end
+  end
+
+  context 'regexp' do
+    subject(:regexp) {
+      described_class::regexp
+    }
+
+    it 'does not match a single segment number' do
+      expect(regexp).not_to match('255')
+    end
+
+    it 'does not match separator by itself' do
+      expect(regexp).not_to match('-')
+    end
+
+    it 'does not match range with only one extreme' do
+      expect(regexp).not_to match('0-')
+      expect(regexp).not_to match('-255')
+    end
+
+    it 'matches range' do
+      expect(regexp).to match_string_exactly('0-255')
+    end
+  end
+
+  context '#to_s' do
+    subject(:to_s) {
+      range.to_s
+    }
+
+    context 'with Range' do
+      let(:formatted_value) {
+        '1-2'
+      }
+
+      it 'equals the original formatted value' do
+        expect(to_s).to eq(formatted_value)
+      end
+    end
+
+    context 'without Range' do
+      let(:formatted_value) {
+        '1..2'
+      }
+
+      it { should == '-' }
+    end
+  end
+
+  context '#value' do
+    subject(:value) {
+      range.value
+    }
+
+    context 'with -' do
+      context 'with extremes' do
+        let(:formatted_value) {
+          '1-2'
+        }
+
+        it { should be_a Range }
+
+        context 'Range#begin' do
+          subject(:range_begin) {
+            value.begin
+          }
+
+          it { should be_a MetasploitDataModels::IPAddress::V4::Segment::Single }
+
+          context 'MetasploitDataModels::IPAddress::V4::Segment::Single#value' do
+            it "is value before '-'" do
+              expect(range_begin.value).to eq(1)
+            end
+          end
+        end
+
+        context 'Range#end' do
+          subject(:range_end) {
+            value.end
+          }
+
+          it { should be_a MetasploitDataModels::IPAddress::V4::Segment::Single }
+
+          context 'MetasploitDataModels::IPAddress::V4::Segment::Single#value' do
+            it "is value after '-'" do
+              expect(range_end.value).to eq(2)
+            end
+          end
+        end
+      end
+
+      context 'without extremes' do
+        let(:formatted_value) {
+          '-'
+        }
+
+        it { should be_a Range }
+
+        context 'Range#begin' do
+          subject(:range_begin) {
+            value.begin
+          }
+
+          it { should be_a MetasploitDataModels::IPAddress::V4::Segment::Single }
+
+          context 'MetasploitDataModels::IPAddress::V4::Segment::Single#value' do
+            subject(:begin_value) {
+              range_begin.value
+            }
+
+            it { should == '' }
+          end
+        end
+
+        context 'Range#end' do
+          subject(:range_end) {
+            value.end
+          }
+
+          it { should be_a MetasploitDataModels::IPAddress::V4::Segment::Single }
+
+          context 'MetasploitDataModels::IPAddress::V4::Segment::Single#value' do
+            subject(:end_value) {
+              range_end.value
+            }
+
+            it { should == '' }
+          end
+        end
+      end
+    end
+
+    context 'without -' do
+      let(:formatted_value) do
+        '1'
+      end
+
+      it { should_not be_a Range }
+    end
+  end
+end