metasploit-model 0.24.1.pre.semantic.pre.versioning.pre.2.pre.0

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

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

@@ -0,0 +1,230 @@
+require 'spec_helper'
+
+describe Metasploit::Model::Search do
+  subject(:base_instance) do
+    base_class.new
+  end
+
+  let(:base_class) do
+    Class.new
+  end
+
+  before(:each) do
+    # class needs to be named or search_i18n_scope will error
+    stub_const('Searched', base_class)
+
+    base_class.send(:include, described_class)
+  end
+
+  it { should be_a Metasploit::Model::Search::Association }
+  it { should be_a Metasploit::Model::Search::Attribute }
+  it { should be_a Metasploit::Model::Search::With }
+
+  context 'search_operator_by_name' do
+    subject(:search_operator_by_name) do
+      base_class.search_operator_by_name
+    end
+
+    context 'with search attribute' do
+      let(:attribute) do
+        :searched_attribute
+      end
+
+      before(:each) do
+        base_class.search_attribute attribute, :type => :string
+      end
+
+      context 'operator' do
+        subject(:operator) do
+          search_operator_by_name[attribute]
+        end
+
+        context 'name' do
+          subject(:name) do
+            operator.name
+          end
+
+          it 'should be same as the attribute' do
+            name.should == attribute
+          end
+        end
+      end
+    end
+
+    context 'with search association' do
+      let(:association) do
+        :associated_things
+      end
+
+      before(:each) do
+        base_class.search_association association
+      end
+
+      context 'with reflect_on_association' do
+        before(:each) do
+          base_class.send(:include, Metasploit::Model::Association)
+        end
+
+        context 'with association' do
+          let(:associated_attribute) do
+            :association_name
+          end
+
+          let(:association_class) do
+            Class.new
+          end
+
+          let(:class_name) do
+            'AssociatedThing'
+          end
+
+          before(:each) do
+            stub_const(class_name, association_class)
+
+            # Include after stub so search_i18n_scope can use Class#name without error
+            association_class.send(:include, Metasploit::Model::Search)
+            association_class.search_attribute associated_attribute, :type => :string
+
+            base_class.association association, :class_name => class_name
+          end
+
+          context 'operator' do
+            subject(:operator) do
+              search_operator_by_name[expected_name]
+            end
+
+            let(:expected_name) do
+              "#{association}.#{associated_attribute}".to_sym
+            end
+
+            it { should be_a Metasploit::Model::Search::Operator::Association }
+
+            context 'association' do
+              subject(:operator_association) do
+                operator.association
+              end
+
+              it 'should be the registered association' do
+                operator_association.should == association
+              end
+            end
+
+            context 'attribute_operator' do
+              subject(:indirect_attribute_operator) do
+                operator.attribute_operator
+              end
+
+              let(:direct_attribute_operator) do
+                association_class.search_operator_by_name.values.first
+              end
+
+              it 'should be operator from associated class' do
+                indirect_attribute_operator.should == direct_attribute_operator
+              end
+            end
+
+            context 'klass' do
+              subject(:klass) do
+                operator.klass
+              end
+
+              it 'should be class that called search_operator_by_name' do
+                klass.should == base_class
+              end
+            end
+          end
+        end
+
+        context 'without association' do
+          it 'should raise Metasploit::Model::Association::Error' do
+            expect {
+              search_operator_by_name
+            }.to raise_error(Metasploit::Model::Association::Error)
+          end
+
+          context 'error' do
+            let(:error) do
+              begin
+                search_operator_by_name
+              rescue Metasploit::Model::Association::Error => error
+                error
+              end
+            end
+
+            context 'model' do
+              subject(:model) do
+                error.model
+              end
+
+              it 'should be class on which search_operator_by_name was called' do
+                model.should == base_class
+              end
+            end
+
+            context 'name' do
+              subject(:name) do
+                error.name
+              end
+
+              it 'should be association name' do
+                name.should == association
+              end
+            end
+          end
+        end
+      end
+
+      context 'without reflect_on_association' do
+        it 'should raise ArgumentError' do
+          expect {
+            search_operator_by_name
+          }.to raise_error(
+                   NameError,
+                   "#{base_class} does not respond to reflect_on_association.  " \
+                     "It can be added to ActiveModels by including Metasploit::Model::Association into the class."
+               )
+        end
+      end
+    end
+
+    context 'with search with' do
+      let(:name) do
+        :searched_with
+      end
+
+      let(:operator) do
+        double(
+            'Operator',
+            :name => name,
+            :valid! => nil
+        )
+      end
+
+      let(:operator_class) do
+        double('Operator Class', :new => operator)
+      end
+
+      before(:each) do
+        base_class.search_with operator_class
+      end
+
+      context 'operator' do
+        subject(:named_operator) do
+          search_operator_by_name[name]
+        end
+
+        it 'should be in search_operator_by_name' do
+          named_operator.should == operator
+        end
+      end
+    end
+
+    context 'without search attribute' do
+      context 'without search association' do
+        context 'without search with' do
+          it { should be_empty }
+        end
+      end
+    end
+  end
+end