metasploit-model 0.24.1-java

data/spec/lib/metasploit/model/reference_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Metasploit::Model::Reference do
+  it_should_behave_like 'Metasploit::Model::Reference',
+                        namespace_name: 'Dummy' do
+    def attribute_type(attribute)
+      type_by_attribute = {
+          :designation => :string,
+          :url => :text
+      }
+
+      type = type_by_attribute.fetch(attribute)
+
+      type
+    end
+
+    def authority_with_abbreviation(abbreviation)
+      Dummy::Authority.with_abbreviation(abbreviation)
+    end
+  end
+end

data/spec/lib/metasploit/model/search/association_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Metasploit::Model::Search::Association do
+  subject(:base_class) do
+    described_class = self.described_class
+
+    Class.new do
+      include described_class
+    end
+  end
+
+  context 'search_association' do
+    it 'should add Symbol to search_association_set' do
+      association_string = 'associated_things'
+
+      base_class.class_eval do
+        search_association association_string
+      end
+
+      base_class.search_association_set.should include(association_string.to_sym)
+    end
+  end
+
+  context 'search_association_set' do
+    let(:search_association_set) do
+      base_class.search_association_set
+    end
+
+    it 'should default to an empty Set' do
+      search_association_set.should == Set.new
+    end
+  end
+end

data/spec/lib/metasploit/model/search/attribute_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+describe Metasploit::Model::Search::Attribute do
+  subject(:base_class) do
+    described_class = self.described_class
+
+    Class.new do
+      include described_class
+    end
+  end
+
+  context 'search_attribute' do
+    context 'with attribute' do
+      let(:attribute) do
+        FactoryGirl.generate :metasploit_model_search_operator_attribute_attribute
+      end
+
+      context 'with :type' do
+        let(:type) do
+          FactoryGirl.generate :metasploit_model_search_operator_attribute_type
+        end
+
+        context 'operator' do
+          subject(:operator) do
+            base_class.search_attribute attribute, :type => type
+          end
+
+          it 'should call search_with' do
+            base_class.should_receive(:search_with).with(
+                Metasploit::Model::Search::Operator::Attribute,
+                hash_including(
+                    :attribute => attribute,
+                    :type => type
+                )
+            )
+
+            operator
+          end
+
+          it 'should be in search_attribute_operator_by_attribute' do
+            # grab operator first since it calls search_attribute and populates search_attribute_operator_by_attribute
+            cached = operator
+            base_class.search_with_operator_by_name[attribute].should == cached
+          end
+
+          context 'attribute' do
+            subject(:operator_attribute) do
+              operator.attribute
+            end
+
+            it 'should be the attribute passed to search_attribute' do
+              operator_attribute.should == attribute
+            end
+          end
+
+          context 'klass' do
+            subject(:klass) do
+              operator.klass
+            end
+
+            it 'should be class on which search_attribute was called' do
+              klass.should == base_class
+            end
+          end
+
+          context 'type' do
+            subject(:operator_type) do
+              operator.type
+            end
+
+            it 'should be type passed to search_attribute' do
+              operator_type.should == type
+            end
+          end
+        end
+      end
+
+      context 'without :type' do
+        it 'should raise Metasploit::Model::Invalid' do
+          expect {
+            base_class.search_attribute(attribute)
+          }.to raise_error(Metasploit::Model::Invalid)
+        end
+      end
+    end
+
+    context 'without attribute' do
+      let(:attribute) do
+        ''
+      end
+
+      it 'should raise Metasploit::Model::Invalid' do
+        expect {
+          base_class.search_attribute attribute, :type => :string
+        }.to raise_error(Metasploit::Model::Invalid)
+      end
+    end
+  end
+end

data/spec/lib/metasploit/model/search/operation/integer/value_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Metasploit::Model::Search::Operation::Integer::Value do
+  it_should_behave_like 'Metasploit::Model::Search::Operation::Integer::Value' do
+    let(:operation_class) do
+      described_class = self.described_class
+
+      Class.new(Metasploit::Model::Base) do
+        include described_class
+
+        #
+        # Attributes
+        #
+
+        # @!attribute [rw] value
+        attr_reader :value
+      end
+    end
+  end
+end

data/spec/lib/metasploit/model/search/operation/string/value_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Metasploit::Model::Search::Operation::String::Value do
+  it_should_behave_like 'Metasploit::Model::Search::Operation::String::Value' do
+    let(:operation_class) do
+      described_class = self.described_class
+
+      Class.new(Metasploit::Model::Base) do
+        include described_class
+
+        #
+        # Attributes
+        #
+
+        # @!attribute [rw] value
+        attr_reader :value
+      end
+    end
+  end
+end

data/spec/lib/metasploit/model/search/operation_spec.rb

@@ -0,0 +1,144 @@
+require 'spec_helper'
+
+describe Metasploit::Model::Search::Operation do
+  context 'parse' do
+    subject(:parse) do
+      described_class.parse(options)
+    end
+
+    context 'with :formatted_operation' do
+      let(:formatted_operation) do
+        "#{formatted_operator}:#{formatted_value}"
+      end
+
+      let(:formatted_operator) do
+        'operator'
+      end
+
+      let(:formatted_value) do
+        'value'
+      end
+
+      let(:options) do
+        {
+            :formatted_operation => formatted_operation
+        }
+      end
+
+      context 'with :query' do
+        let(:operation) do
+          double('Operation')
+        end
+
+        let(:operator) do
+          double('Operator')
+        end
+
+        let(:options) do
+          super().merge(
+              {
+                  :query => query
+              }
+          )
+        end
+
+        let(:query) do
+          double('Metasploit::Model::Search::Query')
+        end
+
+        context "with at least one ':' in :formatted_operation" do
+          before(:each) do
+            query.stub(:parse_operator).with(formatted_operator).and_return(operator)
+            operator.stub(:operate_on).with(formatted_value).and_return(operation)
+          end
+
+          context "with multiple ':' in :formatted_operation" do
+            let(:formatted_value) do
+              '1:2'
+            end
+
+            it "should treat portion before first ':' as formatted operator" do
+              query.should_receive(:parse_operator).with(formatted_operator)
+
+              parse
+            end
+
+            it "should treat portion after first ':' as formatted value including later ':'" do
+              operator.should_receive(:operate_on).with(formatted_value)
+
+              parse
+            end
+          end
+
+          context "with single ':' in :formatted_operation" do
+            let(:formatted_value) do
+              '1'
+            end
+
+            it "should use portion before ':' as formatted operator" do
+              query.should_receive(:parse_operator).with(formatted_operator)
+
+              parse
+            end
+
+            it "should use portion after ':' as formatted value" do
+              operator.should_receive(:operate_on).with(formatted_value)
+
+              parse
+            end
+          end
+        end
+
+        context "without ':' in :formatted_operation" do
+          let(:formatted_operation) do
+            formatted_operator
+          end
+
+          let(:formatted_operator) do
+            '1'
+          end
+
+          let(:formatted_value) do
+            nil
+          end
+
+          it "should use entirety as formatted operator" do
+            operator.stub(:operate_on).and_return(operation)
+
+            query.should_receive(:parse_operator).with(formatted_operator).and_return(operator)
+
+            parse
+          end
+
+          it "should use '' as formatted value instead of nil" do
+            query.stub(:parse_operator).and_return(operator)
+
+            operator.should_receive(:operate_on).with('')
+
+            parse
+          end
+        end
+      end
+
+      context 'without :query' do
+        it 'should raise KeyError' do
+          expect {
+            parse
+          }.to raise_error(KeyError)
+        end
+      end
+    end
+
+    context 'without :formatted_operation' do
+      let(:options) do
+        {}
+      end
+
+      it 'should raise KeyError' do
+        expect {
+          parse
+        }.to raise_error(KeyError)
+      end
+    end
+  end
+end

data/spec/lib/metasploit/model/search/operator/help_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Metasploit::Model::Search::Operator::Help do
+  it_should_behave_like 'Metasploit::Model::Search::Operator::Help' do
+    let(:operator) do
+      operator_class.new(
+          klass: klass,
+          name: name
+      )
+    end
+
+    let(:operator_class) do
+      described_class = self.described_class
+
+      Class.new(Metasploit::Model::Base) do
+        include described_class
+
+        #
+        # Attributes
+        #
+
+        # @!attribute [rw] name
+        #   Name of this operator
+        #
+        #   @return [String]
+        attr_accessor :name
+
+        # @!attribute [rw] klass
+        #   Class being searched
+        #
+        #   @return [Class]
+        attr_accessor :klass
+      end
+    end
+
+    before(:each) do
+      # operator needs to be named or mode_name will fail.
+      stub_const('OperatorClass', operator_class)
+    end
+  end
+end

data/spec/lib/metasploit/model/search/with_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+describe Metasploit::Model::Search::With do
+  let(:base_class) do
+    described_class = self.described_class
+
+    Class.new do
+      include described_class
+    end
+  end
+
+  context 'search_with' do
+    subject(:search_with_operator) do
+      base_class.search_with operator_class, options
+    end
+
+    let(:options) do
+      {
+          a: 1,
+          b: 2
+      }
+    end
+
+    let(:operator) do
+      double(
+          'Operator',
+          :name => 'op',
+          :valid! => nil
+      )
+    end
+
+    let(:operator_class) do
+      double(
+          'Operator Class',
+          :new => operator
+      )
+    end
+
+    it 'should pass given options to operator_class.new' do
+      operator_class.should_receive(:new).with(
+          hash_including(options)
+      ).and_return(operator)
+
+      search_with_operator
+    end
+
+    it 'should merge :klass into options passed to operator.new' do
+      operator_class.should_receive(:new).with(
+          hash_including(
+              :klass => base_class
+          )
+      )
+
+      search_with_operator
+    end
+
+    it 'should validate operator' do
+      operator_class.stub(:new).and_return(operator)
+
+      operator.should_receive(:valid!)
+
+      search_with_operator
+    end
+
+    it 'should add operator to search_with_operator_by_name' do
+      search_with_operator
+
+      base_class.search_with_operator_by_name[operator.name].should == operator
+    end
+  end
+
+  context 'search_with_operator_by_name' do
+    subject(:search_with_operator_by_name) do
+      base_class.search_with_operator_by_name
+    end
+
+    it 'should default to empty Hash' do
+      search_with_operator_by_name.should == {}
+    end
+  end
+end