wg-metasploit_data_models 4.1.4.01 → 4.1.4.02

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

@@ -0,0 +1,160 @@
+RSpec.describe MetasploitDataModels::Search::Operator::Multitext, type: :model do
+  subject(:multitext_operator) {
+    described_class.new(
+        attributes
+    )
+  }
+
+  let(:attributes) {
+    {}
+  }
+
+  context 'validations' do
+    it { is_expected.to validate_length_of(:operator_names).is_at_least(2) }
+    it { is_expected.to 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 { is_expected.to eq([]) }
+    end
+
+    context 'with empty String' do
+      let(:formatted_value) {
+        ''
+      }
+
+      it { is_expected.to eq([]) }
+    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.length).to eq(1)
+
+        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 { is_expected.to 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 { is_expected.to eq([]) }
+    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,162 @@
+RSpec.describe MetasploitDataModels::Search::Operator::Port::List, type: :model 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 { is_expected.to eq(',') }
+    end
+  end
+
+  context '#attribute' do
+    subject(:attribute) {
+      port_list_operator.attribute
+    }
+
+    context 'default' do
+      it { is_expected.to eq(:port) }
+    end
+
+    context 'setter' do
+      let(:value) {
+        :alternate_port
+      }
+
+      #
+      # Callbacks
+      #
+
+      before(:example) 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 { is_expected.to 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 { is_expected.to 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(:example) 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 { is_expected.to eq('port_list') }
+  end
+end

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

@@ -0,0 +1,96 @@
+RSpec.describe MetasploitDataModels::Search::Visitor::Attribute, type: :model do
+  subject(:visitor) do
+    described_class.new
+  end
+
+  it_should_behave_like 'Metasploit::Concern.run'
+
+  context '#visit' do
+    subject(:visit) 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 { is_expected.to be_a Arel::Attributes::Attribute }
+
+        context '#name' do
+          subject(:name) do
+            visit.name
+          end
+
+          it "should be #{node_class}#attribute" do
+            expect(name).to eq(node.attribute)
+          end
+        end
+
+        context '#relation' do
+          subject(:relation) do
+            visit.relation
+          end
+
+          it "should be Class#arel_table for #{node_class}#klass" do
+            expect(relation).to eq(node.klass.arel_table)
+          end
+        end
+      end
+    end
+
+    context 'with Metasploit::Model::Search::Operator::Association' do
+      let(:source_operator) do
+        double('source operator')
+      end
+
+      let(:node) do
+        Metasploit::Model::Search::Operator::Association.new(
+            :source_operator => source_operator
+        )
+      end
+
+      it 'should visit Metasploit::Model::Search::Operator::Association#source_operator' do
+        expect(visitor).to receive(:visit).with(node).and_call_original
+        expect(visitor).to receive(:visit).with(source_operator)
+
+        visit
+      end
+
+      it 'should return visit of Metasploit::Model::Search::Operator::Association#source_operator' do
+        expect(visitor).to receive(:visit).with(node).and_call_original
+
+        visited = double('Source Operator Visited')
+        allow(visitor).to receive(:visit).with(source_operator).and_return(visited)
+
+        expect(visit).to eq(visited)
+      end
+    end
+
+    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,
+            # needs to be a real class so Class#arel_table works
+            klass: Mdm::Host
+        )
+      }
+    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

@@ -0,0 +1,175 @@
+RSpec.describe MetasploitDataModels::Search::Visitor::Includes, type: :model do
+  subject(:visitor) do
+    described_class.new
+  end
+
+  it_should_behave_like 'Metasploit::Concern.run'
+
+  context '#visit' do
+    subject(:visit) do
+      visitor.visit(node)
+    end
+
+    children_classes = [
+        Metasploit::Model::Search::Group::Intersection,
+        Metasploit::Model::Search::Group::Union,
+        Metasploit::Model::Search::Operation::Group::Intersection,
+        Metasploit::Model::Search::Operation::Group::Union
+    ]
+
+    children_classes.each do |children_class|
+      context "with #{children_class}" do
+        it_should_behave_like "MetasploitDataModels::Search::Visitor::Includes#visit with #children" do
+          let(:node_class) do
+            children_class
+          end
+        end
+      end
+    end
+
+    context 'with Metasploit::Model::Search::Operation::Association' do
+      let(:association) {
+        :parent_association
+      }
+
+      let(:node) {
+        operator.operate_on('formatted_value')
+      }
+
+      let(:operator) {
+        Metasploit::Model::Search::Operator::Association.new(
+            association: association,
+            source_operator: source_operator
+        )
+      }
+
+      context '#source_operation' do
+        let(:attribute_operator) {
+          Metasploit::Model::Search::Operator::Attribute.new(
+              type: :string
+          )
+        }
+
+        context 'with Metasploit::Model::Search::Operation::Association' do
+          let(:source_operator) {
+            Metasploit::Model::Search::Operator::Association.new(
+                association: source_operator_association,
+                source_operator: attribute_operator
+            )
+          }
+
+          let(:source_operator_association) {
+            :child_association
+          }
+
+          it 'is [{ association => nested associations }]' do
+            expect(visit).to eq([{association => [source_operator_association]}])
+          end
+        end
+
+        context 'without Metasploit::Model::Search::Operation::Association' do
+          let(:source_operator) {
+            attribute_operator
+          }
+
+          it 'is [association]' do
+            expect(visit).to eq([association])
+          end
+        end
+      end
+    end
+
+    operation_classes = [
+        Metasploit::Model::Search::Operation::Boolean,
+        Metasploit::Model::Search::Operation::Date,
+        Metasploit::Model::Search::Operation::Integer,
+        Metasploit::Model::Search::Operation::Null,
+        Metasploit::Model::Search::Operation::Set::Integer,
+        Metasploit::Model::Search::Operation::Set::String,
+        Metasploit::Model::Search::Operation::String
+    ]
+
+    operation_classes.each do |operation_class|
+      context "with #{operation_class}" do
+        it_should_behave_like 'MetasploitDataModels::Search::Visitor::Includes#visit with Metasploit::Model::Search::Operation::Base' do
+          let(:node_class) do
+            operation_class
+          end
+        end
+      end
+    end
+
+    context 'with Metasploit::Model::Search::Operator::Association' do
+      let(:association) do
+        FactoryBot.generate :metasploit_model_search_operator_association_association
+      end
+
+      let(:node) do
+        Metasploit::Model::Search::Operator::Association.new(
+            :association => association
+        )
+      end
+    end
+
+    context 'with Metasploit::Model::Search::Operator::Attribute' do
+      let(:node) do
+        Metasploit::Model::Search::Operator::Attribute.new
+      end
+
+      it { is_expected.to eq([]) }
+    end
+
+    context 'with MetasploitDataModels::Search::Operator::Port::List' do
+      let(:node) do
+        MetasploitDataModels::Search::Operator::Port::List.new
+      end
+
+      it { is_expected.to eq([]) }
+    end
+
+    context 'with Metasploit::Model::Search::Query#tree' do
+      let(:node) do
+        query.tree
+      end
+
+      let(:query) do
+        Metasploit::Model::Search::Query.new(
+            :formatted => formatted,
+            :klass => klass
+        )
+      end
+
+      context 'Metasploit::Model::Search::Query#klass' do
+        context 'with Mdm::Host' do
+          let(:klass) {
+            Mdm::Host
+          }
+
+          context 'with name' do
+            let(:name) do
+              FactoryBot.generate :mdm_host_name
+            end
+
+            let(:formatted) do
+              "name:\"#{name}\""
+            end
+
+            it { is_expected.to be_empty }
+          end
+
+          context 'with services.name' do
+            let(:name) do
+              FactoryBot.generate :mdm_service_name
+            end
+
+            let(:formatted) do
+              "services.name:\"#{name}\""
+            end
+
+            it { is_expected.to include :services }
+          end
+        end
+      end
+    end
+  end
+end