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

data/spec/app/models/metasploit/model/search/operator/deprecated/ref_spec.rb

@@ -0,0 +1,327 @@
+require 'spec_helper'
+
+describe Metasploit::Model::Search::Operator::Deprecated::Ref do
+  subject(:operator) do
+    described_class.new(
+        :klass => klass
+    )
+  end
+
+  let(:klass) do
+    Class.new
+  end
+
+  context '#children' do
+    include_context 'Metasploit::Model::Search::Operator::Union#children'
+
+    let(:abbreviation_operator) do
+      Metasploit::Model::Search::Operator::Attribute.new(
+          :attribute => :abbreviation,
+          :klass => authority_class,
+          :type => :string
+      )
+    end
+
+    let(:authority_class) do
+      Class.new
+    end
+
+    let(:authorities_abbreviation_operator) do
+      Metasploit::Model::Search::Operator::Association.new(
+          :association => :authorities,
+          :attribute_operator => abbreviation_operator,
+          :klass => klass
+      )
+    end
+
+    let(:designation_operator) do
+      Metasploit::Model::Search::Operator::Attribute.new(
+          :attribute => :designation,
+          :klass => reference_class,
+          :type => :string
+      )
+    end
+
+    let(:reference_class) do
+      Class.new
+    end
+
+    let(:references_designation_operator) do
+      Metasploit::Model::Search::Operator::Association.new(
+          :association => :references,
+          :attribute_operator => designation_operator,
+          :klass => klass
+      )
+    end
+
+    let(:references_url_operator) do
+      Metasploit::Model::Search::Operator::Association.new(
+          :association => :references,
+          :attribute_operator => url_operator,
+          :klass => klass
+      )
+    end
+
+    let(:url_operator) do
+      Metasploit::Model::Search::Operator::Attribute.new(
+          :attribute => :url,
+          :klass => reference_class,
+          :type => :string
+      )
+    end
+
+    before(:each) do
+      operator.stub(:operator).with('authorities.abbreviation').and_return(authorities_abbreviation_operator)
+      operator.stub(:operator).with('references.designation').and_return(references_designation_operator)
+      operator.stub(:operator).with('references.url').and_return(references_url_operator)
+    end
+
+    context "with '-'" do
+      let(:formatted_value) do
+        "#{head}-#{tail}"
+      end
+
+      context "with 'URL'" do
+        let(:head) do
+          'URL'
+        end
+
+        context 'with blank url' do
+          let(:tail) do
+            ''
+          end
+
+          it { should be_empty }
+        end
+
+        context 'without blank url' do
+          let(:tail) do
+            FactoryGirl.generate :metasploit_model_reference_url
+          end
+
+          context 'authorities.abbreviation' do
+            subject(:operation) do
+              child('authorities.abbreviation')
+            end
+
+            it 'should not be in children' do
+              operation.should be_nil
+            end
+          end
+
+          context 'references.designation' do
+            subject(:operation) do
+              child('references.designation')
+            end
+
+            it 'should not be in children' do
+              operation.should be_nil
+            end
+          end
+
+          context 'references.url' do
+            subject(:operation) do
+              child('references.url')
+            end
+
+            it "should use portion of formatted value after 'URL-' for value" do
+              operation.value.should == tail
+            end
+          end
+        end
+      end
+
+      context "without 'URL'" do
+        let(:head) do
+          FactoryGirl.generate :metasploit_model_authority_abbreviation
+        end
+
+        let(:tail) do
+          FactoryGirl.generate :metasploit_model_reference_designation
+        end
+
+        context 'with blank head' do
+          let(:head) do
+            ''
+          end
+
+          context 'authorities.abbreviation' do
+            subject(:operation) do
+              child('authorities.abbreviation')
+            end
+
+            it 'should not be in children' do
+              operation.should be_nil
+            end
+          end
+
+          context 'references.designation' do
+            subject(:operation) do
+              child('references.designation')
+            end
+
+            it "should use portion of formatted value after '-' for value" do
+              operation.value.should == tail
+            end
+          end
+
+          context 'references.url' do
+            subject(:operation) do
+              child('references.url')
+            end
+
+            it 'should not be in children' do
+              operation.should be_nil
+            end
+          end
+        end
+
+        context 'without blank head' do
+          context 'authorities.abbreviation' do
+            subject(:operation) do
+              child('authorities.abbreviation')
+            end
+
+            it "should use portion of formatted value before '-' as value" do
+              operation.value.should == head
+            end
+          end
+
+          context 'references.designation' do
+            subject(:operation) do
+              child('references.designation')
+            end
+
+            it "should use portion of formatted value after '-' as value" do
+              operation.value.should == tail
+            end
+          end
+
+          context 'references.url' do
+            subject(:operation) do
+              child('references.url')
+            end
+
+            it 'should not be in children' do
+              operation.should be_nil
+            end
+          end
+        end
+
+        context 'with blank tail' do
+          let(:tail) do
+            ''
+          end
+
+          context 'authorities.abbreviation' do
+            subject(:operation) do
+              child('authorities.abbreviation')
+            end
+
+            it "should use portion of formatted value before '-' for value" do
+              operation.value.should == head
+            end
+          end
+
+          context 'references.designation' do
+            subject(:operation) do
+              child('references.designation')
+            end
+
+            it 'should not be in children' do
+              operation.should be_nil
+            end
+          end
+
+          context 'references.url' do
+            subject(:operation) do
+              child('references.url')
+            end
+
+            it 'should not be in children' do
+              operation.should be_nil
+            end
+          end
+        end
+
+        context 'without blank tail' do
+          context 'authorities.abbreviation' do
+            subject(:operation) do
+              child('authorities.abbreviation')
+            end
+
+            it "should use portion of format value before '-' for value" do
+              operation.value.should == head
+            end
+          end
+
+          context 'references.designation' do
+            subject(:operation) do
+              child('references.designation')
+            end
+
+            it "should use portion of format value after '-' for value" do
+              operation.value.should == tail
+            end
+          end
+
+          context 'references.url' do
+            subject(:operation) do
+              child('references.url')
+            end
+
+            it 'should not be in children' do
+              operation.should be_nil
+            end
+          end
+        end
+      end
+    end
+
+    context "without '-'" do
+      context 'with blank' do
+        let(:formatted_value) do
+          ''
+        end
+
+        it { should be_empty }
+      end
+
+      context 'without blank' do
+        let(:formatted_value) do
+          'ref_value'
+        end
+
+        context 'authorities.abbreviation' do
+          subject(:operation) do
+            child('authorities.abbreviation')
+          end
+
+          it 'should use formatted value for value' do
+            operation.value.should == formatted_value
+          end
+        end
+
+        context 'references.designation' do
+          subject(:operation) do
+            child('references.designation')
+          end
+
+          it 'should use formatted value for value' do
+            operation.value.should == formatted_value
+          end
+        end
+
+        context 'references.url' do
+          subject(:operation) do
+            child('references.url')
+          end
+
+          it 'should use formatted value for value' do
+            operation.value.should == formatted_value
+          end
+        end
+      end
+    end
+  end
+end

data/spec/app/models/metasploit/model/search/operator/deprecated/text_spec.rb

@@ -0,0 +1,357 @@
+require 'spec_helper'
+
+describe Metasploit::Model::Search::Operator::Deprecated::Text do
+  subject(:operator) do
+    described_class.new(
+        :klass => klass
+    )
+  end
+
+  let(:klass) do
+    Class.new
+  end
+
+  context 'CONSTANTS' do
+    context 'OPERATOR_NAMES' do
+      subject(:operator_names) do
+        described_class::OPERATOR_NAMES
+      end
+
+      it { should include 'description' }
+      it { should include 'name' }
+      it { should include 'actions.name' }
+
+      it 'should include platform instead of platforms.fully_qualified_name and targets.name' do
+        operator_names.should include('platform')
+        operator_names.should_not include('platforms.fully_qualified_name')
+        operator_names.should_not include('targets.name')
+      end
+
+      it 'should include ref instead of authors.name, references.designation and references.url to handle deprecated reference syntax' do
+        operator_names.should include('ref')
+        operator_names.should_not include('authors.name')
+        operator_names.should_not include('references.designation')
+        operator_names.should_not include('references.url')
+      end
+    end
+  end
+
+  context '#children' do
+    include_context 'Metasploit::Model::Search::Operator::Union#children'
+
+    let(:action_name_operator) do
+      Metasploit::Model::Search::Operator::Attribute.new(
+          :attribute => :name,
+          :klass => action_class,
+          :type => :string
+      )
+    end
+
+    let(:action_class) do
+      Class.new
+    end
+
+    let(:actions_name_operator) do
+      Metasploit::Model::Search::Operator::Association.new(
+          :association => :actions,
+          :attribute_operator => action_name_operator,
+          :klass => klass
+      )
+    end
+
+    let(:architecture_class) do
+      Class.new
+    end
+
+    let(:architecture_abbreviation_operator) do
+      Metasploit::Model::Search::Operator::Attribute.new(
+          :attribute => :abbreviation,
+          :klass => architecture_class,
+          :type => :string
+      )
+    end
+
+    let(:architectures_abbreviation_operator) do
+      Metasploit::Model::Search::Operator::Association.new(
+          :association => :architectures,
+          :attribute_operator => architecture_abbreviation_operator,
+          :klass => klass
+      )
+    end
+
+    let(:authority_class) do
+      Class.new
+    end
+
+    let(:authority_abbreviation_operator) do
+      Metasploit::Model::Search::Operator::Attribute.new(
+          :attribute => :abbreviation,
+          :klass => authority_class,
+          :type => :string
+      )
+    end
+
+    let(:authorities_abbreviation_operator) do
+      Metasploit::Model::Search::Operator::Association.new(
+          :association => :authorities,
+          :attribute_operator => authority_abbreviation_operator,
+          :klass => klass
+      )
+    end
+
+    let(:description_operator) do
+      Metasploit::Model::Search::Operator::Attribute.new(
+          :attribute => :description,
+          :klass => klass,
+          :type => :string
+      )
+    end
+
+    let(:formatted_value) do
+      'value'
+    end
+
+    let(:name_operator) do
+      Metasploit::Model::Search::Operator::Attribute.new(
+          :attribute => :name,
+          :klass => klass,
+          :type => :string
+      )
+    end
+
+    let(:platform_class) do
+      Class.new
+    end
+
+    let(:platform_operator) do
+      Metasploit::Model::Search::Operator::Deprecated::Platform.new(
+          :klass => klass,
+          :name => :platform
+      )
+    end
+
+    let(:platform_fully_qualified_name_operator) do
+      Metasploit::Model::Search::Operator::Attribute.new(
+          :attribute => :fully_qualified_name,
+          :klass => platform_class,
+          :type => :string
+      )
+    end
+
+    let(:platforms_fully_qualified_name_operator) do
+      Metasploit::Model::Search::Operator::Association.new(
+          :association => :platforms,
+          :attribute_operator => platform_fully_qualified_name_operator,
+          :klass => klass
+      )
+    end
+
+    let(:ref_operator) do
+      Metasploit::Model::Search::Operator::Deprecated::Ref.new(
+          :klass => klass
+      )
+    end
+
+    let(:reference_class) do
+      Class.new
+    end
+
+    let(:reference_designation_operator) do
+      Metasploit::Model::Search::Operator::Attribute.new(
+          :attribute => :designation,
+          :klass => reference_class,
+          :type => :string
+      )
+    end
+
+    let(:references_designation_operator) do
+      Metasploit::Model::Search::Operator::Association.new(
+          :association => :references,
+          :attribute_operator => reference_designation_operator,
+          :klass => klass
+      )
+    end
+
+    let(:reference_url_operator) do
+      Metasploit::Model::Search::Operator::Attribute.new(
+          :attribute => :url,
+          :klass => reference_class,
+          :type => :string
+      )
+    end
+
+    let(:references_url_operator) do
+      Metasploit::Model::Search::Operator::Association.new(
+          :association => :references,
+          :attribute_operator => reference_url_operator,
+          :klass => klass
+      )
+    end
+
+    let(:target_class) do
+      Class.new
+    end
+
+    let(:target_name_operator) do
+      Metasploit::Model::Search::Operator::Attribute.new(
+          :attribute => :name,
+          :klass => target_class,
+          :type => :string
+      )
+    end
+
+    let(:targets_name_operator) do
+      Metasploit::Model::Search::Operator::Association.new(
+          :association => :targets,
+          :attribute_operator => target_name_operator,
+          :klass => klass
+      )
+    end
+
+    before(:each) do
+      operator.stub(:operator).with('description').and_return(description_operator)
+      operator.stub(:operator).with('name').and_return(name_operator)
+      operator.stub(:operator).with('actions.name').and_return(actions_name_operator)
+      operator.stub(:operator).with('architectures.abbreviation').and_return(architectures_abbreviation_operator)
+      operator.stub(:operator).with('platform').and_return(platform_operator)
+      operator.stub(:operator).with('ref').and_return(ref_operator)
+
+      platform_operator.stub(:operator).with(
+          'platforms.fully_qualified_name'
+      ).and_return(
+          platforms_fully_qualified_name_operator
+      )
+      platform_operator.stub(:operator).with('targets.name').and_return(targets_name_operator)
+
+      ref_operator.stub(:operator).with('authorities.abbreviation').and_return(authorities_abbreviation_operator)
+      ref_operator.stub(:operator).with('references.designation').and_return(references_designation_operator)
+      ref_operator.stub(:operator).with('references.url').and_return(references_url_operator)
+    end
+
+    context 'description' do
+      subject(:operation) do
+        child('description')
+      end
+
+      it 'should use formatted value for value' do
+        operation.value.should == formatted_value
+      end
+    end
+
+    context 'name' do
+      subject(:operation) do
+        child('name')
+      end
+
+      it 'should use formatted value for value' do
+        operation.value.should == formatted_value
+      end
+    end
+
+    context 'actions.name' do
+      subject(:operation) do
+        child('actions.name')
+      end
+
+      it 'should use formatted value for value' do
+        operation.value.should == formatted_value
+      end
+    end
+
+    context 'architectures.abbreviation' do
+      subject(:operation) do
+        child('architectures.abbreviation')
+      end
+
+      it 'should use formatted value for value' do
+        operation.value.should == formatted_value
+      end
+    end
+
+    context 'platform' do
+      subject(:child_operation) do
+        child('platform')
+      end
+
+      context 'children' do
+        subject(:grandchildren) do
+          child_operation.children
+        end
+
+        def grandchild(formatted_operator)
+          grandchildren.find { |operation|
+            operation.operator.name == formatted_operator.to_sym
+          }
+        end
+
+        context 'platforms.fully_qualified_name' do
+          subject(:grandchild_operation) do
+            grandchild('platforms.fully_qualified_name')
+          end
+
+          it 'should use formatted value for value' do
+            grandchild_operation.value.should == formatted_value
+          end
+        end
+
+        context 'targets.name' do
+          subject(:grandchild_operation) do
+            grandchild('targets.name')
+          end
+
+          it 'should use formatted value for value' do
+            grandchild_operation.value.should == formatted_value
+          end
+        end
+      end
+    end
+
+    context 'ref' do
+      subject(:child_operation) do
+        child('ref')
+      end
+
+      context 'children' do
+        subject(:grandchildren) do
+          child_operation.children
+        end
+
+        def grandchild(formatted_operator)
+          grandchildren.find { |operation|
+            operation.operator.name == formatted_operator.to_sym
+          }
+        end
+
+        context 'authorities.abbreviation' do
+          subject(:grandchild_operation) do
+            grandchild('authorities.abbreviation')
+          end
+
+          it 'should use formatted value for value' do
+            grandchild_operation.value.should == formatted_value
+          end
+        end
+
+        context 'references.designation' do
+          subject(:grandchild_operation) do
+            grandchild('references.designation')
+          end
+
+          it 'should use formatted value for value' do
+            grandchild_operation.value.should == formatted_value
+          end
+        end
+
+        context 'references.url' do
+          subject(:grandchild_operation) do
+            grandchild('references.url')
+          end
+
+          it 'should use formatted value for value' do
+            grandchild_operation.value.should == formatted_value
+          end
+        end
+      end
+    end
+  end
+end