wg-metasploit_data_models 4.1.4.01 → 4.1.4.02

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

@@ -0,0 +1,925 @@
+RSpec.describe MetasploitDataModels::Search::Visitor::Relation, type: :model do
+  subject(:visitor) do
+    described_class.new(
+        :query => query
+    )
+  end
+
+  let(:formatted) do
+    # needs to be a valid operation so that query is valid
+    "name:\"#{value}\""
+  end
+
+  let(:klass) {
+    Mdm::Host
+  }
+
+  let(:query) do
+    Metasploit::Model::Search::Query.new(
+        :formatted => formatted,
+        :klass => klass
+    )
+  end
+
+  let(:value) {
+    FactoryBot.generate :mdm_host_name
+  }
+
+  it_should_behave_like 'Metasploit::Concern.run'
+
+  context 'validations' do
+    context 'query' do
+      it { is_expected.to validate_presence_of(:query) }
+
+      context 'valid' do
+        let(:error) do
+          I18n.translate('errors.messages.invalid')
+        end
+
+        let(:errors) do
+          visitor.errors[:query]
+        end
+
+        context 'with query' do
+          let(:query) do
+            double('Query')
+          end
+
+          before(:example) do
+            allow(query).to receive(:valid?).and_return(query)
+
+            visitor.valid?
+          end
+
+          context 'with valid' do
+            let(:valid) do
+              true
+            end
+
+            it 'should not record error' do
+              expect(errors).not_to include(error)
+            end
+          end
+
+          context 'without valid' do
+            let(:valid) do
+              false
+            end
+
+            it 'should record error' do
+              expect(errors).not_to include(error)
+            end
+          end
+        end
+
+        context 'without query' do
+          let(:query) do
+            nil
+          end
+
+          it 'should not record error' do
+            expect(errors).not_to include(error)
+          end
+        end
+      end
+    end
+  end
+
+  context '#visit' do
+    subject(:visit) do
+      visitor.visit
+    end
+
+    context 'MetasploitDataModels::Search::Visitor::Includes' do
+      subject(:includes_visitor) do
+        visitor.visitor_by_relation_method[:includes]
+      end
+
+      it 'should visit Metasploit::Model::Search::Query#tree' do
+        expect(includes_visitor).to receive(:visit).with(query.tree)
+
+        visit
+      end
+
+      it 'should pass visited to ActiveRecord::Relation#includes' do
+        visited = double('Visited')
+        allow(includes_visitor).to receive(:visit).with(query.tree).and_return(visited)
+
+        expect_any_instance_of(ActiveRecord::Relation).to receive(:includes).with(visited).and_return(query.klass.all)
+
+        visit
+      end
+    end
+
+    context 'MetasploitDataModels::Search::Visitor::Joins' do
+      subject(:joins_visitor) do
+        visitor.visitor_by_relation_method[:joins]
+      end
+
+      it 'should visit Metasploit::Model::Search::Query#tree' do
+        expect(joins_visitor).to receive(:visit).with(query.tree)
+
+        visit
+      end
+
+      it 'should pass visited to ActiveRecord::Relation#joins' do
+        visited = double('Visited')
+        allow(joins_visitor).to receive(:visit).with(query.tree).and_return(visited)
+
+        expect_any_instance_of(ActiveRecord::Relation).to receive(:joins).with(visited).and_return(query.klass.all)
+
+        visit
+      end
+    end
+
+    context 'MetasploitDataModels::Search::Visitor::Where' do
+      subject(:where_visitor) do
+        visitor.visitor_by_relation_method[:where]
+      end
+
+      it 'should visit Metasploit::Model::Search::Query#tree' do
+        expect(where_visitor).to receive(:visit).with(query.tree)
+
+        visit
+      end
+
+      it 'should pass visited to ActiveRecord::Relation#includes' do
+        visited = double('Visited')
+        allow(where_visitor).to receive(:visit).with(query.tree).and_return(visited)
+
+        expect_any_instance_of(ActiveRecord::Relation).to receive(:where).with(visited).and_return(query.klass.all)
+
+        visit
+      end
+    end
+
+    context 'matching record' do
+      context 'Metasploit::Model::Search::Query#klass' do
+        context 'with Mdm::Service' do
+          include_context 'Rex::Text'
+
+          #
+          # lets
+          #
+
+          let(:klass) {
+            Mdm::Service
+          }
+
+          #
+          # Don't use factories to prevent prefix aliasing when sequences go from 1 to 10 or 10 to 100
+          #
+
+          let(:non_matching_host) {
+            FactoryBot.create(
+                :mdm_host,
+                address: non_matching_host_address,
+                name: non_matching_host_name,
+                os_flavor: non_matching_host_os_flavor,
+                os_name: non_matching_host_os_name,
+                os_sp: non_matching_host_os_sp
+            ).tap { |host|
+              FactoryBot.create(
+                  :mdm_host_tag,
+                  host: host,
+                  tag: non_matching_tag
+              )
+            }
+          }
+
+          let(:non_matching_host_address) {
+            '5.6.7.8'
+          }
+
+          let(:non_matching_host_name) {
+            'mdm_host_name_b'
+          }
+
+          let(:non_matching_host_os_flavor) {
+            'mdm_host_os_flavor_b'
+          }
+
+          let(:non_matching_host_os_name) {
+            'mdm_host_os_name_b'
+          }
+
+          let(:non_matching_host_os_sp) {
+            'mdm_host_os_sp_b'
+          }
+
+          let(:non_matching_info) {
+            'mdm_service_info_c'
+          }
+
+          let(:non_matching_name) {
+            'mdm_service_name_c'
+          }
+
+          let(:non_matching_port) {
+            3
+          }
+
+          let(:non_matching_proto) {
+            'udp'
+          }
+
+          let(:non_matching_tag) {
+            FactoryBot.create(
+                :mdm_tag,
+                desc: non_matching_tag_desc,
+                name: non_matching_tag_name
+            )
+          }
+
+          let(:non_matching_tag_desc) {
+            'Mdm::Tag#description b'
+          }
+
+          let(:non_matching_tag_name) {
+            'mdm_tag_name.b'
+          }
+
+          #
+          # let!s
+          #
+
+          let!(:non_matching_record) {
+            FactoryBot.create(
+                :mdm_service,
+                host: non_matching_host,
+                info: non_matching_info,
+                name: non_matching_name,
+                port: non_matching_port,
+                proto: non_matching_proto
+            )
+          }
+
+          context 'with port' do
+            #
+            # lets
+            #
+
+            let(:matching_ports) {
+              [
+                  1,
+                  2
+              ]
+            }
+
+            let(:matching_records) {
+              matching_record_by_port.values
+            }
+
+            #
+            # let!s
+            #
+
+            let!(:matching_record_by_port) {
+              matching_ports.each_with_object({}) { |matching_port, matching_record_by_port|
+                matching_record_by_port[matching_port] = FactoryBot.create(
+                    :mdm_service,
+                    port: matching_port
+                )
+              }
+            }
+
+            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}}
+              }
+
+              it 'should find all records with the matching ports once' do
+                expect(visit).to match_array(matching_records)
+              end
+            end
+          end
+
+          context 'with single matching record' do
+            #
+            # lets
+            #
+
+            #
+            # Don't use factories to prevent prefix aliasing when sequences go from 1 to 10 or 10 to 100
+            #
+
+            let(:matching_host) {
+              FactoryBot.create(
+                  :mdm_host,
+                  address: matching_host_address,
+                  name: matching_host_name,
+                  os_flavor: matching_host_os_flavor,
+                  os_name: matching_host_os_name,
+                  os_sp: matching_host_os_sp
+              ).tap { |host|
+                FactoryBot.create(
+                    :mdm_host_tag,
+                    host: host,
+                    tag: matching_tag
+                )
+              }
+            }
+
+            let(:matching_host_address) {
+              '1.2.3.4'
+            }
+
+            let(:matching_host_name) {
+              'mdm_host_name_a'
+            }
+
+            let(:matching_host_os_flavor) {
+              'mdm_host_os_flavor_a'
+            }
+
+            let(:matching_host_os_name) {
+              'mdm_host_os_name_a'
+            }
+
+            let(:matching_host_os_sp) {
+              'mdm_host_os_sp_a'
+            }
+
+            let(:matching_info) {
+              'mdm_service_info_a'
+            }
+
+            let(:matching_name) {
+              'mdm_service_name_a'
+            }
+
+            let(:matching_port) {
+              1
+            }
+
+            let(:matching_proto) {
+              'tcp'
+            }
+
+            let(:matching_tag) {
+              FactoryBot.create(
+                  :mdm_tag,
+                  desc: matching_tag_desc,
+                  name: matching_tag_name
+              )
+            }
+
+            let(:matching_tag_desc) {
+              'Mdm::Tag#description a'
+            }
+
+            let(:matching_tag_name) {
+              'mdm_tag_name.a'
+            }
+
+            #
+            # let!s
+            #
+
+            let!(:matching_record) {
+              FactoryBot.create(
+                  :mdm_service,
+                  host: matching_host,
+                  info: matching_info,
+                  name: matching_name,
+                  port: matching_port,
+                  proto: matching_proto
+              )
+            }
+
+            context 'with host.address operator' do
+              let(:formatted) do
+                "host.address:#{formatted_address}"
+              end
+
+              context 'with CIDR' do
+                let(:formatted_address) {
+                  '1.3.4.5/8'
+                }
+
+                it 'should find only matching record' do
+                  expect(visit).to match_array([matching_record])
+                end
+              end
+
+              context 'with Range' do
+                let(:formatted_address) {
+                  '1.1.1.1-5.6.7.7'
+                }
+
+                it 'should find only matching record' do
+                  expect(visit).to match_array([matching_record])
+                end
+              end
+
+              context 'with single' do
+                let(:formatted_address) {
+                  '1.2.3.4'
+                }
+
+                it 'should find only matching record' do
+                  expect(visit).to match_array([matching_record])
+                end
+              end
+            end
+
+            it_should_behave_like 'MetasploitDataModels::Search::Visitor::Relation#visit matching record',
+                                  association: :host,
+                                  attribute: :name
+
+            context 'with host.os' do
+              let(:matching_host_os_flavor) {
+                'XP'
+              }
+
+              let(:matching_host_os_name) {
+                'Microsoft Windows'
+              }
+
+              let(:matching_host_os_sp) {
+                'SP1'
+              }
+
+              context 'with a combination of Mdm::Host#os_name and Mdm:Host#os_sp' do
+                let(:formatted) {
+                  %Q{host.os:"win xp"}
+                }
+
+                it 'finds matching record' do
+                  expect(visit).to match_array [matching_record]
+                end
+              end
+
+              context 'with a combination of Mdm::Host#os_flavor and Mdm::Host#os_sp' do
+                let(:formatted) {
+                  %Q{host.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{host.os:"win xp"}
+                }
+
+                let(:non_matching_host_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',
+                                  association: :host,
+                                  attribute: :os_flavor
+
+            it_should_behave_like 'MetasploitDataModels::Search::Visitor::Relation#visit matching record',
+                                  association: :host,
+                                  attribute: :os_name
+
+            it_should_behave_like 'MetasploitDataModels::Search::Visitor::Relation#visit matching record',
+                                  association: :host,
+                                  attribute: :os_sp
+
+            it_should_behave_like 'MetasploitDataModels::Search::Visitor::Relation#visit matching record',
+                                  association: {
+                                      host: :tags
+                                  },
+                                  attribute: :desc
+
+            it_should_behave_like 'MetasploitDataModels::Search::Visitor::Relation#visit matching record',
+                                  association: {
+                                      host: :tags
+                                  },
+                                  attribute: :name
+
+            it_should_behave_like 'MetasploitDataModels::Search::Visitor::Relation#visit matching record',
+                                  attribute: :info
+
+            it_should_behave_like 'MetasploitDataModels::Search::Visitor::Relation#visit matching record',
+                                  attribute: :name
+
+            it_should_behave_like 'MetasploitDataModels::Search::Visitor::Relation#visit matching record',
+                                  attribute: :proto
+
+            context 'with all operators' do
+              let(:formatted) {
+                %Q{
+                  host.address:1.3.4.5/8
+                  host.address:1.1.1.1-5.6.7.7
+                  host.address:1.2.3.4
+                  host.name:#{matching_host_name}
+                  host.os:"#{matching_host_os_name} #{matching_host_os_flavor} #{matching_host_os_sp}"
+                  host.os_flavor:#{matching_host_os_flavor}
+                  host.os_name:#{matching_host_os_name}
+                  host.os_sp:#{matching_host_os_sp}
+                  host.tags.desc:"#{matching_tag_desc}"
+                  host.tags.name:#{matching_tag_name}
+                  name:#{matching_name}
+                  port:#{matching_port}
+                  proto:#{matching_proto}
+                }
+              }
+
+              it 'finds only matching record' do
+                expect(visit).to match_array([matching_record])
+              end
+            end
+          end
+        end
+
+        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_address) {
+            '1.2.3.4'
+          }
+
+          let(:matching_record_os_flavor) {
+            'mdm_host_os_flavor_a'
+          }
+
+          let(:matching_record_os_name) {
+            'mdm_host_os_name_a'
+          }
+
+          let(:matching_record_os_sp) {
+            'mdm_host_os_sp_a'
+          }
+
+          let(:matching_record_name) {
+            'mdm_host_name_a'
+          }
+
+          let(:matching_service_name) {
+            'mdm_service_name_a'
+          }
+
+          let(:non_matching_record_address) {
+            '5.6.7.8'
+          }
+
+          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_record_name) {
+            'mdm_host_name_b'
+          }
+
+          let(:non_matching_service_name) {
+            'mdm_service_name_b'
+          }
+
+          #
+          # let!s
+          #
+
+          let!(:matching_record) do
+            FactoryBot.build(
+                :mdm_host,
+                address: matching_record_address,
+                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
+            FactoryBot.create(
+                :mdm_service,
+                host: matching_record,
+                name: matching_service_name
+            )
+          end
+
+          let!(:non_matching_record) do
+            FactoryBot.build(
+                :mdm_host,
+                address: non_matching_record_address,
+                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
+            FactoryBot.create(
+                :mdm_service,
+                host: non_matching_record,
+                name: non_matching_service_name
+            )
+          end
+
+          context 'with address operator' do
+            let(:formatted) do
+              "address:#{formatted_address}"
+            end
+
+            context 'with CIDR' do
+              let(:formatted_address) {
+                "'1.3.4.5/8'"
+              }
+
+              it 'should find only matching record' do
+                expect(visit).to match_array([matching_record])
+              end
+            end
+
+            context 'with Range' do
+              let(:formatted_address) {
+                '1.1.1.1-5.6.7.7'
+              }
+
+              it 'should find only matching record' do
+                expect(visit).to match_array([matching_record])
+              end
+            end
+
+            context 'with single' do
+              let(:formatted_address) {
+                '1.2.3.4'
+              }
+
+              it 'should find only matching record' do
+                expect(visit).to match_array([matching_record])
+              end
+            end
+          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
+
+            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{
+              address:1.3.4.5/8
+              address:1.1.1.1-5.6.7.7
+              address:1.2.3.4
+              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
+
+        context 'with Mdm::Tag' do
+          #
+          # lets
+          #
+
+          let(:klass) {
+            Mdm::Tag
+          }
+
+          let(:matching_desc) {
+            'This is a description'
+          }
+
+          let(:matching_name) {
+            'matching.tag'
+          }
+
+          let(:non_matching_desc) {
+            'This could be a description'
+          }
+
+          let(:non_matching_name) {
+            'tag.does.not.match'
+          }
+
+          #
+          # let!s
+          #
+
+          let!(:matching_record) {
+            FactoryBot.create(
+                :mdm_tag,
+                desc: matching_desc,
+                name: matching_name
+            )
+          }
+
+          let!(:non_matching_record) {
+            FactoryBot.create(
+                :mdm_tag,
+                desc: non_matching_desc,
+                name: non_matching_name
+            )
+          }
+
+          it_should_behave_like 'MetasploitDataModels::Search::Visitor::Relation#visit matching record',
+                                attribute: :desc
+
+          it_should_behave_like 'MetasploitDataModels::Search::Visitor::Relation#visit matching record',
+                                attribute: :name
+
+          context 'with all operators' do
+            let(:formatted) {
+              %Q{desc:"#{matching_desc}" name:"#{matching_name}"}
+            }
+
+            it 'should find only matching record' do
+              expect(visit).to match_array([matching_record])
+            end
+          end
+        end
+      end
+    end
+  end
+
+  context '#visitor_by_relation_method' do
+    subject(:visitor_by_relation_method) do
+      visitor.visitor_by_relation_method
+    end
+
+    context 'joins' do
+      subject(:joins) {
+        visitor_by_relation_method[:joins]
+      }
+
+      it { is_expected.to be_a MetasploitDataModels::Search::Visitor::Joins }
+    end
+
+    context 'includes' do
+      subject(:includes) {
+        visitor_by_relation_method[:includes]
+      }
+
+      it { is_expected.to be_a MetasploitDataModels::Search::Visitor::Includes }
+    end
+
+    context 'where' do
+      subject(:where) {
+        visitor_by_relation_method[:where]
+      }
+
+      it { is_expected.to be_a MetasploitDataModels::Search::Visitor::Where }
+    end
+  end
+
+  context 'visitor_class_by_relation_method' do
+    subject(:visitor_class_by_relation_method) do
+      described_class.visitor_class_by_relation_method
+    end
+
+    context 'joins' do
+      subject(:joins) {
+        visitor_class_by_relation_method[:joins]
+      }
+
+      it { is_expected.to eq(MetasploitDataModels::Search::Visitor::Joins) }
+    end
+
+    context 'includes' do
+      subject(:includes) {
+        visitor_class_by_relation_method[:includes]
+      }
+
+      it { is_expected.to eq(MetasploitDataModels::Search::Visitor::Includes) }
+    end
+
+    context 'where' do
+      subject(:where) {
+        visitor_class_by_relation_method[:where]
+      }
+
+      it { is_expected.to eq(MetasploitDataModels::Search::Visitor::Where) }
+    end
+  end
+end