metasploit_data_models 0.17.3 → 0.18.0.pre.compatibility

data/spec/app/models/metasploit_data_models/search/visitor/attribute_spec.rb

@@ -12,6 +12,40 @@ describe MetasploitDataModels::Search::Visitor::Attribute do
       visitor.visit(node)
     end
 
+    #
+    # Shared examples
+    #
+
+    shared_examples_for 'operator.klass.arel_table[operator.attribute]' do |options = {}|
+      options.assert_valid_keys(:node_class)
+
+      node_class = options.fetch(:node_class)
+
+      context "with #{node_class}" do
+        it { should be_a Arel::Attributes::Attribute }
+
+        context '#name' do
+          subject(:name) do
+            visit.name
+          end
+
+          it "should be #{node_class}#attribute" do
+            name.should == node.attribute
+          end
+        end
+
+        context '#relation' do
+          subject(:relation) do
+            visit.relation
+          end
+
+          it "should be Class#arel_table for #{node_class}#klass" do
+            relation.should == node.klass.arel_table
+          end
+        end
+      end
+    end
+
     context 'with Metasploit::Model::Search::Operator::Association' do
       let(:attribute_operator) do
         double('Attribute Operator')
@@ -40,37 +74,25 @@ describe MetasploitDataModels::Search::Visitor::Attribute do
       end
     end
 
-    context 'with Metasploit::Model::Search::Operator::Attribute' do
-      let(:node) do
+    it_should_behave_like 'operator.klass.arel_table[operator.attribute]',
+                          node_class: Metasploit::Model::Search::Operator::Attribute do
+      let(:node) {
         Metasploit::Model::Search::Operator::Attribute.new(
             # needs to be a real column so look up on AREL table works
-            :attribute => :name,
+            attribute: :name,
             # needs to be a real class so Class#arel_table works
-            :klass => Mdm::Host
+            klass: Mdm::Host
         )
-      end
-
-      it { should be_a Arel::Attributes::Attribute }
-
-      context 'name' do
-        subject(:name) do
-          visit.name
-        end
-
-        it 'should be Metasploit::Model::Search::Operator::Attribute#attribute' do
-          name.should == node.attribute
-        end
-      end
-
-      context 'relation' do
-        subject(:relation) do
-          visit.relation
-        end
+      }
+    end
 
-        it 'should be Class#arel_table for Metasploit::Model::Search::Operator::Attribute#klass' do
-          relation.should == node.klass.arel_table
-        end
-      end
+    it_should_behave_like 'operator.klass.arel_table[operator.attribute]',
+                          node_class: MetasploitDataModels::Search::Operator::Port::List do
+      let(:node) {
+        Metasploit::Model::Search::Operator::Attribute.new(
+            klass: Mdm::Service
+        )
+      }
     end
   end
 end

data/spec/app/models/metasploit_data_models/search/visitor/includes_spec.rb

@@ -15,7 +15,8 @@ describe MetasploitDataModels::Search::Visitor::Includes do
     children_classes = [
         Metasploit::Model::Search::Group::Intersection,
         Metasploit::Model::Search::Group::Union,
-        Metasploit::Model::Search::Operation::Union
+        Metasploit::Model::Search::Operation::Group::Intersection,
+        Metasploit::Model::Search::Operation::Group::Union
     ]
 
     children_classes.each do |children_class|
@@ -48,12 +49,6 @@ describe MetasploitDataModels::Search::Visitor::Includes do
       end
     end
 
-    context 'with Metasploit::Model::Search::Operation::Union' do
-      let(:node) do
-
-      end
-    end
-
     context 'with Metasploit::Model::Search::Operator::Association' do
       let(:association) do
         FactoryGirl.generate :metasploit_model_search_operator_association_association
@@ -78,6 +73,14 @@ describe MetasploitDataModels::Search::Visitor::Includes do
       it { should == [] }
     end
 
+    context 'with MetasploitDataModels::Search::Operator::Port::List' do
+      let(:node) do
+        MetasploitDataModels::Search::Operator::Port::List.new
+      end
+
+      it { should == [] }
+    end
+
     context 'with Metasploit::Model::Search::Query#tree' do
       let(:node) do
         query.tree

data/spec/app/models/metasploit_data_models/search/visitor/joins_spec.rb

@@ -12,48 +12,55 @@ describe MetasploitDataModels::Search::Visitor::Joins do
       visitor.visit(node)
     end
 
-    context 'with Metasploit::Model::Search::Group::Intersection' do
-      let(:children) do
-        2.times.collect { |n|
-          double("Child #{n}")
-        }
-      end
+    intersection_classes = [
+        Metasploit::Model::Search::Group::Intersection,
+        Metasploit::Model::Search::Operation::Group::Intersection
+    ]
 
-      let(:node) do
-        Metasploit::Model::Search::Group::Intersection.new(
-            :children => children
-        )
-      end
+    intersection_classes.each do |intersection_class|
+      context "with #{intersection_class}" do
+        let(:children) do
+          2.times.collect { |n|
+            double("Child #{n}")
+          }
+        end
+
+        let(:node) do
+          intersection_class.new(
+              :children => children
+          )
+        end
 
-      it 'should visit each child' do
-        # needed for call to visit subject
-        visitor.should_receive(:visit).with(node).and_call_original
+        it 'should visit each child' do
+          # needed for call to visit subject
+          visitor.should_receive(:visit).with(node).and_call_original
 
-        children.each do |child|
-          visitor.should_receive(:visit).with(child).and_return([])
+          children.each do |child|
+            visitor.should_receive(:visit).with(child).and_return([])
+          end
+
+          visit
         end
 
-        visit
-      end
+        it 'should return Array of all child visits' do
+          child_visits = []
 
-      it 'should return Array of all child visits' do
-        child_visits = []
+          visitor.should_receive(:visit).with(node).and_call_original
 
-        visitor.should_receive(:visit).with(node).and_call_original
+          children.each_with_index do |child, i|
+            child_visit = ["Visited Child #{i}"]
+            visitor.stub(:visit).with(child).and_return(child_visit)
+            child_visits.concat(child_visit)
+          end
 
-        children.each_with_index do |child, i|
-          child_visit = ["Visited Child #{i}"]
-          visitor.stub(:visit).with(child).and_return(child_visit)
-          child_visits.concat(child_visit)
+          visit.should == child_visits
         end
-
-        visit.should == child_visits
       end
     end
 
     union_classes = [
         Metasploit::Model::Search::Group::Union,
-        Metasploit::Model::Search::Operation::Union
+        Metasploit::Model::Search::Operation::Group::Union
     ]
 
     union_classes.each do |union_class|
@@ -237,7 +244,7 @@ describe MetasploitDataModels::Search::Visitor::Joins do
       end
     end
 
-    context "with Metasploit::Model::Search::Operator::Attribute" do
+    context 'with Metasploit::Model::Search::Operator::Attribute' do
       let(:node) do
         Metasploit::Model::Search::Operator::Attribute.new
       end
@@ -245,6 +252,14 @@ describe MetasploitDataModels::Search::Visitor::Joins do
       it { should == [] }
     end
 
+    context 'with MetasploitDataModels::Search::Operator::Port::List' do
+      let(:node) do
+        MetasploitDataModels::Search::Operator::Port::List.new
+      end
+
+      it { should == [] }
+    end
+
     context 'with Metasploit::Model::Search::Query#tree' do
       let(:node) do
         query.tree
@@ -263,7 +278,6 @@ describe MetasploitDataModels::Search::Visitor::Joins do
             Mdm::Host
           }
 
-
           context 'with name' do
             let(:name) do
               FactoryGirl.generate :mdm_host_name

data/spec/app/models/metasploit_data_models/search/visitor/method_spec.rb

@@ -24,6 +24,14 @@ describe MetasploitDataModels::Search::Visitor::Method do
       it { should == :and }
     end
 
+    context 'with Metasploit::Model::Search::Operation::Group::Intersection' do
+      let(:node_class) do
+        Metasploit::Model::Search::Operation::Group::Intersection
+      end
+
+      it { should == :and }
+    end
+
     context 'with Metasploit::Model::Search::Group::Union' do
       let(:node_class) do
         Metasploit::Model::Search::Group::Union
@@ -31,5 +39,13 @@ describe MetasploitDataModels::Search::Visitor::Method do
 
       it { should == :or }
     end
+
+    context 'with Metasploit::Model::Search::Operation::Group::Union' do
+      let(:node_class) do
+        Metasploit::Model::Search::Operation::Group::Union
+      end
+
+      it { should == :or }
+    end
   end
 end

data/spec/app/models/metasploit_data_models/search/visitor/relation_spec.rb

@@ -12,10 +12,14 @@ describe MetasploitDataModels::Search::Visitor::Relation do
     "name:\"#{value}\""
   end
 
+  let(:klass) {
+    Mdm::Host
+  }
+
   let(:query) do
     Metasploit::Model::Search::Query.new(
         :formatted => formatted,
-        :klass => Mdm::Host
+        :klass => klass
     )
   end
 
@@ -152,81 +156,285 @@ describe MetasploitDataModels::Search::Visitor::Relation do
     end
 
     context 'matching record' do
-      context 'with Mdm::Host' do
-        #
-        # lets
-        #
-        # Don't use factories to prevent prefix aliasing when sequences go from 1 to 10 or 10 to 100
-        #
-
-        let(:matching_record_name) {
-          'mdm_host_name_a'
-        }
-
-        let(:matching_service_name) {
-          'mdm_service_name_a'
-        }
-
-        let(:non_matching_record_name) {
-          'mdm_host_name_b'
-        }
-
-        let(:non_matching_service_name) {
-          'mdm_service_name_b'
-        }
-
-        #
-        # let!s
-        #
-
-        let!(:matching_record) do
-          FactoryGirl.build(
-              :mdm_host,
-              name: matching_record_name
-          )
-        end
+      context 'Metasploit::Model::Search::Query#klass' do
+        context 'with Mdm::Service' do
+          let(:klass) {
+            Mdm::Service
+          }
 
-        let!(:matching_service) do
-          FactoryGirl.create(
-              :mdm_service,
-              host: matching_record,
-              name: matching_service_name
-          )
-        end
+          let(:matching_ports) {
+            [
+                1,
+                2
+            ]
+          }
 
-        let!(:non_matching_record) do
-          FactoryGirl.build(
-              :mdm_host,
-              name: non_matching_record_name
-          )
-        end
+          let(:matching_records) {
+            matching_record_by_port.values
+          }
+
+          let(:non_matching_port) {
+            3
+          }
+
+          #
+          # let!s
+          #
+
+          let!(:matching_record_by_port) {
+            matching_ports.each_with_object({}) { |matching_port, matching_record_by_port|
+              matching_record_by_port[matching_port] = FactoryGirl.create(
+                  :mdm_service,
+                  port: matching_port
+              )
+            }
+          }
+
+          let!(:non_matching_record) {
+            FactoryGirl.create(
+                :mdm_service,
+                port: non_matching_port
+            )
+          }
+
+          context 'with port' do
+            context 'with single port number' do
+              let(:formatted) {
+                "port:#{matching_port}"
+              }
+
+              let(:matching_port) {
+                matching_ports.sample
+              }
+
+              let(:matching_record) {
+                matching_record_by_port[matching_port]
+              }
+
+              it 'should find only record with that port number' do
+                expect(visit).to match_array([matching_record])
+              end
+            end
+
+            context 'with port range' do
+              let(:formatted) {
+                "port:#{matching_ports.min}-#{matching_ports.max}"
+              }
+
+              it 'should find all records with port numbers within the range' do
+                expect(visit).to match_array(matching_records)
+              end
+            end
+
+            context 'with comma separated port numbers' do
+              let(:formatted) {
+                "port:#{matching_ports.join(',')}"
+              }
+
+              it 'should find all records with the port numbers' do
+                expect(visit).to match_array(matching_records)
+              end
+            end
+
+            context 'with overlapping comma separated port number and range' do
+              let(:matching_port) {
+                matching_ports.sample
+              }
+
+              let(:formatted) {
+                %Q{port:#{matching_port},#{matching_ports.min}-#{matching_ports.max}}
+              }
 
-        let!(:non_matching_service) do
-          FactoryGirl.create(
-              :mdm_service,
-              host: non_matching_record,
-              name: non_matching_service_name
-          )
+              it 'should find all records with the matching ports once' do
+                expect(visit).to match_array(matching_records)
+              end
+            end
+          end
+
+          context 'with all operators' do
+            let(:formatted) {
+              %Q{port:#{matching_port}}
+            }
+          end
         end
 
-        it_should_behave_like 'MetasploitDataModels::Search::Visitor::Relation#visit matching record',
-                              :attribute => :name
+        context 'with Mdm::Host' do
+          #
+          # lets
+          #
 
-        it_should_behave_like 'MetasploitDataModels::Search::Visitor::Relation#visit matching record',
-                              association: :services,
-                              attribute: :name
+          let(:klass) {
+            Mdm::Host
+          }
 
-        context 'with all operators' do
-          let(:formatted) {
-            %Q{name:"#{matching_record_name}" services.name:"#{matching_service_name}"}
+          #
+          # Don't use factories to prevent prefix aliasing when sequences go from 1 to 10 or 10 to 100
+          #
+
+          let(:matching_record_os_flavor) {
+            'mdm_host_os_flavor_a'
           }
 
-          it 'should find only matching record' do
-            if visit.to_a != [matching_record]
-              true
+          let(:matching_record_os_name) {
+            'mdm_host_os_name_a'
+          }
+
+          let(:matching_record_os_sp) {
+            'mdm_host_os_sp_a'
+          }
+
+          let(:matching_service_name) {
+            'mdm_service_name_a'
+          }
+
+          let(:matching_record_name) {
+            'mdm_host_name_a'
+          }
+
+          let(:matching_service_name) {
+            'mdm_service_name_a'
+          }
+
+          let(:non_matching_record_os_flavor) {
+            'mdm_host_os_flavor_b'
+          }
+
+          let(:non_matching_record_os_name) {
+            'mdm_host_os_name_b'
+          }
+
+          let(:non_matching_record_os_sp) {
+            'mdm_host_os_sp_b'
+          }
+
+          let(:non_matching_service_name) {
+            'mdm_service_name_b'
+          }
+
+          let(:non_matching_record_name) {
+            'mdm_host_name_b'
+          }
+
+          let(:non_matching_service_name) {
+            'mdm_service_name_b'
+          }
+
+          #
+          # let!s
+          #
+
+          let!(:matching_record) do
+            FactoryGirl.build(
+                :mdm_host,
+                name: matching_record_name,
+                os_flavor: matching_record_os_flavor,
+                os_name: matching_record_os_name,
+                os_sp: matching_record_os_sp
+            )
+          end
+
+          let!(:matching_service) do
+            FactoryGirl.create(
+                :mdm_service,
+                host: matching_record,
+                name: matching_service_name
+            )
+          end
+
+          let!(:non_matching_record) do
+            FactoryGirl.build(
+                :mdm_host,
+                name: non_matching_record_name,
+                os_flavor: non_matching_record_os_flavor,
+                os_name: non_matching_record_os_name,
+                os_sp: non_matching_record_os_sp
+            )
+          end
+
+          let!(:non_matching_service) do
+            FactoryGirl.create(
+                :mdm_service,
+                host: non_matching_record,
+                name: non_matching_service_name
+            )
+          end
+
+          it_should_behave_like 'MetasploitDataModels::Search::Visitor::Relation#visit matching record',
+                                :attribute => :name
+
+          context 'with os' do
+            let(:matching_record_os_flavor) {
+              'XP'
+            }
+
+            let(:matching_record_os_name) {
+              'Microsoft Windows'
+            }
+
+            let(:matching_record_os_sp) {
+              'SP1'
+            }
+
+            context 'with a combination of Mdm::Host#os_name and Mdm:Host#os_sp' do
+              let(:formatted) {
+                %Q{os:"win xp"}
+              }
+
+              it 'finds matching record' do
+                expect(visit).to match_array [matching_record]
+              end
             end
 
-            expect(visit).to match_array([matching_record])
+            context 'with a combination of Mdm::Host#os_flavor and Mdm::Host#os_sp' do
+              let(:formatted) {
+                %Q{os:"xp sp1"}
+              }
+
+              it 'finds matching record' do
+                expect(visit).to match_array [matching_record]
+              end
+            end
+
+            context 'with multiple records matching one word' do
+              let(:formatted) {
+                %Q{os:"win xp"}
+              }
+
+              let(:non_matching_record_os_name) {
+                'Microsoft Windows'
+              }
+
+              it 'finds only matching record by other words refining search' do
+                expect(visit).to match_array [matching_record]
+              end
+            end
+          end
+
+          it_should_behave_like 'MetasploitDataModels::Search::Visitor::Relation#visit matching record',
+                                :attribute => :os_flavor
+
+          it_should_behave_like 'MetasploitDataModels::Search::Visitor::Relation#visit matching record',
+                                :attribute => :os_name
+
+          it_should_behave_like 'MetasploitDataModels::Search::Visitor::Relation#visit matching record',
+                                :attribute => :os_sp
+
+          it_should_behave_like 'MetasploitDataModels::Search::Visitor::Relation#visit matching record',
+                                association: :services,
+                                attribute: :name
+
+          context 'with all operators' do
+            let(:formatted) {
+              %Q{name:"#{matching_record_name}" os:"#{matching_record_os_name} #{matching_record_os_flavor} #{matching_record_os_sp}" os_flavor:"#{matching_record_os_flavor}" os_name:"#{matching_record_os_name}" os_sp:"#{matching_record_os_sp}" services.name:"#{matching_service_name}"}
+            }
+
+            it 'should find only matching record' do
+              if visit.to_a != [matching_record]
+                true
+              end
+
+              expect(visit).to match_array([matching_record])
+            end
           end
         end
       end