metasploit_data_models 0.17.3 → 0.18.0.pre.compatibility

data/spec/app/models/metasploit_data_models/search/operation/range_spec.rb

@@ -0,0 +1,235 @@
+require 'spec_helper'
+
+describe MetasploitDataModels::Search::Operation::Range do
+  subject(:range_operation) {
+    described_class.new(attributes)
+  }
+
+  context 'CONSTANTS' do
+    context 'SEPARATOR' do
+      subject(:separator) {
+        described_class::SEPARATOR
+      }
+
+      it { should == '-' }
+    end
+  end
+
+  context 'validations' do
+    #
+    # lets
+    #
+
+    let(:attributes) {
+      {
+          value: value
+      }
+    }
+
+    #
+    # Callbacks
+    #
+
+    before(:each) do
+      range_operation.valid?
+    end
+
+    context 'errors on #value' do
+      subject(:errors) {
+        range_operation.errors[:value]
+      }
+
+      context '#ordered' do
+        let(:error) {
+          I18n.translate!('metasploit.model.errors.models.metasploit_data_models/search/operation/range.attributes.value.order', error_attributes)
+        }
+
+        context 'with Range' do
+          context 'with begin before end' do
+            let(:error_attributes) {
+              {
+                  begin: '"1"',
+                  end: '"2"'
+              }
+            }
+
+            let(:value) {
+              '1-2'
+            }
+
+            it { should_not include(error) }
+          end
+
+          context 'with begin same as end' do
+            let(:error_attributes) {
+              {
+                  begin: '"1"',
+                  end: '"1"'
+              }
+            }
+
+            let(:value) {
+              '1-1'
+            }
+
+            it { should_not include(error) }
+          end
+
+          context 'with begin after end' do
+            let(:error_attributes) {
+              {
+                  begin: '"2"',
+                  end: '"1"'
+              }
+            }
+
+            let(:value) {
+              '2-1'
+            }
+
+            it { should include error }
+          end
+        end
+
+        context 'without Range' do
+          let(:error_attributes) {
+            {
+                begin: '"1"',
+                end: '"2"'
+            }
+          }
+
+          let(:value) {
+            '1..2'
+          }
+
+          it { should_not include(error) }
+        end
+      end
+
+      context '#range' do
+        context 'with Range' do
+          let(:value) {
+            '1-2'
+          }
+
+          it { should be_empty }
+        end
+
+        context 'without Range' do
+          let(:error) {
+            I18n.translate!('metasploit.model.errors.models.metasploit_data_models/search/operation/range.attributes.value.range')
+          }
+
+          let(:value) {
+            '1..2'
+          }
+
+          it { should include error }
+        end
+      end
+    end
+  end
+
+  context '#value' do
+    subject(:value) {
+      range_operation.value
+    }
+
+    #
+    # lets
+    #
+
+    let(:attributes) {
+      {
+          value: formatted_value
+      }
+    }
+
+    context "without '-'" do
+      let(:formatted_value) {
+        'a..b'
+      }
+
+      it 'returns unconvertable value' do
+        expect(value).to eq(formatted_value)
+      end
+    end
+
+    context "with one '-'" do
+      let(:formatted_begin) {
+        'a'
+      }
+
+      let(:formatted_end) {
+        'b'
+      }
+
+      let(:formatted_value) {
+        "#{formatted_begin}-#{formatted_end}"
+      }
+
+      it 'returns Ranges' do
+        expect(value).to be_a Range
+      end
+
+      context '#begin' do
+        subject(:range_begin) {
+          value.begin
+        }
+
+        it "is part before '-'" do
+          expect(range_begin).to eq(formatted_begin)
+        end
+      end
+
+      context '#end' do
+        subject(:range_end) {
+          value.end
+        }
+
+        it "is part after '-'" do
+          expect(range_end).to eq(formatted_end)
+        end
+      end
+    end
+
+    context "with multiple '-'" do
+      let(:formatted_begin) {
+        'a'
+      }
+
+      let(:formatted_end) {
+        'b-c'
+      }
+
+      let(:formatted_value) {
+        "#{formatted_begin}-#{formatted_end}"
+      }
+
+      it 'returns Ranges' do
+        expect(value).to be_a Range
+      end
+
+      context '#begin' do
+        subject(:range_begin) {
+          value.begin
+        }
+
+        it "is part before first '-'" do
+          expect(range_begin).to eq(formatted_begin)
+        end
+      end
+
+      context '#end' do
+        subject(:range_end) {
+          value.end
+        }
+
+        it "is part after first '-'" do
+          expect(range_end).to eq(formatted_end)
+        end
+      end
+    end
+  end
+end

data/spec/app/models/metasploit_data_models/search/operator/multitext_spec.rb

@@ -0,0 +1,162 @@
+require 'spec_helper'
+
+describe MetasploitDataModels::Search::Operator::Multitext do
+  subject(:multitext_operator) {
+    described_class.new(
+        attributes
+    )
+  }
+
+  let(:attributes) {
+    {}
+  }
+
+  context 'validations' do
+    it { should ensure_length_of(:operator_names).is_at_least(2) }
+    it { should validate_presence_of :name }
+  end
+
+  context '#children' do
+    subject(:children) {
+      multitext_operator.children(formatted_value)
+    }
+
+    let(:attributes) {
+      {
+          klass: klass,
+          operator_names: operator_names
+      }
+    }
+
+    let(:klass) {
+      Mdm::Host
+    }
+
+    let(:operator_names) {
+      [
+          :os_flavor,
+          :os_name,
+          :os_sp
+      ]
+    }
+
+    context 'with nil' do
+      let(:formatted_value) {
+        nil
+      }
+
+      it { should == [] }
+    end
+
+    context 'with empty String' do
+      let(:formatted_value) {
+        ''
+      }
+
+      it { should == [] }
+    end
+
+    context 'without quotes' do
+      let(:formatted_value) {
+        words.join(' ')
+      }
+
+      let(:words) {
+        %w{multiple words}
+      }
+
+      it 'generates a union for each word' do
+        children.each_with_index do |child, index|
+          expect(child).to be_a Metasploit::Model::Search::Operation::Group::Union
+
+          child.children.each do |grandchild|
+            expect(grandchild.value).to eq(words[index])
+          end
+        end
+      end
+    end
+
+    context 'with quotes' do
+      let(:formatted_value) {
+        %Q{"quoted words"}
+      }
+
+      it 'generates a single union for quoted words as a single argument' do
+        expect(children).to have(1).items
+
+        child = children.first
+
+        expect(child).to be_a Metasploit::Model::Search::Operation::Group::Union
+
+        child.children.each do |grandchild|
+          expect(grandchild.value).to eq('quoted words')
+        end
+      end
+    end
+  end
+
+  context '#name' do
+    subject(:name) {
+      multitext_operator.name
+    }
+
+    context 'default' do
+      it { should be_nil }
+    end
+
+    context 'setter' do
+      let(:new_name) {
+        :new_name
+      }
+
+      it 'sets #name' do
+        expect {
+          multitext_operator.name = new_name
+        }.to change(multitext_operator, :name).to(new_name)
+      end
+    end
+  end
+
+  context '#operator_names' do
+    subject(:operator_names) {
+      multitext_operator.operator_names
+    }
+
+    context 'default' do
+      it { should == [] }
+    end
+  end
+
+  context '#operators' do
+    subject(:operators) {
+      multitext_operator.operators
+    }
+
+    let(:attributes) {
+      {
+          klass: klass,
+          operator_names: operator_names
+      }
+    }
+
+    let(:klass) {
+      Mdm::Host
+    }
+
+    let(:operator_names) {
+      [
+          :os_flavor,
+          :os_name,
+          :os_sp
+      ]
+    }
+
+    it 'looks up all operators by name using #operator' do
+      operator_names.each do |operator_name|
+        expect(multitext_operator).to receive(:operator).with(operator_name).and_call_original
+      end
+
+      operators
+    end
+  end
+end

data/spec/app/models/metasploit_data_models/search/operator/port/list_spec.rb

@@ -0,0 +1,164 @@
+require 'spec_helper'
+
+describe MetasploitDataModels::Search::Operator::Port::List do
+  subject(:port_list_operator) {
+    described_class.new(
+        klass: klass
+    )
+  }
+
+  let(:klass) {
+    Mdm::Service
+  }
+
+  context 'CONSTANTS' do
+    context 'SEPARATOR' do
+      subject(:separator) {
+        described_class::SEPARATOR
+      }
+
+      it { should == ',' }
+    end
+  end
+
+  context '#attribute' do
+    subject(:attribute) {
+      port_list_operator.attribute
+    }
+
+    context 'default' do
+      it { should == :port }
+    end
+
+    context 'setter' do
+      let(:value) {
+        :alternate_port
+      }
+
+      #
+      # Callbacks
+      #
+
+      before(:each) do
+        port_list_operator.attribute = value
+      end
+
+      it 'sets #attribute' do
+        expect(port_list_operator.attribute).to eq(value)
+      end
+    end
+  end
+
+  context '#children' do
+    subject(:children) {
+      port_list_operator.children(formatted_value)
+    }
+
+    context "with ','" do
+    end
+
+    context "without ','" do
+      context "with '-'" do
+        let(:formatted_value) {
+          '1-2'
+        }
+
+        it 'includes a MetasploitDataModels::Search::Operation::Port::Range' do
+          expect(children.map(&:class)).to include(MetasploitDataModels::Search::Operation::Port::Range)
+        end
+
+        context 'MetasploitDataModels::Search::Operation::Port::Range' do
+          subject(:operation_range) {
+            children.first
+          }
+
+          context '#operator' do
+            subject(:operator) {
+              operation_range.operator
+            }
+
+            it 'is this MetasploitDataModels::Search::Operator::Port::List' do
+              expect(operator).to be(port_list_operator)
+            end
+          end
+
+          context '#value' do
+            subject(:value) {
+              operation_range.value
+            }
+
+            it { should be_a Range }
+          end
+        end
+      end
+
+      context "without '-'" do
+        let(:formatted_value) {
+          '1'
+        }
+
+        it 'includes a MetasploitDataModels::Search::Operation::Port::Number' do
+          expect(children.map(&:class)).to include(MetasploitDataModels::Search::Operation::Port::Number)
+        end
+
+        context 'MetasploitDataModels::Search::Operation::Port::Number' do
+          subject(:operation_range) {
+            children.first
+          }
+
+          context '#operator' do
+            subject(:operator) {
+              operation_range.operator
+            }
+
+            it 'is this MetasploitDataModels::Search::Operator::Port::List' do
+              expect(operator).to be(port_list_operator)
+            end
+          end
+
+          context '#value' do
+            subject(:value) {
+              operation_range.value
+            }
+
+            it { should be_an Integer }
+          end
+        end
+      end
+    end
+  end
+
+  context '#name' do
+    subject(:name) {
+      port_list_operator.name
+    }
+
+    #
+    # lets
+    #
+
+    let(:attribute) {
+      :alternate_port_list
+    }
+
+    #
+    # Callbacks
+    #
+
+    before(:each) do
+      port_list_operator.attribute = attribute
+    end
+
+    it 'is #attribute' do
+      expect(name).to eq(attribute)
+    end
+  end
+
+  context 'operator_name' do
+    subject(:operator_name) {
+      described_class.operator_name
+    }
+
+    it { should == 'port_list' }
+  end
+end